Commit 14601aa8 authored by Henry Weller's avatar Henry Weller
Browse files

Function1::Scale: New function to scale a given function by a scalar function, e.g. a ramp

For example in the potentialFreeSurfaceFoam/oscillatingBox tutorial it is
cleaner to apply the "linearRamp" function to the "sine" function rather than
using an amplitude table:

    floatingObject
    {
        type            fixedNormalInletOutletVelocity;

        fixTangentialInflow false;

        normalVelocity
        {
            type            uniformFixedValue;

            uniformValue
            {
                type        scale;

                value
                {
                    type sine;

                    frequency   1;
                    amplitude   0.025;
                    scale       (0 1 0);
                    level       (0 0 0);
                }

                scale
                {
                    type linearRamp;

                    duration 10;
                }
            }
        }

        value           uniform (0 0 0);
    }
parent 98de2293
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 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 "Scale.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
void Foam::Function1Types::Scale<Type>::read(const dictionary& coeffs)
{
scale_ = Function1<scalar>::New("scale", coeffs);
value_ = Function1<Type>::New("value", coeffs);
}
template<class Type>
Foam::Function1Types::Scale<Type>::Scale
(
const word& entryName,
const dictionary& dict
)
:
Function1<Type>(entryName)
{
read(dict);
}
template<class Type>
Foam::Function1Types::Scale<Type>::Scale(const Scale<Type>& se)
:
Function1<Type>(se),
scale_(se.scale_, false),
value_(se.value_, false)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::Function1Types::Scale<Type>::~Scale()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
Type Foam::Function1Types::Scale<Type>::value(const scalar t) const
{
return scale_->value(t)*value_->value(t);
}
template<class Type>
void Foam::Function1Types::Scale<Type>::writeData(Ostream& os) const
{
Function1<Type>::writeData(os);
os << token::END_STATEMENT << nl;
os << indent << word(this->name() + "Coeffs") << nl;
os << indent << token::BEGIN_BLOCK << incrIndent << nl;
scale_->writeData(os);
value_->writeData(os);
os << decrIndent << indent << token::END_BLOCK << endl;
}
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 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::Function1Types::Scale
Description
Function1 which scales a given 'value' function by a scalar 'scale'
function.
This is particularly useful to ramp a time-varying value by one of the
monotonic ramp functions.
Usage for a vector:
\verbatim
<entryName>
{
type scale;
scale
{
type linearRamp;
start 0;
duration 10;
}
value
{
type sine;
frequency 10;
amplitude 1;
scale (1 0.1 0);
level (10 1 0);
}
}
\endverbatim
Where:
\table
Property | Description | Required
value | Function of type Function1<Type> | yes
scale | Scaling function of type Function1<scalar> | yes
\endtable
SourceFiles
Scale.C
\*---------------------------------------------------------------------------*/
#ifndef Scale_H
#define Scale_H
#include "Function1.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace Function1Types
{
/*---------------------------------------------------------------------------*\
Class Scale Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class Scale
:
public Function1<Type>
{
// Private data
//- Scalar scaling function
autoPtr<Function1<scalar>> scale_;
//- Value function
autoPtr<Function1<Type>> value_;
// Private Member Functions
//- Read the coefficients from the given dictionary
void read(const dictionary& coeffs);
//- Disallow default bitwise assignment
void operator=(const Scale<Type>&);
public:
// Runtime type information
TypeName("scale");
// Constructors
//- Construct from entry name and dictionary
Scale
(
const word& entryName,
const dictionary& dict
);
//- Copy constructor
Scale(const Scale<Type>& se);
//- Construct and return a clone
virtual tmp<Function1<Type>> clone() const
{
return tmp<Function1<Type>>(new Scale<Type>(*this));
}
//- Destructor
virtual ~Scale();
// Member Functions
//- Return value for time t
Type value(const scalar t) const;
//- Write in dictionary format
virtual void writeData(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Function1Types
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "Scale.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
......@@ -32,6 +32,7 @@ License
#include "CSV.H"
#include "Table.H"
#include "TableFile.H"
#include "Scale.H"
#include "fieldTypes.H"
......@@ -47,7 +48,8 @@ License
makeFunction1Type(Square, Type); \
makeFunction1Type(CSV, Type); \
makeFunction1Type(Table, Type); \
makeFunction1Type(TableFile, Type);
makeFunction1Type(TableFile, Type); \
makeFunction1Type(Scale, Type);
namespace Foam
{
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment