#include <Geant4ePropagator.h>

Inheritance diagram for Geant4ePropagator:

Public Member Functions
Geant4ePropagator *	clone () const override

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

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

	Geant4ePropagator (const MagneticField *field=0, std::string particleName="mu", PropagationDirection dir=alongMomentum, double plimit=1.0)

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

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

const MagneticField *	magneticField () const override

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

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

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

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

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

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

	~Geant4ePropagator () override

Public Member Functions inherited from Propagator
template<typename STA , typename SUR >
TrajectoryStateOnSurface	propagate (STA const &state, SUR const &surface) const

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

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

virtual std::pair< TrajectoryStateOnSurface, double >	propagateWithPath (const TrajectoryStateOnSurface &tsos, const Surface &sur) 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 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<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<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<class SurfaceType >
ErrorTargetPair	transformToG4SurfaceTarget (const SurfaceType &pDest, bool moveTargetToEndOfSurface) const

Private Attributes
double	plimit_

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

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

private

Definition at line 84 of file Geant4ePropagator.h.

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

private

Definition at line 83 of file Geant4ePropagator.h.

Constructor & Destructor Documentation

Geant4ePropagator::Geant4ePropagator	(	const MagneticField *	field = `0`,
		std::string	particleName = `"mu"`,
		PropagationDirection	dir = `alongMomentum`,
		double	plimit = `1.0`
	)

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 40 of file Geant4ePropagator.cc.

References ensureGeant4eIsInitilized(), and LogDebug.

Referenced by clone().

     : Propagator(dir),
       theField(field),
       theParticleName(particleName),
       theG4eManager(G4ErrorPropagatorManager::GetErrorPropagatorManager()),
       theG4eData(G4ErrorPropagatorData::GetErrorPropagatorData()),
       plimit_(plimit) {
   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);
 }

Geant4ePropagator::~Geant4ePropagator ( )

override

Destructor.

Definition at line 59 of file Geant4ePropagator.cc.

References LogDebug.

                                       {
   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
 }

Member Function Documentation

Geant4ePropagator* Geant4ePropagator::clone ( void ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 78 of file Geant4ePropagator.h.

References Geant4ePropagator().

78 { return new Geant4ePropagator(*this); }

Geant4ePropagator::Geant4ePropagator

Geant4ePropagator(const MagneticField *field=0, std::string particleName="mu", PropagationDirection dir=alongMomentum, double plimit=1.0)

Definition: Geant4ePropagator.cc:40

template<class SurfaceType >

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

private

Referenced by configurePropagation().

template<>

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

Definition at line 162 of file Geant4ePropagator.cc.

References Plane::localZ(), LogDebug, PV3DBase< T, PVType, FrameType >::mag(), and plimit_.

                                                                                       {
   if (cmsInitMom.mag() < plimit_)
     return false;
   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;
 }

template<>

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

Definition at line 184 of file Geant4ePropagator.cc.

References LogDebug, PV3DBase< T, PVType, FrameType >::mag(), plimit_, SurfaceOrientation::positiveSide, Cylinder::side(), and GloballyPositioned< T >::toLocal().

                                                                                       {
   if (cmsInitMom.mag() < plimit_)
     return false;
   //------------------------------------
   // 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;
 }

template<class SurfaceType >

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

private

Definition at line 209 of file Geant4ePropagator.cc.

References alongMomentum, anyDirection, configureAnyPropagation(), LogDebug, PV3DBase< T, PVType, FrameType >::mag(), oppositeToMomentum, plimit_, and Propagator::propagationDirection().

Referenced by propagateGeneric().

                                                                                    {
   if (cmsInitMom.mag() < plimit_)
     return false;
   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;
 }

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 457 of file Geant4ePropagator.cc.

References PV3DBase< T, PVType, FrameType >::eta(), Plane::localZ(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), and PV3DBase< T, PVType, FrameType >::phi().

                                                                         {
   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";
 }

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 473 of file Geant4ePropagator.cc.

References PV3DBase< T, PVType, FrameType >::eta(), LogDebug, PV3DBase< T, PVType, FrameType >::perp(), and PV3DBase< T, PVType, FrameType >::phi().

Referenced by propagateGeneric().

                                                                               {
   LogDebug("Geant4e") << "G4e - 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";
 }

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 75 of file Geant4ePropagator.cc.

References LogDebug, and theG4eManager.

Referenced by Geant4ePropagator().

                                                                       {
   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;
   }
   // define 10 mm step limit for propagator
   G4UImanager::GetUIpointer()->ApplyCommand("/geant4e/limits/stepLength 10.0 mm");
 }

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

private

Definition at line 146 of file Geant4ePropagator.cc.

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

Referenced by propagateGeneric().

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

template<>

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

Definition at line 137 of file Geant4ePropagator.cc.

                                                                    {
   return "Cylinder";
 }

template<>

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

Definition at line 142 of file Geant4ePropagator.cc.

                                                                 {
   return "Plane";
 }

template<class SurfaceType >

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

private

const MagneticField* Geant4ePropagator::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 80 of file Geant4ePropagator.h.

References theField.

80 { return theField; }

Geant4ePropagator::theField

const MagneticField * theField

Definition: Geant4ePropagator.h:87

template<class SurfaceType >

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

private

Definition at line 232 of file Geant4ePropagator.cc.

References SurfaceSideDefinition::afterSurface, TrackPropagation::algebraicSymMatrix55ToG4ErrorTrajErr(), alongMomentum, SurfaceSideDefinition::beforeSurface, GlobalTrajectoryParameters::charge(), FreeTrajectoryState::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().

                                                                                                                 {
   // 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();
 
   // re-initialize navigator to avoid mismatches and/or segfaults
   theG4eManager->GetErrorPropagationNavigator()->LocateGlobalPointAndSetup(
       g4InitPos, &g4InitMom, /*pRelativeSearch = */ false, /*ignoreDirection = */ false);
 
   bool continuePropagation = true;
   while (continuePropagation) {
     iterations++;
     LogDebug("Geant4e") << std::endl << "step count " << iterations << " step length " << finalPathLength;
 
     // re-initialize navigator to avoid mismatches and/or segfaults
     theG4eManager->GetErrorPropagationNavigator()->LocateGlobalPointWithinVolume(g4eTrajState.GetPosition());
 
     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);
 }

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 426 of file Geant4ePropagator.cc.

References propagateGeneric().

                                                                                                            {
   // 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);
 }

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

overridevirtual

Implements Propagator.

Definition at line 434 of file Geant4ePropagator.cc.

References propagateGeneric().

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

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

overridevirtual

Reimplemented from Propagator.

Definition at line 441 of file Geant4ePropagator.cc.

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

                                                                          {
   // 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);
 }

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

overridevirtual

Reimplemented from Propagator.

Definition at line 449 of file Geant4ePropagator.cc.

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

                                                                             {
   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);
 }

template<>

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

Definition at line 98 of file Geant4ePropagator.cc.

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

                                                                                                                       {
   //* 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));
 }

template<class SurfaceType >

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

private

Referenced by propagateGeneric().

template<>

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

Definition at line 117 of file Geant4ePropagator.cc.

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

                                                                                                                       {
   // 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));
 }