#include <SiTrackerMultiRecHitUpdator.h>

Public Types
typedef std::pair< LocalPoint, LocalError >	LocalParameters

Public Member Functions
const std::vector< double > &	annealingProgram () const

virtual TransientTrackingRecHit::RecHitPointer	buildMultiRecHit (const std::vector< const TrackingRecHit * > &rhv, const TrajectoryStateOnSurface &tsos, MeasurementDetWithData &measDet, float annealing=1.) const

double	ComputeWeight (const TrajectoryStateOnSurface &tsos, const TransientTrackingRecHit &aRecHit, bool CutWeight, double annealing=1.) const

template<unsigned int N>
double	ComputeWeight (const TrajectoryStateOnSurface &tsos, const TransientTrackingRecHit &aRecHit, bool CutWeight, double annealing=1.) const

const std::vector< double > &	getAnnealingProgram () const

const TransientTrackingRecHitBuilder *	getBuilder () const

	SiTrackerMultiRecHitUpdator (const TransientTrackingRecHitBuilder builder, const TrackingRecHitPropagator hitpropagator, const float Chi2Cut1D, const float Chi2Cut2D, const std::vector< double > &anAnnealingProgram, bool debug)

virtual TransientTrackingRecHit::RecHitPointer	update (TransientTrackingRecHit::ConstRecHitPointer original, const TrajectoryStateOnSurface &tsos, MeasurementDetWithData &measDet, double annealing=1.) const

TransientTrackingRecHit::RecHitPointer	update (TransientTrackingRecHit::ConstRecHitContainer &tcomponents, const TrajectoryStateOnSurface &tsos, MeasurementDetWithData &measDet, double annealing=1.) const

virtual	~SiTrackerMultiRecHitUpdator ()

Private Member Functions
LocalParameters	calcParameters (const TrajectoryStateOnSurface &tsos, std::vector< std::pair< const TrackingRecHit *, float > > &aHitMap) const

template<unsigned int N>
LocalParameters	calcParameters (const TrajectoryStateOnSurface &tsos, std::vector< std::pair< const TrackingRecHit *, float > > &aHitMap) const

bool	TIDorTEChit (const TrackingRecHit *const &hit) const

Private Attributes
bool	debug_

const std::vector< double >	theAnnealingProgram

const TransientTrackingRecHitBuilder *	theBuilder

double	theChi2Cut1D

double	theChi2Cut2D

TkClonerImpl	theHitCloner

const TrackingRecHitPropagator *	theHitPropagator

Detailed Description

Builds a SiTrackerMultiRecHit out of a vector of TrackingRecHit or updates an existing SiTrackerMultiRecHit given a tsos.

Author: tropiano, genta in May 2014 by brondolin

Definition at line 27 of file SiTrackerMultiRecHitUpdator.h.

Member Typedef Documentation

typedef std::pair<LocalPoint, LocalError> SiTrackerMultiRecHitUpdator::LocalParameters

Definition at line 29 of file SiTrackerMultiRecHitUpdator.h.

Constructor & Destructor Documentation

SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator	(	const TransientTrackingRecHitBuilder *	builder,
		const TrackingRecHitPropagator *	hitpropagator,
		const float	Chi2Cut1D,
		const float	Chi2Cut2D,
		const std::vector< double > &	anAnnealingProgram,
		bool	debug
	)

Definition at line 17 of file SiTrackerMultiRecHitUpdator.cc.

References runTheMatrix::const, and theHitCloner.

     : theBuilder(builder),
       theHitPropagator(hitpropagator),
       theChi2Cut1D(Chi2Cut1D),
       theChi2Cut2D(Chi2Cut2D),
       theAnnealingProgram(anAnnealingProgram),
       debug_(debug) {
   theHitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(builder)->cloner();
 }

virtual SiTrackerMultiRecHitUpdator::~SiTrackerMultiRecHitUpdator ( )

inlinevirtual

Definition at line 36 of file SiTrackerMultiRecHitUpdator.h.

36 {};

Member Function Documentation

const std::vector<double>& SiTrackerMultiRecHitUpdator::annealingProgram ( ) const

inline

Definition at line 68 of file SiTrackerMultiRecHitUpdator.h.

References theAnnealingProgram.

68 { return theAnnealingProgram; }

SiTrackerMultiRecHitUpdator::theAnnealingProgram

const std::vector< double > theAnnealingProgram

Definition: SiTrackerMultiRecHitUpdator.h:86

TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit	(	const std::vector< const TrackingRecHit * > &	rhv,
		const TrajectoryStateOnSurface &	tsos,
		MeasurementDetWithData &	measDet,
		float	annealing = `1.`
	)		const

virtual

Definition at line 32 of file SiTrackerMultiRecHitUpdator.cc.

References TransientTrackingRecHitBuilder::build(), LogTrace, theBuilder, and update().

                            {
   LogTrace("SiTrackerMultiRecHitUpdator")
       << "Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing;
 
   TransientTrackingRecHit::ConstRecHitContainer tcomponents;
   for (std::vector<const TrackingRecHit*>::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++) {
     TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter);
     if (transient->isValid())
       tcomponents.push_back(transient);
   }
   return update(tcomponents, tsos, measDet, annealing);
 }

SiTrackerMultiRecHitUpdator::LocalParameters SiTrackerMultiRecHitUpdator::calcParameters	(	const TrajectoryStateOnSurface &	tsos,
		std::vector< std::pair< const TrackingRecHit *, float > > &	aHitMap
	)		const

private

Definition at line 298 of file SiTrackerMultiRecHitUpdator.cc.

References Exception, first, LogTrace, and mergeVDriftHistosByStation::name.

Referenced by update().

                                                                                                             {
   //supposing all the hits inside of a MRH have the same dimension
   LogTrace("SiTrackerMultiRecHitUpdator")
       << "SiTrackerMultiRecHitUpdator::LocalParameters: dim first recHit: " << aHitMap[0].first->dimension()
       << std::endl;
   switch (aHitMap[0].first->dimension()) {
     case 1:
       return calcParameters<1>(tsos, aHitMap);
     case 2:
       return calcParameters<2>(tsos, aHitMap);
   }
   throw cms::Exception("Rec hit of invalid dimension for computing MRH (not 1,2)")
       << "The value was " << aHitMap[0].first->dimension() << ", type is " << typeid(aHitMap[0].first).name() << "\n";
 }

template<unsigned int N>

LocalParameters SiTrackerMultiRecHitUpdator::calcParameters	(	const TrajectoryStateOnSurface &	tsos,
		std::vector< std::pair< const TrackingRecHit *, float > > &	aHitMap
	)		const

private

double SiTrackerMultiRecHitUpdator::ComputeWeight	(	const TrajectoryStateOnSurface &	tsos,
		const TransientTrackingRecHit &	aRecHit,
		bool	CutWeight,
		double	annealing = `1.`
	)		const

Definition at line 193 of file SiTrackerMultiRecHitUpdator.cc.

References TrackingRecHit::dimension(), Exception, and mergeVDriftHistosByStation::name.

Referenced by update().

                                                                           {
   switch (aRecHit.dimension()) {
     case 1:
       return ComputeWeight<1>(tsos, aRecHit, CutWeight, annealing);
     case 2:
       return ComputeWeight<2>(tsos, aRecHit, CutWeight, annealing);
     case 3:
       return ComputeWeight<3>(tsos, aRecHit, CutWeight, annealing);
     case 4:
       return ComputeWeight<4>(tsos, aRecHit, CutWeight, annealing);
     case 5:
       return ComputeWeight<5>(tsos, aRecHit, CutWeight, annealing);
   }
   throw cms::Exception("Rec hit of invalid dimension (not 1,2,3,4,5)")
       << "The value was " << aRecHit.dimension() << ", type is " << typeid(aRecHit).name() << "\n";
 }

template<unsigned int N>

double SiTrackerMultiRecHitUpdator::ComputeWeight	(	const TrajectoryStateOnSurface &	tsos,
		const TransientTrackingRecHit &	aRecHit,
		bool	CutWeight,
		double	annealing = `1.`
	)		const

const std::vector<double>& SiTrackerMultiRecHitUpdator::getAnnealingProgram ( ) const

inline

Definition at line 69 of file SiTrackerMultiRecHitUpdator.h.

References theAnnealingProgram.

Referenced by DAFTrackProducerAlgorithm::runWithCandidate().

69 { return theAnnealingProgram; }

SiTrackerMultiRecHitUpdator::theAnnealingProgram

const std::vector< double > theAnnealingProgram

Definition: SiTrackerMultiRecHitUpdator.h:86

const TransientTrackingRecHitBuilder* SiTrackerMultiRecHitUpdator::getBuilder ( ) const

inline

Definition at line 71 of file SiTrackerMultiRecHitUpdator.h.

References theBuilder.

Referenced by SimpleDAFHitCollector::SimpleDAFHitCollector().

71 { return theBuilder; }

SiTrackerMultiRecHitUpdator::theBuilder

const TransientTrackingRecHitBuilder * theBuilder

Definition: SiTrackerMultiRecHitUpdator.h:82

bool SiTrackerMultiRecHitUpdator::TIDorTEChit ( const TrackingRecHit *const & hit ) const

private

Definition at line 387 of file SiTrackerMultiRecHitUpdator.cc.

References DetId::det(), TrackingRecHit::geographicalId(), DetId::subdetId(), StripSubdetector::TEC, StripSubdetector::TID, and DetId::Tracker.

                                                                                     {
   DetId hitId = hit->geographicalId();
 
   if (hitId.det() == DetId::Tracker &&
       (hitId.subdetId() == StripSubdetector::TEC || hitId.subdetId() == StripSubdetector::TID)) {
     return true;
   }
 
   return false;
 }

TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update	(	TransientTrackingRecHit::ConstRecHitPointer	original,
		const TrajectoryStateOnSurface &	tsos,
		MeasurementDetWithData &	measDet,
		double	annealing = `1.`
	)		const

virtual

Definition at line 49 of file SiTrackerMultiRecHitUpdator.cc.

References Exception, TrajectoryStateOnSurface::isValid(), LogTrace, TkClonerImpl::makeShared(), and theHitCloner.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), buildMultiRecHit(), progressbar.ProgressBar::finish(), MatrixUtil.Steps::overwrite(), and DAFTrackProducerAlgorithm::updateHits().

                             {
   LogTrace("SiTrackerMultiRecHitUpdator")
       << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing;
 
   if (!tsos.isValid()) {
     //return original->clone();
     throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! ";
   }
 
   //check if to clone is the right thing
   if (original->isValid()) {
     if (original->transientHits().empty()) {
       return theHitCloner.makeShared(original, tsos);
     }
   } else {
     return theHitCloner.makeShared(original, tsos);
   }
 
   TransientTrackingRecHit::ConstRecHitContainer tcomponents = original->transientHits();
   return update(tcomponents, tsos, measDet, annealing);
 }

TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update	(	TransientTrackingRecHit::ConstRecHitContainer &	tcomponents,
		const TrajectoryStateOnSurface &	tsos,
		MeasurementDetWithData &	measDet,
		double	annealing = `1.`
	)		const

Definition at line 76 of file SiTrackerMultiRecHitUpdator.cc.

References calcParameters(), cropTnPTrees::cloned, ComputeWeight(), counter, alignCSCRings::e, Exception, first, MeasurementDet::geomDet(), invalid, TrajectoryStateOnSurface::isValid(), LogTrace, TkClonerImpl::makeShared(), MeasurementDetWithData::mdet(), TrackingRecHit::missing, mergeVDriftHistosByStation::name, AlCaHLTBitMon_ParallelJobs::p, GloballyPositioned< T >::position(), TrackingRecHitPropagator::project(), edm::second(), TrajectoryStateOnSurface::surface(), theBuilder, theHitCloner, theHitPropagator, and createJobs::tmp.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                             {
   if (tcomponents.empty()) {
     LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, "
                                                "returning an InvalidTransientRecHit ";
     return std::make_shared<InvalidTrackingRecHit>(measDet.mdet().geomDet(), TrackingRecHit::missing);
   }
 
   if (!tsos.isValid()) {
     LogTrace("SiTrackerMultiRecHitUpdator")
         << "SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit";
     return std::make_shared<InvalidTrackingRecHit>(measDet.mdet().geomDet(), TrackingRecHit::missing);
   }
 
   std::vector<TransientTrackingRecHit::RecHitPointer> updatedcomponents;
   const GeomDet* geomdet = nullptr;
 
   //running on all over the MRH components
   for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin();
        iter != tcomponents.end();
        iter++) {
     //the first rechit must belong to the same surface of TSOS
     if (iter == tcomponents.begin()) {
       if (&((*iter)->det()->surface()) != &(tsos.surface())) {
         throw cms::Exception("SiTrackerMultiRecHitUpdator")
             << "the Trajectory state and the first rechit "
                "passed to the SiTrackerMultiRecHitUpdator lay on different surfaces!: state lays on surface "
             << tsos.surface().position() << " hit with detid " << (*iter)->det()->geographicalId().rawId()
             << " lays on surface " << (*iter)->det()->surface().position();
       }
 
       geomdet = (*iter)->det();
     }
 
     //if the rechit does not belong to the surface of the tsos
     //GenericProjectedRecHit2D is used to prepagate
     if (&((*iter)->det()->surface()) != &(tsos.surface())) {
       TransientTrackingRecHit::RecHitPointer cloned =
           theHitPropagator->project<GenericProjectedRecHit2D>(*iter, *geomdet, tsos, theBuilder);
       //if it is used a sensor by sensor grouping this should not appear
       if (cloned->isValid())
         updatedcomponents.push_back(cloned);
 
     } else {
       TransientTrackingRecHit::RecHitPointer cloned = theHitCloner.makeShared(*iter, tsos);
       if (cloned->isValid()) {
         updatedcomponents.push_back(cloned);
       }
     }
   }
 
   std::vector<std::pair<const TrackingRecHit*, float> > mymap;
   std::vector<std::pair<const TrackingRecHit*, float> > normmap;
 
   double a_sum = 0, c_sum = 0;
 
   for (std::vector<TransientTrackingRecHit::RecHitPointer>::iterator ihit = updatedcomponents.begin();
        ihit != updatedcomponents.end();
        ihit++) {
     double a_i = ComputeWeight(tsos, *(*ihit), false, annealing);  //exp(-0.5*Chi2)
     LogTrace("SiTrackerMultiRecHitUpdator") << "\t\t a_i:" << a_i;
     //double c_i = ComputeWeight(tsos, *(*ihit), true, annealing);  //exp(-0.5*theChi2Cut/annealing)/(2.*M_PI*sqrt(det));
     //LogTrace("SiTrackerMultiRecHitUpdator")<< "\t\t c_i:" << c_i ;
     mymap.push_back(std::pair<const TrackingRecHit*, float>((*ihit)->hit(), a_i));
 
     a_sum += a_i;
     //with the new definition, the cut weight is computed only once
     if (ihit == updatedcomponents.begin())
       c_sum = ComputeWeight(tsos, *(*ihit), true, annealing);  //exp(-0.5*theChi2Cut/annealing)
   }
   double total_sum = a_sum + c_sum;
   LogTrace("SiTrackerMultiRecHitUpdator") << "\t\t c_sum:" << c_sum;
   LogTrace("SiTrackerMultiRecHitUpdator") << "\t\t total sum:" << total_sum;
 
   unsigned int counter = 0;
   bool invalid = true;
   for (std::vector<TransientTrackingRecHit::RecHitPointer>::iterator ihit = updatedcomponents.begin();
        ihit != updatedcomponents.end();
        ihit++) {
     double p = ((mymap[counter].second) / total_sum > 1.e-12 ? (mymap[counter].second) / total_sum : 1.e-12);
     //ORCA: float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6);
 
 #ifdef EDM_ML_DEBUG
     auto const& tmp = *mymap[counter].first;
     LogTrace("SiTrackerMultiRecHitUpdator")
         << "  Component hit type " << typeid(tmp).name() << " and dim:" << tmp.dimension() << " position (PRECISE!!!)"
         << tmp.localPosition() << " error " << tmp.localPositionError() << " with weight " << p;
 #endif
 
     if (p > 10e-6) {
       invalid = false;
       normmap.push_back(std::pair<const TrackingRecHit*, float>(mymap[counter].first, p));
     }
 
     counter++;
   }
 
   if (!invalid) {
     SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, normmap);
     SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing);
     LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error "
                                             << updated.localPositionError() << std::endl;
 
     return std::make_shared<SiTrackerMultiRecHit>(
         param.first, param.second, *normmap.front().first->det(), normmap, annealing);
 
   } else {
     LogTrace("SiTrackerMultiRecHitUpdator")
         << " No hits with weight (> 10e-6) have been found for this MRH." << std::endl;
     return std::make_shared<InvalidTrackingRecHit>(measDet.mdet().geomDet(), TrackingRecHit::missing);
   }
 }