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 "SimDataFormats/CrossingFrame/interface/MixCollection.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include "SimCalorimetry/CaloSimAlgos/interface/CaloVPECorrection.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