MV1724ProcessRaw
[Raw Data Process]

Produces TPIs from raw data read in from UH CAEN. More...

Functions
static INT	module_init (void)
static INT	module_event_caen (EVENT_HEADER *, void *)
Variables
HNDLE	hDB
TGlobalData *	gData
	Object to hold data used and produced by modules throughout alcapana stage of analysis.
TSetupData *	gSetup
	Hardware information about digitizers and detectors to be used during alcapana stage of analysis.
static vector< string >	caen_houston_bank_names
	List of UH CAEN bank names for the event loop.
static unsigned int	nPreSamples
	Number of samples to record before a trigger.
static const int	NCHAN = 8
	Number of channels in V1724.
ANA_MODULE	MV1724ProcessRaw_module

---

Detailed Description

Produces TPIs from raw data read in from UH CAEN.

Author:

Volodya Tishchenko

Joe Grange

---

Function Documentation

INT module_event_caen	(	EVENT_HEADER *	pheader,
		void *	pevent
	)			[static]

Definition at line 108 of file MV1724ProcessRaw.cpp.

References caen_houston_bank_names, TGlobalData::fPulseIslandToChannelMap, NCHAN, and nPreSamples.

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

  //printf("===================> %s MIDAS event %i\n",__FILE__,pheader->serial_number);
  
  // 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. JG: the islands.clear() line causes seg fault for > 1 TPulseIslandPair
  /*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();
    pulse_islands_map.erase(iter); // AE: need to erase the key so that blocks after the first will be recorded
  }*/    
    
  // Get the event number
  int midas_event_number = pheader->serial_number;

  BYTE *pdata;

  //  printf("In caen ER!\n");

  char bank_name[8];
  sprintf(bank_name,"CDG%i",0); // one MIDAS bank per board
  unsigned int bank_len = bk_locate(pevent, bank_name, &pdata);
  

  uint32_t *p32 = (uint32_t*)pdata;
  uint32_t *p32_0 = (uint32_t*)pdata;

  
  while ( (p32 - p32_0)*4 < bank_len )
    {

      uint32_t caen_event_cw = p32[0]>>28;
      //printf("CW: %08x\n",caen_event_cw);
      if ( caen_event_cw != 0xA )
        {
          printf("***ERROR UH CAEN! Wrong data format: incorrect control word 0x%08x\n", caen_event_cw);
          return SUCCESS;
        }
      
      uint32_t caen_event_size = p32[0] & 0x0FFFFFFF;
      //printf("caen event size: %i\n",caen_event_size);
      
      uint32_t caen_channel_mask = p32[1] & 0x000000FF;
      // count the number of channels in the event
      int nchannels = 0;
      for (int ichannel=0; ichannel<NCHAN; ichannel++ )
        {
          if ( caen_channel_mask & (1<<ichannel) ) nchannels++; 
        }
      
      uint32_t caen_event_counter = p32[2] & 0x00FFFFFF;
      //      printf("caen event counter: %i\n",caen_event_counter);
      
      uint32_t caen_trigger_time = p32[3];
      //      printf("caen trigger time: %i\n",caen_trigger_time);// = clock ticks?
      
      // number of samples per channel
      unsigned int nsamples = ((caen_event_size-4)*2) / nchannels;
      //      printf("waveform length: %i\n",nsamples);

      // Loop through the channels (i.e. banks)
      for (std::vector<std::string>::iterator bankNameIter = caen_houston_bank_names.begin();
           bankNameIter != caen_houston_bank_names.end(); bankNameIter++) {
        
        vector<TPulseIsland*>& pulse_islands = pulse_islands_map[*(bankNameIter)];
        std::vector<int> sample_vector;
        int ichannel = bankNameIter - caen_houston_bank_names.begin();

        //      printf("TGlobalData bank [%s] ----------------------------------------\n", (*bankNameIter).c_str());
        //      printf("Number of TPulseIslands already existing = %d\n", pulse_islands.size());
        //      printf("*-- channel %i -------------------------------------------------------------*\n",ichannel);

        if ( caen_channel_mask & (1<<ichannel) )
          {
            // channel enabled
            unsigned int isample = 0;
            unsigned int nwords = nsamples/2;

            for (int iword=0; iword<nwords; iword++)
              {
                
                for (int isubword=0; isubword<2; isubword++)
                  {
                    uint32_t adc;
                    
                    if (isubword == 0 )
                      adc = (p32[4+iword+ichannel*nwords] & 0x3fff);
                    else 
                      adc = ((p32[4+iword+ichannel*nwords] >> 16) & 0x3fff);
                      
                    //printf("CAEN V1724 channel %d: adc[%i] = %i\n", ichannel, isample, adc);
                    //              h2_v1724_pulses[ichannel]->Fill(isample,adc);
                    isample++;
                      
                    sample_vector.push_back(adc);

                  }
              }
              
            pulse_islands.push_back(new TPulseIsland(caen_trigger_time - nPreSamples, sample_vector, *bankNameIter));
          }
      }
    
      // align the event by two bytes.
      p32 += caen_event_size + (caen_event_size%2);
      //      printf("offset: %i bank size: %i\n", (int)(p32-p32_0), bank_len);

    }
    
  // print for testing
  if(midas_event_number == 1) {
    // Loop through all the banks and print an output (because this ProcessRaw loops through pulses then banks, it has been put here)
    for (std::vector<std::string>::iterator bankNameIter = caen_houston_bank_names.begin();
         bankNameIter != caen_houston_bank_names.end(); bankNameIter++) {
      
      vector<TPulseIsland*>& pulse_islands = pulse_islands_map[*(bankNameIter)];
      printf("TEST MESSAGE: Read %d events from bank %s in event %d\n",
             pulse_islands.size(),
             (*(bankNameIter)).c_str(),
             midas_event_number);
    }
  }
  
  return SUCCESS;
}

INT module_init

(

void

)

[static]

Definition at line 77 of file MV1724ProcessRaw.cpp.

References caen_houston_bank_names, TSetupData::fBankToDetectorMap, hDB, TSetupData::IsHoustonCAEN(), and nPreSamples.

{

  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 CAEN banks here
    if (TSetupData::IsHoustonCAEN(bankname))
      caen_houston_bank_names.push_back(bankname);
  }
  
  /*** Get necessary data from ODB ***/
  char key[80];
  int size;
  unsigned int post_trigger_percentage, nSamples;

  // Get Trigger Time Tag info
  // Timestamp will be shifted by number of presamples
  sprintf(key, "/Equipment/Crate 4/Settings/CAEN0/waveform length");
  size = sizeof(nSamples);
  db_get_value(hDB, 0, key, &nSamples, &size, TID_DWORD, 1);
  post_trigger_percentage = 80; // This is hardcoded in the frontend
  nPreSamples = (int) (0.01 * ((100 - post_trigger_percentage) * nSamples));
  
  return SUCCESS;
}

---

Variable Documentation

vector<string> caen_houston_bank_names [static]

List of UH CAEN bank names for the event loop.

Definition at line 49 of file MV1724ProcessRaw.cpp.

Referenced by module_event_caen(), and module_init().

TGlobalData* gData

Object to hold data used and produced by modules throughout alcapana stage of analysis.

Definition at line 76 of file analyzer.cpp.

TSetupData* gSetup

Hardware information about digitizers and detectors to be used during alcapana stage of analysis.

Definition at line 80 of file analyzer.cpp.

HNDLE hDB

ANA_MODULE MV1724ProcessRaw_module

Initial value:

{
  "MV1724ProcessRaw",            
  "Vladimir Tishchenko",         
  module_event_caen,                  
  NULL,                          
  NULL,                          
  module_init,                   
  NULL,                          
  NULL,                          
  0,                             
  NULL,                          
}

Definition at line 62 of file MV1724ProcessRaw.cpp.

const int NCHAN = 8 [static]

Number of channels in V1724.

Definition at line 59 of file MV1724ProcessRaw.cpp.

unsigned int nPreSamples [static]

Number of samples to record before a trigger.

Number of samples and fraction of sampling window to set aside for after trigger are stored in ODB; this is calculated from those.

Definition at line 56 of file MV1724ProcessRaw.cpp.

Referenced by module_event_caen(), and module_init().