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 RandomEngineAndDistribution;
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);

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

  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,
                               RandomEngineAndDistribution const*);

  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, RandomEngineAndDistribution const*);

  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;

  bool use_hardcoded;

};
#endif