Mesh.hpp

/* Copyright 2017-2021 Fabian Koller
 *
 * 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/backend/Attributable.hpp"
#include "openPMD/backend/BaseRecord.hpp"
#include "openPMD/backend/MeshRecordComponent.hpp"
 
#include <array>
#include <ostream>
#include <string>
#include <type_traits>
#include <vector>
 
 
namespace openPMD
{
class Mesh : public BaseRecord< MeshRecordComponent >
{
    friend class Container< Mesh >;
    friend class Iteration;
 
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& setUnitDimension(std::map< UnitDimension, double > const& unitDimension);
 
    template< typename T >
    T timeOffset() const;
    template< typename T,
              typename = std::enable_if_t<std::is_floating_point< T >::value> >
    Mesh& setTimeOffset(T timeOffset);
 
private:
    Mesh();
 
    void flush_impl(std::string const&) override;
    void read() 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&);
 
} // openPMD