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

Merge branch 'master' of ssh://hunt/~OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
andy
2008-09-26 13:41:46 +01:00
parent 6501c66731 d8f7b85fd9
commit 4fb952b062
8 changed files with 610 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/postProcessing/minMaxFields/IOminMaxFields.H Normal file
View File

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

4
src/postProcessing/minMaxFields/Make/files Normal file
View File

@ -0,0 +1,4 @@
minMaxFields.C
minMaxFieldsFunctionObject.C
LIB = $(FOAM_LIBBIN)/libminMaxFields

8
src/postProcessing/minMaxFields/Make/options Normal file
View File

@ -0,0 +1,8 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
LIB_LIBS = \
-lfiniteVolume \
-lmeshTools

203
src/postProcessing/minMaxFields/minMaxFields.C Normal file
View File

@ -0,0 +1,203 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 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 "minMaxFields.H"
#include "volFields.H"
#include "dictionary.H"
#include "Time.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(minMaxFields, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::minMaxFields::minMaxFields
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
log_(false),
fieldSet_(),
minMaxFieldsFilePtr_(NULL)
{
// Check if the available mesh is an fvMesh otherise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"minMaxFields::minMaxFields"
"(const objectRegistry& obr, const dictionary& dict)"
) << "No fvMesh available, deactivating."
<< endl;
}
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::minMaxFields::~minMaxFields()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::minMaxFields::read(const dictionary& dict)
{
if (active_)
{
log_ = dict.lookupOrDefault<Switch>("log", false);
dict.lookup("fields") >> fieldSet_;
}
}
void Foam::minMaxFields::makeFile()
{
// Create the minMaxFields file if not already created
if (!minMaxFieldsFilePtr_.valid())
{
if (debug)
{
Info<< "Creating minMaxFields file." << endl;
}
// File update
if (Pstream::master())
{
fileName minMaxFieldsDir;
if (Pstream::parRun())
{
// Put in undecomposed case (Note: gives problems for
// distributed data running)
minMaxFieldsDir =
obr_.time().path()/".."/name_/obr_.time().timeName();
}
else
{
minMaxFieldsDir =
obr_.time().path()/name_/obr_.time().timeName();
}
// Create directory if does not exist.
mkDir(minMaxFieldsDir);
// Open new file at start up
minMaxFieldsFilePtr_.reset
(
new OFstream(minMaxFieldsDir/(type() + ".dat"))
);
// Add headers to output data
writeFileHeader();
}
}
}
void Foam::minMaxFields::writeFileHeader()
{
if (minMaxFieldsFilePtr_.valid())
{
minMaxFieldsFilePtr_()
<< "# Time" << tab << "field" << tab << "min" << tab << "max"
<< endl;
}
}
void Foam::minMaxFields::execute()
{
// Do nothing - only valid on write
}
void Foam::minMaxFields::write()
{
if (active_)
{
// Create the minMaxFields file if not already created
makeFile();
forAll(fieldSet_, fieldI)
{
calcMinMaxFields<scalar>(fieldSet_[fieldI]);
calcMinMaxFields<vector>(fieldSet_[fieldI]);
calcMinMaxFields<sphericalTensor>(fieldSet_[fieldI]);
calcMinMaxFields<symmTensor>(fieldSet_[fieldI]);
calcMinMaxFields<tensor>(fieldSet_[fieldI]);
}
}
}
template<>
void Foam::minMaxFields::calcMinMaxFields<Foam::scalar>
(
const word& fieldName
)
{
if (obr_.foundObject<volScalarField>(fieldName))
{
const scalarField& field = obr_.lookupObject<scalarField>(fieldName);
scalar minValue = min(field);
scalar maxValue = max(field);
reduce(minValue, minOp<scalar>());
reduce(maxValue, maxOp<scalar>());
if (Pstream::master())
{
minMaxFieldsFilePtr_() << obr_.time().value() << tab
<< fieldName << tab << minValue << tab << maxValue << endl;
if (log_)
{
Info<< "minMaxFields output:" << nl
<< " min(" << fieldName << ") = " << minValue << nl
<< " max(" << fieldName << ") = " << maxValue << nl
<< endl;
}
}
}
}
// ************************************************************************* //

182
src/postProcessing/minMaxFields/minMaxFields.H Normal file
View File

@ -0,0 +1,182 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 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
Class
Foam::minMaxFields
Description
Calculates scalar minimim and maximum field values.
For variables with rank > 0, computes the magnitude of the min/max
values.
Data written to the file \<timeDir\>/minMaxFields.dat
SourceFiles
minMaxFields.C
IOminMaxFields.H
\*---------------------------------------------------------------------------*/
#ifndef minMaxFields_H
#define minMaxFields_H
#include "primitiveFieldsFwd.H"
#include "volFieldsFwd.H"
#include "labelHashSet.H"
#include "OFstream.H"
#include "Switch.H"
#include "pointFieldFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class minMaxFields Declaration
\*---------------------------------------------------------------------------*/
class minMaxFields
{
protected:
// Private data
//- Name of this set of forces,
// Also used as the name of the probes directory.
word name_;
const objectRegistry& obr_;
//- on/off switch
bool active_;
//- Switch to send output to Info as well as to file
Switch log_;
//- Patches to integrate forces over
wordList fieldSet_;
//- Forces/moment file ptr
autoPtr<OFstream> minMaxFieldsFilePtr_;
// Private Member Functions
//- If the forces file has not been created create it
void makeFile();
//- Disallow default bitwise copy construct
minMaxFields(const minMaxFields&);
//- Disallow default bitwise assignment
void operator=(const minMaxFields&);
//- Output file header information
virtual void writeFileHeader();
public:
//- Runtime type information
TypeName("minMaxFields");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
minMaxFields
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
// Destructor
virtual ~minMaxFields();
// Member Functions
//- Return name of the set of forces
virtual const word& name() const
{
return name_;
}
//- Read the forces data
virtual void read(const dictionary&);
//- Execute
virtual void execute();
//- Calculate the field min/max
template<class Type>
void calcMinMaxFields(const word& fieldName);
//- Write the minMaxFields
virtual void write();
//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}
//- Update for changes of mesh
virtual void movePoints(const pointField&)
{}
};
// Template specialisation for scalar fields
template<>
void minMaxFields::calcMinMaxFields<scalar>(const word& fieldName);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "minMaxFieldsTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

43
src/postProcessing/minMaxFields/minMaxFieldsFunctionObject.C Normal file
View File

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

55
src/postProcessing/minMaxFields/minMaxFieldsFunctionObject.H Normal file
View File

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

65
src/postProcessing/minMaxFields/minMaxFieldsTemplates.C Normal file
View File

@ -0,0 +1,65 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2008 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 "minMaxFields.H"
#include "volFields.H"
#include "dictionary.H"
#include "Time.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type>
void Foam::minMaxFields::calcMinMaxFields(const word& fieldName)
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
if (obr_.foundObject<fieldType>(fieldName))
{
const fieldType& field = obr_.lookupObject<fieldType>(fieldName);
scalar minValue = min(mag(field)).value();
scalar maxValue = max(mag(field)).value();
reduce(minValue, minOp<scalar>());
reduce(maxValue, maxOp<scalar>());
if (Pstream::master())
{
minMaxFieldsFilePtr_() << obr_.time().value() << tab
<< fieldName << tab << minValue << tab << maxValue << endl;
if (log_)
{
Info<< "minMaxFields output:" << nl
<< " min(mag(" << fieldName << ")) = " << minValue << nl
<< " max(mag(" << fieldName << ")) = " << maxValue << nl
<< endl;
}
}
}
}
// ************************************************************************* //