diff --git a/applications/solvers/multiphase/MPPICInterFoam/Make/options b/applications/solvers/multiphase/MPPICInterFoam/Make/options
index abc0537451c6337c71984756ddd167241eb2a886..0ad31d6975c01583c8f4eba520a8518038bf5453 100644
--- a/applications/solvers/multiphase/MPPICInterFoam/Make/options
+++ b/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 \
diff --git a/applications/solvers/multiphase/MPPICInterFoam/alphaEqn.H b/applications/solvers/multiphase/MPPICInterFoam/alphaEqn.H
new file mode 100644
index 0000000000000000000000000000000000000000..3ce881bd06b3c6f7b917d00babd3df5d080816ef
--- /dev/null
+++ b/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;
+}
diff --git a/applications/solvers/multiphase/MPPICInterFoam/alphaEqnSubCycle.H b/applications/solvers/multiphase/MPPICInterFoam/alphaEqnSubCycle.H
new file mode 100644
index 0000000000000000000000000000000000000000..6820b2e596f38d7335013da8d4a1d3559f23541e
--- /dev/null
+++ b/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();
+
diff --git a/applications/solvers/multiphase/compressibleInterFoam/TEqn.H b/applications/solvers/multiphase/compressibleInterFoam/TEqn.H
index 60dd2aecc812fef9ebbfd9edd802c326950f84b3..af74f0362a4ec21ce61cf78d7aaa88a08ab5b256 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/TEqn.H
+++ b/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)
)
*(
diff --git a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C b/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C
index 34e8762709abfd0644471c5dcd4cb16cef4238f4..e3d43a8944ff9289cba853549b81ff9c1f19d1f5 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C
+++ b/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 = "
diff --git a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFoam.C b/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFoam.C
index a657caf01ee388fa595b0bc4364dd643e724ab6b..dee1a578f25cea83ed57808459b85a58c5749819 100644
--- a/applications/solvers/multiphase/compressibleInterFoam/compressibleInterFoam.C
+++ b/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
diff --git a/src/sixDoFRigidBodyMotion/Make/files b/src/sixDoFRigidBodyMotion/Make/files
index f5abd78686c976609663bdc6ef0bc667f8eeffe9..837d2df3fd19a45f3ff0ab7af532f190f69d1fdd 100644
--- a/src/sixDoFRigidBodyMotion/Make/files
+++ b/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
diff --git a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C
new file mode 100644
index 0000000000000000000000000000000000000000..daeb9adf8d976ad0d9f0e6355842790494cee6d8
--- /dev/null
+++ b/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
+
+// ************************************************************************* //
diff --git a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.H b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.H
new file mode 100644
index 0000000000000000000000000000000000000000..04b001706239324ea83324304d280e93b7d07b1d
--- /dev/null
+++ b/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
+
+// ************************************************************************* //
diff --git a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.C
new file mode 100644
index 0000000000000000000000000000000000000000..123b128b9234b14614e8e217a4f458d7995e1634
--- /dev/null
+++ b/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
+
+// ************************************************************************* //
diff --git a/src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.H b/src/sixDoFRigidBodyMotion/pointPatchFields/derived/uncoupledSixDoFRigidBodyDisplacement/uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField.H
new file mode 100644
index 0000000000000000000000000000000000000000..b5025104db503503d87a61e6a8fcd426669b6ef3
--- /dev/null
+++ b/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
+
+// ************************************************************************* //