#include <HcalTBObjectUnpacker.h>

Inheritance diagram for HcalTBObjectUnpacker:

Public Member Functions
	HcalTBObjectUnpacker (const edm::ParameterSet &ps)

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

virtual	~HcalTBObjectUnpacker ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

boost::function< void(const BranchDescription &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Private Member Functions
void	parseCalib ()

Private Attributes
std::string	calibFile_

std::vector< std::vector < std::string > >	calibLines_

bool	doBeamADC_

bool	doEventPosition_

bool	doRunData_

bool	doSourcePos_

bool	doTiming_

bool	doTriggerData_

int	qadcFed_

hcaltb::HcalTBQADCUnpacker	qadcUnpacker_

int	sdFed_

hcaltb::HcalTBSlowDataUnpacker	sdUnpacker_

int	spdFed_

hcaltb::HcalTBSourcePositionDataUnpacker	spdUnpacker_

int	tdcFed_

hcaltb::HcalTBTDCUnpacker	tdcUnpacker_

hcaltb::HcalTBTriggerDataUnpacker	tdUnpacker_

int	triggerFed_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
template<class TProducer , class TMethod >
void	callWhenNewProductsRegistered (TProducer *iProd, TMethod iMethod)

Detailed Description

HcalTBObjectUnpacker is the EDProducer subclass which runs the Hcal Test Beam Object Unpack algorithm.

Author: Phil Dudero

Version: 1st Version June 10, 2005

Definition at line 31 of file HcalTBObjectUnpacker.h.

Constructor & Destructor Documentation

HcalTBObjectUnpacker::HcalTBObjectUnpacker ( const edm::ParameterSet & ps )

explicit

Definition at line 17 of file HcalTBObjectUnpacker.cc.

References calibFile_, calibLines_, gather_cfg::cout, doBeamADC_, doEventPosition_, doRunData_, doSourcePos_, doTiming_, doTriggerData_, edm::hlt::Exception, parseCalib(), qadcFed_, qadcUnpacker_, sdFed_, hcaltb::HcalTBQADCUnpacker::setCalib(), hcaltb::HcalTBTDCUnpacker::setCalib(), spdFed_, tdcFed_, tdcUnpacker_, and triggerFed_.

                                                                        :
     triggerFed_(conf.getUntrackedParameter<int>("HcalTriggerFED",-1)),
     sdFed_(conf.getUntrackedParameter<int>("HcalSlowDataFED",-1)),
     spdFed_(conf.getUntrackedParameter<int>("HcalSourcePositionFED",-1)),
     tdcFed_(conf.getUntrackedParameter<int>("HcalTDCFED",-1)),
     qadcFed_(conf.getUntrackedParameter<int>("HcalQADCFED",-1)),
     calibFile_(conf.getUntrackedParameter<string>("ConfigurationFile","")),
     tdcUnpacker_(conf.getUntrackedParameter<bool>("IncludeUnmatchedHits",false)),
     doRunData_(false),doTriggerData_(false),doEventPosition_(false),doTiming_(false),doSourcePos_(false),doBeamADC_(false)
   {
 
     if (triggerFed_ >=0) {
       std::cout << "HcalTBObjectUnpacker will unpack Trigger FED ";
       std::cout << triggerFed_ << endl;
       doTriggerData_=true;
     }
 
     if (sdFed_ >=0) {
       std::cout << "HcalTBObjectUnpacker will unpack SlowData FED ";
       std::cout << sdFed_ << endl;
       doRunData_=true;
       doEventPosition_=true; // at least the table
     }
 
     if (tdcFed_ >=0) {
       std::cout << "HcalTBObjectUnpacker will unpack TDC FED ";
       std::cout << tdcFed_ << endl;
       doTiming_=true;
       doEventPosition_=true; // at least the WC
     }
 
     if (qadcFed_ >=0) {
       std::cout << "HcalTBObjectUnpacker will unpack QADC FED ";
       std::cout << qadcFed_ << endl;
       doBeamADC_=true;
     }
 
     if (spdFed_ >=0) {
       std::cout << "HcalTBObjectUnpacker will unpack Source Position Data FED ";
       std::cout << spdFed_ << endl;
       doSourcePos_=true;
     }
 
 
     if (tdcFed_ >= 0 || qadcFed_ >=0 ) {
       calibLines_.clear();
       if(calibFile_.size()>0){
     parseCalib();
     //  printf("I got %d lines!\n",calibLines_.size());
     if(calibLines_.size()==0)
       throw cms::Exception("Incomplete configuration") << 
         "HcalTBObjectUnpacker: TDC/QADC/WC configuration file not found or is empty: "<<calibFile_<<endl;
       }
       else{
     throw cms::Exception("Incomplete configuration") << 
       "HcalTBObjectUnpacker: TDC/QADC/WC configuration file not found: "<<calibFile_<<endl;
       }
     }
 
 
     if (doTriggerData_) produces<HcalTBTriggerData>();
     if (doRunData_) produces<HcalTBRunData>();
     if (doEventPosition_) produces<HcalTBEventPosition>();
     if (doTiming_) produces<HcalTBTiming>();
 //    if (doBeamADC_) produces<HcalTBBeamCounters>();
     if (doBeamADC_) {produces<HcalTBBeamCounters>();qadcUnpacker_.setCalib(calibLines_);}
 //    if (doSourcePos_) produces<HcalSourcePositionData>();
     if(doTiming_||doEventPosition_)tdcUnpacker_.setCalib(calibLines_);
   }

HcalTBObjectUnpacker::~HcalTBObjectUnpacker ( )

virtual

Definition at line 88 of file HcalTBObjectUnpacker.cc.

88 { }

Member Function Documentation

void HcalTBObjectUnpacker::parseCalib ( )

private

Definition at line 159 of file HcalTBObjectUnpacker.cc.

References calibFile_, calibLines_, relativeConstraints::empty, i, and EdgesToViz::infile.

Referenced by HcalTBObjectUnpacker().

                                      {
   
   if(calibFile_.size()==0){
     printf("HcalTBObjectUnpacker cowardly refuses to parse a NULL file...\n"); 
     return;
   }
  
   ifstream infile(calibFile_.c_str());
 
   char buffer [1024];
   string tmpStr;
   
   while (infile.getline(buffer, 1024)) {
     if (buffer [0] == '#') continue; //ignore comment
     if (buffer [0] == '/' && buffer [1] == '/') continue; //ignore comment
     tmpStr = string(buffer);
     vector<string> lineVect;
     
     int start = 0; bool empty = true;
     for (unsigned i=0; i<=tmpStr.size(); i++) {
       if (tmpStr[i] == ' ' || i==tmpStr.size()) {
     if (!empty) {
       std::string item(tmpStr, start, i-start);
       lineVect.push_back(item);
       empty = true;
 //    printf("Got: %s\n",item.c_str());
     }
     start = i+1;
       }
       else {
     if (empty) empty = false;   
       }
     }  
     
     if(lineVect.size()>0) calibLines_.push_back(lineVect);    
   }
 
   infile.close();
   return;
 }

void HcalTBObjectUnpacker::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

virtual

Implements edm::EDProducer.

Definition at line 91 of file HcalTBObjectUnpacker.cc.

References doBeamADC_, doEventPosition_, doRunData_, doSourcePos_, doTiming_, doTriggerData_, edm::Event::getByType(), edm::Event::put(), qadcFed_, qadcUnpacker_, sdFed_, sdUnpacker_, spdFed_, spdUnpacker_, tdcFed_, tdcUnpacker_, tdUnpacker_, triggerFed_, hcaltb::HcalTBQADCUnpacker::unpack(), hcaltb::HcalTBTriggerDataUnpacker::unpack(), hcaltb::HcalTBSourcePositionDataUnpacker::unpack(), hcaltb::HcalTBSlowDataUnpacker::unpack(), and hcaltb::HcalTBTDCUnpacker::unpack().

   {
     // Step A: Get Inputs 
     edm::Handle<FEDRawDataCollection> rawraw;  
     //    edm::ProcessNameSelector s("PROD"); // HACK!
     e.getByType(rawraw);           
 
     // Step B: Create empty output    
     std::auto_ptr<HcalTBTriggerData>
       trigd(new HcalTBTriggerData);
 
     std::auto_ptr<HcalTBRunData>
       rund(new HcalTBRunData);
 
     std::auto_ptr<HcalTBEventPosition>
       epd(new HcalTBEventPosition);
 
     std::auto_ptr<HcalTBTiming>
       tmgd(new HcalTBTiming);
 
     std::auto_ptr<HcalTBBeamCounters>
       bcntd(new HcalTBBeamCounters);
 
     std::auto_ptr<HcalSourcePositionData>
       spd(new HcalSourcePositionData);
     
     if (triggerFed_ >=0) {
       // Step C: unpack all requested FEDs
       const FEDRawData& fed = rawraw->FEDData(triggerFed_);
       tdUnpacker_.unpack(fed,*trigd);
     }
 
     if (sdFed_ >=0) {
       // Step C: unpack all requested FEDs
       const FEDRawData& fed = rawraw->FEDData(sdFed_);
       sdUnpacker_.unpack(fed, *rund, *epd);
     }
 
     if (tdcFed_ >=0) {
       // Step C: unpack all requested FEDs
       const FEDRawData& fed = rawraw->FEDData(tdcFed_);
       tdcUnpacker_.unpack(fed, *epd, *tmgd);
     }
 
     if (qadcFed_ >=0) {
       // Step C: unpack all requested FEDs
       const FEDRawData& fed = rawraw->FEDData(qadcFed_);
       bool is04 = true;
       if(qadcFed_==8) is04=false;
       qadcUnpacker_.unpack(fed, *bcntd,is04);
     }
 
     if (spdFed_ >=0) {      
       // Step C: unpack all requested FEDs
       const FEDRawData& fed = rawraw->FEDData(spdFed_);
       spdUnpacker_.unpack(fed, *spd);
     }
 
     // Step D: Put outputs into event
     if (doTriggerData_) e.put(trigd);
     if (doRunData_) e.put(rund);
     if (doEventPosition_) e.put(epd);
     if (doTiming_) e.put(tmgd);
     if (doBeamADC_) e.put(bcntd);
     if (doSourcePos_) e.put(spd);
   }