void Foam::ggiPolyPatch::calcPatchToPatch() const
{
// Create patch-to-patch interpolation
if (patchToPatchPtr_)
{
FatalErrorIn("void ggiPolyPatch::calcPatchToPatch() const")
<< "Patch to patch interpolation already calculated"
<< abort(FatalError);
}
if (master())
{
// Create interpolation for zones
patchToPatchPtr_ =
new ggiZoneInterpolation
(
zone()(),
shadow().zone()(),
forwardT(),
reverseT(),
shadow().separation(), // Slave-to-master separation. Bug fix
0, // Non-overlapping face tolerances
0, // HJ, 24/Oct/2008
true, // Rescale weighting factors. Bug fix, MB.
ggiInterpolation::AABB
);
// Abort immediatly if uncovered faces are present and the option
// bridgeOverlap is not set.
if
(
(
patchToPatch().uncoveredMasterFaces().size() > 0
&&
!bridgeOverlap()
)
||
(
patchToPatch().uncoveredSlaveFaces().size() > 0
&&
!shadow().bridgeOverlap()
)
)
{
FatalErrorIn("void ggiPolyPatch::calcPatchToPatch() const")
<< "Found uncovered faces for GGI interface "
<< name() << "/" << shadowName()
<< " while the bridgeOverlap option is not set "
<< "in the boundary file." << endl
<< "This is an unrecoverable error. Aborting."
<< abort(FatalError);
}
}
else
{
FatalErrorIn("void ggiPolyPatch::calcPatchToPatch() const")
<< "Attempting to create GGIInterpolation on a shadow"
<< abort(FatalError);
}
}
// Return delta (P to N) vectors across coupled patch
tmp<vectorField> cyclicFvPatch::delta() const
{
vectorField patchD = fvPatch::delta();
label sizeby2 = patchD.size()/2;
tmp<vectorField> tpdv(new vectorField(patchD.size()));
vectorField& pdv = tpdv();
// To the transformation if necessary
if (parallel())
{
for (label facei = 0; facei < sizeby2; facei++)
{
vector ddi = patchD[facei];
vector dni = patchD[facei + sizeby2];
pdv[facei] = ddi - dni;
pdv[facei + sizeby2] = -pdv[facei];
}
}
else
{
for (label facei = 0; facei < sizeby2; facei++)
{
vector ddi = patchD[facei];
vector dni = patchD[facei + sizeby2];
pdv[facei] = ddi - transform(forwardT()[0], dni);
pdv[facei + sizeby2] = -transform(reverseT()[0], pdv[facei]);
}
}
return tpdv;
}
void tower_tip()
{
CW();
//Jae
forwardT(700,2);
sleep(1);
reverseT(700,4);
sleep(1);
//Jae
}
void patrol()
{
while (1 == 1) //Maybe I should change?
{
reverseT(1000, 3);
sleep(0.2);
forwardT(1000, 3);
sleep(0.2);
}
}
void bordercross()
{
float sec1 = seconds();
float sec2;
float sec3;
claw_up();
sleep(0.5);
toTouch(500);
sleep(0.2);
reverseT(500, 0.5);
sleep(1);
CCW();
sleep(1);
forwardT(1000, 3);
sleep(0.5);
CCW();
reverseT(500, 1);
sec2 = seconds();
sec3 = sec2 - sec1;
while (sec3 < 15)
{
sec2 = seconds();
sec3 = sec2 - sec1;
}
beep();
forwardT(1000, 6);
sleep(0.3);
claw_down();
sleep(1);
if(IR_left > threshold && IR_right > threshold)
{
while (1)
{
ao();
}
}
sleep(1);
claw_up();
sleep(0.5);
reverseT(500, 1.5);
sleep(1);
}
void Foam::cyclicLduInterfaceField::transformCoupleField
(
scalarField& pnf,
const direction cmpt
) const
{
if (doTransform())
{
label sizeby2 = pnf.size()/2;
scalar forwardScale =
pow(diag(forwardT()[0]).component(cmpt), rank());
scalar reverseScale =
pow(diag(reverseT()[0]).component(cmpt), rank());
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] *= forwardScale;
pnf[facei + sizeby2] *= reverseScale;
}
}
}
tmp<Field<Type> > cyclicFvPatchField<Type>::patchNeighbourField() const
{
const Field<Type>& iField = this->internalField();
const unallocLabelList& faceCells = cyclicPatch_.faceCells();
tmp<Field<Type> > tpnf(new Field<Type>(this->size()));
Field<Type>& pnf = tpnf();
label sizeby2 = this->size()/2;
if (doTransform())
{
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = transform
(
forwardT()[0], iField[faceCells[facei + sizeby2]]
);
pnf[facei + sizeby2] = transform
(
reverseT()[0], iField[faceCells[facei]]
);
}
}
else
{
for (label facei=0; facei<sizeby2; facei++)
{
pnf[facei] = iField[faceCells[facei + sizeby2]];
pnf[facei + sizeby2] = iField[faceCells[facei]];
}
}
return tpnf;
}
void Foam::cyclicFaPatch::calcTransforms()
{
if (size() > 0)
{
pointField half0Ctrs(size()/2);
pointField half1Ctrs(size()/2);
for (label i=0; i<size()/2; i++)
{
half0Ctrs[i] = this->edgeCentres()[i];
half1Ctrs[i] = this->edgeCentres()[i+size()/2];
}
vectorField half0Normals(size()/2);
vectorField half1Normals(size()/2);
vectorField eN = edgeNormals()*magEdgeLengths();
scalar maxMatchError = 0;
label errorEdge = -1;
for (label edgei = 0; edgei < size()/2; edgei++)
{
half0Normals[edgei] = eN[edgei];
label nbrEdgei = edgei + size()/2;
half1Normals[edgei] = eN[nbrEdgei];
scalar magLe = mag(half0Normals[edgei]);
scalar nbrMagLe = mag(half1Normals[edgei]);
scalar avLe = (magLe + nbrMagLe)/2.0;
if (magLe < ROOTVSMALL && nbrMagLe < ROOTVSMALL)
{
// Undetermined normal. Use dummy normal to force separation
// check. (note use of sqrt(VSMALL) since that is how mag
// scales)
half0Normals[edgei] = point(1, 0, 0);
half1Normals[edgei] = half0Normals[edgei];
}
else if
(
mag(magLe - nbrMagLe)/avLe
> matchTol_
)
{
// Error in area matching. Find largest error
maxMatchError =
Foam::max(maxMatchError, mag(magLe - nbrMagLe)/avLe);
errorEdge = edgei;
}
else
{
half0Normals[edgei] /= magLe;
half1Normals[edgei] /= nbrMagLe;
}
}
// Check for error in edge matching
if (maxMatchError > matchTol_)
{
label nbrEdgei = errorEdge + size()/2;
scalar magLe = mag(half0Normals[errorEdge]);
scalar nbrMagLe = mag(half1Normals[errorEdge]);
scalar avLe = (magLe + nbrMagLe)/2.0;
FatalErrorIn
(
"cyclicFaPatch::calcTransforms()"
) << "edge " << errorEdge
<< " area does not match neighbour "
<< nbrEdgei << " by "
<< 100*mag(magLe - nbrMagLe)/avLe
<< "% -- possible edge ordering problem." << endl
<< "patch:" << name()
<< " my area:" << magLe
<< " neighbour area:" << nbrMagLe
<< " matching tolerance:" << matchTol_
<< endl
<< "Mesh edge:" << start() + errorEdge
<< endl
<< "Neighbour edge:" << start() + nbrEdgei
<< endl
<< "Other errors also exist, only the largest is reported. "
<< "Please rerun with cyclic debug flag set"
<< " for more information." << exit(FatalError);
}
// Calculate transformation tensors
calcTransformTensors
(
half0Ctrs,
half1Ctrs,
half0Normals,
half1Normals
);
// Check transformation tensors
if (!parallel())
{
if (forwardT().size() > 1 || reverseT().size() > 1)
{
SeriousErrorIn
(
"void cyclicFaPatch::calcTransforms()"
) << "Transformation tensor is not constant for the cyclic "
<< "patch. Please reconsider your setup and definition of "
<< "cyclic boundaries." << endl;
}
}
}
}
