// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root // SPDX-License-Identifier: LGPL-2.1-or-later /****************************************************************************/ /* */ /* File: gmcheck.c */ /* */ /* Purpose: checks of the data structure */ /* */ /* Author: Stefan Lang */ /* Institut fuer Computeranwendungen III */ /* Universitaet Stuttgart */ /* Pfaffenwaldring 27 */ /* 70569 Stuttgart */ /* email: ug@ica3.uni-stuttgart.de */ /* */ /* History: Juli 1, 1997 moved from ugm.c */ /* */ /* Remarks: */ /* */ /****************************************************************************/ /****************************************************************************/ /* */ /* defines to exclude functions */ /* */ /****************************************************************************/ /****************************************************************************/ /* */ /* include files */ /* system include files */ /* application include files */ /* */ /****************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "evm.h" #include "gm.h" #include "rm.h" #include "dlmgr.h" #include "algebra.h" #include "ugm.h" #include "elements.h" #include "shapes.h" #include "refine.h" #include #ifdef ModelP #include #endif #include "cw.h" USING_UG_NAMESPACES using namespace PPIF; /****************************************************************************/ /* */ /* data structures used in this source file (exported data structures are */ /* in the corresponding include file!) */ /* */ /****************************************************************************/ /****************************************************************************/ /* */ /* definition of exported global variables */ /* */ /****************************************************************************/ /****************************************************************************/ /* */ /* definition of variables global to this source file only (static!) */ /* */ /****************************************************************************/ #ifdef ModelP #if defined(UG_DIM_2) static DOUBLE hghost_overlap = 1.0; #endif #endif /****************************************************************************/ /* */ /* forward declarations of functions used before they are defined */ /* */ /****************************************************************************/ static INT CheckVertex (ELEMENT *theElement, NODE* theNode, VERTEX *theVertex) { ELEMENT *theFather = VFATHER(theVertex); EDGE *theEdge; INT i,nerrors,n; DOUBLE diff; DOUBLE_VECTOR global1; DOUBLE *x[MAX_CORNERS_OF_ELEM]; nerrors = 0; if (SONNODE(theNode) == NULL) { INT cnt = NOOFNODE(theVertex); NODE *Node = theNode; while (Node!=NULL && CORNERTYPE(Node)) { cnt--; Node = (NODE*) NFATHER(Node); } if (cnt != 1) { UserWriteF("elem=" EID_FMTX " node=" ID_FMTX " vertex=" VID_FMTX " NOOFNODE %d wrong\n", EID_PRTX(theElement),ID_PRTX(theNode), VID_PRTX(theVertex), NOOFNODE(theVertex)); nerrors = 1; } } if (theFather==NULL && MASTER(theNode) && LEVEL(theVertex)>0) { #ifdef ModelP if (!CORNERTYPE(theNode)) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } if (nerrors == 0) return(nerrors); #endif UserWriteF("elem=" EID_FMTX " node=" ID_FMTX " vertex=" VID_FMTX " VFATHER=NULL vertex needs VFATHER\n",EID_PRTX(theElement),ID_PRTX(theNode), VID_PRTX(theVertex)); return(nerrors++); } if (theFather!=NULL && MASTER(theNode) && EPRIO(theFather)==PrioHGhost) { #ifdef ModelP if (!CORNERTYPE(theNode)) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } #endif if (nerrors == 0) return(nerrors); UserWriteF("elem=" EID_FMTX " node=" ID_FMTX " vertex=" VID_FMTX " VFATHER=" EID_FMTX " vertex needs VFATHER with prio master or vghost\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex),EID_PRTX(theFather)); return(nerrors++); } if (theFather != NULL) { CORNER_COORDINATES(theFather,n,x); const Dune::FieldVector& global = CVECT(theVertex); const Dune::FieldVector& local = LCVECT(theVertex); LOCAL_TO_GLOBAL(n,x,local,global1); V_DIM_EUKLIDNORM_OF_DIFF(global1,global,diff); if (diff > MAX_PAR_DIST) { nerrors++; #ifdef ModelP if (CORNERTYPE(theNode) || GHOST(theNode)) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } #endif if (nerrors >= 1) { UserWriteF("elem=" EID_FMTX " node=" ID_FMTX "/%d vertex=" VID_FMTX " WARNING VFATHER=%x WARNING diff %f local and global coordinates don't match\n", EID_PRTX(theElement),ID_PRTX(theNode), NTYPE(theNode),VID_PRTX(theVertex),theFather,diff); } } } switch (NTYPE(theNode)) { case (CORNER_NODE) : if (LEVEL(theVertex)==0 && theFather != NULL) { UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " CORNER_NODE has VFATHER\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex)); } #ifdef ModelP IFDEBUG(gm,0) /* break for ghost nodes if debugging off */ if (GHOST(theNode)) break; ENDDEBUG #endif if (LEVEL(theVertex)>0 && theFather == NULL) { UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " CORNER_NODE has no VFATHER\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex)); } break; case (MID_NODE) : /* check ONEDGE and VFATHER */ if (theFather == NULL) { #ifdef ModelP IFDEBUG(gm,0) /* break for ghost nodes if debugging off */ if (GHOST(theNode)) break; ENDDEBUG #endif UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " MID_NODE VFATHER=NULL\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex)); nerrors++; break; } i = ONEDGE(theVertex); theEdge = GetEdge(CORNER(theFather,CORNER_OF_EDGE(theFather,i,0)), CORNER(theFather,CORNER_OF_EDGE(theFather,i,1))); if (theEdge==NULL || theNode!=MIDNODE(theEdge)) { nerrors++; #ifdef ModelP if (EGHOST(theElement)) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } #endif if (nerrors == 0) break; UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " ONEDGE and VFATHER incompatible edgeptr=%08x\n", EID_PRTX(theElement),ID_PRTX(theNode), VID_PRTX(theVertex),theEdge); } break; #ifdef UG_DIM_3 case (SIDE_NODE) : if (theFather == NULL) { nerrors++; #ifdef ModelP if (EPRIO(theElement)==PrioHGhost) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } #endif if (nerrors == 0) break; UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " SIDE_NODE VFATHER=NULL\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex)); break; } else { if (GetSideNode(theFather,ONSIDE(theVertex)) != theNode) { nerrors = 1; UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " inconsistent ONSIDE entry\n", EID_PRTX(theElement),ID_PRTX(theNode), VID_PRTX(theVertex)); } } break; #endif case (CENTER_NODE) : if (theFather == NULL) { nerrors++; #ifdef ModelP if (EGHOST(theElement)) { nerrors = 0; IFDEBUG(gm,1) nerrors = 1; ENDDEBUG } #endif if (nerrors == 0) break; UserWriteF("EID=" EID_FMTX " NID=" ID_FMTX " VID=" VID_FMTX " CENTER_NODE VFATHER=NULL\n", EID_PRTX(theElement),ID_PRTX(theNode),VID_PRTX(theVertex)); break; } break; } return(nerrors); } static INT CheckNode (ELEMENT *theElement, NODE* theNode, INT i) { VERTEX *theVertex = MYVERTEX(theNode); NODE *FatherNode; EDGE *FatherEdge; INT nerrors = 0; SETUSED(theNode,1); if (OBJT(theNode) != NDOBJ) { UserWriteF(" node=" ID_FMTX " has wrong OBJ=%d\n", ID_PRTX(theNode),OBJT(theNode)); return(nerrors++); } switch (NTYPE(theNode)) { case (LEVEL_0_NODE) : if (LEVEL(theNode) > 0) { UserWriteF(" node=" ID_FMTX " has NTYPE=LEVEL_0_NODE" " but is on level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); return(nerrors++); } break; case (CORNER_NODE) : { FatherNode = (NODE *)NFATHER(theNode); if (0) /* this code is for special debugging (980204 s.l.) */ if (GID(theNode)==0x11011 && FatherNode!=NULL) { UserWriteF(" cornernode=" ID_FMTX " has father=" ID_FMTX "\n", ID_PRTX(theNode),ID_PRTX(FatherNode)); } if (FatherNode == NULL) { #ifdef ModelP if (MASTER(theNode)) { #endif UserWriteF(" ERROR cornernode=" ID_FMTX " has no father level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); UserWriteF(" elem=" EID_FMTX, EID_PRTX(theElement)); if (EFATHER(theElement) != NULL) { ELEMENT *theFather = EFATHER(theElement); UserWriteF(" father=" EID_FMTX "\n",EID_PRTX(theFather)); for (int j=0; j < CORNERS_OF_ELEM(theFather); j++) { UserWriteF("son[%d]=" ID_FMTX "\n",j,ID_PRTX(CORNER(theFather,j))); } } else UserWriteF(" father=NULL\n"); nerrors++; #ifdef ModelP } else { INT print = 0; IFDEBUG(gm,1) print = 1; ENDDEBUG if (print) UserWriteF(" WARN cornernode=" ID_FMTX " has no father level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); } #endif } if (FatherNode != NULL) { if (OBJT(FatherNode) != NDOBJ) { UserWriteF(" cornernode=" ID_FMTX " has father of wrong type=%d\n", ID_PRTX(theNode),OBJT(FatherNode)); nerrors++; } else { if (SONNODE(FatherNode) != theNode) { UserWriteF(" cornernode=" ID_FMTX " has node father=" ID_FMTX " with wrong backptr=%x\n", ID_PRTX(theNode),ID_PRTX(FatherNode),SONNODE(FatherNode)); /* TODO: this should be deleted */ if (0) SONNODE(FatherNode) = theNode; else nerrors++; } } } } break; case (MID_NODE) : if (LEVEL(theNode)>0) { FatherEdge = (EDGE *)NFATHER(theNode); if (FatherEdge == NULL) { #ifdef ModelP if (MASTER(theNode)) { #endif UserWriteF(" ERROR midnode=" ID_FMTX " has no father level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); UserWriteF(" elem=" EID_FMTX, EID_PRTX(theElement)); if (EFATHER(theElement) != NULL) UserWriteF(" father=" EID_FMTX "\n",EID_PRTX(EFATHER(theElement))); else UserWriteF(" father=NULL\n"); nerrors++; #ifdef ModelP } else { IFDEBUG(gm,1) UserWriteF(" WARN midnode=" ID_FMTX " has no father level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); ENDDEBUG } #endif } if (FatherEdge != NULL) { if (OBJT(FatherEdge) != EDOBJ) { UserWriteF(" midnode=" ID_FMTX " has father of wrong type=%d obj=\n", ID_PRTX(theNode),OBJT(FatherEdge)); nerrors++; } else { if (MIDNODE(FatherEdge) != theNode) { UserWriteF(" midnode=" ID_FMTX " has edge father=" ID_FMTX " with wrong backptr=%x\n", ID_PRTX(theNode),ID_PRTX(FatherEdge),MIDNODE(FatherEdge)); /* TODO: this should be deleted */ if (0) MIDNODE(FatherEdge) = theNode; else nerrors++; /*nerrors++; temp. auskommentiert, um Reperaturwirkung wirklich nutzen zu koennen */ } } } } else { UserWriteF(" node=" ID_FMTX " is midnode BUT on level=%d\n", ID_PRTX(theNode),LEVEL(theNode)); nerrors++; } break; case (SIDE_NODE) : break; case (CENTER_NODE) : break; default : UserWriteF(" node=" ID_FMTX " has unrecognized NTYPE=%d\n", ID_PRTX(theNode),NTYPE(theNode)); break; } if (theVertex != NULL) { CheckVertex(theElement,theNode,theVertex); } else { UserWriteF("elem=" EID_FMTX " node[%d]=" ID_FMTX " vertex=NULL\n", EID_PRTX(theElement),i,ID_PRTX(theNode)); nerrors++; } return(nerrors); } static INT CheckEdge (ELEMENT *theElement, EDGE* theEdge, UINT i) { INT nerrors = 0; NODE *theNode; VERTEX *theVertex; SETUSED(theEdge,1); /** \todo Commented out because it uses GetElemLink, which does not exist */ #if 0 # if defined(UG_DIM_2) { int elemlink,no_of_elem,No_Of_Elem; NODE *n0,*n1; LINK *l0,*l1; ELEMENT *e0,*e1; n0 = CORNER_OF_EDGE_PTR(theElement,i,0); n1 = CORNER_OF_EDGE_PTR(theElement,i,1); elemlink = GetElemLink(n0,n1,theElement); l0 = LINK0(theEdge); l1 = LINK1(theEdge); e0 = LELEM(l0); e1 = LELEM(l1); /* check number of edge neighbor elements */ no_of_elem = 0; if (e0 != NULL) { no_of_elem++; HEAPFAULT(e0); } if (e1 != NULL) { no_of_elem++; HEAPFAULT(e1); } No_Of_Elem = NO_OF_ELEM(theEdge); if (no_of_elem==0 || No_Of_Elem!=no_of_elem) { UserWriteF("elem=" EID_FMTX " edge%d=" EDID_FMTX " NO_OF_ELEM wrong" "NO_OF_ELEM=%d no_of_elem=%d\n", EID_PRTX(theElement),i,EDID_PRTX(theEdge),No_Of_Elem,no_of_elem); } if (elemlink == 0) { if (e0 != theElement) { UserWriteF("elem=" EID_FMTX " edge%d=" EDID_FMTX " LELEM0 wrong" "elemlink=%d LELEM0=%08x\n", EID_PRTX(theElement),i,EDID_PRTX(theEdge),elemlink, (e0!=NULL) ? EGID(e0) : 0); nerrors++; } } else { if (e1 != theElement) { UserWriteF("elem=" EID_FMTX " edge%d=" EDID_FMTX " LELEM0 wrong" "elemlink=%d LELEM0=%08x\n", EID_PRTX(theElement),i,EDID_PRTX(theEdge),elemlink, (e1!=NULL) ? EGID(e1) : 0); nerrors++; } } } # endif #endif theNode = MIDNODE(theEdge); if (theNode == NULL) { #ifdef DUNE_UGGRID_TET_RULESET if (((REFINE(theElement) == RED) && (TAG(theElement) != TETRAHEDRON)) || ((TAG(theElement) == TETRAHEDRON) && (NSONS(theElement) == 8))) #else if (REFINE(theElement) == RED) #endif { #ifdef ModelP IFDEBUG(gm,1) #endif UserWriteF("elem=" EID_FMTX " edge%d=" EDID_FMTX " midnode NID=NULL" " BUT REFINE(elem)=RED\n",EID_PRTX(theElement),i,EDID_PRTX(theEdge)); nerrors++; #ifdef ModelP ENDDEBUG #endif return(nerrors); } else return(nerrors); } theVertex = MYVERTEX(theNode); if (theVertex == NULL) { UserWriteF("elem=" EID_FMTX " edge=%d/%x midnode NID=" ID_FMTX " vertex=NULL\n", EID_PRTX(theElement),i,theEdge,ID_PRTX(theNode)); return(nerrors++); } if (VFATHER(theVertex) != theElement) return(nerrors); if (i != ONEDGE(theVertex)) { if (EGHOST(theElement)) { IFDEBUG(gm,1) UserWriteF("EID=" EID_FMTX " VID=" VID_FMTX " WARNING edgenumber of vertex wrong\n", EID_PRTX(theElement),VID_PRTX(theVertex)); ENDDEBUG } else { UserWriteF("EID=" EID_FMTX " VID=" VID_FMTX " ERROR edgenumber of vertex wrong\n", EID_PRTX(theElement),VID_PRTX(theVertex)); /*nerrors++; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/ } return(nerrors); } return(nerrors); } #ifdef ModelP int EdgeHasTMasterCopy (DDD::DDDContext& context, ELEMENT *e, int i) { EDGE* edge = GetEdge(CORNER_OF_EDGE_PTR(e,i,0),CORNER_OF_EDGE_PTR(e,i,1)); assert(edge != NULL); const auto& proclist = DDD_InfoProcListRange(context, PARHDR(edge)); const int nmaster = CheckProcListCons(proclist, PrioMaster); const int nborder = CheckProcListCons(proclist, PrioBorder); const int nall = nmaster + nborder; if (0) assert(nall==1 || nall==2); if (nall > 2) { UserWriteF("EID=" EID_FMTX " EDID=" EDID_FMTX " ERROR edge%d has mastertype prios=%d\n", EID_PRTX(e),EDID_PRTX(edge),i,nall); } return(nall-1); } #endif static INT CheckElement (GRID *theGrid, ELEMENT *theElement, INT *SideError, INT *EdgeError, INT *NodeError, INT *ESonError, INT *NSonError, INT *errors) { INT j,k,l,n,nsons,bserror,nerrors; NODE *theNode,*theNode1; EDGE *theEdge; ELEMENT *NbElement,*theFather; ELEMENT *SonList[MAX_SONS]; VERTEX *theVertex,*Vertices[MAX_CORNERS_OF_ELEM]; #if defined(ModelP) && defined(UG_DIM_2) auto& dddContext = theGrid->dddContext(); #endif *SideError = 0; *NodeError = 0; *EdgeError = 0; *ESonError = 0; *NSonError = 0; nerrors = 0; bserror = 0; /* check level */ if (GLEVEL(theGrid) != LEVEL(theElement)) { UserWriteF("elem=" EID_FMTX " ERROR level=%2d but gridlevel=%2d\n", EID_PRTX(theElement),LEVEL(theElement),GLEVEL(theGrid)); nerrors++; } /* check side information */ for (INT i=0; i=1 #endif ) for (l=1; l= EDGES_OF_ELEM(theFather)) { #ifdef ModelP if (EMASTER(theFather)) { IFDEBUG(gm,1) UserWriteF("ELEM(" EID_FMTX ") WARNING MIDNODE=NULL" " for mid node[%d]" ID_FMTX "\n", EID_PRTX(theFather),i,ID_PRTX(theNode)); ENDDEBUG } #else UserWriteF("ELEM(" EID_FMTX ") ERROR MIDNODE=NULL" " for mid node[%d]=" ID_FMTX "\n", EID_PRTX(theFather),i,ID_PRTX(theNode)); nerrors++; #endif } } } /* check son information of father */ if (GetAllSons(theFather,SonList)) { UserWrite("cannot get sons\n"); return (1); } UINT i; for (i=0; i 0) { if (EMASTER(theElement)) { UserWriteF("ELEM(" EID_FMTX ") ERROR father=NULL\n", EID_PRTX(theElement)); nerrors++; } } } #endif /* check son information */ if (NSONS(theElement)!=0) { nsons = NSONS(theElement); if (GetAllSons(theElement,SonList)) { UserWrite("cannot get sons\n"); return (1); } for (INT i=0; (SonList[i]!=NULL || i= nsons) { UserWriteF("ELEM(" EID_FMTX "): element has nsons=%d but " " son[%d]=" EID_FMTX " exists\n", EID_PRTX(theElement), NSONS(theElement),i,EID_PRTX(SonList[i])); /* TODO: activate if NSONS is consistent */ if (0) nerrors++; } if (SonList[i] == NULL) { UserWriteF("ELEM(" EID_FMTX "): element has nsons=%d but " " son[%d]=NULL\n", EID_PRTX(theElement),nsons,i); *ESonError |= (1< 0) { UserWriteF("ELEM(" EID_FMTX "): element has %d errors\n", EID_PRTX(theElement),nerrors); *errors = nerrors; } if (*SideError || *EdgeError || *NodeError || *ESonError || *NSonError) return (1); return (0); } #if defined(UG_DIM_2) || defined(ModelP) INT CheckSubdomains (const MULTIGRID *theMG) { return (0); } #else static INT CheckElementSubdomains (GRID *theGrid, ELEMENT *theElement, INT *NodeError, INT *EdgeError, INT *NbError, INT *FatherError, INT *errors) { INT side,found,i,j,k,nerrors,sdid,sc; NODE *theNode,*n1,*n2,*nbn1,*nbn2,*nbn3,*nbn4; EDGE *theEdge,*father_edge; ELEMENT *theFather; VERTEX *theVertex; *NodeError = 0; *EdgeError = 0; *NbError = 0; *FatherError = 0; nerrors = 0; /* check side information */ for (i=0; iNTYPE(n2)) {theNode=n1; n1=n2; n2=theNode;} switch (NTYPE(n1)|(NTYPE(n2)<<4)) { case (CORNER_NODE | (CORNER_NODE<<4)) : father_edge = GetEdge(NFATHER(n1),NFATHER(n2)); if (father_edge!=NULL) sdid=EDSUBDOM(father_edge); else { /* do fathers of n1, n2 lies on a side (of the father) which has BNDS? */ for (j=0; j=0 && (OBJT(theFather)==BEOBJ) && SIDE_ON_BND(theFather,side)) sdid=0; } break; case (MID_NODE | (MID_NODE<<4)) : father_edge = NFATHEREDGE(n1); assert(father_edge!=NULL); nbn1 = NBNODE(LINK0(father_edge)); nbn2 = NBNODE(LINK1(father_edge)); father_edge = NFATHEREDGE(n2); assert(father_edge!=NULL); nbn3 = NBNODE(LINK0(father_edge)); nbn4 = NBNODE(LINK1(father_edge)); /* do all nodes nbn1, nbn2, nbn3, nbn4 ly on the same side of father? */ side=-1; for (j=0; j=0 && (OBJT(theFather)==BEOBJ) && SIDE_ON_BND(theFather,side)) sdid=0; break; case (CORNER_NODE | (SIDE_NODE<<4)) : theVertex = MYVERTEX(n2); if (VFATHER(theVertex)==theFather) side = ONSIDE(theVertex); else side = ONNBSIDE(theVertex); if ((OBJT(theFather)==BEOBJ) && SIDE_ON_BND(theFather,side)) for (k=0; k0) { UserWriteF("ELEM(" EID_FMTX "): element has %d errors\n",EID_PRTX(theElement),nerrors); *errors = nerrors; } if (*NodeError || *EdgeError || *NbError || *FatherError) return (1); return (0); } INT CheckSubdomains (MULTIGRID *theMG) { GRID *theGrid; NODE *theNode; EDGE *theEdge; LINK *theLink; ELEMENT *theElement; INT i,j,k,nerror,NodeError,EdgeError,NbError,FatherError,sd_errors; /* init */ nerror=0; /* first level 0 */ theGrid = GRID_ON_LEVEL(theMG,0); for (theNode=PFIRSTNODE(theGrid); theNode!=NULL; theNode=SUCCN(theNode)) for (theLink=START(theNode); theLink!=NULL; theLink=NEXT(theLink)) SETUSED(MYEDGE(theLink),1); for (theElement=PFIRSTELEMENT(theGrid); theElement!=NULL; theElement=SUCCE(theElement)) if (OBJT(theElement)==BEOBJ) for (i=0; ippifContext(), errors); #endif if (errors != GM_OK) { totalerrors += errors; error++; UserWriteF(" geometry BAD: %d errors",errors); } else UserWrite(" ok"); } /* check algebraic data structures */ if (checkalgebra) { UserWrite(", algebra:"); errors = CheckAlgebra(theGrid); #ifdef ModelP errors = UG_GlobalSumINT(theGrid->ppifContext(), errors); #endif if (errors != GM_OK) { totalerrors += errors; error++; UserWriteF(" algebra BAD: %d errors",errors); } else UserWrite(" ok"); } /* check lists and counters */ if (checklists) { UserWrite(", lists:"); errors = CheckLists(theGrid); #ifdef ModelP errors = UG_GlobalSumINT(theGrid->ppifContext(), errors); #endif if (errors != GM_OK) { totalerrors += errors; error++; UserWriteF(" lists BAD: %d errors",errors); } else UserWrite(" ok"); } #ifdef ModelP /* check interfaces to other procs */ if (checkif) { UserWrite(", interface:"); errors = CheckInterfaces(theGrid); #ifdef ModelP errors = UG_GlobalSumINT(theGrid->ppifContext(), errors); #endif if (errors != GM_OK) { totalerrors += errors; error++; UserWriteF(" interfaces BAD: %d errors",errors); } else UserWrite(" ok"); } #endif if (totalerrors) UserWriteF(", grid BAD: %d check(s) with %d totalerror(s)", error,totalerrors); else UserWrite(", grid ok"); return(error); }