zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

functionObjects: Renamed streamLine and streamLines to streamlines

Browse Source
This commit is contained in:
Will Bainbridge
2021-07-11 21:50:46 +01:00
parent bf3c2e7ba9
commit e9733e50ba
26 changed files with 169 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/functionObjects/field/Make/files
View File

@ -16,9 +16,9 @@ nearWallFields/findCellParticle.C
processorField/processorField.C
readFields/readFields.C
streamLine/streamLine.C
streamLine/streamLineParticle.C
streamLine/streamLineParticleCloud.C
streamlines/streamlines.C
streamlines/streamlinesParticle.C
streamlines/streamlinesCloud.C
surfaceInterpolate/surfaceInterpolate.C

44
src/functionObjects/field/streamLine/streamLine.C → src/functionObjects/field/streamlines/streamlines.C
View File

@ -25,8 +25,8 @@ License
#include "Pstream.H"
#include "functionObjectList.H"
#include "streamLine.H"
#include "streamLineParticleCloud.H"
#include "streamlines.H"
#include "streamlinesCloud.H"
#include "ReadFields.H"
#include "meshSearch.H"
#include "sampledSet.H"
@ -44,16 +44,16 @@ namespace Foam
{
template<>
const char*
NamedEnum<functionObjects::streamLine::trackDirection, 3>::names[] =
NamedEnum<functionObjects::streamlines::trackDirection, 3>::names[] =
{"forward", "backward", "both"};
namespace functionObjects
{
defineTypeNameAndDebug(streamLine, 0);
addToRunTimeSelectionTable(functionObject, streamLine, dictionary);
defineTypeNameAndDebug(streamlines, 0);
addToRunTimeSelectionTable(functionObject, streamlines, dictionary);
const NamedEnum<streamLine::trackDirection, 3>
streamLine::trackDirectionNames_;
const NamedEnum<streamlines::trackDirection, 3>
streamlines::trackDirectionNames_;
}
}
@ -61,7 +61,7 @@ namespace Foam
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::autoPtr<Foam::indirectPrimitivePatch>
Foam::functionObjects::streamLine::wallPatch() const
Foam::functionObjects::streamlines::wallPatch() const
{
const polyBoundaryMesh& patches = mesh_.boundaryMesh();
@ -107,10 +107,10 @@ Foam::functionObjects::streamLine::wallPatch() const
}
void Foam::functionObjects::streamLine::track()
void Foam::functionObjects::streamlines::track()
{
IDLList<streamLineParticle> initialParticles;
streamLineParticleCloud particles
IDLList<streamlinesParticle> initialParticles;
streamlinesCloud particles
(
mesh_,
cloudName_,
@ -123,7 +123,7 @@ void Foam::functionObjects::streamLine::track()
{
particles.addParticle
(
new streamLineParticle
new streamlinesParticle
(
mesh_,
seedPoints[i],
@ -262,7 +262,7 @@ void Foam::functionObjects::streamLine::track()
// Additional particle info
streamLineParticle::trackingData td
streamlinesParticle::trackingData td
(
particles,
vsInterp,
@ -294,7 +294,7 @@ void Foam::functionObjects::streamLine::track()
if (trackDirection_ == trackDirection::both)
{
particles.IDLList<streamLineParticle>::operator=(initialParticles);
particles.IDLList<streamlinesParticle>::operator=(initialParticles);
td.trackForward_ = !td.trackForward_;
particles.move(particles, td, trackTime);
}
@ -303,7 +303,7 @@ void Foam::functionObjects::streamLine::track()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::functionObjects::streamLine::streamLine
Foam::functionObjects::streamlines::streamlines
(
const word& name,
const Time& runTime,
@ -320,13 +320,13 @@ Foam::functionObjects::streamLine::streamLine
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::functionObjects::streamLine::~streamLine()
Foam::functionObjects::streamlines::~streamlines()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::functionObjects::streamLine::read(const dictionary& dict)
bool Foam::functionObjects::streamlines::read(const dictionary& dict)
{
if (dict != dict_)
{
@ -409,7 +409,7 @@ bool Foam::functionObjects::streamLine::read(const dictionary& dict)
interpolationCellPoint<scalar>::typeName
);
cloudName_ = dict.lookupOrDefault<word>("cloudName", "streamLine");
cloudName_ = dict.lookupOrDefault<word>("cloudName", "streamlines");
meshSearchPtr_.reset(new meshSearch(mesh_));
@ -429,13 +429,13 @@ bool Foam::functionObjects::streamLine::read(const dictionary& dict)
}
bool Foam::functionObjects::streamLine::execute()
bool Foam::functionObjects::streamlines::execute()
{
return true;
}
bool Foam::functionObjects::streamLine::write()
bool Foam::functionObjects::streamlines::write()
{
Info<< type() << " " << name() << " write:" << nl;
@ -715,7 +715,7 @@ bool Foam::functionObjects::streamLine::write()
}
void Foam::functionObjects::streamLine::updateMesh(const mapPolyMesh& mpm)
void Foam::functionObjects::streamlines::updateMesh(const mapPolyMesh& mpm)
{
if (&mpm.mesh() == &mesh_)
{
@ -724,7 +724,7 @@ void Foam::functionObjects::streamLine::updateMesh(const mapPolyMesh& mpm)
}
void Foam::functionObjects::streamLine::movePoints(const polyMesh& mesh)
void Foam::functionObjects::streamlines::movePoints(const polyMesh& mesh)
{
if (&mesh == &mesh_)
{

39
src/functionObjects/field/streamLine/streamLine.H → src/functionObjects/field/streamlines/streamlines.H
View File

@ -22,17 +22,17 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::functionObjects::streamLine
Foam::functionObjects::streamlines
Description
Generates streamline data by sampling a set of user-specified fields along a
particle track, transported by a user-specified velocity field.
Generates streamline data by sampling a set of user-specified fields along
a particle track, transported by a user-specified velocity field.
Example of function object specification:
\verbatim
streamLine1
streamlines1
{
type streamLine;
type streamlines;
libs ("libfieldFunctionObjects.so");
writeControl writeTime;
@ -66,15 +66,15 @@ Description
Usage
\table
Property | Description | Required | Default value
type | Type name: streamLine | yes |
type | Type name: streamlines | yes |
setFormat | Output data type | yes |
U | Tracking velocity field name | no | U
direction | Direction in which to track | yes |
fields | Fields to sample | yes |
writeTime | Write the flow time along the streamline | no | no
writeTime | Write the flow time along the streamlines | no | no
lifetime | Maximum number of particle tracking steps | yes |
trackLength | Tracking segment length | no |
nSubCycle | Number of tracking steps per cell | no|
nSubCycle | Number of tracking steps per cell | no |
cloudName | Cloud name to use | yes |
seedSampleSet| Seeding method (see below)| yes |
\endtable
@ -94,15 +94,14 @@ See also
Foam::functionObject
Foam::functionObjects::timeControl
Foam::sampledSet
Foam::wallBoundedStreamLine
SourceFiles
streamLine.C
streamlines.C
\*---------------------------------------------------------------------------*/
#ifndef functionObjects_streamLine_H
#define functionObjects_streamLine_H
#ifndef functionObjects_streamlines_H
#define functionObjects_streamlines_H
#include "fvMeshFunctionObject.H"
#include "volFieldsFwd.H"
@ -126,10 +125,10 @@ namespace functionObjects
{
/*---------------------------------------------------------------------------*\
Class streamLine Declaration
Class streamlines Declaration
\*---------------------------------------------------------------------------*/
class streamLine
class streamlines
:
public fvMeshFunctionObject
{
@ -189,7 +188,7 @@ private:
//- Names of vector fields
wordList vectorNames_;
//- Write the streamline ages
//- Write the streamlines ages
Switch writeAge_;
@ -236,13 +235,13 @@ private:
public:
//- Runtime type information
TypeName("streamLine");
TypeName("streamlines");
// Constructors
//- Construct from Time and dictionary
streamLine
streamlines
(
const word& name,
const Time& runTime,
@ -250,11 +249,11 @@ public:
);
//- Disallow default bitwise copy construction
streamLine(const streamLine&) = delete;
streamlines(const streamlines&) = delete;
//- Destructor
virtual ~streamLine();
virtual ~streamlines();
// Member Functions
@ -278,7 +277,7 @@ public:
// Member Operators
//- Disallow default bitwise assignment
void operator=(const streamLine&) = delete;
void operator=(const streamlines&) = delete;
};

18
src/functionObjects/field/streamLine/streamLineParticleCloud.C → src/functionObjects/field/streamlines/streamlinesCloud.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,41 +23,41 @@ License
\*---------------------------------------------------------------------------*/
#include "streamLineParticleCloud.H"
#include "streamlinesCloud.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(streamLineParticleCloud, 0);
defineTypeNameAndDebug(streamlinesCloud, 0);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::streamLineParticleCloud::streamLineParticleCloud
Foam::streamlinesCloud::streamlinesCloud
(
const polyMesh& mesh,
const word& cloudName,
bool readFields
)
:
Cloud<streamLineParticle>(mesh, cloudName, false)
Cloud<streamlinesParticle>(mesh, cloudName, false)
{
if (readFields)
{
streamLineParticle::readFields(*this);
streamlinesParticle::readFields(*this);
}
}
Foam::streamLineParticleCloud::streamLineParticleCloud
Foam::streamlinesCloud::streamlinesCloud
(
const polyMesh& mesh,
const word& cloudName,
const IDLList<streamLineParticle>& particles
const IDLList<streamlinesParticle>& particles
)
:
Cloud<streamLineParticle>(mesh, cloudName, particles)
Cloud<streamlinesParticle>(mesh, cloudName, particles)
{}

34
src/functionObjects/field/streamLine/streamLineParticleCloud.H → src/functionObjects/field/streamlines/streamlinesCloud.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,21 +22,21 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::streamLineParticleCloud
Foam::streamlinesCloud
Description
A Cloud of streamLine particles
A Cloud of streamlines particles
SourceFiles
streamLineCloud.C
streamlinesCloud.C
\*---------------------------------------------------------------------------*/
#ifndef streamLineParticleCloud_H
#define streamLineParticleCloud_H
#ifndef streamlinesCloud_H
#define streamlinesCloud_H
#include "Cloud.H"
#include "streamLineParticle.H"
#include "streamlinesParticle.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -44,27 +44,27 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class streamLineCloud Declaration
Class streamlinesCloud Declaration
\*---------------------------------------------------------------------------*/
class streamLineParticleCloud
class streamlinesCloud
:
public Cloud<streamLineParticle>
public Cloud<streamlinesParticle>
{
public:
//- Type of parcel the cloud was instantiated for
typedef streamLineParticle parcelType;
typedef streamlinesParticle parcelType;
//- Runtime type information
TypeName("streamLineParticleCloud");
TypeName("streamlinesCloud");
// Constructors
//- Construct given mesh
streamLineParticleCloud
streamlinesCloud
(
const polyMesh&,
const word& cloudName = "defaultCloud",
@ -72,21 +72,21 @@ public:
);
//- Construct from mesh, cloud name, and a list of particles
streamLineParticleCloud
streamlinesCloud
(
const polyMesh& mesh,
const word& cloudName,
const IDLList<streamLineParticle>& particles
const IDLList<streamlinesParticle>& particles
);
//- Disallow default bitwise copy construction
streamLineParticleCloud(const streamLineParticleCloud&) = delete;
streamlinesCloud(const streamlinesCloud&) = delete;
// Member Operators
//- Disallow default bitwise assignment
void operator=(const streamLineParticleCloud&) = delete;
void operator=(const streamlinesCloud&) = delete;
};

78
src/functionObjects/field/streamLine/streamLineParticle.C → src/functionObjects/field/streamlines/streamlinesParticle.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,14 +23,14 @@ License
\*---------------------------------------------------------------------------*/
#include "streamLineParticle.H"
#include "streamLineParticleCloud.H"
#include "streamlinesParticle.H"
#include "streamlinesCloud.H"
#include "vectorFieldIOField.H"
#include "scalarFieldIOField.H"
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::vector Foam::streamLineParticle::interpolateFields
Foam::vector Foam::streamlinesParticle::interpolateFields
(
const trackingData& td,
const point& position,
@ -80,7 +80,7 @@ Foam::vector Foam::streamLineParticle::interpolateFields
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::streamLineParticle::streamLineParticle
Foam::streamlinesParticle::streamlinesParticle
(
const polyMesh& mesh,
const vector& position,
@ -94,7 +94,7 @@ Foam::streamLineParticle::streamLineParticle
{}
Foam::streamLineParticle::streamLineParticle
Foam::streamlinesParticle::streamlinesParticle
(
const polyMesh& mesh,
Istream& is,
@ -126,15 +126,15 @@ Foam::streamLineParticle::streamLineParticle
// Check state of Istream
is.check
(
"streamLineParticle::streamLineParticle"
"(const Cloud<streamLineParticle>&, Istream&, bool)"
"streamlinesParticle::streamlinesParticle"
"(const Cloud<streamlinesParticle>&, Istream&, bool)"
);
}
Foam::streamLineParticle::streamLineParticle
Foam::streamlinesParticle::streamlinesParticle
(
const streamLineParticle& p
const streamlinesParticle& p
)
:
particle(p),
@ -149,9 +149,9 @@ Foam::streamLineParticle::streamLineParticle
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
bool Foam::streamLineParticle::move
bool Foam::streamlinesParticle::move
(
streamLineParticleCloud& cloud,
streamlinesCloud& cloud,
trackingData& td,
const scalar
)
@ -236,7 +236,7 @@ bool Foam::streamLineParticle::move
// Failure exit. Particle stagnated or it's life ran out.
if (debug)
{
Pout<< "streamLineParticle: Removing stagnant particle:"
Pout<< "streamlinesParticle: Removing stagnant particle:"
<< position() << " sampled positions:"
<< sampledPositions_.size() << endl;
}
@ -251,7 +251,7 @@ bool Foam::streamLineParticle::move
if (debug)
{
Pout<< "streamLineParticle: Removing particle:" << position()
Pout<< "streamlinesParticle: Removing particle:" << position()
<< " sampled positions:" << sampledPositions_.size()
<< endl;
}
@ -286,16 +286,16 @@ bool Foam::streamLineParticle::move
}
bool Foam::streamLineParticle::hitPatch(streamLineParticleCloud&, trackingData&)
bool Foam::streamlinesParticle::hitPatch(streamlinesCloud&, trackingData&)
{
// Disable generic patch interaction
return false;
}
void Foam::streamLineParticle::hitWedgePatch
void Foam::streamlinesParticle::hitWedgePatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -304,9 +304,9 @@ void Foam::streamLineParticle::hitWedgePatch
}
void Foam::streamLineParticle::hitSymmetryPlanePatch
void Foam::streamlinesParticle::hitSymmetryPlanePatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -315,9 +315,9 @@ void Foam::streamLineParticle::hitSymmetryPlanePatch
}
void Foam::streamLineParticle::hitSymmetryPatch
void Foam::streamlinesParticle::hitSymmetryPatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -326,9 +326,9 @@ void Foam::streamLineParticle::hitSymmetryPatch
}
void Foam::streamLineParticle::hitCyclicPatch
void Foam::streamlinesParticle::hitCyclicPatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -337,11 +337,11 @@ void Foam::streamLineParticle::hitCyclicPatch
}
void Foam::streamLineParticle::hitCyclicAMIPatch
void Foam::streamlinesParticle::hitCyclicAMIPatch
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -350,11 +350,11 @@ void Foam::streamLineParticle::hitCyclicAMIPatch
}
void Foam::streamLineParticle::hitCyclicACMIPatch
void Foam::streamlinesParticle::hitCyclicACMIPatch
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -363,11 +363,11 @@ void Foam::streamLineParticle::hitCyclicACMIPatch
}
void Foam::streamLineParticle::hitCyclicRepeatAMIPatch
void Foam::streamlinesParticle::hitCyclicRepeatAMIPatch
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -376,9 +376,9 @@ void Foam::streamLineParticle::hitCyclicRepeatAMIPatch
}
void Foam::streamLineParticle::hitProcessorPatch
void Foam::streamlinesParticle::hitProcessorPatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -387,9 +387,9 @@ void Foam::streamLineParticle::hitProcessorPatch
}
void Foam::streamLineParticle::hitWallPatch
void Foam::streamlinesParticle::hitWallPatch
(
streamLineParticleCloud&,
streamlinesCloud&,
trackingData& td
)
{
@ -398,7 +398,7 @@ void Foam::streamLineParticle::hitWallPatch
}
void Foam::streamLineParticle::readFields(Cloud<streamLineParticle>& c)
void Foam::streamlinesParticle::readFields(Cloud<streamlinesParticle>& c)
{
// if (!c.size())
// {
@ -430,7 +430,7 @@ void Foam::streamLineParticle::readFields(Cloud<streamLineParticle>& c)
c.checkFieldIOobject(c, sampledTimes);
label i = 0;
forAllIter(Cloud<streamLineParticle>, c, iter)
forAllIter(Cloud<streamlinesParticle>, c, iter)
{
iter().lifeTime_ = lifeTime[i];
iter().sampledPositions_.transfer(sampledPositions[i]);
@ -440,7 +440,7 @@ void Foam::streamLineParticle::readFields(Cloud<streamLineParticle>& c)
}
void Foam::streamLineParticle::writeFields(const Cloud<streamLineParticle>& c)
void Foam::streamlinesParticle::writeFields(const Cloud<streamlinesParticle>& c)
{
particle::writeFields(c);
@ -463,7 +463,7 @@ void Foam::streamLineParticle::writeFields(const Cloud<streamLineParticle>& c)
);
label i = 0;
forAllConstIter(Cloud<streamLineParticle>, c, iter)
forAllConstIter(Cloud<streamlinesParticle>, c, iter)
{
lifeTime[i] = iter().lifeTime_;
sampledPositions[i] = iter().sampledPositions_;
@ -479,7 +479,7 @@ void Foam::streamLineParticle::writeFields(const Cloud<streamLineParticle>& c)
// * * * * * * * * * * * * * * * IOstream Operators * * * * * * * * * * * * //
Foam::Ostream& Foam::operator<<(Ostream& os, const streamLineParticle& p)
Foam::Ostream& Foam::operator<<(Ostream& os, const streamlinesParticle& p)
{
os << static_cast<const particle&>(p)
<< token::SPACE << p.lifeTime_
@ -490,7 +490,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const streamLineParticle& p)
<< token::SPACE << p.sampledVectors_;
// Check state of Ostream
os.check("Ostream& operator<<(Ostream&, const streamLineParticle&)");
os.check("Ostream& operator<<(Ostream&, const streamlinesParticle&)");
return os;
}

66
src/functionObjects/field/streamLine/streamLineParticle.H → src/functionObjects/field/streamlines/streamlinesParticle.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,19 +22,19 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::streamLineParticle
Foam::streamlinesParticle
Description
Particle class that samples fields as it passes through. Used in streamline
Particle class that samples fields as it passes through. Used in streamlines
calculation.
SourceFiles
streamLineParticle.C
streamlinesParticle.C
\*---------------------------------------------------------------------------*/
#ifndef streamLineParticle_H
#define streamLineParticle_H
#ifndef streamlinesParticle_H
#define streamlinesParticle_H
#include "particle.H"
#include "Cloud.H"
@ -49,16 +49,16 @@ namespace Foam
// Forward declaration of friend functions and operators
class streamLineParticle;
class streamLineParticleCloud;
class streamlinesParticle;
class streamlinesCloud;
Ostream& operator<<(Ostream&, const streamLineParticle&);
Ostream& operator<<(Ostream&, const streamlinesParticle&);
/*---------------------------------------------------------------------------*\
Class streamLineParticle Declaration
Class streamlinesParticle Declaration
\*---------------------------------------------------------------------------*/
class streamLineParticle
class streamlinesParticle
:
public particle
{
@ -98,7 +98,7 @@ public:
//- Construct from components
trackingData
(
streamLineParticleCloud& cloud,
streamlinesCloud& cloud,
const PtrList<interpolation<scalar>>& vsInterp,
const PtrList<interpolation<vector>>& vvInterp,
const label UIndex,
@ -166,7 +166,7 @@ public:
// Constructors
//- Construct from components
streamLineParticle
streamlinesParticle
(
const polyMesh& c,
const vector& position,
@ -175,7 +175,7 @@ public:
);
//- Construct from Istream
streamLineParticle
streamlinesParticle
(
const polyMesh& c,
Istream& is,
@ -183,12 +183,12 @@ public:
);
//- Construct copy
streamLineParticle(const streamLineParticle& p);
streamlinesParticle(const streamlinesParticle& p);
//- Construct and return a clone
autoPtr<particle> clone() const
{
return autoPtr<particle>(new streamLineParticle(*this));
return autoPtr<particle>(new streamlinesParticle(*this));
}
//- Factory class to read-construct particles used for parallel transfer
@ -203,11 +203,11 @@ public:
mesh_(mesh)
{}
autoPtr<streamLineParticle> operator()(Istream& is) const
autoPtr<streamlinesParticle> operator()(Istream& is) const
{
return autoPtr<streamLineParticle>
return autoPtr<streamlinesParticle>
(
new streamLineParticle(mesh_, is, true)
new streamlinesParticle(mesh_, is, true)
);
}
};
@ -218,25 +218,25 @@ public:
// Tracking
//- Track all particles to their end point
bool move(streamLineParticleCloud&, trackingData&, const scalar);
bool move(streamlinesCloud&, trackingData&, const scalar);
//- Overridable function to handle the particle hitting a patch
// Executed before other patch-hitting functions
bool hitPatch(streamLineParticleCloud&, trackingData&);
bool hitPatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a wedge
void hitWedgePatch(streamLineParticleCloud&, trackingData&);
void hitWedgePatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a
// symmetry plane
void hitSymmetryPlanePatch(streamLineParticleCloud&, trackingData&);
void hitSymmetryPlanePatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a
// symmetry patch
void hitSymmetryPatch(streamLineParticleCloud&, trackingData&);
void hitSymmetryPatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a cyclic
void hitCyclicPatch(streamLineParticleCloud&, trackingData&);
void hitCyclicPatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a
// cyclicAMIPatch
@ -244,7 +244,7 @@ public:
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData&
);
@ -254,7 +254,7 @@ public:
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData&
);
@ -264,30 +264,30 @@ public:
(
const vector&,
const scalar,
streamLineParticleCloud&,
streamlinesCloud&,
trackingData&
);
//- Overridable function to handle the particle hitting a
//- processorPatch
void hitProcessorPatch(streamLineParticleCloud&, trackingData&);
void hitProcessorPatch(streamlinesCloud&, trackingData&);
//- Overridable function to handle the particle hitting a wallPatch
void hitWallPatch(streamLineParticleCloud&, trackingData&);
void hitWallPatch(streamlinesCloud&, trackingData&);
// I-O
//- Read
static void readFields(Cloud<streamLineParticle>&);
static void readFields(Cloud<streamlinesParticle>&);
//- Write
static void writeFields(const Cloud<streamLineParticle>&);
static void writeFields(const Cloud<streamlinesParticle>&);
// Ostream Operator
friend Ostream& operator<<(Ostream&, const streamLineParticle&);
friend Ostream& operator<<(Ostream&, const streamlinesParticle&);
};