Merge branch 'olesenm'

applications/utilities/mesh/conversion/polyDualMesh/Make/files

-polyDualMesh.C
 polyDualMeshApp.C
 
 EXE = $(FOAM_APPBIN)/polyDualMesh

applications/utilities/mesh/conversion/polyDualMesh/Make/options

 EXE_INC = \
-    -I$(LIB_SRC)/meshTools/lnInclude
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/conversion/lnInclude
 
 EXE_LIBS = \
-    -lmeshTools
+    -lmeshTools -lconversion

applications/utilities/parallelProcessing/decomposePar/decomposePar.C

@@ -50,6 +50,14 @@ Usage
     Remove any existing @a processor subdirectories before decomposing the
     geometry.
 
+    @param -lazy \n
+    Only decompose the geometry if the number of domains has changed from a
+    previous decomposition. No @a processor subdirectories will be removed
+    unless the @a -force option is also specified. This option can be used
+    to avoid redundant geometry decomposition (eg, in scripts), but should
+    be used with caution when the underlying (serial) geometry or the
+    decomposition method etc. have been changed between decompositions.
+
 \*---------------------------------------------------------------------------*/
 
 #include "OSspecific.H"
@@ -80,6 +88,7 @@ int main(int argc, char *argv[])
     argList::validOptions.insert("fields", "");
     argList::validOptions.insert("filterPatches", "");
     argList::validOptions.insert("force", "");
+    argList::validOptions.insert("lazy", "");
 
 #   include "setRootCase.H"
 
@@ -88,6 +97,7 @@ int main(int argc, char *argv[])
     bool decomposeFieldsOnly(args.options().found("fields"));
     bool filterPatches(args.options().found("filterPatches"));
     bool forceOverwrite(args.options().found("force"));
+    bool lazyDecomposition(args.options().found("lazy"));
 
 #   include "createTime.H"
 
@@ -100,47 +110,84 @@ int main(int argc, char *argv[])
         ++nProcs;
     }
 
-    // Check for previously decomposed case first
+    // get requested numberOfSubdomains
+    label nDomains = 0;
+    {
+        IOdictionary decompDict
+        (
+            IOobject
+            (
+                "decomposeParDict",
+                runTime.time().system(),
+                runTime,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE,
+                false
+            )
+        );
+
+        decompDict.lookup("numberOfSubdomains") >> nDomains;
+    }
+
     if (decomposeFieldsOnly)
     {
-        if (!nProcs)
+        // Sanity check on previously decomposed case
+        if (nProcs != nDomains)
         {
             FatalErrorIn(args.executable())
-                << "Specifying -fields requires a decomposed geometry!"
+                << "Specified -fields, but the case was decomposed with "
+                << nProcs << " domains"
+                << nl
+                << "instead of " << nDomains
+                << " domains as specified in decomposeParDict"
                 << nl
                 << exit(FatalError);
         }
     }
-    else
+    else if (nProcs)
     {
-        if (nProcs)
+        bool procDirsProblem = true;
+
+        if (lazyDecomposition && nProcs == nDomains)
         {
-            if (forceOverwrite)
-            {
-                Info<< "Removing " << nProcs
-                    << " existing processor directories" << endl;
+            // we can reuse the decomposition
+            decomposeFieldsOnly = true;
+            procDirsProblem = false;
+            forceOverwrite = false;
 
-                // remove existing processor dirs
-                for (label procI = nProcs-1; procI >= 0; --procI)
-                {
-                    fileName procDir
-                    (
-                        runTime.path()/(word("processor") + name(procI))
-                    );
+            Info<< "Using existing processor directories" << nl;
+        }
 
-                    rmDir(procDir);
-                }
-            }
-            else
+        if (forceOverwrite)
+        {
+            Info<< "Removing " << nProcs
+                << " existing processor directories" << endl;
+
+            // remove existing processor dirs
+            // reverse order to avoid gaps if someone interrupts the process
+            for (label procI = nProcs-1; procI >= 0; --procI)
             {
-                FatalErrorIn(args.executable())
-                    << "Case is already decomposed, "
-                        "use the -force option or manually remove" << nl
-                    << "processor directories before decomposing. e.g.," << nl
-                    << "    rm -rf " << runTime.path().c_str() << "/processor*"
-                    << nl
-                    << exit(FatalError);
+                fileName procDir
+                (
+                    runTime.path()/(word("processor") + name(procI))
+                );
+
+                rmDir(procDir);
             }
+
+            procDirsProblem = false;
+        }
+
+        if (procDirsProblem)
+        {
+            FatalErrorIn(args.executable())
+                << "Case is already decomposed with " << nProcs
+                << " domains, use the -force option or manually" << nl
+                << "remove processor directories before decomposing. e.g.,"
+                << nl
+                << "    rm -rf " << runTime.path().c_str() << "/processor*"
+                << nl
+                << exit(FatalError);
         }
     }
 

applications/utilities/parallelProcessing/decomposePar/decomposeParDict

-// Mesh decomposition control dictionary
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
+/*-------------------------------*- C++ -*---------------------------------*\
+|    =========                                                              |
+|    \\      /     OpenFOAM                                                 |
+|     \\    /                                                               |
+|      \\  /       The Open Source CFD Toolbox                              |
+|       \\/                                        http://www.OpenFOAM.org  |
+\*-------------------------------------------------------------------------*/
 FoamFile
 {
-    version 0.5;
-    format ascii;
-
-    root     "ROOT";
-    case     "CASE";
-    instance "system";
-    local    "";
-
-    class dictionary;
-
-    object decompositionDict;
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    note        "mesh decomposition control dictionary";
+    location    "system";
+    object      decomposeParDict;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-numberOfSubdomains   4;
+numberOfSubdomains  4;
 
-//preservePatches (inlet);
-//preserveFaceZones (heater solid1 solid3);
+// preservePatches (inlet);
+// preserveFaceZones (heater solid1 solid3);
 
-method               simple;
-//method               hierarchical;
-//method               metis;
-//method               manual;
+method          simple;
+// method          hierarchical;
+// method          metis;
+// method          manual;
 
 simpleCoeffs
 {
-    n                    (2 2 1);
-    delta                0.001;
+    n           (2 2 1);
+    delta       0.001;
 }
 
 hierarchicalCoeffs
 {
-    n                    (2 2 1);
-    delta                0.001;
-    order                xyz;
+    n           (2 2 1);
+    delta       0.001;
+    order       xyz;
 }
 
 metisCoeffs
 {
-    //processorWeights 
-    //(
-    //    1
-    //    1
-    //    1
-    //    1
-    //);
+ /*
+    processorWeights
+    (
+        1
+        1
+        1
+        1
+    );
+  */
 }
 
 manualCoeffs
 {
-    dataFile             "decompositionData";
+    dataFile    "decompositionData";
 }
 
 // ************************************************************************* //

src/Allwmake

@@ -31,6 +31,7 @@ wmake libso randomProcesses
 ( cd turbulenceModels && ./Allwmake )
 ( cd lagrangian && ./Allwmake )
 ( cd postProcessing && ./Allwmake )
+( cd conversion && ./Allwmake )
 
 wmake libso autoMesh
 wmake libso errorEstimation

src/conversion/Allwmake

+#!/bin/sh
+set -x
+
+wmake libso

src/conversion/Make/files

+polyDualMesh/polyDualMesh.C
+
+LIB = $(FOAM_LIBBIN)/libconversion

src/conversion/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -lmeshTools