#include <Geant4ePropagator.h>

Inheritance diagram for Geant4ePropagator:

Public Member Functions
virtual 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)

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

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

virtual const MagneticField *	magneticField () const override

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

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

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

virtual 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

virtual	~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
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 83 of file Geant4ePropagator.h.

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

private

Definition at line 82 of file Geant4ePropagator.h.

Constructor & Destructor Documentation

Geant4ePropagator::Geant4ePropagator	(	const MagneticField *	field = `0`,
		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 40 of file Geant4ePropagator.cc.

References ensureGeant4eIsInitilized(), and LogDebug.

Referenced by clone().

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

Geant4ePropagator::~Geant4ePropagator ( )

overridevirtual

Destructor.

Definition at line 56 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

virtual Geant4ePropagator* Geant4ePropagator::clone ( void ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 72 of file Geant4ePropagator.h.

References Geant4ePropagator().

                                                       {
         return new Geant4ePropagator(*this);
     }

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

References Plane::localZ(), and LogDebug.

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

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

 {
     //------------------------------------
     //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 224 of file Geant4ePropagator.cc.

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

Referenced by propagateGeneric().

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

References Geom::Phi< T >::degrees(), 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 535 of file Geant4ePropagator.cc.

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

Referenced by propagateGeneric().

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

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 72 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;
     }
 
     // example code uses
     // G4UImanager::GetUIpointer()->ApplyCommand("/geant4e/limits/stepLength 100 mm");
     G4UImanager::GetUIpointer()->ApplyCommand(
             "/geant4e/limits/stepLength 10.0 mm");
 }

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

private

Definition at line 162 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<class SurfaceType >

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

private

template<>

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

Definition at line 151 of file Geant4ePropagator.cc.

 {
     return "Cylinder";
 }

template<>

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

Definition at line 157 of file Geant4ePropagator.cc.

 {
     return "Plane";
 }

virtual const MagneticField* Geant4ePropagator::magneticField ( ) const

inlineoverridevirtual

Implements Propagator.

Definition at line 76 of file Geant4ePropagator.h.

References theField.

                                                                 {
         return theField;
     }

template<class SurfaceType >

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

private

Definition at line 253 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();
 
     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);
 }

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 475 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 485 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 493 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 503 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<class SurfaceType >

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

private

Referenced by propagateGeneric().

template<>

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

Definition at line 104 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<>

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

Definition at line 126 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));
 }