CachedTrajectory.h

Go to the documentation of this file.

#ifndef TrackAssociator_CachedTrajectory_h
#define TrackAssociator_CachedTrajectory_h 1
// -*- C++ -*-
//
// Package:    TrackAssociator
// Class:      CachedTrajectory
// 
/*

 Description: CachedTrajectory is a transient class, which stores a set of
 * trajectory states that can be used as starting points when there is need
 * propagate the same track to a number of different surfaces, which might 
 * not be know in advance.

 Implementation:
     <Notes on implementation>
*/
//
// Original Author:  Dmytro Kovalskyi
//         Created:  Fri Apr 21 10:59:41 PDT 2006
// $Id: CachedTrajectory.h,v 1.13 2009/09/06 16:32:46 dmytro Exp $
//
//

#include "TrackingTools/TrackAssociator/interface/DetIdAssociator.h"
#include "TrackingTools/TrackAssociator/interface/TAMuonChamberMatch.h"
#include "TrackingTools/TrackAssociator/interface/FiducialVolume.h"
#include "TrackPropagation/SteppingHelixPropagator/interface/SteppingHelixStateInfo.h"
#include "Geometry/CommonDetUnit/interface/GlobalTrackingGeometry.h"
#include "Geometry/CommonDetUnit/interface/GeomDet.h"
#include "DataFormats/DetId/interface/DetId.h"
#include <deque>

class CachedTrajectory {
 public:
   CachedTrajectory();
   enum TrajectorType { IpToEcal, IpToHcal, IpToHO, FullTrajectory };
   enum WideTrajectoryType { Ecal, Hcal, HO };

   void reset_trajectory();
   
   bool propagateAll(const SteppingHelixStateInfo& initialState);
   
   void propagateForward(SteppingHelixStateInfo& state, float distance);
   void propagate(SteppingHelixStateInfo& state, const Plane& plane);
   void propagate(SteppingHelixStateInfo& state, const Cylinder& cylinder);

   TrajectoryStateOnSurface propagate(const Plane* plane);
   
   std::pair<float,float> trajectoryDelta( TrajectorType );
   
   void setPropagator(const Propagator* ptr){   propagator_ = ptr; }
   void setStateAtIP(const SteppingHelixStateInfo& state){ stateAtIP_ = state; }
   
   void getTrajectory(std::vector<SteppingHelixStateInfo>&,
              const FiducialVolume&,
              int steps = 4);
   
   void findEcalTrajectory(const FiducialVolume&);
   void findHcalTrajectory(const FiducialVolume&);
   void findHOTrajectory(const FiducialVolume&);
   void findPreshowerTrajectory(const FiducialVolume&);

   const std::vector<SteppingHelixStateInfo>& getEcalTrajectory();
   const std::vector<SteppingHelixStateInfo>& getHcalTrajectory();
   const std::vector<SteppingHelixStateInfo>& getHOTrajectory();
   const std::vector<SteppingHelixStateInfo>& getPreshowerTrajectory();

   std::vector<GlobalPoint>* getWideTrajectory(const std::vector<SteppingHelixStateInfo>&,
                                                     WideTrajectoryType);

   SteppingHelixStateInfo getStateAtEcal();
   SteppingHelixStateInfo getStateAtPreshower();
   SteppingHelixStateInfo getStateAtHcal();
   SteppingHelixStateInfo getStateAtHO();
   
   //get the innermost state of the whole trajectory 
   SteppingHelixStateInfo getInnerState();
   //get the outermost state of the whole trajectory 
   SteppingHelixStateInfo getOuterState();
   
   // specify the detector global boundaries to limit the propagator
   // units: cm
   // HINT: use lower bounds to limit propagateAll() action within
   //       smaller region, such as ECAL for example
   void setMaxDetectorRadius(float r = 800.){ maxRho_ = r;}
   void setMaxDetectorLength(float l = 2200.){ maxZ_ = l/2.;}
   void setMaxHORadius(float r = 800.) { HOmaxRho_ = r;}
   void setMaxHOLength(float l = 2200.) { HOmaxZ_ = l/2.;}
   void setMinDetectorRadius(float r = 0.){ minRho_ = r;}
   void setMinDetectorLength(float l = 0.){ minZ_ = l/2.;}

   void setPropagationStep(float s = 20.){ step_ = s;}
   float getPropagationStep() const { return step_;}
   
 protected:
   
   static int sign (float number){
      if (number ==0) return 0;
      if (number > 0)
    return 1;
      else
    return -1;
   }
   
   std::pair<float,float> delta( const double& theta1,
                 const double& theta2,
                 const double& phi1,
                 const double& phi2);
   
   float distance(const Plane* plane, int index) {
      if (index<0 || fullTrajectory_.empty() || (unsigned int)index >= fullTrajectory_.size()) return 0;
      return plane->localZ(fullTrajectory_[index].position());
   }
   
   std::deque<SteppingHelixStateInfo> fullTrajectory_;
   std::vector<SteppingHelixStateInfo> ecalTrajectory_;
   std::vector<SteppingHelixStateInfo> hcalTrajectory_;
   std::vector<SteppingHelixStateInfo> hoTrajectory_;
   std::vector<SteppingHelixStateInfo> preshowerTrajectory_;
   std::vector<GlobalPoint> wideEcalTrajectory_; 
   std::vector<GlobalPoint> wideHcalTrajectory_;
   std::vector<GlobalPoint> wideHOTrajectory_;
   SteppingHelixStateInfo stateAtIP_;
   
   bool fullTrajectoryFilled_;
   
   const Propagator* propagator_;
   
   float maxRho_;
   float maxZ_;
   float HOmaxRho_;
   float HOmaxZ_;
   float minRho_;
   float minZ_;
   float step_;

};
#endif