#include <Geant4ePropagator.h>

Inheritance diagram for Geant4ePropagator:

Public Member Functions
Geant4ePropagator *	clone () const override

	Geant4ePropagator (const MagneticField *field=nullptr, std::string particleName="mu", PropagationDirection dir=alongMomentum)

const MagneticField *	magneticField () const override

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Cylinder &) const override

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Plane &) const override

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Cylinder &) const override

std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &, const Plane &) const override

	~Geant4ePropagator () override

Public Member Functions inherited from Propagator
virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const final

virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const final

virtual FreeTrajectoryState	propagate (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const final

template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const FreeTrajectoryState &, const Surface &) const final

virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest) const

virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const GlobalPoint &pDest1, const GlobalPoint &pDest2) const
	Propagate to PCA to a line (given by 2 points) given a starting point. More...

virtual std::pair< FreeTrajectoryState, double >	propagateWithPath (const FreeTrajectoryState &ftsStart, const reco::BeamSpot &beamSpot) const
	Propagate to PCA to a line (given by beamSpot position and slope) given a starting point. More...

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) const final

virtual PropagationDirection	propagationDirection () const final

	Propagator (PropagationDirection dir=alongMomentum)

virtual bool	setMaxDirectionChange (float phiMax)

virtual void	setPropagationDirection (PropagationDirection dir)

virtual	~Propagator ()

Private Types
typedef std::pair< bool, std::shared_ptr< G4ErrorTarget > >	ErrorTargetPair

typedef std::pair< TrajectoryStateOnSurface, double >	TsosPP

Private Member Functions
template<>
bool	configureAnyPropagation (G4ErrorMode &mode, Cylinder const &pDest, GlobalPoint const &cmsInitPos, GlobalVector const &cmsInitMom) const

template<>
bool	configureAnyPropagation (G4ErrorMode &mode, Plane const &pDest, GlobalPoint const &cmsInitPos, GlobalVector const &cmsInitMom) const

template<class SurfaceType >
bool	configureAnyPropagation (G4ErrorMode &mode, SurfaceType const &pDest, GlobalPoint const &cmsInitPos, GlobalVector const &cmsInitMom) const

template<class SurfaceType >
bool	configurePropagation (G4ErrorMode &mode, SurfaceType const &pDest, GlobalPoint const &cmsInitPos, GlobalVector const &cmsInitMom) const

void	debugReportPlaneSetup (GlobalPoint const &posPlane, HepGeom::Point3D< double > const &surfPos, GlobalVector const &normalPlane, HepGeom::Normal3D< double > const &surfNorm, const Plane &pDest) const

template<class SurfaceType >
void	debugReportTrackState (std::string const &currentContext, GlobalPoint const &cmsInitPos, CLHEP::Hep3Vector const &g4InitPos, GlobalVector const &cmsInitMom, CLHEP::Hep3Vector const &g4InitMom, const SurfaceType &pDest) const

void	ensureGeant4eIsInitilized (bool forceInit) const

std::string	generateParticleName (int charge) const

template<>
std::string	getSurfaceType (Cylinder const &c) const

template<>
std::string	getSurfaceType (Plane const &c) const

template<class SurfaceType >
std::string	getSurfaceType (SurfaceType const &surface) const

template<class SurfaceType >
std::pair< TrajectoryStateOnSurface, double >	propagateGeneric (const FreeTrajectoryState &ftsStart, const SurfaceType &pDest) const

template<>
Geant4ePropagator::ErrorTargetPair	transformToG4SurfaceTarget (const Cylinder &pDest, bool moveTargetToEndOfSurface) const

template<>
Geant4ePropagator::ErrorTargetPair	transformToG4SurfaceTarget (const Plane &pDest, bool moveTargetToEndOfSurface) const

template<class SurfaceType >
ErrorTargetPair	transformToG4SurfaceTarget (const SurfaceType &pDest, bool moveTargetToEndOfSurface) const

Private Attributes
const MagneticField *	theField

G4ErrorPropagatorData *	theG4eData

G4ErrorPropagatorManager *	theG4eManager

std::string	theParticleName

Detailed Description

Propagator based on the Geant4e package. Uses the Propagator class in the TrackingTools/GeomPropagators package to define the interface. See that class for more details.

Definition at line 20 of file Geant4ePropagator.h.

Member Typedef Documentation

◆ ErrorTargetPair

typedef std::pair<bool, std::shared_ptr<G4ErrorTarget> > Geant4ePropagator::ErrorTargetPair

private

Definition at line 83 of file Geant4ePropagator.h.

◆ TsosPP

typedef std::pair<TrajectoryStateOnSurface, double> Geant4ePropagator::TsosPP

private

Definition at line 82 of file Geant4ePropagator.h.

Constructor & Destructor Documentation

◆ Geant4ePropagator()

Geant4ePropagator::Geant4ePropagator	(	const MagneticField *	field = `nullptr`,
		std::string	particleName = `"mu"`,
		PropagationDirection	dir = `alongMomentum`
	)

Constructor. Takes as arguments:

The magnetic field
The particle name whose properties will be used in the propagation. Without the charge, i.e. "mu", "pi", ...
The propagation direction. It may be: alongMomentum, oppositeToMomentum

Constructor.

Definition at line 39 of file Geant4ePropagator.cc.

     : Propagator(dir),
       theField(field),
       theParticleName(particleName),
       theG4eManager(G4ErrorPropagatorManager::GetErrorPropagatorManager()),
       theG4eData(G4ErrorPropagatorData::GetErrorPropagatorData()) {
   LogDebug("Geant4e") << "Geant4e Propagator initialized";
  
   // has to be called here, doing it later will not load the G4 physics list
   // properly when using the G4 ES Producer. Reason: unclear
   ensureGeant4eIsInitilized(true);
 }

References ensureGeant4eIsInitilized(), and LogDebug.

Referenced by clone().

◆ ~Geant4ePropagator()

Geant4ePropagator::~Geant4ePropagator ( )

override

Destructor.

Definition at line 54 of file Geant4ePropagator.cc.

                                       {
   LogDebug("Geant4e") << "Geant4ePropagator::~Geant4ePropagator()" << std::endl;
  
   // don't close the g4 Geometry here, because the propagator might have been
   // cloned
   // but there is only one, globally-shared Geometry
 }

References LogDebug.

Member Function Documentation

◆ clone()

Geant4ePropagator* Geant4ePropagator::clone ( void ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 77 of file Geant4ePropagator.h.

77 { return new Geant4ePropagator(*this); }

References Geant4ePropagator().

◆ configureAnyPropagation() [1/3]

template<>

bool Geant4ePropagator::configureAnyPropagation	(	G4ErrorMode &	mode,
		Cylinder const &	pDest,
		GlobalPoint const &	cmsInitPos,
		GlobalVector const &	cmsInitMom
	)		const

private

Definition at line 180 of file Geant4ePropagator.cc.

                                                                                       {
   //------------------------------------
   // For cylinder assume outside is backwards, inside is along
   // General use for particles from collisions
   LocalPoint lpos = pDest.toLocal(cmsInitPos);
   Surface::Side theSide = pDest.side(lpos, 0);
   if (theSide == SurfaceOrientation::positiveSide) {  // outside cylinder
     mode = G4ErrorMode_PropBackwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'backwards\' indirect "
                            "via the Any direction";
   } else {  // inside cylinder
     mode = G4ErrorMode_PropForwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'forwards\' indirect "
                            "via the Any direction";
   }
  
   return true;
 }

References LogDebug, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, SurfaceOrientation::positiveSide, Cylinder::side(), and GloballyPositioned< T >::toLocal().

◆ configureAnyPropagation() [2/3]

template<>

bool Geant4ePropagator::configureAnyPropagation	(	G4ErrorMode &	mode,
		Plane const &	pDest,
		GlobalPoint const &	cmsInitPos,
		GlobalVector const &	cmsInitMom
	)		const

private

Definition at line 160 of file Geant4ePropagator.cc.

                                                                                       {
   if (pDest.localZ(cmsInitPos) * pDest.localZ(cmsInitMom) < 0) {
     mode = G4ErrorMode_PropForwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'forwards\' indirect "
                            "via the Any direction"
                         << std::endl;
   } else {
     mode = G4ErrorMode_PropBackwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'backwards\' indirect "
                            "via the Any direction"
                         << std::endl;
   }
  
   return true;
 }

References Plane::localZ(), LogDebug, and ALCARECOPromptCalibProdSiPixelAli0T_cff::mode.

◆ configureAnyPropagation() [3/3]

template<class SurfaceType >

bool Geant4ePropagator::configureAnyPropagation	(	G4ErrorMode &	mode,
		SurfaceType const &	pDest,
		GlobalPoint const &	cmsInitPos,
		GlobalVector const &	cmsInitMom
	)		const

private

Referenced by configurePropagation().

◆ configurePropagation()

template<class SurfaceType >

bool Geant4ePropagator::configurePropagation	(	G4ErrorMode &	mode,
		SurfaceType const &	pDest,
		GlobalPoint const &	cmsInitPos,
		GlobalVector const &	cmsInitMom
	)		const

private

Definition at line 203 of file Geant4ePropagator.cc.

                                                                                    {
   if (propagationDirection() == oppositeToMomentum) {
     mode = G4ErrorMode_PropBackwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'backwards\' " << std::endl;
   } else if (propagationDirection() == alongMomentum) {
     mode = G4ErrorMode_PropForwards;
     LogDebug("Geant4e") << "G4e -  Propagator mode is \'forwards\'" << std::endl;
   } else if (propagationDirection() == anyDirection) {
     if (configureAnyPropagation(mode, pDest, cmsInitPos, cmsInitMom) == false)
       return false;
   } else {
     edm::LogError("Geant4e") << "G4e - Unsupported propagation mode";
     return false;
   }
   return true;
 }

References alongMomentum, anyDirection, configureAnyPropagation(), LogDebug, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, oppositeToMomentum, and Propagator::propagationDirection().

Referenced by propagateGeneric().

◆ debugReportPlaneSetup()

void Geant4ePropagator::debugReportPlaneSetup	(	GlobalPoint const &	posPlane,
		HepGeom::Point3D< double > const &	surfPos,
		GlobalVector const &	normalPlane,
		HepGeom::Normal3D< double > const &	surfNorm,
		const Plane &	pDest
	)		const

private

Definition at line 442 of file Geant4ePropagator.cc.

                                                                         {
   LogDebug("Geant4e") << "G4e -  Destination CMS plane position:" << posPlane << "cm\n"
                       << "G4e -                  (Ro, eta, phi): (" << posPlane.perp() << " cm, " << posPlane.eta()
                       << ", " << posPlane.phi().degrees() << " deg)\n"
                       << "G4e -  Destination G4  plane position: " << surfPos << " mm, Ro = " << surfPos.perp()
                       << " mm";
   LogDebug("Geant4e") << "G4e -  Destination CMS plane normal  : " << normalPlane << "\n"
                       << "G4e -  Destination G4  plane normal  : " << normalPlane;
   LogDebug("Geant4e") << "G4e -  Distance from plane position to plane: " << pDest.localZ(posPlane) << " cm";
 }

References Geom::Phi< T1, Range >::degrees(), PV3DBase< T, PVType, FrameType >::eta(), Plane::localZ(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), and PV3DBase< T, PVType, FrameType >::phi().

◆ debugReportTrackState()

template<class SurfaceType >

void Geant4ePropagator::debugReportTrackState	(	std::string const &	currentContext,
		GlobalPoint const &	cmsInitPos,
		CLHEP::Hep3Vector const &	g4InitPos,
		GlobalVector const &	cmsInitMom,
		CLHEP::Hep3Vector const &	g4InitMom,
		const SurfaceType &	pDest
	)		const

private

Definition at line 458 of file Geant4ePropagator.cc.

                                                                               {
   LogDebug("Geant4e") << "G3 -- Current Context: " << currentContext;
   LogDebug("Geant4e") << "G4e -  CMS point position:" << cmsInitPos << "cm\n"
                       << "G4e -              (Ro, eta, phi): (" << cmsInitPos.perp() << " cm, " << cmsInitPos.eta()
                       << ", " << cmsInitPos.phi().degrees() << " deg)\n"
                       << "G4e -   G4  point position: " << g4InitPos << " mm, Ro = " << g4InitPos.perp() << " mm";
   LogDebug("Geant4e") << "G4e -   CMS momentum      :" << cmsInitMom << "GeV\n"
                       << " pt: " << cmsInitMom.perp() << "G4e -  G4  momentum      : " << g4InitMom << " MeV";
 }

References Geom::Phi< T1, Range >::degrees(), PV3DBase< T, PVType, FrameType >::eta(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), and PV3DBase< T, PVType, FrameType >::phi().

Referenced by propagateGeneric().

◆ ensureGeant4eIsInitilized()

void Geant4ePropagator::ensureGeant4eIsInitilized ( bool forceInit ) const

private

Propagate from a free state (e.g. position and momentum in in global cartesian coordinates) to a plane.

Definition at line 70 of file Geant4ePropagator.cc.

                                                                       {
   LogDebug("Geant4e") << "ensureGeant4eIsInitilized called" << std::endl;
   if ((G4ErrorPropagatorData::GetErrorPropagatorData()->GetState() == G4ErrorState_PreInit) || forceInit) {
     LogDebug("Geant4e") << "Initializing G4 propagator" << std::endl;
  
     G4UImanager::GetUIpointer()->ApplyCommand("/exerror/setField -10. kilogauss");
  
     theG4eManager->InitGeant4e();
  
     const G4Field *field = G4TransportationManager::GetTransportationManager()->GetFieldManager()->GetDetectorField();
     if (field == nullptr) {
       edm::LogError("Geant4e") << "No G4 magnetic field defined";
     }
     LogDebug("Geant4e") << "G4 propagator initialized" << std::endl;
   } else {
     LogDebug("Geant4e") << "G4 not in preinit state: " << G4ErrorPropagatorData::GetErrorPropagatorData()->GetState()
                         << std::endl;
   }
  
   // example code uses
   // G4UImanager::GetUIpointer()->ApplyCommand("/geant4e/limits/stepLength 100
   // mm");
   G4UImanager::GetUIpointer()->ApplyCommand("/geant4e/limits/stepLength 10.0 mm");
 }

References LogDebug, and theG4eManager.

Referenced by Geant4ePropagator().

◆ generateParticleName()

std::string Geant4ePropagator::generateParticleName ( int charge ) const

private

Definition at line 144 of file Geant4ePropagator.cc.

                                                                   {
   std::string particleName = theParticleName;
  
   if (charge > 0) {
     particleName += "+";
   }
   if (charge < 0) {
     particleName += "-";
   }
  
   LogDebug("Geant4e") << "G4e -  Particle name: " << particleName;
  
   return particleName;
 }

References ALCARECOTkAlJpsiMuMu_cff::charge, LogDebug, HiggsValidation_cfi::particleName, AlCaHLTBitMon_QueryRunRegistry::string, and theParticleName.

Referenced by propagateGeneric().

◆ getSurfaceType() [1/3]

template<>

std::string Geant4ePropagator::getSurfaceType ( Cylinder const & c ) const

private

Definition at line 135 of file Geant4ePropagator.cc.

                                                                    {
   return "Cylinder";
 }

◆ getSurfaceType() [2/3]

template<>

std::string Geant4ePropagator::getSurfaceType ( Plane const & c ) const

private

Definition at line 140 of file Geant4ePropagator.cc.

                                                                 {
   return "Plane";
 }

◆ getSurfaceType() [3/3]

template<class SurfaceType >

std::string Geant4ePropagator::getSurfaceType ( SurfaceType const & surface ) const

private

◆ magneticField()

const MagneticField* Geant4ePropagator::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 79 of file Geant4ePropagator.h.

79 { return theField; }

References theField.

◆ propagateGeneric()

template<class SurfaceType >

std::pair< TrajectoryStateOnSurface, double > Geant4ePropagator::propagateGeneric	(	const FreeTrajectoryState &	ftsStart,
		const SurfaceType &	pDest
	)		const

private

Definition at line 224 of file Geant4ePropagator.cc.

                                                                                                                 {
   // Construct the target surface
   //
   //* Set the target surface
  
   ErrorTargetPair g4eTarget_center = transformToG4SurfaceTarget(pDest, false);
  
   // * Get the starting point and direction and convert them to
   // CLHEP::Hep3Vector
   //   for G4. CMS uses cm and GeV while Geant4 uses mm and MeV
   GlobalPoint cmsInitPos = ftsStart.position();
   GlobalVector cmsInitMom = ftsStart.momentum();
   bool flipped = false;
   if (propagationDirection() == oppositeToMomentum) {
     // flip the momentum vector as Geant4 will not do this
     // on it's own in a backward propagation
     cmsInitMom = -cmsInitMom;
     flipped = true;
   }
  
   // Set the mode of propagation according to the propagation direction
   G4ErrorMode mode = G4ErrorMode_PropForwards;
   if (!configurePropagation(mode, pDest, cmsInitPos, cmsInitMom))
     return TsosPP(TrajectoryStateOnSurface(), 0.0f);
  
   // re-check propagation direction chosen in case of AnyDirection
   if (mode == G4ErrorMode_PropBackwards && !flipped)
     cmsInitMom = -cmsInitMom;
  
   CLHEP::Hep3Vector g4InitPos = TrackPropagation::globalPointToHep3Vector(cmsInitPos);
   CLHEP::Hep3Vector g4InitMom = TrackPropagation::globalVectorToHep3Vector(cmsInitMom * GeV);
  
   debugReportTrackState("intitial", cmsInitPos, g4InitPos, cmsInitMom, g4InitMom, pDest);
  
   // Set the mode of propagation according to the propagation direction
   // G4ErrorMode mode = G4ErrorMode_PropForwards;
  
   // if (!configurePropagation(mode, pDest, cmsInitPos, cmsInitMom))
   //    return TsosPP(TrajectoryStateOnSurface(), 0.0f);
  
   // Set the error and trajectories, and finally propagate
   //
   G4ErrorTrajErr g4error(5, 1);
   if (ftsStart.hasError()) {
     CurvilinearTrajectoryError initErr;
     initErr = ftsStart.curvilinearError();
     g4error = TrackPropagation::algebraicSymMatrix55ToG4ErrorTrajErr(initErr, ftsStart.charge());
     LogDebug("Geant4e") << "CMS -  Error matrix: " << std::endl << initErr.matrix();
   } else {
     LogDebug("Geant4e") << "No error matrix available" << std::endl;
     return TsosPP(TrajectoryStateOnSurface(), 0.0f);
   }
  
   LogDebug("Geant4e") << "G4e -  Error matrix: " << std::endl << g4error;
  
   // in CMSSW, the state errors are deflated when performing the backward
   // propagation
   if (mode == G4ErrorMode_PropForwards) {
     G4ErrorPropagatorData::GetErrorPropagatorData()->SetStage(G4ErrorStage_Inflation);
   } else if (mode == G4ErrorMode_PropBackwards) {
     G4ErrorPropagatorData::GetErrorPropagatorData()->SetStage(G4ErrorStage_Deflation);
   }
  
   G4ErrorFreeTrajState g4eTrajState(generateParticleName(ftsStart.charge()), g4InitPos, g4InitMom, g4error);
   LogDebug("Geant4e") << "G4e -  Traj. State: " << (g4eTrajState);
  
   // Propagate
   int iterations = 0;
   double finalPathLength = 0;
  
   HepGeom::Point3D<double> finalRecoPos;
  
   G4ErrorPropagatorData::GetErrorPropagatorData()->SetMode(mode);
  
   theG4eData->SetTarget(g4eTarget_center.second.get());
   LogDebug("Geant4e") << "Running Propagation to the RECO surface" << std::endl;
  
   theG4eManager->InitTrackPropagation();
  
   bool continuePropagation = true;
   while (continuePropagation) {
     iterations++;
     LogDebug("Geant4e") << std::endl << "step count " << iterations << " step length " << finalPathLength;
  
     const int ierr = theG4eManager->PropagateOneStep(&g4eTrajState, mode);
  
     if (ierr != 0) {
       // propagation failed, return invalid track state
       return TsosPP(TrajectoryStateOnSurface(), 0.0f);
     }
  
     const float thisPathLength = TrackPropagation::g4doubleToCmsDouble(g4eTrajState.GetG4Track()->GetStepLength());
  
     LogDebug("Geant4e") << "step Length was " << thisPathLength << " cm, current global position: "
                         << TrackPropagation::hepPoint3DToGlobalPoint(g4eTrajState.GetPosition()) << std::endl;
  
     finalPathLength += thisPathLength;
  
     // if (std::fabs(finalPathLength) > 10000.0f)
     if (std::fabs(finalPathLength) > 200.0f) {
       LogDebug("Geant4e") << "ERROR: Quitting propagation: path length mega large" << std::endl;
       theG4eManager->GetPropagator()->InvokePostUserTrackingAction(g4eTrajState.GetG4Track());
       continuePropagation = false;
       LogDebug("Geant4e") << "WARNING: Quitting propagation: max path length "
                              "exceeded, returning invalid state"
                           << std::endl;
  
       // reached maximum path length, bail out
       return TsosPP(TrajectoryStateOnSurface(), 0.0f);
     }
  
     if (theG4eManager->GetPropagator()->CheckIfLastStep(g4eTrajState.GetG4Track())) {
       theG4eManager->GetPropagator()->InvokePostUserTrackingAction(g4eTrajState.GetG4Track());
       continuePropagation = false;
     }
   }
  
   // CMSSW Tracking convention, backward propagations have negative path length
   if (propagationDirection() == oppositeToMomentum)
     finalPathLength = -finalPathLength;
  
   // store the correct location for the hit on the RECO surface
   LogDebug("Geant4e") << "Position on the RECO surface" << g4eTrajState.GetPosition() << std::endl;
   finalRecoPos = g4eTrajState.GetPosition();
  
   theG4eManager->EventTermination();
  
   LogDebug("Geant4e") << "Final position of the Track :" << g4eTrajState.GetPosition() << std::endl;
  
   // Retrieve the state in the end from Geant4e, convert them to CMS vectors
   // and points, and build global trajectory parameters.
   // CMS uses cm and GeV while Geant4 uses mm and MeV
   //
   const HepGeom::Vector3D<double> momEnd = g4eTrajState.GetMomentum();
  
   // use the hit on the the RECO plane as the final position to be d'accor with
   // the RecHit measurements
   const GlobalPoint posEndGV = TrackPropagation::hepPoint3DToGlobalPoint(finalRecoPos);
   GlobalVector momEndGV = TrackPropagation::hep3VectorToGlobalVector(momEnd) / GeV;
  
   debugReportTrackState("final", posEndGV, finalRecoPos, momEndGV, momEnd, pDest);
  
   // Get the error covariance matrix from Geant4e. It comes in curvilinear
   // coordinates so use the appropiate CMS class
   G4ErrorTrajErr g4errorEnd = g4eTrajState.GetError();
  
   CurvilinearTrajectoryError curvError(
       TrackPropagation::g4ErrorTrajErrToAlgebraicSymMatrix55(g4errorEnd, ftsStart.charge()));
  
   if (mode == G4ErrorMode_PropBackwards) {
     GlobalTrajectoryParameters endParm(
         posEndGV, momEndGV, ftsStart.parameters().charge(), &ftsStart.parameters().magneticField());
  
     // flip the momentum direction because it has been flipped before running
     // G4's backwards prop
     momEndGV = -momEndGV;
   }
  
   LogDebug("Geant4e") << "G4e -  Error matrix after propagation: " << std::endl << g4errorEnd;
  
   LogDebug("Geant4e") << "CMS -  Error matrix after propagation: " << std::endl << curvError.matrix();
  
   GlobalTrajectoryParameters tParsDest(posEndGV, momEndGV, ftsStart.charge(), theField);
  
   SurfaceSideDefinition::SurfaceSide side;
  
   side = propagationDirection() == alongMomentum ? SurfaceSideDefinition::afterSurface
                                                  : SurfaceSideDefinition::beforeSurface;
  
   return TsosPP(TrajectoryStateOnSurface(tParsDest, curvError, pDest, side), finalPathLength);
 }

References SurfaceSideDefinition::afterSurface, TrackPropagation::algebraicSymMatrix55ToG4ErrorTrajErr(), alongMomentum, SurfaceSideDefinition::beforeSurface, FreeTrajectoryState::charge(), GlobalTrajectoryParameters::charge(), configurePropagation(), FreeTrajectoryState::curvilinearError(), debugReportTrackState(), f, TrackPropagation::g4doubleToCmsDouble(), TrackPropagation::g4ErrorTrajErrToAlgebraicSymMatrix55(), generateParticleName(), GeV, TrackPropagation::globalPointToHep3Vector(), TrackPropagation::globalVectorToHep3Vector(), FreeTrajectoryState::hasError(), TrackPropagation::hep3VectorToGlobalVector(), TrackPropagation::hepPoint3DToGlobalPoint(), LogDebug, GlobalTrajectoryParameters::magneticField(), CurvilinearTrajectoryError::matrix(), ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, FreeTrajectoryState::momentum(), oppositeToMomentum, FreeTrajectoryState::parameters(), FreeTrajectoryState::position(), Propagator::propagationDirection(), theField, theG4eData, theG4eManager, and transformToG4SurfaceTarget().

Referenced by propagateWithPath().

◆ propagateWithPath() [1/4]

std::pair< TrajectoryStateOnSurface, double > Geant4ePropagator::propagateWithPath	(	const FreeTrajectoryState &	ftsStart,
		const Cylinder &	cDest
	)		const

overridevirtual

Implements Propagator.

Definition at line 419 of file Geant4ePropagator.cc.

                                                                                                               {
   // Finally build the pair<...> that needs to be returned where the second
   // parameter is the exact path length.
   return propagateGeneric(ftsStart, cDest);
 }

References propagateGeneric().

◆ propagateWithPath() [2/4]

std::pair< TrajectoryStateOnSurface, double > Geant4ePropagator::propagateWithPath	(	const FreeTrajectoryState &	ftsStart,
		const Plane &	pDest
	)		const

overridevirtual

Propagate from a free state (e.g. position and momentum in in global cartesian coordinates) to a surface. Propagate from a state on surface (e.g. position and momentum in in global cartesian coordinates associated with a layer) to a surface. The methods propagateWithPath() are identical to the corresponding methods propagate() in what concerns the resulting TrajectoryStateOnSurface, but they provide in addition the exact path length along the trajectory. All of these method calls are internally mapped to

The methods propagateWithPath() are identical to the corresponding methods propagate() in what concerns the resulting TrajectoryStateOnSurface, but they provide in addition the exact path length along the trajectory.

Implements Propagator.

Definition at line 411 of file Geant4ePropagator.cc.

                                                                                                            {
   // Finally build the pair<...> that needs to be returned where the second
   // parameter is the exact path length. Currently calculated with a stepping
   // action that adds up the length of every step
   return propagateGeneric(ftsStart, pDest);
 }

References propagateGeneric().

◆ propagateWithPath() [3/4]

std::pair< TrajectoryStateOnSurface, double > Geant4ePropagator::propagateWithPath	(	const TrajectoryStateOnSurface &	tsosStart,
		const Cylinder &	cDest
	)		const

overridevirtual

Reimplemented from Propagator.

Definition at line 434 of file Geant4ePropagator.cc.

                                                                             {
   const FreeTrajectoryState ftsStart = *tsosStart.freeState();
   // Finally build the pair<...> that needs to be returned where the second
   // parameter is the exact path length.
   return propagateGeneric(ftsStart, cDest);
 }

References TrajectoryStateOnSurface::freeState(), and propagateGeneric().

◆ propagateWithPath() [4/4]

std::pair< TrajectoryStateOnSurface, double > Geant4ePropagator::propagateWithPath	(	const TrajectoryStateOnSurface &	tsosStart,
		const Plane &	pDest
	)		const

overridevirtual

Reimplemented from Propagator.

Definition at line 426 of file Geant4ePropagator.cc.

                                                                          {
   // Finally build the pair<...> that needs to be returned where the second
   // parameter is the exact path length.
   const FreeTrajectoryState ftsStart = *tsosStart.freeState();
   return propagateGeneric(ftsStart, pDest);
 }

References TrajectoryStateOnSurface::freeState(), and propagateGeneric().

◆ transformToG4SurfaceTarget() [1/3]

template<>

Geant4ePropagator::ErrorTargetPair Geant4ePropagator::transformToG4SurfaceTarget	(	const Cylinder &	pDest,
		bool	moveTargetToEndOfSurface
	)		const

private

Definition at line 115 of file Geant4ePropagator.cc.

                                                                                                                       {
   // Get Cylinder parameters.
   // CMS uses cm and GeV while Geant4 uses mm and MeV.
   // - Radius
   G4float radCyl = pDest.radius() * cm;
   // - Position: PositionType & GlobalPoint are Basic3DPoint<float,GlobalTag>
   G4ThreeVector posCyl = TrackPropagation::globalPointToHep3Vector(pDest.position());
   // - Rotation: Type in CMSSW is RotationType == TkRotation<T>, T=float
   G4RotationMatrix rotCyl = TrackPropagation::tkRotationFToHepRotation(pDest.rotation());
  
   // DEBUG
   TkRotation<float> rotation = pDest.rotation();
   LogDebug("Geant4e") << "G4e -  TkRotation" << rotation;
   LogDebug("Geant4e") << "G4e -  G4Rotation" << rotCyl << "mm";
  
   return ErrorTargetPair(!moveTargetToEndOfSurface, std::make_shared<G4ErrorCylSurfaceTarget>(radCyl, posCyl, rotCyl));
 }

References TrackPropagation::globalPointToHep3Vector(), LogDebug, GloballyPositioned< T >::position(), Cylinder::radius(), idealTransformation::rotation, GloballyPositioned< T >::rotation(), and TrackPropagation::tkRotationFToHepRotation().

◆ transformToG4SurfaceTarget() [2/3]

template<>

Geant4ePropagator::ErrorTargetPair Geant4ePropagator::transformToG4SurfaceTarget	(	const Plane &	pDest,
		bool	moveTargetToEndOfSurface
	)		const

private

Definition at line 96 of file Geant4ePropagator.cc.

                                                                                                                       {
   //* Get position and normal (orientation) of the destination plane
   GlobalPoint posPlane = pDest.toGlobal(LocalPoint(0, 0, 0));
   GlobalVector normalPlane = pDest.toGlobal(LocalVector(0, 0, 1.));
   normalPlane = normalPlane.unit();
  
   //* Transform this into HepGeom::Point3D<double>  and
   // HepGeom::Normal3D<double>  that define a plane for
   //  Geant4e.
   //  CMS uses cm and GeV while Geant4 uses mm and MeV
   HepGeom::Point3D<double> surfPos = TrackPropagation::globalPointToHepPoint3D(posPlane);
   HepGeom::Normal3D<double> surfNorm = TrackPropagation::globalVectorToHepNormal3D(normalPlane);
  
   //* Set the target surface
   return ErrorTargetPair(false, std::make_shared<G4ErrorPlaneSurfaceTarget>(surfNorm, surfPos));
 }

References TrackPropagation::globalPointToHepPoint3D(), TrackPropagation::globalVectorToHepNormal3D(), Surface::toGlobal(), and Vector3DBase< T, FrameTag >::unit().

◆ transformToG4SurfaceTarget() [3/3]

template<class SurfaceType >

ErrorTargetPair Geant4ePropagator::transformToG4SurfaceTarget	(	const SurfaceType &	pDest,
		bool	moveTargetToEndOfSurface
	)		const

private

Referenced by propagateGeneric().

Member Data Documentation

◆ theField

const MagneticField* Geant4ePropagator::theField

private

Definition at line 86 of file Geant4ePropagator.h.

Referenced by magneticField(), and propagateGeneric().

◆ theG4eData

G4ErrorPropagatorData* Geant4ePropagator::theG4eData

private

Definition at line 93 of file Geant4ePropagator.h.

Referenced by propagateGeneric().

◆ theG4eManager

G4ErrorPropagatorManager* Geant4ePropagator::theG4eManager

private

Definition at line 92 of file Geant4ePropagator.h.

Referenced by ensureGeant4eIsInitilized(), and propagateGeneric().

◆ theParticleName

std::string Geant4ePropagator::theParticleName

private

Definition at line 89 of file Geant4ePropagator.h.

Referenced by generateParticleName().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ErrorTargetPair

◆ TsosPP

Constructor & Destructor Documentation

◆ Geant4ePropagator()

◆ ~Geant4ePropagator()

Member Function Documentation

◆ clone()

◆ configureAnyPropagation() [1/3]

◆ configureAnyPropagation() [2/3]

◆ configureAnyPropagation() [3/3]

◆ configurePropagation()

◆ debugReportPlaneSetup()

◆ debugReportTrackState()

◆ ensureGeant4eIsInitilized()

◆ generateParticleName()

◆ getSurfaceType() [1/3]

◆ getSurfaceType() [2/3]

◆ getSurfaceType() [3/3]

◆ magneticField()

◆ propagateGeneric()

◆ propagateWithPath() [1/4]

◆ propagateWithPath() [2/4]

◆ propagateWithPath() [3/4]

◆ propagateWithPath() [4/4]

◆ transformToG4SurfaceTarget() [1/3]

◆ transformToG4SurfaceTarget() [2/3]

◆ transformToG4SurfaceTarget() [3/3]

Member Data Documentation

◆ theField

◆ theG4eData

◆ theG4eManager

◆ theParticleName