EMTrackFit.cxx File Reference

#include "egammaEvent/EMTrackFit.h"
#include "AthenaKernel/BaseInfo.h"
#include "AthenaKernel/ClassName.h"
#include "GaudiKernel/GaudiException.h"
#include "TrkMaterialOnTrack/EstimatedBremOnTrack.h"
#include "TrkSurfaces/PerigeeSurface.h"
#include "TrkSurfaces/Surface.h"
#include "TrkTrack/Track.h"
#include <cmath>

Include dependency graph for EMTrackFit.cxx:

Go to the source code of this file.

Functions
	AmgSymMatrix (5) EMTrackFit
	SG_ADD_BASE (EMTrackFit, egDetail)

Function Documentation

AmgSymMatrix()

AmgSymMatrix

(

5

)

Definition at line 307 of file EMTrackFit.cxx.

{
  // Make a 5x5 matrix that is filled with zero's alternatively we could fill it with the identity matrix;
  // Chosen the identity matrix option
  AmgSymMatrix(5) hepSymMatrix;
  hepSymMatrix.setIdentity();
  // Fill the matrix
  hepSymMatrix.fillSymmetric(0,0, track_perigee_Covd0d0());
  hepSymMatrix.fillSymmetric(0,1, track_perigee_Covd0z0());
  hepSymMatrix.fillSymmetric(0,2, track_perigee_Covd0phi());
  hepSymMatrix.fillSymmetric(0,3, track_perigee_Covd0theta());
  hepSymMatrix.fillSymmetric(0,4, track_perigee_Covd0qOverP());
  hepSymMatrix.fillSymmetric(1,1, track_perigee_Covz0z0());
  hepSymMatrix.fillSymmetric(1,2, track_perigee_Covz0phi());
  hepSymMatrix.fillSymmetric(1,3, track_perigee_Covz0theta());
  hepSymMatrix.fillSymmetric(1,4, track_perigee_Covz0qOverP());
  hepSymMatrix.fillSymmetric(2,2, track_perigee_Covphiphi());
  hepSymMatrix.fillSymmetric(2,3, track_perigee_Covphitheta());
  hepSymMatrix.fillSymmetric(2,4, track_perigee_CovphiqOverP());
  hepSymMatrix.fillSymmetric(3,3, track_perigee_Covthetatheta());
  hepSymMatrix.fillSymmetric(3,4, track_perigee_CovthetaqOverP());
  hepSymMatrix.fillSymmetric(4,4, track_perigee_CovqOverPqOverP());
 
 
  return hepSymMatrix;
 
}
 
// ================================================================
const Trk::Perigee* EMTrackFit::getMeasuredPerigee () const
{
  // Create a MeasuredPerigee from the individual doubles stored in the class.
 
  const Trk::PerigeeSurface   surface;
 
  const Trk::Perigee* measuredPerigee =
    surface
      .createUniqueParameters<5, Trk::Charged>(track_perigee_d0(),
                                               track_perigee_z0(),
                                               track_perigee_phi0(),
                                               track_perigee_theta(),
                                               track_perigee_qOverP(),
                                               getErrorMatrix())
      .release();
 
  return measuredPerigee;
 
}
 
// =====================================================================
bool EMTrackFit::hasParameter(egammaParameters::ParamDef key) const {
  if ( hasIntParameter(key) )                                   return true;
  if ( key == egammaParameters::refittedTrack_d0 )         return true;
  else if ( key == egammaParameters::refittedTrack_phi0 )       return true;
  else if ( key == egammaParameters::refittedTrack_qOverP )     return true;
  else if ( key == egammaParameters::refittedTrack_z0 )         return true;
  else if ( key == egammaParameters::refittedTrack_theta )      return true;
  else if ( key == egammaParameters::refittedTrack_Covd0d0 )    return true;
  else if ( key == egammaParameters::refittedTrack_Covd0z0 )    return true;
  else if ( key == egammaParameters::refittedTrack_Covd0phi )   return true;
  else if ( key == egammaParameters::refittedTrack_Covd0theta ) return true;
  else if ( key == egammaParameters::refittedTrack_Covd0qOverP) return true;
  else if ( key == egammaParameters::refittedTrack_Covz0z0 )    return true;
  else if ( key == egammaParameters::refittedTrack_Covz0phi )   return true;
  else if ( key == egammaParameters::refittedTrack_Covz0theta ) return true;
  else if ( key == egammaParameters::refittedTrack_Covz0qOverP )return true;
  else if ( key == egammaParameters::refittedTrack_Covphiphi )  return true;
  else if ( key == egammaParameters::refittedTrack_Covphitheta )return true;
  else if ( key == egammaParameters::refittedTrack_CovphiqOverP)return true;
  else if ( key == egammaParameters::refittedTrack_Covthetatheta )return true;
  else if ( key == egammaParameters::refittedTrack_CovthetaqOverP)return true;
  else if ( key == egammaParameters::refittedTrack_CovqOverPqOverP)return true;
  else if ( key == egammaParameters::refittedTrackLastM_loc1 )  return true;
  else if ( key == egammaParameters::refittedTrackLastM_loc2 )  return true;
  else if ( key == egammaParameters::refittedTrackLastM_phi )   return true;
  else if ( key == egammaParameters::refittedTrackLastM_theta ) return true;
  else if ( key == egammaParameters::refittedTrackLastM_qOverP )return true;
  else if ( key == egammaParameters::bremDeltaQoverP )          return true;
  else if ( key == egammaParameters::bremDeltaQoverPErr )       return true;
  else if ( key == egammaParameters::bremMaterialTraversed )    return true;
  else if ( key == egammaParameters::bremRadius )               return true;
  else if ( key == egammaParameters::bremClusterRadius )        return true;
  else if ( key == egammaParameters::bremFitChi2 )              return true;
  return false;
}
 
// =====================================================================
bool EMTrackFit::hasIntParameter(egammaParameters::ParamDef key) const {
  if (key == egammaParameters::hasBrem)                       return true;
  if (key == egammaParameters::bremTrackAuthor )         return true;
  else if (key == egammaParameters::bremFitStatus )         return true;
  else if (key == egammaParameters::linkIndex )               return true;
 
  return false;
}
 
// =======================================================================
double EMTrackFit::track_perigee_d0    ()  const {return parameter(egammaParameters::refittedTrack_d0)  ;}
double EMTrackFit::track_perigee_phi0  ()  const {return parameter(egammaParameters::refittedTrack_phi0)  ;}
double EMTrackFit::track_perigee_qOverP()  const {return parameter(egammaParameters::refittedTrack_qOverP)  ;}
double EMTrackFit::track_perigee_z0    ()  const {return parameter(egammaParameters::refittedTrack_z0)  ;}
double EMTrackFit::track_perigee_theta ()  const {return parameter(egammaParameters::refittedTrack_theta)  ;}
 
double EMTrackFit::track_perigee_Covd0d0         () const {return parameter(egammaParameters::refittedTrack_Covd0d0)  ;}
double EMTrackFit::track_perigee_Covd0z0         () const {return parameter(egammaParameters::refittedTrack_Covd0z0)  ;}
double EMTrackFit::track_perigee_Covd0phi        () const {return parameter(egammaParameters::refittedTrack_Covd0phi)  ;}
double EMTrackFit::track_perigee_Covd0theta      () const {return parameter(egammaParameters::refittedTrack_Covd0theta)  ;}
double EMTrackFit::track_perigee_Covd0qOverP     () const {return parameter(egammaParameters::refittedTrack_Covd0qOverP)  ;}
double EMTrackFit::track_perigee_Covz0z0         () const {return parameter(egammaParameters::refittedTrack_Covz0z0)  ;}
double EMTrackFit::track_perigee_Covz0phi        () const {return parameter(egammaParameters::refittedTrack_Covz0phi)  ;}
double EMTrackFit::track_perigee_Covz0theta      () const {return parameter(egammaParameters::refittedTrack_Covz0theta)  ;}
double EMTrackFit::track_perigee_Covz0qOverP     () const {return parameter(egammaParameters::refittedTrack_Covz0qOverP)  ;}
double EMTrackFit::track_perigee_Covphiphi       () const {return parameter(egammaParameters::refittedTrack_Covphiphi)  ;}
double EMTrackFit::track_perigee_Covphitheta     () const {return parameter(egammaParameters::refittedTrack_Covphitheta)  ;}
double EMTrackFit::track_perigee_CovphiqOverP    () const {return parameter(egammaParameters::refittedTrack_CovphiqOverP)  ;}
double EMTrackFit::track_perigee_Covthetatheta   () const {return parameter(egammaParameters::refittedTrack_Covthetatheta)  ;}
double EMTrackFit::track_perigee_CovthetaqOverP  () const {return parameter(egammaParameters::refittedTrack_CovthetaqOverP)  ;}
double EMTrackFit::track_perigee_CovqOverPqOverP () const {return parameter(egammaParameters::refittedTrack_CovqOverPqOverP)  ;}
 
double EMTrackFit::track_LastM_loc1    ()  const {return parameter(egammaParameters::refittedTrackLastM_loc1)  ;}
double EMTrackFit::track_LastM_loc2    ()  const {return parameter(egammaParameters::refittedTrackLastM_loc2)  ;}
double EMTrackFit::track_LastM_phi     ()  const {return parameter(egammaParameters::refittedTrackLastM_phi)  ;}
double EMTrackFit::track_LastM_theta   ()  const {return parameter(egammaParameters::refittedTrackLastM_theta)  ;}
double EMTrackFit::track_LastM_qOverP  ()  const {return parameter(egammaParameters::refittedTrackLastM_qOverP)  ;}
 
void EMTrackFit::track_perigee_d0    (double x)  { set_parameter(egammaParameters::refittedTrack_d0,                        x, true); }

SG_ADD_BASE()

SG_ADD_BASE	(	EMTrackFit	,
		egDetail	)