diff --git a/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
index 69dc36bccf838d9659e4f8c01d7a89f8efccf66b..7380562664f590ca6e03288e2199030d52954e51 100644
--- a/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
@@ -23,8 +23,9 @@ License
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Description
- Extrude mesh from existing patch (flipped so has inwards pointing
- normals) or from patch read from file.
+ Extrude mesh from existing patch (by default outwards facing normals;
+ optional flips faces)
+ or from patch read from file.
Note: Merges close points so be careful.
Type of extrusion prescribed by run-time selectable model.
@@ -108,14 +109,11 @@ int main(int argc, char *argv[])
const polyPatch& pp = mesh.boundaryMesh()[patchID];
fMesh.reset(new faceMesh(pp.localFaces(), pp.localPoints()));
- fMesh().flip();
{
- fileName surfName(patchName + ".sMesh");
-
- Info<< "Writing (flipped) patch as surfaceMesh to "
+ fileName surfName(runTime.path()/patchName + ".sMesh");
+ Info<< "Writing patch as surfaceMesh to "
<< surfName << nl << endl;
-
OFstream os(surfName);
os << fMesh() << nl;
}
@@ -142,6 +140,20 @@ int main(int argc, char *argv[])
<< "patch or surface." << exit(FatalError);
}
+ Switch flipNormals(dict.lookup("flipNormals"));
+
+ if (flipNormals)
+ {
+ Info<< "Flipping faces." << nl << endl;
+
+ faceList faces(fMesh().size());
+ forAll(faces, i)
+ {
+ faces[i] = fMesh()[i].reverseFace();
+ }
+ fMesh.reset(new faceMesh(faces, fMesh().localPoints()));
+ }
+
Info<< "Extruding patch with :" << nl
<< " points : " << fMesh().points().size() << nl
diff --git a/applications/utilities/mesh/generation/extrudeMesh/extrudeModel/linearNormal/linearNormal.C b/applications/utilities/mesh/generation/extrudeMesh/extrudeModel/linearNormal/linearNormal.C
index 99c02d214fa17f11ed889329374d535f0e97080f..c36098ab1e6a3cf10b748a84e7062524ad9e3fd9 100644
--- a/applications/utilities/mesh/generation/extrudeMesh/extrudeModel/linearNormal/linearNormal.C
+++ b/applications/utilities/mesh/generation/extrudeMesh/extrudeModel/linearNormal/linearNormal.C
@@ -47,7 +47,14 @@ linearNormal::linearNormal(const dictionary& dict)
:
extrudeModel(typeName, dict),
thickness_(readScalar(coeffDict_.lookup("thickness")))
-{}
+{
+ if (thickness_ <= 0)
+ {
+ FatalErrorIn("linearNormal(const dictionary&)")
+ << "thickness should be positive : " << thickness_
+ << exit(FatalError);
+ }
+}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
diff --git a/applications/utilities/mesh/generation/extrudeMesh/extrudeProperties b/applications/utilities/mesh/generation/extrudeMesh/extrudeProperties
index 20de7b21524b083cf6cc37a684a971bcda890059..8bf73c4bf2ca89172987fec01fcd6939249f409e 100644
--- a/applications/utilities/mesh/generation/extrudeMesh/extrudeProperties
+++ b/applications/utilities/mesh/generation/extrudeMesh/extrudeProperties
@@ -19,31 +19,40 @@ FoamFile
constructFrom patch; //surface;
// If construct from (flipped) patch
-sourceCase "../cavity";
+sourceCase "$FOAM_RUN/icoFoam/cavity";
sourcePatch movingWall;
+// Flip surface normals before usage.
+flipNormals false;
+
// If construct from surface
surface "movingWall.sMesh";
-// Do front and back need to be merged?
-mergeFaces false;
+// Do front and back need to be merged? Usually only makes sense for 360
+// degree wedges.
+mergeFaces true;
+
//- Linear extrusion in point-normal direction
//extrudeModel linearNormal;
+
//- Wedge extrusion. If nLayers is 1 assumes symmetry around plane.
extrudeModel wedge;
+
//- Extrudes into sphere around (0 0 0)
//extrudeModel linearRadial;
+
+//- Extrudes into sphere with grading according to pressure (atmospherics)
//extrudeModel sigmaRadial;
-nLayers 6;
+nLayers 20;
wedgeCoeffs
{
axisPt (0 0.1 0);
- axis (1 0 0);
- angle 90.0; // For nLayers=1 assume symmetry so angle/2 on each side
+ axis (-1 0 0);
+ angle 360; // For nLayers=1 assume symmetry so angle/2 on each side
}
linearNormalCoeffs
diff --git a/applications/utilities/mesh/generation/extrudeMesh/extrudedMesh/extrudedMesh.C b/applications/utilities/mesh/generation/extrudeMesh/extrudedMesh/extrudedMesh.C
index b258c594451332958c13cdda37c9bbfeb28dd459..16bab41094a54fcf6cdda9f98d850ce9f1a0c0fa 100644
--- a/applications/utilities/mesh/generation/extrudeMesh/extrudedMesh/extrudedMesh.C
+++ b/applications/utilities/mesh/generation/extrudeMesh/extrudedMesh/extrudedMesh.C
@@ -109,15 +109,33 @@ Foam::Xfer<Foam::faceList> Foam::extrudedMesh::extrudedFaces
label currentLayerOffset = layer*surfacePoints.size();
label nextLayerOffset = currentLayerOffset + surfacePoints.size();
- // Side faces from layer to layer+1
- for (label i=0; i<nInternalEdges; i++)
+ // Vertical faces from layer to layer+1
+ for (label edgeI=0; edgeI<nInternalEdges; edgeI++)
{
- quad[0] = surfaceEdges[i][1] + currentLayerOffset;
- quad[1] = surfaceEdges[i][0] + currentLayerOffset;
- quad[2] = surfaceEdges[i][0] + nextLayerOffset;
- quad[3] = surfaceEdges[i][1] + nextLayerOffset;
+ const edge& e = surfaceEdges[edgeI];
+ const labelList& edgeFaces = extrudePatch.edgeFaces()[edgeI];
+
+ face& f = eFaces[facei++];
+ f.setSize(4);
- eFaces[facei++] = face(quad).reverseFace();
+ if
+ (
+ (edgeFaces[0] < edgeFaces[1])
+ == sameOrder(surfaceFaces[edgeFaces[0]], e)
+ )
+ {
+ f[0] = e[0] + currentLayerOffset;
+ f[1] = e[1] + currentLayerOffset;
+ f[2] = e[1] + nextLayerOffset;
+ f[3] = e[0] + nextLayerOffset;
+ }
+ else
+ {
+ f[0] = e[1] + currentLayerOffset;
+ f[1] = e[0] + currentLayerOffset;
+ f[2] = e[0] + nextLayerOffset;
+ f[3] = e[1] + nextLayerOffset;
+ }
}
// Faces between layer and layer+1
@@ -128,9 +146,9 @@ Foam::Xfer<Foam::faceList> Foam::extrudedMesh::extrudedFaces
eFaces[facei++] =
face
(
- surfaceFaces[i].reverseFace()
+ surfaceFaces[i] //.reverseFace()
+ nextLayerOffset
- ).reverseFace();
+ );
}
}
}
@@ -142,40 +160,46 @@ Foam::Xfer<Foam::faceList> Foam::extrudedMesh::extrudedFaces
label nextLayerOffset = currentLayerOffset + surfacePoints.size();
// Side faces across layer
- for (label i=nInternalEdges; i<surfaceEdges.size(); i++)
+ for (label edgeI=nInternalEdges; edgeI<surfaceEdges.size(); edgeI++)
{
- const edge& e = surfaceEdges[i];
- quad[0] = e[1] + currentLayerOffset;
- quad[1] = e[0] + currentLayerOffset;
- quad[2] = e[0] + nextLayerOffset;
- quad[3] = e[1] + nextLayerOffset;
+ const edge& e = surfaceEdges[edgeI];
+ const labelList& edgeFaces = extrudePatch.edgeFaces()[edgeI];
- label ownerFace = extrudePatch.edgeFaces()[i][0];
+ face& f = eFaces[facei++];
+ f.setSize(4);
- if (sameOrder(surfaceFaces[ownerFace], e))
+ if (sameOrder(surfaceFaces[edgeFaces[0]], e))
{
- reverse(quad);
+ f[0] = e[0] + currentLayerOffset;
+ f[1] = e[1] + currentLayerOffset;
+ f[2] = e[1] + nextLayerOffset;
+ f[3] = e[0] + nextLayerOffset;
+ }
+ else
+ {
+ f[0] = e[1] + currentLayerOffset;
+ f[1] = e[0] + currentLayerOffset;
+ f[2] = e[0] + nextLayerOffset;
+ f[3] = e[1] + nextLayerOffset;
}
-
- eFaces[facei++] = face(quad);
}
}
- // Top faces
+ // Bottom faces
forAll(surfaceFaces, i)
{
eFaces[facei++] = face(surfaceFaces[i]).reverseFace();
}
- // Bottom faces
+ // Top faces
forAll(surfaceFaces, i)
{
eFaces[facei++] =
face
(
- surfaceFaces[i].reverseFace()
+ surfaceFaces[i]
+ nLayers*surfacePoints.size()
- ).reverseFace();
+ );
}
// return points for transferring
diff --git a/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C b/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
index 9ce34cda1c73f4638439af2c837f24b1a89eb23e..fa51928f9951398334634cb9a7e2e564694ce67f 100644
--- a/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
+++ b/applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
@@ -67,8 +67,13 @@ Foam::label Foam::checkTopology
{
forAll(mesh.faceZones(), zoneI)
{
- if (mesh.faceZones()[zoneI].checkParallelSync(true))
+ if (mesh.faceZones()[zoneI].checkParallelSync(false))
{
+ Info<< " ***FaceZone " << mesh.faceZones()[zoneI].name()
+ << " is not correctly synchronised"
+ << " acrosss coupled boundaries."
+ << " (coupled faces both"
+ << " present in set but with opposite flipmap)" << endl;
noFailedChecks++;
}
}
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
index b5b4174fb3a23963d98831280d98bd368c18a2b6..88f806b5dd1c948ca165439529c4467e19c57f2f 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C
@@ -100,6 +100,12 @@ Foam::label Foam::meshRefinement::createBaffle
<< " ownPatch:" << ownPatch << abort(FatalError);
}
+ bool reverseFlip = false;
+ if (zoneID >= 0)
+ {
+ reverseFlip = !zoneFlip;
+ }
+
dupFaceI = meshMod.setAction
(
polyAddFace
@@ -113,7 +119,7 @@ Foam::label Foam::meshRefinement::createBaffle
true, // face flip
neiPatch, // patch for face
zoneID, // zone for face
- !zoneFlip // face flip in zone
+ reverseFlip // face flip in zone
)
);
}
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 54bfbc7cf6e4a46600704deee7add747fd581d92..6be4b7f3f49731e2966bebb58bb7a4f18618dc66 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -104,6 +104,7 @@ $(constraintFvPatchFields)/wedge/wedgeFvPatchFields.C
$(constraintFvPatchFields)/wedge/wedgeFvPatchScalarField.C
derivedFvPatchFields = $(fvPatchFields)/derived
+$(derivedFvPatchFields)/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
$(derivedFvPatchFields)/advective/advectiveFvPatchFields.C
$(derivedFvPatchFields)/directMappedFixedValue/directMappedFixedValueFvPatchFields.C
$(derivedFvPatchFields)/directMappedVelocityFluxFixedValue/directMappedVelocityFluxFixedValueFvPatchField.C
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
new file mode 100644
index 0000000000000000000000000000000000000000..c090d5296877c2a92d760bacb568971e0117ed4f
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
@@ -0,0 +1,274 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
+ \\/ 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 2 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, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "activeBaffleVelocityFvPatchVectorField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+Foam::activeBaffleVelocityFvPatchVectorField::
+activeBaffleVelocityFvPatchVectorField
+(
+ const fvPatch& p,
+ const DimensionedField<vector, volMesh>& iF
+)
+:
+ fixedValueFvPatchVectorField(p, iF),
+ pName_("p"),
+ cyclicPatchName_(),
+ cyclicPatchLabel_(-1),
+ orientation_(1),
+ initWallSf_(0),
+ initCyclicSf_(0),
+ openFraction_(0),
+ openingTime_(0),
+ maxOpenFractionDelta_(0),
+ curTimeIndex_(-1)
+{}
+
+
+Foam::activeBaffleVelocityFvPatchVectorField::
+activeBaffleVelocityFvPatchVectorField
+(
+ const activeBaffleVelocityFvPatchVectorField& ptf,
+ const fvPatch& p,
+ const DimensionedField<vector, volMesh>& iF,
+ const fvPatchFieldMapper& mapper
+)
+:
+ fixedValueFvPatchVectorField(ptf, p, iF, mapper),
+ pName_(ptf.pName_),
+ cyclicPatchName_(ptf.cyclicPatchName_),
+ cyclicPatchLabel_(ptf.cyclicPatchLabel_),
+ orientation_(ptf.orientation_),
+ initWallSf_(ptf.initWallSf_),
+ initCyclicSf_(ptf.initCyclicSf_),
+ openFraction_(ptf.openFraction_),
+ openingTime_(ptf.openingTime_),
+ maxOpenFractionDelta_(ptf.maxOpenFractionDelta_),
+ curTimeIndex_(-1)
+{}
+
+
+Foam::activeBaffleVelocityFvPatchVectorField::
+activeBaffleVelocityFvPatchVectorField
+(
+ const fvPatch& p,
+ const DimensionedField<vector, volMesh>& iF,
+ const dictionary& dict
+)
+:
+ fixedValueFvPatchVectorField(p, iF),
+ pName_("p"),
+ cyclicPatchName_(dict.lookup("cyclicPatch")),
+ cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
+ orientation_(readLabel(dict.lookup("orientation"))),
+ initWallSf_(p.Sf()),
+ initCyclicSf_(p.boundaryMesh()[cyclicPatchLabel_].Sf()),
+ openFraction_(readScalar(dict.lookup("openFraction"))),
+ openingTime_(readScalar(dict.lookup("openingTime"))),
+ maxOpenFractionDelta_(readScalar(dict.lookup("maxOpenFractionDelta"))),
+ curTimeIndex_(-1)
+{
+ fvPatchVectorField::operator=(vector::zero);
+
+ if (dict.found("p"))
+ {
+ dict.lookup("p") >> pName_;
+ }
+}
+
+
+Foam::activeBaffleVelocityFvPatchVectorField::
+activeBaffleVelocityFvPatchVectorField
+(
+ const activeBaffleVelocityFvPatchVectorField& ptf
+)
+:
+ fixedValueFvPatchVectorField(ptf),
+ pName_(ptf.pName_),
+ cyclicPatchName_(ptf.cyclicPatchName_),
+ cyclicPatchLabel_(ptf.cyclicPatchLabel_),
+ orientation_(ptf.orientation_),
+ initWallSf_(ptf.initWallSf_),
+ initCyclicSf_(ptf.initCyclicSf_),
+ openFraction_(ptf.openFraction_),
+ openingTime_(ptf.openingTime_),
+ maxOpenFractionDelta_(ptf.maxOpenFractionDelta_),
+ curTimeIndex_(-1)
+{}
+
+
+Foam::activeBaffleVelocityFvPatchVectorField::
+activeBaffleVelocityFvPatchVectorField
+(
+ const activeBaffleVelocityFvPatchVectorField& ptf,
+ const DimensionedField<vector, volMesh>& iF
+)
+:
+ fixedValueFvPatchVectorField(ptf, iF),
+ pName_(ptf.pName_),
+ cyclicPatchName_(ptf.cyclicPatchName_),
+ cyclicPatchLabel_(ptf.cyclicPatchLabel_),
+ orientation_(ptf.orientation_),
+ initWallSf_(ptf.initWallSf_),
+ initCyclicSf_(ptf.initCyclicSf_),
+ openFraction_(ptf.openFraction_),
+ openingTime_(ptf.openingTime_),
+ maxOpenFractionDelta_(ptf.maxOpenFractionDelta_),
+ curTimeIndex_(-1)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
+
+void Foam::activeBaffleVelocityFvPatchVectorField::autoMap
+(
+ const fvPatchFieldMapper& m
+)
+{
+ fixedValueFvPatchVectorField::autoMap(m);
+
+ //- Note: cannot map field from cyclic patch anyway so just recalculate
+ // Areas should be consistent when doing autoMap except in case of
+ // topo changes.
+ initWallSf_ = patch().Sf();
+ initCyclicSf_ = patch().boundaryMesh()[cyclicPatchLabel_].Sf();
+}
+
+void Foam::activeBaffleVelocityFvPatchVectorField::rmap
+(
+ const fvPatchVectorField& ptf,
+ const labelList& addr
+)
+{
+ fixedValueFvPatchVectorField::rmap(ptf, addr);
+
+ //- Note: cannot map field from cyclic patch anyway so just recalculate
+ // Areas should be consistent when doing rmap (mainly reconstructPar)
+ initWallSf_ = patch().Sf();
+ initCyclicSf_ = patch().boundaryMesh()[cyclicPatchLabel_].Sf();
+}
+
+
+void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
+{
+ if (updated())
+ {
+ return;
+ }
+
+ // Execute the change to the openFraction only once per time-step
+ if (curTimeIndex_ != this->db().time().timeIndex())
+ {
+ const volScalarField& p = db().lookupObject<volScalarField>
+ (
+ pName_
+ );
+
+ const fvPatch& cyclicPatch = patch().boundaryMesh()[cyclicPatchLabel_];
+ const labelList& cyclicFaceCells = cyclicPatch.patch().faceCells();
+ label nCyclicFaces = cyclicFaceCells.size();
+ label nCyclicFacesPerSide = nCyclicFaces/2;
+
+ scalar forceDiff = 0;
+
+ for (label facei=0; facei<nCyclicFacesPerSide; facei++)
+ {
+ forceDiff += p[cyclicFaceCells[facei]]*mag(initCyclicSf_[facei]);
+ }
+
+ for (label facei=nCyclicFacesPerSide; facei<nCyclicFaces; facei++)
+ {
+ forceDiff -= p[cyclicFaceCells[facei]]*mag(initCyclicSf_[facei]);
+ }
+
+ openFraction_ =
+ max(min(
+ openFraction_
+ + max
+ (
+ this->db().time().deltaT().value()/openingTime_,
+ maxOpenFractionDelta_
+ )
+ *(orientation_*sign(forceDiff)),
+ 1 - 1e-6), 1e-6);
+
+ Info<< "openFraction = " << openFraction_ << endl;
+
+ vectorField::subField Sfw = patch().patch().faceAreas();
+ vectorField newSfw = (1 - openFraction_)*initWallSf_;
+ forAll(Sfw, facei)
+ {
+ Sfw[facei] = newSfw[facei];
+ }
+ const_cast<scalarField&>(patch().magSf()) = mag(patch().Sf());
+
+ const_cast<vectorField&>(cyclicPatch.Sf()) =
+ openFraction_*initCyclicSf_;
+ const_cast<scalarField&>(cyclicPatch.magSf()) =
+ mag(cyclicPatch.Sf());
+
+ curTimeIndex_ = this->db().time().timeIndex();
+ }
+
+ fixedValueFvPatchVectorField::updateCoeffs();
+}
+
+
+void Foam::activeBaffleVelocityFvPatchVectorField::write(Ostream& os) const
+{
+ fvPatchVectorField::write(os);
+ os.writeKeyword("cyclicPatch")
+ << cyclicPatchName_ << token::END_STATEMENT << nl;
+ os.writeKeyword("orientation")
+ << orientation_ << token::END_STATEMENT << nl;
+ os.writeKeyword("openingTime")
+ << openingTime_ << token::END_STATEMENT << nl;
+ os.writeKeyword("maxOpenFractionDelta")
+ << maxOpenFractionDelta_ << token::END_STATEMENT << nl;
+ os.writeKeyword("openFraction")
+ << openFraction_ << token::END_STATEMENT << nl;
+ os.writeKeyword("p")
+ << pName_ << token::END_STATEMENT << nl;
+ writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+ makePatchTypeField
+ (
+ fvPatchVectorField,
+ activeBaffleVelocityFvPatchVectorField
+ );
+}
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.H b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.H
new file mode 100644
index 0000000000000000000000000000000000000000..1f4f3d2b903ee3f93f83526e31809adf1c90ab80
--- /dev/null
+++ b/src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.H
@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 1991-2009 OpenCFD Ltd.
+ \\/ 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 2 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, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::activeBaffleVelocityFvPatchVectorField
+
+Description
+ Boundary condition that modifies mesh areas based on velocity.
+
+SourceFiles
+ activeBaffleVelocityFvPatchVectorField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef activeBaffleVelocityFvPatchVectorField_H
+#define activeBaffleVelocityFvPatchVectorField_H
+
+#include "fvPatchFields.H"
+#include "fixedValueFvPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+ Class activeBaffleVelocityFvPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class activeBaffleVelocityFvPatchVectorField
+:
+ public fixedValueFvPatchVectorField
+{
+ // Private data
+
+ //- Name of the pressure field used to calculate the force
+ // on the active baffle
+ word pName_;
+
+ //- Name of the cyclic patch used when the active baffle is open
+ word cyclicPatchName_;
+
+ //- Index of the cyclic patch used when the active baffle is open
+ label cyclicPatchLabel_;
+
+ //- Orientation (1 or -1) of the active baffle patch.
+ // Used to change the direction of opening without the need for
+ // reordering the patch faces
+ label orientation_;
+
+ //- Initial wall patch areas
+ vectorField initWallSf_;
+
+ //- Initial cyclic patch areas
+ vectorField initCyclicSf_;
+
+ //- Current fraction of the active baffle which is open
+ scalar openFraction_;
+
+ //- Time taken for the active baffle to open
+ scalar openingTime_;
+
+ //- Maximum fractional change to the active baffle openness
+ // per time-step
+ scalar maxOpenFractionDelta_;
+
+ label curTimeIndex_;
+
+
+public:
+
+ //- Runtime type information
+ TypeName("activeBaffleVelocity");
+
+
+ // Constructors
+
+ //- Construct from patch and internal field
+ activeBaffleVelocityFvPatchVectorField
+ (
+ const fvPatch&,
+ const DimensionedField<vector, volMesh>&
+ );
+
+ //- Construct from patch, internal field and dictionary
+ activeBaffleVelocityFvPatchVectorField
+ (
+ const fvPatch&,
+ const DimensionedField<vector, volMesh>&,
+ const dictionary&
+ );
+
+ //- Construct by mapping given activeBaffleVelocityFvPatchVectorField
+ // onto a new patch
+ activeBaffleVelocityFvPatchVectorField
+ (
+ const activeBaffleVelocityFvPatchVectorField&,
+ const fvPatch&,
+ const DimensionedField<vector, volMesh>&,
+ const fvPatchFieldMapper&
+ );
+
+ //- Construct as copy
+ activeBaffleVelocityFvPatchVectorField
+ (
+ const activeBaffleVelocityFvPatchVectorField&
+ );
+
+ //- Construct and return a clone
+ virtual tmp<fvPatchVectorField> clone() const
+ {
+ return tmp<fvPatchVectorField>
+ (
+ new activeBaffleVelocityFvPatchVectorField(*this)
+ );
+ }
+
+ //- Construct as copy setting internal field reference
+ activeBaffleVelocityFvPatchVectorField
+ (
+ const activeBaffleVelocityFvPatchVectorField&,
+ const DimensionedField<vector, volMesh>&
+ );
+
+ //- Construct and return a clone setting internal field reference
+ virtual tmp<fvPatchVectorField> clone
+ (
+ const DimensionedField<vector, volMesh>& iF
+ ) const
+ {
+ return tmp<fvPatchVectorField>
+ (
+ new activeBaffleVelocityFvPatchVectorField(*this, iF)
+ );
+ }
+
+
+ // Member functions
+
+ // Mapping functions
+
+ //- Map (and resize as needed) from self given a mapping object
+ virtual void autoMap
+ (
+ const fvPatchFieldMapper&
+ );
+
+ //- Reverse map the given fvPatchField onto this fvPatchField
+ virtual void rmap
+ (
+ const fvPatchVectorField&,
+ const labelList&
+ );
+
+
+ //- 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/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C b/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
index 04ae825df59f5914dfc968ee84c58c13b387de62..fa2e2393048f5d88a457acf0d6385653e7ccafad 100644
--- a/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
+++ b/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
@@ -37,7 +37,7 @@ Foam::molecule::molecule
bool readFields
)
:
- Particle<molecule>(cloud, is, true),
+ Particle<molecule>(cloud, is, readFields),
Q_(tensor::zero),
v_(vector::zero),
a_(vector::zero),