AlignmentOperators.h

Go to the documentation of this file.

// $Id: $
//==========================================================================
//  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_ALIGNMENTOPERATORS_H
#define DD4HEP_ALIGNMENT_ALIGNMENTOPERATORS_H

// Framework include files
#include "DD4hep/Alignments.h"
#include "DD4hep/GlobalAlignment.h"
#include "DDAlign/GlobalAlignmentCache.h"

namespace DD4hep {

  namespace Alignments {


    class AlignmentOperator  {
    public:
      typedef AlignmentStack::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:
      AlignmentOperator(GlobalAlignmentCache& c, Nodes& n) : cache(c), nodes(n) {}
      void insert(GlobalAlignment alignment)  const;
    };


    class AlignmentSelector : public AlignmentOperator {
    public:
      const Entries& entries;
      AlignmentSelector(GlobalAlignmentCache& c, Nodes& n, const Entries& e) : AlignmentOperator(c,n), entries(e) {}
      const AlignmentSelector& reset()   const { nodes.clear(); return *this; }
      void operator()(const GlobalAlignmentCache::Cache::value_type& e) const;
      void operator()(Entry* e) const;
    };


    template <typename T> class AlignmentActor : public AlignmentOperator {
    public:
      AlignmentActor(GlobalAlignmentCache& c, Nodes& n) : AlignmentOperator(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 AlignmentActor<DDAlign_standard_operations::node_print>::init();
    template <> void AlignmentActor<DDAlign_standard_operations::node_print>::operator() (Nodes::value_type& n)  const;
    template <> void AlignmentActor<DDAlign_standard_operations::node_delete>::operator()(Nodes::value_type& n)  const;
    template <> void AlignmentActor<DDAlign_standard_operations::node_reset>::operator() (Nodes::value_type& n)  const;
    template <> void AlignmentActor<DDAlign_standard_operations::node_align>::operator() (Nodes::value_type& n)  const;

  } /* End namespace Geometry        */
} /* End namespace DD4hep            */
#endif    /* DD4HEP_ALIGNMENT_ALIGNMENTOPERATORS_H       */