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
  enum { BUNCHSPACE = 25 };
 
  CaloHitResponse(const CaloVSimParameterMap *parameterMap, const CaloVShape *shape);
  CaloHitResponse(const CaloVSimParameterMap *parameterMap, const CaloShapes *shapes);
 
  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(); }
 
  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 ignoreTime;
};
 
#endif