Merge pull request UnnamedMoose#8 from UnnamedMoose/OF5

OpenFOAM 5.x compatibility resolved

Author: UnnamedMoose

.gitignore

@@ -79,6 +79,7 @@ doc/Doxygen/DTAGS
 /.cproject
 /.project
 /.dir-locals.el
+/.dropbox
 
 # Ignore the test directory
 /tutorialsTest

OFtutorial0_helloWorld/Make/files renamed to OFtutorial00_helloWorld/Make/files

@@ -49,7 +49,7 @@ int main(int argc, char *argv[])
     );
 
     // Check the if the dictionary is present and follows the OF format
-    if (!dictIO.headerOk())
+    if (!dictIO.typeHeaderOk<dictionary>(true))
         FatalErrorIn(args.executable()) << "Cannot open specified refinement dictionary "
             << dictName << exit(FatalError);
 
@@ -106,6 +106,9 @@ int main(int argc, char *argv[])
     outputFilePtr() << "# This is a header" << endl;
     outputFilePtr() << "0 1 2 3 4 5" << endl;
 
+    // Append to the imported hash table and wirte it too
+    someHashTable.insert("newKey", vector(1., 0., 0.));
+    outputFilePtr() << someHashTable << endl;
 
     Info<< "End\n" << endl;
     return 0;

OFtutorial0_helloWorld/Make/options renamed to OFtutorial00_helloWorld/Make/options

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
+     \\/     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 "fvCFD.H"
+
+int main(int argc, char *argv[])
+{
+    // ===
+    // Define the help message for this application
+    argList::addNote
+    (
+        "Demonstrates how to handle command line options.\n"
+        "\n"
+        "Input arguments:\n"
+        "----------------\n"
+        "  someWord - does stuff\n"
+        "  someScalar - does more things\n"
+    );
+
+    // prepare argument list
+    argList::noParallel();
+    argList::validArgs.append("someWord");
+    argList::validArgs.append("someScalar");
+
+    // prepare options
+    argList::addOption // string variable
+    (
+        "dict",
+        "word",
+        "Path to an additional dictionary (not really used now)"
+    );
+
+    argList::addBoolOption // on/off depending on whether option is given or not
+    (
+        "someSwitch",
+        "Switches from A to B"
+    );
+
+    argList::addOption // integer variable
+    (
+        "someInt",
+        "label",
+        "Optional integer"
+    );
+
+    // ===
+    // create argument list
+    // This is normally defined inside setRootCase.H
+    // #include "setRootCase.H"
+    Foam::argList args(argc, argv);
+    if (!args.checkRootCase())
+    {
+        Foam::FatalError.exit();
+    }
+
+    // ===
+    // read arguments
+    const word someWord = args[1];
+    // NOTE: the built-in method for converting strings to other data types
+    const scalar someScalar = args.argRead<scalar>(2);
+
+    Info << "Got argument word " << someWord << " and scalar " << someScalar << endl;
+
+    // ===
+    // read options
+    // default path to some dictionary
+    fileName dictPath("./system/defaultDict");
+
+    // conditional execution based on an option being passed
+    if (args.optionFound("dict"))
+    {
+        args.optionReadIfPresent("dict", dictPath);
+        Info << "Got an override flag for dictionary path" << endl;
+    }
+    Info << "Would read dict from " << dictPath << endl;
+
+    // switch option
+    const bool someConstBool = args.optionFound("someSwitch");
+    Info << "Boolean switch set to " << someConstBool << endl;
+
+    // numeric value option - same as string variables really
+    label someInt(0);
+    args.optionReadIfPresent("someInt", someInt);
+    Info << "Integer option value " << someInt << endl;
+    
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

OFtutorial0_helloWorld/OFtutorial0.C renamed to OFtutorial00_helloWorld/OFtutorial0.C

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+ofTutorial2

OFtutorial0_helloWorld/testCase/0/U renamed to OFtutorial00_helloWorld/testCase/0/U

@@ -0,0 +1,49 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  3.0.1                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.5;
+
+deltaT          0.005;
+
+writeControl    timeStep;
+
+writeInterval   20;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+
+// ************************************************************************* //

OFtutorial0_helloWorld/testCase/0/p renamed to OFtutorial00_helloWorld/testCase/0/p

@@ -1,4 +1,4 @@
 #!/bin/bash
 
 blockMesh > log.blockMesh
-ofTutorial2
+ofTutorial4

OFtutorial0_helloWorld/testCase/Allclean renamed to OFtutorial00_helloWorld/testCase/Allclean

@@ -1,5 +1,3 @@
-customClass.C
-derivedClass.C
 OFtutorial5.C
 
 EXE = $(FOAM_USER_APPBIN)/ofTutorial5

OFtutorial0_helloWorld/testCase/Allrun renamed to OFtutorial00_helloWorld/testCase/Allrun

@@ -66,13 +66,11 @@ int main(int argc, char *argv[])
     // object-oriented programming in OpenFOAM, so we'll skip this for now.
 
     // Spreading a value across all processors is done using a scatter operation.
-    // The Pstream::blocking makes sure all processors are synchronised at this
-    // line of the code and thus should use the same value.
-    Pstream::scatter(meshVolume, Pstream::blocking);
+    Pstream::scatter(meshVolume);
     Pout << "Mesh volume on this processor is now " << meshVolume << endl;
 
     // It is often useful to check the distribution of something across all
-    // processors. This may be done using a list, with each element of which
+    // processors. This may be done using a list, with each element of it
     // being written to by only one processor.
     List<label> nInternalFaces (Pstream::nProcs()), nBoundaries (Pstream::nProcs());
     nInternalFaces[Pstream::myProcNo()] = mesh.Cf().size();
@@ -129,10 +127,10 @@ int main(int argc, char *argv[])
 
     // pre-calculate geometric information using field expressions rather than
     // cell-by-cell assignment.
-	const dimensionedVector originVector("x0",dimLength,vector(0.05,0.05,0.005));
-    scalarField r (mag(mesh.C()-originVector));
-    // NOTE: we need to get a global value
-	const scalar rFarCell = returnReduce(max(r), maxOp<scalar>());
+	const dimensionedVector originVector("x0", dimLength, vector(0.05,0.05,0.005));
+    volScalarField r (mag(mesh.C()-originVector));
+    // NOTE: we need to get a global value; convert from dimensionedScalar to scalar
+	const scalar rFarCell = returnReduce(max(r).value(), maxOp<scalar>());
     scalar f (1.);
 
 	Info<< "\nStarting time loop\n" << endl;
@@ -141,16 +139,24 @@ int main(int argc, char *argv[])
     {
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
-        // We use .internalField() to assign to the internal values only, thus
-        // leaving boundary values unchanged. Thus, we assign a scalarField
-        // object to the internal scalrField inside the volScalarField p.
-		p.internalField() = Foam::sin(2.*constant::mathematical::pi*f*runTime.time().value())
-            / (r/rFarCell+1e-12);
+        // assign values to the field;
+        // sin function expects a dimensionless argument, hence need to convert
+        // current time using .value().
+        // r has dimensions of length, hence the small value being added to it
+        // needs to match that.
+        // Finally, the result has to match dimensions of pressure, which are
+        // m^2 / s^-2/
+		p = Foam::sin(2.*constant::mathematical::pi*f*runTime.time().value())
+            / (r/rFarCell + dimensionedScalar("small", dimLength, 1e-12))
+            * dimensionedScalar("tmp", dimensionSet(0, 3, -2, 0, 0), 1.);
+
         // NOTE: this is needed to update the values on the processor boundaries.
         // If this is not done, the gradient operator will get confused around the
         // processor patches.
         p.correctBoundaryConditions();
-		U = fvc::grad(p)*dimensionedScalar("tmp",dimTime,1.);
+
+        // calculate velocity from gradient of pressure
+		U = fvc::grad(p)*dimensionedScalar("tmp", dimTime, 1.);
 		runTime.write();
 	}
 

OFtutorial0_helloWorld/testCase/constant/transportProperties renamed to OFtutorial00_helloWorld/testCase/constant/transportProperties

@@ -2,5 +2,5 @@
 
 blockMesh > log.blockMesh
 decomposePar > log.decomposePar
-mpirun -np 4 ofTutorial4 -parallel
+mpirun -np 4 ofTutorial5 -parallel
 rm -r processor* 2>/dev/null

OFtutorial0_helloWorld/testCase/system/blockMeshDict renamed to OFtutorial00_helloWorld/testCase/system/blockMeshDict

@@ -1,3 +1,5 @@
+customClass.C
+derivedClass.C
 OFtutorial6.C
 
 EXE = $(FOAM_USER_APPBIN)/ofTutorial6

OFtutorial0_helloWorld/testCase/system/controlDict renamed to OFtutorial00_helloWorld/testCase/system/controlDict

@@ -0,0 +1,3 @@
+OFtutorial7.C
+
+EXE = $(FOAM_USER_APPBIN)/ofTutorial7

OFtutorial0_helloWorld/testCase/system/fvSchemes renamed to OFtutorial00_helloWorld/testCase/system/fvSchemes

@@ -40,24 +40,38 @@ int main(int argc, char *argv[])
     #include "createMesh.H"
     #include "createFields.H"
 
-    const dimensionedVector originVector("x0",dimLength,vector(0.05,0.05,0.005));
-    scalarField r;
-    // NOTE: use the method implemented in the library to calculate r and rFarCell
-    const scalar rFarCell = computeR(mesh,r,originVector);
+    const dimensionedVector originVector("x0", dimLength, vector(0.05, 0.05, 0.005));
     scalar f (1.);
+    // NOTE: initialise the radius field with zero values and dimensions
+    volScalarField r
+    (
+        IOobject
+        (
+            "r",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimensionedScalar("r0", dimLength, 0.)
+    );
+    // NOTE: use the method implemented in the library to calculate r and rFarCell
+    const scalar rFarCell = computeR(mesh, r, originVector);
 
     Info<< "\nStarting time loop\n" << endl;
 
     while (runTime.loop())
     {
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
-        p.internalField() = Foam::sin(2.*constant::mathematical::pi*f*runTime.time().value())
-            / (r/rFarCell+1e-12);
+        p = Foam::sin(2.*constant::mathematical::pi*f*runTime.time().value())
+            / (r/rFarCell + dimensionedScalar("small", dimLength, 1e-12))
+            * dimensionedScalar("tmp", dimensionSet(0, 3, -2, 0, 0), 1.);
         p.correctBoundaryConditions();
 
         // NOTE: call the library method to calculate U
-        computeU(mesh,U);
+        computeU(mesh, U);
 
         runTime.write();
     }

OFtutorial0_helloWorld/testCase/system/fvSolution renamed to OFtutorial00_helloWorld/testCase/system/fvSolution

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools

OFtutorial1_inputOutput/Make/files renamed to OFtutorial01_inputOutput/Make/files

@@ -1,9 +1,9 @@
 #include "customLibrary.H"
 
-scalar computeR(const fvMesh& mesh, scalarField& r, dimensionedVector x0)
+scalar computeR(const fvMesh& mesh, volScalarField& r, dimensionedVector x0)
 {
     r = mag(mesh.C()-x0);
-    return returnReduce(max(r), maxOp<scalar>());
+    return returnReduce(max(r).value(), maxOp<scalar>());
 }
 
 void computeU(const fvMesh& mesh, volVectorField& U, word pName)
@@ -13,5 +13,5 @@ void computeU(const fvMesh& mesh, volVectorField& U, word pName)
     const volScalarField& pField = mesh.lookupObject<volScalarField>(pName);
 
     // Do the usual
-    U = fvc::grad(pField)*dimensionedScalar("tmp",dimTime,1.);
+    U = fvc::grad(pField)*dimensionedScalar("tmp", dimTime, 1.);
 }

OFtutorial1_inputOutput/Make/options renamed to OFtutorial01_inputOutput/Make/options

@@ -1,10 +1,10 @@
 #include "fvCFD.H"
 
 // This method simply implements the calculation of the distance of each
-// cell centre from x0; it accepts the scalarField r as a reference to avoid
+// cell centre from x0; it accepts the volScalarField r as a reference to avoid
 // passing large amounts of information by value, as this is expensive.
 // It returns the maximum value found.
-scalar computeR(const fvMesh& mesh, scalarField& r, dimensionedVector x0);
+scalar computeR(const fvMesh& mesh, volScalarField& r, dimensionedVector x0);
 
 // This computes the velocity field. The reference to the pressure is obtained
 // through the mesh object, using the name of the p field only. This assmes a