InDetDetectorManager.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// InDetDectorManager.h
// (c) ATLAS Detector software
 
#ifndef INDETREADOUTGEOMETRY_INDETDETECTORMANAGER_H
#define INDETREADOUTGEOMETRY_INDETDETECTORMANAGER_H
 
// Amg
#include "GeoPrimitives/GeoPrimitives.h"
// GeoModel stuff
#include "GeoModelKernel/GeoVDetectorManager.h"
#include "ReadoutGeometryBase/InDetDD_Defs.h"
#include "InDetReadoutGeometry/Version.h"
#include "CLHEP/Geometry/Transform3D.h"
 
// IOV SVC for alignment:
#include "AthenaKernel/IIOVSvc.h"
 
#include "DetDescrConditions/AlignableTransformContainer.h"//typedef
#include "AthenaBaseComps/AthMessaging.h"
 
#include <atomic>
#include <string>
#include <map>
#include <set>
#include <list>
 
class StoreGateSvc;
class AlignableTransform;
class Identifier;
class AtlasDetectorID;
class GeoVAlignmentStore;
class CondAttrListCollection;
 
namespace InDetDD {
 
  typedef std::map<std::string, const void*> RawAlignmentObjects;
 
    class InDetDetectorManager : public GeoVDetectorManager, public AthMessaging  {
 
    public:
 
      // Constructor
      InDetDetectorManager(StoreGateSvc * detStore, const std::string & name);
 
      // Destructor
      virtual ~InDetDetectorManager();
 
 
      const Version & getVersion() const;
      const std::string & getLayout() const; // eg Initial, Final, TestBeam
      void setVersion(const Version & version);
 
      void addChannel(const std::string & key, int level, FrameType frame);
      void addFolder(const std::string & key);
      void addSpecialFolder(const std::string & key);
      void addGlobalFolder(const std::string & key);
      void addAlignFolderType(const AlignFolderType alignfolder);
 
      StatusCode align( IOVSVC_CALLBACK_ARGS );
 
      StatusCode align(const RawAlignmentObjects& alignObjects, GeoVAlignmentStore* alignStore) const;
 
      virtual void invalidateAll() = 0;
 
      virtual void updateAll() const = 0;
 
      virtual bool identifierBelongs(const Identifier & id) const = 0;
 
      AlignFolderType                           m_alignfoldertype;
 
    protected:
      StoreGateSvc * m_detStore;
      mutable std::atomic_bool                  m_suppressWarnings;
 
    private:
      class LevelInfo {
 
        private:
          int m_level;
          FrameType m_type;
 
        public:
          LevelInfo(): m_level(-1), m_type(InDetDD::global) {};
          LevelInfo(int level, FrameType frame): m_level(level), m_type(frame) {};
 
          int level() const {return m_level;}
          FrameType frame() const {return m_type;}
          bool isGlobalDelta() const {return m_type == InDetDD::global;}
          bool isLocalDelta() const {return m_type == InDetDD::local;}
          bool isValid() const {return (m_level >= 0);}
      };
 
      class AlignInfo {
 
        private:
        AlignFolderType m_aligntype;
 
        public:
          AlignInfo(): m_aligntype(InDetDD::none) {};
          AlignInfo(AlignFolderType alignfolder): m_aligntype(alignfolder) {};
          AlignFolderType AlignFolder() const {return m_aligntype;}
          bool isValidAlign() const {return (m_aligntype != InDetDD::none);}
 
      };
 
 
      const LevelInfo & getLevel(const std::string & key) const;
 
      //      InDetDD::AlignFolderType getAlignInfo();
 
      bool processAlignmentContainer(const std::string & key) const;
      bool processAlignmentContainer(const AlignableTransformContainer* container, GeoVAlignmentStore* alignStore) const;
 
      bool processKey(const std::string& key,
                      const AlignableTransform* transformCollection,
                      GeoVAlignmentStore* alignStore=nullptr) const;
 
      virtual bool setAlignableTransformDelta(int level,
                                              const Identifier & id,
                                              const Amg::Transform3D & delta,
                                              FrameType frame,
                                              GeoVAlignmentStore* alignStore=nullptr) const = 0;
 
      //Serial (pre-MT) interface
      virtual bool processSpecialAlignment(const std::string & key,
                                           InDetDD::AlignFolderType alignfolder) = 0;
 
      //MT-Interface
      virtual bool processSpecialAlignment(const std::string& key,
                                           const CondAttrListCollection* obj=nullptr,
                                           GeoVAlignmentStore* alignStore=nullptr) const = 0;
 
      bool processGlobalAlignmentContainer(const std::string & key,
                                           const CondAttrListCollection* obj=nullptr,
                                           GeoVAlignmentStore* alignStore=nullptr) const;
 
      virtual bool processGlobalAlignment(const std::string & key, int level, FrameType frame,
                                          const CondAttrListCollection* obj=nullptr,
                                          GeoVAlignmentStore* alignStore=nullptr) const;
 
      virtual const AtlasDetectorID* getIdHelper() const = 0;
 
      Version                                   m_version;
      std::map<std::string, LevelInfo>          m_keys;
      std::set<std::string>                     m_folders;
      std::set<std::string>                     m_specialFolders;
      std::set<std::string>                     m_globalFolders; // new time-dependent global folders
 
      static const LevelInfo s_invalidLevel;
    };
 
} // namespace InDetDD
 
#endif // INDETREADOUTGEOMETRY_INDETDETECTORMANAGER_H