static void cpDenseProjFree(CPodeMem cp_mem)
{
CPDlsProjMem cpdlsP_mem;
cpdlsP_mem = (CPDlsProjMem) lmemP;
DestroyMat(G);
DestroyMat(savedG);
switch (ftype) {
case CPDIRECT_LU:
DestroyArray(pivotsP);
DestroyMat(K);
break;
case CPDIRECT_QR:
DestroyArray(beta);
if (pnorm == CP_PROJ_ERRNORM) DestroyMat(K);
break;
case CPDIRECT_SC:
DestroyMat(K);
break;
}
free(cpdlsP_mem);
cpdlsP_mem = NULL;
}
void CMatlabDlg3::Reset()
{
if (m_PlaneTrueInput)
{
DestroyArray(m_PlaneTrueInput);
m_PlaneTrueInput = NULL;
}
if (m_TargetTrueInput)
{
DestroyArray(m_TargetTrueInput);
m_TargetTrueInput = NULL;
}
if (m_TargetFusionInput)
{
DestroyArray(m_TargetFusionInput);
m_TargetFusionInput = NULL;
}
if (m_TargetFilterInput)
{
DestroyArray(m_TargetFilterInput);
m_TargetFilterInput = NULL;
}
if (m_GlobalVarInput)
{
DestroyArray(m_GlobalVarInput);
m_GlobalVarInput = NULL;
}
m_PlaneTrueDatas.clear();
m_TargetTrueDatas.clear();
m_TargetFusionDatas.clear();
m_TargetFilterDatas.clear();
m_IsShowing = false;
}
void BiVector<T>::Free() {
if(vector && items >= 0) {
int end = start + items;
if(end <= alloc)
DestroyArray(vector + start, vector + end);
else {
DestroyArray(vector + start, vector + alloc);
DestroyArray(vector, vector + end - alloc);
}
delete[] (byte *)vector;
}
}
void Segtor<T, NBLK>::Free() {
int q = items / NBLK;
int r = items % NBLK;
int i;
for(i = 0; i < q; i++) {
T *a = (T *) block[i].item;
DestroyArray(a, a + NBLK);
}
if(r) {
T *a = (T *) block[i].item;
DestroyArray(a, a + r);
}
}
void IterationProcessNode(TreePtr tree,TreeNodePtr node,NodeCallBack fnNode)
{
unsigned long i;
TreeNodePtr left = NULL;
TreeNodePtr right = NULL;
ArrayPtr nodeList = CreateArray(tree->size,sizeof(void*));
InsertArray(nodeList,&node);
for (i=0; i<nodeList->size; i++)
{
node = *(TreeNodePtr*)GetDataArray(nodeList,i);
left = node->left;
right = node->right;
if (NULL != fnNode)
{
fnNode(tree,node);
}
if (NULL != left)
{
InsertArray(nodeList,&left);
}
if (NULL != right)
{
InsertArray(nodeList,&right);
}
}
DestroyArray(nodeList);
}
void Vector<T>::Remove(int q, int count) {
Chk();
ASSERT(q >= 0 && q <= items - count && count >= 0);
if(count == 0) return;
DestroyArray(vector + q, vector + q + count);
memmove(vector + q, vector + q + count, (items - q - count) * sizeof(T));
items -= count;
}
/* Deallocate an array and all of the elements in it. */
void DestroyArrayAndData(Array *array)
{
int i;
for (i=0; i<array->size; i++) {
free(GetInArray(array, i));
}
DestroyArray(array);
}
/*---------------------------------------------------------------
arkMassLapackDenseFree frees memory specific to the dense mass
matrix solver.
---------------------------------------------------------------*/
static void arkMassLapackDenseFree(ARKodeMem ark_mem)
{
ARKDlsMassMem arkdls_mem;
arkdls_mem = (ARKDlsMassMem) ark_mem->ark_mass_mem;
DestroyMat(arkdls_mem->d_M);
DestroyArray(arkdls_mem->d_pivots);
free(arkdls_mem);
arkdls_mem = NULL;
}
static void kinDenseFree(KINMem kin_mem)
{
KINDlsMem kindls_mem;
kindls_mem = (KINDlsMem) lmem;
DestroyMat(J);
DestroyArray(lpivots);
free(kindls_mem); kindls_mem = NULL;
}
static void kinLapackBandFree(KINMem kin_mem)
{
KINDlsMem kindls_mem;
kindls_mem = (KINDlsMem) lmem;
DestroyMat(J);
DestroyArray(pivots);
free(kindls_mem); kindls_mem = NULL;
}
static void cvDenseFree(CVodeMem cv_mem)
{
CVDlsMem cvdls_mem;
cvdls_mem = (CVDlsMem) lmem;
DestroyMat(M);
DestroyMat(savedJ);
DestroyArray(pivots);
free(cvdls_mem); cvdls_mem = NULL;
}
static int IDADenseFree(IDAMem IDA_mem)
{
IDADlsMem idadls_mem;
idadls_mem = (IDADlsMem) lmem;
DestroyMat(JJ);
DestroyArray(pivots);
free(lmem); lmem = NULL;
return(0);
}
static void cpDenseFree(CPodeMem cp_mem)
{
CPDlsMem cpdls_mem;
cpdls_mem = (CPDlsMem) lmem;
DestroyMat(M);
DestroyArray(pivots);
if (ode_type == CP_EXPL) DestroyMat(savedJ);
free(cpdls_mem);
cpdls_mem = NULL;
}
/*---------------------------------------------------------------
arkLapackBandFree frees memory specific to the band linear
solver.
---------------------------------------------------------------*/
static void arkLapackBandFree(ARKodeMem ark_mem)
{
ARKDlsMem arkdls_mem;
arkdls_mem = (ARKDlsMem) ark_mem->ark_lmem;
DestroyMat(arkdls_mem->d_M);
DestroyArray(arkdls_mem->d_pivots);
DestroyMat(arkdls_mem->d_savedJ);
free(arkdls_mem);
arkdls_mem = NULL;
}
/*
* idaLapackBandFree frees memory specific to the band linear solver.
*/
static int idaLapackBandFree(IDAMem IDA_mem)
{
IDADlsMem idadls_mem;
idadls_mem = (IDADlsMem) lmem;
DestroyMat(JJ);
DestroyArray(pivots);
free(idadls_mem);
idadls_mem = NULL;
return(0);
}
void CPBBDPrecFree(void **bbd_data)
{
CPBBDPrecData pdata;
if (*bbd_data == NULL) return;
pdata = (CPBBDPrecData) (*bbd_data);
DestroyMat(pdata->savedJ);
DestroyMat(pdata->savedP);
DestroyArray(pdata->pivots);
N_VDestroy(pdata->tmp4);
free(*bbd_data);
*bbd_data = NULL;
}
void Vector<T>::SetCountR(int n, const T& init) {
Chk();
ASSERT(n >= 0);
if(n == items) return;
if(n < items)
DestroyArray(vector + n, vector + items);
else
if(n > alloc) {
T *prev = vector;
ReAlloc(alloc + ntl_max(alloc, n - items));
DeepCopyConstructFill(vector + items, vector + n, init);
RawFree(prev);
}
else
DeepCopyConstructFill(vector + items, vector + n, init);
items = n;
}
int main()
{
Array A;
int i, j, k, *p, dim = 3, bound1 = 3, bound2 = 4, bound3 = 2;
ElemType e, *p1;
InitArray(A, dim, bound1, bound2, bound3);
p = A.bounds;
printf("A.bounds = ");
for ( i = 0; i < dim; i++ )
printf("%d ", *(p+i));
p = A.constants;
printf("\nA.constants = ");
for ( i = 0; i < dim; i++ )
printf("%d ", *(p+i));
printf("\n%d页%d行%d列矩阵元素如下：\n", bound1, bound2, bound3);
for ( i = 0; i < bound1; i++ )
{
for ( j = 0; j < bound2; j++ )
{
for ( k = 0; k < bound3; k++ )
{
Assign(A, i * 100 + j * 10 + k, i, j, k);
Value(e, A, i, j, k);
printf("A[%d][%d][%d] = %2d ", i, j, k, e);
}
printf("\n");
}
printf("\n");
}
p1 = A.base;
printf("A.base = \n");
for ( i = 0; i < bound1 * bound2 * bound3; i++ )
{
printf("%4d", *(p1 + i));
if ( i % (bound2 * bound3) == bound2 * bound3 - 1 )
printf("\n");
}
printf("A.dim = %d\n", A.dim);
DestroyArray(A);
printf("1. 最大值为%d\n", Max(4, 7, 9, 5, 8));
printf("2. 最大值为%d\n", Max(3, 17, 36, 25));
return 0;
}
static void cvDenseFree(CVodeMem cv_mem)
{
CVDlsMem cvdls_mem;
/*Free GPU resource*/
if ( cv_mem->GPU ) {
MAGMA_DEVFREE(d_A);
MAGMA_DEVFREE(d_B);
}
cvdls_mem = (CVDlsMem) lmem;
DestroyMat(M);
DestroyMat(savedJ);
DestroyArray(lpivots);
free(cvdls_mem);
cv_mem->cv_lmem = NULL;
}
static void KINBBDPrecFree(KINMem kin_mem)
{
KINSpilsMem kinspils_mem;
KBBDPrecData pdata;
if (kin_mem->kin_lmem == NULL) return;
kinspils_mem = (KINSpilsMem) kin_mem->kin_lmem;
if (kinspils_mem->s_P_data == NULL) return;
pdata = (KBBDPrecData) kinspils_mem->s_P_data;
N_VDestroy(vtemp3);
DestroyMat(PP);
DestroyArray(pivots);
free(pdata);
pdata = NULL;
}
static void CVBBDPrecFree(CVodeMem cv_mem)
{
CVSpilsMem cvspils_mem;
CVBBDPrecData pdata;
if (cv_mem->cv_lmem == NULL) return;
cvspils_mem = (CVSpilsMem) cv_mem->cv_lmem;
if (cvspils_mem->s_P_data == NULL) return;
pdata = (CVBBDPrecData) cvspils_mem->s_P_data;
DestroyMat(savedJ);
DestroyMat(savedP);
DestroyArray(pivots);
free(pdata);
pdata = NULL;
}
/*---------------------------------------------------------------
ARKBandPrecFree:
Frees data associated with the ARKBand preconditioner.
---------------------------------------------------------------*/
static int ARKBandPrecFree(ARKodeMem ark_mem)
{
ARKSpilsMem arkspils_mem;
ARKBandPrecData pdata;
if (ark_mem->ark_lmem == NULL) return(0);
arkspils_mem = (ARKSpilsMem) ark_mem->ark_lmem;
if (arkspils_mem->s_P_data == NULL) return(0);
pdata = (ARKBandPrecData) arkspils_mem->s_P_data;
DestroyMat(pdata->savedJ);
DestroyMat(pdata->savedP);
DestroyArray(pdata->lpivots);
free(pdata);
pdata = NULL;
return(0);
}
void main()
{
Array A;
int i,j,k,*p,dim=3,bound1=3,bound2=4,bound3=2; /* a[3][4][2]数组 */
ElemType e,*p1;
InitArray(&A,dim,bound1,bound2,bound3); /* 构造3＊4＊2的3维数组A */
p=A.bounds;
printf("A.bounds=");
for(i=0;i<dim;i++) /* 顺序输出A.bounds */
printf("%d ",*(p+i));
p=A.constants;
printf("\nA.constants=");
for(i=0;i<dim;i++) /* 顺序输出A.constants */
printf("%d ",*(p+i));
printf("\n%d页%d行%d列矩阵元素如下:\n",bound1,bound2,bound3);
for(i=0;i<bound1;i++)
{
for(j=0;j<bound2;j++)
{
for(k=0;k<bound3;k++)
{
Assign(&A,i*100+j*10+k,i,j,k); /* 将i*100+j*10+k赋值给A[i][j][k] */
// Value(&e,A,i,j,k); /* 将A[i][j][k]的值赋给e */
Value(A,&e,i,j,k); /* 将A[i][j][k]的值赋给e */
printf("A[%d][%d][%d]=%2d ",i,j,k,e); /* 输出A[i][j][k] */
}
printf("\n");
}
printf("\n");
}
p1=A.base;
printf("A.base=\n");
for(i=0;i<bound1*bound2*bound3;i++) /* 顺序输出A.base */
{
printf("%4d",*(p1+i));
if(i%(bound2*bound3)==bound2*bound3-1)
printf("\n");
}
DestroyArray(&A);
}
void Vector<T>::Free() {
if(vector && items >= 0)
DestroyArray((T *)vector, (T *)vector + items);
RawFree(vector);
}
/*---------------------------------------------------------------
ARKLapackBand:
This routine initializes the memory record and sets various
function fields specific to the band linear solver module. It
first calls the existing lfree routine if this is not NULL. It
then sets the ark_linit, ark_lsetup, ark_lsolve, and ark_lfree
fields in (*arkode_mem) to be arkLapackBandInit,
arkLapackBandSetup, arkLapackBandSolve, and arkLapackBandFree,
respectively. It allocates memory for a structure of type
ARKLapackBandMemRec and sets the ark_lmem field in (*arkode_mem)
to the address of this structure. It sets setupNonNull in
(*arkode_mem) to be TRUE, mu to be mupper, and ml to be mlower.
Finally, it allocates memory for M, pivots, and savedJ. The
ARKLapackBand return value is ARKDLS_SUCCESS=0,
ARKDLS_MEM_FAIL=-1, or ARKDLS_ILL_INPUT=-2.
NOTE: The ARKLAPACK linear solver assumes a serial implementation
of the NVECTOR package. Therefore, ARKLapackBand will first
test for compatible a compatible N_Vector internal
representation by checking that the function
N_VGetArrayPointer exists. Again, this test is insufficient
to guarantee the serial NVECTOR package, but it's a start.
---------------------------------------------------------------*/
int ARKLapackBand(void *arkode_mem, int N, int mupper, int mlower)
{
ARKodeMem ark_mem;
ARKDlsMem arkdls_mem;
/* Return immediately if arkode_mem is NULL */
if (arkode_mem == NULL) {
arkProcessError(NULL, ARKDLS_MEM_NULL, "ARKLAPACK",
"ARKLapackBand", MSGD_ARKMEM_NULL);
return(ARKDLS_MEM_NULL);
}
ark_mem = (ARKodeMem) arkode_mem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if (ark_mem->ark_tempv->ops->nvgetarraypointer == NULL) {
arkProcessError(ark_mem, ARKDLS_ILL_INPUT, "ARKLAPACK",
"ARKLapackBand", MSGD_BAD_NVECTOR);
return(ARKDLS_ILL_INPUT);
}
if (ark_mem->ark_lfree != NULL) ark_mem->ark_lfree(ark_mem);
/* Set four main function fields in ark_mem */
ark_mem->ark_linit = arkLapackBandInit;
ark_mem->ark_lsetup = arkLapackBandSetup;
ark_mem->ark_lsolve = arkLapackBandSolve;
ark_mem->ark_lfree = arkLapackBandFree;
ark_mem->ark_lsolve_type = 2;
/* Get memory for ARKDlsMemRec */
arkdls_mem = NULL;
arkdls_mem = (ARKDlsMem) malloc(sizeof(struct ARKDlsMemRec));
if (arkdls_mem == NULL) {
arkProcessError(ark_mem, ARKDLS_MEM_FAIL, "ARKLAPACK",
"ARKLapackBand", MSGD_MEM_FAIL);
return(ARKDLS_MEM_FAIL);
}
/* Set matrix type */
arkdls_mem->d_type = SUNDIALS_BAND;
/* Initialize Jacobian-related data */
arkdls_mem->d_jacDQ = TRUE;
arkdls_mem->d_bjac = NULL;
arkdls_mem->d_J_data = NULL;
arkdls_mem->d_last_flag = ARKDLS_SUCCESS;
ark_mem->ark_setupNonNull = TRUE;
/* Load problem dimension */
arkdls_mem->d_n = (long int) N;
/* Load half-bandwiths in arkdls_mem */
arkdls_mem->d_ml = (long int) mlower;
arkdls_mem->d_mu = (long int) mupper;
/* Test ml and mu for legality */
if ((arkdls_mem->d_ml < 0) || (arkdls_mem->d_mu < 0) ||
(arkdls_mem->d_ml >= arkdls_mem->d_n) ||
(arkdls_mem->d_mu >= arkdls_mem->d_n)) {
arkProcessError(ark_mem, ARKDLS_ILL_INPUT, "ARKLAPACK",
"ARKLapackBand", MSGD_BAD_SIZES);
free(arkdls_mem); arkdls_mem = NULL;
return(ARKDLS_ILL_INPUT);
}
/* Set extended upper half-bandwith for M (required for pivoting) */
arkdls_mem->d_smu = SUNMIN(arkdls_mem->d_n-1,
arkdls_mem->d_mu + arkdls_mem->d_ml);
/* Allocate memory for M, pivot array, and savedJ */
arkdls_mem->d_M = NULL;
arkdls_mem->d_pivots = NULL;
arkdls_mem->d_savedJ = NULL;
arkdls_mem->d_M = NewBandMat(arkdls_mem->d_n, arkdls_mem->d_mu,
arkdls_mem->d_ml, arkdls_mem->d_smu);
if (arkdls_mem->d_M == NULL) {
arkProcessError(ark_mem, ARKDLS_MEM_FAIL, "ARKLAPACK",
"ARKLapackBand", MSGD_MEM_FAIL);
free(arkdls_mem); arkdls_mem = NULL;
return(ARKDLS_MEM_FAIL);
}
arkdls_mem->d_pivots = NewIntArray(N);
if (arkdls_mem->d_pivots == NULL) {
arkProcessError(ark_mem, ARKDLS_MEM_FAIL, "ARKLAPACK",
"ARKLapackBand", MSGD_MEM_FAIL);
DestroyMat(arkdls_mem->d_M);
free(arkdls_mem); arkdls_mem = NULL;
return(ARKDLS_MEM_FAIL);
}
arkdls_mem->d_savedJ = NewBandMat(arkdls_mem->d_n, arkdls_mem->d_mu,
arkdls_mem->d_ml, arkdls_mem->d_smu);
if (arkdls_mem->d_savedJ == NULL) {
arkProcessError(ark_mem, ARKDLS_MEM_FAIL, "ARKLAPACK",
"ARKLapackBand", MSGD_MEM_FAIL);
DestroyMat(arkdls_mem->d_M);
DestroyArray(arkdls_mem->d_pivots);
free(arkdls_mem); arkdls_mem = NULL;
return(ARKDLS_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
ark_mem->ark_lmem = arkdls_mem;
return(ARKDLS_SUCCESS);
}
/*
* -----------------------------------------------------------------
* CVLapackDense
* -----------------------------------------------------------------
* This routine initializes the memory record and sets various function
* fields specific to the linear solver module. CVLapackDense first
* calls the existing lfree routine if this is not NULL. Then it sets
* the cv_linit, cv_lsetup, cv_lsolve, cv_lfree fields in (*cvode_mem)
* to be cvLapackDenseInit, cvLapackDenseSetup, cvLapackDenseSolve,
* and cvLapackDenseFree, respectively. It allocates memory for a
* structure of type CVDlsMemRec and sets the cv_lmem field in
* (*cvode_mem) to the address of this structure. It sets setupNonNull
* in (*cvode_mem) to TRUE, and the d_jac field to the default
* cvDlsDenseDQJac. Finally, it allocates memory for M, pivots, and
* (if needed) savedJ.
* The return value is SUCCESS = 0, or LMEM_FAIL = -1.
*
* NOTE: The dense linear solver assumes a serial implementation
* of the NVECTOR package. Therefore, CVLapackDense will first
* test for a compatible N_Vector internal representation
* by checking that N_VGetArrayPointer and N_VSetArrayPointer
* exist.
* -----------------------------------------------------------------
*/
int CVLapackDense(void *cvode_mem, int N)
{
CVodeMem cv_mem;
CVDlsMem cvdls_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
cvProcessError(NULL, CVDLS_MEM_NULL, "CVSLAPACK", "CVLapackDense", MSGD_CVMEM_NULL);
return(CVDLS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the CVSLAPACK solver */
if (tempv->ops->nvgetarraypointer == NULL ||
tempv->ops->nvsetarraypointer == NULL) {
cvProcessError(cv_mem, CVDLS_ILL_INPUT, "CVSLAPACK", "CVLapackDense", MSGD_BAD_NVECTOR);
return(CVDLS_ILL_INPUT);
}
if (lfree !=NULL) lfree(cv_mem);
/* Set four main function fields in cv_mem */
linit = cvLapackDenseInit;
lsetup = cvLapackDenseSetup;
lsolve = cvLapackDenseSolve;
lfree = cvLapackDenseFree;
/* Get memory for CVDlsMemRec */
cvdls_mem = NULL;
cvdls_mem = (CVDlsMem) malloc(sizeof(struct CVDlsMemRec));
if (cvdls_mem == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackDense", MSGD_MEM_FAIL);
return(CVDLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_DENSE;
/* Initialize Jacobian-related data */
jacDQ = TRUE;
djac = NULL;
J_data = NULL;
last_flag = CVDLS_SUCCESS;
setupNonNull = TRUE;
/* Set problem dimension */
n = N;
/* Allocate memory for M, pivot array, and (if needed) savedJ */
M = NULL;
pivots = NULL;
savedJ = NULL;
M = NewDenseMat(N, N);
if (M == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackDense", MSGD_MEM_FAIL);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
pivots = NewIntArray(N);
if (pivots == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackDense", MSGD_MEM_FAIL);
DestroyMat(M);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
savedJ = NewDenseMat(N, N);
if (savedJ == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackDense", MSGD_MEM_FAIL);
DestroyMat(M);
DestroyArray(pivots);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
lmem = cvdls_mem;
return(CVDLS_SUCCESS);
}
void Vector<T>::Trim(int n)
{
ASSERT(n >= 0 && n <= items);
DestroyArray(vector + n, vector + items);
items = n;
}
int KINBBDPrecInit(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;
KINSpilsMem kinspils_mem;
KINMem kin_mem;
N_Vector vtemp3;
long int muk, mlk, storage_mu;
int flag;
pdata = NULL;
if (kinmem == NULL) {
KINProcessError(NULL, 0, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_MEM_NULL);
return(KINSPILS_MEM_NULL);
}
kin_mem = (KINMem) kinmem;
/* Test if one of the SPILS linear solvers has been attached */
if (kin_mem->kin_lmem == NULL) {
KINProcessError(kin_mem, KINSPILS_LMEM_NULL, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_LMEM_NULL);
return(KINSPILS_LMEM_NULL);
}
kinspils_mem = (KINSpilsMem) kin_mem->kin_lmem;
/* 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, KINSPILS_ILL_INPUT, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_BAD_NVECTOR);
return(KINSPILS_ILL_INPUT);
}
pdata = NULL;
pdata = (KBBDPrecData) malloc(sizeof *pdata); /* allocate data memory */
if (pdata == NULL) {
KINProcessError(kin_mem, KINSPILS_MEM_FAIL, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_MEM_FAIL);
return(KINSPILS_MEM_FAIL);
}
/* set pointers to gloc and gcomm and load half-bandwiths */
pdata->kin_mem = kinmem;
pdata->gloc = gloc;
pdata->gcomm = gcomm;
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 preconditioner matrix */
storage_mu = SUNMIN(Nlocal-1, muk+mlk);
pdata->PP = NULL;
pdata->PP = NewBandMat(Nlocal, muk, mlk, storage_mu);
if (pdata->PP == NULL) {
free(pdata); pdata = NULL;
KINProcessError(kin_mem, KINSPILS_MEM_FAIL, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_MEM_FAIL);
return(KINSPILS_MEM_FAIL);
}
/* allocate memory for lpivots */
pdata->lpivots = NULL;
pdata->lpivots = NewLintArray(Nlocal);
if (pdata->lpivots == NULL) {
DestroyMat(pdata->PP);
free(pdata); pdata = NULL;
KINProcessError(kin_mem, KINSPILS_MEM_FAIL, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_MEM_FAIL);
return(KINSPILS_MEM_FAIL);
}
/* allocate vtemp3 for use by KBBDDQJac routine */
vtemp3 = NULL;
vtemp3 = N_VClone(kin_mem->kin_vtemp1);
if (vtemp3 == NULL) {
DestroyArray(pdata->lpivots);
DestroyMat(pdata->PP);
free(pdata); pdata = NULL;
KINProcessError(kin_mem, KINSPILS_MEM_FAIL, "KINBBDPRE", "KINBBDPrecInit", MSGBBD_MEM_FAIL);
return(KINSPILS_MEM_FAIL);
}
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 = SUNRsqrt(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;
/* make sure s_P_data is free from any previous allocations */
if (kinspils_mem->s_pfree != NULL) {
kinspils_mem->s_pfree(kin_mem);
}
/* Point to the new P_data field in the SPILS memory */
kinspils_mem->s_P_data = pdata;
/* Attach the pfree function */
kinspils_mem->s_pfree = KINBBDPrecFree;
/* Attach preconditioner solve and setup functions */
flag = KINSpilsSetPreconditioner(kinmem, KINBBDPrecSetup, KINBBDPrecSolve);
return(flag);
}
/*
* -----------------------------------------------------------------
* CVLapackBand
* -----------------------------------------------------------------
* This routine initializes the memory record and sets various function
* fields specific to the band linear solver module. It first calls
* the existing lfree routine if this is not NULL. It then sets the
* cv_linit, cv_lsetup, cv_lsolve, and cv_lfree fields in (*cvode_mem)
* to be cvLapackBandInit, cvLapackBandSetup, cvLapackBandSolve,
* and cvLapackBandFree, respectively. It allocates memory for a
* structure of type CVLapackBandMemRec and sets the cv_lmem field in
* (*cvode_mem) to the address of this structure. It sets setupNonNull
* in (*cvode_mem) to be TRUE, mu to be mupper, ml to be mlower, and
* the jacE and jacI field to NULL.
* Finally, it allocates memory for M, pivots, and (if needed) savedJ.
* The CVLapackBand return value is CVDLS_SUCCESS = 0,
* CVDLS_MEM_FAIL = -1, or CVDLS_ILL_INPUT = -2.
*
* NOTE: The CVSLAPACK linear solver assumes a serial implementation
* of the NVECTOR package. Therefore, CVLapackBand will first
* test for compatible a compatible N_Vector internal
* representation by checking that the function
* N_VGetArrayPointer exists.
* -----------------------------------------------------------------
*/
int CVLapackBand(void *cvode_mem, int N, int mupper, int mlower)
{
CVodeMem cv_mem;
CVDlsMem cvdls_mem;
/* Return immediately if cvode_mem is NULL */
if (cvode_mem == NULL) {
cvProcessError(NULL, CVDLS_MEM_NULL, "CVSLAPACK", "CVLapackBand", MSGD_CVMEM_NULL);
return(CVDLS_MEM_NULL);
}
cv_mem = (CVodeMem) cvode_mem;
/* Test if the NVECTOR package is compatible with the BAND solver */
if (tempv->ops->nvgetarraypointer == NULL) {
cvProcessError(cv_mem, CVDLS_ILL_INPUT, "CVSLAPACK", "CVLapackBand", MSGD_BAD_NVECTOR);
return(CVDLS_ILL_INPUT);
}
if (lfree != NULL) lfree(cv_mem);
/* Set four main function fields in cv_mem */
linit = cvLapackBandInit;
lsetup = cvLapackBandSetup;
lsolve = cvLapackBandSolve;
lfree = cvLapackBandFree;
/* Get memory for CVDlsMemRec */
cvdls_mem = NULL;
cvdls_mem = (CVDlsMem) malloc(sizeof(struct CVDlsMemRec));
if (cvdls_mem == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackBand", MSGD_MEM_FAIL);
return(CVDLS_MEM_FAIL);
}
/* Set matrix type */
mtype = SUNDIALS_BAND;
/* Initialize Jacobian-related data */
jacDQ = TRUE;
bjac = NULL;
J_data = NULL;
last_flag = CVDLS_SUCCESS;
setupNonNull = TRUE;
/* Load problem dimension */
n = N;
/* Load half-bandwiths in cvdls_mem */
ml = mlower;
mu = mupper;
/* Test ml and mu for legality */
if ((ml < 0) || (mu < 0) || (ml >= N) || (mu >= N)) {
cvProcessError(cv_mem, CVDLS_ILL_INPUT, "CVSLAPACK", "CVLapackBand", MSGD_BAD_SIZES);
return(CVDLS_ILL_INPUT);
}
/* Set extended upper half-bandwith for M (required for pivoting) */
smu = MIN(N-1, mu + ml);
/* Allocate memory for M, savedJ, and pivot arrays */
M = NULL;
pivots = NULL;
savedJ = NULL;
M = NewBandMat(N, mu, ml, smu);
if (M == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackBand", MSGD_MEM_FAIL);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
pivots = NewIntArray(N);
if (pivots == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackBand", MSGD_MEM_FAIL);
DestroyMat(M);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
savedJ = NewBandMat(N, mu, ml, smu);
if (savedJ == NULL) {
cvProcessError(cv_mem, CVDLS_MEM_FAIL, "CVSLAPACK", "CVLapackBand", MSGD_MEM_FAIL);
DestroyMat(M);
DestroyArray(pivots);
free(cvdls_mem);
return(CVDLS_MEM_FAIL);
}
/* Attach linear solver memory to integrator memory */
lmem = cvdls_mem;
return(CVDLS_SUCCESS);
}
void *CPBBDPrecAlloc(void *cpode_mem, int Nlocal,
int mudq, int mldq, int mukeep, int mlkeep,
realtype dqrely,
void *gloc, CPBBDCommFn cfn)
{
CPodeMem cp_mem;
CPBBDPrecData pdata;
N_Vector tmp4;
int muk, mlk, storage_mu;
if (cpode_mem == NULL) {
cpProcessError(NULL, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_CPMEM_NULL);
return(NULL);
}
cp_mem = (CPodeMem) cpode_mem;
/* Test if the NVECTOR package is compatible with the BLOCK BAND preconditioner */
if(vec_tmpl->ops->nvgetarraypointer == NULL) {
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_BAD_NVECTOR);
return(NULL);
}
/* Allocate data memory */
pdata = NULL;
pdata = (CPBBDPrecData) malloc(sizeof *pdata);
if (pdata == NULL) {
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_MEM_FAIL);
return(NULL);
}
/* Set pointers to gloc and cfn; load half-bandwidths */
pdata->cpode_mem = cpode_mem;
switch (ode_type) {
case CP_EXPL:
pdata->glocE = (CPBBDLocalRhsFn) gloc;
pdata->glocI = NULL;
break;
case CP_IMPL:
pdata->glocI = (CPBBDLocalResFn) gloc;
pdata->glocE = NULL;
break;
}
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 = NewBandMat(Nlocal, muk, mlk, muk);
if (pdata->savedJ == NULL) {
free(pdata); pdata = NULL;
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_MEM_FAIL);
return(NULL);
}
/* Allocate memory for preconditioner matrix */
storage_mu = MIN(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;
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_MEM_FAIL);
return(NULL);
}
/* Allocate memory for pivots */
pdata->pivots = NULL;
pdata->pivots = NewIntArray(Nlocal);
if (pdata->savedJ == NULL) {
DestroyMat(pdata->savedP);
DestroyMat(pdata->savedJ);
free(pdata); pdata = NULL;
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_MEM_FAIL);
return(NULL);
}
/* Allocate tmp4 for use by cpBBDDQJacImpl */
tmp4 = NULL;
tmp4 = N_VClone(vec_tmpl);
if (tmp4 == NULL){
DestroyMat(pdata->savedP);
DestroyMat(pdata->savedJ);
DestroyArray(pdata->pivots);
free(pdata); pdata = NULL;
cpProcessError(cp_mem, 0, "CPBBDPRE", "CPBBDPrecAlloc", MSGBBDP_MEM_FAIL);
return(NULL);
}
pdata->tmp4 = tmp4;
/* Set pdata->dqrely based on input dqrely (0 implies default). */
pdata->dqrely = (dqrely > ZERO) ? dqrely : RSqrt(uround);
/* Store Nlocal to be used in cpBBDPrecSetupExpl and cpBBDPrecSetupImpl */
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);
}