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 = 0.0;
 
    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"; }
 
    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, aligning keys for readability.
        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:
    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:
    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, const std::shared_ptr<GOptions> g) {
        if (!h) return nullptr;
        using fptr = GField* (*)(const 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);
    }
};