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);
}  // namespace rawparticle
 
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