CaloHitResponse.h

Go to the documentation of this file.

#ifndef CaloSimAlgos_CaloHitResponse_h
#define CaloSimAlgos_CaloHitResponse_h

#include "CalibFormats/CaloObjects/interface/CaloSamples.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "Geometry/CaloGeometry/interface/CaloGeometry.h"
#include "SimCalorimetry/CaloSimAlgos/interface/CaloVPECorrection.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include "SimDataFormats/CrossingFrame/interface/MixCollection.h"

#include <map>
#include <vector>

namespace CLHEP {
  class HepRandomEngine;
}

class CaloVShape;
class CaloShapes;
class CaloVSimParameterMap;
class CaloVHitCorrection;
class CaloVHitFilter;
class CaloSimParameters;

class CaloHitResponse {
public:
  typedef std::map<DetId, CaloSamples> AnalogSignalMap;
  // get this from somewhere external
  static constexpr int BUNCHSPACE = 25;
  static constexpr double dt = 0.5;
  static constexpr int invdt = 2;

  CaloHitResponse(const CaloVSimParameterMap *parameterMap,
                  const CaloVShape *shape,
                  bool PreMix1 = false,
                  bool HighFidelity = false);
  CaloHitResponse(const CaloVSimParameterMap *parameterMap,
                  const CaloShapes *shapes,
                  bool PreMix1 = false,
                  bool HighFidelity = false);

  virtual ~CaloHitResponse();

  void setBunchRange(int minBunch, int maxBunch);

  void setGeometry(const CaloGeometry *geometry) { theGeometry = geometry; }

  virtual bool keepBlank() const { return true; }

  virtual void initializeHits() {}

  virtual void finalizeHits(CLHEP::HepRandomEngine *);

  virtual void run(const MixCollection<PCaloHit> &hits, CLHEP::HepRandomEngine *);

  virtual void add(const PCaloHit &hit, CLHEP::HepRandomEngine *);

  virtual void add(const CaloSamples &signal);

  void setHitFilter(const CaloVHitFilter *filter) { theHitFilter = filter; }

  void setHitCorrection(const CaloVHitCorrection *hitCorrection) { theHitCorrection = hitCorrection; }

  void setPECorrection(const CaloVPECorrection *peCorrection) { thePECorrection = peCorrection; }

  void clear() { theAnalogSignalMap.clear(); }

  void addHit(const PCaloHit *hit, CaloSamples &frame) const;

  virtual CaloSamples makeAnalogSignal(const PCaloHit &inputHit, CLHEP::HepRandomEngine *) const;

  double analogSignalAmplitude(const DetId &id,
                               float energy,
                               const CaloSimParameters &parameters,
                               CLHEP::HepRandomEngine *) const;

  CaloSamples *findSignal(const DetId &detId);

  int nSignals() const { return theAnalogSignalMap.size(); }

  int getReadoutFrameSize(const DetId &id) const;

  CaloSamples makeBlankSignal(const DetId &detId) const;

  double timeOfFlight(const DetId &detId) const;

  void setPhaseShift(const double &thePhaseShift) { thePhaseShift_ = thePhaseShift; }


  bool withinBunchRange(int bunchCrossing) const {
    return (bunchCrossing >= theMinBunch && bunchCrossing <= theMaxBunch);
  }

  void setStorePrecise(bool sp) { storePrecise = sp; }

  void setIgnoreGeantTime(bool gt) { ignoreTime = gt; }

protected:
  AnalogSignalMap theAnalogSignalMap;

  const CaloVSimParameterMap *theParameterMap;
  const CaloShapes *theShapes;
  const CaloVShape *theShape;
  const CaloVHitCorrection *theHitCorrection;
  const CaloVPECorrection *thePECorrection;
  const CaloVHitFilter *theHitFilter;

  const CaloGeometry *theGeometry;

  int theMinBunch;
  int theMaxBunch;

  double thePhaseShift_;
  bool storePrecise;
  bool preMixDigis;
  bool highFidelityPreMix;
  bool ignoreTime;
};

#endif