uniformFixedValuePointPatchField.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-2016 OpenFOAM Foundation
    Copyright (C) 2019 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::uniformFixedValuePointPatchField
 
Description
    Enables the specification of a uniform fixed value condition.
 
Usage
    \table
        Property     | Description                  | Required | Default
        uniformValue | uniform value                | yes |
        value        | initial field value          | optional |
    \endtable
 
    Example of the boundary condition specification:
    \verbatim
    inlet
    {
        type            uniformFixedValue;
        uniformValue    constant 0.2;
    }
    \endverbatim
 
Note
    The uniformValue entry is a PatchFunction1 type,
    able to describe time and spatial varying functions.
    The example above gives the usage for supplying a constant value.
 
    The \c value entry (optional) is used for the initial values.
    Otherwise the \c uniformValue is evaluated.
    In some cases (eg, coded or expression entries with references to other
    fields) this can be problematic and the \c value entry will be needed.
 
SourceFiles
    uniformFixedValuePointPatchField.C
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_uniformFixedValuePointPatchField_H
#define Foam_uniformFixedValuePointPatchField_H
 
#include "fixedValuePointPatchField.H"
#include "PatchFunction1.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
              Class uniformFixedValuePointPatchField Declaration
\*---------------------------------------------------------------------------*/
 
template<class Type>
class uniformFixedValuePointPatchField
:
    public fixedValuePointPatchField<Type>
{
    // Private Data
 
        //- Function providing the value
        autoPtr<PatchFunction1<Type>> refValueFunc_;
 
        //- Function providing the value (if not on polyPatch)
        autoPtr<Function1<Type>> refPointValueFunc_;
 
 
    // Private Member Functions
 
        //- Find polyPatch with the same name as the pointPatch
        static const polyPatch* getPolyPatch(const pointPatch& p);
 
 
public:
 
    //- Runtime type information
    TypeName("uniformFixedValue");
 
 
    // Constructors
 
        //- Construct from patch and internal field
        uniformFixedValuePointPatchField
        (
            const pointPatch&,
            const DimensionedField<Type, pointMesh>&
        );
 
        //- Construct from patch, internal field and dictionary
        uniformFixedValuePointPatchField
        (
            const pointPatch&,
            const DimensionedField<Type, pointMesh>&,
            const dictionary&
        );
 
        //- Construct by mapping given patch field onto a new patch
        uniformFixedValuePointPatchField
        (
            const uniformFixedValuePointPatchField<Type>&,
            const pointPatch&,
            const DimensionedField<Type, pointMesh>&,
            const pointPatchFieldMapper&
        );
 
        //- Copy construct with internal field reference
        uniformFixedValuePointPatchField
        (
            const uniformFixedValuePointPatchField<Type>&,
            const DimensionedField<Type, pointMesh>&
        );
 
        //- Copy construct
        uniformFixedValuePointPatchField
        (
            const uniformFixedValuePointPatchField<Type>& pfld
        )
        :
            uniformFixedValuePointPatchField<Type>(pfld, pfld.internalField())
        {}
 
 
        //- Return a clone
        virtual autoPtr<pointPatchField<Type>> clone() const
        {
            return pointPatchField<Type>::Clone(*this);
        }
 
        //- Construct and return a clone setting internal field reference
        virtual autoPtr<pointPatchField<Type>> clone
        (
            const DimensionedField<Type, pointMesh>& iF
        ) const
        {
            return pointPatchField<Type>::Clone(*this, iF);
        }
 
 
    // Member Functions
 
        // Mapping functions
 
            //- Map (and resize as needed) from self given a mapping object
            virtual void autoMap
            (
                const pointPatchFieldMapper&
            );
 
            //- Reverse map the given fvPatchField onto this fvPatchField
            virtual void rmap
            (
                const pointPatchField<Type>&,
                const labelList&
            );
 
 
        // Evaluation functions
 
            //- Update the coefficients associated with the patch field
            virtual void updateCoeffs();
 
 
        //- Write
        virtual void write(Ostream&) const;
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#ifdef NoRepository
    #include "uniformFixedValuePointPatchField.C"
#endif
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //