#include <LUCID_DigitizationToolBox.h>

Inheritance diagram for LUCID_DigitizationToolBox:

Collaboration diagram for LUCID_DigitizationToolBox:

Public Member Functions
	LUCID_DigitizationToolBox ()

	LUCID_DigitizationToolBox (int numTubes, double qdcChannelsPerPE, double qdcPedestal, double qdcFedNoiseFactor, double tdcPmtNoiseFactor, double tdcFedNoiseFactor, double TotalPMTgain, double AmpFactor, double Q1bin, int NoiseCharge, int numDyinodes, double dynodeGammaFactor, std::vector< double > pmtSmearing, std::vector< double > pmtScaling, std::vector< double > gasScaling, std::vector< double > npeThreshold, bool fillRootTree)

StatusCode	recordContainers (const ServiceHandle< StoreGateSvc > &, const std::string &)

StatusCode	fillDigitContainer (TimedHitCollection< LUCID_SimHit > &, CLHEP::HepRandomEngine *)

StatusCode	fillDigitContainer (LUCID_SimHitCollection , CLHEP::HepRandomEngine )

StatusCode	setDebugTree (ITHistSvc *)

Protected Member Functions
TTree *	getDebugTree ()

StatusCode	createAndStoreDigit (unsigned short tubeID, CLHEP::HepRandomEngine *rndEngine)

double	DynodeChainSimulation (double npe, CLHEP::HepRandomEngine *rndEngine) const

Static Protected Member Functions
static unsigned int	roundoff (double x)

static double	DynodeGainSmearing (double npe, CLHEP::HepRandomEngine *rndEngine)

Protected Attributes
LUCID_DigitContainer *	m_digitContainer {}

int	m_numTubes {}

double	m_qdcChannelsPerPE {}

double	m_qdcPedestal {}

double	m_qdcFedNoiseFactor {}

double	m_tdcPmtNoiseFactor {}

double	m_tdcFedNoiseFactor {}

double	m_TotalPMTgain {}

double	m_AmpFactor {}

double	m_Q1bin {}

int	m_NoiseCharge {}

int	m_numDyinodes {}

double	m_dynodeGammaFactor {}

double	m_gainPerDynode {}

double	m_ChargeToQdcFactor {}

std::vector< double >	m_pmtSmearing {}

std::vector< double >	m_pmtScaling {}

std::vector< double >	m_gasScaling {}

std::vector< double >	m_npeThreshold {}

bool	m_fillRootTree {}

unsigned short	m_tubeID {}

double	m_npe {}

unsigned short	m_npeGas {}

unsigned short	m_npePmt {}

unsigned short	m_qdc {}

double	m_tdcTot {}

unsigned short	m_tdc {}

TTree *	m_tubeInfo {}

Detailed Description

Definition at line 19 of file LUCID_DigitizationToolBox.h.

Constructor & Destructor Documentation

◆ LUCID_DigitizationToolBox() [1/2]

LUCID_DigitizationToolBox::LUCID_DigitizationToolBox ( )

Definition at line 17 of file LUCID_DigitizationToolBox.cxx.

                                                     : 
   m_tubeID(0),
   m_npe   (0),
   m_npeGas(0), 
   m_npePmt(0),
   m_qdc   (0),
   m_tdcTot(0),
   m_tdc   (0)
 {
   m_digitContainer = nullptr;
   m_tubeInfo       = nullptr;
   
   m_numTubes          = 0;  
   m_qdcChannelsPerPE  = 0;
   m_qdcPedestal       = 0;
   m_qdcFedNoiseFactor = 0;
   m_tdcPmtNoiseFactor = 0;
   m_tdcFedNoiseFactor = 0;
  
   m_TotalPMTgain      = 0;
   m_AmpFactor         = 0;
   m_Q1bin             = 0;
   m_NoiseCharge       = 0;
   m_numDyinodes       = 0;
   m_dynodeGammaFactor = 0;
   m_gainPerDynode     = 0;
   m_ChargeToQdcFactor = 0;
  
   m_fillRootTree = 0;
 }

◆ LUCID_DigitizationToolBox() [2/2]

LUCID_DigitizationToolBox::LUCID_DigitizationToolBox	(	int	numTubes,
		double	qdcChannelsPerPE,
		double	qdcPedestal,
		double	qdcFedNoiseFactor,
		double	tdcPmtNoiseFactor,
		double	tdcFedNoiseFactor,
		double	TotalPMTgain,
		double	AmpFactor,
		double	Q1bin,
		int	NoiseCharge,
		int	numDyinodes,
		double	dynodeGammaFactor,
		std::vector< double >	pmtSmearing,
		std::vector< double >	pmtScaling,
		std::vector< double >	gasScaling,
		std::vector< double >	npeThreshold,
		bool	fillRootTree
	)

Definition at line 49 of file LUCID_DigitizationToolBox.cxx.

                                                  : 
   m_numTubes            (numTubes),
   m_qdcChannelsPerPE    (qdcChannelsPerPE),
   m_qdcPedestal         (qdcPedestal),
   m_qdcFedNoiseFactor   (qdcFedNoiseFactor),
   m_tdcPmtNoiseFactor   (tdcPmtNoiseFactor),
   m_tdcFedNoiseFactor   (tdcFedNoiseFactor),
   m_TotalPMTgain        (TotalPMTgain),
   m_AmpFactor           (AmpFactor),
   m_Q1bin               (Q1bin),
   m_NoiseCharge         (NoiseCharge),
   m_numDyinodes         (numDyinodes),
   m_dynodeGammaFactor   (dynodeGammaFactor),
   m_pmtSmearing         (std::move(pmtSmearing)),
   m_pmtScaling          (std::move(pmtScaling)),
   m_gasScaling          (std::move(gasScaling)),
   m_npeThreshold        (std::move(npeThreshold)),
   m_fillRootTree        (fillRootTree),    
   m_tubeID              (0),
   m_npe                 (0),
   m_npeGas              (0), 
   m_npePmt              (0),
   m_qdc                 (0),
   m_tdcTot              (0),
   m_tdc                 (0)
 {
   m_gainPerDynode     = std::pow(m_TotalPMTgain/m_dynodeGammaFactor, 1.0/static_cast<double>(m_numDyinodes)); 
   m_ChargeToQdcFactor = (double)1.6e-19 * m_AmpFactor/m_Q1bin;
  
   m_digitContainer = nullptr;
   m_tubeInfo       = nullptr;
 }

Member Function Documentation

◆ createAndStoreDigit()

StatusCode LUCID_DigitizationToolBox::createAndStoreDigit	(	unsigned short	tubeID,
		CLHEP::HepRandomEngine *	rndEngine
	)

protected

Definition at line 129 of file LUCID_DigitizationToolBox.cxx.

                                                                                                                 {
   
   double npePmt     = m_npePmt * m_pmtScaling[tubeID] * CLHEP::RandGaussQ::shoot(rndEngine, 1, m_pmtSmearing[tubeID]);
   double npeGas     = m_npeGas * m_gasScaling[tubeID];
   double npeTot     = npeGas + npePmt;
   double qdcSmeared = DynodeChainSimulation(npeTot, rndEngine);
     
   m_qdc = roundoff(qdcSmeared);
     
   m_npe = (m_qdc - m_qdcPedestal)/m_qdcChannelsPerPE;
  
   double tdcTotSmeared = 0;
     
   tdcTotSmeared = CLHEP::RandGaussQ::shoot(rndEngine, m_tdcTot     , m_tdcPmtNoiseFactor);
   tdcTotSmeared = CLHEP::RandGaussQ::shoot(rndEngine, tdcTotSmeared, m_tdcFedNoiseFactor);
   tdcTotSmeared = (npeTot) ? tdcTotSmeared/npeTot : tdcTotSmeared;
   tdcTotSmeared = (tdcTotSmeared < 0) ? 0 : tdcTotSmeared;
  
   m_tdc = static_cast<unsigned int>(tdcTotSmeared);
     
   if (m_fillRootTree) m_tubeInfo->Fill(); 
  
   m_digitContainer->push_back(new LUCID_Digit(m_tubeID, 
                           m_npe, 
                           m_npeGas, 
                           m_npePmt, 
                           m_qdc, 
                           m_tdc,
                           m_npe > m_npeThreshold[tubeID]));
   return StatusCode::SUCCESS;
 }

◆ DynodeChainSimulation()

double LUCID_DigitizationToolBox::DynodeChainSimulation	(	double	npe,
		CLHEP::HepRandomEngine *	rndEngine
	)		const

protected

Definition at line 238 of file LUCID_DigitizationToolBox.cxx.

                                                                                                         {
   
   double smearedQDC = 0;
   
   if (npe == 0) return CLHEP::RandGaussQ::shoot(rndEngine, npe, m_ChargeToQdcFactor * m_NoiseCharge) + m_qdcPedestal;
   
   for (int i_pe=1; i_pe <= m_numDyinodes; i_pe++ ) {
     
     if (i_pe == 1) smearedQDC = DynodeGainSmearing(npe        * m_gainPerDynode * m_dynodeGammaFactor, rndEngine);  
     else           smearedQDC = DynodeGainSmearing(smearedQDC * m_gainPerDynode                      , rndEngine);  
   }
   
   smearedQDC = smearedQDC*m_ChargeToQdcFactor;
   
   return static_cast<double>(CLHEP::RandGaussQ::shoot(rndEngine, smearedQDC, m_NoiseCharge * m_ChargeToQdcFactor)) + m_qdcPedestal;  
 }

◆ DynodeGainSmearing()

double LUCID_DigitizationToolBox::DynodeGainSmearing	(	double	npe,
		CLHEP::HepRandomEngine *	rndEngine
	)

staticprotected

Definition at line 256 of file LUCID_DigitizationToolBox.cxx.

                                                                                                {
   
   if (npe < 20) return CLHEP::RandPoissonQ::shoot(rndEngine, npe);
   else          return CLHEP::RandGaussQ::shoot  (rndEngine, npe, std::sqrt(npe));
 }

◆ fillDigitContainer() [1/2]

StatusCode LUCID_DigitizationToolBox::fillDigitContainer	(	LUCID_SimHitCollection *	thpclucid,
		CLHEP::HepRandomEngine *	rndEngine
	)

Definition at line 195 of file LUCID_DigitizationToolBox.cxx.

                                                                                                                            {
       
   for (m_tubeID = 0; m_tubeID < m_numTubes; m_tubeID++) {
     
     if (m_tubeID >= 16 &&  m_tubeID <= 19) continue; // skip fiber tubes on sideA
     if (m_tubeID >= 36 &&  m_tubeID <= 39) continue; // skip fiber tubes on sideC
     
     m_npe = m_npeGas = m_npePmt = m_qdc = m_tdc = m_tdcTot = 0;
         
     LUCID_SimHitCollection::const_iterator hitIt  = thpclucid->begin();
     LUCID_SimHitCollection::const_iterator hitItE = thpclucid->end();
  
     for (; hitIt != hitItE; ++hitIt) {
       
       if (m_tubeID != (*hitIt).GetTubeID()) continue;
       
       if (!(*hitIt).isDetected(rndEngine)) continue; // applying quantum efficiency
  
       if ((*hitIt).GetGenVolume() == 1) m_npeGas++;
       if ((*hitIt).GetGenVolume() == 2) m_npeGas++;
       if ((*hitIt).GetGenVolume() == 3) m_npePmt++;
       
       m_tdcTot += (*hitIt).GetPreStepTime();
     }
  
     if (createAndStoreDigit(m_tubeID, rndEngine).isFailure()) return StatusCode::FAILURE;
   }
   
   return StatusCode::SUCCESS;
 }

◆ fillDigitContainer() [2/2]

StatusCode LUCID_DigitizationToolBox::fillDigitContainer	(	TimedHitCollection< LUCID_SimHit > &	thpclucid,
		CLHEP::HepRandomEngine *	rndEngine
	)

Definition at line 162 of file LUCID_DigitizationToolBox.cxx.

                                                                                                                                      {
   
   for (m_tubeID = 0; m_tubeID < m_numTubes; m_tubeID++) {
     
     if (m_tubeID >= 16 &&  m_tubeID <= 19) continue; // skip fiber tubes on sideA
     if (m_tubeID >= 36 &&  m_tubeID <= 39) continue; // skip fiber tubes on sideC
     
     m_npe = m_npeGas = m_npePmt = m_qdc = m_tdc = m_tdcTot = 0;
     
     TimedHitCollection<LUCID_SimHit>                 thpc = thpclucid;
     TimedHitCollection<LUCID_SimHit>::const_iterator i, e, hitIt;
     
     while (thpc.nextDetectorElement(i, e)) for (hitIt = i; hitIt != e; ++hitIt) {
       
       if (m_tubeID != (*hitIt)->GetTubeID()) continue;
  
       if (!(*hitIt)->isDetected(rndEngine)) continue; // applying quantum efficiency
  
       if ((*hitIt)->GetGenVolume() == 1) m_npeGas++;
       if ((*hitIt)->GetGenVolume() == 2) m_npeGas++;
       if ((*hitIt)->GetGenVolume() == 3) m_npePmt++;
       
       m_tdcTot += (*hitIt)->GetPreStepTime();
     }
     
     if (createAndStoreDigit(m_tubeID, rndEngine).isFailure()) return StatusCode::FAILURE;
   }
   
   return StatusCode::SUCCESS;
  
 }

◆ getDebugTree()

TTree* LUCID_DigitizationToolBox::getDebugTree ( )

inlineprotected

Definition at line 51 of file LUCID_DigitizationToolBox.h.

51 { return m_tubeInfo; }

◆ recordContainers()

StatusCode LUCID_DigitizationToolBox::recordContainers	(	const ServiceHandle< StoreGateSvc > &	digitsStore,
		const std::string &	key_digitCnt
	)

Definition at line 228 of file LUCID_DigitizationToolBox.cxx.

                                                                                                                                     {
   
   m_digitContainer = new LUCID_DigitContainer();
  
   StatusCode sc = digitsStore->record(m_digitContainer, key_digitCnt);
   
   return sc;
 }

◆ roundoff()

unsigned int LUCID_DigitizationToolBox::roundoff ( double x )

staticprotected

Definition at line 118 of file LUCID_DigitizationToolBox.cxx.

                                                          {
   
   assert(x >= INT_MIN-0.5);
   assert(x <= INT_MAX+0.5);
   
   if (x >= 0) return static_cast<int>(x+0.5);
   
   return static_cast<int>(x-0.5);
 }

◆ setDebugTree()

StatusCode LUCID_DigitizationToolBox::setDebugTree ( ITHistSvc * digitHistSvc )

Definition at line 99 of file LUCID_DigitizationToolBox.cxx.

                                                                           {
   
   m_tubeInfo = new TTree("t", "LUCID_LUMI_SUMMARY");
   
   StatusCode sc = digitHistSvc->regTree("/AANT/LUCID_LUMI_SUMMARY", m_tubeInfo);
   
   if (sc.isFailure()) return StatusCode::FAILURE;
   
   m_tubeInfo->Branch("tubeID", &m_tubeID, "tubeID/s");
   m_tubeInfo->Branch("npe"   , &m_npe   , "npe/D");
   m_tubeInfo->Branch("npeGas", &m_npeGas, "npeGas/s");
   m_tubeInfo->Branch("npePmt", &m_npePmt, "npePmt/s");
   m_tubeInfo->Branch("qdc"   , &m_qdc   , "qdc/s");
   m_tubeInfo->Branch("tdc"   , &m_tdc   , "tdc/s");
   
   return StatusCode::SUCCESS;
 }