gfield_asciimap.h

Go to the documentation of this file.

#pragma once
 
// gemc gfield framework
#include "gfield.h"
 
// c++
#include <array>
#include <optional>
#include <string>
#include <vector>


class GField_AsciiMapFactory : public GField {
 
public:
    explicit GField_AsciiMapFactory(const std::shared_ptr<GOptions>& gopt) : GField(gopt) {}

    void GetFieldValue(const double pos[3], G4double* bfield) const override;

    void load_field_definitions(GFieldDefinition gfd) override;
 
private:
    enum class Symmetry {
        dipole_x, dipole_y, dipole_z,
        cyl_x, cyl_y, cyl_z,
        phi_segmented,
        cartesian_3d, cartesian_3d_quadrant
    };
 
    Symmetry symmetry = Symmetry::dipole_z;
    int      ndim     = 2; 
    int      ncomp    = 1; 
    bool     linear   = true; 
 
    // Grid geometry in canonical per-symmetry axis order (see class documentation).
    std::array<unsigned, 3> np       = {0, 0, 0};
    std::array<double, 3>   startMap  = {0.0, 0.0, 0.0};
    std::array<double, 3>   endMap    = {0.0, 0.0, 0.0};
    std::array<double, 3>   cellSize  = {1.0, 1.0, 1.0};
 
    // One map-file column per grid coordinate, in file-column order (coordinate1, coordinate2, ...).
    struct Column {
        int    axis       = 0;   
        double unitFactor = 1.0; 
    };
    std::vector<Column> columns;
 
    // Field buffers (contiguous). B2/B3 stay empty for symmetries that do not use them.
    std::vector<float> B1;
    std::vector<float> B2;
    std::vector<float> B3;
 
    // Overall placement (lab frame). Origin in Geant4 length units, rotation in radians.
    double mapOrigin[3]   = {0.0, 0.0, 0.0};
    double mapRotation[3] = {0.0, 0.0, 0.0};
    double sinAlpha = 0.0, cosAlpha = 1.0; // about X
    double sinBeta  = 0.0, cosBeta  = 1.0; // about Y
    double sinGamma = 0.0, cosGamma = 1.0; // about Z
 
    // Flat indexing helpers (canonical axis order).
    inline std::size_t idx2(unsigned i0, unsigned i1) const { return static_cast<std::size_t>(i0) * np[1] + i1; }
    inline std::size_t idx3(unsigned i0, unsigned i1, unsigned i2) const {
        return (static_cast<std::size_t>(i0) * np[1] + i1) * np[2] + i2;
    }
 
    // Per-symmetry field evaluation (point already shifted by mapOrigin).
    void value_dipole(const double x[3], double* bfield) const;
    void value_cylindrical(const double x[3], double* bfield) const;
    void value_phi_segmented(const double x[3], double* bfield) const;
    void value_cartesian3d(const double x[3], double* bfield) const;
 
    // Rotate the field vector (not the point): each rotation is the inverse of the point rotation.
    void rotate_field(double* bfield) const;
 
    // Configuration helpers (the generic node only guarantees name/type).
    std::string param_string(const std::string& key, const std::string& dflt) const;
    double      param_g4number(const std::string& key, const std::string& dflt) const;
 
    // Map the canonical axis of a coordinate name for the current symmetry, or return nullopt if invalid.
    std::optional<unsigned> axis_of_coordinate(const std::string& name) const;
 
    // Parse one "name, npoints, min, max" coordinate string into the grid arrays and a Column.
    void load_coordinate(const std::string& key);
 
    // Read the map file and fill the field buffers.
    void load_map_file();
 
    // Default field-map directory: <plugin_dir>/../fields (the `meson install` layout). No env var.
    std::string field_maps_directory() const;
};