#include <SeedFromConsecutiveHitsCreator.h>

Inheritance diagram for SeedFromConsecutiveHitsCreator:

Public Member Functions
void	init (const TrackingRegion &region, const edm::EventSetup &es, const SeedComparitor *filter) final

void	makeSeed (TrajectorySeedCollection &seedCollection, const SeedingHitSet &hits) final

	SeedFromConsecutiveHitsCreator (const edm::ParameterSet &, edm::ConsumesCollector &&)

	~SeedFromConsecutiveHitsCreator () override

Public Member Functions inherited from SeedCreator
virtual	~SeedCreator ()

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &desc)

static const char *	fillDescriptionsLabel ()

Protected Attributes
TkClonerImpl	cloner

const SeedComparitor *	filter = nullptr

bool	forceKinematicWithRegionDirection_

bool	isBOFF = false

MagneticField const *	magneticField_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldESToken_

std::string	mfName_

float	nomField

Propagator const *	propagator_

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagatorESToken_

const TrackingRegion *	region = nullptr

float	theBOFFMomentum

float	theMinOneOverPtError

float	theOriginTransverseErrorMultiplier

std::string	thePropagatorLabel

TrackerGeometry const *	trackerGeometry_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	trackerGeometryESToken_

const edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	transientTrackingRecHitBuilderESToken_

std::string	TTRHBuilder

Private Member Functions
void	buildSeed (TrajectorySeedCollection &seedCollection, const SeedingHitSet &hits, const FreeTrajectoryState &fts) const

bool	checkHit (const TrajectoryStateOnSurface &tsos, SeedingHitSet::ConstRecHitPointer hit) const

CurvilinearTrajectoryError	initialError (float sin2Theta) const

virtual bool	initialKinematic (GlobalTrajectoryParameters &kine, const SeedingHitSet &hits) const

SeedingHitSet::RecHitPointer	refitHit (SeedingHitSet::ConstRecHitPointer hit, const TrajectoryStateOnSurface &state) const

Detailed Description

Definition at line 25 of file SeedFromConsecutiveHitsCreator.h.

Constructor & Destructor Documentation

◆ SeedFromConsecutiveHitsCreator()

SeedFromConsecutiveHitsCreator::SeedFromConsecutiveHitsCreator	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

Definition at line 26 of file SeedFromConsecutiveHitsCreator.cc.

     : thePropagatorLabel(cfg.getParameter<std::string>("propagator")),
       theBOFFMomentum(cfg.getParameter<double>("SeedMomentumForBOFF")),
       theOriginTransverseErrorMultiplier(cfg.getParameter<double>("OriginTransverseErrorMultiplier")),
       theMinOneOverPtError(cfg.getParameter<double>("MinOneOverPtError")),
       TTRHBuilder(cfg.getParameter<std::string>("TTRHBuilder")),
       mfName_(cfg.getParameter<std::string>("magneticField")),
       forceKinematicWithRegionDirection_(cfg.getParameter<bool>("forceKinematicWithRegionDirection")),
       trackerGeometryESToken_(iC.esConsumes()),
       propagatorESToken_(iC.esConsumes(edm::ESInputTag("", thePropagatorLabel))),
       magneticFieldESToken_(iC.esConsumes(edm::ESInputTag("", mfName_))),
       transientTrackingRecHitBuilderESToken_(iC.esConsumes(edm::ESInputTag("", TTRHBuilder))) {}

◆ ~SeedFromConsecutiveHitsCreator()

SeedFromConsecutiveHitsCreator::~SeedFromConsecutiveHitsCreator ( )

override

Definition at line 40 of file SeedFromConsecutiveHitsCreator.cc.

40 {}

Member Function Documentation

◆ buildSeed()

void SeedFromConsecutiveHitsCreator::buildSeed	(	TrajectorySeedCollection &	seedCollection,
		const SeedingHitSet &	hits,
		const FreeTrajectoryState &	fts
	)		const

private

Definition at line 159 of file SeedFromConsecutiveHitsCreator.cc.

References alongMomentum, checkHit(), hfClusterShapes_cfi::hits, TrackerGeometry::idToDet(), TrajectoryStateOnSurface::isValid(), eostools::move(), trajectoryStateTransform::persistentState(), Propagator::propagate(), propagator_, edm::OwnVector< T, P >::push_back(), refitHit(), ElectronSeedTrackRefFix_cfi::seedCollection, trackerGeometry_, and HLT_2024v11_cff::updator.

Referenced by makeSeed().

                                                                                      {
   // get updator
   KFUpdator updator;
 
   // Now update initial state track using information from seed hits.
 
   TrajectoryStateOnSurface updatedState;
   edm::OwnVector<TrackingRecHit> seedHits;
 
   const TrackingRecHit* hit = nullptr;
   for (unsigned int iHit = 0; iHit < hits.size(); iHit++) {
     hit = hits[iHit]->hit();
     TrajectoryStateOnSurface state =
         (iHit == 0) ? propagator_->propagate(fts, trackerGeometry_->idToDet(hit->geographicalId())->surface())
                     : propagator_->propagate(updatedState, trackerGeometry_->idToDet(hit->geographicalId())->surface());
     if (!state.isValid())
       return;
 
     SeedingHitSet::ConstRecHitPointer tth = hits[iHit];
 
     std::unique_ptr<BaseTrackerRecHit> newtth(refitHit(tth, state));
 
     if (!checkHit(state, &*newtth))
       return;
 
     updatedState = updator.update(state, *newtth);
     if (!updatedState.isValid())
       return;
 
     seedHits.push_back(newtth.release());
   }
 
   if (!hit)
     return;
 
   PTrajectoryStateOnDet const& PTraj =
       trajectoryStateTransform::persistentState(updatedState, hit->geographicalId().rawId());
   seedCollection.emplace_back(PTraj, std::move(seedHits), alongMomentum);
 }

◆ checkHit()

bool SeedFromConsecutiveHitsCreator::checkHit	(	const TrajectoryStateOnSurface &	tsos,
		SeedingHitSet::ConstRecHitPointer	hit
	)		const

private

Definition at line 206 of file SeedFromConsecutiveHitsCreator.cc.

References SeedComparitor::compatible(), and filter.

Referenced by buildSeed().

                                                                                          {
   return (filter ? filter->compatible(tsos, hit) : true);
 }

◆ fillDescriptions()

void SeedFromConsecutiveHitsCreator::fillDescriptions ( edm::ParameterSetDescription & desc )

static

Definition at line 42 of file SeedFromConsecutiveHitsCreator.cc.

References submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by SeedFromConsecutiveHitsTripletOnlyCreator::fillDescriptions().

                                                                                       {
   desc.add<std::string>("propagator", "PropagatorWithMaterialParabolicMf");
   desc.add<double>("SeedMomentumForBOFF", 5.0);
   desc.add<double>("OriginTransverseErrorMultiplier", 1.0);
   desc.add<double>("MinOneOverPtError", 1.0);
   desc.add<std::string>("TTRHBuilder", "WithTrackAngle");
   desc.add<std::string>("magneticField", "ParabolicMf");
   desc.add<bool>("forceKinematicWithRegionDirection", false);
 }

◆ fillDescriptionsLabel()

static const char* SeedFromConsecutiveHitsCreator::fillDescriptionsLabel ( )

inlinestatic

Definition at line 32 of file SeedFromConsecutiveHitsCreator.h.

32 { return "ConsecutiveHits"; }

◆ init()

void SeedFromConsecutiveHitsCreator::init	(	const TrackingRegion &	region,
		const edm::EventSetup &	es,
		const SeedComparitor *	filter
	)

finalvirtual

Implements SeedCreator.

Definition at line 52 of file SeedFromConsecutiveHitsCreator.cc.

References cloner, filter, edm::EventSetup::getData(), isBOFF, magneticField_, magneticFieldESToken_, nomField, MagneticField::nominalValue(), propagator_, propagatorESToken_, region, trackerGeometry_, trackerGeometryESToken_, and transientTrackingRecHitBuilderESToken_.

                                                                          {
   region = &iregion;
   filter = ifilter;
   trackerGeometry_ = &es.getData(trackerGeometryESToken_);
   propagator_ = &es.getData(propagatorESToken_);
   magneticField_ = &es.getData(magneticFieldESToken_);
   nomField = magneticField_->nominalValue();
   isBOFF = (0 == nomField);
 
   TransientTrackingRecHitBuilder const* transientTrackingRecHitBuilder =
       &es.getData(transientTrackingRecHitBuilderESToken_);
   auto builder = (TkTransientTrackingRecHitBuilder const*)(transientTrackingRecHitBuilder);
   cloner = (*builder).cloner();
 }

◆ initialError()

CurvilinearTrajectoryError SeedFromConsecutiveHitsCreator::initialError ( float sin2Theta ) const

private

Definition at line 137 of file SeedFromConsecutiveHitsCreator.cc.

References correctionTermsCaloMet_cff::C, CurvilinearTrajectoryError::matrix(), SiStripPI::max, TrackingRegion::originRBound(), TrackingRegion::originZBound(), TrackingRegion::ptMin(), region, funct::sqr(), theMinOneOverPtError, and theOriginTransverseErrorMultiplier.

Referenced by makeSeed().

                                                                                              {
   // Set initial uncertainty on track parameters, using only P.V. constraint and no hit
   // information.
   CurvilinearTrajectoryError newError;  // zeroed
   auto& C = newError.matrix();
 
   // FIXME: minC00. Prevent apriori uncertainty in 1/P from being too small,
   // to avoid instabilities.
   // N.B. This parameter needs optimising ...
   // Probably OK based on quick study: KS 22/11/12.
   auto sin2th = sin2Theta;
   auto minC00 = sqr(theMinOneOverPtError);
   C[0][0] = std::max(sin2th / sqr(region->ptMin()), minC00);
   auto zErr = sqr(region->originZBound());
   auto transverseErr = sqr(theOriginTransverseErrorMultiplier * region->originRBound());
   C[1][1] = C[2][2] = 1.;  // no good reason. no bad reason....
   C[3][3] = transverseErr;
   C[4][4] = zErr * sin2th + transverseErr * (1.f - sin2th);
 
   return newError;
 }

◆ initialKinematic()

bool SeedFromConsecutiveHitsCreator::initialKinematic	(	GlobalTrajectoryParameters &	kine,
		const SeedingHitSet &	hits
	)		const

privatevirtual

Reimplemented in SeedFromConsecutiveHitsTripletOnlyCreator, and SeedFromConsecutiveHitsStraightLineCreator.

Definition at line 114 of file SeedFromConsecutiveHitsCreator.cc.

References GlobalTrajectoryParameters::charge(), SeedComparitor::compatible(), filter, hfClusterShapes_cfi::hits, isBOFF, magneticField_, GlobalTrajectoryParameters::momentum(), nomField, TrackingRegion::origin(), GlobalTrajectoryParameters::position(), region, theBOFFMomentum, Vector3DBase< T, FrameTag >::unit(), and UNLIKELY.

Referenced by makeSeed().

                                                                                        {
   SeedingHitSet::ConstRecHitPointer tth1 = hits[0];
   SeedingHitSet::ConstRecHitPointer tth2 = hits[1];
 
   const GlobalPoint& vertexPos = region->origin();
 
   FastHelix helix(tth2->globalPosition(), tth1->globalPosition(), vertexPos, nomField, magneticField_);
   if (helix.isValid()) {
     kine = helix.stateAtVertex();
   } else {
     GlobalVector initMomentum(tth2->globalPosition() - vertexPos);
     initMomentum *= (100.f / initMomentum.perp());
     kine = GlobalTrajectoryParameters(vertexPos, initMomentum, 1, magneticField_);
   }
 
   if UNLIKELY (isBOFF && (theBOFFMomentum > 0)) {
     kine = GlobalTrajectoryParameters(
         kine.position(), kine.momentum().unit() * theBOFFMomentum, kine.charge(), magneticField_);
   }
   return (filter ? filter->compatible(hits, kine, helix) : true);
 }

◆ makeSeed()

void SeedFromConsecutiveHitsCreator::makeSeed	(	TrajectorySeedCollection &	seedCollection,
		const SeedingHitSet &	hits
	)

finalvirtual

Implements SeedCreator.

Definition at line 69 of file SeedFromConsecutiveHitsCreator.cc.

References buildSeed(), correctionTermsCaloMet_cff::C, FreeTrajectoryState::charge(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), TrackingRegion::direction(), relativeConstraints::error, forceKinematicWithRegionDirection_, hfClusterShapes_cfi::hits, initialError(), initialKinematic(), TkTrackingRegionsMargin< T >::left(), PV3DBase< T, PVType, FrameType >::mag(), PV3DBase< T, PVType, FrameType >::mag2(), GlobalTrajectoryParameters::magneticField(), CurvilinearTrajectoryError::matrix(), SiStripPI::max, GlobalTrajectoryParameters::momentum(), FreeTrajectoryState::momentum(), TrackingRegion::origin(), TrackingRegion::originRBound(), TrackingRegion::originZBound(), FreeTrajectoryState::parameters(), PV3DBase< T, PVType, FrameType >::perp2(), RectangularEtaPhiTrackingRegion::phiMargin(), position, TrackingRegion::ptMin(), ptMin, region, TkTrackingRegionsMargin< T >::right(), ElectronSeedTrackRefFix_cfi::seedCollection, funct::sqr(), RectangularEtaPhiTrackingRegion::tanLambdaRange(), and PV3DBase< T, PVType, FrameType >::x().

                                                                                                                  {
   if (hits.size() < 2)
     return;
 
   GlobalTrajectoryParameters kine;
   if (!initialKinematic(kine, hits))
     return;
 
   auto sin2Theta = kine.momentum().perp2() / kine.momentum().mag2();
 
   CurvilinearTrajectoryError error = initialError(sin2Theta);
   FreeTrajectoryState fts(kine, error);
 
   if (region->direction().x() != 0 &&
       forceKinematicWithRegionDirection_)  // a direction was given, check if it is an etaPhi region
   {
     const RectangularEtaPhiTrackingRegion* etaPhiRegion = dynamic_cast<const RectangularEtaPhiTrackingRegion*>(region);
     if (etaPhiRegion) {
       //the following completely reset the kinematics, perhaps it makes no sense and newKine=kine would do better
       GlobalVector direction = region->direction() / region->direction().mag();
       GlobalVector momentum = direction * fts.momentum().mag();
       GlobalPoint position = region->origin() + 5 * direction;
       GlobalTrajectoryParameters newKine(position, momentum, fts.charge(), &fts.parameters().magneticField());
 
       auto ptMin = region->ptMin();
       CurvilinearTrajectoryError newError;  //zeroed
       auto& C = newError.matrix();
       constexpr float minC00 = 0.4f;
       C[0][0] = std::max(sin2Theta / sqr(ptMin), minC00);
       auto zErr = sqr(region->originZBound());
       auto transverseErr = sqr(region->originRBound());  // assume equal cxx cyy
       auto twiceDeltaLambda =
           std::atan(etaPhiRegion->tanLambdaRange().first) - std::atan(etaPhiRegion->tanLambdaRange().second);
       auto twiceDeltaPhi = etaPhiRegion->phiMargin().right() + etaPhiRegion->phiMargin().left();
       C[1][1] = twiceDeltaLambda * twiceDeltaLambda;  //2 sigma of what given in input
       C[2][2] = twiceDeltaPhi * twiceDeltaPhi;
       C[3][3] = transverseErr;
       C[4][4] = zErr * sin2Theta + transverseErr * (1.f - sin2Theta);
       fts = FreeTrajectoryState(newKine, newError);
     }
   }
 
   buildSeed(seedCollection, hits, fts);
 }

◆ refitHit()

SeedingHitSet::RecHitPointer SeedFromConsecutiveHitsCreator::refitHit	(	SeedingHitSet::ConstRecHitPointer	hit,
		const TrajectoryStateOnSurface &	state
	)		const

private

Definition at line 201 of file SeedFromConsecutiveHitsCreator.cc.

References cloner.

Referenced by buildSeed().

                                                                                                                    {
   return (SeedingHitSet::RecHitPointer)(cloner(*hit, state));
 }