Trk::MatrixTool Class Reference

#include <MatrixTool.h>

Inheritance diagram for Trk::MatrixTool:

Collaboration diagram for Trk::MatrixTool:

Public Types
enum	SolveOption {   NONE = 0 , SOLVE = 1 , SOLVE_FAST = 2 , DIRECT_SOLVE = 3 ,   DIRECT_SOLVE_FAST = 4 , DIRECT_SOLVE_CLUSTER = 5 , SOLVE_ROOT = 6 , SOLVE_CLHEP = 7 }

Public Member Functions
	MatrixTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
virtual	~MatrixTool ()
	Virtual destructor.
StatusCode	initialize ()
	initialize
StatusCode	finalize ()
	initialize
StatusCode	allocateMatrix (int nDoF=0)
	allocates memory for big matrix and big vector
void	prepareBinaryFiles (int solveOption)
	reads/writes matrix entries from/to binary files as necessary
void	addFirstDerivatives (AlVec *vector)
	adds first derivative to vector
void	addFirstDerivatives (std::list< int, double > &derivatives)
	adds first derivative to vector for only some entries
void	addFirstDerivative (int irow, double firstderiv)
void	addSecondDerivatives (AlSymMatBase *matrix)
	adds second derivatives to matrix
void	addSecondDerivatives (std::list< std::pair< int, int >, double > &derivatives)
	adds first derivative to vector for only some entries
void	addSecondDerivative (int irow, int icol, double secondderiv)
bool	accumulateFromFiles ()
	accumulates derivates from files.
bool	accumulateFromBinaries ()
	accumulates derivates from binary files
int	solve ()
	solves for alignment parameters
void	storeInTFile (const TString &filename)
	Store Files in a tfile.
bool	accumulateFromTFiles ()
	Store Files in a tfile.
void	printModuleSolution (std::ostream &os, const AlignModule *module, const CLHEP::HepSymMatrix *cov) const
	namespace { class RestoreIOSFlags { public: RestoreIOSFlags (std::ostream &os) : m_os(&os), m_flags(m_os->flags()), m_precision(m_os->precision()) {} ~RestoreIOSFlags() { m_os->flags(m_flags); m_os->precision(m_precision); } private: std::ostream *m_os; std::ios_base::fmtflags m_flags; std::streamsize m_precision; }; }
void	printGlobalSolution (std::ostream &os, const CLHEP::HepSymMatrix *cov)
void	printGlobalSolution (std::ostream &os, const TMatrixDSym *cov)
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
void	addModule (int alignModuleIndex, int nAlignParam)
int	entryNumber (int alignModuleIndex)
void	setNHits (int n)
	set module identifier
int	nHits () const
void	setNTracks (int n)
	set number of tracks
int	nTracks () const
void	setNMeasurements (int n)
	set number of measurements
int	nMeasurements () const
virtual void	setLogStream (std::ostream *os)
	sets the output stream for the logfile

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

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

Protected Attributes
std::ostream *	m_logStream
	logfile output stream
int	m_nHits
int	m_nTracks
int	m_nMeasurements

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
int	solveROOT ()
int	solveCLHEP ()
int	solveLapack ()
int	solveSparseEigen ()
int	solveLocal ()
StatusCode	spuriousRemoval ()
void	postSolvingLapack (AlVec *dChi2, AlSymMat *d2Chi2, AlVec &w, AlMat &z, int size)
void	writeHitmap ()
void	readHitmaps ()
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static int	fillVecMods ()

Private Attributes
ToolHandle< IAlignModuleTool >	m_alignModuleTool
AlSymMatBase *	m_bigmatrix
	matrix to contain second derivative terms to be used for alignment
AlVec *	m_bigvector
	vector to contain first derivative terms to be used for alignment
bool	m_useSparse
	flag to use AlSpaMat for the big matrix (default is AlSymMat)
bool	m_diagonalize
	run diagonalization instead of inversion
double	m_eigenvaluethreshold
	cut on the minimum eigenvalue
int	m_solveOption
	solving option
int	m_modcut
	cut on the weak modes which number is <par_modcut
int	m_minNumHits
	cut on the minimum number of hits per module
int	m_minNumTrks
	cut on the minimum number of tracks per module
float	m_pullcut
	pull cut for the automatic weak mode removal method
float	m_eigenvalueStep
	eigenvalue step for the second pass in the automatic weak mode removal method
float	m_Align_db_step
	corr in the diagonal basis step for the third pass in the auto weak mode removal method
bool	m_calDet
	Compute bigmatrix's determinant ?
bool	m_wSqMatrix
	write a triangular matrix by default (true: square format) ?
bool	m_writeMat
	write big matrix and vector into files ?
bool	m_writeMatTxt
	also write big matrix and vector into txt files ?
bool	m_writeEigenMat
	write eigenvalues and eigenvectors into files ?
bool	m_writeEigenMatTxt
	also write eigenvalues and eigenvectors into txt files ?
bool	m_writeModuleNames
	write module name instead of Identifier to vector file
bool	m_writeHitmap
	write hitmap into file
bool	m_writeHitmapTxt
	write hitmap into text file
bool	m_readHitmaps
	accumulate hitymap from files
bool	m_writeTFile
	write out files to a root file
bool	m_readTFiles
	write out files to a root file
bool	m_runLocal
	Run solving using Local method.
double	m_scale
	scale for big matrix and vector normalization
bool	m_scaleMatrix
	scale matrix by number of hits before solving
double	m_softEigenmodeCut
	add constant to diagonal to effectively cut on weak eigenmodes
bool	m_removeSpurious
	run spurious removal
bool	m_calculateFullCovariance
std::string	m_pathbin
	path binary files (in/out)
std::string	m_pathtxt
	path ascii files (in/out)
std::string	m_prefixName
	prefix string to filenames
std::string	m_tfileName
	prefix string to filenames
std::string	m_scalaMatName
	Scalapack matrix name.
std::string	m_scalaVecName
	Scalapack vector name.
std::vector< std::string >	m_inputMatrixFiles
	input binary files containing matrix terms
std::vector< std::string >	m_inputVectorFiles
	input binary files containing vector terms
std::vector< std::string >	m_inputHitmapFiles
	input binary files containing the hitmaps
std::vector< std::string >	m_inputTFiles
	input binary files containing matrix terms
std::vector< int >	m_activeIndices
	vector of indices which pass the min-hits cut
int	m_aNDoF
	number of active DoF (size of m_activeIndices)
int	m_maxReadErrors
	maximum number of reading TFile errors
bool	m_AlignIBLbutNotPixel
bool	m_AlignPixelbutNotIBL
bool	m_DeactivateSCT_ECA_LastDisk
bool	m_Remove_Pixel_Tx
bool	m_Remove_Pixel_Ty
bool	m_Remove_Pixel_Tz
bool	m_Remove_Pixel_Rx
bool	m_Remove_Pixel_Ry
bool	m_Remove_Pixel_Rz
bool	m_Remove_IBL_Tx
bool	m_Remove_IBL_Ty
bool	m_Remove_IBL_Tz
bool	m_Remove_IBL_Rx
bool	m_Remove_IBL_Ry
bool	m_Remove_IBL_Rz
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
std::map< int, int >	m_alignModuleMap
int	m_nentries

Detailed Description

Definition at line 55 of file MatrixTool.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::MatrixTool::SolveOption

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
SOLVE_ROOT	computation using ROOT
SOLVE_CLHEP	computation using CLHEP

Definition at line 58 of file MatrixTool.h.

                     { 
      NONE                 = 0, 
      SOLVE                = 1, 
      SOLVE_FAST           = 2, 
      DIRECT_SOLVE         = 3, 
      DIRECT_SOLVE_FAST    = 4, 
      DIRECT_SOLVE_CLUSTER = 5, 
      SOLVE_ROOT           = 6, 
      SOLVE_CLHEP          = 7  
    };

Constructor & Destructor Documentation

MatrixTool()

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

Constructor.

Definition at line 58 of file MatrixTool.cxx.

    : IMatrixTool()
    , AthAlgTool(type,name,parent)
    , m_alignModuleTool("Trk::AlignModuleTool/AlignModuleTool")
    , m_bigmatrix(nullptr)
    , m_bigvector(nullptr)
    //m_useSparse
    //m_diagonalize
    //m_eigenvaluethreshold
    //m_solveOption
    //m_modcut
    //m_minNumHits
    //m_minNumTrks
    //m_pullcut
    //m_eigenvalueStep
    //m_Align_db_step
    //m_calDet
    //m_wSqMatrix
    //m_writeMat
    //m_writeMatTxt
    //m_writeEigenMat
    //m_writeEigenMatTxt
    //m_writeModuleNames
    //m_writeHitmap
    //m_writeHitmapTxt
    //m_readHitmaps
    //m_writeTFile
    //m_readTFiles
    //m_runLocal
    , m_scale(-1.)
    //m_scaleMatrix
    //m_softEigenmodeCut
    //m_removeSpurious
    //m_calculateFullCovariance
    //m_pathbin, m_pathtxt, m_prefixName, m_tfileName, m_scalaMatName, m_scalaVecName
    //m_inputMatrixFiles, m_inputVectorFiles, m_inputHitmapFiles, m_inputTFiles
    //m_activeIndices
    , m_aNDoF(0)
    //m_maxReadErrors
    //m_AlignIBLbutNotPixel, m_AlignPixelbutNotIBL
    //m_Remove_Pixel_Tx, m_Remove_Pixel_Ty, m_Remove_Pixel_Tz
    //m_Remove_Pixel_Rx, m_Remove_Pixel_Ry, m_Remove_Pixel_Rz
    //m_Remove_IBL_Tx, m_Remove_IBL_Ty, m_Remove_IBL_Tz
    //m_Remove_IBL_Rx, m_Remove_IBL_Ry, m_Remove_IBL_Rz
  {
    declareInterface<IMatrixTool>(this);
 
    declareProperty("UseSparse",          m_useSparse       = false);
    declareProperty("SolveOption",        m_solveOption     = NONE);
 
    declareProperty("Diagonalize",          m_diagonalize     = true);
    declareProperty("EigenvalueThreshold",  m_eigenvaluethreshold   = 0.);
 
    declareProperty("ModCut",             m_modcut        = 0);
    declareProperty("PullCut",            m_pullcut       = 1.0);
    declareProperty("EigenvalueStep",     m_eigenvalueStep    = 1e3);
    declareProperty("AlignCorrDBStep",    m_Align_db_step     = 10);
    declareProperty("MinNumHitsPerModule",  m_minNumHits      = 0);
    declareProperty("MinNumTrksPerModule",  m_minNumTrks      = 0);
    declareProperty("RunLocalMethod",     m_runLocal      = true);
 
    declareProperty("MatrixDet",          m_calDet          = false);
    declareProperty("WriteSquareMatrix",  m_wSqMatrix       = false);
    declareProperty("WriteMat",           m_writeMat        = true);
    declareProperty("WriteMatTxt",        m_writeMatTxt       = true);
    declareProperty("WriteEigenMat",      m_writeEigenMat     = true);
    declareProperty("WriteEigenMatTxt",   m_writeEigenMatTxt    = true);
    declareProperty("WriteModuleNames",   m_writeModuleNames    = false);
    
    declareProperty("WriteTFile",     m_writeTFile      = false);
    // if True then files will be read from TFiles instead of Binary files
    declareProperty("ReadTFile",    m_readTFiles      = false);
      
 
    std::vector<std::string> defaultMatInput,defaultVecInput,defaultTFile;
    defaultMatInput.emplace_back("matrix.bin");
    defaultVecInput.emplace_back("vector.bin");
    defaultTFile.emplace_back("AlignmentTFile.root");
 
    declareProperty("InputMatrixFiles",   m_inputMatrixFiles    = defaultMatInput);
    declareProperty("InputVectorFiles",   m_inputVectorFiles    = defaultVecInput);
    declareProperty("InputTFiles",        m_inputTFiles     = defaultTFile);
 
    declareProperty("AlignModuleTool",    m_alignModuleTool);
 
    declareProperty("PathBinName",        m_pathbin               = "./");
    declareProperty("PathTxtName",        m_pathtxt               = "./");
    declareProperty("PrefixName",         m_prefixName            = "");
    
    declareProperty("TFileName",          m_tfileName       = "AlignmentTFile.root");
 
    declareProperty("SoftEigenmodeCut",   m_softEigenmodeCut    = 0.);
    declareProperty("RemoveSpurious",     m_removeSpurious    = false);
    declareProperty("CalculateFullCovariance",  m_calculateFullCovariance = true);
 
    // ScaLapack
    declareProperty("ScalapackMatrixName",  m_scalaMatName      = "eigenvectors.bin");
    declareProperty("ScalapackVectorName",  m_scalaVecName      = "eigenvalues.bin");
 
    declareProperty("ScaleMatrix",        m_scaleMatrix       = false);
 
    // Hitmap
    declareProperty("WriteHitmap",        m_writeHitmap       = false);
    declareProperty("WriteHitmapTxt",     m_writeHitmapTxt    = false);
    declareProperty("ReadHitmaps",        m_readHitmaps       = false);
    std::vector<std::string> defaultHitmapInput;
    defaultMatInput.emplace_back("hitmap.bin");
    declareProperty("InputHitmapFiles",   m_inputHitmapFiles    = defaultHitmapInput);
  
    declareProperty("MaxReadErrors",    m_maxReadErrors     = 10);
    //To skip IBL or Pixel Alignment
    declareProperty("AlignIBLbutNotPixel",    m_AlignIBLbutNotPixel = false);
    declareProperty("AlignPixelbutNotIBL",    m_AlignPixelbutNotIBL = false);
 
    //To Skip Solving of SCT ECA Last Disk
    declareProperty("DeactivateSCT_ECA_LastDisk",    m_DeactivateSCT_ECA_LastDisk = false);
    
    //By Pixel DoF
    declareProperty("Remove_Pixel_Tx",    m_Remove_Pixel_Tx = false);
    declareProperty("Remove_Pixel_Ty",    m_Remove_Pixel_Ty = false);
    declareProperty("Remove_Pixel_Tz",    m_Remove_Pixel_Tz = false);
    declareProperty("Remove_Pixel_Rx",    m_Remove_Pixel_Rx = false);
    declareProperty("Remove_Pixel_Ry",    m_Remove_Pixel_Ry = false);
    declareProperty("Remove_Pixel_Rz",    m_Remove_Pixel_Rz = false);
 
    //By IBL DoF
    declareProperty("Remove_IBL_Tx",    m_Remove_IBL_Tx = false);
    declareProperty("Remove_IBL_Ty",    m_Remove_IBL_Ty = false);
    declareProperty("Remove_IBL_Tz",    m_Remove_IBL_Tz = false);
    declareProperty("Remove_IBL_Rx",    m_Remove_IBL_Rx = false);
    declareProperty("Remove_IBL_Ry",    m_Remove_IBL_Ry = false);
    declareProperty("Remove_IBL_Rz",    m_Remove_IBL_Rz = false);
 
  }

~MatrixTool()

MatrixTool::~MatrixTool ( )

virtual

Virtual destructor.

Definition at line 195 of file MatrixTool.cxx.

  {
    delete m_bigmatrix;
    delete m_bigvector;
  }

Member Function Documentation

accumulateFromBinaries()

bool MatrixTool::accumulateFromBinaries

(

)

accumulates derivates from binary files

Definition at line 763 of file MatrixTool.cxx.

  {
    
    
    DataVector<AlignPar>* alignParList = m_alignModuleTool->alignParList1D();
    int nDoF=alignParList->size();
 
    std::map<int,unsigned long long> modIndexMap;
    float dummyVersion(0.);
    double totalscale=0.;
    for (int ivec=0;ivec<(int)m_inputVectorFiles.size();ivec++) {
 
      ATH_MSG_DEBUG("Reading vector "<<ivec<<" from file "<<m_inputVectorFiles[ivec]);
 
      AlVec newVector(nDoF);
      std::map<int,unsigned long long> newModIndexMap;
      newVector.SetPathBin(m_pathbin+m_prefixName);
      newVector.SetPathTxt(m_pathtxt+m_prefixName);
      double scale=0;
      StatusCode sc = newVector.ReadPartial(m_inputVectorFiles[ivec],scale,newModIndexMap,dummyVersion);
      totalscale += scale;
      if (sc==StatusCode::FAILURE) {
        msg(MSG::FATAL)<<"Problem reading vector from "<<m_inputVectorFiles[ivec]<<endmsg;
        return false;
      }
      if (newVector.size()!=m_bigvector->size()) {
        msg(MSG::FATAL) <<"vector wrong size!  newVector size "<<newVector.size()
                        <<", bigvector size "<<m_bigvector->size()<<endmsg;
        return false;
      }
 
      // check modIndexMaps to make sure they are the same
      if (ivec==0)
        modIndexMap = newModIndexMap;
      else if (modIndexMap!=newModIndexMap) {
        msg(MSG::FATAL)<<"module index maps don't agree!"<<endmsg;
        return false;
      }
      if (ivec>0)
        *m_bigvector += newVector;
      else
        *m_bigvector  = newVector;
    }
 
    m_scale = totalscale;
 
    AlSymMat * symBigMatrix=dynamic_cast<AlSymMat*>(m_bigmatrix);
    AlSpaMat * spaBigMatrix=dynamic_cast<AlSpaMat*>(m_bigmatrix);
 
 
    for (int imat=0;imat<(int)m_inputMatrixFiles.size();imat++) {
      ATH_MSG_DEBUG("Reading matrix "<<imat<<" from file "<<m_inputMatrixFiles[imat]);
 
      // create new matrix to read data from current file
      int nDoF=modIndexMap.size();
      bool triang;
      StatusCode sc;
      if (symBigMatrix) {
        AlSymMat newMatrix(nDoF);
        sc = newMatrix.Read(m_inputMatrixFiles[imat],nDoF,triang,dummyVersion);
        if (sc==StatusCode::SUCCESS)
          *symBigMatrix += newMatrix;
      }
      else {
        if (!spaBigMatrix) {
          throw std::logic_error("Unhandled matrix type");
        }
 
        AlSpaMat newMatrix(nDoF);
        sc = newMatrix.Read(m_inputMatrixFiles[imat],nDoF,triang,dummyVersion);
 
        if (sc==StatusCode::SUCCESS) {
          if (imat>0)
            *spaBigMatrix += newMatrix;
          else
            *spaBigMatrix  = newMatrix;
        }
      }
 
      if (sc==StatusCode::FAILURE) {
        msg(MSG::FATAL)<<"problem reading matrix from "<<m_inputMatrixFiles[imat]<<endmsg;
        return false;
      }
 
      if (!m_useSparse && triang==m_wSqMatrix) {
        ATH_MSG_WARNING("matrix not expected format!  Changing m_wSqMatrix to "<<!triang);
        m_wSqMatrix=!triang;
      }
 
    }
 
    // accumulate hitmap from hitmap files
    if(m_readHitmaps)
      readHitmaps();
 
    return true;
  }

accumulateFromFiles()

bool MatrixTool::accumulateFromFiles ( )

virtual

accumulates derivates from files.

Flag decides if it is binary or TFiles

Implements Trk::IMatrixTool.

Definition at line 750 of file MatrixTool.cxx.

  {
    
    if(m_readTFiles){ 
      ATH_MSG_INFO("Info to obtained from from TFiles");
      return accumulateFromTFiles();
    }else{ 
      ATH_MSG_INFO("Info to obtained from from Binary files");
      return accumulateFromBinaries();
    }
  }

accumulateFromTFiles()

bool MatrixTool::accumulateFromTFiles

(

)

Store Files in a tfile.

Definition at line 957 of file MatrixTool.cxx.

  {
    DataVector<AlignPar>* alignParList = m_alignModuleTool->alignParList1D();
    int nDoF=alignParList->size();
    ATH_MSG_DEBUG("OPENING TFILES");
 
    std::map<int,unsigned long long> modIndexMap;
    std::map<int,unsigned long long> DoFMap;
    double totalscale=0.;
 
    AlSymMat * symBigMatrix=dynamic_cast<AlSymMat*>(m_bigmatrix);
    AlSpaMat * spaBigMatrix=dynamic_cast<AlSpaMat*>(m_bigmatrix);
    //TMatrixDSparse *accumMatrix(0);
    AlSpaMat *accumMatrix = nullptr;
    
    const AlignModuleList * moduleList = m_alignModuleTool->alignModules1D();
    int nModules = moduleList->size();
    
    TVectorD TotalHits(nModules);
    TVectorD TotalTracks(nModules);
   
    int numberOfReadErrors = 0; 
   
    struct rusage myusage{};
    int itworked =  getrusage(RUSAGE_SELF,&myusage);
    if(itworked)//note: rusage returns zero if it succeeds!
          ATH_MSG_DEBUG("ItWorked");
 
    long intialMemUse = myusage.ru_maxrss;
 
    for (int ifile = 0; ifile < (int)m_inputTFiles.size(); ifile++) {
      if (numberOfReadErrors > m_maxReadErrors){
        msg(MSG::FATAL) << " number of errors when reading the TFiles already exceed " << m_maxReadErrors << endmsg;
        return false;
      }
   
      ATH_MSG_DEBUG("Reading File number " << ifile << ",  " << m_inputTFiles[ifile]);
      
      itworked =  getrusage(RUSAGE_SELF,&myusage);
      ATH_MSG_DEBUG("Memory usage [MB], total " << myusage.ru_maxrss/1024 << ", increase  " << (myusage.ru_maxrss-intialMemUse)/1024);
       
      TFile* myFile = TFile::Open(m_inputTFiles[ifile].c_str()); 
      
      if ( myFile->IsZombie() || !(myFile->IsOpen()) ) {
        ++numberOfReadErrors;
        ATH_MSG_ERROR( " Problem reading TFile " << m_inputTFiles[ifile] );
        continue;
      }
      
      std::map<int,unsigned long long> newModIndexMap;
      
      TVectorD* myModuleIDs;
      myModuleIDs = (TVectorD*)myFile->Get("ModuleID");
      if( !myModuleIDs ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Modules ID not read!!!");
        continue;
      }
      
      for (int i(0); i<myModuleIDs->GetNrows(); ++i){
        //Coverting back from a double to a unvi signed long long
        double source = (*myModuleIDs)(i);
        uint64_t target;
        memcpy(&target, &source, sizeof(target));
        newModIndexMap[i]=target;
        //std::cout << i<< " " <<target <<std::endl; 
      }
      
      delete myModuleIDs;
      
      std::map<int,unsigned long long> newDoFMap;
      
      TVectorD* myDoFs;
      myDoFs = (TVectorD*)myFile->Get("dof");
      if( !myDoFs ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("DoFs not read!!!");
        continue;
      }
      
      for (int i(0); i<myDoFs->GetNrows(); ++i){
        //Coverting back from a double to a unsigned long long
        double source = (*myDoFs)(i);
        uint64_t target;
        memcpy(&target, &source, sizeof(target));
        newDoFMap[i]=target;
      }
      delete myDoFs;
      
      
      TVectorD* Scale;
      Scale = (TVectorD*)myFile->Get("Scale");
      if( !Scale ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Scale not read!!!");
        continue;
      }
      
      double scale=(*Scale)(0);
      totalscale += scale;
      delete Scale;
      
            
      ATH_MSG_DEBUG("Reading Vector");
      TVectorD* vector = (TVectorD*)myFile->Get("Vector");
      if( !vector ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Vector not read!!!");
        continue;
      }
      
      AlVec* newVector = new AlVec(nDoF);
      newVector->SetPathBin(m_pathbin+m_prefixName);
      newVector->SetPathTxt(m_pathtxt+m_prefixName);
      
      if (newVector->size()  != m_bigvector->size() ) {
         msg(MSG::FATAL) << "vector wrong size!  newVector size " << newVector->size()
                         << ", bigvector size " << m_bigvector->size()<<endmsg;
         delete newVector;
         delete vector;
         return false;
      }
      
      if (m_bigvector->size() != vector->GetNrows() ) {
         msg(MSG::FATAL) << "File vector wrong size!  File Vector size " << vector->GetNrows()
                         << ", bigvector size " << m_bigvector->size()<<endmsg;
         delete newVector;
         delete vector;
         return false;
      }
      
        
      for (int i=0;i<nDoF;i++) {
        (*newVector)[i] = (*vector)(i);
      }
      delete vector;
      
      // check modIndexMaps to make sure they are the same
      if (ifile == 0){
        DoFMap = newDoFMap;
      } else if (DoFMap!=newDoFMap) {
        msg(MSG::FATAL) << "module dofs don't agree!" << endmsg;
        return false;
      }
      
      if (ifile == 0){
         modIndexMap = newModIndexMap;
      } else if (modIndexMap!=newModIndexMap) {
         msg(MSG::FATAL) << "module index maps don't agree!" << endmsg;
         return false;
      }
      
      if (ifile>0){
        *m_bigvector += *newVector;
        delete newVector;  
      } else {
        delete m_bigvector;
        m_bigvector  = newVector;
      }
      
      
      ATH_MSG_DEBUG("Reading matrix ");
      TMatrixDSparse* matrix = (TMatrixDSparse*)myFile->Get("Matrix");
      
      if( !matrix ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Matrix not read!!!");
        continue;
      }
      
      
      if (ifile == 0 ){ 
      
        accumMatrix = new AlSpaMat(nDoF);
        ATH_MSG_DEBUG("Matrix size b4 "<< accumMatrix->ptrMap()->size()  );
        
        //This method is ok for large matrix files... really only access the non zero elements
        for (int ii=0;ii<nDoF;ii++) {
          const TMatrixTSparseRow_const<double> myRow = (*matrix)[ii];
          int i =  myRow.GetRowIndex();
          for (int jj=0;jj<myRow.GetNindex();jj++) {
            int j = (myRow.GetColPtr())[jj];
            const double  myElement= (myRow.GetDataPtr())[jj];
            if (i<j){
              ATH_MSG_DEBUG("i < j " );
              j = i;
              i = (myRow.GetColPtr())[jj];
            }
            (*accumMatrix)[i][j] = myElement;
          }
        }         
        ATH_MSG_DEBUG("Matrix size AF "<< accumMatrix->ptrMap()->size()  );
  
      } else if ( accumMatrix) {        
        ATH_MSG_DEBUG("Matrix size b4 "<< accumMatrix->ptrMap()->size()  );
  
        for (int ii=0;ii<nDoF;ii++) {
          const TMatrixTSparseRow_const<double> myRow = (*matrix)[ii];
          int i =  myRow.GetRowIndex();
          for (int jj=0;jj<myRow.GetNindex();jj++) {
            int j = (myRow.GetColPtr())[jj];
            const double  myElement= (myRow.GetDataPtr())[jj];
            if (i<j){
              ATH_MSG_DEBUG("i < j " );
              j = i;
              i = (myRow.GetColPtr())[jj];
            }
            (*accumMatrix)[i][j] += myElement;
          }
        }
        ATH_MSG_DEBUG("Matrix size AF "<< accumMatrix->ptrMap()->size()  );
 
      } else {
        delete matrix;
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Matrix allocation error!!!");
        continue;
      }
            
      delete matrix;
      
      TVectorD* hits;
      TVectorD* tracks;
      
      ATH_MSG_DEBUG("Reading hitmap ");
      hits = (TVectorD*)myFile->Get("Hits");
      if( !hits ){
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Hitmap 1 not read!!!");
        continue;
      }
      
      tracks = (TVectorD*)myFile->Get("Tracks");
      if( !tracks ){
        delete hits;
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Hitmap 2 not read!!!");
        continue;
      }
      
      if(hits->GetNrows() != TotalHits.GetNrows() ){
        delete hits;
        delete tracks; 
        ++numberOfReadErrors;
        ATH_MSG_ERROR("Hitmap size incorrect!!!");
        continue;
      }
      
      TotalHits   += (*hits);    
      TotalTracks += (*tracks);
      
      delete hits;
      delete tracks;
      
      myFile->Close("R");
      delete myFile;
 
      itworked =  getrusage(RUSAGE_SELF,&myusage);
      ATH_MSG_DEBUG("Memory usage [MB], total " << myusage.ru_maxrss/1024 << ", increase  " << (myusage.ru_maxrss-intialMemUse)/1024);
 
    }
 
 
 
    // create new matrix to read data from current file
    if(accumMatrix){
      if (symBigMatrix) {
        AlSymMat newMatrix(nDoF);
        //This method is ok for small matrix files
        for (int i=0;i<nDoF;i++) {
          for (int j=0;j<=i;j++) {
            newMatrix[i][j] = (*accumMatrix)[i][j];
          }
        }       
 
        *symBigMatrix += newMatrix;
        delete accumMatrix;
      } else if (spaBigMatrix) { 
        ATH_MSG_DEBUG( "should reassign matrix "<< spaBigMatrix->ptrMap()->size() );        
        *spaBigMatrix  += *accumMatrix;     
        ATH_MSG_DEBUG( "??????  "<< spaBigMatrix->ptrMap()->size() );
        delete accumMatrix;
      }
    }
 
    ATH_MSG_DEBUG( "??????  "<< m_bigmatrix->ptrMap()->size() );
 
    AlignModuleList::const_iterator imod     = moduleList->begin();
    AlignModuleList::const_iterator imod_end = moduleList->end();
    int index = 0;
    int totalhits = 0;
    for(; imod != imod_end; ++imod, ++index ) {
          AlignModule * module = *imod;
          module->setNHits((int)TotalHits(index));
          module->setNTracks((int)TotalTracks(index));
          totalhits += (int)TotalHits(index);
    }
 
 
    m_nHits = totalhits;
    m_nTracks = 0;
    m_nMeasurements = 0;
    m_scale = totalscale;
 
    return true;
  }

addFirstDerivative()

void MatrixTool::addFirstDerivative ( int irow, double firstderiv )

virtual

Implements Trk::IMatrixTool.

Definition at line 1609 of file MatrixTool.cxx.

  {
    (*m_bigvector)[irow] += firstderiv;
  }

addFirstDerivatives() [1/2]

void MatrixTool::addFirstDerivatives ( AlVec * vector )

virtual

adds first derivative to vector

Implements Trk::IMatrixTool.

Definition at line 1589 of file MatrixTool.cxx.

  {
     }

addFirstDerivatives() [2/2]

void MatrixTool::addFirstDerivatives ( std::list< int, double > & derivatives )

virtual

adds first derivative to vector for only some entries

Implements Trk::IMatrixTool.

Definition at line 1599 of file MatrixTool.cxx.

  {
     }

addModule()

void IMatrixTool::addModule ( int alignModuleIndex, int nAlignParam )

inlineinherited

Definition at line 116 of file IMatrixTool.h.

{ m_alignModuleMap[alignModuleIndex]=m_nentries; m_nentries += nAlignParam; }

addSecondDerivative()

void MatrixTool::addSecondDerivative ( int irow, int icol, double secondderiv )

virtual

Implements Trk::IMatrixTool.

Definition at line 1615 of file MatrixTool.cxx.

  {
    (*m_bigmatrix)[irow][icol] += secondderiv;
  }

addSecondDerivatives() [1/2]

void MatrixTool::addSecondDerivatives ( AlSymMatBase * matrix )

virtual

adds second derivatives to matrix

Implements Trk::IMatrixTool.

Definition at line 1594 of file MatrixTool.cxx.

  {
     }

addSecondDerivatives() [2/2]

void MatrixTool::addSecondDerivatives ( std::list< std::pair< int, int >, double > & derivatives )

virtual

adds first derivative to vector for only some entries

Implements Trk::IMatrixTool.

Definition at line 1604 of file MatrixTool.cxx.

  {
     }

allocateMatrix()

StatusCode MatrixTool::allocateMatrix ( int nDoF = 0 )

virtual

allocates memory for big matrix and big vector

Implements Trk::IMatrixTool.

Definition at line 232 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("allocating matrix and vector with nDoF = "<<nDoF);
 
    if (nullptr!=m_bigmatrix || nullptr!=m_bigvector)
      ATH_MSG_ERROR("big matrix already allocated!");
 
    // Decide upon the big matrix representation:
    if( m_useSparse )
      m_bigmatrix = new AlSpaMat(nDoF);
    else
      m_bigmatrix = new AlSymMat(nDoF);
 
    m_bigvector       = new AlVec(nDoF);
 
    ATH_MSG_INFO(" After Matrix and Vector allocation");
 
    // set paths for matrix and vector output
    m_bigmatrix->SetPathBin(m_pathbin+m_prefixName);
    m_bigmatrix->SetPathTxt(m_pathtxt+m_prefixName);
    m_bigvector->SetPathBin(m_pathbin+m_prefixName);
    m_bigvector->SetPathTxt(m_pathtxt+m_prefixName);
 
    ATH_MSG_INFO("set path to "<<m_pathbin+m_prefixName);
    return StatusCode::SUCCESS;
  }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

entryNumber()

int IMatrixTool::entryNumber ( int alignModuleIndex )

inlineinherited

Definition at line 118 of file IMatrixTool.h.

{ if ( m_alignModuleMap.find(alignModuleIndex) == m_alignModuleMap.end()) return -1; else return m_alignModuleMap[alignModuleIndex]; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

fillVecMods()

int MatrixTool::fillVecMods ( )

staticprivate

Definition at line 1759 of file MatrixTool.cxx.

  {
    return 0;
  }

finalize()

StatusCode MatrixTool::finalize

(

)

initialize

Definition at line 223 of file MatrixTool.cxx.

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

initialize()

StatusCode MatrixTool::initialize

(

)

initialize

Definition at line 202 of file MatrixTool.cxx.

  {
    ATH_MSG_DEBUG("initialize() of MatrixTool");
 
    // get AlignModuleTool
    if (m_alignModuleTool.retrieve().isSuccess())
      ATH_MSG_INFO("Retrieved " << m_alignModuleTool);
    else{
      msg(MSG::FATAL) << "Could not get " << m_alignModuleTool << endmsg;
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO("Retrieving data from the following files: ");
    for (auto & inputVectorFile : m_inputVectorFiles) {
      ATH_MSG_INFO(m_pathbin+inputVectorFile);
    }    
 
    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 & IMatrixTool::interfaceID ( )

inlinestaticinherited

Retrieve interface ID.

Definition at line 110 of file IMatrixTool.h.

                                                     {
    return IID_TRKALIGNINTERFACES_IMatrixTool;
  }

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

nHits()

int Trk::IMatrixTool::nHits ( ) const

inlineinherited

Definition at line 84 of file IMatrixTool.h.

{ return m_nHits; }

nMeasurements()

int Trk::IMatrixTool::nMeasurements ( ) const

inlineinherited

Definition at line 92 of file IMatrixTool.h.

{ return m_nMeasurements; }

nTracks()

int Trk::IMatrixTool::nTracks ( ) const

inlineinherited

Definition at line 88 of file IMatrixTool.h.

{ return m_nTracks; }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

postSolvingLapack()

void MatrixTool::postSolvingLapack ( AlVec * dChi2, AlSymMat * d2Chi2, AlVec & w, AlMat & z, int size )

private

Definition at line 1958 of file MatrixTool.cxx.

  {
    ATH_MSG_DEBUG("in postSolvinglapack()");
 
    if( z.ncol() != size) {
      msg(MSG::ERROR)<<"Eigenvector matrix has incorrect size : "<<z.ncol()<<" != "<<size<<endmsg;
      return;
    }
 
    if( (int)m_activeIndices.size() != size) {
      msg(MSG::ERROR)<<"Number of active parameters is incorrect : "<<m_activeIndices.size()<<" != "<<size<<endmsg;
      return;
    }
 
    // Compute bigvector in diagonal basis (Vb = Ut * bigvector)
    AlVec D(size);
    D = z*(*dChi2);
 
    if (m_writeEigenMat) {
 
      ATH_MSG_INFO("writing the eigenvectors in a matrix: "<< z.nrow() << "x" << z.ncol());
 
      // Set Path for the z matrix (eigenvector matrix)
      z.SetPathBin(m_pathbin+m_prefixName);
      z.SetPathTxt(m_pathtxt+m_prefixName);
 
      ATH_MSG_INFO("writing the eigenvector matrix: "<< m_scalaMatName);
      ATH_MSG_DEBUG("matrix will be in: "<< m_pathbin+m_prefixName+m_scalaMatName);
 
      StatusCode sc = z.Write("eigenvectors.bin",true); // write the eigenvector matrix
 
      if (sc!=StatusCode::SUCCESS)
        msg(MSG::ERROR)<<"Problem writing eigenvector matrix"<<endmsg;
 
      // Set Path for the w matrix (eigenvalues matrix - diagonal bigmatrix)
      w.SetPathBin(m_pathbin+m_prefixName);
      w.SetPathTxt(m_pathtxt+m_prefixName);
 
      ATH_MSG_INFO("writing the eigenvectors in a vector: "<< w.size());
      ATH_MSG_INFO("writing the eigenvalues vector (diagonal bigmatrix): "<< m_scalaVecName);
      ATH_MSG_DEBUG("vector will be in: "<< m_pathbin+m_prefixName+m_scalaVecName);
 
      sc = w.WriteEigenvalueVec("eigenvalues.bin",true); // write the eigenvalues vecor
 
      if (sc!=StatusCode::SUCCESS)
        msg(MSG::ERROR)<<"Problem writing eigenvector matrix"<<endmsg;
 
      if (m_writeEigenMatTxt) {
        sc = z.Write("eigenvectors.txt", false);
        if (sc!=StatusCode::SUCCESS)
          msg(MSG::ERROR)<<"Problem writing eigenvector matrix to text file"<<endmsg;
        sc = w.WriteEigenvalueVec("eigenvalues.txt", false);
        if (sc!=StatusCode::SUCCESS)
          msg(MSG::ERROR)<<"Problem writing eigenvalue vector to text file"<<endmsg;
      }
 
    }
 
    // Set eigenvalue thresholds
    const double eigenvalue_threshold = 1e-19;
 
    // weak mode removal
    if (m_modcut == -1) {
 
      ATH_MSG_INFO(" Starting the automatic Weak Mode Removal method");
 
      // create a pull vector for the alignment corrections in diagonal basis (db_pulls)
      //int nDoF=m_alignModuleTool->nAlignParameters();
      AlVec* Align_db = new AlVec(size);
      AlVec* Align_error_db = new AlVec(size);
      AlVec* AlignPull = new AlVec(size);
      ATH_MSG_DEBUG("AlignPull vector size is: "<< (*AlignPull).size());
 
      m_modcut = 0;
      bool wm_stop = false;
 
      // -----------------------------------------------------------------------
      // First pass: removing weak modes because of large pull
      // compute alignment pulls for corrections in diagonal basis (db)
      for(int i=0; i<size; i++) {
 
        (*Align_db)[i] = (-D[i]/w[i]);
        (*Align_error_db)[i] = sqrt(1.0/w[i]/m_scale);
 
        if (w[i]<eigenvalue_threshold) {
          ATH_MSG_INFO("  + EigenMode " << i
                         << " removed as eigenvalue lower than the threshold " << eigenvalue_threshold
                         << ": " << w[i]);
          (*AlignPull)[i] = 0.0;
          m_modcut++;
        }
        else
          (*AlignPull)[i] = (*Align_db)[i] / (*Align_error_db)[i];
 
        ATH_MSG_DEBUG(i << ". AlignPar: " << (*Align_db)[i] << " +- " << (*Align_error_db)[i]
                        << " (pull: " << (*AlignPull)[i]  << ") ; w[i]: " << w[i]);
      }
      ATH_MSG_INFO(" +++ Weak Mode removal ++ stop after mode "<< m_modcut << " (First pass)");
      // -----------------------------------------------------------------------
 
      // -----------------------------------------------------------------------
      // Second pass
      // if the error is greater than the correction -> cut this mode
      for(int i=m_modcut; (i<size && !wm_stop); i++) {
 
        // if the error is greater than the correction -> cut this mode
        if (fabs((*AlignPull)[i])<m_pullcut) {
          ATH_MSG_INFO("  + EigenMode " << i
                         << " removed as pull is lower than " << m_pullcut << ": "
                         << (*AlignPull)[i]);
          m_modcut++;
        }
        else
          wm_stop = true;
 
      }
      ATH_MSG_INFO(" +++ Weak Mode removal ++ stop after mode "<< m_modcut << " (Second pass)");
      // -----------------------------------------------------------------------
 
      wm_stop = false;
 
      // ----------------------------------------------------------------------
      // Third pass
      // Check if the next eigenvalues is far away. If it is two orders of
      // magnitude bigger remove also this mode and allow the search
      for(int i=m_modcut; (i<size && !wm_stop); i++) {
 
        // if the next eigenvalues is far away -> cut this mode
        if (m_eigenvalueStep*w[i]<w[i+1]) {
          ATH_MSG_INFO("  + EigenMode " << i
                         << " removed as diff between eigenvalues, " << w[i] << " and " << w[i+1]
                         << ", is greater than " << m_eigenvalueStep);
          m_modcut++;
        }
        else
          wm_stop = true;
 
      }
      ATH_MSG_INFO(" +++ Weak Mode removal ++ stop after mode "<< m_modcut << " (Third pass)");
      // -----------------------------------------------------------------------
 
      wm_stop = false;
 
      // -----------------------------------------------------------------------
      // Fourth pass
      // Check if the next eigenvalues is far away. If it is two orders of
      // magnitude bigger remove also this mode and allow the search
      for(int i=m_modcut; (i<size && !wm_stop); i++) {
 
        // if the next eigenvalues is far away -> cut this mode
        if ( fabs((*Align_db)[i]) > m_Align_db_step*fabs((*Align_db)[i+1]) ) {
          ATH_MSG_INFO("  + EigenMode " << i
                         << " removed as diff between corrections, " << w[i] << " and " << w[i+1]
                         << ", is greater than "
                         << m_Align_db_step);
          m_modcut++;
        }
        else
          wm_stop = true;
 
      }
      ATH_MSG_INFO(" +++ Weak Mode removal ++ stop after mode "<< m_modcut << " (Fourth pass)");
      // -----------------------------------------------------------------------------------------------------
 
      // Free memory and clear the pointer to
      // prevent using invalid memory reference
      delete Align_db;
      delete Align_error_db;
      delete AlignPull;
      Align_db = nullptr;
      Align_error_db = nullptr;
      AlignPull = nullptr;
 
    } // end of if(m_modcut == -1)
 
    // Save some stuff to debug purposes
    /*
      if (m_storeDia) {
      std::string path = m_pathtxt+m_prefixName+"align_dia";
      std::fstream orthogon(path.c_str(), std::ios::out);
      orthogon.setf(std::ios::fixed);
      orthogon.setf(std::ios::showpoint);
      orthogon.precision(6);
 
      orthogon << std::setw(10)
      << "--------------------------------------------------------------------------------"
      << std::endl;
      orthogon << std::setw(10) << " ModeCut = " << m_modcut << std::endl;
      orthogon << std::setw(10)
      << "--------------------------------------------------------------------------------"
      << std::endl;
 
      orthogon << std::setw(10) << "mode"
      << std::setw(20) << "eigenmode"
      << std::setw(20) << "eigenmode error"
      << std::setw(25) << "eigenvalue"
      << std::endl;
 
      for( int m=0; m<size; m++) {
 
      // mode
      orthogon << std::setw(10) << m;
 
      // eigenmode (db)
      if( w[m]>1.0e-15) orthogon << std::setw(20) << -D[m]/w[m];
      else orthogon << std::setw(20) << 0.0;
 
      // error eigenmode (error_db)
      if( w[m]>1.0e-15) orthogon << std::setw(20) << sqrt(1.0/w[m]/m_scale);
      else orthogon << std::setw(20) << 0.0;
 
      // eigenvalues
      orthogon << std::setw(25) << w[m] << std::endl;
      }
      orthogon.close();
      } // end store align_dia.txt
    */
 
    AlVec delta(size);
    AlVec deltafull(size);
    AlVec errSq(size);
 
    // full covariance matrix
    CLHEP::HepSymMatrix * cov = nullptr;
    if(m_calculateFullCovariance)
      // Warning ! The matrix can be huge!
      // This can lead to memory problems
      cov = new CLHEP::HepSymMatrix(size,0);
 
    if(m_logStream)
      *m_logStream<<"/------ The Eigenvalue Spectrum -------"<<std::endl;
 
    for (int i=0;i<size;i++) {
      AlVec thisdelta(size);
      for(int j=0;j<size;j++)
        thisdelta[j] = z[i][j] * (-D[i]/w[i]);
      deltafull += thisdelta;
 
      ATH_MSG_DEBUG("eigenvalue "<<w[i]);
      if( i<m_modcut ) {
        ATH_MSG_INFO("skipping eigenvalue "<<w[i]<<" , modcut is "<<m_modcut);
        if(m_logStream)
           *m_logStream<<"| skipping eigenvalue "<<w[i]<<std::endl;
      }
      else if( w[i] < m_eigenvaluethreshold ) {
        ATH_MSG_INFO("skipping eigenvalue "<<w[i]<<" , cut is "<<m_eigenvaluethreshold);
        if(m_logStream)
           *m_logStream<<"| skipping eigenvalue "<<w[i]<<std::endl;
      }
      else {
        if(m_logStream)
          *m_logStream<<"| "<<w[i]<<std::endl;
 
        delta += thisdelta;
        for(int j=0;j<size;j++) {
          errSq[j] += z[i][j] * z[i][j] / w[i];
          if(m_calculateFullCovariance) {
            for(int k=0;k<=j;k++)
              (*cov)[j][k] += z[i][j] * z[i][k] / w[i];
          }
        }
      }
    }
 
    if(m_logStream)
      *m_logStream<<"\\----- End of Eigenvalue Spectrum -----"<<std::endl;
 
    ATH_MSG_DEBUG("Alignment constants:");
 
    DataVector<AlignPar> * alignParList = m_alignModuleTool->alignParList1D();
 
    // compute alignment corrections (translations in mm and rotations in rad) and their variances
    for(int i=0; i<size; i++) {
 
      double param = delta[i];
      double err = sqrt(2.*std::fabs(errSq[i]));
 
      int idof = m_activeIndices[i];
      AlignPar * alignPar=(*alignParList)[idof];
 
      // undo the sigma scaling
      double sigma = alignPar->sigma();
 
      param *= sigma;
      err *= sigma;
 
      // undo normalization scaling of error
      if(m_scaleMatrix && m_scale>0.)
        err /= sqrt(m_scale);
 
      ATH_MSG_DEBUG(i <<" : "<< param << " +/- "<< err);
      ATH_MSG_DEBUG("cov("<<i<<")="<<errSq[i]<<", sigma: "<<sigma);
      ATH_MSG_DEBUG("init par: "<<alignPar->initPar());
      alignPar->setPar(param, err);
      ATH_MSG_DEBUG("set param to "<<param<<" for alignPar "<<alignPar);
      ATH_MSG_DEBUG(*(*alignParList)[idof]);
    }
 
    if(m_logStream) {
      printGlobalSolution(*m_logStream, cov);
 
      // norm of first derivative
      double norm1st = dChi2->norm();
      if(m_scaleMatrix && m_scale>0.) // undo normalization scaling
        norm1st *= m_scale;
      *m_logStream<<"norm of first derivative :            "<<norm1st<<std::endl;
 
      if(d2Chi2) {
        // distance to solution
        double dist = ( (*d2Chi2) * deltafull + (*dChi2) ).norm();
        if(m_scaleMatrix && m_scale>0.) // undo normalization scaling
          dist *= m_scale;
        *m_logStream<<"distance to solution :                "<<dist<<std::endl;
 
        // calculate chi2 of the alignment change
        double chi2 = delta * (*d2Chi2) * delta * .5;
        if(m_scaleMatrix && m_scale>0.) // undo normalization scaling
          chi2 *= m_scale;
        *m_logStream<<"delta(chi2) of the alignment change : "<<chi2<<" / "<<size<<std::endl;
      }
    }
 
    delete cov;
  }

prepareBinaryFiles()

void MatrixTool::prepareBinaryFiles ( int solveOption )

virtual

reads/writes matrix entries from/to binary files as necessary

Implements Trk::IMatrixTool.

Definition at line 260 of file MatrixTool.cxx.

  {
     }

printGlobalSolution() [1/2]

void MatrixTool::printGlobalSolution	(	std::ostream &	os,
		const CLHEP::HepSymMatrix *	cov )

Definition at line 1621 of file MatrixTool.cxx.

  {
    const AlignModuleList * alignModules = m_alignModuleTool->alignModules1D();
 
    AlignModuleList::const_iterator imod     = alignModules->begin();
    AlignModuleList::const_iterator imod_end = alignModules->end();
    for( ; imod!=imod_end; ++imod) {
      AlignModule * module = *imod;
 
      DataVector<AlignPar> * alignPars = m_alignModuleTool->getAlignPars(module);
      int thisNDoF = alignPars->size();
 
      // fill local covariance matrix
      CLHEP::HepSymMatrix * covsub = nullptr;
      if(cov && module->nHits() >= m_minNumHits && module->nTracks() >= m_minNumTrks) {
        covsub = new CLHEP::HepSymMatrix(thisNDoF,0);
        for (int i=0;i<thisNDoF;++i) {
          int ipar = alignPars->at(i)->index();
          double sigma_i = alignPars->at(i)->sigma();
 
          std::vector<int>::iterator itActive = std::find(m_activeIndices.begin(),m_activeIndices.end(),ipar);
          if( itActive == m_activeIndices.end() )
            continue;
          int iActive = std::distance(m_activeIndices.begin(),itActive);
 
          for (int j=0;j<=i;++j) {
            int jpar = alignPars->at(j)->index();
            double sigma_j = alignPars->at(j)->sigma();
 
            std::vector<int>::iterator jtActive = std::find(m_activeIndices.begin(),m_activeIndices.end(),jpar);
            if( jtActive == m_activeIndices.end() )
              continue;
            int jActive = std::distance(m_activeIndices.begin(),jtActive);
 
            (*covsub)[i][j] = (*cov)[iActive][jActive] * sigma_i * sigma_j;
          }
        }
      }
 
      printModuleSolution(os,module,covsub);
 
      delete covsub;
    }
    os << "--------------------------------------------------------------------------------" << std::endl;
  }

printGlobalSolution() [2/2]

void MatrixTool::printGlobalSolution	(	std::ostream &	os,
		const TMatrixDSym *	cov )

Definition at line 1668 of file MatrixTool.cxx.

  {
    CLHEP::HepSymMatrix * cov = nullptr;
    if(cov0) {
      int nsize = cov0->GetNrows();
      cov = new CLHEP::HepSymMatrix(nsize,0);
 
      for(int i=0; i<nsize; i++)
        for(int j=0; j<=i; j++)
          (*cov)[i][j] = (*cov0)[i][j];
    }
 
    printGlobalSolution(os,cov);
 
    delete cov;
  }

printModuleSolution()

void MatrixTool::printModuleSolution	(	std::ostream &	os,
		const AlignModule *	module,
		const CLHEP::HepSymMatrix *	cov ) const

namespace { class RestoreIOSFlags { public: RestoreIOSFlags (std::ostream &os) : m_os(&os), m_flags(m_os->flags()), m_precision(m_os->precision()) {} ~RestoreIOSFlags() { m_os->flags(m_flags); m_os->precision(m_precision); } private: std::ostream *m_os; std::ios_base::fmtflags m_flags; std::streamsize m_precision; }; }

Definition at line 1706 of file MatrixTool.cxx.

  {
    boost::io::ios_all_saver  ias( os ); //save the stream state    
 
    os << "--------------------------------------------------------------------------------" << std::endl;
    os << "Alignment parameters for module: " << module->name() << std::endl;
    os << "Number of tracks passing: " << module->nTracks() << std::endl;
    if(m_minNumHits>0 && module->nHits()<m_minNumHits) {
      os << "Number of hits too small: "<<module->nHits()<<" < "<<m_minNumHits<<"  Skipping the module"<<std::endl;
      return;
    }
    if(m_minNumTrks>0 && module->nTracks()<m_minNumTrks) {
      os << "Number of tracks too small: "<<module->nTracks()<<" < "<<m_minNumTrks<<"  Skipping the module"<<std::endl;
      return;
    }
    os << "Number of hits seen:      " << module->nHits() << std::endl;
    os << "Number of tracks seen:    " << module->nTracks() << std::endl;
 
    DataVector<AlignPar> * alignPars = m_alignModuleTool->getAlignPars(module);
    int thisNDoF = alignPars->size();
 
    if(alignPars->empty())
      os << "No active parameters" << std::endl;
    else
    {
      //RestoreIOSFlags restore_flags(os);
 
      os.unsetf(std::ios_base::floatfield);
      os << std::setiosflags(std::ios_base::left) << std::setprecision(5);
 
      // output alignment parameters and errors
      DataVector<AlignPar>::const_iterator ipar     = alignPars->begin();
      DataVector<AlignPar>::const_iterator ipar_end = alignPars->end();
      for ( ; ipar != ipar_end; ++ipar) {
        const AlignPar * par = *ipar;
        os << std::setw(10) << par->dumpType()
           << std::setw(12) << par->par() << " +/- " << std::setw(12) << par->err()
           << std::endl;
      }
 
      if(cov) {
        // calculate local correlation matrix
        CLHEP::HepSymMatrix corrsub(thisNDoF,0);
        for(int irow=0; irow<thisNDoF; ++irow)
          for(int icol=0; icol<=irow; ++icol)
            corrsub[irow][icol] = (*cov)[irow][icol] / sqrt((*cov)[irow][irow] * (*cov)[icol][icol]);
        os << "Local correlation matrix: " << corrsub << std::flush;
      }
    }
    ias.restore(); //restore the stream state
  }

readHitmaps()

void MatrixTool::readHitmaps ( )

private

Definition at line 2455 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("read hitmaps from files");
 
    const AlignModuleList * moduleList = m_alignModuleTool->alignModules1D();
    int nModules = moduleList->size();
 
    AlMat hitmap(nModules,2);
    int nFiles = (int)m_inputHitmapFiles.size();
    for(int imap=0;imap<nFiles; imap++) {
      AlMat nextmap(nModules,2);
 
      ATH_MSG_INFO("Reading hitmap "<<imap<<" from file "<<m_inputHitmapFiles[imap]);
 
      if(nextmap.ReadScalaPack(m_inputHitmapFiles[imap]).isFailure()) {
        ATH_MSG_WARNING("Problem reading hitmap from \'"<<m_inputHitmapFiles[imap]<<"\'. Skipping.");
        continue;
      }
 
      if(nextmap.nrow()!=nModules || nextmap.ncol()!=2) {
        ATH_MSG_WARNING("Matrix in file \'"<<m_inputHitmapFiles[imap]<<"\' has wrong size ("
            <<nextmap.nrow()<<" x "<<nextmap.ncol()<<"), should be ("<<nModules<<" x 2). Skipping.");
        continue;
      }
 
      hitmap += nextmap;
    }
 
    AlignModuleList::const_iterator imod     = moduleList->begin();
    AlignModuleList::const_iterator imod_end = moduleList->end();
    int index = 0;
    int totalhits = 0;
    for(; imod != imod_end; ++imod) {
      AlignModule * module = *imod;
      //if ((int)hitmap[index][0]!=(int)module->identify().get_identifier32().get_compact()) ATH_MSG_ERROR("bad module identifier");
      //module->setIdentifier((Identifier)hitmap[index][0]);
      module->setNHits((int)hitmap[index][0]);
      module->setNTracks((int)hitmap[index][1]);
      totalhits += (int)hitmap[index][0];
      index++;
    }
 
    m_nHits = totalhits;
    m_nTracks = 0;
    m_nMeasurements = 0;
 
    ATH_MSG_INFO("Hitmap accumulated from "<<nFiles<<" files with total of "<<totalhits<<" hits.");
  }

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setLogStream()

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

inlinevirtualinherited

sets the output stream for the logfile

Definition at line 95 of file IMatrixTool.h.

{ m_logStream = os; }

setNHits()

void Trk::IMatrixTool::setNHits ( int n )

inlineinherited

set module identifier

set number of hits

Definition at line 83 of file IMatrixTool.h.

{ m_nHits = n; }

setNMeasurements()

void Trk::IMatrixTool::setNMeasurements ( int n )

inlineinherited

set number of measurements

Definition at line 91 of file IMatrixTool.h.

{ m_nMeasurements = n; }

setNTracks()

void Trk::IMatrixTool::setNTracks ( int n )

inlineinherited

set number of tracks

Definition at line 87 of file IMatrixTool.h.

{ m_nTracks = n; }

solve()

int MatrixTool::solve ( )

virtual

solves for alignment parameters

Implements Trk::IMatrixTool.

Definition at line 1268 of file MatrixTool.cxx.

  {
    // ============
    // solve
    // ============
    ATH_MSG_DEBUG("in MatrixTool::solve()");    
 
    // set normalization scale to number of hits for now
    if(m_scale<0)
      m_scale = m_nHits;
 
    //-------------------------------------------------------
    // write matrix and vector to file
    if (m_writeMat) {
      // version has to be 2 to for reading matrices and vectors back in to work properly
      double dummyVersion(2.);
 
      // make map of matrix entry to module index (set by geometry manager tool)
      std::map<int,unsigned long long> modIndexMap;
      std::map<int,std::string>        modNameMap;
      DataVector<AlignPar>* alignPars = m_alignModuleTool->alignParList1D();
      for (int i=0;i<(int)alignPars->size();i++) {
        modIndexMap[i]=(*alignPars)[i]->alignModule()->identify().get_compact();
        modNameMap [i]=(*alignPars)[i]->alignModule()->name();
      }
 
      // binary files
      ATH_MSG_DEBUG("writing binary files");
      StatusCode sc1 = m_bigmatrix->Write("matrix.bin",true,m_wSqMatrix,m_scale,dummyVersion);
      StatusCode sc2 = m_bigvector->WritePartial("vector.bin",true,m_scale,modIndexMap,dummyVersion);
      if (!sc1.isSuccess() || !sc2.isSuccess()) {
        msg(MSG::ERROR)<<"problem writing matrix or vector"<<endmsg;
        return -1;
      }
 
      if (m_writeMatTxt) {
 
        // text files
        ATH_MSG_DEBUG("writing text files");
        sc1 = m_bigmatrix->Write("matrix.txt",false,m_wSqMatrix,m_scale,dummyVersion);
        sc2 = m_writeModuleNames ? 
          m_bigvector->WritePartial("vector.txt",false,m_scale,modNameMap,dummyVersion) :
          m_bigvector->WritePartial("vector.txt",false,m_scale,modIndexMap,dummyVersion);
  
        if (!sc1.isSuccess() || !sc2.isSuccess()) {
          msg(MSG::ERROR)<<"problem writing matrix or vector"<<endmsg;
          return -1;
        }
      }
 
      ATH_MSG_DEBUG("matrix and vector written to: "<<m_pathbin+m_prefixName<<"matrix.bin (.txt) and "<<m_pathbin+m_prefixName<<"vector.bin (.txt)");
    }
 
    //-------------------------------------------------------
    // write hitmap to file
    if (m_writeHitmap)
      writeHitmap();
 
    if(m_writeTFile)
      storeInTFile(m_pathbin+m_prefixName+m_tfileName);
 
 
    if(!m_runLocal && m_solveOption==0) {
      ATH_MSG_DEBUG("No solving requested.");
      return 1;
    }
 
    //-------------------------------------------------------
    // rescale the vector and the matrix according to sigmas
    // and apply soft mode cut
 
    ATH_MSG_DEBUG("rescaling the matrix/vector and applying the soft-mode-cut");
 
    DataVector<AlignPar>* alignParList = m_alignModuleTool->alignParList1D();
    int nDoF = alignParList->size();
 
 
    const AlSymMat * chkMatrix = dynamic_cast<const AlSymMat*>(m_bigmatrix);
    if(chkMatrix){
      // Method when using the dense matrix
      for (int i=0;i<nDoF;i++) {
        // scale the vector
        double sigma_i = (*alignParList)[i]->sigma();
        double softCut = 2 * pow( (*alignParList)[i]->softCut() , -2 );
        (*m_bigvector)[i] *= sigma_i;
  
        for (int j=0;j<=i;j++) {
          // scale the matrix
          if ((*chkMatrix)[i][j] != 0.) {
            double sigma_j = (*alignParList)[j]->sigma();
            (*m_bigmatrix)[i][j] *= sigma_i * sigma_j;
          }
          // apply soft-mode-cut
          if (i==j && m_softEigenmodeCut>0.){
            (*m_bigmatrix)[i][j] += m_softEigenmodeCut * softCut;
         
          }
  
          // set first and second derivatives on AlignPar
          if (i==j) {
            (*alignParList)[i]->setFirstDeriv((*m_bigvector)[i]/sigma_i);
            (*alignParList)[i]->setSecndDeriv((*m_bigmatrix)[i][i]/sigma_i/sigma_i);
          }
        }
      }    
    } else {
      // Method when using the sparse matrix
      for (const datamap::value_type& p : *m_bigmatrix->ptrMap()) {
        int i = p.first.first;
        int j = p.first.second;
  
        // Scale matrix
        double sigma_i = (*alignParList)[i]->sigma();
        double sigma_j = (*alignParList)[j]->sigma();
        
        (*m_bigmatrix)[i][j] *= sigma_i * sigma_j;
  
      }
  
  
      for (int i=0;i<nDoF;i++) {
        // scale the vector
        double sigma_i = (*alignParList)[i]->sigma();
        (*m_bigvector)[i] *= sigma_i;
        if (m_softEigenmodeCut >0. ){
          double softCut = 2 * pow( (*alignParList)[i]->softCut() , -2 );
          (*m_bigmatrix)[i][i] += m_softEigenmodeCut * softCut;
          ATH_MSG_DEBUG( "DOF "<< i <<" Nhits "<< (*alignParList)[i]->alignModule()->nHits() << " soft-mode-cut "<< (*alignParList)[i]->softCut() <<" -> " << m_softEigenmodeCut * softCut  << " sigma_i "<< sigma_i << " Matrix: " << (*m_bigmatrix)[i][i] << " Vector: " << (*m_bigvector)[i]);
        }
        (*alignParList)[i]->setFirstDeriv((*m_bigvector)[i]/sigma_i);
        (*alignParList)[i]->setSecndDeriv((*m_bigmatrix)[i][i]/sigma_i/sigma_i);
      }
    }
    
    unsigned long long OldPixelIdentifier = 37769216; //Identifier for the Pixel Detector
    unsigned long long IBLIdentifier      = 33574912; //Identifier for the Pixel Detector
    
    unsigned long long SCT_ECA_8_Identifier = 218116096; //Identifier for the SCT ECA Last Disk
    std::string SCT_ECA_8_Name = "SCT/EndcapA/Disk_8";
 
    
 
    ATH_MSG_INFO("rescaling done");
    ATH_MSG_INFO("Javi: Printing (*alignParList)[i]->alignModule()->identify32()");
 
    // select modules with non-zero tracks
    for(int i=0;i<nDoF;i++)
      {
        ATH_MSG_DEBUG(i);
        ATH_MSG_DEBUG((*alignParList)[i]->alignModule()->identify32());
        ATH_MSG_DEBUG((*alignParList)[i]->alignModule());
        ATH_MSG_DEBUG((*alignParList)[i]->alignModule()->name());
        ATH_MSG_DEBUG((*alignParList)[i]->paramType());
 
        //Skip solving for Pixel or IBL:
    const auto & theParameterList = *alignParList;      
    const auto & thisIdentifier = theParameterList[i]->alignModule()->identify32();
    const auto & thisName       = theParameterList[i]->alignModule()->name();
    const auto & thisParameterType = theParameterList[i]->paramType();
    const bool oldPixel = (thisIdentifier == OldPixelIdentifier);
    const bool ibl = (thisIdentifier == IBLIdentifier);
    const bool SCTECA8   = (thisIdentifier == SCT_ECA_8_Identifier);
    const bool SCTECA8_n = (thisName.find(SCT_ECA_8_Name)!= std::string::npos);
 
    if (m_DeactivateSCT_ECA_LastDisk){ 
      if (SCTECA8)
        {ATH_MSG_INFO( "SCT ECA Last Disk DoF have been skipped in the solving because DeactivateSCT_ECA_LastDisk is set to True");
          continue;}
      if (SCTECA8_n)
        {ATH_MSG_INFO( "SCT ECA Last Disk DoF have been skipped in the solving because DeactivateSCT_ECA_LastDisk is set to True");
          continue;}
    }
 
    if (m_AlignIBLbutNotPixel) //If m_AlignIBLbutNotPixel is set to True, Pixel will be skipped in the solving.
      if  (oldPixel)  
        {ATH_MSG_INFO( "Pixel DoF have been skipped in the solving because AlignIBLbutNotPixel is set to True");
          continue;} 
    
    if (m_AlignPixelbutNotIBL) //If m_AlignPixelbutNotIBL is set to True, IBL will be skipped in the solving.
      if  (ibl)  
        {ATH_MSG_INFO( "IBL DoF have been skipped in the solving because AlignPixelbutNotIBL is set to True");
          continue;}
 
        //For specific DoF: (*alignParList)[i]->paramType() = 0,1,2,3,4,5,6 for Tx,Ty,Tz,Rx,Ry,Rz,Bx
    //Pixel Dofs:
    if (m_Remove_Pixel_Tx) //If m_Remove_Pixel_Tx is set to True, Pixel Tx will be skipped in the solving.
      if  ( oldPixel and (thisParameterType == 0))  
        {ATH_MSG_INFO( "Pixel Tx DoF has been skipped in the solving because Remove_Pixel_Tx is set to True");
          continue;} 
        
    if (m_Remove_Pixel_Ty) //If m_Remove_Pixel_Ty is set to True, Pixel Ty will be skipped in the solving.
      if  ( oldPixel and (thisParameterType == 1))  
        {ATH_MSG_INFO( "Pixel Ty DoF has been skipped in the solving because Remove_Pixel_Ty is set to True");
          continue;} 
        
    if (m_Remove_Pixel_Tz) //If m_Remove_Pixel_Tz is set to True, Pixel Tz will be skipped in the solving.
      if  (oldPixel and (thisParameterType == 2))  
        {ATH_MSG_INFO( "Pixel Tz DoF has been skipped in the solving because Remove_Pixel_Tz is set to True");
          continue;} 
        
    if (m_Remove_Pixel_Rx) //If m_Remove_Pixel_Rx is set to True, Pixel Rx will be skipped in the solving.
      if  (oldPixel and (thisParameterType == 3))
        {ATH_MSG_INFO( "Pixel Rx DoF has been skipped in the solving because Remove_Pixel_Rx is set to True");
          continue;} 
        
    if (m_Remove_Pixel_Ry) //If m_Remove_Pixel_Ry is set to True, Pixel Ry will be skipped in the solving.
      if  (oldPixel and (thisParameterType == 4)) 
        {ATH_MSG_INFO( "Pixel Ry DoF has been skipped in the solving because Remove_Pixel_Ry is set to True");
          continue;} 
        
    if (m_Remove_Pixel_Rz) //If m_Remove_Pixel_Rz is set to True, Pixel Rz will be skipped in the solving.
      if  (oldPixel and (thisParameterType == 5)) 
        {ATH_MSG_INFO( "Pixel Rz DoF has been skipped in the solving because Remove_Pixel_Rz is set to True");
          continue;} 
        
        //IBL Dofs:
    if (m_Remove_IBL_Tx) //If m_Remove_IBL_Tx is set to True, IBL Tx will be skipped in the solving.
      if  (ibl and (thisParameterType == 0))  
        {ATH_MSG_INFO( "IBL Tx DoF has been skipped in the solving because Remove_IBL_Tx is set to True");
          continue;} 
        
    if (m_Remove_IBL_Ty) //If m_Remove_IBL_Ty is set to True, IBL Ty will be skipped in the solving.
      if  (ibl and (thisParameterType == 1)) 
        {ATH_MSG_INFO( "IBL Ty DoF has been skipped in the solving because Remove_IBL_Ty is set to True");
          continue;} 
        
    if (m_Remove_IBL_Tz) //If m_Remove_IBL_Tz is set to True, IBL Tz will be skipped in the solving.
      if  (ibl and (thisParameterType == 2))  
        {ATH_MSG_INFO( "IBL Tz DoF has been skipped in the solving because Remove_IBL_Tz is set to True");
          continue;} 
        
    if (m_Remove_IBL_Rx) //If m_Remove_IBL_Rx is set to True, IBL Rx will be skipped in the solving.
      if  (ibl and (thisParameterType == 3))
        {ATH_MSG_INFO( "IBL Rx DoF has been skipped in the solving because Remove_IBL_Rx is set to True");
          continue;} 
        
    if (m_Remove_IBL_Ry) //If m_Remove_IBL_Ry is set to True, IBL Ry will be skipped in the solving.
      if  (ibl and (thisParameterType == 4))  
        {ATH_MSG_INFO( "IBL Ry DoF has been skipped in the solving because Remove_IBL_Ry is set to True");
          continue;} 
 
    if (m_Remove_IBL_Rz) //If m_Remove_IBL_Rz is set to True, IBL Rz will be skipped in the solving.
      if  (ibl and (thisParameterType == 5))  
        {ATH_MSG_INFO( "IBL Rz DoF has been skipped in the solving because Remove_IBL_Rz is set to True");
          continue;}
 
    if(theParameterList[i]->alignModule()->nHits() >= m_minNumHits && theParameterList[i]->alignModule()->nTracks() >= m_minNumTrks)
      m_activeIndices.push_back(i);
      }
    m_aNDoF = m_activeIndices.size();
    ATH_MSG_DEBUG("aNDoF/nDoF: "<<m_aNDoF<<"/"<<nDoF);
 
    // --------------------
    // now do the SOLVING
    // --------------------
 
    int info = 0;
 
    // first Local solving
    if (m_runLocal)
      info = solveLocal();
 
    // remove spurious modules and resize
    if (m_removeSpurious) {
 
      ATH_MSG_INFO("Spurious removal not implemented at the moment.");
/*      if (StatusCode::SUCCESS != spuriousRemoval()) {
        ATH_MSG_ERROR("Problem while trying to remove spurious. Stopping solving");
        return -1;
      }
 
      // if nDoF=0, bad job...
      int NDoF = m_alignModuleTool->nAlignParameters();
      if(NDoF==0) {
        ATH_MSG_WARNING("Removal removed everything: NDoF=" << NDoF << " !!!");
        return 1;
      }
      ATH_MSG_DEBUG("NDoF: " << NDoF);
*/
    }
 
    // --------------------
    // now Global solving
    switch(m_solveOption) {
 
      case NONE:
        ATH_MSG_DEBUG("No global solving requested.");
        break;
 
      case SOLVE_ROOT:
        info = solveROOT();
        break;
 
      case SOLVE_CLHEP:
        info = solveCLHEP();
        break;
 
      case SOLVE:
      case DIRECT_SOLVE:
      case DIRECT_SOLVE_CLUSTER:
        info = solveLapack();
        break;
 
      case SOLVE_FAST:
      case DIRECT_SOLVE_FAST:
        info = solveSparseEigen();
        break;
 
      default:
        ATH_MSG_INFO("Unknown solving option.");
        info = 0;
        break;
    }
 
    ATH_MSG_INFO("Return value from solving: "<<info);
 
    return info;
  }

solveCLHEP()

int MatrixTool::solveCLHEP ( )

private

Definition at line 391 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("solving Global using CLHEP");
    if(m_logStream) {
      *m_logStream<<"*************************************************************"<<std::endl;
      *m_logStream<<"**************  solving using Global method  ****************"<<std::endl;
      *m_logStream<<"**************          using CLHEP          ****************"<<std::endl;
      *m_logStream<<"*************************************************************"<<std::endl;
    }
 
    // start measuring time
    clock_t starttime = clock();
 
    DataVector<AlignPar> * alignParList = m_alignModuleTool->alignParList1D();
    //const AlignModuleList* alignModules = m_alignModuleTool->alignModules1D();
    for (int i=0;i<(int)alignParList->size();i++)
      ATH_MSG_DEBUG("ap["<<i<<"]="<<(*alignParList)[i]);
 
    int nDoF = m_alignModuleTool->nAlignParameters();
 
    // some debugging output
    if (msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG)<<"dumping matrix and vector to screen"<<endmsg;
      for (int i=0;i<nDoF;i++)
        for (int j=0;j<nDoF;j++)
        //if (std::fabs((*m_bigmatrix)[i][j])>.0001)
          msg(MSG::DEBUG)<<i<<", "<<j<<" : "<<(*m_bigmatrix)[i][j] <<endmsg;
 
      for (int i=0;i<nDoF;i++)
        msg(MSG::DEBUG)<<i <<" : "<<(*m_bigvector)[i]<<endmsg;
    }
 
    // get rescaled first and second derivatives
    CLHEP::HepSymMatrix * d2Chi2 = new CLHEP::HepSymMatrix(m_aNDoF,0);
    CLHEP::HepVector    * dChi2  = new CLHEP::HepVector(m_aNDoF,0);
    for (int iActive=0;iActive<m_aNDoF;iActive++) {
      int i = m_activeIndices[iActive];
      (*dChi2)[iActive] = (*m_bigvector)[i];
      for (int jActive=0;jActive<m_aNDoF;jActive++) {
        int j = m_activeIndices[jActive];
        (*d2Chi2)[iActive][jActive] = (*m_bigmatrix)[i][j];
      }
    }
 
    ATH_MSG_DEBUG("First derivatives:" << (*dChi2));
    ATH_MSG_DEBUG("Second derivatives:" << (*d2Chi2));
 
    CLHEP::HepSymMatrix cov(m_aNDoF,0);
    CLHEP::HepVector delta(m_aNDoF,0);
    CLHEP::HepVector deltafull(m_aNDoF,0);
 
    bool status=true;
    int ierr(0);
    if(!m_diagonalize) {
      // ==========================================================
      //  Run Matrix Inversion
      ATH_MSG_INFO("Running matrix inversion");
      if(m_logStream)
        *m_logStream<<"Running matrix inversion"<<std::endl;
 
      cov = *d2Chi2;
      cov.invert(ierr);
      if(ierr>0)
        msg(MSG::ERROR)<<"CLHEP inversion status flag = "<<ierr<<endmsg;
      else
        ATH_MSG_INFO("CLHEP inversion OK");
      if(m_logStream)
        *m_logStream<<"CLHEP inversion status flag = "<<ierr<<std::endl;
 
      // calculate corrections
      delta = cov * (*dChi2);
 
      // the covariance matrix is actually defined as 2 * d2Chi2^-1
      ATH_MSG_DEBUG("Result: "<<delta);
      ATH_MSG_DEBUG("cov: "<<cov*2);
 
      // -----------------------
      // calculate also for matrix and vector multiplied by factor 0.5
      // this should make no difference if everything is correct but
      // it can go wrong if insensitive DoF is included
      CLHEP::HepSymMatrix cov2 = *d2Chi2 * .5;
      // invert the matrix
      int ierr2 = 0;
      cov2.invert(ierr2);
      if(ierr2>0)
        msg(MSG::WARNING)<<"Second CLHEP inversion status flag = "<<ierr2<<endmsg;
 
      CLHEP::HepVector delta2 = cov2 * (*dChi2) * .5;
      for (int i=0;i<delta.num_row(); ++i)
        if ( fabs((delta[i] - delta2[i])/delta[i]) > 1e-5 ) {
          msg(MSG::WARNING)<<"Something's wrong with the matrix inversion: delta["<<i<<"] = "<<delta[i]<<"    delta2["<<i<<"] = "<<delta2[i]<<endmsg;
          status=false;
          break;
        }
 
      if(m_logStream && (ierr2>0 || !status)) {
        *m_logStream<<"CLHEP inversion status flag for halfed matrix = "<<ierr2<<std::endl;
        *m_logStream<<"Matrix inversion check failed"<<std::endl;
        *m_logStream<<std::endl;
      }
      // -- end of check of matrix inversion
    }
    else {
      // ==========================================================
      // Run Diagonalization
      ATH_MSG_INFO("Running diagonalization");
      if(m_logStream)
        *m_logStream<<"Running diagonalization"<<std::endl;
 
      CLHEP::HepSymMatrix D = *d2Chi2;
      CLHEP::HepMatrix U = CLHEP::diagonalize( &D );
 
      ATH_MSG_INFO("Diagonalization done");
      //sold = U*sdiag*U.T.
 
      // reorder eigenvalues ascending
      // eigenvectors need to be reordered consistently
      ATH_MSG_DEBUG(" Reordering eigenvalues ascending ");
      for (int i=0; i<m_aNDoF-1; i++)
        for (int j=i+1; j<m_aNDoF; j++)
          if(D[j][j] < D[i][i]) {
            // swap eigenvalues
            double ei = D[i][i];
            D[i][i] = D[j][j];
            D[j][j] = ei;
            // swap eigenvectors
            for(int k=0;k<m_aNDoF; k++) {
              double ev = U[k][i];
              U[k][i] = U[k][j];
              U[k][j] = ev;
            }
          }
 
      // how do I now get the eigenvalues? this cannot be the most
      // efficient way ...  CLHEP::HepSymMatrix D = d2Chi2->similarityT( U );
      CLHEP::HepVector eigenvector(m_aNDoF);
 
      if(m_logStream)
        *m_logStream<<"/------ The Eigenvalue Spectrum -------"<<std::endl;
 
      ATH_MSG_DEBUG("Calculating eigenvalues");
      for(int imode=0; imode<m_aNDoF; ++imode) {
 
        // get the relevant eigenvector
        for(int irow=0; irow<m_aNDoF; ++irow)
          eigenvector[irow] = U[irow][imode];
 
        // calculate the eigenvalue
        //double eigenvalue = d2Chi2->similarity( eigenvector );
        double eigenvalue = D[imode][imode];
        ATH_MSG_DEBUG("eigenvalue "<<eigenvalue);
 
        double evdotb = dot(*dChi2,eigenvector);
        CLHEP::HepVector thisdelta = evdotb/eigenvalue * eigenvector;
        deltafull += thisdelta;
 
        if(imode<m_modcut) {
          ATH_MSG_INFO("skipping eigenvalue "<<imode<<" : "<<eigenvalue<<" , modcut is "<<m_modcut);
          if(m_logStream)
             *m_logStream<<"| skipping eigenvalue "<<eigenvalue<<std::endl;
        }
        else if( eigenvalue < m_eigenvaluethreshold ) {
          ATH_MSG_INFO("skipping eigenvalue "<<eigenvalue<<" , cut is "<<m_eigenvaluethreshold);
          if(m_logStream)
             *m_logStream<<"| skipping eigenvalue "<<eigenvalue<<std::endl;
        }
        else {
          if(m_logStream)
            *m_logStream<<"| "<<eigenvalue<<std::endl;
 
          delta += thisdelta;
 
          // this is the time consuming part
          for(int irow=0; irow<m_aNDoF; ++irow)
            for(int icol=0; icol<=irow; ++icol)
              cov[irow][icol] += eigenvector[irow] * eigenvector[icol] / eigenvalue;
        }
      }
 
      // the covariance matrix is actually defined as 2 * d2Chi2^-1
 
      ATH_MSG_DEBUG("Result: "<<delta);
      ATH_MSG_DEBUG("cov: "<<cov);
 
      if(m_logStream)
        *m_logStream<<"\\----- End of Eigenvalue Spectrum -----"<<std::endl;
 
      // end of diagonalization
      // ==========================================================
    }
 
    // stop measuring time
    clock_t stoptime = clock();
    double totaltime = (stoptime-starttime)/double(CLOCKS_PER_SEC);
    ATH_MSG_INFO("Time spent in solveCLHEP: "<<totaltime<<" s");
 
    if(ierr==0 && status)
    {
      ATH_MSG_DEBUG("Alignment constants:");
      for (int iAdof=0;iAdof<m_aNDoF;iAdof++) {
 
        int idof = m_activeIndices[iAdof];
        AlignPar * alignPar=(*alignParList)[idof];
 
        double sigma = alignPar->sigma();
        double param = -delta[iAdof] * sigma;
        double err = std::sqrt(2.*std::fabs(cov[iAdof][iAdof])) * sigma;
 
        ATH_MSG_DEBUG(iAdof <<" : "<< param << " +/- "<< err);
        ATH_MSG_DEBUG("cov("<<iAdof<<")="<<cov[iAdof][iAdof]<<", sigma: "<<sigma);
        ATH_MSG_DEBUG("init par: "<<alignPar->initPar());
        alignPar->setPar(param,err);
        ATH_MSG_DEBUG("set param to "<<param<<" for alignPar "<<alignPar);
        ATH_MSG_DEBUG(*(*alignParList)[idof]);
      }
 
      if(m_logStream) {
        printGlobalSolution(*m_logStream,&cov);
 
        // norm of first derivative
        *m_logStream<<"norm of first derivative :            "<<dChi2->norm()<<std::endl;
 
        // distance to solution
        double dist = ( - (*d2Chi2) * deltafull + (*dChi2) ).norm();
        *m_logStream<<"distance to solution :                "<<dist<<std::endl;
 
        // calculate chi2 of the alignment change
        double chi2 = d2Chi2->similarity(delta) * .5;
        *m_logStream<<"delta(chi2) of the alignment change : "<<chi2<<" / "<<m_aNDoF<<std::endl;
 
        // time spent here
        *m_logStream<<"time spent in solve :                 "<<totaltime<<" s"<<std::endl;
      }
    }
 
    delete d2Chi2;
    delete dChi2;
 
    return 1;
  }

solveLapack()

int MatrixTool::solveLapack ( )

private

Definition at line 1765 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("solving Global using Lapack");
    if(m_logStream) {
      *m_logStream<<"*************************************************************"<<std::endl;
      *m_logStream<<"**************  solving using Global method  ****************"<<std::endl;
      *m_logStream<<"**************         using LAPACK          ****************"<<std::endl;
      *m_logStream<<"*************************************************************"<<std::endl;
    }
 
    // get rescaled first and second derivatives
    AlSymMat* aBetterMat = new AlSymMat(m_aNDoF);
    AlVec*    aBetterVec = new AlVec(m_aNDoF);
    for (int iActive=0;iActive<m_aNDoF;iActive++) {
      int i = m_activeIndices[iActive];
      (*aBetterVec)[iActive] = (*m_bigvector)[i];
      for (int jActive=0;jActive<m_aNDoF;jActive++) {
        int j = m_activeIndices[jActive];
        (*aBetterMat)[iActive][jActive] = (*m_bigmatrix)[i][j];
      }
    }
 
    // normalize bigmatrix and bigvector
    if(m_scaleMatrix) {
      if(m_scale<=0.)
        ATH_MSG_WARNING("Scaling requested but scale not set. Not scaling matrix and vector.");
      else {
        (*aBetterVec) *= 1./m_scale;
        (*aBetterMat) *= 1./m_scale;
      }
    }
 
    ATH_MSG_DEBUG("Now Solving alignment using lapack diagonalization routine dspev...");
 
    if (m_calDet) {
      const double tol = 1.e-20;
      // compute final determinant
      double determ = (*aBetterMat).determinant();
      ATH_MSG_INFO("Determinant: " << determ);
      if (fabs(determ) < tol)
        ATH_MSG_WARNING("Matrix is singular!");
    }
 
    // store the original matrix for checks
    AlSymMat * d2Chi2 = nullptr;
    if (m_calculateFullCovariance)
      d2Chi2 = new AlSymMat(*aBetterMat);
 
    clock_t starttime = clock();
 
    // declare transition matrix + vector to store eigenvalues
    AlMat z(m_aNDoF,m_aNDoF);
    AlVec w(m_aNDoF); // vector to store the eigenvalues
    ATH_MSG_DEBUG("MatrixTool::after z/w allocation");
 
    char jobz = 'V';
    int info = (*aBetterMat).diagonalize(jobz,w,z);
    ATH_MSG_DEBUG(" info: " << info);
    ATH_MSG_INFO("MatrixTool::after diagonalization");
 
    // stop time calculation
    clock_t stoptime = clock();
    double time_diag = (stoptime-starttime)/double(CLOCKS_PER_SEC);
    ATH_MSG_INFO(" - time spent diagonalizing the matrix: "<<time_diag<<" s");
 
    double time_solve = 0.;
    if (info==0) {
      starttime = clock();
      postSolvingLapack(aBetterVec,d2Chi2,w,z,m_aNDoF);
      stoptime = clock();
      time_solve = (stoptime-starttime)/double(CLOCKS_PER_SEC);
      ATH_MSG_INFO(" - time spent solving the system: "<<time_solve<<" s");
      if(m_logStream) {
        *m_logStream<<"time spent for diagonalization: "<<time_diag<<" s"<<std::endl;
        *m_logStream<<"time spent for post-solving: "<<time_solve<<" s"<<std::endl;
      }
    }
    else {
      ATH_MSG_ERROR("Problem in diagonalization. Solving skipped.");
      if(m_logStream)
        *m_logStream<<"time spent for diagonalization: "<<time_diag<<" s"<<std::endl;
    }
 
    if(m_logStream) {
      *m_logStream<<"total time spent in solve: "<<time_diag+time_solve<<" s"<<std::endl;
      *m_logStream<<std::endl;
    }
 
    delete d2Chi2;
    delete aBetterMat;
    delete aBetterVec;
 
    // need to do this since success return value from Lapack is 0
    // and from solveLapack() it is 1
    if (info==0)
      info = 1;
 
    return info;
  }

solveLocal()

int MatrixTool::solveLocal ( )

private

Definition at line 633 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("solving using Local method");
    if(m_logStream) {
      *m_logStream<<"*************************************************************"<<std::endl;
      *m_logStream<<"**************  solving using Local method  *****************"<<std::endl;
      *m_logStream<<"*************************************************************"<<std::endl;
    }
 
    int    totalNDoF(0);
    double totalChi2(0.);
 
    const AlignModuleList * alignModules = m_alignModuleTool->alignModules1D();
 
    AlignModuleList::const_iterator imod     = alignModules->begin();
    AlignModuleList::const_iterator imod_end = alignModules->end();
    for( ; imod!=imod_end; ++imod) {
 
      AlignModule * module = *imod;
 
      ATH_MSG_INFO("Solving for module: "<<module->name());
 
      DataVector<AlignPar> * alignPars = m_alignModuleTool->getAlignPars(module);
 
      int thisNDoF = alignPars->size();
 
      CLHEP::HepSymMatrix d2Chi2(thisNDoF,0);
      CLHEP::HepVector dChi2(thisNDoF,0);
      for (int i=0;i<thisNDoF;++i) {
        int ipar = alignPars->at(i)->index();
        dChi2[i] = (*m_bigvector)[ipar];
        for (int j=0;j<thisNDoF;++j) {
          int jpar = alignPars->at(j)->index();
          d2Chi2[i][j] = (*m_bigmatrix)[ipar][jpar];
        }
      }
 
      ATH_MSG_DEBUG("First derivatives:" << dChi2);
      ATH_MSG_DEBUG("Second derivatives:" << d2Chi2);
 
      if(module->nHits() < m_minNumHits || module->nTracks() < m_minNumTrks) {
        ATH_MSG_INFO("Not enough hits in module \'"<<module->name()<<"\':  "
         <<module->nHits()<<" < "<<m_minNumHits<<" or "
         <<module->nTracks()<<" <  "<<m_minNumTrks
         <<". Skipping...");
 
        // print module summary even when solving is not done
        if(m_logStream)
          printModuleSolution(*m_logStream,module,nullptr);
 
        continue;
      }
 
      ATH_MSG_DEBUG("First derivatives:" << dChi2);
      ATH_MSG_DEBUG("Second derivatives:" << d2Chi2);
 
 
      totalNDoF += thisNDoF;
 
      CLHEP::HepSymMatrix cov(d2Chi2);
 
      // invert the matrix
      int ierr = 0;
      cov.invert(ierr);
      if(ierr>0)
        ATH_MSG_WARNING("CLHEP inversion status flag = "<<ierr);
      else
        ATH_MSG_DEBUG("CLHEP inversion status flag = "<<ierr);
 
      // calculate corrections
      CLHEP::HepVector delta = cov * dChi2;
      //ATH_MSG_DEBUG("d2Chi2: "<<d2Chi2);
      //ATH_MSG_DEBUG("cov: "<<cov);
      //ATH_MSG_DEBUG("d2Chi2*cov: "<<d2Chi2*cov);
      //ATH_MSG_DEBUG("dChi2: "<<dChi2);
      ATH_MSG_DEBUG("Result: "<<delta);
 
      ATH_MSG_DEBUG("Alignment constants:");
      for (int idof=0;idof<thisNDoF;++idof) {
        AlignPar * alignPar = alignPars->at(idof);
 
        double sigma = alignPar->sigma();
        double param = -delta[idof] * sigma;
        double err = std::sqrt(2.*std::fabs(cov[idof][idof])) * sigma;
 
        ATH_MSG_DEBUG(idof <<" : "<< param << " +/- "<< err);
        ATH_MSG_DEBUG("cov("<<idof<<")="<<cov[idof][idof]<<", sigma: "<<sigma);
        ATH_MSG_DEBUG("init par: "<<alignPar->initPar());
 
        ATH_MSG_DEBUG("Filling constants obtained using Local method");
        alignPar->setPar(param,err);
        ATH_MSG_DEBUG("set param to "<<param<<" for alignPar "<<alignPar);
        ATH_MSG_DEBUG(*alignPar);
      }
 
      if(m_logStream) {
        printModuleSolution(*m_logStream,module,&cov);
 
        *m_logStream<<"CLHEP inversion status flag = "<<ierr<<std::endl;
 
        // calculate chi2 of the alignment change
        double chi2 = d2Chi2.similarity(delta) * .5;
        totalChi2 += chi2;
        *m_logStream<<"delta(chi2) of the alignment change : "<<chi2<<" / "<<thisNDoF<<std::endl;
      }
    }
 
    if(m_logStream) {
      *m_logStream<<"--------------------------------------------------------------------------------"<<std::endl;
      *m_logStream<<"Total delta(chi2) of the alignment change from the local method : "<<totalChi2<<" / "<<totalNDoF<<std::endl;
      *m_logStream<<std::endl;
    }
 
    return 1;
  }

solveROOT()

int MatrixTool::solveROOT ( )

private

Definition at line 265 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("solving Global using ROOT");
    if(m_logStream) {
      *m_logStream<<"*************************************************************"<<std::endl;
      *m_logStream<<"**************  solving using Global method  ****************"<<std::endl;
      *m_logStream<<"**************          using ROOT           ****************"<<std::endl;
      *m_logStream<<"*************************************************************"<<std::endl;
    }
 
    // start measuring time
    clock_t starttime = clock();
 
    DataVector<AlignPar>*  alignParList = m_alignModuleTool->alignParList1D();
    //const AlignModuleList* alignModules = m_alignModuleTool->alignModules1D();
 
    int nDoF=m_alignModuleTool->nAlignParameters();
 
    // some debugging output
    if (msgLvl(MSG::VERBOSE)) {
      msg(MSG::VERBOSE)<<"dumping matrix and vector to screen"<<endmsg;
      for (int i=0;i<nDoF;i++)
        for (int j=0;j<nDoF;j++)
        //if (std::fabs((*m_bigmatrix)[i][j])>.0001)
          msg(MSG::VERBOSE)<<i<<", "<<j<<" : "<<(*m_bigmatrix)[i][j] <<endmsg;
 
      for (int i=0;i<nDoF;i++)
        msg(MSG::VERBOSE)<<i <<" : "<<(*m_bigvector)[i]<<endmsg;
    }
 
    // get rescaled first and second derivatives
    double * secderiv   = new double[m_aNDoF*m_aNDoF];
    double * firstderiv = new double[m_aNDoF];
    for (int iActive=0;iActive<m_aNDoF;iActive++) {
      int i = m_activeIndices[iActive];
      firstderiv[iActive] = (*m_bigvector)[i];
      for (int jActive=0;jActive<m_aNDoF;jActive++) {
        int j = m_activeIndices[jActive];
        secderiv[iActive*m_aNDoF+jActive] = (*m_bigmatrix)[i][j];
      }
    }
 
    // attention, the dimension of matrix a and b is m_aNDoF not nDoF,
    // this means some alignment parameters have not been calculated
    // if the corresponding modules did not satify the select cut
 
    TMatrixDSym a(m_aNDoF,secderiv);
    TVectorD    b(m_aNDoF,firstderiv);
 
    if(msgLvl(MSG::DEBUG)) {
      msg(MSG::DEBUG)<<"First derivatives:"<<endmsg;
      b.Print();
      msg(MSG::DEBUG)<<"Second derivatives:"<<endmsg;
      a.Print();
    }
 
    TDecompBK c(a);
    Bool_t status;
    TMatrixDSym ainv(c.Invert(status));
 
    TVectorD r(b.GetNrows());
    if(status)
      r = c.Solve(b,status);
 
    // stop measuring time
    clock_t stoptime = clock();
    double totaltime = (stoptime-starttime)/double(CLOCKS_PER_SEC);
    ATH_MSG_INFO("Time spent in solveROOT: "<<totaltime<<" s");
 
    if(!status) {
      msg(MSG::ERROR)<<"ROOT inversion failed"<<endmsg;
      if(m_logStream) {
        *m_logStream<<"ROOT inversion failed"<<std::endl;
        *m_logStream<<std::endl;
      }
    }
    else {
      ATH_MSG_INFO("ROOT inversion ok");
 
      ATH_MSG_DEBUG("Alignment constants:");
      for (int iAdof=0;iAdof<m_aNDoF;iAdof++) {
 
        int idof = m_activeIndices[iAdof];
        AlignPar * alignPar=(*alignParList)[idof];
 
        double sigma = alignPar->sigma();
        double param = -r[iAdof] * sigma;
        double err = std::sqrt(2.*std::fabs(ainv(iAdof,iAdof))) * sigma;
 
        ATH_MSG_DEBUG(iAdof <<" : "<< param << " +/- "<< err);
        ATH_MSG_DEBUG("ainv("<<iAdof<<")="<<ainv(iAdof,iAdof)<<", sigma: "<<sigma);
        ATH_MSG_DEBUG("init par: "<<alignPar->initPar());
        alignPar->setPar(param,err);
        ATH_MSG_DEBUG("set param to "<<param<<" for alignPar "<<alignPar);
        ATH_MSG_DEBUG(*(*alignParList)[idof]);
      }
 
      if(m_logStream)
      {
        *m_logStream<<"ROOT inversion ok"<<std::endl;
 
        printGlobalSolution(*m_logStream,&ainv);
 
        // norm of first derivative
        *m_logStream<<"norm of first derivative :            "<<sqrt(b.Norm2Sqr())<<std::endl;
 
        // distance to solution
        double dist = sqrt( ( b - (a * r) ).Norm2Sqr() );
        *m_logStream<<"distance to solution :                "<<dist<<std::endl;
 
        // calculate chi2 of the alignment change
        double chi2 = a.Similarity(r) * .5;
        *m_logStream<<"delta(chi2) of the alignment change : "<<chi2<<" / "<<m_aNDoF<<std::endl;
 
        // time spent here
        *m_logStream<<"time spent in solve :                 "<<totaltime<<" s"<<std::endl;
      }
    }
 
    delete [] secderiv;
    delete [] firstderiv;
 
    return 1;
  }

solveSparseEigen()

int MatrixTool::solveSparseEigen ( )

private

Definition at line 2284 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("solving Global using SparseEigen");
    if(m_logStream) {
      *m_logStream<<"*************************************************************"<<std::endl;
      *m_logStream<<"**************  solving using Global method  ****************"<<std::endl;
      *m_logStream<<"**************      using SparseEigen        ****************"<<std::endl;
      *m_logStream<<"*************************************************************"<<std::endl;
    }
 
    // start measuring time
    clock_t starttime = clock();
 
    DataVector<AlignPar> * alignParList = m_alignModuleTool->alignParList1D();
 
    AlSpaMat * ABetterMat = nullptr;
    bool isCopy = false;
    if ( dynamic_cast<AlSymMat*>(m_bigmatrix) ) {
      ATH_MSG_INFO("Converting Matrix Format for fast solving");
      ABetterMat = new AlSpaMat(*(dynamic_cast<AlSymMat*>(m_bigmatrix)));
      isCopy = true;
    }
    else if ( dynamic_cast<AlSpaMat*>(m_bigmatrix) ) {
      ATH_MSG_INFO("Matrix format native to the fast solving");
      ABetterMat = (dynamic_cast<AlSpaMat*>(m_bigmatrix));
    }
    else {
      ATH_MSG_ERROR("Cannot cast to neither AlSymMat nor AlSpaMat");
      return 0;
    }
 
    ATH_MSG_DEBUG("checking active indices");
 
    // use const matrix when checking for non-zero elements to avoid
    // filling of the whole matrix
    const AlSpaMat * chkMatrix = ABetterMat;
 
    AlSpaMat * aBetterMat = new AlSpaMat(m_aNDoF);
    AlVec    * aBetterVec = new AlVec(m_aNDoF);
 
      
    for (int iActive=0;iActive<m_aNDoF;iActive++) {
      int i = m_activeIndices[iActive];
      (*aBetterVec)[iActive] = (*m_bigvector)[i];
      for (int jActive=0;jActive<m_aNDoF;jActive++) {
        int j = m_activeIndices[jActive];
        // only fill if non-zero !!!
        if ( (*chkMatrix)[iActive][jActive] != 0. )
          (*aBetterMat)[iActive][jActive]=(*ABetterMat)[i][j];
      }
    }
 
    // store original vector for cross-checks
    AlVec origVec(*aBetterVec);
 
    ATH_MSG_DEBUG("running the solving");
 
    // solve
    int info = (*aBetterMat).SolveWithEigen(*aBetterVec);
 
    if(info == 0) {
      ATH_MSG_INFO("SolveWithEigen solving OK");
      if(m_logStream)
        *m_logStream<<"SolveWithEigen solving OK."<<std::endl;
    }
    else {
      ATH_MSG_ERROR( "SolveWithEigen error code (0 if OK) = "<<info );
      if(m_logStream)
        *m_logStream<<"SolveWithEigen error code (0 if OK) = "<<info<<std::endl;
    }
 
    if( isCopy )
      delete ABetterMat;
    ABetterMat = nullptr;
 
    // stop measuring time
    clock_t stoptime = clock();
    double totaltime = (stoptime-starttime)/double(CLOCKS_PER_SEC);
    ATH_MSG_INFO("Time spent in SolveWithEigen: "<<totaltime<<" s");
 
    ATH_MSG_DEBUG("Alignment constants:");
    // compute alignment corrections (translations in mm and rotations in rad)
    // for solveSparseEigen variances are not calculated
    for(int i=0; i<m_aNDoF; i++) {
 
      double param = -(*aBetterVec)[i];
      double err = 0.;
 
      int idof = m_activeIndices[i];
      AlignPar * alignPar=(*alignParList)[idof];
 
      // undo the sigma scaling
      double sigma = alignPar->sigma();
      param *= sigma;
 
      ATH_MSG_DEBUG(i <<" : "<< param << " +/- "<< err);
      ATH_MSG_DEBUG("sigma: "<<sigma);
      ATH_MSG_DEBUG("init par: "<<alignPar->initPar());
      alignPar->setPar(param, err);
      ATH_MSG_DEBUG("set param to "<<param<<" for alignPar "<<alignPar);
      ATH_MSG_DEBUG(*(*alignParList)[idof]);
    }
 
    if(m_logStream) {
      CLHEP::HepSymMatrix * cov = nullptr;
      printGlobalSolution(*m_logStream, cov);
 
      // norm of first derivative
      *m_logStream<<"norm of first derivative :            "<<origVec.norm()<<std::endl;
 
      // distance to solution
      double dist = ( (*aBetterMat) * (*aBetterVec) - origVec ).norm();
      *m_logStream<<"distance to solution :                "<<dist<<std::endl;
 
      // calculate chi2 of the alignment change
      double chi2 = (*aBetterVec) * (*aBetterMat) * (*aBetterVec) * .5;
      *m_logStream<<"delta(chi2) of the alignment change : "<<chi2<<" / "<<m_aNDoF<<std::endl;
 
      // time spent here
      *m_logStream<<"time spent in solve :                 "<<totaltime<<" s"<<std::endl;
    }
 
    delete aBetterMat;
    delete aBetterVec;
 
    // need to do this since success return value from Lapack is 0
    // and from SolveWithEigen() it is 1
    if (info==0)
      info = 1;
 
    return info;
  }

spuriousRemoval()

StatusCode MatrixTool::spuriousRemoval ( )

private

Definition at line 1866 of file MatrixTool.cxx.

  {
 
    // copied from SiGlobalChi2Algs
    ATH_MSG_DEBUG("in spuriousRemoval");
 
    // compute determinant before resizing
    if (m_calDet) {
      const double tol = 1.e-20;
      double determ = m_bigmatrix->determinant();
      ATH_MSG_INFO("Determinant: " << determ);
      if (std::fabs(determ) < tol)
        ATH_MSG_WARNING("Matrix is singular!");
    }
 
    // fill vector with modules that need to be removed
    int fillvecmods=fillVecMods();
    if (fillvecmods==0) {
 
      //ATH_MSG_INFO(" No resize needed (NhitsCut = "
      //     << m_hitscut << ")");
 
      if (msgLvl(MSG::DEBUG)) {
        //m_bigmatrix->Write("bigmatrix.txt", false, m_wSqMatrix, m_scale,
        //           MatVersion);
        //m_bigvector->Write("bigvector.txt", false, m_scale, m_modcodemap,
        //           VecVersion, m_alignProcessLevel, m_fitParam);
      }
 
      return StatusCode::SUCCESS;
    }
    else if (fillvecmods==2)
      return StatusCode::FAILURE;
 
    /* this is a bit difficult to implement for now....
 
    // remove matrix/vector elements
    int cont=0;
    ModuleIndexMap::iterator itcode;
    ATH_MSG_INFO("Eliminating module...");
 
 
 
    for (std::vector<int>::const_iterator it=m_dropmods.begin();
    it!= m_dropmods.end(); ++it) {
 
    itcode = m_modcodemap.find((*it));
 
    if (itcode == m_modcodemap.end()) {
    ATH_MSG_WARNING("Could not find module " << *it << " in map.");
    return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO(" - Removing mcode: " << (itcode->second)
    << " (old index: " << (*it) << " -> new index: " << (*it)-cont << ")");
 
    m_bigmatrix->RemoveModule((*it)-cont);
    m_bigvector->RemoveModule((*it)-cont);
    cont++;
    }
    ATH_MSG_INFO("Modules removed from the Matrix and from the Vector Successfully!");
    ATH_MSG_DEBUG("(DoF: " << nDoF << ")");
 
    // resizing...
    ATH_MSG_INFO("Resizing the bigvector in memory...");
    m_bigvector->reSize(nDoF-6*m_dropmods.size());
    ATH_MSG_INFO("Resizing the bigmatrix in memory...");
    m_bigmatrix->reSize(nDoF-6*m_dropmods.size());
 
    ATH_MSG_INFO(m_dropmods.size() << " modules eliminated from the matrix, i.e, "
    << 6*m_dropmods.size() << " DoFs");
    ATH_MSG_INFO(nDoF/6 - m_dropmods.size() << " modules to align (" << nDoF-6*m_dropmods.size() << " DoFs)");
    ATH_MSG_INFO("New bigmatrix size is: " << m_bigmatrix->size());
    ATH_MSG_INFO("New bigvector size is: " << (*m_bigvector).size());
 
    NDoF = nDoF-6*(m_dropmods.size());
 
    // resize (update) nDoF variable
    nDoF = NDoF;
 
    // Resizing vectors to store results
    m_alignPar->reSize(nDoF);
    m_alignSqErr->reSize(nDoF);
 
    // Fill the mapping module map and updating m_modcodemap
    UpdateModMap();
    */
 
    return StatusCode::SUCCESS;
  }

storeInTFile()

void MatrixTool::storeInTFile

(

const TString &

filename

)

Store Files in a tfile.

Definition at line 862 of file MatrixTool.cxx.

  {
    //Store reults in a single TFile....
    //Including Matrix Vector Hitmap.. Soluton EVs etc.
    
    ATH_MSG_DEBUG("Writing Results to a TFile");
    
    DataVector<AlignPar> * alignParList = m_alignModuleTool->alignParList1D();
    int nDoF = alignParList->size();
  
    TMatrixDSparse* myTMatrix = m_bigmatrix->makeTMatrix();
 
    ATH_MSG_DEBUG( "Created TMatrixDSparse" );
 
  
    double *val = new double[nDoF];
    for (int i=0;i<nDoF;i++) {
      val[i] = (*m_bigvector)[i];
    }
  
    TVectorD myTVector(nDoF, val);
    delete [] val;
  
    ATH_MSG_DEBUG( "Created TVectorD" );
 
  
    const AlignModuleList * moduleList = m_alignModuleTool->alignModules1D();
    int nModules = moduleList->size();
  
    double *hitmapA = new double[nModules];
    double *hitmapB = new double[nModules];
    AlignModuleList::const_iterator imod     = moduleList->begin();
    AlignModuleList::const_iterator imod_end = moduleList->end();
    int index(0);
    for(; imod != imod_end; ++imod) {
      AlignModule * module = *imod;
      hitmapA[index] = (double)module->nHits();
      hitmapB[index] = (double)module->nTracks();
      index++;
    }
  
    TVectorD hitmapHits(nModules, hitmapA); 
    TVectorD hitmapTracks(nModules, hitmapB);
    
    delete [] hitmapA;
    delete [] hitmapB;
    
 
 
    TFile myFile(filename,"recreate");
    hitmapHits.Write("Hits");
    hitmapTracks.Write("Tracks");
    myTMatrix->Write("Matrix");
    myTVector.Write("Vector");
    
    TVectorD scale(1, &m_scale) ;
    scale.Write("Scale");
    
   
    double *moduleInfoA = new double[nDoF];//unsigned long long 
    double *dofInfoA = new double[nDoF];//int 
  
    if (sizeof(unsigned long long) != sizeof(double))      
      ATH_MSG_ERROR("Module Identifiers will not be saved.  sizeof(double)!=sizeof(ulonglong)");
    else{      
      
      DataVector<AlignPar>* alignPars = m_alignModuleTool->alignParList1D();
      for (int i=0;i<(int)alignPars->size();i++) {
        //Do a direct memory copy to store unsigned long long in the momory of a double
        double target;
        uint64_t  id = (*alignPars)[i]->alignModule()->identify().get_compact();
        memcpy(&target, &id, sizeof(target));
        moduleInfoA[i]=target;
        //moduleInfoB[i]=(*alignPars)[i]->alignModule()->name();
        uint64_t dof = (*alignPars)[i]->paramType();
        memcpy(&target, &dof, sizeof(target));
        dofInfoA[i]=target;
      }
  
      TVectorD moduleIDs(nDoF, moduleInfoA) ;
      TVectorD moduleDoFs(nDoF,dofInfoA);
      delete [] moduleInfoA;
      moduleIDs.Write("ModuleID");
      moduleDoFs.Write("dof");
    }
    
    myFile.Write();
    myFile.Close();
    
    delete myTMatrix;
    ATH_MSG_DEBUG("Finshed writing TFILE");
 
  }

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

writeHitmap()

void MatrixTool::writeHitmap ( )

private

Definition at line 2418 of file MatrixTool.cxx.

  {
    ATH_MSG_INFO("writing the hitmap to file");
 
    const AlignModuleList * moduleList = m_alignModuleTool->alignModules1D();
    int nModules = moduleList->size();
 
    AlMat hitmap(nModules,2);
    AlignModuleList::const_iterator imod     = moduleList->begin();
    AlignModuleList::const_iterator imod_end = moduleList->end();
    int index(0);
    for(; imod != imod_end; ++imod) {
      AlignModule * module = *imod;
      hitmap[index][0] = module->nHits();
      hitmap[index][1] = module->nTracks();
      index++;
    }
 
    // Set Path for the hitmap matrix
    hitmap.SetPathBin(m_pathbin+m_prefixName);
    hitmap.SetPathTxt(m_pathtxt+m_prefixName);
 
    StatusCode sc = hitmap.Write("hitmap.bin",true); // write the hitmap matrix
 
    if (sc!=StatusCode::SUCCESS)
      ATH_MSG_ERROR("Problem writing hitmap matrix");
 
    if (m_writeHitmapTxt) {
      sc = hitmap.Write("hitmap.txt", false, 0);
      if (sc!=StatusCode::SUCCESS)
        ATH_MSG_ERROR("Problem writing hitmap matrix to text file");
    }
 
    ATH_MSG_DEBUG("hitmap written to: "<< m_pathbin+m_prefixName <<"hitmap.bin (.txt)");
  }

Member Data Documentation

m_activeIndices

std::vector<int> Trk::MatrixTool::m_activeIndices

private

vector of indices which pass the min-hits cut

Definition at line 209 of file MatrixTool.h.

m_Align_db_step

float Trk::MatrixTool::m_Align_db_step

private

corr in the diagonal basis step for the third pass in the auto weak mode removal method

Definition at line 162 of file MatrixTool.h.

m_AlignIBLbutNotPixel

bool Trk::MatrixTool::m_AlignIBLbutNotPixel

private

Definition at line 214 of file MatrixTool.h.

m_alignModuleMap

std::map<int,int> Trk::IMatrixTool::m_alignModuleMap

privateinherited

Definition at line 105 of file IMatrixTool.h.

m_alignModuleTool

ToolHandle<IAlignModuleTool> Trk::MatrixTool::m_alignModuleTool

private

Definition at line 142 of file MatrixTool.h.

m_AlignPixelbutNotIBL

bool Trk::MatrixTool::m_AlignPixelbutNotIBL

private

Definition at line 215 of file MatrixTool.h.

m_aNDoF

int Trk::MatrixTool::m_aNDoF

private

number of active DoF (size of m_activeIndices)

Definition at line 210 of file MatrixTool.h.

m_bigmatrix

AlSymMatBase* Trk::MatrixTool::m_bigmatrix

private

matrix to contain second derivative terms to be used for alignment

Definition at line 145 of file MatrixTool.h.

m_bigvector

AlVec* Trk::MatrixTool::m_bigvector

private

vector to contain first derivative terms to be used for alignment

Definition at line 148 of file MatrixTool.h.

m_calculateFullCovariance

bool Trk::MatrixTool::m_calculateFullCovariance

private

Definition at line 188 of file MatrixTool.h.

m_calDet

bool Trk::MatrixTool::m_calDet

private

Compute bigmatrix's determinant ?

Definition at line 164 of file MatrixTool.h.

m_DeactivateSCT_ECA_LastDisk

bool Trk::MatrixTool::m_DeactivateSCT_ECA_LastDisk

private

Definition at line 216 of file MatrixTool.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_diagonalize

bool Trk::MatrixTool::m_diagonalize

private

run diagonalization instead of inversion

Definition at line 153 of file MatrixTool.h.

m_eigenvalueStep

float Trk::MatrixTool::m_eigenvalueStep

private

eigenvalue step for the second pass in the automatic weak mode removal method

Definition at line 161 of file MatrixTool.h.

m_eigenvaluethreshold

double Trk::MatrixTool::m_eigenvaluethreshold

private

cut on the minimum eigenvalue

Definition at line 154 of file MatrixTool.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_inputHitmapFiles

std::vector<std::string> Trk::MatrixTool::m_inputHitmapFiles

private

input binary files containing the hitmaps

Definition at line 205 of file MatrixTool.h.

m_inputMatrixFiles

std::vector<std::string> Trk::MatrixTool::m_inputMatrixFiles

private

input binary files containing matrix terms

Definition at line 202 of file MatrixTool.h.

m_inputTFiles

std::vector<std::string> Trk::MatrixTool::m_inputTFiles

private

input binary files containing matrix terms

Definition at line 207 of file MatrixTool.h.

m_inputVectorFiles

std::vector<std::string> Trk::MatrixTool::m_inputVectorFiles

private

input binary files containing vector terms

Definition at line 203 of file MatrixTool.h.

m_logStream

std::ostream* Trk::IMatrixTool::m_logStream

protectedinherited

logfile output stream

Definition at line 98 of file IMatrixTool.h.

m_maxReadErrors

int Trk::MatrixTool::m_maxReadErrors

private

maximum number of reading TFile errors

Definition at line 212 of file MatrixTool.h.

m_minNumHits

int Trk::MatrixTool::m_minNumHits

private

cut on the minimum number of hits per module

Definition at line 158 of file MatrixTool.h.

m_minNumTrks

int Trk::MatrixTool::m_minNumTrks

private

cut on the minimum number of tracks per module

Definition at line 159 of file MatrixTool.h.

m_modcut

int Trk::MatrixTool::m_modcut

private

cut on the weak modes which number is <par_modcut

Definition at line 157 of file MatrixTool.h.

m_nentries

int Trk::IMatrixTool::m_nentries

privateinherited

Definition at line 106 of file IMatrixTool.h.

m_nHits

int Trk::IMatrixTool::m_nHits

protectedinherited

Definition at line 100 of file IMatrixTool.h.

m_nMeasurements

int Trk::IMatrixTool::m_nMeasurements

protectedinherited

Definition at line 102 of file IMatrixTool.h.

m_nTracks

int Trk::IMatrixTool::m_nTracks

protectedinherited

Definition at line 101 of file IMatrixTool.h.

m_pathbin

std::string Trk::MatrixTool::m_pathbin

private

path binary files (in/out)

Definition at line 190 of file MatrixTool.h.

m_pathtxt

std::string Trk::MatrixTool::m_pathtxt

private

path ascii files (in/out)

Definition at line 191 of file MatrixTool.h.

m_prefixName

std::string Trk::MatrixTool::m_prefixName

private

prefix string to filenames

Definition at line 192 of file MatrixTool.h.

m_pullcut

float Trk::MatrixTool::m_pullcut

private

pull cut for the automatic weak mode removal method

Definition at line 160 of file MatrixTool.h.

m_readHitmaps

bool Trk::MatrixTool::m_readHitmaps

private

accumulate hitymap from files

Definition at line 174 of file MatrixTool.h.

m_readTFiles

bool Trk::MatrixTool::m_readTFiles

private

write out files to a root file

Definition at line 177 of file MatrixTool.h.

m_Remove_IBL_Rx

bool Trk::MatrixTool::m_Remove_IBL_Rx

private

Definition at line 228 of file MatrixTool.h.

m_Remove_IBL_Ry

bool Trk::MatrixTool::m_Remove_IBL_Ry

private

Definition at line 229 of file MatrixTool.h.

m_Remove_IBL_Rz

bool Trk::MatrixTool::m_Remove_IBL_Rz

private

Definition at line 230 of file MatrixTool.h.

m_Remove_IBL_Tx

bool Trk::MatrixTool::m_Remove_IBL_Tx

private

Definition at line 225 of file MatrixTool.h.

m_Remove_IBL_Ty

bool Trk::MatrixTool::m_Remove_IBL_Ty

private

Definition at line 226 of file MatrixTool.h.

m_Remove_IBL_Tz

bool Trk::MatrixTool::m_Remove_IBL_Tz

private

Definition at line 227 of file MatrixTool.h.

m_Remove_Pixel_Rx

bool Trk::MatrixTool::m_Remove_Pixel_Rx

private

Definition at line 221 of file MatrixTool.h.

m_Remove_Pixel_Ry

bool Trk::MatrixTool::m_Remove_Pixel_Ry

private

Definition at line 222 of file MatrixTool.h.

m_Remove_Pixel_Rz

bool Trk::MatrixTool::m_Remove_Pixel_Rz

private

Definition at line 223 of file MatrixTool.h.

m_Remove_Pixel_Tx

bool Trk::MatrixTool::m_Remove_Pixel_Tx

private

Definition at line 218 of file MatrixTool.h.

m_Remove_Pixel_Ty

bool Trk::MatrixTool::m_Remove_Pixel_Ty

private

Definition at line 219 of file MatrixTool.h.

m_Remove_Pixel_Tz

bool Trk::MatrixTool::m_Remove_Pixel_Tz

private

Definition at line 220 of file MatrixTool.h.

m_removeSpurious

bool Trk::MatrixTool::m_removeSpurious

private

run spurious removal

Definition at line 186 of file MatrixTool.h.

m_runLocal

bool Trk::MatrixTool::m_runLocal

private

Run solving using Local method.

Definition at line 179 of file MatrixTool.h.

m_scalaMatName

std::string Trk::MatrixTool::m_scalaMatName

private

Scalapack matrix name.

Definition at line 197 of file MatrixTool.h.

m_scalaVecName

std::string Trk::MatrixTool::m_scalaVecName

private

Scalapack vector name.

Definition at line 198 of file MatrixTool.h.

m_scale

double Trk::MatrixTool::m_scale

private

scale for big matrix and vector normalization

Definition at line 181 of file MatrixTool.h.

m_scaleMatrix

bool Trk::MatrixTool::m_scaleMatrix

private

scale matrix by number of hits before solving

Definition at line 182 of file MatrixTool.h.

m_softEigenmodeCut

double Trk::MatrixTool::m_softEigenmodeCut

private

add constant to diagonal to effectively cut on weak eigenmodes

Definition at line 184 of file MatrixTool.h.

m_solveOption

int Trk::MatrixTool::m_solveOption

private

solving option

Definition at line 156 of file MatrixTool.h.

m_tfileName

std::string Trk::MatrixTool::m_tfileName

private

prefix string to filenames

Definition at line 194 of file MatrixTool.h.

m_useSparse

bool Trk::MatrixTool::m_useSparse

private

flag to use AlSpaMat for the big matrix (default is AlSymMat)

Definition at line 151 of file MatrixTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_writeEigenMat

bool Trk::MatrixTool::m_writeEigenMat

private

write eigenvalues and eigenvectors into files ?

Definition at line 168 of file MatrixTool.h.

m_writeEigenMatTxt

bool Trk::MatrixTool::m_writeEigenMatTxt

private

also write eigenvalues and eigenvectors into txt files ?

Definition at line 169 of file MatrixTool.h.

m_writeHitmap

bool Trk::MatrixTool::m_writeHitmap

private

write hitmap into file

Definition at line 172 of file MatrixTool.h.

m_writeHitmapTxt

bool Trk::MatrixTool::m_writeHitmapTxt

private

write hitmap into text file

Definition at line 173 of file MatrixTool.h.

m_writeMat

bool Trk::MatrixTool::m_writeMat

private

write big matrix and vector into files ?

Definition at line 166 of file MatrixTool.h.

m_writeMatTxt

bool Trk::MatrixTool::m_writeMatTxt

private

also write big matrix and vector into txt files ?

Definition at line 167 of file MatrixTool.h.

m_writeModuleNames

bool Trk::MatrixTool::m_writeModuleNames

private

write module name instead of Identifier to vector file

Definition at line 170 of file MatrixTool.h.

m_writeTFile

bool Trk::MatrixTool::m_writeTFile

private

write out files to a root file

Definition at line 176 of file MatrixTool.h.

m_wSqMatrix

bool Trk::MatrixTool::m_wSqMatrix

private

write a triangular matrix by default (true: square format) ?

Definition at line 165 of file MatrixTool.h.

---

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

• MatrixTool.h
• MatrixTool.cxx