56 <<
"Attempting to recompute points residing within control boxes"
73 Info<<
"Control Points bounds \n"
74 <<
"\tX1 : (" << lowerX <<
" " << upperX <<
")\n"
75 <<
"\tX2 : (" << lowerY <<
" " << upperY <<
")\n"
76 <<
"\tX3 : (" << lowerZ <<
" " << upperZ <<
")\n" <<
endl;
81 const vector& pointI = meshPoints[pI];
84 pointI.
x() >= lowerX && pointI.
x() <= upperX
85 && pointI.
y() >= lowerY && pointI.
y() <= upperY
86 && pointI.
z() >= lowerZ && pointI.
z() <= upperZ
90 reverseMap[pI] =
count;
99 Info<<
"Initially found " <<
count <<
" points inside control boxes"
109 scalar timeBef = mesh_.time().elapsedCpuTime();
111 if (parametricCoordinatesPtr_)
114 <<
"Attempting to recompute parametric coordinates"
119 labelList& reverseMap = reverseMapPtr_();
121 parametricCoordinatesPtr_.reset
127 "parametricCoordinates" + name_,
128 mesh_.time().timeName(),
137 vectorField& paramCoors = parametricCoordinatesPtr_().primitiveFieldRef();
142 parametricCoordinatesPtr_().typeHeaderOk<pointVectorField>(
true)
150 Info<<
"Reading parametric coordinates from file" <<
endl;
151 IOobject& header = parametricCoordinatesPtr_().ref();
152 parametricCoordinatesPtr_() =
166 const label globalPointIndex = map[pI];
169 actualMap[curIndex] = map[pI];
170 reverseMap[globalPointIndex] = curIndex;
175 reverseMap[globalPointIndex] = -1;
183 Info<<
"Read non-zero parametric coordinates for " << curIndex
184 <<
" points" <<
endl;
193 scalar minX1 =
min(cps_.component(0));
194 scalar maxX1 =
max(cps_.component(0));
195 scalar minX2 =
min(cps_.component(1));
196 scalar maxX2 =
max(cps_.component(1));
197 scalar minX3 =
min(cps_.component(2));
198 scalar maxX3 =
max(cps_.component(2));
200 scalar oneOverDenomX(1./(maxX1 - minX1));
201 scalar oneOverDenomY(1./(maxX2 - minX2));
202 scalar oneOverDenomZ(1./(maxX3 - minX3));
206 const label globalPI = map[pI];
207 paramCoors[globalPI].x() = (
points[pI].x() - minX1)*oneOverDenomX;
208 paramCoors[globalPI].y() = (
points[pI].y() - minX2)*oneOverDenomY;
209 paramCoors[globalPI].z() = (
points[pI].z() - minX3)*oneOverDenomZ;
214 boolList dropOffPoints(map.size(),
false);
215 label nDropedPoints(0);
223 Info<<
"Mapping of mesh points to parametric space for box " << name_
226 label maxIterNeeded(0);
230 label nBoundIters(0);
231 vector res(GREAT, GREAT, GREAT);
234 const label globalPI = map[pI];
235 vector& uVec = paramCoors[globalPI];
236 vector& coorPointI = splinesBasedCoors[pI];
237 uVec += ((
inv(JacobianUVW(uVec))) & (
points[pI] - coorPointI));
245 if (nBoundIters > nMaxBound_)
247 dropOffPoints[pI] =
true;
268 <<
"Mapping to parametric space for point " << pI
269 <<
" failed." <<
endl
270 <<
"Residual after " << maxIter_ + 1 <<
" iterations : "
272 <<
"parametric coordinates " << paramCoors[map[pI]]
274 <<
"Local system coordinates " <<
points[pI] <<
endl
275 <<
"Threshold residual per direction : " << tolerance_
278 maxIterNeeded =
max(maxIterNeeded, iter);
282 label nParameterizedPoints = map.size() - nDropedPoints;
288 map.
setSize(nParameterizedPoints);
293 if (!dropOffPoints[pI])
295 map[curIndex] = mapOld[pI];
296 reverseMap[mapOld[pI]] = curIndex;
302 reverseMap[mapOld[pI]] = -1;
308 Info<<
"Found " << nDropedPoints
309 <<
" to discard from morphing boxes" <<
endl;
310 Info<<
"Keeping " << nParameterizedPoints
311 <<
" parameterized points in boxes" <<
endl;
314 scalar maxDiff(-GREAT);
315 forAll(splinesBasedCoors, pI)
318 mag(splinesBasedCoors[pI] - localSystemCoordinates_[map[pI]]);
325 scalar timeAft = mesh_.time().elapsedCpuTime();
326 Info<<
"\tMapping completed in " << timeAft - timeBef <<
" seconds"
328 Info<<
"\tMax iterations per point needed to compute parametric "
330 << maxIterNeeded <<
endl;
331 Info<<
"\tMax difference between original mesh points and "
332 <<
"parameterized ones "
344 computeParametricCoordinates(
points);
355 bool boundPoint(
false);
357 if (vec.
x() < scalar(0))
362 if (vec.
y() < scalar(0))
367 if (vec.
z() < scalar(0))
396 mkDir(mesh_.time().globalPath()/
"optimisation"/cpsFolder_);
403 label nCPs = cps_.size();
404 activeControlPoints_ =
boolList(nCPs,
true);
405 activeDesignVariables_ =
boolList(3*nCPs,
true);
408 confineBoundaryControlPoints();
411 continuityRealatedConfinement();
414 confineControlPointsDirections();
418 forAll(activeControlPoints_, cpI)
422 !activeDesignVariables_[3*cpI]
423 && !activeDesignVariables_[3*cpI + 1]
424 && !activeDesignVariables_[3*cpI + 2]
427 activeControlPoints_[cpI] =
false;
435 const label nCPsU = basisU_.nCPs();
436 const label nCPsV = basisV_.nCPs();
437 const label nCPsW = basisW_.nCPs();
440 if (confineBoundaryControlPoints_)
443 for (label iCPw = 0; iCPw < nCPsW; iCPw += nCPsW - 1)
445 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
447 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
449 confineControlPoint(getCPID(iCPu, iCPv, iCPw));
454 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
456 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
458 for (label iCPu = 0; iCPu < nCPsU; iCPu += nCPsU - 1)
460 confineControlPoint(getCPID(iCPu, iCPv, iCPw));
465 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
467 for (label iCPv = 0; iCPv < nCPsV; iCPv += nCPsV - 1)
469 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
471 confineControlPoint(getCPID(iCPu, iCPv, iCPw));
481 const label nCPsU = basisU_.nCPs();
482 const label nCPsV = basisV_.nCPs();
483 const label nCPsW = basisW_.nCPs();
487 forAll(confineUMinCPs_, iCPu)
489 const boolVector& confineSlice = confineUMinCPs_[iCPu];
491 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
493 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
495 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
500 forAll(confineUMaxCPs_, sliceI)
502 const boolVector& confineSlice = confineUMaxCPs_[sliceI];
503 label iCPu = nCPsU - 1 - sliceI;
505 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
507 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
509 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
516 forAll(confineVMinCPs_, iCPv)
518 const boolVector& confineSlice = confineVMinCPs_[iCPv];
520 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
522 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
524 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
529 forAll(confineVMaxCPs_, sliceI)
531 const boolVector& confineSlice = confineVMaxCPs_[sliceI];
532 label iCPv = nCPsV - 1 - sliceI;
534 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
536 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
538 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
545 forAll(confineWMinCPs_, iCPw)
547 const boolVector& confineSlice = confineWMinCPs_[iCPw];
549 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
551 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
553 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
558 forAll(confineWMaxCPs_, sliceI)
560 const boolVector& confineSlice = confineWMaxCPs_[sliceI];
561 label iCPw = nCPsW - 1 - sliceI;
563 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
565 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
567 confineControlPoint(getCPID(iCPu, iCPv, iCPw), confineSlice);
576 for (label cpI = 0; cpI < cps_.size(); ++cpI)
578 if (confineUMovement_) activeDesignVariables_[3*cpI] =
false;
579 if (confineVMovement_) activeDesignVariables_[3*cpI + 1] =
false;
580 if (confineWMovement_) activeDesignVariables_[3*cpI + 2] =
false;
587 if (cpI < 0 || cpI > cps_.size() -1)
590 <<
"Attempted to confine control point movement for a control point "
591 <<
" ID which is out of bounds"
596 activeDesignVariables_[3*cpI] =
false;
597 activeDesignVariables_[3*cpI + 1] =
false;
598 activeDesignVariables_[3*cpI + 2] =
false;
609 if (cpI < 0 || cpI > cps_.size() -1)
612 <<
"Attempted to confine control point movement for a control point "
613 <<
" ID which is out of bounds"
618 if (confineDirections.
x()) activeDesignVariables_[3*cpI] =
false;
619 if (confineDirections.
y()) activeDesignVariables_[3*cpI + 1] =
false;
620 if (confineDirections.
z()) activeDesignVariables_[3*cpI + 2] =
false;
631 bool computeParamCoors
645 reverseMapPtr_(
nullptr),
646 parametricCoordinatesPtr_(
nullptr),
647 localSystemCoordinates_(mesh_.nPoints(),
Zero),
652 "confineUMovement", {{
"confineX1movement", 1912}}, false
659 "confineVMovement", {{
"confineX2movement", 1912}}, false
666 "confineWMovement", {{
"confineX3movement", 1912}}, false
669 confineBoundaryControlPoints_
677 "confineUMinCPs", {{
"boundUMinCPs", 1912}}, boolVectorList()
684 "confineUMaxCPs", {{
"boundUMaxCPs", 1912}}, boolVectorList()
691 "confineVMinCPs", {{
"boundVMinCPs", 1912}}, boolVectorList()
698 "confineVMaxCPs", {{
"boundVMaxCPs", 1912}}, boolVectorList()
705 "confineWMinCPs", {{
"boundWMinCPs", 1912}}, boolVectorList()
712 "confineWMaxCPs", {{
"boundWMaxCPs", 1912}}, boolVectorList()
715 activeControlPoints_(0),
716 activeDesignVariables_(0),
717 cpsFolder_(
"controlPoints"),
726 (confineUMinCPs_.size() + confineUMaxCPs_.size() >= basisU_.nCPs())
727 || (confineVMinCPs_.size() + confineVMaxCPs_.size() >= basisV_.nCPs())
728 || (confineWMinCPs_.size() + confineWMaxCPs_.size() >= basisW_.nCPs())
732 <<
"Number of control point slices to be kept frozen at "
733 <<
"the boundaries is invalid \n"
734 <<
"Number of control points in u " << basisU_.nCPs() <<
"\n"
735 <<
"Number of control points in v " << basisV_.nCPs() <<
"\n"
736 <<
"Number of control points in w " << basisW_.nCPs() <<
"\n"
742 determineActiveDesignVariablesAndPoints();
753 bool computeParamCoors
758 Info<<
"NURBS3DVolume type : " << modelType <<
endl;
760 auto* ctorPtr = dictionaryConstructorTable(modelType);
769 *dictionaryConstructorTablePtr_
786 const label degreeU = basisU_.degree();
787 const label degreeV = basisV_.degree();
788 const label degreeW = basisW_.degree();
790 const label nCPsU = basisU_.nCPs();
791 const label nCPsV = basisV_.nCPs();
792 const label nCPsW = basisW_.nCPs();
796 for (label iCPw = 0; iCPw < nCPsW; ++iCPw)
798 const scalar basisW(basisW_.basisValue(iCPw, degreeW, w));
799 for (label iCPv = 0; iCPv < nCPsV; ++iCPv)
801 const scalar basisVW = basisW*basisV_.basisValue(iCPv, degreeV, v);
802 for (label iCPu = 0; iCPu < nCPsU; ++iCPu)
805 cps_[getCPID(iCPu, iCPv, iCPw)]
806 *basisU_.basisDerivativeU(iCPu, degreeU, u)
823 const label degreeU = basisU_.degree();
824 const label degreeV = basisV_.degree();
825 const label degreeW = basisW_.degree();
827 const label nCPsU = basisU_.nCPs();
828 const label nCPsV = basisV_.nCPs();
829 const label nCPsW = basisW_.nCPs();
833 for (label iCPw = 0; iCPw < nCPsW; ++iCPw)
835 const scalar basisW(basisW_.basisValue(iCPw, degreeW, w));
836 for (label iCPv = 0; iCPv < nCPsV; ++iCPv)
838 const scalar basisWDeriV =
839 basisW*basisV_.basisDerivativeU(iCPv, degreeV, v);
840 for (label iCPu = 0; iCPu < nCPsU; ++iCPu)
843 cps_[getCPID(iCPu, iCPv, iCPw)]
844 *basisU_.basisValue(iCPu, degreeU, u)
861 const label degreeU = basisU_.degree();
862 const label degreeV = basisV_.degree();
863 const label degreeW = basisW_.degree();
865 const label nCPsU = basisU_.nCPs();
866 const label nCPsV = basisV_.nCPs();
867 const label nCPsW = basisW_.nCPs();
871 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
873 const scalar derivW(basisW_.basisDerivativeU(iCPw, degreeW, w));
874 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
876 const scalar derivWBasisV =
877 derivW*basisV_.basisValue(iCPv, degreeV, v);
878 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
881 cps_[getCPID(iCPu, iCPv, iCPw)]
882 *basisU_.basisValue(iCPu, degreeU, u)
897 const scalar u = uVector.
x();
898 const scalar v = uVector.
y();
899 const scalar w = uVector.
z();
901 vector uDeriv = volumeDerivativeU(u, v, w);
902 vector vDeriv = volumeDerivativeV(u, v, w);
903 vector wDeriv = volumeDerivativeW(u, v, w);
927 const scalar u = uVector.
x();
928 const scalar v = uVector.
y();
929 const scalar w = uVector.
z();
931 const label nCPsU = basisU_.nCPs();
932 const label nCPsV = basisV_.nCPs();
934 const label degreeU = basisU_.degree();
935 const label degreeV = basisV_.degree();
936 const label degreeW = basisW_.degree();
938 label iCPw = cpI/label(nCPsU*nCPsV);
939 label iCPv = (cpI - iCPw*nCPsU*nCPsV)/nCPsU;
940 label iCPu = (cpI - iCPw*nCPsU*nCPsV - iCPv*nCPsU);
946 basisU_.basisValue(iCPu, degreeU, u)
947 *basisV_.basisValue(iCPv, degreeV, v)
948 *basisW_.basisValue(iCPw, degreeW, w);
963 const vectorField& parametricCoordinates = getParametricCoordinates();
965 forAll(controlPointDerivs, cpI)
967 forAll(sensitivityPatchIDs, pI)
969 const label patchI = sensitivityPatchIDs[pI];
976 const label whichPointInBox = reverseMapPtr_()[
globalIndex];
980 if (whichPointInBox != -1)
982 controlPointDerivs[cpI] +=
1001 return controlPointDerivs;
1012 computeControlPointSensitivities
1030 const vectorField& parametricCoordinates = getParametricCoordinates();
1034 const labelList& reverseMap = reverseMapPtr_();
1036 forAll(controlPointDerivs, cpI)
1038 forAll(sensitivityPatchIDs, pI)
1040 const label patchI = sensitivityPatchIDs[pI];
1042 const label patchStart =
patch.start();
1048 const face& fGlobal = mesh_.faces()[fI + patchStart];
1055 const label whichPointInBox = reverseMap[
globalIndex];
1058 if (whichPointInBox != -1)
1062 facePointDerivs[pI] =
1064 * volumeDerivativeCP
1079 controlPointDerivs[cpI] += patchSens[fI] & fCtrs_d;
1087 return controlPointDerivs;
1101 const vectorField& parametricCoordinates = getParametricCoordinates();
1105 const labelList& reverseMap = reverseMapPtr_();
1108 const label patchStart =
patch.start();
1112 const face& fGlobal = mesh_.faces()[fI + patchStart];
1119 const label whichPointInBox = reverseMap[
globalIndex];
1122 if (whichPointInBox != -1)
1126 facePointDerivs[pI] =
1142 cpSens += faceSens[fI] & fCtrs_d;
1155 bool DimensionedNormalSens
1165 const label patchStart = ppatch.
start();
1166 const labelList& reverseMap = reverseMapPtr_();
1169 const vectorField& parametricCoordinates = getParametricCoordinates();
1174 const face& fGlobal = mesh_.faces()[fI + patchStart];
1181 const label whichPointInBox = reverseMap[
globalIndex];
1184 if (whichPointInBox != -1)
1188 facePointDerivs[pI] =
1206 if (DimensionedNormalSens)
1208 dndbSens[fI] = dNdbSens[1];
1212 dndbSens[fI] = dNdbSens[2];
1227 const vectorField& parametricCoordinates = getParametricCoordinates();
1235 auto& dxdb = tdxdb.ref();
1240 const label whichPointInBox = reverseMapPtr_()[
globalIndex];
1243 if (whichPointInBox != -1)
1266 const vectorField& parametricCoordinates = getParametricCoordinates();
1270 const label patchStart =
patch.start();
1274 auto& dxdb = tdxdb.ref();
1281 const face& fGlobal = mesh_.faces()[fI + patchStart];
1288 const label whichPointInBox = reverseMapPtr_()[
globalIndex];
1291 if (whichPointInBox != -1)
1295 facePointDerivs[pI] =
1322 const label
nPoints = mapPtr_().size();
1324 auto&
points = tpoints.ref();
1328 const label globalPI = mapPtr_()[pI];
1341 const label degreeU = basisU_.degree();
1342 const label degreeV = basisV_.degree();
1343 const label degreeW = basisW_.degree();
1345 const label nCPsU = basisU_.nCPs();
1346 const label nCPsV = basisV_.nCPs();
1347 const label nCPsW = basisW_.nCPs();
1349 const scalar u = uVector.
x();
1350 const scalar v = uVector.
y();
1351 const scalar w = uVector.
z();
1354 for (label iCPw = 0; iCPw < nCPsW; iCPw++)
1356 const scalar basisW(basisW_.basisValue(iCPw, degreeW, w));
1357 for (label iCPv = 0; iCPv < nCPsV; iCPv++)
1359 const scalar basisVW =
1360 basisW*basisV_.basisValue(iCPv, degreeV, v);
1361 for (label iCPu = 0; iCPu < nCPsU; iCPu++)
1364 cps_[getCPID(iCPu, iCPv, iCPw)]
1365 *basisU_.basisValue(iCPu, degreeU, u)
1381 const vectorField& paramCoors = getParametricCoordinates();
1385 cps_ += controlPointsMovement;
1386 writeCps(
"cpsBsplines"+mesh_.time().timeName());
1391 const vectorField& parameterizedPoints = tparameterizedPoints();
1398 forAll(parameterizedPoints, pI)
1400 newPoints[map[pI]] = transformPointToCartesian(parameterizedPoints[pI]);
1404 updateLocalCoordinateSystem(newPoints);
1406 <<
"Max mesh movement equal to "
1420 const vectorField& paramCoors = getParametricCoordinates();
1423 cps_ += controlPointsMovement;
1425 writeCps(
"cpsBsplines"+mesh_.time().timeName());
1433 for (
const label patchI : patchesToBeMoved)
1440 const label whichPointInBox = reverseMapPtr_()[
globalIndex];
1443 if (whichPointInBox != -1)
1446 transformPointToCartesian
1458 updateLocalCoordinateSystem(newPoints);
1460 <<
"Max mesh movement equal to "
1474 const label nCPsU = basisU_.nCPs();
1475 const label nCPsV = basisV_.nCPs();
1477 return k*nCPsU*nCPsV + j*nCPsU + i;
1483 if (cps_.size() != newCps.size())
1486 <<
"Attempting to replace control points with a set of "
1499 forAll(controlPointsMovement, cpI)
1501 if (!activeDesignVariables_[3*cpI])
1503 controlPointsMovement[cpI].x() =
Zero;
1505 if (!activeDesignVariables_[3*cpI + 1])
1507 controlPointsMovement[cpI].y() =
Zero;
1509 if (!activeDesignVariables_[3*cpI + 2])
1511 controlPointsMovement[cpI].z() =
Zero;
1526 const vectorField& paramCoors = getParametricCoordinates();
1528 cps_ += controlPointsMovement;
1530 scalar maxDisplacement(
Zero);
1531 for (
const label patchI : patchesToBeMoved)
1538 const label whichPointInBox = reverseMapPtr_()[
globalIndex];
1541 if (whichPointInBox != -1)
1544 transformPointToCartesian
1563 return maxDisplacement;
1571 findPointsInBox(localSystemCoordinates_);
1575 new vectorField(localSystemCoordinates_, mapPtr_())
1586 findPointsInBox(localSystemCoordinates_);
1595 if (!reverseMapPtr_)
1597 findPointsInBox(localSystemCoordinates_);
1600 return reverseMapPtr_();
1607 if (!parametricCoordinatesPtr_)
1613 findPointsInBox(localSystemCoordinates_);
1615 computeParametricCoordinates(getPointsInBox()());
1618 return parametricCoordinatesPtr_();
1625 const vectorField& parametricCoordinates = getParametricCoordinates();
1635 mesh_.time().timeName(),
1671 const vectorField& parametricCoordinates = getParametricCoordinates();
1681 mesh_.time().timeName(),
1712 const label cellI = pointCellsI[cI];
1713 DxDb[cellI] += C_d[cI] & pointDxDb;
1718 forAll(mesh_.boundary(), pI)
1721 if (!isA<coupledFvPatch>(
patch))
1736 label nU(basisU_.nCPs());
1743 nU = (nU - 1)/2 + 1;
1751 label nV(basisV_.nCPs());
1758 nV = (nV - 1)/2 + 1;
1766 label nW(basisW_.nCPs());
1773 nW = (nW - 1)/2 + 1;
1785 const label nCPsU = basisU_.nCPs();
1786 const label nCPsV = basisV_.nCPs();
1791 forAll(cpsInCartesian, cpI)
1793 cpsInCartesian[cpI] = transformPointToCartesian(cps_[cpI]);
1797 Info<<
"Writing control point positions to file" <<
endl;
1801 OFstream cpsFile(
"optimisation"/cpsFolder_/name_ + baseName +
".csv");
1804 <<
"\"Points : 0\", \"Points : 1\", \"Points : 2\","
1805 <<
"\"i\", \"j\", \"k\","
1806 <<
"\"active : 0\", \"active : 1\", \"active : 2\"" <<
endl;
1808 forAll(cpsInCartesian, cpI)
1810 const label iCPw = cpI/label(nCPsU*nCPsV);
1811 const label iCPv = (cpI - iCPw*nCPsU*nCPsV)/nCPsU;
1812 const label iCPu = (cpI - iCPw*nCPsU*nCPsV - iCPv*nCPsU);
1815 << cpsInCartesian[cpI].x() <<
", "
1816 << cpsInCartesian[cpI].y() <<
", "
1817 << cpsInCartesian[cpI].z() <<
", "
1821 << activeDesignVariables_[3*cpI] <<
", "
1822 << activeDesignVariables_[3*cpI + 1] <<
", "
1823 << activeDesignVariables_[3*cpI + 2] <<
endl;
1835 name_ +
"cpsBsplines" + mesh_.time().timeName(),
1836 mesh_.time().caseConstant(),
1845 cpsDict.
add(
"controlPoints", cps_);
1848 cpsDict.regIOobject::writeObject
1858 parametricCoordinatesPtr_().write();