CrystalPad.h

Go to the documentation of this file.

#ifndef FastSimulation_CaloGeometryTools_CrystalPad
#define FastSimulation_CaloGeometryTools_CrystalPad
 
#include "Geometry/CaloTopology/interface/CaloDirection.h"
 
#include "CLHEP/Vector/TwoVector.h"
#include "DataFormats/Math/interface/Vector3D.h"
//#include "Math/GenVector/Transform3D.h"
#include "FastSimulation/CaloGeometryTools/interface/Transform3DPJ.h"
//C++ headers
#include <vector>
 
class CrystalPad {
public:
  typedef math::XYZVector XYZVector;
  typedef math::XYZVector XYZPoint;
  typedef ROOT::Math::Transform3DPJ Transform3D;
  typedef ROOT::Math::Transform3DPJ::Point Point;
 
  CrystalPad() { dummy_ = true; };
  CrystalPad(unsigned number, const std::vector<CLHEP::Hep2Vector>& corners);
  CrystalPad(unsigned number,
             int onEcal,
             const std::vector<XYZPoint>& corners,
             const XYZPoint& origin,
             const XYZVector& vec1,
             const XYZVector& vec2);
 
  CrystalPad(unsigned number,
             const std::vector<XYZPoint>& corners,
             const Transform3D&,
             double scaf = 1.,
             bool bothdirections = false);
 
  CrystalPad(const CrystalPad& right);
 
  CrystalPad& operator=(const CrystalPad& rhs);
 
  ~CrystalPad() { ; };
 
  bool inside(const CLHEP::Hep2Vector& point, bool debug = false) const;
  //  bool globalinside(XYZPoint) const;
 
  //  CLHEP::Hep2Vector localPoint(XYZPoint point) const;
 
  inline const std::vector<CLHEP::Hep2Vector>& getCorners() const { return corners_; }
 
  void resetCorners();
 
  void print() const;
 
  inline double survivalProbability() const { return survivalProbability_; };
  inline void setSurvivalProbability(double val) { survivalProbability_ = val; };
 
  CLHEP::Hep2Vector& edge(unsigned iside, int n);
 
  CLHEP::Hep2Vector& edge(CaloDirection);
 
  inline unsigned getNumber() const { return number_; };
 
  /*
  inline XYZPoint originalCoordinates(CLHEP::Hep2Vector point) const
    {
      XYZPoint p(point.x(),point.y(),0.);
      return trans_.Inverse() * p;
    }
  */
 
  inline bool operator==(const CrystalPad& quad) const {
    //      std::cout << " First " << quad.getCellID() << " Second " << this->getCellID() << std::endl;
    return quad.getNumber() == this->getNumber();
  }
 
  inline bool operator<(const CrystalPad& quad) const { return (center_.mag() < quad.center().mag()); }
 
  void extrems(double& xmin, double& xmax, double& ymin, double& ymax) const;
 
  inline const CLHEP::Hep2Vector& center() const { return center_; }
 
  void getDrawingCoordinates(std::vector<float>& x, std::vector<float>& y) const;
 
private:
  static std::vector<CLHEP::Hep2Vector> aVector;
 
  std::vector<CLHEP::Hep2Vector> corners_;
  std::vector<CLHEP::Hep2Vector> dir_;
  unsigned number_;
  Transform3D trans_;
  ROOT::Math::Rotation3D rotation_;
  XYZVector translation_;
  double survivalProbability_;
  CLHEP::Hep2Vector center_;
  double epsilon_;
  bool dummy_;
  double yscalefactor_;
 
public:
  class padEqual {
  public:
    padEqual(unsigned cell)
        : ref_(cell){
              //        std::cout << " quadEqual " << ref_ << std::endl;
          };
    ~padEqual() { ; };
    inline bool operator()(const CrystalPad& quad) const { return (ref_ == quad.getNumber()); }
 
  private:
    unsigned ref_;
  };
};
 
#include <iosfwd>
std::ostream& operator<<(std::ostream& o, CrystalPad& quad);
 
#endif