functionObjects: Renamed streamLine and streamLines to streamlines

etc/caseDicts/postProcessing/streamlines/streamlines.cfg

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-type            streamLine;
+type            streamlines;
 libs            ("libfieldFunctionObjects.so");
 
 executeControl  writeTime;

etc/caseDicts/postProcessing/streamlines/streamlinesLine

@@ -20,6 +20,6 @@ fields  (<fieldNames>);
 direction both; // Direction in which to track from the starting points. Can be
                 // "both", "forward" or "backward"
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLinesLine.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlinesLine.cfg"
 
 // ************************************************************************* //

etc/caseDicts/postProcessing/streamlines/streamlinesLine.cfg

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLines.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlines.cfg"
 
 seedSampleSet
 {

etc/caseDicts/postProcessing/streamlines/streamlinesPatch

@@ -19,6 +19,6 @@ fields  (<fieldNames>);
 direction both; // Direction in which to track from the starting points. Can be
                 // "both", "forward" or "backward"
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLinesPatch.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlinesPatch.cfg"
 
 // ************************************************************************* //

etc/caseDicts/postProcessing/streamlines/streamlinesPatch.cfg

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLines.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlines.cfg"
 
 seedSampleSet
 {

etc/caseDicts/postProcessing/streamlines/streamlinesPoints

@@ -18,6 +18,6 @@ fields  (<fieldNames>);
 direction both; // Direction in which to track from the starting points. Can be
                 // "both", "forward" or "backward"
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLinesPoints.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlinesPoints.cfg"
 
 // ************************************************************************* //

etc/caseDicts/postProcessing/streamlines/streamlinesPoints.cfg

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLines.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlines.cfg"
 
 seedSampleSet
 {

etc/caseDicts/postProcessing/streamlines/streamlinesSphere

@@ -20,6 +20,6 @@ fields  (<fieldNames>);
 direction both; // Direction in which to track from the starting points. Can be
                 // "both", "forward" or "backward"
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLinesSphere.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlinesSphere.cfg"
 
 // ************************************************************************* //

etc/caseDicts/postProcessing/streamlines/streamlinesSphere.cfg

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/streamLines/streamLines.cfg"
+#includeEtc "caseDicts/postProcessing/streamlines/streamlines.cfg"
 
 seedSampleSet
 {

src/functionObjects/field/Make/files

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

src/functionObjects/field/streamlines/streamlines.C

@@ -25,8 +25,8 @@ License
 
 #include "Pstream.H"
 #include "functionObjectList.H"
-#include "streamLine.H"
+#include "streamlines.H"
-#include "streamLineParticleCloud.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);
+        defineTypeNameAndDebug(streamlines, 0);
-        addToRunTimeSelectionTable(functionObject, streamLine, dictionary);
+        addToRunTimeSelectionTable(functionObject, streamlines, dictionary);
 
-        const NamedEnum<streamLine::trackDirection, 3>
+        const NamedEnum<streamlines::trackDirection, 3>
-            streamLine::trackDirectionNames_;
+            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;
+    IDLList<streamlinesParticle> initialParticles;
-    streamLineParticleCloud particles
+    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_)
     {

src/functionObjects/field/streamlines/streamlines.H

@@ -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
+    Generates streamline data by sampling a set of user-specified fields along
-    particle track, transported by a user-specified velocity field.
+    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
+#ifndef functionObjects_streamlines_H
-#define functionObjects_streamLine_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;
 };
 
 

src/functionObjects/field/streamlines/streamlinesCloud.C

@@ -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)
 {}
 
 

src/functionObjects/field/streamlines/streamlinesCloud.H

@@ -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
+#ifndef streamlinesCloud_H
-#define streamLineParticleCloud_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;
 };
 
 

src/functionObjects/field/streamlines/streamlinesParticle.C

@@ -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 "streamlinesParticle.H"
-#include "streamLineParticleCloud.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"
+        "streamlinesParticle::streamlinesParticle"
-        "(const Cloud<streamLineParticle>&, Istream&, bool)"
+        "(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;
 }

src/functionObjects/field/streamlines/streamlinesParticle.H

@@ -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
+#ifndef streamlinesParticle_H
-#define streamLineParticle_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 streamlinesParticle;
-class streamLineParticleCloud;
+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&);
 };
 
 

test/postProcessing/channel/system/controlDict

@@ -323,9 +323,9 @@ solversFunctions
     //#includeFunc particles
 }
 
-streamLinesFunctions
+streamlinesFunctions
 {
-    #includeFunc streamLinesSphere
+    #includeFunc streamlinesSphere
     (
         centre=(0 0 0),
         radius=0.1,
@@ -335,7 +335,7 @@ streamLinesFunctions
         direction=forward
     )
 
-    #includeFunc streamLinesLine
+    #includeFunc streamlinesLine
     (
         start=(-0.5 -0.5 -0.05),
         end=(0.5 0.5 0.05),
@@ -345,7 +345,7 @@ streamLinesFunctions
         direction=backward
     )
 
-    #includeFunc streamLinesPatch
+    #includeFunc streamlinesPatch
     (
         patch=inlet,
         nPoints=100,
@@ -353,7 +353,7 @@ streamLinesFunctions
         U
     )
 
-    #includeFunc streamLinesPoints
+    #includeFunc streamlinesPoints
     (
         points=((-0.2 -0.2 0) (0 0 0) (0.2 0.2 0))
         p,
@@ -409,7 +409,7 @@ functions
     $pressureFunctions;
     $probesFunctions;
     $solversFunctions;
-    $streamLinesFunctions;
+    $streamlinesFunctions;
     $surfaceFunctions;
     $surfaceFieldValueFunctions;
 }

tutorials/heatTransfer/buoyantPimpleFoam/BernardCells/system/controlDict

@@ -47,7 +47,7 @@ runTimeModifiable true;
 functions
 {
     #includeFunc residuals(p_rgh)
-    #includeFunc streamLinesLine(funcName=streamlines, start=(0 0.5 0), end=(9 0.5 0), nPoints=24, U)
+    #includeFunc streamlinesLine(funcName=streamlines, start=(0 0.5 0), end=(9 0.5 0), nPoints=24, U)
 }
 
 // ************************************************************************* //

tutorials/incompressible/pisoFoam/LES/motorBike/lesFiles/controlDict

@@ -65,7 +65,7 @@ functions
     }
 
     #include "cuttingPlane"
-    #include "streamLines"
+    #include "streamlines"
     #include "forceCoeffs"
 }
 

tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/controlDict

@@ -47,7 +47,7 @@ runTimeModifiable true;
 functions
 {
     #include "cuttingPlane"
-    #include "streamLines"
+    #include "streamlines"
     #include "forceCoeffs"
 }
 

tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/streamlines

@@ -6,9 +6,9 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-streamLines
+streamlines
 {
-    type            streamLine;
+    type            streamlines;
 
     libs            ("libfieldFunctionObjects.so");
 

tutorials/incompressible/simpleFoam/drivaerFastback/system/controlDict.orig

@@ -53,7 +53,7 @@ functions
 
     #includeFunc time
 
-    #includeFunc streamLinesSphere
+    #includeFunc streamlinesSphere
     (
         funcName=streamlines,
         centre=(4 0 0.7),

tutorials/incompressible/simpleFoam/motorBike/system/controlDict

@@ -45,7 +45,7 @@ runTimeModifiable true;
 
 functions
 {
-    #include "streamLines"
+    #include "streamlines"
     #include "cuttingPlane"
     #include "forceCoeffs"
 }

tutorials/incompressible/simpleFoam/motorBike/system/streamlines

@@ -6,12 +6,12 @@
      \\/     M anipulation  |
 \*---------------------------------------------------------------------------*/
 
-streamLines
+streamlines
 {
     // Where to load it from
     libs            ("libfieldFunctionObjects.so");
 
-    type            streamLine;
+    type            streamlines;
 
     // Output every
     writeControl    writeTime;

tutorials/incompressible/simpleFoam/pitzDaily/system/controlDict

@@ -51,7 +51,7 @@ cacheTemporaryObjects
 
 functions
 {
-    #includeFunc streamLinesLine
+    #includeFunc streamlinesLine
     (
         funcName=streamlines,
         start=(-0.0205 0.001 0.00001),

tutorials/incompressible/simpleFoam/pitzDailyExptInlet/system/controlDict

@@ -46,9 +46,9 @@ runTimeModifiable true;
 
 functions
 {
-    streamLines
+    streamlines
     {
-        type            streamLine;
+        type            streamlines;
 
         // Where to load it from (if not already in solver)
         libs            ("libfieldFunctionObjects.so");