C++ API Reference

template<class T>
class ArangeContainer

helper class to generate range iterators

Public Types

using iterator = iterators::ArangeIterator<T>

undocumented

Public Functions

inline constexpr ArangeContainer(T start, T stop, T step = 1)

undocumented

inline explicit constexpr ArangeContainer(T stop)

undocumented

inline constexpr T operator[](size_t i)

undocumented

inline constexpr T size()

undocumented

inline constexpr iterator begin()

undocumented

inline constexpr iterator end()

undocumented

Private Members

const T start = {0}

const T stop = {0}

const T step = {1}

template<class T>
class ArangeIterator

emulates python’s range iterator

Public Types

using value_type = T

undocumented

using pointer = T*

undocumented

using reference = T&

undocumented

using iterator_category = std::input_iterator_tag

undocumented

Public Functions

inline constexpr ArangeIterator(T value, T step)

undocumented

constexpr ArangeIterator(const ArangeIterator&) = default

undocumented

inline constexpr ArangeIterator &operator++()

undocumented

inline constexpr const T &operator*() const

undocumented

inline constexpr bool operator==(const ArangeIterator &other) const

undocumented

inline constexpr bool operator!=(const ArangeIterator &other) const

undocumented

Private Members

T value = {0}

const T step = {1}

template<Dim_t Rank>
struct AxisTransformer

template<>
struct AxisTransformer<firstOrder>

Public Static Functions

template<class T1, class T2>
static inline decltype(auto) push_forward(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &F)

template<class T1, class T2>
static inline decltype(auto) pull_back(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &F)

template<>
struct AxisTransformer<fourthOrder>

Public Static Functions

template<class T4, class T2>
static inline decltype(auto) push_forward(const Eigen::MatrixBase<T4> &t4, const Eigen::MatrixBase<T2> &F)

template<class T4, class T2>
static inline decltype(auto) pull_back(const Eigen::MatrixBase<T4> &t4, const Eigen::MatrixBase<T2> &F)

template<>
struct AxisTransformer<secondOrder>

Public Static Functions

template<class T2, class T2_F>
static inline decltype(auto) push_forward(const Eigen::MatrixBase<T2> &t2, const Eigen::MatrixBase<T2_F> &F)

template<class T2, class T2_F>
static inline decltype(auto) pull_back(const Eigen::MatrixBase<T2> &t2, const Eigen::MatrixBase<T2_F> &F)

template<Dim_t order, typename Fun_t, Dim_t dim, Dim_t... args>
struct CallSizesHelper

#include <eigen_tools.hh>

Call a passed lambda with the unpacked sizes as arguments.

Public Static Functions

static inline decltype(auto) call(Fun_t &&fun)

applies the call

template<typename Fun_t, Dim_t dim, Dim_t... args>
struct CallSizesHelper<0, Fun_t, dim, args...>

#include <eigen_tools.hh>

Call a passed lambda with the unpacked sizes as arguments.

Public Static Functions

static inline decltype(auto) call(Fun_t &&fun)

applies the call

class CartesianCommunicator : public muGrid::Communicator

Public Types

using Parent_t = Communicator

Public Functions

explicit CartesianCommunicator(const Parent_t &parent, const DynCcoord_t &nb_subdivisions)

Construct a Cartesian communicator from the parent communicator with specified shape.

Parameters:

• parent – the communicator of parent type

• nb_subdivisions – number of subdivisions in each direction

CartesianCommunicator() = delete

inline virtual ~CartesianCommunicator()

CartesianCommunicator &operator=(const CartesianCommunicator &other)

const DynCcoord_t &get_nb_subdivisions() const

const DynCcoord_t &get_coordinates() const

void sendrecv_right(int direction, int block_len, int stride_in_next_dim, int nb_block, Index_t send_offset, Index_t recv_offset, char *begin_addr, int stride_in_direction, int elem_size_in_bytes) const

void sendrecv_left(int direction, int block_len, int stride_in_next_dim, int nb_block, Index_t send_offset, Index_t recv_offset, char *begin_addr, int stride_in_direction, int elem_size_in_bytes) const

Protected Attributes

Parent_t parent

DynCcoord_t nb_subdivisions

DynCcoord_t coordinates

class CartesianContainer

Public Functions

CartesianContainer() = delete

Default constructor.

explicit CartesianContainer(const Shape_t &shape, const Shape_t &strides)

Constructor from shape.

CartesianContainer(const CartesianContainer &other) = delete

Copy constructor.

CartesianContainer(CartesianContainer &&other) = default

Move constructor.

virtual ~CartesianContainer() = default

Destructor.

CartesianContainer &operator=(const CartesianContainer &other) = delete

Copy assignment operator.

CartesianContainer &operator=(CartesianContainer &&other) = default

Move assignment operator.

inline Index_t get_nb_dim() const

inline iterator begin() const

inline iterator end() const

Protected Attributes

Shape_t shape

Shape_t axes_order

class CartesianDecomposition : public muGrid::Decomposition

Public Types

using Parent_t = Decomposition

using SubPtMap_t = FieldCollection::SubPtMap_t

Public Functions

CartesianDecomposition(const Communicator &comm, const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdivisions, const DynCcoord_t &nb_ghost_left, const DynCcoord_t &nb_ghost_right, const SubPtMap_t &nb_sub_pts = {})

CartesianDecomposition() = delete

inline virtual ~CartesianDecomposition()

virtual void communicate_ghosts(std::string field_name) const

fill the ghost buffers with the values from the neighboring processes.

GlobalFieldCollection &get_collection() const

get the field collection

const DynCcoord_t get_nb_subdivisions() const

get the number of subdivisions

const DynCcoord_t get_nb_domain_grid_pts() const

get the number of grid points of the whole domain

const DynCcoord_t get_nb_subdomain_grid_pts() const

get the number of grid points per subdomain

const DynCcoord_t get_subdomain_locations() const

get the subdomain locations

Protected Attributes

std::unique_ptr<GlobalFieldCollection> collection

DynCcoord_t nb_ghosts_left

DynCcoord_t nb_ghosts_right

CartesianCommunicator comm

class Communicator

#include <communicator.hh>

stub communicator object that doesn’t communicate anything

Subclassed by muGrid::CartesianCommunicator

Public Functions

inline Communicator()

inline ~Communicator()

inline int rank() const

get rank of present process

inline int size() const

get total number of processes

inline void barrier()

Barrier syncronization, nothing to be done in serial.

template<typename T>
inline T sum(const T &arg) const

sum reduction on scalar types

template<typename T>
inline DynMatrix_t<T> sum(const Eigen::Ref<DynMatrix_t<T>> &arg) const

sum on EigenMatrix types

template<typename T>
inline T max(const T &arg) const

max reduction on scalar types

template<typename T>
inline T cumulative_sum(const T &arg) const

ordered partial cumulative sum on scalar types. Find more details in the doc of the into the parallel implementation.

template<typename T>
inline T gather(const T &arg) const

gather on scalar types

template<typename T>
inline DynMatrix_t<T> gather(const Eigen::Ref<DynMatrix_t<T>> &arg) const

gather on EigenMatrix types

template<typename T>
inline T bcast(T &arg, const Int&)

broadcast of scalar types

inline bool logical_or(const bool &arg) const

return logical and

inline bool logical_and(const bool &arg) const

return logical and

Public Static Functions

static inline bool has_mpi()

find whether the underlying communicator is mpi

class ConvolutionOperator : public muGrid::ConvolutionOperatorBase

#include <convolution_operator.hh>

Implements convolution operations that can be applied pixel-wise to the field.

This class extends ConvolutionOperatorBase to provide specific implementations for gradient and divergence operations based on the shape function gradients for each quadrature point. It is designed to work with fields defined on nodal points and quadrature points, facilitating the evaluation of gradients and the discretised divergence.

Note

This class cannot be instantiated directly and does not support copy construction or copy assignment.

Public Types

using Parent = ConvolutionOperatorBase

Public Functions

ConvolutionOperator() = delete

Default constructor is deleted to prevent instantiation.

ConvolutionOperator(const Eigen::MatrixXd &pixel_operator, const Shape_t &conv_pts_shape, const Index_t &nb_pixelnodal_pts, const Index_t &nb_quad_pts, const Index_t &nb_operators)

Constructs a ConvolutionOperator object. It initializes the convolution operator with the provided pixel-wise operator, and necessary information to indicate its shape.

Parameters:

• pixel_operator – The pixel-wise operator raveled as a matrix.

• conv_pts_shape – Shape of convolution points.

• nb_pixelnodal_pts – Number of pixel nodal points.

• nb_quad_pts – Number of quadrature points per pixel.

• nb_operators – Number of operators.

ConvolutionOperator(const ConvolutionOperator &other) = delete

Copy constructor.

ConvolutionOperator(ConvolutionOperator &&other) = default

Move constructor.

virtual ~ConvolutionOperator() = default

Destructor.

ConvolutionOperator &operator=(const ConvolutionOperator &other) = delete

Copy assignment operator.

ConvolutionOperator &operator=(ConvolutionOperator &&other) = default

Move assignment operator.

virtual void apply(const TypedFieldBase<Real> &nodal_field, TypedFieldBase<Real> &quadrature_point_field) const final

Evaluates the gradient of nodal_field into quadrature_point_field

Parameters:

• nodal_field – input field of which to take gradient. Defined on nodal points

• quadrature_point_field – output field to write gradient into. Defined on quadrature points

virtual void apply_increment(const TypedFieldBase<Real> &nodal_field, const Real &alpha, TypedFieldBase<Real> &quadrature_point_field) const override

Evaluates the gradient of nodal_field and adds it to quadrature_point_field

Parameters:

• nodal_field – input field of which to take gradient. Defined on nodal points

• quadrature_point_field – output field to increment by the gradient field. Defined on quadrature points

virtual void transpose(const TypedFieldBase<Real> &quadrature_point_field, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const final

Evaluates the discretised divergence of quadrature_point_field into nodal_field, weights corrensponds to Gaussian quadrature weights. If weights are omitted, this returns some scaled version of discretised divergence.

Parameters:

• quadrature_point_field – input field of which to take the divergence. Defined on quadrature points.

• nodal_field – ouput field into which divergence is written

• weights – Gaussian quadrature weigths

virtual void transpose_increment(const TypedFieldBase<Real> &quadrature_point_field, const Real &alpha, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const final

Evaluates the discretised divergence of quadrature_point_field and adds the result to nodal_field, weights corrensponds to Gaussian quadrature weights. If weights are omitted, this returns some scaled version of discretised divergence.

Parameters:

• quadrature_point_field – input field of which to take the divergence. Defined on quadrature points.

• nodal_field – ouput field to be incremented by theh divergence

• weights – Gaussian quadrature weigths

const Eigen::MatrixXd &get_pixel_operator() const

Return the operator matrix linking the nodal degrees of freedom to their quadrature-point values.

virtual Index_t get_nb_quad_pts() const final

returns the number of quadrature points are associated with any pixel/voxel (i.e., the sum of the number of quadrature points associated with each element belonging to any pixel/voxel.

virtual Index_t get_nb_nodal_pts() const final

returns the number of nodal points associated with any pixel/voxel. (Every node belonging to at least one of the elements belonging to any pixel/voxel, without recounting nodes that appear multiple times)

virtual Index_t get_spatial_dim() const final

return the spatial dimension of this gradient operator

Protected Attributes

Eigen::MatrixXd pixel_operator = {}

matrix linking the nodal degrees of freedom to their quadrature-point values.

Shape_t conv_pts_shape

number of convolution points, i.e., number of nodal points that is invovled in the convolution of one pixel.

Index_t nb_pixelnodal_pts

number of pixel nodal points. When the grid gets complicated, it shall be divided into sub-grids, where each of them is a regular grid. Hence the name “pixel nodal”.

Index_t nb_quad_pts

number of quadrature points per pixel (e.g.. 4 for linear quadrilateral)

Index_t nb_operators

number of nodal points that is invovled in the convolution of this pixel.

Index_t spatial_dim

the spatial dimension & number of the nodal points involved in the convolution of one pixel.

Index_t nb_conv_pts

class ConvolutionOperatorBase

#include <convolution_operator_base.hh>

Base class for gradient and divergence operations.

This class defines the interface for performing gradient and divergence operations in the context of finite element analysis. It provides the foundational structure for implementing these operations on various types of fields and supports both nodal and quadrature point evaluations.

The class is designed to be inherited by specific implementations that define the actual computational logic for gradient and divergence operations. It includes constructors, a destructor, and assignment operators to manage object lifecycle and ensure proper resource management.

Subclassed by muGrid::ConvolutionOperator, muGrid::GradientOperator

Public Functions

ConvolutionOperatorBase() = default

Default constructor.

Initializes a new instance of the ConvolutionOperatorBase class. This constructor is defaulted, indicating that it performs no special actions other than initializing the object.

ConvolutionOperatorBase(const ConvolutionOperatorBase &other) = delete

Copy constructor (deleted).

Disables the copy construction of ConvolutionOperatorBase instances. This ensures that a ConvolutionOperatorBase object cannot be copied, enforcing unique ownership of its resources.

ConvolutionOperatorBase(ConvolutionOperatorBase &&other) = default

Move constructor.

Enables the move semantics for ConvolutionOperatorBase instances. This allows the efficient transfer of resources from one object to another without copying.

virtual ~ConvolutionOperatorBase() = default

Virtual destructor.

Ensures that derived classes can be properly cleaned up through pointers to the base class. This destructor is defaulted.

ConvolutionOperatorBase &operator=(const ConvolutionOperatorBase &other) = delete

Copy assignment operator (deleted).

Disables the copy assignment of ConvolutionOperatorBase instances. This prevents the accidental or intentional copying of an instance, enforcing unique ownership of its resources.

ConvolutionOperatorBase &operator=(ConvolutionOperatorBase &&other) = default

Move assignment operator.

Enables the move assignment of ConvolutionOperatorBase instances, allowing resources to be transferred between objects without copying.

virtual void apply(const TypedFieldBase<Real> &nodal_field, TypedFieldBase<Real> &quadrature_point_field) const = 0

Applies the gradient operation.

This method evaluates the gradient of a field defined at nodal points and writes the result into a field defined at quadrature points.

Parameters:

• nodal_field – The input field from which the gradient is computed. Defined on nodal points.

• quadrature_point_field – The output field where the gradient is written. Defined on quadrature points.

virtual void apply_increment(const TypedFieldBase<Real> &nodal_field, const Real &alpha, TypedFieldBase<Real> &quadrature_point_field) const = 0

Applies the gradient operation with increment.

Evaluates the gradient of a field defined at nodal points and adds the result to a field defined at quadrature points.

Parameters:

• nodal_field – The input field from which the gradient is computed. Defined on nodal points.

• alpha – A scaling factor applied to the gradient before adding it to the quadrature_point_field.

• quadrature_point_field – The field to which the scaled gradient is added. Defined on quadrature points.

virtual void transpose(const TypedFieldBase<Real> &quadrature_point_field, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const = 0

Applies the discretised divergence operation.

Evaluates the discretised divergence of a field defined at quadrature points and writes the result into a field defined at nodal points.

Parameters:

• quadrature_point_field – The input field from which the divergence is computed. Defined on quadrature points.

• nodal_field – The output field where the divergence is written. Defined on nodal points.

• weights – Optional Gaussian quadrature weights. If omitted, a scaled version of the discretised divergence is returned.

virtual void transpose_increment(const TypedFieldBase<Real> &quadrature_point_field, const Real &alpha, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const = 0

Applies the discretised divergence operation with increment.

Evaluates the discretised divergence of a field defined at quadrature points and adds the result to a field defined at nodal points.

Parameters:

• quadrature_point_field – The input field from which the divergence is computed. Defined on quadrature points.

• alpha – A scaling factor applied to the divergence before adding it to the nodal_field.

• nodal_field – The field to which the scaled divergence is added. Defined on nodal points.

• weights – Optional Gaussian quadrature weights. If omitted, a scaled version of the discretised divergence is returned.

virtual Index_t get_nb_quad_pts() const = 0

Returns the number of quadrature points per pixel/voxel.

Calculates the total number of quadrature points associated with each pixel/voxel, summing the quadrature points of all elements belonging to the pixel/voxel.

Returns:

The total number of quadrature points per pixel/voxel.

virtual Index_t get_nb_nodal_pts() const = 0

Returns the number of nodal points per pixel/voxel.

Calculates the total number of nodal points associated with each pixel/voxel, without recounting nodes that appear in multiple elements.

Returns:

The total number of nodal points per pixel/voxel.

virtual Index_t get_spatial_dim() const = 0

Returns the spatial dimension of the gradient operator.

Returns:

The spatial dimensionality of the operations performed by this gradient operator.

class Decomposition

Subclassed by muGrid::CartesianDecomposition

Public Functions

inline Decomposition()

inline virtual ~Decomposition()

virtual void communicate_ghosts(std::string field_name) const = 0

fill the ghost buffers with the values from the neighboring processes.

class Dictionary

#include <options_dictionary.hh>

The Dictionary class holds a smart pointer to a RuntimeValue and provides the interface to assign, modify and get typed values out of thhat RuntimeValue. It behaves like a subset of the python dict class

Public Functions

Dictionary()

default constructor

Dictionary(Dictionary&&) = default

move constructor

Dictionary(const Dictionary &other) = default

Dictionary(const std::string &key, const Real &value)

constructor with a single key-value pair

Dictionary(const std::string &key, const Int &value)

Dictionary(const std::string &key, const Eigen::Ref<const Eigen::MatrixXd> &value)

~Dictionary() = default

Dictionary &operator=(const Dictionary &other) = default

copy operator

Dictionary &operator=(const Int &value)

assignment to a single runtime value (rather than a dict)

Dictionary &operator=(const Real &value)

Dictionary &operator=(const Eigen::Ref<const Eigen::MatrixXd> &value)

const Int &get_int() const

get a typed value, throws DictionaryError if the type is mismatched

const Real &get_real() const

const Eigen::MatrixXd &get_matrix() const

Dictionary operator[](const std::string &name) const

index operator returns a modifiable sub-dictionary (modifications propagate back into the original dictionary)

void add(const std::string &key, const Dictionary &other)

add a value to the dictionary

void add(const std::string &key, const Int &value)

void add(const std::string &key, const Real &value)

void add(const std::string &key, const Eigen::Ref<const Eigen::MatrixXd> &value)

const RuntimeValue::ValueType &get_value_type() const

Protected Attributes

std::shared_ptr<RuntimeValue> ptr

Private Functions

explicit Dictionary(std::shared_ptr<RuntimeValue> ptr)

class DictionaryError : public muGrid::ExceptionWithTraceback<T>

Subclassed by muGrid::KeyError, muGrid::ValueError

template<class Derived>
struct DimCounter

template<class Derived>
struct DimCounter<Eigen::MatrixBase<Derived>>

#include <T4_map_proxy.hh>

Convenience structure to determine the spatial dimension of a tensor represented by a fixed-size Eigen::Matrix. used to derive spatial dimension from input arguments of template functions thus avoiding the need for redundant explicit specification.

Public Static Attributes

static constexpr Dim_t value = {ct_sqrt(Rows)}

storage for the dimension

Private Types

using Type = Eigen::MatrixBase<Derived>

Private Static Attributes

static constexpr Dim_t Rows = {Type::RowsAtCompileTime}

template<Dim_t Dim, Dim_t Rank1, Dim_t Rank2>
struct Dotter

template<Dim_t Dim>
struct Dotter<Dim, fourthOrder, fourthOrder>

#include <tensor_algebra.hh>

Double contraction between two fourth-rank tensors A and B returns a fourth-rank tensor Cᵢⱼₖₗ = Aᵢⱼₐₑ·Bₐₑₖₗ

Public Static Functions

template<class T1, class T2>
static inline constexpr decltype(auto) ddot(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &t2)

raison d’être

template<Dim_t Dim>
struct Dotter<Dim, fourthOrder, secondOrder>

#include <tensor_algebra.hh>

Tensor-product between a fourth-rank tensor A and a second-rank tensor B. Returns a fourth-rank Cᵢⱼₖₗ = Aᵢⱼₖₐ·Bₐₗ

Public Static Functions

template<class T4, class T2>
static inline constexpr decltype(auto) dot(const Eigen::MatrixBase<T4> &t4, const Eigen::MatrixBase<T2> &t2)

raison d’être

template<Dim_t Dim>
struct Dotter<Dim, secondOrder, fourthOrder>

#include <tensor_algebra.hh>

Tensor-product between a second-rank tensor A and a fourth-rank tensor B. Returns a fourth-rank Cᵢⱼₖₗ = Aᵢₐ·Bₐⱼₖₗ

Public Static Functions

template<class T1, class T2>
static inline constexpr decltype(auto) dot(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &t2)

raison d’être

template<Dim_t Dim>
struct Dotter<Dim, secondOrder, secondOrder>

#include <tensor_algebra.hh>

Double contraction between two second-rank tensors A and B returns a scalar c = AᵢⱼBᵢⱼ

Public Static Functions

template<class T1, class T2>
static inline constexpr decltype(auto) ddot(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &t2)

raison d’être

class DynamicPixels

#include <ccoord_operations.hh>

Iteration over square (or cubic) discretisation grids. Duplicates capabilities of muGrid::CcoordOps::Pixels without needing to be templated with the spatial dimension. Iteration is slower, though.

Subclassed by muGrid::CcoordOps::Pixels< Dim >

Public Functions

DynamicPixels()

explicit DynamicPixels(const DynCcoord_t &nb_subdomain_grid_pts, const DynCcoord_t &subdomain_locations = DynCcoord_t{})

Constructor with default strides (column-major pixel storage order)

DynamicPixels(const DynCcoord_t &nb_subdomain_grid_pts, const DynCcoord_t &subdomain_locations, const DynCcoord_t &strides)

Constructor with custom strides (any, including partially transposed pixel storage order)

template<size_t Dim>
explicit DynamicPixels(const Ccoord_t<Dim> &nb_subdomain_grid_pts, const Ccoord_t<Dim> &subdomain_locations = Ccoord_t<Dim>{})

Constructor with default strides from statically sized coords.

template<size_t Dim>
DynamicPixels(const Ccoord_t<Dim> &nb_subdomain_grid_pts, const Ccoord_t<Dim> &subdomain_locations, const Ccoord_t<Dim> &strides)

Constructor with custom strides from statically sized coords.

DynamicPixels(const DynamicPixels &other) = default

Copy constructor.

DynamicPixels(DynamicPixels &&other) = default

Move constructor.

virtual ~DynamicPixels() = default

Destructor.

DynamicPixels &operator=(const DynamicPixels &other) = default

Copy assignment operator.

DynamicPixels &operator=(DynamicPixels &&other) = default

Move assignment operator.

inline Index_t get_index(const DynCcoord_t &ccoord) const

evaluate and return the linear index corresponding to dynamic ccoord

template<size_t Dim>
inline Index_t get_index(const Ccoord_t<Dim> &ccoord) const

evaluate and return the linear index corresponding to ccoord

inline DynCcoord_t get_ccoord(const Index_t &index) const

return coordinates of the i-th pixel

DynCcoord_t get_neighbour(const DynCcoord_t &ccoord, const DynCcoord_t &offset) const

template<size_t Dim>
const Pixels<Dim> &get_dimensioned_pixels() const

return a reference to the Pixels object cast into a statically dimensioned grid. the statically dimensioned version duplicates muGrid::Ccoordops::DynamicPixels’s capabilities, but iterates much more efficiently.

iterator begin() const

stl conformance

iterator end() const

stl conformance

size_t size() const

stl conformance

inline const Dim_t &get_dim() const

return spatial dimension

inline const DynCcoord_t &get_nb_subdomain_grid_pts() const

return the resolution of the discretisation grid in each spatial dim

inline const DynCcoord_t &get_subdomain_locations() const

return the ccoordinates of the bottom, left, (front) pixel/voxel of this processors partition of the discretisation grid. For sequential calculations, this is alvays the origin

inline const DynCcoord_t &get_strides() const

return the strides used for iterating over the pixels

Enumerator enumerate() const

iterates in tuples of pixel index ond coordinate. Useful in parallel problems, where simple enumeration of the pixels would be incorrect

Protected Attributes

Dim_t dim

spatial dimension

DynCcoord_t nb_subdomain_grid_pts

nb_grid_pts of this domain

DynCcoord_t subdomain_locations

locations of this domain

DynCcoord_t strides

strides of memory layout

DynCcoord_t axes_order

order of axes

bool contiguous

is this a contiguous buffer?

template<size_t MaxDim, typename T = Index_t>
class DynCcoord

#include <grid_common.hh>

Class to represent integer (cell-) coordinates or real-valued coordinates. This class can dynamically accept any spatial-dimension between 1 and MaxDim, and DynCcoord references can be cast to muGrid::Ccoord_t & or muGrid::Rcoord_t & references. These are used when templating with the spatial dimension of the problem is undesireable/impossible.

Public Types

typedef typename std::array<T, MaxDim>::iterator iterator

A type alias for an iterator over the elements of a std::array.

This type alias is used to create an iterator that can traverse the elements of a std::array. The std::array is templated on type T and has a maximum size of MaxDim. The iterator can be used to access and modify the elements of the std::array.

typedef typename std::array<T, MaxDim>::const_iterator const_iterator

A type alias for a constant iterator over the elements of a std::array.

This type alias is used to create a constant iterator that can traverse the elements of a std::array. The std::array is templated on type T and has a maximum size of MaxDim. The constant iterator can be used to access the elements of the std::array, but cannot modify them.

Public Functions

inline DynCcoord()

default constructor

inline DynCcoord(std::initializer_list<T> init_list)

Constructs a DynCcoord object from an initializer list.

This constructor creates a DynCcoord object using an initializer list. The length of the initializer list determines the spatial dimension of the coordinate. The initializer list must have a length between 1 and MaxDim.

Parameters:

init_list – Initializer list used to set the values of the DynCcoord object. The length of the list becomes the spatial dimension of the coordinate.

Throws:

RuntimeError – If the length of the initializer list is greater than MaxDim, a RuntimeError is thrown with a message indicating the maximum dimension and the provided dimension.

inline explicit DynCcoord(Dim_t dim, const T value = T{})

Constructs a DynCcoord object with a specified dimension.

This constructor creates a DynCcoord object with a specified dimension. The dimension must be between 1 and MaxDim. Note: This constructor requires regular (round) braces ‘()’. Using curly braces ‘{}’ will result in the initializer list constructor being called and creating a DynCcoord with spatial dimension 1.

Parameters:

• dim – The spatial dimension of the DynCcoord object. It needs to be between 1 and MaxDim.

• value – The value to fill the DynCcoord object with. (optional)

template<size_t Dim>
inline explicit DynCcoord(const std::array<T, Dim> &ccoord)

Constructor from a statically sized coord.

inline explicit DynCcoord(const std::vector<T> &ccoord)

Constructs a DynCcoord object from a std::vector.

This constructor creates a DynCcoord object using a std::vector. The size of the std::vector determines the spatial dimension of the coordinate. The std::vector must have a size between 1 and MaxDim.

Parameters:

ccoord – std::vector used to set the values of the DynCcoord object. The size of the vector becomes the spatial dimension of the coordinate.

Throws:

RuntimeError – If the size of the std::vector is greater than MaxDim, a RuntimeError is thrown with a message indicating the maximum dimension and the provided dimension.

DynCcoord(const DynCcoord &other) = default

Copy constructor.

DynCcoord(DynCcoord &&other) = default

Move constructor.

~DynCcoord() = default

nonvirtual Destructor

template<size_t Dim>
inline DynCcoord &operator=(const std::array<T, Dim> &ccoord)

Assign arrays.

DynCcoord &operator=(const DynCcoord &other) = default

Copy assignment operator.

DynCcoord &operator=(DynCcoord &&other) = default

Move assignment operator.

template<size_t Dim2>
inline bool operator==(const std::array<T, Dim2> &other) const

comparison operator

inline bool operator==(const DynCcoord &other) const

comparison operator

inline DynCcoord &operator+=(const DynCcoord &other)

element-wise addition

template<typename T2>
inline DynCcoord<MaxDim, decltype(T{} + T2{})> operator+(const DynCcoord<MaxDim, T2> &other) const

element-wise addition

inline DynCcoord &operator-=(const DynCcoord &other)

element-wise subtraction

template<typename T2>
inline DynCcoord<MaxDim, decltype(T{} - T2{})> operator-(const DynCcoord<MaxDim, T2> &other) const

element-wise subtraction

template<typename T2>
inline DynCcoord<MaxDim, decltype(T{} * T2{})> operator*(const DynCcoord<MaxDim, T2> &other) const

element-wise multiplication

template<typename T2>
inline DynCcoord<MaxDim, decltype(T{} / T2{})> operator/(const DynCcoord<MaxDim, T2> &other) const

element-wise division

inline DynCcoord &operator%=(const DynCcoord &other)

modulo assignment operator (mostly for periodic boundaries stuff)

inline DynCcoord operator%(const DynCcoord &other) const

modulo operator (mostly for periodic boundaries stuff)

inline T &operator[](const size_t &index)

access operator

inline const T &operator[](const size_t &index) const

access operator

inline void push_back(const T &value)

push element to the end

template<size_t Dim>
inline operator std::array<T, Dim>() const

conversion operator

template<Dim_t Dim>
inline std::array<T, Dim> &get()

cast to a reference to a statically sized array

template<Dim_t Dim>
inline const std::array<T, Dim> &get() const

cast to a const reference to a statically sized array

inline const Dim_t &get_dim() const

return the spatial dimension of this coordinate

inline const Dim_t &size() const

return the spatial dimension of this coordinate, STL compatibility

inline explicit operator std::vector<T>() const

convert into a vector

inline iterator begin()

iterator to the first entry for iterating over only the valid entries

inline iterator end()

iterator past the dim-th entry for iterating over only the valid entries

inline const_iterator begin() const

const iterator to the first entry for iterating over only the valid entries

inline const_iterator end() const

const iterator past the dim-th entry for iterating over only the valid entries

inline T *data()

return the underlying data pointer

inline const T *data() const

return the underlying data pointer

inline T &back()

return a reference to the last valid entry

inline const T &back() const

return a const reference to the last valid entry

Protected Attributes

Dim_t dim

spatial dimension of the coordinate

std::array<T, MaxDim> long_array

storage for coordinate components

Private Functions

template<size_t Dim>
inline constexpr std::array<T, MaxDim> fill_front(const std::array<T, Dim> &ccoord)

Private Static Functions

template<size_t Dim, size_t... Indices>
static inline constexpr std::array<T, MaxDim> fill_front_helper(const std::array<T, Dim> &ccoord, std::index_sequence<Indices...>)

template<typename T, class EigenPlain>
struct EigenMap

#include <field_map_static.hh>

Internal struct for handling the matrix-shaped iterates of muGrid::FieldMap

Public Types

using PlainType = EigenPlain

Eigen type of the iterate.

template<Mapping MutIter>
using value_type = std::conditional_t<MutIter == Mapping::Const, Eigen::Map<const PlainType>, Eigen::Map<PlainType>>

stl (const-correct)

template<Mapping MutIter>
using ref_type = value_type<MutIter>

stl (const-correct)

template<Mapping MutIter>
using Return_t = value_type<MutIter>

for direct access through operator[]

template<Mapping MutIter>
using storage_type = value_type<MutIter>

stored type (cannot always be same as ref_type)

Public Static Functions

static inline constexpr bool IsValidStaticMapType()

check at compile time whether the type is meant to be a map with statically sized iterates.

static inline constexpr bool IsScalarMapType()

check at compiler time whether this map is scalar

template<Mapping MutIter>
static inline constexpr value_type<MutIter> &provide_ref(storage_type<MutIter> &storage)

return the return_type version of the iterate from storage_type

template<Mapping MutIter>
static inline constexpr const value_type<MutIter> &provide_const_ref(const storage_type<MutIter> &storage)

return the const return_type version of the iterate from storage_type

template<Mapping MutIter>
static inline constexpr value_type<MutIter> *provide_ptr(storage_type<MutIter> &storage)

return a pointer to the iterate from storage_type

template<Mapping MutIter>
static inline constexpr Return_t<MutIter> from_data_ptr(std::conditional_t<MutIter == Mapping::Const, const T*, T*> data)

return a return_type version of the iterate from its pointer

template<Mapping MutIter>
static inline constexpr storage_type<MutIter> to_storage(value_type<MutIter> &&value)

return a storage_type version of the iterate from its value

static inline constexpr Index_t stride()

return the nb of components of the iterate (known at compile time)

static inline std::string shape()

return the iterate’s shape as text, mostly for error messages

static inline constexpr Index_t NbRow()

class Enumerator

#include <ccoord_operations.hh>

enumerator class for muSpectre::DynamicPixels

Public Functions

Enumerator() = delete

Default constructor.

explicit Enumerator(const DynamicPixels &pixels)

Constructor.

Enumerator(const Enumerator &other) = default

Copy constructor.

Enumerator(Enumerator &&other) = default

Move constructor.

virtual ~Enumerator() = default

Destructor.

Enumerator &operator=(const Enumerator &other) = delete

Copy assignment operator.

Enumerator &operator=(Enumerator &&other) = delete

Move assignment operator.

iterator begin() const

stl conformance

iterator end() const

stl conformance

size_t size() const

stl conformance

Protected Attributes

const DynamicPixels &pixels

template<class T>
class ExceptionWithTraceback : public T

#include <exception.hh>

A template class that extends the exception class provided as a template parameter.

This class is used to add traceback information to exceptions. It captures the stack trace at the point of exception creation. The traceback information is then included in the exception message.

Template Parameters:

T – The exception class to extend. This should be a type derived from std::exception.

Subclassed by muGrid::DictionaryError, muGrid::FieldCollectionError, muGrid::FieldError, muGrid::FieldMapError, muGrid::FileIOError, muGrid::NumpyError, muGrid::UnitError

Public Functions

inline explicit ExceptionWithTraceback(const std::string &message)

Construct a new ExceptionWithTraceback object.

This constructor initializes the base exception with the provided message, captures the current stack trace, and prepares the full exception message including the traceback information.

Parameters:

message – The message for the base exception.

inline virtual ~ExceptionWithTraceback() noexcept

Destroy the ExceptionWithTraceback object.

This is a no-throw destructor, as required for exceptions.

inline virtual const char *what() const noexcept

Get the exception message.

This function returns the full exception message, including the traceback information.

Returns:

const char* The exception message.

Protected Attributes

Traceback traceback

The captured stack trace.

std::string buffer

The full exception message, including the traceback information.

class Field

#include <field.hh>

Abstract base class for all fields. A field provides storage discretising a mathematical (scalar, vectorial, tensorial) (real-valued, integer-valued, complex-valued) field on a fixed number of quadrature points per pixel/voxel of a regular grid. Fields defined on the same domains are grouped within muGrid::FieldCollections.

To understand the interface, it is important to clarify the following nomenclature:

• Pixels are the grid dimensions for global fields or a single linear dimension for local fields

• SubPts specify the number of (tensor) quantities held per pixel. These could for example be quadrature points.

• Components are the components of the physical tensor quantity represented by the field.

Subclassed by muGrid::TypedFieldBase< Scalar >, muGrid::TypedFieldBase< T >

Public Functions

Field() = delete

Default constructor.

Field(const Field &other) = delete

Copy constructor.

Field(Field &&other) = default

Move constructor.

virtual ~Field() = default

Destructor.

Field &operator=(const Field &other) = delete

Copy assignment operator.

Field &operator=(Field &&other) = delete

Move assignment operator.

const std::string &get_name() const

return the field’s unique name

FieldCollection &get_collection() const

return a const reference to the field’s collection

const Index_t &get_nb_components() const

return the number of components stored per sub-point point

const Index_t &get_nb_sub_pts() const

return the number of sub points per pixel

Index_t get_nb_dof_per_pixel() const

return the number of components stored per pixel

Index_t get_nb_pixels() const

return the number of pixels

Index_t get_nb_buffer_pixels() const

return the number of pixels that are required for the buffer. This can be larger than get_nb_pixels if the buffer contains padding regions.

Index_t get_nb_entries() const

returns the number of entries held by this field. This corresponds to nb_pixels × nb_sub_pts, (I.e., a scalar field and a vector field sharing the the same collection and subdivision tag have the same number of entries, even though the vector field has more scalar values.)

Index_t get_nb_buffer_entries() const

returns the number of entries held by the buffer of this field. This corresponds to nb_buffer_pixels × nb_sub_pts, (I.e., a scalar field and a vector field sharing the the same collection have the same number of entries, even though the vector field has more scalar values.)

Shape_t get_components_shape() const

evaluate and return the shape of the data contained in a single sub-point (e.g. quadrature point) (for passing the field to generic multidimensional array objects such as numpy.ndarray)

void reshape(const Shape_t &components_shape)

Reshape the components part of the field. The total number of degrees of freedom per pixel must remain the same.

void reshape(const Shape_t &components_shape, const std::string &sub_div_tag)

Reshape component and sub-point parts of the field. The total number of degrees of freedom per pixel must remain the same.

Shape_t get_sub_pt_shape(const IterUnit &iter_type) const

evaluate and return the shape of the data contained in a single pixel (for passing the field to generic multidimensional array objects such as numpy.ndarray)

Shape_t get_pixels_shape() const

evaluate and return the overall shape of the pixels portion of the field (for passing the field to generic multidimensional array objects such as numpy.ndarray)

Shape_t get_shape(const IterUnit &iter_type) const

evaluate and return the overall shape of the field (for passing the field to generic multidimensional array objects such as numpy.ndarray)

virtual Shape_t get_strides(const IterUnit &iter_type, Index_t element_size = 1) const

evaluate and return the overall strides field (for passing the field to generic multidimensional array objects such as numpy.ndarray). The multiplier can be used e.g., if strides are needed in bytes, rather than in pointer offsets.

virtual StorageOrder get_storage_order() const

Return the storage order

Index_t get_stride(const IterUnit &iter_type) const

evaluate and return the number of components in an iterate when iterating over this field

bool has_same_memory_layout(const Field &other) const

check whether two fields have the same memory layout

Index_t get_default_nb_rows(const IterUnit &iter_type) const

evaluate and return the number of rows of a default iterate over this field. Warning, this function does no sanity checks at all. It is assumed that the user called get_stride before, that all checks have been performed there, and that rechecking would be a waste of time)

Index_t get_default_nb_cols(const IterUnit &iter_type) const

evaluate and return the number of cols of a default iterate over this field. Warning, this function does no sanity checks at all. It is assumed that the user called get_stride before, that all checks have been performed there, and that rechecking would be a waste of time)

virtual const std::type_info &get_typeid() const = 0

return the type information of the stored scalar (for compatibility checking)

virtual const std::size_t get_element_size_in_bytes() const = 0

return the size of the elementary field entry in bytes

void assert_typeid(const std::type_info &type) const

assert that the stored type corresponds to the given type id

virtual void *get_void_data_ptr() const = 0

return a pointer to the raw data

Index_t get_current_nb_entries() const

number of entries in the field (= nb_pixel × nb_sub_pts)

virtual size_t get_buffer_size() const = 0

size of the internal buffer including the pad region (in scalars)

virtual void set_pad_size(const size_t &pad_size_) = 0

add a pad region to the end of the field buffer; required for using this as e.g. an FFT workspace

const size_t &get_pad_size() const

pad region size

virtual void set_zero() = 0

initialise field to zero (do more complicated initialisations through fully typed maps)

bool is_global() const

checks whether this field is registered in a global FieldCollection

const Index_t &get_spatial_dim() const

return the spatial dimension of the underlying discretisation grid

bool has_nb_sub_pts() const

check wether the number of pixel sub-divisions has been set

const std::string &get_sub_division_tag() const

returns a const ref to the field’s pixel sub-division type

const Unit &get_physical_unit() const

returns the physical unit of the values stored in the field

Protected Functions

Field(const std::string &unique_name, FieldCollection &collection, const Index_t &nb_components, const std::string &sub_div_tag, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. The Field constructor is protected to ensure this. This constructor initializes a field that does not know the shape and storage order of its components.

Parameters:

• unique_name – unique field name (unique within a collection)

• nb_components – number of components to store per sub-point

• collection – reference to the holding field collection.

Field(const std::string &unique_name, FieldCollection &collection, const Shape_t &components_shape, const std::string &sub_div_tag, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. The Field constructor is protected to ensure this.

Parameters:

• unique_name – unique field name (unique within a collection)

• collection – reference to the holding field collection.

• components_shape – number of components to store per quadrature point

• storage_oder – in-memory storage order of the components

void set_nb_sub_pts(const Index_t &nb_quad_pts_per_pixel)

sets the number of sub points per pixel

Shape_t get_components_strides(Index_t element_size = 1) const

evaluate and return the strides of the sub-point portion of the field (for passing the field to generic multidimensional array objects such as numpy.ndarray)

Shape_t get_sub_pt_strides(const IterUnit &iter_type, Index_t element_size = 1) const

evaluate and return the strides of the pixels portion of the field (for passing the field to generic multidimensional array objects such as numpy.ndarray)

Shape_t get_pixels_strides(Index_t element_size = 1) const

evaluate and return the overall strides of the pixels portion of the field (for passing the field to generic multidimensional array objects such as numpy.ndarray)

virtual void resize() = 0

resizes the field to the given size

Protected Attributes

friend FieldCollection

gives field collections the ability to resize() fields

Index_t current_nb_entries = {}

maintains a tally of the current size, as it cannot be reliably determined from values alone.

const std::string name

the field’s unique name

FieldCollection &collection

reference to the collection this field belongs to

Index_t nb_components

number of components stored per sub-point (e.g., 3 for a three-dimensional vector, or 9 for a three-dimensional second-rank tensor)

Shape_t components_shape

shape of the data stored per sub-point (e.g., 3, 3 for a three-dimensional second-rank tensor)

size_t pad_size = {}

size of padding region at end of buffer

Index_t nb_sub_pts

number of pixel subdivisions. Will depend on sub_division. This value depends on the field collection and might or might not exist at construction time (it would be muGrid::Unknown if not yes set

std::string sub_division_tag

Pixel subdivision kind (determines how many datapoints to store per pixel)

Unit unit

Physical unit of the values stored in this field.

class FieldCollection

#include <field_collection.hh>

Base class for both muGrid::GlobalFieldCollection and muGrid::LocalFieldCollection. Manages the a group of fields with the same domain of validity (i.e., global fields, or local fields defined on the same pixels).

Subclassed by muGrid::GlobalFieldCollection, muGrid::LocalFieldCollection

Public Types

enum class ValidityDomain

domain of validity of the managed fields

Values:

enumerator Global

enumerator Local

using Field_ptr = std::unique_ptr<Field, FieldDestructor<Field>>

unique_ptr for holding fields

using SubPtMap_t = std::map<std::string, Index_t>

map to hold nb_sub_pts by tag

using StateField_ptr = std::unique_ptr<StateField, FieldDestructor<StateField>>

unique_ptr for holding state fields

Public Functions

FieldCollection() = delete

Default constructor.

FieldCollection(const FieldCollection &other) = delete

Copy constructor.

FieldCollection(FieldCollection &&other) = default

Move constructor.

virtual ~FieldCollection() = default

Destructor.

FieldCollection &operator=(const FieldCollection &other) = delete

Copy assignment operator.

FieldCollection &operator=(FieldCollection &&other) = default

Move assignment operator.

template<typename T>
inline TypedField<T> &register_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

template<typename T>
inline TypedField<T> &register_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

template<typename T>
std::unique_ptr<TypedField<T>, FieldDestructor<Field>> detached_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

create a detached field (i.e., the field collection does not take responsibility for it, and it is up to the user to make sure that the field is used only during the life-time of the collection.

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Real> &register_real_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new real-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Real> &register_real_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Complex> &register_complex_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new complex-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Complex> &register_complex_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Int> &register_int_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new integer-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Int> &register_int_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Uint> &register_uint_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new unsigned integer-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Uint> &register_uint_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

template<typename T>
inline TypedStateField<T> &register_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

TypedStateField<Real> &register_real_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new real-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Complex> &register_complex_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new complex-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Int> &register_int_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new integer-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Uint> &register_uint_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new unsigned integer-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

template<typename T>
inline TypedField<T> &field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Real> &real_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new real-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Real> &real_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Complex> &complex_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new complex-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Complex> &complex_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Int> &int_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new integer-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Int> &int_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

TypedField<Uint> &uint_field(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new unsigned integer-valued field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• nb_components – number of components to be stored per sub-point (e.g., 4 for a two-dimensional second-rank tensor, or 1 for a scalar field)

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

TypedField<Uint> &uint_field(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new field in the responsibility of this collection (Note, because fields have protected constructors, users can’t create them

Parameters:

• unique_name – unique identifier for this field

• components_shape – number of components to store per quadrature point

• sub_division_tag – unique identifier of the subdivision scheme

• unit – phyiscal unit of this field

• storage_oder – in-memory storage order of the components

template<typename T>
inline TypedStateField<T> &state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

TypedStateField<Real> &real_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new real-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Complex> &complex_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new complex-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Int> &int_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new integer-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

TypedStateField<Uint> &uint_state_field(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag = PixelTag, const Unit &unit = Unit::unitless())

place a new unsigned integer-valued state field in the responsibility of this collection (Note, because state fields have protected constructors, users can’t create them

Parameters:

• unique_prefix – unique idendifier for this state field

• nb_memory – number of previous values of this field to store

• nb_components – number of scalar components to store per quadrature point

bool field_exists(const std::string &unique_name) const

check whether a field of name ‘unique_name’ has already been registered

bool state_field_exists(const std::string &unique_prefix) const

check whether a field of name ‘unique_name’ has already been registered

Index_t get_nb_pixels() const

returns the number of pixels present in the collection

Index_t get_nb_buffer_pixels() const

returns the number of (virtual) pixels required to store the underlying data that may involve padding regions

bool has_nb_sub_pts(const std::string &tag) const

Check whether the number of subdivision points peir pixel/voxel has been set for a given tags

void set_nb_sub_pts(const std::string &tag, const Index_t &nb_sub_pts_per_pixel)

set the number of sub points per pixel/voxel for a given tag. Can only be done once per tag

const Index_t &get_nb_sub_pts(const std::string &tag)

return the number of subpoints per pixel/voxel for a given tag

const Index_t &get_nb_sub_pts(const std::string &tag) const

return the number of subpoints per pixel/voxel for a given tag

const Index_t &get_spatial_dim() const

return the spatial dimension of the underlying discretisation grid

const ValidityDomain &get_domain() const

return the domain of validity (i.e., wher the fields are defined globally (muGrid::FieldCollection::ValidityDomain::Global) or locally (muGrid::FieldCollection::ValidityDomain::Local)

virtual Shape_t get_pixels_shape() const = 0

return shape of the pixels

virtual Shape_t get_pixels_strides(Index_t element_size = 1) const = 0

return strides of the pixels

const StorageOrder &get_storage_order() const

return the storage order of the pixels vs. subpoints

bool has_same_memory_layout(const FieldCollection &other) const

check whether two field collections have the same memory layout

bool is_initialised() const

whether the collection has been properly initialised (i.e., it knows the number of quadrature points and all its pixels/voxels

PixelIndexIterable get_pixel_indices() const

return an iterable proxy to the collection which allows to efficiently iterate over the indices fo the collection’s pixels

IndexIterable get_sub_pt_indices(const std::string &tag) const

return an iterable proxy to the collection which allows to iterate over the indices fo the collection’s quadrature points

inline const std::vector<Index_t> &get_pixel_ids()

Field &get_field(const std::string &unique_name)

returns a (base-type) reference to the field identified by unique_name. Throws a muGrid::FieldCollectionError if the field does not exist.

Field_ptr pop_field(const std::string &unique_name)

returns the unique ptr holding the field named unique_name. Warning: note that this effectively removes the field from the collection. You can use this to delete fields to free memory

StateField &get_state_field(const std::string &unique_prefix)

returns a (base-type) reference to the state field identified by unique_prefix. Throws a muGrid::FieldCollectionError if the state field does not exist.

std::vector<std::string> list_fields() const

returns a vector of all field names

std::vector<std::string> list_state_field_unique_prefixes() const

returns a vector of all unique_prefixes of state fields in the field collection

void preregister_map(std::shared_ptr<std::function<void()>> &call_back)

preregister a map for latent initialisation

Index_t check_nb_sub_pts(const Index_t &nb_sub_pts, const IterUnit &iteration_type, const std::string &tag) const

run-time checker for nb_sub_pts: checks whether the number of sub-points (e.g., quadrature points) is compatible with the sub-division scheme). Attention: this does allow Unknown as valid values for IterUnit::SubPt, if the tag is defined, since these values can be specified for the entire FieldCollection at a later point, before initialisation. Hence, this function cannot be used for checking nb_sub_pts for iterators, which need a known value. Use check_initialised_nb_sub_pts() instead for that.

size_t check_initialised_nb_sub_pts(const Index_t &nb_sub_pts, const IterUnit &iteration_type, const std::string &tag) const

run-time checker for nb_sub_pts: checks whether the number of sub-points (e.g., quadrature points) is compatible with the sub-division scheme), and set to a positive integer value (i.e., not Unknown).

std::string generate_unique_name() const

use this to obtain an unused unique name for a new field to register, if you do not care about what name you obtain.

template<typename T>
TypedField<T> &register_field_helper(const std::string &unique_name, const Index_t &nb_components, const std::string &sub_division_tag, const Unit &unit, bool allow_existing = false)

internal worker function called by register_<T>_field

template<typename T>
TypedField<T> &register_field_helper(const std::string &unique_name, const Shape_t &components_shape, const std::string &sub_division_tag, const Unit &unit, bool allow_existing = false)

internal worker function called by register_<T>_field

template<typename T>
TypedStateField<T> &register_state_field_helper(const std::string &unique_prefix, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division_tag, const Unit &unit, bool allow_existing = false)

internal worker function called by register_<T>_state_field

Protected Functions

FieldCollection(ValidityDomain domain, const Index_t &spatial_dimension, const SubPtMap_t &nb_sub_pts, StorageOrder storage_order = StorageOrder::ArrayOfStructures)

Constructor (not called by user, who constructs either a LocalFieldCollection or a GlobalFieldCollection

Parameters:

• domain – Domain of validity, can be global or local

• spatial_dimension – spatial dimension of the field (can be muGrid::Unknown, e.g., in the case of the local fields for storing internal material variables)

• nb_sub_pts – Specification of pixel subdivision. This is a map that of a string (the name of the subdivision scheme) to the number of subdivisions

• storage_order – Storage order of the pixels vs subdivision portion of the field. In a column-major storage order, the pixel subdivision (i.e. the components of the field) are stored next to each other in memory, file in a row-major storage order for each component the pixels are stored next to each other in memory. (This is also sometimes called the array of structures vs. structure of arrays storage order.) Important: The pixels or subpoints have their own storage order that is not affected by this setting.

void allocate_fields()

loop through all fields and allocate their memory. Is exclusively called by the daughter classes’ initialise member function.

void initialise_maps()

initialise all preregistered maps

Protected Attributes

std::map<std::string, Field_ptr> fields = {}

storage container for fields

std::map<std::string, StateField_ptr> state_fields = {}

storage container for state fields

std::vector<std::weak_ptr<std::function<void()>>> init_callbacks = {}

Maps registered before initialisation which will need their data_ptr set.

ValidityDomain domain

domain of validity

Index_t spatial_dim

spatial dimension

SubPtMap_t nb_sub_pts

number of subpoints per pixel/voxel, stored by tag

Index_t nb_pixels = {Unknown}

total number of pixels

Index_t nb_buffer_pixels = {Unknown}

total number of pixels for the buffer (including padding regions)

StorageOrder storage_order

storage oder

bool initialised = {false}

keeps track of whether the collection has already been initialised

std::vector<Index_t> pixel_indices = {}

Storage for indices of the stored pixels in the global field collection. Note that these are not truly global indices, but rather absolute indices within the domain of the local processor. I.e., they are universally valid to address any pixel on the local processor, and not for any pixel located on another processor.

class FieldCollectionError : public muGrid::ExceptionWithTraceback<T>

#include <field_collection.hh>

base class for field collection-related exceptions

Public Functions

inline explicit FieldCollectionError(const std::string &what)

constructor

inline explicit FieldCollectionError(const char *what)

constructor

template<class DefaultDestroyable>
struct FieldDestructor

#include <field_collection.hh>

forward declacation of the field’s destructor-functor

Public Functions

void operator()(DefaultDestroyable *field)

deletes the held field

class FieldError : public muGrid::ExceptionWithTraceback<T>

#include <field.hh>

base class for field-related exceptions

Public Functions

inline explicit FieldError(const std::string &what)

constructor

inline explicit FieldError(const char *what)

constructor

template<typename T, Mapping Mutability>
class FieldMap

#include <field_map.hh>

forward declaration

Dynamically sized field map. Field maps allow iterating over the pixels or quadrature points of a field and to select the shape (in a matrix sense) of the iterate. For example, it allows to iterate in 2×2 matrices over the quadrature points of a strain field for a two-dimensional problem.

Subclassed by muGrid::StaticFieldMap< T, Mutability, MapType, IterationType >

Public Types

using Scalar = T

stored scalar type

using Field_t = std::conditional_t<Mutability == Mapping::Const, const TypedFieldBase<T>, TypedFieldBase<T>>

const-correct field depending on mapping mutability

using PlainType = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

dynamically mapped eigen type

template<Mapping MutVal>
using Return_t = std::conditional_t<MutVal == Mapping::Const, Eigen::Map<const PlainType>, Eigen::Map<PlainType>>

return type for iterators over this- map

using EigenRef = Eigen::Ref<const PlainType>

Input type for matrix-like values (used for setting uniform values)

using PixelEnumeration_t = akantu::containers::ZipContainer<FieldCollection::PixelIndexIterable, FieldMap&>

zip-container for iterating over pixel index and stored value simultaneously

using Enumeration_t = akantu::containers::ZipContainer<FieldCollection::IndexIterable, FieldMap&>

zip-container for iterating over pixel or quadrature point index and stored value simultaneously

using iterator = Iterator<(Mutability == Mapping::Mut) ? Mapping::Mut : Mapping::Const>

stl

using const_iterator = Iterator<Mapping::Const>

stl

Public Functions

FieldMap() = delete

Default constructor.

explicit FieldMap(Field_t &field, const IterUnit &iter_type = IterUnit::SubPt)

Constructor from a field. The iter_type can be the natural sub-division of the field, or `muGridIterUnit::Pixel. The default case is a map iterating over sub-division points with a matrix of shape (nb_components × 1) per field entry

FieldMap(Field_t &field, Index_t nb_rows, const IterUnit &iter_type = IterUnit::SubPt)

Constructor from a field with explicitly chosen shape of iterate. (the number of columns is inferred). The iter_type can be the natural sub-division of the field, or `muGridIterUnit::Pixel

FieldMap(const FieldMap &other) = delete

Copy constructor.

FieldMap(FieldMap &&other)

Move constructor.

virtual ~FieldMap() = default

Destructor.

FieldMap &operator=(const FieldMap &other) = delete

Copy assignment operator (delete because of reference member)

FieldMap &operator=(FieldMap &&other) = delete

Move assignment operator (delete because of reference member)

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator=(const EigenRef &val)

Assign a matrix-like value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator+=(const EigenRef &val)

Addition-assign a matrix-like value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator-=(const EigenRef &val)

Subtraction-assign a matrix-like value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator=(const Scalar &val)

Assign a scalar value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator+=(const Scalar &val)

Addition-assign a scalar value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, FieldMap> &operator-=(const Scalar &val)

Subtraction-assign a scalar value to every entry.

iterator begin()

stl

iterator end()

stl

const_iterator cbegin()

stl

const_iterator cend()

stl

const_iterator begin() const

stl

const_iterator end() const

stl

size_t size() const

returns the number of iterates produced by this map (corresponds to the number of field entries if Iteration::Subpt, or the number of pixels/voxels if Iteration::Pixel); In parallel, if the processor does not hold a part of the field (empty processor) this empty processor returns size=0.

inline Return_t<Mutability> operator[](size_t index)

random access operator

inline Return_t<Mapping::Const> operator[](size_t index) const

random const access operator

void set_data_ptr()

query the size from the field’s collection and set data_ptr

PixelEnumeration_t enumerate_pixel_indices_fast()

return an iterable proxy over pixel indices and stored values simultaneously. Throws a muGrid::FieldMapError if the iteration type is over quadrature points

Enumeration_t enumerate_indices()

return an iterable proxy over pixel/quadrature indices and stored values simultaneously

PlainType sum() const

evaluate and return the sum of the map. In parallel, if the processor does not hold a part of the field (empty processor) this empty processor returns a zero matrix of the proper size and type.

PlainType mean() const

evaluate and return the mean value of the map. In parallel, if the processor does not hold a part of the field (empty processor) this empty processor returns a zero matrix of the proper size and type.

const Field_t &get_field() const

return const reference to the mapped field

Public Static Functions

static inline constexpr Mapping FieldMutability()

determine whether a field is mutably mapped at compile time

static inline constexpr bool IsStatic()

determine whether a field map is statically sized at compile time

Protected Attributes

const Field_t &field

mapped field. Needed for query at initialisations

const IterUnit iteration

type of map iteration

const Index_t stride

precomputed stride

const Index_t nb_rows

number of rows of the iterate

const Index_t nb_cols

number of columns fo the iterate

T *data_ptr = {nullptr}

Pointer to mapped data; is also unknown at construction and set in the map’s begin function

bool is_initialised = {false}

keeps track of whether the map has been initialised.

std::shared_ptr<std::function<void()>> callback = {nullptr}

shared_ptr used for latent initialisation

class FieldMapError : public muGrid::ExceptionWithTraceback<T>

#include <field_map.hh>

base class for field map-related exceptions

Public Functions

inline explicit FieldMapError(const std::string &what)

constructor

inline explicit FieldMapError(const char *what)

constructor

class FileFrame

#include <file_io_base.hh>

A virtual base class for Frame classes.

This class provides a common interface for file frame operations. It provides a set of constructors and assignment operators (both copy and move are deleted). It also provides a virtual destructor and methods for reading and writing frames.

Note

This class cannot be instantiated directly (default constructor is deleted).

Public Functions

FileFrame() = delete

Default constructor is deleted to prevent direct instantiation of this class without parameters.

explicit FileFrame(FileIOBase &parent, Index_t frame)

Constructor with the FileIOBase object and the required frame number.

This constructor initializes a FileFrame object with the given FileIOBase object and frame number.

Parameters:

• parent – The FileIOBase object.

• frame – The frame number.

FileFrame(const FileFrame &other) = default

Copy constructor is deleted to prevent copying of FileFrame objects.

FileFrame(FileFrame &&other) = default

Move constructor is deleted to prevent moving of FileFrame objects.

virtual ~FileFrame() = default

Virtual destructor.

FileFrame &operator=(const FileFrame &other) = delete

Copy assignment operator is deleted to prevent copying of FileFrame objects.

FileFrame &operator=(FileFrame &&other) = delete

Move assignment operator is deleted to prevent moving of FileFrame objects.

void read(const std::vector<std::string> &field_names) const

Read the fields identified by field_names from the current frame.

Parameters:

field_names – The names of the fields to read.

void read() const

Read all fields of the registered field collection(s) from the current frame.

void write(const std::vector<std::string> &field_names) const

Write the contents of all fields within the field collection with the names ‘field_names’ to the file.

Parameters:

field_names – The names of the fields to write.

void write() const

Write the contents of all fields within the field collection to the file.

Protected Attributes

FileIOBase &parent

The FileIOBase object.

Index_t frame

The frame number.

class FileIOBase

#include <file_io_base.hh>

A virtual base class for FileIO classes.

This class provides a common interface for file input/output operations. It defines an enumeration for open modes (Read, Write, Append) and provides a set of constructors and assignment operators (both copy and move are deleted). It also provides a virtual destructor and a random access operator.

Note

This class cannot be instantiated directly (default constructor is deleted).

Subclassed by muGrid::FileIONetCDF

Public Types

enum class OpenMode

Enumeration for file open modes.

This enumeration defines the possible modes for opening a file:

• Read: File is opened for reading only. This mode is used when the data in the file is only needed for input and will not be modified.

• Write: File is opened for writing only. This mode is used when new data is to be written to a file. If the file already exists, this mode will fail to prevent accidental data loss.

• Overwrite: File is opened for writing only. This mode is used when new data is to be written to a file. If the file already exists, it will be overwritten. Use this mode with caution to prevent accidental data loss.

• Append: File is opened for writing only. This mode is used when new data is to be added to the end of a file. If the file already exists, the new data will be added at the end, preserving the existing data.

Values:

enumerator Read

enumerator Write

enumerator Overwrite

enumerator Append

Public Functions

FileIOBase() = delete

Default constructor is deleted to prevent direct instantiation of this class without parameters.

FileIOBase(const std::string &file_name, const OpenMode &open_mode, Communicator comm = Communicator())

Constructor with file name, open mode, and communicator.

This constructor initializes a FileIOBase object with the given file name, open mode, and communicator.

Parameters:

• file_name – The name of the file to be opened.

• open_mode – The mode to open the file in (Read, Write, or Append).

• comm – The communicator to be used for parallel I/O operations (default is a default-constructed Communicator object).

FileIOBase(const FileIOBase &other) = delete

Copy constructor is deleted to prevent copying of FileIOBase objects.

FileIOBase(FileIOBase &&other) = delete

Move constructor is deleted to prevent moving of FileIOBase objects.

virtual ~FileIOBase() = default

Virtual destructor.

FileIOBase &operator=(const FileIOBase &other) = delete

Copy assignment operator is deleted to prevent copying of FileIOBase objects.

FileIOBase &operator=(FileIOBase &&other) = delete

Move assignment operator is deleted to prevent moving of FileIOBase objects.

FileFrame operator[](const Index_t &frame_index)

Random access operator.

This operator provides access to a specific frame in the file. The frame must exist for this operation to succeed.

Parameters:

frame_index – The index of the frame to access.

Returns:

FileFrame The requested frame.

virtual void register_field_collection(muGrid::FieldCollection &fc, std::vector<std::string> field_names = {REGISTER_ALL_FIELDS}, std::vector<std::string> state_field_unique_prefixes = {REGISTER_ALL_STATE_FIELDS}) = 0

Register a field collection to be dumped to the file.

This function should be called before the file is opened. If no field names are given, all fields of the given field collection are registered by default.

Parameters:

• fc – The field collection to be registered.

• field_names – The names of the fields to be registered. Default is all fields.

• state_field_unique_prefixes – The unique prefixes of the state fields to be registered. Default is all state fields.

virtual void close() = 0

Close the file.

virtual void read(const Index_t &frame, const std::vector<std::string> &field_names) = 0

Read the fields identified by field_names from a specific frame in the file.

Parameters:

• frame – The frame to read from.

• field_names – The names of the fields to read.

virtual void read(const Index_t &frame) = 0

Read all registered fields from a specific frame in the file.

Parameters:

frame – The frame to read from.

virtual void write(const Index_t &frame, const std::vector<std::string> &field_names) = 0

Write the contents of all fields identified by field_names within the field collection to a specific frame in the file.

Parameters:

• frame – The frame to write to.

• field_names – The names of the fields to write.

virtual void write(const Index_t &frame) = 0

Write the contents of all fields within the field collection to a specific frame in the file.

Parameters:

frame – The frame to write to.

FileFrame append_frame()

Yield an empty file frame at the end of the file.

Returns:

FileFrame The empty file frame.

Communicator &get_communicator()

Get the communicator object.

Returns:

Communicator& The communicator object.

iterator begin()

Get an iterator pointing to the first frame in the file.

Returns:

iterator An iterator pointing to the first frame.

iterator end()

Get an iterator pointing one past the last frame in the file.

Returns:

iterator An iterator pointing one past the last frame.

size_t size() const

Get the number of frames in the file.

Returns:

size_t The number of frames.

Protected Functions

virtual void open() = 0

Open the file for read/write operations.

This function should be called by the constructor at instantiation. It is a pure virtual function and must be implemented by derived classes.

virtual void register_field_collection_global(muGrid::GlobalFieldCollection &fc_global, const std::vector<std::string> &field_names, const std::vector<std::string> &state_field_unique_prefixes) = 0

Register a global field collection to be dumped to the file.

This function should be called before the file is opened. If no field names are given, all fields of the given field collection are registered by default.

Parameters:

• fc_global – The global field collection to be registered.

• field_names – The names of the fields to be registered. Default is all fields.

• state_field_unique_prefixes – The unique prefixes of the state fields to be registered. Default is all state fields.

virtual void register_field_collection_local(muGrid::LocalFieldCollection &fc_local, const std::vector<std::string> &field_names, const std::vector<std::string> &state_field_unique_prefixes) = 0

Register a local field collection to be dumped to the file.

This function should be called before the file is opened. If no field names are given, all fields of the given field collection are registered by default.

Parameters:

• fc_local – The local field collection to be registered.

• field_names – The names of the fields to be registered. Default is all fields.

• state_field_unique_prefixes – The unique prefixes of the state fields to be registered. Default is all state fields.

Protected Attributes

const std::string file_name

The name of the file to be opened.

const OpenMode open_mode

The mode to open the file in (Read, Write, or Append).

Communicator comm

The communicator to be used for parallel I/O operations.

Index_t nb_frames = {0}

The number of frames in the file.

class FileIOError : public muGrid::ExceptionWithTraceback<T>

#include <file_io_base.hh>

base class for FileIO related exceptions

Public Functions

inline explicit FileIOError(const std::string &what)

constructor

inline explicit FileIOError(const char *what)

constructor

class FileIONetCDF : public muGrid::FileIOBase

#include <file_io_netcdf.hh>

A class for handling NetCDF files in the µGrid codebase.

This class inherits from the FileIOBase class and provides specific functionality for handling NetCDF files. NetCDF (Network Common Data Format) is a self-describing, machine-independent data format that support the creation, access, and sharing of array-oriented scientific data.

Public Types

enum class NetCDFMode

Values:

enumerator UndefinedMode

enumerator DefineMode

enumerator DataMode

Public Functions

FileIONetCDF() = delete

Default constructor.

FileIONetCDF(const std::string &file_name, const FileIOBase::OpenMode &open_mode, Communicator comm = Communicator())

Constructs a new FileIONetCDF object.

This constructor creates a new FileIONetCDF object with the specified file name, open mode, and communicator. The FileIONetCDF class is used for handling NetCDF files in the µGrid codebase.

Parameters:

• file_name – The name of the file to be handled. This should be a valid file path.

• open_mode – The mode in which the file should be opened. This should be a valid mode from the FileIOBase::OpenMode enumeration.

• comm – The communicator to be used for parallel I/O operations. If not provided, a default Communicator object is used.

FileIONetCDF(const FileIONetCDF &other) = delete

Copy constructor (deleted)

This copy constructor is deleted to prevent copying of FileIONetCDF objects.

Parameters:

other – The other FileIONetCDF object to be copied.

FileIONetCDF(FileIONetCDF &&other) = delete

Move constructor (deleted)

This move constructor is deleted to prevent moving of FileIONetCDF objects.

Parameters:

other – The other FileIONetCDF object to be moved.

virtual ~FileIONetCDF()

Destructor.

This is the destructor for the FileIONetCDF class. It is responsible for freeing any resources that the object may have acquired during its lifetime.

FileIONetCDF &operator=(const FileIONetCDF &other) = delete

Copy assignment operator (deleted)

This copy assignment operator is deleted to prevent copying of FileIONetCDF objects.

Parameters:

other – The other FileIONetCDF object to be copied.

Returns:

A reference to the current object.

FileIONetCDF &operator=(FileIONetCDF &&other) = delete

Move assignment operator (deleted)

This move assignment operator is deleted to prevent moving of FileIONetCDF objects.

Parameters:

other – The other FileIONetCDF object to be moved.

Returns:

A reference to the current object.

virtual void register_field_collection(muGrid::FieldCollection &fc, std::vector<std::string> field_names = {REGISTER_ALL_FIELDS}, std::vector<std::string> state_field_unique_prefixes = {REGISTER_ALL_STATE_FIELDS}) final

Registers the field collections that should be written to the file.

This function should be called before the file is opened. It allows the user to specify which fields from the field collection should be saved in the NetCDF file.

Parameters:

• fc – The field collection to be registered.

• field_names – A vector of names of fields from the field collection that should be saved in the NetCDF file. This parameter should be used if not all fields from the field collection will be written to the file (default case).

• state_field_unique_prefixes – A vector of unique prefixes for state fields.

virtual void close() final

Closes the file.

This function is used to close the NetCDF file after all operations are done.

virtual void read(const Index_t &frame, const std::vector<std::string> &field_names) final

Reads the specified fields from the file.

This function reads the fields identified by field_names from the specified frame in the file.

Parameters:

• frame – The frame from which to read the fields.

• field_names – A vector of names of fields to be read from the file.

virtual void read(const Index_t &frame) final

Reads all fields from the specified frame in the file.

This function reads all fields from the specified frame in the file.

Parameters:

frame – The frame from which to read the fields.

virtual void write(const Index_t &frame, const std::vector<std::string> &field_names) final

Writes the specified fields to the file.

This function writes the contents of all fields within the field collection with the name in field_names to the specified frame in the file.

Parameters:

• frame – The frame to which to write the fields.

• field_names – A vector of names of fields to be written to the file.

virtual void write(const Index_t &frame) final

Writes all fields to the file.

This function writes the contents of all fields within the field collection to the specified frame in the file.

Parameters:

frame – The frame to which to write the fields.

Index_t handle_frame(Index_t frame) const

Checks if the frame is valid and computes the corresponding positive frame value for a negative frame value.

This function checks if the frame is valid and computes the corresponding positive frame value for a negative frame value. For example, if the total number of frames is 5:

• If the input frame is -3, the output frame is 2.

• If the input frame is 3, the output frame is 3.

• If the input frame is 7 or -6, an error is thrown.

Parameters:

frame – The frame to be checked and converted. This can be a positive or negative integer.

Throws:

FileIOError – If the input frame is not valid (i.e., it is greater than the total number of frames or less than the negative of the total number of frames).

Returns:

The corresponding positive frame value for the input frame.

template<class T>
inline void write_global_attribute(const std::string &att_name, T value)

Registers a global attribute to the NetCDF file.

This function can only be used in open_mode = FileIOBase::OpenMode::Write or FileIOBase::OpenMode::Overwrite and before write() was called the first time. Otherwise, there is the danger of having time expensive NetCDF header expansions, which is the reason why this is prevented.

Template Parameters:

T – The type of the value to be written as a global attribute.

Parameters:

• att_name – The name of the attribute.

• value – The value of the attribute.

Throws:

FileIOError – If the global attributes are already defined or if the open mode is not Write.

const NetCDFGlobalAtt &read_global_attribute(const std::string &att_name) const

Retrieves a global attribute from the NetCDF file by its name.

This function is used to fetch a global attribute from the NetCDF file. The attribute is identified by its name.

Parameters:

att_name – The name of the attribute.

Returns:

A constant reference to the NetCDFGlobalAtt object representing the global attribute.

const std::vector<std::string> read_global_attribute_names() const

Retrieves the names of all current global attributes in the NetCDF file.

This function is used to fetch the names of all global attributes present in the NetCDF file.

Returns:

A constant vector of strings containing the names of all current global attributes.

template<class T>
inline void update_global_attribute(const std::string &old_att_name, const std::string &new_att_name, T new_att_value)

Updates the value or name of an existing global attribute in the NetCDF file.

This function can only be used in open_mode = FileIOBase::OpenMode::Write, FileIOBase::OpenMode::Overwrite or FileIOBase::OpenMode::Append. The changes are only allowed if they do not lead to an increase in the size of the global attribute and the data_type of the attribute is not changed.

Template Parameters:

T – The type of the new value for the global attribute.

Parameters:

• old_att_name – The current name of the attribute.

• new_att_name – The new name for the attribute.

• new_att_value – The new value for the attribute.

Throws:

FileIOError – If the function is called in a mode other than Write or Append, or if the attribute was not previously written to the NetCDF file.

Public Static Functions

static Index_t handle_frame(Index_t frame, Index_t tot_nb_frames)

Checks if the frame is valid and computes the corresponding positive frame value for a negative frame value (static version).

This is a static version of the handle_frame function. It performs the same operation but takes an additional parameter for the total number of frames.

Parameters:

• frame – The frame to be checked and converted. This can be a positive or negative integer.

• tot_nb_frames – The total number of frames.

Throws:

FileIOError – If the input frame is not valid (i.e., it is greater than the total number of frames or less than the negative of the total number of frames).

Returns:

The corresponding positive frame value for the input frame.

Public Static Attributes

static constexpr int MAX_NB_ATTRIBUTES{10}

static constexpr int MAX_LEN_ATTRIBUTE_NAME{NC_MAX_NAME}

static constexpr int MAX_NB_GLOBAL_ATTRIBUTES{30}

static constexpr int MAX_LEN_GLOBAL_ATTRIBUTE_NAME{NC_MAX_NAME}

Protected Functions

virtual void open() final

open file for read/write This function is called by the constructor at instantiation.

virtual void register_field_collection_global(muGrid::GlobalFieldCollection &fc_global, const std::vector<std::string> &field_names, const std::vector<std::string> &state_field_unique_prefixes) final

register global field collection

virtual void register_field_collection_local(muGrid::LocalFieldCollection &fc_local, const std::vector<std::string> &field_names, const std::vector<std::string> &state_field_unique_prefixes) final

register local field collection

void initialise_gfc_local_pixels(const muGrid::GlobalFieldCollection &fc_global)

when registering the first global field collection, I initialise the global field collection local_pixels.

std::string register_lfc_to_gfc_local_pixels(muGrid::LocalFieldCollection &fc_local)

add the global pixels field associated with a local field collection to the global field collection which stores the position of the local pixels and the offsets to read the data of a local variable in a proper way.

void write_no_frame(const std::vector<std::string> &field_names)

write contents of all fields within the field collection with the name in field_names that have no frame dimension.

void define_netcdf_dimensions(NetCDFDimensions &dimensions)

define the dimensions in the NetCDF file (to write a file)

actual call of NetCDF functions to read in the data of a single NetCDFVarBase

void define_netcdf_variables(NetCDFVariables &variables)

define the variables in the NetCDF file (to write a file)

void define_netcdf_attributes(NetCDFVariables &variables)

define the variables attributes in the NetCDF file (to write a file)

void register_netcdf_dimension_ids(std::uint64_t ndims, Index_t unlimdimid)

inquiry and register the dimension ids of the NetCDF file (to read or append a file) @ ndims : number of dimensions that have to be registered, i.e. computed by ncmu_inq(). @ unlimdimid : the NetCDF dimension ID of the unlimited dimension, i.e. computed by ncmu_inq().

void register_netcdf_variable_ids(std::uint64_t nvars)

inquiry and register the variable ids of the NetCDF file (to read or append a file) @ ndims : number of variables that have to be registered, i.e. computed by ncmu_inq().

void register_netcdf_attribute_names()

inquiry and register the attribute names of variables from the NetCDF file. Here the names are registered because attributes have no unique IDs, their numbers can change. (to read or append a file)

void register_netcdf_attribute_values()

register the values of all attributes with registered names

void define_global_attributes()

write NetCDFGlobalAtts from global_attributes (which are not already written) this function is only called if the file was open in FileIOBase::OpenMode::Write or FileIOBase::OpenMode::Overwrite. Then it is only called twice, once in FileIONetCDF::open() and once in FileIONetCDF::write() or FileIONetCDF::close() if write() was not called before close.

void define_global_attributes_save_call()

call define global attributes and check all requiremnts and bring the NetCDF file in the correct status if necessary. If no save call is possible the function exits without doing anything

void register_netcdf_global_attribute_names()

inquiry and register the global attribute names of variables from the NetCDF file. Here the names are registered because global attributes have no unique IDs, their numbers can change. (to read or append a file)

void register_netcdf_global_attribute_values()

register the values of all global attributes with registered names

void update_global_attribute_last_modified()

update the last modified flag by the current date and time

void update_global_attribute_last_modified_save_call()

save call of update_global_attribute_last_modified which checks all necessary conditions and otherwise do not call the function.

void netcdf_file_changes()

stes the flag netcdf_file_changed to true if it is not already true

Protected Attributes

int netcdf_id = {-1}

NetCDFMode netcdf_mode{NetCDFMode::UndefinedMode}

bool netcdf_file_changed = {false}

bool global_attributes_defined{false}

NetCDFGlobalAttributes global_attributes

NetCDFDimensions dimensions

NetCDFVariables variables

const std::string pixel = {"pixel"}

const muGrid::FieldCollection::SubPtMap_t nb_sub_pts

muGrid::GlobalFieldCollection GFC_local_pixels

bool initialised_GFC_local_pixels = {false}

std::vector<std::string> written_local_pixel_fields = {}

std::vector<std::string> read_local_pixel_fields = {}

std::vector<std::string> state_field_field_names = {}

template<size_t N>
struct Foreach

#include <iterators.hh>

static for loop

Public Static Functions

template<class Tuple>
static inline bool not_equal(Tuple &&a, Tuple &&b)

undocumented

template<>
struct Foreach<0>

#include <iterators.hh>

static comparison

Public Static Functions

template<class Tuple>
static inline bool not_equal(Tuple &&a, Tuple &&b)

undocumented

class GlobalFieldCollection : public muGrid::FieldCollection

#include <field_collection_global.hh>

muGrid::GlobalFieldCollection derives from muGrid::FieldCollection and stores global fields that live throughout the whole computational domain, i.e. are defined for every pixel/voxel.

Public Types

using Parent = FieldCollection

alias of base class

using DynamicPixels = CcoordOps::DynamicPixels

pixel iterator

using SubPtMap_t = std::map<std::string, Index_t>

map to hold nb_sub_pts by tag

Public Functions

GlobalFieldCollection() = delete

Default constructor.

GlobalFieldCollection(const Index_t &spatial_dimension, const SubPtMap_t &nb_sub_pts = {}, StorageOrder storage_order = StorageOrder::ArrayOfStructures)

Constructor

Parameters:

• spatial_dimension – number of spatial dimensions, must be 1, 2, 3, or Unknown

• nb_sub_pts – number of quadrature points per pixel/voxel

GlobalFieldCollection(const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdomain_grid_pts = {}, const DynCcoord_t &subdomain_locations = {}, const SubPtMap_t &nb_sub_pts = {}, StorageOrder storage_order = StorageOrder::ArrayOfStructures)

Constructor with initialization

Parameters:

• nb_subdomain_grid_pts – number of grid points on the current MPI process (subdomain)

• subdomain_locations – location of the current subdomain within the global grid

• nb_sub_pts – number of quadrature points per pixel/voxel

GlobalFieldCollection(const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdomain_grid_pts, const DynCcoord_t &subdomain_locations, const DynCcoord_t &pixels_strides, const SubPtMap_t &nb_sub_pts = {}, StorageOrder storage_order = StorageOrder::ArrayOfStructures)

Constructor with initialisation

Parameters:

• nb_subdomain_grid_pts – number of grid points on the current MPI process (subdomain)

• subdomain_locations – location of the current subdomain within the global grid

• pixels_strides – strides specifying memory layout of the pixels

• storage_order – Storage order of the pixels vs subdivision portion of the field. In a column-major storage order, the pixel subdivision (i.e. the components of the field) are stored next to each other in memory, file in a row-major storage order for each component the pixels are stored next to each other in memory. (This is also sometimes called the array of structures vs. structure of arrays storage order.) Important: The pixels or subpoints have their own storage order that is not affected by this setting.

GlobalFieldCollection(const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdomain_grid_pts, const DynCcoord_t &subdomain_locations, StorageOrder pixels_storage_order, const SubPtMap_t &nb_sub_pts = {}, StorageOrder storage_order = StorageOrder::ArrayOfStructures)

Constructor with initialisation

Parameters:

• nb_subdomain_grid_pts – number of grid points on the current MPI process (subdomain)

• subdomain_locations – location of the current subdomain within the global grid

• pixels_storage_order – Storage order of the pixels

• storage_order – Storage order of the pixels vs subdivision portion of the field. In a column-major storage order, the pixel subdivision (i.e. the components of the field) are stored next to each other in memory, file in a row-major storage order for each component the pixels are stored next to each other in memory. (This is also sometimes called the array of structures vs. structure of arrays storage order.) Important: The pixels or subpoints have their own storage order that is not affected by this setting.

GlobalFieldCollection(const GlobalFieldCollection &other) = delete

Copy constructor.

GlobalFieldCollection(GlobalFieldCollection &&other) = default

Move constructor.

virtual ~GlobalFieldCollection() = default

Destructor.

GlobalFieldCollection &operator=(const GlobalFieldCollection &other) = delete

Copy assignment operator.

GlobalFieldCollection &operator=(GlobalFieldCollection &&other) = delete

Move assignment operator.

const DynamicPixels &get_pixels() const

Return the pixels class that allows to iterator over pixels.

inline Index_t get_index(const DynCcoord_t &ccoord) const

evaluate and return the linear index corresponding to dynamic ccoord

template<size_t Dim>
inline Index_t get_index(const Ccoord_t<Dim> &ccoord) const

evaluate and return the linear index corresponding to ccoord

inline DynCcoord_t get_ccoord(const Index_t &index) const

return coordinates of the i-th pixel

void initialise(const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdomain_grid_pts, const DynCcoord_t &subdomain_locations, const DynCcoord_t &pixels_strides)

freeze the problem size and allocate memory for all fields of the collection. Fields added later on will have their memory allocated upon construction.

template<size_t Dim>
inline void initialise(const Ccoord_t<Dim> &nb_domain_grid_pts, const Ccoord_t<Dim> &nb_subdomain_grid_pts, const Ccoord_t<Dim> &subdomain_locations, const Ccoord_t<Dim> &pixels_strides)

freeze the problem size and allocate memory for all fields of the collection. Fields added later on will have their memory allocated upon construction.

void initialise(const DynCcoord_t &nb_domain_grid_pts, const DynCcoord_t &nb_subdomain_grid_pts = {}, const DynCcoord_t &subdomain_locations = {}, StorageOrder pixels_storage_order = StorageOrder::Automatic)

freeze the problem size and allocate memory for all fields of the collection. Fields added later on will have their memory allocated upon construction.

template<size_t Dim>
inline void initialise(const Ccoord_t<Dim> &nb_domain_grid_pts, const Ccoord_t<Dim> &nb_subdomain_grid_pts = {}, const Ccoord_t<Dim> &subdomain_locations = {}, StorageOrder pixels_storage_order = StorageOrder::Automatic)

freeze the problem size and allocate memory for all fields of the collection. Fields added later on will have their memory allocated upon construction.

GlobalFieldCollection get_empty_clone() const

obtain a new field collection with the same domain and pixels

virtual Shape_t get_pixels_shape() const

return shape of the pixels

virtual Shape_t get_pixels_strides(Index_t element_size = 1) const

return strides of the pixels

inline const DynCcoord_t &get_nb_domain_grid_pts() const

returns the global (domain) number of grid points in each direction

inline const DynCcoord_t &get_nb_subdomain_grid_pts() const

returns the process-local (subdomain) number of grid points in each direction

inline const DynCcoord_t &get_subdomain_locations() const

returns the process-local (subdomain) locations of subdomain grid

Protected Attributes

DynamicPixels pixels = {}

helper to iterate over the grid

DynCcoord_t nb_domain_grid_pts = {}

class GradientOperator : public muGrid::ConvolutionOperatorBase

#include <gradient_operator.hh>

Implements gradient operations based on shape function gradients.

This class extends ConvolutionOperatorBase to provide specific implementations for gradient and divergence operations based on the shape function gradients for each quadrature point. It is designed to work with fields defined on nodal points and quadrature points, facilitating the evaluation of gradients and the discretised divergence.

Note

This class cannot be instantiated directly and does not support copy construction or copy assignment.

Public Types

using Parent = ConvolutionOperatorBase

Public Functions

GradientOperator() = delete

Default constructor is deleted to prevent instantiation.

GradientOperator(const Index_t &spatial_dim, const Index_t &nb_quad_pts, const Index_t &nb_elements, const Index_t &nb_elemnodal_pts, const Index_t &nb_pixelnodal_pts, const std::vector<std::vector<Eigen::MatrixXd>> &shape_fn_gradients, const std::vector<std::tuple<Eigen::VectorXi, Eigen::MatrixXi>> &nodal_pts)

Constructs a GradientOperator object.

Initializes the gradient operator with the provided spatial dimensions, number of quadrature points, elements, nodal points, and shape function gradients.

Parameters:

• spatial_dim – Spatial dimension of the stencil.

• nb_quad_pts – Number of quadrature points per element.

• nb_elements – Number of elements per pixel.

• nb_elemnodal_pts – Number of nodal points per element.

• nb_pixelnodal_pts – Number of nodal points per pixel.

• shape_fn_gradients – Shape function gradients for each quadrature point and element.

• nodal_pts – Nodal point indices composed of nodal point index within a pixel and pixel coordinate offset.

GradientOperator(const Eigen::MatrixXd &pixel_operator, const Index_t &spatial_dim, const Index_t &nb_quad_pts, const Index_t &nb_pixelnodal_pts)

Constructs a GradientOperator object.

Initializes the gradient operator with the provided pixel operator, spatial dimensions, number of quadrature points, nodal points.

Parameters:

• pixel_operator – The pixel-wise operator.

• spatial_dim – Spatial dimension of the pixel.

• nb_quad_pts – Number of quadrature points per pixel.

• nb_pixelnodal_pts – Number of nodal points per pixel.

GradientOperator(const GradientOperator &other) = delete

Copy constructor.

GradientOperator(GradientOperator &&other) = default

Move constructor.

virtual ~GradientOperator() = default

Destructor.

GradientOperator &operator=(const GradientOperator &other) = delete

Copy assignment operator.

GradientOperator &operator=(GradientOperator &&other) = default

Move assignment operator.

virtual void apply(const TypedFieldBase<Real> &nodal_field, TypedFieldBase<Real> &quadrature_point_field) const final

Evaluates the gradient of nodal_field into quadrature_point_field

Parameters:

• nodal_field – input field of which to take gradient. Defined on nodal points

• quadrature_point_field – output field to write gradient into. Defined on quadrature points

virtual void apply_increment(const TypedFieldBase<Real> &nodal_field, const Real &alpha, TypedFieldBase<Real> &quadrature_point_field) const override

Evaluates the gradient of nodal_field and adds it to quadrature_point_field

Parameters:

• nodal_field – input field of which to take gradient. Defined on nodal points

• quadrature_point_field – output field to increment by the gradient field. Defined on quadrature points

virtual void transpose(const TypedFieldBase<Real> &quadrature_point_field, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const final

Evaluates the discretised divergence of quadrature_point_field into nodal_field, weights corrensponds to Gaussian quadrature weights. If weights are omitted, this returns some scaled version of discretised divergence.

Parameters:

• quadrature_point_field – input field of which to take the divergence. Defined on quadrature points.

• nodal_field – ouput field into which divergence is written

• weights – Gaussian quadrature weigths

virtual void transpose_increment(const TypedFieldBase<Real> &quadrature_point_field, const Real &alpha, TypedFieldBase<Real> &nodal_field, const std::vector<Real> &weights = {}) const final

Evaluates the discretised divergence of quadrature_point_field and adds the result to nodal_field, weights corrensponds to Gaussian quadrature weights. If weights are omitted, this returns some scaled version of discretised divergence.

Parameters:

• quadrature_point_field – input field of which to take the divergence. Defined on quadrature points.

• nodal_field – ouput field to be incremented by theh divergence

• weights – Gaussian quadrature weigths

const Eigen::MatrixXd &get_pixel_operator() const

Return the gradient matrix linking the nodal degrees of freedom to their quadrature-point derivatives.

virtual Index_t get_nb_quad_pts() const final

returns the number of quadrature points are associated with any pixel/voxel (i.e., the sum of the number of quadrature points associated with each element belonging to any pixel/voxel.

virtual Index_t get_nb_nodal_pts() const final

returns the number of nodal points associated with any pixel/voxel. (Every node belonging to at least one of the elements belonging to any pixel/voxel, without recounting nodes that appear multiple times)

virtual Index_t get_spatial_dim() const final

return the spatial dimension of this gradient operator

Protected Attributes

Eigen::MatrixXd pixel_operator = {}

matrix linking the nodal degrees of freedom to their quadrature-point derivatives.

Index_t spatial_dim

Index_t nb_quad_pts

number of quadrature points per element (e.g.. 4 for linear quadrilateral)

Index_t nb_pixelnodal_pts

number of nodal points per pixel

Index_t nb_possible_nodal_contribution

number of nodal points that could possibly have an influnce on gradient values in this pixel. This corresponds to the number of nodal points per pixel for this pixel plus the upper neighbour plus the right neighbour plus the frontal neighbour for a three-dimensional problem.

Index_t nb_grad_component_per_pixel

class IndexIterable

#include <field_collection.hh>

Iterate class for iterating over quadrature point indices of a field collection (i.e. the iterate you get when iterating over the result of muGrid::FieldCollection::get_quad_pt_indices).

Public Functions

IndexIterable() = delete

Default constructor.

IndexIterable(const IndexIterable &other) = delete

Copy constructor.

IndexIterable(IndexIterable &&other) = default

Move constructor.

virtual ~IndexIterable() = default

Destructor.

IndexIterable &operator=(const IndexIterable &other) = delete

Copy assignment operator.

IndexIterable &operator=(IndexIterable &&other) = delete

Move assignment operator.

iterator begin() const

stl

iterator end() const

stl

size_t size() const

stl

Protected Functions

IndexIterable(const FieldCollection &collection, const std::string &tag, const Index_t &stride = Unknown)

Constructor is protected, because no one ever need to construct this except the fieldcollection. Constructor for sub_point iteration

explicit IndexIterable(const FieldCollection &collection, const Index_t &stride = Unknown)

Constructor is protected, because no one ever need to construct this except the fieldcollection. Constructor for pixel iteration

Protected Attributes

friend FieldCollection

allow the field collection to create muGrid::FieldCollection::IndexIterables

const FieldCollection &collection

reference back to the proxied collection

const IterUnit iteration_type

whether to iterate over pixels or quadrature points

size_t stride

stride for the slow moving index

template<class Derived>
struct is_fixed

#include <eigen_tools.hh>

Helper class to check whether an Eigen::Array or Eigen::Matrix is statically sized

Public Types

using T = std::remove_cv_t<std::remove_reference_t<Derived>>

raw type for testing

Public Static Attributes

static constexpr bool value = {T::SizeAtCompileTime != Eigen::Dynamic}

evaluated test

template<class TestClass>
struct is_matrix

#include <eigen_tools.hh>

Structure to determine whether an expression can be evaluated into a Eigen::Matrix, Eigen::Array, etc. and which helps determine compile-time size

Public Types

using T = std::remove_cv_t<std::remove_reference_t<TestClass>>

Public Static Attributes

static constexpr bool value{std::is_base_of<Eigen::MatrixBase<T>, T>::value}

template<class Derived>
struct is_matrix<Eigen::Map<Derived>>

Public Static Attributes

static constexpr bool value = {is_matrix<Derived>::value}

template<class Derived>
struct is_matrix<Eigen::MatrixBase<Eigen::Map<Derived>>>

Public Static Attributes

static constexpr bool value = {is_matrix<Derived>::value}

template<class Derived>
struct is_matrix<Eigen::Ref<Derived>>

Public Static Attributes

static constexpr bool value = {is_matrix<Derived>::value}

template<class T>
struct is_reference_wrapper : public std::false_type

template<class U>
struct is_reference_wrapper<std::reference_wrapper<U>> : public std::true_type

template<class Derived>
struct is_square

#include <eigen_tools.hh>

Helper class to check whether an Eigen::Array or Eigen::Matrix is a static-size and square.

Public Types

using T = std::remove_cv_t<std::remove_reference_t<Derived>>

raw type for testing

Public Static Attributes

static constexpr bool value{(T::RowsAtCompileTime == T::ColsAtCompileTime) && is_fixed<T>::value}

true if the object is square and statically sized

template<class T, Dim_t order>
struct is_tensor

#include <tensor_algebra.hh>

Check whether a given expression represents a Tensor specified order.

Public Static Attributes

static constexpr bool value = (std::is_convertible<T, Eigen::Tensor<Real, order>>::value || std::is_convertible<T, Eigen::Tensor<Int, order>>::value || std::is_convertible<T, Eigen::Tensor<Complex, order>>::value)

evaluated test

class iterator : public muGrid::CcoordOps::DynamicPixels::iterator

#include <ccoord_operations.hh>

A derived class from DynamicPixels::iterator, used for iterating over Pixels.

This class is a final class, meaning it cannot be further derived from. It provides a custom implementation of the dereference operator (*).

Note

The using Parent::Parent; statement is a C++11 feature called “Inheriting Constructors” which means that this derived class will have the same constructors as the base class.

Template Parameters:

Parent – Alias for the base class DynamicPixels::iterator.

Public Types

using Parent = DynamicPixels::iterator

Public Functions

inline std::tuple<Index_t, Parent::value_type> operator*() const

Overloaded dereference operator (*).

This function returns a tuple containing the index of the pixel and the pixel’s coordinates.

Returns:

std::tuple<Index_t, Parent::value_type> A tuple containing the index of the pixel and the pixel’s coordinates.

class iterator

#include <ccoord_operations.hh>

Iterator class for muSpectre::DynamicPixels

Subclassed by muGrid::CcoordOps::DynamicPixels::Enumerator::iterator

Public Types

using value_type = DynCcoord<threeD>

stl

using const_value_type = const value_type

stl conformance

using pointer = value_type*

stl conformance

using difference_type = std::ptrdiff_t

stl conformance

using iterator_category = std::forward_iterator_tag

stl conformance

Public Functions

inline iterator(const DynamicPixels &pixels, size_t index)

constructor

iterator() = delete

Default constructor.

iterator(const iterator &other) = default

Copy constructor.

iterator(iterator &&other) = default

Move constructor.

~iterator() = default

Destructor.

iterator &operator=(const iterator &other) = delete

Copy assignment operator.

iterator &operator=(iterator &&other) = delete

Move assignment operator.

inline value_type operator*() const

dereferencing

inline iterator &operator++()

pre-increment

inline bool operator!=(const iterator &other) const

inequality

inline bool operator==(const iterator &other) const

equality

Protected Attributes

const DynamicPixels &pixels

ref to pixels in cell

size_t index

index of currently pointed-to pixel

class iterator

#include <ccoord_operations.hh>

iterators over Pixels dereferences to cell coordinates

Public Types

using value_type = Ccoord

stl conformance

using const_value_type = const value_type

stl conformance

using pointer = value_type*

stl conformance

using difference_type = std::ptrdiff_t

stl conformance

using iterator_category = std::forward_iterator_tag

stl conformance

using reference = value_type

stl conformance

Public Functions

explicit iterator(const Pixels &pixels, bool begin = true)

constructor

virtual ~iterator() = default

inline value_type operator*() const

dereferencing

inline iterator &operator++()

pre-increment

inline bool operator!=(const iterator &other) const

inequality

inline bool operator==(const iterator &other) const

equality

Protected Attributes

const Pixels &pixels

ref to pixels in cell

size_t index

index of currently pointed-to pixel

class iterator

#include <field_collection.hh>

iterator class for iterating over quadrature point indices or pixel indices of a muGrid::FieldCollection::IndexIterable. Dereferences to an index.

Public Types

using PixelIndexIterator_t = typename std::vector<Index_t>::const_iterator

convenience alias

Public Functions

iterator() = delete

Default constructor.

iterator(const PixelIndexIterator_t &pixel_index_iterator, const size_t &stride)

constructor

iterator(const iterator &other) = default

Copy constructor.

iterator(iterator &&other) = default

Move constructor.

~iterator() = default

Destructor.

inline iterator &operator++()

pre-increment

inline bool operator!=(const iterator &other) const

comparison

inline bool operator==(const iterator &other) const

comparison (required by akantu::iterators)

inline size_t operator*()

dereference

Protected Attributes

size_t stride

stride for the slow moving index

Index_t offset = {}

fast-moving index

PixelIndexIterator_t pixel_index_iterator

iterator of slow moving index

template<Mapping MutIter>
class Iterator

forward-declaration for mugrid::FieldMap’s iterator

Public Types

using FieldMap_t = std::conditional_t<MutIter == Mapping::Const, const FieldMap, FieldMap>

convenience alias

using value_type = typename FieldMap<T, Mutability>::template Return_t<MutIter>

stl

using cvalue_type = typename FieldMap<T, Mutability>::template Return_t<Mapping::Const>

stl

Public Functions

Iterator() = delete

Default constructor.

inline Iterator(FieldMap_t &map, bool end)

Constructor to beginning, or to end.

Iterator(const Iterator &other) = delete

Copy constructor.

Iterator(Iterator &&other) = default

Move constructor.

virtual ~Iterator() = default

Destructor.

Iterator &operator=(const Iterator &other) = default

Copy assignment operator.

Iterator &operator=(Iterator &&other) = default

Move assignment operator.

inline Iterator &operator++()

pre-increment

inline value_type operator*()

dereference

inline cvalue_type operator*() const

dereference

inline bool operator==(const Iterator &other) const

equality

inline bool operator!=(const Iterator &other) const

inequality

Protected Attributes

FieldMap_t &map

FieldMap being iterated over.

size_t index

current iteration index

class iterator

#include <file_io_base.hh>

A class for iterating over the frames in the file.

This class provides a common interface for file frame iteration operations. It provides a set of constructors and assignment operators (both copy and move are deleted). It also provides a destructor and methods for dereferencing and incrementing.

Note

This class cannot be instantiated directly (default constructor is deleted).

Public Types

using value_type = FileFrame

STL type aliases for iterator conformance.

using const_value_type = const value_type

STL conformance.

using pointer = value_type*

STL conformance.

using difference_type = std::ptrdiff_t

STL conformance.

using iterator_category = std::forward_iterator_tag

STL conformance.

Public Functions

iterator() = delete

Default constructor is deleted to prevent direct instantiation of this class without parameters.

inline explicit iterator(FileIOBase &parent, Index_t frame_index = 0)

Constructor with the FileIOBase object and the required frame index.

This constructor initializes an iterator object with the given FileIOBase object and frame index.

Parameters:

• parent – The FileIOBase object.

• frame_index – The frame index.

iterator(const iterator &other) = default

Copy constructor.

iterator(iterator &&other) = default

Move constructor.

~iterator() = default

Destructor.

iterator &operator=(const iterator &other) = delete

Copy assignment operator is deleted to prevent copying of iterator objects.

iterator &operator=(iterator &&other) = delete

Move assignment operator is deleted to prevent moving of iterator objects.

inline const_value_type operator*() const

Dereferencing operator.

This operator provides access to a specific frame in the file. The frame must exist for this operation to succeed.

Returns:

const_value_type The requested frame.

inline iterator &operator++()

Pre-increment operator.

This operator increments the frame index by one.

Returns:

iterator& A reference to the incremented iterator.

inline bool operator==(const iterator &other) const

Equality comparison operator.

This operator checks if the frame index of the current iterator is equal to that of the other iterator.

Parameters:

other – The other iterator to compare with.

Returns:

bool True if the frame indices are equal, false otherwise.

inline bool operator!=(const iterator &other) const

Inequality comparison operator.

This operator checks if the frame index of the current iterator is not equal to that of the other iterator.

Parameters:

other – The other iterator to compare with.

Returns:

bool True if the frame indices are not equal, false otherwise.

Protected Attributes

FileIOBase &parent

The FileIOBase object.

Index_t frame_index = {}

The frame index.

class iterator

Public Functions

inline explicit iterator(const CartesianContainer &container, const size_t &counter = 0)

~iterator() = default

inline iterator &operator++()

inline const Shape_t &operator*() const

inline bool operator!=(const iterator &other) const

Protected Attributes

const CartesianContainer &container

Shape_t index

size_t counter = {0}

class iterator : public std::vector::iterator

#include <ref_vector.hh>

iterator over muGrid::RefVector

Public Functions

inline iterator(Parent &iterator)

copy constructor

inline iterator(Parent &&iterator)

move constructor

inline T &operator*()

dereference

Private Types

using Parent = typename std::vector<T*>::iterator

template<Mapping MutIter>
class Iterator

#include <state_field_map.hh>

iterator type

Iterator class for muGrid::StateFieldMap

Public Types

using StateFieldMap_t = std::conditional_t<MutIter == Mapping::Const, const StateFieldMap, StateFieldMap>

convenience alias

using StateWrapper_t = typename StateFieldMap::template StateWrapper<MutIter>

const-correct proxy for iterates

Public Functions

Iterator() = delete

Deleted default constructor.

Iterator(StateFieldMap_t &state_field_map, size_t index)

constructor (should never have to be called by the user)

Iterator(const Iterator &other) = delete

Copy constructor.

Iterator(Iterator &&other) = default

Move constructor.

virtual ~Iterator() = default

destructor

Iterator &operator=(const Iterator &other) = delete

Copy assignment operator.

Iterator &operator=(Iterator &&other) = default

Move assignment operator.

inline bool operator!=(const Iterator &other)

comparison

inline Iterator &operator++()

pre-increment

inline StateWrapper_t operator*()

dereference

Protected Attributes

StateFieldMap_t &state_field_map

reference back to the iterated map

size_t index

current iteration progress

template<Mapping MutIter>
class Iterator

#include <field_map_static.hh>

Iterator class for muGrid::StaticFieldMap

Public Types

using value_type = typename MapType::template value_type<MutIter>

type returned by iterator

using storage_type = typename MapType::template storage_type<MutIter>

type stored

Public Functions

Iterator() = delete

Default constructor.

inline Iterator(const StaticFieldMap &map, bool end)

Constructor to beginning, or to end.

Iterator(const Iterator &other) = default

Copy constructor.

Iterator(Iterator &&other) = default

Move constructor.

virtual ~Iterator() = default

Destructor.

Iterator &operator=(const Iterator &other) = default

Copy assignment operator.

Iterator &operator=(Iterator &&other) = default

Move assignment operator.

inline Iterator &operator++()

pre-increment

inline value_type &operator*()

dereference

inline value_type *operator->()

pointer to member

inline bool operator==(const Iterator &other) const

equality

inline bool operator!=(const Iterator &other) const

inequality

Protected Attributes

const StaticFieldMap &map

FieldMap being iterated over.

size_t index

current iteration index

storage_type iterate

map which is being returned per iterate

template<Mapping MutIter>
class Iterator

froward declaration of iterator class

Public Types

using StaticStateFieldMap_t = std::conditional_t<MutIter == Mapping::Const, const StaticStateFieldMap, StaticStateFieldMap>

const correct iterated map

using StateWrapper_t = typename StaticStateFieldMap::template StaticStateWrapper<MutIter>

convenience alias to dererencing return type

Public Functions

Iterator() = delete

Default constructor.

Iterator(const Iterator &other) = delete

Copy constructor.

inline Iterator(StaticStateFieldMap_t &state_field_map, size_t index)

constructor with field map and index, not for user to call

Iterator(Iterator &&other) = default

Move constructor.

virtual ~Iterator() = default

Destructor.

Iterator &operator=(const Iterator &other) = delete

Copy assignment operator.

Iterator &operator=(Iterator &&other) = default

Move assignment operator.

inline bool operator!=(const Iterator &other) const

comparison

inline bool operator==(const Iterator &other) const

comparison (needed by akantu::iterator

inline Iterator &operator++()

pre-increment

inline StateWrapper_t operator*()

dereference

Protected Attributes

StaticStateFieldMap_t &state_field_map

reference bap to iterated map

size_t index

current progress in iteration

class KeyError : public muGrid::DictionaryError

class LocalFieldCollection : public muGrid::FieldCollection

#include <field_collection_local.hh>

muGrid::LocalFieldCollection derives from muGrid::FieldCollection and stores local fields, i.e. fields that are only defined for a subset of all pixels/voxels in the computational domain. The coordinates of these active pixels are explicitly stored by this field collection. muGrid::LocalFieldCollection::add_pixel allows to add individual pixels/voxels to the field collection.

Public Types

using Parent = FieldCollection

alias for base class

Public Functions

LocalFieldCollection() = delete

Default constructor.

LocalFieldCollection(const Index_t &spatial_dimension, const SubPtMap_t &nb_sub_pts = {})

Constructor

Parameters:

spatial_dimension – spatial dimension of the field (can be muGrid::Unknown, e.g., in the case of the local fields for storing internal material variables)

LocalFieldCollection(const Index_t &spatial_dimension, const std::string &name, const SubPtMap_t &nb_sub_pts = {})

Constructor with explicit given name for the field collection. This name can be arbitrary and only has to be unique for all LocalFieldCollections which are saved to the same NetCDF file through the parallel IO object ‘FileIONetCDF’. If you register two LocalFieldCollections with the same name in a FileIONetCDF object you will get a muGrid::FieldCollectionError.

LocalFieldCollection(const LocalFieldCollection &other) = delete

Copy constructor.

LocalFieldCollection(LocalFieldCollection &&other) = default

Move constructor.

virtual ~LocalFieldCollection() = default

Destructor.

LocalFieldCollection &operator=(const LocalFieldCollection &other) = delete

Copy assignment operator.

LocalFieldCollection &operator=(LocalFieldCollection &&other) = delete

Move assignment operator.

void add_pixel(const size_t &global_index)

Insert a new pixel/voxel into the collection.

Parameters:

global_index – refers to the linear index this pixel has in the global field collection defining the problem space

void initialise()

Freeze the set of pixels this collection is responsible for and allocate memory for all fields of the collection. Fields added lateron will have their memory allocated upon construction

LocalFieldCollection get_empty_clone(const std::string &new_name) const

obtain a new field collection with the same domain and pixels and a given new name

LocalFieldCollection get_empty_clone() const

obtain a new field collection with the same domain and pixels and the same name

virtual Shape_t get_pixels_shape() const

return shape of the pixels

virtual Shape_t get_pixels_strides(Index_t element_size = 1) const

return strides of the pixels

inline std::map<Index_t, Index_t> &get_global_to_local_index_map()

const std::string &get_name() const

return the unique name of the local field collection

Protected Attributes

std::map<Index_t, Index_t> global_to_local_index_map = {}

std::string name = {}

template<class FieldMapType>
class MappedField

#include <mapped_field.hh>

MappedFields are a combination of a field and an associated map, and as such it does not introduce any new functionality that Fields and FieldMaps do not already possess. They provide a convenience structure for the default use case of internal variables, which are typically used only by a single material and always the same way.

Public Types

using Scalar = typename FieldMapType::Scalar

stored scalar type

using Return_t = typename FieldMapType::template Return_t<FieldMapType::FieldMutability()>

return type for iterators over this- map

using iterator = typename FieldMapType::iterator

iterator over this map

using const_iterator = typename FieldMapType::const_iterator

constant iterator over this map

Public Functions

MappedField() = delete

Default constructor.

template<bool StaticConstructor = IsStatic(), std::enable_if_t<StaticConstructor, int> = 0>
inline MappedField(const std::string &unique_name, FieldCollection &collection, const std::string &sub_division_tag, const Unit &unit = Unit::unitless())

Constructor with name and collection for statically sized mapped fields

template<bool StaticConstructor = IsStatic(), std::enable_if_t<not StaticConstructor, int> = 0>
inline MappedField(const std::string &unique_name, const Index_t &nb_rows, const Index_t &nb_cols, const IterUnit &iter_type, FieldCollection &collection, const std::string &sub_division_tag, const Unit &unit = Unit::unitless())

Constructor for dynamically sized mapped field

Parameters:

• unique_name – unique identifier for this field

• nb_rows – number of rows for the iterates

• nb_cols – number of columns for the iterates

• iter_type – whether to iterate over pixels or quadrature points

• collection – collection where the field is to be registered

• unit – physical units of mapped field

• nb_sub_pts – number of subpoints per pixel. Specify only if iter_type is muGrid::IterUnit::FreePt

template<bool StaticConstructor = IsStatic(), std::enable_if_t<StaticConstructor, int> = 0>
inline explicit MappedField(TypedField<Scalar> &field)

Constructor of statically sized mapped fields from a pre-existing field checking the consistency of the size of the map and the field is handled in the constructor of the FieldMap

template<bool StaticConstructor = IsStatic(), std::enable_if_t<not StaticConstructor, int> = 0>
inline MappedField(TypedField<Scalar> &field, const Index_t &nb_rows, const IterUnit &iter_type)

Constructor of statically sized mapped fields from a pre-existing field checking the consistency of the size of the map and the field is handled in the constructor of the FieldMap

MappedField(const MappedField &other) = delete

Copy constructor.

MappedField(MappedField &&other) = default

Move constructor.

virtual ~MappedField() = default

Destructor.

MappedField &operator=(const MappedField &other) = delete

Copy assignment operator.

MappedField &operator=(MappedField &&other) = default

Move assignment operator.

inline MappedField &operator-=(const MappedField &other)

subtraction assignment

inline MappedField &operator+=(const MappedField &other)

addition assignment

inline MappedField &operator=(const TypedFieldBase<Scalar> &other)

Copy assignment operator.

inline MappedField &operator=(const typename TypedFieldBase<Scalar>::Negative &other)

Copy assignment operator.

inline Return_t operator[](size_t index)

random access operator

inline iterator begin()

stl

inline iterator end()

stl

inline const_iterator begin() const

stl

inline const_iterator end() const

stl

inline TypedField<Scalar> &get_field()

return a reference to the mapped field

inline const TypedField<Scalar> &get_field() const

return a reference to the mapped field

inline FieldMapType &get_map()

return a reference to the map

inline const FieldMapType &get_map() const

return a reference to the map

Public Static Functions

static inline constexpr bool IsStatic()

detemine at compile time whether the field map is statically sized

Protected Attributes

TypedField<Scalar> &field

reference to mapped field

FieldMapType map

associated field map

template<class StateFieldMapType>
class MappedStateField

#include <mapped_state_field.hh>

MappedStateFields are a combination of a state field and an associated map, and as such it does not introduce any new functionality that StateFields and StateFieldMaps do not already possess. They provide a convenience structure for the default use case of internal variables, which are typically used only by a single material and always the same way.

Public Types

using Scalar = typename StateFieldMapType::Scalar

stored scalar type

using Return_t = typename StateFieldMapType::template StaticStateWrapper<StateFieldMapType::FieldMutability()>

return type for iterators over this- map

using iterator = typename StateFieldMapType::iterator

iterator over this map

using const_iterator = typename StateFieldMapType::const_iterator

constant iterator over this map

Public Functions

MappedStateField() = delete

Deleted default constructor.

inline MappedStateField(const std::string &unique_name, FieldCollection &collection, const std::string &sub_division_tag)

Constructor with name and collection.

MappedStateField(const MappedStateField &other) = delete

Copy constructor.

MappedStateField(MappedStateField &&other) = default

Move constructor.

virtual ~MappedStateField() = default

Destructor.

MappedStateField &operator=(const MappedStateField &other) = delete

Copy assignment operator.

MappedStateField &operator=(MappedStateField &&other) = default

Move assignment operator.

inline Return_t operator[](size_t index)

random access operator

inline iterator begin()

stl

inline iterator end()

stl

inline const_iterator begin() const

stl

inline const_iterator end() const

stl

inline TypedStateField<Scalar> &get_state_field()

return a reference to the mapped state field

inline StateFieldMapType &get_map()

return a reference to the map

Protected Attributes

size_t nb_components

number of components stored per quadrature point

TypedStateField<Scalar> &state_field

ref to mapped state field

StateFieldMapType map

associated field map

struct Negative

#include <field_typed.hh>

Simple structure used to allow for lazy evaluation of the unary ‘-’ sign. When assiging the the negative of a field to another, as in field_a = -field_b, this structure allows to implement this operation without needing a temporary object holding the negative value of field_b.

Public Members

const TypedFieldBase &field

field on which the unary ‘-’ was applied

class NetCDFAtt

#include <file_io_netcdf.hh>

Class to store the attributes belonging to a NetCDFVar variable (att_name, data_type, nelems, value, name_initialised, value_initialised)

Subclassed by muGrid::NetCDFGlobalAtt

Public Functions

NetCDFAtt() = delete

Default constructor.

NetCDFAtt(const std::string &att_name, const std::vector<char> &value)

Constructor with the attribute name and its value (char, muGrid::Int, muGrid::Uint, muGrid::real) the values are represented by std::vector<T> of the corresponding type ‘T’. The type char has an additional convenience constructor which can take also std::string as input.

NetCDFAtt(const std::string &att_name, const std::string &value)

NetCDFAtt(const std::string &att_name, const std::vector<muGrid::Int> &value)

NetCDFAtt(const std::string &att_name, const std::vector<muGrid::Uint> &value)

NetCDFAtt(const std::string &att_name, const std::vector<muGrid::Index_t> &value)

NetCDFAtt(const std::string &att_name, const std::vector<muGrid::Real> &value)

NetCDFAtt(const std::string &att_name, const nc_type &att_data_type, const IOSize_t &att_nelems)

Constructor with the attribute name, data_type and nelems

NetCDFAtt(const NetCDFAtt &other) = default

Copy constructor.

NetCDFAtt(NetCDFAtt &&other) = default

Move constructor.

virtual ~NetCDFAtt() = default

Destructor.

NetCDFAtt &operator=(const NetCDFAtt &other) = delete

Copy assignment operator.

NetCDFAtt &operator=(NetCDFAtt &&other) = delete

Move assignment operator.

const std::string &get_name() const

return attribute name

const nc_type &get_data_type() const

return nc_type data type of attribute value

const IOSize_t &get_nelems() const

return ‘nelems’ number of values stored in the attribute value

IOSize_t get_data_size() const

return the size of the attributes raw data in bytes

IOSize_t get_name_size() const

return the size of the attributes name in bytes

const void *get_value() const

return a const pointer on the attribute value

const std::vector<char> &get_typed_value_c() const

return the attribute values in its ‘real type’, there is a function for each type indicated by the suffix of the function name. It is only allowed to call the function of the correct return type. This can be satisfyed by using NetCDFAtt::get_data_type(), i.e. muGrid::MU_NC_CHAR &#8212; get_typed_value_c() muGrid::MU_NC_INT &#8212; get_typed_value_i() muGrid::MU_NC_UINT &#8212; get_typed_value_ui() muGrid::MU_NC_INDEX_T &#8212; get_typed_value_l() muGrid::MU_NC_REAL &#8212; get_typed_value_d() If you call a function which is not matching the data type a FileIOError will be thrown.

const std::vector<muGrid::Int> &get_typed_value_i() const

const std::vector<muGrid::Uint> &get_typed_value_ui() const

const std::vector<muGrid::Index_t> &get_typed_value_l() const

const std::vector<muGrid::Real> &get_typed_value_d() const

std::string get_value_as_string() const

return the attribute value as std::string

std::string convert_void_value_to_string(void *value) const

converts an input void * value into an std::string under the assumption that its data type is equal to the attributes data type and also its number of elements corresponds to the attributes number of elements. Internal the function get_value_as_string() is used.

void register_value(void *value)

register the attribute value from a void * on the value it is assumed that the value type is the already registered data_type.

void *reserve_value_space()

reserve enoug space for the value returned from the NetCDF file and return a pointer on it

bool equal_value(void *value) const

compares the input void * value with the stored attributes value and returns true if they have the same value(s) and otherwise false. The function compares the actual stored value(s) and not the pointers.

bool is_name_initialised() const

return initialisation status of name, data_type and nelems

bool is_value_initialised() const

return initialisation status of the value

Private Functions

void update_attribute(const std::string &new_att_name, const nc_type &new_att_data_type, const IOSize_t &new_att_nelems, void *new_att_value)

update the name and value of the NetCDFAtt while keeping the data_type. The user of this function is responsible to take care of possible resulting time consuming extensions of the NetCDF header.

void *get_value_non_const_ptr()

return a non const pointer on the attribute value

Private Members

std::string att_name

nc_type data_type

IOSize_t nelems = {0}

std::vector<char> value_c = {}

std::vector<muGrid::Int> value_i = {}

std::vector<muGrid::Uint> value_ui = {}

std::vector<muGrid::Index_t> value_l = {}

std::vector<muGrid::Real> value_d = {}

bool name_initialised{false}

bool value_initialised = {false}

Friends

friend class NetCDFGlobalAtt

class NetCDFDim

#include <file_io_netcdf.hh>

Class to store the properties of a single NetCDF dimension (name, id, size, initialised)

Public Functions

NetCDFDim() = delete

Default constructor.

NetCDFDim(const std::string &dim_base_name, const IOSize_t &dim_size)

Constructor with the dimension name and size

NetCDFDim(const NetCDFDim &other) = default

Copy constructor.

NetCDFDim(NetCDFDim &&other) = delete

Move constructor.

virtual ~NetCDFDim() = default

Destructor.

NetCDFDim &operator=(const NetCDFDim &other) = delete

Copy assignment operator.

NetCDFDim &operator=(NetCDFDim &&other) = delete

Move assignment operator.

const int &get_id() const

get_dimension id

int &set_id()

set_dimension id

const IOSize_t &get_size() const

get_dimension size

const std::string &get_name() const

get_dimension name

std::string get_base_name() const

get the base name of the dimension

int compute_tensor_dim_index() const

bool equal(const std::string &dim_name, const IOSize_t &dim_size) const

compare the dimension is equal to the given dim_name and size

void register_id(const int dim_id)

register dimension id, only possible if the id was not already registered (initialised == false).

void register_unlimited_dim_size()

register unlimited dimension size to NC_UNLIMITED this is only possible for the dimension with name “frame”.

Public Static Functions

static std::string compute_base_name(const std::string &full_name)

compute the base name of a given name.

static std::string compute_dim_name(const std::string &dim_base_name, const std::string &suffix)

Protected Attributes

int id = {DEFAULT_NETCDFDIM_ID}

location to store the returned dimension ID.

IOSize_t size = {}

Length of dimension; that is, number of values for this dimension as an index to variables that use it. 0 is reserved for the unlimited dimension, NC_UNLIMITED.

std::string name

Dimension name. Must be a legal netCDF identifier.

bool initialised{false}

bool to check the initialisation status of a dimension only true if size was correct initialised.

class NetCDFDimensions

#include <file_io_netcdf.hh>

Class to store the NetCDF dimensions (dim_vector, global_domain_grid)

Public Functions

NetCDFDimensions() = default

NetCDFDimensions(const NetCDFDimensions &other) = delete

Copy constructor.

NetCDFDimensions(NetCDFDimensions &&other) = delete

Move constructor.

virtual ~NetCDFDimensions() = default

Destructor.

NetCDFDimensions &operator=(const NetCDFDimensions &other) = delete

Copy assignment operator.

NetCDFDimensions &operator=(NetCDFDimensions &&other) = delete

Move assignment operator.

std::shared_ptr<NetCDFDim> add_dim(const std::string &dim_name, const IOSize_t &dim_size)

Add a Dimension given its base name and size returns a std::shared_ptr<NetCDFDim> to the added NetCDFDim object

void add_field_dims_global(const muGrid::Field &field, std::vector<std::shared_ptr<NetCDFDim>> &field_dims, std::string state_field_name = std::string{})

Add all dimensions of a global Field (f, (h,) s, n, x, y, z) f: frame h: history index for state fields x: number of points in x direction y: number of points in y direction z: number of points in z direction s: number of sub points per point (pixel) n: number of DOFs per sub point

void add_field_dims_local(const muGrid::Field &field, std::vector<std::shared_ptr<NetCDFDim>> &field_dims, const Communicator &comm, std::string state_field_name = std::string{})

Add all dimensions of a local Field (f, (h,) s, n, i) f: frame h: history index for state fields s: number of sub points per point (pixel) n: number of DOFs per sub point i: total number of points (pixels) in the local field

std::shared_ptr<NetCDFDim> find_dim(const std::string &dim_name, const IOSize_t &dim_size)

find dimension by unique dim_name and size returns a std::shared_ptr<NetCDFDim> to the found dimension, if the dimension is not found it returns the end of the dim_vector of the NetCDFDimensions object and throws a muGrid::FielIOError.

std::shared_ptr<NetCDFDim> find_dim(const std::string &dim_name)

find dimension only by the unique dim_name returns a std::shared_ptr<NetCDFDim> to the found dimension, if the dimension is not found it returns the end of the dim_vector of the NetCDFDimensions object and throws a muGrid::FielIOError.

const std::vector<std::shared_ptr<NetCDFDim>> &get_dim_vector() const

return a std::vector<std::shared_ptr<NetCDFDim>> & of all NetCDFDims belonging to the NetCDFDimensions

Protected Attributes

std::vector<std::shared_ptr<NetCDFDim>> dim_vector = {}

std::vector<Index_t> global_domain_grid = {0, 0, 0}

class NetCDFGlobalAtt : public muGrid::NetCDFAtt

#include <file_io_netcdf.hh>

Class to represent GLOBAL NetCDF attributes which do not belong to a NetCDFVar

Public Functions

NetCDFGlobalAtt() = delete

Default constructor.

NetCDFGlobalAtt(const std::string &att_name, const std::vector<char> &value)

Constructor from parent with the attribute name and its value (char, muGrid::Int, muGrid::Uint, muGrid::real) the values are represented by std::vector<T> of the corresponding type ‘T’. The type char has an additional convenience constructor which can take also std::string as input.

NetCDFGlobalAtt(const std::string &att_name, const std::string &value)

NetCDFGlobalAtt(const std::string &att_name, const std::vector<muGrid::Int> &value)

NetCDFGlobalAtt(const std::string &att_name, const std::vector<muGrid::Uint> &value)

NetCDFGlobalAtt(const std::string &att_name, const std::vector<muGrid::Index_t> &value)

NetCDFGlobalAtt(const std::string &att_name, const std::vector<muGrid::Real> &value)

NetCDFGlobalAtt(const std::string &att_name, const nc_type &att_data_type, const IOSize_t &att_nelems)

Constructor from parent with the attribute name, data_type and nelems

NetCDFGlobalAtt(const NetCDFGlobalAtt &other) = default

Copy constructor.

NetCDFGlobalAtt(NetCDFGlobalAtt &&other) = delete

Move constructor.

virtual ~NetCDFGlobalAtt() = default

Destructor.

NetCDFGlobalAtt &operator=(const NetCDFGlobalAtt &other) = delete

Copy assignment operator.

NetCDFGlobalAtt &operator=(NetCDFGlobalAtt &&other) = delete

Move assignment operator.

inline bool is_already_written_to_file()

check if the global attribute was already written to the file; true &#8212; the attribute was already written to the file false &#8212; the attribute was up to now not written to the file

inline void was_written()

call this function after the NetCDFGlobalAtt was written to the NetCDF file to set is_written to true.

template<class T>
inline void update_global_attribute(const std::string &new_att_name, T new_att_value)

changes the global attributes value to new_value if the type of the new_value matches the old value and the size of the new_value does not exceed the size of the old value. Here with old value the current calue of the global attribute is meant.

Protected Attributes

bool is_written

class NetCDFGlobalAttributes

#include <file_io_netcdf.hh>

Class to store the GLOBAL NetCDF attributes

Public Functions

NetCDFGlobalAttributes() = default

NetCDFGlobalAttributes(const NetCDFGlobalAttributes &other) = delete

Copy constructor.

NetCDFGlobalAttributes(NetCDFGlobalAttributes &&other) = delete

Move constructor.

virtual ~NetCDFGlobalAttributes() = default

Destructor.

NetCDFGlobalAttributes &operator=(const NetCDFGlobalAttributes &other) = delete

Copy assignment operator.

NetCDFGlobalAttributes &operator=(NetCDFGlobalAttributes &&other) = delete

Move assignment operator.

template<class T>
inline NetCDFGlobalAtt &add_attribute(const std::string &global_att_name, const T &value)

add a global attribute in all available value type versions

const NetCDFGlobalAtt &get_attribute(const std::string &global_att_name) const

get a global attribute from the global_att_vector by its name

const std::vector<std::shared_ptr<NetCDFGlobalAtt>> get_global_attribute_vector() const

get a const std::vector<std::shared_ptr<NetCDFGlobalAtt>> of all NetCDFGlobalAtts belonging to the NetCDFGlobalAttributes object, i.e. a const view on the global_att_vector.

std::vector<std::shared_ptr<NetCDFGlobalAtt>> set_global_attribute_vector()

get a std::vector<std::shared_ptr<NetCDFGlobalAtt>> of all NetCDFGlobalAtts belonging to the NetCDFGlobalAttributes object, i.e. a non const view on the global_att_vector.

std::shared_ptr<NetCDFGlobalAtt> set_global_attribute(const std::string &global_att_name)

get a std::shared_ptr<NetCDFGlobalAtt> of the NetCDFGlobalAtt with name ‘global_att_name’ from the global_att_vector.

std::vector<std::string> get_global_attribute_names() const

get a std::vector<std::string> of all global attribute names

void register_attribute(const std::string &g_att_name, const nc_type &g_att_data_type, const IOSize_t &g_att_nelems)

register a global attribute by its name (g_att_name), data type (g_att_data_type) and number of elements (g_att_nelems), afterwards you can read in a value of type ‘void *’ from a NetCDF file by e.g. ncmu_get_att()

std::string todays_date() const

std::string todays date

std::string time_now() const

std::string time now

void add_date_and_time(std::string name_prefix = "creation")

add the actual date and time to the global_att_vector as creation_date and creation_time

void add_muGrid_version_info()

add muGrid version information

Protected Functions

void check_global_attribute_name(const std::string global_att_name)

check if the global_att_name is valid/already in use no Error &#8212; if global_att_name is valid and was not used before Error &#8212; if global_att_name is in use and can not be used twice

Protected Attributes

std::vector<std::shared_ptr<NetCDFGlobalAtt>> global_att_vector = {}

class NetCDFVarBase

#include <file_io_netcdf.hh>

Base class to store the properties of a single NetCDF variable (name, data_type, ndims, id, netcdf_dims, field, netcdf_atts, initialised, validity_domain, local_field_name, hidden)

Subclassed by muGrid::NetCDFVarField, muGrid::NetCDFVarStateField

Public Functions

NetCDFVarBase() = delete

Default constructor.

NetCDFVarBase(const std::string &var_name, const nc_type &var_data_type, const IOSize_t &var_ndims, const std::vector<std::shared_ptr<NetCDFDim>> &netcdf_var_dims, const muGrid::FieldCollection::ValidityDomain &validity_domain, bool hidden = false)

Constructor with the variable name, data type, variable dimensions and a vector of shared pointers to its associated NetCDFDims.

NetCDFVarBase(const NetCDFVarBase &other) = default

Copy constructor.

NetCDFVarBase(NetCDFVarBase &&other) = delete

Move constructor.

virtual ~NetCDFVarBase() = default

Destructor.

NetCDFVarBase &operator=(const NetCDFVarBase &other) = delete

Copy assignment operator.

NetCDFVarBase &operator=(NetCDFVarBase &&other) = delete

Move assignment operator.

const std::string &get_name() const

get the name of the NetCDF variable

const nc_type &get_data_type() const

get the data type of the NetCDF variable

const IOSize_t &get_ndims() const

get the number of dimensions of the NetCDF variable

const int &get_id() const

get the unique id of the NetCDF variable

int &set_id()

get a non const reference to the unique id of the NetCDF variable to set its value

std::vector<int> get_netcdf_dim_ids() const

get a vector of all dimension ids of the NetCDF variable

std::vector<std::string> get_netcdf_dim_names() const

get a vector of all dimension names of the NetCDF variable

virtual const muGrid::Field &get_field() const = 0

get a reference to the field represented by the NetCDF variable

const std::vector<NetCDFAtt> &get_netcdf_attributes() const

get a const std::vector<NetCDFAtt> & of all attributes belonging to the NetCDFVarBase

std::vector<NetCDFAtt> &set_netcdf_attributes()

get a non const std::vector<NetCDFAtt> & of all attributes belonging to the NetCDFVarBase to set the actual values of the attributes

std::vector<std::string> get_netcdf_attribute_names() const

get a std::vector<std::string> with the names of all attributes

const muGrid::FieldCollection::ValidityDomain &get_validity_domain() const

get the FieldCollection::ValidityDomain & of the NetCDFVarBase

IOSize_t get_nb_local_pixels() const

get the number of pixels of the local field collection living on the current processor

void *get_buf() const

get a pointer to the raw data for the NetCDF variable

IOSize_t get_bufcount_mpi_global() const

An integer indicates the number of MPI derived data type elements in the global variable buffer to be written to a file.

IOSize_t get_bufcount_mpi_local() const

An integer indicates the number of MPI derived data type elements in the local variable buffer to be written to a file. (this is the buf count for a single pixel)

Datatype_t get_buftype() const

A data type that describes the memory layout of the variable buffer.

virtual std::vector<IOSize_t> get_start_global(const Index_t &frame) const = 0

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for contiguous global fields written with ncmu_put_varm_all

virtual std::vector<IOSize_t> get_start_local(const Index_t &frame, muGrid::Field &local_pixels) const = 0

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for distributed local fields written with ncmu_put_varn_all

std::vector<IOSize_t> get_count_global() const

A vector of IOSize_t values specifying the edge lengths along each dimension of the block of data values to be written. This function gives the count for contiguous global fields written with ncmu_put_varm_all

std::vector<IOSize_t> get_count_local(muGrid::Field &local_pixels) const

A vector of IOSize_t values specifying the edge lengths along each dimension of the block of data values to be written. This function gives the count for distributed local fields written with ncmu_put_varn_all

virtual std::vector<IODiff_t> get_nc_stride() const = 0

virtual std::vector<IODiff_t> get_nc_imap_global() const = 0

virtual std::vector<IODiff_t> get_nc_imap_local() const = 0

void register_id(const int var_id)

register variable id, only possible if the id was not already registered (id=-1).

void register_local_field_name(const std::string &local_field_name)

register local_field_name, only possible if the variable belongs to a local field collection

const std::string &get_local_field_name() const

get the local_field_name, only possible if the variable belongs to a local field collection

bool get_hidden_status() const

return the status of the variable whether it is a hidden=true netCDFVar which is only used for book keeping of local fields or a normal NetCDFVarBase hidden=false

template<typename T>
inline void add_attribute(const std::string &att_name, const T &value)

add an attribute to the variable by its name and value the following types are supported:

void register_attribute(const std::string &att_name, const nc_type &att_data_type, const IOSize_t &att_nelems)

register an attribute by its name (att_name), data type (att_data_type) and number of elements (att_nelems), afterwards you can read in a value of type ‘void *’ from a NetCDF file by e.g. ncmu_get_att()

void add_attribute_unit()

add the unit of the field as attribute to the variable

void add_attribute_local_pixels_field()

add the name of the associated local pixels field as attribute to the variable

void *increment_buf_ptr(void *buf_ptr, const IOSize_t &increment_nb_elements) const

increments the input buf pointer “buf_ptr” by n elements “increment_nb_elements” and returns the incremented void pointer to the new buffer position. This function is made to increment the pointer of the variables field. Therefore the variables data_type is assumed to be the data type of the input void * buf_ptr. If your input does not have the same type the increment will give you wrong results

void consistency_check_global_var() const

cross check the properties (start, count, stride and imap, which are crucial for reading and writing) of the initialised NetCDFVarBase for consistency.

void consistency_check_local_var(muGrid::Field &local_pixels) const

virtual void write(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to write a single NetCDFVar into the NetCDF file

virtual void read(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to read in the data of a single NetCDFVar from a NetCDF file

Public Static Functions

static nc_type typeid_to_nc_type(const std::type_info &type_id)

Convert a “std::type_info” into a NetCDF “nc_type” type.

Protected Attributes

std::string name

nc_type data_type = {NC_NAT}

IOSize_t ndims = {}

int id = {DEFAULT_NETCDFVAR_ID}

std::vector<std::shared_ptr<NetCDFDim>> netcdf_dims{nullptr}

std::vector<NetCDFAtt> netcdf_atts = {}

bool initialised{false}

bool to check the initialisation status of a variable only true if ndims was correct initialised.

const muGrid::FieldCollection::ValidityDomain validity_domain = {}

std::string local_field_name = {}

bool hidden = {false}

class NetCDFVarField : public muGrid::NetCDFVarBase

#include <file_io_netcdf.hh>

Class to store the properties of a single NetCDF variable representing a Field

Public Functions

NetCDFVarField() = delete

Default constructor.

NetCDFVarField(const std::string &var_name, const nc_type &var_data_type, const IOSize_t &var_ndims, const std::vector<std::shared_ptr<NetCDFDim>> &netcdf_var_dims, muGrid::Field &var_field, bool hidden = false)

Constructor with the variable name, data type, variable dimensions and a vector of shared pointers to its associated NetCDFDims.

NetCDFVarField(const NetCDFVarField &other) = default

Copy constructor.

NetCDFVarField(NetCDFVarField &&other) = delete

Move constructor.

virtual ~NetCDFVarField() = default

Destructor.

NetCDFVarField &operator=(const NetCDFVarField &other) = delete

Copy assignment operator.

NetCDFVarField &operator=(NetCDFVarField &&other) = delete

Move assignment operator.

virtual const muGrid::Field &get_field() const

get a reference to the field represented by the NetCDF variable

virtual std::vector<IOSize_t> get_start_global(const Index_t &frame) const

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for contiguous global fields written with ncmu_put_varm_all

virtual std::vector<IOSize_t> get_start_local(const Index_t &frame, muGrid::Field &local_pixels) const

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for distributed local fields written with ncmu_put_varn_all

virtual std::vector<IODiff_t> get_nc_stride() const

virtual std::vector<IODiff_t> get_nc_imap_global() const

virtual std::vector<IODiff_t> get_nc_imap_local() const

virtual void write(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to write a single NetCDFVar into the NetCDF file

virtual void read(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to read in the data of a single NetCDFVar from a NetCDF file

Protected Attributes

muGrid::Field &field

class NetCDFVariables

#include <file_io_netcdf.hh>

Class to store the NetCDF variables

Public Functions

NetCDFVariables() = default

NetCDFVariables(const NetCDFVariables &other) = delete

Copy constructor.

NetCDFVariables(NetCDFVariables &&other) = delete

Move constructor.

virtual ~NetCDFVariables() = default

Destructor.

NetCDFVariables &operator=(const NetCDFVariables &other) = delete

Copy assignment operator.

NetCDFVariables &operator=(NetCDFVariables &&other) = delete

Move assignment operator.

NetCDFVariables &operator+=(std::shared_ptr<NetCDFVarBase> &rhs)

Add operator for a single NetCDFVarBase.

NetCDFVarBase &add_field_var(muGrid::Field &var_field, const std::vector<std::shared_ptr<NetCDFDim>> &var_dims, bool hidden = false)

Add a local or global field as variable and attach the dimensions to it.

NetCDFVarBase &add_state_field_var(muGrid::StateField &var_state_field, const std::vector<std::shared_ptr<NetCDFDim>> &var_dims)

Add a local or global state field as variable and attach the dimensions to it.

const std::vector<std::shared_ptr<NetCDFVarBase>> &get_var_vector() const

return a const reference on the var_vector which stores all variables

std::vector<std::shared_ptr<NetCDFVarBase>> &set_var_vector()

return a non const reference on the var_vector which stores all variables to modify the NetCDFVarBase objects

std::vector<std::string> get_names() const

vector of all variable names (i.e. all field names stored in variables) with exception of the book keeping variables for the local fields which can be given by get_hidden_names()

std::vector<std::string> get_hidden_names() const

vector of all book keeping variables for the registered local fields

const NetCDFVarBase &get_variable(const std::string &var_name) const

get a NetCDFVarBase variable from the var_vector by its unique name

NetCDFVarBase &get_variable(const std::string &var_name)

get a NetCDFVarBase variable from the var_vector by its unique name

Protected Attributes

std::vector<std::shared_ptr<NetCDFVarBase>> var_vector = {}

class NetCDFVarStateField : public muGrid::NetCDFVarBase

#include <file_io_netcdf.hh>

Class to store the properties of a single NetCDF variable representing a StateField. The class behaves like it represents a single Field of the StateField. The state_filed_index decides which Field is represented. The Fields are always ordered such that state_field_index=0 represents the current Field of the StateField and state_field_index=nb_memory represents the oldest Field of the StateField.

Public Functions

NetCDFVarStateField() = delete

Default constructor.

NetCDFVarStateField(const std::string &var_name, const nc_type &var_data_type, const IOSize_t &var_ndims, const std::vector<std::shared_ptr<NetCDFDim>> &netcdf_var_dims, muGrid::StateField &var_state_field)

Constructor with the variable name, data type, variable dimensions and a vector of shared pointers to its associated NetCDFDims.

NetCDFVarStateField(const NetCDFVarStateField &other) = default

Copy constructor.

NetCDFVarStateField(NetCDFVarStateField &&other) = delete

Move constructor.

virtual ~NetCDFVarStateField() = default

Destructor.

NetCDFVarStateField &operator=(const NetCDFVarStateField &other) = delete

Copy assignment operator.

NetCDFVarStateField &operator=(NetCDFVarStateField &&other) = delete

Move assignment operator.

virtual const muGrid::Field &get_field() const

get a reference to the field represented by the NetCDF variable

size_t get_nb_fields() const

return the number of fields belonging to the state field (nb_memory + 1)

virtual std::vector<IOSize_t> get_start_global(const Index_t &frame) const

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for contiguous global fields written with ncmu_put_varm_all

virtual std::vector<IOSize_t> get_start_local(const Index_t &frame, muGrid::Field &local_pixels) const

A vector of IOSize_t values specifying the index in the variable where the first of the data values will be written. This function gives the start for distributed local fields written with ncmu_put_varn_all

virtual std::vector<IODiff_t> get_nc_stride() const

virtual std::vector<IODiff_t> get_nc_imap_global() const

virtual std::vector<IODiff_t> get_nc_imap_local() const

virtual void write(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to write a single NetCDFVar into the NetCDF file

virtual void read(const int netcdf_id, const Index_t &tot_nb_frames, GlobalFieldCollection &GFC_local_pixels, const Index_t &frame_index)

actual call of NetCDF functions to read in the data of a single NetCDFVar from a NetCDF file

Protected Attributes

muGrid::StateField &state_field

size_t state_field_index{DEFAULT_STATE_FIELD_INDEX}

Private Static Attributes

static constexpr size_t DEFAULT_STATE_FIELD_INDEX{0}

class NumpyError : public muGrid::ExceptionWithTraceback<T>

#include <numpy_tools.hh>

base class for numpy related exceptions

Public Functions

inline explicit NumpyError(const std::string &what)

constructor

inline explicit NumpyError(const char *what)

constructor

template<typename T, int flags = py::array::forcecast, class Collection_t = GlobalFieldCollection>
class NumpyProxy

#include <numpy_tools.hh>

Construct a NumpyProxy given that we only know the number of components of the field. The constructor will complain if the grid dimension differs but will wrap any field whose number of components match. For example, a 3x3 grid with 8 components could look like this:

1. (8, 3, 3)

2. (2, 4, 3, 3)

3. (2, 2, 2, 3, 3) The method get_components_shape returns the shape of the component part of the field in this case. For the above examples, it would return:

1. (8,)

2. (2, 4)

3. (2, 2, 2) Note that a field with a single component can be passed either with a shape having leading dimension of one or without any leading dimension. In the latter case, get_component_shape will return a vector of size 0. The same applies for fields with a single quadrature point, whose dimension can be omitted. In general, the shape of the field needs to look like this: (component_1, component_2, sub_pt, grid_x, grid_y, grid_z) where the number of components and grid indices can be arbitrary.

Public Functions

inline NumpyProxy(DynCcoord_t nb_domain_grid_pts, DynCcoord_t nb_subdomain_grid_pts, DynCcoord_t subdomain_locations, Index_t nb_dof_per_pixel, py::array_t<T, flags> &array, const Unit &unit = Unit::unitless())

Construct a NumpyProxy given that we only know the number of components of the field. The constructor will complain if the grid dimension differs but will wrap any field whose number of components match. For example, a 3x3 grid with 8 components could look like this:

1. (8, 3, 3)

2. (2, 4, 3, 3)

3. (2, 2, 2, 3, 3) The method get_components_shape returns the shape of the component part of the field in this case. For the above examples, it would return:

1. (8,)

2. (2, 4)

3. (2, 2, 2) Note that a field with a single component can be passed either with a shape having leading dimension of one or without any leading dimension. In the latter case, get_component_shape will return a vector of size 0. The same applies for fields with a single quadrature point, whose dimension can be omitted. In general, the shape of the field needs to look like this: (component_1, component_2, sub_pt, grid_x, grid_y, grid_z) where the number of components and grid indices can be arbitrary.

inline NumpyProxy(DynCcoord_t nb_domain_grid_pts, DynCcoord_t nb_subdomain_grid_pts, DynCcoord_t subdomain_locations, Index_t nb_sub_pts, Shape_t components_shape, py::array_t<T, flags> &array, const Unit &unit = Unit::unitless())

Construct a NumpyProxy given that we know the shape of the leading component indices. The constructor will complain if both the grid dimensions and the component dimensions differ. get_component_shape returns exactly the shape passed to this constructor.

In general, the shape of the field needs to look like this: (component_1, component_2, sub_pt, grid_x, grid_y, grid_z) where the number of components and grid indices can be arbitrary. The sub_pt dimension can be omitted if there is only a single sub-point.

NumpyProxy(NumpyProxy &&other) = default

move constructor

inline WrappedField<T> &get_field()

inline Collection_t &get_collection()

inline const Shape_t get_components_shape() const

inline Shape_t get_sub_pt_shape() const

inline IterUnit get_iter_type() const

Protected Attributes

std::unique_ptr<Collection_t> collection

std::unique_ptr<WrappedField<T>> field

IterUnit iter_type

template<class MappedField>
class OptionalMappedField

#include <optional_mapped_field.hh>

Param MappedField:

needs to be any of the template variants of muGrid::MappedField, typically one of its aliases, e.g., muGrid::MappedT2Field

Public Functions

OptionalMappedField() = delete

Default constructor.

inline OptionalMappedField(FieldCollection &collection, const std::string &unique_name, const std::string &sub_division_tag)

constructor

OptionalMappedField(const OptionalMappedField &other) = delete

Copy constructor.

OptionalMappedField(OptionalMappedField &&other) = delete

Move constructor.

virtual ~OptionalMappedField() = default

Destructor.

OptionalMappedField &operator=(const OptionalMappedField &other) = delete

Copy assignment operator.

OptionalMappedField &operator=(OptionalMappedField &&other) = delete

Move assignment operator.

inline bool has_value() const

returns whether the field has been created

inline MappedField &get()

returns a reference to the held mapped field. If the field has not yet been created, this call will cause it to be.

Protected Attributes

bool field_exists = {false}

FieldCollection &collection

std::string unique_name

std::string sub_division_tag

std::unique_ptr<MappedField> mapped_field = {nullptr}

class PhysicsDomain : private std::tuple<Uint, Unit, Unit>

Public Functions

PhysicsDomain() = delete

Deleted default constructor.

PhysicsDomain(const Uint &rank, const Unit &input, const Unit &output, const std::string &name = "")

constructor from rank, input- and output units, with validity check

PhysicsDomain(const PhysicsDomain &other)

Copy constructor.

PhysicsDomain(PhysicsDomain &&other) = default

Move constructor.

virtual ~PhysicsDomain() = default

Destructor.

PhysicsDomain &operator=(const PhysicsDomain &other) = default

Copy assignment operator.

PhysicsDomain &operator=(PhysicsDomain &&other) = default

Move assignment operator.

bool operator<(const PhysicsDomain &other) const

for usage as keys in maps

bool operator==(const PhysicsDomain &other) const

comparison operator

const Uint &rank() const

return tensorial rank of this physics domain

const Unit &input() const

return units of input variable

const Unit &output() const

return units of output variable

const std::string &get_name() const

Public Static Functions

static PhysicsDomain mechanics(const Int &tag = 0)

factory function for mechanics domain

static PhysicsDomain heat(const Int &tag = 0)

factory function for heat diffusion domain

Protected Attributes

std::string domain_name

Private Types

using Parent = std::tuple<Uint, Unit, Unit>

Friends

friend std::ostream &operator<<(std::ostream&, const PhysicsDomain&)

class PixelIndexIterable

#include <field_collection.hh>

Lightweight proxy class providing iteration over the pixel indices of a muGrid::FieldCollection

Public Types

using iterator = typename std::vector<Index_t>::const_iterator

stl

Public Functions

PixelIndexIterable() = delete

Default constructor.

PixelIndexIterable(const PixelIndexIterable &other) = delete

Copy constructor.

PixelIndexIterable(PixelIndexIterable &&other) = default

Move constructor.

virtual ~PixelIndexIterable() = default

Destructor.

PixelIndexIterable &operator=(const PixelIndexIterable &other) = delete

Copy assignment operator.

PixelIndexIterable &operator=(PixelIndexIterable &&other) = delete

Move assignment operator.

iterator begin() const

stl

iterator end() const

stl

size_t size() const

stl

Protected Functions

explicit PixelIndexIterable(const FieldCollection &collection)

Constructor is protected, because no one ever need to construct this except the field collection

Protected Attributes

friend FieldCollection

allow field collections to call the protected constructor of this iterable

const FieldCollection &collection

reference back to the proxied collection

template<size_t Dim>
class Pixels : public muGrid::CcoordOps::DynamicPixels

#include <ccoord_operations.hh>

forward declaration

Centralised iteration over square (or cubic) discretisation grids.

Public Types

using Parent = DynamicPixels

base class

using Ccoord = Ccoord_t<Dim>

cell coordinates

Public Functions

inline Pixels(const Ccoord &nb_subdomain_grid_pts = Ccoord{}, const Ccoord &subdomain_locations = Ccoord{})

constructor

inline Pixels(const Ccoord &nb_subdomain_grid_pts, const Ccoord &subdomain_locations, const Ccoord &strides)

constructor with strides

Pixels(const Pixels &other) = default

copy constructor

Pixels &operator=(const Pixels &other) = default

assignment operator

virtual ~Pixels() = default

inline Index_t get_index(const Ccoord &ccoord) const

return index for a ccoord

inline Ccoord get_ccoord(const Index_t &index) const

return coordinates of the i-th pixel

inline iterator begin() const

stl conformance

inline iterator end() const

stl conformance

inline size_t size() const

stl conformance

Protected Functions

inline const Ccoord &get_nb_grid_pts() const

inline const Ccoord &get_subdomain_locations() const

inline const Ccoord &get_strides() const

template<Dim_t Dim, Dim_t I, Dim_t J = Dim - 1>
struct Proj

#include <eigen_tools.hh>

This is a static implementation of the explicit determination of log(Tensor) following Jog, C.S. J Elasticity (2008) 93:

1. https://doi.org/10.1007/s10659-008-9169-x

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

template<>
struct Proj<1, 0, 0>

#include <eigen_tools.hh>

catch the general tail case

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec>&, const Eigen::MatrixBase<DerivedMat>&)

wrapped function (raison d’être)

Public Static Attributes

static constexpr Dim_t Dim = {1}

short-hand

static constexpr Dim_t I = {0}

short-hand

static constexpr Dim_t J = {0}

short-hand

template<Dim_t Dim>
struct Proj<Dim, 0, 1>

#include <eigen_tools.hh>

catch the tail case when the last dimension is i

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

Public Static Attributes

static constexpr Dim_t I = {0}

short-hand

static constexpr Dim_t J = {1}

short-hand

template<Dim_t Dim, Dim_t I>
struct Proj<Dim, I, 0>

#include <eigen_tools.hh>

catch the normal tail case

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

Public Static Attributes

static constexpr Dim_t j = {0}

short-hand

template<Dim_t Dim, Dim_t Other>
struct Proj<Dim, Other, Other>

#include <eigen_tools.hh>

catch the case when there’s nothing to do

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

template<typename T, size_t N>
class RefArray

#include <ref_array.hh>

work-around to allow making a statically sized array of references (which are forbidden by the C++ language

Public Functions

RefArray() = delete

Deleted default constructor.

template<typename ...Vals>
inline explicit RefArray(Vals&... vals)

bulk initialisation constructor

RefArray(const RefArray &other) = default

Copy constructor.

RefArray(RefArray &&other) = default

Move constructor.

virtual ~RefArray() = default

Destructor.

RefArray &operator=(const RefArray &other) = default

Copy assignment operator.

RefArray &operator=(RefArray &&other) = delete

Move assignment operator.

inline T &operator[](size_t index)

random access operator

inline constexpr T &operator[](size_t index) const

random constant access operator

Protected Attributes

std::array<T*, N> values = {}

storage

template<typename T>
class RefVector : protected std::vector<T*>

#include <ref_vector.hh>

work-around to allow using vectors of references (which are forbidden by the C++ stl

Public Functions

RefVector() = default

Default constructor.

RefVector(const RefVector &other) = default

Copy constructor.

RefVector(RefVector &&other) = default

Move constructor.

virtual ~RefVector() = default

Destructor.

RefVector &operator=(const RefVector &other) = default

Copy assignment operator.

RefVector &operator=(RefVector &&other) = default

Move assignment operator.

inline void push_back(T &value)

stl

inline T &at(size_t index)

stl

inline const T &at(size_t index) const

stl

inline T &operator[](size_t index)

random access operator

inline const T &operator[](size_t index) const

random const access operator

inline iterator begin()

stl

inline iterator end()

stl

Private Types

using Parent = std::vector<T*>

class RuntimeValue

#include <options_dictionary.hh>

this class holds the dictionary tree structure and protects acccess to the union type holding the actual data

Public Types

enum class ValueType

Currently, the only types we can hold in an options dictionary are integers, real numbers, matrices of real numbers and nested dictionaries to which these restrictions also apply

Values:

enumerator Dictionary

enumerator Int

enumerator Real

enumerator Matrix

using Map_t = std::map<std::string, std::shared_ptr<RuntimeValue>>

Public Functions

explicit RuntimeValue(const Int &value)

constructors from values

explicit RuntimeValue(const Real &value)

explicit RuntimeValue(const Eigen::Ref<const Eigen::MatrixXd> &value)

explicit RuntimeValue(const RuntimeValue &value)

explicit RuntimeValue(const Map_t &value)

RuntimeValue &operator=(const Int &value)

assignment operators

RuntimeValue &operator=(const Real &value)

RuntimeValue &operator=(const Eigen::Ref<const Eigen::MatrixXd> &value)

RuntimeValue &operator=(const Map_t &value)

RuntimeValue &operator=(const RuntimeValue &other)

template<typename T>
void add(const std::string &key, T value)

add a new dictionary entry. throws a ValueError if this RuntimeValue isn’t of ^ValueTypeDictionary`

void add(const std::string &key, std::shared_ptr<RuntimeValue> other)

const Int &get_int() const

safely recover a typed value, throws ValueError if types mismatch

const Real &get_real() const

const Eigen::MatrixXd &get_matrix() const

std::shared_ptr<RuntimeValue> &get_value(const std::string &key)

~RuntimeValue()

void potentially_destroy_non_trivial_member()

const ValueType &get_value_type() const

Protected Attributes

ValueType value_type

Variant variant

template<typename T>
struct ScalarMap

#include <field_map_static.hh>

Internal struct for handling the scalar iterates of muGrid::FieldMap

Public Types

using PlainType = T

Scalar maps don’t have an eigen type representing the iterate, just the raw stored type itsef

template<Mapping MutIter>
using value_type = std::conditional_t<MutIter == Mapping::Const, const T, T>

return type for iterates

template<Mapping MutIter>
using ref_type = value_type<MutIter>&

reference type for iterates

template<Mapping MutIter>
using Return_t = value_type<MutIter>&

for direct access through operator[]

template<Mapping MutIter>
using storage_type = std::conditional_t<MutIter == Mapping::Const, const T*, T*>

need to encapsulate

Public Static Functions

static inline constexpr bool IsValidStaticMapType()

check at compile time whether this map is suitable for statically sized iterates

static inline constexpr bool IsScalarMapType()

check at compiler time whether this map is scalar

template<Mapping MutIter>
static inline constexpr value_type<MutIter> &provide_ref(storage_type<MutIter> storage)

return the return_type version of the iterate from storage_type

template<Mapping MutIter>
static inline constexpr const value_type<MutIter> &provide_const_ref(const storage_type<MutIter> storage)

return the const return_type version of the iterate from storage_type

template<Mapping MutIter>
static inline constexpr storage_type<MutIter> provide_ptr(storage_type<MutIter> storage)

return a pointer to the iterate from storage_type

template<Mapping MutIter>
static inline constexpr Return_t<MutIter> from_data_ptr(std::conditional_t<MutIter == Mapping::Const, const T*, T*> data)

return a return_type version of the iterate from its pointer

template<Mapping MutIter>
static inline constexpr storage_type<MutIter> to_storage(ref_type<MutIter> ref)

return a storage_type version of the iterate from its value

static inline constexpr Index_t stride()

return the nb of components of the iterate (known at compile time)

static inline std::string shape()

return the iterate’s shape as text, mostly for error messages

static inline constexpr Index_t NbRow()

template<Dim_t order, Dim_t dim>
struct SizesByOrder

#include <eigen_tools.hh>

Creates a Eigen::Sizes type for a Tensor defined by an order and dim.

Public Types

using Sizes = typename internal::SizesByOrderHelper<order - 1, dim, dim>::Sizes

Eigen::Sizes

template<Dim_t order, Dim_t dim, Dim_t... dims>
struct SizesByOrderHelper

#include <eigen_tools.hh>

Creates a Eigen::Sizes type for a Tensor defined by an order and dim.

Public Types

using Sizes = typename SizesByOrderHelper<order - 1, dim, dim, dims...>::Sizes

type to use

template<Dim_t dim, Dim_t... dims>
struct SizesByOrderHelper<0, dim, dims...>

#include <eigen_tools.hh>

Creates a Eigen::Sizes type for a Tensor defined by an order and dim.

Public Types

using Sizes = Eigen::Sizes<dims...>

type to use

class StateField

#include <state_field.hh>

Base class for state fields, useful for storing polymorphic references

Subclassed by muGrid::TypedStateField< Scalar >, muGrid::TypedStateField< T >

Public Functions

StateField() = delete

Default constructor.

StateField(const StateField &other) = delete

Copy constructor.

StateField(StateField &&other) = delete

Move constructor.

virtual ~StateField() = default

Destructor.

StateField &operator=(const StateField &other) = delete

Copy assignment operator.

StateField &operator=(StateField &&other) = delete

Move assignment operator.

const Index_t &get_nb_memory() const

return number of old states that are stored

const Index_t &get_nb_components() const

return the number of components stored per sub-point point

const std::string &get_sub_division_tag() const

returns a const ref to the field’s pixel sub-division type

const Unit &get_physical_unit() const

returns the physical unit of the values stored in the field

virtual const std::type_info &get_typeid() const = 0

return type_id of stored type

virtual const std::size_t get_element_size_in_bytes() const = 0

return the size of the elementary field entry in bytes

void assert_typeid(const std::type_info &type) const

assert that the stored type corresponds to the given type id

void cycle()

cycle the fields (current becomes old, old becomes older, oldest becomes current)

Field &current()

return a reference to the field holding the current values

const Field &current() const

return a const reference to the field holding the current values

const Field &old(const size_t &nb_steps_ago = 1) const

return a reference to the field holding the values which were current nb_steps_ago ago

inline const std::vector<size_t> &get_indices() const

get the current ordering of the fields (inlineable because called in hot loop)

FieldCollection &get_collection()

get the field collection which holds all fields of the state field

const std::string &get_unique_prefix() const

get the unique prefix used for the naming of the associated fields and can be used like a name for the StateField

const RefVector<Field> &get_fields() const

return a const RefVector<Field> of fields belonging to the StateField

RefVector<Field> &set_fields()

return a mutable RefVector<Field> of fields belonging to the StateField

Protected Functions

StateField(const std::string &unique_prefix, FieldCollection &collection, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division, const Unit &unit)

Protected constructor

Protected Attributes

std::string prefix

the unique prefix is used as the first part of the unique name of the subfields belonging to this state field

FieldCollection &collection

reference to the collection this statefield belongs to

const Index_t nb_memory

number of old states to store, defaults to 1

const Index_t nb_components

number of dof_per_sub_pt stored per sub-point (e.g., 3 for a three-dimensional vector, or 9 for a three-dimensional second-rank tensor)

std::string sub_division_tag

Pixel subdivision kind (determines how many datapoints to store per pixel)

Unit unit

Physical unit of the values stored in this field.

Index_t nb_sub_pts

number of pixel subdivisions. Will depend on sub_division

std::vector<size_t> indices = {}

the current (historically accurate) ordering of the fields

RefVector<Field> fields = {}

storage of references to the diverse fields

template<typename T, Mapping Mutability>
class StateFieldMap

#include <state_field_map.hh>

forward-declaration for friending

Dynamically sized map for iterating over muGrid::StateFields

Subclassed by muGrid::StaticStateFieldMap< T, Mutability, MapType, NbMemory, IterationType >

Public Types

using FieldMap_t = FieldMap<T, Mutability>

type for the current-values map (may be mutable, if the underlying field was)

using CFieldMap_t = FieldMap<T, Mapping::Const>

type for the old-values map, non-mutable

using iterator = Iterator<(Mutability == Mapping::Mut) ? Mapping::Mut : Mapping::Const>

stl

using const_iterator = Iterator<Mapping::Const>

stl

Public Functions

StateFieldMap() = delete

Default constructor.

StateFieldMap(TypedStateField<T> &state_field, IterUnit iter_type = IterUnit::SubPt)

constructor from a state field. The default case is a map iterating over quadrature points with a matrix of shape (nb_components × 1) per field entry

StateFieldMap(TypedStateField<T> &state_field, Index_t nb_rows, IterUnit iter_type = IterUnit::SubPt)

Constructor from a state field with explicitly chosen shape of iterate. (the number of columns is inferred).

StateFieldMap(const StateFieldMap &other) = delete

StateFieldMap(StateFieldMap &&other) = delete

Move constructor.

virtual ~StateFieldMap() = default

Destructor.

StateFieldMap &operator=(const StateFieldMap &other) = delete

Copy assignment operator.

StateFieldMap &operator=(StateFieldMap &&other) = delete

Move assignment operator.

iterator begin()

stl

iterator end()

stl

const TypedStateField<T> &get_state_field() const

return a const reference to the mapped state field

const Index_t &get_nb_rows() const

return the number of rows the iterates have

size_t size() const

returns the number of iterates produced by this map (corresponds to the number of field entries if Iteration::Quadpt, or the number of pixels/voxels if Iteration::Pixel);

inline StateWrapper<Mutability> operator[](size_t index)

random access operator

inline StateWrapper<Mapping::Const> operator[](size_t index) const

random constaccess operator

FieldMap_t &get_current()

returns a reference to the map over the current data

const FieldMap_t &get_current() const

returns a const reference to the map over the current data

const CFieldMap_t &get_old(size_t nb_steps_ago) const

returns a const reference to the map over the data which was current nb_steps_ago ago

Protected Functions

RefVector<Field> &get_fields()

protected access to the constituent fields

std::vector<FieldMap_t> make_maps(RefVector<Field> &fields)

helper function creating the list of maps to store for current values

std::vector<CFieldMap_t> make_cmaps(RefVector<Field> &fields)

helper function creating the list of maps to store for old values

Protected Attributes

TypedStateField<T> &state_field

mapped state field. Needed for query at initialisations

const IterUnit iteration

type of map iteration

const Index_t nb_rows

number of rows of the iterate

std::vector<FieldMap_t> maps

maps over nb_memory + 1 possibly mutable maps. current points to one of these

std::vector<CFieldMap_t> cmaps

maps over nb_memory + 1 const maps. old(nb_steps_ago) points to one of these

template<Mapping MutWrapper>
class StateWrapper

#include <state_field_map.hh>

The iterate needs to give access to current or previous values. This is handled by the muGrid::StateFieldMap::StateWrapper, a light-weight wrapper around the iterate’s data.

Public Types

using StateFieldMap_t = std::conditional_t<MutWrapper == Mapping::Const, const StateFieldMap, StateFieldMap>

convenience alias

using CurrentVal_t = typename FieldMap_t::template Return_t<MutWrapper>

return value when getting current value from iterate

using OldVal_t = typename FieldMap_t::template Return_t<Mapping::Const>

return value when getting old value from iterate

Public Functions

inline StateWrapper(StateFieldMap_t &state_field_map, size_t index)

constructor (should never have to be called by user)

~StateWrapper() = default

inline CurrentVal_t &current()

return the current value at this iterate

inline const OldVal_t &old(size_t nb_steps_ago) const

return the value at this iterate which was current nb_steps_ago ago

Protected Attributes

CurrentVal_t current_val

current value at this iterate

std::vector<OldVal_t> old_vals = {}

all old values at this iterate

template<typename T, Mapping Mutability, class MapType, IterUnit IterationType = IterUnit::SubPt>
class StaticFieldMap : public muGrid::FieldMap<T, Mutability>

#include <field_map_static.hh>

Statically sized field map. Static field maps reproduce the capabilities of the (dynamically sized) muGrid::FieldMap, but iterate much more efficiently.

Public Types

using Scalar = T

stored scalar type

using Parent = FieldMap<T, Mutability>

base class

using Field_t = typename Parent::Field_t

convenience alias

template<Mapping MutType>
using Return_t = typename MapType::template Return_t<MutType>

return type when dereferencing iterators over this map

using reference = Return_t<Mutability>

stl

using PlainType = typename MapType::PlainType

Eigen type representing iterates of this map.

using Enumeration_t = akantu::containers::ZipContainer<std::conditional_t<(IterationType == IterUnit::SubPt), FieldCollection::IndexIterable, FieldCollection::PixelIndexIterable>, StaticFieldMap&>

iterable proxy type to iterate over the quad point/pixel indices and stored values simultaneously

using iterator = Iterator<(Mutability == Mapping::Mut) ? Mapping::Mut : Mapping::Const>

stl

using const_iterator = Iterator<Mapping::Const>

stl

Public Functions

StaticFieldMap() = delete

Default constructor.

inline explicit StaticFieldMap(Field &field)

Constructor from a non-typed field ref (has more runtime cost than the next constructor

inline explicit StaticFieldMap(Field_t &field)

Constructor from typed field ref.

StaticFieldMap(const StaticFieldMap &other) = delete

Copy constructor.

StaticFieldMap(StaticFieldMap &&other) = default

Move constructor.

virtual ~StaticFieldMap() = default

Destructor.

StaticFieldMap &operator=(const StaticFieldMap &other) = delete

Copy assignment operator.

StaticFieldMap &operator=(StaticFieldMap &&other) = delete

Move assignment operator.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, StaticFieldMap> &operator=(const typename Parent::EigenRef &val)

Assign a matrix-like value with dynamic size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, StaticFieldMap> &operator+=(const typename Parent::EigenRef &val)

Addition-assign a matrix-like value with dynamic size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField, StaticFieldMap> &operator-=(const typename Parent::EigenRef &val)

Subtraction-assign a matrix-like value with dynamic size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && !MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator=(const reference &val)

Assign a matrix-like value with static size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && !MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator+=(const reference &val)

Addition-assign a matrix-like value with static size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && !MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator-=(const reference &val)

Subtraction-assign a matrix-like value with static size to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator=(const Scalar &val)

Assign a scalar value to every entry.

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator+=(const Scalar &val)

add a scalar value to every entry

template<bool IsMutableField = Mutability == Mapping::Mut>
inline std::enable_if_t<IsMutableField && MapType::IsScalarMapType(), StaticFieldMap<T, Mutability, MapType, IterationType>> &operator-=(const Scalar &val)

Subtract a scalar value from every entry.

inline Return_t<Mutability> operator[](size_t index)

random access operator

inline Return_t<Mapping::Const> operator[](size_t index) const

random const access operator

inline PlainType mean() const

evaluate the average of the field

inline iterator begin()

stl

inline iterator end()

stl

inline const_iterator begin() const

stl

inline const_iterator end() const

stl

template<bool IsPixelIterable = (IterationType == IterUnit::Pixel)>
inline std::enable_if_t<IsPixelIterable, Enumeration_t> enumerate_indices()

iterate over pixel/quad point indices and stored values simultaneously

template<IterUnit Iter = IterUnit::SubPt, class Dummy = std::enable_if_t<IterationType == Iter, bool>>
inline Enumeration_t enumerate_indices()

iterate over pixel/quad point indices and stored values simultaneously

Public Static Functions

static inline constexpr IterUnit GetIterationType()

determine at compile time whether pixels or quadrature points are iterater over

static inline constexpr size_t Stride()

determine the number of components in the iterate at compile time

static inline constexpr bool IsStatic()

determine whether this map has statically sized iterates at compile time

template<typename T, Mapping Mutability, class MapType, size_t NbMemory, IterUnit IterationType = IterUnit::SubPt>
class StaticStateFieldMap : public muGrid::StateFieldMap<T, Mutability>

#include <state_field_map_static.hh>

statically sized version of muGrid::TypedStateField. Duplicates its capabilities, with much more efficient statically sized iterates.

Public Types

using Scalar = T

stored scalar type

using Parent = StateFieldMap<T, Mutability>

base class

using StaticFieldMap_t = StaticFieldMap<T, Mutability, MapType, IterationType>

convenience alias for current map

using CStaticFieldMap_t = StaticFieldMap<T, Mapping::Const, MapType, IterationType>

convenience alias for old map

using MapArray_t = std::array<StaticFieldMap_t, NbMemory + 1>

storage type for current maps

using CMapArray_t = std::array<CStaticFieldMap_t, NbMemory + 1>

storage type for old maps

using iterator = Iterator<(Mutability == Mapping::Mut) ? Mapping::Mut : Mapping::Const>

stl

using const_iterator = Iterator<Mapping::Const>

stl

Public Functions

StaticStateFieldMap() = delete

Deleted default constructor.

inline explicit StaticStateFieldMap(TypedStateField<T> &state_field)

constructor from a state field. The default case is a map iterating over quadrature points with a matrix of shape (nb_components × 1) per field entry

StaticStateFieldMap(const StaticStateFieldMap &other) = delete

Deleted copy constructor.

StaticStateFieldMap(StaticStateFieldMap &&other) = default

Move constructor.

virtual ~StaticStateFieldMap() = default

Destructor.

StaticStateFieldMap &operator=(const StaticStateFieldMap &other) = delete

Copy assignment operator.

StaticStateFieldMap &operator=(StaticStateFieldMap &&other) = default

Move assignment operator.

inline iterator begin()

stl

inline iterator end()

stl

inline const CStaticFieldMap_t &get_old_static(size_t nb_steps_ago) const

return a const ref to an old value map

inline StaticFieldMap_t &get_current_static()

return a ref to an the current map

inline StaticFieldMap_t &get_current()

inline StaticFieldMap_t &get_current_static() const

return a const ref to an the current map

inline StaticFieldMap_t &get_current() const

inline StaticStateWrapper<Mutability> operator[](size_t index)

random access operator

inline StaticStateWrapper<Mapping::Const> operator[](size_t index) const

random const access operator

Public Static Functions

static inline constexpr size_t GetNbMemory()

determine at compile time the number of old values stored

static inline constexpr Mapping FieldMutability()

determine the map’s mutability at compile time

static inline constexpr IterUnit GetIterationType()

determine the map’s iteration type (pixels vs quad pts) at compile time

Protected Types

template<Mapping MutIter>
using HelperRet_t = std::conditional_t<MutIter == Mapping::Const, CMapArray_t, MapArray_t>

internal convenience alias

Protected Functions

template<Mapping MutIter, size_t... I>
inline auto map_helper(std::index_sequence<I...>) -> HelperRet_t<MutIter>

helper for building the maps

inline MapArray_t make_maps()

build the current value maps

inline CMapArray_t make_cmaps()

build the old value maps

Protected Attributes

MapArray_t static_maps

container for current maps

CMapArray_t static_cmaps

container for old maps

template<Mapping MutWrapper>
class StaticStateWrapper

#include <state_field_map_static.hh>

The iterate needs to give access to current or previous values. This is handled by the muGrid::StaticStateFieldMap::StateWrapper, a light-weight wrapper around the iterate’s data.

Template Parameters:

MutWrapper – mutability of the mapped field. It should never be necessary to set this manually, rather the iterators dereference operator*() should return the correct type.

Public Types

using StaticStateFieldMap_t = std::conditional_t<MutWrapper == Mapping::Const, const StaticStateFieldMap, StaticStateFieldMap>

const-correct map

using CurrentVal_t = typename MapType::template ref_type<MutWrapper>

return type handle for current value

using CurrentStorage_t = typename MapType::template storage_type<MutWrapper>

storage type for current value handle

using OldVal_t = typename MapType::template ref_type<Mapping::Const>

return type handle for old value

using OldStorage_t = typename MapType::template storage_type<Mapping::Const>

storage type for old value handle

Public Functions

inline StaticStateWrapper(StaticStateFieldMap_t &state_field_map, size_t index)

constructor with map and index, not for user to call

~StaticStateWrapper() = default

inline CurrentVal_t &current()

return the current value of the iterate

inline const OldVal_t &old(size_t nb_steps_ago) const

return the value of the iterate which was current nb_steps_ago steps ago. Possibly has excess runtime cost compared to the next function, and has no bounds checking, unlike the next function

template<size_t NbStepsAgo = 1>
inline const OldVal_t &old() const

return the value of the iterate which was current NbStepsAgo steps ago

Protected Functions

inline std::array<OldStorage_t, NbMemory> make_old_vals_static(StaticStateFieldMap_t &state_field_map, size_t index)

helper function to build the list of old values

template<size_t... NbStepsAgo>
inline std::array<OldStorage_t, NbMemory> old_vals_helper_static(StaticStateFieldMap_t &state_field_map, size_t index, std::index_sequence<NbStepsAgo...>)

helper function to build the list of old values

Protected Attributes

CurrentStorage_t current_val

handle to current value

std::array<OldStorage_t, NbMemory> old_vals = {}

storage for handles to old values

template<Dim_t Dim, Dim_t I = Dim - 1>
struct Summand

#include <eigen_tools.hh>

sum term

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

template<Dim_t Dim>
struct Summand<Dim, 0>

#include <eigen_tools.hh>

sum term

Public Static Functions

template<class DerivedVec, class DerivedMat>
static inline decltype(auto) compute(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

wrapped function (raison d’être)

Public Static Attributes

static constexpr Dim_t I = {0}

short-hand

template<class Derived>
struct tensor_4_dim

#include <eigen_tools.hh>

computes the dimension from a fourth order tensor represented by a square matrix

Public Types

using T = std::remove_reference_t<Derived>

raw type for testing

Public Static Attributes

static constexpr Index_t value = {ct_sqrt(T::RowsAtCompileTime)}

evaluated dimension

template<class Derived>
struct tensor_dim

#include <eigen_tools.hh>

computes the dimension from a second order tensor represented square matrix or array

Public Types

using T = std::remove_cv_t<std::remove_reference_t<Derived>>

raw type for testing

Public Static Attributes

static constexpr Index_t value = {T::RowsAtCompileTime}

evaluated dimension

template<class Derived, Dim_t Dim>
struct tensor_rank

#include <eigen_tools.hh>

computes the rank of a tensor given the spatial dimension

Public Types

using T = std::remove_reference_t<Derived>

Public Static Attributes

static constexpr Dim_t value = {internal::get_rank<Dim, T::RowsAtCompileTime, T::ColsAtCompileTime>()}

template<Dim_t Dim, Dim_t SmallRank>
struct TensorMultiplicationProvider

template<Dim_t Dim>
struct TensorMultiplicationProvider<Dim, firstOrder>

Public Static Functions

template<typename T2, typename T1>
static inline constexpr auto multiply(const Eigen::MatrixBase<T2> &A, const Eigen::MatrixBase<T1> &B) -> decltype(A * B)

template<Dim_t Dim>
struct TensorMultiplicationProvider<Dim, secondOrder>

Public Static Functions

template<typename T4, typename T2>
static inline constexpr auto multiply(const Eigen::MatrixBase<T4> &A, const Eigen::MatrixBase<T2> &B) -> Eigen::Matrix<typename T2::Scalar, T2::RowsAtCompileTime, T2::RowsAtCompileTime>

template<>
struct TensorMultiplicationProvider<oneD, firstOrder>

Public Static Functions

template<typename T2, typename T1>
static inline constexpr auto multiply(const Eigen::MatrixBase<T2> &A, const Eigen::MatrixBase<T1> &B) -> decltype(A * B)

template<>
struct TensorMultiplicationProvider<oneD, secondOrder>

Public Static Functions

template<typename T2, typename T1>
static inline constexpr auto multiply(const Eigen::MatrixBase<T2> &A, const Eigen::MatrixBase<T1> &B) -> decltype(A * B)

class Traceback

#include <exception.hh>

A class that captures and manages a stack traceback.

This class is used to capture the stack traceback at the point of exception creation. It provides methods to get the stack traceback and to print it.

Public Functions

explicit Traceback(int discard_entries)

Construct a new Traceback object.

This constructor captures the current stack traceback, discarding the topmost entries as specified.

Parameters:

discard_entries – The number of topmost entries to discard from the captured stack traceback.

virtual ~Traceback()

Destroy the Traceback object.

This is a virtual destructor, allowing this class to be used as a base class.

inline const std::vector<TracebackEntry> &get_stack() const

Get the stack traceback.

This function returns a reference to the vector of traceback entries.

Returns:

const std::vector<TracebackEntry>& The stack traceback.

Protected Attributes

std::vector<TracebackEntry> stack

The captured stack traceback.

This vector contains the entries of the captured stack traceback.

Friends

inline friend std::ostream &operator<<(std::ostream &os, const Traceback &self)

Output the stack traceback.

This function outputs the stack traceback to the provided output stream. The traceback is output in reverse order (most recent entry last), and stops at the first entry that could not be resolved to a function name.

Parameters:

• os – The output stream to output the traceback to.

• self – The Traceback object to output the traceback of.

Returns:

std::ostream& The output stream.

class TracebackEntry

#include <exception.hh>

A class that represents an entry from the stack traceback.

This class is used to manage individual entries in a stack traceback. It provides methods to get the symbol, name, and file associated with the entry, and to check if the entry has been successfully resolved to a function/method name.

Public Functions

TracebackEntry(void *address, const std::string &symbol)

Construct a new TracebackEntry object with a given address and symbol.

Parameters:

• address – The address of the stack frame.

• symbol – The symbol associated with the stack frame.

TracebackEntry(void *address, const char *symbol)

Construct a new TracebackEntry object with a given address and symbol.

Parameters:

• address – The address of the stack frame.

• symbol – The symbol associated with the stack frame.

TracebackEntry(const TracebackEntry &other)

Copy constructor for the TracebackEntry class.

Parameters:

other – The TracebackEntry object to copy from.

~TracebackEntry()

Destroy the TracebackEntry object.

TracebackEntry &operator=(const TracebackEntry &other)

Assignment operator for the TracebackEntry class.

Parameters:

other – The TracebackEntry object to assign from.

Returns:

TracebackEntry& A reference to the assigned object.

inline const std::string &get_symbol() const

Get the symbol associated with the stack frame.

Returns:

const std::string& The symbol associated with the stack frame.

inline const std::string &get_name() const

Get the name associated with the stack frame.

Returns:

const std::string& The name associated with the stack frame.

inline const std::string &get_file() const

Get the file associated with the stack frame.

Returns:

const std::string& The file associated with the stack frame.

inline bool is_resolved() const

Check if the stack frame has been successfully resolved to a function/method name.

Returns:

bool True if the stack frame has been successfully resolved, false otherwise.

Protected Functions

void discover_name_and_file()

Discover the name and file associated with the stack frame.

This function attempts to resolve the stack frame to a function/method name and file. It demangles the function name if necessary.

Protected Attributes

void *address

The address of the stack frame.

std::string symbol

The symbol associated with the stack frame.

std::string name

The name associated with the stack frame.

std::string file

The file associated with the stack frame.

bool resolved

True if the stack frame has been successfully resolved to a function/method name, false otherwise.

Friends

inline friend std::ostream &operator<<(std::ostream &os, const TracebackEntry &self)

Output the TracebackEntry object.

This function outputs the TracebackEntry object to the provided output stream. If the stack frame has been successfully resolved, it outputs the file and name associated with the stack frame. Otherwise, it outputs a message indicating that the stack frame could not be resolved to a function/method name.

The output is formatted like Python stack tracebacks, because its primary purpose is to be displayed in conjunction with a Python exception.

Parameters:

• os – The output stream to output the TracebackEntry object to.

• self – The TracebackEntry object to output.

Returns:

std::ostream& The output stream.

template<typename T, typename FirstVal, typename ...RestVals>
struct TypeChecker

#include <ref_array.hh>

Struct user for checking that every member of a parameter pack has type T

Public Static Attributes

static constexpr bool value  {std::is_same<T, std::remove_reference_t<FirstVal>>::value andTypeChecker<T, RestVals...>::value}

whether the check passed

template<typename T, typename OnlyVal>
struct TypeChecker<T, OnlyVal>

#include <ref_array.hh>

Specialisation for recursion tail

Public Static Attributes

static constexpr bool value{std::is_same<T, std::remove_reference_t<OnlyVal>>::value}

whether the check passed

template<typename T>
class TypedField : public muGrid::TypedFieldBase<T>

#include <field_typed.hh>

forward declaration of the muSpectre::TypedField

forward declaration of the muGrid::TypedField

A muGrid::TypedField holds a certain number of components (scalars of type T per quadrature point of a muGrid::FieldCollection’s domain.

Template Parameters:

T – type of scalar to hold. Must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex.

Public Types

using Parent = TypedFieldBase<T>

base class

using EigenRep_t = typename Parent::EigenRep_t

Eigen type to represent the field’s data.

using Negative = typename Parent::Negative

convenience alias

Public Functions

TypedField() = delete

Default constructor.

TypedField(const TypedField &other) = delete

Copy constructor.

TypedField(TypedField &&other) = delete

Move constructor.

virtual ~TypedField() = default

Destructor.

TypedField &operator=(TypedField &&other) = delete

Move assignment operator.

TypedField &operator=(const TypedField &other)

Copy assignment operator.

TypedField &operator=(const Parent &other)

Copy assignment operator.

TypedField &operator=(const Negative &other)

Copy assignment operator.

TypedField &operator=(const EigenRep_t &other)

Copy assignment operator.

virtual void set_zero() final

initialise field to zero (do more complicated initialisations through fully typed maps)

virtual void set_pad_size(const size_t &pad_size) final

add a pad region to the end of the field buffer; required for using this as e.g. an FFT workspace

virtual size_t get_buffer_size() const final

size of the internal buffer including the pad region (in scalars)

void push_back(const T &value)

add a new scalar value at the end of the field (incurs runtime cost, do not use this in any hot loop). If your field has more than one quadrature point per pixel the same scalar value is pushed back on all quadrature points of the pixel.

void push_back_single(const T &value)

add a new scalar value at the end of the field (incurs runtime cost, do not use this in any hot loop). Even if you have several quadrature points per pixel you push back only a single value on a single quadrature point. Thus you can push back different values on quadrature points belongign to the same pixel.

void push_back(const Eigen::Ref<const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>> &value)

add a new non-scalar value at the end of the field (incurs runtime cost, do not use this in any hot loop) If your field has more than one quadrature point per pixel the same non-scalar value is pushed back on all quadrature points of the pixel.

void push_back_single(const Eigen::Ref<const Eigen::Array<T, Eigen::Dynamic, Eigen::Dynamic>> &value)

add a new non-scalar value at the end of the field (incurs runtime cost, do not use this in any hot loop) Even if you have several quadrature points per pixel you push back only a single non-scalar value on a single quadrature point. Thus you can push back different values on quadrature points belongign to the same pixel.

TypedField &clone(const std::string &new_name, const bool &allow_overwrite = false) const

perform a full copy of a field

Parameters:

• new_name – the name under which the new field will be stored

• allow_overwrite – by default, this function throws an error if the destination field already exists to avoid accidental clobbering of fields. If set to true, the copy will be made into the existing field.

inline std::vector<T> &get_values()

return the values of the field

Public Members

friend FieldCollection

give access to collections

Public Static Functions

static TypedField &safe_cast(Field &other)

cast a reference to a base type to this type, with full checks

static const TypedField &safe_cast(const Field &other)

cast a const reference to a base type to this type, with full checks

static TypedField &safe_cast(Field &other, const Index_t &nb_components, const std::string &sub_division)

cast a reference to a base type to this type safely, plus check whether it has the right number of components

static const TypedField &safe_cast(const Field &other, const Index_t &nb_components, const std::string &sub_division)

cast a const reference to a base type to this type safely, plus check whether it has the right number of components

Protected Functions

inline TypedField(const std::string &unique_name, FieldCollection &collection, const Index_t &nb_components, const std::string &sub_division, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. The Field constructor is protected to ensure this.

Parameters:

• unique_name – unique field name (unique within a collection)

• nb_components – number of components to store per quadrature point

• collection – reference to the holding field collection.

inline TypedField(const std::string &unique_name, FieldCollection &collection, const Shape_t &components_shape, const std::string &sub_division, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. The Field constructor is protected to ensure this.

Parameters:

• unique_name – unique field name (unique within a collection)

• collection – reference to the holding field collection.

• components_shape – number of components to store per quadrature point

• storage_oder – in-memory storage order of the components

virtual void resize() final

resizes the field to the given size

Protected Attributes

std::vector<T> values = {}

storage of the raw field data

template<typename T>
class TypedFieldBase : public muGrid::Field

forward declaration

Subclassed by muGrid::TypedField< Scalar >, muGrid::TypedField< T >, muGrid::WrappedField< T >

Public Types

using Scalar = T

stored scalar type

using EigenRep_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

Eigen type used to represent the field’s data.

using EigenVecRep_t = Eigen::Matrix<T, Eigen::Dynamic, 1>

Eigen type used to represent the field’s data.

using Eigen_map = Eigen::Map<EigenRep_t>

eigen map (handle for EigenRep_t)

using Eigen_cmap = Eigen::Map<const EigenRep_t>

eigen const map (handle for EigenRep_t)

using EigenVec_map = Eigen::Map<EigenVecRep_t>

eigen vector map (handle for EigenVecRep_t)

using EigenVec_cmap = Eigen::Map<const EigenVecRep_t>

eigen vector const map (handle for EigenVecRep_t)

using Parent = Field

base class

Public Functions

TypedFieldBase() = delete

Default constructor.

TypedFieldBase(const TypedFieldBase &other) = delete

Copy constructor.

TypedFieldBase(TypedFieldBase &&other) = default

Move constructor.

virtual ~TypedFieldBase() = default

Destructor.

TypedFieldBase &operator=(TypedFieldBase &&other) = delete

Move assignment operator.

TypedFieldBase &operator=(const TypedFieldBase &other)

Copy assignment operator.

TypedFieldBase &operator=(const Negative &other)

Copy assignment operator.

TypedFieldBase &operator=(const EigenRep_t &other)

Copy assignment operators.

Negative operator-() const

Unary negative.

TypedFieldBase &operator+=(const TypedFieldBase &other)

addition assignment

TypedFieldBase &operator-=(const TypedFieldBase &other)

subtraction assignment

inline virtual const std::type_info &get_typeid() const final

return type of the stored data

inline virtual const std::size_t get_element_size_in_bytes() const final

return the size of the elementary field entry in bytes

Eigen_map eigen_mat()

return a vector map onto the underlying data

Eigen_cmap eigen_mat() const

return a const vector map onto the underlying data

EigenVec_map eigen_vec()

return a vector map onto the underlying data

EigenVec_cmap eigen_vec() const

return a const vector map onto the underlying data

Eigen_map eigen_sub_pt()

return a matrix map onto the underlying data with one column per quadrature point

Eigen_cmap eigen_sub_pt() const

return a const matrix map onto the underlying data with one column per quadrature point

Eigen_map eigen_pixel()

return a matrix map onto the underlying data with one column per pixel

Eigen_cmap eigen_pixel() const

return a const matrix map onto the underlying data with one column per pixel

FieldMap<T, Mapping::Mut> get_pixel_map(const Index_t &nb_rows = Unknown)

convenience function returns a map of this field, iterable per pixel.

Parameters:

nb_rows – optional specification of the number of rows for the iterate. If left to default value, a matrix of shape nb_components × nb_quad_pts is used

FieldMap<T, Mapping::Const> get_pixel_map(const Index_t &nb_rows = Unknown) const

convenience function returns a const map of this field, iterable per pixel.

Parameters:

nb_rows – optional specification of the number of rows for the iterate. If left to default value, a matrix of shape nb_components × nb_quad_pts is used

FieldMap<T, Mapping::Mut> get_sub_pt_map(const Index_t &nb_rows = Unknown)

convenience function returns a map of this field, iterable per quadrature point.

Parameters:

nb_rows – optional specification of the number of rows for the iterate. If left to default value, a column vector is used

FieldMap<T, Mapping::Const> get_sub_pt_map(const Index_t &nb_rows = Unknown) const

convenience function returns a const map of this field, iterable per quadrature point.

Parameters:

nb_rows – optional specification of the number of rows for the iterate. If left to default value, a column vector is used

T *data() const

get the raw data ptr. Don’t use unless interfacing with external libs

virtual void *get_void_data_ptr() const final

return a pointer to the raw data. Don’t use unless interfacing with external libs

Eigen_map eigen_map(const Index_t &nb_rows, const Index_t &nb_cols)

non-const eigen_map with arbitrary sizes

Eigen_cmap eigen_map(const Index_t &nb_rows, const Index_t &nb_cols) const

const eigen_map with arbitrary sizes

Protected Functions

inline TypedFieldBase(const std::string &unique_name, FieldCollection &collection, Index_t nb_components, const std::string &sub_division, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. TheFieldconstructor is protected to ensure this. Fields are instantiated through theregister_field` methods FieldCollection.

Parameters:

• unique_name – unique field name (unique within a collection)

• collection – reference to the holding field collection.

• nb_components – number of components to store per quadrature point

inline TypedFieldBase(const std::string &unique_name, FieldCollection &collection, const Shape_t &components_shape, const std::string &sub_division, const Unit &unit)

Fields are supposed to only exist in the form of std::unique_ptrs held by a FieldCollection. TheFieldconstructor is protected to ensure this. Fields are instantiated through theregister_field` methods FieldCollection.

Parameters:

• unique_name – unique field name (unique within a collection)

• collection – reference to the holding field collection.

• components_shape – number of components to store per quadrature point

void set_data_ptr(T *ptr)

set the data_ptr

Protected Attributes

T *data_ptr = {}

in order to accomodate both registered fields (who own and manage their data) and unregistered temporary field proxies (piggy-backing on a chunk of existing memory as e.g., a numpy array) efficiently, the get_ptr_to_entry methods need to be branchless. this means that we cannot decide on the fly whether to return pointers pointing into values or into alt_values, we need to maintain an (shudder) raw data pointer that is set either at construction (for unregistered fields) or at any resize event (which may invalidate existing pointers). For the coder, this means that they need to be absolutely vigilant that any operation on the values vector that invalidates iterators needs to be followed by an update of data_ptr, or we will get super annoying memory bugs.

Friends

friend class FieldMap

template<typename T>
class TypedStateField : public muGrid::StateField

#include <state_field.hh>

forward declaration of the state field

forward declaration

The TypedStateField class is a byte compatible daughter class of the StateField class, and it can return fully typed Field references.

Public Types

using Parent = StateField

base class

Public Functions

TypedStateField() = delete

Deleted default constructor.

TypedStateField(const TypedStateField &other) = delete

Copy constructor.

TypedStateField(TypedStateField &&other) = delete

Move constructor.

virtual ~TypedStateField() = default

Destructor.

TypedStateField &operator=(const TypedStateField &other) = delete

Copy assignment operator.

TypedStateField &operator=(TypedStateField &&other) = delete

Move assignment operator.

virtual const std::type_info &get_typeid() const final

return type_id of stored type

virtual const std::size_t get_element_size_in_bytes() const final

return the size of the elementary field entry in bytes

TypedField<T> &current()

return a reference to the current field

const TypedField<T> &current() const

return a const reference to the current field

const TypedField<T> &old(size_t nb_steps_ago = 1) const

return a const reference to the field which was current nb_steps_ago steps ago

Protected Functions

TypedStateField(const std::string &unique_prefix, FieldCollection &collection, const Index_t &nb_memory, const Index_t &nb_components, const std::string &sub_division, const Unit &unit)

protected constructor, to avoid the creation of unregistered fields. Users should create fields through the muGrid::FieldCollection::register_real_field() (or int, uint, complex) factory functions.

RefVector<Field> &get_fields()

return a reference to the storage of the constituent fields

Protected Attributes

friend FieldCollection

give access to the protected state field constructor

Friends

friend class StateFieldMap< T, Mapping::Const >

friend class StateFieldMap< T, Mapping::Mut >

class Unit

#include <units.hh>

A wrapper class around 5 DynBaseUnit objects representing length, mass, time, temperature, and change. This should be sufficient to handle all of µSpectre’s needs, but could easily be extended by mol and luminous intensity to represent the full SI.

Public Functions

Unit(const UnitExponent &length, const UnitExponent &mass, const UnitExponent &time, const UnitExponent &temperature, const UnitExponent &current, const UnitExponent &luminous_intensity, const UnitExponent &amount, const Int &tag = 0)

constructor from subunits ond optional integer tag can be used to handle cases of additional incompatibilities, e.g., for species. Imagine a coupled diffusion calculation, where one constitutive law handles a concentration of mol·Na/l, and another one a concentration of mol·Ka/l. Both have the same SI unit, but are not compatible. Use different tags for units that need to be mutually incompatible for whatever reason

const UnitExponent &get_length() const

returns a const reference to length

const UnitExponent &get_mass() const

returns a const reference to mass

const UnitExponent &get_time() const

returns a const reference to time

const UnitExponent &get_temperature() const

returns a const reference to temperature

const UnitExponent &get_current() const

returns a const reference to current

const UnitExponent &get_luminous_intensity() const

returns a const reference to luminous intensity

const UnitExponent &get_amount() const

returns a const reference to amount of matter

Unit(const Unit &other) = default

Copy constructor.

Unit(Unit &&other) = default

Move constructor.

virtual ~Unit() = default

Destructor.

Unit &operator=(const Unit &other) = default

Copy assignment operator.

Unit &operator=(Unit &&other) = default

Move assignment operator.

bool operator==(const Unit &other) const

comparison operator

bool operator!=(const Unit &other) const

comparison operator

bool operator<(const Unit &other) const

comparison (required for use as key in std::map)

Unit operator+(const Unit &other) const

addition

Unit operator-(const Unit &other) const

subtraction

Unit operator*(const Unit &other) const

multiplication

Unit operator/(const Unit &other) const

division

Public Static Functions

static Unit unitless(const Int &tag = 0)

factory function for base unit pure number

static Unit length(const Int &tag = 0)

factory function for base unit length

static Unit mass(const Int &tag = 0)

factory function for base unit mass

static Unit time(const Int &tag = 0)

factory function for base unit time

static Unit temperature(const Int &tag = 0)

factory function for base unit temperature

static Unit current(const Int &tag = 0)

factory function for base unit current

static Unit luminous_intensity(const Int &tag = 0)

factory function for base unit luminous intensity

static Unit amount(const Int &tag = 0)

factory function for base unit amount of matter

static Unit force(const Int &tag = 0)

factory function for mechanical stress

static Unit stress(const Int &tag = 0)

factory function for mechanical stress

static Unit strain(const Int &tag = 0)

factory function for mechanical strain

Protected Functions

UnitExponent &get_length()

returns a reference to length

UnitExponent &get_mass()

returns a reference to mass

UnitExponent &get_time()

returns a reference to time

UnitExponent &get_temperature()

returns a reference to temperature

UnitExponent &get_current()

returns a reference to current

UnitExponent &get_luminous_intensity()

returns a reference to luminous intensity

UnitExponent &get_amount()

returns a reference to amount of matter

void check_tags(const Unit &other) const

Throws a UnitError if *this and other have mismatched tags.

explicit Unit(const Int &tag)

tagged almost-default constructor

Protected Attributes

std::array<UnitExponent, NbUnits> units = {}

Int tag

Protected Static Attributes

static constexpr int NbUnits = {7}

Friends

friend std::ostream &operator<<(std::ostream&, const Unit &unit)

class UnitError : public muGrid::ExceptionWithTraceback<T>

Public Types

using Parent = RuntimeError

Public Functions

UnitError() = delete

Default constructor.

explicit UnitError(const std::string &what)

Constructor with message.

UnitError(const UnitError &other) = default

Copy constructor.

UnitError(UnitError &&other) = default

Move constructor.

virtual ~UnitError() = default

Destructor.

UnitError &operator=(const UnitError &other) = default

Copy assignment operator.

UnitError &operator=(UnitError &&other) = default

Move assignment operator.

class UnitExponent

#include <units.hh>

Run-time representation of a rational exponent for base units. This can be used to compose any unit. e.g., speed would be length per time, i.e. length¹ · time⁻¹. Note that the rational exponent allows to express more exotic units such as for instance the 1/√length in fracture toughness (length^(⁻¹/₂)). The rational exponent is always reduced to the simplest form with a positive denominator. A zero denominator results in a UnitError being thrown.

Public Functions

UnitExponent() = default

default constructor (needed for default initialisation of std::array)

explicit UnitExponent(const Int &numerator, const Int &denominator = 1)

constructor

UnitExponent(const UnitExponent &other) = default

Copy constructor.

UnitExponent(UnitExponent &&other) = default

Move constructor.

virtual ~UnitExponent() = default

Destructor.

UnitExponent &operator=(const UnitExponent &other) = default

Copy assignment operator.

UnitExponent &operator=(UnitExponent &&other) = default

Move assignment operator.

bool operator==(const UnitExponent &other) const

comparison operator

bool operator!=(const UnitExponent &other) const

comparison operator

bool operator<(const UnitExponent &other) const

comparison operator (required for use as key in std::map)

UnitExponent operator+(const UnitExponent &other) const

addition

UnitExponent operator-(const UnitExponent &other) const

subtraction

UnitExponent operator*(const UnitExponent &other) const

multiplication (exponent addition)

UnitExponent operator/(const UnitExponent &other) const

division (exponent subtraction)

const Int &get_numerator() const

const Int &get_denominator() const

Protected Functions

void reduce()

Protected Attributes

Int numerator = {}

Int denominator = {}

Friends

friend std::ostream &operator<<(std::ostream&, const UnitExponent &unit)

class ValueError : public muGrid::DictionaryError

union Variant

Public Functions

inline Variant(const Int &value)

inline Variant(const Real &value)

inline Variant(const Eigen::Ref<const Eigen::MatrixXd> &value)

inline Variant(const Map_t &value)

inline ~Variant()

doesn’t do anything, responsibility of ValueHolder

Public Members

Map_t dictionary = {}

Int integer_value

Real real_value

Eigen::MatrixXd matrix_value

template<typename T>
class WrappedField : public muGrid::TypedFieldBase<T>

#include <field_typed.hh>

Wrapper class providing a field view of existing memory. This is particularly useful when dealing with input from external libraries (e.g., numpy arrays)

Public Types

using Parent = TypedFieldBase<T>

base class

using EigenRep_t = typename Parent::EigenRep_t

convenience alias to the Eigen representation of this field’s data

Public Functions

WrappedField(const std::string &unique_name, FieldCollection &collection, const Index_t &nb_components, const size_t &size, T *ptr, const std::string &sub_division, const Unit &unit = Unit::unitless(), const Shape_t &strides = {})

constructor from a raw pointer. Typically, this would be a reference to a numpy array from the python bindings.

WrappedField(const std::string &unique_name, FieldCollection &collection, const Shape_t &components_shape, const size_t &size, T *ptr, const std::string &sub_division, const Unit &unit = Unit::unitless(), const Shape_t &strides = {})

constructor from a raw pointer. Typically, this would be a reference to a numpy array from the python bindings.

WrappedField(const std::string &unique_name, FieldCollection &collection, const Index_t &nb_components, Eigen::Ref<EigenRep_t> values, const std::string &sub_division, const Unit &unit = Unit::unitless(), const Shape_t &strides = {})

constructor from an eigen array ref.

WrappedField(const std::string &unique_name, FieldCollection &collection, const Shape_t &components_shape, Eigen::Ref<EigenRep_t> values, const std::string &sub_division, const Unit &unit = Unit::unitless(), const Shape_t &strides = {})

constructor from an eigen array ref.

WrappedField() = delete

Default constructor.

WrappedField(const WrappedField &other) = delete

Copy constructor.

WrappedField(WrappedField &&other) = default

Move constructor.

virtual ~WrappedField() = default

Destructor.

WrappedField &operator=(WrappedField &&other) = delete

Move assignment operator.

WrappedField &operator=(const Parent &other)

Copy assignment operator.

virtual void set_zero() final

initialise field to zero (do more complicated initialisations through fully typed maps)

virtual void set_pad_size(const size_t &pad_size) final

add a pad region to the end of the field buffer; required for using this as e.g. an FFT workspace

virtual size_t get_buffer_size() const final

size of the internal buffer including the pad region (in scalars)

virtual Shape_t get_strides(const IterUnit &iter_type, Index_t element_size = 1) const final

evaluate and return the overall strides field (for passing the field to generic multidimensional array objects such as numpy.ndarray). The multiplier can be used e.g., if strides are needed in bytes, rather than in pointer offsets.

virtual StorageOrder get_storage_order() const final

Return the storage order

Public Members

friend FieldCollection

give access to collections

Public Static Functions

static std::unique_ptr<const WrappedField> make_const(const std::string &unique_name, FieldCollection &collection, const Index_t &nb_components, const Eigen::Ref<const EigenRep_t> values, const std::string &sub_division, const Unit &unit = Unit::unitless(), const Shape_t &strides = {})

Emulation of a const constructor

Protected Functions

virtual void resize() final

resizes the field to the given size

Protected Attributes

size_t size

size of the wrapped buffer

Shape_t strides

Strides of the wrapped field when iterating over sub-points, they are decoupled from the underlying FieldCollection. If they are empty, then the natural muGrid storage order applies.

template<class ...Containers>
class ZipContainer

helper for the emulation of python zip

Public Functions

inline explicit ZipContainer(Containers&&... containers)

undocumented

inline decltype(auto) begin() const

undocumented

inline decltype(auto) end() const

undocumented

inline decltype(auto) begin()

undocumented

inline decltype(auto) end()

undocumented

Private Types

using containers_t = std::tuple<Containers...>

Private Members

containers_t containers

template<class ...Iterators>
class ZipIterator

#include <iterators.hh>

iterator for emulation of python zip

Public Functions

inline explicit ZipIterator(tuple_t iterators)

undocumented

inline decltype(auto) operator*()

undocumented

inline ZipIterator &operator++()

undocumented

inline bool operator==(const ZipIterator &other) const

undocumented

inline bool operator!=(const ZipIterator &other) const

undocumented

Private Types

using tuple_t = std::tuple<Iterators...>

Private Members

tuple_t iterators

namespace akantu

Functions

template<class ...Iterators>
decltype(auto) zip_iterator(std::tuple<Iterators...> &&iterators_tuple)

emulates python zip()

template<class ...Containers>
decltype(auto) zip(Containers&&... conts)

emulates python’s zip()

template<class T, typename = std::enable_if_t<std::is_integral<std::decay_t<T>>::value>>
inline decltype(auto) arange(const T &stop)

emulates python’s range()

template<class T1, class T2, typename = std::enable_if_t<std::is_integral<std::common_type_t<T1, T2>>::value>>
inline constexpr decltype(auto) arange(const T1 &start, const T2 &stop)

emulates python’s range()

template<class T1, class T2, class T3, typename = std::enable_if_t<std::is_integral<std::common_type_t<T1, T2, T3>>::value>>
inline constexpr decltype(auto) arange(const T1 &start, const T2 &stop, const T3 &step)

emulates python’s range()

template<class Container>
inline constexpr decltype(auto) enumerate(Container &&container, size_t start_ = 0)

emulates python’s enumerate

template<class Container, class ...Containers>
decltype(auto) enum_zip(Container &&cont0, Containers&&... conts, size_t start_ = 0)

emulates python’s enumerate(zip())

template<class Container0, class Container1>
decltype(auto) enum_zip(Container0 &&cont0, Container1 &&cont1, size_t start_ = 0)

emulates python’s enumerate(zip())

namespace containers

namespace iterators

namespace tuple

Functions

template<class Tuple>
bool are_not_equal(Tuple &&a, Tuple &&b)

detail

template<class F, class Tuple>
void foreach_(F &&func, Tuple &&tuple)

detail

template<class F, class Tuple>
decltype(auto) transform(F &&func, Tuple &&tuple)

detail

namespace details

Functions

template<typename ...Ts>
decltype(auto) make_tuple_no_decay(Ts&&... args)

eats up a bunch of arguments and returns them packed in a tuple

template<class F, class Tuple, size_t... Is>
void foreach_impl(F &&func, Tuple &&tuple, std::index_sequence<Is...>&&)

helper for static for loop

template<class F, class Tuple, size_t... Is>
decltype(auto) transform_impl(F &&func, Tuple &&tuple, std::index_sequence<Is...>&&)

detail

namespace muGrid

Typedefs

template<typename T>
using DynMatrix_t = Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>

template<class T>
using optional = typename std::experimental::optional<T>

emulation std::optional (a C++17 feature)

using nullopt_t = std::experimental::fundamentals_v1::nullopt_t

template<Dim_t Dim>
using Matrix_t = Eigen::Matrix<Real, Dim, Dim>

template<Dim_t Dim>
using SelfAdjointDecomp_t = Eigen::SelfAdjointEigenSolver<Eigen::Matrix<Real, Dim, Dim>>

typedef ExceptionWithTraceback<std::runtime_error> RuntimeError

A type alias for ExceptionWithTraceback specialized with std::runtime_error.

This type is used to throw exceptions that include a stack trace, for runtime errors.

template<class EigenPlain, Mapping Mutability, IterUnit IterationType>
using EigenFieldMap = StaticFieldMap<typename EigenPlain::Scalar, Mutability, internal::EigenMap<typename EigenPlain::Scalar, EigenPlain>, IterationType>

Alias of muGrid::StaticFieldMap you wish to iterate over pixel by pixel or quadrature point by quadrature point with a chosen, statically sized plain Eigen type

Template Parameters:

• EigenPlain – a statically sized Eigen::Array or Eigen::Matrix

• Mutability – whether or not the map allows to modify the content of the field

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType>
using MatrixFieldMap = StaticFieldMap<T, Mutability, internal::MatrixMap<T, NbRow, NbCol>, IterationType>

Alias of muGrid::StaticFieldMap you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Matrix iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType>
using ArrayFieldMap = StaticFieldMap<T, Mutability, internal::ArrayMap<T, NbRow, NbCol>, IterationType>

Alias of muGrid::StaticFieldMap you wish to iterate over pixel by pixel or quadrature point by quadrature point with* statically sized Eigen::Array iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivisionuadrature points

template<typename T, Mapping Mutability, IterUnit IterationType>
using ScalarFieldMap = StaticFieldMap<T, Mutability, internal::ScalarMap<T>, IterationType>

Alias of muGrid::StaticFieldMap over a scalar field you wish to iterate over

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Rank, Dim_t Dim, IterUnit IterationType>
using TensorFieldMap = StaticFieldMap<T, Mutability, internal::TensorMap<T, Rank, Dim>, IterationType>

Alias of muGrid::StaticNFieldMap over a tensor field you wish to iterate over

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Rank – tensorial rank

• Dim – spatial dimension of the tensor

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using T1FieldMap = StaticFieldMap<T, Mutability, internal::MatrixMap<T, Dim, 1>, IterationType>

Alias of muGrid::StaticFieldMap over a second-rank tensor field you wish to iterate over

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using T2FieldMap = StaticFieldMap<T, Mutability, internal::MatrixMap<T, Dim, Dim>, IterationType>

Alias of muGrid::StaticFieldMap over a second-rank tensor field you wish to iterate over

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using T4FieldMap = StaticFieldMap<T, Mutability, internal::MatrixMap<T, Dim * Dim, Dim * Dim>, IterationType>

Alias of muGrid::StaticFieldMap over a fourth-rank tensor field you wish to iterate over

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• IterationType – describes the pixel-subdivision

using RealField = TypedField<Real>

Alias for real-valued fields.

using ComplexField = TypedField<Complex>

Alias for complex-valued fields.

using IntField = TypedField<Int>

Alias for integer-valued fields.

using UintField = TypedField<Uint>

Alias for unsigned integer-valued fields.

using IndexField = TypedField<Index_t>

Alias for unsigned integer-valued fields.

using Shape_t = std::vector<Index_t>

Type used for shapes and strides.

using DynCcoord_t = DynCcoord<threeD>

Cell coordinates, i.e. up to three integer numbers with dynamic (determined during runtime) dimension

using DynRcoord_t = DynCcoord<threeD, Real>

Real space coordinates, i.e. up to three floating point numbers with dynamic (determined during runtime) dimension

template<class EigenPlain, Mapping Mutability, IterUnit IterationType>
using MappedEigenField = MappedField<EigenFieldMap<EigenPlain, Mutability, IterationType>>

Alias of muGrid::MappedField for a map with corresponding muSpectre::Field you wish to iterate over pixel by pixel or quadrature point by quadrature point with a chosen, statically sized plain Eigen type

Template Parameters:

• EigenPlain – a statically sized Eigen::Array or Eigen::Matrix

• Mutability – whether or not the map allows to modify the content of the field

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType>
using MappedMatrixField = MappedField<MatrixFieldMap<T, Mutability, NbRow, NbCol, IterationType>>

Alias of muGrid::MappedField for a map with corresponding muSpectre::Field you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Matrix iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType>
using MappedArrayField = MappedField<ArrayFieldMap<T, Mutability, NbRow, NbCol, IterationType>>

Alias of muGrid::MappedField for a map with corresponding muSpectre::Field you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Array iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, IterUnit IterationType>
using MappedScalarField = MappedField<ScalarFieldMap<T, Mutability, IterationType>>

Alias of muGrid::MappedField for a map of scalars with corresponding muSpectre::Field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Rank, Dim_t Dim, IterUnit IterationType>
using MappedTensorField = MappedField<TensorFieldMap<T, Mutability, Rank, Dim, IterationType>>

Alias of muGrid::MappedField for a map of second-rank with corresponding muSpectre::Field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Rank – tensorial rank

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using MappedT1Field = MappedField<T1FieldMap<T, Mutability, Dim, IterationType>>

Alias of muGrid::MappedField for a map of second-rank with corresponding muSpectre::Field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using MappedT2Field = MappedField<T2FieldMap<T, Mutability, Dim, IterationType>>

Alias of muGrid::MappedField for a map of first-rank with corresponding muSpectre::Field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType>
using MappedT4Field = MappedField<T4FieldMap<T, Mutability, Dim, IterationType>>

Alias of muGrid::MappedField for a map of fourth-rank with corresponding muSpectre::Field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType, size_t NbMemory = 1>
using MappedMatrixStateField = MappedStateField<MatrixStateFieldMap<T, Mutability, NbRow, NbCol, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map with corresponding muSpectre::StateField you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Matrix iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, IterUnit IterationType, size_t NbMemory = 1>
using MappedArrayStateField = MappedStateField<ArrayStateFieldMap<T, Mutability, NbRow, NbCol, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map with corresponding muSpectre::StateField you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Array iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, IterUnit IterationType, size_t NbMemory = 1>
using MappedScalarStateField = MappedStateField<ScalarStateFieldMap<T, Mutability, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map of scalars with corresponding muSpectre::StateField you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, Dim_t Rank, Dim_t Dim, IterUnit IterationType, size_t NbMemory = 1>
using MappedTensorStateNField = MappedStateField<TensorStateFieldMap<T, Mutability, Rank, Dim, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map of first-rank with corresponding muSpectre::StateNField you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Rank – tensorial rank

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType, size_t NbMemory = 1>
using MappedT1StateNField = MappedStateField<T1StateFieldMap<T, Mutability, Dim, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map of first-rank with corresponding muSpectre::StateNField you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType, size_t NbMemory = 1>
using MappedT2StateField = MappedStateField<T2StateFieldMap<T, Mutability, Dim, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map of second-rank with corresponding muSpectre::StateField you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

template<typename T, Mapping Mutability, Dim_t Dim, IterUnit IterationType, size_t NbMemory = 1>
using MappedT4StateField = MappedStateField<T4StateFieldMap<T, Mutability, Dim, NbMemory, IterationType>>

Alias of muGrid::MappedStateField for a map of fourth-rank with corresponding muSpectre::StateField you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensors

• IterationType – describes the pixel-subdivision

• NbMemory – number of previous values to store

using RealStateField = TypedStateField<Real>

Alias for real-valued state fields.

using ComplexStateField = TypedStateField<Complex>

Alias for complex-valued state fields.

using IntStateField = TypedStateField<Int>

Alias for integer-valued state fields.

using Uintfield = TypedStateField<Uint>

Alias for unsigned integer-valued state fields.

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, size_t NbMemory, IterUnit IterationType = IterUnit::SubPt>
using MatrixStateFieldMap = StaticStateFieldMap<T, Mutability, internal::MatrixMap<T, NbRow, NbCol>, NbMemory, IterationType>

Alias of muGrid::StaticStateFieldMap you wish to iterate over pixel by pixel or quadrature point by quadrature point with statically sized Eigen::Matrix iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• NbMemory – number of previous values to store

• IterationType – whether to iterate over pixels or quadrature points

template<typename T, Mapping Mutability, Dim_t NbRow, Dim_t NbCol, size_t NbMemory, IterUnit IterationType>
using ArrayStateFieldMap = StaticStateFieldMap<T, Mutability, internal::ArrayMap<T, NbRow, NbCol>, NbMemory, IterationType>

Alias of muGrid::StaticStateFieldMap you wish to iterate over pixel by pixel or quadrature point by quadrature point with* statically sized Eigen::Array iterates

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbRow – number of rows of the iterate

• NbCol – number of columns of the iterate

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, size_t NbMemory, IterUnit IterationType>
using ScalarStateFieldMap = StaticStateFieldMap<T, Mutability, internal::ScalarMap<T>, NbMemory, IterationType>

Alias of muGrid::StaticStateFieldMap over a scalar field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Rank, Dim_t Dim, size_t NbMemory, IterUnit IterationType>
using TensorStateFieldMap = StaticStateFieldMap<T, Mutability, internal::TensorMap<T, Rank, Dim>, NbMemory, IterationType>

Alias of muGrid::StaticStateNFieldMap over a first-rank tensor field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Rank – tensorial rank

• Dim – spatial dimension of the tensor

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, size_t NbMemory, IterUnit IterationType>
using T1StateFieldMap = StaticStateFieldMap<T, Mutability, internal::MatrixMap<T, Dim, 1>, NbMemory, IterationType>

Alias of muGrid::StaticStateNFieldMap over a first-rank tensor field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, size_t NbMemory, IterUnit IterationType>
using T2StateFieldMap = StaticStateFieldMap<T, Mutability, internal::MatrixMap<T, Dim, Dim>, NbMemory, IterationType>

Alias of muGrid::StaticStateNFieldMap over a second-rank tensor field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Mapping Mutability, Dim_t Dim, size_t NbMemory, IterUnit IterationType>
using T4StateFieldMap = StaticStateFieldMap<T, Mutability, internal::MatrixMap<T, Dim * Dim, Dim * Dim>, NbMemory, IterationType>

Alias of muGrid::StaticStateFieldMap over a fourth-rank tensor field you wish to iterate over.

Template Parameters:

• T – scalar type stored in the field, must be one of muGrid::Real, muGrid::Int, muGrid::Uint, muGrid::Complex

• Mutability – whether or not the map allows to modify the content of the field

• Dim – spatial dimension of the tensor

• NbMemory – number of previous values to store

• IterationType – describes the pixel-subdivision

template<typename T, Dim_t Dim>
using T4Mat = Eigen::Matrix<T, Dim * Dim, Dim * Dim>

simple adapter function to create a matrix that can be mapped as a tensor

template<typename T, Dim_t Dim, bool ConstMap = false>
using T4MatMap = std::conditional_t<ConstMap, Eigen::Map<const T4Mat<T, Dim>>, Eigen::Map<T4Mat<T, Dim>>>

Map onto muGrid::T4Mat

Enums

enum class IterUnit

An enumeration class for iteration units.

This enumeration class is used in two contexts within the µGrid codebase. Firstly, it is used in Fields to specify the relative storage of data with respect to pixels, quadrature points, or nodal points. Secondly, it is used in FieldMaps to specify the unit of iteration, whether it be over pixels, quadrature points, or nodal points.

Values:

enumerator Pixel

dofs relative to a pixel/voxel, no subdivision

enumerator SubPt

dofs relative to sub-points (e.g. quadrature points)

enum class StorageOrder

An enumeration class for storage orders of field components.

This enumeration class defines six types of storage orders: ColMajor, ArrayOfStructures, RowMajor, StructurOfArrays, Unknown, and Automatic. These storage orders can be used to determine the order in which field components are stored in memory.

Values:

enumerator ColMajor

column-major storage order (first index is fast)

enumerator ArrayOfStructures

components are consecutive in memory

enumerator RowMajor

row-major storage order (last index is fast)

enumerator StructurOfArrays

enumerator Unknown

storage order is unknown, only for WrappedField

enumerator Automatic

inherit storage order from FieldCollection

enum class Mapping

An enumeration class for mapping types.

This enumeration class defines two types of mappings: Const and Mut. These mappings can be used to determine the type of access (constant or mutable) to the mapped field through their iterators or access operators.

Values:

enumerator Const

enumerator Mut

enum class Verbosity

Enum class for verbose-flag

Values:

enumerator Silent

enumerator Some

enumerator Detailed

enumerator Full

Functions

template<Dim_t order, Dim_t dim, typename Fun_t>
inline decltype(auto) call_sizes(Fun_t &&fun)

takes a lambda and calls it with the proper Eigen::Sizes unpacked as arguments. Is used to call constructors of a Eigen::Tensor or map thereof in a context where the spatial dimension is templated

static constexpr Dim_t ct_sqrt(Dim_t res, Dim_t l, Dim_t r)

static constexpr Dim_t ct_sqrt(Dim_t res)

template<class Derived>
inline decltype(auto) logm(const Eigen::MatrixBase<Derived> &mat)

computes the matrix logarithm efficiently for dim=1, 2, or 3 for a diagonizable tensor. For larger tensors, better use the direct eigenvalue/vector computation

template<class Derived, template<class Matrix_t> class DecompType = Eigen::SelfAdjointEigenSolver>
inline decltype(auto) spectral_decomposition(const Eigen::MatrixBase<Derived> &mat)

compute the spectral decomposition

template<Dim_t Dim, template<class Matrix_t> class DecompType = Eigen::SelfAdjointEigenSolver>
inline decltype(auto) logm_alt_spectral(const DecompType<Matrix_t<Dim>> &spectral_decomp)

It seems we only need to take logs of self-adjoint matrices

template<class Derived>
inline decltype(auto) logm_alt(const Eigen::MatrixBase<Derived> &mat)

compute the matrix log with a spectral decomposition. This may not be the most efficient way to do this

template<Dim_t Dim, template<class Matrix_t> class DecompType = Eigen::SelfAdjointEigenSolver>
inline decltype(auto) expm_spectral(const DecompType<Matrix_t<Dim>> &spectral_decomp)

Uses a pre-existing spectral decomposition of a matrix to compute its exponential

Parameters:

spectral_decomp – spectral decomposition of a matrix

Template Parameters:

Dim – spatial dimension (i.e., number of rows and colums in the matrix)

template<class Derived>
inline decltype(auto) expm(const Eigen::MatrixBase<Derived> &mat)

compute the matrix exponential with a spectral decomposition. This may not be the most efficient way to do this

std::ostream &operator<<(std::ostream &os, const muGrid::FieldCollection::ValidityDomain &value)

Allows inserting muGrid::FieldCollection::ValidityDomain into std::ostreams

template<int size>
constexpr nc_type netcdf_signed_type()

template<>
constexpr nc_type netcdf_signed_type<1>()

template<>
constexpr nc_type netcdf_signed_type<2>()

template<>
constexpr nc_type netcdf_signed_type<4>()

template<>
constexpr nc_type netcdf_signed_type<8>()

template<int size>
constexpr nc_type netcdf_unsigned_type()

template<>
constexpr nc_type netcdf_unsigned_type<1>()

template<>
constexpr nc_type netcdf_unsigned_type<2>()

template<>
constexpr nc_type netcdf_unsigned_type<4>()

template<>
constexpr nc_type netcdf_unsigned_type<8>()

template<typename T>
constexpr nc_type netcdf_type()

template<>
constexpr nc_type netcdf_type<char>()

template<>
constexpr nc_type netcdf_type<float>()

template<>
constexpr nc_type netcdf_type<double>()

Eigen::MatrixXd permutation(const Eigen::VectorXi &nodal_indices, const Eigen::MatrixXi &pixel_offsets, const Index_t &nb_pixelnodes)

bool operator<(const Verbosity v1, const Verbosity v2)

comparison operators for Verbosity-class

bool operator>(const Verbosity v1, const Verbosity v2)

bool operator<=(const Verbosity v1, const Verbosity v2)

bool operator>=(const Verbosity v1, const Verbosity v2)

std::ostream &operator<<(std::ostream &os, const IterUnit &sub_division)

inserts muGrid::IterUnit into std::ostreams

std::ostream &operator<<(std::ostream &os, const StorageOrder &storage_order)

inserts muGrid::StorageOrder into std::ostreams

template<typename T>
Index_t get_nb_from_shape(const T &shape)

template<typename T, size_t Dim>
Eigen::Map<Eigen::Matrix<T, Dim, 1>> eigen(std::array<T, Dim> &coord)

return a Eigen representation of the data stored in a std::array (e.g., for doing vector operations on a coordinate)

template<typename T, size_t Dim>
Eigen::Map<const Eigen::Matrix<T, Dim, 1>> eigen(const std::array<T, Dim> &coord)

return a constant Eigen representation of the data stored in a std::array (e.g., for doing vector operations on a coordinate)

template<typename T, size_t MaxDim>
Eigen::Map<Eigen::Matrix<T, Eigen::Dynamic, 1>> eigen(DynCcoord<MaxDim, T> &coord)

return a Eigen representation of the data stored in a std::array (e.g., for doing vector operations on a coordinate)

template<typename T, size_t MaxDim>
Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, 1>> eigen(const DynCcoord<MaxDim, T> &coord)

return a const Eigen representation of the data stored in a std::array (e.g., for doing vector operations on a coordinate)

template<typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &values)

Allows inserting std::vector into std::ostreams

template<typename T, size_t dim>
std::ostream &operator<<(std::ostream &os, const std::array<T, dim> &values)

Allows inserting muGrid::Ccoord_t and muGrid::Rcoord_t into std::ostreams

template<size_t MaxDim, typename T>
std::ostream &operator<<(std::ostream &os, const DynCcoord<MaxDim, T> &values)

Allows inserting muGrid::DynCcoord into std::ostreams

template<size_t dim>
Rcoord_t<dim> operator/(const Rcoord_t<dim> &a, const Rcoord_t<dim> &b)

element-wise division

template<size_t dim>
Rcoord_t<dim> operator/(const Rcoord_t<dim> &a, const Ccoord_t<dim> &b)

element-wise division

template<typename R, typename I>
constexpr R ipow(R base, I exponent)

compile-time potentiation required for field-size computations

template<typename T>
py::array_t<T, py::array::f_style> numpy_wrap(const TypedFieldBase<T> &field, IterUnit iter_type = IterUnit::SubPt)

template<typename T>
py::array_t<T, py::array::f_style> numpy_copy(const TypedFieldBase<T> &field, IterUnit iter_type = IterUnit::SubPt)

template<typename T>
py::tuple to_tuple(T a)

std::ostream &operator<<(std::ostream &os, const PhysicsDomain &domain)

template<typename T4>
inline auto get(const Eigen::MatrixBase<T4> &t4, Dim_t i, Dim_t j, Dim_t k, Dim_t l) -> decltype(auto)

provides index-based access to fourth-order Tensors represented by square matrices

template<typename T4>
inline auto get(Eigen::MatrixBase<T4> &t4, Dim_t i, Dim_t j, Dim_t k, Dim_t l) -> decltype(t4.coeffRef(i, j))

provides constant index-based access to fourth-order Tensors represented by square matrices

constexpr Int compute_gcd_worker(const Uint &a, const Uint &b)

computes the greatest common divisor of two integer values using the Binary GCD algorithm. Can hopefully soon be replaced by C++17’s std::gcd.

Int compute_gcd(const Int &a_signed, const Int &b_signed)

computes the greatest common divisor of two integer values using the Binary GCD algorithm. Can hopefully soon be replaced by C++17’s std::gcd.

std::string superscript(const int &val)

std::ostream &operator<<(std::ostream &os, const UnitExponent &unit)

std::ostream &operator<<(std::ostream &os, const Unit &unit)

Variables

constexpr nullopt_t nullopt = {std::experimental::fundamentals_v1::nullopt}

static constexpr char REGISTER_ALL_FIELDS[] = "REGISTER_ALL_FIELDS"

static constexpr char REGISTER_ALL_STATE_FIELDS[] = "REGISTER_ALL_STATE_FIELDS"

constexpr nc_type MU_NC_CHAR = netcdf_type<char>()

constexpr nc_type MU_NC_INT = netcdf_type<muGrid::Int>()

constexpr nc_type MU_NC_UINT = netcdf_type<muGrid::Uint>()

constexpr nc_type MU_NC_INDEX_T = netcdf_type<muGrid::Index_t>()

constexpr nc_type MU_NC_REAL = netcdf_type<muGrid::Real>()

static constexpr std::int64_t GFC_LOCAL_PIXELS_DEFAULT_VALUE{-1}

static constexpr int DEFAULT_NETCDFDIM_ID{-1}

static constexpr int DEFAULT_NETCDFVAR_ID{-1}

constexpr Index_t oneD = {1}

constant for a one-dimensional problem

constexpr Index_t twoD = {2}

constant for a two-dimensional problem

constexpr Index_t threeD = {3}

constant for a three-dimensional problem

constexpr Index_t zerothOrder = {0}

constant for scalars

constexpr Index_t firstOrder = {1}

constant for vectors

constexpr Index_t secondOrder = {2}

constant second-order tensors

constexpr Index_t fourthOrder = {4}

constant fourth-order tensors

constexpr Index_t OneQuadPt = {1}

constant for 1 quadrature point/pixel

constexpr Index_t TwoQuadPts = {2}

constant for 2 quadrature point/pixel

constexpr Index_t FourQuadPts = {4}

constant for 4 quadrature point/pixel

constexpr Index_t FiveQuadPts = {5}

constant for 5 quadrature point/pixel

constexpr Index_t SixQuadPts = {6}

constant for 6 quadrature point/pixel

constexpr Index_t EightQuadPts = {8}

constant for 8 quadrature point/pixel

constexpr Index_t OneNode = {1}

constant for 1 node per pixel

const std::string PixelTag = {"pixel"}

this tag is always defined to one in every field collection

constexpr Real pi = {3.1415926535897932384626433}

convenience definitions

static constexpr Dim_t Unknown = {-1}

constant used to explicitly denote unknown positive integers

namespace CcoordOps

Functions

Dim_t get_index(const DynCcoord_t &nb_grid_pts, const DynCcoord_t &locations, const DynCcoord_t &ccoord)

get the linear index of a pixel in a column-major grid

Real compute_pixel_volume(const DynCcoord_t &nb_grid_pts, const DynRcoord_t &lenghts)

size_t get_buffer_size(const DynCcoord_t &nb_grid_pts, const DynCcoord_t &strides)

get the buffer size required to store a grid given its strides

size_t get_buffer_size(const Shape_t &nb_grid_pts, const Shape_t &strides)

get the buffer size required to store a grid given its strides

template<typename T>
inline T modulo(const T &a, const T &b)

modulo operator that can handle negative values

template<size_t Dim, typename T>
constexpr std::array<T, Dim> get_cube(T nb_grid_pts)

returns a grid of equal number of grid points in each direction

template<size_t MaxDim = threeD>
DynCcoord<MaxDim> get_cube(const Dim_t &dim, const Index_t &nb_grid_pts)

returns a grid of equal number of grid points in each direction

template<size_t Dim>
Eigen::Matrix<Real, Dim, 1> get_vector(const Ccoord_t<Dim> &ccoord, Real pix_size = 1.)

return physical vector of a cell of cubic pixels

template<size_t Dim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const Ccoord_t<Dim> &ccoord, Eigen::Matrix<T, Dim_t(Dim), 1> pix_size)

return physical vector of a cell of general pixels

template<size_t Dim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const Ccoord_t<Dim> &ccoord, const std::array<T, Dim> &pix_size)

return physical vector of a cell of general pixels

template<size_t Dim, size_t MaxDim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const Ccoord_t<Dim> &ccoord, const DynCcoord<MaxDim, T> &pix_size)

return physical vector of a cell of general pixels

template<size_t Dim>
Eigen::Matrix<Real, Dim, 1> get_vector(const DynCcoord_t &ccoord, Real pix_size = 1.)

return physical vector of a cell of cubic pixels

template<size_t Dim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const DynCcoord_t ccoord, Eigen::Matrix<T, Dim_t(Dim), 1> pix_size)

return physical vector of a cell of general pixels

template<size_t Dim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const DynCcoord_t ccoord, const std::array<T, Dim> &pix_size)

return physical vector of a cell of general pixels

template<size_t Dim, size_t MaxDim, typename T>
Eigen::Matrix<T, Dim, 1> get_vector(const DynCcoord_t ccoord, const DynCcoord<MaxDim, T> &pix_size)

return physical vector of a cell of general pixels

template<size_t Dim>
constexpr Ccoord_t<Dim> get_col_major_strides(const Ccoord_t<Dim> &nb_grid_pts)

get all strides from a column-major grid

template<size_t MaxDim>
constexpr DynCcoord<MaxDim> get_col_major_strides(const DynCcoord<MaxDim> &nb_grid_pts)

get all strides from a column-major grid

template<size_t Dim>
constexpr Ccoord_t<Dim> get_row_major_strides(const Ccoord_t<Dim> &nb_grid_pts)

get all strides from a row-major grid

template<size_t MaxDim>
constexpr DynCcoord<MaxDim> get_row_major_strides(const DynCcoord<MaxDim> &nb_grid_pts)

get all strides from a row-major grid

template<size_t Dim>
constexpr Ccoord_t<Dim> get_ccoord(const Ccoord_t<Dim> &nb_grid_pts, const Ccoord_t<Dim> &locations, Index_t index)

get the i-th pixel in a grid of size nb_grid_pts

template<size_t Dim, size_t... I>
constexpr Ccoord_t<Dim> get_ccoord(const Ccoord_t<Dim> &nb_grid_pts, const Ccoord_t<Dim> &locations, Index_t index, std::index_sequence<I...>)

get the i-th pixel in a grid of size nb_grid_pts

template<size_t... I>
constexpr Ccoord_t<1> get_ccoord(const Ccoord_t<1> &nb_grid_pts, const Ccoord_t<1> &locations, Index_t index, std::index_sequence<I...>)

get the i-th pixel in a grid of size nb_grid_pts - specialization for one dimension

template<class T>
T compute_axes_order(const T &shape, const T &strides)

compute the order of the axes given strides, fastest first

template<size_t dim>
Ccoord_t<dim> compute_axes_order(const Ccoord_t<dim> &shape, const Ccoord_t<dim> &strides)

compute the order of the axes given strides, fastest first

template<size_t dim>
Ccoord_t<dim> get_ccoord_from_axes_order(const Ccoord_t<dim> &nb_grid_pts, const Ccoord_t<dim> &locations, const Ccoord_t<dim> &strides, const Ccoord_t<dim> &axes_order, Index_t index)

get the i-th pixel in a grid of size nb_grid_pts, with axes order

template<size_t dim>
Ccoord_t<dim> get_ccoord_from_strides(const Ccoord_t<dim> &nb_grid_pts, const Ccoord_t<dim> &locations, const Ccoord_t<dim> &strides, Index_t index)

get the i-th pixel in a grid of size nb_grid_pts, with strides

template<class T>
T get_ccoord_from_axes_order(const T &nb_grid_pts, const T &locations, const T &strides, const T &axes_order, Index_t index)

get the i-th pixel in a grid of size nb_grid_pts, with axes order

template<class T>
T get_ccoord_from_strides(const T &nb_grid_pts, const T &locations, const T &strides, Index_t index)

get the i-th pixel in a grid of size nb_grid_pts, with strides

template<size_t Dim>
constexpr Dim_t get_index(const Ccoord_t<Dim> &nb_grid_pts, const Ccoord_t<Dim> &locations, const Ccoord_t<Dim> &ccoord)

get the linear index of a pixel in a column-major grid

template<size_t MaxDim, typename T>
T compute_volume(const DynCcoord<MaxDim, T> &lengths)

these functions can be used whenever it is necessary to calculate the volume of a cell or each pixels of the cell

template<typename T>
T compute_volume(const std::vector<T> &lengths)

these functions can be used whenever it is necessary to calculate the volume of a cell or each pixels of the cell

template<class T>
bool is_buffer_contiguous(const T &nb_grid_pts, const T &strides)

check whether strides represent a contiguous buffer

template<size_t Dim>
constexpr Index_t get_index_from_strides(const Ccoord_t<Dim> &strides, const Ccoord_t<Dim> &locations, const Ccoord_t<Dim> &ccoord)

get the linear index of a pixel given a set of strides

template<class T>
Index_t get_index_from_strides(const T &strides, const T &locations, const T &ccoord)

get the linear index of a pixel given a set of strides

template<size_t Dim>
constexpr size_t get_size(const Ccoord_t<Dim> &nb_grid_pts)

get the number of pixels in a grid

template<size_t MaxDim>
size_t get_size(const DynCcoord<MaxDim> &nb_grid_pts)

get the number of pixels in a grid

template<size_t dim>
constexpr size_t get_buffer_size(const Ccoord_t<dim> &nb_grid_pts, const Ccoord_t<dim> &strides)

get the buffer size required to store a grid given its strides

namespace internal

Functions

template<typename T>
constexpr T ret(T val, size_t)

simple helper returning the first argument and ignoring the second

template<Dim_t Dim, typename T, size_t... I>
constexpr std::array<T, Dim> cube_fun(T val, std::index_sequence<I...>)

helper to build cubes

template<Dim_t Dim, size_t... I>
constexpr Ccoord_t<Dim> herm(const Ccoord_t<Dim> &nb_grid_pts, std::index_sequence<I...>)

computes hermitian size according to FFTW

template<Dim_t Dim>
constexpr Index_t col_major_stride(const Ccoord_t<Dim> &nb_grid_pts, const size_t index)

compute the stride in a direction of a column-major grid

template<Dim_t Dim>
constexpr Index_t row_major_stride(const Ccoord_t<Dim> &nb_grid_pts, const size_t index)

compute the stride in a direction of a row-major grid

template<Dim_t Dim, size_t... I>
constexpr Ccoord_t<Dim> compute_col_major_strides(const Ccoord_t<Dim> &nb_grid_pts, std::index_sequence<I...>)

get all strides from a column-major grid (helper function)

template<Dim_t Dim, size_t... I>
constexpr Ccoord_t<Dim> compute_row_major_strides(const Ccoord_t<Dim> &nb_grid_pts, std::index_sequence<I...>)

get all strides from a row-major grid (helper function)

namespace EigenCheck

namespace internal

Functions

template<Dim_t Dim, Dim_t NbRow, Dim_t NbCol>
inline constexpr Dim_t get_rank()

determine the rank of a Dim-dimensional tensor represented by an Eigen::Matrix of shape NbRow × NbCol

Template Parameters:

• Dim – spatial dimension

• NbRow – number of rows

• NbCol – number of columns

namespace internal

Typedefs

template<typename T, Dim_t NbRow, Dim_t NbCol>
using MatrixMap = EigenMap<T, Eigen::Matrix<T, NbRow, NbCol>>

internal convenience alias for creating maps iterating over statically sized Eigen::Matrixs

template<typename T, Dim_t Rank, Dim_t Dim>
using TensorMap = EigenMap<T, Eigen::Matrix<T, TensorRows(Rank, Dim), TensorCols(Rank, Dim)>>

internal convenience alias for creating maps iterating over statically sized tensors

template<typename T, Dim_t NbRow, Dim_t NbCol>
using ArrayMap = EigenMap<T, Eigen::Array<T, NbRow, NbCol>>

internal convenience alias for creating maps iterating over statically sized Eigen::Arrays

Functions

constexpr Dim_t TensorRows(Dim_t rank, Dim_t dim)

returns number of rows a dim-dimensional tensor of rank rank has in matrix representation

constexpr Dim_t TensorCols(Dim_t rank, Dim_t dim)

returns number of columns a dim-dimensional tensor of rank rank has in matrix representation

template<typename T, int flags = py::array::forcecast>
inline std::tuple<StorageOrder, DynCcoord_t, Shape_t> detect_storage_order(const DynCcoord_t &nb_subdomain_grid_pts, const Shape_t &components_shape, Index_t nb_sub_pts, py::array_t<T, flags> &array)

convert strides into the storage order description used by muGrid

namespace log_comp

Typedefs

template<Dim_t dim>
using Mat_t = Eigen::Matrix<Real, dim, dim>

Matrix type used for logarithm evaluation.

template<Dim_t dim>
using Vec_t = Eigen::Matrix<Real, dim, 1>

Vector type used for logarithm evaluation.

Functions

template<Dim_t I, class DerivedVec, class DerivedMat>
inline decltype(auto) P(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

Product term.

template<class DerivedVec, class DerivedMat>
inline decltype(auto) Sum(const Eigen::MatrixBase<DerivedVec> &eigs, const Eigen::MatrixBase<DerivedMat> &T)

sum implementation

namespace Matrices

Typedefs

template<Dim_t dim>
using Tens2_t = Eigen::Matrix<Real, dim, dim>

second-order tensor representation

template<Dim_t dim>
using Tens4_t = T4Mat<Real, dim>

fourth-order tensor representation

Functions

template<Dim_t dim>
inline constexpr Tens2_t<dim> I2()

compile-time second-order identity

template<typename T1, typename T2>
inline constexpr decltype(auto) outer(const Eigen::MatrixBase<T1> &A, const Eigen::MatrixBase<T2> &B)

compile-time outer tensor product as defined by Curnier R_ijkl = A_ij.B_klxx 0123 01 23

template<typename Derived1, typename Derived2>
inline constexpr decltype(auto) outer_under(const Eigen::MatrixBase<Derived1> &A, const Eigen::MatrixBase<Derived2> &B)

compile-time underlined outer tensor product as defined by Curnier R_ijkl = A_ik.B_jlxx 0123 02 13 0213 01 23 <- this defines the shuffle order

template<typename T1, typename T2>
inline constexpr decltype(auto) outer_over(const Eigen::MatrixBase<T1> &A, const Eigen::MatrixBase<T2> &B)

compile-time overlined outer tensor product as defined by Curnier R_ijkl = A_il.B_jkxx 0123 03 12 0231 01 23 <- this defines the shuffle order

template<typename TLarge, typename TSmall>
inline constexpr decltype(auto) tensmult(const Eigen::MatrixBase<TLarge> &A, const Eigen::MatrixBase<TSmall> &B)

Standard tensor multiplication

template<Dim_t dim>
inline constexpr Tens4_t<dim> Itrac()

compile-time fourth-order tracer

template<Dim_t dim>
inline constexpr Tens4_t<dim> Iiden()

compile-time fourth-order identity

template<Dim_t dim>
inline constexpr Tens4_t<dim> Itrns()

compile-time fourth-order transposer

template<Dim_t dim>
inline constexpr Tens4_t<dim> Isymm()

compile-time fourth-order symmetriser

template<Dim_t dim>
inline constexpr Tens4_t<dim> Iasymm()

compile-time fourth-order asymmetriser

template<Dim_t Dim, class T1, class T2>
decltype(auto) dot(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &t2)

simple contraction between two tensors. The result depends on the rank of the tesnors, see documentation for muGrid::internal::Dotter

template<Dim_t Dim, class T1, class T2>
decltype(auto) ddot(const Eigen::MatrixBase<T1> &t1, const Eigen::MatrixBase<T2> &t2)

double contraction between two tensors. The result depends on the rank of the tesnors, see documentation for muGrid::internal::Dotter

namespace AxisTransform

Functions

template<class T_in, class T2>
static inline decltype(auto) push_forward(const Eigen::MatrixBase<T_in> &t, const Eigen::MatrixBase<T2> &F)

template<class T_in, class T2>
static inline decltype(auto) pull_back(const Eigen::MatrixBase<T_in> &t, const Eigen::MatrixBase<T2> &F)

namespace internal

namespace raw_mem_ops

Functions

inline size_t prod(const Shape_t &vec)

inline size_t linear_index(const Shape_t &index, const Shape_t &strides)

template<typename T>
void strided_copy(const Shape_t &logical_shape, const Shape_t &input_strides, const Shape_t &output_strides, const T *input_data, T *output_data)

namespace Tensors

Typedefs

template<Dim_t dim>
using Tens2_t = Eigen::TensorFixedSize<Real, Eigen::Sizes<dim, dim>>

second-order tensor representation

template<Dim_t dim>
using Tens4_t = Eigen::TensorFixedSize<Real, Eigen::Sizes<dim, dim, dim, dim>>

fourth-order tensor representation

Functions

template<Dim_t dim>
inline constexpr Tens2_t<dim> I2()

compile-time second-order identity

template<Dim_t dim, typename T1, typename T2>
inline constexpr decltype(auto) outer(T1 &&A, T2 &&B)

compile-time outer tensor product as defined by Curnier R_ijkl = A_ij.B_klxx 0123 01 23

template<Dim_t dim, typename T1, typename T2>
inline constexpr decltype(auto) outer_under(T1 &&A, T2 &&B)

compile-time underlined outer tensor product as defined by Curnier R_ijkl = A_ik.B_jlxx 0123 02 13 0213 01 23 <- this defines the shuffle order

template<Dim_t dim, typename T1, typename T2>
inline constexpr decltype(auto) outer_over(T1 &&A, T2 &&B)

compile-time overlined outer tensor product as defined by Curnier R_ijkl = A_il.B_jkxx 0123 03 12 0231 01 23 <- this defines the shuffle order

template<Dim_t dim>
inline constexpr Tens4_t<dim> I4S()

compile-time fourth-order symmetrising identity

namespace version

Functions

std::string info()

Returns a formatted text that can be printed to stdout or to output files.

This function generates a string that contains the git commit hash and repository url used to compile µGrid. It also indicates whether the current state was dirty or not.

Returns:

A formatted string containing the git commit hash, repository url and the state of the repository.

const char *hash()

Returns the git commit hash.

This function retrieves the git commit hash used to compile µGrid.

Returns:

A constant character pointer representing the git commit hash.

const char *description()

Returns the repository description.

This function retrieves the repository description used to compile µGrid.

Returns:

A constant character pointer representing the repository description.

bool is_dirty()

Checks if the current state was dirty.

This function checks if the current state of the repository used to compile µGrid was dirty or not.

Returns:

A boolean value indicating if the state was dirty (true) or not (false).

namespace std

namespace std_replacement

Functions

template<class F, class ...ArgTypes>
auto invoke(F &&f, ArgTypes&&... args) noexcept(noexcept(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...))) -> decltype(detail::INVOKE(std::forward<F>(f), std::forward<ArgTypes>(args)...))

from cppreference

template<class F, class Tuple>
constexpr decltype(auto) apply(F &&f, Tuple &&t)

from cppreference

namespace detail

Functions

template<class Base, class T, class Derived, class ...Args>
auto INVOKE(T Base::* pmf, Derived &&ref, Args&&... args) noexcept(noexcept((std::forward<Derived>(ref) .* pmf)(std::forward<Args>(args)...))) -> std::enable_if_t<std::is_function<T>::value && std::is_base_of<Base, std::decay_t<Derived>>::value, decltype((std::forward<Derived>(ref) .* pmf)(std::forward<Args>(args)...))>

from cppreference

template<class Base, class T, class RefWrap, class ...Args>
auto INVOKE(T Base::* pmf, RefWrap &&ref, Args&&... args) noexcept(noexcept((ref.get() .* pmf)(std::forward<Args>(args)...))) -> std::enable_if_t<std::is_function<T>::value && is_reference_wrapper<std::decay_t<RefWrap>>::value, decltype((ref.get() .* pmf)(std::forward<Args>(args)...))>

from cppreference

template<class Base, class T, class Pointer, class ...Args>
auto INVOKE(T Base::* pmf, Pointer &&ptr, Args&&... args) noexcept(noexcept(((*std::forward<Pointer>(ptr)) .* pmf)(std::forward<Args>(args)...))) -> std::enable_if_t<std::is_function<T>::value && !is_reference_wrapper<std::decay_t<Pointer>>::value && !std::is_base_of<Base, std::decay_t<Pointer>>::value, decltype(((*std::forward<Pointer>(ptr)) .* pmf)(std::forward<Args>(args)...))>

from cppreference

template<class Base, class T, class Derived>
auto INVOKE(T Base::* pmd, Derived &&ref) noexcept(noexcept(std::forward<Derived>(ref) .* pmd)) -> std::enable_if_t<!std::is_function<T>::value && std::is_base_of<Base, std::decay_t<Derived>>::value, decltype(std::forward<Derived>(ref) .* pmd)>

from cppreference

template<class Base, class T, class RefWrap>
auto INVOKE(T Base::* pmd, RefWrap &&ref) noexcept(noexcept(ref.get() .* pmd)) -> std::enable_if_t<!std::is_function<T>::value && is_reference_wrapper<std::decay_t<RefWrap>>::value, decltype(ref.get() .* pmd)>

from cppreference

template<class Base, class T, class Pointer>
auto INVOKE(T Base::* pmd, Pointer &&ptr) noexcept(noexcept((*std::forward<Pointer>(ptr)) .* pmd)) -> std::enable_if_t<!std::is_function<T>::value && !is_reference_wrapper<std::decay_t<Pointer>>::value && !std::is_base_of<Base, std::decay_t<Pointer>>::value, decltype((*std::forward<Pointer>(ptr)) .* pmd)>

from cppreference

template<class F, class ...Args>
auto INVOKE(F &&f, Args&&... args) noexcept(noexcept(std::forward<F>(f)(std::forward<Args>(args)...))) -> std::enable_if_t<!std::is_member_pointer<std::decay_t<F>>::value, decltype(std::forward<F>(f)(std::forward<Args>(args)...))>

from cppreference

template<class F, class Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F &&f, Tuple &&t, std::index_sequence<I...>)

from cppreference

file cartesian_communicator.cc

#include “grid_common.hh”

#include “communicator.hh”

#include “cartesian_communicator.hh”

file cartesian_communicator.hh

#include “grid_common.hh”

#include “communicator.hh”

file cartesian_decomposition.cc

#include <iterator>

#include “grid_common.hh”

#include “field.hh”

#include “field_collection_global.hh”

#include “cartesian_communicator.hh”

#include “cartesian_decomposition.hh”

file cartesian_decomposition.hh

#include “grid_common.hh”

#include “field_collection_global.hh”

#include “communicator.hh”

#include “cartesian_communicator.hh”

#include “decomposition.hh”

file ccoord_operations.cc

#include <iostream>

#include “exception.hh”

#include “ccoord_operations.hh”

pre-compilable pixel operations

Author

Till Junge till.junge@epfl.ch

Date

01 Oct 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file ccoord_operations.hh

#include <functional>

#include <numeric>

#include <utility>

#include “Eigen/Dense”

#include “exception.hh”

#include “grid_common.hh”

#include “iterators.hh”

common operations on pixel addressing

Author

Till Junge till.junge@epfl.ch

Date

29 Sep 2017

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file communicator.cc

#include “communicator.hh”

implementation for mpi abstraction layer

Author

Till Junge till.junge@epfl.ch

Date

02 Oct 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file communicator.hh

#include <type_traits>

#include “Eigen/Dense”

#include “grid_common.hh”

abstraction layer for the distributed memory communicator object

Author

Lars Pastewka lars.pastewka@imtek.uni-freiburg.de

Date

07 Mar 2018

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file convolution_operator.cc

#include “convolution_operator.hh”

#include “grid_common.hh”

#include “field_collection_global.hh”

#include “field_map.hh”

#include “ccoord_operations.hh”

#include “iterators.hh”

#include “exception.hh”

#include <sstream>

file convolution_operator.hh

#include “convolution_operator_base.hh”

#include “Eigen/Dense”

#include <vector>

file convolution_operator_base.hh

#include “grid_common.hh”

#include “field_typed.hh”

file cpp_compliance.hh

#include <tuple>

#include <experimental/optional>

additions to the standard name space to anticipate C++17 features

Author

Till Junge till.junge@epfl.ch

Date

17 Nov 2017

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file decomposition.hh

#include “grid_common.hh”

#include “field_collection_global.hh”

#include “communicator.hh”

file eigen_tools.hh

#include “grid_common.hh”

#include “Eigen/Dense”

#include “unsupported/Eigen/CXX11/Tensor”

#include <type_traits>

#include <utility>

small tools to be used with Eigen

Author

Till Junge till.junge@epfl.ch

Date

20 Sep 2017

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file exception.cc

#include <cxxabi.h>

#include <dlfcn.h>

#include <execinfo.h>

#include “exception.hh”

exception class for libmuGrid that collect a stack trace

Author

Lars Pastewka lars.pastewka@imtek.uni-freiburg.de

Date

04 Feb 2020

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

Variables

const int MAX_DEPTH = 256

file exception.hh

#include <iostream>

#include <sstream>

#include <string>

#include <vector>

exception class for libmuGrid that collect a stack trace

Author

Lars Pastewka lars.pastewka@imtek.uni-freiburg.de

Date

04 Feb 2020

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field.cc

#include “field.hh”

#include “field_collection.hh”

#include “field_collection_global.hh”

implementation of Field

Author

Till Junge till.junge@altermail.ch

Date

11 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field.hh

#include “exception.hh”

#include “grid_common.hh”

#include “units.hh”

#include <string>

#include <typeinfo>

Base class for fields.

Author

Till Junge till.junge@altermail.ch

Date

10 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection.cc

#include “field_collection.hh”

#include “field.hh”

#include “state_field.hh”

#include “field_typed.hh”

Implementations for field collections.

Author

Till Junge till.junge@altermail.ch

Date

11 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection.hh

#include “exception.hh”

#include “grid_common.hh”

#include “units.hh”

#include <map>

#include <string>

#include <memory>

#include <sstream>

#include <stdexcept>

#include <vector>

Base class for field collections.

Author

Till Junge till.junge@altermail.ch

Date

10 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection_global.cc

#include “field_collection_global.hh”

Implementation of GlobalFieldCollection.

Author

Till Junge till.junge@altermail.ch

Date

11 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection_global.hh

#include “field_collection.hh”

#include “ccoord_operations.hh”

Global field collections.

Author

Till Junge till.junge@altermail.ch

Date

11 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection_local.cc

#include “field_collection_local.hh”

implementation of local field collection

Author

Till Junge till.junge@epfl.ch

Date

12 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_collection_local.hh

#include “field_collection.hh”

#include “field_collection_global.hh”

Local field collection.

Author

Till Junge till.junge@epfl.ch

Date

12 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_map.cc

#include “field_map.hh”

#include “field_typed.hh”

#include “field_collection.hh”

#include “iterators.hh”

#include <sstream>

#include <iostream>

Implementation for basic FieldMap.

Author

Till Junge till.junge@epfl.ch

Date

15 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_map.hh

#include “grid_common.hh”

#include “iterators.hh”

#include “field_collection.hh”

#include <type_traits>

#include <memory>

#include <functional>

Implementation of the base class of all field maps.

Author

Till Junge till.junge@epfl.ch

Date

15 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_map_static.hh

#include “field.hh”

#include “field_typed.hh”

#include “field_map.hh”

#include “T4_map_proxy.hh”

#include <sstream>

header-only implementation of field maps with statically known iterate sizes

Author

Till Junge till.junge@epfl.ch

Date

20 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_typed.cc

#include <sstream>

#include “ccoord_operations.hh”

#include “field_typed.hh”

#include “field_collection.hh”

#include “field_map.hh”

#include “raw_memory_operations.hh”

#include “tensor_algebra.hh”

Implementation for typed fields.

Author

Till Junge till.junge@epfl.ch

Date

13 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file field_typed.hh

#include “field.hh”

#include “field_collection.hh”

#include “grid_common.hh”

#include “Eigen/Dense”

#include <vector>

#include <memory>

Field classes for which the scalar type has been defined.

Author

Till Junge till.junge@altermail.ch

Date

10 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file file_io_base.cc

#include “file_io_base.hh”

Interface for parallel I/O of grid data.

Author

Richard Leute richard.leute@imtek.uni-freiburg.de

Date

20 Mai 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file file_io_base.hh

#include “communicator.hh”

#include “field_collection.hh”

#include “field_collection_global.hh”

#include “field_collection_local.hh”

#include <vector>

#include <string>

#include <iostream>

Interface for parallel I/O of grid data.

Author

Lars Pastewka lars.pastewka@imtek.uni-freiburg.de Richard Leute richard.leute@imtek.uni-freiburg.de

Date

17 May 2020

Copyright © 2020 Richard Leute, Lars Pastewka, Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

Typedefs

using Size_t = size_t

file file_io_netcdf.cc

#include “exception.hh”

#include “iterators.hh”

#include “units.hh”

#include “file_io_netcdf.hh”

Using the FileIOBase class to implement a serial and parallel I/O interface for NetCDF files.

Author

Richard Leute richard.leute@imtek.uni-freiburg.de

Date

25 Mai 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file file_io_netcdf.hh

#include <string>

#include <memory>

#include <typeinfo>

#include <type_traits>

#include <iomanip>

#include “communicator.hh”

#include “grid_common.hh”

#include “field.hh”

#include “state_field.hh”

#include “field_collection.hh”

#include “field_map_static.hh”

#include “file_io_base.hh”

#include <netcdf.h>

Using the FileIOBase class to implement a serial and parallel I/O interface for NetCDF files.

Author

Richard Leute richard.leute@imtek.uni-freiburg.de

Date

25 Mai 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

Typedefs

using Datatype_t = nc_type

using IOSize_t = size_t

using IODiff_t = ptrdiff_t

Variables

const auto ncmu_create = nc_create

const auto ncmu_open = nc_open

const auto ncmu_enddef = nc_enddef

const auto ncmu_redef = nc_redef

const auto ncmu_close = nc_close

const auto ncmu_strerror = nc_strerror

const auto ncmu_def_dim = nc_def_dim

const auto ncmu_def_var = nc_def_var

const auto ncmu_inq = nc_inq

const auto ncmu_inq_varid = nc_inq_varid

const auto ncmu_inq_dimlen = nc_inq_dimlen

const auto ncmu_inq_dimid = nc_inq_dimid

const auto ncmu_inq_unlimdim = nc_inq_unlimdim

const auto ncmu_inq_attname = nc_inq_attname

const auto ncmu_inq_att = nc_inq_att

const auto ncmu_get_vara_all = nc_get_vara

const auto ncmu_get_varm_all = nc_get_varm

const auto ncmu_get_varm = nc_get_varm

const auto ncmu_get_varn_all = nc_get_vara

const auto ncmu_get_att = nc_get_att

const auto ncmu_put_vara_all = nc_put_vara

const auto ncmu_put_varm_all = nc_put_varm

const auto ncmu_put_varm = nc_put_varm

const auto ncmu_put_varn_all = nc_put_vara

const auto ncmu_put_att_text = nc_put_att_text

const auto ncmu_put_att = nc_put_att

const auto ncmu_rename_att = nc_rename_att

file gradient_operator.cc

#include “gradient_operator.hh”

#include “field_collection_global.hh”

#include “field_map.hh”

#include “ccoord_operations.hh”

#include “iterators.hh”

#include “exception.hh”

#include <sstream>

file gradient_operator.hh

#include “convolution_operator_base.hh”

#include “Eigen/Dense”

#include <vector>

file grid_common.cc

#include “grid_common.hh”

Implementation of grid utilities.

Author

Indre Joedicke indre.joedicke@imtek.uni-freiburg.de

Date

17 Feb 2020

LICENSE

Copyright © 2020 Indre Joedicke

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file grid_common.hh

#include “exception.hh”

#include “iterators.hh”

#include “Eigen/Dense”

#include <array>

#include <cmath>

#include <complex>

#include <type_traits>

#include <initializer_list>

#include <algorithm>

#include <vector>

#include <cstdint>

#include <numeric>

#include “cpp_compliance.hh”

Small definitions of commonly used types throughout µgrid.

Author

Till Junge till.junge@epfl.ch

Date

24 Jan 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file iterators.hh

#include <tuple>

#include <utility>

iterator interfaces

Author

Nicolas Richart

Date

creation Wed Jul 19 2017

Copyright (©) 2010-2011 EPFL (Ecole Polytechnique Fédérale de Lausanne) Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)

Akantu is free software: you can redistribute it and/or modify it under the terms of 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.

Akantu 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with Akantu. If not, see http://www.gnu.org/licenses/.

Above block was left intact as in akantu. µGrid exercises the right to redistribute and modify the code below

file mapped_field.hh

#include “field_map_static.hh”

#include “field_collection.hh”

#include “field_typed.hh”

#include <string>

convenience class to deal with data structures common to most internal variable fields in materials

Author

Till Junge till.junge@epfl.ch

Date

04 Sep 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file mapped_state_field.hh

#include “state_field_map_static.hh”

#include “state_field.hh”

#include “field_collection.hh”

Convenience class extending the mapped field concept to state fields.

Author

Till Junge till.junge@epfl.ch

Date

09 Sep 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file numpy_tools.hh

#include “field_typed.hh”

#include “field_collection_global.hh”

#include “raw_memory_operations.hh”

#include “pybind11/pybind11.h”

#include “pybind11/numpy.h”

#include <algorithm>

#include <limits>

Convenience functionality for working with (py::’s) numpy arrays. These are implemented header-only, in order to avoid an explicit dependency on py::

Author

Lars Pastewka lars.pastewka@imtek.uni-freiburg.de

Author

Till Junge till.junge@epfl.ch

Date

02 Dec 2019

Copyright © 2018 Lars Pastewka, Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file optional_mapped_field.hh

Simple structure for optional mapped fields with low runtime overhead. This is practical if some fields need be be stored depending on some solver arguments. The original use-case is a stress field for storing native stresses, which usually do not need to be stored, but are useful for visualisation and analysis of stress states.

Author

Till Junge till.junge@epfl.ch

Date

27 Jan 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file options_dictionary.cc

#include “options_dictionary.hh”

class mimicking the python dictionary

Author

Till Junge till.junge@altermail.ch

Date

24 Jun 2021

Copyright © 2021 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file options_dictionary.hh

#include “grid_common.hh”

#include “Eigen/Dense”

#include <map>

#include <string>

#include <memory>

class mimicking the python dictionary

Author

Till Junge till.junge@altermail.ch

Date

24 Jun 2021

Copyright © 2021 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file physics_domain.cc

#include “physics_domain.hh”

#include <sstream>

Implementation of PhysicsDomain member functions.

Author

Till Junge till.junge@altermail.ch

Date

03 Jun 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file physics_domain.hh

#include “grid_common.hh”

#include “units.hh”

#include <iostream>

#include <tuple>

Helper class to identify and separate physics domains based on the rank and physical units of the input and output fields of constitutive models. I.e., a mechanics domain problem is rank 2 (strain, stress) with units pressure, and unitless.

Author

Till Junge till.junge@altermail.ch

Date

03 Jun 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file raw_memory_operations.cc

#include <algorithm>

#include “ccoord_operations.hh”

#include “raw_memory_operations.hh”

implementation of functions for unsafe raw memory operations. Use these only when necessary

Author

Till Junge till.junge@altermail.ch

Date

29 May 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file raw_memory_operations.hh

#include “grid_common.hh”

#include “exception.hh”

#include <cstring>

#include <numeric>

#include <vector>

functions for unsafe raw memory operations. Use these only when necessary

Author

Till Junge till.junge@altermail.ch

Date

29 May 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file ref_array.hh

#include <array>

#include <initializer_list>

#include “iterators.hh”

convenience class to simulate an array of references

Author

Till Junge till.junge@epfl.ch

Date

04 Dec 2018

Copyright © 2018 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file ref_vector.hh

#include <vector>

convenience class providing a vector of references

Author

Till Junge till.junge@epfl.ch

Date

21 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file state_field.cc

#include “state_field.hh”

#include “field.hh”

#include “field_typed.hh”

#include “field_collection.hh”

#include <sstream>

implementation for state fields

Author

Till Junge till.junge@altermail.ch

Date

20 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file state_field.hh

#include “grid_common.hh”

#include “ref_vector.hh”

#include “state_field_map.hh”

#include <string>

#include <vector>

#include <utility>

A state field is an abstraction of a field that can hold current, as well as a chosen number of previous values. This is useful for instance for internal state variables in plastic laws, where a current, new, or trial state is computed based on its previous state, and at convergence, this new state gets cycled into the old, the old into the old-1 etc. The state field abstraction helps doing this safely (i.e. only const references to the old states are available, while the current state can be assigned to/modified), and efficiently (i.e., no need to copy values from new to old, we just cycle the labels). This file implements the state field as well as state maps using the Field, FieldCollection and FieldMap abstractions of µGrid.

Author

Till Junge till.junge@altermail.ch

Date

20 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file state_field_map.cc

#include “state_field_map.hh”

#include “state_field.hh”

#include “field_map.hh”

#include “field_typed.hh”

#include “field_collection.hh”

#include “field.hh”

implementation of state field maps

Author

Till Junge till.junge@epfl.ch

Date

22 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file state_field_map.hh

#include “grid_common.hh”

#include “field_map.hh”

#include “ref_vector.hh”

#include <vector>

#include <memory>

implementation of state field maps

Author

Till Junge till.junge@epfl.ch

Date

22 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file state_field_map_static.hh

#include “state_field_map.hh”

#include “field_map_static.hh”

#include “field_typed.hh”

#include <array>

#include <sstream>

#include <utility>

header-only implementation of state field maps with statically known iterate sizes

Author

Till Junge till.junge@epfl.ch

Date

27 Aug 2019

Copyright © 2019 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file T4_map_proxy.hh

#include “eigen_tools.hh”

#include “Eigen/Dense”

#include “Eigen/src/Core/util/Constants.h”

#include <type_traits>

Map type to allow fourth-order tensor-like maps on 2D matrices.

Author

Till Junge till.junge@altermail.ch

Date

19 Nov 2017

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file tensor_algebra.hh

#include “grid_common.hh”

#include “T4_map_proxy.hh”

#include “eigen_tools.hh”

#include “Eigen/Dense”

#include “unsupported/Eigen/CXX11/Tensor”

#include <type_traits>

collection of compile-time quantities and algrebraic functions for tensor operations

Author

Till Junge till.junge@epfl.ch

Date

05 Nov 2017

Copyright © 2017 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

• Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file units.cc

#include “units.hh”

#include “iterators.hh”

#include <algorithm>

#include <sstream>

#include <cmath>

dynamic units class based on mass, length, time (could be interpreted as kg, m, s according to the SI). Useful to avoid bugs due to multiphisics mixing of domains.

Author

Till Junge till.junge@altermail.ch

Date

23 Apr 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

file units.hh

#include “grid_common.hh”

#include “exception.hh”

#include <array>

#include <iostream>

dynamic units class based on mass, length, time (could be interpreted as kg, m, s according to the SI). Useful to avoid bugs due to multiphisics mixing of domains.

Author

Till Junge till.junge@altermail.ch

Date

23 Apr 2020

Copyright © 2020 Till Junge

µGrid is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3, or (at your option) any later version.

µGrid 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with µGrid; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

Additional permission under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or combining it with proprietary FFT implementations or numerical libraries, containing parts covered by the terms of those libraries’ licenses, the licensors of this Program grant you additional permission to convey the resulting work.

group Scalar types

Typedefs

typedef int Dim_t

A type alias for signed integers used for static dimensions.

This type alias is used to represent signed integers for static dimensions in the µGrid codebase. It is used for consistency throughout the code. It is also capable of representing -1, which is a requirement for Eigen.

typedef Eigen::Index Index_t

A type alias for Eigen::Index used for size-related values.

This type alias is used to represent size-related values in the µGrid codebase. It is used for consistency with Eigen and to handle large arrays that have more indices than can be counted with Dim_t. For example, arrays with dimensions 65536 × 65536 would overflow Dim_t, so Index_t is used instead.

using Uint = unsigned int

type to use in math for unsigned integers

using Int = int

type to use in math for signed integers

using Real = double

type to use in math for real numbers

using Complex = std::complex<Real>

type to use in math for complex numbers

group Coordinate types

Typedefs

typedef std::array<Index_t, Dim> Ccoord_t

A type alias for cell coordinates.

This type alias represents cell coordinates, which are up to three integer numbers with a fixed dimension. The dimension is determined by the template parameter Dim. The coordinates are stored in a std::array of type Index_t.

Template Parameters:

Dim – The dimension of the cell coordinates. It should be between 1 and 3.

typedef std::array<Real, Dim> Rcoord_t

A type alias for real space coordinates.

This type alias represents real space coordinates, which are up to three floating point numbers with a fixed dimension. The dimension is determined by the template parameter Dim. The coordinates are stored in a std::array of type Real.

Template Parameters:

Dim – The dimension of the real space coordinates. It should be between 1 and 3.

dir /home/runner/work/muGrid/muGrid/src/libmugrid

dir /home/runner/work/muGrid/muGrid/src