gfield.h

Go to the documentation of this file.

#pragma once
 
// G4 headers
#include "G4MagneticField.hh"
#include "G4FieldManager.hh"
 
// gemc
#include "gfactory.h"
#include "gbase.h"
 
 
constexpr const char* GFIELD_LOGGER = "gfield";
constexpr const char* GMAGNETO_LOGGER = "gmagneto";
 
struct GFieldDefinition {
    GFieldDefinition() = default;
 
    std::string name;                
    std::string integration_stepper; 
    double      minimum_step;        
    std::string type;                
 
    std::map<std::string, std::string> field_parameters; 
 
    void add_map_parameter(const std::string& key, const std::string& value) { field_parameters[key] = value; }
 
    std::string gfieldPluginName() const { return "gfield" + type + "Factory"; }
 
    // overload << to print the field definition
    friend std::ostream& operator<<(std::ostream& stream, GFieldDefinition gfd) {
        stream << "  > Field name:            " << gfd.name << std::endl;
        stream << "    - integration stepper  " << gfd.integration_stepper << std::endl;
        stream << "    - minimum step         " << gfd.minimum_step << " mm" << std::endl;
        stream << "    - type                 " << gfd.type << std::endl;
 
        // print the field parameters
        // align the keys to the left
        for (auto& field_parameter : gfd.field_parameters) { stream << "    - " << std::left << std::setw(21) << field_parameter.first << field_parameter.second << std::endl; }
 
        return stream;
    }
};
 
class GField : public GBase<GField>, public G4MagneticField {
 
public:
    //GField() = default;
    explicit GField(const std::shared_ptr<GOptions>& gopt) : GBase(gopt, GFIELD_LOGGER) {}
 
    virtual void GetFieldValue(const double x[3], double* bfield) const = 0;
 
    G4FieldManager* create_FieldManager();
 
    virtual void load_field_definitions(GFieldDefinition gfd) { gfield_definitions = gfd; }
 
    int    get_field_parameter_int(const std::string& key) { return stoi(gfield_definitions.field_parameters[key]); }
    double get_field_parameter_double(const std::string& key) { return stod(gfield_definitions.field_parameters[key]); }
 
    void set_loggers([[ maybe_unused ]] const std::shared_ptr<GOptions>& g) {
    }
 
private:
    // TODO: make this list automatic
    std::vector<std::string> SUPPORTED_STEPPERS = { 
        "G4DormandPrince745",
        "G4ClassicalRK4",
        "G4SimpleRunge",
        "G4HelixExplicitEuler",
        "G4HelixImplicitEuler",
        "G4CashKarpRKF45",
        "G4RKG3_Stepper",
        "G4SimpleHeum",
        "G4NystromRK4",
        "G4ImplicitEuler",
        "G4ExplicitEuler"
    };
 
protected:
    GFieldDefinition gfield_definitions;
 
public:
    static GField* instantiate(const dlhandle h, std::shared_ptr<GOptions> g) {
        if (!h) return nullptr;
        using fptr = GField* (*)(std::shared_ptr<GOptions>);
 
        // Must match the extern "C" declaration in the derived factories.
        auto sym = dlsym(h, "GFieldFactory");
        if (!sym) return nullptr;
 
        auto func = reinterpret_cast<fptr>(sym);
        return func(g);
    }
 
};