Mesh.hpp

/* Copyright 2017-2025 Fabian Koller, Axel Huebl, Franz Poeschel
 *
 * This file is part of openPMD-api.
 *
 * openPMD-api is free software: you can redistribute it and/or modify
 * it under the terms of of either the GNU General Public License or
 * the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * openPMD-api is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License and the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * and the GNU Lesser General Public License along with openPMD-api.
 * If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once
 
#include "openPMD/UnitDimension.hpp"
#include "openPMD/backend/Attributable.hpp"
#include "openPMD/backend/BaseRecord.hpp"
#include "openPMD/backend/Container.hpp"
#include "openPMD/backend/MeshRecordComponent.hpp"
#include "openPMD/backend/scientific_defaults/ScientificDefaults.hpp"
#include "openPMD/backend/scientific_defaults/ScientificDefaults_auxiliary.hpp"
 
#include <ostream>
#include <string>
#include <type_traits>
#include <vector>
 
namespace openPMD
{
class Mesh : public BaseRecord<MeshRecordComponent>
{
    friend class Container<Mesh>;
    friend class Iteration;
    friend class internal::ScientificDefaults;
    friend class Attributable;
 
public:
    Mesh(Mesh const &) = default;
    Mesh &operator=(Mesh const &) = default;
    ~Mesh() override = default;
 
    enum class Geometry
    {
        cartesian,
        thetaMode,
        cylindrical,
        spherical,
        other
    }; // Geometry
 
    enum class DataOrder : char
    {
        C = 'C',
        F = 'F'
    }; // DataOrder
 
    Geometry geometry() const;
    std::string geometryString() const;
    Mesh &setGeometry(Geometry g);
    Mesh &setGeometry(std::string geometry);
 
    std::string geometryParameters() const;
    Mesh &setGeometryParameters(std::string const &geometryParameters);
 
    DataOrder dataOrder() const;
    Mesh &setDataOrder(DataOrder dor);
 
    std::vector<std::string> axisLabels() const;
    Mesh &setAxisLabels(std::vector<std::string> const &axisLabels);
 
    template <typename T>
    std::vector<T> gridSpacing() const;
    template <
        typename T,
        typename = std::enable_if_t<std::is_floating_point<T>::value>>
    Mesh &setGridSpacing(std::vector<T> const &gridSpacing);
 
    std::vector<double> gridGlobalOffset() const;
    Mesh &setGridGlobalOffset(std::vector<double> const &gridGlobalOffset);
 
    double gridUnitSI() const;
    Mesh &setGridUnitSI(double gridUnitSI);
 
    Mesh &setGridUnitSI(std::vector<double> const &gridUnitSI);
 
    std::vector<double> gridUnitSIPerDimension() const;
 
    /* Set the unit-conversion factors per axis to multiply each value in
     * Mesh::gridSpacing and Mesh::gridGlobalOffset, in order to convert from
     * simulation units to SI units.
     *
     * Valid for openPMD 2.*.
     * The legacy behavior (openPMD 1.*, a scalar gridUnitSI) is implemented
     * by `setGridUnitSI(double)`.
     *
     * @param   gridUnitSI  unit-conversion factor to multiply each value in
     * Mesh::gridSpacing and Mesh::gridGlobalOffset, in order to convert from
     * simulation units to SI units.
     *
     * @return  Reference to modified mesh.
     */
    Mesh &setGridUnitSIPerDimension(std::vector<double> const &gridUnitSI);
 
    Mesh &setUnitDimension(unit_representations::AsMap const &unitDimension);
 
    Mesh &setUnitDimension(unit_representations::AsArray const &unitDimension);
 
    Mesh &
    setGridUnitDimension(unit_representations::AsMaps const &gridUnitDimension);
 
    Mesh &setGridUnitDimension(
        unit_representations::AsArrays const &gridUnitDimension);
 
    unit_representations::AsArrays gridUnitDimension() const;
 
    template <typename T>
    T timeOffset() const;
    template <
        typename T,
        typename = std::enable_if_t<std::is_floating_point<T>::value>>
    Mesh &setTimeOffset(T timeOffset);
 
    void visitHierarchy(HierarchyVisitor &v, bool recursive) override;
 
private:
    Mesh();
 
    void
    flush_impl(std::string const &, internal::FlushParams const &) override;
    void read();
    auto retrieveDimensionality() const -> uint64_t;
 
protected:
    void scientificDefaults_impl(
        internal::WriteOrRead, OpenpmdStandard) override;
}; // Mesh
 
template <typename T>
inline std::vector<T> Mesh::gridSpacing() const
{
    return readVectorFloatingpoint<T>("gridSpacing");
}
 
template <typename T>
inline T Mesh::timeOffset() const
{
    return readFloatingpoint<T>("timeOffset");
}
 
std::ostream &operator<<(std::ostream &, openPMD::Mesh::Geometry const &);
 
std::ostream &operator<<(std::ostream &, openPMD::Mesh::DataOrder const &);
 
} // namespace openPMD