InDetAlignDBTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETALIGNGENTOOLS_ALIGNDBTOOL_H
#define INDETALIGNGENTOOLS_ALIGNDBTOOL_H
// InDetAlignDBTool.h
// an AlgTool to manage the inner detector alignment database classes
// Richard Hawkings, started 8/4/05
//
// This AlgTool provides utilities to manage the ID alignment conditions
// data in the transient store, and to read and write it in a variety of
// formats
// Tool methods provided:
//   createDB - create a 'null' set of AlignableTransforms, with no shifts
//   dispGroup - apply a pattern to displace a group of modules randomly
//               or systematically
//   printDB - printout details of all the module transforms
//   writeFile - export database contents on a text file or ntuple
//   readTextFile - import database from text file
//   readNtuple - import database from ntuple
//
// The following utility methods are also exposed
//   idToDetSet - convert an SCT/pixel Identifier to set of integers
//         specifying detector,barrel/ec,layer,ring, sector (and side for SCT)
//   dirkey - return the AlignableTransform TDS key for a given module
//            (by Identifier or set of integers)
//   setTrans - set the transformation for a particular module, identified by 
//              a given Identifier
//   tweakTrans - tweak (add to existing transform) the transformation for
//              a particular module, identified by a given Identifier
 
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h" 
#include "InDetAlignGenTools/IInDetAlignDBTool.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "CxxUtils/checker_macros.h"
#include "AthenaKernel/IAthenaOutputStreamTool.h"
#include "GaudiKernel/ToolHandle.h"
#include <vector>
#include <string>
 
class PixelID;
class SCT_ID;
class AlignableTransform;
 
namespace InDetDD {
  class PixelDetectorManager;
  class SCT_DetectorManager;
  class SiDetectorManager;
}
 
class ATLAS_NOT_THREAD_SAFE InDetAlignDBTool: // Global variables and const_cast are used.
virtual public IInDetAlignDBTool, public AthAlgTool {
 public:
  InDetAlignDBTool(const std::string& type, const std::string& name,
         const IInterface* parent);
  virtual ~InDetAlignDBTool();
 
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
 
  // tool methods
  // create null database in TDS for subsequent manipulation
 
  virtual void createDB() const override;
 
  // displace a group of modules
  // modules to effect are specified by dettype (1=pixel, 2=SCT, -1 both),
  // bec (barrel=0, 2 for both endcaps, -1 for all), layer (0 to n-1, -1=all)
  // ring (-1=all) and sector (-1=all)
  // rphidisp,rdisp and zdisp specify the offsets to be used
  // syst specifies what will be done, 1=systematic displacement of affected
  // modules, 2=random (rphidisp etc are RMS), 3,4=systematic and random
  // displacements but interpreting r/phi/zdisp as x/y/z, 5 chooses the
  // same randomised numbers for all modules;
  // level specifies the level oill look for the right balance of CERN staff supervisors and ATLAS
  //USERS supervisors; f transformations affected
  // skip=n optionally skips n random numbers to enable different patterns
  virtual void dispGroup(const int dettype, const int bec, const int layer,
                          const int ring, const int sector,
                          const float rphidisp, const float rdisp, const float zdisp, 
                          const int syst, const int level, const int skip) const override;
 
  // write database contents to flat text file or ntuple
  // for flat file, file gives filename, for ntuple, file is e.g. 
  //  /NTUPLES/FILE1
  virtual void writeFile(const bool ntuple, const std::string& file) const override;
 
  // write IBLDist txt files
  virtual void writeIBLDistFile( const std::string& file) const override;
 
  // write GlobalFolder txt files
  virtual void writeGlobalFolderFile( const std::string& file) const override;
 
  // read back database from text file
  virtual void readTextFile(const std::string& file) const override;
 
  // read back database from text file
  //  void readOldTextFile(const std::string file) const;
 
  // read back database from ntuple
  virtual void readNtuple(const std::string& file) const override;
 
  // convert an Identifier to a set of integers specifying detector, barrel/ec
  // (0 for barrel, -1 for endcap C, +1 for endcap A), layer, ring (eta), 
  // sector (phi), and side (0/1, pixel always 0)
  // same as the fields of the Identifier, except bec is +-1 not +-2 for endcap
  virtual bool idToDetSet(const Identifier ident,
          int& det,int& bec,int& layer,int& ring,int& sector,int& side) const override;
 
  // return the AlignableTransform name where the transform for the given
  // module can be found, 3 levels corresponding to alignment hierarchy
  virtual std::string dirkey(const Identifier&, const int) const override;
  virtual std::string dirkey(const int,const int,const int, const int) const override;
  virtual std::string dirkey(const int,const int,const int, const int, const int) const override;
  virtual std::string DBMkey(const int,const int,const int, const int) const override;
  
  // set a particular transform specified by Identifier
  virtual bool setTrans(const Identifier& ident, const int level,
    const Amg::Transform3D& trans) const override;
 
  // As above but takes translation and rotations alpha, beta, gamma (rotations around x,y,z axes) as input.
  // Calculates transform as HepGeom::Translate3D(translate) * HepGeom::RotateX3D(alpha) * HepGeom::RotateY3D(beta) * HepGeom::RotateZ3D(gamma)
  virtual bool setTrans(const Identifier& ident, const int level,
            const Amg::Vector3D& translate, double alpha, double beta, double gamma) const override;
 
 
  // tweak a particular transform specified by Identifier (i.e. add to 
  //   already existing transformation)
  virtual bool tweakTrans(const Identifier& ident, const int level,
    const Amg::Transform3D& trans) const override;
 
  // As above but takes translation and rotations alpha, beta, gamma (rotations around x,y,z axes) as input.
  // Calculates transform as HepGeom::Translate3D(translate) * HepGeom::RotateX3D(alpha) * HepGeom::RotateY3D(beta) * HepGeom::RotateZ3D(gamma)
  virtual bool tweakTrans(const Identifier& ident, const int level,
                        const Amg::Vector3D& translate, double alpha, double beta, double gamma) const override;

  virtual bool tweakIBLDist(const int, const float) const override;

  virtual bool tweakGlobalFolder(const Identifier& ident, const int level,
                 const Amg::Transform3D& trans) const;

  virtual Identifier getL1L2fromL3Identifier( const Identifier& ident
                                            , const int& level
                                            ) const override;

  virtual Amg::Transform3D getTransL123( const Identifier& ident ) const override;

  virtual Amg::Transform3D getTrans( const Identifier& ident
                                 , const int level
                                 ) const override;
 
  // write the transforms to outputstream
  virtual StatusCode outputObjs() override;
 
  // write the transform IOVs to IOVDB
  virtual void fillDB(const std::string& tag, 
     const unsigned int run1, const unsigned int event1,
     const unsigned int run2, const unsigned int event2) const override;
 
  // print the transforms, level=1 lists sizes, level=2 lists all transforms
  virtual void printDB(const int level) const override;
 
  // sort all the AlignableTransform objects so searches/inserts work properly
  virtual void sortTrans() const override;
  
  //calculate three rotations around locX,locY,locY = alpha,beta,gamma out of an HepGeom::Transform3D
  void extractAlphaBetaGamma(const Amg::Transform3D & trans, 
                             double& alpha, double& beta, double &gamma) const override;
  
 private:
 
  const PixelID* m_pixid{};
  const SCT_ID* m_sctid{};
  const InDetDD::PixelDetectorManager* m_pixman{};
  const InDetDD::SCT_DetectorManager* m_sctman{};
  bool m_dynamicDB{false};
  std::vector<const InDetDD::SiDetectorManager *> m_managers;
 
  std::vector<std::string> m_alignobjs;
  std::vector<int> m_alignchans;
 
  CondAttrListCollection* m_attrListCollection{};
 
  std::string m_par_dbkey;
 
  Gaudi::Property<bool> m_par_newdb{this, "NewDB", true, "create database using new (collection) format"};  // FIXME: "New" is misleading
  Gaudi::Property<bool> m_par_scttwoside{this, "SCTTwoSide", false, "create structures with separated SCT module sides"};
  Gaudi::Property<int> m_par_fake{this, "FakeDB", 0, "set to 1 to fake full ATLAS geom, 2 to fake CTB geom"};
  ToolHandle<IAthenaOutputStreamTool> m_par_condstream{this, "CondStream", "AthenaOutputStreamTool/AthenaOutputStreamTool"};
  Gaudi::Property<std::string> m_par_dbroot{ this, "DBRoot", "/Indet/Align", "Root folder for alignment" };
  Gaudi::Property<bool> m_par_oldTextFile{this, "OldTextFile", false, "Input text file using old format"};
  Gaudi::Property<bool> m_forceUserDBConfig{this, "forceUserDBConfig", false, "Set to true to override any DB auto-configuration"};
  Gaudi::Property<std::string> m_pixmanName{this, "PixelManager", "Pixel", "Pixel manager name" };
  Gaudi::Property<std::string> m_sctmanName{this, "SCT_Manager", "SCT", "SCT manager name" };
  Gaudi::Property<bool> m_doPix{this, "AlignPixel", true, "Include Pixel" };
  Gaudi::Property<bool> m_doStrip{this, "AlignStrip", true, "Include SCT/ITkStrip" };
 
  AlignableTransform* getTransPtr(const std::string& key) const;
  const AlignableTransform* cgetTransPtr(const std::string& key) const;
  void fakeGeom(const int nbpix, const int necpix, 
        const int nbsct, const int necsct);
};
 
#endif // INDETALIGNGENTOOLS_ALIGNDBTOOL_H