1

Previous: codedFixedValue Up: Creating new boundary condition Next: Test case: longMixerVessel
This is an automatically generated documentation by LaTeX2HTML utility. In case of any issue, please, contact us at info@cfdsupport.com.

uniformFixedValue

  • The uniformFixedValue boundary condition extends the fixedValue boundary condition
  • It sets the field to the uniform value as a function of time
  • It is applicable to all variables types (scalars, vectors, etc.)
  • Look inside the source code:
    # cat $FOAM_SRC/finiteVolume/fields/fvPatchFields/\
    derived/uniformFixedValue/uniformFixedValueFvPatchField.H

     

    Description
        This boundary condition provides a uniform fixed value condition.
    
    Usage
        \table
            Property     | Description             | Required    | Default value
            uniformValue | uniform value           |         yes |
        \endtable
    
        Example of the boundary condition specification:
        \verbatim
        <patchName>
        {
            type            uniformFixedValue;
            uniformValue    constant 0.2;
        }
        \endverbatim
    
    Note
        The uniformValue entry is a Function1 type, able to describe time
        varying functions.  The example above gives the usage for supplying a
        constant value.
    

     

  • The uniformValue entry is a Function1 type.
  • To implement ([*]) we have create new function.
  • We need to find the place in OF structure where the Function1 is implemented:
    # find $FOAM_SRC -name "Function1"
  • We can read the path and take a similar function to ([*]) using which we implement the new function.
  • The function Sine seems to be a good choice.
  • First, we start by copying the Sine into our working directory, e.g.,
    # mkdir $FOAM_RUN/newFunction1
    # cp -r $FOAM_SRC/OpenFOAM/primitives/functions/Function1/Sine $FOAM_RUN/newFunction1
  • We have to rename it, e.g., to TrainingExp:
    • Rename the directory Sine to TrainingExp
    • Rename all files in TrainingExp directory to TrainingExp*
      # rename "s/Sine/TrainingExp/g" Sine*
    • Rename all occurances of Sine to TrainingExp in all TrainingExp.* files # sed -i "s/Sine/TrainingExp/g" TrainingExp*
  • Now we have to reimplement the Sine function to our TrainingExp
  • We are going to implement a general version of ([*]):

     

    $\displaystyle x = \frac{x_0}{1 + e^{A\frac{t}{t_0}+B}}$(13.2)

     

  • Lets look inside the file TrainingExp.h:
    namespace Foam
    {
    namespace Function1Types
    {
    
    /*---------------------------------------------------------------------------*\
                               Class TrainingExp Declaration
    \*---------------------------------------------------------------------------*/
    
    template<class Type>
    class TrainingExp
    :
        public Function1<Type>
    {
        // Private data
    
            //- Start-time for the sin function
            scalar t0_;
    
            //- Scalar amplitude of the sin function
            autoPtr<Function1<scalar>> amplitude_;
    
            //- Frequency of the sin function
            autoPtr<Function1<scalar>> frequency_;
    
            //- Scaling factor of the sin function
            autoPtr<Function1<Type>> scale_;
    
            //- Level to which the sin function is added
            autoPtr<Function1<Type>> level_;
    
    
        // Private Member Functions
    
            //- Read the coefficients from the given dictionary
            void read(const dictionary& coeffs);
    
            //- Disallow default bitwise assignment
            void operator=(const TrainingExp<Type>&);
    
    
    public:
    
        // Runtime type information
        TypeName("trainingExp");
    
    
        // Constructors
    
            //- Construct from entry name and dictionary
            TrainingExp
            (
                const word& entryName,
                const dictionary& dict
            );
    
            //- Copy constructor
            TrainingExp(const TrainingExp<Type>& se);
    
    
        //- Destructor
        virtual ~TrainingExp();
    
    
        // Member Functions
    
            //- Return value for time t
            virtual inline Type value(const scalar t) const;
    
            //- Write in dictionary format
            virtual void writeData(Ostream& os) const;
    };
    

     

  • First lines, which are not listed here, cotains a decription of the implemented function. We leave it to the user to change it by him or herself.
  • This is a declaration of the templated class TrainingExp
  • Line 126 defines the name which will be used to refer to this particular Function1 type, therefore it has to be renamed to “trainingExp”
  • The private data holds the constants of the implemented functions
  • We need to define new constant for the new boundary condition we rename it to trainingExp
  • Lines 98-111 declare constants for the original Sine function, we are going to modify it in the following way:
    • t0_ – is kept
    • amplitude_ – is renamed to A_
    • frequence_ – is renamed to B_
    • scale_ – is deleted
    • level_ – is renamed to x0_
  • We cen read that A_ and B_ can be Function1 type of scalar, nevertheless we will use it as constants
  • x0_ is a Function1 type of general Type, i.e. we will specify it later on as scalar, vector etc.
  • In all files TrainingExp* we have to redefine the private members to the new names given above
  • We can do it by a series of the following commands:
    # sed -i "s/amplitude/A/g" TrainingExp*
    # sed -i "s/frequency/B/g" TrainingExp*
    # sed -i "s/level/x0/g" TrainingExp*
  • All entries containing scale_ variable have to be deleted.
  • Finally we need to implement formula ([*]) in the file TrainingExpI.H:
    #include "TrainingExp.H"
    #include "mathematicalConstants.H"
    
    // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
    
    template<class Type>
    inline Type Foam::Function1Types::TrainingExp<Type>::value(const scalar t) const
    {
        return
        (t < t0_) ? 
            x0_->value(t) * ( 1.0 / 
                  ( 1.0 + exp(A_->value(t) * t/t0_ + B_->value(t)) ) )
                            : x0_->value(t);
    
  • To compile this code we need to create the Make directory and provide explicit template class instantiation.
  • We can get inspired in the source code:
    # cat $FOAM_SRC/OpenFOAM/primitives/functions/Function1/makeFunction1.C
  • We need to do a similar file which is relevent for the TrainingExp function # cp $FOAM_SRC/OpenFOAM/primitives/functions/Function1/makeFunction1s.C \
    $FOAM_RUN/newFunction1
  • Therefore, we modify it to the following form:
    #include "TrainingExp.H"
    #include "fieldTypes.H"
    
    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
    
    #define makeFunction1s(Type)                                                   \
        makeFunction1Type(TrainingExp, Type);                                             \
    
    namespace Foam
    {
        makeFunction1s(scalar);
        makeFunction1s(vector);    
    }
    
  • The last thing is to set the wmake routines, we have to create the Make directory with the files and options files.
    # mkdir $FOAM_RUN/newFunction1/Make
  • We have to provide the file options – there is no need to explicitely link any header files or libraries
  • The file files have to contain the source .C file which is going to be compiled and provide the name of the new library, i.e.,
    /* Run-time selectable functions */
    makeFunction1s.C
    
    LIB = $(FOAM_USER_LIBBIN)/libUserFunction1
    
  • Now is time to compile the code:
    # cd $FOAM_RUN/newFunction1
    # wmake
  • When the compilation is done without any error, it is ready for a test.
  • We are going to use the cavity case similarly as for codedFixedValue in previous secion.
  • We modify the boundary condition at the movingWall patch for velocity $ U$ as follows
        movingWall
        {
            type            uniformFixedValue;
            uniformValue
            {
                type        trainingExp;
                t0          5;
                A           -10;
                B           5;
                x0          (1 0 0);
            }
        }
    
  • Additionally, we have to provide the user created library inside the controlDict:
    libs (
       "libUserFunction1.so"
    );
    

     

  • Now we can test the new boundary condition:
    # blockMesh
    # pisoFoam

     

  • We can check the values at the movingWall in paraView or extract the patch values using the command:
    # pisoFoam -postProcess -func "patchAverage(U,name=movingWall)" | grep "of U = \|Time ="

 

% increaseToFixedValue/increaseToFixedValueFvPatchFields.C
% 
% LIB = $(FOAM_USER_LIBBIN)/libuserBCs
% EXE_INC = \
%     -I$(LIB_SRC)/finiteVolume/lnInclude
% 
% LIB_LIBS = \
%     -lfiniteVolume
% template<class Type>
% scalar increaseToFixedValueFvPatchField<Type>::currentScale() const
% {
%     const scalar t = this->db().time().timeOutputValue();
%     const scalar t0 = t0_->value(t);
%     return 1.0/(1.0 + exp(-10*t/t0 + 5));
% }
% timePrecision   6;
% 
% runTimeModifiable yes;
% 
% libs ("libuserBCs.so");
% 
% // ************************************************************************* //
% 
% libs ("libuserBCs.dll");
% boundaryField
% {
%     movingWall      
%     {
%         type            increaseToFixedValue;
%         refValue        uniform (1 0 0);
%         t0              constant 0.5;
%         value           uniform (0 0 0);
%     }