CMS 3D CMS Logo

EcalRawToDigiDev Class Reference

#include <EventFilter/EcalRawToDigiDev/interface/EcalRawToDigi.h>

Inheritance diagram for EcalRawToDigiDev:

edm::EDProducer edm::ProducerBase edm::ProductRegistryHelper

List of all members.

Public Member Functions

 EcalRawToDigiDev (const edm::ParameterSet &ps)
 Class constructor.
virtual void produce (edm::Event &e, const edm::EventSetup &c)
 Functions that are called by framework at each event.
virtual ~EcalRawToDigiDev ()
 Class destructor.

Private Attributes

std::string dataLabel_
edm::InputTag fedsLabel_
std::vector< int > fedUnpackList_
bool feIdCheck_
bool feUnpacking_
bool first_
bool headerUnpacking_
bool memUnpacking_
EcalElectronicsMapping * mmm_
EcalElectronicsMapper * myMap_
uint nevts_
uint numbTriggerTSamples_
uint numbXtalTSamples_
std::vector< int > orderedDCCIdList_
std::vector< int > orderedFedUnpackList_
bool put_
bool REGIONAL_
double RUNNING_TIME_
double SETUP_TIME_
bool srpUnpacking_
bool syncCheck_
bool tccUnpacking_
DCCDataUnpacker * theUnpacker_

Detailed Description

Definition at line 41 of file EcalRawToDigi.h.

Constructor & Destructor Documentation

EcalRawToDigiDev::EcalRawToDigiDev ( const edm::ParameterSet &  ps  )  [explicit]

Class constructor.

Definition at line 16 of file EcalRawToDigi.cc.

References fedUnpackList_, feIdCheck_, feUnpacking_, first_, FEDNumbering::getEcalFEDIds(), edm::ParameterSet::getUntrackedParameter(), headerUnpacking_, i, memUnpacking_, mmm_, myMap_, numbTriggerTSamples_, numbXtalTSamples_, orderedDCCIdList_, orderedFedUnpackList_, output(), DCCDataUnpacker::silentMode_, srpUnpacking_, syncCheck_, tccUnpacking_, and theUnpacker_.

00016                                                              :
00017   
00018   //define the list of FED to be unpacked
00019   fedUnpackList_(conf.getUntrackedParameter<std::vector<int> >("FEDs", std::vector<int>())),
00020 
00021   //define the ordered FED list
00022   orderedFedUnpackList_(conf.getUntrackedParameter<std::vector<int> >("orderedFedList", std::vector<int>())),
00023 
00024   //define the ordered DCCId list
00025   orderedDCCIdList_(conf.getUntrackedParameter<std::vector<int> >("orderedDCCIdList", std::vector<int>())),
00026 
00027   //get number of Xtal Time Samples
00028   numbXtalTSamples_(conf.getUntrackedParameter<uint>("numbXtalTSamples",10)),
00029 
00030   //Get number of Trigger Time Samples
00031   numbTriggerTSamples_(conf.getUntrackedParameter<uint>("numbTriggerTSamples",1)),
00032   
00033   //See if header unpacking is enabled
00034   headerUnpacking_(conf.getUntrackedParameter<bool>("headerUnpacking",true)),
00035  
00036   //See if srp unpacking is enabled
00037   srpUnpacking_(conf.getUntrackedParameter<bool>("srpUnpacking",true)),
00038   
00039   //See if tcc unpacking is enabled
00040   tccUnpacking_(conf.getUntrackedParameter<bool>("tccUnpacking",true)),
00041   
00042   //See if fe unpacking is enabled
00043   feUnpacking_(conf.getUntrackedParameter<bool>("feUnpacking",true)),
00044   
00045   //See if fe unpacking is enabled for mem box
00046   memUnpacking_(conf.getUntrackedParameter<bool>("memUnpacking",true)), 
00047 
00048   //See if syncCheck is enabled
00049   syncCheck_(conf.getUntrackedParameter<bool>("syncCheck",true)), 
00050 
00051   //See if feIdCheck is enabled
00052   feIdCheck_(conf.getUntrackedParameter<bool>("feIdCheck",true)),
00053   
00054   put_(conf.getUntrackedParameter<bool>("eventPut",false)),
00055   
00056   dataLabel_(conf.getUntrackedParameter<std::string>("InputLabel","source")),
00057 
00058   REGIONAL_(conf.getUntrackedParameter<bool>("DoRegional",false)),
00059 
00060   fedsLabel_(conf.getUntrackedParameter<edm::InputTag>("FedLabel",edm::InputTag(":listfeds"))),
00061 
00062   myMap_(0),
00063   
00064   theUnpacker_(0)
00065 
00066 {
00067   
00068   first_ = true;
00069   mmm_ = new EcalElectronicsMapping();
00070   DCCDataUnpacker::silentMode_ = conf.getUntrackedParameter<bool>("silentMode",false) ;
00071   
00072   if( numbXtalTSamples_ <6 || numbXtalTSamples_>64 || (numbXtalTSamples_-2)%4 ){
00073     std::ostringstream output;
00074     output      <<"\n Unsuported number of xtal time samples : "<<numbXtalTSamples_
00075                 <<"\n Valid Number of xtal time samples are : 6,10,14,18,...,62"; 
00076     edm::LogError("EcalRawToDigiDev")<< output.str();
00077     // todo : throw an execption
00078   }
00079   
00080   if( numbTriggerTSamples_ !=1 && numbTriggerTSamples_ !=4 && numbTriggerTSamples_ !=8  ){
00081     std::ostringstream output;
00082     output      <<"\n Unsuported number of trigger time samples : "<<numbTriggerTSamples_
00083                 <<"\n Valid number of trigger time samples are :  1, 4 or 8"; 
00084     edm::LogError("EcalRawToDigiDev")<< output.str();
00085     // todo : throw an execption
00086   }
00087   
00088   //NA : testing
00089   //nevts_=0;
00090   //RUNNING_TIME_=0;
00091 
00092   // if there are FEDs specified to unpack fill the vector of the fedUnpackList_
00093   // else fill with the entire ECAL fed range (600-670)
00094   if (fedUnpackList_.empty()) 
00095     for (int i=FEDNumbering::getEcalFEDIds().first; i<=FEDNumbering::getEcalFEDIds().second; i++)
00096       fedUnpackList_.push_back(i);
00097 
00098   //print the FEDs to unpack to the logger
00099   std::ostringstream loggerOutput_;
00100   if(fedUnpackList_.size()!=0){
00101     for (uint i=0; i<fedUnpackList_.size(); i++) 
00102       loggerOutput_ << fedUnpackList_[i] << " ";
00103     edm::LogInfo("EcalRawToDigiDev") << "EcalRawToDigi will unpack FEDs ( " << loggerOutput_.str() << ")";
00104   }
00105   
00106   edm::LogInfo("EcalRawToDigiDev")
00107     <<"\n ECAL RawToDigi configuration:"
00108     <<"\n Header  unpacking is "<<headerUnpacking_
00109     <<"\n SRP Bl. unpacking is "<<srpUnpacking_
00110     <<"\n TCC Bl. unpacking is "<<tccUnpacking_  
00111     <<"\n FE  Bl. unpacking is "<<feUnpacking_
00112     <<"\n MEM Bl. unpacking is "<<memUnpacking_<<"\n";
00113   
00114   // Producer products :
00115   produces<EBDigiCollection>("ebDigis"); 
00116   produces<EEDigiCollection>("eeDigis");
00117   produces<EBSrFlagCollection>();
00118   produces<EESrFlagCollection>();
00119   produces<EcalRawDataCollection>();
00120   produces<EcalPnDiodeDigiCollection>();
00121   produces<EcalTrigPrimDigiCollection>("EcalTriggerPrimitives");
00122   
00123   // Integrity for xtal data
00124   produces<EBDetIdCollection>("EcalIntegrityGainErrors");
00125   produces<EBDetIdCollection>("EcalIntegrityGainSwitchErrors");
00126   produces<EBDetIdCollection>("EcalIntegrityChIdErrors");
00127 
00128   // Integrity for xtal data - EE specific (to be rivisited towards EB+EE common collection)
00129   produces<EEDetIdCollection>("EcalIntegrityGainErrors");
00130   produces<EEDetIdCollection>("EcalIntegrityGainSwitchErrors");
00131   produces<EEDetIdCollection>("EcalIntegrityChIdErrors");
00132 
00133   // Integrity Errors
00134   produces<EcalElectronicsIdCollection>("EcalIntegrityTTIdErrors");
00135   produces<EcalElectronicsIdCollection>("EcalIntegrityBlockSizeErrors");
00136  
00137   // Mem channels' integrity
00138   produces<EcalElectronicsIdCollection>("EcalIntegrityMemTtIdErrors");
00139   produces<EcalElectronicsIdCollection>("EcalIntegrityMemBlockSizeErrors");
00140   produces<EcalElectronicsIdCollection>("EcalIntegrityMemChIdErrors");
00141   produces<EcalElectronicsIdCollection>("EcalIntegrityMemGainErrors");
00142 
00143 
00144  
00145   // Build a new Electronics mapper and parse default map file
00146   myMap_ = new EcalElectronicsMapper(numbXtalTSamples_,numbTriggerTSamples_);
00147 
00148   // in case of external  text file (deprecated by HLT environment) 
00149   //  bool readResult = myMap_->readDCCMapFile(conf.getUntrackedParameter<std::string>("DCCMapFile",""));
00150 
00151   // use two arrays from cfg to establish DCCId:FedId. If they are empy, than use hard coded correspondence 
00152   bool readResult = myMap_->makeMapFromVectors(orderedFedUnpackList_, orderedDCCIdList_);
00153 
00154 
00155   if(!readResult){
00156     edm::LogError("EcalRawToDigiDev")<<"\n unable to read file : "
00157       <<conf.getUntrackedParameter<std::string>("DCCMapFile","");
00158   }
00159   
00160   // Build a new ECAL DCC data unpacker
00161   theUnpacker_ = new DCCDataUnpacker(myMap_,headerUnpacking_,srpUnpacking_,tccUnpacking_,feUnpacking_,memUnpacking_,syncCheck_,feIdCheck_);
00162    
00163 }

EcalRawToDigiDev::~EcalRawToDigiDev (  )  [virtual]

Class destructor.

Definition at line 367 of file EcalRawToDigi.cc.

References myMap_, and theUnpacker_.

00367                                     { 
00368   
00369   //cout << "EcalDCCUnpackingModule  " << "N events        " << (nevts_-1)<<endl;
00370   //cout << "EcalDCCUnpackingModule  " << " --- SETUP time " << endl;
00371   //cout << "EcalDCCUnpackingModule  " << "Time (sys)      " << SETUP_TIME_ << endl;
00372   //cout << "EcalDCCUnpackingModule  " << "Time in sec.    " << SETUP_TIME_/ CLOCKS_PER_SEC  << endl;
00373   //cout << "EcalDCCUnpackingModule  " << " --- Per event  " << endl;
00374   
00375   //RUNNING_TIME_ = RUNNING_TIME_ / (nevts_-1);
00376   
00377   //cout << "EcalDCCUnpackingModule  "<< "Time (sys)      " << RUNNING_TIME_  << endl;
00378   //cout << "EcalDCCUnpackingModule  "<< "Time in sec.    " << RUNNING_TIME_ / CLOCKS_PER_SEC  << endl;
00379   
00380   
00381   
00382   if(myMap_      ) delete myMap_;
00383   if(theUnpacker_) delete theUnpacker_;
00384   
00385 }

Member Function Documentation

void EcalRawToDigiDev::produce ( edm::Event &  e,
const edm::EventSetup &  c 
) [virtual]

Functions that are called by framework at each event.

Implements edm::EDProducer.

Definition at line 165 of file EcalRawToDigi.cc.

References FEDRawData::data(), dataLabel_, EMPTYEVENTSIZE, fedsLabel_, fedUnpackList_, feUnpacking_, find(), first_, edm::EventSetup::get(), EcalElectronicsMapper::getActiveSM(), edm::Event::getByLabel(), headerUnpacking_, i, LogDebug, memUnpacking_, mmm_, myMap_, edm::ESHandle< T >::product(), edm::Event::put(), put_, REGIONAL_, EcalElectronicsMapper::setActiveDCC(), DCCDataUnpacker::setDccHeadersCollection(), DCCDataUnpacker::setEBDigisCollection(), DCCDataUnpacker::setEBSrFlagsCollection(), DCCDataUnpacker::setEcalTpsCollection(), DCCDataUnpacker::setEEDigisCollection(), DCCDataUnpacker::setEESrFlagsCollection(), DCCDataUnpacker::setInvalidBlockLengthsCollection(), DCCDataUnpacker::setInvalidChIdsCollection(), DCCDataUnpacker::setInvalidEEChIdsCollection(), DCCDataUnpacker::setInvalidEEGainsCollection(), DCCDataUnpacker::setInvalidEEGainsSwitchCollection(), DCCDataUnpacker::setInvalidGainsCollection(), DCCDataUnpacker::setInvalidGainsSwitchCollection(), DCCDataUnpacker::setInvalidMemBlockSizesCollection(), DCCDataUnpacker::setInvalidMemChIdsCollection(), DCCDataUnpacker::setInvalidMemGainsCollection(), DCCDataUnpacker::setInvalidMemTtIdsCollection(), DCCDataUnpacker::setInvalidTTIdsCollection(), DCCDataUnpacker::setPnDiodeDigisCollection(), FEDRawData::size(), srpUnpacking_, tccUnpacking_, theUnpacker_, and DCCDataUnpacker::unpack().

00165                                                                    {
00166 
00167   //double TIME_START = clock();
00168   //nevts_++; //NUNO
00169 
00170 
00171   if (first_) {
00172 
00173    edm::ESHandle< EcalElectronicsMapping > ecalmapping;
00174    es.get< EcalMappingRcd >().get(ecalmapping);
00175 
00176    const EcalElectronicsMapping* TheMapping = ecalmapping.product();
00177    *mmm_ = *TheMapping;
00178    myMap_ -> setEcalElectronicsMapping(mmm_);   // because I can not pass a const to SetEcalElectronicsMapping
00179 
00180    first_ = false;
00181 
00182   }
00183 
00184   // Get list of FEDS :
00185   std::vector<int> FEDS_to_unpack;
00186   if (REGIONAL_) {
00187         edm::Handle<EcalListOfFEDS> listoffeds;
00188         e.getByLabel(fedsLabel_, listoffeds);
00189         FEDS_to_unpack = listoffeds -> GetList();
00190   }
00191 
00192 
00193 
00194   // Step A: Get Inputs    
00195 
00196   edm::Handle<FEDRawDataCollection> rawdata;  
00197   e.getByLabel(dataLabel_,rawdata);
00198 
00199 
00200   // Step B: encapsulate vectors in actual collections and set unpacker pointers
00201 
00202   // create the collection of Ecal Digis
00203   std::auto_ptr<EBDigiCollection> productDigisEB(new EBDigiCollection);
00204   productDigisEB->reserve(1700);
00205   theUnpacker_->setEBDigisCollection(&productDigisEB);
00206   
00207   // create the collection of Ecal Digis
00208   std::auto_ptr<EEDigiCollection> productDigisEE(new EEDigiCollection);
00209   theUnpacker_->setEEDigisCollection(&productDigisEE);
00210   
00211   // create the collection for headers
00212   std::auto_ptr<EcalRawDataCollection> productDccHeaders(new EcalRawDataCollection);
00213   theUnpacker_->setDccHeadersCollection(&productDccHeaders); 
00214 
00215   // create the collection for invalid gains
00216   std::auto_ptr< EBDetIdCollection> productInvalidGains(new EBDetIdCollection);
00217   theUnpacker_->setInvalidGainsCollection(&productInvalidGains); 
00218 
00219   // create the collection for invalid gain Switch
00220   std::auto_ptr< EBDetIdCollection> productInvalidGainsSwitch(new EBDetIdCollection);
00221   theUnpacker_->setInvalidGainsSwitchCollection(&productInvalidGainsSwitch);
00222    
00223   // create the collection for invalid chids
00224   std::auto_ptr< EBDetIdCollection> productInvalidChIds(new EBDetIdCollection);
00225   theUnpacker_->setInvalidChIdsCollection(&productInvalidChIds);
00226   
00228     
00229   // create the collection for invalid gains
00230   std::auto_ptr<EEDetIdCollection> productInvalidEEGains(new EEDetIdCollection);
00231   theUnpacker_->setInvalidEEGainsCollection(&productInvalidEEGains); 
00232     
00233   // create the collection for invalid gain Switch
00234   std::auto_ptr<EEDetIdCollection> productInvalidEEGainsSwitch(new EEDetIdCollection);
00235   theUnpacker_->setInvalidEEGainsSwitchCollection(&productInvalidEEGainsSwitch);
00236     
00237   // create the collection for invalid chids
00238   std::auto_ptr<EEDetIdCollection> productInvalidEEChIds(new EEDetIdCollection);
00239   theUnpacker_->setInvalidEEChIdsCollection(&productInvalidEEChIds);
00240 
00242 
00243   // create the collection for EB srflags       
00244   std::auto_ptr<EBSrFlagCollection> productEBSrFlags(new EBSrFlagCollection);
00245   theUnpacker_->setEBSrFlagsCollection(&productEBSrFlags);
00246   
00247   // create the collection for EB srflags       
00248   std::auto_ptr<EESrFlagCollection> productEESrFlags(new EESrFlagCollection);
00249   theUnpacker_->setEESrFlagsCollection(&productEESrFlags);
00250 
00251   // create the collection for ecal trigger primitives
00252   std::auto_ptr<EcalTrigPrimDigiCollection> productEcalTps(new EcalTrigPrimDigiCollection);
00253   theUnpacker_->setEcalTpsCollection(&productEcalTps);
00255 
00256   // create the collection for invalid TTIds
00257   std::auto_ptr<EcalElectronicsIdCollection> productInvalidTTIds(new EcalElectronicsIdCollection);
00258   theUnpacker_->setInvalidTTIdsCollection(&productInvalidTTIds);
00259   
00260   // create the collection for invalid BlockLengths
00261   std::auto_ptr<EcalElectronicsIdCollection> productInvalidBlockLengths(new EcalElectronicsIdCollection);
00262   theUnpacker_->setInvalidBlockLengthsCollection(&productInvalidBlockLengths);
00263 
00264   // MEMs Collections
00265   // create the collection for the Pn Diode Digis
00266   std::auto_ptr<EcalPnDiodeDigiCollection> productPnDiodeDigis(new EcalPnDiodeDigiCollection);
00267   theUnpacker_->setPnDiodeDigisCollection(&productPnDiodeDigis);
00268 
00269   // create the collection for invalid Mem Tt id 
00270   std::auto_ptr<EcalElectronicsIdCollection> productInvalidMemTtIds(new EcalElectronicsIdCollection);
00271   theUnpacker_->setInvalidMemTtIdsCollection(& productInvalidMemTtIds);
00272   
00273   // create the collection for invalid Mem Block Size 
00274   std::auto_ptr<EcalElectronicsIdCollection> productInvalidMemBlockSizes(new EcalElectronicsIdCollection);
00275   theUnpacker_->setInvalidMemBlockSizesCollection(& productInvalidMemBlockSizes);
00276   
00277   // create the collection for invalid Mem Block Size 
00278   std::auto_ptr<EcalElectronicsIdCollection> productInvalidMemChIds(new EcalElectronicsIdCollection);
00279   theUnpacker_->setInvalidMemChIdsCollection(& productInvalidMemChIds);
00280  
00281   // create the collection for invalid Mem Gain Errors 
00282   std::auto_ptr<EcalElectronicsIdCollection> productInvalidMemGains(new EcalElectronicsIdCollection);
00283   theUnpacker_->setInvalidMemGainsCollection(& productInvalidMemGains); 
00284   //  double TIME_START = clock(); 
00285   
00286 
00287   // Step C: unpack all requested FEDs    
00288   for (std::vector<int>::const_iterator i=fedUnpackList_.begin(); i!=fedUnpackList_.end(); i++) {
00289 
00290     if (REGIONAL_) {
00291       std::vector<int>::const_iterator fed_it = find(FEDS_to_unpack.begin(), FEDS_to_unpack.end(), *i);
00292       if (fed_it == FEDS_to_unpack.end()) continue;
00293     }
00294 
00295   
00296     // get fed raw data and SM id
00297     const FEDRawData & fedData = rawdata->FEDData(*i);
00298     int length = fedData.size();
00299 
00300     LogDebug("EcalRawToDigiDev") << "raw data length: " << length ;
00301     //if data size is not null interpret data
00302     if ( length >= EMPTYEVENTSIZE ){
00303       
00304       if(myMap_->setActiveDCC(*i)){
00305 
00306         int smId = myMap_->getActiveSM();
00307         LogDebug("EcalRawToDigiDev") << "Getting FED = " << *i <<"(SM = "<<smId<<")"<<" data size is: " << length;
00308 
00309         uint64_t * pData = (uint64_t *)(fedData.data());
00310         theUnpacker_->unpack( pData, static_cast<uint>(length),smId,*i);
00311       }
00312     }
00313     
00314   }// loop on FEDs
00315   
00316   //if(nevts_>1){   //NUNO
00317   //  double TIME_END = clock(); //NUNO
00318   //  RUNNING_TIME_ += TIME_END-TIME_START; //NUNO
00319   // }
00320   
00321   
00322   // Add collections to the event 
00323   
00324   if(put_){
00325     
00326     if( headerUnpacking_){ 
00327       e.put(productDccHeaders); 
00328     }
00329     
00330     if(feUnpacking_){
00331       e.put(productDigisEB,"ebDigis");
00332       e.put(productDigisEE,"eeDigis");
00333       e.put(productInvalidGains,"EcalIntegrityGainErrors");
00334       e.put(productInvalidGainsSwitch, "EcalIntegrityGainSwitchErrors");
00335       e.put(productInvalidChIds, "EcalIntegrityChIdErrors");
00336       // EE (leaving for now the same names as in EB)
00337       e.put(productInvalidEEGains,"EcalIntegrityGainErrors");
00338       e.put(productInvalidEEGainsSwitch, "EcalIntegrityGainSwitchErrors");
00339       e.put(productInvalidEEChIds, "EcalIntegrityChIdErrors");
00340       // EE
00341       e.put(productInvalidTTIds,"EcalIntegrityTTIdErrors");
00342       e.put(productInvalidBlockLengths,"EcalIntegrityBlockSizeErrors");
00343       e.put(productPnDiodeDigis);
00344     }
00345     if(memUnpacking_){
00346       e.put(productInvalidMemTtIds,"EcalIntegrityMemTtIdErrors");
00347       e.put(productInvalidMemBlockSizes,"EcalIntegrityMemBlockSizeErrors");
00348       e.put(productInvalidMemChIds,"EcalIntegrityMemChIdErrors");
00349       e.put(productInvalidMemGains,"EcalIntegrityMemGainErrors");
00350     }
00351     if(srpUnpacking_){
00352       e.put(productEBSrFlags);
00353       e.put(productEESrFlags);
00354     }
00355     if(tccUnpacking_){
00356       e.put(productEcalTps,"EcalTriggerPrimitives");
00357     }
00358   }
00359   
00360 //if(nevts_>1){   //NUNO
00361 //  double TIME_END = clock(); //NUNO 
00362 //  RUNNING_TIME_ += TIME_END-TIME_START; //NUNO
00363 //}
00364   
00365 }

Member Data Documentation

std::string EcalRawToDigiDev::dataLabel_ [private]

Definition at line 80 of file EcalRawToDigi.h.

Referenced by produce().

edm::InputTag EcalRawToDigiDev::fedsLabel_ [private]

Definition at line 84 of file EcalRawToDigi.h.

Referenced by produce().

std::vector<int> EcalRawToDigiDev::fedUnpackList_ [private]

Definition at line 62 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

bool EcalRawToDigiDev::feIdCheck_ [private]

Definition at line 76 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

bool EcalRawToDigiDev::feUnpacking_ [private]

Definition at line 73 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

bool EcalRawToDigiDev::first_ [private]

Definition at line 77 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

bool EcalRawToDigiDev::headerUnpacking_ [private]

Definition at line 70 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

bool EcalRawToDigiDev::memUnpacking_ [private]

Definition at line 74 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

EcalElectronicsMapping* EcalRawToDigiDev::mmm_ [private]

Definition at line 89 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

EcalElectronicsMapper* EcalRawToDigiDev::myMap_ [private]

Definition at line 87 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), produce(), and ~EcalRawToDigiDev().

uint EcalRawToDigiDev::nevts_ [private]

Definition at line 96 of file EcalRawToDigi.h.

uint EcalRawToDigiDev::numbTriggerTSamples_ [private]

Definition at line 68 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

uint EcalRawToDigiDev::numbXtalTSamples_ [private]

Definition at line 67 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

std::vector<int> EcalRawToDigiDev::orderedDCCIdList_ [private]

Definition at line 65 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

std::vector<int> EcalRawToDigiDev::orderedFedUnpackList_ [private]

Definition at line 64 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

bool EcalRawToDigiDev::put_ [private]

Definition at line 78 of file EcalRawToDigi.h.

Referenced by produce().

bool EcalRawToDigiDev::REGIONAL_ [private]

Definition at line 83 of file EcalRawToDigi.h.

Referenced by produce().

double EcalRawToDigiDev::RUNNING_TIME_ [private]

Definition at line 97 of file EcalRawToDigi.h.

double EcalRawToDigiDev::SETUP_TIME_ [private]

Definition at line 97 of file EcalRawToDigi.h.

bool EcalRawToDigiDev::srpUnpacking_ [private]

Definition at line 71 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

bool EcalRawToDigiDev::syncCheck_ [private]

Definition at line 75 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev().

bool EcalRawToDigiDev::tccUnpacking_ [private]

Definition at line 72 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), and produce().

DCCDataUnpacker* EcalRawToDigiDev::theUnpacker_ [private]

Definition at line 92 of file EcalRawToDigi.h.

Referenced by EcalRawToDigiDev(), produce(), and ~EcalRawToDigiDev().

The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:19:48 2009 for CMSSW by  doxygen 1.5.4