#include <MuIDReadoutSimStandardAlg.h>

Inheritance diagram for gar::rosim::MuIDReadoutSimStandardAlg:

Public Member Functions
	MuIDReadoutSimStandardAlg (CLHEP::HepRandomEngine &engine, fhicl::ParameterSet const &pset)

virtual	~MuIDReadoutSimStandardAlg ()

void	reconfigure (fhicl::ParameterSet const &pset)

void	ClearLists ()

void	PrepareAlgo (const std::vector< art::Ptr< sdp::CaloDeposit > > &hitVector)

void	DoDigitization ()

std::vector< raw::CaloRawDigit * >	GetDigitizedHits () const

Public Member Functions inherited from gar::rosim::SiPMReadoutSimAlg
	SiPMReadoutSimAlg (CLHEP::HepRandomEngine &engine, fhicl::ParameterSet const &pset)

virtual	~SiPMReadoutSimAlg ()

Protected Member Functions
float	DoPhotonStatistics (float x, float y, float z, float energy) const

float	DoTimeSmearing (float time) const

float	AddElectronicNoise (float energy) const

raw::CaloRawDigit *	DoStripDigitization (float x, float y, float z, float energy, float time, raw::CellID_t cID) const

std::pair< std::array< double, 3 >, bool >	CalculatePosition (float x, float y, float z, raw::CellID_t cID) const

std::pair< float, float >	DoLightPropagation (float x, float y, float z, float time, raw::CellID_t cID) const

Private Attributes
std::unique_ptr< util::SiPMUtils >	fSiPMUtils
	used for the SiPM saturation More...

std::vector< const sdp::CaloDeposit * >	m_SimCaloHitVec
	used to store the simulated hits More...

std::vector< raw::CaloRawDigit * >	m_DigitHitVec
	vector of digitized hits More...

TGeoManager *	fGeoManager

Additional Inherited Members
Protected Attributes inherited from gar::rosim::SiPMReadoutSimAlg
CLHEP::HepRandomEngine &	fEngine
	random number engine More...

bool	fAddNoise
	flag to add noise or not More...

bool	fSaturation
	flag for sipm saturation or not More...

bool	fTimeSmearing
	flag for time smearing or not More...

const detinfo::DetectorProperties *	fDetProp
	detector properties More...

gar::geo::GeometryCore const *	fGeo
	geometry information More...

Detailed Description

Definition at line 23 of file MuIDReadoutSimStandardAlg.h.

Constructor & Destructor Documentation

gar::rosim::MuIDReadoutSimStandardAlg::MuIDReadoutSimStandardAlg	(	CLHEP::HepRandomEngine &	engine,
		fhicl::ParameterSet const &	pset
	)

Definition at line 29 of file MuIDReadoutSimStandardAlg.cxx.

         : SiPMReadoutSimAlg(engine, pset)
         {
             fGeo = gar::providerFrom<geo::GeometryGAr>();
             fGeoManager = fGeo->ROOTGeoManager();
             fDetProp = gar::providerFrom<detinfo::DetectorPropertiesService>();
 
             this->reconfigure(pset);
 
             return;
         }

gar::rosim::MuIDReadoutSimStandardAlg::~MuIDReadoutSimStandardAlg ( )

virtual

Definition at line 42 of file MuIDReadoutSimStandardAlg.cxx.

         {
             return;
         }

Member Function Documentation

float gar::rosim::MuIDReadoutSimStandardAlg::AddElectronicNoise ( float energy ) const

protected

Definition at line 197 of file MuIDReadoutSimStandardAlg.cxx.

         {
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "AddElectronicNoise()";
 
             //Random noise shooting (Gaussian electronic noise)
             CLHEP::RandGauss GausRand(fEngine);
             float smeared_energy = energy + GausRand.shoot(0., fDetProp->NoisePx());
             return smeared_energy;
         }

std::pair< std::array< double, 3 >, bool > gar::rosim::MuIDReadoutSimStandardAlg::CalculatePosition	(	float	x,
		float	y,
		float	z,
		raw::CellID_t	cID
	)		const

protected

Definition at line 208 of file MuIDReadoutSimStandardAlg.cxx.

         {
             bool drop = false;
 
             //Use the segmentation algo to get the position
             std::array<double, 3> point = {x, y, z};
             TGeoNode *node = fGeo->FindNode(point);//Node in cm...
             std::string nodename = node->GetName();
             std::array<double, 3> pointLocal;
             gar::geo::LocalTransformation<TGeoHMatrix> trans;
             fGeo->WorldToLocal(point, pointLocal, trans);
 
             std::array<double, 3> pointLocal_back = fGeo->GetPosition(node, cID);//returns in cm
             std::array<double, 3> point_back;
             fGeo->LocalToWorld(pointLocal_back, point_back, trans);
             TGeoNode *new_node = fGeo->FindNode(point_back);//Node in cm...
             std::string newnodename = new_node->GetName();
 
             //get the base of the node names (slice can be added in the new node)
             std::string base_node_name = nodename.substr(0, nodename.find("_layer_") + 9);
             std::string base_new_node_name = newnodename.substr(0, newnodename.find("_layer_") + 9);
 
             if( base_new_node_name != base_node_name ){
                 MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "CalculatePosition()"
                 << " Strip length " << fGeo->getStripLength(point, cID) << "\n"
                 << " Local Point before new position ( " << pointLocal[0] << ", " << pointLocal[1] << ", " << pointLocal[2] << " ) in node " << nodename << "\n"
                 << " Local Point after new position ( " << pointLocal_back[0] << ", " << pointLocal_back[1] << ", " << pointLocal_back[2] << " ) in node " << newnodename << "\n"
                 << " Dropping the hit ";
 
                 //Drop the hit
                 drop = true;
             }
 
             return std::make_pair(point_back, drop);
         }

void gar::rosim::MuIDReadoutSimStandardAlg::ClearLists ( )

Definition at line 60 of file MuIDReadoutSimStandardAlg.cxx.

         {
             m_SimCaloHitVec.clear();
             m_DigitHitVec.clear();
         }

void gar::rosim::MuIDReadoutSimStandardAlg::DoDigitization ( )

virtual

Implements gar::rosim::SiPMReadoutSimAlg.

Definition at line 87 of file MuIDReadoutSimStandardAlg.cxx.

         {
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "DoDigitization()";
 
             //Treating tiled hits
             for(auto const &it : m_SimCaloHitVec)
             {
                 float energy = it->Energy();
                 float time = it->Time();
                 float x = it->X();
                 float y = it->Y();
                 float z = it->Z();
                 raw::CellID_t cellID = it->CellID();
 
                 raw::CaloRawDigit *digihit = this->DoStripDigitization(x, y, z, energy, time, cellID);
 
                 if( nullptr != digihit) {
                     m_DigitHitVec.emplace_back(digihit);
                 } else {
                     MF_LOG_DEBUG("MuIDReadoutSimStandardAlg")
                     << "Could not digitize the simulated hit " << it;
                 }
             }
         }

std::pair< float, float > gar::rosim::MuIDReadoutSimStandardAlg::DoLightPropagation	(	float	x,
		float	y,
		float	z,
		float	time,
		raw::CellID_t	cID
	)		const

protected

Definition at line 245 of file MuIDReadoutSimStandardAlg.cxx.

         {
             //Find the volume path
             std::array<double, 3> point = {x, y, z};
             std::array<double, 3> pointLocal;
             gar::geo::LocalTransformation<TGeoHMatrix> trans;
             fGeo->WorldToLocal(point, pointLocal, trans);
 
             //Calculate light propagation along the strip
             std::pair<float, float> times = fGeo->CalculateLightPropagation(point, pointLocal, cID);
 
             //t1 is left SiPM, t2 is right SiPM
             float time1 = time + times.first;
             float time2 = time + times.second;
 
             //Smear the times
             float smeared_time1 = this->DoTimeSmearing(time1);
             float smeared_time2 = this->DoTimeSmearing(time2);
 
             return std::make_pair(smeared_time1, smeared_time2);
         }

float gar::rosim::MuIDReadoutSimStandardAlg::DoPhotonStatistics	(	float	x,
		float	y,
		float	z,
		float	energy
	)		const

protected

Definition at line 145 of file MuIDReadoutSimStandardAlg.cxx.

         {
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "DoPhotonStatistics()";
             CLHEP::RandBinomial BinomialRand(fEngine);
 
             TVector3 point(x, y, z);
             float factor = fGeo->GetSensVolumeThickness(point) / 0.5;
 
             //Convert energy from GeV to MIP
             float energy_mip = energy / (fDetProp->MeVtoMIP() * factor * CLHEP::MeV / CLHEP::GeV);
 
             //conversion to px
             float pixel = energy_mip * fDetProp->LightYield();
 
             //Saturation
             float sat_pixel = 0.;
             if(fSaturation)
                 sat_pixel = fSiPMUtils->Saturate(pixel);
             else
                 sat_pixel = pixel;
 
             //Binomial Smearing
             double prob = sat_pixel / fDetProp->EffectivePixel();
             float smeared_px = BinomialRand.shoot(fDetProp->EffectivePixel(), prob);
 
             float smeared_px_noise = smeared_px;
             //Add noise
             if(fAddNoise)
                 smeared_px_noise = this->AddElectronicNoise(smeared_px);
 
             //Convertion to ADC
             float ADC = 0.;
 
             if(smeared_px_noise > 0)
                 ADC = smeared_px_noise * fDetProp->SiPMGain();
 
             if(ADC > fDetProp->IntercalibrationFactor() * fDetProp->ADCSaturation())
                 ADC = fDetProp->IntercalibrationFactor() * fDetProp->ADCSaturation();
 
             return ADC;
         }

raw::CaloRawDigit * gar::rosim::MuIDReadoutSimStandardAlg::DoStripDigitization	(	float	x,
		float	y,
		float	z,
		float	energy,
		float	time,
		raw::CellID_t	cID
	)		const

protected

Definition at line 113 of file MuIDReadoutSimStandardAlg.cxx.

         {
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "DoStripDigitization()";
 
             //Calculate the light propagation along the strip
             std::pair<float, float> times = this->DoLightPropagation(x, y, z, time, cID);
 
             //Calculate the SiPM energy
             float new_energy = this->DoPhotonStatistics(x, y, z, energy);
 
             //Calculate the position of the strip
             std::pair< std::array<double, 3>, bool > calc_pos = this->CalculatePosition(x, y, z, cID);
             //Check if need to drop the hit
             if ( calc_pos.second ) {
                 return nullptr;
             }
 
             std::array<double, 3> pos = calc_pos.first;
 
             //make the shared ptr
             raw::CaloRawDigit *digihit = new raw::CaloRawDigit( static_cast<unsigned int>(new_energy), times, pos[0], pos[1], pos[2], cID );
 
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "Strip digihit " << digihit
             << " with cellID " << cID
             << " has energy " << static_cast<unsigned int>(new_energy)
             << " time (" << times.first << ", " << times.second << ")"
             << " pos (" << pos[0] << ", " <<  pos[1] << ", " << pos[2] << ")";
 
             return digihit;
         }

float gar::rosim::MuIDReadoutSimStandardAlg::DoTimeSmearing ( float time ) const

protected

Definition at line 188 of file MuIDReadoutSimStandardAlg.cxx.

         {
             MF_LOG_DEBUG("MuIDReadoutSimStandardAlg") << "DoTimeSmearing()";
             CLHEP::RandGauss GausRand(fEngine);
             float smeared_time = time + GausRand.fire(0., fDetProp->TimeResolution());
             return smeared_time;
         }

std::vector< raw::CaloRawDigit* > gar::rosim::MuIDReadoutSimStandardAlg::GetDigitizedHits ( ) const

inlinevirtual

Implements gar::rosim::SiPMReadoutSimAlg.

Definition at line 39 of file MuIDReadoutSimStandardAlg.h.

39 { return m_DigitHitVec; }

gar::rosim::MuIDReadoutSimStandardAlg::m_DigitHitVec

std::vector< raw::CaloRawDigit * > m_DigitHitVec

vector of digitized hits

Definition: MuIDReadoutSimStandardAlg.h:61

void gar::rosim::MuIDReadoutSimStandardAlg::PrepareAlgo ( const std::vector< art::Ptr< sdp::CaloDeposit > > & hitVector )

virtual

Implements gar::rosim::SiPMReadoutSimAlg.

Definition at line 67 of file MuIDReadoutSimStandardAlg.cxx.

         {
             //Clear the lists
             ClearLists();
 
             //Loop over all hits
             for (std::vector< art::Ptr<sdp::CaloDeposit> >::const_iterator iter = hitVector.begin(), iterEnd = hitVector.end(); iter != iterEnd; ++iter)
             {
                 art::Ptr<sdp::CaloDeposit> hitPtr = *iter;
                 const sdp::CaloDeposit *hit = hitPtr.get();
                 m_SimCaloHitVec.emplace_back(hit);
             }
 
             //Sort the list by time
             std::sort(m_SimCaloHitVec.begin(), m_SimCaloHitVec.end(), [](const sdp::CaloDeposit *rha, const sdp::CaloDeposit *rhb) { return rha->Time() < rhb->Time(); } );
 
             return;
         }

void gar::rosim::MuIDReadoutSimStandardAlg::reconfigure ( fhicl::ParameterSet const & pset )

virtual

Implements gar::rosim::SiPMReadoutSimAlg.

Definition at line 48 of file MuIDReadoutSimStandardAlg.cxx.

         {
             fAddNoise = pset.get<bool>("AddNoise", false);
             fSaturation = pset.get<bool>("Saturation", false);
             fTimeSmearing = pset.get<bool>("TimeSmearing", false);
 
             fSiPMUtils = std::make_unique<util::SiPMUtils>(fDetProp->EffectivePixel());
 
             return;
         }