Trk::GlobalChi2AlignTool Class Reference

#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.
virtual	~GlobalChi2AlignTool ()
	Virtual destructor.
virtual StatusCode	initialize ()
	initialize
virtual StatusCode	finalize ()
	finalize
virtual StatusCode	firstEventInitialize ()
	sets up matrix
virtual StatusCode	solve ()
	solves for alignment parameters
bool	accumulate (AlignTrack *alignTrack)
	accumulates information from an AlignTrack
bool	accumulateFromFiles ()
	accumulates information from binary files
unsigned int	nAccumulatedTracks ()
	returns total number of accumulated tracks
void	setNtuple (TFile *ntuple)
	set ntuple
void	setLogStream (std::ostream *os)
	sets the output stream for the logfile
StatusCode	fillNtuple ()
	writes tree to ntuple
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 ()

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.

Protected Attributes
std::ostream *	m_logStream
	logfile output stream

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
double	getMaterialOnTrack (const Trk::Track *track)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< Trk::IMatrixTool >	m_matrixTool
	Pointer to MatrixTool, used to write to and solve matrix.
PublicToolHandle< Trk::IAlignModuleTool >	m_alignModuleTool
	Pointer to AlignModuleTool.
std::string	m_pathbin
	path binary files (in/out)
std::string	m_pathtxt
	path ascii files (in/out)
std::string	m_prefixName
	prefix string to filenames
unsigned int	m_ntracks = 0
	number of accumulated tracks
unsigned int	m_nmeas = 0
	number of accumulated measurements
unsigned int	m_nhits = 0
	number of accumulated hits
double	m_chi2 = 0.
	total chi2
unsigned int	m_nDoF = 0
	number of degrees of freedom
Gaudi::Property< double >	m_secondDerivativeCut {this, "SecondDerivativeCut", -1e5}
Gaudi::Property< bool >	m_doTree {this, "DoTree", false}
Gaudi::Property< bool >	m_writeActualSecDeriv {this, "WriteActualSecDeriv", false}
Gaudi::Property< bool >	m_storeLocalDerivOnly {this, "StoreLocalDerivOnly", false}
TFile *	m_ntuple = nullptr
	output ntuple
TTree *	m_tree = nullptr
int	m_run {}
int	m_event {}
double	m_materialOnTrack {}
double	m_momentum {}
int	m_nChambers = 0
int *	m_chamberIds = new int[MAXNCHAMBERS]
int	m_nMatrixIndices = 0
int *	m_matrixIndices = new int[MAXNINDICES]
int	m_nSecndDeriv = 0
double *	m_secndDeriv = new double[MAXNINDICES*MAXNINDICES]
double *	m_firstDeriv = new double[MAXNINDICES]
double *	m_actualSecndDeriv = new double[MAXNINDICES]
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 = false
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

Static Private Attributes
static constexpr int	MAXNCHAMBERS =50
static constexpr int	MAXNINDICES =50*6

Detailed Description

Definition at line 38 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 37 of file GlobalChi2AlignTool.cxx.

    : AthAlgTool(type,name,parent)
  {      
    declareInterface<IAlignTool>(this);
    m_logStream = nullptr;
  }

~GlobalChi2AlignTool()

GlobalChi2AlignTool::~GlobalChi2AlignTool ( )

virtual

Virtual destructor.

Definition at line 46 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 95 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 526 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()

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; }

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

fillNtuple()

StatusCode GlobalChi2AlignTool::fillNtuple ( )

virtual

writes tree to ntuple

Reimplemented from Trk::IAlignTool.

Definition at line 582 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 594 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 78 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 601 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 61 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()

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

nAccumulatedTracks()

unsigned int Trk::GlobalChi2AlignTool::nAccumulatedTracks ( )

inline

returns total number of accumulated tracks

Definition at line 67 of file GlobalChi2AlignTool.h.

{ 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 71 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 70 of file GlobalChi2AlignTool.h.

{ m_ntuple=ntuple; }

solve()

StatusCode GlobalChi2AlignTool::solve ( )

virtual

solves for alignment parameters

Implements Trk::IAlignTool.

Definition at line 542 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 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_actualSecndDeriv

double* Trk::GlobalChi2AlignTool::m_actualSecndDeriv = new double[MAXNINDICES]

private

Definition at line 122 of file GlobalChi2AlignTool.h.

m_alignModuleTool

PublicToolHandle<Trk::IAlignModuleTool> Trk::GlobalChi2AlignTool::m_alignModuleTool

private

Initial value:

{this,
      "AlignModuleTool", "Trk::AlignModuleTool/AlignModuleTool"}

Pointer to AlignModuleTool.

Definition at line 87 of file GlobalChi2AlignTool.h.

                                                           {this,
      "AlignModuleTool", "Trk::AlignModuleTool/AlignModuleTool"};

m_bremFit

int Trk::GlobalChi2AlignTool::m_bremFit {}

private

Definition at line 129 of file GlobalChi2AlignTool.h.

{};

m_bremFitSuccessful

int Trk::GlobalChi2AlignTool::m_bremFitSuccessful {}

private

Definition at line 130 of file GlobalChi2AlignTool.h.

{};

m_chamberIds

int* Trk::GlobalChi2AlignTool::m_chamberIds = new int[MAXNCHAMBERS]

private

Definition at line 116 of file GlobalChi2AlignTool.h.

m_chi2

double Trk::GlobalChi2AlignTool::m_chi2 = 0.

private

total chi2

Definition at line 97 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

Gaudi::Property<bool> Trk::GlobalChi2AlignTool::m_doTree {this, "DoTree", false}

private

Definition at line 101 of file GlobalChi2AlignTool.h.

{this, "DoTree", false};

m_eta

double Trk::GlobalChi2AlignTool::m_eta {}

private

Definition at line 123 of file GlobalChi2AlignTool.h.

{};

m_event

int Trk::GlobalChi2AlignTool::m_event {}

private

Definition at line 112 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 = new double[MAXNINDICES]

private

Definition at line 121 of file GlobalChi2AlignTool.h.

m_fromFiles

bool Trk::GlobalChi2AlignTool::m_fromFiles = false

private

Definition at line 136 of file GlobalChi2AlignTool.h.

m_hardScatterOrKink

int Trk::GlobalChi2AlignTool::m_hardScatterOrKink {}

private

Definition at line 133 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 134 of file GlobalChi2AlignTool.h.

{};

m_materialOnTrack

double Trk::GlobalChi2AlignTool::m_materialOnTrack {}

private

Definition at line 113 of file GlobalChi2AlignTool.h.

{};

m_matrixIndices

int* Trk::GlobalChi2AlignTool::m_matrixIndices = new int[MAXNINDICES]

private

Definition at line 118 of file GlobalChi2AlignTool.h.

m_matrixTool

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

private

Initial value:

{this, "MatrixTool", "Trk::MatrixTool",
      "tool for storing and inverting matrix"}

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

Definition at line 83 of file GlobalChi2AlignTool.h.

                                           {this, "MatrixTool", "Trk::MatrixTool",
      "tool for storing and inverting matrix"};

m_momentum

double Trk::GlobalChi2AlignTool::m_momentum {}

private

Definition at line 114 of file GlobalChi2AlignTool.h.

{};

m_nChambers

int Trk::GlobalChi2AlignTool::m_nChambers = 0

private

Definition at line 115 of file GlobalChi2AlignTool.h.

m_nDoF

unsigned int Trk::GlobalChi2AlignTool::m_nDoF = 0

private

number of degrees of freedom

Definition at line 98 of file GlobalChi2AlignTool.h.

m_nhits

unsigned int Trk::GlobalChi2AlignTool::m_nhits = 0

private

number of accumulated hits

Definition at line 96 of file GlobalChi2AlignTool.h.

m_nMatrixIndices

int Trk::GlobalChi2AlignTool::m_nMatrixIndices = 0

private

Definition at line 117 of file GlobalChi2AlignTool.h.

m_nmeas

unsigned int Trk::GlobalChi2AlignTool::m_nmeas = 0

private

number of accumulated measurements

Definition at line 95 of file GlobalChi2AlignTool.h.

m_nSecndDeriv

int Trk::GlobalChi2AlignTool::m_nSecndDeriv = 0

private

Definition at line 119 of file GlobalChi2AlignTool.h.

m_ntracks

unsigned int Trk::GlobalChi2AlignTool::m_ntracks = 0

private

number of accumulated tracks

Definition at line 94 of file GlobalChi2AlignTool.h.

m_ntuple

TFile* Trk::GlobalChi2AlignTool::m_ntuple = nullptr

private

output ntuple

Definition at line 109 of file GlobalChi2AlignTool.h.

m_pathbin

std::string Trk::GlobalChi2AlignTool::m_pathbin

private

path binary files (in/out)

Definition at line 90 of file GlobalChi2AlignTool.h.

m_pathtxt

std::string Trk::GlobalChi2AlignTool::m_pathtxt

private

path ascii files (in/out)

Definition at line 91 of file GlobalChi2AlignTool.h.

m_perigee_x

double Trk::GlobalChi2AlignTool::m_perigee_x {}

private

Definition at line 125 of file GlobalChi2AlignTool.h.

{};

m_perigee_y

double Trk::GlobalChi2AlignTool::m_perigee_y {}

private

Definition at line 126 of file GlobalChi2AlignTool.h.

{};

m_perigee_z

double Trk::GlobalChi2AlignTool::m_perigee_z {}

private

Definition at line 127 of file GlobalChi2AlignTool.h.

{};

m_phi

double Trk::GlobalChi2AlignTool::m_phi {}

private

Definition at line 124 of file GlobalChi2AlignTool.h.

{};

m_prefixName

std::string Trk::GlobalChi2AlignTool::m_prefixName

private

prefix string to filenames

Definition at line 92 of file GlobalChi2AlignTool.h.

m_run

int Trk::GlobalChi2AlignTool::m_run {}

private

Definition at line 111 of file GlobalChi2AlignTool.h.

{};

m_secndDeriv

double* Trk::GlobalChi2AlignTool::m_secndDeriv = new double[MAXNINDICES*MAXNINDICES]

private

Definition at line 120 of file GlobalChi2AlignTool.h.

m_secondDerivativeCut

Gaudi::Property<double> Trk::GlobalChi2AlignTool::m_secondDerivativeCut {this, "SecondDerivativeCut", -1e5}

private

Definition at line 100 of file GlobalChi2AlignTool.h.

{this, "SecondDerivativeCut", -1e5};

m_slimmedTrack

int Trk::GlobalChi2AlignTool::m_slimmedTrack {}

private

Definition at line 132 of file GlobalChi2AlignTool.h.

{};

m_storeLocalDerivOnly

Gaudi::Property<bool> Trk::GlobalChi2AlignTool::m_storeLocalDerivOnly {this, "StoreLocalDerivOnly", false}

private

Definition at line 103 of file GlobalChi2AlignTool.h.

{this, "StoreLocalDerivOnly", false};

m_straightTrack

int Trk::GlobalChi2AlignTool::m_straightTrack {}

private

Definition at line 131 of file GlobalChi2AlignTool.h.

{};

m_trackInfo

int Trk::GlobalChi2AlignTool::m_trackInfo {}

private

Definition at line 128 of file GlobalChi2AlignTool.h.

{};

m_tree

TTree* Trk::GlobalChi2AlignTool::m_tree = nullptr

private

Definition at line 110 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

Gaudi::Property<bool> Trk::GlobalChi2AlignTool::m_writeActualSecDeriv {this, "WriteActualSecDeriv", false}

private

Definition at line 102 of file GlobalChi2AlignTool.h.

{this, "WriteActualSecDeriv", false};

MAXNCHAMBERS

int Trk::GlobalChi2AlignTool::MAXNCHAMBERS =50

staticconstexprprivate

Definition at line 105 of file GlobalChi2AlignTool.h.

MAXNINDICES

int Trk::GlobalChi2AlignTool::MAXNINDICES =50*6

staticconstexprprivate

Definition at line 106 of file GlobalChi2AlignTool.h.

---

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

• GlobalChi2AlignTool.h
• GlobalChi2AlignTool.cxx