Commit 942338b0 authored by Henry Weller's avatar Henry Weller
Browse files

sixDoFRigidBodyDisplacementPointPatchVectorField,...

sixDoFRigidBodyDisplacementPointPatchVectorField, uncoupledSixDoFRigidBodyDisplacementPointPatchVectorField: removed

These legacy boundary conditions are no longer needed and have been superseded
by the more flexible sixDoFRigidBodyMotion and rigidBodyMotion solvers.  See tutorials:

incompressible/pimpleDyMFoam/wingMotion/wingMotion2D_pimpleDyMFoam
multiphase/interDyMFoam/RAS/DTCHull
multiphase/interDyMFoam/RAS/floatingObject

Resolves bug-report https://bugs.openfoam.org/view.php?id=2487
parent 7f5c1350
......@@ -24,9 +24,6 @@ $(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
......
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / 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
// ************************************************************************* //
/*---------------------------------------------------------------------------*\
========= |
\\ / 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