InDet::InDetBeamSpotVertex Class Reference

A concrete implementation of IInDetBeamSpotTool, using primary vertex information to determine the position of the beamspot using a chi2 and/or log-likelihood method. More...

#include <InDetBeamSpotVertex.h>

Inheritance diagram for InDet::InDetBeamSpotVertex:

Collaboration diagram for InDet::InDetBeamSpotVertex:

Public Types
enum	FitStatus { unsolved =0 , problems , failed , successful }
	Internally used enum for fit status. More...
enum	FitID {   trackChi2 =1 , trackChi2Widths =2 , vertexLL =3 , vertexChi2 =4 ,   RooFitLL = 6 , unknown = 99 }
	Beamspot determination type. More...

Public Member Functions
	InDetBeamSpotVertex (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~InDetBeamSpotVertex ()
	InDetBeamSpotVertex (const InDetBeamSpotVertex &rhs)
virtual StatusCode	initialize ()
	Standard initialize.
virtual StatusCode	finalize ()
	Standard finalize.
virtual FitStatus	fit (std::vector< BeamSpot::VrtHolder > &)
	Attempt a to find a solution of the beamspot.
virtual FitID	getFitID () const
	A unique ID for the specific fit type.
IInDetBeamSpotTool *	Clone ()
double	getX (double z) const
double	getY (double z) const
double	getZ () const
double	getErrX (double z) const
double	getErrY (double z) const
double	getErrZ () const
double	getSigmaX (double) const
double	getSigmaY (double) const
double	getSigmaZ () const
double	getErrSigmaX (double) const
double	getErrSigmaY (double) const
double	getErrSigmaZ () const
double	getTiltX () const
double	getTiltY () const
double	getErrTiltX () const
double	getErrTiltY () const
double	getRhoXY () const
double	getK () const
double	getErrRhoXY () const
double	getErrK () const
double	getSigmaXY (double z) const
double	getErrSigmaXY (double z) const
CLHEP::HepSymMatrix	getCov (double z) const
const CLHEP::HepVector &	getLLpos () const
const CLHEP::HepSymMatrix &	getLLcov () const
virtual std::map< std::string, double >	getCovMap () const
virtual std::map< std::string, double >	getParamMap () const
void	clear ()
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Retrieve interface ID.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	solveChi2 ()
bool	solveLL (bool printOut=false)
bool	applyOutlierRemoval ()
int	setInitialPars (TMinuit *minuit)
int	setParsFromChi2 (TMinuit *minuit)
bool	setOutput (TMinuit *minuit)
bool	successfulFit (TMinuit *, std::pair< int, std::string > &)
void	doFit2 (TMinuit *, bool printOut=false)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
CLHEP::HepVector	m_x
CLHEP::HepSymMatrix	m_cov
double	m_z
double	m_zErr
CLHEP::HepVector	m_p
CLHEP::HepSymMatrix	m_V
double	m_zSolved
double	m_zErrSolved
const int	m_NPARS
CLHEP::HepVector	m_pLL
CLHEP::HepSymMatrix	m_VLL
long	m_vertexCount
bool	m_useLL
bool	m_getLLres
std::vector< BeamSpot::VrtHolder >	m_vertexData
double	m_init_x
double	m_init_y
double	m_init_z
double	m_init_sx
double	m_init_sy
double	m_init_sz
double	m_init_ax
double	m_init_ay
double	m_init_k
double	m_init_rhoxy
double	m_init_min_x
double	m_init_min_y
double	m_init_min_z
double	m_init_min_sx
double	m_init_min_sy
double	m_init_min_sz
double	m_init_min_ax
double	m_init_min_ay
double	m_init_min_k
double	m_init_min_rhoxy
double	m_init_max_x
double	m_init_max_y
double	m_init_max_z
double	m_init_max_sx
double	m_init_max_sy
double	m_init_max_sz
double	m_init_max_ax
double	m_init_max_ay
double	m_init_max_k
double	m_init_max_rhoxy
int	m_minuit_maxIter
double	m_def_x0
double	m_def_y0
double	m_def_z
double	m_def_ax
double	m_def_ay
double	m_def_sx
double	m_def_sy
double	m_def_sz
double	m_sigTr
double	m_maxVtxErTr
double	m_widthFail
double	m_rhoFail
int	m_singleIterationMax
bool	m_truncatedRMS
float	m_fractionRMS
bool	m_setInitialRMS
FitStatus	m_fitStatus
double	m_outlierChi2Tr
int	m_maxOutlierLoops
bool	m_doFitSanityCheck
bool	m_doChi2OutlierRemoval
double	m_kMaxFail
double	m_kMinFail
double	m_minVtxProb
bool	m_fixInputK
bool	m_useLLNorm
bool	m_fixWidth
int	m_nUsed
std::atomic< int >	m_rCount {0}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

A concrete implementation of IInDetBeamSpotTool, using primary vertex information to determine the position of the beamspot using a chi2 and/or log-likelihood method.

Abstract class for all beamspot determination algorithms.

Any class for finding the position of the beamspot needs to derive itself from this class.

Definition at line 32 of file InDetBeamSpotVertex.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

FitID

enum InDet::IInDetBeamSpotTool::FitID

inherited

Beamspot determination type.

Enumerator
trackChi2
trackChi2Widths
vertexLL
vertexChi2
RooFitLL
unknown

Definition at line 51 of file IInDetBeamSpotTool.h.

{trackChi2=1, trackChi2Widths=2, vertexLL=3, vertexChi2=4, RooFitLL = 6, unknown = 99};

FitStatus

enum InDet::IInDetBeamSpotTool::FitStatus

inherited

Internally used enum for fit status.

Useful for quick checks.

Enumerator
unsolved
problems
failed
successful

Definition at line 49 of file IInDetBeamSpotTool.h.

{unsolved=0, problems, failed, successful};

Constructor & Destructor Documentation

InDetBeamSpotVertex() [1/2]

InDetBeamSpotVertex::InDetBeamSpotVertex	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 40 of file InDetBeamSpotVertex.cxx.

                                       :
  AthAlgTool(type,name,parent),
  m_x(4),m_cov(4,0),m_z(0.),m_zErr(0.),
  m_p(4), m_V(4,0),
  m_zSolved(0.), m_zErrSolved(0.),
  m_NPARS(10), m_pLL(m_NPARS,0),m_VLL(m_NPARS,0),
  m_vertexCount(0),m_getLLres(false),
  m_fitStatus(unsolved),m_minVtxProb{},m_nUsed(0)
 
{
  declareInterface<IInDetBeamSpotTool>(this);
  declareProperty("UseLikelihood",m_useLL = true);
 
  //Fit initial parameter setup
  declareProperty("InitParX",      m_init_x =0.0);
  declareProperty("InitParY",      m_init_y =0.0);
  declareProperty("InitParZ",      m_init_z =0.0);
  declareProperty("InitParAx",     m_init_ax=0.0);
  declareProperty("InitParAy",     m_init_ay=0.0);
  declareProperty("InitParSigmaX", m_init_sx=0.01);
  declareProperty("InitParSigmaY", m_init_sy=0.01);
  declareProperty("InitParSigmaZ", m_init_sz=56.0);
  declareProperty("InitParK",      m_init_k =1.0);
  declareProperty("InitParRhoXY",  m_init_rhoxy=0.0);
  declareProperty("MinuitMaxIterations",  m_minuit_maxIter=2000);
  declareProperty("InitParMinX",      m_init_min_x =0.0);
  declareProperty("InitParMinY",      m_init_min_y =0.0);
  declareProperty("InitParMinZ",      m_init_min_z =0.0);
  declareProperty("InitParMinAx",     m_init_min_ax=0.0);
  declareProperty("InitParMinAy",     m_init_min_ay=0.0);
  declareProperty("InitParMinSigmaX", m_init_min_sx=0.0001);
  declareProperty("InitParMinSigmaY", m_init_min_sy=0.0001);
 
  declareProperty("InitParMinSigmaZ", m_init_min_sz=0.0);
  declareProperty("InitParMinK",      m_init_min_k =0);
  declareProperty("InitParMinRhoXY",  m_init_min_rhoxy=-1.0);
 
  declareProperty("InitParMaxX",      m_init_max_x =0.0);
  declareProperty("InitParMaxY",      m_init_max_y =0.0);
  declareProperty("InitParMaxZ",      m_init_max_z =0.0);
  declareProperty("InitParMaxAx",     m_init_max_ax=0.0);
  declareProperty("InitParMaxAy",     m_init_max_ay=0.0);
  declareProperty("InitParMaxSigmaX", m_init_max_sx=2.0);
  declareProperty("InitParMaxSigmaY", m_init_max_sy=2.0);
  declareProperty("InitParMaxSigmaZ", m_init_max_sz=3000.);
  declareProperty("InitParMaxK",      m_init_max_k =10.);
  declareProperty("InitParMaxRhoXY",  m_init_max_rhoxy=1.0);
 
  declareProperty("DefaultX0",  m_def_x0=0.0);
  declareProperty("DefaultY0",  m_def_y0=0.0);
  declareProperty("DefaultZ",   m_def_z=0.0);
  declareProperty("DefaultTiltX",  m_def_ax=0.0);
  declareProperty("DefaultTiltY",  m_def_ay=0.0);
  //these are used when returning a chi2 value
  declareProperty("DefaultSigmaX",  m_def_sx=0.0);
  declareProperty("DefaultSigmaY",  m_def_sy=0.0);
  declareProperty("DefaultSigmaZ",  m_def_sz=0.0);
 
 
  // selections
  declareProperty("MaxSigmaTr", m_sigTr=20.); 
  declareProperty("MaxVtxErrTr", m_maxVtxErTr=100.); // in mm
  declareProperty("OutlierChi2Tr", m_outlierChi2Tr=20.);
  declareProperty("MaxOutlierLoops",m_maxOutlierLoops = 30);
  declareProperty("OutlierMaxRejection",m_singleIterationMax=30);
  declareProperty("OutlierWidthFail", m_widthFail=5.1e-3); // in mm
  declareProperty("OutlierRhoFail", m_rhoFail=0.8); 
 
  declareProperty("OutlierKFailMin", m_kMinFail = 0);
  declareProperty("OutlierKFailMax", m_kMaxFail = 9.9);
  
  declareProperty("DoFitSanityCheck", m_doFitSanityCheck=true); 
  declareProperty("DoChi2OnlyOutlierRemoval",m_doChi2OutlierRemoval=false);
  //  declareProperty( "MinVertexProb", m_minVtxProb=0.001); // min prob(chi2,ndf)
  
  declareProperty( "FixParK" ,   m_fixInputK = false);
  declareProperty( "UseLLNorm" , m_useLLNorm = false);
  declareProperty( "FixWidth",   m_fixWidth  = false); 
 
  declareProperty("TruncatedRMS", m_truncatedRMS = true); 
  declareProperty("RMSFraction", m_fractionRMS = 0.95); 
  declareProperty("SetInitialRMS", m_setInitialRMS = false);
 
}

~InDetBeamSpotVertex()

virtual InDet::InDetBeamSpotVertex::~InDetBeamSpotVertex ( )

inlinevirtual

Definition at line 40 of file InDetBeamSpotVertex.h.

{}

InDetBeamSpotVertex() [2/2]

InDetBeamSpotVertex::InDetBeamSpotVertex

(

const InDetBeamSpotVertex &

rhs

)

Definition at line 127 of file InDetBeamSpotVertex.cxx.

                                                                        : 
  IInDetBeamSpotTool(rhs), 
  AthAlgTool(rhs.type(), rhs.name(), rhs.parent()),
  m_x(4),m_cov(4,0),m_z(0.),m_zErr(0.),
  m_p(4), m_V(4,0),
  m_zSolved(0.), m_zErrSolved(0.),
  m_NPARS(10), m_pLL(m_NPARS,0),m_VLL(m_NPARS,0),
  m_vertexCount(0),m_getLLres(false),
  m_fitStatus(unsolved),m_nUsed(0)
{
  m_useLL = rhs.m_useLL;
  m_init_x = rhs.m_init_x;
  m_init_y = rhs.m_init_y;
  m_useLL = rhs.m_useLL;
 
  m_init_x = rhs.m_init_x; 
  m_init_y = rhs.m_init_y;
  m_init_z = rhs.m_init_z;
  m_init_sx = rhs.m_init_sx; 
  m_init_sy = rhs.m_init_sy;
  m_init_sz = rhs.m_init_sz;
  m_init_ax = rhs.m_init_ax;
  m_init_ay = rhs.m_init_ay;
  m_init_k = rhs.m_init_k;
  m_init_rhoxy = rhs.m_init_rhoxy;
  
  m_init_min_x = rhs.m_init_min_x;
  m_init_min_y = rhs.m_init_min_y;
  m_init_min_z = rhs.m_init_min_z;
  m_init_min_sx = rhs.m_init_min_sx;
  m_init_min_sy = rhs.m_init_min_sy;
  m_init_min_sz = rhs.m_init_min_sz;
  m_init_min_ax = rhs.m_init_min_ax;
  m_init_min_ay = rhs.m_init_min_ay;
  m_init_min_k = rhs.m_init_min_k;
  m_init_min_rhoxy = rhs.m_init_min_rhoxy;
  
  m_init_max_x = rhs.m_init_max_x;
  m_init_max_y = rhs.m_init_max_y;
  m_init_max_z = rhs.m_init_max_z;
  m_init_max_sx = rhs.m_init_max_sx;
  m_init_max_sy = rhs.m_init_max_sy;
  m_init_max_sz = rhs.m_init_max_sz;
  m_init_max_ax = rhs.m_init_max_ax;
  m_init_max_ay = rhs.m_init_max_ay;
  m_init_max_k = rhs.m_init_max_k;
  m_init_max_rhoxy = rhs.m_init_max_rhoxy;
  
  m_def_x0 = rhs.m_def_x0;
  m_def_y0 = rhs.m_def_y0;
  m_def_z = rhs.m_def_z;
  m_def_ax = rhs.m_def_ax;
  m_def_ay = rhs.m_def_ay;
  m_def_sx = rhs.m_def_sx;
  m_def_sy = rhs.m_def_sy;
  m_def_sz = rhs.m_def_sz;
 
  m_sigTr = rhs.m_sigTr;
  m_maxVtxErTr = rhs.m_maxVtxErTr;
 
 
  m_minuit_maxIter = rhs.m_minuit_maxIter;
  
  m_outlierChi2Tr       = rhs.m_outlierChi2Tr;
  m_maxOutlierLoops     = rhs.m_maxOutlierLoops;
  m_singleIterationMax  = rhs.m_singleIterationMax;
  m_widthFail           = rhs.m_widthFail;
  m_rhoFail             = rhs.m_rhoFail;
  m_kMinFail            = rhs.m_kMinFail;
  m_kMaxFail            = rhs.m_kMaxFail;
 
  m_doFitSanityCheck      = rhs.m_doFitSanityCheck;
  m_doChi2OutlierRemoval  = rhs.m_doChi2OutlierRemoval;
 
  m_fixInputK   = rhs.m_fixInputK;
  m_useLLNorm   = rhs.m_useLLNorm;
  m_fixWidth    = rhs.m_fixWidth;
 
  m_truncatedRMS = rhs.m_truncatedRMS;
  m_fractionRMS = rhs.m_fractionRMS;
  m_setInitialRMS = rhs.m_setInitialRMS;
  m_minVtxProb = rhs.m_minVtxProb;
}

Member Function Documentation

applyOutlierRemoval()

bool InDetBeamSpotVertex::applyOutlierRemoval ( )

private

Definition at line 512 of file InDetBeamSpotVertex.cxx.

                                              {
  ATH_MSG_DEBUG( "In Outlier removal" );
  // apply selection using results of a chi2 fit (eg. displacement)
  if (!m_vertexData.size()) {
    ATH_MSG_INFO( "No vertices found" );
    return false;
  }
 
  
  // determine simple means
  double meanx(0.),meany(0.), meanz(0.);
  double meanxSqr(0.),meanySqr(0.), meanzSqr(0.);
  double rmsX(0.),rmsY(0.), rmsZ(0.);
  
  // for use in median determination
  std::vector<double> vx,vy,vz;
 
  int count(0);
  for ( std::vector< BeamSpot::VrtHolder >::iterator it =  
    m_vertexData.begin();
  it != m_vertexData.end(); ++it) {
    if (!it->valid) continue;
 
    if (!m_truncatedRMS) {
      meanx += it->x;    
      meanxSqr += (it->x)*(it->x);
      meany += it->y;    
      meanySqr += (it->y)*(it->y); 
      meanz += it->z;
      meanzSqr += (it->z)*(it->z);
      
      ++count;
    }
 
    vx.push_back(it->x);
    vy.push_back(it->y);
    vz.push_back(it->z);   
  }
 
  // sort the vectors
  std::sort(vx.begin(),vx.end());
  std::sort(vy.begin(),vy.end());
  std::sort(vz.begin(),vz.end());
 
  // get the median values -- don't worry about extrapolating betweeen even sized entries
  double medianx = (vx.size() > 1 ?  vx.at(vx.size()/2) : 0.);
  double mediany = (vy.size() > 1 ?  vy.at(vy.size()/2) : 0.);
  double medianz = (vz.size() > 1 ?  vz.at(vz.size()/2) : 0.);
 
  ATH_MSG_DEBUG(  "Median: x: " << medianx  
            <<  " y: " << mediany 
            <<  " z: " << medianz );
 
  if (m_truncatedRMS) {
 
    ATH_MSG_DEBUG( "Truncating RMS ... " );
    // Only use the fraction (95%) of tracks closest to the median position to determin the RMS
    int nvtx(vx.size());
    std::sort(vx.begin(), vx.end(), SortDistToMedian(medianx));
    vx.erase(vx.begin()+int(m_fractionRMS*nvtx), vx.end());
    
    std::sort(vy.begin(), vy.end(), SortDistToMedian(mediany));
    vy.erase(vy.begin()+int(m_fractionRMS*nvtx), vy.end());
    
    std::sort(vz.begin(), vz.end(), SortDistToMedian(medianz));
    vz.erase(vz.begin()+int(m_fractionRMS*nvtx), vz.end());
    
    ATH_MSG_DEBUG( "... using " << int(m_fractionRMS*nvtx) << " from " << nvtx << " vertices" );
 
    for (unsigned int ivtx(0); ivtx < vx.size(); ++ivtx) {
      double x = vx.at(ivtx);
      double y = vy.at(ivtx);
      double z = vz.at(ivtx);
      
      meanx += x;
      meanxSqr += x*x;
      meany += y;
      meanySqr += y*y;
      meanz += z;
      meanzSqr += z*z;
       
      ++count;
    }
  }
 
  if (count) {
    meanx /= count;
    meanxSqr /=count;
    rmsX = std::sqrt( std::abs(meanxSqr - meanx*meanx));
    meany /= count;
    meanySqr /=count;
    rmsY = std::sqrt( std::abs(meanySqr - meany*meany));
    meanz  /=count;
    meanzSqr /=count;
    rmsZ = std::sqrt( std::abs(meanzSqr - meanz*meanz));
  }
 
  if(m_setInitialRMS){
    rmsX = m_init_sx;
    rmsY = m_init_sy;
    // should we include z here too??
 
    ATH_MSG_DEBUG( "Setting RMS in x to " << rmsX );
    ATH_MSG_DEBUG( "Setting RMS in y to " << rmsY );
 
  }
 
  ATH_MSG_DEBUG(  "mean, RMS; x: " << meanx << " " << rmsX
    << "   "  << ", y: " << meany << " " << rmsY <<  ", z: " << meanz << " " << rmsZ );
 
 
  // varivables to hold the new chi2 and weighted z-mean values
  CLHEP::HepVector chi2Pos(4);
  CLHEP::HepSymMatrix chi2Cov(4);
  double  zpos(0), zerr(0);
  
  
  // use simple mean and RMS to eliminate any vertices too far from centroid
  // also redetermine a new chi2 value, based on passed vertices
  long failCount(0);
  for ( std::vector< BeamSpot::VrtHolder >::iterator it =  
    m_vertexData.begin();
  it != m_vertexData.end(); ++it) {
    if (!it->valid) continue;
    int fail=0;
    
    if ( std::abs( medianx - it->x ) > m_sigTr *rmsX) fail += 4;
    if ( std::abs( mediany - it->y ) > m_sigTr *rmsY) fail += 8;
    if ( std::abs( medianz - it->z ) > 10*rmsZ) fail += 16;
    if ((rmsX == 0.) or (rmsY == 0.))[[unlikely]]{
      throw std::runtime_error("InDetBeamSpotVertex::solveChi2: rmsX or rmsY is zero!");
    }
    
    if (  (medianx - it->x)*(medianx-it->x)/rmsX/rmsX + (mediany-it->y)*(mediany-it->y)/rmsY/rmsY > m_sigTr*m_sigTr) {
      ATH_MSG_DEBUG( "Vertex info: extended past radial extent: sig."
                     << std::sqrt((medianx - it->x)*(medianx-it->x)/rmsX/rmsX + (mediany-it->y)*(mediany-it->y)/rmsY/rmsY) << " > "
                     << std::sqrt( m_sigTr*m_sigTr ) << "." ); 
      fail += 128;
    }
    
    //and in Z?
    
    if (fail) { // TBD only allow failed vertices here to be removed on every nth iteration (to aid stability)
      ATH_MSG_DEBUG( "Vertex reject from simple mean; reason: " << fail << " : x,y,z: " 
        << it->x << "  " << it->y << "  " << it->z 
        << " , sigma(x,y,z): " << std::sqrt(it->vxx) << "  " << std::sqrt(it->vyy)
        << "  " << std::sqrt(it->vzz) 
        );
      
      it->valid = false;
      ++failCount;
    } else {
      // still valid, so add into chi2
      
      chi2Pos(1) += it->x * it->vxx          + it->y*it->vxy;
      chi2Pos(2) += it->x*it->vxx*it->z     + it->y*it->vxy*it->z;
      chi2Pos(3) += it->y*it->vyy            + it->x*it->vxy;
      chi2Pos(4) += it->y*it->vyy*it->z     + it->x*it->vxy*it->z;
      
      
      chi2Cov.fast(1,1) += it->vxx;
      chi2Cov.fast(2,1) += it->vxx*it->z;
      chi2Cov.fast(2,2) += it->vxx*it->z*it->z;
      chi2Cov.fast(3,1) += it->vxy;
      chi2Cov.fast(3,2) += it->vxy*it->z;
      chi2Cov.fast(3,3) += it->vyy;
      chi2Cov.fast(4,1) += it->vxy*it->z;
      chi2Cov.fast(4,2) += it->vxy*it->z*it->z;
      chi2Cov.fast(4,3) += it->vyy*it->z;
      chi2Cov.fast(4,4) += it->vyy*it->z*it->z;
      
      zpos += it->z/it->vzz; //weighted
      zerr += 1./it->vzz;
    }// end of valid vertex
    
  }// for 
  ATH_MSG_DEBUG( "Removed: " << failCount << " vertices from simple mean,RMS." );
  
  
  // update the new global chi2  - need to do this after the invert has been successful though !!!
  m_cov = chi2Cov;
  m_x   = chi2Pos;
  m_z   = zpos;
  m_zErr =zerr;
  // attempt to solve the new chi2 solution
  int  invFail(0);
  chi2Cov.invert(invFail);
  chi2Pos = chi2Cov*chi2Pos;
  if (zerr == 0.)[[unlikely]]{
    throw std::runtime_error("InDetBeamSpotVertex::applyOutlierRemoval: zerr is zero.");
  }
  zpos    = zpos / zerr;
  zerr    = 1./std::sqrt(zerr);
  
  
  
  
  // make comparisons of old chi2, new mean and new chi2 values
  if (msgLvl(MSG::DEBUG) ) {
    ATH_MSG_DEBUG( "Mean position: x,y,z " << meanx << "  " << meany << "  " << meanz );
    ATH_MSG_DEBUG( "     RMS:      x,y,z " << rmsX  << "  " << rmsY  << "  " << rmsZ  );
    
    ATH_MSG_DEBUG( "Original chi2:" << m_p << "\n" << m_V << "\n" << m_zSolved << "  " << m_zErrSolved );
    
    ATH_MSG_DEBUG( "New      chi2:" << chi2Pos << "\n" << chi2Cov << "\n" << zpos << "  " << zerr );
 
  } // debug statement
  
  m_V = chi2Cov;
  m_p = chi2Pos;
  m_zSolved = zpos;
  m_zErrSolved = zerr;
  
  
  
  
  //Dubious - !!! TBD: move this into the general LL solve area and do it properly!
 
  m_init_sz = rmsZ;
  
  // perform LL fit?
  bool llSolve(false);
  m_getLLres = false;
  if (m_useLL) {
    llSolve = solveLL();
    m_getLLres = llSolve; // allow the log-likelihood accessor values to returned, if sucessful
  }
 
  if ( llSolve and m_rCount > 0 ) {
    ATH_MSG_INFO( "Log-Likelihood fit converged in outlier removal. Exiting outlier removal." );
    return true;
  }
  
  CLHEP::HepSymMatrix bsCov(2); // for individual chi2 values
  double xbar = 0.;
  double ybar = 0.;
  double ax   = 0.;
  double ay   = 0.;
  
  
  
  if ( llSolve == false || getSigmaX(0.) < m_widthFail || getSigmaY(0.) < m_widthFail || std::abs(getRhoXY()) > m_rhoFail ) {
    // ll solution not used, or not trusted
    // set a wide solution
    m_getLLres = false;
    ATH_MSG_INFO( ": removeOutliers: LL fit not use/converged/trusted - " <<
      "using chi2 for mean and simple RMS for width values " );
    ATH_MSG_DEBUG( llSolve << " " << getSigmaX(0.) << " " << getSigmaY(0.) << " " << getRhoXY() );
    xbar = getX(0.);
    ybar = getY(0.);
    ax  =  getTiltX();
    ay  =  getTiltY();
 
    bsCov(1,1) = rmsX*rmsX;
    bsCov(2,2) = rmsY*rmsY;
    bsCov(2,1) = 0.;
    
  } else { // ll fit succeeded
    xbar = getX(0.);
    ybar = getY(0.);
    ax  =  getTiltX();
    ay  =  getTiltY();
    
    
    bsCov(1,1) = getSigmaX(0.)*getSigmaX(0.);
    bsCov(2,2) = getSigmaY(0.)*getSigmaY(0.);
    bsCov(2,1) = getSigmaX(0.)*getSigmaY(0.) * getRhoXY();
    
  } // 
  
  // loop over all vertices and populate a map with the chi2 values of the vertices
  std::multimap<double, BeamSpot::VrtHolder*> chi2map;
  int fail(0);
  long fCount(0);
  for ( std::vector< BeamSpot::VrtHolder >::iterator it =  m_vertexData.begin();
       it != m_vertexData.end(); ++it) {
    if ( !it->valid) continue; // ignore vertices set to invalid
    fail = 0; // reset the fail value variable
    
    // selections
    if ( std::abs(it->x - (xbar + it->z*ax))  > m_sigTr * rmsX) fail += 1;
    if ( std::abs(it->y - (ybar + it->z*ay))  > m_sigTr * rmsY) fail += 2;
    
    if ( it->vxx >  m_maxVtxErTr*m_maxVtxErTr || it->vyy >  m_maxVtxErTr*m_maxVtxErTr) fail += 4;
 
    if (  std::abs(it->z - meanz)  > m_sigTr * rmsZ) fail += 8;
 
    // add all other selections above here:
    double increaseChi2(0);
    if (fail) {
      increaseChi2 = fail * 1e5;
    }
    
    
    // chi2 value in transversve plane
    CLHEP::HepSymMatrix b(2);
    // TEST TBD !!!
    
    b(1,1) = it->vxx + bsCov(1,1);
    b(2,2) = it->vyy + bsCov(2,2);
    b(2,1) = it->vxy + bsCov(2,1);
    
    int failInv =0;
    b.invert(failInv);
    if (failInv) continue;
    double ch = (it->x - (xbar + it->z*ax)) * b(1,1) * (it->x - (xbar + it->z*ax))
    + (it->y - (ybar + it->z*ay)) * b(2,2) * (it->y - (ybar + it->z*ay))
    + 2*(it->x - (xbar + it->z*ax)) *b(2,1) * (it->y - (ybar + it->z*ay));
    
    //if (ch > m_outlierChi2Tr ) fail += 128; fail is never used after this
 
    // if vertex fails selection based on [1,2,4] add a large artificial chi2 value to make sure is removed.
    ch += increaseChi2;
    
    chi2map.insert(std::make_pair(ch, &(*it))); // add to list
    
  } // end for 
  
  // from the map remove the largest chi2 values, up to some maximum number of vertices
  fCount = 0;
  for (std::multimap<double, BeamSpot::VrtHolder*>::reverse_iterator vit =  chi2map.rbegin(); vit != chi2map.rend(); ++vit) {
    if ( !vit->second) continue; // no valid pointer ... 
    if ( !vit->second->valid) continue; // ignore vertices set to invalid - shouldn't happen here though
    if ( fCount >= m_singleIterationMax && m_singleIterationMax != -1) {
      ATH_MSG_DEBUG( " removeOutlier: Reached max number of vertex rejections for this iteration.\n" 
        << "\tNeed to recalculate mean positions." );
      break;
    } // if reached max iterations for this round
 
    ATH_MSG_VERBOSE( "Vertex chi2: " << vit->first  );
 
 
    
    if ( vit->first  < m_outlierChi2Tr ) {
      if (msgLvl(MSG::DEBUG)) {
        ATH_MSG_DEBUG( " No more 'bad' vertices found in this iteration."  );
        if (fCount == 0) {
          ATH_MSG_DEBUG( " No futher vertices removed - moving to final iteration" );
        } else {
          ATH_MSG_DEBUG( " Moving to next iteration of outlier removal." );
        }
      }
      break;
    } // if 
    
    // any vertex that is found here should be removed
    ++fCount;
    vit->second->valid = false;
    //    vit->second->outlierRemoved = true;
    ATH_MSG_DEBUG( "Vertex rejected; chi2: " << vit->first <<". pos(x,y,z): " 
      << vit->second->x << "  " << vit->second->y << "  " << vit->second->z 
      << " , sigma(x,y,z): " << sqrt(vit->second->vxx) << "  " << sqrt(vit->second->vyy)
      << "  " << sqrt(vit->second->vzz) 
      );
                   
  } // for
  
  // if no vertices removed and ll fit still fails, then we continue to have a problem ... 
  if (fCount == 0 && m_useLL && !llSolve && m_rCount !=0 ) { // if first iteration, we have another iteration later.
    ATH_MSG_WARNING( "No vertices removed and fit still fails - most likely final result will fail"  );
    
    // this is our 'last-ditch approach'. Split the collection of vertices into two 'random' sets and solve for each.
    // if both successful, then compare (and be a little confused). If only one, compare to chi2 and take if ok.
    // if none, then really have to give up. No valid solution possible.
 
    //    m_vertexData // key holder.
    //    copy the original values
    std::vector< BeamSpot::VrtHolder > vertexTemp(m_vertexData);
    // muddle up the original
    std::random_device rng;
    std::mt19937 urng(rng());
    std::shuffle(m_vertexData.begin(), m_vertexData.end(), urng);
    // divide the sample into two
    std::vector< BeamSpot::VrtHolder > vertex1,vertex2;
    std::copy(m_vertexData.begin() + m_vertexData.size()/2, m_vertexData.end(),    back_inserter(vertex2)) ; 
    std::copy(m_vertexData.begin(),  m_vertexData.begin() + m_vertexData.size()/2, back_inserter(vertex1)) ; 
    
    bool goodFit1(false), goodFit2(false);
 
    ATH_MSG_DEBUG( "Attempting fit with vextex half: 1");
    m_vertexData = vertex1;
    llSolve = solveLL();
    m_getLLres = true;
    ATH_MSG_WARNING( "Fit using \"vertex1\"  " << ( llSolve ? "Successful": "Failed") );
    if (llSolve) {
      goodFit1 = true;
 
      
      ATH_MSG_DEBUG( "x:  " << getX(0) << " +- " << getErrX(0) );
      ATH_MSG_DEBUG( "y:  " << getY(0) << " +- " << getErrY(0) );
      ATH_MSG_DEBUG( "z:  " << getZ() << " +- " << getErrZ() );
      ATH_MSG_DEBUG( "sx: " << getSigmaX(0) << " +- " << getErrSigmaX(0) );
      ATH_MSG_DEBUG( "sy: " << getSigmaY(0) << " +- " << getErrSigmaY(0) );
      ATH_MSG_DEBUG( "sz: " << getSigmaZ() << " +- " << getErrSigmaZ() );
      ATH_MSG_DEBUG( "ax: " << getTiltX() << " +- " << getErrTiltX() );
      ATH_MSG_DEBUG( "ay: " << getTiltY() << " +- " << getErrTiltY() );
      ATH_MSG_DEBUG( "sxy:" << getSigmaXY(0) << " +- " << getErrSigmaXY(0) );
      ATH_MSG_DEBUG( "rh: " << getRhoXY() << " +- " << getErrRhoXY() );
      ATH_MSG_DEBUG( "k:  " << getK() << " +- " << getErrK() );
      
 
    } // good fit
 
    ATH_MSG_DEBUG( "Attempting fit with vextex half: 2");
    m_vertexData = vertex2;
    llSolve = solveLL();
    m_getLLres = true;
    ATH_MSG_WARNING( "Fit using \"vertex2\"  " << ( llSolve ? "Successful": "Failed") );
    if (llSolve) { 
      goodFit2 = true;
      
      ATH_MSG_DEBUG( "x:  " << getX(0) << " +- " << getErrX(0) );
      ATH_MSG_DEBUG( "y:  " << getY(0) << " +- " << getErrY(0) );
      ATH_MSG_DEBUG( "z:  " << getZ() << " +- " << getErrZ() );
      ATH_MSG_DEBUG( "sx: " << getSigmaX(0) << " +- " << getErrSigmaX(0) );
      ATH_MSG_DEBUG( "sy: " << getSigmaY(0) << " +- " << getErrSigmaY(0) );
      ATH_MSG_DEBUG( "sz: " << getSigmaZ() << " +- " << getErrSigmaZ() );
      ATH_MSG_DEBUG( "ax: " << getTiltX() << " +- " << getErrTiltX() );
      ATH_MSG_DEBUG( "ay: " << getTiltY() << " +- " << getErrTiltY() );
      ATH_MSG_DEBUG( "sxy:" << getSigmaXY(0) << " +- " << getErrSigmaXY(0) );
      ATH_MSG_DEBUG( "rh: " << getRhoXY() << " +- " << getErrRhoXY() );
      ATH_MSG_DEBUG( "k:  " << getK() << " +- " << getErrK() );
      
 
    }
 
    // what now ? ...
    ATH_MSG_WARNING( "Fit was " <<  ( goodFit2 || goodFit1 ? "Successful ": "Unsuccessful ") 
            <<"  using a subset of the available vertices" );
    if (( goodFit2 || goodFit1) )
      ATH_MSG_WARNING( "Using these subset data for final result!!! " );
    ATH_MSG_WARNING( "FIT HALFVERTX" );
 
    if (goodFit1) {
      m_vertexData = std::move(vertex1);
    } else if (goodFit2) {
      m_vertexData = std::move(vertex2);
    } else {
      m_vertexData = std::move(vertexTemp); // give up and go home...
    }
 
  } // last solution
  
  
  
  // recursive mode
  ATH_MSG_DEBUG( " Recursive debug: Loop: " << m_rCount << ". Number of failed vertices: " << fCount );
  
  ++m_rCount;
  if ( fCount > 0 || ( fCount == 0 && m_rCount == 1 && !llSolve)) { // if failed vertices or, no failed, first iteration, and no succesful fit
    if ( m_rCount > m_maxOutlierLoops) {
      ATH_MSG_WARNING( "OutlierRemoval: Reached maximum number of recursive loops: " << m_rCount 
        << ". No more iterations performed." );
    } else {
      ATH_MSG_DEBUG( "OutlierRemoval: Entering recursive loop: " << m_rCount );
      applyOutlierRemoval();
    } // if entering loop
  } // if fails > 0
  --m_rCount;
  return true;
} // outlier removal

clear()

void InDetBeamSpotVertex::clear

(

)

Definition at line 223 of file InDetBeamSpotVertex.cxx.

                                {
  //reset the data information;
 
  m_x *= 0.;
  m_p *= 0.;
  
  m_cov *= 0.;
  m_V *= 0.;
  m_z=0.;
  m_zErr =0.;
  m_zSolved =0.;
  m_zErrSolved =0.;
 
  m_vertexCount =0;
  m_fitStatus = unsolved;
 
  m_vertexData.clear();
 
  m_nUsed = 0;
}

Clone()

IInDetBeamSpotTool * InDet::InDetBeamSpotVertex::Clone ( )

inlinevirtual

Implements InDet::IInDetBeamSpotTool.

Definition at line 50 of file InDetBeamSpotVertex.h.

{return new InDetBeamSpotVertex(*this);}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doFit2()

void InDetBeamSpotVertex::doFit2 ( TMinuit * minuit, bool printOut = false )

private

Definition at line 1106 of file InDetBeamSpotVertex.cxx.

                                                                 {
  //second attempt to fit in a controlled way.
  //reset initial values
  setParsFromChi2(minuit);
  
  //fix k, and rho,
  minuit->FixParameter(6);
  minuit->FixParameter(7);
  
  //fix x0,y0,ax,ay
  minuit->FixParameter(0);
  minuit->FixParameter(1);
  minuit->FixParameter(2);
  minuit->FixParameter(3);
 
  if(m_fixWidth){
    minuit->FixParameter(4);
    minuit->FixParameter(5);
  }
 
  minuit->Migrad();
  minuit->Migrad();
  //release k,rho
  if ( !m_fixInputK){
    minuit->Release(7);
    minuit->Migrad();
  }
 
  if(!m_fixWidth){
    minuit->Release(6);
    minuit->Migrad();
  }
 
  minuit->Release(0);
  minuit->Release(1);
  minuit->Release(2);
  minuit->Release(3);
  minuit->Migrad();
  if(printOut) minuit->SetPrintLevel(0);
  minuit->Migrad();
  //look at fit status from calling function
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode InDetBeamSpotVertex::finalize ( )

virtual

Standard finalize.

Will attempt a solution if not already done

Implements InDet::IInDetBeamSpotTool.

Definition at line 216 of file InDetBeamSpotVertex.cxx.

                                         {
  ATH_MSG_DEBUG( "In finalize" );
  clear(); // clear the data;
 
  return StatusCode::SUCCESS;
}

fit()

InDetBeamSpotVertex::FitStatus InDetBeamSpotVertex::fit ( std::vector< BeamSpot::VrtHolder > & )

virtual

Attempt a to find a solution of the beamspot.

Implements InDet::IInDetBeamSpotTool.

Definition at line 244 of file InDetBeamSpotVertex.cxx.

                                                                                            { 
  //get solution from current data;
  //Note, even if doing LL, use the chi2 information
  m_vertexData = vtxData;
  m_vertexCount = vtxData.size();
 
  
  bool chi2Result = solveChi2();
  m_getLLres = false;
  bool llResult = false;
  if (m_useLL) {
    applyOutlierRemoval(); // Apply a final selection
    m_getLLres =  true; //set system to use these results
    llResult = solveLL();
    if (!llResult) {
      ATH_MSG_WARNING( "Log-likelihood fit failed: Reverting to chi2 solution" );
      m_getLLres = false;
      chi2Result = solveChi2(); //unfortunately need to resolve, to set correct fit parameters
    }
  }
 
  if (m_useLL) {
    m_getLLres =  true; //set system to use these results
    bool printOut = true;
    llResult = solveLL(printOut);
    if (!llResult) {
      ATH_MSG_WARNING( "Log-likelihood fit failed: Reverting to chi2 solution" );
      m_getLLres = false;
      chi2Result = solveChi2(); //unfortunately need to resolve, to set correct fit parameters
    }
  } // if use LL
  
  
 
  if (m_getLLres) 
   m_fitStatus = (llResult ? successful : failed);
  else
    m_fitStatus = (chi2Result ? successful : failed);
  m_nUsed+=std::count_if(m_vertexData.begin(),m_vertexData.end(),[](const BeamSpot::VrtHolder & v){return v.valid;});
 
  //display results
  ATH_MSG_INFO( "Fit result was: " << ( m_fitStatus == successful ? "Successful" : "Failure") 
     << " using Vertex " << (m_getLLres ? "Log-likelihood":"Chi2") << " method" );
  ATH_MSG_INFO( "Number of vertices: " << m_vertexCount );
  ATH_MSG_INFO( "x(z=0) = " << getX(0.) << " +- " << getErrX(0) );
  ATH_MSG_INFO( "y(z=0) = " << getY(0.) << " +- " << getErrY(0) );
  ATH_MSG_INFO( "z = " << getZ() << " +- " << getErrZ() );
  double z = getZ();
  ATH_MSG_INFO( "x(z) = " << getX(z) << " +- " << getErrX(z) );
  ATH_MSG_INFO( "y(z) = " << getY(z) << " +- " << getErrY(z) );
  
  ATH_MSG_INFO( "TiltX = " << getTiltX() << " +- " << getErrTiltX() );
  ATH_MSG_INFO( "TiltY = " << getTiltY() << " +- " << getErrTiltY() );
  
  ATH_MSG_INFO( "SigmaX(z=0) = " << getSigmaX(0.) << " +- " << getErrSigmaX(0.) );
  ATH_MSG_INFO( "SigmaY(z=0) = " << getSigmaY(0.) << " +- " << getErrSigmaY(0.) );
  ATH_MSG_INFO( "SigmaZ      = " << getSigmaZ()   << " +- " << getErrSigmaZ() );
  
  ATH_MSG_INFO( "rhoXY = " << getRhoXY() << " +- " << getErrRhoXY() ); 
  ATH_MSG_INFO( "K = " << getK() << " +- " << getErrK() ); 
  
  return m_fitStatus;
}

getCov()

CLHEP::HepSymMatrix InDetBeamSpotVertex::getCov

(

double

z

)

const

Definition at line 309 of file InDetBeamSpotVertex.cxx.

                                                            { //x(z),y(z),tiltx,tilty
  CLHEP::HepSymMatrix c(4,0);
 
  if ( m_getLLres ) {
    //maximum likelihood
    c(1,1) = m_VLL(1,1) + 2*z*m_VLL(3,1) + z*z*m_VLL(3,3);
    c(2,2) = m_VLL(2,2) + 2*z*m_VLL(4,2) + z*z*m_VLL(4,4);
    c(3,3) = m_VLL(3,3);
    c(4,4) = m_VLL(4,4);
 
    c(2,1) = m_VLL(2,1) + z*m_VLL(2,3) + z*m_VLL(4,1)+z*z*m_VLL(4,3);
    c(3,1) = m_VLL(3,1) + z*m_VLL(3,3);
    c(4,1) = m_VLL(4,1) + z*m_VLL(3,4);
 
    c(3,2) = m_VLL(2,3) + z*m_VLL(4,3);
    c(4,2) = m_VLL(4,2) + z*m_VLL(4,4);
    
    c(4,3) = m_VLL(4,3);
    
  } else {
    //chi2
    c(1,1) = m_V(1,1) + 2*z*m_V(2,1) + z*z*m_V(2,2);
    c(2,2) = m_V(3,3) + 2*z*m_V(4,3) + z*z*m_V(4,4);
    c(3,3) = m_V(2,2);
    c(4,4) = m_V(4,4);
 
    c(2,1) = m_V(3,1) + z*m_V(3,2) + z*m_V(4,1)+z*z*m_V(4,2);
    c(3,1) = m_V(2,1) + z*m_V(2,2);
    c(4,1) = m_V(4,1) + z*m_V(4,2);
 
    c(3,2) = m_V(3,2) + z*m_V(4,2);
    c(4,2) = m_V(4,3) + z*m_V(4,4);
    
    c(4,3) = m_V(4,2);
 
  }
 
  return c;
}

getCovMap()

std::map< std::string, double > InDetBeamSpotVertex::getCovMap ( ) const

virtual

Implements InDet::IInDetBeamSpotTool.

Definition at line 1150 of file InDetBeamSpotVertex.cxx.

                                                              {
 
  //Note: all the off-diagonal elements are errors calculated at (0,0,0).
  //While the diagonal elements are calculated at the z centroid
  //In practice, this should make little difference, but it is important to note for now.
 
  std::map<std::string,double> covMap;
  std::vector<double> covVector;
  covVector.resize(55);
 
  //This is the method that was used before to put the covariance matrix in the required order
  //We don't want to mess with this, because no one knows the original order
 
  int map[] = {1,2,9,3,4,5,6,10,7,8};
  if(m_fixInputK){
    int map2[] = {1,2,8,3,4,5,6,9,7,10};
    for(int i=0; i < 10; ++i){
      map[i] = map2[i];
    }
  } else if (m_fixWidth) {
    int map2[] = {1,2,6,3,4,8,9,7,10,5};
    for(int i=0; i < 10; ++i){
      map[i] = map2[i];
    }
  }
 
  int temp = 0;
  for (int i=0;i<10;++i) {
    for (int j=i;j<10;++j) {
      if( m_fixInputK && (i == 9 || j ==9 )){ 
        covVector[temp++] = 0; 
      } else if ( m_fixWidth && ( i == 5 || i == 6 || i == 8 || j == 5 || j == 6 || j == 8  ) ){
        covVector[temp++] = 0;
      }else{  
        covVector[temp++] = m_VLL( map[i], map[j] );
      }
    }
  }
 
  //This array is in the order required from the original ntuple format
 
  const std::string keyArr[] = {"posXErr","covXY","covXZ","covXTiltX","covXTiltY","covXSx","covXSy","covXSz","covXRhoXY","covXk",
                                "posYErr","covYZ","covYTiltX","covYTiltY","covYSx","covYSy","covYSz","covYRhoXY","covYk",
                                "posZErr","covZTiltX","covZTiltY","covZSx","covZSy","covZSz","covZRhoXY","covZk",
                                "tiltXErr","covTiltXTiltY","covTiltXSx","covTiltXSy","covTiltXSz","covTiltXRhoXY","covTiltXk",
                                "tiltYErr","covTiltYSx","covTiltYSy","covTiltYSz","covTiltYRhoXY","covTiltYk",
                                "sigmaXErr","covSxSy","covSxSz","covSxRhoXY","covSxk",
                                "sigmaYErr","covSySz","covSyRhoXY","covSyk",
                                "sigmaZErr","covSzRhoXY","covSzk",
                                "rhoXYErr","covRhoXYk",
                                "kErr"};
 
 
  //Now that everything should be in the right order, it's simple to set the covariance matrix map correctly:
  
  
  for(int i = 0; i < 55; i++){
    covMap[keyArr[i]] = covVector[i];
    //std::cout << keyArr[i] << "  " <<  covVector[i] <<  std::endl;
    //covMap[keyArr2[i]]= covVector[i];
  }
 
  covMap[ keyArr[0] ]  = sqrt(covVector[0]);
  covMap[ keyArr[10] ] = sqrt(covVector[10]);
  covMap[ keyArr[19] ] = sqrt(covVector[19]);
  covMap[ keyArr[27] ] = sqrt(covVector[27]);
  covMap[ keyArr[34] ] = sqrt(covVector[34]);
  covMap[ keyArr[40] ] = sqrt(covVector[40]);
  covMap[ keyArr[45] ] = sqrt(covVector[45]);
  covMap[ keyArr[49] ] = sqrt(covVector[49]);
  covMap[ keyArr[52] ] = sqrt(covVector[52]);
  covMap[ keyArr[54] ] = sqrt(covVector[54]);
  
  
  //The errors on these 5 parameters were calculated at (0,0,0). This is how we convert them to be
  //at the centroid
 
  double z = getZ();
  CLHEP::HepSymMatrix covc = getCov(z);
 
  covMap["posXErr"]    = sqrt( covc(1,1) ); //xcxc
  covMap["posYErr"]    = sqrt( covc(2,2) ); //ycyc
  covMap["tiltXErr"]   = sqrt( covc(3,3) ); //axcaxc
  covMap["tiltYErr"]   = sqrt( covc(4,4) ); //aycayc
  covMap["sigmaXErr"]  = sqrt( getErrSigmaX(z)*getErrSigmaX(z) ); //sxcsxc
  covMap["sigmaYErr"]  = sqrt( getErrSigmaY(z)*getErrSigmaY(z) ); //sycsyc
    
  return covMap;
 
  
}

getErrK()

double InDet::InDetBeamSpotVertex::getErrK ( ) const

inline

Definition at line 95 of file InDetBeamSpotVertex.h.

{ return  (m_getLLres ?  (m_fixInputK ? 0. : sqrt(m_VLL(8,8)) ) : 0.);}

getErrRhoXY()

double InDet::InDetBeamSpotVertex::getErrRhoXY ( ) const

inline

Definition at line 94 of file InDetBeamSpotVertex.h.

{ return  (m_getLLres ? sqrt(m_VLL(7,7)) : 0.);}

getErrSigmaX()

double InDet::InDetBeamSpotVertex::getErrSigmaX ( double ) const

inline

Definition at line 75 of file InDetBeamSpotVertex.h.

                                       {
      return (m_getLLres ? sqrt(m_VLL(5,5)) :0.);}

getErrSigmaXY()

double InDet::InDetBeamSpotVertex::getErrSigmaXY ( double z ) const

inline

Definition at line 99 of file InDetBeamSpotVertex.h.

                                         {
      // Error proporagtion multiplied thorughout by sigmaXY to remove denominator ->  safer against zeros
 
      double rhoXY = getRhoXY();
      double sigmaX = getSigmaX(z);
      double sigmaY = getSigmaY(z);
 
      double errRhoXY = getErrRhoXY();
      double errSigmaX = getErrSigmaX(z);
      double errSigmaY = getErrSigmaY(z);
 
      double errSigmaXY = sqrt((errRhoXY*errRhoXY) * (sigmaX*sigmaX) * (sigmaY*sigmaY) +
                   (rhoXY*rhoXY) * (errSigmaX*errSigmaX) * (sigmaY*sigmaY) +
                   (rhoXY*rhoXY) * (sigmaX*sigmaX) * (errSigmaY*errSigmaY));
      return errSigmaXY;
    }

getErrSigmaY()

double InDet::InDetBeamSpotVertex::getErrSigmaY ( double ) const

inline

Definition at line 77 of file InDetBeamSpotVertex.h.

                                       {
      return (m_getLLres ? sqrt(m_VLL(6,6)) :0.);}

getErrSigmaZ()

double InDet::InDetBeamSpotVertex::getErrSigmaZ ( ) const

inline

Definition at line 79 of file InDetBeamSpotVertex.h.

                                  {
      return (m_getLLres ?  (m_fixInputK ? sqrt(m_VLL(9,9)) : sqrt(m_VLL(10,10))) :0.);}

getErrTiltX()

double InDet::InDetBeamSpotVertex::getErrTiltX ( ) const

inline

Definition at line 86 of file InDetBeamSpotVertex.h.

                                { 
      return (m_getLLres ? sqrt(m_VLL(3,3)):sqrt( m_V(2,2)));}

getErrTiltY()

double InDet::InDetBeamSpotVertex::getErrTiltY ( ) const

inline

Definition at line 88 of file InDetBeamSpotVertex.h.

                                { 
      return (m_getLLres ? sqrt(m_VLL(4,4)):sqrt( m_V(4,4)));}

getErrX()

double InDet::InDetBeamSpotVertex::getErrX ( double z ) const

inline

Definition at line 58 of file InDetBeamSpotVertex.h.

                                      {
      return (m_getLLres ? sqrt(m_VLL(1,1) + 2*z*m_VLL(3,1) + z*z*m_VLL(3,3)):
          sqrt(m_V(1,1) + 2*z*m_V(2,1) + z*z*m_V(2,2)));
    }

getErrY()

double InDet::InDetBeamSpotVertex::getErrY ( double z ) const

inline

Definition at line 62 of file InDetBeamSpotVertex.h.

                                     {
    return  (m_getLLres ? sqrt(m_VLL(2,2) + 2*z*m_VLL(4,2) + z*z*m_VLL(4,4)):
         sqrt(m_V(3,3) + 2*z*m_V(4,3) + z*z*m_V(4,4)) );
    }

getErrZ()

double InDet::InDetBeamSpotVertex::getErrZ ( ) const

inline

Definition at line 66 of file InDetBeamSpotVertex.h.

                            {
      return (m_getLLres ?  (m_fixInputK ? sqrt(m_VLL(8,8)) : sqrt(m_VLL(9,9))):m_zErrSolved);} // defined as centroid of beam

getFitID()

virtual FitID InDet::InDetBeamSpotVertex::getFitID ( ) const

inlinevirtual

A unique ID for the specific fit type.

Implements InDet::IInDetBeamSpotTool.

Definition at line 49 of file InDetBeamSpotVertex.h.

{ return (m_getLLres ? vertexLL : vertexChi2  );}

getK()

double InDet::InDetBeamSpotVertex::getK ( ) const

inline

Definition at line 93 of file InDetBeamSpotVertex.h.

{ return (m_getLLres ? m_pLL(8) : 0.);}

getLLcov()

const CLHEP::HepSymMatrix & InDet::InDetBeamSpotVertex::getLLcov ( ) const

inline

Definition at line 118 of file InDetBeamSpotVertex.h.

{ return m_VLL;}

getLLpos()

const CLHEP::HepVector & InDet::InDetBeamSpotVertex::getLLpos ( ) const

inline

Definition at line 117 of file InDetBeamSpotVertex.h.

{ return m_pLL;}

getParamMap()

std::map< std::string, double > InDetBeamSpotVertex::getParamMap ( ) const

virtual

Implements InDet::IInDetBeamSpotTool.

Definition at line 1241 of file InDetBeamSpotVertex.cxx.

                                                                {
  double z = getZ();
 
  std::map<std::string,double> paramMap;
  paramMap["tiltX"]  = (m_getLLres ? m_pLL(3) : m_p(2));
  paramMap["tiltY"]  = (m_getLLres ? m_pLL(4) : m_p(4));
  paramMap["k"]      = (m_getLLres ? m_pLL(8) : 0.);
  paramMap["posX"]   = (m_getLLres ? m_pLL(1) + m_pLL(3)*z  : m_p(1) + m_p(2)*z);
  paramMap["posY"]   = (m_getLLres ? m_pLL(2) + m_pLL(4)*z  : m_p(3) + m_p(4)*z);
  paramMap["posZ"]   = (m_getLLres ? m_pLL(9) : m_zSolved);
  paramMap["sigmaX"] = (m_getLLres ? m_pLL(5) : m_def_sx);
  paramMap["sigmaY"] = (m_getLLres ? m_pLL(6) : m_def_sy);
  paramMap["sigmaZ"] = (m_getLLres ? m_pLL(10) : m_def_sz);
  paramMap["rhoXY"]  = (m_getLLres ? m_pLL(7) : 0.);
  paramMap["nUsed"] = m_nUsed;
 
  return paramMap;
}

getRhoXY()

double InDet::InDetBeamSpotVertex::getRhoXY ( ) const

inline

Definition at line 92 of file InDetBeamSpotVertex.h.

{ return (m_getLLres ? m_pLL(7) : 0.);}

getSigmaX()

double InDet::InDetBeamSpotVertex::getSigmaX ( double ) const

inline

Definition at line 69 of file InDetBeamSpotVertex.h.

                                    { 
      return (m_getLLres ? m_pLL(5) : m_def_sx);}

getSigmaXY()

double InDet::InDetBeamSpotVertex::getSigmaXY ( double z ) const

inline

Definition at line 97 of file InDetBeamSpotVertex.h.

{return getRhoXY()*getSigmaX(z)*getSigmaY(z);}

getSigmaY()

double InDet::InDetBeamSpotVertex::getSigmaY ( double ) const

inline

Definition at line 71 of file InDetBeamSpotVertex.h.

                                     { 
      return (m_getLLres ? m_pLL(6) : m_def_sy);}

getSigmaZ()

double InDet::InDetBeamSpotVertex::getSigmaZ ( ) const

inline

Definition at line 73 of file InDetBeamSpotVertex.h.

                              { 
      return (m_getLLres ? m_pLL(10) : m_def_sz);}

getTiltX()

double InDet::InDetBeamSpotVertex::getTiltX ( ) const

inline

Definition at line 82 of file InDetBeamSpotVertex.h.

                             {
      return (m_getLLres ? m_pLL(3) :m_p(2));}

getTiltY()

double InDet::InDetBeamSpotVertex::getTiltY ( ) const

inline

Definition at line 84 of file InDetBeamSpotVertex.h.

                             {
      return (m_getLLres ? m_pLL(4) :m_p(4));}

getX()

double InDet::InDetBeamSpotVertex::getX ( double z ) const

inline

Definition at line 52 of file InDetBeamSpotVertex.h.

                                   {
      return (m_getLLres ? m_pLL(1) + m_pLL(3)*z  : m_p(1) + m_p(2)*z);}

getY()

double InDet::InDetBeamSpotVertex::getY ( double z ) const

inline

Definition at line 54 of file InDetBeamSpotVertex.h.

                                 {
      return (m_getLLres ? m_pLL(2) + m_pLL(4)*z  : m_p(3) + m_p(4)*z);}

getZ()

double InDet::InDetBeamSpotVertex::getZ ( ) const

inline

Definition at line 57 of file InDetBeamSpotVertex.h.

{ return (m_getLLres ? m_pLL(9):m_zSolved);}

initialize()

StatusCode InDetBeamSpotVertex::initialize ( )

virtual

Standard initialize.

Implements InDet::IInDetBeamSpotTool.

Definition at line 211 of file InDetBeamSpotVertex.cxx.

                                           {
  ATH_MSG_DEBUG( "In initialize" );
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & InDet::IInDetBeamSpotTool::interfaceID ( )

inlinestaticinherited

Retrieve interface ID.

Definition at line 53 of file IInDetBeamSpotTool.h.

{ return IID_IInDetBeamSpotTool; }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setInitialPars()

int InDetBeamSpotVertex::setInitialPars ( TMinuit * minuit )

private

Definition at line 457 of file InDetBeamSpotVertex.cxx.

                                                         {
  int errFlag;
  //Set initial Parameters
  minuit->mnparm(0,"X0",m_init_x ,1e-5,m_init_min_x,m_init_max_x, errFlag);
  minuit->mnparm(1,"Y0",m_init_y ,1e-5,m_init_min_y,m_init_max_y, errFlag);
  minuit->mnparm(2,"Ax",m_init_ax ,1e-6,m_init_min_ax,m_init_max_ax, errFlag);
  minuit->mnparm(3,"Ay",m_init_ay ,1e-6,m_init_min_ay,m_init_max_ay, errFlag);
  minuit->mnparm(4,"#sigma(x)",m_init_sx, 1e-5,m_init_min_sx,m_init_max_sx, errFlag);
  minuit->mnparm(5,"#sigma(y)",m_init_sy, 1e-5,m_init_min_sy,m_init_max_sy, errFlag);
  minuit->mnparm(6,"#rhoxy",m_init_rhoxy,1e-5,m_init_min_rhoxy,m_init_max_rhoxy, errFlag);
  minuit->mnparm(7,"k",m_init_k, 1e-5,m_init_min_k,m_init_max_k, errFlag);
  minuit->mnparm(8,"z0",m_init_z, 1e-3,m_init_min_z,m_init_max_z, errFlag);
  minuit->mnparm(9,"#sigma(z)",m_init_sz, 1e-3,m_init_min_sz,m_init_max_sz, errFlag);
  
  minuit->SetMaxIterations(m_minuit_maxIter);
 
  return errFlag;
}

setOutput()

bool InDetBeamSpotVertex::setOutput ( TMinuit * minuit )

private

Definition at line 416 of file InDetBeamSpotVertex.cxx.

                                                     {
  //set the LL fitted parameters to the output.
  //output
  double t;
  for (int i =0; i<m_NPARS; ++i) {
    minuit->GetParameter(i, m_pLL(i+1)  ,t);
  }//for
 
  double * cov = new double[m_NPARS*m_NPARS];
  minuit->mnemat(cov,m_NPARS);
  for (int i =0; i<m_NPARS; ++i) {
    for ( int j=i; j<m_NPARS; ++j) {
      m_VLL(i+1,j+1) = cov[ i*m_NPARS + j]; 
    }//for j
  }//for i
  delete[] cov;
  
  return true;
}

setParsFromChi2()

int InDetBeamSpotVertex::setParsFromChi2 ( TMinuit * minuit )

private

Definition at line 438 of file InDetBeamSpotVertex.cxx.

                                                          {
  // use results of a chi2 fit to override some initial paramters
  int errFlag;
  minuit->mnparm(0,"X0",m_p(1) ,1e-5,m_init_min_x,m_init_max_x, errFlag);
  minuit->mnparm(1,"Y0",m_p(3) ,1e-5,m_init_min_y,m_init_max_y, errFlag);
  minuit->mnparm(2,"Ax",m_p(2) ,1e-6,m_init_min_ax,m_init_max_ax, errFlag);
  minuit->mnparm(3,"Ay",m_p(4) ,1e-6,m_init_min_ay,m_init_max_ay, errFlag);
  minuit->mnparm(4,"#sigma(x)",m_init_sx, 1e-5,m_init_min_sx,m_init_max_sx, errFlag);
  minuit->mnparm(5,"#sigma(y)",m_init_sy, 1e-5,m_init_min_sy,m_init_max_sy, errFlag);
  minuit->mnparm(6,"#rhoxy",m_init_rhoxy,1e-5,m_init_min_rhoxy,m_init_max_rhoxy, errFlag);
  minuit->mnparm(7,"k",m_init_k, 1e-5,m_init_min_k,m_init_max_k, errFlag);
  minuit->mnparm(8,"z0",m_zSolved, 1e-3,m_init_min_z,m_init_max_z, errFlag);
  minuit->mnparm(9,"#sigma(z)",m_init_sz, 1e-3,m_init_min_sz,m_init_max_sz, errFlag);
  
  minuit->SetMaxIterations(m_minuit_maxIter);
 
  return errFlag;
}

solveChi2()

bool InDetBeamSpotVertex::solveChi2 ( )

private

Definition at line 476 of file InDetBeamSpotVertex.cxx.

                                    {
  ATH_MSG_DEBUG( "Attempting to solve " );
  
  //calulate a solution for the current set of data
  if (m_vertexCount == 0) {
    ATH_MSG_DEBUG( "No vertices stored for solve" );
    m_fitStatus = failed;
    return false; 
  }
 
 
  //invert matrix
  int fail;
  m_V = m_cov;
  ATH_MSG_DEBUG( "Matrix prior to inversion\n" << m_V);
 
  m_V.invert(fail); //replaces the matrix with inverse
  if (fail != 0) {
    return false;
  }
  ATH_MSG_DEBUG( "Matrix post inversion\n" << m_V);
 
 
  m_p = m_V*m_x;  // calculate parameter estimates
  m_zSolved = m_z / m_zErr; // weighted 
  m_zErrSolved = 1./std::sqrt(m_zErr);
 
  
  ATH_MSG_DEBUG( "Fit solved succesfully from " << m_vertexCount << " vertices");
  ATH_MSG_DEBUG( "Chi2 Solution:\n"<<m_p <<"\n" << "Covariance: \n" << m_V );
 
  return true;
}

solveLL()

bool InDetBeamSpotVertex::solveLL ( bool printOut = false )

private

Definition at line 350 of file InDetBeamSpotVertex.cxx.

                                               {
  ATH_MSG_DEBUG( "In solveLL" );
 
  TMinuit * minuit = new TMinuit(m_NPARS);
  //setInitialPars( minuit);  
 
  //Set Minuit output level
  if (msg().level() < MSG::DEBUG) {
    printOut = true;
    minuit->SetPrintLevel(1);
  } else if (msg().level() == MSG::DEBUG) {
    printOut = true;
    minuit->SetPrintLevel(0);
  } else {
    minuit->SetPrintLevel(-1);
  }
  
  setParsFromChi2(minuit);
 
  minuit->SetErrorDef(0.5); // for Log-Likeihood: 0.5
 
  int errFlag =0;
  //SET STRategy for calculating second derivs.
  double arglist[1];
  arglist[0] = 2;
  minuit->mnexcm("SET STR",arglist,1,errFlag);
 
  std::lock_guard<std::mutex> lock(BeamSpot::mutex); // To protect global BeamSpot::vertexData
  // Insert the likelihood function
  // need to make the data accessible to it
  BeamSpot::vertexData = &m_vertexData;
  if ( !m_useLLNorm)
    minuit->SetFCN(BeamSpot::myFCN_LLsolver);
  else {
    minuit->SetFCN(BeamSpot::myFCN_LLsolverNorm);
  }
  
  std::pair<int, std::string>  status; // fit status
  //standard fit
  bool goodFit = false;
 
  //tried this approach - we want to succeed, so if fail, try another approach
  if (!goodFit) {
    doFit2(minuit,printOut);
    successfulFit(minuit, status);
    if ( status.first == 3 && ( status.second == "SUCCESSFUL" ||
        status.second == "CONVERGED " ||
        status.second == "CONVERGED") ){
      goodFit = true;
    } else {
      goodFit = false;
    }
  }
 
  if (goodFit){
    ATH_MSG_INFO( "Successful fit" );
    setOutput( minuit);
  } else {
    ATH_MSG_DEBUG( "No LL fit convergence" );
  }
  
  delete minuit;
  
  return goodFit;
}

successfulFit()

bool InDetBeamSpotVertex::successfulFit ( TMinuit * minuit, std::pair< int, std::string > & status )

private

Definition at line 975 of file InDetBeamSpotVertex.cxx.

                                                  {
  if (!minuit) return false;
  //This should be called directly after the fit
  std::string sRes = minuit->fCstatu.Data();
 
  Double_t fmin{}, fedm{}, errdef{};
  Int_t npari{},nparx{},istat{};
  minuit->mnstat(fmin, fedm, errdef,npari,nparx,istat);
  
  ATH_MSG_DEBUG( "Fit reports status: " << istat << " and " << sRes );
 
  status.first = istat;
  status.second = std::move(sRes);
 
  bool sanityPassed(true);
  if ( m_doFitSanityCheck) {
    double x(0), ex(0);
    minuit->GetParameter(6,x,ex); // rhoxy
    if ( std::abs(x) > m_rhoFail){
      sanityPassed = false;
      ATH_MSG_DEBUG( "Fit Failed with rhoxy: " << x << " > " << m_rhoFail );
    }
    minuit->GetParameter(4,x,ex); // sigma x
    if ( std::abs(x) < m_widthFail ){
      sanityPassed = false;
      ATH_MSG_DEBUG( "Fit Failed with sigmaX:" << x << " > " << m_widthFail );
    }
    minuit->GetParameter(5,x,ex); // sigma y
    if ( std::abs(x) < m_widthFail ){
      sanityPassed = false;
      ATH_MSG_DEBUG( "Fit Failed with sigmaY: " << x << " > " <<m_widthFail  );
    }
    
    minuit->GetParameter(7,x,ex); // k
    if ( std::abs(x) < m_kMinFail || std::abs(x) > m_kMaxFail ){
      sanityPassed = false;
      ATH_MSG_DEBUG( "Fit Failed with k: " << x << " > " << m_kMaxFail 
                 << ", or " << x << " < " << m_kMinFail  );
    }
 
 
    
  } // sanity check
  if (!sanityPassed) {
    status.first = 99;
    status.second = "FAILED BEAMSPOT SANITY CHECK";
  }
  ATH_MSG_DEBUG( "Fit " << ( sanityPassed ? "Passed": "Failed") << " sanity check: " );
 
  if ( istat != 3) return false;
 
 
  return true;
}

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_cov

CLHEP::HepSymMatrix InDet::InDetBeamSpotVertex::m_cov

private

Definition at line 126 of file InDetBeamSpotVertex.h.

m_def_ax

double InDet::InDetBeamSpotVertex::m_def_ax

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_ay

double InDet::InDetBeamSpotVertex::m_def_ay

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_sx

double InDet::InDetBeamSpotVertex::m_def_sx

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_sy

double InDet::InDetBeamSpotVertex::m_def_sy

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_sz

double InDet::InDetBeamSpotVertex::m_def_sz

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_x0

double InDet::InDetBeamSpotVertex::m_def_x0

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_y0

double InDet::InDetBeamSpotVertex::m_def_y0

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_def_z

double InDet::InDetBeamSpotVertex::m_def_z

private

Definition at line 164 of file InDetBeamSpotVertex.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doChi2OutlierRemoval

bool InDet::InDetBeamSpotVertex::m_doChi2OutlierRemoval

private

Definition at line 193 of file InDetBeamSpotVertex.h.

m_doFitSanityCheck

bool InDet::InDetBeamSpotVertex::m_doFitSanityCheck

private

Definition at line 192 of file InDetBeamSpotVertex.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_fitStatus

FitStatus InDet::InDetBeamSpotVertex::m_fitStatus

private

Definition at line 176 of file InDetBeamSpotVertex.h.

m_fixInputK

bool InDet::InDetBeamSpotVertex::m_fixInputK

private

Definition at line 197 of file InDetBeamSpotVertex.h.

m_fixWidth

bool InDet::InDetBeamSpotVertex::m_fixWidth

private

Definition at line 199 of file InDetBeamSpotVertex.h.

m_fractionRMS

float InDet::InDetBeamSpotVertex::m_fractionRMS

private

Definition at line 173 of file InDetBeamSpotVertex.h.

m_getLLres

bool InDet::InDetBeamSpotVertex::m_getLLres

private

Definition at line 144 of file InDetBeamSpotVertex.h.

m_init_ax

double InDet::InDetBeamSpotVertex::m_init_ax

private

Definition at line 154 of file InDetBeamSpotVertex.h.

m_init_ay

double InDet::InDetBeamSpotVertex::m_init_ay

private

Definition at line 154 of file InDetBeamSpotVertex.h.

m_init_k

double InDet::InDetBeamSpotVertex::m_init_k

private

Definition at line 154 of file InDetBeamSpotVertex.h.

m_init_max_ax

double InDet::InDetBeamSpotVertex::m_init_max_ax

private

Definition at line 160 of file InDetBeamSpotVertex.h.

m_init_max_ay

double InDet::InDetBeamSpotVertex::m_init_max_ay

private

Definition at line 160 of file InDetBeamSpotVertex.h.

m_init_max_k

double InDet::InDetBeamSpotVertex::m_init_max_k

private

Definition at line 160 of file InDetBeamSpotVertex.h.

m_init_max_rhoxy

double InDet::InDetBeamSpotVertex::m_init_max_rhoxy

private

Definition at line 160 of file InDetBeamSpotVertex.h.

m_init_max_sx

double InDet::InDetBeamSpotVertex::m_init_max_sx

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_max_sy

double InDet::InDetBeamSpotVertex::m_init_max_sy

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_max_sz

double InDet::InDetBeamSpotVertex::m_init_max_sz

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_max_x

double InDet::InDetBeamSpotVertex::m_init_max_x

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_max_y

double InDet::InDetBeamSpotVertex::m_init_max_y

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_max_z

double InDet::InDetBeamSpotVertex::m_init_max_z

private

Definition at line 159 of file InDetBeamSpotVertex.h.

m_init_min_ax

double InDet::InDetBeamSpotVertex::m_init_min_ax

private

Definition at line 157 of file InDetBeamSpotVertex.h.

m_init_min_ay

double InDet::InDetBeamSpotVertex::m_init_min_ay

private

Definition at line 157 of file InDetBeamSpotVertex.h.

m_init_min_k

double InDet::InDetBeamSpotVertex::m_init_min_k

private

Definition at line 157 of file InDetBeamSpotVertex.h.

m_init_min_rhoxy

double InDet::InDetBeamSpotVertex::m_init_min_rhoxy

private

Definition at line 157 of file InDetBeamSpotVertex.h.

m_init_min_sx

double InDet::InDetBeamSpotVertex::m_init_min_sx

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_min_sy

double InDet::InDetBeamSpotVertex::m_init_min_sy

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_min_sz

double InDet::InDetBeamSpotVertex::m_init_min_sz

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_min_x

double InDet::InDetBeamSpotVertex::m_init_min_x

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_min_y

double InDet::InDetBeamSpotVertex::m_init_min_y

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_min_z

double InDet::InDetBeamSpotVertex::m_init_min_z

private

Definition at line 156 of file InDetBeamSpotVertex.h.

m_init_rhoxy

double InDet::InDetBeamSpotVertex::m_init_rhoxy

private

Definition at line 154 of file InDetBeamSpotVertex.h.

m_init_sx

double InDet::InDetBeamSpotVertex::m_init_sx

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_init_sy

double InDet::InDetBeamSpotVertex::m_init_sy

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_init_sz

double InDet::InDetBeamSpotVertex::m_init_sz

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_init_x

double InDet::InDetBeamSpotVertex::m_init_x

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_init_y

double InDet::InDetBeamSpotVertex::m_init_y

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_init_z

double InDet::InDetBeamSpotVertex::m_init_z

private

Definition at line 153 of file InDetBeamSpotVertex.h.

m_kMaxFail

double InDet::InDetBeamSpotVertex::m_kMaxFail

private

Definition at line 194 of file InDetBeamSpotVertex.h.

m_kMinFail

double InDet::InDetBeamSpotVertex::m_kMinFail

private

Definition at line 194 of file InDetBeamSpotVertex.h.

m_maxOutlierLoops

int InDet::InDetBeamSpotVertex::m_maxOutlierLoops

private

Definition at line 181 of file InDetBeamSpotVertex.h.

m_maxVtxErTr

double InDet::InDetBeamSpotVertex::m_maxVtxErTr

private

Definition at line 168 of file InDetBeamSpotVertex.h.

m_minuit_maxIter

int InDet::InDetBeamSpotVertex::m_minuit_maxIter

private

Definition at line 162 of file InDetBeamSpotVertex.h.

m_minVtxProb

double InDet::InDetBeamSpotVertex::m_minVtxProb

private

Definition at line 195 of file InDetBeamSpotVertex.h.

m_NPARS

const int InDet::InDetBeamSpotVertex::m_NPARS

private

Definition at line 135 of file InDetBeamSpotVertex.h.

m_nUsed

int InDet::InDetBeamSpotVertex::m_nUsed

private

Definition at line 201 of file InDetBeamSpotVertex.h.

m_outlierChi2Tr

double InDet::InDetBeamSpotVertex::m_outlierChi2Tr

private

Definition at line 180 of file InDetBeamSpotVertex.h.

m_p

CLHEP::HepVector InDet::InDetBeamSpotVertex::m_p

private

Definition at line 130 of file InDetBeamSpotVertex.h.

m_pLL

CLHEP::HepVector InDet::InDetBeamSpotVertex::m_pLL

private

Definition at line 136 of file InDetBeamSpotVertex.h.

m_rCount

std::atomic<int> InDet::InDetBeamSpotVertex::m_rCount {0}

mutableprivate

Definition at line 203 of file InDetBeamSpotVertex.h.

{0}; // counter used for recussive mode

m_rhoFail

double InDet::InDetBeamSpotVertex::m_rhoFail

private

Definition at line 170 of file InDetBeamSpotVertex.h.

m_setInitialRMS

bool InDet::InDetBeamSpotVertex::m_setInitialRMS

private

Definition at line 174 of file InDetBeamSpotVertex.h.

m_sigTr

double InDet::InDetBeamSpotVertex::m_sigTr

private

Definition at line 167 of file InDetBeamSpotVertex.h.

m_singleIterationMax

int InDet::InDetBeamSpotVertex::m_singleIterationMax

private

Definition at line 171 of file InDetBeamSpotVertex.h.

m_truncatedRMS

bool InDet::InDetBeamSpotVertex::m_truncatedRMS

private

Definition at line 172 of file InDetBeamSpotVertex.h.

m_useLL

bool InDet::InDetBeamSpotVertex::m_useLL

private

Definition at line 143 of file InDetBeamSpotVertex.h.

m_useLLNorm

bool InDet::InDetBeamSpotVertex::m_useLLNorm

private

Definition at line 198 of file InDetBeamSpotVertex.h.

m_V

CLHEP::HepSymMatrix InDet::InDetBeamSpotVertex::m_V

private

Definition at line 131 of file InDetBeamSpotVertex.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexCount

long InDet::InDetBeamSpotVertex::m_vertexCount

private

Definition at line 139 of file InDetBeamSpotVertex.h.

m_vertexData

std::vector< BeamSpot::VrtHolder > InDet::InDetBeamSpotVertex::m_vertexData

private

Definition at line 145 of file InDetBeamSpotVertex.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_VLL

CLHEP::HepSymMatrix InDet::InDetBeamSpotVertex::m_VLL

private

Definition at line 137 of file InDetBeamSpotVertex.h.

m_widthFail

double InDet::InDetBeamSpotVertex::m_widthFail

private

Definition at line 169 of file InDetBeamSpotVertex.h.

m_x

CLHEP::HepVector InDet::InDetBeamSpotVertex::m_x

private

Definition at line 125 of file InDetBeamSpotVertex.h.

m_z

double InDet::InDetBeamSpotVertex::m_z

private

Definition at line 127 of file InDetBeamSpotVertex.h.

m_zErr

double InDet::InDetBeamSpotVertex::m_zErr

private

Definition at line 127 of file InDetBeamSpotVertex.h.

m_zErrSolved

double InDet::InDetBeamSpotVertex::m_zErrSolved

private

Definition at line 132 of file InDetBeamSpotVertex.h.

m_zSolved

double InDet::InDetBeamSpotVertex::m_zSolved

private

Definition at line 132 of file InDetBeamSpotVertex.h.

---

The documentation for this class was generated from the following files:

• InDetBeamSpotVertex.h
• InDetBeamSpotVertex.cxx