Alignments.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 DD4HEP_ALIGNMENTS_H
#define DD4HEP_ALIGNMENTS_H
 
// Framework include files
#include <DD4hep/IOV.h>
#include <DD4hep/Volumes.h>
#include <DD4hep/Conditions.h>
 
namespace dd4hep {
 
  class IOV;
  class AlignmentData;
  class Alignment;
  class Delta;
  class ConditionsMap;
 
  namespace detail  {
    class ConditionObject;
    class AlignmentObject;
  }
 
  namespace align  {
 
    class Keys  {
    public:
      static const std::string                         deltaName;
      static const Condition::itemkey_type deltaKey;
      static const std::string                         alignmentName;
      static const Condition::itemkey_type alignmentKey;
    };
  }
 
  
 
  class AlignmentCondition : public Handle<detail::AlignmentObject>   {
  public:
    typedef unsigned long long int    key_type;
 
  public:
    AlignmentCondition() : Handle<Object>() {}
    AlignmentCondition(Object* p) : Handle<Object>(p) {}
    AlignmentCondition(detail::ConditionObject* p) : Handle<Object>(p) {}
    template <typename Q> AlignmentCondition(const Handle<Q>& e) : Handle<Object>(e) {}
    AlignmentCondition(const std::string& name);
    const IOVType& iovType()  const;
    const IOV& iov()  const;
    key_type key()  const;
 
    AlignmentData& data();
    const AlignmentData& data() const;
    const Delta& delta() const;
    const TGeoHMatrix& worldTransformation()  const;
    const TGeoHMatrix& detectorTransformation() const;
    bool is_bound()  const;
  };
 
 
  class Alignment : public Handle<detail::AlignmentObject>   {
  public:
 
    class Processor {
    public:
      Processor();
      virtual ~Processor() = default;
      virtual int operator()(Alignment alignment) const = 0;
    };
 
  public:
    Alignment() = default;
    Alignment(Object* p) : Handle<Object>(p)  {}
    template <typename Q> Alignment(const Handle<Q>& e) : Handle<Object>(e)  {}
    Alignment(const std::string& name) ;
    AlignmentData& data();
    const AlignmentData& data() const;
    const Delta& delta() const;
    const TGeoHMatrix& worldTransformation()  const;
    const TGeoHMatrix& detectorTransformation() const;
    const std::vector<PlacedVolume>& nodes() const;
      
    void localToWorld(const Position& local, Position& global) const;
    void localToWorld(const Double_t local[3], Double_t global[3]) const;
    Position localToWorld(const Position& local) const;
    Position localToWorld(const Double_t local[3]) const
    {  return localToWorld({local[0],local[1],local[2]});                             }
 
    void worldToLocal(const Position& global, Position& local) const;
    void worldToLocal(const Double_t global[3], Double_t local[3]) const;
    Position worldToLocal(const Position& global) const;
    Position worldToLocal(const Double_t global[3]) const
    {  return worldToLocal({global[0],global[1],global[2]});                          }
 
    void localToDetector(const Position& local, Position& detector) const;
    void localToDetector(const Double_t local[3], Double_t detector[3]) const;
    Position localToDetector(const Position& local) const;
    Position localToDetector(const Double_t local[3]) const
    {  return localToDetector({local[0],local[1],local[2]});                         }
 
    void detectorToLocal(const Position& detector, Position& local) const;
    void detectorToLocal(const Double_t detector[3], Double_t local[3]) const;
    Position detectorToLocal(const Position& detector) const;
    Position detectorToLocal(const Double_t det[3]) const
    {  return detectorToLocal({det[0],det[1],det[2]});                              }
  };
}         /* End namespace dd4hep                    */
#endif // DD4HEP_ALIGNMENTS_H