RawParticle.h

Go to the documentation of this file.

#ifndef RAWPARTTICLE_H
#define RAWPARTTICLE_H

#include "SimGeneral/HepPDTRecord/interface/ParticleDataTable.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"

class ParticleTable;

#include <string>
#include <iosfwd>

#include<memory>


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

class RawParticle : public XYZTLorentzVector {
public:

  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();

  virtual ~RawParticle();

  RawParticle(const XYZTLorentzVector& p);

  RawParticle(const int id, 
          const XYZTLorentzVector& p);

  RawParticle(const std::string name, 
          const XYZTLorentzVector& p);

  RawParticle(const XYZTLorentzVector& p, 
          const XYZTLorentzVector& xStart);

  RawParticle(double px, double py, double pz, double e);

  RawParticle(const RawParticle &p);

  RawParticle&  operator = (const RawParticle & rhs );

public:

  void setID(const int id); 

  void setID(const std::string name); 

  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); 

  /***  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 PDGcharge() const;   
  
  double mass() const;        
  
  double PDGmass() const;     
  
  double PDGcTau() const;     
  
  std::string    PDGname() 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;   
  
  const XYZTLorentzVector& momentum() const;   
  
  void printName() const; 
  
  void print() const;
  
  int isUsed() const {return myUsed;}
  
  void use() { myUsed = 1;}    
  
  void reUse() { myUsed = 0;}  
  
 private:
  
  void init();
  
 protected:
  
  XYZTLorentzVector myVertex;         
  int myId;                           
  int myStatus;                       
  int myUsed;                         
  double myCharge;                    
  double myMass;                      
  const ParticleData* myInfo;         
  
 private:
  const ParticleTable* tab;
};


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()/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 const XYZTLorentzVector&  RawParticle::vertex() const { return myVertex ; }
inline const XYZTLorentzVector&  RawParticle::momentum() const { return *this; }

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::rotate(const RawParticle::Rotation3D& r) { 
  XYZVector v ( r(Vect()) ); SetXYZT(v.X(),v.Y(),v.Z(),E());
}

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

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

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

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

inline void RawParticle::boost(const RawParticle::Boost& b) { 
  XYZTLorentzVector p ( b(momentum()) ); SetXYZT(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