84 if (Pstream::parRun())
87 if ((srcPatch.size() > 0) || (tgtPatch.size() > 0))
89 facesPresentOnProc[Pstream::myProcNo()] = 1;
93 facesPresentOnProc[Pstream::myProcNo()] = 0;
96 Pstream::gatherList(facesPresentOnProc);
97 Pstream::scatterList(facesPresentOnProc);
99 label nHaveFaces =
sum(facesPresentOnProc);
107 <<
"AMI split across multiple processors" <<
endl;
110 else if (nHaveFaces == 1)
112 proci = facesPresentOnProc.find(1);
116 <<
"AMI local to processor" << proci <<
endl;
133 addProfiling(ami,
"AMIInterpolation::projectPointsToSurface");
148 pts[i] =
pi.hitPoint();
160 <<
"Error projecting points to surface: "
161 << nMiss <<
" faces could not be determined"
170 const word& patchName,
174 const bool conformal,
176 const scalar lowWeightTol
179 addProfiling(ami,
"AMIInterpolation::normaliseWeights");
182 wghtSum.setSize(wght.size(), 0.0);
183 label nLowWeight = 0;
191 scalar denom = patchAreas[facei];
206 if (t < lowWeightTol)
224 <<
"AMI: Patch " << patchName
226 <<
" min:" <<
gMin(wghtSum)
227 <<
" max:" <<
gMax(wghtSum)
235 <<
"AMI: Patch " << patchName
236 <<
" identified " << nLow
237 <<
" faces with weights less than " << lowWeightTol
252 const labelList& sourceRestrictAddressing,
253 const labelList& targetRestrictAddressing,
264 label sourceCoarseSize =
266 sourceRestrictAddressing.size()
267 ?
max(sourceRestrictAddressing)+1
271 label targetCoarseSize =
273 targetRestrictAddressing.size()
274 ?
max(targetRestrictAddressing)+1
280 srcMagSf.
setSize(sourceRestrictAddressing.size(), 0.0);
281 forAll(sourceRestrictAddressing, facei)
283 label coarseFacei = sourceRestrictAddressing[facei];
284 srcMagSf[coarseFacei] += fineSrcMagSf[facei];
294 labelList allRestrict(targetRestrictAddressing);
327 tgtSubMap[Pstream::myProcNo()] =
identity(targetCoarseSize);
332 if (proci != Pstream::myProcNo())
346 newSubMap.
setSize(elems.size());
348 labelList oldToNew(targetCoarseSize, -1);
351 for (
const label elemi : elems)
353 label fineElem = elemsMap[elemi];
354 label coarseElem = allRestrict[fineElem];
355 if (oldToNew[coarseElem] == -1)
357 oldToNew[coarseElem] = newi;
358 newSubMap[newi] = coarseElem;
374 tgtConstructMap[Pstream::myProcNo()] =
identity(targetCoarseSize);
387 for (
const label fineElem : elemsMap)
389 label coarseElem = allRestrict[fineElem];
390 tgtCompactMap[fineElem] = coarseElem;
394 label compacti = targetCoarseSize;
399 if (proci != Pstream::myProcNo())
406 labelList& newConstructMap = tgtConstructMap[proci];
407 newConstructMap.
setSize(elems.size());
413 label remoteTargetCoarseSize =
labelMin;
414 for (
const label elemi : elems)
416 remoteTargetCoarseSize =
max
418 remoteTargetCoarseSize,
422 remoteTargetCoarseSize += 1;
425 labelList oldToNew(remoteTargetCoarseSize, -1);
428 for (
const label fineElem : elems)
431 label coarseElem = allRestrict[fineElem];
432 if (oldToNew[coarseElem] == -1)
434 oldToNew[coarseElem] = newi;
435 tgtCompactMap[fineElem] = compacti;
436 newConstructMap[newi] = compacti++;
442 label compacti = oldToNew[coarseElem];
443 tgtCompactMap[fineElem] = newConstructMap[compacti];
451 srcAddress.
setSize(sourceCoarseSize);
452 srcWeights.
setSize(sourceCoarseSize);
454 forAll(fineSrcAddress, facei)
458 const labelList& elems = fineSrcAddress[facei];
459 const scalarList& weights = fineSrcWeights[facei];
460 const scalar fineArea = fineSrcMagSf[facei];
462 label coarseFacei = sourceRestrictAddressing[facei];
464 labelList& newElems = srcAddress[coarseFacei];
465 scalarList& newWeights = srcWeights[coarseFacei];
469 label elemi = elems[i];
470 label coarseElemi = tgtCompactMap[elemi];
472 label index = newElems.find(coarseElemi);
475 newElems.
append(coarseElemi);
476 newWeights.
append(fineArea*weights[i]);
480 newWeights[index] += fineArea*weights[i];
490 std::move(tgtSubMap),
491 std::move(tgtConstructMap)
497 srcAddress.
setSize(sourceCoarseSize);
498 srcWeights.
setSize(sourceCoarseSize);
500 forAll(fineSrcAddress, facei)
504 const labelList& elems = fineSrcAddress[facei];
505 const scalarList& weights = fineSrcWeights[facei];
506 const scalar fineArea = fineSrcMagSf[facei];
508 label coarseFacei = sourceRestrictAddressing[facei];
510 labelList& newElems = srcAddress[coarseFacei];
511 scalarList& newWeights = srcWeights[coarseFacei];
515 const label elemi = elems[i];
516 const label coarseElemi = targetRestrictAddressing[elemi];
518 const label index = newElems.find(coarseElemi);
521 newElems.
append(coarseElemi);
522 newWeights.
append(fineArea*weights[i]);
526 newWeights[index] += fineArea*weights[i];
552 const bool reverseTarget
555 requireMatch_(
dict.getOrDefault(
"requireMatch",
true)),
556 reverseTarget_(
dict.getOrDefault(
"reverseTarget", reverseTarget)),
557 lowWeightCorrection_(
dict.getOrDefault<scalar>(
"lowWeightCorrection", -1)),
558 singlePatchProc_(-999),
577 const bool requireMatch,
578 const bool reverseTarget,
579 const scalar lowWeightCorrection
582 requireMatch_(requireMatch),
583 reverseTarget_(reverseTarget),
584 lowWeightCorrection_(lowWeightCorrection),
585 singlePatchProc_(-999),
607 const labelList& sourceRestrictAddressing,
608 const labelList& targetRestrictAddressing
613 lowWeightCorrection_(-1.0),
629 label sourceCoarseSize =
631 sourceRestrictAddressing.size()
632 ?
max(sourceRestrictAddressing)+1
636 label neighbourCoarseSize =
638 targetRestrictAddressing.size()
639 ?
max(targetRestrictAddressing)+1
645 Pout<<
"AMI: Creating addressing and weights as agglomeration of AMI :"
648 <<
" coarse source size:" << sourceCoarseSize
649 <<
" neighbour source size:" << neighbourCoarseSize
655 fineAMI.
srcAddress().size() != sourceRestrictAddressing.size()
656 || fineAMI.
tgtAddress().size() != targetRestrictAddressing.size()
660 <<
"Size mismatch." <<
nl
661 <<
"Source patch size:" << fineAMI.
srcAddress().size() <<
nl
662 <<
"Source agglomeration size:"
663 << sourceRestrictAddressing.size() <<
nl
664 <<
"Target patch size:" << fineAMI.
tgtAddress().size() <<
nl
665 <<
"Target agglomeration size:"
666 << targetRestrictAddressing.size()
680 sourceRestrictAddressing,
681 targetRestrictAddressing,
697 targetRestrictAddressing,
698 sourceRestrictAddressing,
711 requireMatch_(ami.requireMatch_),
712 reverseTarget_(ami.reverseTarget_),
713 lowWeightCorrection_(ami.lowWeightCorrection_),
714 singlePatchProc_(ami.singlePatchProc_),
715 srcMagSf_(ami.srcMagSf_),
716 srcAddress_(ami.srcAddress_),
717 srcWeights_(ami.srcWeights_),
718 srcWeightsSum_(ami.srcWeightsSum_),
719 srcCentroids_(ami.srcCentroids_),
721 tgtMagSf_(ami.tgtMagSf_),
722 tgtAddress_(ami.tgtAddress_),
723 tgtWeights_(ami.tgtWeights_),
724 tgtWeightsSum_(ami.tgtWeightsSum_),
725 tgtCentroids_(ami.tgtCentroids_),
749 srcPatchPts_ = srcPatch.
points();
750 projectPointsToSurface(surfPtr(), srcPatchPts_);
757 tgtPatchPts_ = tgtPatch.
points();
758 projectPointsToSurface(surfPtr(), tgtPatchPts_);
767 tsrcPatch0_.cref(srcPatch);
768 ttgtPatch0_.cref(tgtPatch);
774 if (srcTotalSize == 0)
776 DebugInfo<<
"AMI: no source faces present - no addressing constructed"
783 <<
"AMI: Creating addressing and weights between "
784 << srcTotalSize <<
" source faces and "
785 << tgtTotalSize <<
" target faces"
788 singlePatchProc_ = calcDistribution(srcPatch, tgtPatch);
792 Info<<
"AMIInterpolation:" <<
nl
793 <<
" singlePatchProc:" << singlePatchProc_ <<
nl
813 srcAddress_.transfer(srcAddress);
814 srcWeights_.transfer(srcWeights);
815 tgtAddress_.transfer(tgtAddress);
816 tgtWeights_.transfer(tgtWeights);
819 srcWeightsSum_.setSize(srcWeights_.size());
820 forAll(srcWeights_, facei)
822 srcWeightsSum_[facei] =
sum(srcWeights_[facei]);
825 tgtWeightsSum_.setSize(tgtWeights_.size());
826 forAll(tgtWeights_, facei)
828 tgtWeightsSum_[facei] =
sum(tgtWeights_[facei]);
831 srcMapPtr_ = std::move(srcToTgtMap);
832 tgtMapPtr_ = std::move(tgtToSrcMap);
847 auto newPtr = clone();
848 newPtr->calculate(srcPatch, tgtPatch);
860 labelListList& newSrcConstructMap = newPtr->srcMapPtr_->constructMap();
863 labelListList& newTgtConstructMap = newPtr->tgtMapPtr_->constructMap();
874 srcConstructMap[proci].size(),
875 (mapMap.size() + newMapMap.size())
882 newSrcConstructMap[proci].size(),
883 (mapMap.size() + newMapMap.size())
890 forAll(srcConstructMap[proci], srci)
892 srcConstructMap[proci][srci] =
893 mapMap[srcConstructMap[proci][srci]];
899 forAll(newSrcConstructMap[proci], srci)
901 newSrcConstructMap[proci][srci] =
902 newMapMap[newSrcConstructMap[proci][srci]];
908 forAll(tgtAddress_[tgti], tgtj)
910 tgtAddress_[tgti][tgtj] = mapMap[tgtAddress_[tgti][tgtj]];
914 forAll(newPtr->tgtAddress_, tgti)
916 forAll(newPtr->tgtAddress_[tgti], tgtj)
918 newPtr->tgtAddress_[tgti][tgtj] =
919 newMapMap[newPtr->tgtAddress_[tgti][tgtj]];
933 tgtConstructMap[proci].size(),
934 (mapMap.size() + newMapMap.size())
941 newTgtConstructMap[proci].size(),
942 (mapMap.size() + newMapMap.size())
949 forAll(tgtConstructMap[proci], tgti)
951 tgtConstructMap[proci][tgti] =
952 mapMap[tgtConstructMap[proci][tgti]];
958 forAll(newTgtConstructMap[proci], tgti)
960 newTgtConstructMap[proci][tgti] =
961 newMapMap[newTgtConstructMap[proci][tgti]];
967 forAll(srcAddress_[srci], srcj)
969 srcAddress_[srci][srcj] =
970 mapMap[srcAddress_[srci][srcj]];
974 forAll(newPtr->srcAddress_, srci)
976 forAll(newPtr->srcAddress_[srci], srcj)
978 newPtr->srcAddress_[srci][srcj] =
979 newMapMap[newPtr->srcAddress_[srci][srcj]];
985 srcMapPtr_->constructSize() += newPtr->srcMapPtr_->constructSize();
986 tgtMapPtr_->constructSize() += newPtr->tgtMapPtr_->constructSize();
991 srcSubMap[proci].
append(newSrcSubMap[proci]);
992 srcConstructMap[proci].
append(newSrcConstructMap[proci]);
994 tgtSubMap[proci].
append(newTgtSubMap[proci]);
995 tgtConstructMap[proci].
append(newTgtConstructMap[proci]);
1000 forAll(srcMagSf_, srcFacei)
1002 srcAddress_[srcFacei].append(newPtr->srcAddress()[srcFacei]);
1003 srcWeights_[srcFacei].append(newPtr->srcWeights()[srcFacei]);
1004 srcWeightsSum_[srcFacei] += newPtr->srcWeightsSum()[srcFacei];
1008 forAll(tgtMagSf_, tgtFacei)
1010 tgtAddress_[tgtFacei].append(newPtr->tgtAddress()[tgtFacei]);
1011 tgtWeights_[tgtFacei].append(newPtr->tgtWeights()[tgtFacei]);
1012 tgtWeightsSum_[tgtFacei] += newPtr->tgtWeightsSum()[tgtFacei];
1019 const bool conformal,
1032 lowWeightCorrection_
1044 lowWeightCorrection_
1054 const label tgtFacei,
1062 const labelList& addr = tgtAddress_[tgtFacei];
1066 label nearestFacei = -1;
1068 for (
const label srcFacei : addr)
1070 const face&
f = srcPatch[srcFacei];
1073 f.ray(tgtPoint,
n, srcPoints, intersection::algorithm::VISIBLE);
1084 nearestFacei = srcFacei;
1091 return nearestFacei;
1103 const label srcFacei,
1112 label nearestFacei = -1;
1115 const labelList& addr = srcAddress_[srcFacei];
1117 for (
const label tgtFacei : addr)
1119 const face&
f = tgtPatch[tgtFacei];
1122 f.ray(srcPoint,
n, tgtPoints, intersection::algorithm::VISIBLE);
1129 const pointHit near =
f.nearestPoint(srcPoint, tgtPoints);
1134 nearestFacei = tgtFacei;
1141 return nearestFacei;
1152 Log <<
"Checks only valid for serial running (currently)" <<
endl;
1157 bool symmetricSrc =
true;
1159 Log <<
" Checking for missing src face in tgt lists" <<
nl;
1161 forAll(srcAddress_, srcFacei)
1163 const labelList& tgtIds = srcAddress_[srcFacei];
1164 for (
const label tgtFacei : tgtIds)
1166 if (!tgtAddress_[tgtFacei].
found(srcFacei))
1168 symmetricSrc =
false;
1170 Log <<
" srcFacei:" << srcFacei
1171 <<
" not found in tgtToSrc list for tgtFacei:"
1179 Log <<
" - symmetric" <<
endl;
1182 bool symmetricTgt =
true;
1184 Log <<
" Checking for missing tgt face in src lists" <<
nl;
1186 forAll(tgtAddress_, tgtFacei)
1188 const labelList& srcIds = tgtAddress_[tgtFacei];
1189 for (
const label srcFacei : srcIds)
1191 if (!srcAddress_[srcFacei].
found(tgtFacei))
1193 symmetricTgt =
false;
1195 Log <<
" tgtFacei:" << tgtFacei
1196 <<
" not found in srcToTgt list for srcFacei:"
1204 Log <<
" - symmetric" <<
endl;
1207 return symmetricSrc && symmetricTgt;
1228 for (
const label tgtPti : addr)
1235 os <<
"l " << pti <<
" " << pti + 1 <<
endl;
1257 if (lowWeightCorrection_ > 0)
1259 os.
writeEntry(
"lowWeightCorrection", lowWeightCorrection_);