GlobalAlignmentStack.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DDALIGN_GLOBALALIGNMENTSTACK_H
#define DDALIGN_GLOBALALIGNMENTSTACK_H
 
// Framework include files
#include <DD4hep/Alignments.h>
#include <DD4hep/AlignmentData.h>
#include <DD4hep/Memory.h>
 
 
namespace dd4hep {
 
  namespace align {
 
 
    class GlobalAlignmentStack  {
    public:
      enum Flags {
        OVERLAP_DEFINED     = 1<<20,
        MATRIX_DEFINED      = 1<<21,
        CHECKOVL_DEFINED    = 1<<22,
        CHECKOVL_VALUE      = 1<<23,
        RESET_VALUE         = 1<<24,
        RESET_CHILDREN      = 1<<25,
        ____LLLAST          = 1<<31
      };
      //#if 0
 
      class StackEntry {
      public:
        DetElement        detector;
        Delta             delta;
        std::string       path;
        double            overlap = 0.0;
 
        StackEntry() = delete;
        StackEntry(DetElement p, const std::string& placement, const Delta& t, double ov);
        StackEntry(const StackEntry& e);
        virtual ~StackEntry();
 
        StackEntry& operator=(const StackEntry& e) = default;
#if 0
        bool overlapDefined() const    {  return delta.checkFlag(OVERLAP_DEFINED);  }
        bool checkOverlap() const      {  return delta.checkFlag(CHECKOVL_DEFINED); }
        bool overlapValue() const      {  return delta.checkFlag(CHECKOVL_VALUE);   }
        bool hasMatrix() const         {  return delta.checkFlag(MATRIX_DEFINED);   }
        bool needsReset() const        {  return delta.checkFlag(RESET_VALUE);      }
        bool resetChildren() const     {  return delta.checkFlag(RESET_CHILDREN);   }
 
        StackEntry& setReset(bool new_value=true);
        StackEntry& setResetChildren(bool new_value=true);
        StackEntry& setOverlapCheck(bool new_value=true);
        StackEntry& setOverlapPrecision(double precision=0.001);
#endif
      };
      //#endif
      //typedef AlignmentData StackEntry;
      typedef std::map<std::string, StackEntry*> Stack;
 
    protected:
      Stack m_stack;
 
      GlobalAlignmentStack();
    public:
 
      virtual ~GlobalAlignmentStack();
 
      static GlobalAlignmentStack& get();
      static void create();
      static bool exists();
 
      static bool overlapDefined(const StackEntry& e)    {  return e.delta.checkFlag(OVERLAP_DEFINED);  }
      static bool checkOverlap(const StackEntry& e)      {  return e.delta.checkFlag(CHECKOVL_DEFINED); }
      static bool overlapValue(const StackEntry& e)      {  return e.delta.checkFlag(CHECKOVL_VALUE);   }
      static bool hasMatrix(const StackEntry& e)         {  return e.delta.checkFlag(MATRIX_DEFINED);   }
      static bool needsReset(const StackEntry& e)        {  return e.delta.checkFlag(RESET_VALUE);      }
      static bool resetChildren(const StackEntry& e)     {  return e.delta.checkFlag(RESET_CHILDREN);   }
 
      bool insert(const std::string& full_path, dd4hep_ptr<StackEntry>& new_entry);
      bool insert(dd4hep_ptr<StackEntry>& new_entry);
      void release();
      size_t size() const  {  return m_stack.size(); }
      bool add(dd4hep_ptr<StackEntry>& new_entry);
      dd4hep_ptr<StackEntry> pop();
      std::vector<const StackEntry*> entries() const;
    };
 
  }       /* End namespace detail                        */
}         /* End namespace dd4hep                          */
#endif // DDALIGN_GLOBALALIGNMENTSTACK_H