/*---------------------------------------------------------------------------*\
========= |
\\ / 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 .
Class
Foam::fvsPatchField
Description
An abstract base class with a fat-interface to all derived classes
covering all possible ways in which they might be used.
The first level of derivation is to basic patchFields which cover
zero-gradient, fixed-gradient, fixed-value and mixed conditions.
The next level of derivation covers all the specialised typed with
specific evaluation procedures, particularly with respect to specific
fields.
SourceFiles
fvsPatchField.C
fvsPatchFieldNew.C
\*---------------------------------------------------------------------------*/
#ifndef fvsPatchField_H
#define fvsPatchField_H
#include "fvPatch.H"
#include "DimensionedField.H"
#include "fvPatchFieldMapperFwd.H"
#include "expressionAssignment.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class fieldMapper;
class surfaceMesh;
// Forward declaration of friend functions and operators
template
class fvsPatchField;
template
class calculatedFvsPatchField;
template
class slicedFvsPatchField;
template
Ostream& operator<<(Ostream&, const fvsPatchField&);
/*---------------------------------------------------------------------------*\
Class patch Declaration
\*---------------------------------------------------------------------------*/
template
class fvsPatchField
:
public Field
{
// Private Data
//- Reference to patch
const fvPatch& patch_;
//- Reference to internal field
const DimensionedField& internalField_;
public:
// Public Types
//- Declare primitive type
using pType = typename FieldTraits::pType;
//- Declare component type
using cmptType = typename FieldTraits::cmptType;
//- Declare component primitive type
using pCmptType = typename FieldTraits::pCmptType;
//- Declare patch type
using Patch = fvPatch;
//- Declare calculated patch field type
using Calculated = calculatedFvsPatchField;
//- Declare sliced patch field type
using Sliced = slicedFvsPatchField;
//- Declare component Field type
using cmptField = fvsPatchField;
//- Runtime type information
TypeName("fvsPatchField");
//- Debug switch to disallow the use of genericFvsPatchField
static int disallowGenericFvsPatchField;
// Declare run-time constructor selection tables
declareRunTimeSelectionTable
(
tmp,
fvsPatchField,
patch,
(
const fvPatch& p,
const DimensionedField& iF
),
(p, iF)
);
declareRunTimeSelectionTable
(
tmp,
fvsPatchField,
dictionary,
(
const fvPatch& p,
const DimensionedField& iF,
const dictionary& dict
),
(p, iF, dict)
);
declareRunTimeSelectionTable
(
tmp,
fvsPatchField,
patchMapper,
(
const fvsPatchField& ptf,
const fvPatch& p,
const DimensionedField& iF,
const fieldMapper& m
),
(dynamic_cast(ptf), p, iF, m)
);
// Constructors
//- Construct from patch and internal field
fvsPatchField
(
const fvPatch&,
const DimensionedField&
);
//- Construct from patch and internal field and patch field
fvsPatchField
(
const fvPatch&,
const DimensionedField&,
const Field&
);
//- Construct from patch, internal field and dictionary
fvsPatchField
(
const fvPatch&,
const DimensionedField&,
const dictionary&,
const bool valueRequired=true
);
//- Construct by mapping the given fvsPatchField onto a new patch
fvsPatchField
(
const fvsPatchField&,
const fvPatch&,
const DimensionedField&,
const fieldMapper&,
const bool mappingRequired=true
);
//- Disallow copy without setting internal field reference
fvsPatchField(const fvsPatchField&) = delete;
//- Disallow clone without setting internal field reference
tmp> clone() const
{
// Temporarily reinstate the clone() function pending a rewrite of
// the mapping of surfaceFields in fvMeshDistribute
return tmp>
(
new fvsPatchField(*this, internalField_)
);
// NotImplemented;
// return tmp>(nullptr);
}
//- Copy constructor setting internal field reference
fvsPatchField
(
const fvsPatchField&,
const DimensionedField&
);
//- Construct and return a clone setting internal field reference
virtual tmp> clone
(
const DimensionedField& iF
) const
{
return tmp>
(
new fvsPatchField(*this, iF)
);
}
//- Construct and return a clone onto a new patch
// setting internal field reference
virtual tmp> clone
(
const fvPatch& patch,
const DimensionedField& iF
) const
{
return tmp>
(
new fvsPatchField(patch, iF, *this)
);
}
// Selectors
//- Return a pointer to a new patchField created on freestore given
// patch and internal field
// (does not set the patch field values)
static tmp> New
(
const word&,
const fvPatch&,
const DimensionedField&
);
//- Return a pointer to a new patchField created on freestore given
// patch and internal field
// (does not set the patch field values)
// Allows override of constraint type
static tmp> New
(
const word&,
const word& actualPatchType,
const fvPatch&,
const DimensionedField&
);
//- Return a pointer to a new patchField created on freestore from
// a given fvsPatchField mapped onto a new patch
static tmp> New
(
const fvsPatchField&,
const fvPatch&,
const DimensionedField&,
const fieldMapper&
);
//- Return a pointer to a new patchField created on freestore
// from dictionary
static tmp> New
(
const fvPatch&,
const DimensionedField&,
const dictionary&
);
//- Destructor
virtual ~fvsPatchField()
{}
// Member Functions
// Attributes
//- Return the type of the calculated for of fvsPatchField
static const word& calculatedType();
//- Return true if this patch field fixes a value.
// Needed to check if a level has to be specified while solving
// Poissons equations.
virtual bool fixesValue() const
{
return false;
}
//- Return true if this patch field is coupled
virtual bool coupled() const
{
return false;
}
//- Return true if this overrides the underlying constraint type
bool overridesConstraint() const
{
if (type() == patch_.type())
{
return false;
}
typename patchConstructorTable::iterator patchTypeCstrIter
= patchConstructorTablePtr_->find(patch_.type());
return
patchTypeCstrIter
!= patchConstructorTablePtr_->end();
}
// Access
//- Return local objectRegistry
const objectRegistry& db() const;
//- Return time
const Time& time() const;
//- Return patch
const fvPatch& patch() const
{
return patch_;
}
//- Return reference to the base patch field
const Field& field() const
{
return *this;
}
//- Return dimensioned internal field reference
const DimensionedField&
internalField() const
{
return internalField_;
}
//- Return internal field reference
const Field& primitiveField() const
{
return internalField_;
}
// Evaluation functions
//- Initialise return of the patchField on the opposite patch of a
// coupled patch
virtual void initPatchNeighbourField
(
const Pstream::commsTypes commsType
) const
{}
//- Return patchField on the opposite patch of a coupled patch
virtual tmp> patchNeighbourField
(
const Pstream::commsTypes commsType
) const
{
NotImplemented;
return *this;
}
// Mapping functions
//- Map the given fvsPatchField onto this fvsPatchField
virtual void map(const fvsPatchField&, const fieldMapper&);
//- Reset the fvsPatchField to the given fvsPatchField
// Used for mesh to mesh mapping
virtual void reset(const fvsPatchField&);
//- Write
virtual void write(Ostream&) const;
// Check
//- Check fvsPatchField against given fvsPatchField
void check(const fvsPatchField&) const;
// Member Operators
virtual void operator=(const UList&);
virtual void operator=(const Field&);
virtual void operator=(const fvsPatchField&);
//- Virtual assign to an expression
virtual void operator=
(
const expression::Assignment>& a
);
//- Templated assign to an expression
template>
void operator=(const Expression& e);
virtual void operator+=(const fvsPatchField&);
virtual void operator-=(const fvsPatchField&);
virtual void operator*=(const fvsPatchField&);
virtual void operator/=(const fvsPatchField&);
virtual void operator+=(const Field&);
virtual void operator-=(const Field&);
virtual void operator*=(const Field&);
virtual void operator/=(const Field&);
virtual void operator=(const Type&);
virtual void operator+=(const Type&);
virtual void operator-=(const Type&);
virtual void operator*=(const scalar);
virtual void operator/=(const scalar);
// Force an assignment irrespective of form of patch
virtual void operator==(const fvsPatchField&);
virtual void operator==(const Field&);
virtual void operator==(const Type&);
//- Virtual force-assign to an expression
virtual void operator==
(
const expression::Assignment>& a
);
//- Templated force-assign
template>
void operator==(const Expression& e);
// Ostream operator
friend Ostream& operator<< (Ostream&, const fvsPatchField&);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "fvsPatchFieldExpression.H"
#ifdef NoRepository
#include "fvsPatchField.C"
#include "calculatedFvsPatchField.H"
#endif
#define makeFvsPatchField(fvsPatchTypeField) \
defineNamedTemplateTypeNameAndDebug(fvsPatchTypeField, 0); \
template<> \
int fvsPatchTypeField::disallowGenericFvsPatchField \
( \
debug::debugSwitch("disallowGenericFvsPatchField", 0) \
); \
defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patch); \
defineTemplateRunTimeSelectionTable(fvsPatchTypeField, patchMapper); \
defineTemplateRunTimeSelectionTable(fvsPatchTypeField, dictionary);
#define addToFvsPatchFieldRunTimeSelection(PatchTypeField, typePatchTypeField) \
addToRunTimeSelectionTable \
( \
PatchTypeField, \
typePatchTypeField, \
patch \
); \
addToRunTimeSelectionTable \
( \
PatchTypeField, \
typePatchTypeField, \
patchMapper \
); \
addToRunTimeSelectionTable \
( \
PatchTypeField, \
typePatchTypeField, \
dictionary \
);
// For non-templated patch fields
#define makeFvsPatchTypeField(PatchTypeField, typePatchTypeField) \
defineTypeNameAndDebug(typePatchTypeField, 0); \
addToFvsPatchFieldRunTimeSelection(PatchTypeField, typePatchTypeField)
// For templated patch fields
#define makeTemplateFvsPatchTypeField(fieldType, type) \
defineNamedTemplateTypeNameAndDebug \
( \
CAT4(type, FvsPatch, CAPITALIZE(fieldType), Field), \
0 \
); \
addToFvsPatchFieldRunTimeSelection \
( \
CAT3(fvsPatch, CAPITALIZE(fieldType), Field), \
CAT4(type, FvsPatch, CAPITALIZE(fieldType), Field) \
)
#define makeFvsPatchFields(type) \
FOR_ALL_FIELD_TYPES(makeTemplateFvsPatchTypeField, type)
#define makeFvsPatchFieldTypeName(fieldType, type) \
defineNamedTemplateTypeNameAndDebug \
( \
CAT4(type, FvsPatch, CAPITALIZE(fieldType), Field), \
0 \
);
#define makeFvsPatchFieldTypeNames(type) \
FOR_ALL_FIELD_TYPES(makeFvsPatchFieldTypeName, type)
#define makeFvsPatchTypeFieldTypedef(fieldType, type) \
typedef type##FvsPatchField \
CAT4(type, FvsPatch, CAPITALIZE(fieldType), Field);
#define makeFvsPatchTypeFieldTypedefs(type) \
FOR_ALL_FIELD_TYPES(makeFvsPatchTypeFieldTypedef, type)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //