Objects.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_GEOMETRY_OBJECTS_H
#define DD4HEP_GEOMETRY_OBJECTS_H

// Framework include files
#include "DD4hep/Handle.h"
#include "DD4hep/NamedObject.h"

// Forward declarations
class TMap;
class TGeoElement;
class TGeoMaterial;
class TGeoMedium;
class TGeoMatrix;
class TGeoRotation;
class TGeoTranslation;
class TGeoPhysicalNode;
class TGeoIdentity;

#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated" // Code that causes warning goes here
#endif
// ROOT include files
#include "TGeoPhysicalNode.h"
#include "Math/Vector3D.h"
#include "Math/Transform3D.h"
#include "Math/Translation3D.h"
#include "Math/RotationX.h"
#include "Math/RotationY.h"
#include "Math/RotationZ.h"
#include "Math/Rotation3D.h"
#include "Math/RotationZYX.h"
#include "Math/EulerAngles.h"
#include "Math/VectorUtil.h"
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif

// C/C++ include files
#include <set>
#include <cmath>
#include <limits>
#include <vector>

#define _USE_MATH_DEFINES
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

namespace DD4hep {

  namespace Geometry {

    // Forward declarations
    class LCDD;
    class IDDescriptor;
    class VisAttrObject;
    class HeaderObject;
    class ConstantObject;
    class RegionObject;
    class LimitSetObject;

    typedef ROOT::Math::XYZVector Position;
    template <class V> V RotateX(const V& v, double a) {
      return ROOT::Math::VectorUtil::RotateX(v, a);
    }
    template <class V> V RotateY(const V& v, double a) {
      return ROOT::Math::VectorUtil::RotateY(v, a);
    }
    template <class V> V RotateZ(const V& v, double a) {
      return ROOT::Math::VectorUtil::RotateZ(v, a);
    }

    typedef ROOT::Math::RotationZYX   RotationZYX;
    typedef ROOT::Math::RotationZ     RotationZ;
    typedef ROOT::Math::RotationY     RotationY;
    typedef ROOT::Math::RotationX     RotationX;
    typedef ROOT::Math::Rotation3D    Rotation3D;
    typedef ROOT::Math::EulerAngles   EulerAngles;
    typedef ROOT::Math::Transform3D   Transform3D;
    typedef ROOT::Math::Translation3D Translation3D;

    TGeoIdentity* identityTransform();

    

    class Author: public Ref_t {
    public:
      typedef NamedObject Object;
      Author()
        : Ref_t() {
      }
      Author(const Author& e)
        : Ref_t(e) {
      }
      template <typename Q>
      Author(const Handle<Q>& e)
        : Ref_t(e) {
      }
      Author(LCDD& doc);
      Author& operator=(const Author& e)  {
        if ( this != & e )  {
          m_element = e.m_element;
        }
        return *this;
      }
      std::string authorName() const;
      void setAuthorName(const std::string& nam);
      std::string authorEmail() const;
      void setAuthorEmail(const std::string& addr);
    };


    class Header: public Handle<HeaderObject> {
    public:
      typedef HeaderObject Object;
      Header()
        : Handle<HeaderObject>() {
      }
      Header(const Header& e)
        : Handle<HeaderObject>(e) {
      }
      template <typename Q> Header(const Handle<Q>& e)
        : Handle<HeaderObject>(e) {
      }
      Header(const std::string& author, const std::string& url);
      Header& operator=(const Header& e)  {
        if ( this != & e )  {
          m_element = e.m_element;
        }
        return *this;
      }
      const std::string name() const;
      void setName(const std::string& new_name);
      const std::string title() const;
      void setTitle(const std::string& new_title);
      const std::string& author() const;
      void setAuthor(const std::string& new_author);
      const std::string& url() const;
      void setUrl(const std::string& new_url);
      const std::string& status() const;
      void setStatus(const std::string& new_status);
      const std::string& version() const;
      void setVersion(const std::string& new_version);
      const std::string& comment() const;
      void setComment(const std::string& new_comment);
    };


    class Constant: public Handle<ConstantObject> {
    public:
      typedef ConstantObject Object;
      Constant()
        : Handle<ConstantObject> () {
      }
      Constant(const Constant& e)
        : Handle<ConstantObject> (e) {
      }
      template <typename Q>
      Constant(const Handle<Q>& e)
        : Handle<ConstantObject> (e) {
      }
      Constant(const std::string& name);
      Constant(const std::string& name, const std::string& val, const std::string& typ="number");
      std::string dataType() const;
      std::string toString() const;
    };


    class Atom: public Handle<TGeoElement> {
    public:
      typedef TGeoElement Object;
      Atom()
        : Handle<Object>() {
      }
#ifndef __CINT__
      Atom(const Handle<Object>& e)
        : Handle<Object>(e) {
      }
#endif
      template <typename Q>
      Atom(const Handle<Q>& e)
        : Handle<Object>(e) {
      }
      Atom(const std::string& name, const std::string& formula, int Z, int N, double density);
    };


    class Material: public Handle<TGeoMedium> {
    public:
      typedef TGeoMedium Object;

      Material()
        : Handle<Object>() {
      }
#ifndef __CINT__
      Material(const Handle<Object>& e)
        : Handle<Object>(e) {
      }
#endif
      template <typename Q>
      Material(const Handle<Q>& e)
        : Handle<Object>(e) {
      }
      double Z() const ;
      double A() const ;
      double density() const ;
      std::string toString() const;
      double radLength() const;
      double intLength() const;
    };


    class VisAttr: public Handle<VisAttrObject> {
    public:
      enum Style {
        SOLID = 0x1, WIREFRAME = 0x2, DASHED = 0x2, LAST_STYLE
      };
      typedef VisAttrObject Object;
      VisAttr()
        : Handle<Object>() {
      }
      VisAttr(const VisAttr& e)
        : Handle<Object>(e) {
      }
#ifndef __CINT__
      VisAttr(const Handle<Object>& e)
        : Handle<Object>(e) {
      }
#endif
      template <typename Q>
      VisAttr(const Handle<Q>& e)
        : Handle<Object>(e) {
      }
      VisAttr(const std::string& name);
      VisAttr(const char* name);
      VisAttr& operator=(const VisAttr& attr) {
        m_element = attr.m_element;
        return *this;
      }

      bool showDaughters() const;
      void setShowDaughters(bool value);

      bool visible() const;
      void setVisible(bool value);

      int lineStyle() const;
      void setLineStyle(int style);

      int drawingStyle() const;
      void setDrawingStyle(int style);

      float alpha() const;
      void setAlpha(float value);

      int color() const;
      void setColor(float red, float green, float blue);

      bool rgb(float& red, float& green, float& blue) const;

      std::string toString() const;
    };


    class AlignmentEntry: public Handle<TGeoPhysicalNode> {
    public:
      typedef Handle<TGeoPhysicalNode> Base;
      template <typename Q>
      AlignmentEntry(const Handle<Q>& h)
        : Base(h) {
      }
      AlignmentEntry(const std::string& path);
      int align(const Position& pos, bool check = false, double overlap = 0.001);
      int align(const RotationZYX& rot, bool check = false, double overlap = 0.001);
      int align(const Position& pos, const RotationZYX& rot, bool check = false, double overlap = 0.001);
    };


    class Limit {
    public:
      std::string particles;
      std::string name;
      std::string unit;
      std::string content;
      double value;
      Limit()
        : particles(), name(), unit(), content(), value(0.0) {
      }
      Limit(const Limit& c)
        : particles(c.particles), name(c.name), unit(c.unit), content(c.content), value(c.value) {
      }
      Limit& operator=(const Limit& c);
      bool operator==(const Limit& c) const;
      bool operator<(const Limit& c) const;
      std::string toString() const;
    };


    class LimitSet: public Handle<LimitSetObject> {
    public:
      typedef LimitSetObject Object;
      LimitSet()
        : Handle<LimitSetObject>() {
      }
      LimitSet(const LimitSet& e)
        : Handle<LimitSetObject>(e) {
      }
#ifndef __CINT__
      LimitSet(const Handle<LimitSetObject>& e)
        : Handle<LimitSetObject>(e) {
      }
#endif
      template <typename Q>
      LimitSet(const Handle<Q>& e)
        : Handle<LimitSetObject>(e) {
      }
      LimitSet& operator=(const LimitSet& c)  {
        m_element = c.m_element;
        return *this;
      }
      LimitSet(const std::string& name);
      bool addLimit(const DD4hep::Geometry::Limit& limit);
      const std::set<DD4hep::Geometry::Limit>& limits() const;
    };


    class Region: public Handle<RegionObject> {
    public:
      typedef RegionObject Object;
      Region()
        : Handle<Object>() {
      }
      Region(const Region& e)
        : Handle<Object>(e) {
      }
#ifndef __CINT__
      Region(const Handle<RegionObject>& e)
        : Handle<Object>(e) {
      }
#endif
      template <typename Q>
      Region(const Handle<Q>& e)
        : Handle<Object>(e) {
      }
      Region(const std::string& name);
      Region& operator=(const Region& c)  {
        m_element = c.m_element;
        return *this;
      }

      Region& setStoreSecondaries(bool value);
      Region& setThreshold(double value);
      Region& setCut(double value);
      std::vector<std::string>& limits() const;

      double cut() const;
      double threshold() const;
      bool storeSecondaries() const;
    };

  } /* End namespace Geometry           */
}   /* End namespace DD4hep             */

#include "Math/Vector4D.h"
#include "Math/Point3D.h"

namespace ROOT {
  namespace Math {
    typedef DD4hep::Geometry::Position Position;
    inline double operator *(const Position& l, const Position& r) {
      return std::sqrt(l.X() * r.X() + l.Y() * r.Y() + l.Z() * r.Z());
    }
    inline double mean_length(const Position& p1, const Position& p2) {
      return 0.5 * (p1.R() + p2.R()) / 2.0;
    }
    inline Position mean_direction(const Position& p1, const Position& p2) {
      return 0.5 * (p1 + p2);
    }

    // These operators are used for component properties.
    // The implementation is in the parsers, but since the parsers
    // do not have public include files, they are defined here.

    bool operator<(const XYZPoint& a, const XYZPoint& b);
    bool operator<(const XYZVector& a, const XYZVector& b);
    bool operator<(const PxPyPzEVector& a, const PxPyPzEVector& b);
  }
}

#endif    /* DD4HEP_GEOMETRY_OBJECTS_H        */