AlignmentData.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_ALIGNMENTDATA_H
#define DD4HEP_ALIGNMENTDATA_H
 
// Framework include files
#include <DD4hep/NamedObject.h>
#include <DD4hep/DetElement.h>
#include <DD4hep/Volumes.h>
 
// ROOT include files
#include <TGeoMatrix.h>
 
namespace dd4hep {
 
  // 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);       }
    void computeMatrix(TGeoHMatrix& tr_delta)  const;
  };
 
 
  class AlignmentData   {
  public:
    typedef unsigned int              BitMask;
 
    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  detectorTrafo;
    std::vector<PlacedVolume> nodes;
    Transform3D          trToWorld;
    DetElement           detector;
    PlacedVolume         placement;
    mutable BitMask      flag;
    unsigned int         magic;
 
  public:
    AlignmentData();
    AlignmentData(const AlignmentData& copy);
    virtual ~AlignmentData();
    AlignmentData& operator=(const AlignmentData& copy);
    inline AlignmentData& data()                       {  return *this;               }
    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({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               */
std::ostream& operator << (std::ostream& s, const dd4hep::Delta& data);
std::ostream& operator << (std::ostream& s, const dd4hep::AlignmentData& data);
#endif // DD4HEP_ALIGNMENTDATA_H