Inheritance diagram for CTPPSDirectProtonSimulation:

Public Member Functions
	CTPPSDirectProtonSimulation (const edm::ParameterSet &)

	~CTPPSDirectProtonSimulation () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	processProton (const HepMC::GenVertex in_vtx, const HepMC::GenParticle in_trk, const CTPPSGeometry &geometry, const CTPPSBeamParameters &beamParameters, const LHCInterpolatedOpticalFunctionsSetCollection &opticalFunctions, std::vector< CTPPSLocalTrackLite > &out_tracks, edm::DetSetVector< TotemRPRecHit > &out_strip_hits, edm::DetSetVector< CTPPSPixelRecHit > &out_pixel_hits, edm::DetSetVector< CTPPSDiamondRecHit > &out_diamond_hits) const

void	produce (edm::Event &, const edm::EventSetup &) override

Static Private Member Functions
static bool	isPixelHit (float xLocalCoordinate, float yLocalCoordinate, bool is3x2=true)

Private Attributes
bool	checkApertures_
	simulation parameters More...

bool	checkIsHit_

double	empiricalAperture45_a_

double	empiricalAperture45_xi0_

double	empiricalAperture56_a_

double	empiricalAperture56_xi0_

edm::EDGetTokenT< edm::HepMCProduct >	hepMCToken_
	input tag More...

double	insensitiveMarginStrips_
	size of insensitive margin at sensor's edge facing the beam, in mm More...

double	pitchPixelsHor_

double	pitchPixelsVer_

double	pitchStrips_
	strip pitch in mm More...

bool	produceHitsRelativeToBeam_

bool	produceRecHits_

bool	produceScoringPlaneHits_
	flags what output to be produced More...

bool	roundToPitch_

double	stripZeroPosition_
	internal variable: v position of strip 0, in mm More...

bool	useEmpiricalApertures_

unsigned int	verbosity_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 45 of file CTPPSDirectProtonSimulation.cc.

Constructor & Destructor Documentation

CTPPSDirectProtonSimulation::CTPPSDirectProtonSimulation ( const edm::ParameterSet & iConfig )

explicit

Definition at line 122 of file CTPPSDirectProtonSimulation.cc.

References RPTopology::last_strip_to_border_dist_, RPTopology::no_of_strips_, RPTopology::pitch_, produceRecHits_, produceScoringPlaneHits_, stripZeroPosition_, and RPTopology::y_width_.

     : hepMCToken_(consumes<edm::HepMCProduct>(iConfig.getParameter<edm::InputTag>("hepMCTag"))),
 
       produceScoringPlaneHits_(iConfig.getParameter<bool>("produceScoringPlaneHits")),
       produceRecHits_(iConfig.getParameter<bool>("produceRecHits")),
 
       useEmpiricalApertures_(iConfig.getParameter<bool>("useEmpiricalApertures")),
       empiricalAperture45_xi0_(iConfig.getParameter<double>("empiricalAperture45_xi0")),
       empiricalAperture45_a_(iConfig.getParameter<double>("empiricalAperture45_a")),
       empiricalAperture56_xi0_(iConfig.getParameter<double>("empiricalAperture56_xi0")),
       empiricalAperture56_a_(iConfig.getParameter<double>("empiricalAperture56_a")),
 
       produceHitsRelativeToBeam_(iConfig.getParameter<bool>("produceHitsRelativeToBeam")),
       roundToPitch_(iConfig.getParameter<bool>("roundToPitch")),
       checkIsHit_(iConfig.getParameter<bool>("checkIsHit")),
 
       pitchStrips_(iConfig.getParameter<double>("pitchStrips")),
       insensitiveMarginStrips_(iConfig.getParameter<double>("insensitiveMarginStrips")),
 
       pitchPixelsHor_(iConfig.getParameter<double>("pitchPixelsHor")),
       pitchPixelsVer_(iConfig.getParameter<double>("pitchPixelsVer")),
 
       verbosity_(iConfig.getUntrackedParameter<unsigned int>("verbosity", 0)) {
   if (produceScoringPlaneHits_)
     produces<std::vector<CTPPSLocalTrackLite>>();
 
   if (produceRecHits_) {
     produces<edm::DetSetVector<TotemRPRecHit>>();
     produces<edm::DetSetVector<CTPPSDiamondRecHit>>();
     produces<edm::DetSetVector<CTPPSPixelRecHit>>();
   }
 
   // v position of strip 0
   stripZeroPosition_ = RPTopology::last_strip_to_border_dist_ + (RPTopology::no_of_strips_ - 1) * RPTopology::pitch_ -
                        RPTopology::y_width_ / 2.;
 }

CTPPSDirectProtonSimulation::~CTPPSDirectProtonSimulation ( )

inlineoverride

Definition at line 48 of file CTPPSDirectProtonSimulation.cc.

References fillDescriptions(), GenParticle::GenParticle, processProton(), and produce().

48 {}

Member Function Documentation

void CTPPSDirectProtonSimulation::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 466 of file CTPPSDirectProtonSimulation.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), DEFINE_FWK_MODULE, and HLT_2018_cff::InputTag.

Referenced by ~CTPPSDirectProtonSimulation().

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.addUntracked<unsigned int>("verbosity", 0);
   desc.add<edm::InputTag>("hepMCTag", edm::InputTag("generator", "unsmeared"));
   desc.add<bool>("produceScoringPlaneHits", true);
   desc.add<bool>("produceRecHits", true);
   desc.add<bool>("useEmpiricalApertures", false);
   desc.add<double>("empiricalAperture45_xi0", 0.);
   desc.add<double>("empiricalAperture45_a", 0.);
   desc.add<double>("empiricalAperture56_xi0", 0.);
   desc.add<double>("empiricalAperture56_a", 0.);
   desc.add<bool>("produceHitsRelativeToBeam", false);
   desc.add<bool>("roundToPitch", true);
   desc.add<bool>("checkIsHit", true);
   desc.add<double>("pitchStrips", 66.e-3);              // in mm
   desc.add<double>("insensitiveMarginStrips", 34.e-3);  // in mm
   desc.add<double>("pitchPixelsHor", 100.e-3)->setComment("x in local coordinates, in mm");
   desc.add<double>("pitchPixelsVer", 150.e-3)->setComment("y in local coordinates, in mm");
 
   descriptions.add("ctppsDirectProtonSimulation", desc);
 }

static bool CTPPSDirectProtonSimulation::isPixelHit	(	float	xLocalCoordinate,
		float	yLocalCoordinate,
		bool	is3x2 = `true`
	)

inlinestaticprivate

Definition at line 65 of file CTPPSDirectProtonSimulation.cc.

Referenced by processProton().

                                                                                             {
     float tmpXlocalCoordinate = xLocalCoordinate + (79 * 0.1 + 0.2);
     float tmpYlocalCoordinate = yLocalCoordinate + (0.15 * 51 + 0.3 * 2 + 0.15 * 25);
 
     if (tmpXlocalCoordinate < 0)
       return false;
     if (tmpYlocalCoordinate < 0)
       return false;
     int xModuleSize = 0.1 * 79 + 0.2 * 2 + 0.1 * 79;  // mm - 100 um pitch direction
     int yModuleSize;                                  // mm - 150 um pitch direction
     if (is3x2)
       yModuleSize = 0.15 * 51 + 0.3 * 2 + 0.15 * 50 + 0.3 * 2 + 0.15 * 51;
     else
       yModuleSize = 0.15 * 51 + 0.3 * 2 + 0.15 * 51;
     if (tmpXlocalCoordinate > xModuleSize)
       return false;
     if (tmpYlocalCoordinate > yModuleSize)
       return false;
     return true;
   }

void CTPPSDirectProtonSimulation::processProton	(	const HepMC::GenVertex *	in_vtx,
		const HepMC::GenParticle *	in_trk,
		const CTPPSGeometry &	geometry,
		const CTPPSBeamParameters &	beamParameters,
		const LHCInterpolatedOpticalFunctionsSetCollection &	opticalFunctions,
		std::vector< CTPPSLocalTrackLite > &	out_tracks,
		edm::DetSetVector< TotemRPRecHit > &	out_strip_hits,
		edm::DetSetVector< CTPPSPixelRecHit > &	out_pixel_hits,
		edm::DetSetVector< CTPPSDiamondRecHit > &	out_diamond_hits
	)		const

private

xi is positive for diffractive protons, thus proton momentum p = (1-xi) * p_nom horizontal component of proton momentum: p_x = th_x * (1-xi) * p_nom

Definition at line 223 of file CTPPSDirectProtonSimulation.cc.

References MaterialEffects_cfi::A, CTPPSDetId::arm(), TtFullHadDaughter::B, checkIsHit_, empiricalAperture45_a_, empiricalAperture45_xi0_, empiricalAperture56_a_, empiricalAperture56_xi0_, Exception, edm::DetSetVector< T >::find_or_insert(), CTPPSBeamParameters::getBeamMom45(), CTPPSBeamParameters::getBeamMom56(), CTPPSBeamParameters::getHalfXangleX45(), CTPPSBeamParameters::getHalfXangleX56(), CTPPSGeometry::globalToLocal(), hfClusterShapes_cfi::hits, insensitiveMarginStrips_, createfilelist::int, invalid, RPTopology::IsHit(), isPixelHit(), CTPPSGeometry::localToGlobal(), visualization-live-secondInstance_cfg::m, AlCaHLTBitMon_ParallelJobs::p, pitchPixelsHor_, pitchPixelsVer_, pitchStrips_, CTPPSPixelDetId::plane(), produceHitsRelativeToBeam_, produceRecHits_, produceScoringPlaneHits_, edm::DetSet< T >::push_back(), DetId::rawId(), roundToPitch_, CTPPSDetId::rp(), CTPPSDetId::sdTimingDiamond, CTPPSDetId::sdTrackingPixel, CTPPSDetId::sdTrackingStrip, CTPPSGeometry::sensorsInRP(), mathSSE::sqrt(), CTPPSDetId::station(), digitizers_cfi::strip, stripZeroPosition_, DetId::subdetId(), LHCInterpolatedOpticalFunctionsSet::Kinematics::th_x, LHCInterpolatedOpticalFunctionsSet::Kinematics::th_y, useEmpiricalApertures_, findQualityFiles::v, verbosity_, LHCInterpolatedOpticalFunctionsSet::Kinematics::x, hybridSuperClusters_cfi::xi, and LHCInterpolatedOpticalFunctionsSet::Kinematics::y.

Referenced by produce(), and ~CTPPSDirectProtonSimulation().

                                                                                                              {
 
   std::stringstream ssLog;
 
   // vectors in CMS convention
   const HepMC::FourVector& vtx_cms = in_vtx->position();  // in mm
   const HepMC::FourVector& mom_cms = in_trk->momentum();
 
   // transformation to LHC/TOTEM convention
   HepMC::FourVector vtx_lhc(-vtx_cms.x(), vtx_cms.y(), -vtx_cms.z(), vtx_cms.t());
   HepMC::FourVector mom_lhc(-mom_cms.x(), mom_cms.y(), -mom_cms.z(), mom_cms.t());
 
   // determine the LHC arm and related parameters
   unsigned int arm = 3;
   double z_sign;
   double beamMomentum = 0.;
   double xangle = 0.;
   double empiricalAperture_xi0, empiricalAperture_a;
 
   if (mom_lhc.z() < 0)  // sector 45
   {
     arm = 0;
     z_sign = -1;
     beamMomentum = beamParameters.getBeamMom45();
     xangle = beamParameters.getHalfXangleX45();
     empiricalAperture_xi0 = empiricalAperture45_xi0_;
     empiricalAperture_a = empiricalAperture45_a_;
   } else {  // sector 56
     arm = 1;
     z_sign = +1;
     beamMomentum = beamParameters.getBeamMom56();
     xangle = beamParameters.getHalfXangleX56();
     empiricalAperture_xi0 = empiricalAperture56_xi0_;
     empiricalAperture_a = empiricalAperture56_a_;
   }
 
   // calculate kinematics for optics parametrisation
   const double p = mom_lhc.rho();
   const double xi = 1. - p / beamMomentum;
   const double th_x_phys = mom_lhc.x() / p;
   const double th_y_phys = mom_lhc.y() / p;
   const double vtx_lhc_eff_x = vtx_lhc.x() - vtx_lhc.z() * (mom_lhc.x() / mom_lhc.z() + xangle);
   const double vtx_lhc_eff_y = vtx_lhc.y() - vtx_lhc.z() * (mom_lhc.y() / mom_lhc.z());
 
   if (verbosity_) {
     ssLog << "simu: xi = " << xi << ", th_x_phys = " << th_x_phys << ", th_y_phys = " << th_y_phys
           << ", vtx_lhc_eff_x = " << vtx_lhc_eff_x << ", vtx_lhc_eff_y = " << vtx_lhc_eff_y << std::endl;
   }
 
   // check empirical aperture
   if (useEmpiricalApertures_) {
     const double xi_th = empiricalAperture_xi0 + th_x_phys * empiricalAperture_a;
     if (xi > xi_th) {
       if (verbosity_) {
         ssLog << "stop because of empirical appertures";
         edm::LogInfo("CTPPSDirectProtonSimulation") << ssLog.str();
       }
 
       return;
     }
   }
 
   // transport the proton into each pot/scoring plane
   for (const auto& ofp : opticalFunctions) {
     CTPPSDetId rpId(ofp.first);
     const unsigned int rpDecId = rpId.arm() * 100 + rpId.station() * 10 + rpId.rp();
 
     // first check the arm
     if (rpId.arm() != arm)
       continue;
 
     if (verbosity_)
       ssLog << "  RP " << rpDecId << std::endl;
 
     // transport proton
     LHCInterpolatedOpticalFunctionsSet::Kinematics k_in = {
         vtx_lhc_eff_x * 1E-1, th_x_phys, vtx_lhc_eff_y * 1E-1, th_y_phys, xi};  // conversions: mm -> cm
     LHCInterpolatedOpticalFunctionsSet::Kinematics k_out;
     ofp.second.transport(k_in, k_out, true);
 
     double b_x = k_out.x * 1E1, b_y = k_out.y * 1E1;  // conversions: cm -> mm
     double a_x = k_out.th_x, a_y = k_out.th_y;
 
     // if needed, subtract beam position and angle
     if (produceHitsRelativeToBeam_) {
       // determine beam position
       LHCInterpolatedOpticalFunctionsSet::Kinematics k_be_in = {0., 0., 0., 0., 0.};
       LHCInterpolatedOpticalFunctionsSet::Kinematics k_be_out;
       ofp.second.transport(k_be_in, k_be_out, true);
 
       a_x -= k_be_out.th_x;
       a_y -= k_be_out.th_y;
       b_x -= k_be_out.x * 1E1;
       b_y -= k_be_out.y * 1E1;  // conversions: cm -> mm
     }
 
     const double z_scoringPlane = ofp.second.getScoringPlaneZ() * 1E1;  // conversion: cm --> mm
 
     if (verbosity_) {
       ssLog << "    proton transported: a_x = " << a_x << " rad, a_y = " << a_y << " rad, b_x = " << b_x
             << " mm, b_y = " << b_y << " mm, z = " << z_scoringPlane << " mm" << std::endl;
     }
 
     // save scoring plane hit
     if (produceScoringPlaneHits_)
       out_tracks.emplace_back(
           rpId.rawId(), b_x, 0., b_y, 0., 0., 0., 0., 0., 0., CTPPSpixelLocalTrackReconstructionInfo::invalid, 0, 0., 0.);
 
     // stop if rec hits are not to be produced
     if (!produceRecHits_)
       continue;
 
     // loop over all sensors in the RP
     for (const auto& detIdInt : geometry.sensorsInRP(rpId)) {
       CTPPSDetId detId(detIdInt);
 
       // determine the track impact point (in global coordinates)
       // !! this assumes that local axes (1, 0, 0) and (0, 1, 0) describe the sensor surface
       CLHEP::Hep3Vector gl_o = geometry.localToGlobal(detId, CLHEP::Hep3Vector(0, 0, 0));
       CLHEP::Hep3Vector gl_a1 = geometry.localToGlobal(detId, CLHEP::Hep3Vector(1, 0, 0)) - gl_o;
       CLHEP::Hep3Vector gl_a2 = geometry.localToGlobal(detId, CLHEP::Hep3Vector(0, 1, 0)) - gl_o;
 
       TMatrixD A(3, 3);
       TVectorD B(3);
       A(0, 0) = a_x;
       A(0, 1) = -gl_a1.x();
       A(0, 2) = -gl_a2.x();
       B(0) = gl_o.x() - b_x;
       A(1, 0) = a_y;
       A(1, 1) = -gl_a1.y();
       A(1, 2) = -gl_a2.y();
       B(1) = gl_o.y() - b_y;
       A(2, 0) = z_sign;
       A(2, 1) = -gl_a1.z();
       A(2, 2) = -gl_a2.z();
       B(2) = gl_o.z() - z_scoringPlane;
       TMatrixD Ai(3, 3);
       Ai = A.Invert();
       TVectorD P(3);
       P = Ai * B;
 
       double ze = P(0);
       CLHEP::Hep3Vector h_glo(a_x * ze + b_x, a_y * ze + b_y, z_sign * ze + z_scoringPlane);
 
       // hit in local coordinates
       CLHEP::Hep3Vector h_loc = geometry.globalToLocal(detId, h_glo);
 
       if (verbosity_) {
         ssLog << std::endl
               << "    de z = " << P(0) << " mm, p1 = " << P(1) << " mm, p2 = " << P(2) << " mm" << std::endl
               << "    h_glo: x = " << h_glo.x() << " mm, y = " << h_glo.y() << " mm, z = " << h_glo.z() << " mm"
               << std::endl
               << "    h_loc: c1 = " << h_loc.x() << " mm, c2 = " << h_loc.y() << " mm, c3 = " << h_loc.z() << " mm"
               << std::endl;
       }
 
       // strips
       if (detId.subdetId() == CTPPSDetId::sdTrackingStrip) {
         double u = h_loc.x();
         double v = h_loc.y();
 
         if (verbosity_ > 5)
           ssLog << "            u=" << u << ", v=" << v;
 
         // is it within detector?
         if (checkIsHit_ && !RPTopology::IsHit(u, v, insensitiveMarginStrips_)) {
           if (verbosity_ > 5)
             ssLog << " | no hit" << std::endl;
           continue;
         }
 
         // round the measurement
         if (roundToPitch_) {
           double m = stripZeroPosition_ - v;
           signed int strip = (int)floor(m / pitchStrips_ + 0.5);
 
           v = stripZeroPosition_ - pitchStrips_ * strip;
 
           if (verbosity_ > 5)
             ssLog << " | strip=" << strip;
         }
 
         double sigma = pitchStrips_ / sqrt(12.);
 
         if (verbosity_ > 5)
           ssLog << " | m=" << v << ", sigma=" << sigma << std::endl;
 
         edm::DetSet<TotemRPRecHit>& hits = out_strip_hits.find_or_insert(detId);
         hits.push_back(TotemRPRecHit(v, sigma));
       }
 
       // diamonds
       if (detId.subdetId() == CTPPSDetId::sdTimingDiamond) {
         throw cms::Exception("CTPPSDirectProtonSimulation") << "Diamonds are not yet supported.";
       }
 
       // pixels
       if (detId.subdetId() == CTPPSDetId::sdTrackingPixel) {
         if (verbosity_) {
           CTPPSPixelDetId pixelDetId(detIdInt);
           ssLog << "    pixel plane " << pixelDetId.plane() << ": local hit x = " << h_loc.x()
                 << " mm, y = " << h_loc.y() << " mm, z = " << h_loc.z() << " mm" << std::endl;
         }
 
         if (checkIsHit_ && !isPixelHit(h_loc.x(), h_loc.y()))
           continue;
 
         if (roundToPitch_) {
           h_loc.setX(pitchPixelsHor_ * floor(h_loc.x() / pitchPixelsHor_ + 0.5));
           h_loc.setY(pitchPixelsVer_ * floor(h_loc.y() / pitchPixelsVer_ + 0.5));
         }
 
         if (verbosity_ > 5)
           ssLog << "            hit accepted: m1 = " << h_loc.x() << " mm, m2 = " << h_loc.y() << " mm" << std::endl;
 
         const double sigmaHor = pitchPixelsHor_ / sqrt(12.);
         const double sigmaVer = pitchPixelsVer_ / sqrt(12.);
 
         const LocalPoint lp(h_loc.x(), h_loc.y(), h_loc.z());
         const LocalError le(sigmaHor, 0., sigmaVer);
 
         edm::DetSet<CTPPSPixelRecHit>& hits = out_pixel_hits.find_or_insert(detId);
         hits.push_back(CTPPSPixelRecHit(lp, le));
       }
     }
   }
 
   if (verbosity_)
     edm::LogInfo("CTPPSDirectProtonSimulation") << ssLog.str();
 }

void CTPPSDirectProtonSimulation::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 161 of file CTPPSDirectProtonSimulation.cc.

References geometry, edm::EventSetup::get(), edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), hepMCToken_, eostools::move(), processProton(), produceRecHits_, produceScoringPlaneHits_, edm::Event::put(), and badGlobalMuonTaggersAOD_cff::vtx.

Referenced by ~CTPPSDirectProtonSimulation().

                                                                                        {
   // get input
   edm::Handle<edm::HepMCProduct> hepmc_prod;
   iEvent.getByToken(hepMCToken_, hepmc_prod);
 
   // get conditions
   edm::ESHandle<CTPPSBeamParameters> hBeamParameters;
   iSetup.get<CTPPSBeamParametersRcd>().get(hBeamParameters);
 
   edm::ESHandle<LHCInterpolatedOpticalFunctionsSetCollection> hOpticalFunctions;
   iSetup.get<CTPPSInterpolatedOpticsRcd>().get(hOpticalFunctions);
 
   edm::ESHandle<CTPPSGeometry> geometry;
   iSetup.get<VeryForwardMisalignedGeometryRecord>().get(geometry);
 
   // prepare outputs
   std::unique_ptr<edm::DetSetVector<TotemRPRecHit>> pStripRecHits(new edm::DetSetVector<TotemRPRecHit>());
   std::unique_ptr<edm::DetSetVector<CTPPSDiamondRecHit>> pDiamondRecHits(new edm::DetSetVector<CTPPSDiamondRecHit>());
   std::unique_ptr<edm::DetSetVector<CTPPSPixelRecHit>> pPixelRecHits(new edm::DetSetVector<CTPPSPixelRecHit>());
 
   std::unique_ptr<std::vector<CTPPSLocalTrackLite>> pTracks(new std::vector<CTPPSLocalTrackLite>());
 
   // loop over event vertices
   auto evt = new HepMC::GenEvent(*hepmc_prod->GetEvent());
   for (auto it_vtx = evt->vertices_begin(); it_vtx != evt->vertices_end(); ++it_vtx) {
     auto vtx = *(it_vtx);
 
     // loop over outgoing particles
     for (auto it_part = vtx->particles_out_const_begin(); it_part != vtx->particles_out_const_end(); ++it_part) {
       auto part = *(it_part);
 
       // accept only stable protons
       if (part->pdg_id() != 2212)
         continue;
 
       if (part->status() != 1 && part->status() < 83)
         continue;
 
       processProton(vtx,
                     part,
                     *geometry,
                     *hBeamParameters,
                     *hOpticalFunctions,
                     *pTracks,
                     *pStripRecHits,
                     *pPixelRecHits,
                     *pDiamondRecHits);
     }
   }
 
   if (produceScoringPlaneHits_)
     iEvent.put(std::move(pTracks));
 
   if (produceRecHits_) {
     iEvent.put(std::move(pStripRecHits));
     iEvent.put(std::move(pPixelRecHits));
     iEvent.put(std::move(pDiamondRecHits));
   }
 }