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