/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/DataFormats/BeamSpot/interface/BeamSpot.h

Go to the documentation of this file.

#ifndef BeamSpot_BeamSpot_h
#define BeamSpot_BeamSpot_h

#include <Rtypes.h>
#include "DataFormats/Math/interface/Error.h"
#include "DataFormats/Math/interface/Point3D.h"
#include <string>
#include <sstream>


namespace reco {

  class BeamSpot {
  public:
          
    enum BeamType { Unknown=-1, Fake=0, LHC=1, Tracker=2 };
    
    typedef math::XYZPoint Point;
    enum { dimension = 7 };
    typedef math::Error<dimension>::type CovarianceMatrix;
    enum { dim3 = 3 };
    typedef math::Error<dim3>::type Covariance3DMatrix;
    enum { resdim = 2 };
    typedef math::Error<resdim>::type ResCovMatrix;
        
    BeamSpot();

    BeamSpot( const Point &point,
              double sigmaZ,
              double dxdz,
              double dydz,
              double BeamWidthX,
                  const CovarianceMatrix &error,
                  BeamType type = Unknown) { 
      position_ = point;
      sigmaZ_ = sigmaZ;
      dxdz_ = dxdz;
      dydz_ = dydz;
      BeamWidthX_ = BeamWidthX;
      BeamWidthY_ = BeamWidthX;
      error_ = error;
          type_ = type;
          emittanceX_ = emittanceY_ = 0;
          betaStar_ = 0;
    };

        
    const Point & position() const { return position_; }
    double x0() const { return position_.X(); }
    double y0() const { return position_.Y(); }
    double z0() const { return position_.Z(); }

    double x(const double z) const { return x0() + dxdz() * (z - z0()); }
    double y(const double z) const { return y0() + dydz() * (z - z0()); }
    const Point position(const double z) const;
    //    const Point position(const double z) const {Point pos(x(z),y(z),z);    return pos;}


    double sigmaZ() const { return sigmaZ_; }
    double dxdz() const { return dxdz_; }
    double dydz() const { return dydz_; }
    double BeamWidthX() const { return BeamWidthX_; }
    double BeamWidthY() const { return BeamWidthY_; }
    double x0Error() const { return sqrt( error_(0,0) ); }
    double y0Error() const { return sqrt( error_(1,1) ); }
    double z0Error() const { return sqrt( error_(2,2) ); }
    double sigmaZ0Error() const { return sqrt ( error_(3,3) ); }
    double dxdzError() const { return sqrt ( error_(4,4) ); }
    double dydzError() const { return sqrt ( error_(5,5) ); }

    double BeamWidthXError() const { return sqrt ( error_(6,6) );}
    double BeamWidthYError() const { return sqrt ( error_(6,6) );}
                
        void setBeamWidthX( double v ) { BeamWidthX_ = v; }
        void setBeamWidthY( double v ) { BeamWidthY_ = v; }
        
    double covariance( int i, int j) const {
      return error_(i,j);
    }
    CovarianceMatrix covariance() const { return error_; }
    Covariance3DMatrix covariance3D() const {

                Covariance3DMatrix matrix;
                for (int j=0; j<3; j++) {
                        for (int k=j; k<3; k++) {
                                matrix(j,k) = error_(j,k);
                        }
                }
      return matrix;
    };
        BeamType type() const { return type_; }
        void setType( BeamType type ) { type_ = type; }
    Covariance3DMatrix rotatedCovariance3D() const;

        double emittanceX() const { return emittanceX_; }
        double emittanceY() const { return emittanceY_; }
        double betaStar() const { return betaStar_; }
        double beamWidthFromBeta( double z, double e ) const {
                return sqrt( e*betaStar_*(1 + pow((z-position_.Z())/betaStar_,2) ) );
        }
        void setEmittanceX( double v ) { emittanceX_ = v; }
        void setEmittanceY( double v ) { emittanceY_ = v; }
        void setbetaStar( double v ) { betaStar_ = v; }
        
    void print( std::stringstream& ss ) const;

  private:
        Point position_;
        CovarianceMatrix error_;

        Double32_t sigmaZ_;
        Double32_t BeamWidthX_;
        Double32_t BeamWidthY_;
        Double32_t dxdz_;
        Double32_t dydz_;
        Double32_t emittanceX_;
        Double32_t emittanceY_;
        Double32_t betaStar_;
        
        BeamType type_;
        
  };
  std::ostream& operator<< ( std::ostream&, BeamSpot beam );

}

#endif