SeedFromNuclearInteraction Class Reference

#include <SeedFromNuclearInteraction.h>

Public Member Functions
PropagationDirection	direction () const
recHitContainer	hits () const
const TSOS &	initialTSOS () const
bool	isValid () const
ConstRecHitPointer	outerHit () const
DetId	outerHitDetId () const
GlobalPoint	outerHitPosition () const
AlgebraicMatrix33	rotationMatrix (const GlobalVector &perp) const
	SeedFromNuclearInteraction (const Propagator *prop, const TrackerGeometry *geom, const edm::ParameterSet &iConfig)
void	setMeasurements (const TSOS &tsosAtInteractionPoint, ConstRecHitPointer ihit, ConstRecHitPointer ohit)
	Fill all data members from 2 TM's where the first one is supposed to be at the interaction point. More...
void	setMeasurements (TangentHelix &primHelix, const TSOS &inner_TSOS, ConstRecHitPointer ihit, ConstRecHitPointer ohit)
	Fill all data members from 1 TSOS and 2 rec Hits and using the circle associated to the primary track as constraint. More...
FreeTrajectoryState *	stateWithError () const
FreeTrajectoryState *	stateWithError (TangentHelix &helix) const
PTrajectoryStateOnDet const &	trajectoryState () const
TrajectorySeed	TrajSeed () const
const TSOS &	updatedTSOS () const
virtual	~SeedFromNuclearInteraction ()

Private Types
typedef std::vector< ConstRecHitPointer >	ConstRecHitContainer
typedef TransientTrackingRecHit::ConstRecHitPointer	ConstRecHitPointer
typedef edm::OwnVector< TrackingRecHit >	recHitContainer
typedef TrajectoryMeasurement	TM
typedef TrajectoryStateOnSurface	TSOS

Private Member Functions
bool	construct ()

Private Attributes
std::shared_ptr< FreeTrajectoryState >	freeTS_
std::shared_ptr< TSOS >	initialTSOS_
ConstRecHitPointer	innerHit_
bool	isValid_
ConstRecHitPointer	outerHit_
double	ptMin
PTrajectoryStateOnDet	pTraj
ConstRecHitContainer	theHits
const Propagator *	thePropagator
const TrackerGeometry *	theTrackerGeom
std::shared_ptr< TSOS >	updatedTSOS_

Detailed Description

Definition at line 19 of file SeedFromNuclearInteraction.h.

Member Typedef Documentation

ConstRecHitContainer

typedef std::vector<ConstRecHitPointer> SeedFromNuclearInteraction::ConstRecHitContainer

private

Definition at line 25 of file SeedFromNuclearInteraction.h.

ConstRecHitPointer

typedef TransientTrackingRecHit::ConstRecHitPointer SeedFromNuclearInteraction::ConstRecHitPointer

private

Definition at line 24 of file SeedFromNuclearInteraction.h.

recHitContainer

typedef edm::OwnVector<TrackingRecHit> SeedFromNuclearInteraction::recHitContainer

private

Definition at line 23 of file SeedFromNuclearInteraction.h.

TM

typedef TrajectoryMeasurement SeedFromNuclearInteraction::TM

private

Definition at line 21 of file SeedFromNuclearInteraction.h.

TSOS

typedef TrajectoryStateOnSurface SeedFromNuclearInteraction::TSOS

private

Definition at line 22 of file SeedFromNuclearInteraction.h.

Constructor & Destructor Documentation

SeedFromNuclearInteraction()

SeedFromNuclearInteraction::SeedFromNuclearInteraction	(	const Propagator *	prop,
		const TrackerGeometry *	geom,
		const edm::ParameterSet &	iConfig
	)

Definition at line 14 of file SeedFromNuclearInteraction.cc.

    : ptMin(iConfig.getParameter<double>("ptMin")), thePropagator(prop), theTrackerGeom(geom) {
  isValid_ = true;
  initialTSOS_ = std::make_shared<TrajectoryStateOnSurface>();
  updatedTSOS_ = std::make_shared<TrajectoryStateOnSurface>();
  freeTS_ = std::make_shared<FreeTrajectoryState>();
}

References freeTS_, initialTSOS_, isValid_, and updatedTSOS_.

~SeedFromNuclearInteraction()

virtual SeedFromNuclearInteraction::~SeedFromNuclearInteraction ( )

inlinevirtual

Definition at line 30 of file SeedFromNuclearInteraction.h.

{}

Member Function Documentation

construct()

bool SeedFromNuclearInteraction::construct ( )

private

Definition at line 133 of file SeedFromNuclearInteraction.cc.

                                           {
  // loop on all hits in theHits
  KFUpdator theUpdator;
 
  const TrackingRecHit* hit = nullptr;
 
  LogDebug("NuclearSeedGenerator") << "Seed ** initial state " << freeTS_->cartesianError().matrix();
 
  for (unsigned int iHit = 0; iHit < theHits.size(); iHit++) {
    hit = theHits[iHit]->hit();
    TrajectoryStateOnSurface state =
        (iHit == 0)
            ? thePropagator->propagate(*freeTS_, theTrackerGeom->idToDet(hit->geographicalId())->surface())
            : thePropagator->propagate(*updatedTSOS_, theTrackerGeom->idToDet(hit->geographicalId())->surface());
 
    if (!state.isValid())
      return false;
 
    const TransientTrackingRecHit::ConstRecHitPointer& tth = theHits[iHit];
    updatedTSOS_.reset(new TrajectoryStateOnSurface(theUpdator.update(state, *tth)));
  }
 
  LogDebug("NuclearSeedGenerator") << "Seed ** updated state " << updatedTSOS_->cartesianError().matrix();
 
  pTraj = trajectoryStateTransform::persistentState(*updatedTSOS_, outerHitDetId().rawId());
  return true;
}

References freeTS_, TrackerGeometry::idToDet(), TrajectoryStateOnSurface::isValid(), LogDebug, outerHitDetId(), trajectoryStateTransform::persistentState(), Propagator::propagate(), pTraj, theHits, thePropagator, theTrackerGeom, KFUpdator::update(), and updatedTSOS_.

Referenced by setMeasurements().

direction()

PropagationDirection SeedFromNuclearInteraction::direction ( ) const

inline

Definition at line 47 of file SeedFromNuclearInteraction.h.

{ return alongMomentum; }

References alongMomentum.

Referenced by stateWithError(), and TrajSeed().

hits()

edm::OwnVector< TrackingRecHit > SeedFromNuclearInteraction::hits

(

void

)

const

Definition at line 162 of file SeedFromNuclearInteraction.cc.

                                                                    {
  recHitContainer _hits;
  for (ConstRecHitContainer::const_iterator it = theHits.begin(); it != theHits.end(); it++) {
    _hits.push_back(it->get()->hit()->clone());
  }
  return _hits;
}

References edm::OwnVector< T, P >::push_back(), and theHits.

Referenced by TrajSeed().

initialTSOS()

const TSOS& SeedFromNuclearInteraction::initialTSOS ( ) const

inline

Definition at line 57 of file SeedFromNuclearInteraction.h.

{ return *initialTSOS_; }

References initialTSOS_.

isValid()

bool SeedFromNuclearInteraction::isValid ( void  ) const

inline

Definition at line 53 of file SeedFromNuclearInteraction.h.

{ return isValid_; }

References isValid_.

Referenced by ntupleDataFormat._Object::_checkIsValid(), and core.AutoHandle.AutoHandle::ReallyLoad().

outerHit()

ConstRecHitPointer SeedFromNuclearInteraction::outerHit ( ) const

inline

Definition at line 65 of file SeedFromNuclearInteraction.h.

{ return outerHit_; }

References outerHit_.

outerHitDetId()

DetId SeedFromNuclearInteraction::outerHitDetId ( ) const

inline

Definition at line 63 of file SeedFromNuclearInteraction.h.

{ return outerHit_->geographicalId(); }

References outerHit_.

Referenced by construct(), and outerHitPosition().

outerHitPosition()

GlobalPoint SeedFromNuclearInteraction::outerHitPosition ( ) const

inline

Definition at line 59 of file SeedFromNuclearInteraction.h.

                                       {
    return theTrackerGeom->idToDet(outerHitDetId())->surface().toGlobal(outerHit_->localPosition());
  }

References TrackerGeometry::idToDet(), outerHit_, outerHitDetId(), GeomDet::surface(), theTrackerGeom, and Surface::toGlobal().

Referenced by stateWithError().

rotationMatrix()

AlgebraicMatrix33 SeedFromNuclearInteraction::rotationMatrix

(

const GlobalVector &

perp

)

const

Return the rotation matrix to be applied to get parameters in a framework where the z direction is along perp

Definition at line 170 of file SeedFromNuclearInteraction.cc.

                                                                                           {
  AlgebraicMatrix33 result;
 
  // z axis coincides with perp
  GlobalVector zAxis = perp.unit();
 
  // x axis has no global Z component
  GlobalVector xAxis;
  if (zAxis.x() != 0 || zAxis.y() != 0) {
    // precision is not an issue here, just protect against divizion by zero
    xAxis = GlobalVector(-zAxis.y(), zAxis.x(), 0).unit();
  } else {  // perp coincides with global Z
    xAxis = GlobalVector(1, 0, 0);
  }
 
  // y axis obtained by cross product
  GlobalVector yAxis(zAxis.cross(xAxis));
 
  result(0, 0) = xAxis.x();
  result(0, 1) = xAxis.y();
  result(0, 2) = xAxis.z();
  result(1, 0) = yAxis.x();
  result(1, 1) = yAxis.y();
  result(1, 2) = yAxis.z();
  result(2, 0) = zAxis.x();
  result(2, 1) = zAxis.y();
  result(2, 2) = zAxis.z();
  return result;
}

References perp(), mps_fire::result, unit(), HLT_2018_cff::xAxis, HLT_2018_cff::yAxis, and HLT_2018_cff::zAxis.

Referenced by stateWithError().

setMeasurements() [1/2]

void SeedFromNuclearInteraction::setMeasurements	(	const TSOS &	tsosAtInteractionPoint,
		ConstRecHitPointer	ihit,
		ConstRecHitPointer	ohit
	)

Fill all data members from 2 TM's where the first one is supposed to be at the interaction point.

Definition at line 25 of file SeedFromNuclearInteraction.cc.

                                                                          {
  // delete pointer to TrackingRecHits
  theHits.clear();
 
  // get the inner and outer transient TrackingRecHits
  innerHit_ = ihit;
  outerHit_ = ohit;
 
  //theHits.push_back(  inner_TM.recHit() ); // put temporarily - TODO: remove this line
  theHits.push_back(outerHit_);
 
  initialTSOS_.reset(new TrajectoryStateOnSurface(inner_TSOS));
 
  // calculate the initial FreeTrajectoryState.
  freeTS_.reset(stateWithError());
 
  // check transverse momentum
  if (freeTS_->momentum().perp() < ptMin) {
    isValid_ = false;
  } else {
    // convert freeTS_ into a persistent TSOS on the outer surface
    isValid_ = construct();
  }
}

References construct(), freeTS_, initialTSOS_, innerHit_, isValid_, outerHit_, ptMin, stateWithError(), and theHits.

Referenced by NuclearInteractionFinder::fillSeeds(), and NuclearInteractionFinder::improveSeeds().

setMeasurements() [2/2]

void SeedFromNuclearInteraction::setMeasurements	(	TangentHelix &	primHelix,
		const TSOS &	inner_TSOS,
		ConstRecHitPointer	ihit,
		ConstRecHitPointer	ohit
	)

Fill all data members from 1 TSOS and 2 rec Hits and using the circle associated to the primary track as constraint.

Definition at line 52 of file SeedFromNuclearInteraction.cc.

                                                                          {
  // delete pointer to TrackingRecHits
  theHits.clear();
 
  // get the inner and outer transient TrackingRecHits
  innerHit_ = ihit;
  outerHit_ = ohit;
 
  GlobalPoint innerPos =
      theTrackerGeom->idToDet(innerHit_->geographicalId())->surface().toGlobal(innerHit_->localPosition());
  GlobalPoint outerPos =
      theTrackerGeom->idToDet(outerHit_->geographicalId())->surface().toGlobal(outerHit_->localPosition());
 
  TangentHelix helix(thePrimaryHelix, outerPos, innerPos);
 
  theHits.push_back(innerHit_);
  theHits.push_back(outerHit_);
 
  initialTSOS_.reset(new TrajectoryStateOnSurface(inner_TSOS));
 
  // calculate the initial FreeTrajectoryState from the inner and outer TM assuming that the helix equation is already known.
  freeTS_.reset(stateWithError(helix));
 
  if (freeTS_->momentum().perp() < ptMin) {
    isValid_ = false;
  } else {
    // convert freeTS_ into a persistent TSOS on the outer surface
    isValid_ = construct();
  }
}

References construct(), freeTS_, TrackerGeometry::idToDet(), initialTSOS_, innerHit_, isValid_, outerHit_, ptMin, stateWithError(), theHits, theTrackerGeom, and GeomDet::toGlobal().

stateWithError() [1/2]

FreeTrajectoryState * SeedFromNuclearInteraction::stateWithError

(

)

const

Definition at line 86 of file SeedFromNuclearInteraction.cc.

                                                                      {
  // Calculation of the helix assuming that the secondary track has the same direction
  // than the primary track and pass through the inner and outer hits.
  GlobalVector direction = initialTSOS_->globalDirection();
  GlobalPoint inner = initialTSOS_->globalPosition();
  TangentHelix helix(direction, inner, outerHitPosition());
 
  return stateWithError(helix);
}

References direction(), initialTSOS_, SurfaceOrientation::inner, and outerHitPosition().

Referenced by setMeasurements().

stateWithError() [2/2]

FreeTrajectoryState * SeedFromNuclearInteraction::stateWithError

(

TangentHelix &

helix

)

const

Definition at line 96 of file SeedFromNuclearInteraction.cc.

                                                                                         {
  //   typedef TkRotation<float> Rotation;
 
  GlobalVector dirAtVtx = helix.directionAtVertex();
  const MagneticField& mag = initialTSOS_->globalParameters().magneticField();
 
  // Get the global parameters of the trajectory
  // we assume that the magnetic field at the vertex is equal to the magnetic field at the inner TM.
  GlobalTrajectoryParameters gtp(
      helix.vertexPoint(), dirAtVtx, helix.charge(mag.inTesla(helix.vertexPoint()).z()) / helix.rho(), 0, &mag);
 
  // Error matrix in a frame where z is in the direction of the track at the vertex
  AlgebraicSymMatrix66 primaryError(initialTSOS_->cartesianError().matrix());
  double p_max = initialTSOS_->globalParameters().momentum().mag();
  AlgebraicMatrix33 rot = this->rotationMatrix(dirAtVtx);
 
  AlgebraicMatrix66 globalRotation;
  globalRotation.Place_at(rot, 0, 0);
  globalRotation.Place_at(rot, 3, 3);
  AlgebraicSymMatrix66 primaryErrorInNewFrame = ROOT::Math::Similarity(globalRotation, primaryError);
 
  AlgebraicSymMatrix66 secondaryErrorInNewFrame = AlgebraicMatrixID();
  double p_perp_max = 2;  // energy max of a secondary track emited perpendicularly to the
                          // primary track is +/- 2 GeV
  secondaryErrorInNewFrame(0, 0) = primaryErrorInNewFrame(0, 0) + helix.vertexError() * p_perp_max / p_max;
  secondaryErrorInNewFrame(1, 1) = primaryErrorInNewFrame(1, 1) + helix.vertexError() * p_perp_max / p_max;
  secondaryErrorInNewFrame(2, 2) = helix.vertexError() * helix.vertexError();
  secondaryErrorInNewFrame(3, 3) = p_perp_max * p_perp_max;
  secondaryErrorInNewFrame(4, 4) = p_perp_max * p_perp_max;
  secondaryErrorInNewFrame(5, 5) = p_max * p_max;
 
  AlgebraicSymMatrix66 secondaryError = ROOT::Math::SimilarityT(globalRotation, secondaryErrorInNewFrame);
 
  return new FreeTrajectoryState(gtp, CartesianTrajectoryError(secondaryError));
}

References TangentHelix::charge(), TangentHelix::directionAtVertex(), initialTSOS_, mag(), TangentHelix::rho(), makeMuonMisalignmentScenario::rot, rotationMatrix(), TangentHelix::vertexError(), TangentHelix::vertexPoint(), and z.

trajectoryState()

PTrajectoryStateOnDet const& SeedFromNuclearInteraction::trajectoryState ( ) const

inline

Definition at line 41 of file SeedFromNuclearInteraction.h.

{ return pTraj; }

References pTraj.

Referenced by TrajSeed().

TrajSeed()

TrajectorySeed SeedFromNuclearInteraction::TrajSeed ( ) const

inline

Definition at line 51 of file SeedFromNuclearInteraction.h.

{ return TrajectorySeed(trajectoryState(), hits(), direction()); }

References direction(), hits(), and trajectoryState().

updatedTSOS()

const TSOS& SeedFromNuclearInteraction::updatedTSOS ( ) const

inline

Definition at line 55 of file SeedFromNuclearInteraction.h.

{ return *updatedTSOS_; }

References updatedTSOS_.

Member Data Documentation

freeTS_

std::shared_ptr<FreeTrajectoryState> SeedFromNuclearInteraction::freeTS_

private

Initial FreeTrajectoryState

Definition at line 84 of file SeedFromNuclearInteraction.h.

Referenced by construct(), SeedFromNuclearInteraction(), and setMeasurements().

initialTSOS_

std::shared_ptr<TSOS> SeedFromNuclearInteraction::initialTSOS_

private

Initial TSOS used as input

Definition at line 82 of file SeedFromNuclearInteraction.h.

Referenced by initialTSOS(), SeedFromNuclearInteraction(), setMeasurements(), and stateWithError().

innerHit_

ConstRecHitPointer SeedFromNuclearInteraction::innerHit_

private

Pointer to the hit of the inner TM

Definition at line 77 of file SeedFromNuclearInteraction.h.

Referenced by setMeasurements().

isValid_

bool SeedFromNuclearInteraction::isValid_

private

check if the seed is valid

Definition at line 72 of file SeedFromNuclearInteraction.h.

Referenced by isValid(), SeedFromNuclearInteraction(), and setMeasurements().

outerHit_

ConstRecHitPointer SeedFromNuclearInteraction::outerHit_

private

Pointer to the outer hit

Definition at line 78 of file SeedFromNuclearInteraction.h.

Referenced by outerHit(), outerHitDetId(), outerHitPosition(), and setMeasurements().

ptMin

double SeedFromNuclearInteraction::ptMin

private

Minimum transverse momentum of the seed

Definition at line 90 of file SeedFromNuclearInteraction.h.

Referenced by setMeasurements().

pTraj

PTrajectoryStateOnDet SeedFromNuclearInteraction::pTraj

private

the final persistent TSOS

Definition at line 86 of file SeedFromNuclearInteraction.h.

Referenced by construct(), and trajectoryState().

theHits

ConstRecHitContainer SeedFromNuclearInteraction::theHits

private

all the hits to be used to update the

Definition at line 74 of file SeedFromNuclearInteraction.h.

Referenced by construct(), hits(), and setMeasurements().

thePropagator

const Propagator* SeedFromNuclearInteraction::thePropagator

private

Definition at line 92 of file SeedFromNuclearInteraction.h.

Referenced by construct().

theTrackerGeom

const TrackerGeometry* SeedFromNuclearInteraction::theTrackerGeom

private

Definition at line 93 of file SeedFromNuclearInteraction.h.

Referenced by construct(), outerHitPosition(), and setMeasurements().

updatedTSOS_

std::shared_ptr<TSOS> SeedFromNuclearInteraction::updatedTSOS_

private

Final TSOS

Definition at line 80 of file SeedFromNuclearInteraction.h.

Referenced by construct(), SeedFromNuclearInteraction(), and updatedTSOS().