AlignmentData.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_ALIGNMENTDATA_H
#define DD4HEP_ALIGMENTS_ALIGNMENTDATA_H

// Framework include files
#include "DD4hep/NamedObject.h"
#include "DD4hep/Detector.h"
#include "DD4hep/Volumes.h"

// ROOT include files
#include "TGeoMatrix.h"

namespace DD4hep {

  namespace Alignments {

    // The DetElement is a central object. We alias it here.
    using Geometry::DetElement;
    using Geometry::RotationZYX;
    using Geometry::Transform3D;
    using Geometry::Translation3D;
    using Geometry::Position;
    using Geometry::LCDD;

    // Forward declarations
    class Alignment;
    class AlignmentCondition;
    

    class Delta   {
    public:
      typedef Translation3D Pivot;
      Position      translation;
      Pivot         pivot;
      RotationZYX   rotation;
      unsigned int  flags = 0;

      enum AlignmentFlags {
        HAVE_NONE         = 0,
        HAVE_TRANSLATION  = 1<<2,
        HAVE_ROTATION     = 1<<3,
        HAVE_PIVOT        = 1<<4,
      };

      Delta() = default;
      Delta(const Position& tr)
        : translation(tr), flags(HAVE_TRANSLATION) {}
      Delta(const RotationZYX& rot)
        : translation(), rotation(rot), flags(HAVE_ROTATION) {}
      Delta(const Position& tr, const RotationZYX& rot)
        : translation(tr), rotation(rot), flags(HAVE_ROTATION|HAVE_TRANSLATION) {}
      Delta(const Translation3D& piv, const RotationZYX& rot)
        : pivot(piv), rotation(rot), flags(HAVE_ROTATION|HAVE_PIVOT) {}
      Delta(const Position& tr, const Translation3D& piv, const RotationZYX& rot)
        : translation(tr), pivot(piv), rotation(rot), flags(HAVE_ROTATION|HAVE_PIVOT|HAVE_TRANSLATION) {}
      Delta(const Delta& c);
      ~Delta();
      Delta& operator=(const Delta& c);
      void clear();
      bool checkFlag(unsigned int mask) const {  return (flags&mask) == mask;        }
      void setFlag(unsigned int mask)         {  flags |= mask;                      }
      bool hasTranslation() const             {  return checkFlag(HAVE_TRANSLATION); }
      bool hasRotation() const                {  return checkFlag(HAVE_ROTATION);    }
      bool hasPivot() const                   {  return checkFlag(HAVE_PIVOT);       }
    };


    class AlignmentData   {
    public:

      typedef Geometry::PlacedVolume    PlacedVolume;
      typedef std::vector<PlacedVolume> NodeList;
      typedef Alignments::Delta         Delta;
      typedef unsigned int              BitMask;
      typedef ReferenceBitMask<BitMask> MaskManipulator;
      

      enum AlignmentFlags {
        HAVE_NONE = 0,
        HAVE_WORLD_TRAFO  = 1<<0,
        HAVE_PARENT_TRAFO = 1<<1,
        HAVE_OTHER        = 1<<31
      };
      enum DataType  {
        IDEAL   = 1<<10,
        SURVEY  = 1<<11,
        TIME_STAMPED = 1<<12
      };

      Delta                delta;
      mutable TGeoHMatrix  worldTrafo;
      mutable TGeoHMatrix  worldDelta;
      mutable TGeoHMatrix  detectorTrafo;
      NodeList             nodes;
      Transform3D          trToWorld;
      DetElement           detector;
      PlacedVolume         placement;
      Ref_t                condition;
      mutable BitMask      flag;
      unsigned int         magic;

    public:
      AlignmentData();
      AlignmentData(const AlignmentData& copy);
      virtual ~AlignmentData();
      AlignmentData& operator=(const AlignmentData& copy);
      inline AlignmentData& data()                       {  return *this;               }
      bool hasCondition()  const                         {  return condition.isValid(); }
      Alignment nominal() const;
      const TGeoHMatrix& worldTransformation()  const    {  return worldTrafo;          }
      const TGeoHMatrix& detectorTransformation() const  {  return detectorTrafo;       }
      const Transform3D& localToWorld() const            {  return trToWorld;           }

      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(Position(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(Position(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(Position(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(Position(det[0],det[1],det[2]));                        }
    };

    template <typename T> class AlignmentDecorator : public T  {
    public:
      typedef AlignmentData::PlacedVolume    PlacedVolume;
      typedef AlignmentData::NodeList        NodeList;
      typedef AlignmentData::Delta           Delta;
      
      AlignmentDecorator();
      AlignmentDecorator(const AlignmentDecorator& c);
      template <typename Q> AlignmentDecorator(Q q) : T(q) {}
      ~AlignmentDecorator()  {                                  }

      const AlignmentData& data()   const { return T::data();   }
      DetElement detector()   const
      {  return data().detector;                                }
      PlacedVolume placement()   const
      {  return data().placement;                               }
      PlacedVolume detectorPlacement()   const
      {  return data().detector.placement();                    }

      const Transform3D& localToWorld() const
      {  return data().trToWorld;  }
      const TGeoHMatrix& worldTransformation() const
      {  return data().worldTransformation();                   }
      const TGeoHMatrix& detectorTransformation() const
      {  return data().detectorTransformation();                }

      void localToWorld(const Position& local, Position& global) const
      {  return data().localToWorld(local, global);             }
      void localToWorld(const Double_t local[3], Double_t global[3]) const
      {  return data().localToWorld(local, global);             }

      void localToDetector(const Position& local, Position& det) const
      {  return data().localToDetector(local, det);             }
      void localToDetector(const Double_t local[3], Double_t det[3]) const
      {  return data().localToDetector(local, det);             }

      void worldToLocal(const Position& global, Position& local) const
      {  return data().worldToLocal(global, local);             }
      void worldToLocal(const Double_t global[3], Double_t local[3]) const
      {  return data().worldToLocal(global, local);             }

      void detectorToLocal(const Position& det, Position& local) const
      {  return data().detectorToLocal(det, local);             }
      void detectorToLocal(const Double_t det[3], Double_t local[3]) const
      {  return data().detectorToLocal(det, local);             }

      const Alignment& nominal() const
      {  return data().detector.ideal();                        }
      const Delta& delta() const
      {  return data().delta;                                   }

      void setDelta(const Delta& del)      {
        AlignmentData& d = data();
        d.delta = del;
      }
      void setDelta(const Position& translation)      {
        AlignmentData& d = data();
        d.delta.translation = translation;
        d.delta.flags |= Delta::HAVE_TRANSLATION;
      }
      void setDelta(const RotationZYX& rotation)  {
        AlignmentData& d = data();
        d.delta.rotation = rotation;
        d.delta.flags |= Delta::HAVE_ROTATION;
      }
      void setDelta(const Position& translation, RotationZYX& rotation)     {
        AlignmentData& d = data();
        d.delta.rotation = rotation;
        d.delta.translation = translation;
        d.delta.flags |= Delta::HAVE_ROTATION;
        d.delta.flags |= Delta::HAVE_TRANSLATION;
      }
      void setDeltaPivot(const Translation3D& pivot, const RotationZYX& rotation)  {
        AlignmentData& d = data();
        d.delta.pivot = pivot;
        d.delta.rotation = rotation;
        d.delta.flags |= Delta::HAVE_PIVOT;
        d.delta.flags |= Delta::HAVE_ROTATION;
      }
      void setDeltaPivot(const Position& translation, const Translation3D& pivot, const RotationZYX& rotation)  {
        AlignmentData& d = data();
        d.delta.pivot = pivot;
        d.delta.rotation = rotation;
        d.delta.translation = translation;
        d.delta.flags |= Delta::HAVE_PIVOT;
        d.delta.flags |= Delta::HAVE_ROTATION;
        d.delta.flags |= Delta::HAVE_TRANSLATION;
      }
    };

    template <typename T> inline 
    AlignmentDecorator<T>::AlignmentDecorator() : T() {}

    template <typename T> inline 
    AlignmentDecorator<T>::AlignmentDecorator(const AlignmentDecorator& c) : T(c)  {}


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