Objects.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_OBJECTS_H
#define DD4HEP_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 <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>
#include <TGeoElement.h>
#include <TGeoMaterial.h>
#include <TGeoMedium.h>
#include <TGeoPhysicalNode.h>
#include <TGDMLMatrix.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 {
 
  // Forward declarations
  class Detector;
  class IDDescriptor;
  class VisAttrObject;
  class HeaderObject;
  class ConstantObject;
  class RegionObject;
  class LimitSetObject;
 
  typedef ROOT::Math::RhoZPhiVector PositionRhoZPhi;
  typedef ROOT::Math::Polar3DVector PositionPolar;
  typedef ROOT::Math::XYZVector     Position;
  typedef ROOT::Math::XYZVector     Direction;
  typedef ROOT::Math::XYZVector     XYZAngles;
  
  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;
 
 
 
  class Author: public Ref_t {
  public:
    Author() = default;
    Author(const Author& e) = default;
    template <typename Q> Author(const Handle<Q>& e) : Ref_t(e) {   }
    Author(Detector& doc);
    Author& operator=(const Author& e) = default;
    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:
    Header() = default;
    Header(const Header& copy) = default;
    template <typename Q> Header(const Handle<Q>& e) : Handle<HeaderObject>(e) {  }
    Header(const std::string& author, const std::string& url);
    Header& operator=(const Header& copy) = default;
    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:
    Constant() = default;
    Constant(const Constant& copy) = default;
    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");
    Constant& operator=(const Constant& copy) = default;
    bool operator==(const Constant& rhs) const   {
      return m_element == rhs.m_element;
    }
    std::string dataType() const;
    std::string toString() const;
  };
 
 
  class Atom: public Handle<TGeoElement> {
  public:
    Atom() = default;
    Atom(const Atom& copy) = default;
    Atom(Object* e) : Handle<Object>(e) { }
#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);
    Atom& operator=(const Atom& copy) = default;
  };
 
 
  class Material: public Handle<TGeoMedium> {
  public:
    typedef const TGDMLMatrix* Property;
 
  public:
    Material() = default;
    Material(const Material& copy) = default;
    Material(Object* e) : Handle<Object>(e) { }
#ifndef __CINT__
    Material(const Handle<Object>& e) : Handle<Object>(e) { }
#endif
    template <typename Q> Material(const Handle<Q>& e) : Handle<Object>(e) {  }
    Material& operator=(const Material& copy) = default;
    double Z() const ;
    double A() const ;
    double density() const ;
    std::string toString() const;
    double radLength() const;
    double intLength() const;
    double fraction(Atom atom) const;
    Property property(const char* name)  const;
    Property property(const std::string& name)  const;
    std::string propertyRef(const std::string& name, const std::string& default_value="");
    double constProperty(const std::string& name)  const;
    std::string constPropertyRef(const std::string& name, const std::string& default_value="");
  };
 
 
  class VisAttr: public Handle<VisAttrObject> {
  public:
    enum Style {
      SOLID = 0x1, WIREFRAME = 0x2, DASHED = 0x2, LAST_STYLE
    };
    VisAttr() = default;
    VisAttr(const VisAttr& e) = default;
#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) = default;
 
    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;
 
    int color() const;
    void setColor(float alpha, float red, float green, float blue);
 
    bool rgb(float& red, float& green, float& blue) const;
    bool argb(float& alpha, float& red, float& green, float& blue) const;
 
    std::string toString() const;
  };
 
 
  class Limit {
  public:
    std::string particles;
    std::string name;
    std::string unit;
    std::string content;
    double value = 0.0;
  public:
    Limit() = default;
    Limit(const Limit& c) = default;
    Limit& operator=(const Limit& c) = default;
    bool operator==(const Limit& c) const;
    bool operator<(const Limit& c) const;
    std::string toString() const;
  };
 
 
  class LimitSet: public Handle<LimitSetObject> {
  public:
    typedef std::set<Limit>                 Set;
    typedef std::set<Limit>::iterator       iterator;
    typedef std::set<Limit>::const_iterator const_iterator;
  public:
    LimitSet() = default;
    LimitSet(const LimitSet& e) = default;
#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) = default;
    LimitSet(const std::string& name);
    bool addLimit(const Limit& limit);
    const std::set<Limit>& limits() const;
    bool addCut(const Limit& limit);
    const std::set<Limit>& cuts() const;
  };
 
 
  class Region: public Handle<RegionObject> {
  public:
    Region() = default;
    Region(const Region& e) = default;
#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)  = default;
 
    Region& setStoreSecondaries(bool value);
    Region& setThreshold(double value);
    Region& setCut(double value);
    Region& setCut(double value, const std::string& particle);
 
    std::vector<std::string>& limits() const;
 
    double cut() const;
    double threshold() const;
    bool storeSecondaries() const;
    bool useDefaultCut() const;
    bool wasThresholdSet() const;
  };
 
}   /* End namespace dd4hep             */
 
#include <Math/Vector4D.h>
#include <Math/Point3D.h>
 
namespace ROOT {
  namespace Math {
    inline double operator *(const dd4hep::Position& l, const dd4hep::Position& r) {
      return std::sqrt(l.X() * r.X() + l.Y() * r.Y() + l.Z() * r.Z());
    }
    inline double mean_length(const dd4hep::Position& p1, const dd4hep::Position& p2) {
      return 0.5 * (p1.R() + p2.R()) / 2.0;
    }
    inline dd4hep::Position mean_direction(const dd4hep::Position& p1, const dd4hep::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_OBJECTS_H