1)Adding alphaEqn.H and alphaEqnSubCycle.H specialized version for MPPICInterFoam

2)Adapting divU in TEqn.H for compressibleInterDyMFoam and compressibleInterFoam
3)Re-instated sixDoFRigidBodyDisplacement as patch for pointFields. It allows to use a different fvDynamincMesh type
independently of the BC's

applications/solvers/multiphase/MPPICInterFoam/Make/options

@@ -2,9 +2,9 @@ interFoamPath = $(FOAM_SOLVERS)/multiphase/interFoam
 
 EXE_INC =  \
     -I. \
+    -I../VoF \
     -I./IncompressibleTwoPhaseMixtureTurbulenceModels/lnInclude \
     -I$(interFoamPath) \
-    -I../VoF \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/fvOptions/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \

applications/solvers/multiphase/MPPICInterFoam/alphaEqn.H

@@ -0,0 +1,258 @@
+{
+    word alphaScheme("div(phi,alpha)");
+    word alpharScheme("div(phirb,alpha)");
+
+    // Set the off-centering coefficient according to ddt scheme
+    scalar ocCoeff = 0;
+    {
+        tmp<fv::ddtScheme<scalar>> tddtAlpha
+        (
+            fv::ddtScheme<scalar>::New
+            (
+                mesh,
+                mesh.ddtScheme("ddt(alpha)")
+            )
+        );
+        const fv::ddtScheme<scalar>& ddtAlpha = tddtAlpha();
+
+        if
+        (
+            isType<fv::EulerDdtScheme<scalar>>(ddtAlpha)
+         || isType<fv::localEulerDdtScheme<scalar>>(ddtAlpha)
+        )
+        {
+            ocCoeff = 0;
+        }
+        else if (isType<fv::CrankNicolsonDdtScheme<scalar>>(ddtAlpha))
+        {
+            if (nAlphaSubCycles > 1)
+            {
+                FatalErrorInFunction
+                    << "Sub-cycling is not supported "
+                       "with the CrankNicolson ddt scheme"
+                    << exit(FatalError);
+            }
+
+            if
+            (
+                alphaRestart
+             || mesh.time().timeIndex() > mesh.time().startTimeIndex() + 1
+            )
+            {
+                ocCoeff =
+                    refCast<const fv::CrankNicolsonDdtScheme<scalar>>(ddtAlpha)
+                   .ocCoeff();
+            }
+        }
+        else
+        {
+            FatalErrorInFunction
+                << "Only Euler and CrankNicolson ddt schemes are supported"
+                << exit(FatalError);
+        }
+    }
+
+    // Set the time blending factor, 1 for Euler
+    scalar cnCoeff = 1.0/(1.0 + ocCoeff);
+
+    // Standard face-flux compression coefficient
+    surfaceScalarField phic(mixture.cAlpha()*mag(alphaPhic/mesh.magSf()));
+
+    // Add the optional isotropic compression contribution
+    if (icAlpha > 0)
+    {
+        phic *= (1.0 - icAlpha);
+        phic += (mixture.cAlpha()*icAlpha)*fvc::interpolate(mag(U));
+    }
+
+    surfaceScalarField::Boundary& phicBf =
+        phic.boundaryFieldRef();
+
+    // Do not compress interface at non-coupled boundary faces
+    // (inlets, outlets etc.)
+    forAll(phic.boundaryField(), patchi)
+    {
+        fvsPatchScalarField& phicp = phicBf[patchi];
+
+        if (!phicp.coupled())
+        {
+            phicp == 0;
+        }
+    }
+
+    tmp<surfaceScalarField> phiCN(alphaPhic);
+
+    // Calculate the Crank-Nicolson off-centred volumetric flux
+    if (ocCoeff > 0)
+    {
+        phiCN = cnCoeff*alphaPhic + (1.0 - cnCoeff)*alphaPhic.oldTime();
+    }
+
+    if (MULESCorr)
+    {
+        #include "alphaSuSp.H"
+
+        fvScalarMatrix alpha1Eqn
+        (
+            (
+                LTS
+              ? fv::localEulerDdtScheme<scalar>(mesh).fvmDdt(alphac, alpha1)
+              : fv::EulerDdtScheme<scalar>(mesh).fvmDdt(alpha1)
+            )
+          + fv::gaussConvectionScheme<scalar>
+            (
+                mesh,
+                phiCN,
+                upwind<scalar>(mesh, phiCN)
+            ).fvmDiv(phiCN, alpha1)
+         - fvm::Sp(fvc::ddt(alphac) + fvc::div(phiCN), alpha1)
+         ==
+            Su + fvm::Sp(Sp + divU, alpha1)
+        );
+
+        alpha1Eqn.solve();
+
+        Info<< "Phase-1 volume fraction = "
+            << alpha1.weightedAverage(mesh.Vsc()).value()
+            << "  Min(" << alpha1.name() << ") = " << min(alpha1).value()
+            << "  Max(" << alpha1.name() << ") = " << max(alpha1).value()
+            << endl;
+
+        tmp<surfaceScalarField> talphaPhiUD(alpha1Eqn.flux());
+        alphaPhi = talphaPhiUD();
+
+        if (alphaApplyPrevCorr && talphaPhiCorr0.valid())
+        {
+            Info<< "Applying the previous iteration compression flux" << endl;
+            MULES::correct
+            (
+                alphac,
+                alpha1,
+                alphaPhi,
+                talphaPhiCorr0.ref(),
+                zeroField(), zeroField(),
+                1, 0
+            );
+
+            alphaPhi += talphaPhiCorr0();
+        }
+
+        // Cache the upwind-flux
+        talphaPhiCorr0 = talphaPhiUD;
+
+        alpha2 = 1.0 - alpha1;
+
+        mixture.correct();
+    }
+
+
+    for (int aCorr=0; aCorr<nAlphaCorr; aCorr++)
+    {
+        #include "alphaSuSp.H"
+
+        surfaceScalarField phir(phic*mixture.nHatf());
+
+        tmp<surfaceScalarField> talphaPhiUn
+        (
+            fvc::flux
+            (
+                phiCN(),
+                cnCoeff*alpha1 + (1.0 - cnCoeff)*alpha1.oldTime(),
+                alphaScheme
+            )
+          + fvc::flux
+            (
+               -fvc::flux(-phir, alpha2, alpharScheme),
+                alpha1,
+                alpharScheme
+            )
+        );
+
+        if (MULESCorr)
+        {
+            tmp<surfaceScalarField> talphaPhiCorr(talphaPhiUn() - alphaPhi);
+            volScalarField alpha10("alpha10", alpha1);
+
+            MULES::correct
+            (
+                alphac,
+                alpha1,
+                talphaPhiUn(),
+                talphaPhiCorr.ref(),
+                Sp,
+                (-Sp*alpha1)(),
+                1,
+                0
+            );
+
+            // Under-relax the correction for all but the 1st corrector
+            if (aCorr == 0)
+            {
+                alphaPhi += talphaPhiCorr();
+            }
+            else
+            {
+                alpha1 = 0.5*alpha1 + 0.5*alpha10;
+                alphaPhi += 0.5*talphaPhiCorr();
+            }
+        }
+        else
+        {
+            alphaPhi = talphaPhiUn;
+
+            MULES::explicitSolve
+            (
+                alphac,
+                alpha1,
+                phiCN,
+                alphaPhi,
+                Sp,
+                (Su + divU*min(alpha1(), scalar(1)))(),
+                1,
+                0
+            );
+        }
+
+        alpha2 = 1.0 - alpha1;
+
+        mixture.correct();
+    }
+
+    if (alphaApplyPrevCorr && MULESCorr)
+    {
+        talphaPhiCorr0 = alphaPhi - talphaPhiCorr0;
+        talphaPhiCorr0.ref().rename("alphaPhiCorr0");
+    }
+    else
+    {
+        talphaPhiCorr0.clear();
+    }
+
+    if
+    (
+        word(mesh.ddtScheme("ddt(rho,U)"))
+     == fv::EulerDdtScheme<vector>::typeName
+    )
+    {
+        #include "rhofs.H"
+        rhoPhi = alphaPhi*(rho1f - rho2f) + phiCN*rho2f;
+    }
+    else
+    {
+        if (ocCoeff > 0)
+        {
+            // Calculate the end-of-time-step alpha flux
+            alphaPhi = (alphaPhi - (1.0 - cnCoeff)*alphaPhi.oldTime())/cnCoeff;
+        }
+
+        // Calculate the end-of-time-step mass flux
+        #include "rhofs.H"
+        rhoPhi = alphaPhi*(rho1f - rho2f) + alphaPhic*rho2f;
+    }
+
+    Info<< "Phase-1 volume fraction = "
+        << alpha1.weightedAverage(mesh.Vsc()).value()
+        << "  Min(" << alpha1.name() << ") = " << min(alpha1).value()
+        << "  Max(" << alpha1.name() << ") = " << max(alpha1).value()
+        << endl;
+}

applications/solvers/multiphase/MPPICInterFoam/alphaEqnSubCycle.H

@@ -0,0 +1,43 @@
+if (nAlphaSubCycles > 1)
+{
+    dimensionedScalar totalDeltaT = runTime.deltaT();
+    surfaceScalarField rhoPhiSum
+    (
+        IOobject
+        (
+            "rhoPhiSum",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        dimensionedScalar("0", rhoPhi.dimensions(), 0)
+    );
+
+    tmp<volScalarField> trSubDeltaT;
+
+    if (LTS)
+    {
+        trSubDeltaT =
+            fv::localEulerDdt::localRSubDeltaT(mesh, nAlphaSubCycles);
+    }
+
+    for
+    (
+        subCycle<volScalarField> alphaSubCycle(alpha1, nAlphaSubCycles);
+        !(++alphaSubCycle).end();
+    )
+    {
+        #include "alphaEqn.H"
+        rhoPhiSum += (runTime.deltaT()/totalDeltaT)*rhoPhi;
+    }
+
+    rhoPhi = rhoPhiSum;
+}
+else
+{
+    #include "alphaEqn.H"
+}
+
+rho == alpha1*rho1 + alpha2*rho2;
+mu = mixture.mu();
+

applications/solvers/multiphase/compressibleInterFoam/TEqn.H

@@ -5,7 +5,7 @@
       + fvm::div(rhoPhi, T)
       - fvm::laplacian(mixture.alphaEff(turbulence->mut()), T)
       + (
-            fvc::div(fvc::absolute(phi, U), p)
+            divU*p
           + fvc::ddt(rho, K) + fvc::div(rhoPhi, K)
         )
        *(

applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -167,6 +167,12 @@ int main(int argc, char *argv[])
             }
         }
 
+        rho = alpha1*rho1 + alpha2*rho2;
+
+        // Correct p_rgh for consistency with p and the updated densities
+        p_rgh = p - rho*gh;
+        p_rgh.correctBoundaryConditions();
+
         runTime.write();
 
         Info<< "ExecutionTime = "

applications/solvers/multiphase/compressibleInterFoam/compressibleInterFoam.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) OpenCFD Ltd. 2017
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -113,6 +113,7 @@ int main(int argc, char *argv[])
             solve(fvm::ddt(rho) + fvc::div(rhoPhi));
 
             #include "UEqn.H"
+            volScalarField divU(fvc::div(fvc::absolute(phi, U)));
             #include "TEqn.H"
 
             // --- Pressure corrector loop

src/sixDoFRigidBodyMotion/Make/files

@@ -24,6 +24,9 @@ $(constraints)/orientation/sixDoFRigidBodyMotionOrientationConstraint.C
 $(constraints)/plane/sixDoFRigidBodyMotionPlaneConstraint.C
 $(constraints)/point/sixDoFRigidBodyMotionPointConstraint.C
 
+pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C
+pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C
+
 sixDoFRigidBodyMotionSolver/sixDoFRigidBodyMotionSolver.C
 
 sixDoFSolvers/sixDoFSolver/sixDoFSolver.C

src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C

@@ -0,0 +1,290 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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 "sixDoFRigidBodyDisplacementPointPatchVectorField.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Time.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "uniformDimensionedFields.H"
+#include "forces.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+sixDoFRigidBodyDisplacementPointPatchVectorField::
+sixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(p, iF),
+    motion_(),
+    initialPoints_(p.localPoints()),
+    rhoInf_(1.0),
+    rhoName_("rho"),
+    lookupGravity_(-1),
+    g_(Zero),
+    curTimeIndex_(-1)
+{}
+
+
+sixDoFRigidBodyDisplacementPointPatchVectorField::
+sixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValuePointPatchField<vector>(p, iF, dict),
+    motion_(dict, dict),
+    rhoInf_(1.0),
+    rhoName_(dict.lookupOrDefault<word>("rho", "rho")),
+    lookupGravity_(-1),
+    g_(Zero),
+    curTimeIndex_(-1)
+{
+    if (rhoName_ == "rhoInf")
+    {
+        rhoInf_ = readScalar(dict.lookup("rhoInf"));
+    }
+
+    if (dict.readIfPresent("g", g_))
+    {
+        lookupGravity_ = -2;
+    }
+
+    if (!dict.found("value"))
+    {
+        updateCoeffs();
+    }
+
+    if (dict.found("initialPoints"))
+    {
+        initialPoints_ = vectorField("initialPoints", dict , p.size());
+    }
+    else
+    {
+        initialPoints_ = p.localPoints();
+    }
+}
+
+
+sixDoFRigidBodyDisplacementPointPatchVectorField::
+sixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const sixDoFRigidBodyDisplacementPointPatchVectorField& ptf,
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    fixedValuePointPatchField<vector>(ptf, p, iF, mapper),
+    motion_(ptf.motion_),
+    initialPoints_(ptf.initialPoints_, mapper),
+    rhoInf_(ptf.rhoInf_),
+    rhoName_(ptf.rhoName_),
+    lookupGravity_(ptf.lookupGravity_),
+    g_(ptf.g_),
+    curTimeIndex_(-1)
+{}
+
+
+sixDoFRigidBodyDisplacementPointPatchVectorField::
+sixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const sixDoFRigidBodyDisplacementPointPatchVectorField& ptf,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(ptf, iF),
+    motion_(ptf.motion_),
+    initialPoints_(ptf.initialPoints_),
+    rhoInf_(ptf.rhoInf_),
+    rhoName_(ptf.rhoName_),
+    lookupGravity_(ptf.lookupGravity_),
+    g_(ptf.g_),
+    curTimeIndex_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void sixDoFRigidBodyDisplacementPointPatchVectorField::autoMap
+(
+    const pointPatchFieldMapper& m
+)
+{
+    fixedValuePointPatchField<vector>::autoMap(m);
+
+    initialPoints_.autoMap(m);
+}
+
+
+void sixDoFRigidBodyDisplacementPointPatchVectorField::rmap
+(
+    const pointPatchField<vector>& ptf,
+    const labelList& addr
+)
+{
+    const sixDoFRigidBodyDisplacementPointPatchVectorField& sDoFptf =
+        refCast<const sixDoFRigidBodyDisplacementPointPatchVectorField>(ptf);
+
+    fixedValuePointPatchField<vector>::rmap(sDoFptf, addr);
+
+    initialPoints_.rmap(sDoFptf.initialPoints_, addr);
+}
+
+
+void sixDoFRigidBodyDisplacementPointPatchVectorField::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    if (lookupGravity_ < 0)
+    {
+        if (db().foundObject<uniformDimensionedVectorField>("g"))
+        {
+            if (lookupGravity_ == -2)
+            {
+                FatalErrorInFunction
+                    << "Specifying the value of g in this boundary condition "
+                    << "when g is available from the database is considered "
+                    << "a fatal error to avoid the possibility of inconsistency"
+                    << exit(FatalError);
+            }
+            else
+            {
+                lookupGravity_ = 1;
+            }
+        }
+        else
+        {
+            lookupGravity_ = 0;
+        }
+    }
+
+    const polyMesh& mesh = this->internalField().mesh()();
+    const Time& t = mesh.time();
+    const pointPatch& ptPatch = this->patch();
+
+    // Store the motion state at the beginning of the time-step
+    bool firstIter = false;
+    if (curTimeIndex_ != t.timeIndex())
+    {
+        motion_.newTime();
+        curTimeIndex_ = t.timeIndex();
+        firstIter = true;
+    }
+
+    dictionary forcesDict;
+
+    forcesDict.add("type", functionObjects::forces::typeName);
+    forcesDict.add("patches", wordList(1, ptPatch.name()));
+    forcesDict.add("rhoInf", rhoInf_);
+    forcesDict.add("rho", rhoName_);
+    forcesDict.add("CofR", motion_.centreOfRotation());
+
+    functionObjects::forces f("forces", db(), forcesDict);
+
+    f.calcForcesMoment();
+
+    // Get the forces on the patch faces at the current positions
+
+    if (lookupGravity_ == 1)
+    {
+        uniformDimensionedVectorField g =
+            db().lookupObject<uniformDimensionedVectorField>("g");
+
+        g_ = g.value();
+    }
+
+    // scalar ramp = min(max((t.value() - 5)/10, 0), 1);
+    scalar ramp = 1.0;
+
+    motion_.update
+    (
+        firstIter,
+        ramp*(f.forceEff() + motion_.mass()*g_),
+        ramp*(f.momentEff() + motion_.mass()*(motion_.momentArm() ^ g_)),
+        t.deltaTValue(),
+        t.deltaT0Value()
+    );
+
+    Field<vector>::operator=
+    (
+        motion_.transform(initialPoints_) - initialPoints_
+    );
+
+    fixedValuePointPatchField<vector>::updateCoeffs();
+}
+
+
+void sixDoFRigidBodyDisplacementPointPatchVectorField::write(Ostream& os) const
+{
+    pointPatchField<vector>::write(os);
+
+    os.writeKeyword("rho") << rhoName_ << token::END_STATEMENT << nl;
+
+    if (rhoName_ == "rhoInf")
+    {
+        os.writeKeyword("rhoInf") << rhoInf_ << token::END_STATEMENT << nl;
+    }
+
+    if (lookupGravity_ == 0 || lookupGravity_ == -2)
+    {
+        os.writeKeyword("g") << g_ << token::END_STATEMENT << nl;
+    }
+
+    motion_.write(os);
+
+    initialPoints_.writeEntry("initialPoints", os);
+
+    writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchTypeField
+(
+    pointPatchVectorField,
+    sixDoFRigidBodyDisplacementPointPatchVectorField
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.H

@@ -0,0 +1,196 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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/>.
+
+Class
+    Foam::sixDoFRigidBodyDisplacementPointPatchVectorField
+
+Description
+    Foam::sixDoFRigidBodyDisplacementPointPatchVectorField
+
+SourceFiles
+    sixDoFRigidBodyDisplacementPointPatchVectorField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef sixDoFRigidBodyDisplacementPointPatchVectorField_H
+#define sixDoFRigidBodyDisplacementPointPatchVectorField_H
+
+#include "fixedValuePointPatchField.H"
+#include "sixDoFRigidBodyMotion.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+        Class sixDoFRigidBodyDisplacementPointPatchVectorField Declaration
+\*---------------------------------------------------------------------------*/
+
+class sixDoFRigidBodyDisplacementPointPatchVectorField
+:
+    public fixedValuePointPatchField<vector>
+{
+    // Private data
+
+        //- Six dof motion object
+        sixDoFRigidBodyMotion motion_;
+
+        //- Initial positions of points on the patch
+        pointField initialPoints_;
+
+        //- Reference density required by the forces object for
+        //  incompressible calculations, required if rho == rhoInf
+        scalar rhoInf_;
+
+        //- Name of density field, optional unless used for an
+        //  incompressible simulation, when this needs to be specified
+        //  as rhoInf
+        word rhoName_;
+
+        //- State of gravity lookup:
+        //  -1 = not determined yet, as the BC may be instantiated before g has
+        //       been read into the db yet.  Determination deferred until first
+        //       call to updateCoeffs.  A g keyword was not supplied to the
+        //       dictionary.
+        //  -2 = as for -1, but a gravity value was specified in the dictionary,
+        //       specifying a value in the dictionary is considered a fatal
+        //       error if g is available from the db.
+        //   0 = Use this boundary condition's own value of gravity, as not
+        //       available from the db.
+        //   1 = Lookup gravity from db.
+        label lookupGravity_;
+
+        //- Gravity vector to store when not available from the db
+        vector g_;
+
+        //- Current time index (used for updating)
+        label curTimeIndex_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("sixDoFRigidBodyDisplacement");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        sixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        sixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<vector> onto a new patch
+        sixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const sixDoFRigidBodyDisplacementPointPatchVectorField&,
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<vector>> clone() const
+        {
+            return autoPtr<pointPatchField<vector>>
+            (
+                new sixDoFRigidBodyDisplacementPointPatchVectorField
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        sixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const sixDoFRigidBodyDisplacementPointPatchVectorField&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<vector>> clone
+        (
+            const DimensionedField<vector, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<vector>>
+            (
+                new sixDoFRigidBodyDisplacementPointPatchVectorField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Mapping functions
+
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const pointPatchFieldMapper&
+            );
+
+            //- Reverse map the given pointPatchField onto this pointPatchField
+            virtual void rmap
+            (
+                const pointPatchField<vector>&,
+                const labelList&
+            );
+
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C

@@ -0,0 +1,216 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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 "uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.H"
+#include "pointPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Time.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "uniformDimensionedFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(p, iF),
+    motion_(),
+    initialPoints_(p.localPoints()),
+    curTimeIndex_(-1)
+{}
+
+
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValuePointPatchField<vector>(p, iF, dict),
+    motion_(dict, dict),
+    curTimeIndex_(-1)
+{
+    if (!dict.found("value"))
+    {
+        updateCoeffs();
+    }
+
+    if (dict.found("initialPoints"))
+    {
+        initialPoints_ = vectorField("initialPoints", dict , p.size());
+    }
+    else
+    {
+        initialPoints_ = p.localPoints();
+    }
+}
+
+
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField& ptf,
+    const pointPatch& p,
+    const DimensionedField<vector, pointMesh>& iF,
+    const pointPatchFieldMapper& mapper
+)
+:
+    fixedValuePointPatchField<vector>(ptf, p, iF, mapper),
+    motion_(ptf.motion_),
+    initialPoints_(ptf.initialPoints_, mapper),
+    curTimeIndex_(-1)
+{}
+
+
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::
+uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+(
+    const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField& ptf,
+    const DimensionedField<vector, pointMesh>& iF
+)
+:
+    fixedValuePointPatchField<vector>(ptf, iF),
+    motion_(ptf.motion_),
+    initialPoints_(ptf.initialPoints_),
+    curTimeIndex_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::autoMap
+(
+    const pointPatchFieldMapper& m
+)
+{
+    fixedValuePointPatchField<vector>::autoMap(m);
+
+    initialPoints_.autoMap(m);
+}
+
+
+void uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::rmap
+(
+    const pointPatchField<vector>& ptf,
+    const labelList& addr
+)
+{
+    const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField& uSDoFptf =
+    refCast
+    <
+        const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+    >(ptf);
+
+    fixedValuePointPatchField<vector>::rmap(uSDoFptf, addr);
+
+    initialPoints_.rmap(uSDoFptf.initialPoints_, addr);
+}
+
+
+void uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    const polyMesh& mesh = this->internalField().mesh()();
+    const Time& t = mesh.time();
+
+    // Store the motion state at the beginning of the time-step
+    bool firstIter = false;
+    if (curTimeIndex_ != t.timeIndex())
+    {
+        motion_.newTime();
+        curTimeIndex_ = t.timeIndex();
+        firstIter = true;
+    }
+
+    vector gravity = Zero;
+
+    if (db().foundObject<uniformDimensionedVectorField>("g"))
+    {
+        uniformDimensionedVectorField g =
+        db().lookupObject<uniformDimensionedVectorField>("g");
+
+        gravity = g.value();
+    }
+
+    // Do not modify the accelerations, except with gravity, where available
+    motion_.update
+    (
+        firstIter,
+        gravity*motion_.mass(),
+        Zero,
+        t.deltaTValue(),
+        t.deltaT0Value()
+    );
+
+    Field<vector>::operator=
+    (
+        motion_.transform(initialPoints_) - initialPoints_
+    );
+
+    fixedValuePointPatchField<vector>::updateCoeffs();
+}
+
+
+void uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField::write
+(
+    Ostream& os
+) const
+{
+    pointPatchField<vector>::write(os);
+    motion_.write(os);
+    initialPoints_.writeEntry("initialPoints", os);
+    writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePointPatchTypeField
+(
+    pointPatchVectorField,
+    uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.H

@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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/>.
+
+Class
+    Foam::uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+
+Description
+    Foam::uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+
+SourceFiles
+    uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField_H
+#define uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField_H
+
+#include "fixedValuePointPatchField.H"
+#include "sixDoFRigidBodyMotion.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+  Class uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField Declaration
+\*---------------------------------------------------------------------------*/
+
+class uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+:
+    public fixedValuePointPatchField<vector>
+{
+    // Private data
+
+        //- Six dof motion object
+        sixDoFRigidBodyMotion motion_;
+
+        //- Initial positions of points on the patch
+        pointField initialPoints_;
+
+        //- Current time index (used for updating)
+        label curTimeIndex_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("uncoupledSixDoFRigidBodyDisplacement");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patchField<vector> onto a new patch
+        uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField&,
+            const pointPatch&,
+            const DimensionedField<vector, pointMesh>&,
+            const pointPatchFieldMapper&
+        );
+
+        //- Construct and return a clone
+        virtual autoPtr<pointPatchField<vector>> clone() const
+        {
+            return autoPtr<pointPatchField<vector>>
+            (
+                new uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+                (
+                    *this
+                )
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+        (
+            const uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField&,
+            const DimensionedField<vector, pointMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual autoPtr<pointPatchField<vector>> clone
+        (
+            const DimensionedField<vector, pointMesh>& iF
+        ) const
+        {
+            return autoPtr<pointPatchField<vector>>
+            (
+                new uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+    // Member functions
+
+        // Mapping functions
+
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const pointPatchFieldMapper&
+            );
+
+            //- Reverse map the given pointPatchField onto this pointPatchField
+            virtual void rmap
+            (
+                const pointPatchField<vector>&,
+                const labelList&
+            );
+
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //