Subversion Repositories slepc-dev

Compare Revisions

Ignore whitespace Rev 2212 → Rev 2213

/trunk/include/slepcqep.h
27,7 → 27,7
#include "slepceps.h"
PETSC_EXTERN_CXX_BEGIN
 
extern PetscCookie QEP_COOKIE;
extern PetscClassId QEP_CLASSID;
 
/*S
QEP - Abstract SLEPc object that manages all the quadratic eigenvalue
/trunk/include/slepcst.h
26,7 → 26,7
#include "petscksp.h"
PETSC_EXTERN_CXX_BEGIN
 
extern PetscCookie ST_COOKIE;
extern PetscClassId ST_CLASSID;
 
/*S
ST - Abstract SLEPc object that manages spectral transformations.
/trunk/include/slepceps.h
28,7 → 28,7
#include "slepcip.h"
PETSC_EXTERN_CXX_BEGIN
 
extern PetscCookie EPS_COOKIE;
extern PetscClassId EPS_CLASSID;
 
/*S
EPS - Abstract SLEPc object that manages all the eigenvalue
/trunk/include/slepcip.h
24,7 → 24,7
#include "slepcsys.h"
PETSC_EXTERN_CXX_BEGIN
 
extern PetscCookie IP_COOKIE;
extern PetscClassId IP_CLASSID;
 
/*E
IPOrthogonalizationType - determines what type of orthogonalization to use
/trunk/include/slepcsvd.h
27,7 → 27,7
#include "slepceps.h"
PETSC_EXTERN_CXX_BEGIN
 
extern PetscCookie SVD_COOKIE;
extern PetscClassId SVD_CLASSID;
 
/*S
SVD - Abstract SLEPc object that manages all the singular value
/trunk/src/qep/interface/qepsolve.c
54,7 → 54,7
char filename[PETSC_MAX_PATH_LEN];
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
 
flg = PETSC_FALSE;
ierr = PetscOptionsGetTruth(((PetscObject)qep)->prefix,"-qep_view_binary",&flg,PETSC_NULL);CHKERRQ(ierr);
169,7 → 169,7
PetscErrorCode QEPGetIterationNumber(QEP qep,PetscInt *its)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidIntPointer(its,2);
*its = qep->its;
PetscFunctionReturn(0);
198,7 → 198,7
PetscErrorCode QEPGetConverged(QEP qep,PetscInt *nconv)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidIntPointer(nconv,2);
*nconv = qep->nconv;
PetscFunctionReturn(0);
234,7 → 234,7
PetscErrorCode QEPGetConvergedReason(QEP qep,QEPConvergedReason *reason)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidIntPointer(reason,2);
*reason = qep->reason;
PetscFunctionReturn(0);
278,7 → 278,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (!qep->eigr || !qep->eigi || !qep->V) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "QEPSolve must be called first");
}
348,7 → 348,7
PetscErrorCode QEPGetErrorEstimate(QEP qep, PetscInt i, PetscReal *errest)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (!qep->eigr || !qep->eigi) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "QEPSolve must be called first");
}
465,7 → 465,7
PetscScalar kr,ki;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(norm,3);
ierr = VecDuplicate(qep->V[0],&xr);CHKERRQ(ierr);
ierr = VecDuplicate(qep->V[0],&xi);CHKERRQ(ierr);
546,7 → 546,7
PetscScalar kr,ki;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(error,3);
ierr = VecDuplicate(qep->V[0],&xr);CHKERRQ(ierr);
ierr = VecDuplicate(qep->V[0],&xi);CHKERRQ(ierr);
784,7 → 784,7
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (matvecs) *matvecs = qep->matvecs;
if (dots) {
ierr = IPGetOperationCounters(qep->ip,dots);CHKERRQ(ierr);
/trunk/src/qep/interface/qepmon.c
77,7 → 77,7
void *mctx,PetscErrorCode (*monitordestroy)(void*))
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (qep->numbermonitors >= MAXQEPMONITORS) {
SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Too many QEP monitors set");
}
112,7 → 112,7
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
for (i=0; i<qep->numbermonitors; i++) {
if (qep->monitordestroy[i]) {
ierr = (*qep->monitordestroy[i])(qep->monitorcontext[i]);CHKERRQ(ierr);
143,7 → 143,7
PetscErrorCode QEPGetMonitorContext(QEP qep, void **ctx)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
*ctx = (qep->monitorcontext[0]);
PetscFunctionReturn(0);
}
/trunk/src/qep/interface/qepsetup.c
52,7 → 52,7
PetscReal knorm,mnorm,norm;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
 
if (qep->setupcalled) PetscFunctionReturn(0);
 
196,10 → 196,10
PetscInt m,n,m0;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(M,MAT_COOKIE,2);
PetscValidHeaderSpecific(C,MAT_COOKIE,3);
PetscValidHeaderSpecific(K,MAT_COOKIE,4);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidHeaderSpecific(M,MAT_CLASSID,2);
PetscValidHeaderSpecific(C,MAT_CLASSID,3);
PetscValidHeaderSpecific(K,MAT_CLASSID,4);
PetscCheckSameComm(qep,1,M,2);
PetscCheckSameComm(qep,1,C,3);
PetscCheckSameComm(qep,1,K,4);
258,7 → 258,7
PetscErrorCode QEPGetOperators(QEP qep, Mat *M, Mat *C,Mat *K)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (M) { PetscValidPointer(M,2); *M = qep->M; }
if (C) { PetscValidPointer(C,3); *C = qep->C; }
if (K) { PetscValidPointer(K,4); *K = qep->K; }
301,7 → 301,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (n<0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n cannot be negative");
 
/* free previous non-processed vectors */
361,7 → 361,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (n<0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n cannot be negative");
 
/* free previous non-processed vectors */
/trunk/src/qep/interface/qepbasic.c
24,7 → 24,7
#include "private/qepimpl.h" /*I "slepcqep.h" I*/
 
PetscFList QEPList = 0;
PetscCookie QEP_COOKIE = 0;
PetscClassId QEP_CLASSID = 0;
PetscLogEvent QEP_SetUp = 0, QEP_Solve = 0, QEP_Dense = 0;
static PetscTruth QEPPackageInitialized = PETSC_FALSE;
 
70,19 → 70,19
if (QEPPackageInitialized) PetscFunctionReturn(0);
QEPPackageInitialized = PETSC_TRUE;
/* Register Classes */
ierr = PetscCookieRegister("Quadratic Eigenproblem Solver",&QEP_COOKIE);CHKERRQ(ierr);
ierr = PetscClassIdRegister("Quadratic Eigenproblem Solver",&QEP_CLASSID);CHKERRQ(ierr);
/* Register Constructors */
ierr = QEPRegisterAll(path);CHKERRQ(ierr);
/* Register Events */
ierr = PetscLogEventRegister("QEPSetUp",QEP_COOKIE,&QEP_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("QEPSolve",QEP_COOKIE,&QEP_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("QEPDense",QEP_COOKIE,&QEP_Dense);CHKERRQ(ierr);
ierr = PetscLogEventRegister("QEPSetUp",QEP_CLASSID,&QEP_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("QEPSolve",QEP_CLASSID,&QEP_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("QEPDense",QEP_CLASSID,&QEP_Dense);CHKERRQ(ierr);
/* Process info exclusions */
ierr = PetscOptionsGetString(PETSC_NULL,"-log_info_exclude",logList,256,&opt);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL,"-info_exclude",logList,256,&opt);CHKERRQ(ierr);
if (opt) {
ierr = PetscStrstr(logList,"qep",&className);CHKERRQ(ierr);
if (className) {
ierr = PetscInfoDeactivateClass(QEP_COOKIE);CHKERRQ(ierr);
ierr = PetscInfoDeactivateClass(QEP_CLASSID);CHKERRQ(ierr);
}
}
/* Process summary exclusions */
90,7 → 90,7
if (opt) {
ierr = PetscStrstr(logList,"qep",&className);CHKERRQ(ierr);
if (className) {
ierr = PetscLogEventDeactivateClass(QEP_COOKIE);CHKERRQ(ierr);
ierr = PetscLogEventDeactivateClass(QEP_CLASSID);CHKERRQ(ierr);
}
}
ierr = PetscRegisterFinalize(QEPFinalizePackage);CHKERRQ(ierr);
133,9 → 133,9
PetscTruth isascii;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (!viewer) viewer = PETSC_VIEWER_STDOUT_(((PetscObject)qep)->comm);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2);
PetscCheckSameComm(qep,1,viewer,2);
 
#if defined(PETSC_USE_COMPLEX)
244,7 → 244,7
PetscValidPointer(outqep,2);
*outqep = 0;
 
ierr = PetscHeaderCreate(qep,_p_QEP,struct _QEPOps,QEP_COOKIE,-1,"QEP",comm,QEPDestroy,QEPView);CHKERRQ(ierr);
ierr = PetscHeaderCreate(qep,_p_QEP,struct _QEPOps,QEP_CLASSID,-1,"QEP",comm,QEPDestroy,QEPView);CHKERRQ(ierr);
*outqep = qep;
 
ierr = PetscMemzero(qep->ops,sizeof(struct _QEPOps));CHKERRQ(ierr);
329,7 → 329,7
PetscTruth match;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidCharPointer(type,2);
 
ierr = PetscTypeCompare((PetscObject)qep,type,&match);CHKERRQ(ierr);
373,7 → 373,7
PetscErrorCode QEPGetType(QEP qep,const QEPType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(type,2);
*type = ((PetscObject)qep)->type_name;
PetscFunctionReturn(0);
481,7 → 481,7
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (--((PetscObject)qep)->refct > 0) PetscFunctionReturn(0);
 
/* if memory was published with AMS then destroy it */
545,8 → 545,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_COOKIE,2);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,2);
PetscCheckSameComm(qep,1,ip,2);
ierr = PetscObjectReference((PetscObject)ip);CHKERRQ(ierr);
ierr = IPDestroy(qep->ip); CHKERRQ(ierr);
575,7 → 575,7
PetscErrorCode QEPGetIP(QEP qep,IP *ip)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(ip,2);
*ip = qep->ip;
PetscFunctionReturn(0);
/trunk/src/qep/interface/qepdefault.c
32,7 → 32,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscFree(qep->data);CHKERRQ(ierr);
 
/* free work vectors */
77,7 → 77,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (qep->work) {
ierr = VecDestroyVecs(qep->work,qep->nwork);CHKERRQ(ierr);
}
/trunk/src/qep/interface/qepopts.c
52,7 → 52,7
QEPMONITOR_CONV *ctx;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscOptionsBegin(((PetscObject)qep)->comm,((PetscObject)qep)->prefix,"Quadratic Eigenvalue Problem (QEP) Solver Options","QEP");CHKERRQ(ierr);
ierr = PetscOptionsList("-qep_type","Quadratic Eigenvalue Problem method","QEPSetType",QEPList,(char*)(((PetscObject)qep)->type_name?((PetscObject)qep)->type_name:QEPLINEAR),type,256,&flg);CHKERRQ(ierr);
if (flg) {
185,7 → 185,7
PetscErrorCode QEPGetTolerances(QEP qep,PetscReal *tol,PetscInt *maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (tol) *tol = qep->tol;
if (maxits) *maxits = qep->max_it;
PetscFunctionReturn(0);
221,7 → 221,7
PetscErrorCode QEPSetTolerances(QEP qep,PetscReal tol,PetscInt maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (tol != PETSC_IGNORE) {
if (tol == PETSC_DEFAULT) {
qep->tol = 1e-7;
268,7 → 268,7
PetscErrorCode QEPGetDimensions(QEP qep,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (nev) *nev = qep->nev;
if (ncv) *ncv = qep->ncv;
if (mpd) *mpd = qep->mpd;
316,7 → 316,7
PetscErrorCode QEPSetDimensions(QEP qep,PetscInt nev,PetscInt ncv,PetscInt mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
 
if( nev != PETSC_IGNORE ) {
if (nev<1) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of nev. Must be > 0");
386,7 → 386,7
PetscErrorCode QEPSetWhichEigenpairs(QEP qep,QEPWhich which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (which!=PETSC_IGNORE) {
if (which==PETSC_DECIDE || which==PETSC_DEFAULT) qep->which = (QEPWhich)0;
else switch (which) {
432,7 → 432,7
PetscErrorCode QEPGetWhichEigenpairs(QEP qep,QEPWhich *which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(which,2);
*which = qep->which;
PetscFunctionReturn(0);
464,7 → 464,7
PetscErrorCode QEPSetLeftVectorsWanted(QEP qep,PetscTruth leftvecs)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (qep->leftvecs != leftvecs) {
qep->leftvecs = leftvecs;
qep->setupcalled = 0;
493,7 → 493,7
PetscErrorCode QEPGetLeftVectorsWanted(QEP qep,PetscTruth *leftvecs)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(leftvecs,2);
*leftvecs = qep->leftvecs;
PetscFunctionReturn(0);
523,7 → 523,7
PetscErrorCode QEPGetScaleFactor(QEP qep,PetscReal *alpha)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (alpha) *alpha = qep->sfactor;
PetscFunctionReturn(0);
}
556,7 → 556,7
PetscErrorCode QEPSetScaleFactor(QEP qep,PetscReal alpha)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (alpha != PETSC_IGNORE) {
if (alpha == PETSC_DEFAULT || alpha == PETSC_DECIDE) {
qep->sfactor = 0.0;
602,7 → 602,7
PetscErrorCode QEPSetProblemType(QEP qep,QEPProblemType type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
if (type!=QEP_GENERAL && type!=QEP_HERMITIAN && type!=QEP_GYROSCOPIC)
SETERRQ(PETSC_ERR_ARG_WRONG,"Unknown eigenvalue problem type");
qep->problem_type = type;
629,7 → 629,7
PetscErrorCode QEPGetProblemType(QEP qep,QEPProblemType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(type,2);
*type = qep->problem_type;
PetscFunctionReturn(0);
701,7 → 701,7
PetscErrorCode QEPSetTrackAll(QEP qep,PetscTruth trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
qep->trackall = trackall;
PetscFunctionReturn(0);
}
727,7 → 727,7
PetscErrorCode QEPGetTrackAll(QEP qep,PetscTruth *trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(trackall,2);
*trackall = qep->trackall;
PetscFunctionReturn(0);
765,7 → 765,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectSetOptionsPrefix((PetscObject)qep,prefix);CHKERRQ(ierr);
ierr = IPSetOptionsPrefix(qep->ip,prefix);CHKERRQ(ierr);
ierr = IPAppendOptionsPrefix(qep->ip,"qep_");CHKERRQ(ierr);
796,7 → 796,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)qep, prefix);CHKERRQ(ierr);
ierr = IPSetOptionsPrefix(qep->ip,prefix);CHKERRQ(ierr);
ierr = IPAppendOptionsPrefix(qep->ip,"qep_");CHKERRQ(ierr);
828,7 → 828,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
PetscValidPointer(prefix,2);
ierr = PetscObjectGetOptionsPrefix((PetscObject)qep,prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
/trunk/src/qep/impls/linear/linear.c
512,7 → 512,7
PetscErrorCode ierr, (*f)(QEP,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearSetCompanionForm_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,cform);CHKERRQ(ierr);
557,7 → 557,7
PetscErrorCode ierr, (*f)(QEP,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearGetCompanionForm_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,cform);CHKERRQ(ierr);
602,7 → 602,7
PetscErrorCode ierr, (*f)(QEP,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearSetExplicitMatrix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,explicitmatrix);CHKERRQ(ierr);
647,7 → 647,7
PetscErrorCode ierr, (*f)(QEP,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearGetExplicitMatrix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,explicitmatrix);CHKERRQ(ierr);
664,7 → 664,7
QEP_LINEAR *ctx = (QEP_LINEAR *)qep->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,2);
PetscValidHeaderSpecific(eps,EPS_CLASSID,2);
PetscCheckSameComm(qep,1,eps,2);
ierr = PetscObjectReference((PetscObject)eps);CHKERRQ(ierr);
ierr = EPSDestroy(ctx->eps);CHKERRQ(ierr);
695,7 → 695,7
PetscErrorCode ierr, (*f)(QEP,EPS);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearSetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,eps);CHKERRQ(ierr);
740,7 → 740,7
PetscErrorCode ierr, (*f)(QEP,EPS*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(qep,QEP_COOKIE,1);
PetscValidHeaderSpecific(qep,QEP_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)qep,"QEPLinearGetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(qep,eps);CHKERRQ(ierr);
/trunk/src/st/interface/stsolve.c
48,9 → 48,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(y,VEC_COOKIE,3);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
if (x == y) SETERRQ(PETSC_ERR_ARG_IDN,"x and y must be different vectors");
 
if (!st->setupcalled) { ierr = STSetUp(st); CHKERRQ(ierr); }
93,7 → 93,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(B,2);
ierr = (*st->ops->getbilinearform)(st,B);CHKERRQ(ierr);
PetscFunctionReturn(0);
138,9 → 138,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(y,VEC_COOKIE,3);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
if (x == y) SETERRQ(PETSC_ERR_ARG_IDN,"x and y must be different vectors");
 
if (!st->setupcalled) { ierr = STSetUp(st); CHKERRQ(ierr); }
193,7 → 193,7
PetscScalar *array,one = 1.0;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(mat,2);
 
ierr = MatGetVecs(st->A,&in,&out);CHKERRQ(ierr);
244,7 → 244,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
 
PetscInfo(st,"Setting up new ST\n");
if (st->setupcalled) PetscFunctionReturn(0);
283,7 → 283,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (st->ops->postsolve) {
ierr = (*st->ops->postsolve)(st);CHKERRQ(ierr);
}
314,7 → 314,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (st->ops->backtr) {
ierr = (*st->ops->backtr)(st,n,eigr,eigi);CHKERRQ(ierr);
}
/trunk/src/st/interface/stfunc.c
23,7 → 23,7
 
#include "private/stimpl.h" /*I "slepcst.h" I*/
 
PetscCookie ST_COOKIE = 0;
PetscClassId ST_CLASSID = 0;
PetscLogEvent ST_SetUp = 0, ST_Apply = 0, ST_ApplyTranspose = 0;
static PetscTruth STPackageInitialized = PETSC_FALSE;
 
69,19 → 69,19
if (STPackageInitialized) PetscFunctionReturn(0);
STPackageInitialized = PETSC_TRUE;
/* Register Classes */
ierr = PetscCookieRegister("Spectral Transform",&ST_COOKIE);CHKERRQ(ierr);
ierr = PetscClassIdRegister("Spectral Transform",&ST_CLASSID);CHKERRQ(ierr);
/* Register Constructors */
ierr = STRegisterAll(path);CHKERRQ(ierr);
/* Register Events */
ierr = PetscLogEventRegister("STSetUp",ST_COOKIE,&ST_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("STApply",ST_COOKIE,&ST_Apply);CHKERRQ(ierr);
ierr = PetscLogEventRegister("STApplyTranspose",ST_COOKIE,&ST_ApplyTranspose); CHKERRQ(ierr);
ierr = PetscLogEventRegister("STSetUp",ST_CLASSID,&ST_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("STApply",ST_CLASSID,&ST_Apply);CHKERRQ(ierr);
ierr = PetscLogEventRegister("STApplyTranspose",ST_CLASSID,&ST_ApplyTranspose); CHKERRQ(ierr);
/* Process info exclusions */
ierr = PetscOptionsGetString(PETSC_NULL, "-log_info_exclude", logList, 256, &opt);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);CHKERRQ(ierr);
if (opt) {
ierr = PetscStrstr(logList, "st", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscInfoDeactivateClass(ST_COOKIE);CHKERRQ(ierr);
ierr = PetscInfoDeactivateClass(ST_CLASSID);CHKERRQ(ierr);
}
}
/* Process summary exclusions */
89,7 → 89,7
if (opt) {
ierr = PetscStrstr(logList, "st", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscLogEventDeactivateClass(ST_COOKIE);CHKERRQ(ierr);
ierr = PetscLogEventDeactivateClass(ST_CLASSID);CHKERRQ(ierr);
}
}
ierr = PetscRegisterFinalize(STFinalizePackage);CHKERRQ(ierr);
115,7 → 115,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (--((PetscObject)st)->refct > 0) PetscFunctionReturn(0);
 
/* if memory was published with AMS then destroy it */
163,7 → 163,7
PetscValidPointer(newst,2);
*newst = 0;
 
ierr = PetscHeaderCreate(st,_p_ST,struct _STOps,ST_COOKIE,-1,"ST",comm,STDestroy,STView);CHKERRQ(ierr);
ierr = PetscHeaderCreate(st,_p_ST,struct _STOps,ST_CLASSID,-1,"ST",comm,STDestroy,STView);CHKERRQ(ierr);
ierr = PetscMemzero(st->ops,sizeof(struct _STOps));CHKERRQ(ierr);
 
st->A = 0;
214,9 → 214,9
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(A,MAT_COOKIE,2);
if (B) PetscValidHeaderSpecific(B,MAT_COOKIE,3);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(A,MAT_CLASSID,2);
if (B) PetscValidHeaderSpecific(B,MAT_CLASSID,3);
PetscCheckSameComm(st,1,A,2);
if (B) PetscCheckSameComm(st,1,B,3);
ierr = PetscObjectReference((PetscObject)A);CHKERRQ(ierr);
250,7 → 250,7
PetscErrorCode STGetOperators(ST st,Mat *A,Mat *B)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (A) *A = st->A;
if (B) *B = st->B;
PetscFunctionReturn(0);
279,7 → 279,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (st->sigma != shift) {
if (st->ops->setshift) {
ierr = (*st->ops->setshift)(st,shift); CHKERRQ(ierr);
309,7 → 309,7
PetscErrorCode STGetShift(ST st,PetscScalar* shift)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (shift) *shift = st->sigma;
PetscFunctionReturn(0);
}
332,7 → 332,7
PetscErrorCode STSetDefaultShift(ST st,PetscScalar defaultshift)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
st->defsigma = defaultshift;
PetscFunctionReturn(0);
}
363,8 → 363,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(D,VEC_COOKIE,2);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(D,VEC_CLASSID,2);
PetscCheckSameComm(st,1,D,2);
ierr = PetscObjectReference((PetscObject)D);CHKERRQ(ierr);
if (st->D) {
400,7 → 400,7
PetscErrorCode STGetBalanceMatrix(ST st,Vec *D)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(D,2);
*D = st->D;
PetscFunctionReturn(0);
432,7 → 432,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectSetOptionsPrefix((PetscObject)st,prefix);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(st->ksp,prefix);CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(st->ksp,"st_");CHKERRQ(ierr);
465,7 → 465,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)st,prefix);CHKERRQ(ierr);
ierr = KSPSetOptionsPrefix(st->ksp,((PetscObject)st)->prefix);CHKERRQ(ierr);
ierr = KSPAppendOptionsPrefix(st->ksp,"st_");CHKERRQ(ierr);
498,7 → 498,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectGetOptionsPrefix((PetscObject)st, prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
538,9 → 538,9
PetscViewerFormat format;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (!viewer) viewer = PETSC_VIEWER_STDOUT_(((PetscObject)st)->comm);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2);
PetscCheckSameComm(st,1,viewer,2);
 
ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&isascii);CHKERRQ(ierr);
/trunk/src/st/interface/stset.c
64,7 → 64,7
PetscTruth match;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidCharPointer(type,2);
 
ierr = PetscTypeCompare((PetscObject)st,type,&match);CHKERRQ(ierr);
110,7 → 110,7
PetscErrorCode STGetType(ST st,const STType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(type,2);
*type = ((PetscObject)st)->type_name;
PetscFunctionReturn(0);
144,7 → 144,7
const char *structure_list[3] = { "same", "different", "subset" };
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
 
ierr = PetscOptionsBegin(((PetscObject)st)->comm,((PetscObject)st)->prefix,"Spectral Transformation (ST) Options","ST");CHKERRQ(ierr);
ierr = PetscOptionsList("-st_type","Spectral Transformation type","STSetType",STList,(char*)(((PetscObject)st)->type_name?((PetscObject)st)->type_name:STSHIFT),type,256,&flg);CHKERRQ(ierr);
211,7 → 211,7
PetscErrorCode STSetMatStructure(ST st,MatStructure str)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
switch (str) {
case SAME_NONZERO_PATTERN:
case DIFFERENT_NONZERO_PATTERN:
248,7 → 248,7
PetscErrorCode STGetMatStructure(ST st,MatStructure *str)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(str,2);
*str = st->str;
PetscFunctionReturn(0);
298,7 → 298,7
PetscErrorCode STSetMatMode(ST st,STMatMode mode)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
st->shift_matrix = mode;
PetscFunctionReturn(0);
}
324,7 → 324,7
PetscErrorCode STGetMatMode(ST st,STMatMode *mode)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
*mode = st->shift_matrix;
PetscFunctionReturn(0);
}
/trunk/src/st/interface/stsles.c
44,9 → 44,9
KSPConvergedReason reason;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(b,VEC_COOKIE,2);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(b,VEC_CLASSID,2);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
if (!st->ksp) { SETERRQ(PETSC_ERR_SUP,"ST has no associated KSP"); }
ierr = KSPSolve(st->ksp,b,x);CHKERRQ(ierr);
ierr = KSPGetConvergedReason(st->ksp,&reason);CHKERRQ(ierr);
77,9 → 77,9
KSPConvergedReason reason;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(b,VEC_COOKIE,2);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(b,VEC_CLASSID,2);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
if (!st->ksp) { SETERRQ(PETSC_ERR_SUP,"ST has no associated KSP"); }
ierr = KSPSolveTranspose(st->ksp,b,x);CHKERRQ(ierr);
ierr = KSPGetConvergedReason(st->ksp,&reason);CHKERRQ(ierr);
110,8 → 110,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(ksp,KSP_COOKIE,2);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(ksp,KSP_CLASSID,2);
PetscCheckSameComm(st,1,ksp,2);
ierr = PetscObjectReference((PetscObject)ksp);CHKERRQ(ierr);
if (st->ksp) {
146,7 → 146,7
PetscErrorCode STGetKSP(ST st,KSP* ksp)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (!((PetscObject)st)->type_name) { SETERRQ(PETSC_ERR_ARG_WRONGSTATE,"Must call STSetType first"); }
if (ksp) *ksp = st->ksp;
PetscFunctionReturn(0);
177,7 → 177,7
PetscErrorCode STGetOperationCounters(ST st,PetscInt* ops,PetscInt* lits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
if (ops) *ops = st->applys;
if (lits) *lits = st->lineariterations;
PetscFunctionReturn(0);
202,7 → 202,7
PetscErrorCode STResetOperationCounters(ST st)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
st->lineariterations = 0;
st->applys = 0;
PetscFunctionReturn(0);
/trunk/src/st/impls/cayley/cayley.c
373,7 → 373,7
PetscErrorCode ierr, (*f)(ST,PetscScalar);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STCayleySetAntishift_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,nu);CHKERRQ(ierr);
/trunk/src/st/impls/shell/shell.c
62,7 → 62,7
PetscTruth flg;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidPointer(ctx,2);
ierr = PetscTypeCompare((PetscObject)st,STSHELL,&flg);CHKERRQ(ierr);
if (!flg) *ctx = 0;
95,7 → 95,7
PetscTruth flg;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscTypeCompare((PetscObject)st,STSHELL,&flg);CHKERRQ(ierr);
if (flg) {
shell->ctx = ctx;
289,7 → 289,7
PetscErrorCode ierr, (*f)(ST,PetscErrorCode (*)(ST,Vec,Vec));
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STShellSetApply_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,apply);CHKERRQ(ierr);
327,7 → 327,7
PetscErrorCode ierr, (*f)(ST,PetscErrorCode (*)(ST,Vec,Vec));
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STShellSetApplyTranspose_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,applytrans);CHKERRQ(ierr);
366,7 → 366,7
PetscErrorCode ierr, (*f)(ST,PetscErrorCode (*)(ST,PetscInt,PetscScalar*,PetscScalar*));
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STShellSetBackTransform_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,backtr);CHKERRQ(ierr);
395,7 → 395,7
PetscErrorCode ierr, (*f)(ST,const char []);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STShellSetName_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,name);CHKERRQ(ierr);
427,7 → 427,7
PetscErrorCode ierr, (*f)(ST,char *[]);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STShellGetName_C",(void (**)(void))&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,name);CHKERRQ(ierr);
/trunk/src/st/impls/precond/precond.c
264,7 → 264,7
PetscErrorCode ierr, (*f)(ST,Mat*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STPrecondGetMatForPC_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,mat);CHKERRQ(ierr);
280,7 → 280,7
PetscTruth flag;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
 
ierr = KSPGetPC(st->ksp, &pc); CHKERRQ(ierr);
ierr = PCGetOperatorsSet(pc, PETSC_NULL, &flag); CHKERRQ(ierr);
316,8 → 316,8
PetscErrorCode ierr, (*f)(ST,Mat);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(mat,MAT_COOKIE,2);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(mat,MAT_CLASSID,2);
ierr = PetscObjectQueryFunction((PetscObject)st,"STPrecondSetMatForPC_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,mat);CHKERRQ(ierr);
334,8 → 334,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(mat,MAT_COOKIE,2);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
PetscValidHeaderSpecific(mat,MAT_CLASSID,2);
 
ierr = KSPGetPC(st->ksp, &pc); CHKERRQ(ierr);
/* Yes, all these lines are needed to safely set mat as the preconditioner
378,7 → 378,7
PetscErrorCode ierr, (*f)(ST,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STPrecondSetKSPHasMat_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,setmat);CHKERRQ(ierr);
410,7 → 410,7
PetscErrorCode ierr, (*f)(ST,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)st,"STPrecondGetKSPHasMat_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(st,setmat);CHKERRQ(ierr);
425,7 → 425,7
 
PetscFunctionBegin;
 
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
 
data->setmat = setmat;
 
440,7 → 440,7
 
PetscFunctionBegin;
 
PetscValidHeaderSpecific(st,ST_COOKIE,1);
PetscValidHeaderSpecific(st,ST_CLASSID,1);
 
*setmat = data->setmat;
 
/trunk/src/eps/interface/mem.c
37,7 → 37,7
PetscScalar *pV,*pW;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->allocated_ncv != eps->ncv) {
if (eps->allocated_ncv > 0) {
ierr = PetscFree(eps->eigr);CHKERRQ(ierr);
93,7 → 93,7
PetscScalar *pV,*pW;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->allocated_ncv > 0) {
ierr = PetscFree(eps->eigr);CHKERRQ(ierr);
ierr = PetscFree(eps->eigi);CHKERRQ(ierr);
/trunk/src/eps/interface/setup.c
58,7 → 58,7
#endif
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if (eps->setupcalled) PetscFunctionReturn(0);
 
244,9 → 244,9
PetscInt m,n,m0;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(A,MAT_COOKIE,2);
if (B) PetscValidHeaderSpecific(B,MAT_COOKIE,3);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidHeaderSpecific(A,MAT_CLASSID,2);
if (B) PetscValidHeaderSpecific(B,MAT_CLASSID,3);
PetscCheckSameComm(eps,1,A,2);
if (B) PetscCheckSameComm(eps,1,B,3);
 
294,7 → 294,7
ST st;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (A) PetscValidPointer(A,2);
if (B) PetscValidPointer(B,3);
ierr = EPSGetST(eps,&st);CHKERRQ(ierr);
340,7 → 340,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (n<=0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n out of range");
 
/* free previous vectors */
380,7 → 380,7
PetscScalar *pV;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->nds > 0) {
ierr = VecGetArray(eps->DS[0],&pV);CHKERRQ(ierr);
ierr = VecRestoreArray(eps->DS[0],PETSC_NULL);CHKERRQ(ierr);
434,7 → 434,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (n<0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n cannot be negative");
 
/* free previous non-processed vectors */
494,7 → 494,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (n<0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n cannot be negative");
 
/* free previous non-processed vectors */
/trunk/src/eps/interface/basic.c
24,7 → 24,7
#include "private/epsimpl.h" /*I "slepceps.h" I*/
 
PetscFList EPSList = 0;
PetscCookie EPS_COOKIE = 0;
PetscClassId EPS_CLASSID = 0;
PetscLogEvent EPS_SetUp = 0, EPS_Solve = 0, EPS_Dense = 0;
static PetscTruth EPSPackageInitialized = PETSC_FALSE;
 
70,19 → 70,19
if (EPSPackageInitialized) PetscFunctionReturn(0);
EPSPackageInitialized = PETSC_TRUE;
/* Register Classes */
ierr = PetscCookieRegister("Eigenproblem Solver",&EPS_COOKIE);CHKERRQ(ierr);
ierr = PetscClassIdRegister("Eigenproblem Solver",&EPS_CLASSID);CHKERRQ(ierr);
/* Register Constructors */
ierr = EPSRegisterAll(path);CHKERRQ(ierr);
/* Register Events */
ierr = PetscLogEventRegister("EPSSetUp",EPS_COOKIE,&EPS_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("EPSSolve",EPS_COOKIE,&EPS_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("EPSDense",EPS_COOKIE,&EPS_Dense); CHKERRQ(ierr);
ierr = PetscLogEventRegister("EPSSetUp",EPS_CLASSID,&EPS_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("EPSSolve",EPS_CLASSID,&EPS_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("EPSDense",EPS_CLASSID,&EPS_Dense); CHKERRQ(ierr);
/* Process info exclusions */
ierr = PetscOptionsGetString(PETSC_NULL, "-log_info_exclude", logList, 256, &opt);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);CHKERRQ(ierr);
if (opt) {
ierr = PetscStrstr(logList, "eps", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscInfoDeactivateClass(EPS_COOKIE);CHKERRQ(ierr);
ierr = PetscInfoDeactivateClass(EPS_CLASSID);CHKERRQ(ierr);
}
}
/* Process summary exclusions */
90,7 → 90,7
if (opt) {
ierr = PetscStrstr(logList, "eps", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscLogEventDeactivateClass(EPS_COOKIE);CHKERRQ(ierr);
ierr = PetscLogEventDeactivateClass(EPS_CLASSID);CHKERRQ(ierr);
}
}
ierr = PetscRegisterFinalize(EPSFinalizePackage);CHKERRQ(ierr);
133,9 → 133,9
PetscTruth isascii;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!viewer) viewer = PETSC_VIEWER_STDOUT_(((PetscObject)eps)->comm);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2);
PetscCheckSameComm(eps,1,viewer,2);
 
#if defined(PETSC_USE_COMPLEX)
324,7 → 324,7
PetscValidPointer(outeps,2);
*outeps = 0;
 
ierr = PetscHeaderCreate(eps,_p_EPS,struct _EPSOps,EPS_COOKIE,-1,"EPS",comm,EPSDestroy,EPSView);CHKERRQ(ierr);
ierr = PetscHeaderCreate(eps,_p_EPS,struct _EPSOps,EPS_CLASSID,-1,"EPS",comm,EPSDestroy,EPSView);CHKERRQ(ierr);
*outeps = eps;
 
ierr = PetscMemzero(eps->ops,sizeof(struct _EPSOps));CHKERRQ(ierr);
433,7 → 433,7
PetscTruth match;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidCharPointer(type,2);
 
ierr = PetscTypeCompare((PetscObject)eps,type,&match);CHKERRQ(ierr);
477,7 → 477,7
PetscErrorCode EPSGetType(EPS eps,const EPSType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(type,2);
*type = ((PetscObject)eps)->type_name;
PetscFunctionReturn(0);
583,7 → 583,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (--((PetscObject)eps)->refct > 0) PetscFunctionReturn(0);
 
/* if memory was published with AMS then destroy it */
638,7 → 638,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
eps->target = target;
ierr = STSetDefaultShift(eps->OP,target);CHKERRQ(ierr);
PetscFunctionReturn(0);
667,7 → 667,7
PetscErrorCode EPSGetTarget(EPS eps,PetscScalar* target)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (target) {
*target = eps->target;
}
699,8 → 699,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(st,ST_COOKIE,2);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidHeaderSpecific(st,ST_CLASSID,2);
PetscCheckSameComm(eps,1,st,2);
ierr = PetscObjectReference((PetscObject)st);CHKERRQ(ierr);
ierr = STDestroy(eps->OP); CHKERRQ(ierr);
729,7 → 729,7
PetscErrorCode EPSGetST(EPS eps, ST *st)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(st,2);
*st = eps->OP;
PetscFunctionReturn(0);
759,8 → 759,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_COOKIE,2);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,2);
PetscCheckSameComm(eps,1,ip,2);
ierr = PetscObjectReference((PetscObject)ip);CHKERRQ(ierr);
ierr = IPDestroy(eps->ip); CHKERRQ(ierr);
789,7 → 789,7
PetscErrorCode EPSGetIP(EPS eps,IP *ip)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(ip,2);
*ip = eps->ip;
PetscFunctionReturn(0);
818,7 → 818,7
Mat B;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = STGetOperators(eps->OP,PETSC_NULL,&B);CHKERRQ(ierr);
if( B ) *is = PETSC_TRUE;
else *is = PETSC_FALSE;
850,7 → 850,7
PetscErrorCode EPSIsHermitian(EPS eps,PetscTruth* is)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if( eps->ishermitian ) *is = PETSC_TRUE;
else *is = PETSC_FALSE;
PetscFunctionReturn(0);
/trunk/src/eps/interface/default.c
31,7 → 31,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscFree(eps->data);CHKERRQ(ierr);
 
/* free work vectors */
47,7 → 47,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = STBackTransform(eps->OP,eps->nconv,eps->eigr,eps->eigi);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
261,7 → 261,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->work) {
ierr = VecDestroyVecs(eps->work,eps->nwork); CHKERRQ(ierr);
}
/trunk/src/eps/interface/opts.c
54,7 → 54,7
EPSMONITOR_CONV *ctx;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscOptionsBegin(((PetscObject)eps)->comm,((PetscObject)eps)->prefix,"Eigenproblem Solver (EPS) Options","EPS");CHKERRQ(ierr);
ierr = PetscOptionsList("-eps_type","Eigenproblem Solver method","EPSSetType",EPSList,(char*)(((PetscObject)eps)->type_name?((PetscObject)eps)->type_name:EPSKRYLOVSCHUR),type,256,&flg);CHKERRQ(ierr);
if (flg) {
244,7 → 244,7
PetscErrorCode EPSGetTolerances(EPS eps,PetscReal *tol,PetscInt *maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (tol) *tol = eps->tol;
if (maxits) *maxits = eps->max_it;
PetscFunctionReturn(0);
280,7 → 280,7
PetscErrorCode EPSSetTolerances(EPS eps,PetscReal tol,PetscInt maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (tol != PETSC_IGNORE) {
if (tol == PETSC_DEFAULT) {
eps->tol = 1e-7;
327,7 → 327,7
PetscErrorCode EPSGetDimensions(EPS eps,PetscInt *nev,PetscInt *ncv,PetscInt *mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (nev) *nev = eps->nev;
if (ncv) *ncv = eps->ncv;
if (mpd) *mpd = eps->mpd;
375,7 → 375,7
PetscErrorCode EPSSetDimensions(EPS eps,PetscInt nev,PetscInt ncv,PetscInt mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if( nev != PETSC_IGNORE ) {
if (nev<1) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of nev. Must be > 0");
458,7 → 458,7
PetscErrorCode EPSSetWhichEigenpairs(EPS eps,EPSWhich which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (which!=PETSC_IGNORE) {
if (which==PETSC_DECIDE || which==PETSC_DEFAULT) eps->which = (EPSWhich)0;
else switch (which) {
510,7 → 510,7
PetscErrorCode EPSGetWhichEigenpairs(EPS eps,EPSWhich *which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(which,2);
*which = eps->which;
PetscFunctionReturn(0);
542,7 → 542,7
PetscErrorCode EPSSetLeftVectorsWanted(EPS eps,PetscTruth leftvecs)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->leftvecs != leftvecs) {
eps->leftvecs = leftvecs;
eps->setupcalled = 0;
571,7 → 571,7
PetscErrorCode EPSGetLeftVectorsWanted(EPS eps,PetscTruth *leftvecs)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(leftvecs,2);
*leftvecs = eps->leftvecs;
PetscFunctionReturn(0);
616,7 → 616,7
PetscErrorCode EPSSetMatrixNorms(EPS eps,PetscReal nrma,PetscReal nrmb,PetscTruth adaptive)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (nrma != PETSC_IGNORE) {
if (nrma == PETSC_DEFAULT) eps->nrma = 1.0;
else if (nrma == PETSC_DETERMINE) {
670,7 → 670,7
PetscErrorCode EPSGetMatrixNorms(EPS eps,PetscReal *nrma,PetscReal *nrmb,PetscTruth *adaptive)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(nrma,2);
PetscValidPointer(nrmb,3);
PetscValidPointer(adaptive,4);
757,7 → 757,7
EXTERN PetscErrorCode EPSSetConvergenceTestFunction(EPS eps,PetscErrorCode (*func)(EPS,PetscScalar,PetscScalar,PetscReal,PetscReal*,void*),void* ctx)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
eps->conv_func = func;
eps->conv_ctx = ctx;
if (func == EPSEigRelativeConverged) eps->conv = EPS_CONV_EIG;
798,7 → 798,7
PetscErrorCode EPSSetConvergenceTest(EPS eps,EPSConv conv)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
switch(conv) {
case EPS_CONV_EIG: eps->conv_func = EPSEigRelativeConverged; break;
case EPS_CONV_NORM: eps->conv_func = EPSNormRelativeConverged; break;
832,7 → 832,7
PetscErrorCode EPSGetConvergenceTest(EPS eps,EPSConv *conv)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(conv,2);
*conv = eps->conv;
PetscFunctionReturn(0);
878,7 → 878,7
PetscErrorCode EPSSetProblemType(EPS eps,EPSProblemType type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
switch (type) {
case EPS_HEP:
951,7 → 951,7
PetscErrorCode EPSGetProblemType(EPS eps,EPSProblemType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(type,2);
*type = eps->problem_type;
PetscFunctionReturn(0);
995,7 → 995,7
PetscErrorCode EPSSetExtraction(EPS eps,EPSExtraction extr)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
eps->extraction = extr;
PetscFunctionReturn(0);
}
1020,7 → 1020,7
PetscErrorCode EPSGetExtraction(EPS eps,EPSExtraction *extr)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(extr,2);
*extr = eps->extraction;
PetscFunctionReturn(0);
1074,7 → 1074,7
PetscErrorCode EPSSetBalance(EPS eps,EPSBalance bal,PetscInt its,PetscReal cutoff)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (bal!=PETSC_IGNORE) {
if (bal==PETSC_DECIDE || bal==PETSC_DEFAULT) eps->balance = EPS_BALANCE_TWOSIDE;
else switch (bal) {
1125,7 → 1125,7
PetscErrorCode EPSGetBalance(EPS eps,EPSBalance *bal,PetscInt *its,PetscReal *cutoff)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(bal,2);
PetscValidPointer(its,3);
PetscValidPointer(cutoff,4);
1167,7 → 1167,7
PetscErrorCode EPSSetTrueResidual(EPS eps,PetscTruth trueres)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
eps->trueres = trueres;
PetscFunctionReturn(0);
}
1193,7 → 1193,7
PetscErrorCode EPSGetTrueResidual(EPS eps,PetscTruth *trueres)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(trueres,2);
*trueres = eps->trueres;
PetscFunctionReturn(0);
1227,7 → 1227,7
PetscErrorCode EPSSetTrackAll(EPS eps,PetscTruth trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
eps->trackall = trackall;
PetscFunctionReturn(0);
}
1253,7 → 1253,7
PetscErrorCode EPSGetTrackAll(EPS eps,PetscTruth *trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(trackall,2);
*trackall = eps->trackall;
PetscFunctionReturn(0);
1291,7 → 1291,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectSetOptionsPrefix((PetscObject)eps, prefix);CHKERRQ(ierr);
ierr = STSetOptionsPrefix(eps->OP,prefix);CHKERRQ(ierr);
ierr = IPSetOptionsPrefix(eps->ip,prefix);CHKERRQ(ierr);
1323,7 → 1323,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)eps, prefix);CHKERRQ(ierr);
ierr = STAppendOptionsPrefix(eps->OP,prefix); CHKERRQ(ierr);
ierr = IPSetOptionsPrefix(eps->ip,prefix);CHKERRQ(ierr);
1356,7 → 1356,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(prefix,2);
ierr = PetscObjectGetOptionsPrefix((PetscObject)eps, prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
/trunk/src/eps/interface/monitor.c
77,7 → 77,7
void *mctx,PetscErrorCode (*monitordestroy)(void*))
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (eps->numbermonitors >= MAXEPSMONITORS) {
SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Too many EPS monitors set");
}
112,7 → 112,7
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
for (i=0; i<eps->numbermonitors; i++) {
if (eps->monitordestroy[i]) {
ierr = (*eps->monitordestroy[i])(eps->monitorcontext[i]);CHKERRQ(ierr);
143,7 → 143,7
PetscErrorCode EPSGetMonitorContext(EPS eps, void **ctx)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
*ctx = (eps->monitorcontext[0]);
PetscFunctionReturn(0);
}
/trunk/src/eps/interface/solve.c
102,7 → 102,7
const EPSType solvers[NUMEXTSOLV] = { EPSARPACK, EPSBLZPACK, EPSTRLAN, EPSBLOPEX, EPSPRIMME };
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
flg = PETSC_FALSE;
ierr = PetscOptionsGetTruth(((PetscObject)eps)->prefix,"-eps_view_binary",&flg,PETSC_NULL);CHKERRQ(ierr);
294,7 → 294,7
PetscErrorCode EPSGetIterationNumber(EPS eps,PetscInt *its)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidIntPointer(its,2);
*its = eps->its;
PetscFunctionReturn(0);
333,7 → 333,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = STGetOperationCounters(eps->OP,ops,lits);CHKERRQ(ierr);
if (dots) {
ierr = IPGetOperationCounters(eps->ip,dots);CHKERRQ(ierr);
364,7 → 364,7
PetscErrorCode EPSGetConverged(EPS eps,PetscInt *nconv)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidIntPointer(nconv,2);
*nconv = eps->nconv;
PetscFunctionReturn(0);
401,7 → 401,7
PetscErrorCode EPSGetConvergedReason(EPS eps,EPSConvergedReason *reason)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidIntPointer(reason,2);
*reason = eps->reason;
PetscFunctionReturn(0);
444,9 → 444,9
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(v,2);
PetscValidHeaderSpecific(*v,VEC_COOKIE,2);
PetscValidHeaderSpecific(*v,VEC_CLASSID,2);
if (!eps->V) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
504,9 → 504,9
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(v,2);
PetscValidHeaderSpecific(*v,VEC_COOKIE,2);
PetscValidHeaderSpecific(*v,VEC_CLASSID,2);
if (!eps->leftvecs) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "Must request left vectors with EPSSetLeftVectorsWanted");
}
564,7 → 564,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->eigr || !eps->eigi || !eps->V) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
611,7 → 611,7
PetscInt k;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->eigr || !eps->eigi) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
671,7 → 671,7
PetscInt k;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->V) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
742,7 → 742,7
PetscInt k;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->leftvecs) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "Must request left vectors with EPSSetLeftVectorsWanted");
}
807,7 → 807,7
PetscErrorCode EPSGetErrorEstimate(EPS eps, PetscInt i, PetscReal *errest)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->eigr || !eps->eigi) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
846,7 → 846,7
PetscErrorCode EPSGetErrorEstimateLeft(EPS eps, PetscInt i, PetscReal *errest)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->eigr || !eps->eigi) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "EPSSolve must be called first");
}
955,7 → 955,7
PetscScalar kr, ki;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(norm,3);
ierr = VecDuplicate(eps->V[0],&xr); CHKERRQ(ierr);
ierr = VecDuplicate(eps->V[0],&xi); CHKERRQ(ierr);
1003,7 → 1003,7
#endif
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!eps->leftvecs) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "Must request left vectors with EPSSetLeftVectorsWanted");
}
1113,7 → 1113,7
PetscScalar kr, ki;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidPointer(error,3);
ierr = VecDuplicate(eps->V[0],&xr); CHKERRQ(ierr);
ierr = VecDuplicate(eps->V[0],&xi); CHKERRQ(ierr);
1158,7 → 1158,7
#endif
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = EPSComputeResidualNormLeft(eps,i,&norm); CHKERRQ(ierr);
ierr = VecDuplicate(eps->W[0],&xr); CHKERRQ(ierr);
ierr = VecDuplicate(eps->W[0],&xi); CHKERRQ(ierr);
1464,8 → 1464,8
Vec w;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(vec,VEC_COOKIE,3);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidHeaderSpecific(vec,VEC_CLASSID,3);
 
ierr = VecDuplicate(eps->V[0],&w);CHKERRQ(ierr);
 
1538,8 → 1538,8
Vec w;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(vec,VEC_COOKIE,3);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
PetscValidHeaderSpecific(vec,VEC_CLASSID,3);
 
ierr = VecDuplicate(eps->W[0],&w);CHKERRQ(ierr);
 
/trunk/src/eps/impls/external/trlan/trlan.c
158,7 → 158,7
EPS_TRLAN *tr = (EPS_TRLAN *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscFree(tr->work);CHKERRQ(ierr);
ierr = PetscFree(eps->data);CHKERRQ(ierr);
ierr = EPSFreeSolution(eps);CHKERRQ(ierr);
/trunk/src/eps/impls/external/arpack/arpack.c
321,7 → 321,7
EPS_ARPACK *ar = (EPS_ARPACK *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscFree(ar->workev);CHKERRQ(ierr);
ierr = PetscFree(ar->workl);CHKERRQ(ierr);
ierr = PetscFree(ar->select);CHKERRQ(ierr);
/trunk/src/eps/impls/external/blzpack/blzpack.c
292,7 → 292,7
EPS_BLZPACK *blz = (EPS_BLZPACK *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscFree(blz->istor);CHKERRQ(ierr);
ierr = PetscFree(blz->rstor);CHKERRQ(ierr);
ierr = PetscFree(blz->u);CHKERRQ(ierr);
407,7 → 407,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSBlzpackSetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,bs);CHKERRQ(ierr);
465,7 → 465,7
PetscErrorCode ierr, (*f)(EPS,PetscReal,PetscReal);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSBlzpackSetInterval_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,initial,final);CHKERRQ(ierr);
510,7 → 510,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSBlzpackSetNSteps_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,nsteps);CHKERRQ(ierr);
/trunk/src/eps/impls/external/primme/primme.c
303,7 → 303,7
EPS_PRIMME *ops = (EPS_PRIMME *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
primme_Free(&ops->primme);
ierr = VecDestroy(ops->x);CHKERRQ(ierr);
420,7 → 420,7
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPRIMMESetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,bs);CHKERRQ(ierr);
466,7 → 466,7
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPRIMMEGetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,bs);CHKERRQ(ierr);
524,7 → 524,7
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPRIMMESetMethod_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,method); CHKERRQ(ierr);
578,7 → 578,7
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPRIMMEGetMethod_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,method); CHKERRQ(ierr);
/trunk/src/eps/impls/krylov/arnoldi/arnoldi.c
508,7 → 508,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSArnoldiSetDelayed_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,delayed);CHKERRQ(ierr);
552,7 → 552,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSArnoldiGetDelayed_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,delayed);CHKERRQ(ierr);
567,7 → 567,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = EPSDestroy_Default(eps);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)eps,"EPSArnoldiSetDelayed_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)eps,"EPSArnoldiGetDelayed_C","",PETSC_NULL);CHKERRQ(ierr);
/trunk/src/eps/impls/krylov/lanczos/lanczos.c
768,7 → 768,7
PetscErrorCode ierr, (*f)(EPS,EPSLanczosReorthogType);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSLanczosSetReorthog_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,reorthog);CHKERRQ(ierr);
811,7 → 811,7
PetscErrorCode ierr, (*f)(EPS,EPSLanczosReorthogType*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSLanczosGetReorthog_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,reorthog);CHKERRQ(ierr);
827,7 → 827,7
EPS_LANCZOS *lanczos = (EPS_LANCZOS *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (lanczos->AV) { ierr = VecDestroyVecs(lanczos->AV,eps->ncv);CHKERRQ(ierr); }
ierr = EPSDestroy_Default(eps);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)eps,"EPSLanczosSetReorthog_C","",PETSC_NULL);CHKERRQ(ierr);
/trunk/src/eps/impls/davidson/common/davidson.c
392,7 → 392,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
data->krylovstart = krylovstart;
 
406,7 → 406,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
*krylovstart = data->krylovstart;
 
420,7 → 420,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if(blocksize == PETSC_DEFAULT || blocksize == PETSC_DECIDE) blocksize = 1;
if(blocksize <= 0)
437,7 → 437,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
*blocksize = data->blocksize;
 
451,7 → 451,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if(minv == PETSC_DEFAULT || minv == PETSC_DECIDE) minv = 5;
if(minv <= 0)
472,7 → 472,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
*minv = data->minv;
*plusk = data->plusk;
487,7 → 487,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
*initialsize = data->initialsize;
 
501,7 → 501,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if(initialsize == PETSC_DEFAULT || initialsize == PETSC_DECIDE) initialsize = 5;
if(initialsize <= 0)
518,7 → 518,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
*fix = data->fix;
 
532,7 → 532,7
EPS_DAVIDSON *data = (EPS_DAVIDSON*)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
 
if(fix == PETSC_DEFAULT || fix == PETSC_DECIDE) fix = 0.01;
if(fix < 0.0)
/trunk/src/eps/impls/davidson/gd/gd.c
168,7 → 168,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDSetKrylovStart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,krylovstart);CHKERRQ(ierr);
200,7 → 200,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDGetKrylovStart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,krylovstart);CHKERRQ(ierr);
233,7 → 233,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDSetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,blocksize);CHKERRQ(ierr);
265,7 → 265,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDGetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,blocksize);CHKERRQ(ierr);
299,7 → 299,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDGetRestart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,minv,plusk);CHKERRQ(ierr);
337,7 → 337,7
PetscErrorCode ierr, (*f)(EPS,PetscInt,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDSetRestart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,minv,plusk);CHKERRQ(ierr);
374,7 → 374,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDGetInitialSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,initialsize);CHKERRQ(ierr);
413,7 → 413,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSGDSetInitialSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,initialsize);CHKERRQ(ierr);
/trunk/src/eps/impls/davidson/jd/jd.c
183,7 → 183,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDSetKrylovStart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,krylovstart);CHKERRQ(ierr);
215,7 → 215,7
PetscErrorCode ierr, (*f)(EPS,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDGetKrylovStart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,krylovstart);CHKERRQ(ierr);
248,7 → 248,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDSetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,blocksize);CHKERRQ(ierr);
280,7 → 280,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDGetBlockSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,blocksize);CHKERRQ(ierr);
314,7 → 314,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDGetRestart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,minv,plusk);CHKERRQ(ierr);
352,7 → 352,7
PetscErrorCode ierr, (*f)(EPS,PetscInt,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDSetRestart_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,minv,plusk);CHKERRQ(ierr);
389,7 → 389,7
PetscErrorCode ierr, (*f)(EPS,PetscInt*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDGetInitialSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,initialsize);CHKERRQ(ierr);
428,7 → 428,7
PetscErrorCode ierr, (*f)(EPS,PetscInt);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDSetInitialSize_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,initialsize);CHKERRQ(ierr);
459,7 → 459,7
PetscErrorCode ierr, (*f)(EPS,PetscReal*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDGetFix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,fix);CHKERRQ(ierr);
495,7 → 495,7
PetscErrorCode ierr, (*f)(EPS,PetscReal);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSJDSetFix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,fix);CHKERRQ(ierr);
/trunk/src/eps/impls/lapack/lapack.c
200,7 → 200,7
EPS_LAPACK *la = (EPS_LAPACK *)eps->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (la->OP) { ierr = MatDestroy(la->OP);CHKERRQ(ierr); }
if (la->A) { ierr = MatDestroy(la->A);CHKERRQ(ierr); }
if (la->B) { ierr = MatDestroy(la->B);CHKERRQ(ierr); }
/trunk/src/eps/impls/power/power.c
475,7 → 475,7
PetscErrorCode ierr, (*f)(EPS,EPSPowerShiftType);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPowerSetShiftType_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,shift);CHKERRQ(ierr);
518,7 → 518,7
PetscErrorCode ierr, (*f)(EPS,EPSPowerShiftType*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)eps,"EPSPowerGetShiftType_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(eps,shift);CHKERRQ(ierr);
533,7 → 533,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,1);
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
ierr = EPSDestroy_Default(eps);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)eps,"EPSPowerSetShiftType_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)eps,"EPSPowerGetShiftType_C","",PETSC_NULL);CHKERRQ(ierr);
/trunk/src/ip/ipdot.c
55,8 → 55,8
PetscScalar p;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidPointer(norm,3);
if (!ip->matrix && ip->bilinear_form == IP_INNER_HERMITIAN) {
103,8 → 103,8
PetscScalar p;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidPointer(norm,3);
if (!ip->matrix && ip->bilinear_form == IP_INNER_HERMITIAN) {
143,8 → 143,8
PetscScalar p;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidPointer(norm,3);
if (!ip->matrix && ip->bilinear_form == IP_INNER_HERMITIAN) {
198,9 → 198,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(y,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
PetscValidScalarPointer(p,4);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
248,9 → 248,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(y,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
PetscValidScalarPointer(p,4);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
300,9 → 300,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,2);
PetscValidHeaderSpecific(y,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,2);
PetscValidHeaderSpecific(y,VEC_CLASSID,3);
PetscValidScalarPointer(p,4);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
356,10 → 356,10
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
PetscValidPointer(y,4);
PetscValidHeaderSpecific(*y,VEC_COOKIE,4);
PetscValidHeaderSpecific(*y,VEC_CLASSID,4);
PetscValidScalarPointer(p,5);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
408,11 → 408,11
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
if (n == 0) PetscFunctionReturn(0);
PetscValidPointer(y,4);
PetscValidHeaderSpecific(*y,VEC_COOKIE,4);
PetscValidHeaderSpecific(*y,VEC_CLASSID,4);
PetscValidScalarPointer(p,5);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
463,11 → 463,11
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
if (n == 0) PetscFunctionReturn(0);
PetscValidPointer(y,4);
PetscValidHeaderSpecific(*y,VEC_COOKIE,4);
PetscValidHeaderSpecific(*y,VEC_CLASSID,4);
PetscValidScalarPointer(p,5);
ierr = PetscLogEventBegin(IP_InnerProduct,ip,x,0,0);CHKERRQ(ierr);
/trunk/src/ip/ipbasic.c
23,7 → 23,7
 
#include "private/ipimpl.h" /*I "slepcip.h" I*/
 
PetscCookie IP_COOKIE = 0;
PetscClassId IP_CLASSID = 0;
PetscLogEvent IP_InnerProduct = 0, IP_Orthogonalize = 0, IP_ApplyMatrix = 0;
 
#undef __FUNCT__
52,17 → 52,17
if (initialized) PetscFunctionReturn(0);
initialized = PETSC_TRUE;
/* Register Classes */
ierr = PetscCookieRegister("Inner product",&IP_COOKIE);CHKERRQ(ierr);
ierr = PetscClassIdRegister("Inner product",&IP_CLASSID);CHKERRQ(ierr);
/* Register Events */
ierr = PetscLogEventRegister("IPOrthogonalize",IP_COOKIE,&IP_Orthogonalize); CHKERRQ(ierr);
ierr = PetscLogEventRegister("IPInnerProduct",IP_COOKIE,&IP_InnerProduct); CHKERRQ(ierr);
ierr = PetscLogEventRegister("IPApplyMatrix",IP_COOKIE,&IP_ApplyMatrix); CHKERRQ(ierr);
ierr = PetscLogEventRegister("IPOrthogonalize",IP_CLASSID,&IP_Orthogonalize); CHKERRQ(ierr);
ierr = PetscLogEventRegister("IPInnerProduct",IP_CLASSID,&IP_InnerProduct); CHKERRQ(ierr);
ierr = PetscLogEventRegister("IPApplyMatrix",IP_CLASSID,&IP_ApplyMatrix); CHKERRQ(ierr);
/* Process info exclusions */
ierr = PetscOptionsGetString(PETSC_NULL, "-log_info_exclude", logList, 256, &opt);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);CHKERRQ(ierr);
if (opt) {
ierr = PetscStrstr(logList, "ip", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscInfoDeactivateClass(IP_COOKIE);CHKERRQ(ierr);
ierr = PetscInfoDeactivateClass(IP_CLASSID);CHKERRQ(ierr);
}
}
/* Process summary exclusions */
70,7 → 70,7
if (opt) {
ierr = PetscStrstr(logList, "ip", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscLogEventDeactivateClass(IP_COOKIE);CHKERRQ(ierr);
ierr = PetscLogEventDeactivateClass(IP_CLASSID);CHKERRQ(ierr);
}
}
PetscFunctionReturn(0);
104,7 → 104,7
 
PetscFunctionBegin;
PetscValidPointer(newip,2);
ierr = PetscHeaderCreate(ip,_p_IP,int,IP_COOKIE,-1,"IP",comm,IPDestroy,IPView);CHKERRQ(ierr);
ierr = PetscHeaderCreate(ip,_p_IP,int,IP_CLASSID,-1,"IP",comm,IPDestroy,IPView);CHKERRQ(ierr);
*newip = ip;
ip->orthog_type = IP_ORTH_CGS;
ip->orthog_ref = IP_ORTH_REFINE_IFNEEDED;
145,7 → 145,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
ierr = PetscObjectSetOptionsPrefix((PetscObject)ip,prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
174,7 → 174,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)ip,prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
204,7 → 204,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidPointer(prefix,2);
ierr = PetscObjectGetOptionsPrefix((PetscObject)ip, prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
237,7 → 237,7
PetscInt i,j;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
ierr = PetscOptionsBegin(((PetscObject)ip)->comm,((PetscObject)ip)->prefix,"Inner Product (IP) Options","IP");CHKERRQ(ierr);
i = ip->orthog_type;
ierr = PetscOptionsEList("-orthog_type","Orthogonalization method","IPSetOrthogonalization",orth_list,2,orth_list[i],&i,PETSC_NULL);CHKERRQ(ierr);
288,7 → 288,7
PetscErrorCode IPSetOrthogonalization(IP ip,IPOrthogonalizationType type, IPOrthogonalizationRefinementType refinement, PetscReal eta)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
switch (type) {
case IP_ORTH_CGS:
case IP_ORTH_MGS:
339,7 → 339,7
PetscErrorCode IPGetOrthogonalization(IP ip,IPOrthogonalizationType *type,IPOrthogonalizationRefinementType *refinement, PetscReal *eta)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (type) *type = ip->orthog_type;
if (refinement) *refinement = ip->orthog_ref;
if (eta) *eta = ip->orthog_eta;
378,9 → 378,9
PetscTruth isascii;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (!viewer) viewer = PETSC_VIEWER_STDOUT_(((PetscObject)ip)->comm);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2);
PetscCheckSameComm(ip,1,viewer,2);
 
ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&isascii);CHKERRQ(ierr);
434,7 → 434,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (--((PetscObject)ip)->refct > 0) PetscFunctionReturn(0);
 
if (ip->matrix) { ierr = MatDestroy(ip->matrix);CHKERRQ(ierr); }
464,7 → 464,7
PetscErrorCode IPGetOperationCounters(IP ip,PetscInt *dots)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
PetscValidPointer(dots,2);
*dots = ip->innerproducts;
PetscFunctionReturn(0);
488,7 → 488,7
PetscErrorCode IPResetOperationCounters(IP ip)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
ip->innerproducts = 0;
PetscFunctionReturn(0);
}
/trunk/src/ip/ipform.c
50,9 → 50,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (mat) {
PetscValidHeaderSpecific(mat,MAT_COOKIE,1);
PetscValidHeaderSpecific(mat,MAT_CLASSID,1);
PetscObjectReference((PetscObject)mat);
}
if (ip->matrix) {
87,7 → 87,7
PetscErrorCode IPGetBilinearForm(IP ip,Mat* mat,IPBilinearForm* form)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (mat) *mat = ip->matrix;
if (form) *form = ip->bilinear_form;
PetscFunctionReturn(0);
137,7 → 137,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(ip,IP_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,1);
if (ip->matrix) {
ierr = IPApplyMatrix_Private(ip,x);CHKERRQ(ierr);
ierr = VecCopy(ip->Bx,y);CHKERRQ(ierr);
/trunk/src/svd/interface/svdbasic.c
24,7 → 24,7
#include "private/svdimpl.h" /*I "slepcsvd.h" I*/
 
PetscFList SVDList = 0;
PetscCookie SVD_COOKIE = 0;
PetscClassId SVD_CLASSID = 0;
PetscLogEvent SVD_SetUp = 0, SVD_Solve = 0, SVD_Dense = 0;
static PetscTruth SVDPackageInitialized = PETSC_FALSE;
 
71,19 → 71,19
if (SVDPackageInitialized) PetscFunctionReturn(0);
SVDPackageInitialized = PETSC_TRUE;
/* Register Classes */
ierr = PetscCookieRegister("Singular Value Solver",&SVD_COOKIE);CHKERRQ(ierr);
ierr = PetscClassIdRegister("Singular Value Solver",&SVD_CLASSID);CHKERRQ(ierr);
/* Register Constructors */
ierr = SVDRegisterAll(path);CHKERRQ(ierr);
/* Register Events */
ierr = PetscLogEventRegister("SVDSetUp",SVD_COOKIE,&SVD_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SVDSolve",SVD_COOKIE,&SVD_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SVDDense",SVD_COOKIE,&SVD_Dense);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SVDSetUp",SVD_CLASSID,&SVD_SetUp);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SVDSolve",SVD_CLASSID,&SVD_Solve);CHKERRQ(ierr);
ierr = PetscLogEventRegister("SVDDense",SVD_CLASSID,&SVD_Dense);CHKERRQ(ierr);
/* Process info exclusions */
ierr = PetscOptionsGetString(PETSC_NULL, "-log_info_exclude", logList, 256, &opt);CHKERRQ(ierr);
ierr = PetscOptionsGetString(PETSC_NULL, "-info_exclude", logList, 256, &opt);CHKERRQ(ierr);
if (opt) {
ierr = PetscStrstr(logList, "svd", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscInfoDeactivateClass(SVD_COOKIE);CHKERRQ(ierr);
ierr = PetscInfoDeactivateClass(SVD_CLASSID);CHKERRQ(ierr);
}
}
/* Process summary exclusions */
91,7 → 91,7
if (opt) {
ierr = PetscStrstr(logList, "svd", &className);CHKERRQ(ierr);
if (className) {
ierr = PetscLogEventDeactivateClass(SVD_COOKIE);CHKERRQ(ierr);
ierr = PetscLogEventDeactivateClass(SVD_CLASSID);CHKERRQ(ierr);
}
}
ierr = PetscRegisterFinalize(SVDFinalizePackage);CHKERRQ(ierr);
134,9 → 134,9
PetscTruth isascii;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (!viewer) viewer = PETSC_VIEWER_STDOUT_(((PetscObject)svd)->comm);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_COOKIE,2);
PetscValidHeaderSpecific(viewer,PETSC_VIEWER_CLASSID,2);
PetscCheckSameComm(svd,1,viewer,2);
 
ierr = PetscTypeCompare((PetscObject)viewer,PETSC_VIEWER_ASCII,&isascii);CHKERRQ(ierr);
215,7 → 215,7
PetscFunctionBegin;
PetscValidPointer(outsvd,2);
 
ierr = PetscHeaderCreate(svd,_p_SVD,struct _SVDOps,SVD_COOKIE,-1,"SVD",comm,SVDDestroy,SVDView);CHKERRQ(ierr);
ierr = PetscHeaderCreate(svd,_p_SVD,struct _SVDOps,SVD_CLASSID,-1,"SVD",comm,SVDDestroy,SVDView);CHKERRQ(ierr);
*outsvd = svd;
 
ierr = PetscMemzero(svd->ops,sizeof(struct _SVDOps));CHKERRQ(ierr);
277,7 → 277,7
PetscScalar *p;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (--((PetscObject)svd)->refct > 0) PetscFunctionReturn(0);
 
/* if memory was published with AMS then destroy it */
327,7 → 327,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscFree(svd->data);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
369,7 → 369,7
PetscTruth match;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidCharPointer(type,2);
 
ierr = PetscTypeCompare((PetscObject)svd,type,&match);CHKERRQ(ierr);
413,7 → 413,7
PetscErrorCode SVDGetType(SVD svd,const SVDType *type)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(type,2);
*type = ((PetscObject)svd)->type_name;
PetscFunctionReturn(0);
525,8 → 525,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(ip,IP_COOKIE,2);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidHeaderSpecific(ip,IP_CLASSID,2);
PetscCheckSameComm(svd,1,ip,2);
ierr = PetscObjectReference((PetscObject)ip);CHKERRQ(ierr);
ierr = IPDestroy(svd->ip); CHKERRQ(ierr);
555,7 → 555,7
PetscErrorCode SVDGetIP(SVD svd,IP *ip)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(ip,2);
*ip = svd->ip;
PetscFunctionReturn(0);
/trunk/src/svd/interface/svdmat.c
30,9 → 30,9
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(x,VEC_COOKIE,3);
PetscValidHeaderSpecific(y,VEC_COOKIE,4);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidHeaderSpecific(x,VEC_CLASSID,3);
PetscValidHeaderSpecific(y,VEC_CLASSID,4);
svd->matvecs++;
if (trans) {
if (svd->AT) {
57,7 → 57,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->A) {
ierr = MatGetVecs(svd->A,x,y);CHKERRQ(ierr);
} else {
73,7 → 73,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->A) {
ierr = MatGetSize(svd->A,m,n);CHKERRQ(ierr);
} else {
89,7 → 89,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->A) {
ierr = MatGetLocalSize(svd->A,m,n);CHKERRQ(ierr);
} else {
/trunk/src/svd/interface/svdopts.c
60,7 → 60,7
PetscErrorCode SVDSetTransposeMode(SVD svd,SVDTransposeMode mode)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (mode == PETSC_DEFAULT || mode == PETSC_DECIDE) mode = (SVDTransposeMode)PETSC_DECIDE;
else switch (mode) {
case SVD_TRANSPOSE_EXPLICIT:
97,7 → 97,7
PetscErrorCode SVDGetTransposeMode(SVD svd,SVDTransposeMode *mode)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(mode,2);
*mode = svd->transmode;
PetscFunctionReturn(0);
131,7 → 131,7
PetscErrorCode SVDSetTolerances(SVD svd,PetscReal tol,PetscInt maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (tol != PETSC_IGNORE) {
if (tol == PETSC_DEFAULT) {
tol = 1e-7;
177,7 → 177,7
PetscErrorCode SVDGetTolerances(SVD svd,PetscReal *tol,PetscInt *maxits)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (tol) *tol = svd->tol;
if (maxits) *maxits = svd->max_it;
PetscFunctionReturn(0);
224,7 → 224,7
PetscErrorCode SVDSetDimensions(SVD svd,PetscInt nsv,PetscInt ncv,PetscInt mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
 
if (nsv != PETSC_IGNORE) {
if (nsv<1) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Illegal value of nsv. Must be > 0");
276,7 → 276,7
PetscErrorCode SVDGetDimensions(SVD svd,PetscInt *nsv,PetscInt *ncv,PetscInt *mpd)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (nsv) *nsv = svd->nsv;
if (ncv) *ncv = svd->ncv;
if (mpd) *mpd = svd->mpd;
314,7 → 314,7
PetscErrorCode SVDSetWhichSingularTriplets(SVD svd,SVDWhich which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
switch (which) {
case SVD_LARGEST:
case SVD_SMALLEST:
353,7 → 353,7
PetscErrorCode SVDGetWhichSingularTriplets(SVD svd,SVDWhich *which)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(which,2);
*which = svd->which;
PetscFunctionReturn(0);
390,7 → 390,7
SVDMONITOR_CONV *ctx;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
svd->setupcalled = 0;
ierr = PetscOptionsBegin(((PetscObject)svd)->comm,((PetscObject)svd)->prefix,"Singular Value Solver (SVD) Options","SVD");CHKERRQ(ierr);
 
495,7 → 495,7
PetscErrorCode SVDSetTrackAll(SVD svd,PetscTruth trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
svd->trackall = trackall;
PetscFunctionReturn(0);
}
521,7 → 521,7
PetscErrorCode SVDGetTrackAll(SVD svd,PetscTruth *trackall)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(trackall,2);
*trackall = svd->trackall;
PetscFunctionReturn(0);
563,7 → 563,7
EPS eps;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectSetOptionsPrefix((PetscObject)svd,prefix);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)svd,SVDCROSS,&flg1);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)svd,SVDCYCLIC,&flg2);CHKERRQ(ierr);
608,7 → 608,7
EPS eps;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectAppendOptionsPrefix((PetscObject)svd,prefix);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)svd,SVDCROSS,&flg1);CHKERRQ(ierr);
ierr = PetscTypeCompare((PetscObject)svd,SVDCYCLIC,&flg2);CHKERRQ(ierr);
651,7 → 651,7
{
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(prefix,2);
ierr = PetscObjectGetOptionsPrefix((PetscObject)svd,prefix);CHKERRQ(ierr);
PetscFunctionReturn(0);
/trunk/src/svd/interface/svdsolve.c
49,7 → 49,7
PetscViewer viewer;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
 
if (!svd->setupcalled) { ierr = SVDSetUp(svd);CHKERRQ(ierr); }
svd->its = 0;
117,7 → 117,7
PetscErrorCode SVDGetIterationNumber(SVD svd,PetscInt *its)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidIntPointer(its,2);
*its = svd->its;
PetscFunctionReturn(0);
152,7 → 152,7
PetscErrorCode SVDGetConvergedReason(SVD svd,SVDConvergedReason *reason)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidIntPointer(reason,2);
*reason = svd->reason;
PetscFunctionReturn(0);
180,7 → 180,7
PetscErrorCode SVDGetConverged(SVD svd,PetscInt *nconv)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidIntPointer(nconv,2);
if (svd->reason == SVD_CONVERGED_ITERATING) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "SVDSolve must be called first");
224,7 → 224,7
Vec w;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(sigma,3);
if (svd->reason == SVD_CONVERGED_ITERATING) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "SVDSolve must be called first");
236,7 → 236,7
ierr = MatGetSize(svd->OP,&M,&N);CHKERRQ(ierr);
if (M<N) { w = u; u = v; v = w; }
if (u) {
PetscValidHeaderSpecific(u,VEC_COOKIE,4);
PetscValidHeaderSpecific(u,VEC_CLASSID,4);
if (!svd->U) {
ierr = PetscMalloc(sizeof(Vec)*svd->ncv,&svd->U);CHKERRQ(ierr);
ierr = SVDMatGetLocalSize(svd,&nloc,PETSC_NULL);CHKERRQ(ierr);
253,7 → 253,7
ierr = VecCopy(svd->U[svd->perm[i]],u);CHKERRQ(ierr);
}
if (v) {
PetscValidHeaderSpecific(v,VEC_COOKIE,5);
PetscValidHeaderSpecific(v,VEC_CLASSID,5);
ierr = VecCopy(svd->V[svd->perm[i]],v);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
292,7 → 292,7
PetscInt M,N;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->reason == SVD_CONVERGED_ITERATING) {
SETERRQ(PETSC_ERR_ARG_WRONGSTATE, "SVDSolve must be called first");
}
359,7 → 359,7
PetscReal sigma,norm1,norm2;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(error,2);
ierr = SVDGetSingularTriplet(svd,i,&sigma,PETSC_NULL,PETSC_NULL);CHKERRQ(ierr);
ierr = SVDComputeResidualNorms(svd,i,&norm1,&norm2);CHKERRQ(ierr);
394,7 → 394,7
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (matvecs) *matvecs = svd->matvecs;
if (dots) {
ierr = IPGetOperationCounters(svd->ip,dots);CHKERRQ(ierr);
/trunk/src/svd/interface/svdmon.c
74,7 → 74,7
void *mctx,PetscErrorCode (*monitordestroy)(void*))
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->numbermonitors >= MAXSVDMONITORS) {
SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Too many SVD monitors set");
}
109,7 → 109,7
PetscInt i;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
for (i=0; i<svd->numbermonitors; i++) {
if (svd->monitordestroy[i]) {
ierr = (*svd->monitordestroy[i])(svd->monitorcontext[i]);CHKERRQ(ierr);
140,7 → 140,7
PetscErrorCode SVDGetMonitorContext(SVD svd, void **ctx)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
*ctx = (svd->monitorcontext[0]);
PetscFunctionReturn(0);
}
/trunk/src/svd/interface/svdsetup.c
43,8 → 43,8
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(mat,MAT_COOKIE,2);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidHeaderSpecific(mat,MAT_CLASSID,2);
PetscCheckSameComm(svd,1,mat,2);
ierr = PetscObjectReference((PetscObject)mat);CHKERRQ(ierr);
if (svd->OP) {
75,7 → 75,7
PetscErrorCode SVDGetOperator(SVD svd,Mat *A)
{
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
PetscValidPointer(A,2);
*A = svd->OP;
PetscFunctionReturn(0);
110,7 → 110,7
PetscReal norm;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (svd->setupcalled) PetscFunctionReturn(0);
ierr = PetscLogEventBegin(SVD_SetUp,svd,0,0,0);CHKERRQ(ierr);
 
262,7 → 262,7
PetscInt i;
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
if (n<0) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Argument n cannot be negative");
 
/* free previous non-processed vectors */
/trunk/src/svd/impls/trlanczos/trlanczos.c
427,7 → 427,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDTRLanczosSetOneSide_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,oneside);CHKERRQ(ierr);
458,7 → 458,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDTRLanczosGetOneSide_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,oneside);CHKERRQ(ierr);
488,7 → 488,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = SVDDestroy_Default(svd);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)svd,"SVDTRLanczosSetOneSide_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)svd,"SVDTRLanczosGetOneSide_C","",PETSC_NULL);CHKERRQ(ierr);
/trunk/src/svd/impls/cyclic/cyclic.c
381,7 → 381,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCyclicSetExplicitMatrix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,explicitmatrix);CHKERRQ(ierr);
425,7 → 425,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCyclicGetExplicitMatrix_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,explicitmatrix);CHKERRQ(ierr);
442,7 → 442,7
SVD_CYCLIC *cyclic = (SVD_CYCLIC *)svd->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,2);
PetscValidHeaderSpecific(eps,EPS_CLASSID,2);
PetscCheckSameComm(svd,1,eps,2);
ierr = PetscObjectReference((PetscObject)eps);CHKERRQ(ierr);
ierr = EPSDestroy(cyclic->eps);CHKERRQ(ierr);
473,7 → 473,7
PetscErrorCode ierr, (*f)(SVD,EPS eps);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCyclicSetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,eps);CHKERRQ(ierr);
518,7 → 518,7
PetscErrorCode ierr, (*f)(SVD,EPS *eps);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCyclicGetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,eps);CHKERRQ(ierr);
/trunk/src/svd/impls/cross/cross.c
218,7 → 218,7
SVD_CROSS *cross = (SVD_CROSS *)svd->data;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_COOKIE,2);
PetscValidHeaderSpecific(eps,EPS_CLASSID,2);
PetscCheckSameComm(svd,1,eps,2);
ierr = PetscObjectReference((PetscObject)eps);CHKERRQ(ierr);
ierr = EPSDestroy(cross->eps);CHKERRQ(ierr);
249,7 → 249,7
PetscErrorCode ierr, (*f)(SVD,EPS eps);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCrossSetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,eps);CHKERRQ(ierr);
294,7 → 294,7
PetscErrorCode ierr, (*f)(SVD,EPS *eps);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDCrossGetEPS_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,eps);CHKERRQ(ierr);
/trunk/src/svd/impls/lanczos/gklanczos.c
362,7 → 362,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDLanczosSetOneSide_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,oneside);CHKERRQ(ierr);
393,7 → 393,7
PetscErrorCode ierr, (*f)(SVD,PetscTruth*);
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = PetscObjectQueryFunction((PetscObject)svd,"SVDLanczosGetOneSide_C",(void (**)())&f);CHKERRQ(ierr);
if (f) {
ierr = (*f)(svd,oneside);CHKERRQ(ierr);
422,7 → 422,7
PetscErrorCode ierr;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(svd,SVD_COOKIE,1);
PetscValidHeaderSpecific(svd,SVD_CLASSID,1);
ierr = SVDDestroy_Default(svd);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)svd,"SVDLanczosSetOneSide_C","",PETSC_NULL);CHKERRQ(ierr);
ierr = PetscObjectComposeFunctionDynamic((PetscObject)svd,"SVDLanczosGetOneSide_C","",PETSC_NULL);CHKERRQ(ierr);
/trunk/src/sys/slepcutil.c
54,8 → 54,8
PetscScalar *px,t;
PetscFunctionBegin;
PetscValidHeaderSpecific(x,VEC_COOKIE,1);
if (rctx) PetscValidHeaderSpecific(rctx,PETSC_RANDOM_COOKIE,2);
PetscValidHeaderSpecific(x,VEC_CLASSID,1);
if (rctx) PetscValidHeaderSpecific(rctx,PETSC_RANDOM_CLASSID,2);
if (!rctx) {
MPI_Comm comm;
ierr = PetscObjectGetComm((PetscObject)x,&comm);CHKERRQ(ierr);
254,7 → 254,7
PetscTruth flg;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(mat,MAT_COOKIE,1);
PetscValidHeaderSpecific(mat,MAT_CLASSID,1);
PetscValidPointer(newmat,2);
 
ierr = PetscObjectGetComm((PetscObject)mat,&comm);CHKERRQ(ierr);
536,12 → 536,12
PetscScalar *py,*px;
 
PetscFunctionBegin;
PetscValidHeaderSpecific(y,VEC_COOKIE,1);
PetscValidHeaderSpecific(y,VEC_CLASSID,1);
if (!nv || !(y)->map->n) PetscFunctionReturn(0);
if (nv < 0) SETERRQ1(PETSC_ERR_ARG_OUTOFRANGE,"Number of vectors (given %D) cannot be negative",nv);
PetscValidScalarPointer(a,3);
PetscValidPointer(x,6);
PetscValidHeaderSpecific(*x,VEC_COOKIE,6);
PetscValidHeaderSpecific(*x,VEC_CLASSID,6);
PetscValidType(y,1);
PetscValidType(*x,6);
PetscCheckSameTypeAndComm(y,1,*x,6);
/trunk/src/sys/slepcinit.c
166,12 → 166,12
 
ierr = PetscLogEventRegister("UpdateVectors",0,&SLEPC_UpdateVectors);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecMAXPBY",0,&SLEPC_VecMAXPBY);CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatProd", EPS_COOKIE, &SLEPC_SlepcDenseMatProd); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseOrth", EPS_COOKIE, &SLEPC_SlepcDenseOrth); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatInvProd", EPS_COOKIE, &SLEPC_SlepcDenseMatInvProd); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatNorm", EPS_COOKIE, &SLEPC_SlepcDenseNorm); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseCopy", EPS_COOKIE, &SLEPC_SlepcDenseCopy); CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecsMult", EPS_COOKIE, &SLEPC_VecsMult); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatProd", EPS_CLASSID, &SLEPC_SlepcDenseMatProd); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseOrth", EPS_CLASSID, &SLEPC_SlepcDenseOrth); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatInvProd", EPS_CLASSID, &SLEPC_SlepcDenseMatInvProd); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseMatNorm", EPS_CLASSID, &SLEPC_SlepcDenseNorm); CHKERRQ(ierr);
ierr = PetscLogEventRegister("DenseCopy", EPS_CLASSID, &SLEPC_SlepcDenseCopy); CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecsMult", EPS_CLASSID, &SLEPC_VecsMult); CHKERRQ(ierr);
 
#if defined(PETSC_HAVE_DRAND48)
/* work-around for Cygwin drand48() initialization bug */