Fields.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_FIELDS_H
#define DD4HEP_FIELDS_H
 
// Framework include files
#include <DD4hep/NamedObject.h>
#include <DD4hep/Objects.h>
 
// C/C++ include files
#include <vector>
#include <map>
 
namespace dd4hep {
 
  // Forward declarations
  typedef Position Direction;
 
 
  class CartesianField: public Handle<NamedObject> {
  public:
    enum FieldType {
      UNKNOWN = 0, ELECTRIC = 0x1, MAGNETIC = 0x2, OVERLAY  = 0x4,
    };
    typedef std::map<std::string, std::map<std::string, std::string> > Properties;
 
 
    class TypedObject : public NamedObject {
    public:
      int   field_type { UNKNOWN };
      using NamedObject::NamedObject;
    };
 
 
    class Object: public TypedObject {
    public:
      typedef std::vector<double> Coefficents;
      Properties properties;
      Object();
      virtual ~Object();
 
      virtual void fieldComponents(const double* pos, double* field) = 0;
    };
 
    CartesianField() = default;
 
    CartesianField(const CartesianField& e) = default;
 
    template <typename Q> CartesianField(const Handle<Q>& e) : Ref_t(e) {
    }
 
    CartesianField& operator=(const CartesianField& f) = default;
 
    int fieldType() const {
      return data<Object>()->field_type;
    }
 
    const char* type() const;
 
    bool changesEnergy() const;
 
    void value(const Position& pos, Direction& field) const;
 
    void value(const Position& pos, double* val) const;
 
    void value(const double* pos, double* val) const;
 
    Properties& properties() const;
  };
 
 
  class OverlayedField: public Handle<NamedObject> {
  public:
    enum FieldType {
      ELECTRIC = CartesianField::ELECTRIC,
      MAGNETIC = CartesianField::MAGNETIC,
      OVERLAY  = CartesianField::OVERLAY,
    };
    typedef std::map<std::string, std::string> PropertyValues;
    typedef std::map<std::string, PropertyValues> Properties;
 
 
    class Object: public CartesianField::TypedObject {
    public:
      CartesianField electric;
      CartesianField magnetic;
      std::vector<CartesianField> electric_components;
      std::vector<CartesianField> magnetic_components;
      Properties properties;
 
    public:
      Object();
      virtual ~Object();
    };
 
    OverlayedField() = default;
 
    template <typename Q>  OverlayedField(const Handle<Q>& e) : Ref_t(e) {      }
 
    OverlayedField(const std::string& name);
 
    int fieldType() const {
      return data<Object>()->field_type;
    }
 
    bool changesEnergy() const;
 
    void add(CartesianField field);
 
    void combinedElectric(const Position& pos, double* field) const;
 
    Direction combinedElectric(const Position& pos) const {
      double field[3] = { 0e0, 0e0, 0e0 };
      combinedElectric(pos, field);
      return {field[0], field[1], field[2]};
    }
 
    void combinedElectric(const double* pos, double* field) const   {
      combinedElectric(Position(pos[0], pos[1], pos[2]), field);
    }
 
    void combinedMagnetic(const Position& pos, double* field) const;
 
    Direction combinedMagnetic(const Position& pos) const {
      double field[3] = { 0e0, 0e0, 0e0 };
      combinedMagnetic({pos.X(), pos.Y(), pos.Z()}, field);
      return { field[0], field[1], field[2] };
    }
 
    void combinedMagnetic(const double* pos, double* field) const   {
      combinedMagnetic(Position(pos[0], pos[1], pos[2]), field);
    }
 
    void electricField(const Position& pos, double* field) const;
 
    Direction electricField(const Position& pos) const {
      double field[3] = { 0e0, 0e0, 0e0 };
      electricField(pos, field);
      return { field[0], field[1], field[2] };
    }
 
    void electricField(const Position& pos, Direction& field) const {
      double fld[3] = { 0e0, 0e0, 0e0 };
      electricField(Position(pos.X(), pos.Y(), pos.Z()), fld);
      field = { fld[0], fld[1], fld[2] };
    }
 
    void electricField(const double* pos, double* field) const {
      field[0] = field[1] = field[2] = 0.0;
      CartesianField f = data<Object>()->electric;
      f.isValid() ? f.value(pos, field) : combinedElectric(pos, field);
    }
 
    void magneticField(const Position& pos, double* field) const;
 
    void magneticField(const double* pos, double* field) const   {
      magneticField(Position(pos[0], pos[1], pos[2]), field);
    }
 
    void magneticField(const double* pos, Direction& field) const {
      double fld[3] = { 0e0, 0e0, 0e0 };
      magneticField(Position(pos[0], pos[1], pos[2]), fld);
      field = { fld[0], fld[1], fld[2] };
    }
 
    Direction magneticField(const Position& pos) const {
      double field[3] = { 0e0, 0e0, 0e0 };
      magneticField(pos, field);
      return { field[0], field[1], field[2] };
    }
 
    void electromagneticField(const Position& pos, double* field) const;
 
    void electromagneticField(const double* pos, double* val) const   {
      electromagneticField(Position(pos[0], pos[1], pos[2]), val);
    }
 
    Properties& properties() const;
  };
}         /* End namespace dd4hep             */
#endif // DD4HEP_FIELDS_H