FieldMap.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 CERN for the benefit of the SHiP Collaboration
//
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
// In-memory form of a SHiP field map (format specified in
// docs/field_map_format.md). This header has no ROOT or covfie dependency:
// file I/O lives in the MapIO component (SHiP/FieldService/FieldMapIO.h), and
// evaluation is built from a FieldMap via makeFieldEvaluator().
 
#include "SHiP/FieldService/IFieldSource.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
namespace SHiP {
 
struct FieldMapGrid {
    std::array<double, 3> min{};
    std::array<double, 3> max{};
    std::array<std::uint32_t, 3> n{};
 
    [[nodiscard]] std::size_t size() const;
    [[nodiscard]] std::size_t index(std::size_t i, std::size_t j, std::size_t k) const {
        return (i * n[1] + j) * n[2] + k;
    }
    [[nodiscard]] double node(std::size_t axis, std::size_t i) const;
};
 
struct FieldMapSymmetry {
    std::array<bool, 3> mirror{};
    std::array<std::int8_t, 9> parity{1, 1, 1, 1, 1, 1, 1, 1, 1};
 
    [[nodiscard]] bool any() const { return mirror[0] || mirror[1] || mirror[2]; }
 
    [[nodiscard]] static FieldMapSymmetry quadrantDipole();
};
 
struct FieldMapProvenance {
    std::string source;       
    std::string comment;      
    std::string producer;     
    std::string created_utc;  
};
 
struct FieldMap {
    std::string name;
    FieldMapGrid grid;
    FieldMapSymmetry symmetry;
    std::vector<float> bx;
    std::vector<float> by;
    std::vector<float> bz;
    FieldMapProvenance provenance;
};
 
void validate(FieldMap const& map);
 
[[nodiscard]] std::shared_ptr<IFieldEvaluator> makeFieldEvaluator(FieldMap const& map);
 
struct FieldBox {
    std::array<double, 3> min{};
    std::array<double, 3> max{};
 
    [[nodiscard]] bool contains(double x, double y, double z) const;
};
 
[[nodiscard]] FieldBox extent(FieldMap const& map);
 
[[nodiscard]] std::shared_ptr<IFieldEvaluator> translated(std::shared_ptr<IFieldEvaluator> inner,
                                                          std::array<double, 3> const& offset);
 
[[nodiscard]] std::shared_ptr<IFieldEvaluator> zeroOutside(std::shared_ptr<IFieldEvaluator> inner,
                                                           FieldBox const& box);
 
[[nodiscard]] std::string resolveFieldMapPath(std::string const& path);
 
}  // namespace SHiP