int main(void)
{
printf("\n Start of test on Default SolverOptions\n");
int info = 0 ;
SolverOptions * options = (SolverOptions *)malloc(sizeof(SolverOptions));
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_NSGS);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_NSGSV);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_PROX);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_TFP);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_DSFP);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_EG);
solver_options_print(options);
solver_options_delete(options);
info = fc3d_setDefaultSolverOptions(options, SICONOS_FRICTION_3D_HP);
solver_options_print(options);
solver_options_delete(options);
free(options);
printf("\n End of test on Default SolverOptions\n");
return info;
}
int variationalInequality_driver(VariationalInequality* problem,
double *x, double *w,
SolverOptions* options)
{
if (options == NULL)
numerics_error("variationalInequality_driver", "null input for solver and/or global options");
assert(options->isSet);
if (verbose > 0)
solver_options_print(options);
/* Solver name */
/*char * name = options->solverName;*/
int info = -1 ;
/* Check for trivial case */
info = checkTrivialCase_vi(problem, x, w, options);
if (info == 0){
double error;
variationalInequality_computeError(problem, x , w, options->dparam[0], options, &error);
printf("variationalInequality_driver. error = %8.4e\n", error);
return info;
}
switch (options->solverId)
{
/* Non Smooth Gauss Seidel (NSGS) */
/* Extra Gradient algorithm */
case SICONOS_VI_EG:
{
numerics_printf_verbose(1,
" ========================== Call ExtraGradient (EG) solver for VI problem ==========================\n");
variationalInequality_ExtraGradient(problem, x , w , &info , options);
break;
}
case SICONOS_VI_FPP:
{
numerics_printf_verbose(1,
" ========================== Call Fixed Point Projection (FPP) solver for VI problem ==========================\n");
variationalInequality_FixedPointProjection(problem, x , w , &info , options);
break;
}
case SICONOS_VI_HP:
{
numerics_printf_verbose(1,
" ========================== Call Hyperplane Projection (HP) solver for VI problem ==========================\n");
variationalInequality_HyperplaneProjection(problem, x , w , &info , options);
break;
}
case SICONOS_VI_BOX_QI:
{
variationalInequality_box_newton_QiLSA(problem, x, w, &info, options);
break;
}
case SICONOS_VI_BOX_AVI_LSA:
{
vi_box_AVI_LSA(problem, x, w, &info, options);
break;
}
case SICONOS_VI_BOX_PATH:
{
vi_box_path(problem, x, w, &info, options);
break;
}
default:
{
fprintf(stderr, "Numerics, variationalInequality_driver failed. Unknown solver.\n");
exit(EXIT_FAILURE);
}
}
return info;
}
int soclcp_driver(SecondOrderConeLinearComplementarityProblem* problem,
double *r, double *v,
SolverOptions* options)
{
if(options == NULL)
numerics_error("soclcp_driver", "null input for solver and/or global options");
assert(options->isSet);
if(verbose > 0)
solver_options_print(options);
/* Solver name */
/*const char* const name = options->solverName;*/
int info = -1 ;
/* Check for trivial case */
info = soclcp_checkTrivialCase(problem, v, r, options);
if(info == 0)
return info;
switch(options->solverId)
{
/* Non Smooth Gauss Seidel (NSGS) */
case SICONOS_SOCLCP_NSGS:
{
numerics_printf(" ========================== Call NSGS solver for Second Order Cone LCP problem ==========================\n");
soclcp_nsgs(problem, r , v , &info , options);
break;
}
/* case SICONOS_SOCLCP_NSGSV: */
/* { */
/* numerics_printf(numerics_printf(" ========================== Call NSGSV solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_nsgs_v(problem, r , v , &info , options); */
/* break; */
/* } */
/* /\* Proximal point algorithm *\/ */
/* case SICONOS_SOCLCP_PROX: */
/* { */
/* numerics_printf(numerics_printf(" ========================== Call PROX (Proximal Point) solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_proximal(problem, r , v , &info , options); */
/* break; */
/* } */
/* /\* Tresca Fixed point algorithm *\/ */
/* case SICONOS_SOCLCP_TFP: */
/* { */
/* numerics_printf(" ========================== Call TFP (Tresca Fixed Point) solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_TrescaFixedPoint(problem, r , v , &info , options); */
/* break; */
/* } */
case SICONOS_SOCLCP_VI_FPP:
{
numerics_printf(" ========================== Call VI_FixedPointProjection (VI_FPP) solver for Second Order Cone LCP problem ==========================\n");
soclcp_VI_FixedPointProjection(problem, r , v , &info , options);
break;
}
/* VI Extra Gradient algorithm */
case SICONOS_SOCLCP_VI_EG:
{
numerics_printf(" ========================== Call VI_ExtraGradient (VI_EG) solver for Second Order Cone LCP problem ==========================\n");
soclcp_VI_ExtraGradient(problem, r , v , &info , options);
break;
}
/* /\* Hyperplane Projection algorithm *\/ */
/* case SICONOS_SOCLCP_HP: */
/* { */
/* numerics_printf(" ========================== Call Hyperplane Projection (HP) solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_HyperplaneProjection(problem, r , v , &info , options); */
/* break; */
/* } */
/* /\* Alart Curnier in local coordinates *\/ */
/* case SICONOS_SOCLCP_NSN_AC: */
/* { */
/* numerics_printf(" ========================== Call Alart Curnier solver for Second Order Cone LCP problem ==========================\n"); */
/* if (problem->M->matrix0) */
/* { */
/* soclcp_nonsmooth_Newton_AlartCurnier(problem, r , v , &info , options); */
/* } */
/* else */
/* { */
/* soclcp_nonsmooth_Newton_AlartCurnier(problem, r , v , &info , options); */
/* } */
/* break; */
/* } */
/* /\* Fischer Burmeister in local coordinates *\/ */
/* case SICONOS_SOCLCP_NSN_FB: */
/* { */
/* numerics_printf(" ========================== Call Fischer Burmeister solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_nonsmooth_Newton_FischerBurmeister(problem, r , v , &info , options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_QUARTIC_NU: */
/* case SICONOS_SOCLCP_QUARTIC: */
/* { */
/* numerics_printf(" ========================== Call Quartic solver for Second Order Cone LCP problem ==========================\n"); */
/* soclcp_unitary_enumerative(problem, r , v , &info , options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_AlartCurnierNewton: */
/* case SICONOS_SOCLCP_DampedAlartCurnierNewton: */
/* { */
/* numerics_printf(" ========================== Call Quartic solver for Second Order Cone LCP problem ==========================\n"); */
/* info =soclcp_Newton_solve(problem, r , options); */
/* break; */
/* } */
default:
{
fprintf(stderr, "Numerics, SecondOrderConeLinearComplementarity_driver failed. Unknown solver.\n");
exit(EXIT_FAILURE);
}
}
return info;
}
int main(void)
{
printf("\n Start of test on Default SolverOptions\n");
int info = 0 ;
SolverOptions * options = (SolverOptions *)malloc(sizeof(SolverOptions));
FILE * finput = fopen("./data/lcp_mmc.dat", "r");
LinearComplementarityProblem* problem = (LinearComplementarityProblem *)malloc(sizeof(LinearComplementarityProblem));
info = linearComplementarity_newFromFile(problem, finput);
fclose(finput);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSGS_SBM);
assert(options->internalSolvers);
solver_options_set(options->internalSolvers, SICONOS_LCP_LEMKE);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PGS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_RPGS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_QP);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NSQP);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_CPG);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PSOR);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LATIN);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LATIN_W);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_LEMKE);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PATH);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_ENUM);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_NEWTONMIN);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_AVI_CAOFERRIS);
solver_options_print(options);
solver_options_delete(options);
info = linearComplementarity_setDefaultSolverOptions(problem, options, SICONOS_LCP_PIVOT);
solver_options_print(options);
solver_options_delete(options);
freeLinearComplementarityProblem(problem);
free(options);
printf("\n End of test on Default SolverOptions\n");
return info;
}
void fc3d_Panagiotopoulos_FixedPoint(FrictionContactProblem* problem, double *reaction, double *velocity, int* info, SolverOptions* options)
{
/* verbose=1; */
/* int and double parameters */
int* iparam = options->iparam;
double* dparam = options->dparam;
/* Number of contacts */
int nc = problem->numberOfContacts;
/* Maximum number of iterations */
int itermax = iparam[SICONOS_IPARAM_MAX_ITER];
/* Tolerance */
double tolerance = dparam[SICONOS_DPARAM_TOL];
double norm_q = cblas_dnrm2(nc*3 , problem->q , 1);
if (options->numberOfInternalSolvers < 1)
{
numerics_error("fc3d_TrescaFixedpoint", "The Tresca Fixed Point method needs options for the internal solvers, options[0].numberOfInternalSolvers should be >1");
}
SolverOptions * internalsolver_options = options->internalSolvers;
if (verbose) solver_options_print(options);
/***** Fixed Point Iterations *****/
int iter = 0; /* Current iteration number */
double error = 1.; /* Current error */
int hasNotConverged = 1;
normalInternalSolverPtr internalsolver_normal;
tangentInternalSolverPtr internalsolver_tangent;
options->dWork = (double *) malloc(nc * sizeof(double));
options->dWorkSize = nc;
double * mu = options->dWork;
internalsolver_options->dWork = options->dWork;
double * r_n = (double *) malloc(nc * sizeof(double));
double * r_t = (double *) malloc(2* nc * sizeof(double));
for (int contact = 0 ; contact < nc; contact ++)
{
r_n[contact] = reaction[contact*3];
r_t[2*contact] = reaction[contact*3+1];
r_t[2*contact+1] = reaction[contact*3+2];
}
SplittedFrictionContactProblem * splitted_problem = (SplittedFrictionContactProblem *)malloc(sizeof(SplittedFrictionContactProblem));
createSplittedFrictionContactProblem(problem, splitted_problem);
LinearComplementarityProblem* normal_lcp_problem;
ConvexQP * tangent_cqp;
if (options->numberOfInternalSolvers !=2)
numerics_error("fc3d_Panagiotopoulos_FixedPoint", " the solver requires 2 internal solver");
if (internalsolver_options[0].solverId == SICONOS_LCP_PGS||
internalsolver_options[0].solverId == SICONOS_LCP_CONVEXQP_PG)
{
normal_lcp_problem = (LinearComplementarityProblem*)malloc(sizeof(LinearComplementarityProblem));
normal_lcp_problem->size = nc;
normal_lcp_problem->M = splitted_problem->M_nn;
/* for (int contact = 0 ; contact < nc; contact ++) */
/* { */
/* problem->mu[contact] =0.0; */
/* } */
/* splitted_problem->M_nn->matrix0 =(double *)malloc(splitted_problem->M_nn->size0*splitted_problem->M_nn->size1*sizeof(double)); */
/* SBM_to_dense(splitted_problem->M_nn->matrix1, splitted_problem->M_nn->matrix0); */
/* splitted_problem->M_nn->storageType=NM_DENSE; */
normal_lcp_problem->q = (double *)malloc(nc*sizeof(double));
}
else
{
numerics_error("fc3d_Panagiotopoulos_FixedPoint", "Unknown internal solver for the normal part.");
}
if (internalsolver_options[1].solverId == SICONOS_CONVEXQP_PG ||
internalsolver_options[1].solverId == SICONOS_CONVEXQP_VI_FPP||
internalsolver_options[1].solverId == SICONOS_CONVEXQP_VI_EG)
{
tangent_cqp = (ConvexQP *)malloc(sizeof(ConvexQP));
tangent_cqp->M = splitted_problem->M_tt;
tangent_cqp->q = (double *) malloc(2* nc * sizeof(double));
tangent_cqp->ProjectionOnC = &Projection_ConvexQP_FC3D_Disk;
tangent_cqp->A=NULL;
tangent_cqp->b= NULL;
FrictionContactProblem_as_ConvexQP *fc3d_as_cqp= (FrictionContactProblem_as_ConvexQP*)malloc(sizeof(FrictionContactProblem_as_ConvexQP));
tangent_cqp->env = fc3d_as_cqp ;
tangent_cqp->size = nc*2;
/*set the norm of the VI to the norm of problem->q */
double norm_q_t = cblas_dnrm2(nc*2 , splitted_problem->q_t , 1);
tangent_cqp->normConvexQP= norm_q_t;
tangent_cqp->istheNormConvexQPset=1;
fc3d_as_cqp->cqp = tangent_cqp;
fc3d_as_cqp->fc3d = problem;
fc3d_as_cqp->options = options;
}
else
{
numerics_error("fc3d_Panagiotopoulos_FixedPoint", "Unknown internal solver for the tangent part.");
}
if (internalsolver_options[0].solverId == SICONOS_LCP_PGS)
{
if (verbose > 0)
printf(" ========================== Call LCP_PGS solver for Friction-Contact 3D problem ==========================\n");
internalsolver_normal = &lcp_pgs;
}
else if (internalsolver_options[0].solverId == SICONOS_LCP_CONVEXQP_PG)
{
if (verbose > 0)
printf(" ========================== Call LCP_CONVEX_QP solver for Friction-Contact 3D problem ==========================\n");
internalsolver_normal = &lcp_ConvexQP_ProjectedGradient;
}
else
{
numerics_error("fc3d_Panagiotopoulos_FixedPoint", "Unknown internal solver for the normal part.");
}
if (internalsolver_options[1].solverId == SICONOS_CONVEXQP_PG)
{
if (verbose > 0)
printf(" ========================== Call SICONOS_CONVEX_QP solver for Friction-Contact 3D problem ==========================\n");
internalsolver_tangent = &convexQP_ProjectedGradient;
}
else if (internalsolver_options[1].solverId == SICONOS_CONVEXQP_VI_FPP ||
internalsolver_options[1].solverId == SICONOS_CONVEXQP_VI_EG )
{
if (verbose > 0)
printf(" ========================== Call SICONOS_CONVEX_VI_FPP solver for Friction-Contact 3D problem ==========================\n");
internalsolver_tangent = &convexQP_VI_solver;
}
int cumul_internal=0;
//verbose=1;
while ((iter < itermax) && (hasNotConverged > 0))
{
++iter;
fc3d_set_internalsolver_tolerance(problem,options,&internalsolver_options[0], error);
/* ----------------- */
/* normal resolution */
/* ----------------- */
/* compute the rhs of the normal problem */
cblas_dcopy(nc , splitted_problem->q_n , 1 , normal_lcp_problem->q, 1);
NM_gemv(1.0, splitted_problem->M_nt, r_t, 1.0, normal_lcp_problem->q);
(*internalsolver_normal)(normal_lcp_problem, r_n , velocity , info , &internalsolver_options[0]);
cumul_internal += internalsolver_options[0].iparam[SICONOS_IPARAM_ITER_DONE];
for (int contact = 0 ; contact < nc; contact ++)
{
reaction[contact*3]= r_n[contact];
}
fc3d_compute_error(problem, reaction , velocity, tolerance, options, norm_q, &error);
if (error < tolerance)
{
hasNotConverged = 0;
}
else
{
/* ------------------ */
/* tangent resolution */
/* ------------------ */
fc3d_set_internalsolver_tolerance(problem,options,&internalsolver_options[1], error);
/* compute the rhs of the tangent problem */
cblas_dcopy(2*nc , splitted_problem->q_t, 1 , tangent_cqp->q, 1);
NM_gemv(1.0, splitted_problem->M_tn, r_n, 1.0, tangent_cqp->q);
/* Compute the value of the initial value friction threshold*/
for (int ic = 0 ; ic < nc ; ic++) mu[ic] = fmax(0.0, problem->mu[ic] * reaction [ic * 3]);
/* if (verbose>0) */
/* printf("norm of mu = %10.5e \n", cblas_dnrm2(nc , mu , 1)); */
fc3d_compute_error(problem, reaction , velocity, tolerance, options, norm_q, &error);
(*internalsolver_tangent)(tangent_cqp, r_t , velocity , info , &internalsolver_options[1]);
cumul_internal += internalsolver_options->iparam[SICONOS_IPARAM_ITER_DONE];
for (int contact = 0 ; contact < nc; contact ++)
{
reaction[contact*3+1]= r_t[2*contact];
reaction[contact*3+2]= r_t[2*contact+1];
}
/* **** Criterium convergence **** */
fc3d_compute_error(problem, reaction , velocity, tolerance, options, norm_q, &error);
if (options->callback)
{
options->callback->collectStatsIteration(options->callback->env, nc * 3,
reaction, velocity, error, NULL);
}
if (error < tolerance) hasNotConverged = 0;
}
*info = hasNotConverged;
if (verbose > 0)
{
if (hasNotConverged)
{
printf("--------------- FC3D - PFP - Iteration %i error = %14.7e > %10.5e\n", iter, error, tolerance);
}
else
{
printf("--------------- FC3D - PFP - Iteration %i error = %14.7e < %10.5e\n", iter, error, tolerance);
printf("--------------- FC3D - PFP - # Internal iteration = %i\n", cumul_internal);
}
}
}
free(options->dWork);
options->dWork = NULL;
internalsolver_options->dWork = NULL;
if (internalsolver_options->internalSolvers != NULL)
internalsolver_options->internalSolvers->dWork = NULL;
dparam[SICONOS_DPARAM_RESIDU] = error;
iparam[SICONOS_IPARAM_ITER_DONE] = iter;
}
int gfc3d_driver(GlobalFrictionContactProblem* problem, double *reaction , double *velocity, double* globalVelocity, SolverOptions* options)
{
assert(options->isSet);
if (verbose > 0)
solver_options_print(options);
/* Solver name */
/* char * name = options->solverName;*/
int info = -1 ;
if (problem->dimension != 3)
numerics_error("gfc3d_driver", "Dimension of the problem : problem-> dimension is not compatible or is not set");
/* Non Smooth Gauss Seidel (NSGS) */
switch (options->solverId)
{
case SICONOS_GLOBAL_FRICTION_3D_NSGS_WR:
{
if (verbose == 1)
printf(" ========================== Call NSGS_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_nsgs_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_NSGSV_WR:
{
if (verbose == 1)
printf(" ========================== Call NSGSV_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_nsgs_velocity_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_NSN_AC_WR:
{
if (verbose == 1)
printf(" ========================== Call NSN_AC_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_globalAlartCurnier_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_PROX_WR:
{
if (verbose == 1)
printf(" ========================== Call PROX_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_proximal_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_DSFP_WR:
{
if (verbose == 1)
printf(" ========================== Call DSFP_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_DeSaxceFixedPoint_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_TFP_WR:
{
if (verbose == 1)
printf(" ========================== Call TFP_WR solver with reformulation into Friction-Contact 3D problem ==========================\n");
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_TrescaFixedPoint_wr(problem, reaction , velocity, globalVelocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_NSGS:
{
Global_ipiv = NULL;
Global_MisInverse = 0;
Global_MisLU = 0;
gfc3d_nsgs(problem, reaction , velocity, globalVelocity,
&info , options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_NSN_AC:
{
gfc3d_nonsmooth_Newton_AlartCurnier(problem, reaction , velocity,
globalVelocity, &info , options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_GAMS_PATH:
{
printf(" ========================== Call PATH solver via GAMS for an AVI Friction-Contact 3D problem ==========================\n");
gfc3d_AVI_gams_path(problem, reaction , velocity, &info, options);
break;
}
case SICONOS_GLOBAL_FRICTION_3D_GAMS_PATHVI:
{
printf(" ========================== Call PATHVI solver via GAMS for an AVI Friction-Contact 3D problem ==========================\n");
gfc3d_AVI_gams_pathvi(problem, reaction , globalVelocity, &info, options);
break;
}
default:
{
fprintf(stderr, "Numerics, gfc3d_driver failed. Unknown solver %d.\n", options->solverId);
exit(EXIT_FAILURE);
}
}
return info;
}
int fc3d_driver(FrictionContactProblem* problem,
double *reaction, double *velocity,
SolverOptions* options)
{
if (options == NULL)
numerics_error("fc3d_driver", "null input for solver options");
assert(options->isSet); /* true(1) if the SolverOptions structure has been filled in else false(0) */
if (verbose > 1)
solver_options_print(options);
int info = -1 ;
if (problem->dimension != 3)
numerics_error("fc3d_driver", "Dimension of the problem : problem-> dimension is not compatible or is not set");
/* Check for trivial case */
info = checkTrivialCase(problem, velocity, reaction, options);
if (info == 0)
{
/* If a trivial solution is found, we set the number of iterations to 0
and the reached acuracy to 0.0 .
Since the indexing of parameters is non uniform, this may have side
effects for some solvers. The two main return parameters iparam[7] and
dparam[1] have to be defined and protected by means of enum*/
options->iparam[7] = 0;
options->dparam[1] = 0.0;
goto exit;
}
switch (options->solverId)
{
/* Non Smooth Gauss Seidel (NSGS) */
case SICONOS_FRICTION_3D_NSGS:
{
numerics_printf(" ========================== Call NSGS solver for Friction-Contact 3D problem ==========================\n");
fc3d_nsgs(problem, reaction , velocity , &info , options);
break;
}
case SICONOS_FRICTION_3D_NSGSV:
{
numerics_printf(" ========================== Call NSGSV solver for Friction-Contact 3D problem ==========================\n");
fc3d_nsgs_velocity(problem, reaction , velocity , &info , options);
break;
}
/* Proximal point algorithm */
case SICONOS_FRICTION_3D_PROX:
{
numerics_printf(" ========================== Call PROX (Proximal Point) solver for Friction-Contact 3D problem ==========================\n");
fc3d_proximal(problem, reaction , velocity , &info , options);
break;
}
/* Tresca Fixed point algorithm */
case SICONOS_FRICTION_3D_TFP:
{
numerics_printf(" ========================== Call TFP (Tresca Fixed Point) solver for Friction-Contact 3D problem ==========================\n");
fc3d_TrescaFixedPoint(problem, reaction , velocity , &info , options);
break;
}
/* ACLM Fixed point algorithm */
case SICONOS_FRICTION_3D_ACLMFP:
{
numerics_printf(" ========================== Call ACLM (Acary Cadoux Lemarechal Malick Fixed Point) solver for Friction-Contact 3D problem ==========================\n");
fc3d_ACLMFixedPoint(problem, reaction , velocity , &info , options);
break;
}
/* SOCLCP Fixed point algorithm */
case SICONOS_FRICTION_3D_SOCLCP:
{
numerics_printf(" ========================== Call SOCLCP solver for Friction-Contact 3D problem (Associated one) ==========================\n");
fc3d_SOCLCP(problem, reaction , velocity , &info , options);
break;
}
/* De Saxce Fixed point algorithm */
case SICONOS_FRICTION_3D_DSFP:
{
numerics_printf(" ========================== Call DeSaxce Fixed Point (DSFP) solver for Friction-Contact 3D problem ==========================\n");
fc3d_DeSaxceFixedPoint(problem, reaction , velocity , &info , options);
break;
}
/* Fixed point projection algorithm */
case SICONOS_FRICTION_3D_FPP:
{
numerics_printf(" ========================== Call Fixed Point Projection (FPP) solver for Friction-Contact 3D problem ==========================\n");
fc3d_fixedPointProjection(problem, reaction , velocity , &info , options);
break;
}
/* Extra Gradient algorithm */
case SICONOS_FRICTION_3D_EG:
{
numerics_printf(" ========================== Call ExtraGradient (EG) solver for Friction-Contact 3D problem ==========================\n");
fc3d_ExtraGradient(problem, reaction , velocity , &info , options);
break;
}
/* VI Fixed Point Projection algorithm */
case SICONOS_FRICTION_3D_VI_FPP:
{
numerics_printf(" ========================== Call VI_FixedPointProjection (VI_FPP) solver for Friction-Contact 3D problem ==========================\n");
fc3d_VI_FixedPointProjection(problem, reaction , velocity , &info , options);
break;
}
/* VI Extra Gradient algorithm */
case SICONOS_FRICTION_3D_VI_EG:
{
numerics_printf(" ========================== Call VI_ExtraGradient (VI_EG) solver for Friction-Contact 3D problem ==========================\n");
fc3d_VI_ExtraGradient(problem, reaction , velocity , &info , options);
break;
}
/* Hyperplane Projection algorithm */
case SICONOS_FRICTION_3D_HP:
{
numerics_printf(" ========================== Call Hyperplane Projection (HP) solver for Friction-Contact 3D problem ==========================\n");
fc3d_HyperplaneProjection(problem, reaction , velocity , &info , options);
break;
}
/* Alart Curnier in local coordinates */
case SICONOS_FRICTION_3D_NSN_AC:
{
numerics_printf(" ========================== Call Alart Curnier solver for Friction-Contact 3D problem ==========================\n");
if (problem->M->matrix0)
{
fc3d_nonsmooth_Newton_AlartCurnier(problem, reaction , velocity , &info , options);
}
else
{
fc3d_nonsmooth_Newton_AlartCurnier(problem, reaction , velocity , &info , options);
}
break;
}
/* Fischer Burmeister in local coordinates */
case SICONOS_FRICTION_3D_NSN_FB:
{
numerics_printf(" ========================== Call Fischer Burmeister solver for Friction-Contact 3D problem ==========================\n");
fc3d_nonsmooth_Newton_FischerBurmeister(problem, reaction , velocity , &info , options);
break;
}
case SICONOS_FRICTION_3D_NSN_NM:
{
numerics_printf(" ========================== Call natural map solver for Friction-Contact 3D problem ==========================\n");
fc3d_nonsmooth_Newton_NaturalMap(problem, reaction , velocity , &info , options);
break;
}
case SICONOS_FRICTION_3D_ONECONTACT_QUARTIC_NU:
case SICONOS_FRICTION_3D_ONECONTACT_QUARTIC:
{
numerics_printf(" ========================== Call Quartic solver for Friction-Contact 3D problem ==========================\n");
fc3d_unitary_enumerative(problem, reaction , velocity , &info , options);
break;
}
case SICONOS_FRICTION_3D_ONECONTACT_NSN:
case SICONOS_FRICTION_3D_ONECONTACT_NSN_GP:
{
numerics_printf(" ========================== Call Newton-based solver for one contact Friction-Contact 3D problem ==========================\n");
fc3d_onecontact_nonsmooth_Newton_solvers_initialize(problem, problem, options);
info = fc3d_onecontact_nonsmooth_Newton_solvers_solve(problem, reaction , options);
break;
}
case SICONOS_FRICTION_3D_ONECONTACT_ProjectionOnConeWithLocalIteration:
{
numerics_printf(" ========================== Call Projection on cone solver for one contact Friction-Contact 3D problem ==========================\n");
fc3d_projectionOnConeWithLocalIteration_initialize(problem, problem, options);
info = fc3d_projectionOnConeWithLocalIteration_solve(problem, reaction , options);
fc3d_projectionOnConeWithLocalIteration_free(problem, problem, options);
break;
}
case SICONOS_FRICTION_3D_GAMS_PATH:
{
numerics_printf(" ========================== Call PATH solver via GAMS for an AVI Friction-Contact 3D problem ==========================\n");
fc3d_AVI_gams_path(problem, reaction , velocity, &info, options);
break;
}
case SICONOS_FRICTION_3D_GAMS_PATHVI:
{
numerics_printf(" ========================== Call PATHVI solver via GAMS for an AVI Friction-Contact 3D problem ==========================\n");
fc3d_AVI_gams_pathvi(problem, reaction , velocity, &info, options);
break;
}
case SICONOS_FRICTION_3D_GAMS_LCP_PATH:
{
numerics_printf(" ========================== Call PATH solver via GAMS for an LCP-based reformulation of the AVI Friction-Contact 3D problem ==========================\n");
fc3d_lcp_gams_path(problem, reaction , velocity, &info, options);
break;
}
case SICONOS_FRICTION_3D_GAMS_LCP_PATHVI:
{
numerics_printf(" ========================== Call PATHVI solver via GAMS for an LCP-based reformulation of the AVI Friction-Contact 3D problem ==========================\n");
fc3d_lcp_gams_pathvi(problem, reaction , velocity, &info, options);
break;
}
default:
{
fprintf(stderr, "Numerics, fc3d_driver failed. Unknown solver.\n");
exit(EXIT_FAILURE);
}
}
exit:
return info;
}