Resolved confict

src/lagrangian/intermediate/Make/files

@@ -48,6 +48,7 @@ $(RADIATION)/absorptionEmission/cloudAbsorptionEmission/cloudAbsorptionEmission.
 $(RADIATION)/scatter/cloudScatter/cloudScatter.C
 
 submodels/Kinematic/PatchInteractionModel/LocalInteraction/patchInteractionData.C
+submodels/Kinematic/PatchInteractionModel/LocalInteraction/patchInteractionDataList.C
 
 KINEMATICINJECTION=submodels/Kinematic/InjectionModel
 $(KINEMATICINJECTION)/KinematicLookupTableInjection/kinematicParcelInjectionData.C

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/cloudSolution/cloudSolution.C

@@ -127,17 +127,19 @@ void Foam::cloudSolution::read()
     schemes_.setSize(vars.size());
     forAll(vars, i)
     {
+        // read solution variable name
         schemes_[i].first() = vars[i];
 
+        // set semi-implicit (1) explicit (0) flag
         Istream& is = schemesDict.lookup(vars[i]);
         const word scheme(is);
         if (scheme == "semiImplicit")
         {
-            is >> schemes_[i].second();
+            schemes_[i].second().first() = true;
         }
         else if (scheme == "explicit")
         {
-            schemes_[i].second() = -1;
+            schemes_[i].second().first() = false;
         }
         else
         {
@@ -145,6 +147,9 @@ void Foam::cloudSolution::read()
                 << "Invalid scheme " << scheme << ". Valid schemes are "
                 << "explicit and semiImplicit" << exit(FatalError);
         }
+
+        // read under-relaxation factor
+        is  >> schemes_[i].second().second();
     }
 }
 
@@ -155,7 +160,7 @@ Foam::scalar Foam::cloudSolution::relaxCoeff(const word& fieldName) const
     {
         if (fieldName == schemes_[i].first())
         {
-            return schemes_[i].second();
+            return schemes_[i].second().second();
         }
     }
 
@@ -173,7 +178,7 @@ bool Foam::cloudSolution::semiImplicit(const word& fieldName) const
     {
         if (fieldName == schemes_[i].first())
         {
-            return schemes_[i].second() >= 0;
+            return schemes_[i].second().first();
         }
     }
 

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/cloudSolution/cloudSolution.H

@@ -25,7 +25,7 @@ Class
     Foam::cloudSolution
 
 Description
-    - Stores all relevant solution info
+    Stores all relevant solution info for cloud
 
 SourceFiles
     cloudSolutionI.H
@@ -100,7 +100,7 @@ class cloudSolution
             Switch resetSourcesOnStartup_;
 
             //- List schemes, e.g. U semiImplicit 1
-            List<Tuple2<word, scalar> > schemes_;
+            List<Tuple2<word, Tuple2<bool, scalar> > > schemes_;
 
 
     // Private Member Functions

src/lagrangian/intermediate/submodels/Kinematic/PatchInteractionModel/LocalInteraction/LocalInteraction.C

@@ -33,9 +33,9 @@ Foam::label Foam::LocalInteraction<CloudType>::applyToPatch
     const label globalPatchI
 ) const
 {
-    forAll(patchIds_, patchI)
+    forAll(patchIDs_, patchI)
     {
-        if (patchIds_[patchI] == globalPatchI)
+        if (patchIDs_[patchI] == globalPatchI)
         {
             return patchI;
         }
@@ -130,8 +130,8 @@ Foam::LocalInteraction<CloudType>::LocalInteraction
 )
 :
     PatchInteractionModel<CloudType>(dict, cloud, typeName),
-    patchData_(this->coeffDict().lookup("patches")),
+    patchData_(cloud.mesh(), this->coeffDict().lookup("patches")),
-    patchIds_(patchData_.size()),
+    patchIDs_(patchData_.size()),
     nEscape0_(patchData_.size(), 0),
     massEscape0_(patchData_.size(), 0.0),
     nStick0_(patchData_.size(), 0),
@@ -141,44 +141,6 @@ Foam::LocalInteraction<CloudType>::LocalInteraction
     nStick_(patchData_.size(), 0),
     massStick_(patchData_.size(), 0.0)
 {
-    const polyMesh& mesh = cloud.mesh();
-    const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
-
-    // check that user patches are valid region patches
-    forAll(patchData_, patchI)
-    {
-        const word& patchName = patchData_[patchI].patchName();
-        patchIds_[patchI] = bMesh.findPatchID(patchName);
-        if (patchIds_[patchI] < 0)
-        {
-            FatalErrorIn("LocalInteraction(const dictionary&, CloudType&)")
-                << "Patch " << patchName << " not found. Available patches "
-                << "are: " << bMesh.names() << nl << exit(FatalError);
-        }
-    }
-
-    // check that all walls are specified
-    DynamicList<word> badWalls;
-    forAll(bMesh, patchI)
-    {
-        if
-        (
-            isA<wallPolyPatch>(bMesh[patchI])
-         && applyToPatch(bMesh[patchI].index()) < 0
-        )
-        {
-            badWalls.append(bMesh[patchI].name());
-        }
-    }
-
-    if (badWalls.size() > 0)
-    {
-        FatalErrorIn("LocalInteraction(const dictionary&, CloudType&)")
-            << "All wall patches must be specified when employing local patch "
-            << "interaction. Please specify data for patches:" << nl
-            << badWalls << nl << exit(FatalError);
-    }
-
     // check that interactions are valid/specified
     forAll(patchData_, patchI)
     {
@@ -211,7 +173,7 @@ Foam::LocalInteraction<CloudType>::LocalInteraction
 :
     PatchInteractionModel<CloudType>(pim),
     patchData_(pim.patchData_),
-    patchIds_(pim.patchIds_),
+    patchIDs_(pim.patchIDs_),
     nEscape0_(pim.nEscape0_),
     massEscape0_(pim.massEscape0_),
     nStick0_(pim.nStick0_),

src/lagrangian/intermediate/submodels/Kinematic/PatchInteractionModel/LocalInteraction/LocalInteraction.H

@@ -33,7 +33,7 @@ Description
 #define LocalInteraction_H
 
 #include "PatchInteractionModel.H"
-#include "patchInteractionData.H"
+#include "patchInteractionDataList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,10 +51,10 @@ class LocalInteraction
     // Private data
 
         //- List of participating patches
-        const List<patchInteractionData> patchData_;
+        const patchInteractionDataList patchData_;
 
         //- List of participating patch ids
-        List<label> patchIds_;
+        List<label> patchIDs_;
 
 
         // Counters for initial particle fates

src/lagrangian/intermediate/submodels/Kinematic/PatchInteractionModel/LocalInteraction/patchInteractionDataList.C

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "patchInteractionDataList.H"
+#include "stringListOps.H"
+#include "wallPolyPatch.H"
+
+// * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
+
+Foam::patchInteractionDataList::patchInteractionDataList()
+:
+    List<patchInteractionData>(),
+    patchGroupIDs_()
+{}
+
+
+Foam::patchInteractionDataList::patchInteractionDataList
+(
+    const polyMesh& mesh,
+    const dictionary& dict
+)
+:
+    List<patchInteractionData>(dict.lookup("patches")),
+    patchGroupIDs_(this->size())
+{
+    const polyBoundaryMesh& bMesh = mesh.boundaryMesh();
+    const wordList allPatchNames = bMesh.names();
+
+    const List<patchInteractionData>& items = *this;
+    forAllReverse(items, i)
+    {
+        const word& patchName = items[i].patchName();
+        labelList patchIDs = findStrings(patchName, allPatchNames);
+
+        if (patchIDs.empty())
+        {
+            WarningIn
+            (
+                "Foam::patchInteractionDataList::patchInteractionDataList"
+                "("
+                    "const polyMesh&, "
+                    "const dictionary&"
+                ")"
+            )   << "Cannot find any patch names matching " << patchName
+                << endl;
+        }
+
+        patchGroupIDs_[i].transfer(patchIDs);
+    }
+
+    // check that all walls are specified
+    DynamicList<word> badWalls;
+    forAll(bMesh, patchI)
+    {
+        const polyPatch& pp = bMesh[patchI];
+        if (isA<wallPolyPatch>(pp) && applyToPatch(pp.index()) < 0)
+        {
+            badWalls.append(pp.name());
+        }
+    }
+
+    if (badWalls.size() > 0)
+    {
+        FatalErrorIn
+        (
+            "Foam::patchInteractionDataList::patchInteractionDataList"
+            "("
+                "const polyMesh&, "
+                "const dictionary&"
+            ")"
+        )    << "All wall patches must be specified when employing local patch "
+            << "interaction. Please specify data for patches:" << nl
+            << badWalls << nl << exit(FatalError);
+    }
+}
+
+
+Foam::patchInteractionDataList::patchInteractionDataList
+(
+    const patchInteractionDataList& pidl
+)
+:
+    List<patchInteractionData>(pidl),
+    patchGroupIDs_(pidl.patchGroupIDs_)
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::label Foam::patchInteractionDataList::applyToPatch(const label id) const
+{
+    forAll(patchGroupIDs_, groupI)
+    {
+        const labelList& patchIDs = patchGroupIDs_[groupI];
+        forAll(patchIDs, patchI)
+        {
+            if (patchIDs[patchI] == id)
+            {
+                return groupI;
+            }
+        }
+    }
+
+    return -1;
+}
+
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/PatchInteractionModel/LocalInteraction/patchInteractionDataList.H

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2011 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::patchInteractionDataList
+
+Description
+    List container for patchInteractionData class
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchInteractionDataList_H
+#define patchInteractionDataList_H
+
+#include "patchInteractionData.H"
+#include "polyMesh.H"
+#include "dictionary.H"
+#include "labelList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                  Class patchInteractionDataList Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchInteractionDataList
+:
+    public List<patchInteractionData>
+{
+private:
+
+    // Private data
+
+        //- List of patch IDs for each patch group
+        labelListList patchGroupIDs_;
+
+
+public:
+
+    // Constructor
+
+        //- Construct null
+        patchInteractionDataList();
+
+        //- Construct copy
+        patchInteractionDataList(const patchInteractionDataList& pidl);
+
+        //- Construct from Istream
+        patchInteractionDataList(const polyMesh& mesh, const dictionary& dict);
+
+
+    // Member functions
+
+        //- Return label of group containing patch id
+        //  Returns -1 if patch id is not present
+        label applyToPatch(const label id) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,7 @@ License
 
 #include "PatchPostProcessing.H"
 #include "Pstream.H"
+#include "stringListOps.H"
 #include "ListListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -35,12 +36,15 @@ Foam::label Foam::PatchPostProcessing<CloudType>::applyToPatch
     const label globalPatchI
 ) const
 {
-    forAll(patchIds_, patchI)
+    label patchI = 0;
+    forAllConstIter(labelHashSet, patchIDs_, iter)
     {
-        if (patchIds_[patchI] == globalPatchI)
+        if (iter.key() == globalPatchI)
         {
             return patchI;
         }
+
+        patchI++;
     }
 
     return -1;
@@ -52,16 +56,18 @@ Foam::label Foam::PatchPostProcessing<CloudType>::applyToPatch
 template<class CloudType>
 void Foam::PatchPostProcessing<CloudType>::write()
 {
-    forAll(patchData_, patchI)
+    forAll(patchData_, i)
     {
         List<List<string> > procData(Pstream::nProcs());
-        procData[Pstream::myProcNo()] = patchData_[patchI];
+        procData[Pstream::myProcNo()] = patchData_[i];
 
         Pstream::gatherList(procData);
 
         if (Pstream::master())
         {
-            fileName outputDir = this->owner().time().path();
+            const fvMesh& mesh = this->owner().mesh();
+
+            fileName outputDir = mesh.time().path();
 
             if (Pstream::parRun())
             {
@@ -69,24 +75,26 @@ void Foam::PatchPostProcessing<CloudType>::write()
                 // distributed data running)
                 outputDir =
                     outputDir/".."/"postProcessing"/cloud::prefix/
-                    this->owner().name()/this->owner().time().timeName();
+                    this->owner().name()/mesh.time().timeName();
             }
             else
             {
                 outputDir =
                     outputDir/"postProcessing"/cloud::prefix/
-                    this->owner().name()/this->owner().time().timeName();
+                    this->owner().name()/mesh.time().timeName();
             }
 
             // Create directory if it doesn't exist
             mkDir(outputDir);
 
+            const word& patchName = mesh.boundaryMesh()[patchIDs_[i]].name();
+
             OFstream patchOutFile
             (
-                outputDir/patchNames_[patchI] + ".post",
+                outputDir/patchName + ".post",
                 IOstream::ASCII,
                 IOstream::currentVersion,
-                this->owner().time().writeCompression()
+                mesh.time().writeCompression()
             );
 
             List<string> globalData;
@@ -99,13 +107,13 @@ void Foam::PatchPostProcessing<CloudType>::write()
 
             patchOutFile<< "# Time " + parcelType::propHeader << nl;
 
-            forAll(globalData, i)
+            forAll(globalData, dataI)
             {
-                patchOutFile<< globalData[i].c_str() << nl;
+                patchOutFile<< globalData[dataI].c_str() << nl;
             }
         }
 
-        patchData_[patchI].clearStorage();
+        patchData_[i].clearStorage();
     }
 }
 
@@ -121,29 +129,36 @@ Foam::PatchPostProcessing<CloudType>::PatchPostProcessing
 :
     PostProcessingModel<CloudType>(dict, owner, typeName),
     maxStoredParcels_(readLabel(this->coeffDict().lookup("maxStoredParcels"))),
-    patchNames_(this->coeffDict().lookup("patches")),
+    patchIDs_(),
-    patchData_(patchNames_.size()),
+    patchData_()
-    patchIds_(patchNames_.size())
 {
-    const polyBoundaryMesh& bMesh = this->owner().mesh().boundaryMesh();
+    const wordList allPatchNames = owner.mesh().boundaryMesh().names();
-    forAll(patchNames_, patchI)
+    wordList patchName(this->coeffDict().lookup("patches"));
+
+    forAllReverse(patchName, i)
     {
-        const label id = bMesh.findPatchID(patchNames_[patchI]);
+        labelList patchIDs = findStrings(patchName[i], allPatchNames);
-        if (id < 0)
+
+        if (patchIDs.empty())
         {
-            FatalErrorIn
+            WarningIn
             (
-                "PatchPostProcessing<CloudType>::PatchPostProcessing"
+                "Foam::PatchPostProcessing<CloudType>::PatchPostProcessing"
                 "("
                     "const dictionary&, "
-                    "CloudType& owner"
+                    "CloudType& "
                 ")"
-            )<< "Requested patch " << patchNames_[patchI] << " not found" << nl
+            )   << "Cannot find any patch names matching " << patchName[i]
-             << "Available patches are: " << bMesh.names() << nl
+                << endl;
-             << exit(FatalError);
+        }
+
+        forAll(patchIDs, j)
+        {
+            patchIDs_.insert(patchIDs[j]);
         }
-        patchIds_[patchI] = id;
     }
+
+    patchData_.setSize(patchIDs_.size());
 }
 
 
@@ -155,9 +170,8 @@ Foam::PatchPostProcessing<CloudType>::PatchPostProcessing
 :
     PostProcessingModel<CloudType>(ppm),
     maxStoredParcels_(ppm.maxStoredParcels_),
-    patchNames_(ppm.patchNames_),
+    patchIDs_(ppm.patchIDs_),
-    patchData_(ppm.patchData_),
+    patchData_(ppm.patchData_)
-    patchIds_(ppm.patchIds_)
 {}
 
 
@@ -177,8 +191,8 @@ void Foam::PatchPostProcessing<CloudType>::postPatch
     const label patchI
 )
 {
-    label localPatchI = applyToPatch(patchI);
+    const label localPatchI = applyToPatch(patchI);
-    if (localPatchI >= 0 && patchData_[localPatchI].size() < maxStoredParcels_)
+    if (localPatchI != -1 && patchData_[localPatchI].size() < maxStoredParcels_)
     {
         OStringStream data;
         data<< this->owner().time().timeName() << ' ' << p;

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessing.H

@@ -58,15 +58,12 @@ class PatchPostProcessing
         //- Maximum number of parcels to store
         label maxStoredParcels_;
 
-        //- List of patch names
+        //- List of patch indices to post-process
-        wordList patchNames_;
+        labelHashSet patchIDs_;
 
         //- List of output data per patch
         List<DynamicList<string> > patchData_;
 
-        //- Mapping from local to global patch ids
-        labelList patchIds_;
-
 
     // Private Member Functions
 
@@ -117,11 +114,8 @@ public:
             //- Return maximum number of parcels to store per patch
             inline label maxStoredParcels() const;
 
-            //- Return const access to the list of patch names
-            inline const wordList& patchNames() const;
-
             //- Return const mapping from local to global patch ids
-            inline const labelList& patchIds() const;
+            inline const labelList& patchIDs() const;
 
 
         // Evaluation

src/lagrangian/intermediate/submodels/Kinematic/PostProcessingModel/PatchPostProcessing/PatchPostProcessingI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2008-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2008-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -31,17 +31,9 @@ Foam::label Foam::PatchPostProcessing<CloudType>::maxStoredParcels() const
 
 
 template<class CloudType>
-const Foam::wordList& Foam::PatchPostProcessing<CloudType>::patchNames() const
+const Foam::labelList& Foam::PatchPostProcessing<CloudType>::patchIDs() const
 {
-    return patchNames_;
+    return patchIDs_;
-}
-
-
-template<class CloudType>
-const Foam::labelList&
-Foam::PatchPostProcessing<CloudType>::patchIds() const
-{
-    return patchIds_;
 }
 
 

src/sampling/sampledSet/sampledSets/sampledSets.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2004-2010 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -231,28 +231,43 @@ void Foam::sampledSets::write()
 void Foam::sampledSets::read(const dictionary& dict)
 {
     dict_ = dict;
-    dict_.lookup("fields") >> fieldSelection_;
-    clearFieldGroups();
 
-    dict.lookup("interpolationScheme") >> interpolationScheme_;
+    bool setsFound = dict_.found("sets");
-    dict.lookup("setFormat") >> writeFormat_;
+    if (setsFound)
+    {
+        dict_.lookup("fields") >> fieldSelection_;
+        clearFieldGroups();
 
-    PtrList<sampledSet> newList
+        dict.lookup("interpolationScheme") >> interpolationScheme_;
-    (
+        dict.lookup("setFormat") >> writeFormat_;
-        dict_.lookup("sets"),
+
-        sampledSet::iNew(mesh_, searchEngine_)
+        PtrList<sampledSet> newList
-    );
+        (
-    transfer(newList);
+            dict_.lookup("sets"),
-    combineSampledSets(masterSampledSets_, indexSets_);
+            sampledSet::iNew(mesh_, searchEngine_)
+        );
+        transfer(newList);
+        combineSampledSets(masterSampledSets_, indexSets_);
+
+        if (this->size())
+        {
+            Info<< "Reading set description:" << nl;
+            forAll(*this, setI)
+            {
+                Info<< "    " << operator[](setI).name() << nl;
+            }
+            Info<< endl;
+        }
+    }
 
     if (Pstream::master() && debug)
     {
         Pout<< "sample fields:" << fieldSelection_ << nl
             << "sample sets:" << nl << "(" << nl;
 
-        forAll(*this, si)
+        forAll(*this, setI)
         {
-            Pout<< "  " << operator[](si) << endl;
+            Pout<< "  " << operator[](setI) << endl;
         }
         Pout<< ")" << endl;
     }
@@ -261,19 +276,23 @@ void Foam::sampledSets::read(const dictionary& dict)
 
 void Foam::sampledSets::correct()
 {
-    // reset interpolation
+    bool setsFound = dict_.found("sets");
-    pointMesh::Delete(mesh_);
+    if (setsFound)
-    volPointInterpolation::Delete(mesh_);
+    {
+        // reset interpolation
+        pointMesh::Delete(mesh_);
+        volPointInterpolation::Delete(mesh_);
 
-    searchEngine_.correct();
+        searchEngine_.correct();
 
-    PtrList<sampledSet> newList
+        PtrList<sampledSet> newList
-    (
+        (
-        dict_.lookup("sets"),
+            dict_.lookup("sets"),
-        sampledSet::iNew(mesh_, searchEngine_)
+            sampledSet::iNew(mesh_, searchEngine_)
-    );
+        );
-    transfer(newList);
+        transfer(newList);
-    combineSampledSets(masterSampledSets_, indexSets_);
+        combineSampledSets(masterSampledSets_, indexSets_);
+    }
 }
 
 

src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C

@@ -216,34 +216,49 @@ void Foam::sampledSurfaces::write()
 
 void Foam::sampledSurfaces::read(const dictionary& dict)
 {
-    dict.lookup("fields") >> fieldSelection_;
+    bool surfacesFound = dict.found("surfaces");
-    clearFieldGroups();
 
-    dict.lookup("interpolationScheme") >> interpolationScheme_;
+    if (surfacesFound)
-    const word writeType(dict.lookup("surfaceFormat"));
-
-    // define the surface formatter
-    // optionally defined extra controls for the output formats
-    formatter_ = surfaceWriter::New
-    (
-        writeType,
-        dict.subOrEmptyDict("formatOptions").subOrEmptyDict(writeType)
-    );
-
-    PtrList<sampledSurface> newList
-    (
-        dict.lookup("surfaces"),
-        sampledSurface::iNew(mesh_)
-    );
-    transfer(newList);
-
-    if (Pstream::parRun())
     {
-        mergeList_.setSize(size());
+        dict.lookup("fields") >> fieldSelection_;
-    }
+        clearFieldGroups();
 
-    // ensure all surfaces and merge information are expired
+        dict.lookup("interpolationScheme") >> interpolationScheme_;
-    expire();
+        const word writeType(dict.lookup("surfaceFormat"));
+
+        // define the surface formatter
+        // optionally defined extra controls for the output formats
+        formatter_ = surfaceWriter::New
+        (
+            writeType,
+            dict.subOrEmptyDict("formatOptions").subOrEmptyDict(writeType)
+        );
+
+        PtrList<sampledSurface> newList
+        (
+            dict.lookup("surfaces"),
+            sampledSurface::iNew(mesh_)
+        );
+        transfer(newList);
+
+        if (Pstream::parRun())
+        {
+            mergeList_.setSize(size());
+        }
+
+        // ensure all surfaces and merge information are expired
+        expire();
+
+        if (this->size())
+        {
+            Info<< "Reading surface description:" << nl;
+            forAll(*this, surfI)
+            {
+                Info<< "    " << operator[](surfI).name() << nl;
+            }
+            Info<< endl;
+        }
+    }
 
     if (Pstream::master() && debug)
     {

tutorials/compressible/rhoCentralFoam/biconic25-55Run35/system/sampleDict

@@ -19,8 +19,6 @@ interpolationScheme cellPointFace;
 
 setFormat       raw;
 
-surfaceFormat   vtk;
-
 sets
 (
     cone25
@@ -49,8 +47,6 @@ sets
     }
 );
 
-surfaces        ( );
-
 fields          ( p wallHeatTransRate );
 
 

tutorials/compressible/rhoCentralFoam/shockTube/system/sampleDict

@@ -19,8 +19,6 @@ interpolationScheme cellPoint;
 
 setFormat       raw;
 
-surfaceFormat   vtk;
-
 sets
 (
     line
@@ -33,8 +31,6 @@ sets
     }
 );
 
-surfaces        ();
-
 fields          ( p U.component(0) T rho );
 
 

tutorials/compressible/sonicFoam/laminar/shockTube/system/sampleDict

@@ -36,5 +36,4 @@ sets
 
 fields          (T magU p);
 
-
 // ************************************************************************* //

tutorials/electromagnetics/mhdFoam/hartmann/system/sampleDict

@@ -31,8 +31,6 @@ sets
     }
 );
 
-surfaces        ();
-
 fields          ( Ux );
 
 

tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/sampleDict

@@ -87,8 +87,6 @@ sets
     }
 );
 
-surfaces ();
-
 fields
 (
     T

tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/sampleDict

@@ -17,8 +17,6 @@ FoamFile
 
 interpolationScheme cellPoint;
 
-setFormat       raw;
-
 sets
 (
     leftPatch
@@ -31,8 +29,6 @@ sets
     }
 );
 
-surfaces        ();
-
 fields          ( sigmaxx );
 
 

tutorials/stressAnalysis/solidDisplacementFoam/plateHole/system/sampleSurfaceDict

@@ -19,7 +19,15 @@ interpolationScheme cellPoint;
 
 surfaceFormat   dx;
 
-surfaces        ( constantPlane { name plate ; basePoint ( 0 0 0.25 ) ; normalVector ( 0 0 1 ) ; } );
+surfaces
+(
+    constantPlane
+    {
+        name plate;
+        basePoint ( 0 0 0.25 );
+        normalVector ( 0 0 1 );
+    }
+);
 
 fields          ( sigmaxx );