MatrixTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRKALIGNGENTOOLS_MATRIXTOOL_H
#define TRKALIGNGENTOOLS_MATRIXTOOL_H
 
#include "GaudiKernel/ToolHandle.h"
#include "AthenaBaseComps/AthAlgTool.h"
 
#include "TrkAlignInterfaces/IMatrixTool.h"
 
#include <TMatrixDSym.h>
#include "CLHEP/Matrix/SymMatrix.h"
 
#include <string>
 
class TString;
 
namespace Trk {
 
  class AlSymMatBase;
  class AlSymMat;
  class AlMat;
  class AlVec;
 
  class IAlignModuleTool;
 
  class MatrixTool : public AthAlgTool, virtual public IMatrixTool {    
  public:
 
    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  
    };
 
    MatrixTool(const std::string& type, const std::string& name,
           const IInterface* parent);
 
    virtual ~MatrixTool();
    
    StatusCode initialize();
    
    StatusCode finalize();
    
    StatusCode allocateMatrix(int nDoF=0); 
    
    void prepareBinaryFiles(int solveOption);
 
    void addFirstDerivatives(AlVec* vector);
 
    void addFirstDerivatives(std::list<int,double>& derivatives);
 
    void addFirstDerivative(int irow, double firstderiv);  
 
    void addSecondDerivatives(AlSymMatBase* matrix);
 
    void addSecondDerivatives(std::list<std::pair<int,int>,double >& derivatives);
 
    void addSecondDerivative(int irow, int icol, double secondderiv);
 
 
    bool accumulateFromFiles();
    
    bool accumulateFromBinaries();
 
    int solve();
 
    
    void storeInTFile(const TString& filename);
 
    bool accumulateFromTFiles();
 
    void printModuleSolution(std::ostream & os, const AlignModule * module, const CLHEP::HepSymMatrix * cov) const;
    void printGlobalSolution(std::ostream & os, const CLHEP::HepSymMatrix * cov);
    void printGlobalSolution(std::ostream & os, const TMatrixDSym * cov);
 
  private:
 
    // private methods
    int solveROOT();
    int solveCLHEP();
    int solveLapack();
    int solveSparseEigen();
    int solveLocal();
 
    StatusCode spuriousRemoval();
    static int        fillVecMods();
    void       postSolvingLapack(AlVec * dChi2, AlSymMat * d2Chi2, AlVec &w, AlMat &z, int size);
 
    void writeHitmap();
    void readHitmaps();
 
    // private variables
    ToolHandle<IAlignModuleTool> m_alignModuleTool;
 
    AlSymMatBase* m_bigmatrix;     
    
    AlVec* m_bigvector; 
    
    bool m_useSparse;    
 
    bool m_diagonalize;           
    double m_eigenvaluethreshold; 
 
    int   m_solveOption;     
    int   m_modcut;          
    int   m_minNumHits;      
    int   m_minNumTrks;      
    float m_pullcut;         
    float m_eigenvalueStep;  
    float m_Align_db_step;   
    
    bool m_calDet;         
    bool m_wSqMatrix;      
    bool m_writeMat;       
    bool m_writeMatTxt;    
    bool m_writeEigenMat;    
    bool m_writeEigenMatTxt; 
    bool m_writeModuleNames; 
 
    bool m_writeHitmap;    
    bool m_writeHitmapTxt; 
    bool m_readHitmaps;    
 
    bool m_writeTFile;    
    bool m_readTFiles;    
 
    bool m_runLocal;       
 
    double m_scale;        
    bool m_scaleMatrix;    
    
    double  m_softEigenmodeCut; 
 
    bool m_removeSpurious; 
 
    bool m_calculateFullCovariance; //?< calculate full covariance matrix for Lapack
 
    std::string m_pathbin;      
    std::string m_pathtxt;      
    std::string m_prefixName;   
 
    std::string m_tfileName;   
 
 
    std::string m_scalaMatName;       
    std::string m_scalaVecName;       
 
 
 
    std::vector<std::string> m_inputMatrixFiles; 
    std::vector<std::string> m_inputVectorFiles; 
 
    std::vector<std::string> m_inputHitmapFiles; 
 
    std::vector<std::string> m_inputTFiles; 
 
    std::vector<int> m_activeIndices; 
    int m_aNDoF;                      
 
    int m_maxReadErrors;    
 
    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;
 
 
  }; // end of class
  
  
 
} // End of namespace 
 
 
 
#endif // TRKALIGNGENTOOLS_MATRIXTOOL_H