AlignmentStack.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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 DD4HEP_ALIGNMENT_ALIGNMENTSTACK_H
#define DD4HEP_ALIGNMENT_ALIGNMENTSTACK_H

// Framework include files
#include "DD4hep/Alignments.h"
#include "DD4hep/Objects.h"
#include "DD4hep/Memory.h"


namespace DD4hep {

  namespace Alignments {


    class AlignmentStack  {
    public:
      enum {
        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
      } Flags;


      struct StackEntry {
        DetElement        detector;
        Delta             delta;
        std::string       path;
        double            overlap;

        StackEntry(DetElement p, const std::string& placement, const Delta& t, double ov);
        StackEntry(const StackEntry& e);
        virtual ~StackEntry();

        StackEntry& operator=(const StackEntry& e);

        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);
      };
      typedef std::map<std::string, StackEntry*> Stack;

    protected:
      Stack m_stack;

      AlignmentStack();
    public:

      virtual ~AlignmentStack();

      static AlignmentStack& get();
      static void create();
      static bool exists();
      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 Geometry        */
} /* End namespace DD4hep            */
#endif    /* DD4HEP_ALIGNMENT_ALIGNMENTSTACK_H       */