#include <HGCDigitizerBase.h>

Public Types
typedef edm::SortedCollection< D >	DColl

Public Member Functions
	HGCDigitizerBase (const edm::ParameterSet &ps)
	CTOR. More...

void	run (std::auto_ptr< DColl > &digiColl, HGCSimHitDataAccumulator &simData, uint32_t digitizationType, CLHEP::HepRandomEngine *engine)
	steer digitization mode More...

virtual void	runDigitizer (std::auto_ptr< DColl > &coll, HGCSimHitDataAccumulator &simData, uint32_t digitizerType, CLHEP::HepRandomEngine *engine)
	to be specialized by top class More...

void	runShaper (D &dataFrame)
	applies a shape to each time sample and propagates the tails to the subsequent time samples More...

void	runTrivial (std::auto_ptr< DColl > &coll, HGCSimHitDataAccumulator &simData, CLHEP::HepRandomEngine *engine)
	a trivial digitization: sum energies and digitize without noise More...

void	updateOutput (std::auto_ptr< DColl > &coll, D rawDataFrame)
	prepares the output according to the number of time samples to produce More...

	~HGCDigitizerBase ()
	DTOR. More...

Public Attributes
uint32_t	adcThreshold_

int	bxTime_

bool	doTimeSamples_

double	lsbInMIP_

double	mip2noise_

double	mipInKeV_

edm::ParameterSet	myCfg_

double	shaperN_

double	shaperTau_

Detailed Description

template<class D>
class HGCDigitizerBase< D >

Definition at line 20 of file HGCDigitizerBase.h.

Member Typedef Documentation

template<class D>

typedef edm::SortedCollection<D> HGCDigitizerBase< D >::DColl

Definition at line 24 of file HGCDigitizerBase.h.

Constructor & Destructor Documentation

template<class D>

HGCDigitizerBase< D >::HGCDigitizerBase ( const edm::ParameterSet & ps )

inline

CTOR.

Definition at line 29 of file HGCDigitizerBase.h.

                                              {
     myCfg_         = ps.getParameter<edm::ParameterSet>("digiCfg"); 
     bxTime_        = ps.getParameter<int32_t>("bxTime");
     doTimeSamples_ = myCfg_.getParameter< bool >("doTimeSamples");
     mipInKeV_      = myCfg_.getParameter<double>("mipInKeV");
     lsbInMIP_      = myCfg_.getParameter<double>("lsbInMIP");
     mip2noise_     = myCfg_.getParameter<double>("mip2noise");
     adcThreshold_  = myCfg_.getParameter< uint32_t >("adcThreshold");
     shaperN_       = myCfg_.getParameter< double >("shaperN");
     shaperTau_     = myCfg_.getParameter< double >("shaperTau");
   }

template<class D>

HGCDigitizerBase< D >::~HGCDigitizerBase ( )

inline

DTOR.

Definition at line 143 of file HGCDigitizerBase.h.

143 { };

Member Function Documentation

template<class D>

void HGCDigitizerBase< D >::run	(	std::auto_ptr< DColl > &	digiColl,
		HGCSimHitDataAccumulator &	simData,
		uint32_t	digitizationType,
		CLHEP::HepRandomEngine *	engine
	)

inline

steer digitization mode

Definition at line 44 of file HGCDigitizerBase.h.

                                                                                                                                    {
     if(digitizationType==0) runTrivial(digiColl,simData,engine);
     else                    runDigitizer(digiColl,simData,digitizationType,engine);
   }

template<class D>

virtual void HGCDigitizerBase< D >::runDigitizer	(	std::auto_ptr< DColl > &	coll,
		HGCSimHitDataAccumulator &	simData,
		uint32_t	digitizerType,
		CLHEP::HepRandomEngine *	engine
	)

inlinevirtual

to be specialized by top class

Definition at line 136 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCEEDataFrame >::run().

                                                                                                                                              {
     throw cms::Exception("HGCDigitizerBaseException") << " Failed to find specialization of runDigitizer";
   }

template<class D>

void HGCDigitizerBase< D >::runShaper ( D & dataFrame )

inline

applies a shape to each time sample and propagates the tails to the subsequent time samples

Definition at line 113 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCEEDataFrame >::runTrivial().

                                {
     std::vector<uint16_t> oldADC(dataFrame.size());
     for(int it=0; it<dataFrame.size(); it++) {
       uint16_t gain=dataFrame[it].gain();
       oldADC[it]=dataFrame[it].adc();
       uint16_t newADC(oldADC[it]);
     
       if(shaperN_*shaperTau_>0){
     for(int jt=0; jt<it; jt++) {
       float relTime(bxTime_*(it-jt)+shaperN_*shaperTau_);   
       newADC += uint16_t(oldADC[jt]*pow(relTime/(shaperN_*shaperTau_),shaperN_)*exp(-(relTime-shaperN_*shaperTau_)/shaperTau_));          
     }
       }
 
       HGCSample newSample;
       newSample.set(gain,newADC);
       dataFrame.setSample(it,newSample);
     }
   }

template<class D>

void HGCDigitizerBase< D >::runTrivial	(	std::auto_ptr< DColl > &	coll,
		HGCSimHitDataAccumulator &	simData,
		CLHEP::HepRandomEngine *	engine
	)

inline

a trivial digitization: sum energies and digitize without noise

Definition at line 53 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCEEDataFrame >::run().

                                                                                                             {
     for(HGCSimHitDataAccumulator::iterator it=simData.begin();
     it!=simData.end(); it++) {
       
       //create a new data frame
       D rawDataFrame( it->first );
 
       for(size_t i=0; i<it->second.size(); i++) {
     //convert total energy GeV->keV->ADC counts
     double totalEn=(it->second)[i]*1e6;
 
     //add noise (in keV)
     double noiseEn=CLHEP::RandGaussQ::shoot(engine,0,mipInKeV_/mip2noise_);
     totalEn += noiseEn;
     if(totalEn<0) totalEn=0;
     
     //round to integer (sample will saturate the value according to available bits)
     uint16_t totalEnInt = floor( (totalEn/mipInKeV_) / lsbInMIP_ );
 
     //0 gain for the moment
     HGCSample singleSample;
     singleSample.set(0, totalEnInt);
     
     rawDataFrame.setSample(i, singleSample);
       }
     
       //run the shaper
       runShaper(rawDataFrame);
 
       //update the output according to the final shape
       updateOutput(coll,rawDataFrame);
     }
   }

template<class D>

void HGCDigitizerBase< D >::updateOutput	(	std::auto_ptr< DColl > &	coll,
		D	rawDataFrame
	)

inline

prepares the output according to the number of time samples to produce

Definition at line 90 of file HGCDigitizerBase.h.

Referenced by HGCDigitizerBase< HGCEEDataFrame >::runTrivial().

                                                              {
     size_t itIdx(4); //index to the in-time digi - this could be configurable in a future version
 
     //check if in-time sample is above threshold and put result into the event
     if(doTimeSamples_) {
       if(rawDataFrame[itIdx].adc() < adcThreshold_ ) return;
       coll->push_back(rawDataFrame);
     } else {
       //create a new data frame containing only the in-time digi
       D singleRawDataFrame( rawDataFrame.id() );
       singleRawDataFrame.resize(1);
 
       HGCSample singleSample;
       singleSample.set(rawDataFrame[itIdx].gain(),rawDataFrame[itIdx].adc());
       singleRawDataFrame.setSample(0, singleSample);
       if(singleRawDataFrame[0].adc() < adcThreshold_ ) return;
       coll->push_back(singleRawDataFrame);
     }
   }