/*@C PetscEmacsClientErrorHandler - Error handler that uses the emacsclient program to load the file where the error occured. Then calls the "previous" error handler. Not Collective Input Parameters: + comm - communicator over which error occured . line - the line number of the error (indicated by __LINE__) . func - the function where error is detected (indicated by __FUNCT__) . file - the file in which the error was detected (indicated by __FILE__) . dir - the directory of the file (indicated by __SDIR__) . mess - an error text string, usually just printed to the screen . n - the generic error number . p - specific error number - ctx - error handler context Options Database Key: . -on_error_emacs <machinename> Level: developer Notes: You must put (server-start) in your .emacs file for the emacsclient software to work Most users need not directly employ this routine and the other error handlers, but can instead use the simplified interface SETERRQ, which has the calling sequence $ SETERRQ(PETSC_COMM_SELF,number,p,mess) Notes for experienced users: Use PetscPushErrorHandler() to set the desired error handler. Developer Note: Since this is an error handler it cannot call CHKERRQ(); thus we just return if an error is detected. Concepts: emacs^going to on error Concepts: error handler^going to line in emacs .seealso: PetscPushErrorHandler(), PetscAttachDebuggerErrorHandler(), PetscAbortErrorHandler() @*/ PetscErrorCode PetscEmacsClientErrorHandler(MPI_Comm comm,int line,const char *fun,const char *file,const char *dir,PetscErrorCode n,PetscErrorType p,const char *mess,void *ctx) { PetscErrorCode ierr; char command[PETSC_MAX_PATH_LEN]; const char *pdir; FILE *fp; PetscInt rval; PetscFunctionBegin; ierr = PetscGetPetscDir(&pdir);if (ierr) PetscFunctionReturn(ierr); sprintf(command,"cd %s; emacsclient --no-wait +%d %s%s\n",pdir,line,dir,file); #if defined(PETSC_HAVE_POPEN) ierr = PetscPOpen(MPI_COMM_WORLD,(char*)ctx,command,"r",&fp);if (ierr) PetscFunctionReturn(ierr); ierr = PetscPClose(MPI_COMM_WORLD,fp,&rval);if (ierr) PetscFunctionReturn(ierr); #else SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP_SYS,"Cannot run external programs on this machine"); #endif ierr = PetscPopErrorHandler();if (ierr) PetscFunctionReturn(ierr); /* remove this handler from the stack of handlers */ if (!eh) { ierr = PetscTraceBackErrorHandler(comm,line,fun,file,dir,n,p,mess,0);if (ierr) PetscFunctionReturn(ierr); } else { ierr = (*eh->handler)(comm,line,fun,file,dir,n,p,mess,eh->ctx);if (ierr) PetscFunctionReturn(ierr); } PetscFunctionReturn(ierr); }
PetscErrorCode petscConverged(KSP ksp, PetscInt n, PetscReal rnorm, KSPConvergedReason * reason, void * ctx) { // Cast the context pointer coming from PETSc to an FEProblem& and // get a reference to the System from it. FEProblem & problem = *static_cast<FEProblem *>(ctx); // Let's be nice and always check PETSc error codes. PetscErrorCode ierr = 0; // We want the default behavior of the KSPDefaultConverged test, but // we don't want PETSc to die in that function with a CHKERRQ // call... that is probably extremely unlikely/impossible, but just // to be on the safe side, we push a different error handler before // calling KSPDefaultConverged(). ierr = PetscPushErrorHandler(PetscReturnErrorHandler, /*void* ctx=*/ PETSC_NULL); CHKERRABORT(problem.comm().get(),ierr); #if PETSC_VERSION_LESS_THAN(3,0,0) // Prior to PETSc 3.0.0, you could call KSPDefaultConverged with a NULL context // pointer, as it was unused. KSPDefaultConverged(ksp, n, rnorm, reason, PETSC_NULL); #elif PETSC_RELEASE_LESS_THAN(3,5,0) // As of PETSc 3.0.0, you must call KSPDefaultConverged with a // non-NULL context pointer which must be created with // KSPDefaultConvergedCreate(), and destroyed with // KSPDefaultConvergedDestroy(). void* default_ctx = NULL; KSPDefaultConvergedCreate(&default_ctx); KSPDefaultConverged(ksp, n, rnorm, reason, default_ctx); KSPDefaultConvergedDestroy(default_ctx); #else // As of PETSc 3.5.0, use KSPConvergedDefaultXXX void* default_ctx = NULL; KSPConvergedDefaultCreate(&default_ctx); KSPConvergedDefault(ksp, n, rnorm, reason, default_ctx); KSPConvergedDefaultDestroy(default_ctx); #endif // Pop the Error handler we pushed on the stack to go back // to default PETSc error handling behavior. ierr = PetscPopErrorHandler(); CHKERRABORT(problem.comm().get(),ierr); // Get tolerances from the KSP object PetscReal rtol = 0.; PetscReal atol = 0.; PetscReal dtol = 0.; PetscInt maxits = 0; ierr = KSPGetTolerances(ksp, &rtol, &atol, &dtol, &maxits); CHKERRABORT(problem.comm().get(),ierr); // Now do some additional MOOSE-specific tests... std::string msg; MooseLinearConvergenceReason moose_reason = problem.checkLinearConvergence(msg, n, rnorm, rtol, atol, dtol, maxits); switch (moose_reason) { case MOOSE_CONVERGED_RTOL: *reason = KSP_CONVERGED_RTOL; break; case MOOSE_CONVERGED_ITS: *reason = KSP_CONVERGED_ITS; break; default: { // If it's not either of the two specific cases we handle, just go // with whatever PETSc decided in KSPDefaultConverged. break; } } return 0; }
PetscErrorCode EPSSetUp_LAPACK(EPS eps) { PetscErrorCode ierr,ierra,ierrb; PetscBool isshift,denseok=PETSC_FALSE; Mat A,B,OP,Adense,Bdense; PetscScalar shift,*Ap,*Bp; PetscInt i,ld,nmat; KSP ksp; PC pc; Vec v; PetscFunctionBegin; eps->ncv = eps->n; if (eps->mpd) { ierr = PetscInfo(eps,"Warning: parameter mpd ignored\n");CHKERRQ(ierr); } if (!eps->which) { ierr = EPSSetWhichEigenpairs_Default(eps);CHKERRQ(ierr); } if (eps->balance!=EPS_BALANCE_NONE) { ierr = PetscInfo(eps,"Warning: balancing ignored\n");CHKERRQ(ierr); } if (eps->extraction) { ierr = PetscInfo(eps,"Warning: extraction type ignored\n");CHKERRQ(ierr); } ierr = EPSAllocateSolution(eps,0);CHKERRQ(ierr); /* attempt to get dense representations of A and B separately */ ierr = PetscObjectTypeCompare((PetscObject)eps->st,STSHIFT,&isshift);CHKERRQ(ierr); if (isshift) { ierr = STGetNumMatrices(eps->st,&nmat);CHKERRQ(ierr); ierr = STGetOperators(eps->st,0,&A);CHKERRQ(ierr); if (nmat>1) { ierr = STGetOperators(eps->st,1,&B);CHKERRQ(ierr); } PetscPushErrorHandler(PetscIgnoreErrorHandler,NULL); ierra = SlepcMatConvertSeqDense(A,&Adense);CHKERRQ(ierr); if (eps->isgeneralized) { ierrb = SlepcMatConvertSeqDense(B,&Bdense);CHKERRQ(ierr); } else { ierrb = 0; } PetscPopErrorHandler(); denseok = (ierra == 0 && ierrb == 0)? PETSC_TRUE: PETSC_FALSE; } else Adense = NULL; /* setup DS */ if (denseok) { if (eps->isgeneralized) { if (eps->ishermitian) { if (eps->ispositive) { ierr = DSSetType(eps->ds,DSGHEP);CHKERRQ(ierr); } else { ierr = DSSetType(eps->ds,DSGNHEP);CHKERRQ(ierr); /* TODO: should be DSGHIEP */ } } else { ierr = DSSetType(eps->ds,DSGNHEP);CHKERRQ(ierr); } } else { if (eps->ishermitian) { ierr = DSSetType(eps->ds,DSHEP);CHKERRQ(ierr); } else { ierr = DSSetType(eps->ds,DSNHEP);CHKERRQ(ierr); } } } else { ierr = DSSetType(eps->ds,DSNHEP);CHKERRQ(ierr); } ierr = DSAllocate(eps->ds,eps->ncv);CHKERRQ(ierr); ierr = DSGetLeadingDimension(eps->ds,&ld);CHKERRQ(ierr); ierr = DSSetDimensions(eps->ds,eps->ncv,0,0,0);CHKERRQ(ierr); if (denseok) { ierr = STGetShift(eps->st,&shift);CHKERRQ(ierr); if (shift != 0.0) { ierr = MatShift(Adense,shift);CHKERRQ(ierr); } /* use dummy pc and ksp to avoid problems when B is not positive definite */ ierr = STGetKSP(eps->st,&ksp);CHKERRQ(ierr); ierr = KSPSetType(ksp,KSPPREONLY);CHKERRQ(ierr); ierr = KSPGetPC(ksp,&pc);CHKERRQ(ierr); ierr = PCSetType(pc,PCNONE);CHKERRQ(ierr); } else { ierr = PetscInfo(eps,"Using slow explicit operator\n");CHKERRQ(ierr); ierr = STComputeExplicitOperator(eps->st,&OP);CHKERRQ(ierr); ierr = MatDestroy(&Adense);CHKERRQ(ierr); ierr = SlepcMatConvertSeqDense(OP,&Adense);CHKERRQ(ierr); } /* fill DS matrices */ ierr = VecCreateSeqWithArray(PETSC_COMM_SELF,1,ld,NULL,&v);CHKERRQ(ierr); ierr = DSGetArray(eps->ds,DS_MAT_A,&Ap);CHKERRQ(ierr); for (i=0;i<ld;i++) { ierr = VecPlaceArray(v,Ap+i*ld);CHKERRQ(ierr); ierr = MatGetColumnVector(Adense,v,i);CHKERRQ(ierr); ierr = VecResetArray(v);CHKERRQ(ierr); } ierr = DSRestoreArray(eps->ds,DS_MAT_A,&Ap);CHKERRQ(ierr); if (denseok && eps->isgeneralized) { ierr = DSGetArray(eps->ds,DS_MAT_B,&Bp);CHKERRQ(ierr); for (i=0;i<ld;i++) { ierr = VecPlaceArray(v,Bp+i*ld);CHKERRQ(ierr); ierr = MatGetColumnVector(Bdense,v,i);CHKERRQ(ierr); ierr = VecResetArray(v);CHKERRQ(ierr); } ierr = DSRestoreArray(eps->ds,DS_MAT_B,&Bp);CHKERRQ(ierr); } ierr = VecDestroy(&v);CHKERRQ(ierr); ierr = MatDestroy(&Adense);CHKERRQ(ierr); if (!denseok) { ierr = MatDestroy(&OP);CHKERRQ(ierr); } if (denseok && eps->isgeneralized) { ierr = MatDestroy(&Bdense);CHKERRQ(ierr); } PetscFunctionReturn(0); }
void PETSC_STDCALL petscpoperrorhandler_(int *__ierr ){ *__ierr = PetscPopErrorHandler(); }
int main(int argc,char **args) { Mat A; /* linear system matrix */ PetscErrorCode ierr; PetscMPIInt rank=0; PetscBool flg; PetscViewer fd; /* viewer */ PetscViewer log; char file[PETSC_MAX_PATH_LEN]; char logfile[PETSC_MAX_PATH_LEN]; char lockfile[PETSC_MAX_PATH_LEN], tmpstr[PETSC_MAX_PATH_LEN], dirname[PETSC_MAX_PATH_LEN], matrix[PETSC_MAX_PATH_LEN]; char hash[20]; PetscLogDouble solveTime,endTime,startTime; PetscInt its; PetscReal norm; KSP ksp; // Linear solver context Vec b,x,u; // RHS, solution, vector for norm calculation PetscScalar one = 1.0; PetscInt m, n, i; FILE *lock; /* if (rank == 0) { printf("Command line arguments:\n"); for (i=0; i < argc; i++) printf("%d: %s\n", i, args[i]); } // Save args int argcount = argc; char **argv = (char**) malloc (argc*sizeof(char*)); for (i=0; i < argc; i++) { argv[i] = (char*) malloc(strlen(args[i]) + 1); strcpy(argv[i],args[i]); } MPI_Comm_rank(MPI_COMM_WORLD,&rank); */ PetscInitialize(&argc,&args,(char *)0,help); ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank);CHKERRQ(ierr); ierr = PetscOptionsGetString(PETSC_NULL,"-hash",hash,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); if (!flg) { strcpy(hash,"nohash"); } ierr = PetscOptionsGetString(PETSC_NULL,"-f",file,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr); if (!flg) { PetscPrintf(PETSC_COMM_WORLD,"Must indicate matrix file with the -f option"); } /* Create lock file */ if (rank == 0) { for (i = strlen(file); i> 0; i--) if (file[i] == '.') break; strncpy(tmpstr, file, i-1); for (i = strlen(tmpstr); i> 0; i--) if (file[i] == '/') break; strncpy(dirname, tmpstr, i); dirname[i] = '\0'; sprintf(lockfile,"%s/../timing/.%s.%s", dirname, basename(tmpstr), hash); sprintf(logfile,"%s/../timing/%s.%s.log", dirname, basename(tmpstr), hash); lock = fopen(lockfile, "w"); fprintf(lock, "%s\n", file); fclose(lock); } /* Read file */ ierr = PetscViewerBinaryOpen(PETSC_COMM_WORLD,file,FILE_MODE_READ,&fd);CHKERRQ(ierr); // Create matrix ierr = MatCreate(PETSC_COMM_WORLD,&A);CHKERRQ(ierr); ierr = MatSetType(A,MATMPIAIJ); CHKERRQ(ierr); ierr = MatSetFromOptions(A);CHKERRQ(ierr); // Load matrix from file ierr = MatLoad(A,fd);CHKERRQ(ierr); ierr = PetscViewerDestroy(&fd);CHKERRQ(ierr); ierr = MatGetSize(A, &m, &n); CHKERRQ(ierr); // Assemble matrix //ierr = MatAssemblyBegin(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); //ierr = MatAssemblyEnd(A,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr); // Create RHS vector ierr = VecCreate(PETSC_COMM_WORLD,&b);CHKERRQ(ierr); ierr = VecSetSizes(b,PETSC_DECIDE,n); CHKERRQ(ierr); ierr = VecSetFromOptions(b);CHKERRQ(ierr); ierr = VecSet(b,one); CHKERRQ(ierr); //ierr = VecLoad(b,fd);CHKERRQ(ierr); // Create vectors x and u ierr = VecDuplicate(b,&x);CHKERRQ(ierr); ierr = VecDuplicate(b,&u);CHKERRQ(ierr); // Create KSP ierr = KSPCreate(PETSC_COMM_WORLD,&ksp); CHKERRQ(ierr); ierr = KSPSetInitialGuessNonzero(ksp,PETSC_FALSE);CHKERRQ(ierr); ierr = KSPSetOperators(ksp,A,A);CHKERRQ(ierr); ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr); // Setup KSP ierr = KSPSetUp(ksp);CHKERRQ(ierr); ierr = KSPSetUpOnBlocks(ksp);CHKERRQ(ierr); // Get start time ierr = PetscTime(&startTime);CHKERRQ(ierr); // Get KSP and PC type KSPType kt; ierr = KSPGetType(ksp,&kt); PC pc; ierr = KSPGetPC(ksp,&pc); PCType pt; ierr = PCGetType(pc,&pt); // Print method info ierr = PetscViewerASCIIOpen(PETSC_COMM_WORLD, logfile, &log); CHKERRQ(ierr); ierr = PetscViewerASCIIPrintf(log, "Hash: %s\n", hash); ierr = PetscViewerASCIIPrintf(log, "%s | %s",kt,pt);CHKERRQ(ierr); // Make sure the program doesn't crash // while trying to solve the system PetscPushErrorHandler(PetscIgnoreErrorHandler,NULL); ierr = KSPSolve(ksp,b,x); PetscPopErrorHandler(); // Check if anything went wrong if(ierr == 0 || ierr == -1){ // If no error occurred or stopped by MyKSPMonitor, // compute normal and stuff ierr = KSPGetIterationNumber(ksp,&its);CHKERRQ(ierr); ierr = MatMult(A,x,u);CHKERRQ(ierr); ierr = VecAXPY(u,-1.0,b);CHKERRQ(ierr); ierr = VecNorm(u,NORM_2,&norm);CHKERRQ(ierr); ierr = PetscTime(&endTime);CHKERRQ(ierr); // Compute solve time solveTime = endTime - startTime; // Check if KSP converged KSPConvergedReason reason; KSPGetConvergedReason(ksp,&reason); // Print convergence code, solve time, preconditioned norm, iterations ierr = PetscViewerASCIIPrintf(log, " | %D | %e | %g | %D\n",reason,solveTime,norm,its);CHKERRQ(ierr); ierr = KSPView(ksp,log); ierr = PCView(pc,log); ierr = PetscLogView(log); } else{ // Disaster happened, bail out if (rank == 0) remove(lockfile); PetscFinalize(); return 0; } // Again, destroy KSP and vector ierr = KSPDestroy(&ksp);CHKERRQ(ierr); ierr = VecDestroy(&x);CHKERRQ(ierr); ierr = VecDestroy(&b);CHKERRQ(ierr); ierr = VecDestroy(&u);CHKERRQ(ierr); if (rank == 0) remove(lockfile); PetscFinalize(); return 0; }