Merge commit 'OpenCFD/master' into olesenm

applications/solvers/combustion/dieselEngineFoam/spraySummary.H

@@ -1,19 +1,20 @@
         label Nparcels = dieselSpray.size();
         reduce(Nparcels, sumOp<label>());
 
-        Info<< "\nNumber of parcels in system | "
+        Info<< "\nNumber of parcels in system.... | "
             << Nparcels << endl
-            << "Injected liquid mass....... | "
+            << "Injected liquid mass........... | "
             << 1e6*dieselSpray.injectedMass(runTime.value()) << " mg" << endl
-            << "Liquid Mass in system...... | "
+            << "Liquid Mass in system.......... | "
             << 1e6*dieselSpray.liquidMass() << " mg" << endl
-            << "SMD, Dmax.................. | "
+            << "SMD, Dmax...................... | "
             << dieselSpray.smd()*1e6 << " mu, "
             << dieselSpray.maxD()*1e6 << " mu"
             << endl;
 
         scalar evapMass =
-            dieselSpray.injectedMass(runTime.value()) - dieselSpray.liquidMass();
+            dieselSpray.injectedMass(runTime.value())
+          - dieselSpray.liquidMass();
 
         scalar gasMass = fvc::domainIntegrate(rho).value();
 
@@ -26,6 +27,6 @@
 
         scalar addedMass = gasMass - gasMass0;
 
-        Info<< "Added gas mass = " << 1e6*addedMass << " mg" << nl
+        Info<< "Added gas mass................. | " << 1e6*addedMass << " mg"
-            << "Evaporation Continuity Error| "
+            << nl << "Evaporation Continuity Error... | "
             << 1e6*(addedMass - evapMass) << " mg" << endl;

applications/utilities/postProcessing/patch/patchIntegrate/patchIntegrate.C

@@ -31,6 +31,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
+#include "cyclicPolyPatch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 // Main program:
@@ -75,26 +76,54 @@ int main(int argc, char *argv[])
             }
 
             // Give patch area
-            Info<< "    Patch area = " << gSum(mesh.Sf().boundaryField()[patchi]) << endl;
+            if (isType<cyclicPolyPatch>(mesh.boundaryMesh()[patchi]))
-
-            if (fieldHeader.headerClassName() == "volScalarField")
             {
-                Info<< "    Reading volScalarField " << fieldName << endl;
+                Info<< "    Cyclic patch area: " << nl;
-                volScalarField field(fieldHeader, mesh);
+                label nFaces = mesh.boundaryMesh()[patchi].size();
+                vector sum1 = vector::zero;
+                vector sum2 = vector::zero;
+                for (label i=0; i<nFaces/2; i++)
+                {
+                    sum1 += mesh.Sf().boundaryField()[patchi][i];
+                    sum2 += mesh.Sf().boundaryField()[patchi][i+nFaces/2];
+                }
+                reduce(sum1, sumOp<vector>());
+                reduce(sum2, sumOp<vector>());
+                Info<< "    - half 1 = " << sum1 << ", " << mag(sum1) << nl
+                    << "    - half 2 = " << sum2 << ", " << mag(sum2) << nl
+                    << "    - total  = " << (sum1 + sum2) << ", "
+                    << mag(sum1 + sum2) << endl;;
+            }
+            else
+            {
+                Info<< "    Patch area = "
+                    << gSum(mesh.Sf().boundaryField()[patchi]) << endl;
+            }
 
+            // Read field and calc integral
+            if (fieldHeader.headerClassName() == volScalarField::typeName)
+            {
+                Info<< "    Reading " << volScalarField::typeName << " "
+                    << fieldName << endl;
+
+                volScalarField field(fieldHeader, mesh);
                 vector sumField = gSum
                 (
                     mesh.Sf().boundaryField()[patchi]
-                  * field.boundaryField()[patchi]
+                   *field.boundaryField()[patchi]
                 );
 
                 Info<< "    Integral of " << fieldName << " over patch "
                     << patchName << '[' << patchi << ']' << " = "
                     << sumField << nl;
             }
-            else if (fieldHeader.headerClassName() == "surfaceScalarField")
+            else if
+            (
+                fieldHeader.headerClassName() == surfaceScalarField::typeName
+            )
             {
-                Info<< "    Reading surfaceScalarField " << fieldName << endl;
+                Info<< "    Reading " << surfaceScalarField::typeName << " "
+                    << fieldName << endl;
 
                 surfaceScalarField field(fieldHeader, mesh);
                 scalar sumField = gSum(field.boundaryField()[patchi]);
@@ -106,8 +135,10 @@ int main(int argc, char *argv[])
             else
             {
                 FatalError
-                    << "Only possible to integrate volScalarFields "
+                    << "Only possible to integrate "
-                    << "and surfaceScalarFields" << nl << exit(FatalError);
+                    << volScalarField::typeName << "s "
+                    << "and " << surfaceScalarField::typeName << "s"
+                    << nl << exit(FatalError);
             }
         }
         else

etc/settings.csh

@@ -121,7 +121,7 @@ unset MPI_ARCH_PATH
 
 switch ("$WM_MPLIB")
 case OPENMPI:
-    set mpi_version=openmpi-1.2.8
+    set mpi_version=openmpi-1.3
     setenv MPI_HOME $WM_THIRD_PARTY_DIR/$mpi_version
     setenv MPI_ARCH_PATH $MPI_HOME/platforms/$WM_OPTIONS
 

etc/settings.sh

@@ -151,7 +151,7 @@ unset MPI_ARCH_PATH
 
 case "$WM_MPLIB" in
 OPENMPI)
-    mpi_version=openmpi-1.2.8
+    mpi_version=openmpi-1.3
     export MPI_HOME=$WM_THIRD_PARTY_DIR/$mpi_version
     export MPI_ARCH_PATH=$MPI_HOME/platforms/$WM_OPTIONS
 

src/finiteVolume/cfdTools/general/bound/bound.C

@@ -53,7 +53,6 @@ void Foam::bound(volScalarField& vsf, const dimensionedScalar& vsf0)
             vsf0.value()
         );
 
-        vsf.correctBoundaryConditions();
         vsf.boundaryField() = max(vsf.boundaryField(), vsf0.value());
     }
 }

src/finiteVolume/cfdTools/general/include/setDeltaT.H

@@ -27,7 +27,7 @@ Global
 
 Description
     Reset the timestep to maintain a constant maximum courant Number.
-    Reduction of time-step is imediate but increase is damped to avoid
+    Reduction of time-step is immediate, but increase is damped to avoid
     unstable oscillations.
 
 \*---------------------------------------------------------------------------*/

src/finiteVolume/cfdTools/general/include/setInitialDeltaT.H

@@ -33,7 +33,7 @@ Description
 
 if (adjustTimeStep)
 {
-    if (CoNum > SMALL)
+    if ((runTime.timeIndex() == 0) && (CoNum > SMALL))
     {
         runTime.setDeltaT
         (

src/lagrangian/dieselSpray/injector/unitInjector/unitInjector.C

@@ -30,19 +30,19 @@ License
 #include "mathematicalConstants.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
 namespace Foam
 {
+    defineTypeNameAndDebug(unitInjector, 0);
 
-defineTypeNameAndDebug(unitInjector, 0);
+    addToRunTimeSelectionTable
-
+    (
-addToRunTimeSelectionTable
+        injectorType,
-(
+        unitInjector,
-    injectorType,
+        dictionary
-    unitInjector,
+    );
-    dictionary
-);
 }
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -74,22 +74,32 @@ Foam::unitInjector::unitInjector
     // check if time entries for soi and eoi match
     if (mag(massFlowRateProfile_[0][0]-TProfile_[0][0]) > SMALL)
     {
-        FatalError << "unitInjector::unitInjector(const time& t, const dictionary dict) " << endl
+        FatalErrorIn
-            << " start-times do not match for TemperatureProfile and massFlowRateProfile."
+        (
-            << abort(FatalError);
+            "unitInjector::unitInjector(const time& t, const dictionary dict)"
+        )<< "start-times do not match for TemperatureProfile and "
+         << " massFlowRateProfile." << nl << exit (FatalError);
     }
 
-    if (mag(massFlowRateProfile_[massFlowRateProfile_.size()-1][0]-TProfile_[TProfile_.size()-1][0]) > SMALL)
+    if
+    (
+        mag(massFlowRateProfile_[massFlowRateProfile_.size()-1][0]
+      - TProfile_[TProfile_.size()-1][0])
+      > SMALL
+    )
     {
-        FatalError << "unitInjector::unitInjector(const time& t, const dictionary dict) " << endl
+        FatalErrorIn
-            << " end-times do not match for TemperatureProfile and massFlowRateProfile."
+        (
-            << abort(FatalError);
+            "unitInjector::unitInjector(const time& t, const dictionary dict)"
+        )<< "end-times do not match for TemperatureProfile and "
+         << "massFlowRateProfile." << nl << exit(FatalError);
     }
 
     // convert CA to real time
     forAll(massFlowRateProfile_, i)
     {
-        massFlowRateProfile_[i][0] = t.userTimeToTime(massFlowRateProfile_[i][0]);
+        massFlowRateProfile_[i][0] =
+            t.userTimeToTime(massFlowRateProfile_[i][0]);
         velocityProfile_[i][0] = massFlowRateProfile_[i][0];
         injectionPressureProfile_[i][0] = massFlowRateProfile_[i][0];
     }
@@ -124,9 +134,9 @@ Foam::unitInjector::unitInjector
 
     if (mag(Xsum - 1.0) > SMALL)
     {
-        Info << "Warning!!!\n unitInjector::unitInjector(const time& t, Istream& is)"
+        WarningIn("unitInjector::unitInjector(const time& t, Istream& is)")
-            << "X does not add up to 1.0, correcting molar fractions."
+            << "X does not sum to 1.0, correcting molar fractions."
-            << endl;
+            << nl << endl;
         forAll(X_, i)
         {
             X_[i] /= Xsum;
@@ -169,18 +179,18 @@ Foam::label Foam::unitInjector::nParcelsToInject
     const scalar time1
 ) const
 {
-
     scalar mInj = mass_*(fractionOfInjection(time1)-fractionOfInjection(time0));
     label nParcels = label(mInj/averageParcelMass_ + 0.49);
-    
     return nParcels;
 }
 
+
 const Foam::vector Foam::unitInjector::position(const label n) const
 {
     return position_;
 }
 
+
 Foam::vector Foam::unitInjector::position
 (
     const label n,
@@ -226,16 +236,19 @@ Foam::vector Foam::unitInjector::position
     return position_;
 }
 
+
 Foam::label Foam::unitInjector::nHoles() const
 {
     return 1;
 }
 
+
 Foam::scalar Foam::unitInjector::d() const
 {
     return d_;
 }
 
+
 const Foam::vector& Foam::unitInjector::direction
 (
     const label i,
@@ -245,6 +258,7 @@ const Foam::vector& Foam::unitInjector::direction
     return direction_;
 }
 
+
 Foam::scalar Foam::unitInjector::mass
 (
     const scalar time0,
@@ -264,82 +278,80 @@ Foam::scalar Foam::unitInjector::mass
     return mInj;
 }
 
+
 Foam::scalar Foam::unitInjector::mass() const
 {
     return mass_;
 }
 
+
 const Foam::scalarField& Foam::unitInjector::X() const
 {
     return X_;
 }
 
+
 Foam::List<Foam::unitInjector::pair> Foam::unitInjector::T() const
 {
     return TProfile_;
 }
 
+
 Foam::scalar Foam::unitInjector::T(const scalar time) const
 {
     return getTableValue(TProfile_, time);
 }
 
+
 Foam::scalar Foam::unitInjector::tsoi() const
 {
     return massFlowRateProfile_[0][0];
 }
 
+
 Foam::scalar Foam::unitInjector::teoi() const
 {
     return massFlowRateProfile_[massFlowRateProfile_.size()-1][0];
 }
 
-Foam::scalar Foam::unitInjector::massFlowRate
+
-(
+Foam::scalar Foam::unitInjector::massFlowRate(const scalar time) const
-    const scalar time
-) const
 {
     return getTableValue(massFlowRateProfile_, time);
 }
 
-Foam::scalar Foam::unitInjector::injectionPressure
+
-(
+Foam::scalar Foam::unitInjector::injectionPressure(const scalar time) const
-    const scalar time
-) const
 {
     return getTableValue(injectionPressureProfile_, time);
 }
 
-Foam::scalar Foam::unitInjector::velocity
+
-(
+Foam::scalar Foam::unitInjector::velocity(const scalar time) const
-    const scalar time
-) const
 {
     return getTableValue(velocityProfile_, time);
 }
 
+
 Foam::List<Foam::unitInjector::pair> Foam::unitInjector::CdProfile() const
 {
     return CdProfile_;
 }
 
-Foam::scalar Foam::unitInjector::Cd
+
-(
+Foam::scalar Foam::unitInjector::Cd(const scalar time) const
-    const scalar time
-) const
 {
     return Cd_;
 }
 
+
 Foam::scalar Foam::unitInjector::fractionOfInjection(const scalar time) const
 {
     return integrateTable(massFlowRateProfile_, time)/mass_;
 }
 
-Foam::scalar Foam::unitInjector::injectedMass
+
-(
+Foam::scalar Foam::unitInjector::injectedMass(const scalar t) const
-    const scalar t
-) const
 {
     return mass_*fractionOfInjection(t);
 }
@@ -351,7 +363,6 @@ void Foam::unitInjector::correctProfiles
     const scalar referencePressure
 )
 {
-
     scalar A = 0.25*mathematicalConstant::pi*pow(d_, 2.0);
     scalar pDummy = 1.0e+5;
 
@@ -365,14 +376,17 @@ void Foam::unitInjector::correctProfiles
     }
 }
 
-Foam::vector Foam::unitInjector::tan1(const label n) const
+
+Foam::vector Foam::unitInjector::tan1(const label) const
 {
     return tangentialInjectionVector1_;
 }
 
-Foam::vector Foam::unitInjector::tan2(const label n) const
+
+Foam::vector Foam::unitInjector::tan2(const label) const
 {
     return tangentialInjectionVector2_;
 }
 
+
 // ************************************************************************* //

src/lagrangian/dieselSpray/spray/sprayInject.C

@@ -66,11 +66,7 @@ void spray::inject()
 
             // constT is only larger than zero for the first
             // part of the injection
-            scalar constT = max
+            scalar constT = max(0.0, it->tsoi() - time0);
-            (
-                0.0,
-                it->tsoi() - time0
-            );
 
             // deltaT is the duration of injection during this timestep
             scalar deltaT = min
@@ -105,7 +101,8 @@ void spray::inject()
                     );
 
                     scalar diameter = injection().d0(i, toi);
-                    vector direction = injection().direction(i, n, toi, diameter);
+                    vector direction =
+                        injection().direction(i, n, toi, diameter);
                     vector U = injection().velocity(i, toi)*direction;
 
                     scalar symComponent = direction & axisOfSymmetry_;
@@ -148,7 +145,7 @@ void spray::inject()
                             fuels_->components()
                         );
 
-                        injectedLiquidKE_ += 0.5*pPtr->m()*pow(mag(U), 2.0);
+                        injectedLiquidKE_ += 0.5*pPtr->m()*magSqr(U);
 
                         scalar dt = time - toi;
 
@@ -156,10 +153,7 @@ void spray::inject()
                             (runTime_.deltaT().value() - dt)
                            /runTime_.deltaT().value();
 
-                        bool keepParcel = pPtr->move
+                        bool keepParcel = pPtr->move(*this);
-                        (
-                            *this
-                        );
 
                         if (keepParcel)
                         {

src/lagrangian/dieselSpray/spray/sprayOps.C

@@ -89,12 +89,7 @@ void spray::move()
 
 void spray::breakupLoop()
 {
-    for
+    forAllIter(spray::iterator, *this, elmnt)
-    (
-        spray::iterator elmnt = begin();
-        elmnt != end();
-        ++elmnt
-    )
     {
         // interpolate...
         vector velocity = UInterpolator().interpolate
@@ -128,12 +123,7 @@ void spray::breakupLoop()
 
 void spray::atomizationLoop()
 {
-    for
+    forAllIter(spray::iterator, *this, elmnt)
-    (
-        spray::iterator elmnt = begin();
-        elmnt != end();
-        ++elmnt
-    )
     {
         // interpolate...
         vector velocity = UInterpolator().interpolate

src/lagrangian/dieselSpray/spraySubModels/breakupModel/reitzKHRT/reitzKHRT.C

@@ -108,31 +108,19 @@ void reitzKHRT::breakupParcel
 
     // frequency of the fastest growing KH-wave
     scalar omegaKH =
-    (
+        (0.34 + 0.38*pow(weGas, 1.5))
-        0.34 + 0.38*pow(weGas, 1.5)
+       /((1 + ohnesorge)*(1 + 1.4*pow(taylor, 0.6)))
-    )/
+       *sqrt(sigma/(rhoLiquid*pow(r, 3)));
-    (
-        (1 + ohnesorge)*(1 + 1.4*pow(taylor, 0.6))
-    )*sqrt(sigma/(rhoLiquid*pow(r, 3)) );
 
-    // ... and the corresponding KH wave-length.
+    // corresponding KH wave-length.
     scalar lambdaKH =
-    9.02*r*
+        9.02
-    (
+       *r
-        1.0 + 0.45*sqrt(ohnesorge)
+       *(1.0 + 0.45*sqrt(ohnesorge))
-    )*
+       *(1.0 + 0.4*pow(taylor, 0.7))
-    (
+       /pow(1.0 + 0.865*pow(weGas, 1.67), 0.6);
-        1.0 + 0.4*pow(taylor, 0.7)
-    )/
-    pow
-    (
-        (
-            1.0 + 0.865*pow(weGas, 1.67)
-        ),
-        0.6
-    );
 
-    // the characteristic Kelvin-Helmholtz breakup time
+    // characteristic Kelvin-Helmholtz breakup time
     scalar tauKH = 3.726*b1_*r/(omegaKH*lambdaKH);
 
     // stable KH diameter
@@ -140,7 +128,6 @@ void reitzKHRT::breakupParcel
 
     // the frequency of the fastest growing RT wavelength.
     scalar helpVariable = mag(gt*(rhoLiquid - rhoGas));
-
     scalar omegaRT = sqrt
     (
         2.0*pow(helpVariable, 1.5)
@@ -148,12 +135,9 @@ void reitzKHRT::breakupParcel
     );
 
     // RT wave number
-    scalar KRT = sqrt
+    scalar KRT = sqrt(helpVariable/(3.0*sigma + VSMALL));
-    (
-        helpVariable/(3.0*sigma + VSMALL)
-    );
 
-    // the wavelength of the fastest growing Raleigh-Taylor frequency
+    // wavelength of the fastest growing RT frequency
     scalar lambdaRT = 2.0*mathematicalConstant::pi*cRT_/(KRT + VSMALL);
 
     // if lambdaRT < diameter, then RT waves are growing on the surface
@@ -163,7 +147,7 @@ void reitzKHRT::breakupParcel
         p.ct() += deltaT;
     }
 
-    // the characteristic RT breakup time
+    // characteristic RT breakup time
     scalar tauRT = cTau_/(omegaRT + VSMALL);
 
     // check if we have RT breakup
@@ -178,7 +162,7 @@ void reitzKHRT::breakupParcel
     // otherwise check for KH breakup
     else if (dc < p.d())
     {
-        // no breakup below weber = 12
+        // no breakup below Weber = 12
         if (weGas > weberLimit_)
         {
 
@@ -188,25 +172,24 @@ void reitzKHRT::breakupParcel
             // reduce the diameter according to the rate-equation
             p.d() = (fraction*dc + p.d())/(1.0 + fraction);
 
-            scalar dc3 = pow(dc, 3.0);
+            scalar ms = rhoLiquid*Np*pow3(dc)*mathematicalConstant::pi/6.0;
-            scalar ms = rhoLiquid*Np*dc3*mathematicalConstant::pi/6.0;
             p.ms() += ms;
 
-            label nParcels = spray_.injectors()[injector].properties()->nParcelsToInject
+            // Total number of parcels for the whole injection event
-            (
+            label nParcels =
-                spray_.injectors()[injector].properties()->tsoi(),
+                spray_.injectors()[injector].properties()->nParcelsToInject
-                spray_.injectors()[injector].properties()->teoi()
+                (
-            );
+                    spray_.injectors()[injector].properties()->tsoi(),
+                    spray_.injectors()[injector].properties()->teoi()
+                );
 
-            scalar averageParcelMass = spray_.injectors()[injector].properties()->mass()/nParcels;
+            scalar averageParcelMass =
+                spray_.injectors()[injector].properties()->mass()/nParcels;
 
-            if
+            if (p.ms()/averageParcelMass > msLimit_)
-            (
-                (p.ms()/averageParcelMass > msLimit_)
-            )
             {
                 // set the initial ms value to -GREAT. This prevents
-                // new droplets from being formed from the childDroplet
+                // new droplets from being formed from the child droplet
                 // from the KH instability
 
                 // mass of stripped child parcel

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.C

@@ -38,6 +38,18 @@ namespace Foam
 }
 
 
+template<>
+const char* Foam::NamedEnum<Foam::fieldMinMax::modeType, 2>::names[] =
+{
+    "magnitude",
+    "component"
+};
+
+
+const Foam::NamedEnum<Foam::fieldMinMax::modeType, 2>
+Foam::fieldMinMax::modeTypeNames_;
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fieldMinMax::fieldMinMax
@@ -52,6 +64,7 @@ Foam::fieldMinMax::fieldMinMax
     obr_(obr),
     active_(true),
     log_(false),
+    mode_(mdMag),
     fieldSet_(),
     fieldMinMaxFilePtr_(NULL)
 {
@@ -85,6 +98,7 @@ void Foam::fieldMinMax::read(const dictionary& dict)
     {
         log_ = dict.lookupOrDefault<Switch>("log", false);
 
+        mode_ = modeTypeNames_[dict.lookup("mode")];
         dict.lookup("fields") >> fieldSet_;
     }
 }
@@ -176,16 +190,13 @@ void Foam::fieldMinMax::calcMinMaxFields<Foam::scalar>
 {
     if (obr_.foundObject<volScalarField>(fieldName))
     {
-        const volScalarField& field =
-            obr_.lookupObject<volScalarField>(fieldName);
-        scalar minValue = min(field).value();
-        scalar maxValue = max(field).value();
-
-        reduce(minValue, minOp<scalar>());
-        reduce(maxValue, maxOp<scalar>());
-
         if (Pstream::master())
         {
+            const volScalarField& field =
+                obr_.lookupObject<volScalarField>(fieldName);
+            scalar minValue = min(field).value();
+            scalar maxValue = max(field).value();
+
             fieldMinMaxFilePtr_() << obr_.time().value() << tab
                 << fieldName << tab << minValue << tab << maxValue << endl;
 

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.H

@@ -49,6 +49,7 @@ SourceFiles
 #include "OFstream.H"
 #include "Switch.H"
 #include "pointFieldFwd.H"
+#include "NamedEnum.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -66,9 +67,18 @@ class mapPolyMesh;
 
 class fieldMinMax
 {
+public:
+
+    enum modeType
+    {
+        mdMag,
+        mdCmpt
+    };
+
+
 protected:
 
-    // Private data
+    // Protected data
 
         //- Name of this set of forces,
         //  Also used as the name of the probes directory.
@@ -82,11 +92,17 @@ protected:
         //- Switch to send output to Info as well as to file
         Switch log_;
 
-        //- Patches to integrate forces over
+        //- Mode type names
+        static const NamedEnum<modeType, 2> modeTypeNames_;
+
+        //- Mode for min/max - only applicable for ranks > 0
+        modeType mode_;
+
+        //- Fields to assess min/max
         wordList fieldSet_;
 
 
-        //- Forces/moment file ptr
+        //- Min/max file ptr
         autoPtr<OFstream> fieldMinMaxFilePtr_;
 
 

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxTemplates.C

@@ -38,24 +38,60 @@ void Foam::fieldMinMax::calcMinMaxFields(const word& fieldName)
 
     if (obr_.foundObject<fieldType>(fieldName))
     {
-        const fieldType& field = obr_.lookupObject<fieldType>(fieldName);
-        scalar minValue = min(mag(field)).value();
-        scalar maxValue = max(mag(field)).value();
-
-        reduce(minValue, minOp<scalar>());
-        reduce(maxValue, maxOp<scalar>());
-
         if (Pstream::master())
         {
-            fieldMinMaxFilePtr_() << obr_.time().value() << tab
+            const fieldType& field = obr_.lookupObject<fieldType>(fieldName);
-                << fieldName << tab << minValue << tab << maxValue << endl;
+            switch (mode_)
-
-            if (log_)
             {
-                Info<< "fieldMinMax output:" << nl
+                case mdMag:
-                    << "    min(mag(" << fieldName << ")) = " << minValue << nl
+                {
-                    << "    max(mag(" << fieldName << ")) = " << maxValue << nl
+                    scalar minValue = min(mag(field)).value();
-                    << endl;
+                    scalar maxValue = max(mag(field)).value();
+
+                    fieldMinMaxFilePtr_() << obr_.time().value() << tab
+                        << fieldName << tab << minValue << tab << maxValue
+                        << endl;
+
+                    if (log_)
+                    {
+                        Info<< "fieldMinMax output:" << nl
+                            << "    min(mag(" << fieldName << ")) = "
+                            << minValue << nl
+                            << "    max(mag(" << fieldName << ")) = "
+                            << maxValue << nl
+                            << endl;
+                    }
+                    break;
+                }
+                case mdCmpt:
+                {
+                    Type minValue = min(field).value();
+                    Type maxValue = max(field).value();
+
+                    fieldMinMaxFilePtr_() << obr_.time().value() << tab
+                        << fieldName << tab << minValue << tab << maxValue
+                        << endl;
+
+                    if (log_)
+                    {
+                        Info<< "fieldMinMax output:" << nl
+                            << "    cmptMin(" << fieldName << ") = "
+                            << minValue << nl
+                            << "    cmptMax(" << fieldName << ") = "
+                            << maxValue << nl
+                            << endl;
+                    }
+                    break;
+                }
+                default:
+                {
+                    FatalErrorIn
+                    (
+                        "Foam::fieldMinMax::calcMinMaxFields"
+                        "(const word& fieldName)"
+                    )<< "Unknown min/max mode: " << modeTypeNames_[mode_]
+                     << exit(FatalError);
+                }
             }
         }
     }

tutorials/dieselFoam/aachenBomb/0/alphat

@@ -0,0 +1,32 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      alphat;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    walls
+    {
+        type            alphatWallFunction;
+        value           uniform 0;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/dieselFoam/aachenBomb/0/epsilon

@@ -1,40 +1,32 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  1.5                                   |
+|  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
 {
     version     2.0;
-    format      ascii;
+    format      binary;
     class       volScalarField;
+    location    "0";
     object      epsilon;
 }
-// ************************************************************************* //
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-dimensions          [ 0 2 -3 0 0 0 0 ];
+dimensions      [0 2 -3 0 0 0 0];
 
-internalField       uniform 90.0;
+internalField   uniform 90;
 
 boundaryField
 {
     walls
     {
-        type                zeroGradient;
+        type            epsilonWallFunction;
+        value           uniform 90;
     }
-
-    front
-    {
-        type                wedge;
-    }
-
-    back
-    {
-        type                wedge;
-    }
-
 }
 
+
 // ************************************************************************* //

tutorials/dieselFoam/aachenBomb/0/k

@@ -1,40 +1,32 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  1.5                                   |
+|  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 FoamFile
 {
     version     2.0;
-    format      ascii;
+    format      binary;
     class       volScalarField;
+    location    "0";
     object      k;
 }
-// ************************************************************************* //
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-dimensions          [ 0 2 -2 0 0 0 0 ];
+dimensions      [0 2 -2 0 0 0 0];
 
-internalField       uniform 1.0;
+internalField   uniform 1;
 
 boundaryField
 {
     walls
     {
-        type                zeroGradient;
+        type            kQRWallFunction;
+        value           uniform 1;
     }
-
-    front
-    {
-        type                wedge;
-    }
-
-    back
-    {
-        type                wedge;
-    }
-
 }
 
+
 // ************************************************************************* //

tutorials/dieselFoam/aachenBomb/0/mut

@@ -0,0 +1,32 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      mut;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    walls
+    {
+        type            mutWallFunction;
+        value           uniform 0;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/dieselFoam/aachenBomb/constant/polyMesh/boundary

@@ -0,0 +1,28 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       polyBoundaryMesh;
+    location    "constant/polyMesh";
+    object      boundary;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+1
+(
+    walls
+    {
+        type            wall;
+        nFaces          19762;
+        startFace       494419;
+    }
+)
+
+// ************************************************************************* //

tutorials/dieselFoam/aachenBomb/constant/turbulenceProperties

@@ -0,0 +1,19 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.5                                   |
+|   \\  /    A nd           | Web:      http://www.OpenFOAM.org               |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType      RASModel;
+
+// ************************************************************************* //

tutorials/dieselFoam/aachenBomb/system/fvSolution

@@ -16,44 +16,51 @@ FoamFile
 
 solvers
 {
-    rho PCG
+    rho
     {
+        solver           PCG;
         preconditioner   DIC;
         tolerance        1e-06;
         relTol           0;
     };
-    U PBiCG
+    U
     {
+        solver           PBiCG;
         preconditioner   DILU;
         tolerance        1e-06;
         relTol           0;
     };
-    p PCG
+    p
     {
+        solver           PCG;
         preconditioner   DIC;
         tolerance        1e-09;
         relTol           0;
     };
-    Yi PBiCG
+    Yi
     {
+        solver           PBiCG;
         preconditioner   DILU;
         tolerance        1e-06;
         relTol           0;
     };
-    h PBiCG
+    h
     {
+        solver           PBiCG;
         preconditioner   DILU;
         tolerance        1e-06;
         relTol           0;
     };
-    k PBiCG
+    k
     {
+        solver           PBiCG;
         preconditioner   DILU;
         tolerance        1e-06;
         relTol           0;
     };
-    epsilon PBiCG
+    epsilon
     {
+        solver           PBiCG;
         preconditioner   DILU;
         tolerance        1e-06;
         relTol           0;