void FKIN_SETIIN(char key_name[], long int *ival, int *ier, int key_len)
{
if (!strncmp(key_name,"PRNT_LEVEL", (size_t)key_len))
*ier = KINSetPrintLevel(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"MAX_NITERS", (size_t)key_len))
*ier = KINSetNumMaxIters(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"ETA_FORM", (size_t)key_len))
*ier = KINSetEtaForm(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"MAX_SETUPS", (size_t)key_len))
*ier = KINSetMaxSetupCalls(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"MAX_SP_SETUPS", (size_t)key_len))
*ier = KINSetMaxSubSetupCalls(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"NO_INIT_SETUP", (size_t)key_len))
*ier = KINSetNoInitSetup(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"NO_MIN_EPS", (size_t)key_len))
*ier = KINSetNoMinEps(KIN_kinmem, (int) *ival);
else if (!strncmp(key_name,"NO_RES_MON", (size_t)key_len))
*ier = KINSetNoResMon(KIN_kinmem, (int) *ival);
else {
*ier = -99;
printf("FKINSETIIN: Unrecognized key.\n\n");
}
}
int nlsKinsolAllocate(int size, NONLINEAR_SYSTEM_DATA *nlsData, int linearSolverMethod)
{
int i, flag, printLevel;
NLS_KINSOL_DATA *kinsolData = (NLS_KINSOL_DATA*) malloc(sizeof(NLS_KINSOL_DATA));
/* allocate system data */
nlsData->solverData = (void*)kinsolData;
kinsolData->size = size;
kinsolData->linearSolverMethod = linearSolverMethod;
kinsolData->solved = 0;
kinsolData->fnormtol = sqrt(newtonFTol); /* function tolerance */
kinsolData->scsteptol = sqrt(newtonXTol); /* step tolerance */
kinsolData->initialGuess = N_VNew_Serial(size);
kinsolData->xScale = N_VNew_Serial(size);
kinsolData->fScale = N_VNew_Serial(size);
kinsolData->fRes = N_VNew_Serial(size);
kinsolData->kinsolMemory = KINCreate();
/* setup user defined functions */
KINSetErrHandlerFn(kinsolData->kinsolMemory, nlsKinsolErrorPrint, kinsolData);
KINSetInfoHandlerFn(kinsolData->kinsolMemory, nlsKinsolInfoPrint, kinsolData);
KINSetUserData(kinsolData->kinsolMemory, (void*)&(kinsolData->userData));
flag = KINInit(kinsolData->kinsolMemory, nlsKinsolResiduals, kinsolData->initialGuess);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
}
/* Specify linear solver and/or corresponding jacobian function*/
if (kinsolData->linearSolverMethod == 3)
{
if(nlsData->isPatternAvailable)
{
kinsolData->nnz = nlsData->sparsePattern.numberOfNoneZeros;
flag = KINKLU(kinsolData->kinsolMemory, size, kinsolData->nnz);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
}
flag = KINSlsSetSparseJacFn(kinsolData->kinsolMemory, nlsSparseJac);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL Sparse Solver!");
}
}
else
{
flag = KINDense(kinsolData->kinsolMemory, size);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
}
}
}
else if (kinsolData->linearSolverMethod == 1)
{
flag = KINDense(kinsolData->kinsolMemory, size);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
}
}
else if (kinsolData->linearSolverMethod == 2)
{
flag = KINDense(kinsolData->kinsolMemory, size);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL solver!");
}
flag = KINDlsSetDenseJacFn(kinsolData->kinsolMemory, nlsDenseJac);
if (checkReturnFlag(flag)){
errorStreamPrint(LOG_STDOUT, 0, "##KINSOL## Something goes wrong while initialize KINSOL Sparse Solver!");
}
}
/* configuration */
nlsKinsolConfigSetup(kinsolData);
/* debug print level of kinsol */
if (ACTIVE_STREAM(LOG_NLS))
printLevel = 1;
else if (ACTIVE_STREAM(LOG_NLS_V))
printLevel = 3;
else
printLevel = 0;
KINSetPrintLevel(kinsolData->kinsolMemory, printLevel);
return 0;
}
static void KIM_Malloc(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
int status;
mxArray *mx_in[3], *mx_out[2];
int mxiter, msbset, msbsetsub, etachoice, mxnbcf;
double eta, egamma, ealpha, mxnewtstep, relfunc, fnormtol, scsteptol;
booleantype verbose, noInitSetup, noMinEps;
double *constraints;
N_Vector NVconstraints;
int ptype;
int mudq, mldq, mupper, mlower;
int maxl, maxrs;
double dqrely;
/*
* -----------------------------
* Find out the vector type and
* then pass it to the vector
* library.
* -----------------------------
*/
/* Send vec_type and mx_comm */
InitVectors();
/*
* -----------------------------
* Extract stuff from arguments:
* - SYS function
* - problem dimension
* - solver options
* - user data
* -----------------------------
*/
/* Matlab user-provided function */
mxDestroyArray(mx_SYSfct);
mx_SYSfct = mxDuplicateArray(prhs[0]);
/* problem dimension */
N = (int) mxGetScalar(prhs[1]);
/* Solver Options -- optional argument */
status = get_SolverOptions(prhs[2],
&verbose,
&mxiter, &msbset, &msbsetsub, &etachoice, &mxnbcf,
&eta, &egamma, &ealpha, &mxnewtstep,
&relfunc, &fnormtol, &scsteptol,
&constraints,
&noInitSetup, &noMinEps);
/* User data -- optional argument */
mxDestroyArray(mx_data);
mx_data = mxDuplicateArray(prhs[3]);
/*
* -----------------------------------------------------
* Set solution vector (used as a template to KINMAlloc)
* -----------------------------------------------------
*/
y = NewVector(N);
/*
* ----------------------------------------
* Create kinsol object and allocate memory
* ----------------------------------------
*/
kin_mem = KINCreate();
/* attach error handler function */
status = KINSetErrHandlerFn(kin_mem, mtlb_KINErrHandler, NULL);
if (verbose) {
status = KINSetPrintLevel(kin_mem,3);
/* attach info handler function */
status = KINSetInfoHandlerFn(kin_mem, mtlb_KINInfoHandler, NULL);
/* initialize the output window */
mx_in[0] = mxCreateScalarDouble(0);
mx_in[1] = mxCreateScalarDouble(0); /* ignored */
mx_in[2] = mxCreateScalarDouble(0); /* ignored */
mexCallMATLAB(1,mx_out,3,mx_in,"kim_info");
fig_handle = (int)*mxGetPr(mx_out[0]);
}
/* Call KINMalloc */
status = KINMalloc(kin_mem, mtlb_KINSys, y);
/* Redirect output */
status = KINSetErrFile(kin_mem, stdout);
/* Optional inputs */
status = KINSetNumMaxIters(kin_mem,mxiter);
status = KINSetNoInitSetup(kin_mem,noInitSetup);
status = KINSetNoMinEps(kin_mem,noMinEps);
status = KINSetMaxSetupCalls(kin_mem,msbset);
status = KINSetMaxSubSetupCalls(kin_mem,msbsetsub);
status = KINSetMaxBetaFails(kin_mem,mxnbcf);
status = KINSetEtaForm(kin_mem,etachoice);
status = KINSetEtaConstValue(kin_mem,eta);
status = KINSetEtaParams(kin_mem,egamma,ealpha);
status = KINSetMaxNewtonStep(kin_mem,mxnewtstep);
status = KINSetRelErrFunc(kin_mem,relfunc);
status = KINSetFuncNormTol(kin_mem,fnormtol);
status = KINSetScaledStepTol(kin_mem,scsteptol);
if (constraints != NULL) {
NVconstraints = N_VCloneEmpty(y);
N_VSetArrayPointer(constraints, NVconstraints);
status = KINSetConstraints(kin_mem,NVconstraints);
N_VDestroy(NVconstraints);
}
status = get_LinSolvOptions(prhs[2],
&mupper, &mlower,
&mudq, &mldq, &dqrely,
&ptype, &maxrs, &maxl);
switch (ls) {
case LS_NONE:
mexErrMsgTxt("KINMalloc:: no linear solver specified.");
break;
case LS_DENSE:
status = KINDense(kin_mem, N);
if (!mxIsEmpty(mx_JACfct))
status = KINDenseSetJacFn(kin_mem, mtlb_KINDenseJac, NULL);
break;
case LS_BAND:
status = KINBand(kin_mem, N, mupper, mlower);
if (!mxIsEmpty(mx_JACfct))
status = KINBandSetJacFn(kin_mem, mtlb_KINBandJac, NULL);
break;
case LS_SPGMR:
switch(pm) {
case PM_NONE:
status = KINSpgmr(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSpgmr(kin_mem, maxl, bbd_data);
break;
}
status = KINSpilsSetMaxRestarts(kin_mem, maxrs);
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
case LS_SPBCG:
switch(pm) {
case PM_NONE:
status = KINSpbcg(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSpbcg(kin_mem, maxl, bbd_data);
break;
}
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
case LS_SPTFQMR:
switch(pm) {
case PM_NONE:
status = KINSptfqmr(kin_mem, maxl);
if (!mxIsEmpty(mx_PSOLfct)) {
if (!mxIsEmpty(mx_PSETfct))
status = KINSpilsSetPreconditioner(kin_mem, mtlb_KINSpilsPset, mtlb_KINSpilsPsol, NULL);
else
status = KINSpilsSetPreconditioner(kin_mem, NULL, mtlb_KINSpilsPsol, NULL);
}
break;
case PM_BBDPRE:
if (!mxIsEmpty(mx_GCOMfct))
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, mtlb_KINGcom);
else
bbd_data = KINBBDPrecAlloc(kin_mem, N, mudq, mldq, mupper, mlower, dqrely, mtlb_KINGloc, NULL);
status = KINBBDSptfqmr(kin_mem, maxl, bbd_data);
break;
}
if (!mxIsEmpty(mx_JACfct))
status = KINSpilsSetJacTimesVecFn(kin_mem, mtlb_KINSpilsJac, NULL);
break;
}
return;
}
