int KINDense(void *kinmem, long int N)
{
KINMem kin_mem;
KINDlsMem kindls_mem;
/* Return immediately if kinmem is NULL */
if (kinmem == NULL) {
KINProcessError(NULL, KINDLS_MEM_NULL, "KINDENSE", "KINDense", MSGD_KINMEM_NULL);
return(KINDLS_MEM_NULL);
}
kin_mem = (KINMem) kinmem;
/* Test if the NVECTOR package is compatible with the DENSE solver */
if (vec_tmpl->ops->nvgetarraypointer == NULL ||
vec_tmpl->ops->nvsetarraypointer == NULL) {
KINProcessError(kin_mem, KINDLS_ILL_INPUT, "KINDENSE", "KINDense", MSGD_BAD_NVECTOR);
return(KINDLS_ILL_INPUT);
}
if (lfree !=NULL) lfree(kin_mem);
/* Set four main function fields in kin_mem */
linit = kinDenseInit;
lsetup = kinDenseSetup;
lsolve = kinDenseSolve;
lfree = kinDenseFree;
/* Get memory for KINDlsMemRec */
kindls_mem = NULL;
kindls_mem = (KINDlsMem) malloc(sizeof(struct KINDlsMemRec));
if (kindls_mem == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINDENSE", "KINDense", MSGD_MEM_FAIL);
return(KINDLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_DENSE;
/* Set default Jacobian routine and Jacobian data */
jacDQ = TRUE;
djac = NULL;
J_data = NULL;
last_flag = KINDLS_SUCCESS;
setupNonNull = TRUE;
/* Set problem dimension */
n = N;
/* Allocate memory for J and pivot array */
J = NULL;
J = NewDenseMat(N, N);
if (J == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINDENSE", "KINDense", MSGD_MEM_FAIL);
free(kindls_mem); kindls_mem = NULL;
return(KINDLS_MEM_FAIL);
}
lpivots = NULL;
lpivots = NewLintArray(N);
if (lpivots == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINDENSE", "KINDense", MSGD_MEM_FAIL);
DestroyMat(J);
free(kindls_mem); kindls_mem = NULL;
return(KINDLS_MEM_FAIL);
}
/* This is a direct linear solver */
inexact_ls = FALSE;
/* Attach linear solver memory to integrator memory */
lmem = kindls_mem;
return(KINDLS_SUCCESS);
}
int IDABand(void *ida_mem, long int Neq, long int mupper, long int mlower)
{
IDAMem IDA_mem;
IDADlsMem idadls_mem;
int flag;
/* Return immediately if ida_mem is NULL. */
if (ida_mem == NULL) {
IDAProcessError(NULL, IDADLS_MEM_NULL, "IDABAND", "IDABand", MSGD_IDAMEM_NULL);
return(IDADLS_MEM_NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
IDAProcessError(IDA_mem, IDADLS_ILL_INPUT, "IDABAND", "IDABand", MSGD_BAD_NVECTOR);
return(IDADLS_ILL_INPUT);
}
/* Test mlower and mupper for legality. */
if ((mlower < 0) || (mupper < 0) || (mlower >= Neq) || (mupper >= Neq)) {
IDAProcessError(IDA_mem, IDADLS_ILL_INPUT, "IDABAND", "IDABand", MSGD_BAD_SIZES);
return(IDADLS_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 IDADlsMemRec. */
idadls_mem = NULL;
idadls_mem = (IDADlsMem) malloc(sizeof(struct IDADlsMemRec));
if (idadls_mem == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDABAND", "IDABand", MSGD_MEM_FAIL);
return(IDADLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_BAND;
/* Set default Jacobian routine and Jacobian data */
jacDQ = TRUE;
bjac = NULL;
jacdata = NULL;
last_flag = IDADLS_SUCCESS;
setupNonNull = TRUE;
/* Store problem size */
neq = Neq;
idadls_mem->d_ml = mlower;
idadls_mem->d_mu = mupper;
/* Set extended upper half-bandwidth for JJ (required for pivoting). */
smu = SUNMIN(Neq-1, mupper + mlower);
/* Allocate memory for JJ and pivot array. */
JJ = NULL;
JJ = NewBandMat(Neq, mupper, mlower, smu);
if (JJ == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDABAND", "IDABand", MSGD_MEM_FAIL);
free(idadls_mem); idadls_mem = NULL;
return(IDADLS_MEM_FAIL);
}
lpivots = NULL;
lpivots = NewLintArray(Neq);
if (lpivots == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDABAND", "IDABand", MSGD_MEM_FAIL);
DestroyMat(JJ);
free(idadls_mem); idadls_mem = NULL;
return(IDADLS_MEM_FAIL);
}
/* Attach linear solver memory to the integrator memory */
lmem = idadls_mem;
return(IDADLS_SUCCESS);
}
int CVBBDPrecInit(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;
CVSpilsMem cvspils_mem;
CVBBDPrecData pdata;
long int muk, mlk, storage_mu;
int flag;
if (cvode_mem == NULL) {
cvProcessError(NULL, CVSPILS_MEM_NULL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_MEM_NULL);
return(CVSPILS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if one of the SPILS linear solvers has been attached */
if (cv_mem->cv_lmem == NULL) {
cvProcessError(cv_mem, CVSPILS_LMEM_NULL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_LMEM_NULL);
return(CVSPILS_LMEM_NULL);
}
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
/* Test if the NVECTOR package is compatible with the BLOCK BAND preconditioner */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
cvProcessError(cv_mem, CVSPILS_ILL_INPUT, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_BAD_NVECTOR);
return(CVSPILS_ILL_INPUT);
}
/* Allocate data memory */
pdata = NULL;
pdata = (CVBBDPrecData) malloc(sizeof *pdata);
if (pdata == NULL) {
cvProcessError(cv_mem, CVSPILS_MEM_FAIL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_MEM_FAIL);
return(CVSPILS_MEM_FAIL);
}
/* Set pointers to gloc and cfn; load half-bandwidths */
pdata->cvode_mem = cvode_mem;
pdata->gloc = gloc;
pdata->cfn = cfn;
pdata->mudq = SUNMIN(Nlocal-1, SUNMAX(0,mudq));
pdata->mldq = SUNMIN(Nlocal-1, SUNMAX(0,mldq));
muk = SUNMIN(Nlocal-1, SUNMAX(0,mukeep));
mlk = SUNMIN(Nlocal-1, SUNMAX(0,mlkeep));
pdata->mukeep = muk;
pdata->mlkeep = mlk;
/* Allocate memory for saved Jacobian */
pdata->savedJ = NewBandMat(Nlocal, muk, mlk, muk);
if (pdata->savedJ == NULL) {
free(pdata); pdata = NULL;
cvProcessError(cv_mem, CVSPILS_MEM_FAIL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_MEM_FAIL);
return(CVSPILS_MEM_FAIL);
}
/* Allocate memory for preconditioner matrix */
storage_mu = SUNMIN(Nlocal-1, muk + mlk);
pdata->savedP = NULL;
pdata->savedP = NewBandMat(Nlocal, muk, mlk, storage_mu);
if (pdata->savedP == NULL) {
DestroyMat(pdata->savedJ);
free(pdata); pdata = NULL;
cvProcessError(cv_mem, CVSPILS_MEM_FAIL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_MEM_FAIL);
return(CVSPILS_MEM_FAIL);
}
/* Allocate memory for lpivots */
pdata->lpivots = NULL;
pdata->lpivots = NewLintArray(Nlocal);
if (pdata->lpivots == NULL) {
DestroyMat(pdata->savedP);
DestroyMat(pdata->savedJ);
free(pdata); pdata = NULL;
cvProcessError(cv_mem, CVSPILS_MEM_FAIL, "CVBBDPRE", "CVBBDPrecInit", MSGBBD_MEM_FAIL);
return(CVSPILS_MEM_FAIL);
}
/* Set pdata->dqrely based on input dqrely (0 implies default). */
pdata->dqrely = (dqrely > ZERO) ? dqrely : SUNRsqrt(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;
/* Overwrite the P_data field in the SPILS memory */
cvspils_mem->s_P_data = pdata;
/* Attach the pfree function */
cvspils_mem->s_pfree = CVBBDPrecFree;
/* Attach preconditioner solve and setup functions */
flag = CVSpilsSetPreconditioner(cvode_mem, CVBBDPrecSetup, CVBBDPrecSolve);
return(flag);
}
int KINBand(void *kinmem, long int N, long int mupper, long int mlower)
{
KINMem kin_mem;
KINDlsMem kindls_mem;
/* Return immediately if kinmem is NULL */
if (kinmem == NULL) {
KINProcessError(NULL, KINDLS_MEM_NULL, "KINBAND", "KINBand", MSGD_KINMEM_NULL);
return(KINDLS_MEM_NULL);
}
kin_mem = (KINMem) kinmem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if (vec_tmpl->ops->nvgetarraypointer == NULL) {
KINProcessError(kin_mem, KINDLS_ILL_INPUT, "KINBAND", "KINBand", MSGD_BAD_NVECTOR);
return(KINDLS_ILL_INPUT);
}
if (lfree != NULL) lfree(kin_mem);
/* Set four main function fields in kin_mem */
linit = kinBandInit;
lsetup = kinBandSetup;
lsolve = kinBandsolve;
lfree = kinBandFree;
/* Get memory for KINDlsMemRec */
kindls_mem = NULL;
kindls_mem = (KINDlsMem) malloc(sizeof(struct KINDlsMemRec));
if (kindls_mem == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINBAND", "KINBand", MSGD_MEM_FAIL);
return(KINDLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_BAND;
/* Set default Jacobian routine and Jacobian data */
jacDQ = TRUE;
bjac = NULL;
J_data = NULL;
last_flag = KINDLS_SUCCESS;
setupNonNull = TRUE;
/* Load problem dimension */
n = N;
/* Load half-bandwiths in kindls_mem */
ml = mlower;
mu = mupper;
/* Test ml and mu for legality */
if ((ml < 0) || (mu < 0) || (ml >= N) || (mu >= N)) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINBAND", "KINBand", MSGD_MEM_FAIL);
free(kindls_mem); kindls_mem = NULL;
return(KINDLS_ILL_INPUT);
}
/* Set extended upper half-bandwith for M (required for pivoting) */
smu = MIN(N-1, mu + ml);
/* Allocate memory for J and pivot array */
J = NULL;
J = NewBandMat(N, mu, ml, smu);
if (J == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINBAND", "KINBand", MSGD_MEM_FAIL);
free(kindls_mem); kindls_mem = NULL;
return(KINDLS_MEM_FAIL);
}
lpivots = NULL;
lpivots = NewLintArray(N);
if (lpivots == NULL) {
KINProcessError(kin_mem, KINDLS_MEM_FAIL, "KINBAND", "KINBand", MSGD_MEM_FAIL);
DestroyMat(J);
free(kindls_mem); kindls_mem = NULL;
return(KINDLS_MEM_FAIL);
}
/* This is a direct linear solver */
inexact_ls = FALSE;
/* Attach linear solver memory to integrator memory */
lmem = kindls_mem;
return(KINDLS_SUCCESS);
}
int IDADense(void *ida_mem, long int Neq)
{
IDAMem IDA_mem;
IDADlsMem idadls_mem;
int flag;
/* Return immediately if ida_mem is NULL. */
if (ida_mem == NULL) {
IDAProcessError(NULL, IDADLS_MEM_NULL, "IDASDENSE", "IDADense", MSGD_IDAMEM_NULL);
return(IDADLS_MEM_NULL);
}
IDA_mem = (IDAMem) ida_mem;
/* Test if the NVECTOR package is compatible with the DENSE solver */
if(vec_tmpl->ops->nvgetarraypointer == NULL ||
vec_tmpl->ops->nvsetarraypointer == NULL) {
IDAProcessError(IDA_mem, IDADLS_ILL_INPUT, "IDASDENSE", "IDADense", MSGD_BAD_NVECTOR);
return(IDADLS_ILL_INPUT);
}
if (lfree != NULL) flag = lfree(IDA_mem);
/* Set five main function fields in IDA_mem. */
linit = IDADenseInit;
lsetup = IDADenseSetup;
lsolve = IDADenseSolve;
lperf = NULL;
lfree = IDADenseFree;
/* Get memory for IDADlsMemRec. */
idadls_mem = NULL;
idadls_mem = (IDADlsMem) malloc(sizeof(struct IDADlsMemRec));
if (idadls_mem == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDASDENSE", "IDADense", MSGD_MEM_FAIL);
return(IDADLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_DENSE;
/* Set default Jacobian routine and Jacobian data */
jacDQ = TRUE;
djac = NULL;
jacdata = NULL;
last_flag = IDADLS_SUCCESS;
setupNonNull = TRUE;
/* Store problem size */
neq = Neq;
/* Allocate memory for JJ and pivot array. */
JJ = NULL;
JJ = NewDenseMat(Neq, Neq);
if (JJ == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDASDENSE", "IDADense", MSGD_MEM_FAIL);
free(idadls_mem); idadls_mem = NULL;
return(IDADLS_MEM_FAIL);
}
lpivots = NULL;
lpivots = NewLintArray(Neq);
if (lpivots == NULL) {
IDAProcessError(IDA_mem, IDADLS_MEM_FAIL, "IDASDENSE", "IDADense", MSGD_MEM_FAIL);
DestroyMat(JJ);
free(idadls_mem); idadls_mem = NULL;
return(IDADLS_MEM_FAIL);
}
/* Attach linear solver memory to the integrator memory */
lmem = idadls_mem;
return(IDADLS_SUCCESS);
}
int CVDense(void *cvode_mem, long int N)
{
CVodeMem cv_mem;
CVDlsMem cvdls_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
cvProcessError(NULL, CVDLS_MEM_NULL, "CVSDENSE", "CVDense", MSGD_CVMEM_NULL);
return(CVDLS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the DENSE solver */
if (vec_tmpl->ops->nvgetarraypointer == NULL ||
vec_tmpl->ops->nvsetarraypointer == NULL) {
cvProcessError(cv_mem, CVDLS_ILL_INPUT, "CVSDENSE", "CVDense", MSGD_BAD_NVECTOR);
return(CVDLS_ILL_INPUT);
}
if (lfree !=NULL) lfree(cv_mem);
/* Set four main function fields in cv_mem */
linit = cvDenseInit;
lsetup = cvDenseSetup;
lsolve = cvDenseSolve;
lfree = cvDenseFree;
/* Get memory for CVDlsMemRec */
cvdls_mem = NULL;
cvdls_mem = (CVDlsMem) malloc(sizeof(struct CVDlsMemRec));
if (cvdls_mem == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSDENSE", "CVDense", MSGD_MEM_FAIL);
return(CVDLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_DENSE;
/* Initialize Jacobian-related data */
jacDQ = TRUE;
jac = NULL;
J_data = NULL;
last_flag = CVDLS_SUCCESS;
setupNonNull = TRUE;
/* Set problem dimension */
n = N;
/* Allocate GPU memory to d_A and d_B */
if ( cv_mem->GPU ) {
int ldda = ((N+31)/32)*32;
int lddb = N;
MAGMA_DEVALLOC( d_A, double, ldda*N );
MAGMA_DEVALLOC( d_B, double, lddb*N );
}
/* Allocate memory for M, savedJ, and pivot array */
M = NULL;
M = NewDenseMat(N, N);
if (M == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSDENSE", "CVDense", MSGD_MEM_FAIL);
free(cvdls_mem); cvdls_mem = NULL;
return(CVDLS_MEM_FAIL);
}
savedJ = NULL;
savedJ = NewDenseMat(N, N);
if (savedJ == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSDENSE", "CVDense", MSGD_MEM_FAIL);
DestroyMat(M);
free(cvdls_mem); cvdls_mem = NULL;
return(CVDLS_MEM_FAIL);
}
lpivots = NULL;
lpivots = NewLintArray(N);
if (lpivots == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSDENSE", "CVDense", MSGD_MEM_FAIL);
DestroyMat(M);
DestroyMat(savedJ);
free(cvdls_mem); cvdls_mem = NULL;
return(CVDLS_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
lmem = cvdls_mem;
return(CVDLS_SUCCESS);
}
