rigidBodyMeshMotion: displacementMotionSolver for the mesh-motion of multiple articulated rigid-bodies

The motion of the bodies is integrated using the rigidBodyDynamics
library with joints, restraints and external forces.

The mesh-motion is interpolated using septernion averaging.

This development is sponsored by Carnegie Wave Energy Ltd.

src/dynamicMesh/Make/files

@@ -104,4 +104,7 @@ extrudePatchMesh/extrudePatchMesh.C
 polyMeshFilter/polyMeshFilterSettings.C
 polyMeshFilter/polyMeshFilter.C
 
+pointPatchDist/externalPointEdgePoint.C
+pointPatchDist/pointPatchDist.C
+
 LIB = $(FOAM_LIBBIN)/libdynamicMesh

src/dynamicMesh/pointPatchDist/externalPointEdgePoint.C

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-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 "externalPointEdgePoint.H"
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<
+(
+    Foam::Ostream& os,
+    const Foam::externalPointEdgePoint& wDist
+)
+{
+    return os << wDist.origin() << wDist.distSqr();
+}
+
+
+Foam::Istream& Foam::operator>>
+(
+    Foam::Istream& is,
+    Foam::externalPointEdgePoint& wDist
+)
+{
+    return is >> wDist.origin_ >> wDist.distSqr_;
+}
+
+
+// ************************************************************************* //

src/dynamicMesh/pointPatchDist/externalPointEdgePoint.H

@@ -0,0 +1,263 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-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::externalPointEdgePoint
+
+Description
+    Holds information regarding nearest wall point. Used in PointEdgeWave.
+    (so not standard FaceCellWave)
+    To be used in wall distance calculation.
+
+SourceFiles
+    externalPointEdgePointI.H
+    externalPointEdgePoint.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef externalPointEdgePoint_H
+#define externalPointEdgePoint_H
+
+#include "pointField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyPatch;
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class externalPointEdgePoint Declaration
+\*---------------------------------------------------------------------------*/
+
+class externalPointEdgePoint
+{
+    // Private data
+
+        //- Position of nearest wall center
+        point origin_;
+
+        //- Normal distance (squared) from point to origin
+        scalar distSqr_;
+
+
+    // Private Member Functions
+
+        //- Evaluate distance to point. Update distSqr, origin from whomever
+        //  is nearer pt. Return true if w2 is closer to point,
+        //  false otherwise.
+        template<class TrackingData>
+        inline bool update
+        (
+            const point&,
+            const externalPointEdgePoint& w2,
+            const scalar tol,
+            TrackingData& td
+        );
+
+        //- Combine current with w2. Update distSqr, origin if w2 has smaller
+        //  quantities and returns true.
+        template<class TrackingData>
+        inline bool update
+        (
+            const externalPointEdgePoint& w2,
+            const scalar tol,
+            TrackingData& td
+        );
+
+
+public:
+
+    //- Class used to pass data into container
+    class trackingData
+    {
+    public:
+        const pointField& points_;
+
+        trackingData(const pointField& points)
+        :
+            points_(points)
+        {}
+    };
+
+
+
+    // Constructors
+
+        //- Construct null
+        inline externalPointEdgePoint();
+
+        //- Construct from origin, distance
+        inline externalPointEdgePoint(const point&, const scalar);
+
+        //- Construct as copy
+        inline externalPointEdgePoint(const externalPointEdgePoint&);
+
+
+    // Member Functions
+
+        // Access
+
+            inline const point& origin() const;
+
+            inline scalar distSqr() const;
+
+
+        // Needed by PointEdgeWave
+
+            //- Check whether origin has been changed at all or
+            //  still contains original (invalid) value.
+            template<class TrackingData>
+            inline bool valid(TrackingData& td) const;
+
+            //- Check for identical geometrical data. Used for cyclics checking.
+            template<class TrackingData>
+            inline bool sameGeometry
+            (
+                const externalPointEdgePoint&,
+                const scalar tol,
+                TrackingData& td
+            ) const;
+
+            //- Convert origin to relative vector to leaving point
+            //  (= point coordinate)
+            template<class TrackingData>
+            inline void leaveDomain
+            (
+                const polyPatch& patch,
+                const label patchPointI,
+                const point& pos,
+                TrackingData& td
+            );
+
+            //- Convert relative origin to absolute by adding entering point
+            template<class TrackingData>
+            inline void enterDomain
+            (
+                const polyPatch& patch,
+                const label patchPointI,
+                const point& pos,
+                TrackingData& td
+            );
+
+            //- Apply rotation matrix to origin
+            template<class TrackingData>
+            inline void transform
+            (
+                const tensor& rotTensor,
+                TrackingData& td
+            );
+
+            //- Influence of edge on point
+            template<class TrackingData>
+            inline bool updatePoint
+            (
+                const polyMesh& mesh,
+                const label pointI,
+                const label edgeI,
+                const externalPointEdgePoint& edgeInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of different value on same point.
+            //  Merge new and old info.
+            template<class TrackingData>
+            inline bool updatePoint
+            (
+                const polyMesh& mesh,
+                const label pointI,
+                const externalPointEdgePoint& newPointInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of different value on same point.
+            //  No information about current position whatsoever.
+            template<class TrackingData>
+            inline bool updatePoint
+            (
+                const externalPointEdgePoint& newPointInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of point on edge.
+            template<class TrackingData>
+            inline bool updateEdge
+            (
+                const polyMesh& mesh,
+                const label edgeI,
+                const label pointI,
+                const externalPointEdgePoint& pointInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Equivalent to operator== with TrackingData
+            template<class TrackingData>
+            inline bool equal
+            (
+                const externalPointEdgePoint&,
+                TrackingData& td
+            ) const;
+
+
+    // Member Operators
+
+        // Needed for List IO
+        inline bool operator==(const externalPointEdgePoint&) const;
+        inline bool operator!=(const externalPointEdgePoint&) const;
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<<(Ostream&, const externalPointEdgePoint&);
+        friend Istream& operator>>(Istream&, externalPointEdgePoint&);
+};
+
+
+//- Data associated with externalPointEdgePoint type are contiguous
+template<>
+inline bool contiguous<externalPointEdgePoint>()
+{
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "externalPointEdgePointI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/dynamicMesh/pointPatchDist/externalPointEdgePointI.H

@@ -0,0 +1,324 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-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 "polyMesh.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::update
+(
+    const point& pt,
+    const externalPointEdgePoint& w2,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    scalar dist2 = magSqr(pt - w2.origin());
+
+    if (!valid(td))
+    {
+        // current not yet set so use any value
+        distSqr_ = dist2;
+        origin_ = w2.origin();
+
+        return true;
+    }
+
+    scalar diff = distSqr_ - dist2;
+
+    if (diff < 0)
+    {
+        // already nearer to pt
+        return false;
+    }
+
+    if ((diff < SMALL) || ((distSqr_ > SMALL) && (diff/distSqr_ < tol)))
+    {
+        // don't propagate small changes
+        return false;
+    }
+    else
+    {
+        // update with new values
+        distSqr_ = dist2;
+        origin_ = w2.origin();
+
+        return true;
+    }
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::update
+(
+    const externalPointEdgePoint& w2,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    if (!valid(td))
+    {
+        // current not yet set so use any value
+        distSqr_ = w2.distSqr();
+        origin_ = w2.origin();
+
+        return true;
+    }
+
+    scalar diff = distSqr_ - w2.distSqr();
+
+    if (diff < 0)
+    {
+        // already nearer to pt
+        return false;
+    }
+
+    if ((diff < SMALL) || ((distSqr_ > SMALL) && (diff/distSqr_ < tol)))
+    {
+        // don't propagate small changes
+        return false;
+    }
+    else
+    {
+        // update with new values
+        distSqr_ =  w2.distSqr();
+        origin_ = w2.origin();
+
+        return true;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline Foam::externalPointEdgePoint::externalPointEdgePoint()
+:
+    origin_(point::max),
+    distSqr_(GREAT)
+{}
+
+
+inline Foam::externalPointEdgePoint::externalPointEdgePoint
+(
+    const point& origin,
+    const scalar distSqr
+)
+:
+    origin_(origin),
+    distSqr_(distSqr)
+{}
+
+
+inline Foam::externalPointEdgePoint::externalPointEdgePoint
+(
+    const externalPointEdgePoint& wpt
+)
+:
+    origin_(wpt.origin()),
+    distSqr_(wpt.distSqr())
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::point& Foam::externalPointEdgePoint::origin() const
+{
+    return origin_;
+}
+
+
+inline Foam::scalar Foam::externalPointEdgePoint::distSqr() const
+{
+    return distSqr_;
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::valid(TrackingData& td) const
+{
+    return origin_ != point::max;
+}
+
+
+// Checks for cyclic points
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::sameGeometry
+(
+    const externalPointEdgePoint& w2,
+    const scalar tol,
+    TrackingData& td
+) const
+{
+    scalar diff = Foam::mag(distSqr() - w2.distSqr());
+
+    if (diff < SMALL)
+    {
+        return true;
+    }
+    else
+    {
+        if ((distSqr() > SMALL) && ((diff/distSqr()) < tol))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+
+template<class TrackingData>
+inline void Foam::externalPointEdgePoint::leaveDomain
+(
+    const polyPatch& patch,
+    const label patchPointI,
+    const point& coord,
+    TrackingData& td
+)
+{
+    origin_ -= coord;
+}
+
+
+template<class TrackingData>
+inline void Foam::externalPointEdgePoint::transform
+(
+    const tensor& rotTensor,
+    TrackingData& td
+)
+{
+    origin_ = Foam::transform(rotTensor, origin_);
+}
+
+
+template<class TrackingData>
+inline void Foam::externalPointEdgePoint::enterDomain
+(
+    const polyPatch& patch,
+    const label patchPointI,
+    const point& coord,
+    TrackingData& td
+)
+{
+    // back to absolute form
+    origin_ += coord;
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::updatePoint
+(
+    const polyMesh& mesh,
+    const label pointI,
+    const label edgeI,
+    const externalPointEdgePoint& edgeInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return update(td.points_[pointI], edgeInfo, tol, td);
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::updatePoint
+(
+    const polyMesh& mesh,
+    const label pointI,
+    const externalPointEdgePoint& newPointInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return update(td.points_[pointI], newPointInfo, tol, td);
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::updatePoint
+(
+    const externalPointEdgePoint& newPointInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return update(newPointInfo, tol, td);
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::updateEdge
+(
+    const polyMesh& mesh,
+    const label edgeI,
+    const label pointI,
+    const externalPointEdgePoint& pointInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    const edge& e = mesh.edges()[edgeI];
+    return update(e.centre(td.points_), pointInfo, tol, td);
+}
+
+
+template<class TrackingData>
+inline bool Foam::externalPointEdgePoint::equal
+(
+    const externalPointEdgePoint& rhs,
+    TrackingData& td
+) const
+{
+    return operator==(rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline bool Foam::externalPointEdgePoint::operator==
+(
+    const Foam::externalPointEdgePoint& rhs
+)
+const
+{
+    return (origin() == rhs.origin()) && (distSqr() == rhs.distSqr());
+}
+
+
+inline bool Foam::externalPointEdgePoint::operator!=
+(
+    const Foam::externalPointEdgePoint& rhs
+)
+const
+{
+    return !(*this == rhs);
+}
+
+
+// ************************************************************************* //

src/dynamicMesh/pointPatchDist/pointPatchDist.C

@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-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 "pointPatchDist.H"
+#include "externalPointEdgePoint.H"
+#include "pointMesh.H"
+#include "PointEdgeWave.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::pointPatchDist::pointPatchDist
+(
+    const pointMesh& pMesh,
+    const labelHashSet& patchIDs,
+    const pointField& points
+)
+:
+    pointScalarField
+    (
+        IOobject
+        (
+            "pointDistance",
+            pMesh.db().time().timeName(),
+            pMesh.db()
+        ),
+        pMesh,
+        dimensionedScalar("y", dimLength, GREAT)
+    ),
+    points_(points),
+    patchIDs_(patchIDs),
+    nUnset_(0)
+{
+    correct();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::pointPatchDist::~pointPatchDist()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::pointPatchDist::correct()
+{
+    const pointBoundaryMesh& pbm = mesh().boundary();
+
+    label nPoints = 0;
+
+    forAllConstIter(labelHashSet, patchIDs_, iter)
+    {
+        label patchI = iter.key();
+        nPoints += pbm[patchI].meshPoints().size();
+    }
+
+    externalPointEdgePoint::trackingData td(points_);
+
+    // Set initial changed points to all the patch points(if patch present)
+    List<externalPointEdgePoint> wallInfo(nPoints);
+    labelList wallPoints(nPoints);
+    nPoints = 0;
+
+    forAllConstIter(labelHashSet, patchIDs_, iter)
+    {
+        label patchI = iter.key();
+        // Retrieve the patch now we have its index in patches.
+
+        const labelList& mp = pbm[patchI].meshPoints();
+
+        forAll(mp, ppI)
+        {
+            label meshPointI = mp[ppI];
+            wallPoints[nPoints] = meshPointI;
+            wallInfo[nPoints] = externalPointEdgePoint
+            (
+                td.points_[meshPointI],
+                0.0
+            );
+            nPoints++;
+        }
+    }
+
+    // Current info on points
+    List<externalPointEdgePoint> allPointInfo(mesh()().nPoints());
+
+    // Current info on edges
+    List<externalPointEdgePoint> allEdgeInfo(mesh()().nEdges());
+
+    PointEdgeWave
+    <
+        externalPointEdgePoint,
+        externalPointEdgePoint::trackingData
+    > wallCalc
+    (
+        mesh()(),
+        wallPoints,
+        wallInfo,
+
+        allPointInfo,
+        allEdgeInfo,
+        mesh().globalData().nTotalPoints(), // max iterations
+        td
+    );
+
+    pointScalarField& psf = *this;
+
+
+    forAll(allPointInfo, pointI)
+    {
+        if (allPointInfo[pointI].valid(td))
+        {
+            psf[pointI] = Foam::sqrt(allPointInfo[pointI].distSqr());
+        }
+        else
+        {
+            nUnset_++;
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/dynamicMesh/pointPatchDist/pointPatchDist.H

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-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::pointPatchDist
+
+Description
+    Calculation of distance to nearest patch for all points
+
+SourceFiles
+    pointPatchDist.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef pointPatchDist_H
+#define pointPatchDist_H
+
+#include "pointFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class pointMesh;
+
+/*---------------------------------------------------------------------------*\
+                          Class pointPatchDist Declaration
+\*---------------------------------------------------------------------------*/
+
+class pointPatchDist
+:
+    public pointScalarField
+{
+
+private:
+
+    // Private Member Data
+
+        //- Reference to pointField
+        const pointField& points_;
+
+        //- Set of patch IDs
+        const labelHashSet patchIDs_;
+
+        //- Number of unset points
+        label nUnset_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        pointPatchDist(const pointPatchDist&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const pointPatchDist&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from mesh and set of patches
+        pointPatchDist
+        (
+            const pointMesh& pMesh,
+            const labelHashSet& patchIDs,
+            const pointField& points
+        );
+
+
+    //- Destructor
+    virtual ~pointPatchDist();
+
+
+    // Member Functions
+
+        const pointScalarField& y() const
+        {
+            return *this;
+        }
+
+        label nUnset() const
+        {
+            return nUnset_;
+        }
+
+        //- Correct for mesh geom/topo changes
+        void correct();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //