void Foam::sixDoFRigidBodyMotionSolver::solve()
{
const Time& t = mesh().time();
if (mesh().nPoints() != points0().size())
{
FatalErrorInFunction
<< "The number of points in the mesh seems to have changed." << endl
<< "In constant/polyMesh there are " << points0().size()
<< " points; in the current mesh there are " << mesh().nPoints()
<< " points." << exit(FatalError);
}
// Store the motion state at the beginning of the time-stepbool
bool firstIter = false;
if (curTimeIndex_ != t.timeIndex())
{
motion_.newTime();
curTimeIndex_ = t.timeIndex();
firstIter = true;
}
dimensionedVector g("g", dimAcceleration, Zero);
if (mesh().foundObject<uniformDimensionedVectorField>("g"))
{
g = mesh().lookupObject<uniformDimensionedVectorField>("g");
}
else if (coeffDict().found("g"))
{
coeffDict().lookup("g") >> g;
}
Foam::tmp<Foam::pointField>
Foam::displacementLinearMotionMotionSolver::curPoints() const
{
tmp<pointField> tcurPoints(new pointField(points0()));
pointField& curPoints = tcurPoints.ref();
const scalar t = mesh().time().value();
const scalar displacement = displacement_->value(t);
forAll(curPoints, i)
{
const scalar lambda =
(xFixed_ - (axis_ & curPoints[i]))/(xFixed_ - xMoving_);
if (lambda > 1)
{
curPoints[i] += axis_*displacement;
}
else if (lambda > 0)
{
curPoints[i] += axis_*lambda*displacement;
}
}
return tcurPoints;
}
Foam::tmp<Foam::pointField>
Foam::displacementLaplacianFvMotionSolver::curPoints() const
{
volPointInterpolation::New(fvMesh_).interpolate
(
cellDisplacement_,
pointDisplacement_
);
if (pointLocation_.valid())
{
if (debug)
{
Info<< "displacementLaplacianFvMotionSolver : applying "
<< " boundary conditions on " << pointLocation_().name()
<< " to new point location."
<< endl;
}
pointLocation_().primitiveFieldRef() =
points0()
+ pointDisplacement_.primitiveField();
pointLocation_().correctBoundaryConditions();
// Implement frozen points
if (frozenPointsZone_ != -1)
{
const pointZone& pz = fvMesh_.pointZones()[frozenPointsZone_];
forAll(pz, i)
{
pointLocation_()[pz[i]] = points0()[pz[i]];
}
}
twoDCorrectPoints(pointLocation_().primitiveFieldRef());
return tmp<pointField>(pointLocation_().primitiveField());
}
else
{
// Mark edges inside cellZone
forAll(isZoneEdge, edgeI)
{
if (isZoneEdge[edgeI])
{
allEdgeInfo[edgeI] = pointEdgeStructuredWalk
(
mesh().edges()[edgeI].centre(points0()), // location of data
vector::max, // not valid
0.0,
vector::zero
);
}
}
// Mark points inside cellZone.
// Note that we use points0, not mesh.points()
// so as not to accumulate errors.
forAll(isZonePoint, pointI)
{
if (isZonePoint[pointI])
{
allPointInfo[pointI] = pointEdgeStructuredWalk
(
points0()[pointI], // location of data
vector::max, // not valid
0.0,
vector::zero // passive data
);
}
}
// Find distance to starting point
void Foam::displacementLayeredMotionFvMotionSolver::walkStructured
(
const label cellZoneI,
const PackedBoolList& isZonePoint,
const PackedBoolList& isZoneEdge,
const labelList& seedPoints,
const vectorField& seedData,
scalarField& distance,
vectorField& data
) const
{
List<pointEdgeStructuredWalk> seedInfo(seedPoints.size());
forAll(seedPoints, i)
{
seedInfo[i] = pointEdgeStructuredWalk
(
points0()[seedPoints[i]], // location of data
points0()[seedPoints[i]], // previous location
0.0,
seedData[i]
);
}
Foam::tmp<Foam::pointField>
Foam::displacementSBRStressFvMotionSolver::curPoints() const
{
volPointInterpolation::New(fvMesh_).interpolate
(
cellDisplacement_,
pointDisplacement_
);
tmp<pointField> tcurPoints
(
points0() + pointDisplacement().primitiveField()
);
twoDCorrectPoints(tcurPoints.ref());
return tcurPoints;
}
const pointField&
solidBodyMotionDisplacementPointPatchVectorField::localPoints0() const
{
if (!localPoints0Ptr_.valid())
{
pointIOField points0
(
IOobject
(
"points",
this->db().time().constant(),
polyMesh::meshSubDir,
this->db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
localPoints0Ptr_.reset(new pointField(points0, patch().meshPoints()));
}
return localPoints0Ptr_();
}
void Foam::timeVaryingMappedFixedValuePointPatchField<Type>::checkTable()
{
// Initialise
if (startSampleTime_ == -1 && endSampleTime_ == -1)
{
const polyMesh& pMesh = this->patch().boundaryMesh().mesh()();
// Read the initial point position
pointField meshPts;
if (pMesh.pointsInstance() == pMesh.facesInstance())
{
meshPts = pointField(pMesh.points(), this->patch().meshPoints());
}
else
{
// Load points from facesInstance
if (debug)
{
Info<< "Reloading points0 from " << pMesh.facesInstance()
<< endl;
}
pointIOField points0
(
IOobject
(
"points",
pMesh.facesInstance(),
polyMesh::meshSubDir,
pMesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
meshPts = pointField(points0, this->patch().meshPoints());
}
pointIOField samplePoints
(
IOobject
(
"points",
this->db().time().constant(),
"boundaryData"/this->patch().name(),
this->db(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE,
false
)
);
// tbd: run-time selection
bool nearestOnly =
(
!mapMethod_.empty()
&& mapMethod_ != "planarInterpolation"
);
// Allocate the interpolator
mapperPtr_.reset
(
new pointToPointPlanarInterpolation
(
samplePoints,
meshPts,
perturb_,
nearestOnly
)
);
// Read the times for which data is available
const fileName samplePointsFile = samplePoints.filePath();
const fileName samplePointsDir = samplePointsFile.path();
sampleTimes_ = Time::findTimes(samplePointsDir);
if (debug)
{
Info<< "timeVaryingMappedFixedValuePointPatchField : In directory "
<< samplePointsDir << " found times "
<< pointToPointPlanarInterpolation::timeNames(sampleTimes_)
<< endl;
}
}
// Find current time in sampleTimes
label lo = -1;
label hi = -1;
bool foundTime = mapperPtr_().findTime
(
sampleTimes_,
startSampleTime_,
this->db().time().value(),
lo,
hi
);
if (!foundTime)
{
FatalErrorIn
(
"timeVaryingMappedFixedValuePointPatchField<Type>::checkTable"
) << "Cannot find starting sampling values for current time "
<< this->db().time().value() << nl
<< "Have sampling values for times "
<< pointToPointPlanarInterpolation::timeNames(sampleTimes_) << nl
<< "In directory "
<< this->db().time().constant()/"boundaryData"/this->patch().name()
<< "\n on patch " << this->patch().name()
<< " of field " << fieldTableName_
<< exit(FatalError);
}
// Update sampled data fields.
if (lo != startSampleTime_)
{
startSampleTime_ = lo;
if (startSampleTime_ == endSampleTime_)
{
// No need to reread since are end values
if (debug)
{
Pout<< "checkTable : Setting startValues to (already read) "
<< "boundaryData"
/this->patch().name()
/sampleTimes_[startSampleTime_].name()
<< endl;
}
startSampledValues_ = endSampledValues_;
startAverage_ = endAverage_;
}
else
{
if (debug)
{
Pout<< "checkTable : Reading startValues from "
<< "boundaryData"
/this->patch().name()
/sampleTimes_[lo].name()
<< endl;
}
// Reread values and interpolate
AverageIOField<Type> vals
(
IOobject
(
fieldTableName_,
this->db().time().constant(),
"boundaryData"
/this->patch().name()
/sampleTimes_[startSampleTime_].name(),
this->db(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE,
false
)
);
if (vals.size() != mapperPtr_().sourceSize())
{
FatalErrorIn
(
"timeVaryingMappedFixedValuePointPatchField<Type>::"
"checkTable()"
) << "Number of values (" << vals.size()
<< ") differs from the number of points ("
<< mapperPtr_().sourceSize()
<< ") in file " << vals.objectPath() << exit(FatalError);
}
startAverage_ = vals.average();
startSampledValues_ = mapperPtr_().interpolate(vals);
}
}
if (hi != endSampleTime_)
{
endSampleTime_ = hi;
if (endSampleTime_ == -1)
{
// endTime no longer valid. Might as well clear endValues.
if (debug)
{
Pout<< "checkTable : Clearing endValues" << endl;
}
endSampledValues_.clear();
}
else
{
if (debug)
{
Pout<< "checkTable : Reading endValues from "
<< "boundaryData"
/this->patch().name()
/sampleTimes_[endSampleTime_].name()
<< endl;
}
// Reread values and interpolate
AverageIOField<Type> vals
(
IOobject
(
fieldTableName_,
this->db().time().constant(),
"boundaryData"
/this->patch().name()
/sampleTimes_[endSampleTime_].name(),
this->db(),
IOobject::MUST_READ,
IOobject::AUTO_WRITE,
false
)
);
if (vals.size() != mapperPtr_().sourceSize())
{
FatalErrorIn
(
"timeVaryingMappedFixedValuePointPatchField<Type>::"
"checkTable()"
) << "Number of values (" << vals.size()
<< ") differs from the number of points ("
<< mapperPtr_().sourceSize()
<< ") in file " << vals.objectPath() << exit(FatalError);
}
endAverage_ = vals.average();
endSampledValues_ = mapperPtr_().interpolate(vals);
}
}
}
forAll(pz, i)
{
pointLocation_()[pz[i]] = points0()[pz[i]];
}
}
twoDCorrectPoints(pointLocation_().primitiveFieldRef());
return tmp<pointField>(pointLocation_().primitiveField());
}
else
{
tmp<pointField> tcurPoints
(
points0() + pointDisplacement_.primitiveField()
);
pointField& curPoints = tcurPoints.ref();
// Implement frozen points
if (frozenPointsZone_ != -1)
{
const pointZone& pz = fvMesh_.pointZones()[frozenPointsZone_];
forAll(pz, i)
{
curPoints[pz[i]] = points0()[pz[i]];
}
}
twoDCorrectPoints(curPoints);
forAll(pz, i)
{
pointLocation_()[pz[i]] = points0()[pz[i]];
}
}
twoDCorrectPoints(pointLocation_().internalField());
return tmp<pointField>(pointLocation_().internalField());
}
else
{
tmp<pointField> tcurPoints
(
points0() + pointDisplacement_.internalField()
);
// Implement frozen points
if (frozenPointsZone_ != -1)
{
const pointZone& pz = fvMesh_.pointZones()[frozenPointsZone_];
forAll(pz, i)
{
tcurPoints()[pz[i]] = points0()[pz[i]];
}
}
twoDCorrectPoints(tcurPoints());
Foam::sixDoFRigidBodyMotionSolver::sixDoFRigidBodyMotionSolver
(
const polyMesh& mesh,
const dictionary& dict
)
:
displacementMotionSolver(mesh, dict, typeName),
motion_
(
coeffDict(),
IOobject
(
"sixDoFRigidBodyMotionState",
mesh.time().timeName(),
"uniform",
mesh
).typeHeaderOk<IOdictionary>(true)
? IOdictionary
(
IOobject
(
"sixDoFRigidBodyMotionState",
mesh.time().timeName(),
"uniform",
mesh,
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
)
)
: coeffDict()
),
patches_(wordReList(coeffDict().lookup("patches"))),
patchSet_(mesh.boundaryMesh().patchSet(patches_)),
di_(readScalar(coeffDict().lookup("innerDistance"))),
do_(readScalar(coeffDict().lookup("outerDistance"))),
test_(coeffDict().lookupOrDefault<Switch>("test", false)),
rhoInf_(1.0),
rhoName_(coeffDict().lookupOrDefault<word>("rho", "rho")),
scale_
(
IOobject
(
"motionScale",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
pointMesh::New(mesh),
dimensionedScalar(dimless, 0)
),
curTimeIndex_(-1)
{
if (rhoName_ == "rhoInf")
{
rhoInf_ = readScalar(coeffDict().lookup("rhoInf"));
}
// Calculate scaling factor everywhere
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{
const pointMesh& pMesh = pointMesh::New(mesh);
pointPatchDist pDist(pMesh, patchSet_, points0());
// Scaling: 1 up to di then linear down to 0 at do away from patches
scale_.primitiveFieldRef() =
min
(
max
(
(do_ - pDist.primitiveField())/(do_ - di_),
scalar(0)
),
scalar(1)
);
// Convert the scale function to a cosine
scale_.primitiveFieldRef() =
min
(
max
(
0.5
- 0.5
*cos(scale_.primitiveField()
*Foam::constant::mathematical::pi),
scalar(0)
),
scalar(1)
);
pointConstraints::New(pMesh).constrain(scale_);
scale_.write();
}
}
Foam::tmp<Foam::pointField>
Foam::sixDoFRigidBodyMotionSolver::curPoints() const
{
return points0() + pointDisplacement_.primitiveField();
}
