ENH: codedMixed: coded variant of mixed

etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "mixedFvPatchFieldTemplate.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvPatchFieldMapper.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "unitConversion.H"
+//{{{ begin codeInclude
+${codeInclude}
+//}}} end codeInclude
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
+
+//{{{ begin localCode
+${localCode}
+//}}} end localCode
+
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+extern "C"
+{
+    // dynamicCode:
+    // SHA1 = ${SHA1sum}
+    //
+    // unique function name that can be checked if the correct library version
+    // has been loaded
+    void ${typeName}_${SHA1sum}(bool load)
+    {
+        if (load)
+        {
+            // code that can be explicitly executed after loading
+        }
+        else
+        {
+            // code that can be explicitly executed before unloading
+        }
+    }
+}
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeRemovablePatchTypeField
+(
+    fvPatch${FieldType},
+    ${typeName}FixedValueFvPatch${FieldType}
+);
+
+
+const char* const ${typeName}FixedValueFvPatch${FieldType}::SHA1sum =
+    "${SHA1sum}";
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+${typeName}FixedValueFvPatch${FieldType}::
+${typeName}FixedValueFvPatch${FieldType}
+(
+    const fvPatch& p,
+    const DimensionedField<${TemplateType}, volMesh>& iF
+)
+:
+    mixedFvPatchField<${TemplateType}>(p, iF)
+{
+    if (${verbose:-false})
+    {
+        Info<<"construct ${typeName} sha1: ${SHA1sum}"
+            " from patch/DimensionedField\n";
+    }
+}
+
+
+${typeName}FixedValueFvPatch${FieldType}::
+${typeName}FixedValueFvPatch${FieldType}
+(
+    const ${typeName}FixedValueFvPatch${FieldType}& ptf,
+    const fvPatch& p,
+    const DimensionedField<${TemplateType}, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mixedFvPatchField<${TemplateType}>(ptf, p, iF, mapper)
+{
+    if (${verbose:-false})
+    {
+        Info<<"construct ${typeName} sha1: ${SHA1sum}"
+            " from patch/DimensionedField/mapper\n";
+    }
+}
+
+
+${typeName}FixedValueFvPatch${FieldType}::
+${typeName}FixedValueFvPatch${FieldType}
+(
+    const fvPatch& p,
+    const DimensionedField<${TemplateType}, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mixedFvPatchField<${TemplateType}>(p, iF, dict)
+{
+    if (${verbose:-false})
+    {
+        Info<<"construct ${typeName} sha1: ${SHA1sum}"
+            " from patch/dictionary\n";
+    }
+}
+
+
+${typeName}FixedValueFvPatch${FieldType}::
+${typeName}FixedValueFvPatch${FieldType}
+(
+    const ${typeName}FixedValueFvPatch${FieldType}& ptf
+)
+:
+    mixedFvPatchField<${TemplateType}>(ptf)
+{
+    if (${verbose:-false})
+    {
+        Info<<"construct ${typeName} sha1: ${SHA1sum}"
+            " as copy\n";
+    }
+}
+
+
+${typeName}FixedValueFvPatch${FieldType}::
+${typeName}FixedValueFvPatch${FieldType}
+(
+    const ${typeName}FixedValueFvPatch${FieldType}& ptf,
+    const DimensionedField<${TemplateType}, volMesh>& iF
+)
+:
+    mixedFvPatchField<${TemplateType}>(ptf, iF)
+{
+    if (${verbose:-false})
+    {
+        Info<<"construct ${typeName} sha1: ${SHA1sum} "
+            "as copy/DimensionedField\n";
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+${typeName}FixedValueFvPatch${FieldType}::
+~${typeName}FixedValueFvPatch${FieldType}()
+{
+    if (${verbose:-false})
+    {
+        Info<<"destroy ${typeName} sha1: ${SHA1sum}\n";
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void ${typeName}FixedValueFvPatch${FieldType}::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    if (${verbose:-false})
+    {
+        Info<<"updateCoeffs ${typeName} sha1: ${SHA1sum}\n";
+    }
+
+//{{{ begin code
+    ${code}
+//}}} end code
+
+    this->mixedFvPatchField<${TemplateType}>::updateCoeffs();
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

etc/codeTemplates/dynamicCode/mixedFvPatchFieldTemplate.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Description
+    Template for use with dynamic code generation of a
+    mixed fvPatchField.
+
+    - without state
+
+SourceFiles
+    mixedFvPatchFieldTemplate.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef mixedFvPatchTemplate${FieldType}_H
+#define mixedFvPatchTemplate${FieldType}_H
+
+#include "mixedFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         A templated FixedValueFvPatch
+\*---------------------------------------------------------------------------*/
+
+class ${typeName}FixedValueFvPatch${FieldType}
+:
+    public mixedFvPatchField<${TemplateType}>
+{
+public:
+
+    //- Information about the SHA1 of the code itself
+    static const char* const SHA1sum;
+
+    //- Runtime type information
+    TypeName("${typeName}");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        ${typeName}FixedValueFvPatch${FieldType}
+        (
+            const fvPatch&,
+            const DimensionedField<${TemplateType}, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        ${typeName}FixedValueFvPatch${FieldType}
+        (
+            const fvPatch&,
+            const DimensionedField<${TemplateType}, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping a copy onto a new patch
+        ${typeName}FixedValueFvPatch${FieldType}
+        (
+            const ${typeName}FixedValueFvPatch${FieldType}&,
+            const fvPatch&,
+            const DimensionedField<${TemplateType}, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        ${typeName}FixedValueFvPatch${FieldType}
+        (
+            const ${typeName}FixedValueFvPatch${FieldType}&
+        );
+
+        //- Construct and return a clone
+        virtual tmp< fvPatch${FieldType} > clone() const
+        {
+            return tmp< fvPatch${FieldType} >
+            (
+                new ${typeName}FixedValueFvPatch${FieldType}(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        ${typeName}FixedValueFvPatch${FieldType}
+        (
+            const ${typeName}FixedValueFvPatch${FieldType}&,
+            const DimensionedField<${TemplateType}, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp< fvPatch${FieldType} > clone
+        (
+            const DimensionedField<${TemplateType}, volMesh>& iF
+        ) const
+        {
+            return tmp< fvPatch${FieldType} >
+            (
+                new ${typeName}FixedValueFvPatch${FieldType}(*this, iF)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~${typeName}FixedValueFvPatch${FieldType}();
+
+
+    // Member functions
+
+        //- Update the coefficients associated with the patch field
+        virtual void updateCoeffs();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/Make/files

@@ -116,6 +116,7 @@ derivedFvPatchFields = $(fvPatchFields)/derived
 $(derivedFvPatchFields)/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
 $(derivedFvPatchFields)/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C
 $(derivedFvPatchFields)/advective/advectiveFvPatchFields.C
+$(derivedFvPatchFields)/codedMixed/codedMixedFvPatchFields.C
 $(derivedFvPatchFields)/codedFixedValue/codedFixedValueFvPatchFields.C
 $(derivedFvPatchFields)/mappedField/mappedFieldFvPatchFields.C
 $(derivedFvPatchFields)/mappedFixedInternalValue/mappedFixedInternalValueFvPatchFields.C

src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "codedMixedFvPatchField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvPatchFieldMapper.H"
+#include "volFields.H"
+#include "dynamicCode.H"
+#include "dynamicCodeContext.H"
+#include "stringOps.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+template<class Type>
+const Foam::word Foam::codedMixedFvPatchField<Type>::codeTemplateC
+    = "mixedFvPatchFieldTemplate.C";
+
+template<class Type>
+const Foam::word Foam::codedMixedFvPatchField<Type>::codeTemplateH
+    = "mixedFvPatchFieldTemplate.H";
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::setFieldTemplates
+(
+    dynamicCode& dynCode
+)
+{
+    word fieldType(pTraits<Type>::typeName);
+
+    // template type for fvPatchField
+    dynCode.setFilterVariable("TemplateType", fieldType);
+
+    // Name for fvPatchField - eg, ScalarField, VectorField, ...
+    fieldType[0] = toupper(fieldType[0]);
+    dynCode.setFilterVariable("FieldType", fieldType + "Field");
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+const Foam::IOdictionary& Foam::codedMixedFvPatchField<Type>::dict() const
+{
+    const objectRegistry& obr = this->db();
+
+    if (obr.foundObject<IOdictionary>("codeDict"))
+    {
+        return obr.lookupObject<IOdictionary>("codeDict");
+    }
+    else
+    {
+        return obr.store
+        (
+            new IOdictionary
+            (
+                IOobject
+                (
+                    "codeDict",
+                    this->db().time().system(),
+                    this->db(),
+                    IOobject::MUST_READ_IF_MODIFIED,
+                    IOobject::NO_WRITE
+                )
+            )
+        );
+    }
+}
+
+
+template<class Type>
+Foam::dlLibraryTable& Foam::codedMixedFvPatchField<Type>::libs() const
+{
+    return const_cast<dlLibraryTable&>(this->db().time().libs());
+}
+
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::prepare
+(
+    dynamicCode& dynCode,
+    const dynamicCodeContext& context
+) const
+{
+    // take no chances - typeName must be identical to redirectType_
+    dynCode.setFilterVariable("typeName", redirectType_);
+
+    // set TemplateType and FieldType filter variables
+    // (for fvPatchField)
+    setFieldTemplates(dynCode);
+
+    // compile filtered C template
+    dynCode.addCompileFile(codeTemplateC);
+
+    // copy filtered H template
+    dynCode.addCopyFile(codeTemplateH);
+
+
+    // debugging: make BC verbose
+    //  dynCode.setFilterVariable("verbose", "true");
+    //  Info<<"compile " << redirectType_ << " sha1: "
+    //      << context.sha1() << endl;
+
+    // define Make/options
+    dynCode.setMakeOptions
+        (
+            "EXE_INC = -g \\\n"
+            "-I$(LIB_SRC)/finiteVolume/lnInclude \\\n"
+            + context.options()
+            + "\n\nLIB_LIBS = \\\n"
+            + "    -lOpenFOAM \\\n"
+            + "    -lfiniteVolume \\\n"
+            + context.libs()
+        );
+}
+
+
+template<class Type>
+const Foam::dictionary& Foam::codedMixedFvPatchField<Type>::codeDict()
+const
+{
+    // use system/codeDict or in-line
+    return
+    (
+        dict_.found("code")
+      ? dict_
+      : this->dict().subDict(redirectType_)
+    );
+}
+
+
+template<class Type>
+Foam::string Foam::codedMixedFvPatchField<Type>::description() const
+{
+    return
+        "patch "
+      + this->patch().name()
+      + " on field "
+      + this->dimensionedInternalField().name();
+}
+
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::clearRedirect() const
+{
+    // remove instantiation of fvPatchField provided by library
+    redirectPatchFieldPtr_.clear();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::codedMixedFvPatchField<Type>::codedMixedFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mixedFvPatchField<Type>(p, iF),
+    codedBase(),
+    redirectPatchFieldPtr_()
+{}
+
+
+template<class Type>
+Foam::codedMixedFvPatchField<Type>::codedMixedFvPatchField
+(
+    const codedMixedFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    mixedFvPatchField<Type>(ptf, p, iF, mapper),
+    codedBase(),
+    dict_(ptf.dict_),
+    redirectType_(ptf.redirectType_),
+    redirectPatchFieldPtr_()
+{}
+
+
+template<class Type>
+Foam::codedMixedFvPatchField<Type>::codedMixedFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    mixedFvPatchField<Type>(p, iF, dict),
+    codedBase(),
+    dict_(dict),
+    redirectType_(dict.lookup("redirectType")),
+    redirectPatchFieldPtr_()
+{
+    updateLibrary(redirectType_);
+}
+
+
+template<class Type>
+Foam::codedMixedFvPatchField<Type>::codedMixedFvPatchField
+(
+    const codedMixedFvPatchField<Type>& ptf
+)
+:
+    mixedFvPatchField<Type>(ptf),
+    codedBase(),
+    dict_(ptf.dict_),
+    redirectType_(ptf.redirectType_),
+    redirectPatchFieldPtr_()
+{}
+
+
+template<class Type>
+Foam::codedMixedFvPatchField<Type>::codedMixedFvPatchField
+(
+    const codedMixedFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    mixedFvPatchField<Type>(ptf, iF),
+    codedBase(),
+    dict_(ptf.dict_),
+    redirectType_(ptf.redirectType_),
+    redirectPatchFieldPtr_()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+const Foam::mixedFvPatchField<Type>&
+Foam::codedMixedFvPatchField<Type>::redirectPatchField() const
+{
+    if (!redirectPatchFieldPtr_.valid())
+    {
+        // Construct a patch
+        // Make sure to construct the patchfield with up-to-date value
+
+        // Write the data from the mixed b.c.
+        OStringStream os;
+        mixedFvPatchField<Type>::write(os);
+        IStringStream is(os.str());
+        // Construct dictionary from it.
+        dictionary dict(is);
+
+        // Override the type to enforce the fvPatchField::New constructor
+        // to choose our type
+        dict.set("type", redirectType_);
+
+        redirectPatchFieldPtr_.set
+        (
+            dynamic_cast<mixedFvPatchField<Type>*>
+            (
+                fvPatchField<Type>::New
+                (
+                    this->patch(),
+                    this->dimensionedInternalField(),
+                    dict
+                ).ptr()
+            )
+        );
+    }
+    return redirectPatchFieldPtr_();
+}
+
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    // Make sure library containing user-defined fvPatchField is up-to-date
+    updateLibrary(redirectType_);
+
+    const mixedFvPatchField<Type>& fvp = redirectPatchField();
+
+    const_cast<mixedFvPatchField<Type>&>(fvp).updateCoeffs();
+
+    // Copy through coefficients
+    this->refValue() = fvp.refValue();
+    this->refGrad() = fvp.refGrad();
+    this->valueFraction() = fvp.valueFraction();
+
+    mixedFvPatchField<Type>::updateCoeffs();
+}
+
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::evaluate
+(
+    const Pstream::commsTypes commsType
+)
+{
+    // Make sure library containing user-defined fvPatchField is up-to-date
+    updateLibrary(redirectType_);
+
+    const mixedFvPatchField<Type>& fvp = redirectPatchField();
+
+    // - updates the value of fvp (though not used)
+    // - resets the updated() flag
+    const_cast<mixedFvPatchField<Type>&>(fvp).evaluate(commsType);
+
+    // Update the value (using the coefficients) locally
+    mixedFvPatchField<Type>::evaluate(commsType);
+}
+
+
+template<class Type>
+void Foam::codedMixedFvPatchField<Type>::write(Ostream& os) const
+{
+    mixedFvPatchField<Type>::write(os);
+    os.writeKeyword("redirectType") << redirectType_
+        << token::END_STATEMENT << nl;
+
+    if (dict_.found("code"))
+    {
+        os.writeKeyword("code")
+            << token::HASH << token::BEGIN_BLOCK;
+
+        os.writeQuoted(string(dict_["code"]), false)
+            << token::HASH << token::END_BLOCK
+            << token::END_STATEMENT << nl;
+    }
+}
+
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchField.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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::codedMixedFvPatchField
+
+Description
+    Constructs on-the-fly a new boundary condition (derived from
+    mixedFvPatchField) which is then used to evaluate.
+
+    Example:
+    \verbatim
+        movingWall
+        {
+            type            codedMixed;
+            value           uniform 0;
+            redirectType    rampedMixed;   // name of generated bc
+
+            code
+            #{
+                operator==(min(10, 0.1*this->db().time().value()));
+            #};
+
+            //codeInclude
+            //#{
+            //    #include "fvCFD.H"
+            //#};
+
+            //codeOptions
+            //#{
+            //    -I$(LIB_SRC)/finiteVolume/lnInclude
+            //#};
+        }
+    \endverbatim
+
+    A special form is if the 'code' section is not supplied. In this case
+    the code gets read from a (runTimeModifiable!) dictionary system/codeDict
+    which would have a corresponding entry
+
+    \verbatim
+    rampedMixed
+    {
+        code
+        #{
+            operator==(min(10, 0.1*this->db().time().value()));
+        #};
+    }
+    \endverbatim
+
+SeeAlso
+    Foam::dynamicCode and Foam::functionEntries::codeStream
+
+SourceFiles
+    codedMixedFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef codedMixedFvPatchField_H
+#define codedMixedFvPatchField_H
+
+#include "mixedFvPatchFields.H"
+#include "codedBase.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class dynamicCode;
+class dynamicCodeContext;
+class IOdictionary;
+
+/*---------------------------------------------------------------------------*\
+                     Class codedMixedFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class codedMixedFvPatchField
+:
+    public mixedFvPatchField<Type>,
+    public codedBase
+{
+    // Private data
+
+        //- Dictionary contents for the boundary condition
+        mutable dictionary dict_;
+
+        const word redirectType_;
+
+        mutable autoPtr<mixedFvPatchField<Type> > redirectPatchFieldPtr_;
+
+    // Private Member Functions
+
+        const IOdictionary& dict() const;
+
+        //- Set the rewrite vars controlling the Type
+        static void setFieldTemplates(dynamicCode& dynCode);
+
+        //- get the loaded dynamic libraries
+        virtual dlLibraryTable& libs() const;
+
+        //- adapt the context for the current object
+        virtual void prepare(dynamicCode&, const dynamicCodeContext&) const;
+
+        // Return a description (type + name) for the output
+        virtual string description() const;
+
+        // Clear the ptr to the redirected object
+        virtual void clearRedirect() const;
+
+        // Get the dictionary to initialize the codeContext
+        virtual const dictionary& codeDict() const;
+
+public:
+
+    // Static data members
+
+        //- Name of the C code template to be used
+        static const word codeTemplateC;
+
+        //- Name of the H code template to be used
+        static const word codeTemplateH;
+
+
+    //- Runtime type information
+    TypeName("codedMixed");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        codedMixedFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        codedMixedFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given codedMixedFvPatchField
+        //  onto a new patch
+        codedMixedFvPatchField
+        (
+            const codedMixedFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        codedMixedFvPatchField
+        (
+            const codedMixedFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new codedMixedFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        codedMixedFvPatchField
+        (
+            const codedMixedFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type> > clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new codedMixedFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+
+
+    // Member functions
+
+        //- Get reference to the underlying patchField
+        const mixedFvPatchField<Type>& redirectPatchField() const;
+
+        //- Update the coefficients associated with the patch field
+        virtual void updateCoeffs();
+
+        //- Evaluate the patch field
+        //  This is only needed to set the updated() flag of the redirectType
+        //  to false.
+        virtual void evaluate
+        (
+            const Pstream::commsTypes commsType=Pstream::blocking
+        );
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "codedMixedFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchFields.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "codedMixedFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makePatchFields(codedMixed);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchFields.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef codedMixedFvPatchFields_H
+#define codedMixedFvPatchFields_H
+
+#include "codedMixedFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(codedMixed);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/codedMixed/codedMixedFvPatchFieldsFwd.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef codedMixedFvPatchFieldsFwd_H
+#define codedMixedFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class codedMixedFvPatchField;
+
+makePatchTypeFieldTypedefs(codedMixed);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //