#include <ETLDeviceSim.h>

Public Member Functions
	ETLDeviceSim (const edm::ParameterSet &pset, edm::ConsumesCollector iC)

void	getEvent (const edm::Event &evt)

void	getEventSetup (const edm::EventSetup &evt)

void	getHitsResponse (const std::vector< std::tuple< int, uint32_t, float > > &hitRefs, const edm::Handle< edm::PSimHitContainer > &hits, mtd_digitizer::MTDSimHitDataAccumulator simHitAccumulator, CLHEP::HepRandomEngine hre)

Private Attributes
const bool	applyDegradation_

float	bxTime_

const reco::FormulaEvaluator	fluence_

const MTDGeometry *	geom_

const edm::ESGetToken< MTDGeometry, MTDDigiGeometryRecord >	geomToken_

const float	integratedLum_

const reco::FormulaEvaluator	lgadGain_

const reco::FormulaEvaluator	lgadGainDegradation_

float	MIPPerMeV_

const reco::FormulaEvaluator	MPVElectron_

const reco::FormulaEvaluator	MPVKaon_

const reco::FormulaEvaluator	MPVMuon_

const reco::FormulaEvaluator	MPVPion_

const reco::FormulaEvaluator	MPVProton_

float	tofDelay_

Detailed Description

Definition at line 23 of file ETLDeviceSim.h.

Constructor & Destructor Documentation

◆ ETLDeviceSim()

ETLDeviceSim::ETLDeviceSim	(	const edm::ParameterSet &	pset,
		edm::ConsumesCollector	iC
	)

Definition at line 15 of file ETLDeviceSim.cc.

     : geomToken_(iC.esConsumes()),
       geom_(nullptr),
       MIPPerMeV_(1.0 / pset.getParameter<double>("meVPerMIP")),
       integratedLum_(pset.getParameter<double>("IntegratedLuminosity")),
       fluence_(pset.getParameter<std::string>("FluenceVsRadius")),
       lgadGain_(pset.getParameter<std::string>("LGADGainVsFluence")),
       lgadGainDegradation_(pset.getParameter<std::string>("LGADGainDegradation")),
       applyDegradation_(pset.getParameter<bool>("applyDegradation")),
       bxTime_(pset.getParameter<double>("bxTime")),
       tofDelay_(pset.getParameter<double>("tofDelay")),
       MPVMuon_(pset.getParameter<std::string>("MPVMuon")),
       MPVPion_(pset.getParameter<std::string>("MPVPion")),
       MPVKaon_(pset.getParameter<std::string>("MPVKaon")),
       MPVElectron_(pset.getParameter<std::string>("MPVElectron")),
       MPVProton_(pset.getParameter<std::string>("MPVProton")) {}

Member Function Documentation

◆ getEvent()

void ETLDeviceSim::getEvent ( const edm::Event & evt )

inline

Definition at line 27 of file ETLDeviceSim.h.

27 {}

◆ getEventSetup()

void ETLDeviceSim::getEventSetup ( const edm::EventSetup & evt )

Definition at line 32 of file ETLDeviceSim.cc.

References geom_, geomToken_, and edm::EventSetup::getData().

32 { geom_ = &evs.getData(geomToken_); }

ETLDeviceSim::geom_

const MTDGeometry * geom_

Definition: ETLDeviceSim.h:38

ETLDeviceSim::geomToken_

const edm::ESGetToken< MTDGeometry, MTDDigiGeometryRecord > geomToken_

Definition: ETLDeviceSim.h:37

◆ getHitsResponse()

void ETLDeviceSim::getHitsResponse	(	const std::vector< std::tuple< int, uint32_t, float > > &	hitRefs,
		const edm::Handle< edm::PSimHitContainer > &	hits,
		mtd_digitizer::MTDSimHitDataAccumulator *	simHitAccumulator,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 34 of file ETLDeviceSim.cc.

References funct::abs(), applyDegradation_, bxTime_, ALCARECOTkAlJpsiMuMu_cff::charge, cuy::col, angle_units::operators::convertGeVToMeV(), angle_units::operators::convertMmToCm(), TauDecayModes::dec, hcalRecHitTable_cff::detId, reco::FormulaEvaluator::evaluate(), Exception, fluence_, DetId::Forward, PedestalClient_cfi::gain, geom_, hfClusterShapes_cfi::hits, mps_fire::i, MTDGeometry::idToDet(), integratedLum_, RectangularMTDTopology::isInPixel(), lgadGain_, lgadGainDegradation_, LogTrace, METSkim_cff::Max, MIPPerMeV_, MPVElectron_, MPVKaon_, MPVMuon_, MPVPion_, MPVProton_, PbPb_ZMuSkimMuonDPG_cff::particleType, RectangularMTDTopology::pixelIndex(), position, CosmicsPD_Skims::radius, DetId::rawId(), ProxyMTDTopology::specificTopology(), tofDelay_, GeomDet::toGlobal(), GeomDet::topology(), PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                               {
   using namespace geant_units::operators;
 
   std::vector<double> emptyV;
   std::vector<double> radius(1);
   std::vector<double> fluence(1);
   std::vector<double> gain(1);
   std::vector<double> param(2);
   std::vector<double> momentum(1);
 
   //loop over sorted hits
   const int nchits = hitRefs.size();
   LogTrace("ETLDeviceSim") << "Processing " << nchits << " SIM hits";
 
   for (int i = 0; i < nchits; ++i) {
     const int hitidx = std::get<0>(hitRefs[i]);
     const uint32_t id = std::get<1>(hitRefs[i]);
     const MTDDetId detId(id);
 
     // Safety check (this should never happen, it should be an exception
     if (detId.det() != DetId::Forward || detId.mtdSubDetector() != 2) {
       throw cms::Exception("ETLDeviceSim")
           << "got a DetId that was not ETL: Det = " << detId.det() << "  subDet = " << detId.mtdSubDetector();
     }
 
     if (id == 0)
       continue;  // to be ignored at RECO level
 
     ETLDetId etlid(detId);
     DetId geoId = ETLDetId(etlid);
     const MTDGeomDet* thedet = geom_->idToDet(geoId);
     if (thedet == nullptr) {
       throw cms::Exception("ETLDeviceSim") << "GeographicalID: " << std::hex << geoId.rawId() << " (" << detId.rawId()
                                            << ") is invalid!" << std::dec << std::endl;
     }
     const ProxyMTDTopology& topoproxy = static_cast<const ProxyMTDTopology&>(thedet->topology());
     const RectangularMTDTopology& topo = static_cast<const RectangularMTDTopology&>(topoproxy.specificTopology());
 
     const float toa = std::get<2>(hitRefs[i]) + tofDelay_;
     const PSimHit& hit = hits->at(hitidx);
     float charge = convertGeVToMeV(hit.energyLoss()) * MIPPerMeV_;
 
     momentum[0] = hit.pabs();
 
     // particle type
     int particleType = abs(hit.particleType());
     float MPV_ = 0;
     if (particleType == 11) {
       MPV_ = MPVElectron_.evaluate(momentum, emptyV);
     } else if (particleType == 13) {
       MPV_ = MPVMuon_.evaluate(momentum, emptyV);
     } else if (particleType == 211) {
       MPV_ = MPVPion_.evaluate(momentum, emptyV);
     } else if (particleType == 321) {
       MPV_ = MPVKaon_.evaluate(momentum, emptyV);
     } else {
       MPV_ = MPVProton_.evaluate(momentum, emptyV);
     }
     float MPV_charge = convertGeVToMeV(MPV_) * MIPPerMeV_;
 
     // calculate the simhit row and column
     const auto& position = hit.localPosition();
 
     // ETL is already in module-local coordinates so just scale to cm from mm
     Local3DPoint simscaled(convertMmToCm(position.x()), convertMmToCm(position.y()), convertMmToCm(position.z()));
     const auto& global_point = thedet->toGlobal(simscaled);
 
     radius[0] = global_point.perp();
     fluence[0] = integratedLum_ * fluence_.evaluate(radius, emptyV);
     gain[0] = lgadGain_.evaluate(fluence, emptyV);
 
     //The following lines check whether the pixel point is actually out of the active area.
     if (topo.isInPixel(simscaled)) {
       charge *= gain[0];
       MPV_charge *= gain[0];
     } else {
       if (applyDegradation_) {
         double dGapCenter = TMath::Max(TMath::Abs(simscaled.x()), TMath::Abs(simscaled.y()));
         param[0] = gain[0];
         param[1] = dGapCenter;
         gain[0] = lgadGainDegradation_.evaluate(param, emptyV);
         charge *= gain[0];
         MPV_charge *= gain[0];
       }
     }
 
     const auto& thepixel = topo.pixelIndex(simscaled);
     const uint8_t row = static_cast<uint8_t>(thepixel.first);
     const uint8_t col = static_cast<uint8_t>(thepixel.second);
     LogTrace("ETLDeviceSim") << "Processing hit in pixel # " << hitidx << " DetId " << etlid.rawId() << " row/col "
                              << (uint32_t)row << " " << (uint32_t)col << " inPixel " << topo.isInPixel(simscaled)
                              << " tof " << toa << " ene " << hit.energyLoss() << " MIP " << MIPPerMeV_ << " gain "
                              << gain[0] << " charge " << charge << " MPV " << MPV_charge;
 
     auto simHitIt =
         simHitAccumulator->emplace(mtd_digitizer::MTDCellId(id, row, col), mtd_digitizer::MTDCellInfo()).first;
 
     // Accumulate in 15 buckets of 25ns (9 pre-samples, 1 in-time, 5 post-samples)
     const int itime = std::floor(toa / bxTime_) + 9;
     if (itime < 0 || itime > 14)
       continue;
 
     // Check if time index is ok and store energy
     if (itime >= (int)simHitIt->second.hit_info[0].size())
       continue;
     (simHitIt->second).hit_info[0][itime] += charge;
     // Store the time of the first SimHit in the right DataFrame bucket
     const float tof = toa - (itime - 9) * bxTime_;
 
     if ((simHitIt->second).hit_info[1][itime] == 0. || tof < (simHitIt->second).hit_info[1][itime]) {
       (simHitIt->second).hit_info[1][itime] = tof;
     }
     (simHitIt->second).hit_info[2][itime] += MPV_charge;
   }
 }