Datasets:

introvoyz042
/

OpenFOAM-dev

License:

Dataset card Files Files and versions

xet

Community

OpenFOAM-dev / data /src /finiteVolume /fields /DimensionedFields /DimensionedField /DimensionedField.H

introvoyz042

Migrated from GitHub

5a600cf verified 22 days ago

Raw History Blame Contribute Delete

18.4 kB

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2011-2026 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    OpenFOAM 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 General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
Class
    Foam::DimensionedField
Description
    Field with dimensions and associated with geometry type GeoMesh which is
    used to size the field and a reference to it is maintained.
SourceFiles
    DimensionedFieldI.H
    DimensionedField.C
    DimensionedFieldIO.C
\*---------------------------------------------------------------------------*/

#ifndef DimensionedField_H
#define DimensionedField_H

#include "DimensionedFieldFwd.H"
#include "regIOobject.H"
#include "Field.H"
#include "OldTimeField.H"
#include "dimensionedType.H"
#include "expressionExpressionable.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                      Class DimensionedField Declaration
\*---------------------------------------------------------------------------*/

template<class Type, class GeoMesh, template<class> class PrimitiveField>
class DimensionedField
:
    public regIOobject,
    public PrimitiveField<Type>,
    public OldTimeField<DimensionedField<Type, GeoMesh, PrimitiveField>>
{

public:

    // Public Types

        //- Value type
        using Type_ = Type;

        //- Geometric mesh type
        using GeoMesh_ = GeoMesh;

        //- Base mesh type from which GeoMesh is constructed
        using Mesh = typename GeoMesh::Mesh;

        //- Type of the field from which this DimensionedField is derived
        using FieldType = PrimitiveField<Type>;

        //- Type of the field from which this DimensionedField is derived
        using Base = PrimitiveField<Type>;

        //- Component type of the elements of the field
        using cmptType = typename PrimitiveField<Type>::cmptType;


private:

    // Private Data

        //- Reference to mesh
        const GeoMesh& mesh_;

        //- Dimension set for this field
        dimensionSet dimensions_;


    // Private Member Functions

        //- Read from file if it is present
        bool readIfPresent(const word& fieldDictEntry = "value");


public:

    //- Runtime type information
    TypeName("DimensionedField");


    //- Declare friendship with other dimensioned fields
    template<class Type2, class GeoMesh2, template<class> class PrimitiveField2>
    friend class DimensionedField;


    // Static Member Functions

        //- Return a null DimensionedField
        inline static const
            DimensionedField<Type, GeoMesh, PrimitiveField>& null();


    // Constructors

        //- Construct from components
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensionSet&,
            const PrimitiveField<Type>&
        );

        //- Construct from components
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensionSet&,
            const tmp<PrimitiveField<Type>>&
        );

        //- Construct from components
        template<class Expression, class = EnableIfExpression<Expression>>
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensionSet&,
            const Expression& e
        );

        //- Construct from components
        //  Used for temporary fields which are initialised after construction
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensionSet&,
            const bool checkIOFlags
        );

        //- Construct from components
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensioned<Type>&,
            const bool checkIOFlags = true
        );

        //- Construct from dictionary
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dictionary& fieldDict,
            const dimensionSet& dims = dimensions::invalid,
            const word& fieldDictEntry="value"
        );

        //- Construct from dictionary constructed from IOobject
        DimensionedField
        (
            const IOobject&,
            const GeoMesh& mesh,
            const dimensionSet& dims = dimensions::invalid,
            const word& fieldDictEntry="value"
        );

        //- Copy constructor
        DimensionedField
        (
            const DimensionedField<Type, GeoMesh, PrimitiveField>&
        );

        //- Move constructor
        DimensionedField
        (
            DimensionedField<Type, GeoMesh, PrimitiveField>&&
        );

        //- Copy constructor
        template<template<class> class PrimitiveField2>
        explicit DimensionedField
        (
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        //- Copy constructor or reuse as specified.
        template<template<class> class PrimitiveField2>
        DimensionedField
        (
            DimensionedField<Type, GeoMesh, PrimitiveField2>&,
            const bool reuse
        );

        //- Copy constructor of tmp<DimensionedField> deleting argument
        DimensionedField
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
        );

        //- Copy constructor resetting IO parameters
        template<template<class> class PrimitiveField2>
        DimensionedField
        (
            const IOobject&,
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&,
            const bool checkIOFlags = true
        );

        //- Copy constructor resetting IO parameters and reuse as specified.
        template<template<class> class PrimitiveField2>
        DimensionedField
        (
            const IOobject&,
            DimensionedField<Type, GeoMesh, PrimitiveField2>&,
            const bool reuse,
            const bool checkIOFlags = true
        );

        //- Copy constructor from tmp resetting IO parameters
        DimensionedField
        (
            const IOobject&,
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&,
            const bool checkIOFlags = true
        );

        //- Copy constructor from expression resetting IO parameters
        template<class Expression, class = EnableIfExpressionable<Expression>>
        DimensionedField
        (
            const IOobject&,
            const Expression& e,
            const bool checkIOFlags = true
        );

        //- Copy constructor resetting name
        template<template<class> class PrimitiveField2>
        DimensionedField
        (
            const word& newName,
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        //- Copy constructor resetting name and reuse as specified.
        template<template<class> class PrimitiveField2>
        DimensionedField
        (
            const word& newName,
            DimensionedField<Type, GeoMesh, PrimitiveField2>&,
            const bool reuse
        );

        //- Copy constructor from tmp resetting name
        DimensionedField
        (
            const word& newName,
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
        );

        //- Construct from an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        DimensionedField(const Expression& e);

        //- Clone
        tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> clone() const;

        //- Return a temporary field constructed from name, mesh,
        //  dimensionSet and field
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const dimensionSet&,
            const PrimitiveField<Type>&
        );

        //- Return a temporary field constructed from name, mesh,
        //  dimensionSet and tmp field
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const dimensionSet&,
            const tmp<PrimitiveField<Type>>&
        );

        //- Return a temporary field constructed from name, mesh,
        //  dimensionSet and field expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const dimensionSet&,
            const Expression& e
        );

        //- Return a temporary field constructed from name, mesh
        //  and dimensionSet
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const dimensionSet&
        );

        //- Return a temporary field constructed from name, mesh
        //  and dimensionType providing dimensions and value
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const dimensioned<Type>&
        );

        //- Return a temporary field constructed from name and a field
        template<template<class> class PrimitiveField2>
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& newName,
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        //- Return renamed temporary field
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& newName,
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
        );

        //- Return a temporary field constructed from name, mesh
        //  and DimensionedField expression
        template<class Expression, class = EnableIfExpression<Expression>>
        static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
        (
            const word& name,
            const GeoMesh& mesh,
            const Expression& e
        );


    //- Destructor
    virtual ~DimensionedField();


    // Member Functions

        void readField
        (
            const dictionary& fieldDict,
            const word& fieldDictEntry = "value"
        );

        //- Access the IO
        const IOobject& io() const
        {
            return *this;
        }

        //- Return mesh
        inline const GeoMesh& mesh() const;

        //- Return dimensions
        inline const dimensionSet& dimensions() const;

        //- Return non-const access to dimensions
        inline dimensionSet& dimensions();

        //- Return a reference to the internal field
        PrimitiveField<Type>& primitiveFieldRef();

        //- Return a const-reference to the primitive field
        inline const PrimitiveField<Type>& primitiveField() const;

        //- Transfer the list pointer from the given PrimitiveField
        inline virtual void transfer(PrimitiveField<Type>&);

        //- Use old-time methods from the base class
        USING_OLD_TIME_FIELD(DimensionedField);

        //- Return a component field expression of the field
        inline auto component(const direction&) const;

        //- Replace a component field of the field
        template<template<class> class PrimitiveField2>
        void replace
        (
            const direction,
            const DimensionedField<cmptType, GeoMesh, PrimitiveField2>&
        );

        //- Replace a component field of the field
        template<template<class> class PrimitiveField2>
        void replace
        (
            const direction,
            const tmp<DimensionedField<cmptType, GeoMesh, PrimitiveField2>>&
        );

        //- Replace a component field of the field from an expression
        template<class Expression, class = EnableIfExpression<Expression>>
        void replace(const direction, const Expression&);

        //- Replace a component field of the field with given value
        void replace(const direction, const dimensioned<cmptType>&);

        //- Return the field transpose field expression
        //  (only defined for second rank tensors)
        inline auto T() const;

        //- Reset the field values to the given field
        //  Used for mesh to mesh mapping
        template<template<class> class PrimitiveField2>
        void reset(const DimensionedField<Type, GeoMesh, PrimitiveField2>&);

        //- Reset the field values to the given tmp-field
        //  Used for mesh to mesh mapping
        void reset(const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&);

        //- Reset the field values to the given tmp-field
        //  Used for mesh to mesh mapping
        template<template<class> class PrimitiveField2>
        void reset
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
        );

        //- Bound the field to the given lower bound
        void boundLower(const dimensioned<Type>& lower);

        //- Bound the field to the given upper bound
        void boundUpper(const dimensioned<Type>& upper);

        //- Bound the field within the given lower and upper bounds
        void bound
        (
            const dimensioned<Type>& lower,
            const dimensioned<Type>& upper
        );


        // Write

            bool writeData(Ostream&, const word& fieldDictEntry) const;

            bool writeData(Ostream&) const;


    // Member Operators

        void operator=(const DimensionedField<Type, GeoMesh, PrimitiveField>&);

        void operator=(DimensionedField<Type, GeoMesh, PrimitiveField>&&);

        void operator=
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
        );

        template<template<class> class PrimitiveField2>
        void operator=
        (
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        template<template<class> class PrimitiveField2>
        void operator=
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
        );

        //- Assign to an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        void operator=(const Expression& e);

        void operator=(const dimensioned<Type>&);

        void operator=(const zero&);

        template<template<class> class PrimitiveField2>
        void operator+=
        (
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        template<template<class> class PrimitiveField2>
        void operator+=
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
        );

        //- Assign-add to an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        void operator+=(const Expression& e);

        void operator+=(const dimensioned<Type>&);

        template<template<class> class PrimitiveField2>
        void operator-=
        (
            const DimensionedField<Type, GeoMesh, PrimitiveField2>&
        );

        template<template<class> class PrimitiveField2>
        void operator-=
        (
            const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
        );

        //- Assign-subtract to an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        void operator-=(const Expression& e);

        void operator-=(const dimensioned<Type>&);

        template<template<class> class PrimitiveField2>
        void operator*=
        (
            const DimensionedField<scalar, GeoMesh, PrimitiveField2>&
        );

        template<template<class> class PrimitiveField2>
        void operator*=
        (
            const tmp<DimensionedField<scalar, GeoMesh, PrimitiveField2>>&
        );

        //- Assign-multiply to an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        void operator*=(const Expression& e);

        void operator*=(const dimensioned<scalar>&);

        template<template<class> class PrimitiveField2>
        void operator/=
        (
            const DimensionedField<scalar, GeoMesh, PrimitiveField2>&
        );

        template<template<class> class PrimitiveField2>
        void operator/=
        (
            const tmp<DimensionedField<scalar, GeoMesh, PrimitiveField2>>&
        );

        //- Assign-divide to an expression
        template<class Expression, class = EnableIfExpressionable<Expression>>
        void operator/=(const Expression& e);

        void operator/=(const dimensioned<scalar>&);
};


template<class Type, class GeoMesh, template<class> class PrimitiveField>
Ostream& operator<<
(
    Ostream&,
    const DimensionedField<Type, GeoMesh, PrimitiveField>&
);


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#include "DimensionedFieldI.H"
#include "DimensionedFieldExpression.H"

#ifdef NoRepository
    #include "DimensionedField.C"
#endif

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //

	/---------------------------------------------------------------------------\
	========= \|
	\\ / F ield \| OpenFOAM: The Open Source CFD Toolbox
	\\ / O peration \| Website: https://openfoam.org
	\\ / A nd \| Copyright (C) 2011-2026 OpenFOAM Foundation
	\\/ M anipulation \|
	-------------------------------------------------------------------------------
	License
	This file is part of OpenFOAM.

	OpenFOAM is free software: you can redistribute it and/or modify it
	under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	OpenFOAM 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 General Public License
	along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.

	Class
	Foam::DimensionedField

	Description
	Field with dimensions and associated with geometry type GeoMesh which is
	used to size the field and a reference to it is maintained.

	SourceFiles
	DimensionedFieldI.H
	DimensionedField.C
	DimensionedFieldIO.C

	\---------------------------------------------------------------------------/

	#ifndef DimensionedField_H
	#define DimensionedField_H

	#include "DimensionedFieldFwd.H"
	#include "regIOobject.H"
	#include "Field.H"
	#include "OldTimeField.H"
	#include "dimensionedType.H"
	#include "expressionExpressionable.H"

	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

	namespace Foam
	{

	/---------------------------------------------------------------------------\
	Class DimensionedField Declaration
	\---------------------------------------------------------------------------/

	template<class Type, class GeoMesh, template<class> class PrimitiveField>
	class DimensionedField
	:
	public regIOobject,
	public PrimitiveField<Type>,
	public OldTimeField<DimensionedField<Type, GeoMesh, PrimitiveField>>
	{

	public:

	// Public Types

	//- Value type
	using Type_ = Type;

	//- Geometric mesh type
	using GeoMesh_ = GeoMesh;

	//- Base mesh type from which GeoMesh is constructed
	using Mesh = typename GeoMesh::Mesh;

	//- Type of the field from which this DimensionedField is derived
	using FieldType = PrimitiveField<Type>;

	//- Type of the field from which this DimensionedField is derived
	using Base = PrimitiveField<Type>;

	//- Component type of the elements of the field
	using cmptType = typename PrimitiveField<Type>::cmptType;


	private:

	// Private Data

	//- Reference to mesh
	const GeoMesh& mesh_;

	//- Dimension set for this field
	dimensionSet dimensions_;


	// Private Member Functions

	//- Read from file if it is present
	bool readIfPresent(const word& fieldDictEntry = "value");


	public:

	//- Runtime type information
	TypeName("DimensionedField");


	//- Declare friendship with other dimensioned fields
	template<class Type2, class GeoMesh2, template<class> class PrimitiveField2>
	friend class DimensionedField;


	// Static Member Functions

	//- Return a null DimensionedField
	inline static const
	DimensionedField<Type, GeoMesh, PrimitiveField>& null();


	// Constructors

	//- Construct from components
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensionSet&,
	const PrimitiveField<Type>&
	);

	//- Construct from components
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensionSet&,
	const tmp<PrimitiveField<Type>>&
	);

	//- Construct from components
	template<class Expression, class = EnableIfExpression<Expression>>
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensionSet&,
	const Expression& e
	);

	//- Construct from components
	// Used for temporary fields which are initialised after construction
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensionSet&,
	const bool checkIOFlags
	);

	//- Construct from components
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensioned<Type>&,
	const bool checkIOFlags = true
	);

	//- Construct from dictionary
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dictionary& fieldDict,
	const dimensionSet& dims = dimensions::invalid,
	const word& fieldDictEntry="value"
	);

	//- Construct from dictionary constructed from IOobject
	DimensionedField
	(
	const IOobject&,
	const GeoMesh& mesh,
	const dimensionSet& dims = dimensions::invalid,
	const word& fieldDictEntry="value"
	);

	//- Copy constructor
	DimensionedField
	(
	const DimensionedField<Type, GeoMesh, PrimitiveField>&
	);

	//- Move constructor
	DimensionedField
	(
	DimensionedField<Type, GeoMesh, PrimitiveField>&&
	);

	//- Copy constructor
	template<template<class> class PrimitiveField2>
	explicit DimensionedField
	(
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	//- Copy constructor or reuse as specified.
	template<template<class> class PrimitiveField2>
	DimensionedField
	(
	DimensionedField<Type, GeoMesh, PrimitiveField2>&,
	const bool reuse
	);

	//- Copy constructor of tmp<DimensionedField> deleting argument
	DimensionedField
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
	);

	//- Copy constructor resetting IO parameters
	template<template<class> class PrimitiveField2>
	DimensionedField
	(
	const IOobject&,
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&,
	const bool checkIOFlags = true
	);

	//- Copy constructor resetting IO parameters and reuse as specified.
	template<template<class> class PrimitiveField2>
	DimensionedField
	(
	const IOobject&,
	DimensionedField<Type, GeoMesh, PrimitiveField2>&,
	const bool reuse,
	const bool checkIOFlags = true
	);

	//- Copy constructor from tmp resetting IO parameters
	DimensionedField
	(
	const IOobject&,
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&,
	const bool checkIOFlags = true
	);

	//- Copy constructor from expression resetting IO parameters
	template<class Expression, class = EnableIfExpressionable<Expression>>
	DimensionedField
	(
	const IOobject&,
	const Expression& e,
	const bool checkIOFlags = true
	);

	//- Copy constructor resetting name
	template<template<class> class PrimitiveField2>
	DimensionedField
	(
	const word& newName,
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	//- Copy constructor resetting name and reuse as specified.
	template<template<class> class PrimitiveField2>
	DimensionedField
	(
	const word& newName,
	DimensionedField<Type, GeoMesh, PrimitiveField2>&,
	const bool reuse
	);

	//- Copy constructor from tmp resetting name
	DimensionedField
	(
	const word& newName,
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
	);

	//- Construct from an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	DimensionedField(const Expression& e);

	//- Clone
	tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> clone() const;

	//- Return a temporary field constructed from name, mesh,
	// dimensionSet and field
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const dimensionSet&,
	const PrimitiveField<Type>&
	);

	//- Return a temporary field constructed from name, mesh,
	// dimensionSet and tmp field
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const dimensionSet&,
	const tmp<PrimitiveField<Type>>&
	);

	//- Return a temporary field constructed from name, mesh,
	// dimensionSet and field expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const dimensionSet&,
	const Expression& e
	);

	//- Return a temporary field constructed from name, mesh
	// and dimensionSet
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const dimensionSet&
	);

	//- Return a temporary field constructed from name, mesh
	// and dimensionType providing dimensions and value
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const dimensioned<Type>&
	);

	//- Return a temporary field constructed from name and a field
	template<template<class> class PrimitiveField2>
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& newName,
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	//- Return renamed temporary field
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& newName,
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
	);

	//- Return a temporary field constructed from name, mesh
	// and DimensionedField expression
	template<class Expression, class = EnableIfExpression<Expression>>
	static tmp<DimensionedField<Type, GeoMesh, PrimitiveField>> New
	(
	const word& name,
	const GeoMesh& mesh,
	const Expression& e
	);


	//- Destructor
	virtual ~DimensionedField();


	// Member Functions

	void readField
	(
	const dictionary& fieldDict,
	const word& fieldDictEntry = "value"
	);

	//- Access the IO
	const IOobject& io() const
	{
	return *this;
	}

	//- Return mesh
	inline const GeoMesh& mesh() const;

	//- Return dimensions
	inline const dimensionSet& dimensions() const;

	//- Return non-const access to dimensions
	inline dimensionSet& dimensions();

	//- Return a reference to the internal field
	PrimitiveField<Type>& primitiveFieldRef();

	//- Return a const-reference to the primitive field
	inline const PrimitiveField<Type>& primitiveField() const;

	//- Transfer the list pointer from the given PrimitiveField
	inline virtual void transfer(PrimitiveField<Type>&);

	//- Use old-time methods from the base class
	USING_OLD_TIME_FIELD(DimensionedField);

	//- Return a component field expression of the field
	inline auto component(const direction&) const;

	//- Replace a component field of the field
	template<template<class> class PrimitiveField2>
	void replace
	(
	const direction,
	const DimensionedField<cmptType, GeoMesh, PrimitiveField2>&
	);

	//- Replace a component field of the field
	template<template<class> class PrimitiveField2>
	void replace
	(
	const direction,
	const tmp<DimensionedField<cmptType, GeoMesh, PrimitiveField2>>&
	);

	//- Replace a component field of the field from an expression
	template<class Expression, class = EnableIfExpression<Expression>>
	void replace(const direction, const Expression&);

	//- Replace a component field of the field with given value
	void replace(const direction, const dimensioned<cmptType>&);

	//- Return the field transpose field expression
	// (only defined for second rank tensors)
	inline auto T() const;

	//- Reset the field values to the given field
	// Used for mesh to mesh mapping
	template<template<class> class PrimitiveField2>
	void reset(const DimensionedField<Type, GeoMesh, PrimitiveField2>&);

	//- Reset the field values to the given tmp-field
	// Used for mesh to mesh mapping
	void reset(const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&);

	//- Reset the field values to the given tmp-field
	// Used for mesh to mesh mapping
	template<template<class> class PrimitiveField2>
	void reset
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
	);

	//- Bound the field to the given lower bound
	void boundLower(const dimensioned<Type>& lower);

	//- Bound the field to the given upper bound
	void boundUpper(const dimensioned<Type>& upper);

	//- Bound the field within the given lower and upper bounds
	void bound
	(
	const dimensioned<Type>& lower,
	const dimensioned<Type>& upper
	);


	// Write

	bool writeData(Ostream&, const word& fieldDictEntry) const;

	bool writeData(Ostream&) const;


	// Member Operators

	void operator=(const DimensionedField<Type, GeoMesh, PrimitiveField>&);

	void operator=(DimensionedField<Type, GeoMesh, PrimitiveField>&&);

	void operator=
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField>>&
	);

	template<template<class> class PrimitiveField2>
	void operator=
	(
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	template<template<class> class PrimitiveField2>
	void operator=
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
	);

	//- Assign to an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	void operator=(const Expression& e);

	void operator=(const dimensioned<Type>&);

	void operator=(const zero&);

	template<template<class> class PrimitiveField2>
	void operator+=
	(
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	template<template<class> class PrimitiveField2>
	void operator+=
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
	);

	//- Assign-add to an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	void operator+=(const Expression& e);

	void operator+=(const dimensioned<Type>&);

	template<template<class> class PrimitiveField2>
	void operator-=
	(
	const DimensionedField<Type, GeoMesh, PrimitiveField2>&
	);

	template<template<class> class PrimitiveField2>
	void operator-=
	(
	const tmp<DimensionedField<Type, GeoMesh, PrimitiveField2>>&
	);

	//- Assign-subtract to an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	void operator-=(const Expression& e);

	void operator-=(const dimensioned<Type>&);

	template<template<class> class PrimitiveField2>
	void operator*=
	(
	const DimensionedField<scalar, GeoMesh, PrimitiveField2>&
	);

	template<template<class> class PrimitiveField2>
	void operator*=
	(
	const tmp<DimensionedField<scalar, GeoMesh, PrimitiveField2>>&
	);

	//- Assign-multiply to an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	void operator*=(const Expression& e);

	void operator*=(const dimensioned<scalar>&);

	template<template<class> class PrimitiveField2>
	void operator/=
	(
	const DimensionedField<scalar, GeoMesh, PrimitiveField2>&
	);

	template<template<class> class PrimitiveField2>
	void operator/=
	(
	const tmp<DimensionedField<scalar, GeoMesh, PrimitiveField2>>&
	);

	//- Assign-divide to an expression
	template<class Expression, class = EnableIfExpressionable<Expression>>
	void operator/=(const Expression& e);

	void operator/=(const dimensioned<scalar>&);
	};


	template<class Type, class GeoMesh, template<class> class PrimitiveField>
	Ostream& operator<<
	(
	Ostream&,
	const DimensionedField<Type, GeoMesh, PrimitiveField>&
	);


	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

	} // End namespace Foam

	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

	#include "DimensionedFieldI.H"
	#include "DimensionedFieldExpression.H"

	#ifdef NoRepository
	#include "DimensionedField.C"
	#endif

	// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

	#endif

	// ************************************************************************* //