EMErrorDetail.cxx File Reference

#include "egammaEvent/EMErrorDetail.h"
#include "GaudiKernel/GaudiException.h"
#include "egammaEvent/EMShower.h"
#include "AthenaKernel/ClassName.h"
#include "AthLinks/ElementLink.h"
#include "TrkTrack/Track.h"
#include "TrkParametersBase/ParametersBase.h"
#include "TrkParticleBase/TrackParticleBase.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkNeutralParameters/NeutralParameters.h"
#include "VxVertex/VxTrackAtVertex.h"
#include "VxVertex/VxCandidate.h"
#include "AthenaKernel/BaseInfo.h"
#include <cmath>

Go to the source code of this file.

Functions
	AmgSymMatrix (3) EMErrorDetail
	AmgSymMatrix (5) EMErrorDetail
	AmgSymMatrix (4) EMErrorDetail
	SG_ADD_BASE (EMErrorDetail, egDetail)

Function Documentation

AmgSymMatrix() [1/3]

AmgSymMatrix

(

3

)

Definition at line 145 of file EMErrorDetail.cxx.

                                                            {
 
  // Make a 3x3 matrix that is filled with zero's alternatively we could fill it with the identity matrix;
  // Chosen the identity matrix option (second argument = 1)
  AmgSymMatrix(3) hepSymMatrix;
  hepSymMatrix.setZero();
  // Fill the matrix E,eta,phi,M
  hepSymMatrix(1,1) = EMphoton_CovEclusEclus();
  hepSymMatrix(2,2) = EMphoton_Covetaeta();
  hepSymMatrix(3,3) = EMphoton_Covphiphi();
 
  hepSymMatrix.fillSymmetric(1,2,EMphoton_CovetaEclus());
  hepSymMatrix.fillSymmetric(1,3,EMphoton_CovphiEclus());
  hepSymMatrix.fillSymmetric(2,3, EMphoton_Covetaphi());
 
   return hepSymMatrix;
 
}
 
// ====================================================================
Amg::MatrixX EMErrorDetail::getCombinedErrorMatrix() const
{
  // see if combined matrix exists, if so, return it, otherwise,
  // it's an unconverted photon, so just return the photon error
  // matrix.
  if (EMtrack_comb_CovPP() == egammaParameters::EgParamUndefined) {
    return getEMPhotonErrorMatrix();
  }
    return getEMTrackCombinedErrorMatrix();
 
}
 
// ====================================================================
Amg::MatrixX EMErrorDetail::getUncombinedErrorMatrix() const
{
  // this still looks for combined matrix to make the decision
  if (EMtrack_comb_CovPP() == egammaParameters::EgParamUndefined) {
    return getEMPhotonErrorMatrix();
  }
    return getEMTrackUncombinedErrorMatrix();
 
}
 
// ====================================================================
AmgSymMatrix(4) EMErrorDetail::get4x4CombinedErrorMatrix() const
{
  // see if combined matrix exists, if so, return it, otherwise,
  // it's an unconverted photon, so just return the photon error
  // matrix.
  if (EMtrack_comb_CovPP() == egammaParameters::EgParamUndefined) {
    return get4x4EMPhotonErrorMatrix();
  }
    return get4x4EMTrackCombinedErrorMatrix();
 
}
 
// ====================================================================
AmgSymMatrix(4) EMErrorDetail::get4x4UncombinedErrorMatrix() const
{
  // this still looks for combined matrix to make the decision
  if (EMtrack_comb_CovPP() == egammaParameters::EgParamUndefined) {
    return get4x4EMPhotonErrorMatrix();
  }
    return get4x4EMTrackUncombinedErrorMatrix();
 
}
 
// ====================================================================
AmgSymMatrix(5) EMErrorDetail::getEMTrackCombinedErrorMatrix() const {
 
  // 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.setZero();
  // Fill the matrix
  hepSymMatrix(0,0) = EMtrack_comb_Covd0d0();
  hepSymMatrix(1,1) = EMtrack_comb_Covz0z0();
  hepSymMatrix(2,2) = EMtrack_comb_Covphiphi();
  hepSymMatrix(3,3) = EMtrack_comb_Covetaeta();
  hepSymMatrix(4,4) = EMtrack_comb_CovPP();
 
 
  hepSymMatrix.fillSymmetric(0,1, EMtrack_comb_Covd0z0());
  hepSymMatrix.fillSymmetric(0,2 ,EMtrack_comb_Covd0phi());
  hepSymMatrix.fillSymmetric(0,3, EMtrack_comb_Covd0eta());
  hepSymMatrix.fillSymmetric(0,4, EMtrack_comb_Covd0P());
  hepSymMatrix.fillSymmetric(1,2, EMtrack_comb_Covz0phi());
  hepSymMatrix.fillSymmetric(1,3, EMtrack_comb_Covz0eta());
  hepSymMatrix.fillSymmetric(1,4, EMtrack_comb_Covz0P());
  hepSymMatrix.fillSymmetric(2,3, EMtrack_comb_Covphieta());
  hepSymMatrix.fillSymmetric(2,4, EMtrack_comb_CovphiP());
  hepSymMatrix.fillSymmetric(3,4, EMtrack_comb_CovetaP());
 
  return hepSymMatrix;
}
 
// ====================================================================
AmgSymMatrix(5) EMErrorDetail::getEMTrackUncombinedErrorMatrix() const {
 
  // Make a 5x5 matrix that is filled with zero's alternatively we could fill it with the identity matrix;
  // Chosen the identity matrix option
  // Fill the matrix
  if (hasSiliconHits()) {
    AmgSymMatrix(5) hepSymMatrix;
    hepSymMatrix.setZero();
    // use tracks for everything but energy
    hepSymMatrix(0,0) = EMtrack_perigee_Covd0d0();
    hepSymMatrix(1,1) = EMtrack_perigee_Covz0z0();
    hepSymMatrix(2,2) = EMtrack_perigee_Covphiphi();
    hepSymMatrix(3,3) = EMtrack_perigee_Covthetatheta();
    hepSymMatrix(4,4) = EMphoton_CovEclusEclus();
    //Symmetric fill
    hepSymMatrix.fillSymmetric(0,1,EMtrack_perigee_Covd0z0());
    hepSymMatrix.fillSymmetric(0,2,EMtrack_perigee_Covd0phi());
    hepSymMatrix.fillSymmetric(0,3,EMtrack_perigee_Covd0theta()); // note theta
    hepSymMatrix.fillSymmetric(0,4,0.0);
    hepSymMatrix.fillSymmetric(1,2,EMtrack_perigee_Covz0phi());
    hepSymMatrix.fillSymmetric(1,3,EMtrack_perigee_Covz0theta());
    hepSymMatrix.fillSymmetric(1,4,0.0);
    hepSymMatrix.fillSymmetric(2,3,EMtrack_perigee_Covphitheta());
    hepSymMatrix.fillSymmetric(2,4,0.0);
    hepSymMatrix.fillSymmetric(3,4,0.0);
 
    //jacob
    AmgSymMatrix(5) jacob;
    jacob.setIdentity();
    jacob(3,3) = (-1./sin(EMtrack_perigee_theta()));     // deta/dtheta
    //similarity
    return  jacob*hepSymMatrix*jacob.transpose();
 
  }
    AmgSymMatrix(5) hepSymMatrix;
    hepSymMatrix.setIdentity();
    // use cluster for energy and eta
    hepSymMatrix(0,0) = EMtrack_perigee_Covd0d0();
    hepSymMatrix(1,1) = EMtrack_perigee_Covz0z0();
    hepSymMatrix(2,2) = EMtrack_perigee_Covphiphi();
    hepSymMatrix(3,3) = EMphoton_Covetaeta();
    hepSymMatrix(4,4) = EMphoton_CovEclusEclus();
 
    hepSymMatrix.fillSymmetric(0,1,EMtrack_perigee_Covd0z0());
    hepSymMatrix.fillSymmetric(0,2,EMtrack_perigee_Covd0phi());
    hepSymMatrix.fillSymmetric(0,3,0.0);
    hepSymMatrix.fillSymmetric(0,4,0.0);
    hepSymMatrix.fillSymmetric(1,2,EMtrack_perigee_Covz0phi());
    hepSymMatrix.fillSymmetric(1,3,0.0);
    hepSymMatrix.fillSymmetric(1,4,0.0);
    hepSymMatrix.fillSymmetric(2,3,0.0);
    hepSymMatrix.fillSymmetric(2,4,0.0);
    hepSymMatrix.fillSymmetric(3,4,EMphoton_CovetaEclus());
 
    return hepSymMatrix;
 
 
}
 
// ====================================================================
AmgSymMatrix(4) EMErrorDetail::get4x4EMTrackCombinedErrorMatrix() const {
 
  // E,eta,phi,M representation.
  AmgSymMatrix(4)  hepSymMatrix;
  hepSymMatrix.setZero();
  // Fill the matrix
  hepSymMatrix(0,0) = EMtrack_comb_CovPP();
  hepSymMatrix(1,1) = EMtrack_comb_Covetaeta();
  hepSymMatrix(2,2) = EMtrack_comb_Covphiphi();
 
  hepSymMatrix.fillSymmetric(0,1,EMtrack_comb_CovetaP());
  hepSymMatrix.fillSymmetric(0,2,EMtrack_comb_CovphiP());
  hepSymMatrix.fillSymmetric(1,2,EMtrack_comb_Covphieta());
 
  return hepSymMatrix;
}
 
// ====================================================================
AmgSymMatrix(4) EMErrorDetail::get4x4EMTrackUncombinedErrorMatrix() const {
 
  // E,eta,phi,M representation.
  if (hasSiliconHits()) {
    AmgSymMatrix(4) hepSymMatrix;
    hepSymMatrix.setZero();
    // use tracks for everything but energy
    hepSymMatrix(0,0) = EMphoton_CovEclusEclus();
    hepSymMatrix(1,1) = EMtrack_perigee_Covthetatheta();
    hepSymMatrix(2,2) = EMtrack_perigee_Covphiphi();
    //fill symmetric
    hepSymMatrix.fillSymmetric(1,2, EMtrack_perigee_Covphitheta());
 
    //jacobian
    AmgSymMatrix(4) jacob;
    jacob.setIdentity();
    jacob(1,1) = (-1./sin(EMtrack_perigee_theta()));     // deta/dtheta
    //similarity
    return  jacob*hepSymMatrix*jacob.transpose();
  }
 
    AmgSymMatrix(4) hepSymMatrix;
    hepSymMatrix.setZero();
    // use cluster for energy and eta
    hepSymMatrix(0,0) = EMphoton_CovEclusEclus();
    hepSymMatrix(1,1) = EMphoton_Covetaeta();
    hepSymMatrix(2,2) = EMtrack_perigee_Covphiphi();
 
    hepSymMatrix.fillSymmetric(0,1, EMphoton_CovetaEclus());
 
    return hepSymMatrix;
 
 
}
 
// ====================================================================
AmgSymMatrix(4) EMErrorDetail::get4x4EMPhotonErrorMatrix() const {
 
  // E,eta,phi,M representation.
  AmgSymMatrix(4) hepSymMatrix;
  hepSymMatrix.setZero();
 
  // Fill the matrix
  hepSymMatrix(0,0) = EMphoton_CovEclusEclus();
  hepSymMatrix(1,1) = EMphoton_Covetaeta();
  hepSymMatrix(1,2) = EMphoton_Covetaphi();
  hepSymMatrix(2,2) = EMphoton_Covphiphi();
 
  hepSymMatrix.fillSymmetric(0,1, EMphoton_CovetaEclus());
  hepSymMatrix.fillSymmetric(0,3, EMphoton_CovphiEclus());
 
  return hepSymMatrix;
 
}
// ======================================================================
bool EMErrorDetail::hasIntParameter(egammaParameters::ParamDef key) const {
  switch(key) {
  case egammaParameters::linkIndex:
  case egammaParameters::hasSiliconHits:
    return true;
  default:
    return false;
  }
}
 
// =======================================================================
bool EMErrorDetail::hasParameter(egammaParameters::ParamDef key) const {
  if(hasIntParameter(key)) return true;
  switch (key) {
  case egammaParameters::EMConvertedPhoton_d0:
  case egammaParameters::EMConvertedPhoton_phi0:
  case egammaParameters::EMConvertedPhoton_z0:
  case egammaParameters::EMConvertedPhoton_theta:
  case egammaParameters::EMConvertedPhoton_eta:
  case egammaParameters::EMConvertedPhoton_momentum:
  case egammaParameters::EMConvertedPhoton_Covd0d0:
  case egammaParameters::EMConvertedPhoton_Covd0z0:
  case egammaParameters::EMConvertedPhoton_Covd0phi:
  case egammaParameters::EMConvertedPhoton_Covd0theta:
  case egammaParameters::EMConvertedPhoton_Covz0z0:
  case egammaParameters::EMConvertedPhoton_Covz0phi:
  case egammaParameters::EMConvertedPhoton_Covz0theta:
  case egammaParameters::EMConvertedPhoton_Covphiphi:
  case egammaParameters::EMConvertedPhoton_Covphitheta:
  case egammaParameters::EMConvertedPhoton_Covthetatheta:
 
  case egammaParameters::EMTrack_d0:
  case egammaParameters::EMTrack_phi0:
  case egammaParameters::EMTrack_z0:
  case egammaParameters::EMTrack_theta:
  case egammaParameters::EMTrack_eta:
  case egammaParameters::EMTrack_momentum:
  case egammaParameters::EMTrack_Covd0d0:
  case egammaParameters::EMTrack_Covd0z0:
  case egammaParameters::EMTrack_Covd0phi:
  case egammaParameters::EMTrack_Covd0theta:
  case egammaParameters::EMTrack_Covz0z0:
  case egammaParameters::EMTrack_Covz0phi:
  case egammaParameters::EMTrack_Covz0theta:
  case egammaParameters::EMTrack_Covphiphi:
  case egammaParameters::EMTrack_Covphitheta:
  case egammaParameters::EMTrack_Covthetatheta:
 
  case egammaParameters::EMTrack_Combined_Covd0d0:
  case egammaParameters::EMTrack_Combined_Covd0z0:
  case egammaParameters::EMTrack_Combined_Covd0phi:
  case egammaParameters::EMTrack_Combined_Covd0eta:
  case egammaParameters::EMTrack_Combined_Covd0P:
  case egammaParameters::EMTrack_Combined_Covz0z0:
  case egammaParameters::EMTrack_Combined_Covz0phi:
  case egammaParameters::EMTrack_Combined_Covz0eta:
  case egammaParameters::EMTrack_Combined_Covz0P:
  case egammaParameters::EMTrack_Combined_Covphiphi:
  case egammaParameters::EMTrack_Combined_Covphieta:
  case egammaParameters::EMTrack_Combined_CovphiP:
  case egammaParameters::EMTrack_Combined_Covetaeta:
  case egammaParameters::EMTrack_Combined_CovetaP:
  case egammaParameters::EMTrack_Combined_CovPP:
 
  case egammaParameters::EMPhoton_eta:
  case egammaParameters::EMPhoton_phi0:
  case egammaParameters::EMPhoton_Eclus:
 
  case egammaParameters::EMPhoton_Covetaeta:
  case egammaParameters::EMPhoton_Covetaphi:
  case egammaParameters::EMPhoton_CovetaEclus:
  case egammaParameters::EMPhoton_Covphiphi:
  case egammaParameters::EMPhoton_CovphiEclus:
  case egammaParameters::EMPhoton_CovEclusEclus:
    return true;
    // the following are depricated
  case egammaParameters::EMConvertedPhoton_Eclus:
  case egammaParameters::EMConvertedPhoton_Covd0Eclus:
  case egammaParameters::EMConvertedPhoton_Covz0Eclus:
  case egammaParameters::EMConvertedPhoton_CovphiEclus:
  case egammaParameters::EMConvertedPhoton_CovthetaEclus:
  case egammaParameters::EMConvertedPhoton_CovEclusEclus:
  case egammaParameters::EMTrack_Eclus:
  case egammaParameters::EMTrack_Covd0Eclus:
  case egammaParameters::EMTrack_Covz0Eclus:
  case egammaParameters::EMTrack_CovphiEclus:
  case egammaParameters::EMTrack_CovthetaEclus:
  case egammaParameters::EMTrack_CovEclusEclus:
    return true;
  default:
    return false;
  }
}
 
 
/* Get parameters of unconverted photon */
double EMErrorDetail::EMconvertedphoton_perigee_d0    ()  const {return parameter(egammaParameters::EMConvertedPhoton_d0)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_phi0  ()  const {return parameter(egammaParameters::EMConvertedPhoton_phi0)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_Eclus()  const {return parameter(egammaParameters::EMConvertedPhoton_Eclus)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_z0    ()  const {return parameter(egammaParameters::EMConvertedPhoton_z0)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_theta ()  const {return parameter(egammaParameters::EMConvertedPhoton_theta)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_eta    ()  const {return parameter(egammaParameters::EMConvertedPhoton_eta)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_momentum ()  const {return parameter(egammaParameters::EMConvertedPhoton_momentum) ;}
 
double EMErrorDetail::EMconvertedphoton_perigee_Covd0d0         () const {return parameter(egammaParameters::EMConvertedPhoton_Covd0d0)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covd0z0         () const {return parameter(egammaParameters::EMConvertedPhoton_Covd0z0)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covd0phi        () const {return parameter(egammaParameters::EMConvertedPhoton_Covd0phi)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covd0theta      () const {return parameter(egammaParameters::EMConvertedPhoton_Covd0theta)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_Covd0Eclus     () const {return parameter(egammaParameters::EMConvertedPhoton_Covd0Eclus)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covz0z0         () const {return parameter(egammaParameters::EMConvertedPhoton_Covz0z0)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covz0phi        () const {return parameter(egammaParameters::EMConvertedPhoton_Covz0phi)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covz0theta      () const {return parameter(egammaParameters::EMConvertedPhoton_Covz0theta)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_Covz0Eclus     () const {return parameter(egammaParameters::EMConvertedPhoton_Covz0Eclus)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covphiphi       () const {return parameter(egammaParameters::EMConvertedPhoton_Covphiphi)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covphitheta     () const {return parameter(egammaParameters::EMConvertedPhoton_Covphitheta)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_CovphiEclus    () const {return parameter(egammaParameters::EMConvertedPhoton_CovphiEclus)  ;}
double EMErrorDetail::EMconvertedphoton_perigee_Covthetatheta   () const {return parameter(egammaParameters::EMConvertedPhoton_Covthetatheta)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_CovthetaEclus  () const {return parameter(egammaParameters::EMConvertedPhoton_CovthetaEclus)  ;}
// double EMErrorDetail::EMconvertedphoton_perigee_CovEclusEclus () const {return parameter(egammaParameters::EMConvertedPhoton_CovEclusEclus)  ;}
 
/* Set parameters of unconverted photons */
void EMErrorDetail::EMconvertedphoton_perigee_d0    (double x)  {set_parameter(egammaParameters::EMConvertedPhoton_d0, x, true)  ;}

AmgSymMatrix() [2/3]

AmgSymMatrix

(

4

)

Definition at line 646 of file EMErrorDetail.cxx.

{
  AmgSymMatrix(4) m;
  m.setIdentity();
  m(1,1) = (-1./sin(theta));     // deta/dtheta
  return m;
}

AmgSymMatrix() [3/3]

AmgSymMatrix

(

5

)

Definition at line 638 of file EMErrorDetail.cxx.

{
  AmgSymMatrix(5) m;
  m.setIdentity();
  m(3,3) = (-1./sin(theta));     // deta/dtheta
  return m;
}

SG_ADD_BASE()

SG_ADD_BASE	(	EMErrorDetail	,
		egDetail
	)