AlignmentsManager.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_DDALIGN_ALIGNMENTMANAGER_H
#define DD4HEP_DDALIGN_ALIGNMENTMANAGER_H

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

namespace DD4hep {

  namespace Conditions   {
    class UserPool;
    class ConditionDependency;
    class ConditionUpdateContext;
    class ConditionsDependencyCollection;
  }
  
  namespace Alignments {

    class AlignContext;
    class AlignmentsManager;
    class AlignmentsManagerObject;


    class AlignmentsManager : public Handle<AlignmentsManagerObject> {
    public:
      typedef AlignmentsManagerObject                    Object;
      typedef Conditions::ConditionUpdateContext         Context;
      typedef Conditions::ConditionDependency            Dependency;
      typedef Conditions::ConditionsDependencyCollection Dependencies;
      
    public:


      template <typename T> static AlignmentsManager from(T& host);

      AlignmentsManager() = default;
      AlignmentsManager(const AlignmentsManager& copy) = default;
      AlignmentsManager(const Handle<Object>& e) : Handle<Object>(e) {}
      template <typename Q> AlignmentsManager(const Handle<Q>& e) : Handle<Object>(e) {}
      AlignmentsManager(const std::string& name);
      AlignmentsManager(char const* name);
      AlignmentsManager& operator=(const AlignmentsManager& mgr) = default;
      void destroy();
      bool adoptDependency(Dependency* dependency)  const;
      const Dependencies& knownDependencies()  const;
      void compute(dd4hep_ptr<UserPool>& user_pool)  const;
      void compute(dd4hep_ptr<UserPool>& user_pool, const Dependencies& deps)  const;
      static void newEntry(const Context& parameter,
                           DetElement& det,
                           const Dependency* dep,
                           AlignmentCondition& con);
    };



    class AlignmentsManagerObject : public NamedObject {
    public:
      typedef AlignmentsManager::Dependencies Dependencies;
      
      Dependencies*        dependencies;
      AlignContext*        all_alignments;

    protected:
      void to_world(AlignContext& new_alignments, UserPool& pool, DetElement det, TGeoHMatrix& mat)  const;
      void compute(AlignContext& new_alignments, UserPool& pool, DetElement child) const;

    public:
      AlignmentsManagerObject();
      virtual ~AlignmentsManagerObject();
      void compute(UserPool& user_pool) const;
      void compute(UserPool& user_pool, const Dependencies& deps) const;
    };
    
  }       /* End namespace Geometry                    */
}         /* End namespace DD4hep                      */
#endif    /* DD4HEP_DDALIGN_ALIGNMENTMANAGER_H         */