Fast (no G4) proton simulation in within one station. Uses misaligned geometry. More...

Inheritance diagram for PPSFastLocalSimulation:

Classes
struct	Distribution

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

	~PPSFastLocalSimulation () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Protected Member Functions
void	GenerateTrack (unsigned int pi, CLHEP::HepRandomEngine &rndEng, HepMC::GenEvent *gEv, std::unique_ptr< edm::DetSetVector< TotemRPRecHit >> &stripHitColl, std::unique_ptr< edm::DetSetVector< CTPPSDiamondRecHit >> &diamondHitColl, std::unique_ptr< edm::DetSetVector< CTPPSPixelRecHit >> &pixelHitColl, const CTPPSGeometry &geometry)

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

Protected Attributes
Distribution	angular_dist_
	angular parameters in rad More...

edm::ESGetToken< CTPPSGeometry, VeryForwardMisalignedGeometryRecord >	esTokenGeometry_

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

bool	makeHepMC_
	whether a HepMC description of the proton shall be saved in the event More...

bool	makeHits_
	whether the hits of the proton shall be calculated and saved More...

double	particle_E_
	particle energy and momentum More...

double	particle_p_

unsigned int	particlesPerEvent_
	number of particles to generate per event More...

double	pitchDiamonds_

double	pitchPixels_

double	pitchStrips_
	in mm More...

Distribution	position_dist_
	position parameters in mm More...

bool	roundToPitch_
	whether measurement values shall be rounded to the nearest strip More...

std::vector< unsigned int >	RPs_
	the list of RPs to simulate More...

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

unsigned int	verbosity_
	verbosity level More...

double	z0_
	the "origin" of tracks, in mm More...

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Fast (no G4) proton simulation in within one station. Uses misaligned geometry.

Definition at line 44 of file PPSFastLocalSimulation.cc.

Constructor & Destructor Documentation

PPSFastLocalSimulation::PPSFastLocalSimulation ( const edm::ParameterSet & ps )

Definition at line 186 of file PPSFastLocalSimulation.cc.

References RPTopology::last_strip_to_border_dist_, makeHepMC_, makeHits_, RPTopology::no_of_strips_, RPTopology::pitch_, stripZeroPosition_, and RPTopology::y_width_.

     : verbosity_(ps.getUntrackedParameter<unsigned int>("verbosity", 0)),
 
       makeHepMC_(ps.getParameter<bool>("makeHepMC")),
       makeHits_(ps.getParameter<bool>("makeHits")),
 
       RPs_(ps.getParameter<vector<unsigned int>>("RPs")),
 
       particlesPerEvent_(ps.getParameter<unsigned int>("particlesPerEvent")),
       particle_E_(ps.getParameter<double>("particle_E")),
       particle_p_(ps.getParameter<double>("particle_p")),
       z0_(ps.getParameter<double>("z0")),
 
       roundToPitch_(ps.getParameter<bool>("roundToPitch")),
       pitchStrips_(ps.getParameter<double>("pitchStrips")),
       pitchDiamonds_(ps.getParameter<double>("pitchDiamonds")),
       pitchPixels_(ps.getParameter<double>("pitchPixels")),
 
       insensitiveMarginStrips_(ps.getParameter<double>("insensitiveMarginStrips")),
 
       position_dist_(ps.getParameterSet("position_distribution")),
       angular_dist_(ps.getParameterSet("angular_distribution")),
 
       esTokenGeometry_(esConsumes()) {
   // v position of strip 0
   stripZeroPosition_ = RPTopology::last_strip_to_border_dist_ + (RPTopology::no_of_strips_ - 1) * RPTopology::pitch_ -
                        RPTopology::y_width_ / 2.;
 
   // register the output
   if (makeHepMC_)
     produces<HepMCProduct>();
 
   if (makeHits_) {
     produces<DetSetVector<TotemRPRecHit>>();
     produces<DetSetVector<CTPPSDiamondRecHit>>();
     produces<DetSetVector<CTPPSPixelRecHit>>();
   }
 }

PPSFastLocalSimulation::~PPSFastLocalSimulation ( )

override

Definition at line 227 of file PPSFastLocalSimulation.cc.

227 {}

Member Function Documentation

void PPSFastLocalSimulation::GenerateTrack	(	unsigned int	pi,
		CLHEP::HepRandomEngine &	rndEng,
		HepMC::GenEvent *	gEv,
		std::unique_ptr< edm::DetSetVector< TotemRPRecHit >> &	stripHitColl,
		std::unique_ptr< edm::DetSetVector< CTPPSDiamondRecHit >> &	diamondHitColl,
		std::unique_ptr< edm::DetSetVector< CTPPSPixelRecHit >> &	pixelHitColl,
		const CTPPSGeometry &	geometry
	)

protected

Definition at line 231 of file PPSFastLocalSimulation.cc.

References A, angular_dist_, CTPPSDetId::arm(), B, CTPPSGeometry::beginSensor(), makePileupJSON::bx, CTPPSDiamondDetId::channel(), edm::DetSet< T >::emplace_back(), CTPPSGeometry::endSensor(), spr::find(), PPSFastLocalSimulation::Distribution::Generate(), GenParticle::GenParticle, CTPPSGeometry::globalToLocal(), insensitiveMarginStrips_, RPTopology::IsHit(), CTPPSGeometry::localToGlobal(), visualization-live-secondInstance_cfg::m, makeHepMC_, makeHits_, particle_E_, particle_p_, pitchDiamonds_, pitchPixels_, pitchStrips_, position_dist_, gpuVertexFinder::printf(), printId(), roundToPitch_, CTPPSDetId::rp(), RPs_, CTPPSDetId::sdTimingDiamond, CTPPSDetId::sdTrackingPixel, CTPPSDetId::sdTrackingStrip, mathSSE::sqrt(), CTPPSDetId::station(), digitizers_cfi::strip, stripZeroPosition_, DetId::subdetId(), findQualityFiles::v, verbosity_, and z0_.

Referenced by produce().

                                                                           {
   // generate track
   double bx = 0., by = 0., ax = 0., ay = 0.;
   position_dist_.Generate(rndEng, bx, by);
   angular_dist_.Generate(rndEng, ax, ay);
 
   if (verbosity_ > 5)
     printf("\tax = %.3f mrad, bx = %.3f mm, ay = %.3f mrad, by = %.3f mm, z0 = %.3f m\n",
            ax * 1E3,
            bx,
            ay * 1E3,
            by,
            z0_ * 1E-3);
 
   // add HepMC track description
   if (makeHepMC_) {
     GenVertex *gVx = new GenVertex(HepMC::FourVector(bx, by, z0_, 0.));
     gEv->add_vertex(gVx);
 
     GenParticle *gPe;
     double az = sqrt(1. - ax * ax - ay * ay);
     gPe = new GenParticle(HepMC::FourVector(particle_p_ * ax, particle_p_ * ay, particle_p_ * az, particle_E_),
                           2212,
                           1);  // add a proton in final state
     gPe->suggest_barcode(idx + 1);
     gVx->add_particle_out(gPe);
   }
 
   if (makeHits_) {
     // check all sensors known to geometry
     for (CTPPSGeometry::mapType::const_iterator it = geometry.beginSensor(); it != geometry.endSensor(); ++it) {
       // get RP decimal id
       CTPPSDetId detId(it->first);
       unsigned int decRPId = detId.arm() * 100 + detId.station() * 10 + detId.rp();
 
       // stop if the RP is not selected
       if (find(RPs_.begin(), RPs_.end(), decRPId) == RPs_.end())
         continue;
 
       // keep only 1 diamond channel to represent 1 plane
       if (detId.subdetId() == CTPPSDetId::sdTimingDiamond) {
         CTPPSDiamondDetId channelId(it->first);
         if (channelId.channel() != 0)
           continue;
       }
 
       if (verbosity_ > 5) {
         printf("        ");
         printId(it->first);
         printf(": ");
       }
 
       // determine the track impact point (in global coordinates)
       // !! this assumes that local axes (1, 0, 0) and (0, 1, 0) describe the sensor surface
       const auto gl_o = geometry.localToGlobal(detId, CTPPSGeometry::Vector(0, 0, 0));
       const auto gl_a1 = geometry.localToGlobal(detId, CTPPSGeometry::Vector(1, 0, 0)) - gl_o;
       const auto gl_a2 = geometry.localToGlobal(detId, CTPPSGeometry::Vector(0, 1, 0)) - gl_o;
 
       TMatrixD A(3, 3);
       TVectorD B(3);
       A(0, 0) = ax;
       A(0, 1) = -gl_a1.x();
       A(0, 2) = -gl_a2.x();
       B(0) = gl_o.x() - bx;
       A(1, 0) = ay;
       A(1, 1) = -gl_a1.y();
       A(1, 2) = -gl_a2.y();
       B(1) = gl_o.y() - by;
       A(2, 0) = 1.;
       A(2, 1) = -gl_a1.z();
       A(2, 2) = -gl_a2.z();
       B(2) = gl_o.z() - z0_;
       TMatrixD Ai(3, 3);
       Ai = A.Invert();
       TVectorD P(3);
       P = Ai * B;
 
       double de_z = P(0);
       CTPPSGeometry::Vector h_glo(ax * de_z + bx, ay * de_z + by, de_z + z0_);
 
       // hit in local coordinates
       CTPPSGeometry::Vector h_loc = geometry.globalToLocal(detId, h_glo);
 
       // strips
       if (detId.subdetId() == CTPPSDetId::sdTrackingStrip) {
         double u = h_loc.x();
         double v = h_loc.y();
 
         if (verbosity_ > 5)
           printf("            u=%+8.4f, v=%+8.4f", u, v);
 
         // is it within detector?
         if (!RPTopology::IsHit(u, v, insensitiveMarginStrips_)) {
           if (verbosity_ > 5)
             printf(" | no hit\n");
           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)
             printf(" | strip=%+4i", strip);
         }
 
         double sigma = pitchStrips_ / sqrt(12.);
 
         if (verbosity_ > 5)
           printf(" | m=%+8.4f, sigma=%+8.4f\n", v, sigma);
 
         DetSet<TotemRPRecHit> &hits = stripHitColl->find_or_insert(detId);
         hits.emplace_back(v, sigma);
       }
 
       // diamonds
       if (detId.subdetId() == CTPPSDetId::sdTimingDiamond) {
         if (roundToPitch_) {
           h_loc.SetX(pitchDiamonds_ * floor(h_loc.x() / pitchDiamonds_ + 0.5));
         }
 
         if (verbosity_ > 5)
           printf("            m = %.3f\n", h_loc.x());
 
         const double width = pitchDiamonds_;
 
         DetSet<CTPPSDiamondRecHit> &hits = diamondHitColl->find_or_insert(detId);
         hits.emplace_back(h_loc.x(), width, 0., 0., 0., 0., 0., 0., 0., 0, HPTDCErrorFlags(), false);
       }
 
       // pixels
       if (detId.subdetId() == CTPPSDetId::sdTrackingPixel) {
         if (roundToPitch_) {
           h_loc.SetX(pitchPixels_ * floor(h_loc.x() / pitchPixels_ + 0.5));
           h_loc.SetY(pitchPixels_ * floor(h_loc.y() / pitchPixels_ + 0.5));
         }
 
         if (verbosity_ > 5)
           printf("            m1 = %.3f, m2 = %.3f\n", h_loc.x(), h_loc.y());
 
         const double sigma = pitchPixels_ / sqrt(12.);
 
         const LocalPoint lp(h_loc.x(), h_loc.y(), h_loc.z());
         const LocalError le(sigma, 0., sigma);
 
         DetSet<CTPPSPixelRecHit> &hits = pixelHitColl->find_or_insert(detId);
         hits.emplace_back(lp, le);
       }
     }
   }
 }

void PPSFastLocalSimulation::produce	(	edm::Event &	event,
		const edm::EventSetup &	es
	)

overrideprotected

Definition at line 394 of file PPSFastLocalSimulation.cc.

References esTokenGeometry_, edm::EventID::event(), GenerateTrack(), relativeConstraints::geometry, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), edm::EventBase::id(), makeHepMC_, makeHits_, eostools::move(), particlesPerEvent_, pi, gpuVertexFinder::printf(), edm::Event::streamID(), and verbosity_.

                                                                              {
   if (verbosity_ > 2)
     printf(">> PPSFastLocalSimulation::produce > event %llu\n", event.id().event());
 
   Service<edm::RandomNumberGenerator> rng;
   HepRandomEngine &rndEng = rng->getEngine(event.streamID());
 
   if (verbosity_ > 5)
     printf("\tseed = %li\n", rndEng.getSeed());
 
   // get geometry
   auto const &geometry = es.getData(esTokenGeometry_);
 
   // initialize products
   GenEvent *gEv = new GenEvent();
   gEv->set_event_number(event.id().event());
 
   unique_ptr<DetSetVector<TotemRPRecHit>> stripHitColl(new DetSetVector<TotemRPRecHit>());
   unique_ptr<DetSetVector<CTPPSDiamondRecHit>> diamondHitColl(new DetSetVector<CTPPSDiamondRecHit>());
   unique_ptr<DetSetVector<CTPPSPixelRecHit>> pixelHitColl(new DetSetVector<CTPPSPixelRecHit>());
 
   // run particle loop
   for (unsigned int pi = 0; pi < particlesPerEvent_; pi++) {
     if (verbosity_ > 5)
       printf("    generating track %u\n", pi);
 
     GenerateTrack(pi, rndEng, gEv, stripHitColl, diamondHitColl, pixelHitColl, geometry);
   }
 
   // save products
   if (makeHepMC_) {
     unique_ptr<HepMCProduct> hepMCoutput(new HepMCProduct());
     hepMCoutput->addHepMCData(gEv);
     event.put(move(hepMCoutput));
   }
 
   if (makeHits_) {
     event.put(move(stripHitColl));
     event.put(move(diamondHitColl));
     event.put(move(pixelHitColl));
   }
 }