#include <AnalyticalDerivCalcTool.h>

Inheritance diagram for Trk::AnalyticalDerivCalcTool:

Collaboration diagram for Trk::AnalyticalDerivCalcTool:

Public Types
enum	SolveOption { NONE = 0, SOLVE = 1, SOLVE_FAST = 2, DIRECT_SOLVE = 3, DIRECT_SOLVE_FAST = 4, DIRECT_SOLVE_CLUSTER = 5 }
	enum of different solving options More...

Public Member Functions
	AnalyticalDerivCalcTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~AnalyticalDerivCalcTool ()

StatusCode	initialize ()

StatusCode	finalize ()

bool	setDerivatives (AlignTrack *alignTrack)
	sets analytical partial derivatives of residuals w.r.t alignment parameters for TSOS on alignTrack. More...

void	showStatistics ()
	not used yet More...

bool	setResidualCovMatrix (AlignTrack *alignTrack) const
	sets residual covariance matrix More...

void	setSolveOption (int solveOption)
	solving option (see enum above) More...

virtual void	setLogStream (std::ostream *os)
	sets the output stream for the logfile 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 ()
	Retrieve interface ID. More...

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
bool	getMeasErrorMatrix (const AlignTrack *alignTrack, Amg::MatrixX &V) const

bool	getTrkParamCovMatrix (const AlignTrack *alignTrack, Amg::MatrixX &HCH) const

bool	checkValidity (const Amg::MatrixX &R) const

std::vector< Amg::VectorX >	getDerivatives (AlignTrack alignTrack, const AlignModule module)

void	checkResidualType (const AlignTrack *alignTrack)

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< IAlignModuleTool >	m_alignModuleTool

const AtlasDetectorID *	m_idHelper

MeasurementTypeID *	m_measTypeIdHelper

std::vector< std::pair< const AlignModule *, std::vector< Amg::VectorX > > >	m_derivatives

bool	m_useLocalSetting
	use local setup for the covariance matrix of the track More...

bool	m_useIntrinsicPixelErrors = false
	use intrinsic errors for Pixel More...

bool	m_useIntrinsicSCTErrors = false
	use intrinsic errors for SCT More...

bool	m_useIntrinsicTRTErrors = false
	use intrinsic errors for TRT More...

int	m_residualType
	residual type to be used in the calculations More...

bool	m_residualTypeSet
	do we have the residual type set? More...

bool	m_storeDerivatives
	store derivatives on AlignTSOS to be filled into ntuple More...

int	m_solveOption = 0

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 AnalyticalDerivCalcTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ SolveOption

enum Trk::IDerivCalcTool::SolveOption

inherited

enum of different solving options

Enumerator
NONE	not solve in any case (to be used when ipc)
SOLVE	solving after data accumulation (LAPACK)
SOLVE_FAST	Fast (Eigen method) solving after data accumulation.
DIRECT_SOLVE	direct solving (LAPACK), already available matrix & vector
DIRECT_SOLVE_FAST	direct Fast (Eigen method) solving, already available matrix & vector
DIRECT_SOLVE_CLUSTER	computation of alignment parameters from SCALAPAK already solved matrix

Definition at line 41 of file IDerivCalcTool.h.

                      { 
       NONE                 = 0, 
       SOLVE                = 1, 
       SOLVE_FAST           = 2, 
       DIRECT_SOLVE         = 3, 
       DIRECT_SOLVE_FAST    = 4, 
       DIRECT_SOLVE_CLUSTER = 5  
     }; // this is also defined in TrkGlobAlign class

Constructor & Destructor Documentation

◆ AnalyticalDerivCalcTool()

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

Definition at line 33 of file AnalyticalDerivCalcTool.cxx.

     : AthAlgTool(type,name,parent)
     , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
     , m_idHelper(nullptr)
     , m_measTypeIdHelper(nullptr)
     , m_residualType(HitOnly)
     , m_residualTypeSet(false)
     , m_storeDerivatives(false)
   {
     declareInterface<IDerivCalcTool>(this);
  
     declareProperty("AlignModuleTool",   m_alignModuleTool);
  
     declareProperty("UseLocalSetting", m_useLocalSetting=false, "use local setup for the covariance matrix of the track");
  
     // Use constant errors for each sub-detector such that it's equivalent
     // to minimize residual distance instead of minizing residual pull.
     // This is only applied if m_useLocalSetting==true
     declareProperty("UseIntrinsicPixelError", m_useIntrinsicPixelErrors, "use intrinsic errors for Pixel");
     declareProperty("UseIntrinsicSCTError",   m_useIntrinsicSCTErrors,   "use intrinsic errors for SCT");
     declareProperty("UseIntrinsicTRTError",   m_useIntrinsicTRTErrors,   "use intrinsic errors for TRT");
  
     declareProperty("StoreDerivatives", m_storeDerivatives, "store derivatives dr/da on AlignTSOS to be filled into ntuple");
  
     m_logStream = nullptr;
   }

◆ ~AnalyticalDerivCalcTool()

AnalyticalDerivCalcTool::~AnalyticalDerivCalcTool ( )

virtualdefault

Member Function Documentation

◆ checkResidualType()

void AnalyticalDerivCalcTool::checkResidualType ( const AlignTrack * alignTrack )

private

Definition at line 842 of file AnalyticalDerivCalcTool.cxx.

   {
     // get first AlignTSOS of the AlignTrack
     // this assumes that for unbiased or DCA residuals the scatterers
     // and energy deposits are not included in the AlignTSOSSollection
     const AlignTSOS * atsos = *(alignTrack->firstAtsos());
  
     // get residual type of the first residual
     m_residualType = atsos->firstResidual()->residualType();
     ATH_MSG_DEBUG("setting residualType to "<<m_residualType);
  
     m_residualTypeSet = true;
   }

◆ checkValidity()

bool AnalyticalDerivCalcTool::checkValidity ( const Amg::MatrixX & R ) const

private

Definition at line 537 of file AnalyticalDerivCalcTool.cxx.

   {
     // perform some sort of sanity check. depending on how many hits
     // on the track we use, R can have zero determinant, but it
     // should definitely not be negative. for now, we'll just check
     // that all diagonal elements are positive and that all correlation
     // coefficients are within bounds
  
     bool Risvalid(true);
     const double epsilon=1e-10;
     for( int irow=0; irow<R.rows(); ++irow) {
  
       Risvalid = Risvalid && R(irow,irow)>0;
       if ( msgLvl(MSG::DEBUG) ) {
         if( !(R(irow,irow)>0) )
           msg(MSG::DEBUG) << "matrix invalid: (" << irow << "," << irow<<") = " << R(irow,irow) << endmsg;
       }
       else if (!Risvalid)
         break;
  
       for(int icol=0; icol<=irow; ++icol) {
         // this one must be true if everything else succeeded
         double Rcorr = R(irow,icol)/sqrt(R(irow,irow)*R(icol,icol));
         if( Rcorr+epsilon<-1 || Rcorr-epsilon>1 )
         {
           Risvalid = false;
           if (msgLvl(MSG::DEBUG))
             ATH_MSG_DEBUG("matrix corr invalid for (" << irow << "," << icol << ") Rcorr = " << Rcorr);
           else
             break;
         }
       }
     }
  
     if( !Risvalid ) {
       ATH_MSG_WARNING("Checked matrix is invalid.");
       ATH_MSG_WARNING("R: \n"<<R);
     }
     return Risvalid;
   }

◆ 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

◆ finalize()

StatusCode AnalyticalDerivCalcTool::finalize ( )

Definition at line 85 of file AnalyticalDerivCalcTool.cxx.

   {
     ATH_MSG_DEBUG("in AnalyticalDerivCalcTool::finalize()");
     return StatusCode::SUCCESS;
   }

◆ getDerivatives()

std::vector< Amg::VectorX > AnalyticalDerivCalcTool::getDerivatives	(	AlignTrack *	alignTrack,
		const AlignModule *	module
	)

private

for L16 in local stave frame Bowing Parameterised by a 2nd order polynomial
const double localy = refPos.y(); stave length in the IBL – we will see if there a more generic way of doing this const double y0y0 = 366.5*366.5; refPos.y() should be the y position along in the AlignModule Frame projR[AlignModule::BowX] = Rxx * ( localy*localy - y0y0 ) / y0y0; projR[AlignModule::BowX] = -Rxx * ( localy*localy ) / y0y0; // change the bowing base

for L11 in global frame Bowing Parameterised by a 2nd order polynomial
const double localz = refPos.z();
stave length in the IBL – we will see if there a more generic way of doing this
const double z0z0 = 366.5*366.5;
refPos.z() should be the z position along in the AlignModule Frame projR[AlignModule::BowX] = -projR[AlignModule::RotZ] / refPos.perp() * ( localz*localz - z0z0 ) / z0z0;

try a generic formula:

Definition at line 579 of file AnalyticalDerivCalcTool.cxx.

   {
     // module-specific transforms
     Amg::Transform3D globalFrameToAlignFrame = module->globalFrameToAlignFrame();
     ATH_MSG_DEBUG("globalFrameToAlignFrame: ");
     ATH_MSG_DEBUG(globalFrameToAlignFrame(0,0)<<" "<<
                   globalFrameToAlignFrame(0,1)<<" "<<
                   globalFrameToAlignFrame(0,2));
     ATH_MSG_DEBUG(globalFrameToAlignFrame(1,0)<<" "<<
                   globalFrameToAlignFrame(1,1)<<" "<<
                   globalFrameToAlignFrame(1,2));
     ATH_MSG_DEBUG(globalFrameToAlignFrame(2,0)<<" "<<
                   globalFrameToAlignFrame(2,1)<<" "<<
                   globalFrameToAlignFrame(2,2));
  
     Amg::RotationMatrix3D globalToAlignFrameRotation = module->globalToAlignFrameRotation();
     ATH_MSG_DEBUG("globalToAlignFrameRotation: ");
     ATH_MSG_DEBUG(globalToAlignFrameRotation(0,0)<<" "<<
                   globalToAlignFrameRotation(0,1)<<" "<<
                   globalToAlignFrameRotation(0,2));
     ATH_MSG_DEBUG(globalToAlignFrameRotation(1,0)<<" "<<
                   globalToAlignFrameRotation(1,1)<<" "<<
                   globalToAlignFrameRotation(1,2));
     ATH_MSG_DEBUG(globalToAlignFrameRotation(2,0)<<" "<<
                   globalToAlignFrameRotation(2,1)<<" "<<
                   globalToAlignFrameRotation(2,2));
  
     DataVector<AlignPar> * alignPars = m_alignModuleTool->getAlignPars(module);
     const int nAlignPar = alignPars->size();
  
     //Create derivatives storage vector and initialise them ro zero     
     std::vector<Amg::VectorX> derivatives( nAlignPar+3 , Amg::VectorX(alignTrack->nAlignTSOSMeas()));
     for(int i(0); i<nAlignPar+3; ++i) derivatives[i].setZero();
  
     int imeas(0);
     AlignTSOSCollection::iterator iatsos = alignTrack->firstAtsos();
     for (; iatsos != alignTrack->lastAtsos(); ++iatsos) {
       
       AlignTSOS * alignTSOS = *iatsos;
       if (!alignTSOS->isValid() || nullptr==alignTSOS->module()) 
         continue;
  
       // we only calculate the derivatives if the AlignTSOS belongs to the align module
       int nResDim = alignTSOS->nResDim();
       if (alignTSOS->module() != module) {
         imeas += nResDim;
         continue;
       }
  
       // derivatives to be stored on the AlignTSOS
       std::vector<Amg::VectorX> * atsosDerivs = nullptr;
       std::vector<Amg::VectorX> * atsosDerVtx = nullptr;
       if (m_storeDerivatives) {
         atsosDerivs = new std::vector<Amg::VectorX>(nResDim,Amg::VectorX(nAlignPar));
         atsosDerVtx = new std::vector<Amg::VectorX>(nResDim,Amg::VectorX(3));
         ATH_MSG_DEBUG("nResDim = "<<nResDim<<"       vector size is    "<<atsosDerivs->size());
         ATH_MSG_DEBUG("nAlignPar = "<<nAlignPar<<"   CLHEP::HepVector size is "<<atsosDerivs->at(0).rows());
       }
  
       // Get the rotation to the frame in which the residual is
       // defined. In this frame the trkdistance is the x-coordinate.    
       
       const TrackParameters * mtp  = alignTSOS->trackParameters();
       if (!mtp || !(mtp->covariance()) ) continue;
       Amg::RotationMatrix3D localToGlobalRotation =    mtp->measurementFrame();
        
  
       ATH_MSG_DEBUG( "localToGlobalRotation:");
       ATH_MSG_DEBUG(localToGlobalRotation(0,0) << " " <<
                     localToGlobalRotation(0,1) << " " <<
                     localToGlobalRotation(0,2));
       ATH_MSG_DEBUG(localToGlobalRotation(1,0) << " " <<
                     localToGlobalRotation(1,1) << " " <<
                     localToGlobalRotation(1,2));
       ATH_MSG_DEBUG(localToGlobalRotation(2,0) << " " <<
                     localToGlobalRotation(2,1) << " " <<
                     localToGlobalRotation(2,2));
  
       if(double alphastrip=alignTSOS->alphaStrip()) {
         ATH_MSG_DEBUG( "applying fanout rotation : " << alphastrip );
         localToGlobalRotation = localToGlobalRotation * Amg::AngleAxis3D(alphastrip, Amg::Vector3D(0.,0.,1.));
         ATH_MSG_DEBUG( "localToGlobalRotation * fanout_rotation:");
         ATH_MSG_DEBUG(localToGlobalRotation(0,0) << " " <<
                       localToGlobalRotation(0,1) << " " <<
                       localToGlobalRotation(0,2));
         ATH_MSG_DEBUG(localToGlobalRotation(1,0) << " " <<
                       localToGlobalRotation(1,1) << " " <<
                       localToGlobalRotation(1,2));
         ATH_MSG_DEBUG(localToGlobalRotation(2,0) << " " <<
                       localToGlobalRotation(2,1) << " " <<
                       localToGlobalRotation(2,2));
       }
  
       // get the position of the track in the alignmentframe.
       Amg::Vector3D refPos = globalFrameToAlignFrame * alignTSOS->trackParameters()->position();
       ATH_MSG_DEBUG("refPos: "<<refPos);
  
           
       const Amg::RotationMatrix3D R = globalToAlignFrameRotation * localToGlobalRotation;
       ATH_MSG_DEBUG("R:");
       ATH_MSG_DEBUG(R(0,0) << " " << R(0,1) << " " << R(0,2));
       ATH_MSG_DEBUG(R(1,0) << " " << R(1,1) << " " << R(1,2));
       ATH_MSG_DEBUG(R(2,0) << " " << R(2,1) << " " << R(2,2));
  
       // In the SCT measurement frame:
       // x --> perpendicular to strips in wafer plane
       // y --> along strips in wafer plane
       // z --> perpendicular to wafer plane
  
       // In the TRT measurement frame:
       // x --> perpendicular to track and straw
       // y --> along straw wire
       // z --> perpendicular to x and y (but not parallel to track!)
  
       // now 'correct' for the track angle in the measurement frame.
       const TrackParameters * trkpars = nullptr;
       if(m_residualType == HitOnly) {
         ATH_MSG_DEBUG("using BIASED track parameters");
         trkpars = alignTSOS->trackParameters();
       }
       else {
         ATH_MSG_DEBUG("using UNBIASED track parameters");
         trkpars = alignTSOS->unbiasedTrackPars();
       }
       
       
       Amg::Vector3D trackdir = localToGlobalRotation.inverse()  *  trkpars->momentum();
       ATH_MSG_DEBUG( "trackdir " << trackdir[0] << " " << trackdir[1] << " " << trackdir[2]);
  
       // for 1-dimensional measurements and Pixel-x
       ATH_MSG_DEBUG( "trackdir.z(): " << trackdir.z() );
       double cotphi_x = trackdir.x() / trackdir.z();
  
       // some 1D measurements are in Y direction (e.g. in CSC)
       // so we need the other angle
       if (alignTSOS->measDir() == Trk::y) 
         cotphi_x = trackdir.y() / trackdir.z();
       
  
       double Rxx = R(0,0) - cotphi_x * R(0,2);
       double Ryx = R(1,0) - cotphi_x * R(1,2);
       double Rzx = R(2,0) - cotphi_x * R(2,2);
       ATH_MSG_DEBUG("Rxx/Ryx/Rzx: " << Rxx << "/" << Ryx << "/" << Rzx);
  
       double projR[AlignModule::NTransformPar];
       projR[AlignModule::TransX] = Rxx;
       projR[AlignModule::TransY] = Ryx;
       projR[AlignModule::TransZ] = Rzx;
       projR[AlignModule::RotX] = -Ryx * refPos.z() + Rzx * refPos.y();
       projR[AlignModule::RotY] = -Rzx * refPos.x() + Rxx * refPos.z();
       projR[AlignModule::RotZ] = -Rxx * refPos.y() + Ryx * refPos.x();
       projR[AlignModule::BowX]  = 0;  
       projR[AlignModule::BowY]  = 0;    
       projR[AlignModule::BowZ]  = 0;
  
       const double localz = alignTSOS->trackParameters()->position().z(); // - globalToAlignFrameTranslation().z();  // the last term to be doublechecked!
       // stave length in the IBL -- we will see if there is a more generic way of doing this
       const double  z0z0  = 366.5*366.5;
  
       projR[AlignModule::BowX] = ( localz*localz - z0z0) / z0z0;    // this formula should work for both L11 ans L16, sign to be checked!
  
  
       // prepare derivatives w.r.t. the vertex position:
       Amg::Vector3D RxLoc(Rxx, Ryx, Rzx);
       Amg::Vector3D RxGlob=-1.0 * (globalToAlignFrameRotation.inverse() * RxLoc);        // to be double checked!!!
    
       for (int ipar=0; ipar<nAlignPar; ipar++) {
         const AlignPar * alignPar = (*alignPars)[ipar];
         int paramType = alignPar->paramType();
         //double sigma  = alignPar->sigma();
         ATH_MSG_DEBUG("ipar="<<ipar<<", paramType="<<paramType);
         derivatives[ipar][imeas] = projR[paramType];//*sigma;
         if (m_storeDerivatives)
           (*atsosDerivs)[0][ipar] = projR[paramType];//*sigma;
       }
       // the dr/db bit:
       for (int ipar=0; ipar<3; ipar++) {
         derivatives[nAlignPar+ipar][imeas] = RxGlob[ipar];
         if (m_storeDerivatives)   (*atsosDerVtx)[0][ipar] = RxGlob[ipar];
       }
  
       for (int i=0;i<nAlignPar+3;i++)
         ATH_MSG_DEBUG("derivatives["<<i<<"]["<<imeas<<"]="<<derivatives[i][imeas]);
  
       imeas++;
  
       if (nResDim>1) {
         // for Pixel the second measurement has to be corrected
         // for the second angle
         double cotphi_y = trackdir.y() / trackdir.z() ;
         double Rxy = R(0,1) - cotphi_y * R(0,2) ;
         double Ryy = R(1,1) - cotphi_y * R(1,2) ;
         double Rzy = R(2,1) - cotphi_y * R(2,2) ;
         ATH_MSG_DEBUG("Rxy/Ryy/Rzy: " << Rxy << "/" << Ryy << "/" << Rzy);
  
         projR[AlignModule::TransX] = Rxy;
         projR[AlignModule::TransY] = Ryy;
         projR[AlignModule::TransZ] = Rzy;
         projR[AlignModule::RotX] = -Ryy * refPos.z() + Rzy * refPos.y();
         projR[AlignModule::RotY] = -Rzy * refPos.x() + Rxy * refPos.z();
         projR[AlignModule::RotZ] = -Rxy * refPos.y() + Ryy * refPos.x();
  
         //Possibly could add the bowing correction  --  very weakly coupled to y residuals 
         projR[AlignModule::BowX]  = 0;  
         projR[AlignModule::BowY]  = 0; 
         projR[AlignModule::BowZ]  = 0;
  
  
         // prepare derivatives w.r.t. the vertex position:
         Amg::Vector3D RyLoc(Rxy, Ryy, Rzy);
         Amg::Vector3D RyGlob=-1.0 * (globalToAlignFrameRotation.inverse() * RyLoc);        // to be double checked!!!
  
         for (int ipar=0; ipar<nAlignPar; ipar++) {
           const AlignPar * alignPar = (*alignPars)[ipar];
           int paramType = alignPar->paramType();
           ATH_MSG_DEBUG("2nd dim, ipar="<<ipar<<", paramType="<<paramType);
           //double sigma=alignPar->sigma();
           derivatives[ipar][imeas] = projR[paramType];//*sigma;
           if (m_storeDerivatives)
             (*atsosDerivs)[1][ipar] = projR[paramType];//*sigma;
         }
         
         // the dr/db bit:
         for (int ipar=0; ipar<3; ipar++) {
           derivatives[nAlignPar+ipar][imeas] = RyGlob[ipar];
           if (m_storeDerivatives)   (*atsosDerVtx)[1][ipar] = RyGlob[ipar];
         }
  
         for (int i=0;i<nAlignPar+3;i++)
           ATH_MSG_DEBUG("2nd dim: derivatives["<<i<<"]["<<imeas<<"]="<<derivatives[i][imeas]);
  
         imeas++;
       }
  
       alignTSOS->setDerivatives(atsosDerivs);
       alignTSOS->setDerivativesVtx(atsosDerVtx);
     }
     ATH_MSG_DEBUG("returning derivatives");
     return derivatives;
   }

◆ getMeasErrorMatrix()

bool AnalyticalDerivCalcTool::getMeasErrorMatrix	(	const AlignTrack *	alignTrack,
		Amg::MatrixX &	V
	)		const

private

Definition at line 521 of file AnalyticalDerivCalcTool.cxx.

   {
     int index(0);
     AlignTSOSCollection::const_iterator itAtsos=alignTrack->firstAtsos();
     for (; itAtsos != alignTrack->lastAtsos(); ++itAtsos) {      
  
       std::vector<Residual>::const_iterator itRes=(**itAtsos).firstResidual();
       for (; itRes!=(**itAtsos).lastResidual(); ++itRes,index++) {
         
         V(index,index) = itRes->errSq();
       }
     }
     return checkValidity(V);
   }

◆ getTrkParamCovMatrix()

bool AnalyticalDerivCalcTool::getTrkParamCovMatrix	(	const AlignTrack *	alignTrack,
		Amg::MatrixX &	HCH
	)		const

private

Definition at line 291 of file AnalyticalDerivCalcTool.cxx.

   {
        
     // get derivative matrices from fitter
     const Amg::MatrixX * H0 = alignTrack->derivativeMatrix(); 
     const Amg::MatrixX * C  = alignTrack->fullCovarianceMatrix(); //symmetric matrix
  
     // H0 is a q0 x p matrix, 
     // C is a p x p matrix,
     // q0 = number of tsos measurements
     // p = number perigee params+2*nscat+nbrem
  
     if( H0==nullptr || C==nullptr) {
       ATH_MSG_ERROR("no derivative matrix or cov matrix stored on AlignTrack!"
                     << "This should have been done in AlignTrackPreProcessor!"
                     << H0 << " " << C );
       return false;
     }
  
     ATH_MSG_DEBUG("H0 ( "<<H0->rows()<<" x "<<H0->cols()<<" )");
     ATH_MSG_DEBUG("H0: "<<(*H0));
     ATH_MSG_DEBUG("C ( "<<C->rows()<<" x "<<C->cols()<<" )");
     ATH_MSG_DEBUG("C: "<<(*C));
  
  
     int    Csize(C->rows());
     Amg::MatrixX CC(*C);         // take a copy of C //symmetric matrix
     int    ierr(0);
     bool   amendC( !(alignTrack->refitD0() && alignTrack->refitZ0() &&
                      alignTrack->refitPhi() && alignTrack->refitTheta() &&
                      alignTrack->refitQovP()) );
  
     // amendC = true;       // FUDGE!
  
     if( amendC ) {
       // test with AlSymMat:
       // build AlSymMat instance from 
       AlSymMat*     CA = new AlSymMat(Csize);
  
       // take a copy of C:
       for( int ii=0; ii<Csize; ++ii ) {
         for( int jj=ii; jj<Csize; ++jj ) {
           CA->elemr(ii,jj) = (*C)(ii,jj);
         }
       }
  
       // first inversion:
       ierr = CA->invert();
       if( ierr ) {
         ATH_MSG_ERROR("First inversion of matrix CA failed with LAPACK status flag " << ierr);
         return false;
       } else {
         // disable selected track parametrs (remove from refit).
         // It is your duty to assure that corresponding constraints have been imposed!
         if( !(alignTrack->refitD0()) )    {
           for(int ii=0; ii<(Csize); ++ii) CA->elemr(0,ii)=0.0;   // should do the trick. It is a CLHEP::HepSymMatrix! 
           CA->elemr(0,0)=1.0;
         }
         if( !(alignTrack->refitZ0()) )    {
           for(int ii=0; ii<(Csize); ++ii) CA->elemr(1,ii)=0.0;   // should do the trick. It is a CLHEP::HepSymMatrix! 
           CA->elemr(1,1)=1.0;
         }
         if( !(alignTrack->refitPhi()) )   {
           for(int ii=0; ii<(Csize); ++ii) CA->elemr(2,ii)=0.0;   // should do the trick. It is a CLHEP::HepSymMatrix! 
           CA->elemr(2,2)=1.0;
         }
         if( !(alignTrack->refitTheta()) ) {
           for(int ii=0; ii<(Csize); ++ii) CA->elemr(3,ii)=0.0;   // should do the trick. It is a CLHEP::HepSymMatrix!
           CA->elemr(3,3)=1.0;
         } 
         if( !(alignTrack->refitQovP()) )  {
           for(int ii=0; ii<(Csize); ++ii) CA->elemr(4,ii)=0.0;   // should do the trick. It is a CLHEP::HepSymMatrix! 
           CA->elemr(4,4)=1.0;
         }
  
  
   // invert back:
         ierr = CA->invert();
         if( ierr ) {
           ATH_MSG_ERROR("Second inversion of matrix CA failed with LAPACK status flag " << ierr);
           return false;
         }
  
         // copy back to CC:
         for( int ii=0; ii<Csize; ++ii ) {
           for( int jj=ii; jj<Csize; ++jj ) {
             CC(ii,jj) = CA->elemc(ii,jj);
           }
         }
  
         // clear the disabled rows/collumns
         if( !(alignTrack->refitD0()) )    for(int ii=0; ii<(Csize); ++ii){ CC(0,ii)=0.0; CC(ii,0)=0.0;  };   // should do the trick. 
         if( !(alignTrack->refitZ0()) )    for(int ii=0; ii<(Csize); ++ii){ CC(1,ii)=0.0; CC(ii,1)=0.0;  };   // should do the trick. 
         if( !(alignTrack->refitPhi()) )   for(int ii=0; ii<(Csize); ++ii){ CC(2,ii)=0.0; CC(ii,2)=0.0;  };   // should do the trick.  
         if( !(alignTrack->refitTheta()) ) for(int ii=0; ii<(Csize); ++ii){ CC(3,ii)=0.0; CC(ii,3)=0.0;  };   // should do the trick. 
         if( !(alignTrack->refitQovP()) )  for(int ii=0; ii<(Csize); ++ii){ CC(4,ii)=0.0; CC(ii,4)=0.0;  };   // should do the trick.  
  
  
       }
  
       //garbage collection:
       delete CA;
     }
  
  
  
     int nMeas  = H0->rows();
     int nAtsos = alignTrack->nAlignTSOSMeas();
     ATH_MSG_DEBUG("nMeas: "<<nMeas);
  
     //CLHEP::HepSymMatrix HCH(nMeas,0);
     Amg::MatrixX HCH(nAtsos,nAtsos);
     HCH = CC.similarity( *H0 );
  
     ATH_MSG_DEBUG("HCH ( "<<HCH.rows()<<" x "<<HCH.cols()<<" )");
     ATH_MSG_DEBUG("HCH: "<<HCH);
  
     //
     // get indices of HCH matrix corresponding to alignTSOSs in alignTrack
     const AlignTSOSCollection * alignTSOSCollection = alignTrack->alignTSOSCollection();
  
     std::vector<int> matrixIndices(nMeas);
  
     int imeas(-1);
     for (const TrackStateOnSurface* tsos : *alignTrack->trackStateOnSurfaces()){
  
       ATH_MSG_DEBUG("tsos:  "<<tsos->dumpType());
  
       // get tsos and make sure it is a RIO_OnTrack
       if (tsos->type(TrackStateOnSurface::Outlier))
         continue;
  
       // RIO
       if (!tsos->type(TrackStateOnSurface::Scatterer)) {
         ATH_MSG_DEBUG("not scatterer, trying rio");
  
         const MeasurementBase      * mesb = tsos->measurementOnTrack();
         const RIO_OnTrack          * rio  = dynamic_cast<const RIO_OnTrack *>(mesb);
         const CompetingRIOsOnTrack * crio = dynamic_cast<const CompetingRIOsOnTrack *>(mesb);
         if (!rio && crio)
           rio=&crio->rioOnTrack(0);
  
         if (rio==nullptr)
           continue;
  
         ++imeas;
         matrixIndices[imeas]=-1;
  
         Identifier tsosId = rio->identify();
         ATH_MSG_DEBUG("have tsos with Id "<<tsosId);
  
         // get matching alignTSOS and store track index in goodMatrixIndices      
         int iameas(0);
         for (const AlignTSOS* atsos : *alignTSOSCollection) {
  
           if (!atsos->isValid())
             continue;
  
           if (atsos->type(TrackStateOnSurface::Scatterer))
             ATH_MSG_ERROR("can't use scatterers on AlignTrack yet for analytical derivatives!");
  
           const RIO_OnTrack * atsos_rio = atsos->rio();
           if (atsos_rio) {
 //            ATH_MSG_DEBUG("tsosId / atsosId  :  "<<tsosId<<" / "<<atsos_rio->identify());
  
             if (atsos_rio->identify()==tsosId) {
               matrixIndices[imeas]=iameas;
               ATH_MSG_DEBUG("matrixIndices["<<imeas<<"]="<<iameas);
  
               // for Pixel we have two measurements
               if (atsos->nResDim()>1)
               {
                 imeas++;
                 iameas++;
                 matrixIndices[imeas]=iameas;
                 ATH_MSG_DEBUG("matrixIndices["<<imeas<<"]="<<iameas);
               }
               break;
             }
             // for Pixel we have two measurements
             else if(atsos->nResDim()>1)
               iameas++;
           }
           iameas++;
         }
  
         // even when the Pixel is not aligned we have to take into account
         // that it has two measurements
         if(matrixIndices[imeas]==-1 && m_measTypeIdHelper->defineType(mesb) == TrackState::Pixel) {
           imeas++;
           matrixIndices[imeas]=-1;
           ATH_MSG_DEBUG("matrixIndices["<<imeas<<"]="<<matrixIndices[imeas]);
         }
  
       } // end tsos==rio
  
     } // end loop over track tsos
  
     // strip elements in the HCH matrix which don't correspond
     // to AlignTSOS on alignTrack
     ATH_MSG_DEBUG("Filling the Q matrix:");
     for (int k=0;k<nMeas;k++) {
  
       int iameas=matrixIndices[k];
       if (iameas==-1)
         continue;
  
       for (int l=0;l<nMeas;l++) {
         int jameas=matrixIndices[l];
         if (jameas==-1)
           continue;
  
         Q(iameas,jameas) = HCH(k,l);
  
       }
     }
  
     ATH_MSG_DEBUG("before check Q ( "<<Q.rows()<<" x "<<Q.cols()<<" )");
     ATH_MSG_DEBUG("before check Q: "<<Q);
  
     if(!checkValidity(Q)) {
       ATH_MSG_DEBUG("Matrix Q = HCH is invalid, skipping the track");
       return false;
     }
  
     return true;
   }

◆ initialize()

StatusCode AnalyticalDerivCalcTool::initialize ( )

Definition at line 67 of file AnalyticalDerivCalcTool.cxx.

   {
     if (m_alignModuleTool.retrieve().isFailure()) {
       msg(MSG::FATAL) << "Could not get " << m_alignModuleTool << endmsg;
       return StatusCode::FAILURE;
     }
     ATH_MSG_INFO("Retrieved " << m_alignModuleTool);
  
     if (detStore()->retrieve(m_idHelper, "AtlasID").isFailure()) {
       msg(MSG::FATAL) << "Could not get AtlasDetectorID helper" << endmsg;
       return StatusCode::FAILURE;
     }
     m_measTypeIdHelper = new MeasurementTypeID(m_idHelper);
  
     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 & IDerivCalcTool::interfaceID ( )

inlinestaticinherited

Retrieve interface ID.

Definition at line 84 of file IDerivCalcTool.h.

                                                         {
     return IID_TRKALIGNINTERFACES_IDerivCalcTool;
   }

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

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

◆ setDerivatives()

bool AnalyticalDerivCalcTool::setDerivatives ( AlignTrack * alignTrack )

virtual

sets analytical partial derivatives of residuals w.r.t alignment parameters for TSOS on alignTrack.

Implements Trk::IDerivCalcTool.

Definition at line 92 of file AnalyticalDerivCalcTool.cxx.

   {
     if(!m_residualTypeSet)
       checkResidualType(alignTrack);
  
     // create table of modules for checking whether the module
     // is hit by the track or not
     int nModules = m_alignModuleTool->alignModules1D()->size();
     std::vector<bool> hitModules(nModules,false);
  
     // loop over AlignTSOSCollection, 
     // find modules that are in the AlignModuleList,
     std::vector<AlignModule *> alignModules;
     AlignTSOSCollection::iterator atsosItr = alignTrack->firstAtsos();
     for (; atsosItr != alignTrack->lastAtsos(); ++atsosItr) {      
       AlignModule * module=(*atsosItr)->module();
       if (module)
         ATH_MSG_DEBUG("have ATSOS for module "<<module->identify());
       else
         ATH_MSG_DEBUG("no module!");
  
       if (!(*atsosItr)->isValid() || !module)
         continue;
  
       // if the module is not yet in the list for this track, add it
       if(!hitModules[module->identifyHash()]) {
         hitModules[module->identifyHash()] = true;
         alignModules.push_back(module);
       }
     }
  
     // Determine derivatives from shifting these modules
     std::vector<AlignModuleDerivatives> * derivatives = new std::vector<AlignModuleDerivatives>;
     std::vector<AlignModule *>::iterator moduleIt = alignModules.begin();
     for ( ; moduleIt!=alignModules.end(); ++moduleIt) {
       std::vector<Amg::VectorX> deriv_vec = getDerivatives(alignTrack,*moduleIt);
       derivatives->push_back(make_pair(*moduleIt,deriv_vec));
     }
  
     // alignTrack takes care of deleting the derivatives
     ATH_MSG_DEBUG("setting matrix derivatives");
     alignTrack->setDerivatives(derivatives);
  
     ATH_MSG_DEBUG("returning from setDerivatives");
  
     return true;
   }

◆ setLogStream()

virtual void Trk::IDerivCalcTool::setLogStream ( std::ostream * os )

inlinevirtualinherited

sets the output stream for the logfile

Definition at line 71 of file IDerivCalcTool.h.

71 { m_logStream = os; }

◆ setResidualCovMatrix()

bool AnalyticalDerivCalcTool::setResidualCovMatrix ( AlignTrack * alignTrack ) const

virtual

sets residual covariance matrix

Implements Trk::IDerivCalcTool.

Definition at line 141 of file AnalyticalDerivCalcTool.cxx.

   {
     static std::once_flag flag;
     std::call_once(flag, [&]() {
       if(m_logStream) {
         *m_logStream<<"*************************************************************"<<std::endl;
         *m_logStream<<"*************************************************************"<<std::endl;
         *m_logStream<<"***                                                     *****"<<std::endl;
  
         if(m_useLocalSetting)
           *m_logStream<<"***           Running full LOCAL Chi2 method            *****"<<std::endl;
         else
           *m_logStream<<"***           Running full GLOBAL Chi2 method           *****"<<std::endl;
  
         *m_logStream<<"***            using analytical derivatives             *****"<<std::endl;
  
         if(m_useLocalSetting) {
           std::string resType = "HitOnly ";
           if(m_residualType==Unbiased)
             resType = "Unbiased";
           *m_logStream<<"***            with residual type: "<<resType<<"             *****"<<std::endl;
         }
  
         *m_logStream<<"***                                                     *****"<<std::endl;
         *m_logStream<<"*************************************************************"<<std::endl;
       }
     });
  
     // get inverse local error matrix of the track
     const Amg::MatrixX * Vinv = alignTrack->localErrorMatrixInv();
     if(!checkValidity(*Vinv)) {
       ATH_MSG_WARNING("Inverse local error matrix is invalid, skipping the track");
       return false;
     }
     ATH_MSG_DEBUG("V inverse (diagonal only):");
     if (msgLvl(MSG::DEBUG)) {
       for (int i=0;i<Vinv->rows();i++) msg()<<(*Vinv)(i,i)<<" ";
       msg()<<endmsg;
     } 
  
     // ========================
     // setup local chi2 method
     // ========================
     if (m_useLocalSetting) {
       ATH_MSG_DEBUG("setting Residual covariance matrix for local method");
  
       // for local method we only need the Vinv
       const Amg::MatrixX * Vinv = alignTrack->localErrorMatrixInv();
       Amg::MatrixX * W = new Amg::MatrixX(*Vinv);
  
       // if we want to ignore the real errors of measurements for a particular subretector
       // (we should add something similar for Muon detectors)
       if(m_useIntrinsicPixelErrors || m_useIntrinsicSCTErrors || m_useIntrinsicTRTErrors) {
  
         if(m_useIntrinsicPixelErrors)
           ATH_MSG_DEBUG("Ignoring measured errors for Pixel clusters, using intrinsic errors");
         if(m_useIntrinsicSCTErrors)
           ATH_MSG_DEBUG("Ignoring measured errors for SCT clusters, using intrinsic errors");
         if(m_useIntrinsicTRTErrors)
           ATH_MSG_DEBUG("Ignoring measured errors for TRT clusters, using intrinsic errors");
  
         int index(0);
         AlignTSOSCollection::const_iterator itAtsos     = alignTrack->firstAtsos();
         AlignTSOSCollection::const_iterator itAtsos_end = alignTrack->lastAtsos();
         for ( ; itAtsos != itAtsos_end; ++itAtsos) {
           const AlignTSOS * atsos = *itAtsos;
           if (!atsos->isValid())
             continue;
  
           if(m_useIntrinsicPixelErrors && atsos->measType() == Trk::TrackState::Pixel) {
             (*W)(index,index) = 1./(0.05*0.05/12);
             (*W)(index+1,index+1) = 1./(0.4*0.4/12);
           }
           else if(m_useIntrinsicSCTErrors && atsos->measType() == Trk::TrackState::SCT)
             (*W)(index,index) = 1./(0.1*0.1/12);
           else if(m_useIntrinsicTRTErrors && atsos->measType() == Trk::TrackState::TRT)
             (*W)(index,index) = 1./(0.5*0.5/12);
  
           index += atsos->nResDim();
         }
       }
  
       ATH_MSG_DEBUG("setting local weight matrix W ( "<<W->rows()<<" x "<<W->cols()<<" ) (diagonal only):");
       if (msgLvl(MSG::DEBUG)) {
         for (int i=0;i<W->rows();i++) msg()<<(*W)(i,i)<<" ";
         msg()<<endmsg;
       } 
       alignTrack->setWeightMatrix(W);
  
       Amg::MatrixX * W1st = new Amg::MatrixX(*W);
       alignTrack->setWeightMatrixFirstDeriv(W1st);
  
       return true;
     }
  
     // ========================
     // setup global chi2 method
     // ========================
  
     // get the ingredients for calculating R = V - Q    
     const Amg::MatrixX * V = alignTrack->localErrorMatrix();
     ATH_MSG_DEBUG("V ( "<<V->rows()<<" x "<<V->cols()<<" ) (diagonal only):");
     if (msgLvl(MSG::DEBUG)) {
       for (int i=0;i<V->rows();i++) msg()<<(*V)(i,i)<<" ";
       msg()<<endmsg;
     } 
  
     const int outputdim = alignTrack->nAlignTSOSMeas();
  
     Amg::MatrixX Q(outputdim, outputdim); //symmetric matrix
     if (!getTrkParamCovMatrix(alignTrack, Q))
       return false;
     ATH_MSG_DEBUG("Q ( "<<Q.rows()<<" x "<<Q.cols()<<" )");
     ATH_MSG_DEBUG("Q: "<<Q);
  
     // calculate R
     const Amg::MatrixX R = (*V) - Q;
     if (!checkValidity(R)) {
       ATH_MSG_WARNING("Matrix R = V - HCH is invalid, skipping the track");
       return false;
     }
     ATH_MSG_DEBUG("R ( "<<R.rows()<<" x "<<R.cols()<<" )");
     ATH_MSG_DEBUG("R: "<<R);
  
     // calculate weight matrix and set it
     Amg::MatrixX * W = new Amg::MatrixX(outputdim,outputdim); //symmetric matrix
     *W = ((*Vinv) * R * (*Vinv));
     
     if (!checkValidity(*W)) {
       ATH_MSG_DEBUG("Weight matrix is invalid, skipping the track");
       delete W;
       return false;
     }
     ATH_MSG_DEBUG("setting weight: "<<(*W));
     alignTrack->setWeightMatrix(W);
  
     // for 1st derivatives the weight matrix is just the V^-1
     // it has been chacked above so no need to do it again
     Amg::MatrixX * W1st = new Amg::MatrixX(*Vinv); //symmetric matrix
     ATH_MSG_DEBUG("setting weight for 1st derivatives (diagonal only): ");
     if (msgLvl(MSG::DEBUG)) {
       for (int i=0;i<W1st->rows();i++) msg()<<(*W1st)(i,i)<<" ";
       msg()<<endmsg;
     }
     alignTrack->setWeightMatrixFirstDeriv(W1st);
  
     return true;
   }

◆ setSolveOption()

void Trk::IDerivCalcTool::setSolveOption ( int solveOption )

inlineinherited

solving option (see enum above)

Definition at line 57 of file IDerivCalcTool.h.

57 { m_solveOption=solveOption; }

◆ showStatistics()

void Trk::AnalyticalDerivCalcTool::showStatistics ( )

inlinevirtual

not used yet

Implements Trk::IDerivCalcTool.

Definition at line 53 of file AnalyticalDerivCalcTool.h.

53 {}

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

ToolHandle<IAlignModuleTool> Trk::AnalyticalDerivCalcTool::m_alignModuleTool

private

Definition at line 60 of file AnalyticalDerivCalcTool.h.

◆ m_derivatives

std::vector<std::pair<const AlignModule *, std::vector<Amg::VectorX> > > Trk::AnalyticalDerivCalcTool::m_derivatives

private

Definition at line 75 of file AnalyticalDerivCalcTool.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_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_idHelper

const AtlasDetectorID* Trk::AnalyticalDerivCalcTool::m_idHelper

private

Definition at line 62 of file AnalyticalDerivCalcTool.h.

◆ m_logStream

std::ostream* Trk::IDerivCalcTool::m_logStream

protectedinherited

logfile output stream

Definition at line 76 of file IDerivCalcTool.h.

◆ m_measTypeIdHelper

MeasurementTypeID* Trk::AnalyticalDerivCalcTool::m_measTypeIdHelper

private

Definition at line 63 of file AnalyticalDerivCalcTool.h.

◆ m_residualType

int Trk::AnalyticalDerivCalcTool::m_residualType

private

residual type to be used in the calculations

Definition at line 82 of file AnalyticalDerivCalcTool.h.

◆ m_residualTypeSet

bool Trk::AnalyticalDerivCalcTool::m_residualTypeSet

private

do we have the residual type set?

Definition at line 83 of file AnalyticalDerivCalcTool.h.

◆ m_solveOption

int Trk::IDerivCalcTool::m_solveOption = 0

privateinherited

Definition at line 80 of file IDerivCalcTool.h.

◆ m_storeDerivatives

bool Trk::AnalyticalDerivCalcTool::m_storeDerivatives

private

store derivatives on AlignTSOS to be filled into ntuple

Definition at line 85 of file AnalyticalDerivCalcTool.h.

◆ m_useIntrinsicPixelErrors

bool Trk::AnalyticalDerivCalcTool::m_useIntrinsicPixelErrors = false

private

use intrinsic errors for Pixel

Definition at line 78 of file AnalyticalDerivCalcTool.h.

◆ m_useIntrinsicSCTErrors

bool Trk::AnalyticalDerivCalcTool::m_useIntrinsicSCTErrors = false

private

use intrinsic errors for SCT

Definition at line 79 of file AnalyticalDerivCalcTool.h.

◆ m_useIntrinsicTRTErrors

bool Trk::AnalyticalDerivCalcTool::m_useIntrinsicTRTErrors = false

private

use intrinsic errors for TRT

Definition at line 80 of file AnalyticalDerivCalcTool.h.

◆ m_useLocalSetting

bool Trk::AnalyticalDerivCalcTool::m_useLocalSetting

private

use local setup for the covariance matrix of the track

Definition at line 77 of file AnalyticalDerivCalcTool.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.

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

Public Types

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

Member Enumeration Documentation

◆ SolveOption

Constructor & Destructor Documentation

◆ AnalyticalDerivCalcTool()

◆ ~AnalyticalDerivCalcTool()

Member Function Documentation

◆ checkResidualType()

◆ checkValidity()

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

◆ finalize()

◆ getDerivatives()

◆ getMeasErrorMatrix()

◆ getTrkParamCovMatrix()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setDerivatives()

◆ setLogStream()

◆ setResidualCovMatrix()

◆ setSolveOption()

◆ showStatistics()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_alignModuleTool

◆ m_derivatives

◆ m_detStore

◆ m_evtStore

◆ m_idHelper

◆ m_logStream

◆ m_measTypeIdHelper

◆ m_residualType

◆ m_residualTypeSet

◆ m_solveOption

◆ m_storeDerivatives

◆ m_useIntrinsicPixelErrors

◆ m_useIntrinsicSCTErrors

◆ m_useIntrinsicTRTErrors

◆ m_useLocalSetting

◆ m_varHandleArraysDeclared

◆ m_vhka