dynamicMotionSolverListFvMesh: New mesh-motion solver supporting multiple moving regions

e.g. the motion of two counter-rotating AMI regions could be defined:

dynamicFvMesh   dynamicMotionSolverListFvMesh;

solvers
(
    rotor1
    {
        solver solidBody;

        cellZone        rotor1;

        solidBodyMotionFunction  rotatingMotion;
        rotatingMotionCoeffs
        {
            origin        (0 0 0);
            axis          (0 0 1);
            omega         6.2832; // rad/s
        }
    }

    rotor2
    {
        solver solidBody;

        cellZone        rotor2;

        solidBodyMotionFunction  rotatingMotion;
        rotatingMotionCoeffs
        {
            origin        (0 0 0);
            axis          (0 0 1);
            omega         -6.2832; // rad/s
        }
    }
);

Any combination of motion solvers may be selected but there is no special
handling of motion interaction; the motions are applied sequentially and
potentially cumulatively.

To support this new general framework the solidBodyMotionFvMesh and
multiSolidBodyMotionFvMesh dynamicFvMeshes have been converted into the
corresponding motionSolvers solidBody and multiSolidBody and the tutorials
updated to reflect this change e.g. the motion in the mixerVesselAMI2D tutorial
is now defined thus:

dynamicFvMesh   dynamicMotionSolverFvMesh;

solver solidBody;

solidBodyCoeffs
{
    cellZone        rotor;

    solidBodyMotionFunction  rotatingMotion;
    rotatingMotionCoeffs
    {
        origin        (0 0 0);
        axis          (0 0 1);
        omega         6.2832; // rad/s
    }
}
This commit is contained in:
Henry Weller
2016-12-01 15:57:15 +00:00
parent 85036f78ab
commit 1c687baa35
78 changed files with 739 additions and 418 deletions

View File

@ -0,0 +1,241 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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 "motionSolver.H"
#include "Time.H"
#include "polyMesh.H"
#include "dlLibraryTable.H"
#include "twoDPointCorrector.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(motionSolver, 0);
defineRunTimeSelectionTable(motionSolver, dictionary);
}
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
Foam::IOobject Foam::motionSolver::stealRegistration
(
const IOdictionary& dict
)
{
IOobject io(dict);
if (dict.registerObject())
{
// De-register if necessary
const_cast<IOdictionary&>(dict).checkOut();
io.registerObject() = true;
}
return io;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::motionSolver::motionSolver(const polyMesh& mesh)
:
IOdictionary
(
IOobject
(
"dynamicMeshDict",
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::AUTO_WRITE
)
),
mesh_(mesh)
{}
Foam::motionSolver::motionSolver
(
const polyMesh& mesh,
const IOdictionary& dict,
const word& type
)
:
IOdictionary(stealRegistration(dict), dict),
mesh_(mesh),
coeffDict_(dict.subDict(type + "Coeffs"))
{}
Foam::autoPtr<Foam::motionSolver> Foam::motionSolver::clone() const
{
NotImplemented;
return autoPtr<motionSolver>(nullptr);
}
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::motionSolver> Foam::motionSolver::New
(
const polyMesh& mesh,
const IOdictionary& solverDict
)
{
const word solverTypeName(solverDict.lookup("solver"));
Info<< "Selecting motion solver: " << solverTypeName << endl;
const_cast<Time&>(mesh.time()).libs().open
(
solverDict,
"motionSolverLibs",
dictionaryConstructorTablePtr_
);
if (!dictionaryConstructorTablePtr_)
{
FatalErrorInFunction
<< "solver table is empty"
<< exit(FatalError);
}
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(solverTypeName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown solver type "
<< solverTypeName << nl << nl
<< "Valid solver types are:" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<motionSolver>(cstrIter()(mesh, solverDict));
}
Foam::autoPtr<Foam::motionSolver> Foam::motionSolver::New(const polyMesh& mesh)
{
IOdictionary solverDict
(
IOobject
(
"dynamicMeshDict",
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::AUTO_WRITE
)
);
return New(mesh, solverDict);
}
Foam::motionSolver::iNew::iNew(const polyMesh& mesh)
:
mesh_(mesh)
{}
Foam::autoPtr<Foam::motionSolver> Foam::motionSolver::iNew::operator()
(
Istream& is
) const
{
dictionaryEntry dict(dictionary::null, is);
return motionSolver::New
(
mesh_,
IOdictionary
(
IOobject
(
dict.name() + ":meshSolver",
mesh_.time().constant(),
mesh_
),
dict
)
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::motionSolver::~motionSolver()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::pointField> Foam::motionSolver::newPoints()
{
solve();
return curPoints();
}
void Foam::motionSolver::twoDCorrectPoints(pointField& p) const
{
twoDPointCorrector::New(mesh_).correctPoints(p);
}
void Foam::motionSolver::updateMesh(const mapPolyMesh& mpm)
{}
bool Foam::motionSolver::writeObject
(
IOstream::streamFormat fmt,
IOstream::versionNumber ver,
IOstream::compressionType cmp
) const
{
return true;
}
bool Foam::motionSolver::read()
{
if (regIOobject::read())
{
coeffDict_ = subDict(type() + "Coeffs");
return true;
}
else
{
return false;
}
}
// ************************************************************************* //

View File

@ -0,0 +1,192 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / 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::motionSolver
Description
Virtual base class for mesh motion solver.
SourceFiles
motionSolver.C
\*---------------------------------------------------------------------------*/
#ifndef motionSolver_H
#define motionSolver_H
#include "IOdictionary.H"
#include "pointField.H"
#include "Time.H"
#include "polyMesh.H"
#include "dictionaryEntry.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Forward class declarations
class polyMesh;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class motionSolver Declaration
\*---------------------------------------------------------------------------*/
class motionSolver
:
public IOdictionary
{
// Private data
//- Reference to mesh
const polyMesh& mesh_;
//- Model coefficients dictionary
dictionary coeffDict_;
// Private Member Functions
//- De-register object if registered and assign to current
static IOobject stealRegistration(const IOdictionary& dict);
public:
//- Runtime type information
TypeName("motionSolver");
// Declare run-time constructor selection tables
declareRunTimeSelectionTable
(
autoPtr,
motionSolver,
dictionary,
(const polyMesh& mesh, const IOdictionary& dict),
(mesh, dict)
);
// Selectors
//- Select constructed from polyMesh
static autoPtr<motionSolver> New(const polyMesh&);
//- Select constructed from polyMesh and dictionary. If dictionary
// was registered this will 'steal' that registration.
static autoPtr<motionSolver> New(const polyMesh&, const IOdictionary&);
//- Class used for the construction of PtrLists of motionSolvers
class iNew
{
const polyMesh& mesh_;
mutable label index_;
public:
iNew(const polyMesh& mesh);
autoPtr<motionSolver> operator()(Istream& is) const;
};
// Constructors
//- Construct from polyMesh
motionSolver(const polyMesh& mesh);
//- Construct from polyMesh and dictionary and type.
motionSolver
(
const polyMesh& mesh,
const IOdictionary&,
const word& type
);
//- Clone function
virtual autoPtr<motionSolver> clone() const;
//- Destructor
virtual ~motionSolver();
// Member Functions
//- Return reference to mesh
const polyMesh& mesh() const
{
return mesh_;
}
//- Const access to the coefficients dictionary
const dictionary& coeffDict() const
{
return coeffDict_;
}
//- Provide new points for motion. Solves for motion
virtual tmp<pointField> newPoints();
//- Provide current points for motion. Uses current motion field
virtual tmp<pointField> curPoints() const = 0;
virtual void twoDCorrectPoints(pointField&) const;
//- Solve for motion
virtual void solve() = 0;
//- Update local data for geometry changes
virtual void movePoints(const pointField&) = 0;
//- Update local data for topology changes
virtual void updateMesh(const mapPolyMesh&) = 0;
//- Write state using given format, version and compression
virtual bool writeObject
(
IOstream::streamFormat fmt,
IOstream::versionNumber ver,
IOstream::compressionType cmp
) const;
//- Read dynamicMeshDict dictionary
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //