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