BaseParticlePropagator.h

Go to the documentation of this file.

/*Emacs: -*- C++ -*- */
#ifndef CommonTools_BaseParticlePropagator_BaseParticlePropagator_h
#define CommonTools_BaseParticlePropagator_BaseParticlePropagator_h
 
//FAMOS
#include "CommonTools/BaseParticlePropagator/interface/RawParticle.h"
 
class BaseParticlePropagator {
public:
  BaseParticlePropagator();
 
  BaseParticlePropagator(const RawParticle& myPart, double r, double z, double B);
  BaseParticlePropagator(const RawParticle& myPart, double r, double z, double B, double t);
 
  void init();
 
  bool propagate();
 
  bool backPropagate();
 
  BaseParticlePropagator propagated() const;
 
  bool propagateToClosestApproach(double x0 = 0., double y0 = 0, bool first = true);
  bool propagateToEcal(bool first = true);
  bool propagateToPreshowerLayer1(bool first = true);
  bool propagateToPreshowerLayer2(bool first = true);
  bool propagateToEcalEntrance(bool first = true);
  bool propagateToHcalEntrance(bool first = true);
  bool propagateToVFcalEntrance(bool first = true);
  bool propagateToHcalExit(bool first = true);
  bool propagateToHOLayer(bool first = true);
  bool propagateToNominalVertex(const XYZTLorentzVector& hit2 = XYZTLorentzVector(0., 0., 0., 0.));
  bool propagateToBeamCylinder(const XYZTLorentzVector& v, double radius = 0.);
  void setPropagationConditions(double r, double z, bool firstLoop = true);
 
private:
  RawParticle particle_;
  //  RawParticle   particle;
  double rCyl;
  double rCyl2;
  double zCyl;
  double bField;
  double properDecayTime;
  bool debug;
 
protected:
  int success;
  bool fiducial;
 
  inline double c_light() const { return 299.792458; }
 
private:
  bool firstLoop;
  bool decayed;
  double properTime;
  int propDir;
 
public:
  inline RawParticle const& particle() const { return particle_; }
  inline RawParticle& particle() { return particle_; }
  void setParticle(RawParticle const& iParticle) { particle_ = iParticle; }
 
  inline void setProperDecayTime(double t) { properDecayTime = t; }
 
  inline void increaseRCyl(double delta) {
    rCyl = rCyl + delta;
    rCyl2 = rCyl * rCyl;
  }
 
  double xyImpactParameter(double x0 = 0., double y0 = 0.) const;
 
  inline double zImpactParameter(double x0 = 0, double y0 = 0.) const {
    // Longitudinal impact parameter
    return particle_.Z() - particle_.Pz() * std::sqrt(((particle_.X() - x0) * (particle_.X() - x0) +
                                                       (particle_.Y() - y0) * (particle_.Y() - y0)) /
                                                      particle_.Perp2());
  }
 
  inline double helixRadius() const {
    // The helix Radius
    //
    // The helix' Radius sign accounts for the orientation of the magnetic field
    // (+ = along z axis) and the sign of the electric charge of the particle.
    // It signs the rotation of the (charged) particle around the z axis:
    // Positive means anti-clockwise, negative means clockwise rotation.
    //
    // The radius is returned in cm to match the units in RawParticle.
    return particle_.charge() == 0 ? 0.0 : -particle_.Pt() / (c_light() * 1e-5 * bField * particle_.charge());
  }
 
  inline double helixRadius(double pT) const {
    // a faster version of helixRadius, once Perp() has been computed
    return particle_.charge() == 0 ? 0.0 : -pT / (c_light() * 1e-5 * bField * particle_.charge());
  }
 
  inline double helixStartPhi() const {
    // The azimuth of the momentum at the vertex
    return particle_.Px() == 0.0 && particle_.Py() == 0.0 ? 0.0 : std::atan2(particle_.Py(), particle_.Px());
  }
 
  inline double helixCentreX() const {
    // The x coordinate of the helix axis
    return particle_.X() - helixRadius() * std::sin(helixStartPhi());
  }
 
  inline double helixCentreX(double radius, double phi) const {
    // Fast version of helixCentreX()
    return particle_.X() - radius * std::sin(phi);
  }
 
  inline double helixCentreY() const {
    // The y coordinate of the helix axis
    return particle_.Y() + helixRadius() * std::cos(helixStartPhi());
  }
 
  inline double helixCentreY(double radius, double phi) const {
    // Fast version of helixCentreX()
    return particle_.Y() + radius * std::cos(phi);
  }
 
  inline double helixCentreDistToAxis() const {
    // The distance between the cylinder and the helix axes
    double xC = helixCentreX();
    double yC = helixCentreY();
    return std::sqrt(xC * xC + yC * yC);
  }
 
  inline double helixCentreDistToAxis(double xC, double yC) const {
    // Faster version of helixCentreDistToAxis
    return std::sqrt(xC * xC + yC * yC);
  }
 
  inline double helixCentrePhi() const {
    // The azimuth if the vector joining the cylinder and the helix axes
    double xC = helixCentreX();
    double yC = helixCentreY();
    return xC == 0.0 && yC == 0.0 ? 0.0 : std::atan2(yC, xC);
  }
 
  inline double helixCentrePhi(double xC, double yC) const {
    // Faster version of helixCentrePhi()
    return xC == 0.0 && yC == 0.0 ? 0.0 : std::atan2(yC, xC);
  }
 
  inline bool inside() const {
    return (particle_.R2() < rCyl2 - 0.00001 * rCyl && fabs(particle_.Z()) < zCyl - 0.00001);
  }
 
  inline bool inside(double rPos2) const {
    return (rPos2 < rCyl2 - 0.00001 * rCyl && fabs(particle_.Z()) < zCyl - 0.00001);
  }
 
  inline bool onSurface() const { return (onBarrel() || onEndcap()); }
 
  inline bool onSurface(double rPos2) const { return (onBarrel(rPos2) || onEndcap(rPos2)); }
 
  inline bool onBarrel() const {
    double rPos2 = particle_.R2();
    return (fabs(rPos2 - rCyl2) < 0.00001 * rCyl && fabs(particle_.Z()) <= zCyl);
  }
 
  inline bool onBarrel(double rPos2) const {
    return (fabs(rPos2 - rCyl2) < 0.00001 * rCyl && fabs(particle_.Z()) <= zCyl);
  }
 
  inline bool onEndcap() const { return (fabs(fabs(particle_.Z()) - zCyl) < 0.00001 && particle_.R2() <= rCyl2); }
 
  inline bool onEndcap(double rPos2) const { return (fabs(fabs(particle_.Z()) - zCyl) < 0.00001 && rPos2 <= rCyl2); }
 
  inline bool onFiducial() const { return fiducial; }
 
  inline bool hasDecayed() const { return decayed; }
 
  inline int getSuccess() const { return success; }
 
  inline void setMagneticField(double b) { bField = b; }
 
  inline double getMagneticField() const { return bField; }
 
  inline void setDebug() { debug = true; }
  inline void resetDebug() { debug = false; }
};
 
#endif