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