#include <GlobalChi2AlignTool.h>

Inheritance diagram for Trk::GlobalChi2AlignTool:

Collaboration diagram for Trk::GlobalChi2AlignTool:

Public Member Functions
	GlobalChi2AlignTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor. More...

virtual	~GlobalChi2AlignTool ()
	Virtual destructor. More...

virtual StatusCode	initialize ()
	initialize More...

virtual StatusCode	finalize ()
	finalize More...

virtual StatusCode	firstEventInitialize ()
	sets up matrix More...

virtual StatusCode	solve ()
	solves for alignment parameters More...

bool	accumulate (AlignTrack *alignTrack)
	accumulates information from an AlignTrack More...

bool	accumulateFromFiles ()
	accumulates information from binary files More...

unsigned int	nAccumulatedTracks ()
	returns total number of accumulated tracks More...

void	setNtuple (TFile *ntuple)
	set ntuple More...

void	setLogStream (std::ostream *os)
	sets the output stream for the logfile More...

StatusCode	fillNtuple ()
	writes tree to ntuple More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Protected Attributes
std::ostream *	m_logStream
	logfile output stream More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
double	getMaterialOnTrack (const Trk::Track *track)

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
ToolHandle< Trk::IMatrixTool >	m_matrixTool
	Pointer to MatrixTool, used to write to and solve matrix. More...

ToolHandle< Trk::IAlignModuleTool >	m_alignModuleTool
	Pointer to AlignModuleTool. More...

std::string	m_pathbin
	path binary files (in/out) More...

std::string	m_pathtxt
	path ascii files (in/out) More...

std::string	m_prefixName
	prefix string to filenames More...

unsigned int	m_ntracks
	number of accumulated tracks More...

unsigned int	m_nmeas
	number of accumulated measurements More...

unsigned int	m_nhits
	number of accumulated hits More...

double	m_chi2
	total chi2 More...

unsigned int	m_nDoF
	number of degrees of freedom More...

double	m_secondDerivativeCut

bool	m_doTree

bool	m_writeActualSecDeriv

bool	m_storeLocalDerivOnly

TFile *	m_ntuple
	output ntuple More...

TTree *	m_tree

int	m_run

int	m_event

double	m_materialOnTrack

double	m_momentum

int	m_nChambers

int *	m_chamberIds

int	m_nMatrixIndices

int *	m_matrixIndices

int	m_nSecndDeriv

double *	m_secndDeriv

double *	m_firstDeriv

double *	m_actualSecndDeriv

double	m_eta

double	m_phi

double	m_perigee_x

double	m_perigee_y

double	m_perigee_z

int	m_trackInfo

int	m_bremFit

int	m_bremFitSuccessful

int	m_straightTrack

int	m_slimmedTrack

int	m_hardScatterOrKink

int	m_lowPtTrack

bool	m_fromFiles

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 39 of file GlobalChi2AlignTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ GlobalChi2AlignTool()

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

Constructor.

Definition at line 42 of file GlobalChi2AlignTool.cxx.

     : AthAlgTool(type,name,parent)
     , m_matrixTool("Trk::MatrixTool",this)
     , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
     , m_ntracks(0)
     , m_nmeas(0)
     , m_nhits(0)
     , m_chi2(0.)
     , m_nDoF(0)
     , m_ntuple(nullptr)
     , m_tree(nullptr)
     , m_run{}
     , m_event{}
     , m_materialOnTrack{}
     , m_momentum{}
     , m_nChambers(0)
     , m_chamberIds(new int[MAXNCHAMBERS])
     , m_nMatrixIndices(0)
     , m_matrixIndices(new int[MAXNINDICES])
     , m_nSecndDeriv(0)
     , m_secndDeriv(new double[MAXNINDICES*MAXNINDICES])
     , m_firstDeriv(new double[MAXNINDICES])
     , m_actualSecndDeriv(new double[MAXNINDICES])
     , m_eta{}
     , m_phi{}
     , m_perigee_x{}, m_perigee_y{}, m_perigee_z{}
     , m_trackInfo{}
     , m_bremFit{}
     , m_bremFitSuccessful{}
     , m_straightTrack{}
     , m_slimmedTrack{}
     , m_hardScatterOrKink{}
     , m_lowPtTrack{}
     , m_fromFiles(false)
   {      
     declareInterface<IAlignTool>(this);
  
     declareProperty("MatrixTool", m_matrixTool, "tool for storing and inverting matrix");
     declareProperty("AlignModuleTool", m_alignModuleTool);
  
     declareProperty("SecondDerivativeCut", m_secondDerivativeCut = -1e5);
  
     declareProperty("DoTree",              m_doTree = false);
     declareProperty("WriteActualSecDeriv", m_writeActualSecDeriv = false);
  
     declareProperty("StoreLocalDerivOnly", m_storeLocalDerivOnly = false);
  
     m_logStream = nullptr;
   }

◆ ~GlobalChi2AlignTool()

GlobalChi2AlignTool::~GlobalChi2AlignTool ( )

virtual

Virtual destructor.

Definition at line 94 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("in GlobalChi2AlignTool d'tor");
     //delete m_tree;
  
     delete [] m_chamberIds;
     delete [] m_matrixIndices;
     delete [] m_secndDeriv;
     delete [] m_firstDeriv;
     delete [] m_actualSecndDeriv;
  
     ATH_MSG_DEBUG("done with GlobalChi2AlignTool d'tor");
   }

Member Function Documentation

◆ accumulate()

bool GlobalChi2AlignTool::accumulate ( AlignTrack * alignTrack )

virtual

accumulates information from an AlignTrack

Implements Trk::IAlignTool.

Definition at line 143 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("in GlobalChi2AlignTool::accumulate()");
  
     // prepare ROOT tree for derivatives if it doesn't exist yet
     // Shouldn't this be in firstEventInitialize() ?
     if (m_doTree && !m_tree && m_ntuple) {
  
       m_ntuple->cd();
       m_tree=new TTree("globalChi2Deriv","globalChi2Deriv");
       m_tree->Branch("run",              &m_run,              "run/I");
       m_tree->Branch("event",            &m_event,            "event/I");
       m_tree->Branch("nChambers",        &m_nChambers,        "nChambers/I");
       m_tree->Branch("chamberIds",        m_chamberIds,       "chamberIds[nChambers]/I");
       m_tree->Branch("nMatrixIndices",   &m_nMatrixIndices,   "nMatrixIndices/I");
       m_tree->Branch("matrixIndices",     m_matrixIndices,    "matrixIndices[nMatrixIndices]/I");
       m_tree->Branch("nSecndDeriv",      &m_nSecndDeriv,       "nSecndDeriv/I");
       m_tree->Branch("secndDeriv",        m_secndDeriv,        "secndDeriv[nSecndDeriv]/D");
       m_tree->Branch("firstDeriv",        m_firstDeriv,       "firstDeriv[nMatrixIndices]/D");
       if (m_writeActualSecDeriv)
     m_tree->Branch("actualSecndDeriv",  m_actualSecndDeriv,  "actualSecndDeriv[nMatrixIndices]/D");
  
       m_tree->Branch("materialOnTrack",  &m_materialOnTrack,  "materialOnTrack/D");
       m_tree->Branch("momentum",         &m_momentum,         "momentum/D");
       m_tree->Branch("eta",              &m_eta,              "eta/D");
       m_tree->Branch("phi",              &m_phi,              "phi/D");
       m_tree->Branch("perigee_x",        &m_perigee_x,        "perigee_x/D");
       m_tree->Branch("perigee_y",        &m_perigee_y,        "perigee_y/D");
       m_tree->Branch("perigee_z",        &m_perigee_z,        "perigee_z/D");
       m_tree->Branch("trackInfo",         &m_trackInfo,          "trackInfo/I");
       m_tree->Branch("bremFit",           &m_bremFit,            "bremFit/I");           
       m_tree->Branch("bremFitSuccessful", &m_bremFitSuccessful,  "bremFitSuccessful/I"); 
       m_tree->Branch("straightTrack",     &m_straightTrack,      "straightTrack/I");     
       m_tree->Branch("slimmedTrack",      &m_slimmedTrack,       "slimmedTrack/I");      
       m_tree->Branch("hardScatterOrKink", &m_hardScatterOrKink,  "hardScatterOrKink/I"); 
       m_tree->Branch("lowPtTrack",        &m_lowPtTrack,         "lowPtTrack/I");        
     }
  
  
     // check if the track belongs to a vertex. If yes, retrieve the relevant objects:
     bool                                  fullVertex   = false;
     AlignVertex                         * ptrVertex    = alignTrack->getVtx();
     const Amg::Vector3D                 * ptrPosition  = nullptr;
     const AmgSymMatrix(3)               * ptrCovariance = nullptr;
     const std::vector<AlignModuleVertexDerivatives>   * ptrX = nullptr;
     AlignVertex::AlignVertexType          vtxType      = AlignVertex::Unknown;
     if( ptrVertex )  {
       fullVertex       = true;
       ptrPosition      = ptrVertex->position();
       ptrCovariance    = ptrVertex->covariance();
       ptrX             = ptrVertex->derivatives();
       vtxType          = ptrVertex->type();
  
       // check if pointers are valid
       if ( !ptrPosition || !ptrCovariance || !ptrX || vtxType<AlignVertex::Refitted ) {
         msg(MSG::ERROR)<<"something missing from alignVertex!"<<endmsg;
         if (!ptrPosition)     msg(MSG::ERROR)<<"no fitted position!"<<endmsg;
         if (!ptrCovariance)   msg(MSG::ERROR)<<"no covariance!"<<endmsg;
         if (!ptrX)            msg(MSG::ERROR)<<"no link to the X object!"<<endmsg;
         if (vtxType<AlignVertex::Refitted) msg(MSG::ERROR)<<"Vertex type = "<< vtxType << endmsg;
         return false;
       }
     }
  
  
  
     // reset tree variables
     m_nChambers=0;
     m_nMatrixIndices=0;
  
     // get pointers so we can reuse them if they're valid
     const Amg::SymMatrixX           * ptrWeights   = alignTrack->weightMatrix();
     const Amg::SymMatrixX           * ptrWeightsFD = alignTrack->weightMatrixFirstDeriv();
     const Amg::VectorX              * ptrResiduals = alignTrack->residualVector();
     const std::vector<AlignModuleDerivatives> * ptrDerivs    = alignTrack->derivatives();
  
     // check if pointers are valid
     if (!ptrWeights || !ptrWeightsFD || !ptrResiduals || !ptrDerivs) {
       msg(MSG::ERROR)<<"something missing from alignTrack!"<<endmsg;
       if (!ptrWeights)   msg(MSG::ERROR)<<"no weights!"<<endmsg;
       if (!ptrWeightsFD) msg(MSG::ERROR)<<"no weights for first deriv!"<<endmsg;
       if (!ptrResiduals) msg(MSG::ERROR)<<"no residuals!"<<endmsg;
       if (!ptrDerivs)    msg(MSG::ERROR)<<"no derivatives!"<<endmsg;
       return false;
     }
  
     // get weight matrices
     const Amg::SymMatrixX&          weights           = *ptrWeights;
     const Amg::SymMatrixX&          weightsFirstDeriv = *ptrWeightsFD;
     ATH_MSG_VERBOSE("weights="<<weights);
     ATH_MSG_VERBOSE("weightsFirstDeriv="<<weightsFirstDeriv);
  
     // get vectors
     const Amg::VectorX&                  residuals     = *ptrResiduals;
     std::vector<AlignModuleDerivatives>  derivatives   = *ptrDerivs;
     const std::vector<AlignModuleDerivatives>* derivativeErr = alignTrack->derivativeErr();
     const std::vector<std::pair<AlignModule*,std::vector<double> > >* secDerivs = alignTrack->actualSecondDerivatives();
  
  
  
     std::vector<AlignPar*> allAlignPars;
     std::vector<Amg::VectorX*> allDerivatives;
     std::vector<const Amg::VectorX*> allDerivativeErr;
     std::vector<double> allActualSecDeriv;
     int    WSize(weights.cols());
     Amg::MatrixX  matrix_F(3,WSize );
     matrix_F.setZero();
  
     // get all alignPars and all derivatives
     msg(MSG::DEBUG) << "accumulate: The derivative vector size is  " << derivatives.size() << endmsg;
     std::vector<AlignModuleDerivatives>::iterator derivIt     = derivatives.begin();
     std::vector<AlignModuleDerivatives>::iterator derivIt_end = derivatives.end();
  
     std::vector<AlignModuleDerivatives>::const_iterator derivErrIt;
     std::vector<std::pair<AlignModule*,std::vector<double> > >::const_iterator secDerivIt;
     if (derivativeErr) derivErrIt=derivativeErr->begin();
     if (secDerivs)     secDerivIt=secDerivs->begin();
     for ( ; derivIt!=derivIt_end ; ++derivIt) {
  
       // get AlignModule
       AlignModule* module=derivIt->first;
  
       // increment track counter
       module->addTrack();
       ATH_MSG_DEBUG("add track to module "<<module->identify().get_identifier32().get_compact());
       module->addNDoF(alignTrack->fitQuality()->numberDoF());
       module->addTrackChi2(alignTrack->fitQuality()->chiSquared());
  
       // tree variables
       if (m_nChambers<MAXNCHAMBERS) {
         m_chamberIds[m_nChambers]=module->identify().get_identifier32().get_compact();
         m_nChambers++;
       }
       else ATH_MSG_WARNING("number of chambers exceeded maximum");
  
       // get alignment parameters
       std::vector<Amg::VectorX>& deriv_vec = derivIt->second;
       ATH_MSG_DEBUG( "accumulate: The deriv_vec size is  " << deriv_vec.size() );
       DataVector<AlignPar>* alignPars = m_alignModuleTool->getAlignPars(module);
       int nModPars = alignPars->size();
       if (nModPars != (int)deriv_vec.size() && (nModPars+3) != (int)deriv_vec.size()) {
         ATH_MSG_ERROR("accumulate:  wrong size of the deriv_vec!");
         return false;
       }
       for (int i=0;i<3;i++) {
         for (int j=0;j<WSize;j++) {
           matrix_F(i,j) += deriv_vec[nModPars+i][j];        // in the derivIT loop the complete F matrix is built
         }
       }
  
       // get derivatives and derivative errors
       for (int i=0;i<nModPars;i++) {
         ATH_MSG_DEBUG("align par for module "<<(*alignPars)[i]->alignModule()->identify());
         allAlignPars.push_back((*alignPars)[i]);      
         allDerivatives.push_back(&deriv_vec[i]);
         if (derivativeErr)
           allDerivativeErr.push_back(&(derivErrIt->second)[i]);
         if (secDerivs)
           allActualSecDeriv.push_back((secDerivIt->second)[i]);
       }
       if (derivativeErr) ++derivErrIt;
       if (secDerivs) ++secDerivIt;
     }
  
     // increment hit counters in modules
     AlignTSOSCollection::iterator iatsos      = alignTrack->firstAtsos();
     AlignTSOSCollection::iterator iatsos_last = alignTrack->lastAtsos();
     for (; iatsos != iatsos_last; ++iatsos)
       if ((*iatsos)->module())
         (*iatsos)->module()->addHit();
  
     // determine all derivatives and set in matrix tool
     int nAllPars = allAlignPars.size();
     m_nSecndDeriv=0;
     for (int ipar=0;ipar<nAllPars;ipar++) {
  
       // calculate first derivative
       Amg::MatrixX derivativesT = (*allDerivatives[ipar]).transpose();
       ATH_MSG_DEBUG("derivativesT (size "<<derivativesT.cols()<<"): "<<derivativesT);
  
       Amg::MatrixX RHM= weightsFirstDeriv * residuals;
       ATH_MSG_DEBUG("RHM: "<<RHM);
  
       // get global parameter index
       int index1 = allAlignPars[ipar]->index();
  
       Amg::MatrixX firstderivM = 2.* derivativesT * RHM;
       ATH_MSG_DEBUG("firstderivM for i="<<index1 <<firstderivM);
       if (firstderivM(0,0)==0.) {
         ATH_MSG_DEBUG("firstderivM[0][0] is zero : "<<firstderivM(0,0));
         continue;
       }
  
  
  
       // tree variables
       if (m_nChambers<MAXNCHAMBERS) {
         m_matrixIndices[m_nMatrixIndices]=index1;
         ATH_MSG_DEBUG("ipar: "<<ipar<<", m_nMatrixIndices="<<m_nMatrixIndices);
         if (m_writeActualSecDeriv) {
           ATH_MSG_DEBUG("alActualSecDeriv size: "<<allActualSecDeriv.size());
           m_actualSecndDeriv[m_nMatrixIndices]=allActualSecDeriv[ipar];
         }
         m_nMatrixIndices++;
       }
  
       // get module index
       int imodule1 = allAlignPars[ipar]->alignModule()->identifyHash();
  
       // calculate second derivatives
       bool goodSecondDeriv = true;
       for (int jpar=ipar;jpar<nAllPars;jpar++) {
  
         // get global parameter index
         int index2=allAlignPars[jpar]->index();
     
         // get module index
         int imodule2 = allAlignPars[jpar]->alignModule()->identifyHash();
  
         // if only local Chi2 method is used, the 2nd derivatives (correlations)
         // between different modules don't need to be calculated/stored
         if (m_storeLocalDerivOnly)
           if (imodule1 != imodule2)
             continue;
  
         Amg::MatrixX RHM2 = weights * (*allDerivatives[jpar]);
         Amg::MatrixX secondderivM = 2. * derivativesT * RHM2;
  
         // if second derivative on diagonal is below cut
         // ignore the whole row/column
         if (jpar==ipar && secondderivM(0,0)<0.) {
           ATH_MSG_WARNING("second deriv < 0 !!!");
         }
         if (jpar==ipar && secondderivM(0,0)<m_secondDerivativeCut) {
           ATH_MSG_DEBUG("secondderivM[0][0] is below threshold : "<<
                         secondderivM(0,0)<<" < "<<m_secondDerivativeCut);
           goodSecondDeriv = false;
           break;
         }
     
         ATH_MSG_DEBUG("secondderivM for i "<<index1<<", j "<<index2<<": "<<secondderivM(0,0));
         m_matrixTool->addSecondDerivative(index1, index2, secondderivM(0,0));
  
         // store derivatives and indices for ntuple
         m_secndDeriv[m_nSecndDeriv]=secondderivM(0,0);
         m_nSecndDeriv++;
       }
       
       // if second derivative on diagonal didn't pass the cut,
       // ignore also the first derivative
       if (goodSecondDeriv) {
         m_matrixTool->addFirstDerivative(index1, firstderivM(0,0));     
         m_firstDeriv[ipar]=firstderivM(0,0);
       }
       else 
         m_firstDeriv[ipar]=-999.;    
     }
     
     
  
     
     if( fullVertex )  {              //  this track is associated to a vertex.
  
  
       ATH_MSG_DEBUG( "accumulate: Contribution from the fullVTX will be added " );
      
       Amg::MatrixX RHM = (*ptrCovariance) * (matrix_F) * (weightsFirstDeriv * residuals);
  
       std::vector<AlignPar*>           vtxAlignPars;
       std::vector<const Amg::VectorX*> vtxDerivatives;
  
       // get all alignPars and all derivatives
       msg(MSG::DEBUG) << "accumulate: The Vertex derivative vector size is  " << ptrX->size() << endmsg;
       std::vector<AlignModuleVertexDerivatives>::const_iterator XIt     = ptrX->begin();
       std::vector<AlignModuleVertexDerivatives>::const_iterator XIt_end = ptrX->end();
  
       for ( ; XIt!=XIt_end ; ++XIt) {
  
         // get AlignModule
         const AlignModule* module=XIt->first;
  
         // get alignment parameters
         const std::vector<Amg::VectorX>& X_vec = XIt->second;
         msg(MSG::DEBUG) << "accumulate: The X_vec size is  " << X_vec.size() << endmsg;
         DataVector<AlignPar>* alignPars = m_alignModuleTool->getAlignPars(module);
         int nModPars = alignPars->size();
         if (nModPars != (int)X_vec.size()) {
           ATH_MSG_ERROR("accumulate:  wrong size of the X_vec!");
           return false;
         }
  
         // get derivatives and derivative errors
         for (int i=0;i<nModPars;i++) {
           ATH_MSG_DEBUG("align par for module "<<(*alignPars)[i]->alignModule()->identify());
           vtxAlignPars.push_back((*alignPars)[i]);      
           vtxDerivatives.push_back(&X_vec[i]);
           }
  
       }
  
       // bit responsible for the constraint:
       int           ierr(0);
       AmgSymMatrix(3)  Qinv;
       Qinv.setZero();
       Amg::Vector3D    vtemp;
       vtemp.setZero();
       if( vtxType==AlignVertex::Refitted && ptrVertex->Constrained()  && ptrVertex->Qmatrix()->determinant() > 1.0e-24 )   {     // just my guess sigma>0.1 micron ???)    only once per vertex!
     
         bool invertible;
         double determinant;
         ptrVertex->Qmatrix()->computeInverseAndDetWithCheck(Qinv,determinant,invertible);
         
         if(!invertible) {
           std::cout <<"accumulate: Q inversion failed. CLHEP status flag = "<<ierr<< std::endl;
           return false;
         }
         vtemp(0) =   -ptrVertex->originalPosition()->x()+(*(ptrVertex->Vvector()))(0);
         vtemp(1) =   -ptrVertex->originalPosition()->y()+(*(ptrVertex->Vvector()))(1);
         vtemp(2) =   -ptrVertex->originalPosition()->z()+(*(ptrVertex->Vvector()))(2);
       }
  
  
       // determine all derivatives and set in matrix tool
       int nvtxPars = vtxAlignPars.size();
       for (int ipar=0;ipar<nvtxPars;ipar++) {
  
         // calculate first derivative
         Amg::MatrixX derivativesT = (*vtxDerivatives[ipar]).transpose();        
         Amg::MatrixX firstderivM = -2.* derivativesT * RHM;     //  -2 seems correct :)
  
         // bit responsible for the constraint:
         if( vtxType==AlignVertex::Refitted && ptrVertex->Constrained()  && ptrVertex->Qmatrix()->determinant() > 1.0e-24 )   {     // just my guess sigma>0.1 micron ???)   only once per vertex!
                 firstderivM  += 2.* derivativesT * ((*ptrCovariance) * Qinv) * vtemp; 
         }
  
         // get global parameter index
         int index1 = vtxAlignPars[ipar]->index();
  
         ATH_MSG_DEBUG("vtx firstderivM for i="<<index1 <<firstderivM);
  
  
         if( vtxType==AlignVertex::Refitted ) {                       // only once per vertex!
           ATH_MSG_DEBUG("accumulate: Filling second derivative for this vertex... ");
           for (int jpar=0;jpar<nvtxPars;jpar++) {
  
             // calculate second derivative
             Amg::MatrixX secondderivM = -1.* derivativesT * (*ptrCovariance) * (*vtxDerivatives[jpar]);   //  -1 is the right factor  :)
  
             // bit responsible for the constraint:
             if( ptrVertex->Constrained()  && ptrVertex->Qmatrix()->determinant() > 1.0e-24 )   {     // just my guess sigma>0.1 micron ???)
               secondderivM += 2.* derivativesT * ((*ptrCovariance) * Qinv * (*ptrCovariance)) * (*vtxDerivatives[jpar]);
             }
  
             // get global parameter index
             int index2=vtxAlignPars[jpar]->index();
  
             if( index1<=index2 ) {
               ATH_MSG_DEBUG("vtx secondderivM for i="<<index1<<", j="<<index2<<": "<<secondderivM(0,0));
               m_matrixTool->addSecondDerivative(index1, index2, secondderivM(0,0));
             }
  
           }
           ptrVertex->setType(AlignVertex::Accumulated);              // only once per vertex!
         }
  
         m_matrixTool->addFirstDerivative(index1, firstderivM(0,0));     
  
       }
  
     }
     
  
  
  
  
     // fill tree
     if (m_tree) {      
       
       // get tree variables
       const xAOD::EventInfo* currentEvent;
       StatusCode sc = evtStore()->retrieve(currentEvent);
       if (sc==StatusCode::SUCCESS) {
           m_run   = currentEvent->runNumber();
           m_event = currentEvent->eventNumber();
       }
       else {
         m_run   = -999;
         m_event = -999;
       } 
  
       m_materialOnTrack=getMaterialOnTrack(alignTrack->originalTrack());
       ATH_MSG_DEBUG("materialOnTrack: "<<m_materialOnTrack);
  
       double pT=alignTrack->originalTrack()->perigeeParameters()->pT();
       double eta=alignTrack->originalTrack()->perigeeParameters()->eta();    
       m_momentum=std::fabs(pT)*std::sqrt(1.+sinh(eta)*sinh(eta));
       m_eta=eta;
       m_phi=alignTrack->originalTrack()->perigeeParameters()->momentum().phi();
  
       Amg::Vector3D pos=alignTrack->originalTrack()->perigeeParameters()->position();
       m_perigee_x=pos.x();
       m_perigee_y=pos.y();
       m_perigee_z=pos.z();
       
       const TrackInfo info=alignTrack->originalTrack()->info();
       m_trackInfo         = (int)info.trackFitter();
       m_bremFit           = (int)info.trackProperties(Trk::TrackInfo::BremFit);         
       m_bremFitSuccessful = (int)info.trackProperties(Trk::TrackInfo::BremFitSuccessful); 
       m_straightTrack     = (int)info.trackProperties(Trk::TrackInfo::StraightTrack);     
       m_slimmedTrack      = (int)info.trackProperties(Trk::TrackInfo::SlimmedTrack);       
       m_hardScatterOrKink = (int)info.trackProperties(Trk::TrackInfo::HardScatterOrKink); 
       m_lowPtTrack        = (int)info.trackProperties(Trk::TrackInfo::LowPtTrack);    
       
       m_ntuple->cd();
       m_tree->Fill();
     }         
     
     // increment total number of accumulated tracks, hits and the total chi2
     m_ntracks++;
     m_nmeas += alignTrack->nAlignTSOSMeas();
     m_nhits += alignTrack->alignTSOSCollection()->size();
     m_chi2  += alignTrack->fitQuality()->chiSquared();
     m_nDoF  += alignTrack->fitQuality()->numberDoF();
  
     if(m_ntracks%50==0)
       ATH_MSG_INFO(">>>> Number of accumulated tracks: "<<m_ntracks);
  
     return true;
   }

◆ accumulateFromFiles()

bool GlobalChi2AlignTool::accumulateFromFiles ( )

virtual

accumulates information from binary files

Implements Trk::IAlignTool.

Definition at line 574 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("in accumulate");
     bool success = m_matrixTool->accumulateFromFiles();
  
     if (!success) {
       ATH_MSG_FATAL("failure in MatrixTool accumulateFromFiles");
       return false;
     }
  
     m_fromFiles = true;
  
     return true;
   }  

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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

◆ fillNtuple()

StatusCode GlobalChi2AlignTool::fillNtuple ( )

virtual

writes tree to ntuple

Reimplemented from Trk::IAlignTool.

Definition at line 630 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("writing tree");
     int success=1;
     if (m_tree) {
       m_ntuple->cd();
       success = m_tree->Write();
     }
     return success>0 ? StatusCode::SUCCESS : StatusCode::FAILURE;
   }

◆ finalize()

StatusCode GlobalChi2AlignTool::finalize ( )

virtual

finalize

Definition at line 642 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("finalize() of GlobalChi2AlignTool");
     return StatusCode::SUCCESS;    
   }

◆ firstEventInitialize()

StatusCode GlobalChi2AlignTool::firstEventInitialize ( )

virtual

sets up matrix

Implements Trk::IAlignTool.

Definition at line 126 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("in GlobalGhi2AlignTool::firstEventInitialize()");
     
     int nDoF=m_alignModuleTool->nAlignParameters();
     ATH_MSG_DEBUG("allocating matrix with "<<nDoF<<" degrees of freedom");
  
     if( m_matrixTool->allocateMatrix(nDoF).isFailure()) {
       msg(MSG::FATAL)<<"Problem with allocateMatrix"<<endmsg;
       return StatusCode::FAILURE;
     }
     ATH_MSG_DEBUG("done with firstEventInitialize()");
     
     return StatusCode::SUCCESS;
   }

◆ getMaterialOnTrack()

double GlobalChi2AlignTool::getMaterialOnTrack ( const Trk::Track * track )

private

Definition at line 649 of file GlobalChi2AlignTool.cxx.

   {
  
     double materialOnTrack(0.);
     
     const Trk::TrackStates* states = track->trackStateOnSurfaces();
     if ( !states ) {
       ATH_MSG_WARNING("no states");
       return 0;
     }
     
     // loop over TSOSs, find MDT hits, and mark them as outliers:
     Trk::TrackStates::const_iterator tsit = states->begin();
     Trk::TrackStates::const_iterator tsit_end = states->end();
     ATH_MSG_DEBUG("looping over TSOS");
  
     for ( ; tsit!=tsit_end ; ++tsit ) {
       const Trk:: MaterialEffectsBase* materialEffects =  (*tsit)->materialEffectsOnTrack();
       if (materialEffects) {
         const Trk::MaterialEffectsOnTrack* meot=dynamic_cast<const Trk::MaterialEffectsOnTrack*>(materialEffects);
         if (meot) {
           materialOnTrack += meot->thicknessInX0();
           ATH_MSG_DEBUG("new materialOnTrack: "<<materialOnTrack);
         }
         else {
           ATH_MSG_DEBUG("not material on track");
         }      
       }      
     }
     
     return materialOnTrack;
   }

◆ initialize()

StatusCode GlobalChi2AlignTool::initialize ( )

virtual

initialize

Definition at line 109 of file GlobalChi2AlignTool.cxx.

   {
     ATH_MSG_DEBUG("initialize() of GlobalChi2AlignTool");  
     // Get MatrixTool  
     ATH_CHECK( m_matrixTool.retrieve() );
     ATH_CHECK(m_alignModuleTool.retrieve() );
     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 & IAlignTool::interfaceID ( )

inlinestaticinherited

Definition at line 58 of file IAlignTool.h.

                                                     {
     return   IID_TRK_IAlignTool;
   }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ nAccumulatedTracks()

unsigned int Trk::GlobalChi2AlignTool::nAccumulatedTracks ( )

inline

returns total number of accumulated tracks

Definition at line 68 of file GlobalChi2AlignTool.h.

68 { return m_ntracks; };

◆ 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();
   }

◆ setLogStream()

void GlobalChi2AlignTool::setLogStream ( std::ostream * os )

virtual

sets the output stream for the logfile

Reimplemented from Trk::IAlignTool.

Definition at line 119 of file GlobalChi2AlignTool.cxx.

   {
     m_logStream = os;
     m_matrixTool->setLogStream(m_logStream);
   }

◆ setNtuple()

void Trk::GlobalChi2AlignTool::setNtuple ( TFile * ntuple )

inlinevirtual

set ntuple

Reimplemented from Trk::IAlignTool.

Definition at line 71 of file GlobalChi2AlignTool.h.

71 { m_ntuple=ntuple; }

◆ solve()

StatusCode GlobalChi2AlignTool::solve ( )

virtual

solves for alignment parameters

Implements Trk::IAlignTool.

Definition at line 590 of file GlobalChi2AlignTool.cxx.

   {
     if(m_fromFiles)
       m_nhits = m_matrixTool->nHits();
     else {
       m_matrixTool->setNTracks(m_ntracks);
       m_matrixTool->setNMeasurements(m_nmeas);
       m_matrixTool->setNHits(m_nhits);
     }
  
     // print statistics
     if(m_logStream) {
       *m_logStream<<"*************************************************************"<<std::endl;
       *m_logStream<<"******          Global Chi2 alignment solving          ******"<<std::endl;
       *m_logStream<<"*"<<std::endl;
       if(!m_fromFiles)
         *m_logStream<<"* number of accumulated tracks:   "<<m_ntracks<<std::endl;
       *m_logStream<<"* number of processed hits:       "<<m_nhits<<std::endl;
       if(!m_fromFiles) {
         *m_logStream<<"* number of used measurements:    "<<m_nmeas<<std::endl;
         *m_logStream<<"* total chi2 / nDoF:              "<<m_chi2<<" / "<<m_nDoF<<std::endl;
       }
       *m_logStream<<"*"<<std::endl;
       *m_logStream<<"* number of alignable objects:    "<<m_alignModuleTool->alignModules1D()->size()<<std::endl;
       *m_logStream<<"* total number of alignment DoFs: "<<m_alignModuleTool->nAlignParameters()<<std::endl;
       *m_logStream<<"*"<<std::endl;
     }
  
     ATH_MSG_INFO(">>>> -----------------------------------------------");
     ATH_MSG_INFO(">>>> Total number of accumulated tracks: "<<m_ntracks);
     ATH_MSG_INFO(">>>> -----------------------------------------------");  
  
     ATH_MSG_DEBUG("calling matrixTool->solve()");
     if (m_matrixTool->solve()>0)
       return StatusCode::SUCCESS;
  
     return  StatusCode::FAILURE;
   }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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_actualSecndDeriv

double* Trk::GlobalChi2AlignTool::m_actualSecndDeriv

private

Definition at line 118 of file GlobalChi2AlignTool.h.

◆ m_alignModuleTool

ToolHandle<Trk::IAlignModuleTool> Trk::GlobalChi2AlignTool::m_alignModuleTool

private

Pointer to AlignModuleTool.

Definition at line 87 of file GlobalChi2AlignTool.h.

◆ m_bremFit

int Trk::GlobalChi2AlignTool::m_bremFit

private

Definition at line 125 of file GlobalChi2AlignTool.h.

◆ m_bremFitSuccessful

int Trk::GlobalChi2AlignTool::m_bremFitSuccessful

private

Definition at line 126 of file GlobalChi2AlignTool.h.

◆ m_chamberIds

int* Trk::GlobalChi2AlignTool::m_chamberIds

private

Definition at line 112 of file GlobalChi2AlignTool.h.

◆ m_chi2

double Trk::GlobalChi2AlignTool::m_chi2

private

total chi2

Definition at line 96 of file GlobalChi2AlignTool.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_doTree

bool Trk::GlobalChi2AlignTool::m_doTree

private

Definition at line 100 of file GlobalChi2AlignTool.h.

◆ m_eta

double Trk::GlobalChi2AlignTool::m_eta

private

Definition at line 119 of file GlobalChi2AlignTool.h.

◆ m_event

int Trk::GlobalChi2AlignTool::m_event

private

Definition at line 108 of file GlobalChi2AlignTool.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_firstDeriv

double* Trk::GlobalChi2AlignTool::m_firstDeriv

private

Definition at line 117 of file GlobalChi2AlignTool.h.

◆ m_fromFiles

bool Trk::GlobalChi2AlignTool::m_fromFiles

private

Definition at line 132 of file GlobalChi2AlignTool.h.

◆ m_hardScatterOrKink

int Trk::GlobalChi2AlignTool::m_hardScatterOrKink

private

Definition at line 129 of file GlobalChi2AlignTool.h.

◆ m_logStream

std::ostream* Trk::IAlignTool::m_logStream

protectedinherited

logfile output stream

Definition at line 54 of file IAlignTool.h.

◆ m_lowPtTrack

int Trk::GlobalChi2AlignTool::m_lowPtTrack

private

Definition at line 130 of file GlobalChi2AlignTool.h.

◆ m_materialOnTrack

double Trk::GlobalChi2AlignTool::m_materialOnTrack

private

Definition at line 109 of file GlobalChi2AlignTool.h.

◆ m_matrixIndices

int* Trk::GlobalChi2AlignTool::m_matrixIndices

private

Definition at line 114 of file GlobalChi2AlignTool.h.

◆ m_matrixTool

ToolHandle<Trk::IMatrixTool> Trk::GlobalChi2AlignTool::m_matrixTool

private

Pointer to MatrixTool, used to write to and solve matrix.

Definition at line 84 of file GlobalChi2AlignTool.h.

◆ m_momentum

double Trk::GlobalChi2AlignTool::m_momentum

private

Definition at line 110 of file GlobalChi2AlignTool.h.

◆ m_nChambers

int Trk::GlobalChi2AlignTool::m_nChambers

private

Definition at line 111 of file GlobalChi2AlignTool.h.

◆ m_nDoF

unsigned int Trk::GlobalChi2AlignTool::m_nDoF

private

number of degrees of freedom

Definition at line 97 of file GlobalChi2AlignTool.h.

◆ m_nhits

unsigned int Trk::GlobalChi2AlignTool::m_nhits

private

number of accumulated hits

Definition at line 95 of file GlobalChi2AlignTool.h.

◆ m_nMatrixIndices

int Trk::GlobalChi2AlignTool::m_nMatrixIndices

private

Definition at line 113 of file GlobalChi2AlignTool.h.

◆ m_nmeas

unsigned int Trk::GlobalChi2AlignTool::m_nmeas

private

number of accumulated measurements

Definition at line 94 of file GlobalChi2AlignTool.h.

◆ m_nSecndDeriv

int Trk::GlobalChi2AlignTool::m_nSecndDeriv

private

Definition at line 115 of file GlobalChi2AlignTool.h.

◆ m_ntracks

unsigned int Trk::GlobalChi2AlignTool::m_ntracks

private

number of accumulated tracks

Definition at line 93 of file GlobalChi2AlignTool.h.

◆ m_ntuple

TFile* Trk::GlobalChi2AlignTool::m_ntuple

private

output ntuple

Definition at line 105 of file GlobalChi2AlignTool.h.

◆ m_pathbin

std::string Trk::GlobalChi2AlignTool::m_pathbin

private

path binary files (in/out)

Definition at line 89 of file GlobalChi2AlignTool.h.

◆ m_pathtxt

std::string Trk::GlobalChi2AlignTool::m_pathtxt

private

path ascii files (in/out)

Definition at line 90 of file GlobalChi2AlignTool.h.

◆ m_perigee_x

double Trk::GlobalChi2AlignTool::m_perigee_x

private

Definition at line 121 of file GlobalChi2AlignTool.h.

◆ m_perigee_y

double Trk::GlobalChi2AlignTool::m_perigee_y

private

Definition at line 122 of file GlobalChi2AlignTool.h.

◆ m_perigee_z

double Trk::GlobalChi2AlignTool::m_perigee_z

private

Definition at line 123 of file GlobalChi2AlignTool.h.

◆ m_phi

double Trk::GlobalChi2AlignTool::m_phi

private

Definition at line 120 of file GlobalChi2AlignTool.h.

◆ m_prefixName

std::string Trk::GlobalChi2AlignTool::m_prefixName

private

prefix string to filenames

Definition at line 91 of file GlobalChi2AlignTool.h.

◆ m_run

int Trk::GlobalChi2AlignTool::m_run

private

Definition at line 107 of file GlobalChi2AlignTool.h.

◆ m_secndDeriv

double* Trk::GlobalChi2AlignTool::m_secndDeriv

private

Definition at line 116 of file GlobalChi2AlignTool.h.

◆ m_secondDerivativeCut

double Trk::GlobalChi2AlignTool::m_secondDerivativeCut

private

Definition at line 99 of file GlobalChi2AlignTool.h.

◆ m_slimmedTrack

int Trk::GlobalChi2AlignTool::m_slimmedTrack

private

Definition at line 128 of file GlobalChi2AlignTool.h.

◆ m_storeLocalDerivOnly

bool Trk::GlobalChi2AlignTool::m_storeLocalDerivOnly

private

Definition at line 102 of file GlobalChi2AlignTool.h.

◆ m_straightTrack

int Trk::GlobalChi2AlignTool::m_straightTrack

private

Definition at line 127 of file GlobalChi2AlignTool.h.

◆ m_trackInfo

int Trk::GlobalChi2AlignTool::m_trackInfo

private

Definition at line 124 of file GlobalChi2AlignTool.h.

◆ m_tree

TTree* Trk::GlobalChi2AlignTool::m_tree

private

Definition at line 106 of file GlobalChi2AlignTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeActualSecDeriv

bool Trk::GlobalChi2AlignTool::m_writeActualSecDeriv

private

Definition at line 101 of file GlobalChi2AlignTool.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ GlobalChi2AlignTool()

◆ ~GlobalChi2AlignTool()

Member Function Documentation

◆ accumulate()

◆ accumulateFromFiles()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillNtuple()

◆ finalize()

◆ firstEventInitialize()

◆ getMaterialOnTrack()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ nAccumulatedTracks()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setLogStream()

◆ setNtuple()

◆ solve()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_actualSecndDeriv

◆ m_alignModuleTool

◆ m_bremFit

◆ m_bremFitSuccessful

◆ m_chamberIds

◆ m_chi2

◆ m_detStore

◆ m_doTree

◆ m_eta

◆ m_event

◆ m_evtStore

◆ m_firstDeriv

◆ m_fromFiles

◆ m_hardScatterOrKink

◆ m_logStream

◆ m_lowPtTrack

◆ m_materialOnTrack

◆ m_matrixIndices

◆ m_matrixTool

◆ m_momentum

◆ m_nChambers

◆ m_nDoF

◆ m_nhits

◆ m_nMatrixIndices

◆ m_nmeas

◆ m_nSecndDeriv

◆ m_ntracks

◆ m_ntuple

◆ m_pathbin