MOctalFADCProcessRaw.cpp File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <map>
#include <utility>
#include "midas.h"
#include <TH1.h>
#include <TH2.h>
#include "TOctalFADCIsland.h"
#include "TOctalFADCBankReader.h"
#include "TGlobalData.h"
#include "TSetupData.h"

Go to the source code of this file.

Functions
INT	MOctalFADCProcessRaw_init (void)
INT	MOctalFADCProcessRaw (EVENT_HEADER *, void *)

Variables
HNDLE	hDB
TGlobalData *	gData
TSetupData *	gSetup
static TH2 *	hNOctalFADCIslandsReadPerBlock
static vector < TOctalFADCBankReader * >	fadc_bank_readers
ANA_MODULE	MOctalFADCProcessRaw_module

Function Documentation

INT MOctalFADCProcessRaw	(	EVENT_HEADER *	pheader,
		void *	pevent
	)

This method processes one MIDAS block, producing a vector of TOctalFADCIsland objects from the raw Octal FADC data.

Todo:

Check for errors when reading/processing the FADC banks

Definition at line 96 of file MOctalFADCProcessRaw.cpp.

References bank_name, TGlobalData::fPulseIslandToChannelMap, GetTime(), hNOctalFADCIslandsReadPerBlock, i, printf(), and SUCCESS.

{
  // Get the event number
  int midas_event_number = pheader->serial_number;

  // Make TPulseIsland objects for each of the TOctalFADCIslands.

  // Some typedefs
  typedef map<string, vector<TPulseIsland*> > TStringPulseIslandMap;
  typedef pair<string, vector<TPulseIsland*> > TStringPulseIslandPair;
  typedef map<string, vector<TPulseIsland*> >::iterator map_iterator;

  // Fetch a reference to the gData structure that stores a map
  // of (bank_name, vector<TPulseIsland*>) pairs
  TStringPulseIslandMap& pulse_islands_map =
    gData->fPulseIslandToChannelMap;

  // Delete the islands found in the previous block. Don't clear
  // the map of (bank_name, vector) pairs. Once we use a bank name
  // once, it will have a (possibly empty) entry in this map for the
  // whole run.
  for(map_iterator iter = pulse_islands_map.begin();
      iter != pulse_islands_map.end(); iter++){
    vector<TPulseIsland*>& islands = iter->second;
    // Delete the pointers to TPulseIslands, then clear the vector
    for(unsigned int j=0; j<islands.size(); j++) {
      if(islands[j]) { delete islands[j]; islands[j] = NULL; }
    }
    islands.clear();
  }

  // Get islands from all banks and add them to the global structure
  for(unsigned int i=0; i<fadc_bank_readers.size(); i++) {
    string bank_name = fadc_bank_readers[i]->GetBankName();

    // Read the islands with the bank reader
    fadc_bank_readers[i]->ProcessEvent(pheader, pevent);
    vector<TOctalFADCIsland*> fadc_islands =
      fadc_bank_readers[i]->GetIslandVectorCopy();

    // Make vector of TPulseIsland from TOctalFADCIsland. Now this module
    // owns the memory associated with these.
    vector<TPulseIsland*> pulse_islands;
    for(unsigned int j=0; j<fadc_islands.size(); j++) {
      pulse_islands.push_back(new TPulseIsland(
        fadc_islands[j]->GetTime(), fadc_islands[j]->GetSampleVector(),bank_name));
    }

    // Add a pair (bank_name, vector_of_islands) to the std::map in gData
    pulse_islands_map[bank_name] = pulse_islands;

    // Fill Diagnostic histogram
    hNOctalFADCIslandsReadPerBlock->Fill(bank_name.c_str(), midas_event_number,
      fadc_islands.size());

    // print for testing
    if(midas_event_number == 1) {      
                  printf("TEST MESSAGE: Read %d events from bank %s in event %d\n",
        fadc_bank_readers[i]->GetNIslands(),
        fadc_bank_readers[i]->GetBankName().c_str(),
        midas_event_number);
    }
  }

  return SUCCESS;
}

INT MOctalFADCProcessRaw_init

(

)

This method initializes histograms.

Definition at line 67 of file MOctalFADCProcessRaw.cpp.

References TSetupData::fBankToDetectorMap, hNOctalFADCIslandsReadPerBlock, TSetupData::IsFADC(), and SUCCESS.

{
  // This histogram has the bank names labeled on the X-axis, and the midas
  // block number on the Y-axis.
  // This uses the TH1::kCanRebin mechanism to expand automatically to the
  // number of FADC banks.
  hNOctalFADCIslandsReadPerBlock = new TH2I(
    "hNOctalFADCIslandsReadPerBlock",
    "Number of FADC Islands read by block",
    1,0,1, 10000,0,10000);
  hNOctalFADCIslandsReadPerBlock->SetBit(TH1::kCanRebin);

  std::map<std::string, std::string> bank_to_detector_map = gSetup->fBankToDetectorMap;
  for(std::map<std::string, std::string>::iterator mapIter = bank_to_detector_map.begin(); 
      mapIter != bank_to_detector_map.end(); mapIter++) { 
    
    std::string bankname = mapIter->first;

    // We only want the FADC banks here
    if (TSetupData::IsFADC(bankname))
      fadc_bank_readers.push_back(new TOctalFADCBankReader(bankname));
  }

  return SUCCESS;
}

Variable Documentation

vector<TOctalFADCBankReader*> fadc_bank_readers

static

Definition at line 49 of file MOctalFADCProcessRaw.cpp.

TGlobalData* gData

Definition at line 54 of file analyzer.cpp.

TSetupData* gSetup

Definition at line 55 of file analyzer.cpp.

HNDLE hDB

Definition at line 11 of file mucap_compress.cpp.

TH2* hNOctalFADCIslandsReadPerBlock

static

Definition at line 47 of file MOctalFADCProcessRaw.cpp.

Referenced by MOctalFADCProcessRaw(), and MOctalFADCProcessRaw_init().

ANA_MODULE MOctalFADCProcessRaw_module

Initial value:

=
{
  "MOctalFADCProcessRaw",        
  "Michael Murray",              
  MOctalFADCProcessRaw,          
  NULL,                          
  NULL,                          
  MOctalFADCProcessRaw_init,     
  NULL,                          
  NULL,                          
  0,                             
  NULL,                          
}

Definition at line 51 of file MOctalFADCProcessRaw.cpp.