zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ENH: Added new calcMag function object to calculate mag(field)

Browse Source
This commit is contained in:
andy
2012-11-28 15:42:28 +00:00
parent e2dc793da0
commit 7e2368524f
6 changed files with 568 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/postProcessing/functionObjects/fvTools/calcMag/IOcalcMag.H Normal file
View File

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

126
src/postProcessing/functionObjects/fvTools/calcMag/calcMag.C Normal file
View File

@ -0,0 +1,126 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "calcMag.H"
#include "volFields.H"
#include "dictionary.H"
#include "calcMag.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
defineTypeNameAndDebug(Foam::calcMag, 0);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::calcMag::calcMag
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
fieldName_("undefined-fieldName"),
resultName_("undefined-resultName")
{
// Check if the available mesh is an fvMesh, otherwise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"calcMag::calcMag"
"("
"const word&, "
"const objectRegistry&, "
"const dictionary&, "
"const bool"
")"
) << "No fvMesh available, deactivating." << nl
<< endl;
}
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::calcMag::~calcMag()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::calcMag::read(const dictionary& dict)
{
if (active_)
{
dict.lookup("fieldName") >> fieldName_;
dict.lookup("resultName") >> resultName_;
}
}
void Foam::calcMag::execute()
{
// Do nothing - only valid on write
}
void Foam::calcMag::end()
{
// Do nothing - only valid on write
}
void Foam::calcMag::write()
{
if (active_)
{
bool processed = false;
calc<scalar>(fieldName_, resultName_, processed);
calc<vector>(fieldName_, resultName_, processed);
calc<sphericalTensor>(fieldName_, resultName_, processed);
calc<symmTensor>(fieldName_, resultName_, processed);
calc<tensor>(fieldName_, resultName_, processed);
if (!processed)
{
WarningIn("void Foam::calcMag::write()")
<< "Unprocessed field " << fieldName_ << endl;
}
}
}
// ************************************************************************* //

174
src/postProcessing/functionObjects/fvTools/calcMag/calcMag.H Normal file
View File

@ -0,0 +1,174 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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::calcMag
Group
grpFVFunctionObjects
Description
This function object calculates the magnitude of a field. The operation
can be applied to any volume or surface fieldsm and the output is a
volume or surface scalar field.
SourceFiles
calcMag.C
IOcalcMag.H
\*---------------------------------------------------------------------------*/
#ifndef calcMag_H
#define calcMag_H
#include "volFieldsFwd.H"
#include "surfaceFieldsFwd.H"
#include "pointFieldFwd.H"
#include "OFstream.H"
#include "Switch.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class mapPolyMesh;
class dimensionSet;
/*---------------------------------------------------------------------------*\
Class calcMag Declaration
\*---------------------------------------------------------------------------*/
class calcMag
{
// Private data
//- Name of this calcMag object
word name_;
//- Reference to the database
const objectRegistry& obr_;
//- On/off switch
bool active_;
//- Name of field to process
word fieldName_;
//- Name of result field
word resultName_;
// Private Member Functions
//- Helper function to create/store/return the mag field
template<class FieldType>
FieldType& magField(const word& magName, const dimensionSet& dims);
//- Helper function to calculate the gradient of different field types
template<class Type>
void calc
(
const word& fieldName,
const word& resultName,
bool& processed
);
//- Disallow default bitwise copy construct
calcMag(const calcMag&);
//- Disallow default bitwise assignment
void operator=(const calcMag&);
public:
//- Runtime type information
TypeName("calcMag");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
calcMag
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
//- Destructor
virtual ~calcMag();
// Member Functions
//- Return name of the set of calcMag
virtual const word& name() const
{
return name_;
}
//- Read the calcMag 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();
//- Calculate the calcMag and write
virtual void write();
//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}
//- Update for changes of mesh
virtual void movePoints(const pointField&)
{}
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "calcMagTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

42
src/postProcessing/functionObjects/fvTools/calcMag/calcMagFunctionObject.C Normal file
View File

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

53
src/postProcessing/functionObjects/fvTools/calcMag/calcMagFunctionObject.H Normal file
View File

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

124
src/postProcessing/functionObjects/fvTools/calcMag/calcMagTemplates.C Normal file
View File

@ -0,0 +1,124 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012 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 "fvMesh.H"
#include "Time.H"
#include "volFields.H"
#include "surfaceFields.H"
template<class FieldType>
FieldType& Foam::calcMag::magField
(
const word& magName,
const dimensionSet& dims
)
{
const fvMesh& mesh = refCast<const fvMesh>(obr_);
if (!mesh.foundObject<FieldType>(magName))
{
FieldType* magFieldPtr
(
new FieldType
(
IOobject
(
magName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("zero", dims, 0.0)
)
);
mesh.objectRegistry::store(magFieldPtr);
}
const FieldType& f = mesh.lookupObject<FieldType>(magName);
return const_cast<FieldType&>(f);
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::calcMag::calc
(
const word& fieldName,
const word& resultName,
bool& processed
)
{
typedef GeometricField<Type, fvPatchField, volMesh> vfType;
typedef GeometricField<Type, fvsPatchField, surfaceMesh> sfType;
const fvMesh& mesh = refCast<const fvMesh>(obr_);
word magName = resultName;
if (magName == "none")
{
magName = "mag(" + fieldName + ")";
}
if (mesh.foundObject<vfType>(fieldName))
{
const vfType& vf = mesh.lookupObject<vfType>(fieldName);
volScalarField& field =
magField<volScalarField>(magName, vf.dimensions());
field = mag(vf);
Info<< type() << " output:" << nl
<< " writing " << field.name() << " field" << nl << endl;
field.write();
processed = true;
}
else if (mesh.foundObject<sfType>(fieldName))
{
const sfType& sf = mesh.lookupObject<sfType>(fieldName);
surfaceScalarField& field =
magField<surfaceScalarField>(magName, sf.dimensions());
field = mag(sf);
Info<< type() << " output:" << nl
<< " writing " << field.name() << " field" << nl << endl;
field.write();
processed = true;
}
}
// ************************************************************************* //