#include <ShiftingDerivCalcTool.h>

Inheritance diagram for Trk::ShiftingDerivCalcTool:

Collaboration diagram for Trk::ShiftingDerivCalcTool:

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
	ShiftingDerivCalcTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~ShiftingDerivCalcTool ()
StatusCode	initialize ()
StatusCode	finalize ()
bool	setDerivatives (AlignTrack *track)
	sets derivatives of residuals w.r.t.
void	showStatistics ()
	write statistics to log file
bool	setResidualCovMatrix (AlignTrack *alignTrack) const
	sets residual covariance matrix
void	setSolveOption (int solveOption)
	solving option (see enum above)
virtual void	setLogStream (std::ostream *os)
	sets the output stream for the logfile
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

Protected Types
typedef std::vector< Amg::VectorX >	HitDerivative
typedef std::map< const TrackStateOnSurface , HitDerivative >	DerivativeMap
typedef DerivativeMap::value_type	DerivativePair

Protected Member Functions
Amg::VectorX	getDerivatives (AlignTrack alignTrack, int ipar, AlignPar alignPar, Amg::VectorX &derivativeErr, bool &resetIPar, double &actualSecondDerivative)
void	setChi2VAlignParam (const AlignTrack alignTrack, const AlignModule module, int nshifts=0)
void	deleteChi2VAlignParam ()
double	shiftSize (const AlignPar *alignPar) const
bool	setUnshiftedResiduals (AlignTrack *alignTrack)
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 = nullptr
	logfile output stream

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
const Trk::Track *	bestPerigeeTrack (const Track *track) const
bool	scanShifts (const AlignTrack alignTrack, const std::vector< AlignModule > &alignModules)
bool	getAllDerivatives (AlignTrack alignTrack, const AlignModule alignModule, std::vector< Amg::VectorX > &deriv_vec, std::vector< Amg::VectorX > &derivErr_vec, std::vector< double > &actualsecderiv_vec, bool &resetIPar)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ToolHandle< IGlobalTrackFitter >	m_trackFitterTool {this, "TrackFitterTool", "Trk::GlobalChi2Fitter/MCTBFitter"}
ToolHandle< IGlobalTrackFitter >	m_SLTrackFitterTool {this, "SLTrackFitterTool", "Trk::GlobalChi2Fitter/MCTBSLFitter"}
ToolHandle< IGlobalTrackFitter >	m_fitter
ToolHandle< IAlignResidualCalculator >	m_residualCalculator {this, "ResidualCalculator", "Trk::AlignResidualCalculator/ResidualCalculator"}
ToolHandle< IAlignModuleTool >	m_alignModuleTool {this, "AlignModuleTool", "Trk::AlignModuleTool/AlignModuleTool"}
Gaudi::Property< double >	m_traSize {this, "TranslationSize", .1}
Gaudi::Property< double >	m_rotSize {this, "RotationSize", .1}
Gaudi::Property< bool >	m_runOutlierRemoval {this, "RunOutlierRemoval", false}
ParticleHypothesis	m_particleHypothesis = Trk::muon
Gaudi::Property< int >	m_particleNumber {this, "ParticleNumber", 2}
DerivativeMap	m_derivative_map
Gaudi::Property< bool >	m_doFits {this, "doResidualFits", true}
Gaudi::Property< int >	m_nFits {this, "NumberOfShifts", 5}
Gaudi::Property< bool >	m_doChi2VAlignParamMeasType {this, "doChi2VChamberShiftsMeasType", false}
Gaudi::Property< bool >	m_doResidualPlots {this, "doResidualPlots", false}
int	m_nIterations = 0
Amg::VectorX *	m_unshiftedResiduals = nullptr
Amg::VectorX *	m_unshiftedResErrors = nullptr
std::vector< double ** >	m_chi2VAlignParamVec
	track chi2[idof][ichambershift]
std::vector< double ** >	m_chi2VAlignParamXVec
	chamber shift[idof][ichambershift]
double **	m_tmpChi2VAlignParam = nullptr
double **	m_tmpChi2VAlignParamX = nullptr
double ***	m_tmpChi2VAlignParamMeasType = nullptr
std::vector< double *** >	m_chi2VAlignParamVecMeasType
	track chi2[idof][imeastype][ichambershift]
double	m_unshiftedTrackChi2 {}
std::unique_ptr< double[]>	m_unshiftedTrackChi2MeasType
	cut on value of track alignment parameter, determined from fit of chi2 vs.
Gaudi::Property< double >	m_trackAlignParamCut {this, "TrackAlignParamCut", 1e6}
	fit track with AlignModules shifted up and down in each extreme, find the number of iterations fitter uses to converge.
Gaudi::Property< bool >	m_setMinIterations {this, "SetMinIterations", false}
	reject track if exceed maximum number of iterations
Gaudi::Property< int >	m_maxIter {this, "MaxIterations", 50}
	set minimum number of iterations for first track fits
Gaudi::Property< int >	m_minIter {this, "MinIterations", 10}
	flag to remove scattering before refitting track
Gaudi::Property< bool >	m_removeScatteringBeforeRefit {this, "RemoveScatteringBeforeRefit", false}
int	m_ntracksProcessed = 0
	number tracks processed
int	m_ntracksPassInitScan = 0
	number tracks pass initial scan
int	m_ntracksPassSetUnshiftedRes = 0
	number tracks pass setting unshifted residuals
int	m_ntracksPassDerivatives = 0
	number tracks pass setting derivatives
int	m_ntracksPassGetDeriv = 0
	number tracks pass getting derivatives
int	m_ntracksPassGetDerivSecPass = 0
	number tracks pass 2nd pass of getting derivatives
int	m_ntracksPassGetDerivLastPass = 0
	number tracks pass 2nd pass of getting derivatives
int	m_ntracksFailMaxIter = 0
int	m_ntracksFailTrackRefit = 0
int	m_ntracksFailAlignParamCut = 0
int	m_ntracksFailFinalAttempt = 0
bool	m_secPass {}
int	m_solveOption = 0
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 46 of file ShiftingDerivCalcTool.h.

Member Typedef Documentation

◆ DerivativeMap

typedef std::map<const TrackStateOnSurface*,HitDerivative*> Trk::ShiftingDerivCalcTool::DerivativeMap

protected

Definition at line 68 of file ShiftingDerivCalcTool.h.

◆ DerivativePair

typedef DerivativeMap::value_type Trk::ShiftingDerivCalcTool::DerivativePair

protected

Definition at line 69 of file ShiftingDerivCalcTool.h.

◆ HitDerivative

typedef std::vector<Amg::VectorX> Trk::ShiftingDerivCalcTool::HitDerivative

protected

Definition at line 67 of file ShiftingDerivCalcTool.h.

◆ 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

◆ ShiftingDerivCalcTool()

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

Definition at line 35 of file ShiftingDerivCalcTool.cxx.

    : AthAlgTool(type,name,parent)
    , m_unshiftedTrackChi2MeasType(std::make_unique<double[]>(TrackState::NumberOfMeasurementTypes))
  {
    declareInterface<IDerivCalcTool>(this);
 
    m_logStream = nullptr;
  }

◆ ~ShiftingDerivCalcTool()

ShiftingDerivCalcTool::~ShiftingDerivCalcTool ( )

virtual

Definition at line 48 of file ShiftingDerivCalcTool.cxx.

  {
    deleteChi2VAlignParam();
  }

Member Function Documentation

◆ bestPerigeeTrack()

const Trk::Track * Trk::ShiftingDerivCalcTool::bestPerigeeTrack ( const Track * track ) const

private

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

◆ deleteChi2VAlignParam()

void ShiftingDerivCalcTool::deleteChi2VAlignParam ( )

protected

Definition at line 859 of file ShiftingDerivCalcTool.cxx.

{
  for (int i=0;i<(int)m_chi2VAlignParamVec.size();i++) {
    delete [] m_chi2VAlignParamVec[i];  m_chi2VAlignParamVec[i]=nullptr;
    delete [] m_chi2VAlignParamXVec[i]; m_chi2VAlignParamXVec[i]=nullptr;
  }
  m_chi2VAlignParamVec.clear();
  m_chi2VAlignParamXVec.clear();
 
  for (auto & i : m_chi2VAlignParamVecMeasType) {
    delete [] i;  i=nullptr;
  }
  m_chi2VAlignParamVecMeasType.clear();
}

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 ShiftingDerivCalcTool::finalize ( )

Definition at line 82 of file ShiftingDerivCalcTool.cxx.

  {
    ATH_MSG_INFO("number tracks processed:                           "<<m_ntracksProcessed<<
     "\nnumber tracks passing initial scan:                "<<m_ntracksPassInitScan<<
     "\nnumber tracks passing setting unshifted residuals: "<< m_ntracksPassSetUnshiftedRes<<
     "\nnumber tracks pass getting derivatives (1st pass): "<<m_ntracksPassGetDeriv<<
     "\nnumber tracks pass getting derivatives (2nd pass): "<<m_ntracksPassGetDerivSecPass<<
     "\nnumber tracks pass getting derivatives (3rd pass): "<<m_ntracksPassGetDerivLastPass<<
     "\nnumber tracks pass setting derivatives:            "<<m_ntracksPassDerivatives);
    ATH_MSG_INFO("number tracks fail max iterations:                 "<<m_ntracksFailMaxIter<<
     "\nnumber tracks fail track refit:                    "<<m_ntracksFailTrackRefit<<
     "\nnumber tracks fail align param cut:                "<<m_ntracksFailAlignParamCut<<
     "\nnumber tracks fail final attempt:                  "<<m_ntracksFailFinalAttempt);
 
    return StatusCode::SUCCESS;
  }

◆ getAllDerivatives()

bool ShiftingDerivCalcTool::getAllDerivatives	(	AlignTrack *	alignTrack,
		const AlignModule *	alignModule,
		std::vector< Amg::VectorX > &	deriv_vec,
		std::vector< Amg::VectorX > &	derivErr_vec,
		std::vector< double > &	actualsecderiv_vec,
		bool &	resetIPar )

private

Definition at line 875 of file ShiftingDerivCalcTool.cxx.

{
  resetIPar=false;
 
  deriv_vec.clear();
  derivErr_vec.clear();
  actualsecderiv_vec.clear();
 
  setUnshiftedResiduals(alignTrack); // this will set the min number of iterations to the new value
 
  int ipar(0);
  DataVector<AlignPar>* alignPars=m_alignModuleTool->getAlignPars(alignModule);
  for (DataVector<AlignPar>::iterator it=alignPars->begin(); it!=alignPars->end(); ++it,ipar++) {
    ATH_MSG_DEBUG("ipar: "<<ipar);
    Amg::VectorX derivErr(alignTrack->nAlignTSOSMeas());
    double actualSecondDeriv(0.);
    const Amg::VectorX vec=getDerivatives(alignTrack,ipar,*it,derivErr,resetIPar,actualSecondDeriv);
    ATH_MSG_DEBUG("vec size: "<<vec.rows());
 
    ATH_MSG_DEBUG("resetIPar="<<resetIPar);
    if (resetIPar) continue; // continue with derivatives to find max iteration
 
    if (vec.rows()<1) return false; // derivatives won't be set for alignTrack because it's a bad track
 
    deriv_vec.push_back(vec);
    derivErr_vec.push_back(derivErr);
    actualsecderiv_vec.push_back(actualSecondDeriv);
 
    for (int i=0;i<m_nFits;i++) {
      ATH_MSG_DEBUG("m_tmpChi2VAlignParam["<<ipar<<"]["
                <<i<<"]="<<m_tmpChi2VAlignParam[ipar][i]);
    }
  }
 
  return true;
}

◆ getDerivatives()

Amg::VectorX ShiftingDerivCalcTool::getDerivatives	(	AlignTrack *	alignTrack,
		int	ipar,
		AlignPar *	alignPar,
		Amg::VectorX &	derivativeErr,
		bool &	resetIPar,
		double &	actualSecondDerivative )

protected

Definition at line 433 of file ShiftingDerivCalcTool.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  const Trk::Track* trackForRefit =
    (m_removeScatteringBeforeRefit) ? alignTrack->trackWithoutScattering():
    dynamic_cast<const Trk::Track*>(alignTrack);
 
  ATH_MSG_DEBUG("m_nIterations: "<<m_nIterations);
 
  // gets derivatives of residuals w.r.t. a specific alignment parameter given by alignPar
  if (!m_fitter)
    ATH_MSG_ERROR("set m_fitter before calling getDerivatives (by calling setUnshiftedResiduals)");
 
  AlignModule* module=alignPar->alignModule();
 
  // set derivatives for 2 shifts up and 2 shifts down
  const int NFITS = m_nFits;
  const int NMEAS = alignTrack->nAlignTSOSMeas();
  module->setNChamberShifts(m_nFits);
 
  ATH_MSG_DEBUG("NMEAS="<<NMEAS);
  double** residuals=new double*[NFITS];
  double** resErrors=new double*[NFITS];
  double* chi2Array =new double[NFITS];
  double* chi2ArrayX=new double[NFITS];
 
  if (m_doChi2VAlignParamMeasType) {
    for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++)
      m_tmpChi2VAlignParamMeasType[i][ipar] =new double[NFITS];
  }
 
  for (int ifit=0;ifit<NFITS;ifit++) {
    residuals[ifit]=new double[NMEAS];
    resErrors[ifit]=new double[NMEAS];
  }
 
  // set the values for the unshifted track
  const int unshiftedTrackIndex = m_doFits ? (m_nFits-1)/2 : 1;
  chi2Array [unshiftedTrackIndex] = m_unshiftedTrackChi2;
  ATH_MSG_DEBUG("chi2Array["<<unshiftedTrackIndex<<"]="<<chi2Array[unshiftedTrackIndex]);
  chi2ArrayX[unshiftedTrackIndex] = 0.;
  if (m_doChi2VAlignParamMeasType) {
    for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++) {
      m_tmpChi2VAlignParamMeasType[i][ipar][unshiftedTrackIndex]=
      m_unshiftedTrackChi2MeasType[i];
      ATH_MSG_DEBUG("chi2ArrayMeasType["<<i<<"]["<<unshiftedTrackIndex<<"]="<<m_unshiftedTrackChi2MeasType[i]);
    }
  }
 
 
  // get shift size
  double shiftsize=shiftSize(alignPar);
 
  IGlobalTrackFitter::AlignmentCache alignCache;
 
 
  ATH_MSG_VERBOSE("doing refits");
  for (int ifit=0;ifit<NFITS;ifit++) {
 
    ATH_MSG_VERBOSE("ifit="<<ifit);
    int jfit=ifit;
    if (ifit>unshiftedTrackIndex) {
      jfit=NFITS-ifit+unshiftedTrackIndex;
    }
    if (m_doFits && ifit==unshiftedTrackIndex) {
      for (int i=0;i<(int)m_unshiftedResiduals->rows();i++) {
        residuals[ifit][i]=(*m_unshiftedResiduals)[i];
        resErrors[ifit][i]=(*m_unshiftedResErrors)[i];
      }
      // change back in case it got changed on the other side of zero
      shiftsize=shiftSize(alignPar);
      continue;
    }
 
    // shift module and fit track
    double currentshift = 0.;
    if(m_doFits)
      currentshift = shiftsize * (double)(jfit-unshiftedTrackIndex);
    else
      currentshift = (ifit==0) ? -1.*shiftsize : shiftsize;
 
    ATH_MSG_DEBUG("current shift="<<currentshift<<" in getDerivatives");
 
    m_alignModuleTool->shiftModule(module,alignTrack,
    alignPar->paramType(),currentshift);
 
 
    ATH_MSG_VERBOSE("fitting after shift");
    const Track* refittedTrack=m_fitter->alignmentFit(ctx, alignCache,
               *trackForRefit,
               m_runOutlierRemoval,m_particleHypothesis);
    if (m_setMinIterations && alignCache.m_iterationsOfLastFit>m_nIterations) {
      m_nIterations=alignCache.m_iterationsOfLastFit;
      if (m_nIterations>m_maxIter) {
        ATH_MSG_DEBUG("exceeded max number of iterations");
        m_alignModuleTool->restoreModule(module);
        resetIPar=false;
        ATH_MSG_DEBUG("resetIPar set to false");
        delete [] residuals; delete [] resErrors;
        delete [] chi2Array; delete [] chi2ArrayX;
        ATH_MSG_DEBUG("fail max iter");
        m_ntracksFailMaxIter++;
        Amg::VectorX derivatives(1);
        return derivatives;
      }
      ATH_MSG_DEBUG("increasing m_nIterations to "<<m_nIterations<<" (not changing in fit yet)");
      resetIPar=true;
      ATH_MSG_DEBUG("resetIPar set to true");
    }
 
    // if resetIPar refit the rest of the tracks, but don't do anything with them until next pass
    if (resetIPar) {
      m_alignModuleTool->restoreModule(module);
      continue;
    }
 
    if (!refittedTrack) {
      msg(MSG::WARNING) << "track refit failed for jfit "<<jfit <<endmsg;
      delete [] residuals; delete [] resErrors;
      delete [] chi2Array; delete [] chi2ArrayX;
      m_alignModuleTool->restoreModule(module);
      if (!resetIPar || m_secPass) {
        m_ntracksFailTrackRefit++;
      }
      ATH_MSG_DEBUG("fail track refit, resetIPar "<<resetIPar<<", secPass "<<m_secPass);
      Amg::VectorX derivatives(1);
      return derivatives;
    }
    else
      ATH_MSG_VERBOSE("track refit successful");
 
    double chi2=refittedTrack->fitQuality()->chiSquared();
 
    ATH_MSG_VERBOSE("jfit = "<<jfit);
    double localChi2=m_residualCalculator->setResiduals(alignTrack,refittedTrack);
    ATH_MSG_DEBUG("localChi2/fittedChi2="<<localChi2<<"/"<<chi2);
 
    chi2ArrayX[jfit]= shiftsize * (double)(jfit-unshiftedTrackIndex);// / module->sigma(idof);
    chi2Array[jfit]=localChi2;
    ATH_MSG_DEBUG("chi2Array["<<jfit<<"]="<<chi2Array[jfit]);
    if (m_doChi2VAlignParamMeasType) {
      for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++) {
        m_tmpChi2VAlignParamMeasType[i][ipar][jfit]=  m_residualCalculator->chi2ForMeasType(i);
        ATH_MSG_DEBUG("chi2ArrayMeasType["<<i<<"]["<<jfit<<"]="
                      <<m_tmpChi2VAlignParamMeasType[i][ipar][jfit]);
      }
    }
 
    ATH_MSG_DEBUG("positions["<<jfit<<"]="<<chi2ArrayX[jfit]);
 
    int imeas(0);
    AlignTSOSCollection::const_iterator atsosItr=alignTrack->firstAtsos();
    for (; atsosItr != alignTrack->lastAtsos(); ++atsosItr) {
      if (!(*atsosItr)->isValid()) continue;
      for (std::vector<Residual>::const_iterator itRes=(**atsosItr).firstResidual();
           itRes!=(**atsosItr).lastResidual();++itRes,++imeas) {
 
        if (refittedTrack) {
          residuals[jfit][imeas]=itRes->residual();
          resErrors[jfit][imeas]=std::sqrt(itRes->errSq());
        }
        else {
          residuals[jfit][imeas]=resErrors[jfit][imeas]=0.;
        }
        ATH_MSG_DEBUG("residuals["<<jfit<<"]["<<imeas<<"]="<<residuals[jfit][imeas]);
        ATH_MSG_DEBUG("resErrors["<<jfit<<"]["<<imeas<<"]="<<resErrors[jfit][imeas]);
      }
    }
 
    delete refittedTrack; refittedTrack=nullptr;
    ATH_MSG_VERBOSE("calling restoreModule");
    m_alignModuleTool->restoreModule(module);
  } // NFITS
 
  int iimeas(0);
  AlignTSOSCollection::const_iterator aatsosItr=alignTrack->firstAtsos();
  for (; aatsosItr != alignTrack->lastAtsos(); ++aatsosItr) {
    if (!(*aatsosItr)->isValid()) continue;
    for (std::vector<Residual>::const_iterator itRes=(**aatsosItr).firstResidual();
         itRes!=(**aatsosItr).lastResidual();++itRes,++iimeas) {
      for (int ifit=0;ifit<NFITS;ifit++) {
        ATH_MSG_DEBUG("["<<ifit<<"]["<<iimeas<<"]   res="<<residuals[ifit][iimeas]<<
          ",   resErr="<<resErrors[ifit][iimeas]);
      }
    }
  }
 
  if (resetIPar) {
    //resetIPar=false;
    delete [] residuals; delete [] resErrors;
    delete [] chi2Array; delete [] chi2ArrayX;
    if (m_secPass) ATH_MSG_WARNING("failed second pass!");
    ATH_MSG_DEBUG("returning to reset IPar");
    Amg::VectorX derivatives;
    return derivatives;
  }
 
  // check chi2 vs. chamber pos to see if discontinuous
  TGraph* gr = new TGraph(m_nFits,chi2ArrayX,chi2Array);
  gr->Fit("pol2","QF");
  TF1* fit=gr->GetFunction("pol2");
  double chi2 =fit->GetChisquare()/double(m_nFits-3);
  double slope=fit->GetParameter(1);
  actualSecondDeriv=fit->GetParameter(2);
  delete gr;
 
  ATH_MSG_DEBUG("discontinuity check: chi2="<<chi2);
  alignTrack->setTrackAlignParamQuality(alignPar->paramType(),chi2);
 
  // EventInfo
  if (chi2>1.e-6 || std::fabs(slope)<1.e-10) {
    const xAOD::EventInfo* eventInfo;
    StatusCode sc=evtStore()->retrieve(eventInfo);
    if (sc.isFailure())
    ATH_MSG_ERROR("Couldn't retrieve event info");
    int run=eventInfo->runNumber();
    int evt=eventInfo->eventNumber();
    ATH_MSG_DEBUG("discontinuity check: chi2="<<chi2<<", run/evt "<<run<<"/"<<evt);
  }
 
  //reset in case it got changed somewhere
  shiftsize = shiftSize(alignPar);
 
  //-----------------------------------------//
  //--   get derivatives from residuals    --//
  //-----------------------------------------//
  ATH_MSG_VERBOSE("calculating residuals");
  Amg::VectorX derivatives(alignTrack->nAlignTSOSMeas(),0);
  ATH_MSG_DEBUG("created derivatives with "<<derivatives.rows()<<" rows");
 
  // if bad fit or first derivative close to zero, replace derivatives with zeros
  if (chi2>m_trackAlignParamCut) {// || std::fabs(slope)<1.e-10 ) {
    ATH_MSG_DEBUG("chi2/"<<m_nFits-3<<"="<<chi2);
    delete [] residuals; delete [] resErrors;
    delete [] chi2Array; delete [] chi2ArrayX;
 
    m_nIterations=alignCache.m_iterationsOfLastFit+5;
    if (m_nIterations>m_maxIter) {
      ATH_MSG_DEBUG("exceeded max number of iterations");
      resetIPar=false;
    }
    ATH_MSG_DEBUG("increasing m_nIterations to "<<m_nIterations<<" (not changing in fit yet)");
    resetIPar=true;
    ATH_MSG_INFO("fail align param cut, secPass "<<m_secPass);
    if (m_secPass) {
      m_ntracksFailAlignParamCut++;
    }
    Amg::VectorX emptyDerivatives;
    return emptyDerivatives;
  }
 
  int imeas(0);
  TCanvas* canv(nullptr);
  std::vector<TGraph*> vecGraphs;
  AlignTSOSCollection::const_iterator atsosItr=alignTrack->firstAtsos();
  for (; atsosItr != alignTrack->lastAtsos(); ++atsosItr) {
    if (!(*atsosItr)->isValid()) continue;
    for (int idim=0;idim<(*atsosItr)->nResDim();idim++) {
 
      double* gr_x    = new double[NFITS];
      double* gr_y    = new double[NFITS]; // residuals only have float precision if determined from ESD
      int ngoodfits=0;
      for (int ifit=0;ifit<NFITS;ifit++) {
        double residual=residuals[ifit][imeas];
        double resError=resErrors[ifit][imeas];
        if (residual>-999.) {
          gr_x[ngoodfits]   =chi2ArrayX[ifit];
          gr_y[ngoodfits]   =residual/resError;
          ngoodfits++;
        }
      }
 
      if (!m_doFits && ngoodfits==2) {
        derivatives[imeas]=(residuals[1][imeas]-residuals[0][imeas])/(2.*shiftsize)*
        resErrors[unshiftedTrackIndex][imeas];
      }
      else if (m_doFits && ngoodfits>3) {
        TGraph* gr=new TGraph(ngoodfits,gr_x,gr_y);
 
      if (m_doResidualPlots)
        gr->Fit("pol2","VF");
      else
        gr->Fit("pol2","QF");
      TF1* fit=gr->GetFunction("pol2");
 
      //double derivRatio=fit->GetParameter(2)/fit->GetParameter(1);
      ATH_MSG_DEBUG("deriv["<<imeas<<"]="<<fit->GetParameter(1)<<" +/- "<<fit->GetParError(1)
        <<", chi2="<<fit->GetChisquare());
      derivatives[imeas]=fit->GetParameter(1)*resErrors[unshiftedTrackIndex][imeas]; // first derivative at x=0
      derivativeErr[imeas]=fit->GetParError(1)*resErrors[unshiftedTrackIndex][imeas];
 
 
      // plot residuals vs. chamber position
      if (m_doResidualPlots) {
        if (!canv) canv=new TCanvas("resPlots","resPlots");
        canv->cd();
        gr->SetMarkerStyle(20);
              gr->Draw("AP");
 
        gr->GetXaxis()->SetTitle("shift in chamber pos. from nominal (CLHEP::mm)");
        gr->GetYaxis()->SetTitle("residual (CLHEP::mm)");
 
        TPaveText* pave=new TPaveText(.4,.65,.97,.92,"NDC");
        pave->SetFillColor(0);
        pave->SetBorderSize(1);
        std::stringstream measType; measType<<"meas type: ";
        if      ((*atsosItr)->measType()==TrackState::MDT) measType<<" MDT";
        else if ((*atsosItr)->measType()==TrackState::TGC) measType<<" TGC";
        else if ((*atsosItr)->measType()==TrackState::RPC) measType<<" RPC";
        else measType<<" undefined";
 
        pave->AddText(measType.str().c_str());
 
        std::stringstream firstderivtxt,secndderivtxt,aptxt,chi2txt;
        firstderivtxt<<fit->GetParameter(1)<<" +/- "<<fit->GetParError(1);
        secndderivtxt<<fit->GetParameter(2)<<" +/- "<<fit->GetParError(2);
        aptxt  <<"alignPar "<<alignPar->paramType()<<", RIO in "<<(*atsosItr)->identify();
        chi2txt<<"chi2="<<fit->GetChisquare();
 
        pave->AddText(firstderivtxt.str().c_str());
        pave->AddText(secndderivtxt.str().c_str());
        pave->AddText(aptxt.str().c_str());
        pave->AddText(chi2txt.str().c_str());
        pave->Draw();
 
        std::stringstream canvName;
        canvName<<"resPlots_ap"<<alignPar->paramType()<<"_measType"
        <<(*atsosItr)->measType()<<"_"<<imeas<<".eps";
        canv->Print(canvName.str().c_str());
        canv->Clear();
 
        delete pave;
      }
      vecGraphs.push_back(gr);
    }
    else {
      derivatives[imeas]=-999.;
      derivativeErr[imeas]=-999.;
    }
 
    delete [] gr_y;
    delete [] gr_x;
 
    ++imeas;
    }
  }
 
  // delete TGraphs and TCanvas
  for (auto & vecGraph : vecGraphs)
    delete vecGraph;
  delete canv;
 
  delete [] residuals;
  delete [] resErrors;
 
  // set chi2 v alignparam
  for (int ifit=0;ifit<NFITS;ifit++) {
    m_tmpChi2VAlignParamX[ipar]=chi2ArrayX;
    m_tmpChi2VAlignParam [ipar]=chi2Array;
  }
 
  ATH_MSG_DEBUG("derivativeErr: "<<derivativeErr);
  return derivatives;
}

◆ initialize()

StatusCode ShiftingDerivCalcTool::initialize ( )

Definition at line 54 of file ShiftingDerivCalcTool.cxx.

  {
 
    msg(MSG::DEBUG)  << "in ShiftingDerivCalcTool initialize()"<<endmsg;
    ATH_CHECK(m_trackFitterTool.retrieve());
    ATH_CHECK(m_SLTrackFitterTool.retrieve());
    ATH_CHECK(m_residualCalculator.retrieve());
    ATH_CHECK(m_alignModuleTool.retrieve());
 
    m_particleHypothesis = Trk::ParticleSwitcher::particle[m_particleNumber];
    msg(MSG::INFO) << "ParticleNumber: "     << m_particleNumber     << endmsg;
    msg(MSG::INFO) << "ParticleHypothesis: " << m_particleHypothesis << endmsg;
 
 
    if(!m_doFits){
      m_nFits = 2;
    }
 
    m_traSize = 5.*m_traSize/(double)m_nFits;
    m_rotSize = 5.*m_rotSize/(double)m_nFits;
 
    msg(MSG::INFO) << "doFits: "   << m_doFits  << endmsg;
    msg(MSG::INFO) << "nFits:  "   << m_nFits  << endmsg;
 
    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()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ scanShifts()

bool ShiftingDerivCalcTool::scanShifts	(	const AlignTrack *	alignTrack,
		const std::vector< AlignModule * > &	alignModules )

private

Definition at line 100 of file ShiftingDerivCalcTool.cxx.

  {
    ATH_MSG_DEBUG("in scanShifts");
 
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    const Trk::Track* trackForRefit =
      (m_removeScatteringBeforeRefit) ? alignTrack->trackWithoutScattering():
      dynamic_cast<const Trk::Track*>(alignTrack);
 
    // see whether straight track or not
    m_fitter = alignTrack->isSLTrack() ?
      m_SLTrackFitterTool : m_trackFitterTool;
    ATH_MSG_DEBUG("refitting unshifted track with "<<m_fitter<<" (isSLTrack="
      <<alignTrack->isSLTrack()<<")");
 
    ATH_MSG_DEBUG("setting minNIterations to "<<m_nIterations);
 
    // refit track
 
    IGlobalTrackFitter::AlignmentCache alignCache;
    alignCache.m_minIterations = m_nIterations;
    const Track* refittedTrack = m_fitter->alignmentFit(ctx, alignCache, *trackForRefit,
            m_runOutlierRemoval,
            m_particleHypothesis);
    if (!refittedTrack) {
      msg(MSG::WARNING)  << "initial track refit failed" << endmsg;
      return false;
    }
    else
      ATH_MSG_DEBUG("initial track refit successful");
 
    m_nIterations = alignCache.m_iterationsOfLastFit;
    if (m_nIterations>m_maxIter) {
      ATH_MSG_DEBUG("exceeded maximum number of iterations");
      return false;
    }
    ATH_MSG_DEBUG("initial nIterations: "<<m_nIterations);
 
    // loop over AlignModules
    for (std::vector<AlignModule*>::const_iterator moduleIt=alignModules.begin();
   moduleIt!=alignModules.end(); ++moduleIt) {
 
      // loop over AlignPar
      DataVector<AlignPar>* alignPars=m_alignModuleTool->getAlignPars(*moduleIt);
      for (DataVector<AlignPar>::iterator alignParIt=alignPars->begin();
     alignParIt!=alignPars->end(); ++alignParIt) {
 
  for (int ishift=0;ishift<2;ishift++) {
 
    double shiftsize = shiftSize(*alignParIt);
    if (ishift>0) shiftsize*=-1.;
    m_alignModuleTool->shiftModule(*moduleIt,alignTrack,(**alignParIt).paramType(),shiftsize);
    refittedTrack = (m_fitter->fit(ctx,
                                  *trackForRefit,m_runOutlierRemoval,
                                  m_particleHypothesis)).release();
    m_alignModuleTool->restoreModule(*moduleIt);
    if (!refittedTrack) {
      msg(MSG::WARNING) << "track refit failed!"<<endmsg;
      m_nIterations=0;
      return false;
    }
 
    int nIter=alignCache.m_iterationsOfLastFit;
    ATH_MSG_DEBUG("nIter: "<<nIter);
    if (nIter>m_maxIter) {
      ATH_MSG_DEBUG("exceeded maximum number of iterations");
      m_nIterations=0;
      return false;
    }
 
    if (nIter>m_nIterations) m_nIterations=nIter;
  }
      } // loop over AlignPar
    } // loop over AlignModules
 
    ATH_MSG_DEBUG("done with scanShifts, m_nIterations="<<m_nIterations);
    return true;
  }

◆ setChi2VAlignParam()

void Trk::ShiftingDerivCalcTool::setChi2VAlignParam	(	const AlignTrack *	alignTrack,
		const AlignModule *	module,
		int	nshifts = 0 )

protected

◆ setDerivatives()

bool ShiftingDerivCalcTool::setDerivatives ( AlignTrack * track )

virtual

sets derivatives of residuals w.r.t.

alignment parameters for hits on track.

Implements Trk::IDerivCalcTool.

Definition at line 265 of file ShiftingDerivCalcTool.cxx.

{
  ATH_MSG_DEBUG("in ShiftingDerivCalcTool setDerivatives");
  m_ntracksProcessed++;
 
  // loop over AlignTSOSCollection,
  // find modules that are in the AlignModuleList,
  std::vector<AlignModule*> alignModules;
  for (AlignTSOSCollection::iterator atsosItr=alignTrack->firstAtsos();
      atsosItr != alignTrack->lastAtsos(); ++atsosItr) {
 
    ATH_MSG_VERBOSE("getting module");
    AlignModule* module=(*atsosItr)->module();
    if (module)
      ATH_MSG_VERBOSE("have ATSOS for module "<<module->identify());
    else
      ATH_MSG_VERBOSE("no module!");
 
    if (!(*atsosItr)->isValid() || !module) continue;
    if (find(alignModules.begin(),alignModules.end(),module) == alignModules.end())
    alignModules.push_back(module);
  }
 
  // find perigee of best track fit and use as starting perigee for all fits
  m_nIterations=m_minIter;
  if (m_setMinIterations && !scanShifts(alignTrack, alignModules)) {
    return false;
  };
 
  m_ntracksPassInitScan++;
 
  // set unshifted residuals (this is done in AlignTrackDresser but redone here with track refit)
  if (!setUnshiftedResiduals(alignTrack)) {
    ATH_MSG_WARNING("problem with refitting track!");
    return false;
  };
 
  m_ntracksPassSetUnshiftedRes++;
 
  // Determine derivatives from shifting these modules
  std::vector<AlignModuleDerivatives> * derivatives = new std::vector<AlignModuleDerivatives>;
  std::vector<AlignModuleDerivatives> * derivativeErr = new std::vector<AlignModuleDerivatives>;
  std::vector<std::pair<AlignModule*, std::vector<double> > > * actualSecondDerivatives =
      new std::vector<std::pair<AlignModule*, std::vector<double> > >;
  deleteChi2VAlignParam();
  for (auto *alignModule : alignModules) {
 
    ATH_MSG_DEBUG("finding derivatives for module "<<(*alignModule).identify());
 
    std::vector<Amg::VectorX> deriv_vec;
    std::vector<Amg::VectorX> derivErr_vec;
    std::vector<double> actualsecderiv_vec;
 
    // get alignPars and create arrays to store chi2 vs. align pars
    DataVector<AlignPar>* alignPars=m_alignModuleTool->getAlignPars(alignModule);
    const int nAlignPar = alignPars->size();
    m_tmpChi2VAlignParam  = new double*[nAlignPar];
    m_tmpChi2VAlignParamX = new double*[nAlignPar];
    if (m_doChi2VAlignParamMeasType) {
      m_tmpChi2VAlignParamMeasType = new double**[TrackState::NumberOfMeasurementTypes];
      for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++)
        m_tmpChi2VAlignParamMeasType[i] = new double*[nAlignPar];
    }
 
 
    // get derivatives and arrays of chi2 vs. align params
    bool resetIPar=false;
    std::vector<Amg::VectorX> tmpderiv_vec;
    std::vector<Amg::VectorX> tmpderivErr_vec;
    std::vector<double> tmpactualsecderiv_vec;
    m_secPass=false;
 
    // first attempt with normal number of fitter iterations
    bool success=getAllDerivatives(
           alignTrack, alignModule,
           tmpderiv_vec,tmpderivErr_vec,tmpactualsecderiv_vec,
           resetIPar);
    if (!success){
      delete derivatives;
      delete derivativeErr;
      delete actualSecondDerivatives;
      return false;
    }
 
    m_ntracksPassGetDeriv++;
 
    if (resetIPar) {
      // second attempt with increased number of fitter iterations
      m_secPass=true;
      success=getAllDerivatives(alignTrack,alignModule,
              tmpderiv_vec,tmpderivErr_vec,tmpactualsecderiv_vec,
              resetIPar);
    }
 
    if (!success){
      delete derivatives;
      delete derivativeErr;
      delete actualSecondDerivatives;
      return false;
    }
 
    m_ntracksPassGetDerivSecPass++;
 
    if (resetIPar) {
      // third and last attempt with number of fitter iterations set to maximum
      m_nIterations=m_maxIter;
      success=getAllDerivatives(alignTrack,alignModule,
              tmpderiv_vec,tmpderivErr_vec,tmpactualsecderiv_vec,
              resetIPar);
    }
 
    if (!success){
      delete derivatives;
      delete derivativeErr;
      delete actualSecondDerivatives;
      return false;
    }
 
 
    m_ntracksPassGetDerivLastPass++;
 
    if (success && !resetIPar) {
      for (int i=0;i<(int)tmpderiv_vec.size();i++) {
        deriv_vec.push_back(tmpderiv_vec[i]);
        derivErr_vec.push_back(tmpderivErr_vec[i]);
        actualsecderiv_vec.push_back(tmpactualsecderiv_vec[i]);
      }
    }
    else{
      delete derivatives;
      delete derivativeErr;
      delete actualSecondDerivatives;
      return false;
    }
    // set the chi2 vs. align param arrays
    ATH_MSG_DEBUG("setting chi2 vs. align param arrays");
    m_chi2VAlignParamVec.push_back(m_tmpChi2VAlignParam);
    m_chi2VAlignParamXVec.push_back(m_tmpChi2VAlignParamX);
    (*alignModule).setChi2VAlignParamArray (m_tmpChi2VAlignParam);
    (*alignModule).setChi2VAlignParamXArray(m_tmpChi2VAlignParamX);
 
    // arrays for measurement types
    if (m_doChi2VAlignParamMeasType) {
      ATH_MSG_DEBUG("pushing back for measType");
      m_chi2VAlignParamVecMeasType.push_back(m_tmpChi2VAlignParamMeasType);
      for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++)
        (*alignModule).setChi2VAlignParamArrayMeasType(i,m_tmpChi2VAlignParamMeasType[i]);
    }
    ATH_MSG_DEBUG("done setting arrays");
 
    derivatives->push_back(make_pair(alignModule,deriv_vec));
    derivativeErr->push_back(make_pair(alignModule,derivErr_vec));
    actualSecondDerivatives->push_back(make_pair(alignModule,actualsecderiv_vec));
  }
 
  m_ntracksPassDerivatives++;
 
  alignTrack->setDerivatives(derivatives);
  alignTrack->setDerivativeErr(derivativeErr);
  alignTrack->setActualSecondDerivatives(actualSecondDerivatives);
 
  // restore unshifted residuals in AlignTSOS
  setUnshiftedResiduals(alignTrack);
 
  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; }

ReadFromCoolCompare.os

int os

Definition ReadFromCoolCompare.py:226

◆ setResidualCovMatrix()

bool ShiftingDerivCalcTool::setResidualCovMatrix ( AlignTrack * alignTrack ) const

virtual

sets residual covariance matrix

Implements Trk::IDerivCalcTool.

Definition at line 819 of file ShiftingDerivCalcTool.cxx.

{
  Amg::MatrixX W(alignTrack->nAlignTSOSMeas(),alignTrack->nAlignTSOSMeas());
 
  if (alignTrack->localErrorMatrixInv()) {
    ATH_MSG_ERROR("Need to assign this matrix correctly: ShiftingDerivCalcTool.cxx:888");
    W = *(alignTrack->localErrorMatrixInv());
    //W.assign(*(alignTrack->localErrorMatrixInv()));
  } else{
    return false;
  }
  ATH_MSG_DEBUG("W: "<<W);
 
  bool Wisvalid(true);
  const double epsilon=1e-10;
  for( int irow=0; irow<W.rows(); ++irow) {
    Wisvalid = Wisvalid && W(irow,irow)>0;
    if( !(W(irow,irow)>0) )
      msg(MSG::WARNING) << "matrix invalid: " << W(irow,irow) << endmsg;
 
    for(int icol=0; icol<=irow; ++icol) {
 
    // this one must be true if everything else succeeded
    double Wcorr = W(irow,icol)/sqrt(W(irow,irow)*W(icol,icol));
    bool Wcorrisvalid = Wcorr+epsilon>=-1 && Wcorr-epsilon<=1;
    Wisvalid = Wisvalid && Wcorrisvalid;
    if( !Wcorrisvalid )
      msg(MSG::WARNING) << "matrix corr invalid: " << Wcorr-1 << " " << Wcorr+1 << endmsg;
    }
  }
 
  if (Wisvalid)
  alignTrack->setWeightMatrix(new Amg::MatrixX(W));
 
  alignTrack->setWeightMatrixFirstDeriv(new Amg::MatrixX(std::move(W)));
 
  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; }

Trk::IDerivCalcTool::m_solveOption

int m_solveOption

Definition IDerivCalcTool.h:80

◆ setUnshiftedResiduals()

bool ShiftingDerivCalcTool::setUnshiftedResiduals ( AlignTrack * alignTrack )

protected

Definition at line 182 of file ShiftingDerivCalcTool.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
 
    // see whether straight track or not
    m_fitter = alignTrack->isSLTrack() ?
      m_SLTrackFitterTool : m_trackFitterTool;
    ATH_MSG_DEBUG("refitting unshifted track with "<<m_fitter<<" (isSLTrack="
      <<alignTrack->isSLTrack()<<")");
 
    // refit track
    ATH_MSG_DEBUG("\nsetting min number iterations to "<<m_nIterations);
    IGlobalTrackFitter::AlignmentCache alignCache;
    alignCache.m_minIterations = m_nIterations;
 
    const Trk::Track* trackForRefit =
      (m_removeScatteringBeforeRefit) ? alignTrack->trackWithoutScattering():
      dynamic_cast<const Trk::Track*>(alignTrack);
    if (!trackForRefit) {
      ATH_MSG_ERROR("no track for refit!");
      return false;
    }
 
    const Track* refittedTrack = m_fitter->alignmentFit( ctx, alignCache,
            *trackForRefit,
            m_runOutlierRemoval,
            m_particleHypothesis);
 
    if (!refittedTrack) {
      ATH_MSG_WARNING( "initial track refit failed" );
      return false;
    }
    else
      ATH_MSG_DEBUG("initial track refit successful");
 
    // dump local track chi2 for debugging
    double localChi2=m_residualCalculator->setResiduals(alignTrack,refittedTrack);
    msg()<<MSG::DEBUG<<"local Chi2(unshifted) in setChi2VAlignParam="<<localChi2<<endmsg;
    m_unshiftedTrackChi2 = localChi2;
    for (int i=0;i<TrackState::NumberOfMeasurementTypes;i++) {
      ATH_MSG_DEBUG("getting chi2 for measType "<<i);
      m_unshiftedTrackChi2MeasType[i]=m_residualCalculator->chi2ForMeasType(i);
    }
    ATH_MSG_DEBUG("done");
 
    // create vector containing unshifted residuals and matrices containing errors
    const int NMEAS=alignTrack->nAlignTSOSMeas();
 
    // unshiftedResiduals owned by AlignTrack
    m_unshiftedResiduals=new Amg::VectorX(NMEAS);
 
    // unshiftedResErrors owned by ShiftingDerivCalcTool
    if (m_unshiftedResErrors) delete m_unshiftedResErrors;
      m_unshiftedResErrors=new Amg::VectorX(NMEAS);
 
    // loop over atsos and determine residuals and errors
    int imeas=0;
    AlignTSOSCollection::const_iterator atsosItr=alignTrack->firstAtsos();
    for (; atsosItr != alignTrack->lastAtsos(); ++atsosItr) {
      if (!(**atsosItr).isValid()) continue;
      for (std::vector<Residual>::const_iterator itRes=(**atsosItr).firstResidual();
        itRes!=(**atsosItr).lastResidual();++itRes,++imeas) {
          double residual = itRes->residual();
          double errSq    = itRes->errSq();
          (*m_unshiftedResiduals)[imeas]=residual;
          (*m_unshiftedResErrors)[imeas]=std::sqrt(errSq);
          //ATH_MSG_DEBUG("weight: "<<1./errSq<<", unshiftedRes["<<imeas<<"]="
          //      <<(*m_unshiftedResiduals)[imeas]
          //      <<", resNorm="<<itRes->residualNorm());
      }
    }
    if (imeas!=NMEAS) {
      msg(MSG::ERROR)<<"problem with nmeas, imeas="<<imeas<<", NMEAS="<<NMEAS<<endmsg;
      throw std::runtime_error("Error in ShiftingDerivCalcTool::setUnshiftedResiduals");
    }
    alignTrack->setResidualVector(m_unshiftedResiduals);
 
    delete refittedTrack; refittedTrack=nullptr;
 
    return true;
  }

◆ shiftSize()

double ShiftingDerivCalcTool::shiftSize ( const AlignPar * alignPar ) const

protected

Definition at line 805 of file ShiftingDerivCalcTool.cxx.

                                                                      {
  bool rotation =
    alignPar->paramType() == AlignModule::RotX ||
    alignPar->paramType() == AlignModule::RotY ||
    alignPar->paramType() == AlignModule::RotZ;
 
  double shift = rotation ? m_rotSize : m_traSize;
 
  //ok... this is kind of ugly.
  double sigma=alignPar->sigma();
  return shift * sigma;
}

◆ showStatistics()

void Trk::ShiftingDerivCalcTool::showStatistics ( )

inlinevirtual

write statistics to log file

Implements Trk::IDerivCalcTool.

Definition at line 59 of file ShiftingDerivCalcTool.h.

59{}

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

◆ 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::ShiftingDerivCalcTool::m_alignModuleTool {this, "AlignModuleTool", "Trk::AlignModuleTool/AlignModuleTool"}

private

Definition at line 106 of file ShiftingDerivCalcTool.h.

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

◆ m_chi2VAlignParamVec

std::vector<double**> Trk::ShiftingDerivCalcTool::m_chi2VAlignParamVec

private

track chi2[idof][ichambershift]

Definition at line 131 of file ShiftingDerivCalcTool.h.

◆ m_chi2VAlignParamVecMeasType

std::vector<double***> Trk::ShiftingDerivCalcTool::m_chi2VAlignParamVecMeasType

private

track chi2[idof][imeastype][ichambershift]

Definition at line 140 of file ShiftingDerivCalcTool.h.

◆ m_chi2VAlignParamXVec

std::vector<double**> Trk::ShiftingDerivCalcTool::m_chi2VAlignParamXVec

private

chamber shift[idof][ichambershift]

Definition at line 132 of file ShiftingDerivCalcTool.h.

◆ m_derivative_map

DerivativeMap Trk::ShiftingDerivCalcTool::m_derivative_map

private

Definition at line 118 of file ShiftingDerivCalcTool.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_doChi2VAlignParamMeasType

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_doChi2VAlignParamMeasType {this, "doChi2VChamberShiftsMeasType", false}

private

Definition at line 122 of file ShiftingDerivCalcTool.h.

123{this, "doChi2VChamberShiftsMeasType", false};

◆ m_doFits

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_doFits {this, "doResidualFits", true}

private

Definition at line 120 of file ShiftingDerivCalcTool.h.

120{this, "doResidualFits", true};

◆ m_doResidualPlots

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_doResidualPlots {this, "doResidualPlots", false}

private

Definition at line 124 of file ShiftingDerivCalcTool.h.

124{this, "doResidualPlots", false};

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

ToolHandle<IGlobalTrackFitter> Trk::ShiftingDerivCalcTool::m_fitter

private

Definition at line 102 of file ShiftingDerivCalcTool.h.

◆ m_logStream

std::ostream* Trk::IDerivCalcTool::m_logStream = nullptr

protectedinherited

logfile output stream

Definition at line 76 of file IDerivCalcTool.h.

◆ m_maxIter

Gaudi::Property<int> Trk::ShiftingDerivCalcTool::m_maxIter {this, "MaxIterations", 50}

private

set minimum number of iterations for first track fits

Definition at line 152 of file ShiftingDerivCalcTool.h.

152{this, "MaxIterations", 50};

◆ m_minIter

Gaudi::Property<int> Trk::ShiftingDerivCalcTool::m_minIter {this, "MinIterations", 10}

private

flag to remove scattering before refitting track

Definition at line 155 of file ShiftingDerivCalcTool.h.

155{this, "MinIterations", 10};

◆ m_nFits

Gaudi::Property<int> Trk::ShiftingDerivCalcTool::m_nFits {this, "NumberOfShifts", 5}

private

Definition at line 121 of file ShiftingDerivCalcTool.h.

121{this, "NumberOfShifts", 5};

◆ m_nIterations

int Trk::ShiftingDerivCalcTool::m_nIterations = 0

private

Definition at line 125 of file ShiftingDerivCalcTool.h.

◆ m_ntracksFailAlignParamCut

int Trk::ShiftingDerivCalcTool::m_ntracksFailAlignParamCut = 0

private

Definition at line 170 of file ShiftingDerivCalcTool.h.

◆ m_ntracksFailFinalAttempt

int Trk::ShiftingDerivCalcTool::m_ntracksFailFinalAttempt = 0

private

Definition at line 171 of file ShiftingDerivCalcTool.h.

◆ m_ntracksFailMaxIter

int Trk::ShiftingDerivCalcTool::m_ntracksFailMaxIter = 0

private

Definition at line 168 of file ShiftingDerivCalcTool.h.

◆ m_ntracksFailTrackRefit

int Trk::ShiftingDerivCalcTool::m_ntracksFailTrackRefit = 0

private

Definition at line 169 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassDerivatives

int Trk::ShiftingDerivCalcTool::m_ntracksPassDerivatives = 0

private

number tracks pass setting derivatives

Definition at line 164 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassGetDeriv

int Trk::ShiftingDerivCalcTool::m_ntracksPassGetDeriv = 0

private

number tracks pass getting derivatives

Definition at line 165 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassGetDerivLastPass

int Trk::ShiftingDerivCalcTool::m_ntracksPassGetDerivLastPass = 0

private

number tracks pass 2nd pass of getting derivatives

Definition at line 167 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassGetDerivSecPass

int Trk::ShiftingDerivCalcTool::m_ntracksPassGetDerivSecPass = 0

private

number tracks pass 2nd pass of getting derivatives

Definition at line 166 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassInitScan

int Trk::ShiftingDerivCalcTool::m_ntracksPassInitScan = 0

private

number tracks pass initial scan

Definition at line 162 of file ShiftingDerivCalcTool.h.

◆ m_ntracksPassSetUnshiftedRes

int Trk::ShiftingDerivCalcTool::m_ntracksPassSetUnshiftedRes = 0

private

number tracks pass setting unshifted residuals

Definition at line 163 of file ShiftingDerivCalcTool.h.

◆ m_ntracksProcessed

int Trk::ShiftingDerivCalcTool::m_ntracksProcessed = 0

private

number tracks processed

Definition at line 161 of file ShiftingDerivCalcTool.h.

◆ m_particleHypothesis

ParticleHypothesis Trk::ShiftingDerivCalcTool::m_particleHypothesis = Trk::muon

private

Definition at line 114 of file ShiftingDerivCalcTool.h.

◆ m_particleNumber

Gaudi::Property<int> Trk::ShiftingDerivCalcTool::m_particleNumber {this, "ParticleNumber", 2}

private

Definition at line 116 of file ShiftingDerivCalcTool.h.

116{this, "ParticleNumber", 2};

◆ m_removeScatteringBeforeRefit

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_removeScatteringBeforeRefit {this, "RemoveScatteringBeforeRefit", false}

private

Definition at line 158 of file ShiftingDerivCalcTool.h.

159{this, "RemoveScatteringBeforeRefit", false};

◆ m_residualCalculator

ToolHandle<IAlignResidualCalculator> Trk::ShiftingDerivCalcTool::m_residualCalculator {this, "ResidualCalculator", "Trk::AlignResidualCalculator/ResidualCalculator"}

private

Definition at line 104 of file ShiftingDerivCalcTool.h.

105{this, "ResidualCalculator", "Trk::AlignResidualCalculator/ResidualCalculator"};

◆ m_rotSize

Gaudi::Property<double> Trk::ShiftingDerivCalcTool::m_rotSize {this, "RotationSize", .1}

private

Definition at line 110 of file ShiftingDerivCalcTool.h.

110{this, "RotationSize", .1};

◆ m_runOutlierRemoval

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_runOutlierRemoval {this, "RunOutlierRemoval", false}

private

Definition at line 112 of file ShiftingDerivCalcTool.h.

113{this, "RunOutlierRemoval", false};

◆ m_secPass

bool Trk::ShiftingDerivCalcTool::m_secPass {}

private

Definition at line 173 of file ShiftingDerivCalcTool.h.

173{};

◆ m_setMinIterations

Gaudi::Property<bool> Trk::ShiftingDerivCalcTool::m_setMinIterations {this, "SetMinIterations", false}

private

reject track if exceed maximum number of iterations

Definition at line 149 of file ShiftingDerivCalcTool.h.

149{this, "SetMinIterations", false};

◆ m_SLTrackFitterTool

ToolHandle<IGlobalTrackFitter> Trk::ShiftingDerivCalcTool::m_SLTrackFitterTool {this, "SLTrackFitterTool", "Trk::GlobalChi2Fitter/MCTBSLFitter"}

private

Definition at line 100 of file ShiftingDerivCalcTool.h.

101{this, "SLTrackFitterTool", "Trk::GlobalChi2Fitter/MCTBSLFitter"};

◆ m_solveOption

int Trk::IDerivCalcTool::m_solveOption = 0

privateinherited

Definition at line 80 of file IDerivCalcTool.h.

◆ m_tmpChi2VAlignParam

double** Trk::ShiftingDerivCalcTool::m_tmpChi2VAlignParam = nullptr

private

Definition at line 134 of file ShiftingDerivCalcTool.h.

◆ m_tmpChi2VAlignParamMeasType

double*** Trk::ShiftingDerivCalcTool::m_tmpChi2VAlignParamMeasType = nullptr

private

Definition at line 136 of file ShiftingDerivCalcTool.h.

◆ m_tmpChi2VAlignParamX

double** Trk::ShiftingDerivCalcTool::m_tmpChi2VAlignParamX = nullptr

private

Definition at line 135 of file ShiftingDerivCalcTool.h.

◆ m_trackAlignParamCut

Gaudi::Property<double> Trk::ShiftingDerivCalcTool::m_trackAlignParamCut {this, "TrackAlignParamCut", 1e6}

private

fit track with AlignModules shifted up and down in each extreme, find the number of iterations fitter uses to converge.

Set this number for all subsequent track refits.

Definition at line 146 of file ShiftingDerivCalcTool.h.

146{this, "TrackAlignParamCut", 1e6};

◆ m_trackFitterTool

ToolHandle<IGlobalTrackFitter> Trk::ShiftingDerivCalcTool::m_trackFitterTool {this, "TrackFitterTool", "Trk::GlobalChi2Fitter/MCTBFitter"}

private

Definition at line 98 of file ShiftingDerivCalcTool.h.

99{this, "TrackFitterTool", "Trk::GlobalChi2Fitter/MCTBFitter"};

◆ m_traSize

Gaudi::Property<double> Trk::ShiftingDerivCalcTool::m_traSize {this, "TranslationSize", .1}

private

Definition at line 109 of file ShiftingDerivCalcTool.h.

109{this, "TranslationSize", .1};

◆ m_unshiftedResErrors

Amg::VectorX* Trk::ShiftingDerivCalcTool::m_unshiftedResErrors = nullptr

private

Definition at line 128 of file ShiftingDerivCalcTool.h.

◆ m_unshiftedResiduals

Amg::VectorX* Trk::ShiftingDerivCalcTool::m_unshiftedResiduals = nullptr

private

Definition at line 127 of file ShiftingDerivCalcTool.h.

◆ m_unshiftedTrackChi2

double Trk::ShiftingDerivCalcTool::m_unshiftedTrackChi2 {}

private

Definition at line 142 of file ShiftingDerivCalcTool.h.

142{};

◆ m_unshiftedTrackChi2MeasType

std::unique_ptr<double[]> Trk::ShiftingDerivCalcTool::m_unshiftedTrackChi2MeasType

private

cut on value of track alignment parameter, determined from fit of chi2 vs.

align parameters to a quadratic

Definition at line 143 of file ShiftingDerivCalcTool.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 Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DerivativeMap

◆ DerivativePair

◆ HitDerivative

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ SolveOption

Constructor & Destructor Documentation

◆ ShiftingDerivCalcTool()

◆ ~ShiftingDerivCalcTool()

Member Function Documentation

◆ bestPerigeeTrack()

◆ declareGaudiProperty()

◆ declareProperty()

◆ deleteChi2VAlignParam()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ getAllDerivatives()

◆ getDerivatives()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ scanShifts()

◆ setChi2VAlignParam()

◆ setDerivatives()

◆ setLogStream()

◆ setResidualCovMatrix()

◆ setSolveOption()

◆ setUnshiftedResiduals()

◆ shiftSize()

◆ showStatistics()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_alignModuleTool

◆ m_chi2VAlignParamVec

◆ m_chi2VAlignParamVecMeasType

◆ m_chi2VAlignParamXVec

◆ m_derivative_map

◆ m_detStore

◆ m_doChi2VAlignParamMeasType

◆ m_doFits

◆ m_doResidualPlots

◆ m_evtStore

◆ m_fitter

◆ m_logStream

◆ m_maxIter

◆ m_minIter

◆ m_nFits

◆ m_nIterations

◆ m_ntracksFailAlignParamCut

◆ m_ntracksFailFinalAttempt

◆ m_ntracksFailMaxIter

◆ m_ntracksFailTrackRefit

◆ m_ntracksPassDerivatives

◆ m_ntracksPassGetDeriv

◆ m_ntracksPassGetDerivLastPass

◆ m_ntracksPassGetDerivSecPass

◆ m_ntracksPassInitScan

◆ m_ntracksPassSetUnshiftedRes

◆ m_ntracksProcessed

◆ m_particleHypothesis