GeometricBoundaryField.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2011-2017,2022 OpenFOAM Foundation
    Copyright (C) 2015-2026 OpenCFD Ltd.
-------------------------------------------------------------------------------
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::GeometricBoundaryField

Description
    Generic GeometricBoundaryField class.

SourceFiles
    GeometricBoundaryField.C

\*---------------------------------------------------------------------------*/

#ifndef Foam_GeometricBoundaryField_H
#define Foam_GeometricBoundaryField_H

#include "dimensionedTypes.H"
#include "DimensionedField.H"
#include "FieldField.H"
#include "lduInterfaceFieldPtrsList.H"
#include "LduInterfaceFieldPtrsList.H"

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

namespace Foam
{

/*---------------------------------------------------------------------------*\
                   Class GeometricBoundaryField Declaration
\*---------------------------------------------------------------------------*/

template<class Type, template<class> class PatchField, class GeoMesh>
class GeometricBoundaryField
:
    public FieldField<PatchField, Type>
{
public:

    // Public Typedefs

        //- The template instance used for this GeometricBoundaryField type
        typedef GeometricBoundaryField<Type, PatchField, GeoMesh> this_type;

        //- The boundary mesh type for the boundary fields
        typedef typename GeoMesh::BoundaryMesh BoundaryMesh;

        //- The internal field type associated with the boundary fields
        typedef DimensionedField<Type, GeoMesh> Internal;

        //- This boundary field type
        typedef GeometricBoundaryField<Type, PatchField, GeoMesh> Boundary;

        //- The patch field type for the boundary fields
        typedef PatchField<Type> Patch;


private:

    // Private Data

        //- Reference to BoundaryMesh for which this field is defined
        const BoundaryMesh& bmesh_;


    // Private Member Functions

        //- Check if patch fields have been consistently evaluated.
        //  If not:
        //      exit = true  : FatalError
        //      exit = false : return bool
        template<class CheckPatchField>
        bool checkConsistency(const scalar tol, const bool exitIfBad) const;


public:

    //- Enable debug
    static int debug;


    // Constructors

        //- Construct from a BoundaryMesh, setting patches later
        explicit GeometricBoundaryField(const BoundaryMesh& bmesh);

        //- Construct from a BoundaryMesh, reference to the internal field
        //- and a patch type
        GeometricBoundaryField
        (
            const BoundaryMesh& bmesh,
            const Internal& iField,
            const word& patchFieldType = PatchField<Type>::calculatedType()
        );

        //- Construct from a BoundaryMesh, reference to the internal field
        //- and a wordList of patch types and optional the actual patch
        //- types (to override constraint patches)
        GeometricBoundaryField
        (
            const BoundaryMesh& bmesh,
            const Internal& iField,
            const wordList& wantedPatchTypes,
            const wordList& actualPatchTypes = wordList()
        );

        //- Construct from a BoundaryMesh, reference to the internal field
        //- and list of patch fields (to be cloned)
        GeometricBoundaryField
        (
            const BoundaryMesh& bmesh,
            const Internal& iField,
            const UPtrList<PatchField<Type>>& pflds
        );

        //- Construct as copy, setting the reference to the internal field
        GeometricBoundaryField
        (
            const Internal& iField,
            const GeometricBoundaryField& btf
        );

        //- Construct as copy, setting the reference to the internal field
        //- and resetting type of field for given patch IDs
        GeometricBoundaryField
        (
            const Internal& iField,
            const GeometricBoundaryField& btf,
            const labelUList& patchIDs,
            const word& patchFieldName
        );

        //- Construct from dictionary
        GeometricBoundaryField
        (
            const BoundaryMesh& bmesh,
            const Internal& iField,
            const dictionary& dict
        );

        //- No copy construct
        //  Dangerous because it may be set to a field which gets deleted.
        //  Need new type of BoundaryField, one which is part of a geometric
        //  field for which snGrad etc. may be called and a free standing
        //  BoundaryField for which such operations are unavailable.
        GeometricBoundaryField(const GeometricBoundaryField& bf) = delete;
        // :
        //     FieldField<PatchField, Type>(bf),
        //     bmesh_(bf.bmesh_)
        // {}

        //- No move construct: likely just as dangerous as copy construct
        GeometricBoundaryField(GeometricBoundaryField&&) = delete;

        // FUTURE?
        // //- Clone, setting reference to the internal field
        // tmp<GeometricBoundaryField> clone(const Internal& iField) const
        // {
        //     return tmp<GeometricBoundaryField>::New(iField, *this);
        // }


    // Member Functions

        //- Return non-const reference to this boundary field
        this_type& constCast() const noexcept
        {
            return const_cast<this_type&>(*this);
        }

        //- Read the boundary field
        void readField(const Internal& iField, const dictionary& dict);

        //- Update the boundary condition coefficients
        void updateCoeffs();

        //- Evaluate boundary conditions for each patch field.
        //- Uses specified or default comms.
        void evaluate
        (
            const UPstream::commsTypes commsType = UPstream::defaultCommsType
        );

        //- Evaluate boundary conditions for patch fields matching the
        //- given predicate. Uses specified or default comms.
        template<class UnaryPredicate>
        void evaluate_if
        (
            const UnaryPredicate& pred,
            const UPstream::commsTypes commsType = UPstream::defaultCommsType
        );

        //- Evaluate boundary conditions after change in local values.
        //- Uses specified or default comms.
        void evaluateLocal
        (
            const UPstream::commsTypes commsType = UPstream::defaultCommsType
        );

        //- Evaluate boundary conditions on coupled patches of the given type,
        //- using specified or default comms.
        //
        //  \tparam CoupledPatchType The coupled \b patch type that should
        //     be evaluated. For a \c void type,
        //     all coupled patch fields will be evaluated.
        template<class CoupledPatchType>
        void evaluateCoupled
        (
            const UPstream::commsTypes commsType = UPstream::defaultCommsType
        );

        //- Evaluate boundary conditions for selected patches.
        //- Uses non-blocking comms.
        void evaluateSelected(const labelUList& patchIDs);

        //- Return a list of the patch types
        wordList types() const;

        //- Return boundary field of values neighbouring the boundary
        tmp<GeometricBoundaryField> boundaryInternalField() const;

        //- Return a list of pointers for each patch field with only those
        //- pointing to interfaces being set
        LduInterfaceFieldPtrsList<Type> interfaces() const;

        //- Return a list of pointers for each patch field with only those
        //- pointing to interfaces being set
        lduInterfaceFieldPtrsList scalarInterfaces() const;

        //- Helper: check if field has been evaluated. See instantiations.
        bool check() const;


    // Write

        //- Write boundary field as dictionary entry
        void writeEntry(const word& keyword, Ostream& os) const;

        //- Write dictionary entries of the individual boundary fields.
        void writeEntries(Ostream& os) const;


    // Member Operators

        //- Copy assignment from GeometricBoundaryField
        void operator=(const GeometricBoundaryField& bf);

        //- Copy assignment from FieldField<PatchField, Type>
        void operator=(const FieldField<PatchField, Type>& bf);

        //- Assignment to uniform value
        void operator=(const Type& val);

        //- Assignment to zero
        void operator=(Foam::zero);

        //- Forced assignment from GeometricBoundaryField
        void operator==(const GeometricBoundaryField& bf);

        //- Forced assignment from FieldField<PatchField, Type>
        void operator==(const FieldField<PatchField, Type>& bf);

        //- Forced assignment to uniform value
        void operator==(const Type& val);

        //- Forced assignment to zero
        void operator==(Foam::zero) { *this == Type(Foam::zero{}); }

        // Prevent automatic comparison rewriting (c++20)
        bool operator!=(const GeometricBoundaryField&) = delete;
        bool operator!=(const FieldField<PatchField, Type>&) = delete;
        bool operator!=(const Type&) = delete;
        bool operator!=(Foam::zero) = delete;
};


template<class Type, template<class> class PatchField, class GeoMesh>
Ostream& operator<<
(
    Ostream&,
    const GeometricBoundaryField<Type, PatchField, GeoMesh>&
);


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

} // End namespace Foam

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

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

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

#endif

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