ForwardProton.h

Go to the documentation of this file.

/****************************************************************************
 * Authors:
 *   Jan Kašpar
 *   Laurent Forthomme
 ****************************************************************************/

#ifndef DataFormats_ProtonReco_ForwardProton_h
#define DataFormats_ProtonReco_ForwardProton_h

#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"

#include "DataFormats/Common/interface/RefVector.h"

#include "DataFormats/CTPPSReco/interface/CTPPSLocalTrackLiteFwd.h"

namespace reco
{
  class ForwardProton
  {
    public:
      enum { dimension = 5 };
      enum struct Index { xi, th_x, vtx_x, th_y, vtx_y, num_indices = dimension };
      typedef math::ErrorF<dimension>::type CovarianceMatrix;
      typedef math::XYZVectorF Vector;
      typedef math::XYZPointF Point;
      enum class ReconstructionMethod { invalid = -1, singleRP, multiRP };

    public:
      ForwardProton();
      ForwardProton( double chi2, double ndof, const Point& vtx, const Vector& momentum, float xi,
                      const CovarianceMatrix& cov, ReconstructionMethod method,
                      const CTPPSLocalTrackLiteRefVector& local_tracks, bool valid,
                      const float time=0., const float time_err=0. );

      const Point& vertex() const { return vertex_; }
      float vx() const { return vertex_.x(); }
      float vy() const { return vertex_.y(); }
      float vz() const { return vertex_.z(); }
      const Vector& momentum() const { return momentum_; }
      float p() const { return momentum_.r(); }
      float pt() const { return momentum_.rho(); }
      float px() const { return momentum_.x(); }
      float py() const { return momentum_.y(); }
      float pz() const { return momentum_.z(); }

      float chi2() const { return chi2_; }
      unsigned int ndof() const { return ndof_; }
      float normalizedChi2() const {
        return ( ndof_ != 0 ) ? chi2_ / ndof_ : chi2_ * 1.e6;
      }

      float xi() const { return xi_; }
      float thetaX() const { return px() / p(); }
      float thetaY() const { return py() / p(); }

      // vertex position can be obtained via TrackBase::vx() and vy() functions

      double error( Index i ) const {
        return sqrt( covariance_( (unsigned int)i, (unsigned int)i ) );
      }

      float xiError() const { return error( Index::xi ); }
      float thetaXError() const { return error( Index::th_x ); }
      float thetaYError() const { return error( Index::th_y ); }
      float vxError() const { return error( Index::vtx_x ); }
      float vyError() const { return error( Index::vtx_y ); }

      static float mass() { return mass_; }

      static float calculateT( double beam_mom, double proton_mom, double theta );

      float t() const;

      float time() const { return time_; }
      void setTime(float time) { time_ = time; }

      float timeError() const { return time_err_; }
      void setTimeError(float time_err) { time_err_ = time_err; }

      void setValidFit( bool valid = true ) { valid_fit_ = valid; }
      bool validFit() const { return valid_fit_; }

      void setMethod( const ReconstructionMethod& method ) { method_ = method; }
      ReconstructionMethod method() const { return method_; }

      void setContributingLocalTracks( const CTPPSLocalTrackLiteRefVector &v ) { contributing_local_tracks_ = v; }
      const CTPPSLocalTrackLiteRefVector& contributingLocalTracks() const { return contributing_local_tracks_; }

      enum class LHCSector { invalid = -1, sector45, sector56 };
      LHCSector lhcSector() const
      {
        if ( pz() < 0. ) return LHCSector::sector56;
        if ( pz() > 0. ) return LHCSector::sector45;
        return LHCSector::invalid;
      }

    private:
      static constexpr float mass_ = 0.938272046; 
      static constexpr float massSquared_ = 0.88035443; 

      Point vertex_;
      Vector momentum_;
      float time_;
      float time_err_;
      float xi_;
      CovarianceMatrix covariance_;
      float chi2_;
      unsigned int ndof_;
      bool valid_fit_;
      ReconstructionMethod method_;
      CTPPSLocalTrackLiteRefVector contributing_local_tracks_;
  };
}

#endif