Mesh.hpp

/* Copyright 2017-2020 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 <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
    };  //Geometry

    enum class DataOrder : char
    {
        C = 'C',
        F = 'F'
    };  //DataOrder

    Geometry geometry() const;
    Mesh& setGeometry(Geometry g);

    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 >
    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 >
    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