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 /home/noisy3/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
andy
2011-05-20 18:17:12 +01:00
parent ccd2321a90 d0cc87297d
commit a2919d8079
12 changed files with 632 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/createShellMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2010-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2010-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -453,6 +453,7 @@ void Foam::createShellMesh::setRefinement
label region0 = pointRegions_[eFaces[0]][fp0];
label region1 = pointRegions_[eFaces[0]][fp1];
// Pick up points with correct normal
if (layerI == 0)
{
newF[0] = f[fp0];
@ -468,6 +469,22 @@ void Foam::createShellMesh::setRefinement
newF[3] = addedPoints[nLayers*region0+layerI];
}
// Optionally rotate so e[0] is always 0th vertex. Note that
// this normally is automatically done by coupled face ordering
// but with NOORDERING we have to do it ourselves.
if (f[fp0] != e[0])
{
// rotate one back to get newF[1] (originating from e[0])
// into newF[0]
label v0 = newF[0];
for (label i = 0; i < newF.size()-1; i++)
{
newF[i] = newF[newF.fcIndex(i)];
}
newF.last() = v0;
}
label minCellI = addedCells[nLayers*eFaces[0]+layerI];
label maxCellI;
label patchI;
@ -569,6 +586,21 @@ void Foam::createShellMesh::setRefinement
newF[3] = addedPoints[nLayers*region0+layerI];
}
// Optionally rotate so e[0] is always 0th vertex. Note that
// this normally is automatically done by coupled face
// ordering but with NOORDERING we have to do it ourselves.
if (f[fp0] != e[0])
{
// rotate one back to get newF[1] (originating
// from e[0]) into newF[0].
label v0 = newF[0];
for (label i = 0; i < newF.size()-1; i++)
{
newF[i] = newF[newF.fcIndex(i)];
}
newF.last() = v0;
}
////if (ePatches.size() == 0)
//{
// Pout<< "Adding from MULTI face:"

38
src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
View File

@ -24,11 +24,12 @@ License
\*---------------------------------------------------------------------------*/
#include "globalIndexAndTransform.H"
#include "coupledPolyPatch.H"
#include "cyclicPolyPatch.H"
// * * * * * * * * * * * * Private Static Data Members * * * * * * * * * * * //
defineTypeNameAndDebug(Foam::globalIndexAndTransform, 0);
const Foam::label Foam::globalIndexAndTransform::base_ = 32;
@ -478,6 +479,41 @@ Foam::globalIndexAndTransform::globalIndexAndTransform
determineTransformPermutations();
determinePatchTransformSign();
if (debug && transforms_.size() > 1)
{
Info<< "Determined global transforms :" << endl;
Info<< "\t\ttranslation\trotation" << endl;
forAll(transforms_, i)
{
Info<< '\t' << i << '\t';
if (transforms_[i].hasR())
{
Info<< transforms_[i].t() << '\t' << transforms_[i].R();
}
else
{
Info<< transforms_[i].t() << '\t' << "---";
}
Info<< endl;
}
Info<< endl;
const polyBoundaryMesh& patches = mesh_.boundaryMesh();
Info<< "\tpatch\ttransform\tsign" << endl;
forAll(patchTransformSign_, patchI)
{
if (patchTransformSign_[patchI].first() != -1)
{
Info<< '\t' << patches[patchI].name()
<< '\t' << patchTransformSign_[patchI].first()
<< '\t' << patchTransformSign_[patchI].second()
<< endl;
}
}
Info<< endl;
}
}

4
src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.H
View File

@ -164,6 +164,10 @@ public:
friend class globalPoints;
// Declare name of the class and its debug switch
ClassName("globalIndexAndTransform");
// Constructors
//- Construct from components

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

@ -1,3 +1,6 @@
partialWrite/partialWrite.C
partialWrite/partialWriteFunctionObject.C
writeRegisteredObject/writeRegisteredObject.C
writeRegisteredObject/writeRegisteredObjectFunctionObject.C

88
src/postProcessing/functionObjects/IO/controlDict Normal file
View File

@ -0,0 +1,88 @@
/*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.7.1 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "system";
object controlDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
application icoFoam;
startFrom startTime;
startTime 0;
stopAt endTime;
endTime 0.5;
deltaT 0.005;
writeControl timeStep;
writeInterval 20;
purgeWrite 0;
writeFormat ascii;
writePrecision 6;
writeCompression uncompressed;
timeFormat general;
timePrecision 6;
runTimeModifiable yes;
functions
{
partialWrite
{
// Write some registered objects more often than others.
// Above writeControl determines most frequent dump.
type partialWrite;
// Where to load it from
functionObjectLibs ("libIOFunctionObjects.so");
// Execute upon outputTime
outputControl outputTime;
// Objects to write every outputTime
objectNames (p);
// Write as normal every writeInterval'th outputTime.
writeInterval 3;
}
dumpObjects
{
// Forcibly write registered objects. E.g. fields that have been
// created with NO_READ.
type writeRegisteredObject;
// Where to load it from
functionObjectLibs ("libIOFunctionObjects.so");
// Execute upon outputTime
outputControl outputTime;
// Objects to write
objectNames ();
}
}
// ************************************************************************* //

49
src/postProcessing/functionObjects/IO/partialWrite/IOpartialWrite.H Normal file
View File

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

142
src/postProcessing/functionObjects/IO/partialWrite/partialWrite.C Normal file
View File

@ -0,0 +1,142 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 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 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 "partialWrite.H"
#include "dictionary.H"
#include "Time.H"
#include "IOobjectList.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(partialWrite, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::partialWrite::partialWrite
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr)
{
read(dict);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::partialWrite::~partialWrite()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::partialWrite::read(const dictionary& dict)
{
dict.lookup("objectNames") >> objectNames_;
dict.lookup("writeInterval") >> writeInterval_;
writeInstance_ = 0;
Info<< type() << " " << name() << ":" << nl
<< " dumping every outputTime :";
forAllConstIter(HashSet<word>, objectNames_, iter)
{
Info<< ' ' << iter.key();
}
Info<< nl
<< " dumping all other fields every "
<< writeInterval_ << "th outputTime" << nl
<< endl;
if (writeInterval_ < 1)
{
FatalIOErrorIn("partialWrite::read(const dictionary&)", dict)
<< "Illegal value for writeInterval " << writeInterval_
<< ". It should be >= 1."
<< exit(FatalIOError);
}
}
void Foam::partialWrite::execute()
{
//Pout<< "execute at time " << obr_.time().timeName()
// << " index:" << obr_.time().timeIndex() << endl;
}
void Foam::partialWrite::end()
{
//Pout<< "end at time " << obr_.time().timeName() << endl;
// Do nothing - only valid on write
}
void Foam::partialWrite::write()
{
//Pout<< "write at time " << obr_.time().timeName() << endl;
if (obr_.time().outputTime())
{
// Above check so it can be used both with
// outputControl timeStep;
// outputInterval 1;
// or with
// outputControl outputTime;
writeInstance_++;
if (writeInstance_ == writeInterval_)
{
// Normal dump
writeInstance_ = 0;
}
else
{
// Delete all but marked objects
IOobjectList objects(obr_, obr_.time().timeName());
forAllConstIter(HashPtrTable<IOobject>, objects, iter)
{
if (!objectNames_.found(iter()->name()))
{
const fileName f = obr_.time().timePath()/iter()->name();
//Pout<< " rm " << f << endl;
rm(f);
}
}
}
}
}
// ************************************************************************* //

156
src/postProcessing/functionObjects/IO/partialWrite/partialWrite.H Normal file
View File

@ -0,0 +1,156 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2011 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 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::partialWrite
Description
Allows some fields/registered objects to be written more often than others.
Works in the opposite way: deletes at intermediate times all
but selected fields.
SourceFiles
partialWrite.C
IOpartialWrite.H
\*---------------------------------------------------------------------------*/
#ifndef partialWrite_H
#define partialWrite_H
#include "pointFieldFwd.H"
#include "HashSet.H"
#include "DynamicList.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward declaration of classes
class objectRegistry;
class dictionary;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class partialWrite Declaration
\*---------------------------------------------------------------------------*/
class partialWrite
{
protected:
// Private data
//- Name of this set of partialWrite
word name_;
const objectRegistry& obr_;
// Read from dictionary
//- Names of objects to dump always
HashSet<word> objectNames_;
//- Write interval for restart dump
label writeInterval_;
//- Current dump instance. If reaches writeInterval do a full write.
label writeInstance_;
// Private Member Functions
//- Disallow default bitwise copy construct
partialWrite(const partialWrite&);
//- Disallow default bitwise assignment
void operator=(const partialWrite&);
public:
//- Runtime type information
TypeName("partialWrite");
// Constructors
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
partialWrite
(
const word& name,
const objectRegistry&,
const dictionary&,
const bool loadFromFiles = false
);
//- Destructor
virtual ~partialWrite();
// Member Functions
//- Return name of the partialWrite
virtual const word& name() const
{
return name_;
}
//- Read the partialWrite 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();
//- Write the partialWrite
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
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

46
src/postProcessing/functionObjects/IO/partialWrite/partialWriteFunctionObject.C Normal file
View File

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

54
src/postProcessing/functionObjects/IO/partialWrite/partialWriteFunctionObject.H Normal file
View File

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

7
src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.C
View File

@ -44,7 +44,6 @@ Foam::writeRegisteredObject::writeRegisteredObject
:
name_(name),
obr_(obr),
active_(true),
objectNames_()
{
read(dict);
@ -60,12 +59,9 @@ Foam::writeRegisteredObject::~writeRegisteredObject()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::writeRegisteredObject::read(const dictionary& dict)
{
if (active_)
{
dict.lookup("objectNames") >> objectNames_;
}
}
void Foam::writeRegisteredObject::execute()
@ -81,8 +77,6 @@ void Foam::writeRegisteredObject::end()
void Foam::writeRegisteredObject::write()
{
if (active_)
{
forAll(objectNames_, i)
{
@ -109,7 +103,6 @@ void Foam::writeRegisteredObject::write()
}
}
}
// ************************************************************************* //

4
src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H
View File

@ -65,10 +65,6 @@ protected:
const objectRegistry& obr_;
//- On/off switch
bool active_;
// Read from dictionary
//- Names of objects to control