field_base.hh
6483fc77273amaster

field_base.hh
View Options

			/**
			* file field_base.hh
			*
			* @author Till Junge <till.junge@epfl.ch>
			*
			* @date 10 Apr 2018
			*
			* @brief Virtual base class for fields
			*
			* 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
			* 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_COMMON_FIELD_BASE_HH_
			#define SRC_COMMON_FIELD_BASE_HH_

			#include <stdexcept>
			#include <string>

			namespace muGrid {

			/* ---------------------------------------------------------------------- */
			/**
			* base class for field collection-related exceptions
			*/
			class FieldCollectionError : public std::runtime_error {
			public:
			//! constructor
			explicit FieldCollectionError(const std::string & what)
			: std::runtime_error(what) {}
			//! constructor
			explicit FieldCollectionError(const char * what)
			: std::runtime_error(what) {}
			};

			/// base class for field-related exceptions
			class FieldError : public FieldCollectionError {
			using Parent = FieldCollectionError;

			public:
			//! constructor
			explicit FieldError(const std::string & what) : Parent(what) {}
			//! constructor
			explicit FieldError(const char * what) : Parent(what) {}
			};

			/**
			* Thrown when a associating a field map to and incompatible field
			* is attempted
			*/
			class FieldInterpretationError : public FieldError {
			public:
			//! constructor
			explicit FieldInterpretationError(const std::string & what)
			: FieldError(what) {}
			//! constructor
			explicit FieldInterpretationError(const char * what) : FieldError(what) {}
			};

			namespace internal {

			/* ---------------------------------------------------------------------- */
			/**
			* Virtual base class for all fields. A field represents
			* meta-information for the per-pixel storage for a scalar, vector
			* or tensor quantity and is therefore the abstract class defining
			* the field. It is used for type and size checking at runtime and
			* for storage of polymorphic pointers to fully typed and sized
			* fields. `FieldBase` (and its children) are templated with a
			* specific `FieldCollection` (derived from
			* `muGrid::FieldCollectionBase`). A `FieldCollection` stores
			* multiple fields that all apply to the same set of
			* pixels. Addressing and managing the data for all pixels is
			* handled by the `FieldCollection`. Note that `FieldBase` does
			* not know anything about about mathematical operations on the
			* data or how to iterate over all pixels. Mapping the raw data
			* onto for instance Eigen maps and iterating over those is
			* handled by the `FieldMap`.
			*/
			template <class FieldCollection>
			class FieldBase {
			protected:
			//! constructor
			//! unique name (whithin Collection)
			//! number of components
			//! collection to which this field belongs (eg, material, cell)
			FieldBase(std::string unique_name, size_t nb_components,
			FieldCollection & collection);

			public:
			using collection_t = FieldCollection; //!< for type checks

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

			//! Move constructor
			FieldBase(FieldBase && other) = delete;

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

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

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

			/* ----------------------------------------------------------------------
			*/
			//! Identifying accessors
			//! return field name
			inline const std::string & get_name() const;
			//! return field type
			// inline const Field_t & get_type() const;
			//! return my collection (for iterating)
			inline const FieldCollection & get_collection() const;
			//! return number of components (e.g., dimensions) of this field
			inline const size_t & get_nb_components() const;
			//! return type_id of stored type
			virtual const std::type_info & get_stored_typeid() const = 0;

			//! number of pixels in the field
			virtual size_t size() const = 0;

			//! add a pad region to the end of the field buffer; required for
			//! using this as e.g. an FFT workspace
			virtual void set_pad_size(size_t pad_size_) = 0;

			//! pad region size
			virtual size_t get_pad_size() const { return this->pad_size; }

			//! initialise field to zero (do more complicated initialisations through
			//! fully typed maps)
			virtual void set_zero() = 0;

			//! give access to collections
			friend FieldCollection;
			//! give access to collection's base class
			using FParent_t = typename FieldCollection::Parent;
			friend FParent_t;

			protected:
			/* ----------------------------------------------------------------------
			*/
			//! allocate memory etc
			virtual void resize(size_t size) = 0;
			const std::string name; //!< the field's unique name
			const size_t nb_components; //!< number of components per entry
			//! reference to the collection this field belongs to
			FieldCollection & collection;
			size_t pad_size; //!< size of padding region at end of buffer
			};

			/* ---------------------------------------------------------------------- */
			// Implementations
			/* ---------------------------------------------------------------------- */
			template <class FieldCollection>
			FieldBase<FieldCollection>::FieldBase(std::string unique_name,
			size_t nb_components_,
			FieldCollection & collection_)
			: name(unique_name), nb_components(nb_components_),
			collection(collection_), pad_size{0} {}

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection>
			inline const std::string & FieldBase<FieldCollection>::get_name() const {
			return this->name;
			}

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection>
			inline const FieldCollection &
			FieldBase<FieldCollection>::get_collection() const {
			return this->collection;
			}

			/* ---------------------------------------------------------------------- */
			template <class FieldCollection>
			inline const size_t &
			FieldBase<FieldCollection>::get_nb_components() const {
			return this->nb_components;
			}

			} // namespace internal

			} // namespace muGrid

			#endif // SRC_COMMON_FIELD_BASE_HH_

muSpectre/src/libmugrid/field_base.hh6483fc77273amaster

field_base.hhView Options

muSpectre/src/libmugrid/field_base.hh
6483fc77273amaster

field_base.hh
View Options