Skip to content
Snippets Groups Projects
Commit 039adebb authored by Andrew Heather's avatar Andrew Heather
Browse files

added new div postprocessing function, and removed old divPhi and divU apps

parent 2db98ed9
No related branches found
No related tags found
No related merge requests found
divPhiApp.C
EXE = $(FOAM_APPBIN)/divPhi
EXE_INC = \
-I$(FOAM_SRC)/postProcessing/postCalc \
-I$(LIB_SRC)/finiteVolume/lnInclude
EXE_LIBS = \
$(FOAM_LIBBIN)/postCalc.o \
-lfiniteVolume
/*---------------------------------------------------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.0 |
| \\ / A nd | Web: http://www.openfoam.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
// divU tool definition
description "div(U) calculation";
divUDict
{
type dictionary;
description "divU control dictionary";
dictionaryPath "system";
entries
{
arguments
{
type rootCaseTimeArguments;
}
}
}
// ************************************************************************* //
divUApp.C
EXE = $(FOAM_APPBIN)/divU
EXE_INC = \
-I$(FOAM_SRC)/postProcessing/postCalc \
-I$(LIB_SRC)/finiteVolume/lnInclude
EXE_LIBS = \
$(FOAM_LIBBIN)/postCalc.o \
-lfiniteVolume
......@@ -5,5 +5,6 @@ field/components/components.C
field/mag/mag.C
field/magSqr/magSqr.C
field/magGrad/magGrad.C
field/div/div.C
LIB = $(FOAM_LIBBIN)/libfoamCalcFunctions
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2007 OpenCFD Ltd.
\\/ 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 2 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, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
\*---------------------------------------------------------------------------*/
#include "div.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
namespace calcTypes
{
defineTypeNameAndDebug(div, 0);
addToRunTimeSelectionTable(calcType, div, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::calcTypes::div::div()
:
calcType()
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::calcTypes::div::~div()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::calcTypes::div::init()
{
Foam::argList::validArgs.append("div");
argList::validArgs.append("fieldName1 .. fieldNameN");
}
void Foam::calcTypes::div::preCalc
(
const argList& args,
const Time& runTime,
const fvMesh& mesh
)
{
if (args.additionalArgs().size() < 2)
{
Info<< nl << "must specify one or more fields" << nl;
args.printUsage();
FatalError.exit();
}
}
void Foam::calcTypes::div::calc
(
const argList& args,
const Time& runTime,
const fvMesh& mesh
)
{
const stringList& params = args.additionalArgs();
for (label fieldi=1; fieldi<params.size(); fieldi++)
{
const word fieldName(params[fieldi]);
IOobject fieldHeader
(
fieldName,
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// Check field exists
if (fieldHeader.headerOk())
{
bool processed = false;
writeDivField<surfaceScalarField>(fieldHeader, mesh, processed);
writeDivField<volVectorField>(fieldHeader, mesh, processed);
if (!processed)
{
FatalError
<< "Unable to process " << fieldName << nl
<< "No call to div for fields of type "
<< fieldHeader.headerClassName() << nl << nl
<< exit(FatalError);
}
}
else
{
Info<< " No " << fieldName << endl;
}
}
}
// ************************************************************************* //
......@@ -22,63 +22,118 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Application
divU
Class
Foam::div
Description
Calculates and writes the divergence of the velocity field U.
The -noWrite option just outputs the max/min values without writing the
field.
Writes scalar fields corresponding to the divergence of the supplied
field (name) for each time.
SourceFiles
div.C
\*---------------------------------------------------------------------------*/
#include "calc.H"
#include "fvc.H"
#ifndef div_H
#define div_H
#include "calcType.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
namespace Foam
{
namespace calcTypes
{
bool writeResults = !args.options().found("noWrite");
IOobject Uheader
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
if (Uheader.headerOk())
{
Info<< " Reading U" << endl;
volVectorField U(Uheader, mesh);
Info<< " Calculating divU" << endl;
volScalarField divU
(
IOobject
/*---------------------------------------------------------------------------*\
Class div Declaration
\*---------------------------------------------------------------------------*/
class div
:
public calcType
{
// Private Member Functions
//- Disallow default bitwise copy construct
div(const div&);
//- Disallow default bitwise assignment
void operator=(const div&);
protected:
// Member Functions
// Calculation routines
//- Initialise - typically setting static variables,
// e.g. command line arguments
virtual void init();
//- Pre-time loop calculations
virtual void preCalc
(
const argList& args,
const Time& runTime,
const fvMesh& mesh
);
//- Time loop calculations
virtual void calc
(
const argList& args,
const Time& runTime,
const fvMesh& mesh
);
// I-O
//- Write div fields
template<class Type>
void writeDivField
(
"divU",
runTime.timeName(),
mesh
),
fvc::div(U)
);
Info<< "div(U) max/min : "
<< max(divU).value() << " "
<< min(divU).value() << endl;
if (writeResults)
{
divU.write();
}
}
else
{
Info<< " No U" << endl;
}
}
const IOobject& header,
const fvMesh& mesh,
bool& processed
);
public:
//- Runtime type information
TypeName("div");
// Constructors
//- Construct null
div();
// Destructor
virtual ~div();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace calcTypes
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "writeDivField.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //
......@@ -22,58 +22,38 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Application
divPhi
Description
Calculates and writes the divergence of the flux field phi. The
-noWrite option just outputs the max/min values without writing the
field.
\*---------------------------------------------------------------------------*/
#include "calc.H"
#include "fvc.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
template<class Type>
void Foam::calcTypes::div::writeDivField
(
const IOobject& header,
const fvMesh& mesh,
bool& processed
)
{
bool writeResults = !args.options().found("noWrite");
Info<< " Reading phi" << endl;
surfaceScalarField phi
(
IOobject
(
"phi",
runTime.timeName(),
mesh,
IOobject::MUST_READ
),
mesh
);
if (header.headerClassName() == Type::typeName)
{
Info<< " Reading " << header.name() << endl;
Type field(header, mesh);
Info<< " Calculating divPhi" << endl;
volScalarField divPhi
(
IOobject
Info<< " Calculating div" << header.name() << endl;
volScalarField divField
(
"divPhi",
runTime.timeName(),
mesh
),
fvc::div(phi)
);
Info<< "div(phi) max/min : "
<< max(divPhi).value() << " "
<< min(divPhi).value() << endl;
if (writeResults)
{
divPhi.write();
IOobject
(
"div" + header.name(),
mesh.time().timeName(),
mesh,
IOobject::NO_READ
),
fvc::div(field)
);
divField.write();
processed = true;
}
}
// ************************************************************************* //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment