EcalHitMaker.h

Go to the documentation of this file.

#ifndef FastSimulation_CaloHitMakers_EcalHitMaker_h
#define FastSimulation_CaloHitMakers_EcalHitMaker_h
 
#include "Geometry/CaloTopology/interface/CaloDirection.h"
 
//#include "FastSimulation/Event/interface/FSimTrack.h"
#include "FastSimulation/CaloHitMakers/interface/CaloHitMaker.h"
#include "FastSimulation/CaloGeometryTools/interface/CaloPoint.h"
#include "FastSimulation/CaloGeometryTools/interface/CaloSegment.h"
#include "FastSimulation/CaloGeometryTools/interface/CrystalPad.h"
#include "FastSimulation/CaloGeometryTools/interface/Crystal.h"
#include "FastSimulation/Utilities/interface/FamosDebug.h"
 
//#include <boost/cstdint.hpp>
 
#include <vector>
 
class CaloGeometryHelper;
class CrystalWindowMap;
class Histos;
class RandomEngineAndDistribution;
class FSimTrack;
 
class EcalHitMaker : public CaloHitMaker {
public:
  typedef math::XYZVector XYZVector;
  typedef math::XYZVector XYZPoint;
  typedef math::XYZVector XYZNormal;
  typedef ROOT::Math::Plane3D Plane3D;
 
  EcalHitMaker(CaloGeometryHelper* calo,
               const XYZPoint& ecalentrance,
               const DetId& cell,
               int onEcal,
               unsigned size,
               unsigned showertype,
               const RandomEngineAndDistribution* engine);
 
  ~EcalHitMaker() override;
 
  // This is not part of the constructor but it has to be called very early
  void setTrackParameters(const XYZNormal& normal, double X0depthoffset, const FSimTrack& theTrack);
 
  // The following methods are related to the path of the particle
  // through the detector.
 
  // Number of X0 "seen" by the track
  //  inline double totalX0() const {return totalX0_-X0depthoffset_;};
  inline double totalX0() const { return totalX0_; };
 
  inline double totalL0() const { return totalL0_; };
 
  inline double x0DepthOffset() const { return X0depthoffset_; }
 
  // total number of X0 in the PS (Layer1).
  inline double ps1TotalX0() const { return X0PS1_; }
 
  inline double ps2TotalX0() const { return X0PS2_; }
 
  // number of X0 between PS2 and EE
  inline double ps2eeTotalX0() const { return X0PS2EE_; }
 
  inline double ecalTotalX0() const { return X0ECAL_; }
 
  inline double ecalHcalGapTotalX0() const { return X0EHGAP_; }
 
  inline double hcalTotalX0() const { return X0HCAL_; }
 
  inline double ps1TotalL0() const { return L0PS1_; }
 
  inline double ps2TotalL0() const { return L0PS2_; }
 
  // number of X0 between PS2 and EE
  inline double ps2eeTotalL0() const { return L0PS2EE_; }
 
  inline double ecalTotalL0() const { return L0ECAL_; }
 
  inline double hcalTotalL0() const { return L0HCAL_; }
 
  inline double ecalHcalGapTotalL0() const { return L0EHGAP_; }
 
  inline const std::vector<CaloSegment>& getSegments() const { return segments_; };
 
  // The following methods are EM showers specific
 
  bool getPads(double depth, bool inCm = false);
 
  inline double getX0back() const { return maxX0_; }
 
  bool addHitDepth(double r, double phi, double depth = -1);
 
  bool addHit(double r, double phi, unsigned layer = 0) override;
 
  unsigned fastInsideCell(const CLHEP::Hep2Vector& point, double& sp, bool debug = false);
 
  inline void setSpotEnergy(double e) override { spotEnergy = e; }
 
 
  const std::map<CaloHitID, float>& getHits() override;
 
  const FSimTrack* getFSimTrack() const { return myTrack_; }
 
  inline const XYZPoint& ecalEntrance() const { return EcalEntrance_; };
 
  inline void setRadiusFactor(double r) { radiusCorrectionFactor_ = r; }
 
  inline void setPulledPadSurvivalProbability(double val) { pulledPadProbability_ = val; };
 
  inline void setCrackPadSurvivalProbability(double val) { crackPadProbability_ = val; };
 
  // set preshower
  inline void setPreshowerPresent(bool ps) { simulatePreshower_ = ps; };
 
  inline const std::vector<Crystal>& getCrystals() const { return regionOfInterest_; }
 
private:
  // Computes the intersections of a track with the different calorimeters
  void cellLine(std::vector<CaloPoint>& cp);
 
  void preshowerCellLine(std::vector<CaloPoint>& cp) const;
 
  void hcalCellLine(std::vector<CaloPoint>& cp) const;
 
  void ecalCellLine(const XYZPoint&, const XYZPoint&, std::vector<CaloPoint>& cp);
 
  void buildSegments(const std::vector<CaloPoint>& cp);
 
  // retrieves the 7x7 crystals and builds the map of neighbours
  void buildGeometry();
 
  // depth-dependent geometry operations
  void configureGeometry();
 
  // project fPoint on the plane (origin,normal)
  bool pulled(const XYZPoint& origin, const XYZNormal& normal, XYZPoint& fPoint) const;
 
  //  the numbering within the grid
  void prepareCrystalNumberArray();
 
  // find approximately the pad corresponding to (x,y)
  void convertIntegerCoordinates(double x, double y, unsigned& ix, unsigned& iy) const;
 
  // pads reorganization (to lift the gaps)
  void reorganizePads();
 
  // retrieves the coordinates of a corner belonging to the neighbour
  typedef std::pair<CaloDirection, unsigned> neighbour;
  CLHEP::Hep2Vector& correspondingEdge(neighbour& myneighbour, CaloDirection dir2);
 
  // almost the same
  bool diagonalEdge(unsigned myPad, CaloDirection dir, CLHEP::Hep2Vector& point);
 
  // check if there is an unbalanced direction in the input vertor. If the result is true,
  // the cooresponding directions are returned dir1+dir2=unb
  bool unbalancedDirection(const std::vector<neighbour>& dirs, unsigned& unb, unsigned& dir1, unsigned& dir2);
 
  // glue the pads together if there is no crack between them
  void gapsLifting(std::vector<neighbour>& gaps, unsigned iq);
 
  // creates a crack
  void cracksPads(std::vector<neighbour>& cracks, unsigned iq);
 
private:
  bool inside3D(const std::vector<XYZPoint>&, const XYZPoint& p) const;
 
  // the numbering of the pads
  std::vector<std::vector<unsigned> > myCrystalNumberArray_;
 
  // The following quantities are related to the path of the track through the detector
  double totalX0_;
  double totalL0_;
  double X0depthoffset_;
  double X0PS1_;
  double X0PS2_;
  double X0PS2EE_;
  double X0ECAL_;
  double X0EHGAP_;
  double X0HCAL_;
  double L0PS1_;
  double L0PS2_;
  double L0PS2EE_;
  double L0ECAL_;
  double L0HCAL_;
  double L0EHGAP_;
 
  double maxX0_;
  double rearleakage_;
  double outsideWindowEnergy_;
 
  // Grid construction
  Crystal pivot_;
  XYZPoint EcalEntrance_;
  XYZNormal normal_;
  int central_;
  int onEcal_;
 
  bool configuredGeometry_;
  unsigned ncrystals_;
  // size of the grid in the(x,y) plane
  unsigned nx_, ny_;
  double xmin_, xmax_, ymin_, ymax_;
 
  std::vector<DetId> CellsWindow_;
  std::vector<Crystal> regionOfInterest_;
  std::vector<float> hits_;
  // Validity of the pads. To be valid, the intersection of the crytal with the plane should have 4 corners
  std::vector<bool> validPads_;
  // Get the index of the crystal (in hits_ or regionOfInterest_) when its CellID is known
  // Needed because the navigation uses DetIds.
  std::map<DetId, unsigned> DetIdMap_;
 
  CrystalWindowMap* myCrystalWindowMap_;
 
  // First segment in ECAL
  int ecalFirstSegment_;
 
  // Properties of the crystal window
  unsigned etasize_;
  unsigned phisize_;
  // is the grid complete ?
  bool truncatedGrid_;
 
  // shower simulation quantities
  // This one is the shower enlargment wrt Grindhammer
  double radiusCorrectionFactor_;
  // moliere radius  * radiuscorrectionfactor OR interactionlength
  double radiusFactor_;
  // is it necessary to trigger the detailed simulation of the shower tail ?
  bool detailedShowerTail_;
  // current depth
  double currentdepth_;
  // magnetic field correction factor
  double bfactor_;
  // simulate preshower
  bool simulatePreshower_;
 
  // pads-depth specific quantities
  unsigned ncrackpadsatdepth_;
  unsigned npadsatdepth_;
  Plane3D plan_;
  // spot survival probability for a pulled pad - corresponding to the front face of a crystal
  // on the plan located in front of the crystal - Front leaking
  double pulledPadProbability_;
  // spot survival probability for the craks
  double crackPadProbability_;
  // size of the grid in the plane
  double sizex_, sizey_;
 
  //  int fsimtrack_;
  const FSimTrack* myTrack_;
 
  // vector of the intersection of the track with the dectectors (PS,ECAL,HCAL)
  std::vector<CaloPoint> intersections_;
  // segments obtained from the intersections
  std::vector<CaloSegment> segments_;
  // should the pads be reorganized (most of the time YES! )
  bool doreorg_;
 
  // the geometrical objects
  std::vector<CrystalPad> padsatdepth_;
  std::vector<CrystalPad> crackpadsatdepth_;
 
  bool hitmaphasbeencalculated_;
 
  // A local vector of corners, to avoid reserving, newing and mallocing
  std::vector<CLHEP::Hep2Vector> mycorners;
  std::vector<XYZPoint> corners;
 
  const RandomEngineAndDistribution* random;
 
#ifdef FAMOSDEBUG
  Histos* myHistos;
#endif
};
 
#endif