#include <OpticalFunctionsTransport.h>

Inheritance diagram for OpticalFunctionsTransport:

Public Member Functions
	OpticalFunctionsTransport (const edm::ParameterSet &ps, edm::ConsumesCollector iC)

void	process (const HepMC::GenEvent ev, const edm::EventSetup &es, CLHEP::HepRandomEngine engine) override

	~OpticalFunctionsTransport () override

Public Member Functions inherited from BaseProtonTransport
void	addPartToHepMC (const HepMC::GenEvent , HepMC::GenEvent )

void	ApplyBeamCorrection (HepMC::GenParticle *p)

void	ApplyBeamCorrection (TLorentzVector &p)

	BaseProtonTransport (const edm::ParameterSet &iConfig)

double	beamEnergy ()

double	beamMomentum ()

void	clear ()

std::vector< LHCTransportLink > &	getCorrespondenceMap ()

virtual	~BaseProtonTransport ()

Private Member Functions
bool	transportProton (const HepMC::GenParticle *)

Private Attributes
const CTPPSBeamParameters *	beamParameters_ {nullptr}

edm::ESGetToken< CTPPSBeamParameters, CTPPSBeamParametersRcd >	beamParametersToken_

const SimBeamSpotObjects *	beamspot_ {nullptr}

edm::ESGetToken< SimBeamSpotObjects, SimBeamSpotObjectsRcd >	beamspotToken_

double	empiricalAperture45_a_int_

double	empiricalAperture45_a_slp_

double	empiricalAperture45_xi0_int_

double	empiricalAperture45_xi0_slp_

double	empiricalAperture56_a_int_

double	empiricalAperture56_a_slp_

double	empiricalAperture56_xi0_int_

double	empiricalAperture56_xi0_slp_

const LHCInfo *	lhcInfo_ {nullptr}

edm::ESGetToken< LHCInfo, LHCInfoRcd >	lhcInfoToken_

unsigned int	optFunctionId45_ {0}

unsigned int	optFunctionId56_ {0}

const LHCInterpolatedOpticalFunctionsSetCollection *	opticalFunctions_ {nullptr}

edm::ESGetToken< LHCInterpolatedOpticalFunctionsSetCollection, CTPPSInterpolatedOpticsRcd >	opticsToken_

bool	useEmpiricalApertures_

Additional Inherited Members
Protected Types inherited from BaseProtonTransport
enum	TransportMode { TransportMode::HECTOR, TransportMode::TOTEM, TransportMode::OPTICALFUNCTIONS }

Protected Member Functions inherited from BaseProtonTransport
void	setBeamFileNames (const std::string &nam1, const std::string &nam2)

void	setBeamParameters (double stx, double sty, double sx, double sy, double se)

void	setCrossingAngles (double cx45, double cx56, double cy45, double cy56)

Protected Attributes inherited from BaseProtonTransport
bool	bApplyZShift_

std::string	beam1Filename_ {""}

std::string	beam2Filename_ {""}

CLHEP::HepRandomEngine *	engine_ {nullptr}

double	etaCut_

double	fCrossingAngleX_45_ {0.0}

double	fCrossingAngleX_56_ {0.0}

double	fCrossingAngleY_45_ {0.0}

double	fCrossingAngleY_56_ {0.0}

double	fPPSRegionStart_45_

double	fPPSRegionStart_56_

std::map< unsigned int, TLorentzVector >	m_beamPart

std::vector< LHCTransportLink >	m_CorrespondenceMap

std::map< unsigned int, double >	m_xAtTrPoint

std::map< unsigned int, double >	m_yAtTrPoint

TransportMode	MODE

double	momentumCut_

bool	produceHitsRelativeToBeam_

bool	useBeamPositionFromLHCInfo_

bool	verbosity_

Detailed Description

Definition at line 19 of file OpticalFunctionsTransport.h.

Constructor & Destructor Documentation

◆ OpticalFunctionsTransport()

OpticalFunctionsTransport::OpticalFunctionsTransport	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector	iC
	)

Definition at line 4 of file OpticalFunctionsTransport.cc.

References BaseProtonTransport::MODE, and BaseProtonTransport::OPTICALFUNCTIONS.

     : BaseProtonTransport(iConfig),
       lhcInfoToken_(iC.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("lhcInfoLabel")))),
       beamParametersToken_(iC.esConsumes()),
       opticsToken_(iC.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("opticsLabel")))),
       beamspotToken_(iC.esConsumes()),
       useEmpiricalApertures_(iConfig.getParameter<bool>("useEmpiricalApertures")),
       empiricalAperture45_xi0_int_(iConfig.getParameter<double>("empiricalAperture45_xi0_int")),
       empiricalAperture45_xi0_slp_(iConfig.getParameter<double>("empiricalAperture45_xi0_slp")),
       empiricalAperture45_a_int_(iConfig.getParameter<double>("empiricalAperture45_a_int")),
       empiricalAperture45_a_slp_(iConfig.getParameter<double>("empiricalAperture45_a_slp")),
       empiricalAperture56_xi0_int_(iConfig.getParameter<double>("empiricalAperture56_xi0_int")),
       empiricalAperture56_xi0_slp_(iConfig.getParameter<double>("empiricalAperture56_xi0_slp")),
       empiricalAperture56_a_int_(iConfig.getParameter<double>("empiricalAperture56_a_int")),
       empiricalAperture56_a_slp_(iConfig.getParameter<double>("empiricalAperture56_a_slp")) {
   MODE = TransportMode::OPTICALFUNCTIONS;
 }

◆ ~OpticalFunctionsTransport()

OpticalFunctionsTransport::~OpticalFunctionsTransport ( )

override

Definition at line 21 of file OpticalFunctionsTransport.cc.

21 {}

Member Function Documentation

◆ process()

void OpticalFunctionsTransport::process	(	const HepMC::GenEvent *	ev,
		const edm::EventSetup &	es,
		CLHEP::HepRandomEngine *	engine
	)

overridevirtual

Implements BaseProtonTransport.

Definition at line 23 of file OpticalFunctionsTransport.cc.

References beamParameters_, beamParametersToken_, beamspot_, beamspotToken_, BaseProtonTransport::clear(), BaseProtonTransport::engine_, BaseProtonTransport::etaCut_, GenParticle::GenParticle, edm::EventSetup::getData(), lhcInfo_, lhcInfoToken_, mps_splice::line, BaseProtonTransport::m_beamPart, BaseProtonTransport::momentumCut_, optFunctionId45_, optFunctionId56_, opticalFunctions_, opticsToken_, and transportProton().

                                                                       {
   clear();
 
   lhcInfo_ = &iSetup.getData(lhcInfoToken_);
   beamParameters_ = &iSetup.getData(beamParametersToken_);
   opticalFunctions_ = &iSetup.getData(opticsToken_);
   beamspot_ = &iSetup.getData(beamspotToken_);
 
   // Choose the optical function corresponding to the first station ono each side (it is in lhc ref. frame)
   optFunctionId45_ = 0;
   optFunctionId56_ = 0;
   for (const auto& ofp : (*opticalFunctions_)) {
     if (ofp.second.getScoringPlaneZ() < 0) {
       if (optFunctionId45_ == 0)
         optFunctionId45_ = ofp.first;
       if (opticalFunctions_->at(optFunctionId45_).getScoringPlaneZ() < ofp.second.getScoringPlaneZ())
         optFunctionId45_ = ofp.first;
     }
     if (ofp.second.getScoringPlaneZ() > 0) {
       if (optFunctionId56_ == 0)
         optFunctionId56_ = ofp.first;
       if (opticalFunctions_->at(optFunctionId56_).getScoringPlaneZ() > ofp.second.getScoringPlaneZ())
         optFunctionId56_ = ofp.first;
     }
   }
   //
   engine_ = engine;  // the engine needs to be updated for each event
 
   for (HepMC::GenEvent::particle_const_iterator eventParticle = evt->particles_begin();
        eventParticle != evt->particles_end();
        ++eventParticle) {
     if (!((*eventParticle)->status() == 1 && (*eventParticle)->pdg_id() == 2212))
       continue;
 
     if (!(fabs((*eventParticle)->momentum().eta()) > etaCut_ && fabs((*eventParticle)->momentum().pz()) > momentumCut_))
       continue;  // discard protons outside kinematic acceptance
 
     unsigned int line = (*eventParticle)->barcode();
     HepMC::GenParticle* gpart = (*eventParticle);
     if (gpart->pdg_id() != 2212)
       continue;  // only transport stable protons
     if (gpart->status() != 1)
       continue;
     if (m_beamPart.find(line) != m_beamPart.end())  // assures this protons has not been already propagated
       continue;
 
     transportProton(gpart);
   }
 }

◆ transportProton()

bool OpticalFunctionsTransport::transportProton ( const HepMC::GenParticle * in_trk )

private

Definition at line 75 of file OpticalFunctionsTransport.cc.

Referenced by process().

                                                                               {
   const HepMC::FourVector& vtx_cms = in_trk->production_vertex()->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
   double urad = 1.e-6;
   double beamMomentum = 0.;
   double xangle = 0.;
   double empiricalAperture_xi0_int, empiricalAperture_xi0_slp;
   double empiricalAperture_a_int, empiricalAperture_a_slp;
   unsigned int optFunctionId;
   // get the beam position at the IP in mm and in the LHC ref. frame
   double vtxXoffset;
   double vtxYoffset;
   if (useBeamPositionFromLHCInfo_) {
     vtxXoffset = -beamParameters_->getVtxOffsetX45() * cm_to_mm;
     vtxYoffset = beamParameters_->getVtxOffsetY45() * cm_to_mm;
   } else {
     vtxXoffset = -beamspot_->x() * cm_to_mm;
     vtxYoffset = beamspot_->y() * cm_to_mm;
   }
 
   if (mom_lhc.z() < 0)  // sector 45
   {
     optFunctionId = optFunctionId45_;
     beamMomentum = beamParameters_->getBeamMom45();
     xangle = beamParameters_->getHalfXangleX45();
     empiricalAperture_xi0_int = empiricalAperture45_xi0_int_;
     empiricalAperture_xi0_slp = empiricalAperture45_xi0_slp_;
     empiricalAperture_a_int = empiricalAperture45_a_int_;
     empiricalAperture_a_slp = empiricalAperture45_a_slp_;
   } else {  // sector 56
     optFunctionId = optFunctionId56_;
     beamMomentum = beamParameters_->getBeamMom56();
     xangle = beamParameters_->getHalfXangleX56();
     empiricalAperture_xi0_int = empiricalAperture56_xi0_int_;
     empiricalAperture_xi0_slp = empiricalAperture56_xi0_slp_;
     empiricalAperture_a_int = empiricalAperture56_a_int_;
     empiricalAperture_a_slp = empiricalAperture56_a_slp_;
   }
   if (xangle > 1.0)
     xangle *= urad;
   // calculate kinematics for optics parametrisation, avoid the aproximation for small angles xangle -> tan(xangle)
   const double p = mom_lhc.rho();
   const double xi = 1. - p / beamMomentum;
   const double th_x_phys = mom_lhc.x() / abs(mom_lhc.z()) - tan(xangle);  //"-" in the LHC ref. frame
   const double th_y_phys = mom_lhc.y() / abs(mom_lhc.z());
   const double vtx_lhc_eff_x = vtx_lhc.x() - vtx_lhc.z() * (mom_lhc.x() / mom_lhc.z() + tan(xangle)) - (vtxXoffset);
   const double vtx_lhc_eff_y = vtx_lhc.y() - vtx_lhc.z() * (mom_lhc.y() / mom_lhc.z()) - (vtxYoffset);
 
   if (verbosity_) {
     LogDebug("OpticalFunctionsTransport")
         << "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;
   }
 
   // check empirical aperture
   if (useEmpiricalApertures_) {
     const auto& xangle =
         (lhcInfo_->crossingAngle() > 1.0) ? lhcInfo_->crossingAngle() * urad : lhcInfo_->crossingAngle();
     const double xi_th = (empiricalAperture_xi0_int + xangle * empiricalAperture_xi0_slp) +
                          (empiricalAperture_a_int + xangle * empiricalAperture_a_slp) * th_x_phys;
 
     if (xi > xi_th) {
       if (verbosity_) {
         LogDebug("OpticalFunctionsTransport") << "stop because of empirical appertures";
       }
       return false;
     }
   }
 
   // transport the proton into  pot/scoring plane
   auto ofp = opticalFunctions_->at(optFunctionId);
   CTPPSDetId rpId(optFunctionId);
   const unsigned int rpDecId = rpId.arm() * 100 + rpId.station() * 10 + rpId.rp();
 
   if (verbosity_)
     LogDebug("OpticalFunctionsTransport") << "  RP " << rpDecId << std::endl;
 
   // transport proton
   LHCInterpolatedOpticalFunctionsSet::Kinematics k_in = {
       vtx_lhc_eff_x * cm_to_mm, th_x_phys, vtx_lhc_eff_y * cm_to_mm, th_y_phys, xi};  // conversions: mm -> cm
 
   LHCInterpolatedOpticalFunctionsSet::Kinematics k_out;
   ofp.transport(k_in, k_out, true);
 
   // Original code uses mm, but CMS uses cm, so keep it in cm
   double b_x = k_out.x * cm_to_mm, b_y = k_out.y * cm_to_mm;  // 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., -tan(xangle), 0., 0., 0.};
     LHCInterpolatedOpticalFunctionsSet::Kinematics k_be_out;
     ofp.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 * cm_to_mm;
     b_y -= k_be_out.y * cm_to_mm;  // conversions: cm -> mm
   }
 
   const double z_scoringPlane = ofp.getScoringPlaneZ() * cm_to_mm;  // conversion: cm --> mm
 
   if (verbosity_) {
     LogDebug("OpticalFunctionsTransport")
         << "    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";
   }
   //
   // Project the track back to the starting of PPS region in mm
   b_x -= (abs(z_scoringPlane) - ((z_scoringPlane < 0) ? fPPSRegionStart_45_ : fPPSRegionStart_56_) * 1e3) * a_x;
   b_y -= (abs(z_scoringPlane) - ((z_scoringPlane < 0) ? fPPSRegionStart_45_ : fPPSRegionStart_56_) * 1e3) * a_y;
 
   unsigned int line = in_trk->barcode();
   double px = -p * a_x;
   double py = p * a_y;
   double pz = std::copysign(sqrt(p * p - px * px - py * py), mom_cms.z());
   double e = sqrt(px * px + py * py + pz * pz + ProtonMassSQ);
   TLorentzVector p_out(px, py, pz, e);
   m_beamPart[line] = p_out;
   m_xAtTrPoint[line] = -b_x;
   m_yAtTrPoint[line] = b_y;
   return true;
 }