GlobalAlignmentOperators.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_GLOBALALIGNMENTOPERATORS_H
#define DDALIGN_GLOBALALIGNMENTOPERATORS_H
 
// Framework include files
#include <DD4hep/Alignments.h>
#include <DD4hep/GlobalAlignment.h>
#include <DDAlign/GlobalAlignmentCache.h>
 
namespace dd4hep {
 
  namespace align {
 
 
    class GlobalAlignmentOperator  {
    public:
      typedef GlobalAlignmentStack::StackEntry  Entry;
      typedef GlobalAlignmentCache::Cache       Cache;
      typedef std::vector<Entry*>               Entries;
      typedef std::map<std::string,std::pair<TGeoPhysicalNode*,Entry*> > Nodes;
      GlobalAlignmentCache& cache;
      Nodes& nodes;
 
    public:
      GlobalAlignmentOperator(GlobalAlignmentCache& c, Nodes& n) : cache(c), nodes(n) {}
      void insert(GlobalAlignment alignment)  const;
    };
 
 
    class GlobalAlignmentSelector : public GlobalAlignmentOperator {
    public:
      const Entries& entries;
      GlobalAlignmentSelector(GlobalAlignmentCache& c, Nodes& n, const Entries& e)
        : GlobalAlignmentOperator(c,n), entries(e)
      {
      }
      const GlobalAlignmentSelector& reset()   const {
        nodes.clear();
        return *this;
      }
      void operator()(const GlobalAlignmentCache::Cache::value_type& e) const;
      void operator()(Entry* e) const;
    };
 
 
    template <typename T> class GlobalAlignmentActor : public GlobalAlignmentOperator {
    public:
      GlobalAlignmentActor(GlobalAlignmentCache& c, Nodes& n)
        : GlobalAlignmentOperator(c,n)
      {
        init();
      }
      void init() {
      }
      void operator()(Nodes::value_type& e) const;
    };
 
    namespace DDAlign_standard_operations  {
      class node_print;
      class node_reset;
      class node_align;
      class node_delete;
    }
 
    // Specializations
    template <> void GlobalAlignmentActor<DDAlign_standard_operations::node_print>::init();
    template <> void GlobalAlignmentActor<DDAlign_standard_operations::node_print>::operator() (Nodes::value_type& n)  const;
    template <> void GlobalAlignmentActor<DDAlign_standard_operations::node_delete>::operator()(Nodes::value_type& n)  const;
    template <> void GlobalAlignmentActor<DDAlign_standard_operations::node_reset>::operator() (Nodes::value_type& n)  const;
    template <> void GlobalAlignmentActor<DDAlign_standard_operations::node_align>::operator() (Nodes::value_type& n)  const;
  }       /* End namespace align                    */
}         /* End namespace dd4hep                        */
#endif // DDALIGN_GLOBALALIGNMENTOPERATORS_H