[cig-commits] r8326 - in short/3D/PyLith/trunk: . libsrc/faults
libsrc/meshio unittests/libtests/faults/data
knepley at geodynamics.org
knepley at geodynamics.org
Sun Nov 25 15:37:11 PST 2007
Author: knepley
Date: 2007-11-25 15:37:10 -0800 (Sun, 25 Nov 2007)
New Revision: 8326
Modified:
short/3D/PyLith/trunk/TODO
short/3D/PyLith/trunk/libsrc/faults/CohesiveTopology.cc
short/3D/PyLith/trunk/libsrc/meshio/SolutionIOVTK.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8g.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8h.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8i.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataLine2.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4g.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4h.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4b.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4c.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4d.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4f.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4g.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4h.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4i.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4j.cc
short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTri3f.cc
Log:
Trying to fix cohesive elements (need help to fix Lagrange tests)
Modified: short/3D/PyLith/trunk/TODO
===================================================================
--- short/3D/PyLith/trunk/TODO 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/TODO 2007-11-25 23:37:10 UTC (rev 8326)
@@ -297,6 +297,8 @@
10. Move events to Python (make wrappers for events)
+11. For Schur complement directly for mass matrix and Lagrang multiplier problem
+
======================================================================
QUESTIONS FOR LEIF
======================================================================
Modified: short/3D/PyLith/trunk/libsrc/faults/CohesiveTopology.cc
===================================================================
--- short/3D/PyLith/trunk/libsrc/faults/CohesiveTopology.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/libsrc/faults/CohesiveTopology.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -29,9 +29,12 @@
{ // create
assert(0 != fault);
- typedef ALE::SieveAlg<Mesh> sieveAlg;
- typedef ALE::Selection<Mesh> selection;
- typedef std::set<Mesh::point_type> PointSet;
+ typedef ALE::SieveAlg<Mesh> sieveAlg;
+ typedef ALE::Selection<Mesh> selection;
+ typedef std::set<Mesh::point_type> PointSet;
+ typedef std::vector<sieve_type::point_type> PointArray;
+ typedef std::pair<sieve_type::point_type, int> oPoint_type;
+ typedef std::vector<oPoint_type> oPointArray;
const int_section_type::chart_type& chart = groupField->getChart();
PointSet faultVertices; // Vertices on fault
@@ -67,11 +70,29 @@
const PointSet::const_iterator fvEnd = faultVertices.end();
int f = sieve->base()->size() + sieve->cap()->size();
- int debug = mesh->debug();
+ //int debug = mesh->debug();
+ int debug = 1;
ALE::Obj<PointSet> face = new PointSet();
PointSet faultCells;
// Create a sieve which captures the fault
+ const int fDim = (*fault)->getDimension();
+ const Obj<Mesh::arrow_section_type>& orientation = (*fault)->getArrowSection("orientation");
+ std::map<int,int*> curElement;
+ std::map<int,PointArray> bdVertices;
+ std::map<int,PointArray> faultFaces;
+ std::map<int,oPointArray> oFaultFaces;
+ int curCell = f;
+ int curVertex = 0;
+ int newElement = curCell + fDim*faultVertices.size();
+ int o = 1;
+
+ curElement[0] = &curVertex;
+ curElement[fDim] = &curCell;
+ for(int d = 1; d < fDim; d++) {
+ curElement[d] = &newElement;
+ }
+
for(PointSet::const_iterator fv_iter = fvBegin; fv_iter != fvEnd; ++fv_iter) {
const ALE::Obj<sieveAlg::supportArray>& cells =
sieveAlg::nSupport(mesh, *fv_iter, depth);
@@ -105,17 +126,44 @@
if (face->size() == faceSize) {
if (debug)
std::cout << " Contains a face on the fault" << std::endl;
- const ALE::Obj<sieve_type::supportSet> preFace = faultSieve->nJoin1(face);
+ ALE::Obj<sieve_type::supportSet> preFace;
+ if (fDim < 2) {
+ preFace = faultSieve->nJoin1(face);
+ } else {
+ std::cout << " Using general nJoin()" << std::endl;
+ preFace = faultSieve->nJoin(face, fDim);
+ }
if (preFace->size() > 1) {
throw ALE::Exception("Invalid fault sieve: Multiple faces from "
"vertex set");
} else if (preFace->size() == 1) {
// Add the other cell neighbor for this face
- faultSieve->addArrow(*preFace->begin(), *c_iter);
+ if (fDim == 0) {
+ faultSieve->addArrow(*faceVertices.begin(), *c_iter);
+ } else {
+ faultSieve->addArrow(*preFace->begin(), *c_iter);
+ }
} else if (preFace->size() == 0) {
if (debug) std::cout << " Orienting face " << f << std::endl;
selection::getOrientedFace(mesh, *c_iter, face, numCorners, indices, &origVertices, &faceVertices);
+#if 1
+ bdVertices[fDim].clear();
+ for(PointArray::const_iterator v_iter = faceVertices.begin(); v_iter != faceVertices.end(); ++v_iter) {
+ bdVertices[fDim].push_back(*v_iter);
+ if (debug) std::cout << " Boundary vertex " << *v_iter << std::endl;
+ }
+ if (fDim == 0) {
+ f = *faceVertices.begin();
+ }
+ if (faceSize != fDim+1) {
+ if (debug) std::cout << " Adding hex face " << f << std::endl;
+ ALE::SieveBuilder<Mesh>::buildHexFaces(faultSieve, orientation, fDim, curElement, bdVertices, oFaultFaces, f, o);
+ } else {
+ if (debug) std::cout << " Adding simplicial face " << f << std::endl;
+ ALE::SieveBuilder<Mesh>::buildFaces(faultSieve, orientation, fDim, curElement, bdVertices, oFaultFaces, f, o);
+ }
+#else
if (debug) std::cout << " Adding face " << f << std::endl;
int color = 0;
for(PointArray::const_iterator f_iter = faceVertices.begin();
@@ -123,7 +171,9 @@
if (debug) std::cout << " vertex " << *f_iter << std::endl;
faultSieve->addArrow(*f_iter, f, color++);
} // for
+#endif
faultSieve->addArrow(f, *c_iter);
+ faultSieve->view("");
f++;
} // if/else
faultCells.insert(*c_iter);
@@ -134,7 +184,165 @@
(*fault)->stratify();
faultCells.clear();
if (debug) (*fault)->view("Fault mesh");
+ const ALE::Obj<Mesh> faultBd = ALE::Selection<Mesh>::boundary(*fault);
+ if (debug) faultBd->view("Fault boundary mesh");
+
// Orient the fault sieve
+#if 1
+ // Must check the orientation here
+ const Mesh::point_type firstFaultCell = *(*fault)->heightStratum(1)->begin();
+ const ALE::Obj<Mesh::label_sequence>& fFaces = (*fault)->heightStratum(2);
+ int faultDepth = (*fault)->depth()-1; // Depth of fault cells
+ int numFaultCorners = 0; // The number of vertices in a fault cell
+ int faultFaceSize = 0; // The number of vertices in a face between fault cells
+ PointSet flippedFaces; // Incorrectly oriented fault cells
+
+ if (!(*fault)->commRank()) {
+ numFaultCorners = faultSieve->nCone(firstFaultCell, faultDepth)->size();
+ if (debug) std::cout << " Fault corners " << numFaultCorners << std::endl;
+ if (fDim == 0) {
+ assert(numFaultCorners == faceSize-1);
+ } else {
+ assert(numFaultCorners == faceSize);
+ }
+ if (faultDepth == 1) {
+ faultFaceSize = 1;
+ } else {
+ faultFaceSize = faultSieve->nCone(*fFaces->begin(), faultDepth-1)->size();
+ }
+ }
+ if (debug) std::cout << " Fault face size " << faultFaceSize << std::endl;
+
+ // Loop over fault faces
+ for(Mesh::label_sequence::iterator e_iter = fFaces->begin(); e_iter != fFaces->end(); ++e_iter) {
+ if (debug) std::cout << " Checking orientation of fault face " << *e_iter << std::endl;
+ // for each face get the support (2 fault cells)
+ const Obj<sieve_type::traits::supportSequence>& support = faultSieve->support(*e_iter);
+ sieve_type::traits::supportSequence::iterator s_iter = support->begin();
+
+ // Throw out boundary fault faces
+ if (support->size() > 1) {
+ Mesh::point_type cellA = *s_iter; ++s_iter;
+ Mesh::point_type cellB = *s_iter;
+ bool flippedA = (flippedFaces.find(cellA) != flippedFaces.end());
+ bool flippedB = (flippedFaces.find(cellB) != flippedFaces.end());
+
+ if (debug) std::cout << " neighboring cells " << cellA << " and " << cellB << std::endl;
+ if (flippedA && flippedB) {throw ALE::Exception("Fault mesh is non-orientable");}
+ // In 1D, just check that vertices match
+ if (fDim == 1) {
+ const Obj<sieve_type::traits::coneSequence>& coneA = faultSieve->cone(cellA);
+ sieve_type::traits::coneSequence::iterator iterA = coneA->begin();
+ const Obj<sieve_type::traits::coneSequence>& coneB = faultSieve->cone(cellB);
+ sieve_type::traits::coneSequence::iterator iterB = coneB->begin();
+ int posA, posB;
+
+ for(posA = 0; posA < 2; ++posA, ++iterA) if (*iterA == *e_iter) break;
+ for(posB = 0; posB < 2; ++posB, ++iterB) if (*iterB == *e_iter) break;
+ if (debug) std::cout << " with face positions " << posA << " and " << posB << std::endl;
+ if ((posA == 2) || (posB == 2)) {throw ALE::Exception("Could not find fault face in cone");}
+ if ((posA == posB) ^ (flippedA || flippedB)) {
+ std::cout << "Invalid orientation in fault mesh" << std::endl;
+ std::cout << " fault face: " << *e_iter << " cellA: " << cellA << " cellB: " << cellB << std::endl;
+ //throw ALE::Exception("Invalid orientation in fault mesh");
+ if (!flippedA) {
+ flippedFaces.insert(cellA);
+ } else if (!flippedB) {
+ flippedFaces.insert(cellB);
+ }
+ }
+ } else if (fDim == 2) {
+ // Check orientation
+ ALE::MinimalArrow<sieve_type::point_type,sieve_type::point_type> arrowA(*e_iter, cellA);
+ const int oA = orientation->restrictPoint(arrowA)[0];
+ ALE::MinimalArrow<sieve_type::point_type,sieve_type::point_type> arrowB(*e_iter, cellB);
+ const int oB = orientation->restrictPoint(arrowB)[0];
+
+ if ((oA == oB) ^ (flippedA || flippedB)) {
+ std::cout << "Invalid orientation in fault mesh" << std::endl;
+ std::cout << " fault face: " << *e_iter << " cellA: " << cellA << " cellB: " << cellB << std::endl;
+ //throw ALE::Exception("Invalid orientation in fault mesh");
+ if (!flippedA) {
+ flippedFaces.insert(cellA);
+ } else if (!flippedB) {
+ flippedFaces.insert(cellB);
+ }
+ }
+ }
+ }
+ }
+ for(PointSet::const_iterator f_iter = flippedFaces.begin(); f_iter != flippedFaces.end(); ++f_iter) {
+ if (debug) std::cout << " Reversing fault face " << *f_iter << std::endl;
+ faceVertices.clear();
+ const ALE::Obj<sieve_type::traits::coneSequence>& cone = faultSieve->cone(*f_iter);
+ for(sieve_type::traits::coneSequence::iterator v_iter = cone->begin(); v_iter != cone->end(); ++v_iter) {
+ faceVertices.insert(faceVertices.begin(), *v_iter);
+ }
+ faultSieve->clearCone(*f_iter);
+ int color = 0;
+ for(PointArray::const_iterator v_iter = faceVertices.begin(); v_iter != faceVertices.end(); ++v_iter) {
+ faultSieve->addArrow(*v_iter, *f_iter, color++);
+ }
+
+ if (fDim > 1) {
+ // Here, they are edges, not vertices
+ for(PointArray::const_iterator e_iter = faceVertices.begin(); e_iter != faceVertices.end(); ++e_iter) {
+ ALE::MinimalArrow<sieve_type::point_type,sieve_type::point_type> arrow(*e_iter, *f_iter);
+ int o = orientation->restrictPoint(arrow)[0];
+
+ if (debug) std::cout << " Reversing orientation of " << *e_iter <<"-->"<<*f_iter << " from " << o << " to " << -(o+1) << std::endl;
+ o = -(o+1);
+ orientation->updatePoint(arrow, &o);
+ }
+ }
+ }
+ flippedFaces.clear();
+ for(Mesh::label_sequence::iterator e_iter = fFaces->begin(); e_iter != fFaces->end(); ++e_iter) {
+ if (debug) std::cout << " Checking orientation of fault face " << *e_iter << std::endl;
+ // for each face get the support (2 fault cells)
+ const Obj<sieve_type::traits::supportSequence>& support = faultSieve->support(*e_iter);
+ sieve_type::traits::supportSequence::iterator s_iter = support->begin();
+
+ // Throw out boundary fault faces
+ if (support->size() > 1) {
+ Mesh::point_type cellA = *s_iter; ++s_iter;
+ Mesh::point_type cellB = *s_iter;
+
+ if (debug) std::cout << " neighboring cells " << cellA << " and " << cellB << std::endl;
+ // In 1D, just check that vertices match
+ if (fDim == 1) {
+ const Obj<sieve_type::traits::coneSequence>& coneA = faultSieve->cone(cellA);
+ sieve_type::traits::coneSequence::iterator iterA = coneA->begin();
+ const Obj<sieve_type::traits::coneSequence>& coneB = faultSieve->cone(cellB);
+ sieve_type::traits::coneSequence::iterator iterB = coneB->begin();
+ int posA, posB;
+
+ for(posA = 0; posA < 2; ++posA, ++iterA) if (*iterA == *e_iter) break;
+ for(posB = 0; posB < 2; ++posB, ++iterB) if (*iterB == *e_iter) break;
+ if (debug) std::cout << " with face positions " << posA << " and " << posB << std::endl;
+ if ((posA == 2) || (posB == 2)) {throw ALE::Exception("Could not find fault face in cone");}
+ if (posA == posB) {
+ std::cout << "Invalid orientation in fault mesh" << std::endl;
+ std::cout << " fault face: " << *e_iter << " cellA: " << cellA << " cellB: " << cellB << std::endl;
+ throw ALE::Exception("Invalid orientation in fault mesh");
+ }
+ } else {
+ // Check orientation
+ ALE::MinimalArrow<sieve_type::point_type,sieve_type::point_type> arrowA(*e_iter, cellA);
+ const int oA = orientation->restrictPoint(arrowA)[0];
+ ALE::MinimalArrow<sieve_type::point_type,sieve_type::point_type> arrowB(*e_iter, cellB);
+ const int oB = orientation->restrictPoint(arrowB)[0];
+
+ if (oA == oB) {
+ std::cout << "Invalid orientation in fault mesh" << std::endl;
+ std::cout << " fault face: " << *e_iter << " cellA: " << cellA << " cellB: " << cellB << std::endl;
+ throw ALE::Exception("Invalid orientation in fault mesh");
+ }
+ }
+ }
+ }
+ if (debug) (*fault)->view("Oriented Fault mesh");
+#else
const ALE::Obj<Mesh::label_sequence>& fFaces = (*fault)->heightStratum(1);
int faultDepth = (*fault)->depth()-1; // Depth of fault cells
int numFaultCorners = 0; // The number of vertices in a fault cell
@@ -144,7 +352,11 @@
if (!(*fault)->commRank()) {
numFaultCorners = faultSieve->nCone(*fFaces->begin(), faultDepth)->size();
if (debug) std::cout << " Fault corners " << numFaultCorners << std::endl;
- assert(numFaultCorners == faceSize);
+ if (fDim == 0) {
+ assert(numFaultCorners == faceSize-1);
+ } else {
+ assert(numFaultCorners == faceSize);
+ }
faultFaceSize = selection::numFaceVertices(*fFaces->begin(), (*fault), faultDepth);
}
if (debug) std::cout << " Fault face size " << faultFaceSize << std::endl;
@@ -289,6 +501,7 @@
}
}
}
+#endif
// Add new shadow vertices and possibly Lagrange multipler vertices
const ALE::Obj<Mesh::label_sequence>& fVertices = (*fault)->depthStratum(0);
@@ -328,7 +541,7 @@
} // for
// Split the mesh along the fault sieve and create cohesive elements
- const ALE::Obj<Mesh::label_sequence>& faces = (*fault)->depthStratum(1);
+ const ALE::Obj<Mesh::label_sequence>& faces = (*fault)->heightStratum(1);
const ALE::Obj<Mesh::label_type>& material = mesh->getLabel("material-id");
const int firstCohesiveCell = newPoint;
PointSet replaceCells;
@@ -346,16 +559,30 @@
if (debug) std::cout << " Checking orientation against cell " << cell << std::endl;
selection::getOrientedFace(mesh, cell, &vertexRenumber, numCorners, indices, &origVertices, &faceVertices);
+#if 1
+ const ALE::Obj<sieve_type::coneArray>& faceCone = sieveAlg::nCone(*fault, *f_iter, faultDepth);
+ const sieve_type::coneArray::iterator fBegin = faceCone->begin();
+ const sieve_type::coneArray::iterator fEnd = faceCone->end();
+#else
const ALE::Obj<sieve_type::traits::coneSequence>& faceCone = faultSieve->cone(*f_iter);
+ const sieve_type::traits::coneSequence::iterator fBegin = fCone->begin();
+ const sieve_type::traits::coneSequence::iterator fEnd = fCone->end();
+#endif
bool found = true;
- if (numFaultCorners == 2) {
- if (faceVertices[0] != *faceCone->begin()) found = false;
+ if (numFaultCorners == 0) {
+ found = false;
+ } else if (numFaultCorners == 2) {
+ if (faceVertices[0] != *fBegin) found = false;
} else {
int v = 0;
// Locate first vertex
- while((v < numFaultCorners) && (faceVertices[v] != *faceCone->begin())) ++v;
- for(sieve_type::traits::coneSequence::iterator v_iter = faceCone->begin(); v_iter != faceCone->end(); ++v_iter, ++v) {
+ while((v < numFaultCorners) && (faceVertices[v] != *fBegin)) ++v;
+#if 1
+ for(sieve_type::coneArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter, ++v) {
+#else
+ for(sieve_type::traits::coneSequence::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter, ++v) {
+#endif
if (debug) std::cout << " Checking " << *v_iter << " against " << faceVertices[v%numFaultCorners] << std::endl;
if (faceVertices[v%numFaultCorners] != *v_iter) {
found = false;
@@ -372,43 +599,57 @@
if (debug) std::cout << " Verifing reverse orientation" << std::endl;
found = true;
int v = 0;
- // Locate first vertex
- while((v < numFaultCorners) && (faceVertices[v] != *faceCone->rbegin())) ++v;
- for(sieve_type::traits::coneSequence::reverse_iterator v_iter = faceCone->rbegin(); v_iter != faceCone->rend(); ++v_iter, ++v) {
- if (debug) std::cout << " Checking " << *v_iter << " against " << faceVertices[v%numFaultCorners] << std::endl;
- if (faceVertices[v%numFaultCorners] != *v_iter) {
- found = false;
- break;
+ if (numFaultCorners > 0) {
+ // Locate first vertex
+ while((v < numFaultCorners) && (faceVertices[v] != *faceCone->rbegin())) ++v;
+#if 1
+ for(sieve_type::coneArray::reverse_iterator v_iter = faceCone->rbegin(); v_iter != faceCone->rend(); ++v_iter, ++v) {
+#else
+ for(sieve_type::traits::coneSequence::reverse_iterator v_iter = faceCone->rbegin(); v_iter != faceCone->rend(); ++v_iter, ++v) {
+#endif
+ if (debug) std::cout << " Checking " << *v_iter << " against " << faceVertices[v%numFaultCorners] << std::endl;
+ if (faceVertices[v%numFaultCorners] != *v_iter) {
+ found = false;
+ break;
+ }
}
}
assert(found);
}
noReplaceCells.insert(otherCell);
replaceCells.insert(cell);
- replaceVertices.insert(faceCone->begin(), faceCone->end());
+ replaceVertices.insert(fBegin, fEnd);
// Adding cohesive cell (not interpolated)
- const ALE::Obj<sieve_type::traits::coneSequence>& fCone = faultSieve->cone(*f_iter);
- const sieve_type::traits::coneSequence::iterator fBegin = fCone->begin();
- const sieve_type::traits::coneSequence::iterator fEnd = fCone->end();
int color = 0;
if (debug)
std::cout << " Creating cohesive cell " << newPoint << std::endl;
//for(PointArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#if 1
+ for(sieve_type::coneArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#else
for(sieve_type::traits::coneSequence::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#endif
if (debug)
std::cout << " vertex " << *v_iter << std::endl;
sieve->addArrow(*v_iter, newPoint, color++);
}
//for(PointArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#if 1
+ for(sieve_type::coneArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#else
for(sieve_type::traits::coneSequence::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#endif
if (debug)
std::cout << " shadow vertex " << vertexRenumber[*v_iter] << std::endl;
sieve->addArrow(vertexRenumber[*v_iter], newPoint, color++);
}
if (constraintCell) {
- //for(PointArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#if 1
+ for(sieve_type::coneArray::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#else
for(sieve_type::traits::coneSequence::iterator v_iter = fBegin; v_iter != fEnd; ++v_iter) {
+#endif
if (debug)
std::cout << " Lagrange vertex " << vertexRenumber[*v_iter]+1 << std::endl;
sieve->addArrow(vertexRenumber[*v_iter]+1, newPoint, color++);
@@ -421,6 +662,13 @@
PointSet vReplaceCells;
PointSet vNoReplaceCells;
+ // More checking
+ PointSet replaceCellsBase(replaceCells);
+
+ const ALE::Obj<Mesh::label_sequence>& faultBdVerts = faultBd->depthStratum(0);
+ PointSet faultBdVertices;
+
+ faultBdVertices.insert(faultBdVerts->begin(), faultBdVerts->end());
for(PointSet::const_iterator v_iter = replaceVertices.begin(); v_iter != replaceVertices.end(); ++v_iter) {
const ALE::Obj<sieve_type::traits::supportSequence>& neighbors = sieve->support(*v_iter);
const sieve_type::traits::supportSequence::iterator begin = neighbors->begin();
@@ -429,6 +677,7 @@
int classifyTotal = neighbors->size();
int classifySize = 0;
+ if (faultBdVertices.find(*v_iter) != faultBdVertices.end()) continue;
if (debug) {std::cout << "Checking fault vertex " << *v_iter << std::endl;}
vReplaceCells.clear();
vNoReplaceCells.clear();
@@ -494,8 +743,116 @@
assert(classifySize <= classifyTotal);
}
replaceCells.insert(vReplaceCells.begin(), vReplaceCells.end());
+ // More checking
+ noReplaceCells.insert(vNoReplaceCells.begin(), vNoReplaceCells.end());
}
- debug = 0;
+
+ // More checking
+ const ALE::Obj<real_section_type>& problemNodes = mesh->getRealSection("problemNodes");
+ PointSet cellNeighbors;
+
+ problemNodes->setFiberDimension(mesh->depthStratum(0), 1);
+ problemNodes->allocatePoint();
+ for(PointSet::const_iterator v_iter = faultVertices.begin(); v_iter != faultVertices.end(); ++v_iter) {
+ const double one = 1.0;
+
+ problemNodes->updatePoint(*v_iter, &one);
+ }
+ for(PointSet::const_iterator c_iter = replaceCells.begin(); c_iter != replaceCells.end(); ++c_iter) {
+ if (replaceCellsBase.find(*c_iter) != replaceCellsBase.end()) continue;
+ const ALE::Obj<sieve_type::traits::coneSequence>& vertices = sieve->cone(*c_iter);
+ const sieve_type::traits::coneSequence::iterator vBegin = vertices->begin();
+ const sieve_type::traits::coneSequence::iterator vEnd = vertices->end();
+ cellNeighbors.clear();
+
+ for(sieve_type::traits::coneSequence::iterator v_iter = vBegin; v_iter != vEnd; ++v_iter) {
+ const ALE::Obj<sieve_type::traits::supportSequence>& neighbors = sieve->support(*v_iter);
+ const sieve_type::traits::supportSequence::iterator nBegin = neighbors->begin();
+ const sieve_type::traits::supportSequence::iterator nEnd = neighbors->end();
+
+ for(sieve_type::traits::supportSequence::iterator n_iter = nBegin; n_iter != nEnd; ++n_iter) {
+ const ALE::Obj<sieve_type::coneSet>& preFace = sieve->nMeet(*c_iter, *n_iter, depth);
+
+ if (preFace->size() == faceSize) {
+ cellNeighbors.insert(*n_iter);
+ if (noReplaceCells.find(*n_iter) != noReplaceCells.end()) {
+ const ALE::Obj<real_section_type>& coordinates = mesh->getRealSection("coordinates");
+ const int dim = mesh->getDimension();
+ int c = 0;
+
+ std::cout << "Cell " << *c_iter << " in replaceCells has neighbor " << *n_iter << " in noReplaceCells" << std::endl;
+ const double *coordsA = mesh->restrict(coordinates, *c_iter);
+ const ALE::Obj<sieve_type::traits::coneSequence>& verticesA = sieve->cone(*c_iter);
+
+ std::cout << "Cell " << *c_iter << std::endl;
+ for(sieve_type::traits::coneSequence::iterator v_iter = verticesA->begin(); v_iter != verticesA->end(); ++v_iter, ++c) {
+ std::cout << "Corner " << *v_iter << ":";
+ for(int d = 0; d < dim; ++d) {
+ std::cout << " " << coordsA[c*dim+d];
+ }
+ if (faultVertices.find(*v_iter) != faultVertices.end()) {
+ const double ten = 10.0;
+
+ problemNodes->updatePoint(*v_iter, &ten);
+ std::cout << " on fault";
+ }
+ std::cout << std::endl;
+ }
+ const double *coordsB = mesh->restrict(coordinates, *n_iter);
+ const ALE::Obj<sieve_type::traits::coneSequence>& verticesB = sieve->cone(*n_iter);
+
+ std::cout << "Cell " << *n_iter << std::endl;
+ c = 0;
+ for(sieve_type::traits::coneSequence::iterator v_iter = verticesB->begin(); v_iter != verticesB->end(); ++v_iter, ++c) {
+ std::cout << "Corner " << *v_iter << ":";
+ for(int d = 0; d < dim; ++d) {
+ std::cout << " " << coordsB[c*dim+d];
+ }
+ if (faultVertices.find(*v_iter) != faultVertices.end()) {
+ const double ten = 10.0;
+
+ problemNodes->updatePoint(*v_iter, &ten);
+ std::cout << " on fault";
+ }
+ std::cout << std::endl;
+ }
+ //throw ALE::Exception("Invalid division along fault");
+ }
+ }
+ }
+ }
+ // There should be a way to check for boundary elements
+ if (mesh->getDimension() == 1) {
+ if (cellNeighbors.size() > 2) {
+ std::cout << "Cell " << *c_iter << " has an invalid number of neighbors " << cellNeighbors.size() << std::endl;
+ throw ALE::Exception("Invalid number of neighbors");
+ }
+ } else if (mesh->getDimension() == 2) {
+ if (numCorners == 3) {
+ if (cellNeighbors.size() > 3) {
+ std::cout << "Cell " << *c_iter << " has an invalid number of neighbors " << cellNeighbors.size() << std::endl;
+ throw ALE::Exception("Invalid number of neighbors");
+ }
+ } else if (numCorners == 4) {
+ if (cellNeighbors.size() > 4) {
+ std::cout << "Cell " << *c_iter << " has an invalid number of neighbors " << cellNeighbors.size() << std::endl;
+ throw ALE::Exception("Invalid number of neighbors");
+ }
+ }
+ } else if (mesh->getDimension() == 3) {
+ if (numCorners == 4) {
+ if (cellNeighbors.size() > 4) {
+ std::cout << "Cell " << *c_iter << " has an invalid number of neighbors " << cellNeighbors.size() << std::endl;
+ throw ALE::Exception("Invalid number of neighbors");
+ }
+ } else if (numCorners == 8) {
+ if (cellNeighbors.size() > 6) {
+ std::cout << "Cell " << *c_iter << " has an invalid number of neighbors " << cellNeighbors.size() << std::endl;
+ throw ALE::Exception("Invalid number of neighbors");
+ }
+ }
+ }
+ }
#else
for(PointSet::const_iterator v_iter = replaceVertices.begin(); v_iter != replaceVertices.end(); ++v_iter) {
bool modified = true;
Modified: short/3D/PyLith/trunk/libsrc/meshio/SolutionIOVTK.cc
===================================================================
--- short/3D/PyLith/trunk/libsrc/meshio/SolutionIOVTK.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/libsrc/meshio/SolutionIOVTK.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -144,6 +144,9 @@
buffer.str("");
buffer << name << "_verify_t" << t;
err = SectionView_Sieve_Ascii(mesh, field, buffer.str().c_str(), _viewer, -4);
+ if (mesh->hasRealSection("problemNodes")) {
+ err = SectionView_Sieve_Ascii(mesh, mesh->getRealSection("problemNodes"), "problemNodes", _viewer);
+ }
} catch (const std::exception& err) {
std::ostringstream msg;
msg << "Error while writing field '" << name << "' at time "
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8g.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8g.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8g.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -12,20 +12,33 @@
/* Original mesh
*
- * Cells are 0-1 and vertices are 2-13.
*
- * 2,3,4,5 -------- 6,7,8,9 -------- 10,11,12,13
+ * Cells are 0-3 and vertices are 4-22.
*
- * ^^^^^^^ Vertices forming fault
+ * The fault runs through the center (x = 0)
*
+ 1-----7----13 Cells
+ /| /| /|
+ 3-|---9-|--15 | 0 2
+ /| | /| | /| |
+ 5 | 0-----6----12
+ | |/ | |/ | |/
+ | 2-----8----14 1 3
+ |/ |/ |/
+ 4----10----16
+ *
* After adding cohesive elements
*
- * Cells are 0-1,16 and vertices are 4-15.
+ 1----23----7----13
+ /| /| /| /|
+ 3-|--25-|--9----15 |
+ /| | /| | | | /| |
+ 5 | 0----22----6----12
+ | |/ | |/ | |/ | |/
+ | 2----24----8----14
+ |/ |/ |/ |/
+ 4----26---10----16
*
- * 2,3,4,5 -------- 6,7,8,9 -- 14,15,16,17 -------- 10,11,12,13
- *
- * ^^^^^^^^^^^^^^^^^^^^^^ Cohesive element
- *
*/
#include "CohesiveDataHex8g.hh"
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8h.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8h.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8h.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -12,20 +12,32 @@
/* Original mesh
*
- * Cells are 0-1 and vertices are 2-13.
+ * Cells are 0-3 and vertices are 4-22.
*
- * 2,3,4,5 -------- 6,7,8,9 -------- 10,11,12,13
+ * The fault runs through the center (x = 0)
*
- * ^^^^^^^ Vertices forming fault
+ 1-----7----13 Cells
+ /| /| /|
+ 3-|---9-|--15 | 0 2
+ /| | /| | /| |
+ 5 | 0-----6----12
+ | |/ | |/ | |/
+ | 2-----8----14 3 1
+ |/ |/ |/
+ 4----10----16
*
* After adding cohesive elements
*
- * Cells are 0-1,16 and vertices are 4-15.
+ 1----23----7----13
+ /| /| /| /|
+ 3-|--25-|--9----15 |
+ /| | /| | | | /| |
+ 5 | 0----22----6----12
+ | |/ | |/ | |/ | |/
+ | 2----24----8----14
+ |/ |/ |/ |/
+ 4----26---10----16
*
- * 2,3,4,5 -------- 6,7,8,9 -- 14,15,16,17 -------- 10,11,12,13
- *
- * ^^^^^^^^^^^^^^^^^^^^^^ Cohesive element
- *
*/
#include "CohesiveDataHex8h.hh"
@@ -75,12 +87,12 @@
};
const int pylith::faults::CohesiveDataHex8h::_cells[] = {
- 4, 10, 11, 5, 6, 12, 13, 7,
- 19, 18, 20, 21, 25, 24, 26, 27,
- 23, 17, 19, 25, 22, 16, 18, 24,
- 15, 14, 8, 9, 13, 12, 6, 7,
- 11, 13, 12, 10, 23, 25, 24, 22,
- 13, 15, 14, 12, 25, 27, 26, 24,
+ 4, 22, 23, 5, 6, 24, 25, 7,
+ 19, 18, 20, 21, 13, 12, 14, 15,
+ 11, 17, 19, 13, 10, 16, 18, 12,
+ 27, 26, 8, 9, 25, 24, 6, 7,
+ 11, 10, 12, 13, 23, 22, 24, 25,
+ 12, 14, 15, 13, 24, 26, 27, 25,
};
const int pylith::faults::CohesiveDataHex8h::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8i.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8i.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataHex8i.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -80,12 +80,12 @@
8, 7, 20, 21, 13, 12, 23, 24,
14, 9, 10, 15, 13, 8, 21, 24,
15, 10, 11, 16, 24, 21, 22, 25,
- 30, 38, 28, 29, 35, 41, 33, 34,
+ 30, 21, 28, 29, 35, 24, 33, 34,
41, 35, 30, 38, 42, 36, 31, 39,
27, 28, 38, 37, 32, 33, 41, 40,
15, 14, 13, 24, 19, 18, 17, 26,
24, 23, 20, 21, 41, 40, 37, 38,
- 24, 21, 22, 25, 41, 38, 39, 42
+ 25, 24, 21, 22, 42, 41, 38, 39
};
const int pylith::faults::CohesiveDataHex8i::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataLine2.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataLine2.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataLine2.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -17,7 +17,7 @@
* 2 -------- 3 -------- 4
*
* After adding cohesive elements
- * 2 -------- 3 -- 5 -------- 4
+ * 2 -------- 5 -- 3 -------- 4
*/
#include "CohesiveDataLine2.hh"
@@ -44,8 +44,8 @@
};
const int pylith::faults::CohesiveDataLine2::_cells[] = {
- 2, 3,
- 5, 4,
+ 2, 5,
+ 3, 4,
3, 5,
};
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4g.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4g.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4g.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -12,31 +12,31 @@
/* Original mesh
*
- * Cells are 0-3, vertices are 4-12.
+ * Cells are 0-4, vertices are 5-15.
*
* 7 --------12 --------15
* | | |
* | | |
* | | |
+ * | 0 | 2 |
* | | |
* | | |
* | | |
* | | |
- * | | |
* 6 --------11 --------14
* | / | |
- * | / | |
+ * | 3 / | |
* | / | |
* 5-----9 | |
+ * | | 1 |
+ * | 4 | |
* | | |
* | | |
- * | | |
- * | | |
* 8---10 --------13
*
* After adding cohesive elements
*
- * Cells are 0-3,16-17 vertices are 4-15.
+ * Cells are 0-4,19-20 vertices are 5-18.
*
* 7 --------12 -- 18 --------15
* | | | |
@@ -97,13 +97,13 @@
};
const int pylith::faults::CohesiveDataQuad4g::_cells[] = {
- 6, 17, 18, 7,
- 11, 10, 13, 14,
- 15, 12, 11, 14,
- 6, 5, 9, 17,
- 9, 8, 16, 17,
- 11, 10, 17, 16,
- 12, 11, 18, 17,
+ 6, 11, 12, 7,
+ 17, 16, 13, 14,
+ 15, 18, 17, 14,
+ 6, 5, 9, 11,
+ 9, 8, 10, 11,
+ 10, 11, 16, 17,
+ 11, 12, 17, 18,
};
const int pylith::faults::CohesiveDataQuad4g::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4h.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4h.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataQuad4h.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -46,13 +46,13 @@
* | | | | |
* | | | | |
*30 ----31 ----27-19 ----20
- * | 32 | | |
- *17 ----18 | |
- * | | 7 | 8 |
- * | 6 | | |
- * | | | |
- * | | | |
- *21 ----22 ----23 -------24
+ * | 32 |/ | |
+ *17 ----18 | |
+ * | | 7 | 8 |
+ * | 6 | | |
+ * | | | |
+ * | | | |
+ *21 ----22 ------23------24
*
*/
@@ -110,10 +110,10 @@
10, 14, 26, 25,
11, 15, 16, 12,
13, 30, 31, 14,
- 14, 31, 27, 26,
+ 14, 18, 27, 26,
15, 19, 20, 16,
17, 21, 22, 18,
- 18, 22, 23, 27,
+ 18, 22, 23, 19,
19, 23, 24, 20,
11, 15, 25, 26,
15, 19, 26, 27,
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4::_cells[] = {
3, 4, 5, 2,
7, 9, 8, 6,
- 5, 4, 3, 9, 8, 7
+ 4, 3, 5, 8, 7, 9
};
const int pylith::faults::CohesiveDataTet4::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4b.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4b.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4b.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4b::_cells[] = {
2, 7, 9, 8,
3, 6, 5, 4,
- 4, 5, 3, 8, 9, 7
+ 5, 3, 4, 9, 7, 8
};
const int pylith::faults::CohesiveDataTet4b::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4c.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4c.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4c.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4c::_cells[] = {
5, 4, 2, 3,
6, 8, 9, 7,
- 5, 4, 3, 9, 8, 7
+ 4, 3, 5, 8, 7, 9,
};
const int pylith::faults::CohesiveDataTet4c::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4d.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4d.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4d.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4d::_cells[] = {
3, 2, 4, 5,
7, 8, 6, 9,
- 5, 4, 3, 9, 8, 7
+ 4, 3, 5, 8, 7, 9
};
const int pylith::faults::CohesiveDataTet4d::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4f.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4f.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4f.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4f::_cells[] = {
3, 5, 4, 6,
7, 8, 9, 2,
- 4, 5, 3, 8, 9, 7
+ 5, 3, 4, 9, 7, 8
};
const int pylith::faults::CohesiveDataTet4f::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4g.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4g.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4g.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4g::_cells[] = {
3, 5, 4, 6,
7, 9, 2, 8,
- 4, 5, 3, 8, 9, 7
+ 5, 3, 4, 9, 7, 8
};
const int pylith::faults::CohesiveDataTet4g::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4h.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4h.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4h.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -57,7 +57,7 @@
const int pylith::faults::CohesiveDataTet4h::_cells[] = {
9, 8, 2, 7,
5, 4, 3, 6,
- 3, 4, 5, 7, 8, 9
+ 4, 5, 3, 8, 9, 7
};
const int pylith::faults::CohesiveDataTet4h::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4i.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4i.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4i.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -64,8 +64,8 @@
10, 12, 11, 9,
13, 9, 12, 10,
4, 5, 8, 7,
- 7, 6, 5, 12, 11, 10,
- 5, 8, 7, 10, 13, 12,
+ 6, 5, 7, 11, 10, 12,
+ 8, 7, 5, 13, 12, 10
};
const int pylith::faults::CohesiveDataTet4i::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4j.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4j.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTet4j.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -51,13 +51,13 @@
};
const int pylith::faults::CohesiveDataTet4j::_cells[] = {
- 7, 9, 8, 6,
- 17, 15, 13, 14,
+ 7, 9, 8, 6,
+ 11, 9, 13, 14,
16, 13, 17, 15,
10, 9, 11, 7,
- 15, 13, 14, 12,
- 7, 11, 8, 9,
- 11, 9, 10, 17, 15, 16
+ 9, 13, 14, 12,
+ 7, 11, 8, 9,
+ 9, 10, 11, 15, 16, 17
};
const int pylith::faults::CohesiveDataTet4j::_materialIds[] = {
Modified: short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTri3f.cc
===================================================================
--- short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTri3f.cc 2007-11-25 20:52:20 UTC (rev 8325)
+++ short/3D/PyLith/trunk/unittests/libtests/faults/data/CohesiveDataTri3f.cc 2007-11-25 23:37:10 UTC (rev 8326)
@@ -38,7 +38,7 @@
* | / | | / |
* | / 3 | | / 2 |
* | / | | / |
- * 4 -------- 6 --10 -------- 8
+ * 4 -------- 6 --10-6------- 8
*/
#include "CohesiveDataTri3f.hh"
@@ -73,7 +73,7 @@
const int pylith::faults::CohesiveDataTri3f::_cells[] = {
4, 7, 5,
9, 11, 10,
- 10, 8, 9,
+ 6, 8, 9,
6, 7, 4,
6, 7, 10, 11,
};
More information about the cig-commits
mailing list