#include <TrajAnnealing.h>

Public Member Functions
float	getAnnealing () const

Trajectory	getTraj () const

	TrajAnnealing ()

	TrajAnnealing (const Trajectory &, float)

std::vector< float > const &	weights () const

std::vector< float > &	weights ()

virtual	~TrajAnnealing ()

Private Member Functions
std::pair< float, std::vector < float > >	getAnnealingWeight (const TrackingRecHit &aRecHit) const

Private Attributes
float	annealing_

TrackingRecHit::RecHitContainer	theHits_

std::vector< float >	theWeights

Trajectory	traj_

Detailed Description

This class allow to save all the traj info for each annealing cycle suitable for algorithm like DAF (not used in default options)

Definition at line 12 of file TrajAnnealing.h.

Constructor & Destructor Documentation

TrajAnnealing::TrajAnnealing ( )

inline

Definition at line 15 of file TrajAnnealing.h.

                    :
       traj_(),
       annealing_(0),
       theWeights(){}

virtual TrajAnnealing::~TrajAnnealing ( )

inlinevirtual

Definition at line 19 of file TrajAnnealing.h.

19 {}

TrajAnnealing::TrajAnnealing	(	const Trajectory &	traj,
		float	ann
	)

Definition at line 6 of file TrajAnnealing.cc.

References alongMomentum, annealing_, makeMuonMisalignmentScenario::components, Trajectory::direction(), Trajectory::measurements(), SiTrackerMultiRecHit::recHits(), theHits_, theWeights, traj_, and SiTrackerMultiRecHit::weight().

                                                                {
   traj_ = traj;
   annealing_ = ann;
 
   const Trajectory::DataContainer& measurements = traj_.measurements();
   if( measurements.size() > 2 ){
     Trajectory::DataContainer::const_iterator ibegin,iend;
     int increment(0);
     if( traj.direction() == alongMomentum ){
       ibegin = measurements.begin() + 1;
       iend = measurements.end() - 1;
       increment = 1;
     } else {
       ibegin = measurements.end() - 2;
       iend = measurements.begin();
       increment = -1;
     }
     
     for( Trajectory::DataContainer::const_iterator imeas = ibegin; imeas != iend; imeas += increment ){
 
       theHits_.push_back(imeas->recHit());
       if (imeas->recHit()->isValid()){
         SiTrackerMultiRecHit const & mHit = dynamic_cast<SiTrackerMultiRecHit const &>(*imeas->recHit());
         std::vector<const TrackingRecHit*> components = mHit.recHits();
         int iComp = 0;
         for(std::vector<const TrackingRecHit*>::const_iterator iter = components.begin(); 
         iter != components.end(); iter++, iComp++){
             theWeights.push_back(mHit.weight(iComp));
         }
       }
     }
 
   }
 
 }

Member Function Documentation

float TrajAnnealing::getAnnealing ( ) const

inline

Definition at line 23 of file TrajAnnealing.h.

References annealing_.

23 { return annealing_; }

TrajAnnealing::annealing_

float annealing_

Definition: TrajAnnealing.h:33

std::pair< float, std::vector< float > > TrajAnnealing::getAnnealingWeight ( const TrackingRecHit & aRecHit ) const

private

Definition at line 42 of file TrajAnnealing.cc.

References SiTrackerMultiRecHit::getAnnealingFactor(), TrackingRecHit::isValid(), and SiTrackerMultiRecHit::weights().

                                                                                                          {
 
   if (!aRecHit.isValid()) {
     std::vector<float> dumpyVec = {0.0};
     return make_pair(0.0,dumpyVec);
   }
 
   SiTrackerMultiRecHit const & mHit = dynamic_cast<SiTrackerMultiRecHit const &>(aRecHit); 
   return make_pair(mHit.getAnnealingFactor(), mHit.weights());
 
 }