void PVBBDFree(PVBBDData pdata)
{
BandFreeMat(pdata->savedJ);
BandFreeMat(pdata->savedP);
BandFreePiv(pdata->pivots);
free(pdata);
}
void *CVBandPrecAlloc(void *cvode_mem, long int N,
long int mu, long int ml)
{
CVodeMem cv_mem;
CVBandPrecData pdata;
long int mup, mlp, storagemu;
if (cvode_mem == NULL) {
fprintf(stderr, MSGBP_CVMEM_NULL);
return(NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the BAND preconditioner */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGBP_BAD_NVECTOR);
return(NULL);
}
pdata = (CVBandPrecData) malloc(sizeof *pdata); /* Allocate data memory */
if (pdata == NULL) return(NULL);
/* Load pointers and bandwidths into pdata block. */
pdata->cvode_mem = cvode_mem;
pdata->N = N;
pdata->mu = mup = MIN( N-1, MAX(0,mu) );
pdata->ml = mlp = MIN( N-1, MAX(0,ml) );
/* Initialize nfeBP counter */
pdata->nfeBP = 0;
/* Allocate memory for saved banded Jacobian approximation. */
pdata->savedJ = BandAllocMat(N, mup, mlp, mup);
if (pdata->savedJ == NULL) {
free(pdata);
return(NULL);
}
/* Allocate memory for banded preconditioner. */
storagemu = MIN( N-1, mup + mlp);
pdata->savedP = BandAllocMat(N, mup, mlp, storagemu);
if (pdata->savedP == NULL) {
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
/* Allocate memory for pivot array. */
pdata->pivots = BandAllocPiv(N);
if (pdata->savedJ == NULL) {
BandFreeMat(pdata->savedP);
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
return((void *) pdata);
}
static void CVBandFree(CVodeMem cv_mem)
{
CVBandMem cvband_mem;
cvband_mem = (CVBandMem) lmem;
BandFreeMat(M);
BandFreeMat(savedJ);
BandFreePiv(pivots);
free(cvband_mem); cvband_mem = NULL;
}
void CVBBDPrecFree(void *bbd_data)
{
CVBBDPrecData pdata;
if ( bbd_data != NULL ) {
pdata = (CVBBDPrecData) bbd_data;
BandFreeMat(pdata->savedJ);
BandFreeMat(pdata->savedP);
BandFreePiv(pdata->pivots);
free(pdata);
}
}
void CVBandPrecFree(void **bp_data)
{
CVBandPrecData pdata;
if (*bp_data == NULL) return;
pdata = (CVBandPrecData) (*bp_data);
BandFreeMat(pdata->savedJ);
BandFreeMat(pdata->savedP);
BandFreePiv(pdata->pivots);
free(*bp_data);
*bp_data = NULL;
}
PVBBDData PVBBDAlloc(integer Nlocal, integer mudq, integer mldq,
integer mukeep, integer mlkeep, real dqrely,
PVLocalFn gloc, PVCommFn cfn, void *f_data)
{
PVBBDData pdata;
pdata = (PVBBDData) malloc(sizeof *pdata); /* Allocate data memory */
if (pdata == NULL)
return(NULL);
/* Set pointers to f_data, gloc, and cfn; load scalar inputs */
pdata->f_data = f_data;
pdata->mudq = mudq;
pdata->mldq = mldq;
pdata->mukeep = mukeep;
pdata->mlkeep = mlkeep;
pdata->dqrely = dqrely;
pdata->gloc = gloc;
pdata->cfn = cfn;
/* Allocate memory for saved Jacobian */
pdata->savedJ = BandAllocMat(Nlocal, mukeep, mlkeep, mukeep);
if (pdata->savedJ == NULL) {
free(pdata);
return(NULL);
}
/* Allocate memory for preconditioner matrix */
pdata->savedP = BandAllocMat(Nlocal, mukeep, mlkeep, mukeep+mlkeep);
if (pdata->savedP == NULL) {
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
/* Allocate memory for pivots */
pdata->pivots = BandAllocPiv(Nlocal);
if (pdata->savedJ == NULL) {
BandFreeMat(pdata->savedP);
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
/* Set work space sizes and initialize nge */
pdata->rpwsize = Nlocal*(2*mukeep + 3*mlkeep + 2);
pdata->ipwsize = Nlocal;
pdata->nge = 0;
return(pdata);
}
static int IDABandFree(IDAMem IDA_mem)
{
IDABandMem idaband_mem;
idaband_mem = (IDABandMem) lmem;
BandFreeMat(JJ);
BandFreePiv(pivots);
free(lmem);
return(0);
}
void IDABBDPrecFree(void **bbd_data)
{
IBBDPrecData pdata;
if (*bbd_data == NULL) return;
pdata = (IBBDPrecData) (*bbd_data);
BandFreeMat(pdata->PP);
BandFreePiv(pdata->pivots);
N_VDestroy(pdata->tempv4);
free(*bbd_data);
*bbd_data = NULL;
}
void KINBBDPrecFree(void **p_data)
{
KBBDPrecData pdata;
if (*p_data == NULL) return;
pdata = (KBBDPrecData) (*p_data);
N_VDestroy(pdata->vtemp3);
BandFreeMat(pdata->PP);
BandFreePiv(pdata->pivots);
free(*p_data);
*p_data = NULL;
}
void *CVBBDPrecAlloc(void *cvode_mem, long int Nlocal,
long int mudq, long int mldq,
long int mukeep, long int mlkeep,
realtype dqrely,
CVLocalFn gloc, CVCommFn cfn)
{
CVodeMem cv_mem;
CVBBDPrecData pdata;
long int muk, mlk, storage_mu;
if (cvode_mem == NULL) {
fprintf(stderr, MSGBBDP_CVMEM_NULL);
return(NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the BLOCK BAND preconditioner */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGBBDP_BAD_NVECTOR);
return(NULL);
}
/* Allocate data memory */
pdata = (CVBBDPrecData) malloc(sizeof *pdata);
if (pdata == NULL) return(NULL);
/* Set pointers to gloc and cfn; load half-bandwidths */
pdata->cvode_mem = cvode_mem;
pdata->gloc = gloc;
pdata->cfn = cfn;
pdata->mudq = MIN( Nlocal-1, MAX(0,mudq) );
pdata->mldq = MIN( Nlocal-1, MAX(0,mldq) );
muk = MIN( Nlocal-1, MAX(0,mukeep) );
mlk = MIN( Nlocal-1, MAX(0,mlkeep) );
pdata->mukeep = muk;
pdata->mlkeep = mlk;
/* Allocate memory for saved Jacobian */
pdata->savedJ = BandAllocMat(Nlocal, muk, mlk, muk);
if (pdata->savedJ == NULL) { free(pdata); return(NULL); }
/* Allocate memory for preconditioner matrix */
storage_mu = MIN(Nlocal-1, muk + mlk);
pdata->savedP = BandAllocMat(Nlocal, muk, mlk, storage_mu);
if (pdata->savedP == NULL) {
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
/* Allocate memory for pivots */
pdata->pivots = BandAllocPiv(Nlocal);
if (pdata->savedJ == NULL) {
BandFreeMat(pdata->savedP);
BandFreeMat(pdata->savedJ);
free(pdata);
return(NULL);
}
/* Set pdata->dqrely based on input dqrely (0 implies default). */
pdata->dqrely = (dqrely > ZERO) ? dqrely : RSqrt(uround);
/* Store Nlocal to be used in CVBBDPrecSetup */
pdata->n_local = Nlocal;
/* Set work space sizes and initialize nge */
pdata->rpwsize = Nlocal*(muk + 2*mlk + storage_mu + 2);
pdata->ipwsize = Nlocal;
pdata->nge = 0;
return((void *)pdata);
}
int CVBand(void *cvode_mem, long int N,
long int mupper, long int mlower)
{
CVodeMem cv_mem;
CVBandMem cvband_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
CVProcessError(NULL, CVBAND_MEM_NULL, "CVBAND", "CVBand", MSGB_CVMEM_NULL);
return(CVBAND_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if (vec_tmpl->ops->nvgetarraypointer == NULL) {
CVProcessError(cv_mem, CVBAND_ILL_INPUT, "CVBAND", "CVBand", MSGB_BAD_NVECTOR);
return(CVBAND_ILL_INPUT);
}
if (lfree != NULL) lfree(cv_mem);
/* Set four main function fields in cv_mem */
linit = CVBandInit;
lsetup = CVBandSetup;
lsolve = CVBandSolve;
lfree = CVBandFree;
/* Get memory for CVBandMemRec */
cvband_mem = NULL;
cvband_mem = (CVBandMem) malloc(sizeof(CVBandMemRec));
if (cvband_mem == NULL) {
CVProcessError(cv_mem, CVBAND_MEM_FAIL, "CVBAND", "CVBand", MSGB_MEM_FAIL);
return(CVBAND_MEM_FAIL);
}
/* Set default Jacobian routine and Jacobian data */
jac = CVBandDQJac;
J_data = cvode_mem;
last_flag = CVBAND_SUCCESS;
setupNonNull = TRUE;
/* Load problem dimension */
n = N;
/* Load half-bandwiths in cvband_mem */
ml = mlower;
mu = mupper;
/* Test ml and mu for legality */
if ((ml < 0) || (mu < 0) || (ml >= N) || (mu >= N)) {
CVProcessError(cv_mem, CVBAND_ILL_INPUT, "CVBAND", "CVBand", MSGB_BAD_SIZES);
return(CVBAND_ILL_INPUT);
}
/* Set extended upper half-bandwith for M (required for pivoting) */
storage_mu = MIN(N-1, mu + ml);
/* Allocate memory for M, savedJ, and pivot arrays */
M = NULL;
M = BandAllocMat(N, mu, ml, storage_mu);
if (M == NULL) {
CVProcessError(cv_mem, CVBAND_MEM_FAIL, "CVBAND", "CVBand", MSGB_MEM_FAIL);
free(cvband_mem); cvband_mem = NULL;
return(CVBAND_MEM_FAIL);
}
savedJ = NULL;
savedJ = BandAllocMat(N, mu, ml, mu);
if (savedJ == NULL) {
CVProcessError(cv_mem, CVBAND_MEM_FAIL, "CVBAND", "CVBand", MSGB_MEM_FAIL);
BandFreeMat(M);
free(cvband_mem); cvband_mem = NULL;
return(CVBAND_MEM_FAIL);
}
pivots = NULL;
pivots = BandAllocPiv(N);
if (pivots == NULL) {
CVProcessError(cv_mem, CVBAND_MEM_FAIL, "CVBAND", "CVBand", MSGB_MEM_FAIL);
BandFreeMat(M);
BandFreeMat(savedJ);
free(cvband_mem); cvband_mem = NULL;
return(CVBAND_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
lmem = cvband_mem;
return(CVBAND_SUCCESS);
}
void *IDABBDPrecAlloc(void *ida_mem, long int Nlocal,
long int mudq, long int mldq,
long int mukeep, long int mlkeep,
realtype dq_rel_yy,
IDABBDLocalFn Gres, IDABBDCommFn Gcomm)
{
IDAMem IDA_mem;
IBBDPrecData pdata;
N_Vector tempv4;
long int muk, mlk, storage_mu;
if (ida_mem == NULL) {
IDAProcessError(NULL, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_IDAMEM_NULL);
return(NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Test if the NVECTOR package is compatible with BLOCK BAND preconditioner */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
IDAProcessError(IDA_mem, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_BAD_NVECTOR);
return(NULL);
}
/* Allocate data memory. */
pdata = NULL;
pdata = (IBBDPrecData) malloc(sizeof *pdata);
if (pdata == NULL) {
IDAProcessError(IDA_mem, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_MEM_FAIL);
return(NULL);
}
/* Set pointers to glocal and gcomm; load half-bandwidths. */
pdata->ida_mem = IDA_mem;
pdata->glocal = Gres;
pdata->gcomm = Gcomm;
pdata->mudq = MIN(Nlocal-1, MAX(0, mudq));
pdata->mldq = MIN(Nlocal-1, MAX(0, mldq));
muk = MIN(Nlocal-1, MAX(0, mukeep));
mlk = MIN(Nlocal-1, MAX(0, mlkeep));
pdata->mukeep = muk;
pdata->mlkeep = mlk;
/* Set extended upper half-bandwidth for PP (required for pivoting). */
storage_mu = MIN(Nlocal-1, muk+mlk);
/* Allocate memory for preconditioner matrix. */
pdata->PP = NULL;
pdata->PP = BandAllocMat(Nlocal, muk, mlk, storage_mu);
if (pdata->PP == NULL) {
free(pdata); pdata = NULL;
IDAProcessError(IDA_mem, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_MEM_FAIL);
return(NULL);
}
/* Allocate memory for pivots. */
pdata->pivots = NULL;
pdata->pivots = BandAllocPiv(Nlocal);
if (pdata->PP == NULL) {
BandFreeMat(pdata->PP);
free(pdata); pdata = NULL;
IDAProcessError(IDA_mem, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_MEM_FAIL);
return(NULL);
}
/* Allocate tempv4 for use by IBBDDQJac */
tempv4 = NULL;
tempv4 = N_VClone(vec_tmpl);
if (tempv4 == NULL){
BandFreeMat(pdata->PP);
BandFreePiv(pdata->pivots);
free(pdata); pdata = NULL;
IDAProcessError(IDA_mem, 0, "IDABBDPRE", "IDABBDPrecAlloc", MSGBBD_MEM_FAIL);
return(NULL);
}
pdata->tempv4 = tempv4;
/* Set rel_yy based on input value dq_rel_yy (0 implies default). */
pdata->rel_yy = (dq_rel_yy > ZERO) ? dq_rel_yy : RSqrt(uround);
/* Store Nlocal to be used in IDABBDPrecSetup */
pdata->n_local = Nlocal;
/* Set work space sizes and initialize nge. */
pdata->rpwsize = Nlocal*(mlk + storage_mu + 1);
pdata->ipwsize = Nlocal;
pdata->nge = 0;
return((void *)pdata);
}
void *KINBBDPrecAlloc(void *kinmem, long int Nlocal,
long int mudq, long int mldq,
long int mukeep, long int mlkeep,
realtype dq_rel_uu,
KINLocalFn gloc, KINCommFn gcomm)
{
KBBDPrecData pdata;
KINMem kin_mem;
N_Vector vtemp3;
long int muk, mlk, storage_mu;
pdata = NULL;
if (kinmem == NULL) {
KINProcessError(NULL, 0, "KINBBDPRE", "KINBBDPrecAlloc", MSGBBD_KINMEM_NULL);
return(NULL);
}
kin_mem = (KINMem) kinmem;
/* test if the NVECTOR package is compatible with BLOCK BAND preconditioner */
/* Note: do NOT need to check for N_VScale since it is required by KINSOL and
so has already been checked for (see KINMalloc) */
if (vec_tmpl->ops->nvgetarraypointer == NULL) {
KINProcessError(kin_mem, 0, "KINBBDPRE", "KINBBDPrecAlloc", MSGBBD_BAD_NVECTOR);
return(NULL);
}
pdata = NULL;
pdata = (KBBDPrecData) malloc(sizeof *pdata); /* allocate data memory */
if (pdata == NULL) {
KINProcessError(kin_mem, 0, "KINBBDPRE", "KINBBDPrecAlloc", MSGBBD_MEM_FAIL);
return(NULL);
}
/* set pointers to gloc and gcomm and load half-bandwiths */
pdata->kin_mem = kinmem;
pdata->gloc = gloc;
pdata->gcomm = gcomm;
pdata->mudq = MIN(Nlocal-1, MAX(0, mudq));
pdata->mldq = MIN(Nlocal-1, MAX(0, mldq));
muk = MIN(Nlocal-1, MAX(0,mukeep));
mlk = MIN(Nlocal-1, MAX(0,mlkeep));
pdata->mukeep = muk;
pdata->mlkeep = mlk;
/* allocate memory for preconditioner matrix */
storage_mu = MIN(Nlocal-1, muk+mlk);
pdata->PP = NULL;
pdata->PP = BandAllocMat(Nlocal, muk, mlk, storage_mu);
if (pdata->PP == NULL) {
free(pdata); pdata = NULL;
return(NULL);
}
/* allocate memory for pivots */
pdata->pivots = NULL;
pdata->pivots = BandAllocPiv(Nlocal);
if (pdata->pivots == NULL) {
BandFreeMat(pdata->PP);
free(pdata); pdata = NULL;
return(NULL);
}
/* allocate vtemp3 for use by KBBDDQJac routine */
vtemp3 = NULL;
vtemp3 = N_VClone(kin_mem->kin_vtemp1);
if (vtemp3 == NULL) {
BandFreePiv(pdata->pivots);
BandFreeMat(pdata->PP);
free(pdata); pdata = NULL;
return(NULL);
}
pdata->vtemp3 = vtemp3;
/* set rel_uu based on input value dq_rel_uu */
if (dq_rel_uu > ZERO) pdata->rel_uu = dq_rel_uu;
else pdata->rel_uu = RSqrt(uround); /* using dq_rel_uu = 0.0 means use default */
/* store Nlocal to be used by the preconditioner routines */
pdata->n_local = Nlocal;
/* set work space sizes and initialize nge */
pdata->rpwsize = Nlocal * (storage_mu*mlk + 1) + 1;
pdata->ipwsize = Nlocal + 1;
pdata->nge = 0;
return((void *) pdata);
}
int IDABand(void *ida_mem, long int Neq,
long int mupper, long int mlower)
{
IDAMem IDA_mem;
IDABandMem idaband_mem;
int flag;
/* Return immediately if ida_mem is NULL. */
if (ida_mem == NULL) {
fprintf(stderr, MSGB_MEM_FAIL);
return(IDABAND_MEM_NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGB_BAD_NVECTOR);
return(IDABAND_ILL_INPUT);
}
if (lfree != NULL) flag = lfree((IDAMem) ida_mem);
/* Set five main function fields in ida_mem. */
linit = IDABandInit;
lsetup = IDABandSetup;
lsolve = IDABandSolve;
lperf = NULL;
lfree = IDABandFree;
/* Get memory for IDABandMemRec. */
idaband_mem = (IDABandMem) malloc(sizeof(IDABandMemRec));
if (idaband_mem == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGB_MEM_FAIL);
return(IDABAND_MEM_FAIL);
}
/* Set default Jacobian routine and Jacobian data */
jac = IDABandDQJac;
jacdata = IDA_mem;
last_flag = IDABAND_SUCCESS;
setupNonNull = TRUE;
/* Store problem size */
neq = Neq;
/* Test mlower and mupper for legality and load in memory. */
if ((mlower < 0) || (mupper < 0) || (mlower >= Neq) || (mupper >= Neq)) {
if(errfp!=NULL) fprintf(errfp, MSGB_BAD_SIZES);
return(IDABAND_ILL_INPUT);
}
idaband_mem->b_mlower = mlower;
idaband_mem->b_mupper = mupper;
/* Set extended upper half-bandwidth for JJ (required for pivoting). */
storage_mu = MIN(Neq-1, mupper + mlower);
/* Allocate memory for JJ and pivot array. */
JJ = BandAllocMat(Neq, mupper, mlower, storage_mu);
if (JJ == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGB_MEM_FAIL);
return(IDABAND_MEM_FAIL);
}
pivots = BandAllocPiv(Neq);
if (pivots == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGB_MEM_FAIL);
BandFreeMat(JJ);
return(IDABAND_MEM_FAIL);
}
/* Attach linear solver memory to the integrator memory */
lmem = idaband_mem;
return(IDABAND_SUCCESS);
}
