/** * return the phased amplitude of a data point at the specified coordinates * @param k slice index * @param j trace index * @param i point index * @param options * @return data value at input indexes */ double CGLDataMgr::vertexValue(int k, int j, int i){ int ni=0,nj=0,nk=0,maxi=0,maxj=0; // swizzle input indexes to extract the appropriate sliceplane switch(sliceplane){ case X: ni=i; nj=j; nk=k; maxi=slices-1; maxj=traces-1;break; case Y: ni=j; nj=k; nk=i; maxi=np-1; maxj=slices-1; break; default: // 1D 2D case Z: ni=k; nj=j; nk=i; maxi=np-1; maxj=traces-1; break; } ni=ni>maxi?maxi:ni; nj=nj>maxj?maxj:nj; int adrs = 0; adrs = traces * np * ni + ws * nj * np + nk; if (adrs >= data_size || adrs < 0) return 0; double rvalue = vertexValue(adrs); if (complex) { double ivalue = vertexValue(adrs + np); if (absval) return pa * fabs(rvalue) + pb * fabs(ivalue); else return pa * rvalue + pb * ivalue; } else return rvalue; }
Foam::scalar Foam::face::areaInContact ( const pointField& meshPoints, const scalarField& v ) const { // Calculate area in contact given displacement of vertices relative to // the face plane. Positive displacement is above the face (no contact); // negative is in contact // Assemble the vertex values const labelList& labels = *this; scalarField vertexValue(labels.size()); forAll(labels, i) { vertexValue[i] = v[labels[i]]; } // Loop through vertexValue. If all greater that 0 return 0 (no contact); // if all less than zero return 1 // all zeros is assumed to be in contact. bool allPositive = true; bool allNegative = true; forAll(vertexValue, vI) { if (vertexValue[vI] > 0) { allNegative = false; } else { allPositive = false; } } if (allPositive) { return 0.0; } if (allNegative) { return 1.0; } // There is a partial contact. // Algorithm: // Go through all edges. if both vertex values for the edge are // positive, discard. If one is positive and one is negative, // create a point and start the edge with it. If both are // negative, add the edge into the new face. When finished, // calculate area of new face and return relative area (0<x<1) // Dimension new point list to max possible size const labelList& faceLabels = *this; pointField newFacePoints(2*size()); label nNewFacePoints = 0; for (label vI = 0; vI < size() - 1; vI++) { if (vertexValue[vI] <= 0) { // This is a point in contact newFacePoints[nNewFacePoints] = meshPoints[faceLabels[vI]]; nNewFacePoints++; } if ( (vertexValue[vI] > 0 && vertexValue[vI + 1] < 0) || (vertexValue[vI] < 0 && vertexValue[vI + 1] > 0) ) { // Edge intersection. Calculate intersection point and add to list point intersection = meshPoints[faceLabels[vI]] + vertexValue[vI]/(vertexValue[vI + 1] - vertexValue[vI]) *(meshPoints[faceLabels[vI]] - meshPoints[faceLabels[vI + 1]]); newFacePoints[nNewFacePoints] = intersection; nNewFacePoints++; } } // Do last point by hand if (vertexValue[size() - 1] <= 0) { // This is a point in contact newFacePoints[nNewFacePoints] = meshPoints[faceLabels[size() - 1]]; nNewFacePoints++; } if ( (vertexValue[size() - 1] > 0 && vertexValue[0] < 0) || (vertexValue[size() - 1] < 0 && vertexValue[0] > 0) ) { // Edge intersection. Calculate intersection point and add to list point intersection = meshPoints[faceLabels[size() - 1]] + vertexValue[size() - 1]/(vertexValue[0] - vertexValue[size() - 1]) *(meshPoints[faceLabels[size() - 1]] - meshPoints[faceLabels[0]]); newFacePoints[nNewFacePoints] = intersection; nNewFacePoints++; } newFacePoints.setSize(nNewFacePoints); // Make a labelList for the sub-face (points are ordered!) labelList sfl(newFacePoints.size()); forAll(sfl, sflI) { sfl[sflI] = sflI; } // Calculate relative area return face(sfl).mag(newFacePoints)/(mag(meshPoints) + VSMALL); }