RawParticle.h

Go to the documentation of this file.

#ifndef CommonTools_BaseParticlePropagator_RawParticle_h
#define CommonTools_BaseParticlePropagator_RawParticle_h


#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/Math/interface/Vector3D.h"

#include "Math/GenVector/RotationX.h"
#include "Math/GenVector/RotationY.h"
#include "Math/GenVector/RotationZ.h"
#include "Math/GenVector/Rotation3D.h"
#include "Math/GenVector/AxisAngle.h"
#include "Math/GenVector/Boost.h"

#include <string>
#include <iosfwd>

#include<memory>


typedef math::XYZTLorentzVector XYZTLorentzVector;
typedef math::XYZVector XYZVector;

class RawParticle;

namespace rawparticle {
  RawParticle makeMuon(bool isParticle, const XYZTLorentzVector& p, 
                       const XYZTLorentzVector& xStart);
}

class RawParticle {
public:

  friend RawParticle rawparticle::makeMuon(bool, const XYZTLorentzVector&, const XYZTLorentzVector&);
  friend RawParticle unchecked_makeParticle(int id, const math::XYZTLorentzVector& p, double mass, double charge);
  friend RawParticle unchecked_makeParticle(int id, const math::XYZTLorentzVector& p, const math::XYZTLorentzVector& xStart, double mass, double charge);

  typedef ROOT::Math::AxisAngle Rotation;
  typedef ROOT::Math::Rotation3D Rotation3D;
  typedef ROOT::Math::RotationX RotationX;
  typedef ROOT::Math::RotationY RotationY;
  typedef ROOT::Math::RotationZ RotationZ;
  typedef ROOT::Math::Boost Boost;

  RawParticle() = default;

  RawParticle(const XYZTLorentzVector& p);

  RawParticle(const XYZTLorentzVector& p, 
          const XYZTLorentzVector& xStart,
              double charge = 0.);

  RawParticle(double px, double py, double pz, double e, double charge =0.);

  RawParticle(const RawParticle &p) = default;
  RawParticle(RawParticle &&p) = default;

  RawParticle&  operator = (const RawParticle & rhs ) = default;
  RawParticle&  operator = (RawParticle&& rhs ) = default;

public:

  void setStatus(int istat);

  void setMass(float m);   

  void setCharge(float q);

  void setT(const double t);

  void setVertex(const XYZTLorentzVector& vtx); 
  void setVertex(double xv, double yv, double zv, double tv); 

  void setMomentum(const XYZTLorentzVector& vtx); 
  void setMomentum(double xv, double yv, double zv, double tv); 

  void SetPx(double);
  void SetPy(double);
  void SetPz(double);
  void SetE(double);

  /***  methods to be overloaded to include vertex ***/

  void boost(double bx, double by, double bz);
  void boost(const Boost& b);
  
  //  inline void boost(const Hep3Vector<double> &bv );

  void rotate(double rphi, const XYZVector& raxis);
  void rotate(const Rotation& r);
  void rotate(const Rotation3D& r);

  //   void rotateUz(Hep3Vector &nuz);

  void rotateX(double rphi); 
  void rotate(const RotationX& r);

  void rotateY(double rphi);
  void rotate(const RotationY& r);
  void rotateZ(double rphi);
  void rotate(const RotationZ& r);

  void translate(const XYZVector& t);

  //  inline RawParticle & transform(const HepRotation &rot);
  //  inline RawParticle & transform(const HepLorentzRotation &rot);

  void chargeConjugate();
  
  int    pid() const;         
  
  int    status() const;      
  
  double charge() const;      
  
  double mass() const;        
  
  double eta() const; 

  double cos2Theta() const;
  double cos2ThetaV() const;
  
  double et() const;   
  
  double x() const;  
  double X() const;  
  
  double y() const;  
  double Y() const;  
  
  double z() const;  
  double Z() const;  
  
  double t() const;  
  double T() const;  
  
  double r() const;  
  double R() const;  
  
  double r2() const;  
  double R2() const;  
  
  const XYZTLorentzVector& vertex() const;   

  double px() const; 
  double Px() const; 

  double py() const; 
  double Py() const; 

  double pz() const; 
  double Pz() const; 

  double e() const; 
  double E() const; 

  double Pt() const; 
  double pt() const; 

  double Perp2() const; 

  double mag() const; 

  double theta() const; 
  double phi() const; 

  double M2() const; 

  const XYZTLorentzVector& momentum() const;   
  XYZTLorentzVector& momentum();   
  
  XYZVector Vect() const; 

  void printName() const; 
  
  void print() const;
  
  int isUsed() const {return myUsed;}
  
  void use() { myUsed = 1;}    
  
  void reUse() { myUsed = 0;}  
  
 private:

  RawParticle(const int id, 
          const XYZTLorentzVector& p,
              double mass,
              double charge);


  RawParticle(const int id, 
          const XYZTLorentzVector& p,
              const XYZTLorentzVector& xStart,
              double mass,
              double charge);

  
 private:

  XYZTLorentzVector myMomentum;       
  XYZTLorentzVector myVertex;         
  double myCharge= 0.;                
  double myMass = 0.;                 
  int myId = 0;                       
  int myStatus=99;                    
  int myUsed = 0;                     

};


std::ostream& operator <<(std::ostream& o , const RawParticle& p); 

inline int RawParticle::pid() const { return myId; }
inline int RawParticle::status() const { return myStatus; }
inline double RawParticle::eta() const { return -std::log(std::tan(this->theta()/2.)); }
inline double RawParticle::cos2Theta() const { return Pz()*Pz()/myMomentum.Vect().Mag2(); }
inline double RawParticle::cos2ThetaV() const { return Z()*Z()/myVertex.Vect().Mag2(); }
inline double RawParticle::x() const { return myVertex.Px(); }
inline double RawParticle::y() const { return myVertex.Py(); }
inline double RawParticle::z() const { return myVertex.Pz(); }
inline double RawParticle::t() const { return myVertex.E(); }
inline double RawParticle::X() const { return myVertex.Px(); }
inline double RawParticle::Y() const { return myVertex.Py(); }
inline double RawParticle::Z() const { return myVertex.Pz(); }
inline double RawParticle::T() const { return myVertex.E(); }
inline double RawParticle::R() const { return std::sqrt(R2()); }
inline double RawParticle::R2() const { return myVertex.Perp2(); }
inline double RawParticle::r() const { return std::sqrt(r2()); }
inline double RawParticle::r2() const { return myVertex.Perp2(); }
inline double RawParticle::charge() const { return myCharge; }
inline double RawParticle::mass() const { return myMass; }
inline double RawParticle::px() const { return myMomentum.px() ; }
inline double RawParticle::Px() const { return myMomentum.Px() ; }

inline double RawParticle::py() const { return myMomentum.py() ; }
inline double RawParticle::Py() const { return myMomentum.Py() ; }

inline double RawParticle::pz() const { return myMomentum.pz() ; }
inline double RawParticle::Pz() const { return myMomentum.Pz() ; }

inline double RawParticle::e() const { return myMomentum.e() ; }
inline double RawParticle::E() const { return myMomentum.E() ; }

inline double RawParticle::Pt() const { return myMomentum.Pt() ; }
inline double RawParticle::pt() const { return myMomentum.pt() ; }

inline double RawParticle::Perp2() const { return  myMomentum.Perp2(); }

inline double RawParticle::mag() const { return  myMomentum.mag(); }

inline double RawParticle::theta() const { return myMomentum.theta(); }
inline double RawParticle::phi() const { return myMomentum.phi(); }

inline double RawParticle::M2() const { return myMomentum.M2(); }

inline const XYZTLorentzVector&  RawParticle::vertex() const { return myVertex ; }
inline const XYZTLorentzVector&  RawParticle::momentum() const { return myMomentum; }
inline XYZTLorentzVector&  RawParticle::momentum() { return myMomentum; }
inline XYZVector RawParticle::Vect() const { return myMomentum.Vect(); }

inline void RawParticle::setVertex(const XYZTLorentzVector& vtx) { myVertex = vtx; }
inline void RawParticle::setVertex(double a, double b, double c, double d) { myVertex.SetXYZT(a,b,c,d); }

inline void RawParticle::setMomentum(const XYZTLorentzVector& p4) { myMomentum = p4; }
inline void RawParticle::setMomentum(double a, double b, double c, double d) { myMomentum.SetXYZT(a,b,c,d); }

inline void RawParticle::SetPx(double px) {myMomentum.SetPx(px);}
inline void RawParticle::SetPy(double py) {myMomentum.SetPy(py);}
inline void RawParticle::SetPz(double pz) {myMomentum.SetPz(pz);}
inline void RawParticle::SetE(double e) {myMomentum.SetE(e);}


inline void RawParticle::rotate(const RawParticle::Rotation3D& r) { 
  XYZVector v ( r(myMomentum.Vect()) ); setMomentum(v.X(),v.Y(),v.Z(),E());
}

inline void RawParticle::rotate(const RawParticle::Rotation& r) { 
  XYZVector v ( r(myMomentum.Vect()) ); setMomentum(v.X(),v.Y(),v.Z(),E());
}

inline void RawParticle::rotate(const RawParticle::RotationX& r) { 
  XYZVector v ( r(myMomentum.Vect()) ); setMomentum(v.X(),v.Y(),v.Z(),E());
}

inline void RawParticle::rotate(const RawParticle::RotationY& r) { 
  XYZVector v ( r(myMomentum.Vect()) ); setMomentum(v.X(),v.Y(),v.Z(),E());
}

inline void RawParticle::rotate(const RawParticle::RotationZ& r) { 
  XYZVector v ( r(myMomentum.Vect()) ); setMomentum(v.X(),v.Y(),v.Z(),E());
}

inline void RawParticle::boost(const RawParticle::Boost& b) { 
  XYZTLorentzVector p ( b(momentum()) ); setMomentum(p.Px(),p.Py(),p.Pz(),p.E());
}

inline void RawParticle::translate(const XYZVector& tr) { 
  myVertex.SetXYZT(X()+tr.X(),Y()+tr.Y(),Z()+tr.Z(),T());
}

#endif