field_map_matrixlike.hh
27287cdad1b6master

field_map_matrixlike.hh
View Options

			/**
			* @file field_map_matrixlike.hh
			*
			* @author Till Junge <till.junge@epfl.ch>
			*
			* @date 26 Sep 2017
			*
			* @brief Eigen-Matrix and -Array maps over strongly typed fields
			*
			* 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
			* 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.
			*/

			#ifndef SRC_LIBMUGRID_FIELD_MAP_MATRIXLIKE_HH_
			#define SRC_LIBMUGRID_FIELD_MAP_MATRIXLIKE_HH_

			#include "T4_map_proxy.hh"
			#include "field_map_base.hh"

			#include <Eigen/Dense>

			#include <memory>

			namespace muGrid {

			namespace internal {

			/* ---------------------------------------------------------------------- */
			/**
			* lists all matrix-like types consideres by
			* `muGrid::internal::MatrixLikeFieldMap`
			*/
			enum class Map_t {
			Matrix, //!< for wrapping `Eigen::Matrix`
			Array, //!< for wrapping `Eigen::Array`
			T4Matrix //!< for wrapping `Eigen::T4Matrix`
			};

			/**
			* traits structure to define the name shown when a
			* `muGrid::MatrixLikeFieldMap` output into an ostream
			*/
			template <Map_t map_type>
			struct NameWrapper {};

			/// specialisation for `muGrid::ArrayFieldMap`
			template <>
			struct NameWrapper<Map_t::Array> {
			//! string to use for printing
			static std::string field_info_root() { return "Array"; }
			};

			/// specialisation for `muGrid::MatrixFieldMap`
			template <>
			struct NameWrapper<Map_t::Matrix> {
			//! string to use for printing
			static std::string field_info_root() { return "Matrix"; }
			};

			/// specialisation for `muGrid::T4MatrixFieldMap`
			template <>
			struct NameWrapper<Map_t::T4Matrix> {
			//! string to use for printing
			static std::string field_info_root() { return "T4Matrix"; }
			};

			/* ---------------------------------------------------------------------- */
			/*!
			* A `MatrixLikeFieldMap` is the base class for maps of matrices, arrays and
			* fourth-order tensors mapped onto matrices.
			*
			* It should never be necessary to call directly any of the
			* constructors if this class, but rather use the template aliases:
			* - `muGrid::ArrayFieldMap`: iterate in the form of `Eigen::Array<...>`.
			* - `muGrid::MatrixFieldMap`: iterate in the form of
			* `Eigen::Matrix<...>`.
			* - `muGrid::T4MatrixFieldMap`: iterate in the form of
			* `muGrid::T4MatMap`.
			*/
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			class MatrixLikeFieldMap
			: public FieldMap<FieldCollection, typename EigenArray::Scalar,
			EigenArray::SizeAtCompileTime, ConstField> {
			public:
			//! base class
			using Parent = FieldMap<FieldCollection, typename EigenArray::Scalar,
			EigenArray::SizeAtCompileTime, ConstField>;
			//! sister class with all params equal, but ConstField guaranteed true
			using ConstMap =
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, true>;
			using T_t = EigenPlain; //!< plain Eigen type to map
			//! cell coordinates type
			using Ccoord = Ccoord_t<FieldCollection::spatial_dim()>;
			using value_type = EigenArray; //!< stl conformance
			using const_reference = EigenConstArray; //!< stl conformance
			//! stl conformance
			using reference =
			std::conditional_t<ConstField, const_reference,
			value_type>; // since it's a resource handle
			using size_type = typename Parent::size_type; //!< stl conformance
			using pointer = std::unique_ptr<EigenArray>; //!< stl conformance

			using Field = typename Parent::Field; //!< stl conformance
			using Field_c = typename Parent::Field_c; //!< stl conformance
			//! stl conformance
			using const_iterator =
			typename Parent::template iterator<MatrixLikeFieldMap, true>;
			//! stl conformance
			using iterator = std::conditional_t<
			ConstField, const_iterator,
			typename Parent::template iterator<MatrixLikeFieldMap>>;
			using reverse_iterator =
			std::reverse_iterator<iterator>; //!< stl conformance
			//! stl conformance
			using const_reverse_iterator = std::reverse_iterator<const_iterator>;
			//! enumerator over a constant scalar field
			using const_enumerator =
			typename Parent::template enumerator<const_iterator>;
			//! enumerator over a scalar field
			using enumerator =
			std::conditional_t<ConstField, const_enumerator,
			typename Parent::template enumerator<iterator>>;
			//! give access to the protected fields
			friend iterator;

			//! Default constructor
			MatrixLikeFieldMap() = delete;

			/**
			* Constructor using a (non-typed) field. Compatibility is enforced at
			* runtime. This should not be a performance concern, as this constructor
			* will not be called in anny inner loops (if used as intended).
			*/
			explicit MatrixLikeFieldMap(Field_c & field);

			/**
			* Constructor using a typed field. Compatibility is enforced
			* statically. It is not always possible to call this constructor, as the
			* type of the field might not be known at compile time.
			*/
			template <class FC, typename T2, Dim_t NbC>
			MatrixLikeFieldMap(TypedSizedFieldBase<FC, T2, NbC> & field) // NOLINT
			: Parent(field) {}

			//! Copy constructor
			MatrixLikeFieldMap(const MatrixLikeFieldMap & other) = delete;

			//! Move constructorxo
			MatrixLikeFieldMap(MatrixLikeFieldMap && other) = default;

			//! Destructor
			virtual ~MatrixLikeFieldMap() = default;

			//! Copy assignment operator
			MatrixLikeFieldMap & operator=(const MatrixLikeFieldMap & other) = delete;

			//! Move assignment operator
			MatrixLikeFieldMap & operator=(MatrixLikeFieldMap && other) = delete;

			//! Assign a matrixlike value to every entry
			template <class Derived>
			inline MatrixLikeFieldMap &
			operator=(const Eigen::EigenBase<Derived> & val);

			//! give human-readable field map type
			inline std::string info_string() const final;

			//! member access
			inline reference operator[](size_type index);
			//! member access
			inline reference operator[](const Ccoord & ccoord);

			//! member access
			inline const_reference operator[](size_type index) const;
			//! member access
			inline const_reference operator[](const Ccoord & ccoord) const;

			//! return an iterator to head of field for ranges
			inline iterator begin() { return std::move(iterator(*this)); }
			//! return an iterator to head of field for ranges
			inline const_iterator cbegin() const { return const_iterator(*this); }
			//! return an iterator to head of field for ranges
			inline const_iterator begin() const { return this->cbegin(); }
			//! return an iterator to tail of field for ranges
			inline iterator end() { return iterator(*this, false); }
			//! return an iterator to tail of field for ranges
			inline const_iterator cend() const {
			return const_iterator(*this, false);
			}
			//! return an iterator to tail of field for ranges
			inline const_iterator end() const { return this->cend(); }

			/**
			* return an iterable proxy to this field that can be iterated
			* in Ccoord-value tuples
			*/
			enumerator enumerate() { return enumerator(*this); }
			/**
			* return an iterable proxy to this field that can be iterated
			* in Ccoord-value tuples
			*/
			const_enumerator enumerate() const { return const_enumerator(*this); }

			//! evaluate the average of the field
			inline T_t mean() const;

			protected:
			//! for sad, legacy iterator use
			inline pointer ptr_to_val_t(size_type index);
			static const std::string field_info_root() {
			return NameWrapper<map_type>::field_info_root();
			} //!< for printing and debug
			private:
			};

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField>::MatrixLikeFieldMap(Field_c &
			field)
			: Parent(field) {
			this->check_compatibility();
			}

			/* ---------------------------------------------------------------------- */
			//! human-readable field map type
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			std::string
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField>::info_string() const {
			std::stringstream info;
			info << this->field_info_root() << "("
			<< typeid(typename EigenArray::value_type).name() << ", "
			<< EigenArray::RowsAtCompileTime << "x"
			<< EigenArray::ColsAtCompileTime << ")";
			return info.str();
			}

			/* ---------------------------------------------------------------------- */
			//! member access
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::reference
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::
			operator[](size_type index) {
			return reference(this->get_ptr_to_entry(index));
			}

			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::reference
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::
			operator[](const Ccoord & ccoord) {
			size_t && index{this->collection.get_index(ccoord)};
			return reference(this->get_ptr_to_entry(index));
			}

			/* ---------------------------------------------------------------------- */
			//! member access
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type,
			ConstField>::const_reference
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::
			operator[](size_type index) const {
			return const_reference(this->get_ptr_to_entry(index));
			}

			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type,
			ConstField>::const_reference
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::
			operator[](const Ccoord & ccoord) const {
			size_t && index{this->collection.get_index(ccoord)};
			return const_reference(this->get_ptr_to_entry(index));
			}

			//----------------------------------------------------------------------------//
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			template <class Derived>
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField> &
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField>::
			operator=(const Eigen::EigenBase<Derived> & val) {
			for (auto && entry : *this) {
			entry = val;
			}
			return *this;
			}

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::T_t
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField>::mean() const {
			T_t mean{T_t::Zero()};
			for (auto && val : *this) {
			mean += val;
			}
			mean *= 1. / Real(this->size());
			return mean;
			}

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection, class EigenArray, class EigenConstArray,
			class EigenPlain, Map_t map_type, bool ConstField>
			typename MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray,
			EigenPlain, map_type, ConstField>::pointer
			MatrixLikeFieldMap<FieldCollection, EigenArray, EigenConstArray, EigenPlain,
			map_type, ConstField>::ptr_to_val_t(size_type index) {
			return std::make_unique<value_type>(
			this->get_ptr_to_entry(std::move(index)));
			}

			} // namespace internal

			/* ---------------------------------------------------------------------- */
			//! short-hand for an Eigen matrix map as iterate
			template <class FieldCollection, typename T, Dim_t NbRows, Dim_t NbCols,
			bool ConstField = false>
			using MatrixFieldMap = internal::MatrixLikeFieldMap<
			FieldCollection, Eigen::Map<Eigen::Matrix<T, NbRows, NbCols>>,
			Eigen::Map<const Eigen::Matrix<T, NbRows, NbCols>>,
			Eigen::Matrix<T, NbRows, NbCols>, internal::Map_t::Matrix, ConstField>;

			/* ---------------------------------------------------------------------- */
			//! short-hand for an Eigen matrix map as iterate
			template <class FieldCollection, typename T, Dim_t Dim, bool MapConst = false>
			using T4MatrixFieldMap =
			internal::MatrixLikeFieldMap<FieldCollection, T4MatMap<T, Dim, false>,
			T4MatMap<T, Dim, true>, T4Mat<T, Dim>,
			internal::Map_t::T4Matrix, MapConst>;

			/* ---------------------------------------------------------------------- */
			//! short-hand for an Eigen array map as iterate
			template <class FieldCollection, typename T, Dim_t NbRows, Dim_t NbCols,
			bool ConstField = false>
			using ArrayFieldMap = internal::MatrixLikeFieldMap<
			FieldCollection, Eigen::Map<Eigen::Array<T, NbRows, NbCols>>,
			Eigen::Map<const Eigen::Array<T, NbRows, NbCols>>,
			Eigen::Array<T, NbRows, NbCols>, internal::Map_t::Array, ConstField>;

			} // namespace muGrid

			#endif // SRC_LIBMUGRID_FIELD_MAP_MATRIXLIKE_HH_

muSpectre/src/libmugrid/field_map_matrixlike.hh27287cdad1b6master

field_map_matrixlike.hhView Options

muSpectre/src/libmugrid/field_map_matrixlike.hh
27287cdad1b6master

field_map_matrixlike.hh
View Options