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"
#include "Geometry/CommonDetUnit/interface/GeomDet.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 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