Alignments.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_ALIGMENTS_ALIGNMENTS_H
#define DD4HEP_ALIGMENTS_ALIGNMENTS_H

// Framework include files
#include "DD4hep/IOV.h"
#include "DD4hep/Volumes.h"

namespace DD4hep {

  class IOV;

  namespace Conditions   {

    class UserPool;
    namespace Interna  {
      class ConditionObject;
    }
  }
  
  namespace Alignments {

    using Geometry::LCDD;
    using Geometry::DetElement;
    using Geometry::PlacedVolume;
    using Conditions::UserPool;
    
    namespace Interna  {
      class AlignmentContainer;
      class AlignmentNamedObject;
      class AlignmentConditionObject;
    }
    class AlignmentsManagerObject;
    class AlignmentsLoader;
    class AlignmentData;
    class Alignment;
    class Delta;


    class Alignment : public Handle<AlignmentData>   {
    public:

      class Processor {
      public:
        Processor();
        virtual ~Processor() = default;
        virtual int operator()(Alignment container) = 0;
      };

      typedef AlignmentData             Object;
      typedef AlignmentData             Data;
      typedef Geometry::PlacedVolume    PlacedVolume;
      typedef std::vector<PlacedVolume> NodeList;
      typedef Alignments::Delta         Delta;
      typedef unsigned int              key_type;
      typedef IOV                       iov_type;

    public:
      Alignment() = default;
      Alignment(Object* p) : Handle<Object>(p)  {}
      template <typename Q> Alignment(const Handle<Q>& e) : Handle<Object>(e)  {}
#if defined(__APPLE__) || defined(__clang__)
      Alignment(const std::string& name) ;
#else
      template <typename Q=Interna::AlignmentNamedObject> Alignment(const std::string& name);
#endif
      static key_type hashCode(const char* value);
      static key_type hashCode(const std::string& value);

      Data& data()              {   return (*access()); }
      const Data& data() const  {   return (*access()); }
      const TGeoHMatrix& worldTransformation()  const;
      const TGeoHMatrix& detectorTransformation() const;
    };

    inline Alignment::key_type Alignment::hashCode(const char* value)
    {   return hash32(value);    }

    inline Alignment::key_type Alignment::hashCode(const std::string& value)
    {   return hash32(value);    }


    class AlignmentCondition : public Handle<Interna::AlignmentConditionObject>   {
    public:
      typedef Interna::AlignmentConditionObject Object;
      typedef AlignmentData             Data;
      typedef Geometry::PlacedVolume    PlacedVolume;
      typedef std::vector<PlacedVolume> NodeList;
      typedef Alignments::Delta         Delta;
      typedef unsigned int              key_type;
      typedef IOV                       iov_type;

    public:
      AlignmentCondition() : Handle<Object>() {}
      AlignmentCondition(Object* p) : Handle<Object>(p) {}
      AlignmentCondition(Conditions::Interna::ConditionObject* p) : Handle<Object>(p) {}
      template <typename Q> AlignmentCondition(const Handle<Q>& e) : Handle<Object>(e) {}
#if defined(__APPLE__) || defined(__clang__)
      AlignmentCondition(const std::string& name) ;
#else
      template <typename Q=Object> AlignmentCondition(const std::string& name);
#endif

      const IOVType& iovType()  const;
      const iov_type& iov()  const;
      key_type key()  const;

      Data& data();
      const Data& data() const;
      const TGeoHMatrix& worldTransformation()  const;
      const TGeoHMatrix& detectorTransformation() const;
      bool is_bound()  const;
    };



    class Container : public Handle<Interna::AlignmentContainer> {
    public:

      class Processor {
      public:
        Processor();
        virtual ~Processor() = default;
        virtual int operator()(Container container) = 0;
      };

      typedef Interna::AlignmentContainer      Object;
      typedef Alignment::key_type              key_type;
      typedef Alignment::iov_type              iov_type;
      typedef std::pair<key_type, std::string> key_value;
      typedef std::map<key_type, key_value>    Keys;

    public:
      Container();

      template <typename Q> Container(const Container& c) : Handle<Object>(c) {}

      template <typename Q> Container(const Handle<Q>& e) : Handle<Object>(e) {}

      size_t numKeys() const;

      const Keys&  keys()  const;

      Alignment get(const std::string& alignment_key, const iov_type& iov);

      Alignment get(key_type alignment_key, const iov_type& iov);

      Alignment get(const std::string& alignment_key, const UserPool& iov);

      Alignment get(key_type alignment_key, const UserPool& iov);
    };

    inline Container::Container() : Handle<Object>() {
    }

  } /* End namespace Aligments               */
} /* End namespace DD4hep                    */
#endif    /* DD4HEP_ALIGMENTS_ALIGNMENTS_H   */