int CVDense(void *cvode_mem, long int N)
{
CVodeMem cv_mem;
CVDenseMem cvdense_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
fprintf(stderr, MSGDS_CVMEM_NULL);
return(CVDENSE_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) {
if(errfp!=NULL) fprintf(errfp, MSGDS_BAD_NVECTOR);
return(CVDENSE_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 CVDenseMemRec */
cvdense_mem = (CVDenseMem) malloc(sizeof(CVDenseMemRec));
if (cvdense_mem == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGDS_MEM_FAIL);
return(CVDENSE_MEM_FAIL);
}
/* Set default Jacobian routine and Jacobian data */
jac = CVDenseDQJac;
J_data = cvode_mem;
last_flag = CVDENSE_SUCCESS;
setupNonNull = TRUE;
/* Set problem dimension */
n = N;
/* Allocate memory for M, savedJ, and pivot array */
M = DenseAllocMat(N);
if (M == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGDS_MEM_FAIL);
return(CVDENSE_MEM_FAIL);
}
savedJ = DenseAllocMat(N);
if (savedJ == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGDS_MEM_FAIL);
DenseFreeMat(M);
return(CVDENSE_MEM_FAIL);
}
pivots = DenseAllocPiv(N);
if (pivots == NULL) {
if(errfp!=NULL) fprintf(errfp, MSGDS_MEM_FAIL);
DenseFreeMat(M);
DenseFreeMat(savedJ);
return(CVDENSE_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
lmem = cvdense_mem;
return(CVDENSE_SUCCESS);
}
int KINDense(void *kinmem, long int N)
{
KINMem kin_mem;
KINDenseMem kindense_mem;
/* Return immediately if kinmem is NULL */
if (kinmem == NULL) {
KINProcessError(NULL, KINDENSE_MEM_NULL, "KINDENSE", "KINDense", MSGDS_KINMEM_NULL);
return(KINDENSE_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, KINDENSE_ILL_INPUT, "KINDENSE", "KINDense", MSGDS_BAD_NVECTOR);
return(KINDENSE_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 KINDenseMemRec */
kindense_mem = NULL;
kindense_mem = (KINDenseMem) malloc(sizeof(KINDenseMemRec));
if (kindense_mem == NULL) {
KINProcessError(kin_mem, KINDENSE_MEM_FAIL, "KINDENSE", "KINDense", MSGDS_MEM_FAIL);
return(KINDENSE_MEM_FAIL);
}
/* Set default Jacobian routine and Jacobian data */
jac = KINDenseDQJac;
J_data = kin_mem;
last_flag = KINDENSE_SUCCESS;
setupNonNull = TRUE;
/* Set problem dimension */
n = N;
/* Allocate memory for J and pivot array */
J = NULL;
J = DenseAllocMat(N, N);
if (J == NULL) {
KINProcessError(kin_mem, KINDENSE_MEM_FAIL, "KINDENSE", "KINDense", MSGDS_MEM_FAIL);
free(kindense_mem); kindense_mem = NULL;
return(KINDENSE_MEM_FAIL);
}
pivots = NULL;
pivots = DenseAllocPiv(N);
if (pivots == NULL) {
KINProcessError(kin_mem, KINDENSE_MEM_FAIL, "KINDENSE", "KINDense", MSGDS_MEM_FAIL);
DenseFreeMat(J);
free(kindense_mem); kindense_mem = NULL;
return(KINDENSE_MEM_FAIL);
}
/* This is a direct linear solver */
inexact_ls = FALSE;
/* Attach linear solver memory to integrator memory */
lmem = kindense_mem;
return(KINDENSE_SUCCESS);
}
int CVDense(void *cvode_mem, CVDenseJacFn djac, void *jac_data)
{
CVodeMem cv_mem;
CVDenseMem cvdense_mem;
/* Return immediately if cvode_mem is NULL */
cv_mem = (CVodeMem) cvode_mem;
if (cv_mem == NULL) { /* CVode reports this error */
jsfprintf(errfp, MSG_CVMEM_NULL);
return(LMEM_FAIL);
}
/* Test if the NVECTOR package is compatible with the DENSE solver */
if ((strcmp(machenv->tag,"serial")) ||
machenv->ops->nvmake == NULL ||
machenv->ops->nvdispose == NULL ||
machenv->ops->nvgetdata == NULL ||
machenv->ops->nvsetdata == NULL) {
jsfprintf(errfp, MSG_WRONG_NVEC);
return(LMEM_FAIL);
}
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 CVDenseMemRec */
lmem = cvdense_mem = (CVDenseMem) malloc(sizeof(CVDenseMemRec));
if (cvdense_mem == NULL) {
jsfprintf(errfp, MSG_MEM_FAIL);
return(LMEM_FAIL);
}
/* Set Jacobian routine field, J_data, and setupNonNull */
if (djac == NULL) {
jac = CVDenseDQJac;
} else {
jac = djac;
}
J_data = jac_data;
setupNonNull = TRUE;
/* Allocate memory for M, savedJ, and pivot array */
M = DenseAllocMat(N);
if (M == NULL) {
jsfprintf(errfp, MSG_MEM_FAIL);
return(LMEM_FAIL);
}
savedJ = DenseAllocMat(N);
if (savedJ == NULL) {
jsfprintf(errfp, MSG_MEM_FAIL);
DenseFreeMat(M);
return(LMEM_FAIL);
}
pivots = DenseAllocPiv(N);
if (pivots == NULL) {
jsfprintf(errfp, MSG_MEM_FAIL);
DenseFreeMat(M);
DenseFreeMat(savedJ);
return(LMEM_FAIL);
}
return(SUCCESS);
}
