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://noisy/home/noisy2/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
henry
2008-07-31 10:33:52 +01:00
parent 436b8f075d e9d424b7a8
commit 3bd7010781
41 changed files with 879 additions and 1165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/solvers/multiphase/twoPhaseEulerFoam/kineticTheoryModels/kineticTheoryModel/kineticTheoryModel.C
View File

@ -256,8 +256,7 @@ void Foam::kineticTheoryModel::solve()
/(alpha*rhoa_*sqrtPi*(ThetaSqrt + TsmallSqrt));
// bulk viscosity p. 45 (Lun et al. 1984).
volScalarField lambda_ =
(4.0/3.0)*sqr(alpha_)*rhoa_*da_*gs0_*(1.0+e_)*ThetaSqrt/sqrtPi;
lambda_ = (4.0/3.0)*sqr(alpha_)*rhoa_*da_*gs0_*(1.0+e_)*ThetaSqrt/sqrtPi;
// stress tensor, Definitions, Table 3.1, p. 43

7
applications/utilities/mesh/conversion/Optional/Allwmake
View File

@ -5,15 +5,12 @@ set -x
# run from this directory only
cd ${0%/*} || exit 1
# build libccmio if required
if [ ! -e $FOAM_LIBBIN/libccmio.so ]
then
# build libccmio and create lnInclude directory
(
cd $WM_THIRD_PARTY_DIR && ./AllwmakeLibccmio
)
fi
# if the library built okay, the headers must exist too
# if the library built okay, the headers should exist too
if [ -e $FOAM_LIBBIN/libccmio.so ]
then
wmake ccm26ToFoam

71
applications/utilities/mesh/generation/blockMesh/blockMeshApp.C
View File

@ -22,9 +22,29 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Application
blockMesh
Description
A multi-block mesh generator.
Uses the block mesh description found in
@a constant/polyMesh/blockMeshDict
(or @a constant/\<region\>/polyMesh/blockMeshDict).
Usage
- blockMesh [OPTION]
@param -blockTopology \n
Write the topology as a set of edges in OBJ format.
@param -region \<name\> \n
Specify an alternative mesh region.
@param -dict \<dictionary\> \n
Specify an alternative dictionary for the block mesh description.
\*---------------------------------------------------------------------------*/
#include "Time.H"
@ -60,9 +80,12 @@ int main(int argc, char *argv[])
word regionName;
fileName polyMeshDir;
word dictName("blockMeshDict");
fileName dictPath(runTime.constant());
if (args.options().found("region"))
{
// constant/<region>/polyMesh/blockMeshDict
regionName = args.options()["region"];
polyMeshDir = regionName/polyMesh::meshSubDir;
@ -70,49 +93,57 @@ int main(int argc, char *argv[])
}
else
{
// constant/polyMesh/blockMeshDict
regionName = polyMesh::defaultRegion;
polyMeshDir = polyMesh::meshSubDir;
}
Info<< nl << "Reading block mesh description dictionary" << endl;
word dictName("blockMeshDict");
fileName dictPath(runTime.constant()/polyMeshDir);
fileName dictLocal = polyMeshDir;
if (args.options().found("dict"))
{
fileName userDict(args.options()["dict"]);
wordList elems(fileName(args.options()["dict"]).components());
dictName = elems[elems.size()-1];
dictPath = elems[0];
dictLocal = "";
dictName = userDict.name();
dictPath = userDict.path();
if (elems.size() == 1)
{
dictPath = ".";
}
else if (elems.size() > 2)
{
dictLocal = fileName(SubList<word>(elems, elems.size()-2, 1));
}
}
IOobject meshDescriptionIOobject
IOobject meshDictIo
(
dictName,
dictPath,
dictLocal,
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
);
if (!meshDescriptionIOobject.headerOk())
if (!meshDictIo.headerOk())
{
FatalErrorIn(args.executable())
<< "Cannot open mesh description file: " << nl
<< dictPath/dictName << nl
<< "Cannot open mesh description file\n "
<< meshDictIo.objectPath()
<< nl
<< exit(FatalError);
}
IOdictionary meshDescription(meshDescriptionIOobject);
Info<< nl << "Creating block mesh from\n "
<< meshDictIo.objectPath() << endl;
IOdictionary meshDict(meshDictIo);
Info<< nl << "Creating block mesh" << endl;
blockMesh blocks(meshDescription);
blockMesh blocks(meshDict);
if (writeTopo)
{
@ -169,7 +200,7 @@ int main(int argc, char *argv[])
(
runTime,
runTime.constant(),
polyMeshDir, //polyMesh::meshSubDir
polyMeshDir,
patchNames,
patchTypes,
defaultFacesName,
@ -197,11 +228,11 @@ int main(int argc, char *argv[])
// Read in a list of dictionaries for the merge patch pairs
if (meshDescription.found("mergePatchPairs"))
if (meshDict.found("mergePatchPairs"))
{
List<Pair<word> > mergePatchPairs
(
meshDescription.lookup("mergePatchPairs")
meshDict.lookup("mergePatchPairs")
);
if (mergePatchPairs.size())

4
applications/utilities/postProcessing/graphics/PV3FoamReader/Allwclean
View File

@ -1,7 +1,5 @@
#!/bin/sh
set -x
rm -r PV3FoamReader/Make
rm -rf PV3FoamReader/Make
wclean libso vtkPV3Foam

2
applications/utilities/postProcessing/graphics/PV3FoamReader/PV3FoamReader/PV3FoamReader.xml
View File

@ -1,6 +1,6 @@
<ParaViewReaders>
<Reader name="PV3FoamReader"
extensions="OpenFOAM"
file_description="OpenFOAM">
file_description="OpenFOAM Reader">
</Reader>
</ParaViewReaders>

65
applications/utilities/postProcessing/graphics/PV3FoamReader/PV3FoamReader/PV3FoamReader_SM.xml
View File

@ -31,26 +31,6 @@
<TimeRangeInformationHelper/>
</DoubleVectorProperty>
<!-- Update GUI check box -->
<IntVectorProperty
name="UpdateGUI"
command="SetUpdateGUI"
number_of_elements="1"
default_values="0">
<BooleanDomain
name="bool"/>
</IntVectorProperty>
<!-- Cache mesh check box -->
<IntVectorProperty
name="CacheMesh"
command="SetCacheMesh"
number_of_elements="1"
default_values="1">
<BooleanDomain
name="bool"/>
</IntVectorProperty>
<!-- ExtrapolateWalls check box -->
<IntVectorProperty
name="ExtrapolateWalls"
@ -186,34 +166,25 @@
</ArraySelectionDomain>
</StringVectorProperty>
<!-- Available times array -->
<!-- PV3FOAM_TIMESELECTION must be defined when compiling vtkPV3Foam
might discard this in the future
<StringVectorProperty
name="TimeArrayInfo"
information_only="1">
<ArraySelectionInformationHelper
attribute_name="Time"/>
</StringVectorProperty>
<StringVectorProperty
name="TimeStatus"
command="SetTimeArrayStatus"
number_of_elements="0"
repeat_command="1"
number_of_elements_per_command="2"
element_types="2 0"
information_property="TimeArrayInfo">
<ArraySelectionDomain
name="array_list">
<RequiredProperties>
<Property name="TimeArrayInfo"
function="ArrayList"/>
</RequiredProperties>
</ArraySelectionDomain>
</StringVectorProperty>
<!-- Cache mesh check box -->
<IntVectorProperty
name="CacheMesh"
command="SetCacheMesh"
number_of_elements="1"
default_values="1">
<BooleanDomain
name="bool"/>
</IntVectorProperty>
PV3FOAM_TIMESELECTION
-->
<!-- Update GUI check box -->
<IntVectorProperty
name="UpdateGUI"
command="SetUpdateGUI"
number_of_elements="1"
default_values="0">
<BooleanDomain
name="bool"/>
</IntVectorProperty>
</SourceProxy>
</ProxyGroup>

259
applications/utilities/postProcessing/graphics/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx
View File

@ -21,32 +21,19 @@
// VTK includes
#include "vtkCallbackCommand.h"
#include "vtkCellArray.h"
#include "vtkCellData.h"
#include "vtkDataArraySelection.h"
#include "vtkDirectory.h"
#include "vtkDoubleArray.h"
#include "vtkErrorCode.h"
#include "vtkFloatArray.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkIntArray.h"
#include "vtkMultiBlockDataSet.h"
#include "vtkObjectFactory.h"
#include "vtkPoints.h"
#include "vtkRenderer.h"
#include "vtkSMRenderViewProxy.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "vtkStringArray.h"
#include "vtkUnstructuredGrid.h"
#include "vtkUnstructuredGridAlgorithm.h"
#include "vtkAlgorithmOutput.h"
#include "vtkMultiBlockDataSet.h"
// Foam includes
#include "vtkPV3Foam.H"
vtkCxxRevisionMacro(vtkPV3FoamReader, "$Revision: 1.2$");
vtkCxxRevisionMacro(vtkPV3FoamReader, "$Revision: 1.5$");
vtkStandardNewMacro(vtkPV3FoamReader);
@ -60,17 +47,22 @@ vtkPV3FoamReader::vtkPV3FoamReader()
FileName = NULL;
foamData_ = NULL;
CacheMesh = 0;
output1_ = NULL;
UpdateGUI = 1;
UpdateGUIOld = 1;
TimeStep = 0;
TimeStepRange[0] = 0;
TimeStepRange[1] = 0;
CacheMesh = 0;
ExtrapolateWalls = 0;
IncludeSets = 0;
IncludeZones = 0;
ShowPatchNames = 0;
TimeSelection = vtkDataArraySelection::New();
UpdateGUI = 1;
UpdateGUIOld = 1;
RegionSelection = vtkDataArraySelection::New();
VolFieldSelection = vtkDataArraySelection::New();
PointFieldSelection = vtkDataArraySelection::New();
@ -85,11 +77,6 @@ vtkPV3FoamReader::vtkPV3FoamReader()
);
SelectionObserver->SetClientData(this);
TimeSelection->AddObserver
(
vtkCommand::ModifiedEvent,
this->SelectionObserver
);
RegionSelection->AddObserver
(
vtkCommand::ModifiedEvent,
@ -112,6 +99,7 @@ vtkPV3FoamReader::vtkPV3FoamReader()
);
}
vtkPV3FoamReader::~vtkPV3FoamReader()
{
vtkDebugMacro(<<"Deconstructor");
@ -126,7 +114,6 @@ vtkPV3FoamReader::~vtkPV3FoamReader()
delete [] FileName;
}
TimeSelection->RemoveObserver(this->SelectionObserver);
RegionSelection->RemoveObserver(this->SelectionObserver);
VolFieldSelection->RemoveObserver(this->SelectionObserver);
PointFieldSelection->RemoveObserver(this->SelectionObserver);
@ -134,7 +121,6 @@ vtkPV3FoamReader::~vtkPV3FoamReader()
SelectionObserver->Delete();
TimeSelection->Delete();
RegionSelection->Delete();
VolFieldSelection->Delete();
PointFieldSelection->Delete();
@ -152,7 +138,6 @@ int vtkPV3FoamReader::RequestInformation
{
vtkDebugMacro(<<"RequestInformation");
if (Foam::vtkPV3Foam::debug)
{
cout<<"REQUEST_INFORMATION\n";
@ -164,38 +149,6 @@ int vtkPV3FoamReader::RequestInformation
return 0;
}
if (Foam::vtkPV3Foam::debug)
{
vtkInformation* outputInfo = this->GetOutputPortInformation(0);
vtkMultiBlockDataSet* output = vtkMultiBlockDataSet::SafeDownCast
(
outputInfo->Get(vtkMultiBlockDataSet::DATA_OBJECT())
);
outputInfo->Print(cout);
if (output)
{
output->Print(cout);
}
else
{
cout << "no output\n";
}
this->GetExecutive()->GetOutputInformation(0)->Print(cout);
int nInfo = outputVector->GetNumberOfInformationObjects();
cout<< "requestInfo with " << nInfo << " items:\n";
for (int i=0; i<nInfo; i++)
{
vtkInformation *info = outputVector->GetInformationObject(i);
info->Print(cout);
}
}
vtkInformation *outInfo = outputVector->GetInformationObject(0);
if (!foamData_)
@ -205,17 +158,22 @@ int vtkPV3FoamReader::RequestInformation
(
outInfo->Get(vtkMultiBlockDataSet::DATA_OBJECT())
);
foamData_ = new Foam::vtkPV3Foam(FileName, this, output);
foamData_->UpdateInformation();
if (Foam::vtkPV3Foam::debug)
{
cout<< "constructed vtkPV3Foam with output: ";
output->Print(cout);
}
foamData_ = new Foam::vtkPV3Foam(FileName, this);
}
else
{
vtkDebugMacro("RequestInformation: updating information");
foamData_->UpdateInformation();
}
int nTimeSteps = 0;
double* timeSteps = foamData_->timeSteps(nTimeSteps);
double* timeSteps = foamData_->findTimes(nTimeSteps);
outInfo->Set
(
@ -230,7 +188,7 @@ int vtkPV3FoamReader::RequestInformation
timeRange[0] = timeSteps[0];
timeRange[1] = timeSteps[nTimeSteps-1];
if (Foam::vtkPV3Foam::debug)
if (Foam::vtkPV3Foam::debug > 1)
{
cout<<"nTimeSteps " << nTimeSteps << "\n";
cout<<"timeRange " << timeRange[0] << " to " << timeRange[1] << "\n";
@ -271,22 +229,17 @@ int vtkPV3FoamReader::RequestData
return 0;
}
if (Foam::vtkPV3Foam::debug)
{
int nInfo = outputVector->GetNumberOfInformationObjects();
if (Foam::vtkPV3Foam::debug)
{
cout<<"requestData with " << nInfo << " items\n";
}
for (int i=0; i<nInfo; i++)
for (int i = 0; i < nInfo; ++i)
{
vtkInformation *info = outputVector->GetInformationObject(i);
if (Foam::vtkPV3Foam::debug)
{
info->Print(cout);
}
}
}
vtkInformation* outInfo = outputVector->GetInformationObject(0);
vtkMultiBlockDataSet* output = vtkMultiBlockDataSet::SafeDownCast
@ -423,91 +376,29 @@ void vtkPV3FoamReader::removePatchNamesFromView()
}
void vtkPV3FoamReader::PrintSelf
(
ostream& os,
vtkIndent indent
)
void vtkPV3FoamReader::PrintSelf(ostream& os, vtkIndent indent)
{
vtkDebugMacro(<<"PrintSelf");
this->Superclass::PrintSelf(os,indent);
os<< indent << "File name: "
<< (this->FileName ? this->FileName : "(none)") << "\n";
os<< indent << "Number of meshes: " << foamData_->numberOfMeshes() << "\n";
os<< indent << "Number of nodes: " << foamData_->numberOfPoints() << "\n";
os<< indent << "Number of cells: " << foamData_->numberOfCells() << "\n";
os<< indent << "Number of available time steps: " << foamData_->numberOfAvailableTimes()
<< endl;
foamData_->PrintSelf(os, indent);
os<< indent << "Time step range: "
<< this->TimeStepRange[0] << " - " << this->TimeStepRange[1]
<< endl;
<< "\n";
os<< indent << "Time step: " << this->TimeStep << endl;
return;
}
vtkDataArraySelection* vtkPV3FoamReader::GetTimeSelection()
{
vtkDebugMacro(<<"GetTimeSelection");
return TimeSelection;
}
int vtkPV3FoamReader::GetNumberOfTimeArrays()
{
vtkDebugMacro(<<"GetNumberOf TimeArrays");
return TimeSelection->GetNumberOfArrays();
}
const char* vtkPV3FoamReader::GetTimeArrayName
(
int index
)
{
vtkDebugMacro(<<"GetTimeArrayName");
return TimeSelection->GetArrayName(index);
}
int vtkPV3FoamReader::GetTimeArrayStatus
(
const char* name
)
{
vtkDebugMacro(<<"GetTimeArrayStatus");
return TimeSelection->ArrayIsEnabled(name);
}
void vtkPV3FoamReader::SetTimeArrayStatus
(
const char* name,
int status
)
{
vtkDebugMacro(<<"SetTimeArrayStatus");
if (status)
{
TimeSelection->EnableArray(name);
}
else
{
TimeSelection->DisableArray(name);
}
}
// ----------------------------------------------------------------------
// Region selection list control
vtkDataArraySelection* vtkPV3FoamReader::GetRegionSelection()
{
vtkDebugMacro(<<"GetRegionSelection");
return RegionSelection;
}
@ -515,38 +406,25 @@ vtkDataArraySelection* vtkPV3FoamReader::GetRegionSelection()
int vtkPV3FoamReader::GetNumberOfRegionArrays()
{
vtkDebugMacro(<<"GetNumberOfRegionArrays");
return RegionSelection->GetNumberOfArrays();
}
const char* vtkPV3FoamReader::GetRegionArrayName
(
int index
)
const char* vtkPV3FoamReader::GetRegionArrayName(int index)
{
vtkDebugMacro(<<"GetRegionArrayName");
return RegionSelection->GetArrayName(index);
}
int vtkPV3FoamReader::GetRegionArrayStatus
(
const char* name
)
int vtkPV3FoamReader::GetRegionArrayStatus(const char* name)
{
vtkDebugMacro(<<"GetRegionArrayStatus");
return RegionSelection->ArrayIsEnabled(name);
}
void vtkPV3FoamReader::SetRegionArrayStatus
(
const char* name,
int status
)
void vtkPV3FoamReader::SetRegionArrayStatus(const char* name, int status)
{
vtkDebugMacro(<<"SetRegionArrayStatus");
@ -561,10 +439,12 @@ void vtkPV3FoamReader::SetRegionArrayStatus
}
// ----------------------------------------------------------------------
// volField selection list control
vtkDataArraySelection* vtkPV3FoamReader::GetVolFieldSelection()
{
vtkDebugMacro(<<"GetVolFieldSelection");
return VolFieldSelection;
}
@ -572,41 +452,27 @@ vtkDataArraySelection* vtkPV3FoamReader::GetVolFieldSelection()
int vtkPV3FoamReader::GetNumberOfVolFieldArrays()
{
vtkDebugMacro(<<"GetNumberOfVolFieldArrays");
return VolFieldSelection->GetNumberOfArrays();
}
const char* vtkPV3FoamReader::GetVolFieldArrayName
(
int index
)
const char* vtkPV3FoamReader::GetVolFieldArrayName(int index)
{
vtkDebugMacro(<<"GetVolFieldArrayName");
return VolFieldSelection->GetArrayName(index);
}
int vtkPV3FoamReader::GetVolFieldArrayStatus
(
const char* name
)
int vtkPV3FoamReader::GetVolFieldArrayStatus(const char* name)
{
vtkDebugMacro(<<"GetVolFieldArrayStatus");
return VolFieldSelection->ArrayIsEnabled(name);
}
void vtkPV3FoamReader::SetVolFieldArrayStatus
(
const char* name,
int status
)
void vtkPV3FoamReader::SetVolFieldArrayStatus(const char* name, int status)
{
vtkDebugMacro(<<"SetVolFieldArrayStatus");
if (status)
{
VolFieldSelection->EnableArray(name);
@ -618,10 +484,12 @@ void vtkPV3FoamReader::SetVolFieldArrayStatus
}
// ----------------------------------------------------------------------
// pointField selection list control
vtkDataArraySelection* vtkPV3FoamReader::GetPointFieldSelection()
{
vtkDebugMacro(<<"GetPointFieldSelection");
return PointFieldSelection;
}
@ -629,41 +497,27 @@ vtkDataArraySelection* vtkPV3FoamReader::GetPointFieldSelection()
int vtkPV3FoamReader::GetNumberOfPointFieldArrays()
{
vtkDebugMacro(<<"GetNumberOfPointFieldArrays");
return PointFieldSelection->GetNumberOfArrays();
}
const char* vtkPV3FoamReader::GetPointFieldArrayName
(
int index
)
const char* vtkPV3FoamReader::GetPointFieldArrayName(int index)
{
vtkDebugMacro(<<"GetPointFieldArrayName");
return PointFieldSelection->GetArrayName(index);
}
int vtkPV3FoamReader::GetPointFieldArrayStatus
(
const char* name
)
int vtkPV3FoamReader::GetPointFieldArrayStatus(const char* name)
{
vtkDebugMacro(<<"GetPointFieldArrayStatus");
return PointFieldSelection->ArrayIsEnabled(name);
}
void vtkPV3FoamReader::SetPointFieldArrayStatus
(
const char* name,
int status
)
void vtkPV3FoamReader::SetPointFieldArrayStatus(const char* name, int status)
{
vtkDebugMacro(<<"SetPointFieldArrayStatus");
if (status)
{
PointFieldSelection->EnableArray(name);
@ -675,10 +529,12 @@ void vtkPV3FoamReader::SetPointFieldArrayStatus
}
// ----------------------------------------------------------------------
// lagrangianField selection list control
vtkDataArraySelection* vtkPV3FoamReader::GetLagrangianFieldSelection()
{
vtkDebugMacro(<<"GetLagrangianFieldSelection");
return LagrangianFieldSelection;
}
@ -686,29 +542,20 @@ vtkDataArraySelection* vtkPV3FoamReader::GetLagrangianFieldSelection()
int vtkPV3FoamReader::GetNumberOfLagrangianFieldArrays()
{
vtkDebugMacro(<<"GetNumberOfLagrangianFieldArrays");
return LagrangianFieldSelection->GetNumberOfArrays();
}
const char* vtkPV3FoamReader::GetLagrangianFieldArrayName
(
int index
)
const char* vtkPV3FoamReader::GetLagrangianFieldArrayName(int index)
{
vtkDebugMacro(<<"GetLagrangianFieldArrayName");
return LagrangianFieldSelection->GetArrayName(index);
}
int vtkPV3FoamReader::GetLagrangianFieldArrayStatus
(
const char* name
)
int vtkPV3FoamReader::GetLagrangianFieldArrayStatus(const char* name)
{
vtkDebugMacro(<<"GetLagrangianFieldArrayStatus");
return LagrangianFieldSelection->ArrayIsEnabled(name);
}
@ -720,7 +567,6 @@ void vtkPV3FoamReader::SetLagrangianFieldArrayStatus
)
{
vtkDebugMacro(<<"SetLagrangianFieldArrayStatus");
if (status)
{
LagrangianFieldSelection->EnableArray(name);
@ -731,6 +577,7 @@ void vtkPV3FoamReader::SetLagrangianFieldArrayStatus
}
}
// ----------------------------------------------------------------------
void vtkPV3FoamReader::SelectionModifiedCallback
(
@ -747,7 +594,7 @@ void vtkPV3FoamReader::SelectionModifiedCallback
void vtkPV3FoamReader::SelectionModified()
{
vtkDebugMacro(<<"SelectionModified");
Modified();
}
// ************************************************************************* //

49
applications/utilities/postProcessing/graphics/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.h
View File

@ -14,11 +14,9 @@
=========================================================================*/
// .NAME vtkPV3FoamReader - reads a dataset in OpenFOAM format
// .SECTION Description
// vtkPV3FoamReader creates an multiblock dataset. It reads a controlDict
// file, mesh information, and time dependent data. The controlDict file
// contains timestep information. The polyMesh folders contain mesh information
// The time folders contain transient data for the cells Each folder can
// contain any number of data files.
// vtkPV3FoamReader creates an multiblock dataset.
// It uses the OpenFOAM infrastructure (fvMesh, etc) to
// handle mesh and field data.
#ifndef __vtkPV3FoamReader_h
#define __vtkPV3FoamReader_h
@ -66,6 +64,13 @@ public:
vtkSetStringMacro(FileName);
vtkGetStringMacro(FileName);
// Time control
// Set/Get the timestep and the timestep range
vtkSetMacro(TimeStep, int);
vtkGetMacro(TimeStep, int);
vtkSetVector2Macro(TimeStepRange, int);
vtkGetVector2Macro(TimeStepRange, int);
// GUI update control
vtkSetMacro(UpdateGUI, int);
vtkGetMacro(UpdateGUI, int);
@ -86,24 +91,10 @@ public:
vtkSetMacro(IncludeZones, int);
vtkGetMacro(IncludeZones, int);
// FOAM patch names control
// FOAM display patch names control
vtkSetMacro(ShowPatchNames, int);
vtkGetMacro(ShowPatchNames, int);
// Time-step slider control
vtkSetMacro(TimeStep, int);
vtkGetMacro(TimeStep, int);
vtkSetVector2Macro(TimeStepRange, int);
vtkGetVector2Macro(TimeStepRange, int);
// Time selection list control
vtkDataArraySelection* GetTimeSelection();
int GetNumberOfTimeArrays();
const char* GetTimeArrayName(int index);
int GetTimeArrayStatus(const char* name);
void SetTimeArrayStatus(const char* name, int status);
// Region selection list control
vtkDataArraySelection* GetRegionSelection();
int GetNumberOfRegionArrays();
@ -121,16 +112,16 @@ public:
// pointField selection list control
vtkDataArraySelection* GetPointFieldSelection();
int GetNumberOfPointFieldArrays();
const char* GetPointFieldArrayName(int index);
int GetPointFieldArrayStatus(const char* name);
void SetPointFieldArrayStatus(const char* name, int status);
const char* GetPointFieldArrayName(int index);
// lagrangianField selection list control
vtkDataArraySelection* GetLagrangianFieldSelection();
int GetNumberOfLagrangianFieldArrays();
const char* GetLagrangianFieldArrayName(int index);
int GetLagrangianFieldArrayStatus(const char* name);
void SetLagrangianFieldArrayStatus(const char* name, int status);
const char* GetLagrangianFieldArrayName(int index);
// Callback registered with the SelectionObserver
// for all the selection lists
@ -182,7 +173,11 @@ private:
//- Remove patch names from the view
void removePatchNamesFromView();
int TimeStep;
int TimeStepRange[2];
int CacheMesh;
int ExtrapolateWalls;
int IncludeSets;
int IncludeZones;
@ -190,18 +185,22 @@ private:
int UpdateGUI;
int UpdateGUIOld;
int TimeStep;
int TimeStepRange[2];
vtkDataArraySelection* TimeSelection;
vtkDataArraySelection* RegionSelection;
vtkDataArraySelection* VolFieldSelection;
vtkDataArraySelection* PointFieldSelection;
vtkDataArraySelection* LagrangianFieldSelection;
//- Access to the output port1
vtkMultiBlockDataSet* output1_;
//BTX
Foam::vtkPV3Foam* foamData_;
//ETX
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

6
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/Make/files
View File

@ -2,10 +2,8 @@ vtkPV3Foam.C
vtkPV3FoamAddVolumeMesh.C
vtkPV3FoamAddLagrangianMesh.C
vtkPV3FoamAddPatchMesh.C
vtkPV3FoamAddFaceZoneMesh.C
vtkPV3FoamAddPointZoneMesh.C
vtkPV3FoamAddFaceSetMesh.C
vtkPV3FoamAddPointSetMesh.C
vtkPV3FoamAddZoneMesh.C
vtkPV3FoamAddSetMesh.C
vtkPV3FoamUpdate.C
vtkPV3FoamUpdateInformation.C
vtkPV3FoamConvertMesh.C

1
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/Make/options
View File

@ -1,5 +1,4 @@
EXE_INC = \
/* -DPV3FOAM_TIMESELECTION */ \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/lagrangian/basic/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \

408
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.C
View File

@ -32,6 +32,7 @@ License
#include "IOobjectList.H"
#include "patchZones.H"
#include "vtkPV3FoamReader.h"
#include "IFstream.H"
// VTK includes
#include "vtkCharArray.h"
@ -52,7 +53,7 @@ defineTypeNameAndDebug(Foam::vtkPV3Foam, 0);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
#include "vtkPV3FoamAddFields.H"
#include "vtkPV3FoamAddToSelection.H"
#include "vtkPV3FoamUpdateInformationFields.H"
@ -172,38 +173,6 @@ void Foam::vtkPV3Foam::resetCounters()
}
void Foam::vtkPV3Foam::initializeTime()
{
#ifdef PV3FOAM_TIMESELECTION
Time& runTime = dbPtr_();
// Get times list
instantList times = runTime.times();
vtkDataArraySelection* arraySelection = reader_->GetTimeSelection();
// only execute this if there is a mismatch between
// the times available according to FOAM and according to VTK
int nArrays = arraySelection->GetNumberOfArrays();
if (nArrays && nArrays == times.size() - 1)
{
return;
}
// "constant" is implicit - skip it
// All the time selections are enabled by default
for (label timeI = 1; timeI < times.size(); ++timeI)
{
arraySelection->AddArray
(
times[timeI].name().c_str()
);
}
#endif /* PV3FOAM_TIMESELECTION */
}
bool Foam::vtkPV3Foam::setTime(const double& requestedTime)
{
if (debug)
@ -215,24 +184,10 @@ bool Foam::vtkPV3Foam::setTime(const double& requestedTime)
Time& runTime = dbPtr_();
// Get times list
instantList times = runTime.times();
instantList Times = runTime.times();
// logic as per "checkTimeOption.H"
bool found = false;
int nearestIndex = -1;
scalar nearestDiff = Foam::GREAT;
forAll (times, timeIndex)
{
if (times[timeIndex].name() == "constant") continue;
scalar diff = fabs(times[timeIndex].value() - requestedTime);
if (diff < nearestDiff)
{
nearestDiff = diff;
nearestIndex = timeIndex;
}
}
int nearestIndex = Time::findClosestTimeIndex(Times, requestedTime);
if (nearestIndex == -1)
{
@ -244,12 +199,36 @@ bool Foam::vtkPV3Foam::setTime(const double& requestedTime)
found = true;
}
runTime.setTime(times[nearestIndex], nearestIndex);
// see what has changed
if (timeIndex_ != nearestIndex)
{
timeIndex_ = nearestIndex;
runTime.setTime(Times[nearestIndex], nearestIndex);
// the fields change each time
fieldsChanged_ = true;
if (meshPtr_)
{
if (meshPtr_->readUpdate() != polyMesh::UNCHANGED)
{
meshChanged_ = true;
// patches, zones etc might have changed
UpdateInformation();
}
}
else
{
meshChanged_ = true;
}
}
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::setTime() - selected time "
<< times[nearestIndex].name() << endl;
<< Times[nearestIndex].name() << " index=" << nearestIndex
<< " meshChanged=" << meshChanged_
<< " fieldsChanged=" << fieldsChanged_ << endl;
}
return found;
@ -265,15 +244,28 @@ void Foam::vtkPV3Foam::updateSelectedRegions()
vtkDataArraySelection* arraySelection = reader_->GetRegionSelection();
const label nRegions = arraySelection->GetNumberOfArrays();
const label nSelect = arraySelection->GetNumberOfArrays();
selectedRegions_.setSize(nRegions);
selectedRegionDatasetIds_.setSize(nRegions);
// Read the selected patches and add to the region list
for (int regionId=0; regionId < nRegions; ++regionId)
if (selectedRegions_.size() != nSelect)
{
selectedRegions_[regionId] = arraySelection->GetArraySetting(regionId);
selectedRegions_.setSize(nSelect);
selectedRegions_ = 0;
meshChanged_ = true;
}
selectedRegionDatasetIds_.setSize(nSelect);
// Read the selected cell regions, zones, patches and add to region list
forAll (selectedRegions_, regionId)
{
int setting = arraySelection->GetArraySetting(regionId);
if (selectedRegions_[regionId] != setting)
{
selectedRegions_[regionId] = setting;
meshChanged_ = true;
}
selectedRegionDatasetIds_[regionId] = -1;
if (debug)
@ -301,7 +293,13 @@ Foam::stringList Foam::vtkPV3Foam::getSelectedArrayEntries
if (debug)
{
Info << "selections(";
Info<< "available(";
forAll (selections, elemI)
{
Info<< " \"" << arraySelection->GetArrayName(elemI) << "\"";
}
Info<< " )\n"
<< "selected(";
}
forAll (selections, elemI)
@ -351,28 +349,40 @@ Foam::stringList Foam::vtkPV3Foam::getSelectedArrayEntries
if (debug)
{
Info << "selections(";
Info<< "available(";
for
(
int elemI = selector.start();
elemI < selector.end();
++elemI
)
{
Info<< " \"" << arraySelection->GetArrayName(elemI) << "\"";
}
Info<< " )\n"
<< "selected(";
}
for
(
int regionId = selector.start();
regionId < selector.end();
++regionId
int elemI = selector.start();
elemI < selector.end();
++elemI
)
{
if (arraySelection->GetArraySetting(regionId))
if (arraySelection->GetArraySetting(elemI))
{
if (firstWord)
{
selections[nElem] = getFirstWord
(
arraySelection->GetArrayName(regionId)
arraySelection->GetArrayName(elemI)
);
}
else
{
selections[nElem] = arraySelection->GetArrayName(regionId);
selections[nElem] = arraySelection->GetArrayName(elemI);
}
if (debug)
@ -389,7 +399,6 @@ Foam::stringList Foam::vtkPV3Foam::getSelectedArrayEntries
Info<< " )" << endl;
}
selections.setSize(nElem);
return selections;
}
@ -432,10 +441,7 @@ void Foam::vtkPV3Foam::setSelectedArrayEntries
<< endl;
}
arraySelection->EnableArray
(
arrayName.c_str()
);
arraySelection->EnableArray(arrayName.c_str());
break;
}
}
@ -452,12 +458,10 @@ void Foam::vtkPV3Foam::setSelectedArrayEntries
Foam::vtkPV3Foam::vtkPV3Foam
(
const char* const FileName,
vtkPV3FoamReader* reader,
vtkMultiBlockDataSet* output
vtkPV3FoamReader* reader
)
:
reader_(reader),
output_(output),
dbPtr_(NULL),
meshPtr_(NULL),
selectInfoVolume_(VOLUME, "unzoned"),
@ -470,11 +474,15 @@ Foam::vtkPV3Foam::vtkPV3Foam
selectInfoFaceSets_(FACESET, "faceSet"),
selectInfoPointSets_(POINTSET, "pointSet"),
patchTextActorsPtrs_(0),
nMesh_(0)
nMesh_(0),
timeIndex_(-1),
meshChanged_(true),
fieldsChanged_(true)
{
if (debug)
{
Info<< "Foam::vtkPV3Foam::vtkPV3Foam - " << FileName << endl;
printMemory();
}
// avoid argList and get rootPath/caseName directly from the file
@ -518,17 +526,11 @@ Foam::vtkPV3Foam::vtkPV3Foam
dbPtr_().functionObjects().off();
if (debug)
{
cout<< "constructed with output: ";
output_->Print(cout);
}
resetCounters();
// Set initial cloud name
// TODO - TEMPORARY MEASURE UNTIL CAN PROCESS MULTIPLE CLOUDS
cloudName_ = "";
UpdateInformation();
}
@ -555,27 +557,37 @@ void Foam::vtkPV3Foam::UpdateInformation()
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::UpdateInformation - "
<< "TimeStep = " << reader_->GetTimeStep() << endl;
Info<< "<beg> Foam::vtkPV3Foam::UpdateInformation"
<< " [meshPtr=" << (meshPtr_ ? "set" : "NULL") << "] TimeStep="
<< reader_->GetTimeStep() << endl;
}
resetCounters();
// preserve the currently selected values
const stringList selectedEntries = getSelectedArrayEntries
(
reader_->GetRegionSelection()
);
// Clear current region list/array
reader_->GetRegionSelection()->RemoveAllArrays();
vtkDataArraySelection* arraySelection = reader_->GetRegionSelection();
initializeTime();
stringList selectedEntries;
// enable 'internalMesh' on the first call
if (arraySelection->GetNumberOfArrays() == 0 && !meshPtr_)
{
selectedEntries.setSize(1);
selectedEntries[0] = "internalMesh";
}
else
{
// preserve the currently selected values
selectedEntries = getSelectedArrayEntries
(
arraySelection
);
}
// Clear current region list/array
arraySelection->RemoveAllArrays();
// Update region array
updateInformationInternalMesh();
updateInformationLagrangian();
updateInformationPatches();
if (reader_->GetIncludeSets())
@ -588,13 +600,18 @@ void Foam::vtkPV3Foam::UpdateInformation()
updateInformationZones();
}
// Update region selection with the data just read in
// restore the currently enabled values
setSelectedArrayEntries
(
reader_->GetRegionSelection(),
arraySelection,
selectedEntries
);
if (meshChanged_)
{
fieldsChanged_ = true;
}
// Update volField array
updateInformationFields<fvPatchField, volMesh>
(
@ -630,24 +647,24 @@ void Foam::vtkPV3Foam::Update
output->Print(cout);
cout<<"Internally:\n";
output_->Print(cout);
output->Print(cout);
cout<< " has " << output_->GetNumberOfBlocks() << " blocks\n";
cout<< " has " << output->GetNumberOfBlocks() << " blocks\n";
printMemory();
}
// Set up region selection(s)
updateSelectedRegions();
// Update the Foam mesh
updateFoamMesh();
reader_->UpdateProgress(0.2);
// Convert meshes
convertMeshVolume(output);
convertMeshLagrangian(output);
convertMeshPatches(output);
reader_->UpdateProgress(0.4);
if (reader_->GetIncludeZones())
{
@ -658,17 +675,17 @@ void Foam::vtkPV3Foam::Update
if (reader_->GetIncludeSets())
{
convertMeshCellSet(output);
convertMeshFaceSet(output);
convertMeshPointSet(output);
convertMeshCellSets(output);
convertMeshFaceSets(output);
convertMeshPointSets(output);
}
reader_->UpdateProgress(0.8);
// Update fields
updateVolFields(output);
updatePointFields(output);
updateLagrangianFields(output);
reader_->UpdateProgress(1.0);
if (debug)
{
@ -693,90 +710,32 @@ void Foam::vtkPV3Foam::Update
<< GetNumberOfDataSets(output, selectInfoPointSets_) << nl;
// traverse blocks:
int nBlocks = output->GetNumberOfBlocks();
Info << "nBlocks = " << nBlocks << endl;
cout<< "nBlocks = " << output->GetNumberOfBlocks() << "\n";
cout<< "done Update\n";
output_->Print(cout);
cout<< " has " << output_->GetNumberOfBlocks() << " blocks\n";
output_->GetInformation()->Print(cout);
output->Print(cout);
cout<< " has " << output->GetNumberOfBlocks() << " blocks\n";
output->GetInformation()->Print(cout);
cout <<"ShouldIReleaseData :" << output_->ShouldIReleaseData() << "\n";
cout<<"ShouldIReleaseData :" << output->ShouldIReleaseData() << "\n";
printMemory();
}
meshChanged_ = fieldsChanged_ = false;
}
double* Foam::vtkPV3Foam::timeSteps(int& nTimeSteps)
double* Foam::vtkPV3Foam::findTimes(int& nTimeSteps)
{
int nTimes = 0;
double* ts = NULL;
double* tsteps = NULL;
if (dbPtr_.valid())
{
Time& runTime = dbPtr_();
instantList timeLst = runTime.times();
instantList times = runTime.times();
#ifdef PV3FOAM_TIMESELECTION
List<bool> selected = List<bool>(times.size(), false);
vtkDataArraySelection* arraySelection = reader_->GetTimeSelection();
const label nSelectedTimes = arraySelection->GetNumberOfArrays();
for (int i = 0; i < nSelectedTimes; ++i)
{
// always skip "constant" time
const int timeI = i + 1;
if
(
arraySelection->GetArraySetting(i)
&& timeI < times.size()
)
{
if (debug > 1)
{
Info<<"timeSelection["
<< i
<<"] = "
<< arraySelection->GetArraySetting(i)
<< " is "
<< arraySelection->GetArrayName(i) << endl;
}
selected[timeI] = true;
++nTimes;
}
}
if (debug > 1)
{
Info<< "selected " << nTimes << " times ";
Info<< "found " << times.size() << " times: (";
forAll(times, timeI)
{
Info<< " " << times[timeI].value();
}
Info<< " )" << endl;
}
if (nTimes)
{
ts = new double[nTimes];
int stepI = 0;
forAll(selected, selectI)
{
if (selected[selectI])
{
ts[stepI] = times[selectI].value();
stepI++;
}
}
}
#else /* PV3FOAM_TIMESELECTION */
// always skip "constant" time, unless there are no other times
nTimes = times.size();
nTimes = timeLst.size();
label timeI = 0;
if (nTimes > 1)
@ -787,26 +746,25 @@ double* Foam::vtkPV3Foam::timeSteps(int& nTimeSteps)
if (nTimes)
{
ts = new double[nTimes];
tsteps = new double[nTimes];
for (label stepI = 0; stepI < nTimes; ++stepI, ++timeI)
{
ts[stepI] = times[timeI].value();
tsteps[stepI] = timeLst[timeI].value();
}
}
#endif /* PV3FOAM_TIMESELECTION */
}
else
{
if (debug)
{
Info<< "no valid dbPtr:" <<endl;
cout<< "no valid dbPtr:\n";
}
}
// return vector length via the parameter
// vector length returned via the parameter
nTimeSteps = nTimes;
return ts;
return tsteps;
}
@ -820,8 +778,7 @@ void Foam::vtkPV3Foam::addPatchNames(vtkRenderer* renderer)
Info<< "<beg> Foam::vtkPV3Foam::addPatchNames" << endl;
}
const fvMesh& mesh = *meshPtr_;
const polyBoundaryMesh& pbMesh = mesh.boundaryMesh();
const polyBoundaryMesh& pbMesh = meshPtr_->boundaryMesh();
const selectionInfo& selector = selectInfoPatches_;
@ -924,8 +881,8 @@ void Foam::vtkPV3Foam::addPatchNames(vtkRenderer* renderer)
if (debug)
{
Info<< "patch zone centres = " << zoneCentre << endl;
Info<< "zones per patch = " << nZones << endl;
Info<< "patch zone centres = " << zoneCentre << nl
<< "zones per patch = " << nZones << endl;
}
// Set the size of the patch labels to max number of zones
@ -946,9 +903,9 @@ void Foam::vtkPV3Foam::addPatchNames(vtkRenderer* renderer)
{
if (debug)
{
Info<< "patch name = " << pp.name() << endl;
Info<< "anchor = " << zoneCentre[globalZoneI] << endl;
Info<< "globalZoneI = " << globalZoneI << endl;
Info<< "patch name = " << pp.name() << nl
<< "anchor = " << zoneCentre[globalZoneI] << nl
<< "globalZoneI = " << globalZoneI << endl;
}
vtkTextActor* txt = vtkTextActor::New();
@ -1012,48 +969,59 @@ void Foam::vtkPV3Foam::removePatchNames(vtkRenderer* renderer)
}
int Foam::vtkPV3Foam::numberOfAvailableTimes() const
void Foam::vtkPV3Foam::PrintSelf(ostream& os, vtkIndent indent) const
{
if (dbPtr_.valid())
{
return dbPtr_().times().size();
}
else
{
return 0;
}
os << indent << "Number of meshes: " << nMesh_ << "\n";
os << indent << "Number of nodes: "
<< (meshPtr_ ? meshPtr_->nPoints() : 0) << "\n";
os << indent << "Number of cells: "
<< (meshPtr_ ? meshPtr_->nCells() : 0) << "\n";
os << indent << "Number of available time steps: "
<< (dbPtr_.valid() ? dbPtr_().times().size() : 0) << endl;
}
int Foam::vtkPV3Foam::numberOfPoints()
// parse these bits of info from /proc/meminfo (Linux)
//
// MemTotal: 2062660 kB
// MemFree: 1124400 kB
//
// used = MemTotal - MemFree is what the free(1) uses.
//
void Foam::vtkPV3Foam::printMemory()
{
if (meshPtr_)
const char* meminfo = "/proc/meminfo";
if (exists(meminfo))
{
return meshPtr_->nPoints();
IFstream is(meminfo);
label memTotal = 0;
label memFree = 0;
string line;
while (is.getLine(line).good())
{
char tag[32];
int value;
if (sscanf(line.c_str(), "%30s %d", tag, &value) == 2)
{
if (!strcmp(tag, "MemTotal:"))
{
memTotal = value;
}
else
else if (!strcmp(tag, "MemFree:"))
{
return 0;
memFree = value;
}
}
}
int Foam::vtkPV3Foam::numberOfCells()
{
if (meshPtr_)
{
return meshPtr_->nCells();
}
{
return 0;
Info << "memUsed: " << (memTotal - memFree) << " kB\n";
}
}
int Foam::vtkPV3Foam::numberOfMeshes() const
{
return nMesh_;
}
// ************************************************************************* //

84
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3Foam.H
View File

@ -29,18 +29,16 @@ Description
Provides a reader interface for OpenFOAM to VTK interaction.
SourceFiles
interpolatePointToCell.C
interpolatePointToCell.H
vtkPV3Foam.C
vtkPV3Foam.H
vtkPV3FoamAddFaceSetMesh.C
vtkPV3FoamAddFaceZoneMesh.C
vtkPV3FoamAddFields.H
vtkPV3FoamI.H
vtkPV3FoamAddLagrangianMesh.C
vtkPV3FoamAddPatchMesh.C
vtkPV3FoamAddPointSetMesh.C
vtkPV3FoamAddPointZoneMesh.C
vtkPV3FoamAddSetMesh.C
vtkPV3FoamAddToSelection.H
vtkPV3FoamAddVolumeMesh.C
vtkPV3FoamAddZoneMesh.C
vtkPV3FoamConvertFaceField.H
vtkPV3FoamConvertLagrangianFields.H
vtkPV3FoamConvertMesh.C
vtkPV3FoamConvertPatchFaceField.H
@ -52,7 +50,7 @@ SourceFiles
vtkPV3FoamUpdateInformation.C
vtkPV3FoamUpdateInformationFields.H
// Needed by VTK?
// Needed by VTK:
vtkDataArrayTemplateImplicit.txx
\*---------------------------------------------------------------------------*/
@ -64,19 +62,21 @@ SourceFiles
#include "fileName.H"
#include "volPointInterpolation.H"
#include "stringList.H"
#include "wordList.H"
#include "primitivePatch.H"
// * * * * * * * * * * * * * Forward Declarations * * * * * * * * * * * * * //
class vtkDataArraySelection;
class vtkDataSet;
class vtkMultiBlockDataSet;
class vtkPoints;
class vtkPV3FoamReader;
class vtkRenderer;
class vtkTextActor;
class vtkMultiBlockDataSet;
class vtkPolyData;
class vtkUnstructuredGrid;
class vtkIndent;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -196,9 +196,6 @@ private:
//- Access to the controlling vtkPV3FoamReader
vtkPV3FoamReader* reader_;
//- Access to the output block
vtkMultiBlockDataSet* output_;
//- Foam time control
autoPtr<Time> dbPtr_;
@ -232,12 +229,12 @@ private:
labelList superCells_;
//- Label of original cell for decomposed cells
// - cell zone meshes
List<labelList> superCellZonesCells_;
// - cellZone meshes
List<labelList> zoneSuperCells_;
//- Label of original cell for decomposed cells
// - cell set meshes
List<labelList> superCellSetCells_;
// - cellSet meshes
List<labelList> csetSuperCells_;
//- List of patch names
List<vtkTextActor*> patchTextActorsPtrs_;
@ -253,6 +250,15 @@ private:
// TODO - currently only set up to process ONE cloud
word cloudName_;
//- The time index
int timeIndex_;
//- Track changes in mesh geometry
bool meshChanged_;
//- Track changes in fields
bool fieldsChanged_;
// Private Member Functions
@ -287,9 +293,6 @@ private:
//- Reset data counters
void resetCounters();
//- Get all the available times and select the latestTime
void initializeTime();
// Update information helper functions
//- Update the regions selected in the GUI
@ -307,9 +310,21 @@ private:
//- Set info
void updateInformationSets();
//- Read zone names for zoneType from file
wordList readZoneNames(const word& zoneType);
//- Zone info
void updateInformationZones();
//- Add to paraview array selection
template<class Type>
label addToSelection
(
vtkDataArraySelection *arraySelection,
const IOobjectList&,
const string& suffix = ""
);
//- Field info
template<template<class> class patchType, class meshType>
void updateInformationFields
@ -350,20 +365,20 @@ private:
//- Cell zone meshes
void convertMeshCellZones(vtkMultiBlockDataSet* output);
//- Cell zone meshes
//- Face zone meshes
void convertMeshFaceZones(vtkMultiBlockDataSet* output);
//- Cell zone meshes
//- Point zone meshes
void convertMeshPointZones(vtkMultiBlockDataSet* output);
//- Cell set meshes
void convertMeshCellSet(vtkMultiBlockDataSet* output);
void convertMeshCellSets(vtkMultiBlockDataSet* output);
//- Face set meshes
void convertMeshFaceSet(vtkMultiBlockDataSet* output);
void convertMeshFaceSets(vtkMultiBlockDataSet* output);
//- Point set meshes
void convertMeshPointSet(vtkMultiBlockDataSet* output);
void convertMeshPointSets(vtkMultiBlockDataSet* output);
// Add mesh functions
@ -433,7 +448,7 @@ private:
//- Add the fields in the selected time directory to the selection
// lists
template<class GeoField>
label addFields
label addObjectsToSelection
(
vtkDataArraySelection* fieldSelection,
const IOobjectList& objects,
@ -602,8 +617,7 @@ public:
vtkPV3Foam
(
const char* const FileName,
vtkPV3FoamReader* reader,
vtkMultiBlockDataSet* output
vtkPV3FoamReader* reader
);
@ -614,13 +628,14 @@ public:
// Member Functions
//- Update
void UpdateInformation();
void Update(vtkMultiBlockDataSet* output);
//- allocate and return a list of selected times
//- Allocate and return a list of selected times
// returns the count via the parameter
double* timeSteps(int& nTimeSteps);
double* findTimes(int& nTimeSteps);
//- Add patch names to the display
void addPatchNames(vtkRenderer* renderer);
@ -635,14 +650,11 @@ public:
// Access
//- Return the total number of available timesets
int numberOfAvailableTimes() const;
//- Debug information
void PrintSelf(ostream&, vtkIndent) const;
int numberOfCells();
int numberOfPoints();
int numberOfMeshes() const;
//- Simple memory used debugging information
static void printMemory();
};

2
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddLagrangianMesh.C
View File

@ -52,6 +52,7 @@ void Foam::vtkPV3Foam::addLagrangianMesh
{
Info<< "<beg> Foam::vtkPV3Foam::addLagrangianMesh - timePath "
<< mesh.time().timePath()/"lagrangian" << endl;
printMemory();
}
fileNameList cloudDirs
@ -103,6 +104,7 @@ void Foam::vtkPV3Foam::addLagrangianMesh
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addLagrangianMesh" << endl;
printMemory();
}
}

2
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddPatchMesh.C
View File

@ -49,6 +49,7 @@ void Foam::vtkPV3Foam::addPatchMesh
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPatchMesh - " << p.name() << endl;
printMemory();
}
// Convert Foam mesh vertices to VTK
@ -88,6 +89,7 @@ void Foam::vtkPV3Foam::addPatchMesh
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addPatchMesh - " << p.name() << endl;
printMemory();
}
}

73
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddPointSetMesh.C
View File

@ -1,73 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "vtkPV3Foam.H"
// Foam includes
#include "pointSet.H"
#include "vtkPV3FoamInsertNextPoint.H"
// VTK includes
#include "vtkPoints.h"
#include "vtkPolyData.h"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::vtkPV3Foam::addPointSetMesh
(
const fvMesh& mesh,
const pointSet& pSet,
vtkPolyData* vtkmesh
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointSetMesh" << endl;
}
const pointField& meshPoints = mesh.points();
vtkPoints *vtkpoints = vtkPoints::New();
vtkpoints->Allocate(pSet.size());
forAllConstIter(pointSet, pSet, iter)
{
vtkPV3FoamInsertNextPoint(vtkpoints, meshPoints[iter.key()]);
}
vtkmesh->SetPoints(vtkpoints);
vtkpoints->Delete();
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addPointSetMesh" << endl;
}
}
// ************************************************************************* //

72
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddPointZoneMesh.C
View File

@ -1,72 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
Description
\*---------------------------------------------------------------------------*/
#include "vtkPV3Foam.H"
// Foam includes
#include "vtkPV3FoamInsertNextPoint.H"
// VTK includes
#include "vtkPoints.h"
#include "vtkPolyData.h"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::vtkPV3Foam::addPointZoneMesh
(
const fvMesh& mesh,
const labelList& pointLabels,
vtkPolyData* vtkmesh
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointZoneMesh" << endl;
}
const pointField& meshPoints = mesh.points();
vtkPoints *vtkpoints = vtkPoints::New();
vtkpoints->Allocate(pointLabels.size());
forAll(pointLabels, pointI)
{
vtkPV3FoamInsertNextPoint(vtkpoints, meshPoints[pointLabels[pointI]]);
}
vtkmesh->SetPoints(vtkpoints);
vtkpoints->Delete();
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointZoneMesh" << endl;
}
}
// ************************************************************************* //

37
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddFaceSetMesh.C → applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddSetMesh.C
View File

@ -30,6 +30,7 @@ Description
// Foam includes
#include "faceSet.H"
#include "pointSet.H"
#include "vtkPV3FoamInsertNextPoint.H"
// VTK includes
@ -49,6 +50,7 @@ void Foam::vtkPV3Foam::addFaceSetMesh
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addFaceSetMesh" << endl;
printMemory();
}
// Construct primitivePatch of faces in fSet.
@ -100,6 +102,41 @@ void Foam::vtkPV3Foam::addFaceSetMesh
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addFaceSetMesh" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::addPointSetMesh
(
const fvMesh& mesh,
const pointSet& pSet,
vtkPolyData* vtkmesh
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointSetMesh" << endl;
printMemory();
}
const pointField& meshPoints = mesh.points();
vtkPoints *vtkpoints = vtkPoints::New();
vtkpoints->Allocate(pSet.size());
forAllConstIter(pointSet, pSet, iter)
{
vtkPV3FoamInsertNextPoint(vtkpoints, meshPoints[iter.key()]);
}
vtkmesh->SetPoints(vtkpoints);
vtkpoints->Delete();
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addPointSetMesh" << endl;
printMemory();
}
}

39
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddFields.H → applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddToSelection.H
View File

@ -22,13 +22,10 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
InClass
vtkPV3Foam
\*---------------------------------------------------------------------------*/
#ifndef vtkPV3FoamAddFields_H
#define vtkPV3FoamAddFields_H
#ifndef vtkPV3FoamAddToSelection_H
#define vtkPV3FoamAddToSelection_H
// FOAM includes
#include "SortableList.H"
@ -38,48 +35,48 @@ InClass
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class GeoField>
Foam::label Foam::vtkPV3Foam::addFields
template<class Type>
Foam::label Foam::vtkPV3Foam::addToSelection
(
vtkDataArraySelection *fieldSelection,
const IOobjectList& objects,
vtkDataArraySelection *arraySelection,
const IOobjectList& objectLst,
const string& suffix
)
{
IOobjectList fieldObjects(objects.lookupClass(GeoField::typeName));
IOobjectList objects(objectLst.lookupClass(Type::typeName));
SortableList<word> fields(fieldObjects.size());
SortableList<word> objectNames(objects.size());
label count = 0;
forAllConstIter(IOobjectList, fieldObjects, iter)
forAllConstIter(IOobjectList, objects, iter)
{
fields[count++] = iter()->name();
objectNames[count++] = iter()->name();
}
if (count)
{
fields.sort();
objectNames.sort();
forAll(fields, fieldI)
forAll (objectNames, objI)
{
if (debug)
{
Info<<" addField to GUI " << GeoField::typeName
<< ":" << fields[fieldI] << endl;
Info<<" addToSelection<" << Type::typeName << "> to GUI "
<< ":" << objectNames[objI] << endl;
}
if (suffix.size())
{
fieldSelection->AddArray
arraySelection->AddArray
(
(fields[fieldI] + suffix).c_str()
(objectNames[objI] + suffix).c_str()
);
}
else
{
fieldSelection->AddArray
arraySelection->AddArray
(
fields[fieldI].c_str()
objectNames[objI].c_str()
);
}
}

2
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddVolumeMesh.C
View File

@ -55,6 +55,7 @@ void Foam::vtkPV3Foam::addVolumeMesh
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addVolumeMesh" << endl;
printMemory();
}
// Number of additional points needed by the decomposition of polyhedra
@ -354,6 +355,7 @@ void Foam::vtkPV3Foam::addVolumeMesh
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addVolumeMesh" << endl;
printMemory();
}
}

37
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddFaceZoneMesh.C → applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamAddZoneMesh.C
View File

@ -38,6 +38,7 @@ Description
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::vtkPV3Foam::addFaceZoneMesh
(
const fvMesh& mesh,
@ -48,6 +49,7 @@ void Foam::vtkPV3Foam::addFaceZoneMesh
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addFaceZoneMesh" << endl;
printMemory();
}
// Construct primitivePatch of faces in fSet.
@ -98,8 +100,43 @@ void Foam::vtkPV3Foam::addFaceZoneMesh
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::addFaceZoneMesh" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::addPointZoneMesh
(
const fvMesh& mesh,
const labelList& pointLabels,
vtkPolyData* vtkmesh
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointZoneMesh" << endl;
printMemory();
}
const pointField& meshPoints = mesh.points();
vtkPoints *vtkpoints = vtkPoints::New();
vtkpoints->Allocate(pointLabels.size());
forAll(pointLabels, pointI)
{
vtkPV3FoamInsertNextPoint(vtkpoints, meshPoints[pointLabels[pointI]]);
}
vtkmesh->SetPoints(vtkpoints);
vtkpoints->Delete();
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::addPointZoneMesh" << endl;
printMemory();
}
}
// ************************************************************************* //

47
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamConvertMesh.C
View File

@ -51,6 +51,7 @@ void Foam::vtkPV3Foam::convertMeshVolume
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshVolume" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoVolume_;
@ -76,7 +77,7 @@ void Foam::vtkPV3Foam::convertMeshVolume
if (debug)
{
Info<< "Creating VTK internal mesh" << endl;
Info<< "Creating VTK internalMesh" << endl;
}
const label datasetId = 0;
@ -92,6 +93,7 @@ void Foam::vtkPV3Foam::convertMeshVolume
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshVolume" << endl;
printMemory();
}
}
@ -104,6 +106,7 @@ void Foam::vtkPV3Foam::convertMeshLagrangian
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshLagrangian" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoLagrangian_;
@ -139,6 +142,7 @@ void Foam::vtkPV3Foam::convertMeshLagrangian
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshLagrangian" << endl;
printMemory();
}
}
@ -151,6 +155,7 @@ void Foam::vtkPV3Foam::convertMeshPatches
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshPatches" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoPatches_;
@ -209,6 +214,7 @@ void Foam::vtkPV3Foam::convertMeshPatches
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshPatches" << endl;
printMemory();
}
}
@ -221,6 +227,7 @@ void Foam::vtkPV3Foam::convertMeshCellZones
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellZones" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoCellZones_;
@ -258,14 +265,14 @@ void Foam::vtkPV3Foam::convertMeshCellZones
(
subsetter.subMesh(),
vtkmesh,
superCellZonesCells_[datasetId]
zoneSuperCells_[datasetId]
);
// renumber - superCells must contain global cell ids
inplaceRenumber
(
subsetter.cellMap(),
superCellZonesCells_[datasetId]
zoneSuperCells_[datasetId]
);
AddToBlock
@ -281,18 +288,20 @@ void Foam::vtkPV3Foam::convertMeshCellZones
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshCellZones" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::convertMeshCellSet
void Foam::vtkPV3Foam::convertMeshCellSets
(
vtkMultiBlockDataSet* output
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellSet" << endl;
Info<< "<beg> Foam::vtkPV3Foam::convertMeshCellSets" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoCellSets_;
@ -337,14 +346,14 @@ void Foam::vtkPV3Foam::convertMeshCellSet
(
subsetter.subMesh(),
vtkmesh,
superCellSetCells_[datasetId]
csetSuperCells_[datasetId]
);
// renumber - superCells must contain global cell ids
inplaceRenumber
(
subsetter.cellMap(),
superCellSetCells_[datasetId]
csetSuperCells_[datasetId]
);
AddToBlock
@ -359,10 +368,12 @@ void Foam::vtkPV3Foam::convertMeshCellSet
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshCellSet" << endl;
Info<< "<end> Foam::vtkPV3Foam::convertMeshCellSets" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::convertMeshFaceZones
(
vtkMultiBlockDataSet* output
@ -371,6 +382,7 @@ void Foam::vtkPV3Foam::convertMeshFaceZones
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceZones" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoFaceZones_;
@ -421,18 +433,20 @@ void Foam::vtkPV3Foam::convertMeshFaceZones
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceZones" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::convertMeshFaceSet
void Foam::vtkPV3Foam::convertMeshFaceSets
(
vtkMultiBlockDataSet* output
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceSet" << endl;
Info<< "<beg> Foam::vtkPV3Foam::convertMeshFaceSets" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoFaceSets_;
@ -490,7 +504,8 @@ void Foam::vtkPV3Foam::convertMeshFaceSet
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceSet" << endl;
Info<< "<end> Foam::vtkPV3Foam::convertMeshFaceSets" << endl;
printMemory();
}
}
@ -503,6 +518,7 @@ void Foam::vtkPV3Foam::convertMeshPointZones
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointZones" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoPointZones_;
@ -553,19 +569,21 @@ void Foam::vtkPV3Foam::convertMeshPointZones
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshPointZones" << endl;
printMemory();
}
}
void Foam::vtkPV3Foam::convertMeshPointSet
void Foam::vtkPV3Foam::convertMeshPointSets
(
vtkMultiBlockDataSet* output
)
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointSet" << endl;
Info<< "<beg> Foam::vtkPV3Foam::convertMeshPointSets" << endl;
printMemory();
}
const selectionInfo& selector = selectInfoPointSets_;
@ -623,7 +641,8 @@ void Foam::vtkPV3Foam::convertMeshPointSet
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::convertMeshPointSet" << endl;
Info<< "<end> Foam::vtkPV3Foam::convertMeshPointSets" << endl;
printMemory();
}
}

7
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamConvertVolFields.H
View File

@ -173,8 +173,7 @@ void Foam::vtkPV3Foam::convertVolFields
convertPatchFaceField
(
tf.name(),
fvPatchField<Type>(p, tf)
.patchInternalField()(),
fvPatchField<Type>(p, tf).patchInternalField()(),
output,
selectInfoPatches_,
selectedRegionDatasetIds_[regionId]
@ -236,7 +235,7 @@ void Foam::vtkPV3Foam::convertVolFields
(
tf,
output, selectInfoCellZones_, datasetId,
superCellZonesCells_[datasetId]
zoneSuperCells_[datasetId]
);
}
@ -273,7 +272,7 @@ void Foam::vtkPV3Foam::convertVolFields
(
tf,
output, selectInfoCellSets_, datasetId,
superCellSetCells_[datasetId]
csetSuperCells_[datasetId]
);
}

29
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamI.H
View File

@ -28,7 +28,6 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
//- Extract up to the first non-word characters
inline Foam::word Foam::vtkPV3Foam::getFirstWord(const char* str)
{
if (str)
@ -46,32 +45,4 @@ inline Foam::word Foam::vtkPV3Foam::getFirstWord(const char* str)
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Ostream Operator * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //

19
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdate.C
View File

@ -48,16 +48,10 @@ void Foam::vtkPV3Foam::updateFoamMesh()
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updateFoamMesh" << endl;
printMemory();
}
if
(
!reader_->GetCacheMesh()
#ifdef PV3FOAM_TIMESELECTION
// This is only useful if the times are individually selectable
|| reader_->GetTimeSelection()->GetArraySetting(0)
#endif
)
if (!reader_->GetCacheMesh())
{
delete meshPtr_;
meshPtr_ = NULL;
@ -79,6 +73,8 @@ void Foam::vtkPV3Foam::updateFoamMesh()
dbPtr_()
)
);
meshChanged_ = true;
}
else
{
@ -91,6 +87,7 @@ void Foam::vtkPV3Foam::updateFoamMesh()
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::updateFoamMesh" << endl;
printMemory();
}
}
@ -103,6 +100,7 @@ void Foam::vtkPV3Foam::updateVolFields
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updateVolFields" << endl;
printMemory();
}
const fvMesh& mesh = *meshPtr_;
@ -167,6 +165,7 @@ void Foam::vtkPV3Foam::updateVolFields
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::updateVolFields" << endl;
printMemory();
}
}
@ -179,6 +178,7 @@ void Foam::vtkPV3Foam::updatePointFields
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updatePointFields" << endl;
printMemory();
}
const fvMesh& mesh = *meshPtr_;
@ -218,6 +218,7 @@ void Foam::vtkPV3Foam::updatePointFields
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::updatePointFields" << endl;
printMemory();
}
}
@ -230,6 +231,7 @@ void Foam::vtkPV3Foam::updateLagrangianFields
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updateLagrangianFields" << endl;
printMemory();
}
const fvMesh& mesh = *meshPtr_;
@ -281,6 +283,7 @@ void Foam::vtkPV3Foam::updateLagrangianFields
if (debug)
{
Info<< "<end> Foam::vtkPV3Foam::updateLagrangianFields" << endl;
printMemory();
}
}

248
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInformation.C
View File

@ -22,8 +22,6 @@ License
along with OpenFOAM; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
\*---------------------------------------------------------------------------*/
#include "vtkPV3Foam.H"
@ -31,13 +29,17 @@ Description
// Foam includes
#include "cellSet.H"
#include "faceSet.H"
#include "pointSet.H"
#include "IOobjectList.H"
#include "IOPtrList.H"
#include "pointSet.H"
#include "polyBoundaryMeshEntries.H"
#include "entry.H"
#include "vtkPV3FoamReader.h"
// local headers
#include "vtkPV3FoamAddToSelection.H"
#include "vtkPV3FoamUpdateInformationFields.H"
// VTK includes
#include "vtkDataArraySelection.h"
@ -77,10 +79,43 @@ public:
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::wordList Foam::vtkPV3Foam::readZoneNames(const word& zoneType)
{
wordList zoneNames;
// mesh not loaded - read from file
IOobject ioObj
(
zoneType,
dbPtr_().findInstance
(
polyMesh::meshSubDir,
zoneType,
IOobject::READ_IF_PRESENT
),
polyMesh::meshSubDir,
dbPtr_(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
);
if (ioObj.headerOk())
{
zonesEntries zones(ioObj);
zoneNames.setSize(zones.size());
forAll (zones, zoneI)
{
zoneNames[zoneI] = zones[zoneI].keyword();
}
}
return zoneNames;
}
#include "vtkPV3FoamAddFields.H"
#include "vtkPV3FoamUpdateInformationFields.H"
void Foam::vtkPV3Foam::updateInformationInternalMesh()
{
@ -103,6 +138,9 @@ void Foam::vtkPV3Foam::updateInformationInternalMesh()
if (debug)
{
// just for debug info
getSelectedArrayEntries(arraySelection);
Info<< "<end> Foam::vtkPV3Foam::updateInformationInternalMesh" << endl;
}
@ -132,7 +170,7 @@ void Foam::vtkPV3Foam::updateInformationLagrangian()
arraySelection->AddArray("lagrangian");
selectInfoLagrangian_ += 1;
Info<<"added cloudDirs\n";
Info<< "... added cloudDirs\n";
if (cloudDirs.size() > 1)
{
@ -149,13 +187,16 @@ void Foam::vtkPV3Foam::updateInformationLagrangian()
{
if (debug)
{
Info<<"no clouds identified in " <<nl
Info<< "... no clouds identified in " <<nl
<< " " <<dbPtr_->timePath()/"lagrangian" << endl;
}
}
if (debug)
{
// just for debug info
getSelectedArrayEntries(arraySelection);
Info<< "<end> Foam::vtkPV3Foam::updateInformationLagrangian" << endl;
}
}
@ -165,11 +206,36 @@ void Foam::vtkPV3Foam::updateInformationPatches()
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updateInformationPatches" << endl;
Info<< "<beg> Foam::vtkPV3Foam::updateInformationPatches"
<< " [meshPtr=" << (meshPtr_ ? "set" : "NULL") << "]" << endl;
}
vtkDataArraySelection *arraySelection = reader_->GetRegionSelection();
selectInfoPatches_ = arraySelection->GetNumberOfArrays();
int nPatches = 0;
if (meshPtr_)
{
const polyBoundaryMesh& patches = meshPtr_->boundaryMesh();
forAll (patches, patchI)
{
const polyPatch& pp = patches[patchI];
if (pp.size())
{
// Add patch to GUI region list
arraySelection->AddArray
(
(pp.name() + " - patch").c_str()
);
++nPatches;
}
}
}
else
{
// Read patches
polyBoundaryMeshEntries patchEntries
(
@ -185,13 +251,13 @@ void Foam::vtkPV3Foam::updateInformationPatches()
)
);
selectInfoPatches_ = arraySelection->GetNumberOfArrays();
int nPatches = 0;
// Start regions at patches
forAll (patchEntries, entryI)
{
label nFaces(readLabel(patchEntries[entryI].dict().lookup("nFaces")));
label nFaces
(
readLabel(patchEntries[entryI].dict().lookup("nFaces"))
);
// Valid patch if nFace > 0
if (nFaces)
@ -205,10 +271,15 @@ void Foam::vtkPV3Foam::updateInformationPatches()
++nPatches;
}
}
}
selectInfoPatches_ += nPatches;
if (debug)
{
// just for debug info
getSelectedArrayEntries(arraySelection);
Info<< "<end> Foam::vtkPV3Foam::updateInformationPatches" << endl;
}
}
@ -218,108 +289,82 @@ void Foam::vtkPV3Foam::updateInformationZones()
{
if (debug)
{
Info<< "<beg> Foam::vtkPV3Foam::updateInformationZones" << endl;
Info<< "<beg> Foam::vtkPV3Foam::updateInformationZones"
<< " [meshPtr=" << (meshPtr_ ? "set" : "NULL") << "]" << endl;
}
vtkDataArraySelection *arraySelection = reader_->GetRegionSelection();
// Read cell zone information
wordList namesLst;
//
// cellZones information
// ~~~~~~~~~~~~~~~~~~~~~
if (meshPtr_)
{
zonesEntries zones
(
IOobject
(
"cellZones",
dbPtr_().findInstance(polyMesh::meshSubDir, "cellZones"),
polyMesh::meshSubDir,
dbPtr_(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
)
);
namesLst = meshPtr_->cellZones().names();
}
else
{
namesLst = readZoneNames("cellZones");
}
selectInfoCellZones_ = arraySelection->GetNumberOfArrays();
if (zones.headerOk())
forAll (namesLst, elemI)
{
forAll(zones, zoneI)
{
arraySelection->AddArray
(
(zones[zoneI].keyword() + " - cellZone").c_str()
);
}
selectInfoCellZones_ += zones.size();
arraySelection->AddArray((namesLst[elemI] + " - cellZone").c_str());
}
selectInfoCellZones_ += namesLst.size();
zoneSuperCells_.setSize(selectInfoCellZones_.size());
superCellZonesCells_.setSize(selectInfoCellZones_.size());
}
// Read face zone information
//
// faceZones information
// ~~~~~~~~~~~~~~~~~~~~~
if (meshPtr_)
{
zonesEntries zones
(
IOobject
(
"faceZones",
dbPtr_().findInstance(polyMesh::meshSubDir, "faceZones"),
polyMesh::meshSubDir,
dbPtr_(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
)
);
namesLst = meshPtr_->faceZones().names();
}
else
{
namesLst = readZoneNames("faceZones");
}
selectInfoFaceZones_ = arraySelection->GetNumberOfArrays();
if (zones.headerOk())
forAll (namesLst, elemI)
{
forAll(zones, zoneI)
{
arraySelection->AddArray
(
(zones[zoneI].keyword() + " - faceZone").c_str()
);
}
selectInfoFaceZones_ += zones.size();
}
arraySelection->AddArray((namesLst[elemI] + " - faceZone").c_str());
}
selectInfoFaceZones_ += namesLst.size();
// Read point zone information
//
// pointZones information
// ~~~~~~~~~~~~~~~~~~~~~~
if (meshPtr_)
{
zonesEntries zones
(
IOobject
(
"pointZones",
dbPtr_().findInstance(polyMesh::meshSubDir, "pointZones"),
polyMesh::meshSubDir,
dbPtr_(),
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
)
);
namesLst = meshPtr_->pointZones().names();
}
else
{
namesLst = readZoneNames("pointZones");
}
selectInfoPointZones_ = arraySelection->GetNumberOfArrays();
if (zones.headerOk())
forAll (namesLst, elemI)
{
forAll(zones, zoneI)
{
arraySelection->AddArray
(
(zones[zoneI].keyword() + " - pointZone").c_str()
);
}
selectInfoPointZones_ += zones.size();
}
arraySelection->AddArray((namesLst[elemI] + " - pointZone").c_str());
}
selectInfoPointZones_ += namesLst.size();
if (debug)
{
// just for debug info
getSelectedArrayEntries(arraySelection);
Info<< "<end> Foam::vtkPV3Foam::updateInformationZones" << endl;
}
}
@ -332,7 +377,7 @@ void Foam::vtkPV3Foam::updateInformationSets()
vtkDataArraySelection *arraySelection = reader_->GetRegionSelection();
// Add sets
// Add names of sets
IOobjectList objects
(
dbPtr_(),
@ -342,16 +387,16 @@ void Foam::vtkPV3Foam::updateInformationSets()
selectInfoCellSets_ = arraySelection->GetNumberOfArrays();
selectInfoCellSets_ += addFields<cellSet>
selectInfoCellSets_ += addToSelection<cellSet>
(
arraySelection,
objects,
" - cellSet"
);
superCellSetCells_.setSize(selectInfoCellSets_.size());
csetSuperCells_.setSize(selectInfoCellSets_.size());
selectInfoFaceSets_ = arraySelection->GetNumberOfArrays();
selectInfoFaceSets_ += addFields<faceSet>
selectInfoFaceSets_ += addToSelection<faceSet>
(
arraySelection,
objects,
@ -359,7 +404,7 @@ void Foam::vtkPV3Foam::updateInformationSets()
);
selectInfoPointSets_ = arraySelection->GetNumberOfArrays();
selectInfoPointSets_ += addFields<pointSet>
selectInfoPointSets_ += addToSelection<pointSet>
(
arraySelection,
objects,
@ -368,6 +413,9 @@ void Foam::vtkPV3Foam::updateInformationSets()
if (debug)
{
// just for debug info
getSelectedArrayEntries(arraySelection);
Info<< "<end> Foam::vtkPV3Foam::updateInformationSets" << endl;
}
}
@ -399,32 +447,32 @@ void Foam::vtkPV3Foam::updateInformationLagrangianFields()
"lagrangian"/cloudName_
);
addFields<IOField<label> >
addToSelection<IOField<label> >
(
arraySelection,
objects
);
addFields<IOField<scalar> >
addToSelection<IOField<scalar> >
(
arraySelection,
objects
);
addFields<IOField<vector> >
addToSelection<IOField<vector> >
(
arraySelection,
objects
);
addFields<IOField<sphericalTensor> >
addToSelection<IOField<sphericalTensor> >
(
arraySelection,
objects
);
addFields<IOField<symmTensor> >
addToSelection<IOField<symmTensor> >
(
arraySelection,
objects
);
addFields<IOField<tensor> >
addToSelection<IOField<tensor> >
(
arraySelection,
objects
@ -444,5 +492,7 @@ void Foam::vtkPV3Foam::updateInformationLagrangianFields()
}
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// ************************************************************************* //

26
applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamUpdateInformationFields.H
View File

@ -43,11 +43,23 @@ void Foam::vtkPV3Foam::updateInformationFields
Info<< "<beg> Foam::vtkPV3Foam::updateInformationFields" << endl;
}
stringList selectedEntries;
// enable 'p' and 'U' on the first call
if (arraySelection->GetNumberOfArrays() == 0 && !meshPtr_)
{
selectedEntries.setSize(2);
selectedEntries[0] = "p";
selectedEntries[1] = "U";
}
else
{
// preserve the currently selected values
const stringList selectedEntries = getSelectedArrayEntries
selectedEntries = getSelectedArrayEntries
(
arraySelection
);
}
arraySelection->RemoveAllArrays();
// Search for list of objects for this time
@ -56,33 +68,33 @@ void Foam::vtkPV3Foam::updateInformationFields
//- Add volume fields to GUI
/*
addFields<GeometricField<label, patchType, meshType> >
addToSelection<GeometricField<label, patchType, meshType> >
(
arraySelection,
objects
);
*/
addFields<GeometricField<scalar, patchType, meshType> >
addToSelection<GeometricField<scalar, patchType, meshType> >
(
arraySelection,
objects
);
addFields<GeometricField<vector, patchType, meshType> >
addToSelection<GeometricField<vector, patchType, meshType> >
(
arraySelection,
objects
);
addFields<GeometricField<sphericalTensor, patchType, meshType> >
addToSelection<GeometricField<sphericalTensor, patchType, meshType> >
(
arraySelection,
objects
);
addFields<GeometricField<symmTensor, patchType, meshType> >
addToSelection<GeometricField<symmTensor, patchType, meshType> >
(
arraySelection,
objects
);
addFields<GeometricField<tensor, patchType, meshType> >
addToSelection<GeometricField<tensor, patchType, meshType> >
(
arraySelection,
objects

7
applications/utilities/postProcessing/graphics/fieldview9Reader/Allwmake
View File

@ -1,3 +1,8 @@
#if [ "$FV_HOME" -a -r $FV_HOME ] ; then
#!/bin/sh
# disabled
# if [ "$FV_HOME" -a -r $FV_HOME ]
# then
# wmake fieldview9Reader
# fi

0
applications/utilities/postProcessing/graphics/paraFoam/Allwmake
View File

5
applications/utilities/postProcessing/wall/yPlusLES/yPlusLES.C
View File

@ -107,11 +107,12 @@ int main(int argc, char *argv[])
*mag(U.boundaryField()[patchi].snGrad())
)
/sgsModel->nu().boundaryField()[patchi];
const scalarField& Yp = yPlus.boundaryField()[patchi];
Info<< "Patch " << patchi
<< " named " << currPatch.name()
<< " y+ : min: " << min(yPlus) << " max: " << max(yPlus)
<< " average: " << average(yPlus) << nl << endl;
<< " y+ : min: " << min(Yp) << " max: " << max(Yp)
<< " average: " << average(Yp) << nl << endl;
}
}

32
applications/utilities/surface/surfaceCheck/surfaceCheck.C
View File

@ -49,20 +49,20 @@ bool validTri(const triSurface& surf, const label faceI)
|| (f[2] < 0) || (f[2] >= surf.points().size())
)
{
WarningIn("validTri(const triSurface&, const label)")
<< "triangle " << faceI << " vertices " << f
<< " uses point indices outside point range 0.."
<< surf.points().size()-1 << endl;
//WarningIn("validTri(const triSurface&, const label)")
// << "triangle " << faceI << " vertices " << f
// << " uses point indices outside point range 0.."
// << surf.points().size()-1 << endl;
return false;
}
if ((f[0] == f[1]) || (f[0] == f[2]) || (f[1] == f[2]))
{
WarningIn("validTri(const triSurface&, const label)")
<< "triangle " << faceI
<< " uses non-unique vertices " << f
<< endl;
//WarningIn("validTri(const triSurface&, const label)")
// << "triangle " << faceI
// << " uses non-unique vertices " << f
// << endl;
return false;
}
@ -91,11 +91,11 @@ bool validTri(const triSurface& surf, const label faceI)
&& ((f[2] == nbrF[0]) || (f[2] == nbrF[1]) || (f[2] == nbrF[2]))
)
{
WarningIn("validTri(const triSurface&, const label)")
<< "triangle " << faceI << " vertices " << f
<< " has the same vertices as triangle " << nbrFaceI
<< " vertices " << nbrF
<< endl;
//WarningIn("validTri(const triSurface&, const label)")
// << "triangle " << faceI << " vertices " << f
// << " has the same vertices as triangle " << nbrFaceI
// << " vertices " << nbrF
// << endl;
return false;
}
@ -270,9 +270,9 @@ int main(int argc, char *argv[])
if (f[0] == f[1] || f[0] == f[2] || f[1] == f[2])
{
WarningIn(args.executable())
<< "Illegal triangle " << faceI << " vertices " << f
<< " coords " << f.points(surf.points()) << endl;
//WarningIn(args.executable())
// << "Illegal triangle " << faceI << " vertices " << f
// << " coords " << f.points(surf.points()) << endl;
}
else
{

46
src/OpenFOAM/db/Time/Time.C
View File

@ -418,19 +418,55 @@ Foam::instant Foam::Time::findClosestTime(const scalar t) const
return times[times.size() - 1];
}
label nearestIndex = -1;
scalar deltaT = GREAT;
label closesti = 0;
for (label i=1; i<times.size(); i++)
{
if (mag(times[i].value() - t) < deltaT)
scalar diff = mag(times[i].value() - t);
if (diff < deltaT)
{
deltaT = mag(times[i].value() - t);
closesti = i;
deltaT = diff;
nearestIndex = i;
}
}
return times[closesti];
return times[nearestIndex];
}
//
// This should work too,
// if we don't worry about checking "constant" explicitly
//
// Foam::instant Foam::Time::findClosestTime(const scalar t) const
// {
// instantList times = Time::findTimes(path());
// label timeIndex = min(findClosestTimeIndex(times, t), 0);
// return times[timeIndex];
// }
Foam::label Foam::Time::findClosestTimeIndex
(
const instantList& times,
const scalar t
)
{
label nearestIndex = -1;
scalar deltaT = GREAT;
forAll (times, i)
{
if (times[i].name() == "constant") continue;
scalar diff = fabs(times[i].value() - t);
if (diff < deltaT)
{
deltaT = diff;
nearestIndex = i;
}
}
return nearestIndex;
}

3
src/OpenFOAM/db/Time/Time.H
View File

@ -300,6 +300,9 @@ public:
//- Search the case for the time closest to the given time
instant findClosestTime(const scalar) const;
//- Search instantList for the time index closest to the given time
static label findClosestTimeIndex(const instantList&, const scalar);
//- Write using given format, version and compression
virtual bool writeObject
(

10
src/OpenFOAM/db/Time/findInstance.C
View File

@ -33,10 +33,7 @@ Description
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
word Time::findInstance
Foam::word Foam::Time::findInstance
(
const fileName& dir,
const word& name,
@ -139,9 +136,4 @@ word Time::findInstance
return constant();
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

12
src/OpenFOAM/db/Time/findTimes.C
View File

@ -35,12 +35,7 @@ Description
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
instantList Time::findTimes(const fileName& directory)
Foam::instantList Foam::Time::findTimes(const fileName& directory)
{
if (debug)
{
@ -101,9 +96,4 @@ instantList Time::findTimes(const fileName& directory)
return Times;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

20
src/OpenFOAM/global/argList/argList.C
View File

@ -337,25 +337,23 @@ Foam::argList::argList
Switch distributed(false);
if (decompositionDict.found("distributed"))
{
decompositionDict.lookup("distributed") >> distributed;
if (distributed)
if
(
decompositionDict.readIfPresent("distributed", distributed)
&& distributed
)
{
decompositionDict.lookup("roots") >> roots;
if (roots.size() != Pstream::nProcs())
if (roots.size() != Pstream::nProcs()-1)
{
FatalError
<< "number of entries in "
<< "decompositionDict::roots"
<< " is not equal to the number of processors "
<< Pstream::nProcs()
<< "number of entries in decompositionDict::roots"
<< " is not equal to the number of slaves "
<< Pstream::nProcs()-1
<< exit(FatalError);
}
}
}
label dictNProcs

21
src/OpenFOAM/include/checkTimeOption.H
View File

@ -1,22 +1,7 @@
if (args.options().found("time"))
{
scalar time(readScalar(IStringStream(args.options()["time"])()));
scalar timeValue(readScalar(IStringStream(args.options()["time"])()));
int nearestIndex = -1;
scalar nearestDiff = Foam::GREAT;
forAll(Times, timeIndex)
{
if (Times[timeIndex].name() == "constant") continue;
scalar diff = fabs(Times[timeIndex].value() - time);
if (diff < nearestDiff)
{
nearestDiff = diff;
nearestIndex = timeIndex;
}
}
startTime = nearestIndex;
endTime = nearestIndex + 1;
startTime = Time::findClosestTimeIndex(Times, timeValue);
endTime = startTime + 1;
}

2
src/OpenFOAM/meshes/polyMesh/polyMesh.C
View File

@ -1072,7 +1072,7 @@ const Foam::globalMeshData& Foam::polyMesh::globalData() const
// Remove all files and some subdirs (eg, sets)
void Foam::polyMesh::removeFiles(const fileName& instanceDir) const
{
fileName meshFilesPath = db().path()/instanceDir/meshSubDir;
fileName meshFilesPath = db().path()/instanceDir/meshDir();
rm(meshFilesPath/"points");
rm(meshFilesPath/"faces");

2
src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C
View File

@ -102,7 +102,7 @@ Foam::scalar Foam::layerAdditionRemoval::readOldThickness
const dictionary& dict
)
{
dict.lookupOrDefault("oldLayerThickness", -1.0);
return dict.lookupOrDefault("oldLayerThickness", -1.0);
}

126
src/meshTools/Make/files.txt
View File

@ -1,126 +0,0 @@
cellClassification/cellClassification.C
cellClassification/cellInfo.C
cellQuality/cellQuality.C
cellDist/cellDistFuncs.C
cellDist/patchWave/patchWave.C
cellDist/wallPoint/wallPoint.C
cellFeatures/cellFeatures.C
coordinateSystems/parabolicCylindricalCS.C
coordinateSystems/coordinateSystem.C
coordinateSystems/toroidalCS.C
coordinateSystems/cartesianCS.C
coordinateSystems/newCoordinateSystem.C
coordinateSystems/cylindricalCS.C
coordinateSystems/sphericalCS.C
coordinateSystems/coordinateRotation/coordinateRotation.C
coordinateSystems/coordinateRotation/EulerCoordinateRotation.C
coordinateSystems/coordinateRotation/STARCDCoordinateRotation.C
polyMeshZipUpCells/polyMeshZipUpCells.C
primitiveMeshGeometry/primitiveMeshGeometry.C
meshSearch/meshSearch.C
meshTools/meshTools.C
PointEdgeWave/PointEdgeWaveName.C
PointEdgeWave/pointEdgePoint.C
regionSplit/regionSplit.C
octree/octreeName.C
octree/octreeDataPoint.C
octree/octreeDataPointTreeLeaf.C
octree/octreeDataEdges.C
octree/octreeDataCell.C
octree/octreeDataFace.C
octree/treeBoundBox.C
octree/treeNodeName.C
octree/treeLeafName.C
octree/pointIndexHitIOList.C
indexedOctree/indexedOctreeName.C
indexedOctree/treeDataTriSurface.C
topoSets = sets/topoSets
$(topoSets)/cellSet.C
$(topoSets)/topoSet.C
$(topoSets)/faceSet.C
$(topoSets)/pointSet.C
sets/topoSetSource/topoSetSource.C
cellSources = sets/cellSources
$(cellSources)/faceToCell/faceToCell.C
$(cellSources)/fieldToCell/fieldToCell.C
$(cellSources)/pointToCell/pointToCell.C
$(cellSources)/shapeToCell/shapeToCell.C
$(cellSources)/boxToCell/boxToCell.C
$(cellSources)/rotatedBoxToCell/rotatedBoxToCell.C
$(cellSources)/labelToCell/labelToCell.C
$(cellSources)/surfaceToCell/surfaceToCell.C
$(cellSources)/cellToCell/cellToCell.C
$(cellSources)/nearestToCell/nearestToCell.C
$(cellSources)/nbrToCell/nbrToCell.C
$(cellSources)/zoneToCell/zoneToCell.C
faceSources = sets/faceSources
$(faceSources)/faceToFace/faceToFace.C
$(faceSources)/labelToFace/labelToFace.C
$(faceSources)/cellToFace/cellToFace.C
$(faceSources)/normalToFace/normalToFace.C
$(faceSources)/pointToFace/pointToFace.C
$(faceSources)/patchToFace/patchToFace.C
$(faceSources)/boundaryToFace/boundaryToFace.C
$(faceSources)/zoneToFace/zoneToFace.C
$(faceSources)/boxToFace/boxToFace.C
pointSources = sets/pointSources
$(pointSources)/labelToPoint/labelToPoint.C
$(pointSources)/pointToPoint/pointToPoint.C
$(pointSources)/cellToPoint/cellToPoint.C
$(pointSources)/faceToPoint/faceToPoint.C
$(pointSources)/boxToPoint/boxToPoint.C
$(pointSources)/surfaceToPoint/surfaceToPoint.C
$(pointSources)/zoneToPoint/zoneToPoint.C
surfaceSets/surfaceSets.C
triSurface/orientedSurface/orientedSurface.C
booleanOps = triSurface/booleanOps
surfaceIntersection = $(booleanOps)/surfaceIntersection
$(surfaceIntersection)/surfaceIntersection.C
$(surfaceIntersection)/surfaceIntersectionFuncs.C
$(surfaceIntersection)/edgeIntersections.C
booleanSurface = $(booleanOps)/booleanSurface
$(booleanSurface)/booleanSurface.C
intersectedSurface = $(booleanOps)/intersectedSurface
$(intersectedSurface)/intersectedSurface.C
$(intersectedSurface)/edgeSurface.C
triSurface/triSurfaceSearch/triSurfaceSearch.C
triSurface/octreeData/octreeDataTriSurface.C
triSurface/octreeData/octreeDataTriSurfaceTreeLeaf.C
triSurface/triangleFuncs/triangleFuncs.C
triSurface/surfaceFeatures/surfaceFeatures.C
triSurface/triSurfaceMeshes/triSurfaceMeshes.C
twoDPointCorrector/twoDPointCorrector.C
directMapped/directMappedPolyPatch/directMappedPolyPatch.C
directMapped/directMappedPointPatch/directMappedPointPatch.C
LIB = $(FOAM_LIBBIN)/libmeshTools

29
src/sampling/cuttingPlane/cuttingPlane.C
View File

@ -29,6 +29,15 @@ License
#include "linePointRef.H"
#include "meshTools.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
// set values for what is close to zero and what is considered to
// be positive (and not just rounding noise)
//! @cond localScope
const Foam::scalar zeroish = Foam::SMALL;
const Foam::scalar positive = Foam::SMALL * 1E3;
//! @endcond localScope
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
// Find cut cells
@ -71,8 +80,8 @@ void Foam::cuttingPlane::calcCutCells
if
(
(dotProducts[e[0]] < 0 && dotProducts[e[1]] > 0)
|| (dotProducts[e[1]] < 0 && dotProducts[e[0]] > 0)
(dotProducts[e[0]] < zeroish && dotProducts[e[1]] > positive)
|| (dotProducts[e[1]] < zeroish && dotProducts[e[0]] > positive)
)
{
nCutEdges++;
@ -116,8 +125,8 @@ Foam::labelList Foam::cuttingPlane::intersectEdges
if
(
(dotProducts[e[0]] < 0 && dotProducts[e[1]] > 0)
|| (dotProducts[e[1]] < 0 && dotProducts[e[0]] > 0)
(dotProducts[e[0]] < zeroish && dotProducts[e[1]] > positive)
|| (dotProducts[e[1]] < zeroish && dotProducts[e[0]] > positive)
)
{
// Edge is cut.
@ -126,7 +135,19 @@ Foam::labelList Foam::cuttingPlane::intersectEdges
scalar alpha = lineIntersect(linePointRef(p0, p1));
if (alpha < zeroish)
{
dynCuttingPoints.append(p0);
}
else if (alpha > 1.0)
{
dynCuttingPoints.append(p1);
}
else
{
dynCuttingPoints.append((1-alpha)*p0 + alpha*p1);
}
edgePoint[edgeI] = dynCuttingPoints.size() - 1;
}
}

4
src/sampling/cuttingPlane/cuttingPlane.H
View File

@ -30,6 +30,10 @@ Description
No attempt at resolving degenerate cases.
Note
When the cutting plane coincides with a mesh face, the cell edge on the
positive side of the plane is taken.
SourceFiles
cuttingPlane.C