songtianlun/openfoam
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ENH: Added new vorticity function object

Browse Source
This commit is contained in:
andy 2014-04-22 12:40:24 +01:00 committed by Andrew Heather
parent d4ab5953ca
commit 04effdf52d
6 changed files with 468 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/postProcessing/functionObjects/utilities/Make/files
View File

@ -33,6 +33,9 @@ timeActivatedFileUpdate/timeActivatedFileUpdateFunctionObject.C
turbulenceFields/turbulenceFields.C
turbulenceFields/turbulenceFieldsFunctionObject.C
vorticity/vorticity.C
vorticity/vorticityFunctionObject.C
wallShearStress/wallShearStress.C
wallShearStress/wallShearStressFunctionObject.C

49
src/postProcessing/functionObjects/utilities/vorticity/IOvorticity.H Normal file
View File

@ -0,0 +1,49 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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/>.
Typedef
Foam::IOvorticity
Description
Instance of the generic IOOutputFilter for vorticity.
\*---------------------------------------------------------------------------*/
#ifndef IOvorticity_H
#define IOvorticity_H
#include "vorticity.H"
#include "IOOutputFilter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef IOOutputFilter<vorticity> IOvorticity;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

169
src/postProcessing/functionObjects/utilities/vorticity/vorticity.C Normal file
View File

@ -0,0 +1,169 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "vorticity.H"
#include "volFields.H"
#include "dictionary.H"
#include "fvcCurl.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(vorticity, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::vorticity::vorticity
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
UName_("U"),
outputName_(typeName)
{
// Check if the available mesh is an fvMesh, otherwise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"vorticity::vorticity"
"("
"const word&, "
"const objectRegistry&, "
"const dictionary&, "
"const bool"
")"
) << "No fvMesh available, deactivating " << name_ << nl
<< endl;
}
read(dict);
if (active_)
{
const fvMesh& mesh = refCast<const fvMesh>(obr_);
volVectorField* vorticityPtr
(
new volVectorField
(
IOobject
(
outputName_,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedVector("0", dimless/dimTime, vector::zero)
)
);
mesh.objectRegistry::store(vorticityPtr);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::vorticity::~vorticity()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::vorticity::read(const dictionary& dict)
{
if (active_)
{
UName_ = dict.lookupOrDefault<word>("UName", "U");
if (UName_ != "U")
{
outputName_ = typeName + "(" + UName_ + ")";
}
}
}
void Foam::vorticity::execute()
{
if (active_)
{
const volVectorField& U = obr_.lookupObject<volVectorField>(UName_);
volVectorField& vorticity =
const_cast<volVectorField&>
(
obr_.lookupObject<volVectorField>(outputName_)
);
vorticity = fvc::curl(U);
}
}
void Foam::vorticity::end()
{
if (active_)
{
execute();
}
}
void Foam::vorticity::timeSet()
{
// Do nothing
}
void Foam::vorticity::write()
{
if (active_)
{
const volVectorField& vorticity =
obr_.lookupObject<volVectorField>(outputName_);
Info<< type() << " " << name_ << " output:" << nl
<< " writing field " << vorticity.name() << nl
<< endl;
vorticity.write();
}
}
// ************************************************************************* //

152
src/postProcessing/functionObjects/utilities/vorticity/vorticity.H Normal file
View File

@ -0,0 +1,152 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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::vorticity
Group
grpUtilitiesFunctionObjects
Description
This function object calculates the vorticity, the curl of the velocity.
SourceFiles
vorticity.C
IOvorticity.H
\*---------------------------------------------------------------------------*/
#ifndef vorticity_H
#define vorticity_H
#include "volFieldsFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class polyMesh;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class vorticity Declaration
\*---------------------------------------------------------------------------*/
class vorticity
{
// Private data
//- Name of this set of vorticity objects
word name_;
//- Reference to the database
const objectRegistry& obr_;
//- On/off switch
bool active_;
//- Name of velocity field, default is "U"
word UName_;
//- Name of vorticity field
word outputName_;
// Private Member Functions
//- Disallow default bitwise copy construct
vorticity(const vorticity&);
//- Disallow default bitwise assignment
void operator=(const vorticity&);
public:
//- Runtime type information
TypeName("vorticity");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
vorticity
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
//- Destructor
virtual ~vorticity();
// Member Functions
//- Return name of the set of vorticity
virtual const word& name() const
{
return name_;
}
//- Read the vorticity data
virtual void read(const dictionary&);
//- Execute, currently does nothing
virtual void execute();
//- Execute at the final time-loop, currently does nothing
virtual void end();
//- Called when time was set at the end of the Time::operator++
virtual void timeSet();
//- Calculate the vorticity and write
virtual void write();
//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}
//- Update for changes of mesh
virtual void movePoints(const polyMesh&)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/postProcessing/functionObjects/utilities/vorticity/vorticityFunctionObject.C Normal file
View File

@ -0,0 +1,42 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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 "vorticityFunctionObject.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineNamedTemplateTypeNameAndDebug(vorticityFunctionObject, 0);
addToRunTimeSelectionTable
(
functionObject,
vorticityFunctionObject,
dictionary
);
}
// ************************************************************************* //

53
src/postProcessing/functionObjects/utilities/vorticity/vorticityFunctionObject.H Normal file
View File

@ -0,0 +1,53 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2014 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/>.
Typedef
Foam::vorticityFunctionObject
Description
FunctionObject wrapper around vorticity to allow it to be created
via the functions entry within controlDict.
SourceFiles
vorticityFunctionObject.C
\*---------------------------------------------------------------------------*/
#ifndef vorticityFunctionObject_H
#define vorticityFunctionObject_H
#include "vorticity.H"
#include "OutputFilterFunctionObject.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef OutputFilterFunctionObject<vorticity> vorticityFunctionObject;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //