Fields.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_FIELDS_H
#define DD4HEP_GEOMETRY_FIELDS_H

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

// C/C++ include files
#include <vector>
#include <map>

namespace DD4hep {

  namespace Geometry {

    // Forward declarations
    typedef Position Direction;



    class CartesianField: public Ref_t {
    public:
      enum FieldType {
        UNKNOWN = 0, ELECTRIC = 0x1, MAGNETIC = 0x2
      };
      typedef std::map<std::string, std::string> PropertyValues;
      typedef std::map<std::string, PropertyValues> Properties;


      class Object: public NamedObject {
      public:
        int type;
        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>()->type;
      }

      const char* type() const;

      bool changesEnergy() const;

      void value(const Position& pos, Direction& field) const;   // { value(pos,&field.x); }

      void value(const Position& pos, double* val) const;   //      { value(&pos.x,val);   }

      void value(const double* pos, double* val) const;

      Properties& properties() const;
    };

    typedef CartesianField ElectricField;
    typedef CartesianField MagneticField;


    class OverlayedField: public Ref_t {
    public:
      enum FieldType {
        ELECTRIC = 0x1, MAGNETIC = 0x2
      };
      typedef std::map<std::string, std::string> PropertyValues;
      typedef std::map<std::string, PropertyValues> Properties;


      class Object: public NamedObject {
      public:
        int type;
        DD4hep::Geometry::CartesianField electric;
        DD4hep::Geometry::CartesianField magnetic;
        std::vector<DD4hep::Geometry::CartesianField> electric_components;
        std::vector<DD4hep::Geometry::CartesianField> magnetic_components;
        Properties properties;
        Object();
        virtual ~Object();
      };

      OverlayedField() = default;

      template <typename Q>  OverlayedField(const Handle<Q>& e) : Ref_t(e) {      }

      OverlayedField(const std::string& name);

      int type() const {
        return data<Object>()->type;
      }

      bool changesEnergy() const;

      void add(CartesianField field);

      void combinedElectric(const Position& pos, double* field) const {
        combinedElectric((const double*) &pos, field);
      }

      void combinedElectric(const double* pos, double* field) const;

      void combinedMagnetic(const Position& pos, double* field) const {
        combinedMagnetic((const double*) &pos, field);
      }

      void combinedMagnetic(const double* pos, double* field) const;

      void electricField(const Position& pos, Direction& field) const {
        electricField((const double*) &pos, (double*) &field);
      }

      void electricField(const Position& pos, double* field) const {
        electricField((double*) &pos, field);
      }

      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, Direction& field) const {
        magneticField((double*) &pos, (double*) &field);
      }

      void magneticField(const Position& pos, double* field) const {
        magneticField((double*) &pos, field);
      }

      void magneticField(const double* pos, double* field) const {
        field[0] = field[1] = field[2] = 0.0;
        CartesianField f = data<Object>()->magnetic;
        f.isValid() ? f.value(pos, field) : combinedMagnetic(pos, field);
      }

      void electromagneticField(const Position& pos, double* val) const {
        electromagneticField((double*) &pos, val);
      }

      void electromagneticField(const double* pos, double* val) const;

      Properties& properties() const;
    };

    typedef OverlayedField ElectroMagneticField;

  } /* End namespace Geometry           */
} /* End namespace DD4hep             */
#endif    /* DD4HEP_GEOMETRY_FIELDS_H         */