void FKIN_DENSESETJAC(int *flag, int *ier)
{
if (*flag == 0) {
*ier = KINDlsSetDenseJacFn(KIN_kinmem, NULL);
}
else {
*ier = KINDlsSetDenseJacFn(KIN_kinmem, FKINDenseJac);
}
return;
}
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;
}
int main()
{
realtype fnormtol, scsteptol;
N_Vector y, scale, constraints;
int mset, flag, i;
void *kmem;
y = scale = constraints = NULL;
kmem = NULL;
printf("\nRobot Kinematics Example\n");
printf("8 variables; -1 <= x_i <= 1\n");
printf("KINSOL problem size: 8 + 2*8 = 24 \n\n");
/* Create vectors for solution, scales, and constraints */
y = N_VNew_Serial(NEQ);
if (check_flag((void *)y, "N_VNew_Serial", 0)) return(1);
scale = N_VNew_Serial(NEQ);
if (check_flag((void *)scale, "N_VNew_Serial", 0)) return(1);
constraints = N_VNew_Serial(NEQ);
if (check_flag((void *)constraints, "N_VNew_Serial", 0)) return(1);
/* Initialize and allocate memory for KINSOL */
kmem = KINCreate();
if (check_flag((void *)kmem, "KINCreate", 0)) return(1);
flag = KINInit(kmem, func, y); /* y passed as a template */
if (check_flag(&flag, "KINInit", 1)) return(1);
/* Set optional inputs */
N_VConst_Serial(ZERO,constraints);
for (i = NVAR+1; i <= NEQ; i++) Ith(constraints, i) = ONE;
flag = KINSetConstraints(kmem, constraints);
if (check_flag(&flag, "KINSetConstraints", 1)) return(1);
fnormtol = FTOL;
flag = KINSetFuncNormTol(kmem, fnormtol);
if (check_flag(&flag, "KINSetFuncNormTol", 1)) return(1);
scsteptol = STOL;
flag = KINSetScaledStepTol(kmem, scsteptol);
if (check_flag(&flag, "KINSetScaledStepTol", 1)) return(1);
/* Attach dense linear solver */
flag = KINDense(kmem, NEQ);
if (check_flag(&flag, "KINDense", 1)) return(1);
flag = KINDlsSetDenseJacFn(kmem, jac);
if (check_flag(&flag, "KINDlsSetDenseJacFn", 1)) return(1);
/* Indicate exact Newton */
mset = 1;
flag = KINSetMaxSetupCalls(kmem, mset);
if (check_flag(&flag, "KINSetMaxSetupCalls", 1)) return(1);
/* Initial guess */
N_VConst_Serial(ONE, y);
for(i = 1; i <= NVAR; i++) Ith(y,i) = SQRT(TWO)/TWO;
printf("Initial guess:\n");
PrintOutput(y);
/* Call KINSol to solve problem */
N_VConst_Serial(ONE,scale);
flag = KINSol(kmem, /* KINSol memory block */
y, /* initial guess on input; solution vector */
KIN_LINESEARCH, /* global stragegy choice */
scale, /* scaling vector, for the variable cc */
scale); /* scaling vector for function values fval */
if (check_flag(&flag, "KINSol", 1)) return(1);
printf("\nComputed solution:\n");
PrintOutput(y);
/* Print final statistics and free memory */
PrintFinalStats(kmem);
N_VDestroy_Serial(y);
N_VDestroy_Serial(scale);
N_VDestroy_Serial(constraints);
KINFree(&kmem);
return(0);
}
bool kinsol_solve(void) {
double fnormtol;
N_Vector y, scale, constraints;
int mset, flag;
void *kmem;
y = scale = constraints = NULL;
kmem = NULL;
/* Create vectors for solution, scales, and constraints */
y = N_VMake_Serial(nvariables, variables);
if (y == NULL) goto cleanup;
scale = N_VNew_Serial(nvariables);
if (scale == NULL) goto cleanup;
constraints = N_VNew_Serial(nvariables);
if (constraints == NULL) goto cleanup;
/* Initialize and allocate memory for KINSOL */
kmem = KINCreate();
if (kmem == NULL) goto cleanup;
flag = KINInit(kmem, _f, y);
if (flag < 0) goto cleanup;
// This constrains metabolites >= 0
N_VConst_Serial(1.0, constraints);
flag = KINSetConstraints(kmem, constraints);
if (flag < 0) goto cleanup;
fnormtol = ARGS.ABSTOL;
flag = KINSetFuncNormTol(kmem, fnormtol);
if (flag < 0) goto cleanup;
//scsteptol = ARGS.RELTOL;
//flag = KINSetScaledStepTol(kmem, scsteptol);
//if (flag < 0) goto cleanup;
/* Attach dense linear solver */
flag = KINDense(kmem, nvariables);
if (flag < 0) goto cleanup;
flag = KINDlsSetDenseJacFn(kmem, _dfdy);
if (flag < 0) goto cleanup;
/* Indicate exact Newton */
//This makes sure that the user-supplied Jacobian gets evaluated onevery step.
mset = 1;
flag = KINSetMaxSetupCalls(kmem, mset);
if (flag < 0) goto cleanup;
/* Initial guess is the intial variable concentrations */
/* Call KINSol to solve problem */
N_VConst_Serial(1.0,scale);
flag = KINSol(kmem, /* KINSol memory block */
y, /* initial guess on input; solution vector */
KIN_NONE, /* basic Newton iteration */
scale, /* scaling vector, for the variable cc */
scale); /* scaling vector for function values fval */
if((ARGS.MODE != ABC) and (ARGS.MODE != ABCSIM) and (ARGS.MODE != Prior))
OUT_nums();
if (flag < 0) goto cleanup;
N_VDestroy_Serial(y);
N_VDestroy_Serial(scale);
N_VDestroy_Serial(constraints);
KINFree(&kmem);
return true;
cleanup:
error("Could not integrate!\n");
if (y!=NULL) N_VDestroy_Serial(y);
if (scale!=NULL) N_VDestroy_Serial(scale);
if (constraints!=NULL) N_VDestroy_Serial(constraints);
if (kmem!=NULL) KINFree(&kmem);
return false;
}
