ENH: patchProbes additions. Test probes at patches

src/sampling/Make/files

 probes/probes.C
+probes/patchProbes.C
 probes/probesGrouping.C
 probes/probesFunctionObject/probesFunctionObject.C
 

src/sampling/probes/IOprobes.H

@@ -33,6 +33,7 @@ Description
 #define IOprobes_H
 
 #include "probes.H"
+#include "patchProbes.H"
 #include "IOOutputFilter.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -40,6 +41,7 @@ Description
 namespace Foam
 {
     typedef IOOutputFilter<probes> IOprobes;
+    typedef IOOutputFilter<patchProbes> IOpatchProbes;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/sampling/probes/patchProbes.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "patchProbes.H"
+#include "volFields.H"
+#include "dictionary.H"
+#include "Time.H"
+#include "IOmanip.H"
+#include "directMappedPatchBase.C"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(patchProbes, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::patchProbes::findElements(const fvMesh& mesh)
+{
+
+    elementList_.clear();
+    elementList_.setSize(size());
+     // All the info for nearest. Construct to miss
+    List<nearInfo> nearest(this->size());
+
+    // Octree based search engine
+    meshSearch meshSearchEngine(mesh, false);
+
+    forAll(*this, probeI)
+    {
+        const vector& sample = operator[](probeI);
+        label faceI = meshSearchEngine.findNearestBoundaryFace(sample);
+        if (faceI == -1)
+        {
+            nearest[probeI].second().first() = Foam::sqr(GREAT);
+            nearest[probeI].second().second() = Pstream::myProcNo();
+        }
+        else
+        {
+            const point& fc = mesh.faceCentres()[faceI];
+            nearest[probeI].first() = pointIndexHit
+            (
+                true,
+                fc,
+                faceI
+            );
+            nearest[probeI].second().first() = magSqr(fc-sample);
+            nearest[probeI].second().second() = Pstream::myProcNo();
+        }
+    }
+
+
+    // Find nearest.
+    Pstream::listCombineGather(nearest, nearestEqOp());
+    Pstream::listCombineScatter(nearest);
+
+    if (debug)
+    {
+        Info<< "patchProbes::findElements" << " : " << endl;
+        forAll(nearest, sampleI)
+        {
+            label procI = nearest[sampleI].second().second();
+            label localI = nearest[sampleI].first().index();
+
+            Info<< "    " << sampleI << " coord:"<< operator[](sampleI)
+                << " found on processor:" << procI
+                << " in local cell/face:" << localI
+                << " with cc:" << nearest[sampleI].first().rawPoint() << endl;
+        }
+    }
+
+
+
+    // Check if all patchProbes have been found.
+    forAll(nearest, sampleI)
+    {
+        label localI = nearest[sampleI].first().index();
+
+        if (localI == -1)
+        {
+             if (Pstream::master())
+             {
+                WarningIn("patchProbes::findElements()")
+                    << "Did not find location "
+                    <<  nearest[sampleI].second().first()
+                    << " in any cell. Skipping location." << endl;
+             }
+        }
+        else
+        {
+            elementList_[sampleI] = localI;
+        }
+    }
+}
+
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchProbes::patchProbes
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    probes(name, obr, dict, loadFromFiles)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchProbes::~patchProbes()
+{}
+
+
+void Foam::patchProbes::write()
+{
+    if (this->size() && prepare())
+    {
+        sampleAndWrite(scalarFields_);
+        sampleAndWrite(vectorFields_);
+        sampleAndWrite(sphericalTensorFields_);
+        sampleAndWrite(symmTensorFields_);
+        sampleAndWrite(tensorFields_);
+    }
+}
+
+void Foam::patchProbes::read(const dictionary& dict)
+{
+    probes::read(dict);
+}
+
+
+// ************************************************************************* //

src/sampling/probes/patchProbes.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::patchProbes
+
+Description
+    Set of locations to sample.at patches
+
+    Call write() to sample and write files.
+
+SourceFiles
+    patchProbes.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchProbes_H
+#define patchProbes_H
+
+#include "HashPtrTable.H"
+#include "OFstream.H"
+#include "polyMesh.H"
+#include "pointField.H"
+#include "volFieldsFwd.H"
+#include "probes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class fvMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                          Class patchProbes Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchProbes
+:
+    public probes
+{
+
+    // Private Member Functions
+
+        //- Sample and write a particular volume field
+        template<class Type>
+        void sampleAndWrite
+        (
+            const GeometricField<Type, fvPatchField, volMesh>&
+        );
+
+
+        //- Sample and write all the fields of the given type
+        template <class Type>
+        void sampleAndWrite(const fieldGroup<Type>&);
+
+
+        //- Sample a volume field at all locations
+        template<class Type>
+        tmp<Field<Type> > sample
+        (
+            const GeometricField<Type, fvPatchField, volMesh>&
+        ) const;
+
+
+        //- Sample a single field on all sample locations
+        template <class Type>
+        tmp<Field<Type> > sample(const word& fieldName) const;
+
+
+        //- Disallow default bitwise copy construct
+        patchProbes(const patchProbes&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const patchProbes&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("patchProbes");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        patchProbes
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~patchProbes();
+
+    //- Public members
+
+        //- Sample and write
+        virtual void write();
+
+        //- Read
+        virtual void read(const dictionary&);
+
+        //- Find elements containing patchProbes
+        virtual void findElements(const fvMesh&);
+
+
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "patchProbesTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/sampling/probes/patchProbesTemplates.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2010 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "patchProbes.H"
+#include "volFields.H"
+#include "IOmanip.H"
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::patchProbes::sampleAndWrite
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vField
+)
+{
+    Field<Type> values = sample(vField);
+
+    if (Pstream::master())
+    {
+        unsigned int w = IOstream::defaultPrecision() + 7;
+        OFstream& probeStream = *probeFilePtrs_[vField.name()];
+
+        probeStream << setw(w) << vField.time().value();
+
+        forAll(values, probeI)
+        {
+            probeStream << ' ' << setw(w) << values[probeI];
+        }
+        probeStream << endl;
+    }
+}
+
+
+template <class Type>
+void Foam::patchProbes::sampleAndWrite
+(
+    const fieldGroup<Type>& fields
+)
+{
+    forAll(fields, fieldI)
+    {
+        if (loadFromFiles_)
+        {
+            sampleAndWrite
+            (
+                GeometricField<Type, fvPatchField, volMesh>
+                (
+                    IOobject
+                    (
+                        fields[fieldI],
+                        mesh_.time().timeName(),
+                        mesh_,
+                        IOobject::MUST_READ,
+                        IOobject::NO_WRITE,
+                        false
+                    ),
+                    mesh_
+                )
+            );
+        }
+        else
+        {
+            objectRegistry::const_iterator iter = mesh_.find(fields[fieldI]);
+
+            if
+            (
+                iter != objectRegistry::end()
+             && iter()->type()
+             == GeometricField<Type, fvPatchField, volMesh>::typeName
+            )
+            {
+                sampleAndWrite
+                (
+                    mesh_.lookupObject
+                    <GeometricField<Type, fvPatchField, volMesh> >
+                    (
+                        fields[fieldI]
+                    )
+                );
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::patchProbes::sample
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vField
+) const
+{
+    const Type unsetVal(-VGREAT*pTraits<Type>::one);
+
+    tmp<Field<Type> > tValues
+    (
+        new Field<Type>(this->size(), unsetVal)
+    );
+
+    Field<Type>& values = tValues();
+
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    forAll(*this, probeI)
+    {
+        label faceI = elementList_[probeI];
+
+        if (faceI >= 0)
+        {
+            label patchI = patches.whichPatch(faceI);
+            label localFaceI = patches[patchI].whichFace(faceI);
+            values[probeI] = vField.boundaryField()[patchI][localFaceI];
+        }
+    }
+
+    Pstream::listCombineGather(values, isNotEqOp<Type>());
+    Pstream::listCombineScatter(values);
+
+    return tValues;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::patchProbes::sample(const word& fieldName) const
+{
+    return sample
+    (
+        mesh_.lookupObject<GeometricField<Type, fvPatchField, volMesh> >
+        (
+            fieldName
+        )
+    );
+}
+
+
+// ************************************************************************* //

src/sampling/probes/probes.C

@@ -36,30 +36,30 @@ defineTypeNameAndDebug(Foam::probes, 0);
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::probes::findCells(const fvMesh& mesh)
+void Foam::probes::findElements(const fvMesh& mesh)
 {
-    cellList_.clear();
-    cellList_.setSize(size());
+    elementList_.clear();
+    elementList_.setSize(size());
 
     forAll(*this, probeI)
     {
         const vector& location = operator[](probeI);
 
-        cellList_[probeI] = mesh.findCell(location);
+        elementList_[probeI] = mesh.findCell(location);
 
-        if (debug && cellList_[probeI] != -1)
+        if (debug && elementList_[probeI] != -1)
         {
             Pout<< "probes : found point " << location
-                << " in cell " << cellList_[probeI] << endl;
+                << " in cell " << elementList_[probeI] << endl;
         }
     }
 
 
     // Check if all probes have been found.
-    forAll(cellList_, probeI)
+    forAll(elementList_, probeI)
     {
         const vector& location = operator[](probeI);
-        label cellI = cellList_[probeI];
+        label cellI = elementList_[probeI];
 
         // Check at least one processor with cell.
         reduce(cellI, maxOp<label>());
@@ -76,12 +76,12 @@ void Foam::probes::findCells(const fvMesh& mesh)
         else
         {
             // Make sure location not on two domains.
-            if (cellList_[probeI] != -1 && cellList_[probeI] != cellI)
+            if (elementList_[probeI] != -1 && elementList_[probeI] != cellI)
             {
                 WarningIn("probes::read()")
                     << "Location " << location
                     << " seems to be on multiple domains:"
-                    << " cell " << cellList_[probeI]
+                    << " cell " << elementList_[probeI]
                     << " on my domain " << Pstream::myProcNo()
                         << " and cell " << cellI << " on some other domain."
                     << endl
@@ -249,7 +249,7 @@ void Foam::probes::read(const dictionary& dict)
     dict.lookup("fields") >> fieldSelection_;
 
     // redetermined all cell locations
-    findCells(mesh_);
+    findElements(mesh_);
     prepare();
 }
 

src/sampling/probes/probes.H

@@ -64,7 +64,9 @@ class probes
 :
     public pointField
 {
-    // Private classes
+protected:
+
+    // Protected classes
 
         //- Class used for grouping field types
         template<class Type>
@@ -110,7 +112,7 @@ class probes
             fieldGroup<tensor> tensorFields_;
 
             // Cells to be probed (obtained from the locations)
-            labelList cellList_;
+            labelList elementList_;
 
             //- Current open files
             HashPtrTable<OFstream> probeFilePtrs_;
@@ -128,12 +130,14 @@ class probes
         label classifyFields();
 
         //- Find cells containing probes
-        void findCells(const fvMesh&);
+        virtual void findElements(const fvMesh&);
 
         //- Classify field type and Open/close file streams,
         //  returns number of fields
         label prepare();
 
+private:
+
         //- Sample and write a particular volume field
         template<class Type>
         void sampleAndWrite
@@ -202,9 +206,9 @@ public:
         }
 
         //- Cells to be probed (obtained from the locations)
-        const labelList& cells() const
+        const labelList& elemets() const
         {
-            return cellList_;
+            return elementList_;
         }
 
         //- Execute, currently does nothing

src/sampling/probes/probesFunctionObject/probesFunctionObject.C

@@ -30,6 +30,7 @@ License
 namespace Foam
 {
     defineNamedTemplateTypeNameAndDebug(probesFunctionObject, 0);
+    defineNamedTemplateTypeNameAndDebug(patchProbesFunctionObject, 0);
 
     addToRunTimeSelectionTable
     (
@@ -37,6 +38,12 @@ namespace Foam
         probesFunctionObject,
         dictionary
     );
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        patchProbesFunctionObject,
+        dictionary
+    );