/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/FastSimulation/TrajectoryManager/interface/TrajectoryManager.h

Go to the documentation of this file.

#ifndef TRAJECTORYMANAGER_H
#define TRAJECTORYMANAGER_H

//DataFormats
#include "SimDataFormats/TrackingHit/interface/PSimHit.h"
#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"

//FAMOS Headers
#include "FastSimulation/MaterialEffects/interface/MaterialEffects.h"

#include "Math/GenVector/AxisAngle.h"

#include <vector>
#include <map>

class PythiaDecays;
class TrackerInteractionGeometry;
class TrackerLayer;
class ParticlePropagator;
class FSimEvent;
//class Histos;
class RandomEngine;
class TrajectoryStateOnSurface;
class DetLayer;
class GeomDet;
class GeomDetUnit;
class MagneticField;
class MagneticFieldMap;
class GeometricSearchTracker;
class TrackerGeometry;
class TrackerTopology;

namespace edm { 
  class ParameterSet;
}

class TrajectoryManager

{
 public:

  typedef ROOT::Math::AxisAngle Rotation;

  TrajectoryManager() {;}

  TrajectoryManager(FSimEvent* aSimEvent, 
                    const edm::ParameterSet& matEff,
                    const edm::ParameterSet& simHits,
                    const edm::ParameterSet& decays,
                    const RandomEngine* engine);

  ~TrajectoryManager();
  
  void reconstruct(const TrackerTopology *tTopo);

  void createPSimHits(const TrackerLayer& layer,
                      const ParticlePropagator& P_before,
                      std::map<double,PSimHit>& theHitMap,
                      int trackID, int partID, const TrackerTopology *tTopo);

  void propagateToCalorimeters(ParticlePropagator& PP, 
                               int fsimi);


  bool propagateToLayer(ParticlePropagator& PP,unsigned layer);

  const TrackerInteractionGeometry* theGeometry();

  void initializeRecoGeometry(const GeometricSearchTracker* geomSearchTracker,
                              const TrackerInteractionGeometry* interactionGeometry,
                              const MagneticFieldMap* aFieldMap);

  void initializeTrackerGeometry(const TrackerGeometry* geomTracker);

  // load container from edm::Event
  void loadSimHits(edm::PSimHitContainer & c) const;

 private:

  void updateWithDaughters(ParticlePropagator& PP, int fsimi);

  void moveAllDaughters(int fsimi, const Rotation& r, double rescale);

  void initializeLayerMap();

  TrajectoryStateOnSurface makeTrajectoryState( const DetLayer* layer, 
                                                const ParticlePropagator& pp,
                                                const MagneticField* field) const;

  void makePSimHits( const GeomDet* det, const TrajectoryStateOnSurface& ts,
                     std::map<double,PSimHit>& theHitMap,
                     int tkID, float el, float thick, int pID, const TrackerTopology *tTopo);
  std::pair<double,PSimHit> makeSinglePSimHit( const GeomDetUnit& det,
                                               const TrajectoryStateOnSurface& ts, 
                                               int tkID, float el, float thick, int pID, const TrackerTopology *tTopo) const;

  const DetLayer* detLayer( const TrackerLayer& layer, float zpos) const;

 private:

  FSimEvent* mySimEvent;

  const TrackerInteractionGeometry* _theGeometry;
  const MagneticFieldMap* _theFieldMap;
  
  MaterialEffects* theMaterialEffects;

  PythiaDecays* myDecayEngine;
  std::string decayer;
  double distCut;

  double pTmin;
  bool firstLoop;
  std::map<unsigned,std::map<double,PSimHit> > thePSimHits;

  const TrackerGeometry*                      theGeomTracker;
  const GeometricSearchTracker*               theGeomSearchTracker;
  std::vector<const DetLayer*>                theLayerMap;
  int                                         theNegLayerOffset;

  //  Histos* myHistos;

  const RandomEngine* random;

  bool use_hardcoded;

};
#endif