int fc3d_VI_FixedPointProjection_setDefaultSolverOptions(SolverOptions* options)
{
if (verbose > 0)
{
printf("Set the Default SolverOptions for the FixedPointProjection Solver\n");
}
/*strcpy(options->solverName,"DSFP");*/
options->solverId = SICONOS_FRICTION_3D_VI_FPP;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 8;
options->dSize = 8;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->iparam[0] = 20000;
options->dparam[0] = 1e-3;
options->dparam[3] = 1e-3;
options->dparam[3] = -1.0; // rho is variable by default
options->internalSolvers = NULL;
return 0;
}
int linearComplementarity_latin_setDefaultSolverOptions(SolverOptions* options)
{
int i;
if (verbose > 0)
{
printf("Set the Default SolverOptions for the Latin Solver\n");
}
options->solverId = SICONOS_LCP_LATIN;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 5;
options->dSize = 5;
options->iparam = (int *)malloc(options->iSize * sizeof(int));
options->dparam = (double *)malloc(options->dSize * sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
for (i = 0; i < 5; i++)
{
options->iparam[i] = 0;
options->dparam[i] = 0.0;
}
options->iparam[0] = 1000;
options->dparam[0] = 1e-4;
options->dparam[2] = 0.3;
options->dparam[3] = 1.0;
return 0;
}
int fc3d_Panagiotopoulos_FixedPoint_setDefaultSolverOptions(SolverOptions* options)
{
numerics_printf("fc3d_Panagiotopoulos_FixedPoint_setDefaultSolverOptions", "set default options");
options->solverId = SICONOS_FRICTION_3D_PFP;
options->numberOfInternalSolvers = 1;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 8;
options->dSize = 8;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
solver_options_nullify(options);
options->iparam[SICONOS_IPARAM_MAX_ITER] = 1000;
options->iparam[SICONOS_FRICTION_3D_IPARAM_INTERNAL_ERROR_STRATEGY] = SICONOS_FRICTION_3D_INTERNAL_ERROR_STRATEGY_ADAPTIVE;
options->dparam[SICONOS_DPARAM_TOL] = 1e-4;
options->dparam[SICONOS_FRICTION_3D_DPARAM_INTERNAL_ERROR_RATIO] =10.0;
options->numberOfInternalSolvers=2;
options->internalSolvers = (SolverOptions *)malloc(options->numberOfInternalSolvers*sizeof(SolverOptions));
linearComplementarity_pgs_setDefaultSolverOptions(&options->internalSolvers[0]);
options->internalSolvers[0].iparam[SICONOS_IPARAM_MAX_ITER] =1000;
convexQP_VI_solver_setDefaultSolverOptions(&options->internalSolvers[1]);
options->internalSolvers[1].iparam[SICONOS_IPARAM_MAX_ITER] =1000;
/* convexQP_ProjectedGradient_setDefaultSolverOptions(&options->internalSolvers[1]); */
/* options->internalSolvers[1].iparam[SICONOS_IPARAM_MAX_ITER] =1000; */
return 0;
}
int variationalInequality_common_setDefaultSolverOptions(SolverOptions* options, int solverId)
{
int i;
if (verbose > 0)
{
printf("Set the Default SolverOptions for a VI Solver\n");
}
options->solverId = solverId;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 8;
options->dSize = 8;
options->iparam = (int *)malloc(options->iSize * sizeof(int));
options->dparam = (double *)malloc(options->dSize * sizeof(double));
solver_options_nullify(options);
for (i = 0; i < 8; i++)
{
options->iparam[i] = 0;
options->dparam[i] = 0.0;
}
options->iparam[0] = 1000;
options->dparam[0] = 1e-10;
options->internalSolvers = NULL;
return 0;
}
int linearComplementarity_qp_setDefaultSolverOptions(SolverOptions* options)
{
int i;
if (verbose > 0)
{
printf("Set the Default SolverOptions for the QP Solver\n");
}
/* strcpy(options->solverName,"QP");*/
options->solverId = SICONOS_LCP_QP;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 5;
options->dSize = 5;
options->iparam = (int *)malloc(options->iSize * sizeof(int));
options->dparam = (double *)malloc(options->dSize * sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
for (i = 0; i < 5; i++)
{
options->iparam[i] = 0;
options->dparam[i] = 0.0;
}
options->dparam[0] = 1e-6;
return 0;
}
int relay_path_setDefaultSolverOptions(SolverOptions* options)
{
#ifdef HAVE_PATHFERRIS
// int i;
if (verbose > 0)
{
printf("Set the Default SolverOptions for the PATH Solver\n");
}
/* strcpy(options->solverName,"PATH");*/
options->solverId = SICONOS_RELAY_PATH;
options->numberOfInternalSolvers = 0;
options->internalSolvers = NULL;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 2;
options->dSize = 2;
options->iparam = (int *)malloc(options->iSize * sizeof(int));
options->dparam = (double *)malloc(options->dSize * sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->dparam[0] = 1e-8;
options->dparam[1] = 1.0;
#endif /*HAVE_PATHFERRIS*/
return 0;
}
int fc3d_HyperplaneProjection_setDefaultSolverOptions(SolverOptions* options)
{
if (verbose > 0)
{
printf("Set the Default SolverOptions for the HyperplaneProjection Solver\n");
}
/*strcpy(options->solverName,"DSFP");*/
options->solverId = SICONOS_FRICTION_3D_HP;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 8;
options->dSize = 8;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->iparam[0] = 2000000;
options->iparam[1] = 50;
options->dparam[0] = 1e-3;
options->dparam[3] = 1.0;
options->dparam[4] = 0.99;
options->internalSolvers = NULL;
return 0;
}
int fc3d_nonsmooth_Newton_FischerBurmeister_setDefaultSolverOptions(
SolverOptions* options)
{
if (verbose > 0)
{
printf("Set the default solver options for the NSN_FB Solver\n");
}
options->solverId = SICONOS_FRICTION_3D_NSN_FB;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 14;
options->dSize = 14;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->iparam[0] = 200;
options->iparam[1] = 1;
options->iparam[3] = 100000; /* nzmax*/
options->iparam[5] = 1;
options->iparam[7] = 1; /* erritermax */
options->dparam[0] = 1e-3;
options->dparam[3] = 1; /* default rho */
options->iparam[8] = -1; /* mpi com fortran */
options->iparam[10] = 0;
options->iparam[11] = 0; /* 0 GoldsteinPrice line search, 1 FBLSA */
options->iparam[12] = 100; /* max iter line search */
#ifdef WITH_MUMPS
options->iparam[13] = 1;
#else
options->iparam[13] = 0; /* Linear solver used at each Newton iteration. 0: cs_lusol, 1 mumps */
#endif
options->internalSolvers = NULL;
#ifdef HAVE_MPI
options->solverData = MPI_COMM_NULL;
#endif
return 0;
}
void siconos_io(Archive& ar, SolverOptions&v, unsigned int version)
{
SERIALIZE(v, (solverId)(isSet)(iSize)(dSize)(filterOn)(numberOfInternalSolvers), ar);
if (Archive::is_loading::value)
{
solver_options_nullify(&v);
v.iparam = (int *) malloc(v.iSize * sizeof(int));
v.dparam = (double *) malloc(v.dSize * sizeof(double));
v.internalSolvers = (SolverOptions *) malloc(v.numberOfInternalSolvers * sizeof(SolverOptions));
v.callback = (Callback *) malloc(sizeof(Callback));
}
SERIALIZE(v, (callback), ar);
SERIALIZE_C_ARRAY(v.iSize, v, iparam, ar);
SERIALIZE_C_ARRAY(v.dSize, v, dparam, ar);
SERIALIZE_C_ARRAY(v.numberOfInternalSolvers, v, internalSolvers, ar);
}
void mixedLinearComplementarity_deleteDefaultSolverOptions(MixedLinearComplementarityProblem* problem, SolverOptions* pOptions)
{
if (pOptions->iparam)
free(pOptions->iparam);
if (pOptions->dparam)
free(pOptions->dparam);
if (pOptions->iWork)
free(pOptions->iWork);
if (pOptions->dWork)
free(pOptions->dWork);
// FP : I comment the lines below, that results in failures
// in some test-GMP-REDUCED3_3D_QUARTIC-GMP.
// Todo : fix this ...
//if (pOptions->callback)
// free(pOptions->callback);
solver_options_nullify(pOptions);
}
int fc3d_nonsmooth_Newton_AlartCurnier_setDefaultSolverOptions(
SolverOptions* options)
{
if (verbose > 0)
{
printf("Set the default solver options for the NSN_AC Solver\n");
}
options->solverId = SICONOS_FRICTION_3D_NSN_AC;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 20;
options->dSize = 20;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->iparam[SICONOS_IPARAM_MAX_ITER] = 200;
options->iparam[3] = 100000; /* nzmax*/
options->iparam[5] = 1;
options->iparam[SICONOS_FRICTION_3D_IPARAM_ERROR_EVALUATION] = 1; /* erritermax */
options->dparam[SICONOS_DPARAM_TOL] = 1e-3;
options->iparam[SICONOS_FRICTION_3D_NSN_RHO_STRATEGY] = SICONOS_FRICTION_3D_NSN_FORMULATION_RHO_STRATEGY_SPECTRAL_NORM;
options->dparam[SICONOS_FRICTION_3D_NSN_RHO] = 1; /* default rho */
options->iparam[8] = -1; /* mpi com fortran */
options->iparam[SICONOS_FRICTION_3D_NSN_FORMULATION] = SICONOS_FRICTION_3D_NSN_FORMULATION_ALARTCURNIER_GENERATED;
/* 0 STD AlartCurnier, 1 JeanMoreau, 2 STD generated, 3 JeanMoreau generated */
options->iparam[SICONOS_FRICTION_3D_NSN_LINESEARCH] = SICONOS_FRICTION_3D_NSN_LINESEARCH_GOLDSTEINPRICE; /* 0 GoldsteinPrice line search, 1 FBLSA */
options->iparam[SICONOS_FRICTION_3D_NSN_LINESEARCH_MAXITER] = 100; /* max iter line search */
#ifdef WITH_MUMPS
options->iparam[13] = 1;
#else
options->iparam[13] = 0; /* Linear solver used at each Newton iteration. 0: cs_lusol, 1 mumps */
#endif
options->internalSolvers = NULL;
return 0;
}
int rolling_fc3d_setDefaultSolverOptions(SolverOptions* options, int solverId)
{
solver_options_nullify(options);
int info = -1;
switch (solverId)
{
case SICONOS_ROLLING_FRICTION_3D_NSGS:
{
info = rolling_fc3d_nsgs_setDefaultSolverOptions(options);
break;
}
default:
{
solver_options_set(options, solverId);
}
}
return info;
}
int fc2d_lexicolemke_setDefaultSolverOptions(SolverOptions* options)
{
if (verbose > 0)
{
printf("Set the Default SolverOptions for the Lemke Solver for fc2d\n");
}
/* strcpy(options->solverName,"Lemke");*/
options->solverId = SICONOS_FRICTION_2D_LEMKE;
options->numberOfInternalSolvers = 1;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 5;
options->dSize = 5;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->dparam[0] = 1e-6;
options->internalSolvers = (SolverOptions *)malloc(sizeof(SolverOptions));
linearComplementarity_lexicolemke_setDefaultSolverOptions(options->internalSolvers);
return 0;
}
int fc2d_cpg_setDefaultSolverOptions(SolverOptions *options)
{
if (verbose > 0)
{
printf("Set the Default SolverOptions for the CPG Solver\n");
}
/* strcpy(options->solverName,"CPG");*/
options->solverId = SICONOS_FRICTION_2D_CPG;
options->numberOfInternalSolvers = 0;
options->isSet = 1;
options->filterOn = 1;
options->iSize = 5;
options->dSize = 5;
options->iparam = (int *)calloc(options->iSize, sizeof(int));
options->dparam = (double *)calloc(options->dSize, sizeof(double));
options->dWork = NULL;
solver_options_nullify(options);
options->iparam[0] = 1000;
options->dparam[0] = 1e-4;
options ->internalSolvers = NULL;
return 0;
}
void mixedLinearComplementarity_default_setDefaultSolverOptions(MixedLinearComplementarityProblem* problem, SolverOptions* pOptions)
{
pOptions->isSet = 0;
pOptions->iSize = 10;
pOptions->iparam = 0;
pOptions->dSize = 10;
pOptions->dparam = 0;
pOptions->filterOn = 0;
pOptions->dWork = 0;
pOptions->iWork = 0;
pOptions->iparam = (int*)malloc(10 * sizeof(int));
pOptions->dparam = (double*)malloc(10 * sizeof(double));
pOptions->numberOfInternalSolvers = 0;
solver_options_nullify(pOptions);
pOptions->dparam[0] = 10 - 7;
/*default number of it*/
pOptions->iparam[0] = 1000;
/*enum case : do not use dgels*/
pOptions->iparam[4] = 0;
pOptions->iparam[5] = 3; /*Number of registered configurations*/
pOptions->iparam[8] = 0; /*Prb nedd a update*/
pOptions->dparam[5] = 1e-12; /*tol used by direct solver to check complementarity*/
pOptions->dparam[6] = 1e-12; /*tol for direct solver to determinate if a value is positive*/
int sizeOfIwork = mlcp_driver_get_iwork(problem, pOptions);
if (sizeOfIwork)
pOptions->iWork = (int*)malloc(sizeOfIwork * sizeof(int));
int sizeOfDwork = mlcp_driver_get_dwork(problem, pOptions);
if (sizeOfDwork)
pOptions->dWork = (double*)malloc(sizeOfDwork * sizeof(double));
}
int variationalInequality_setDefaultSolverOptions(SolverOptions* options, int solverId)
{
solver_options_nullify(options);
int info = -1;
switch (solverId)
{
case SICONOS_VI_EG:
{
info = variationalInequality_ExtraGradient_setDefaultSolverOptions(options);
break;
}
case SICONOS_VI_FPP:
{
info = variationalInequality_FixedPointProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_VI_HP:
{
info = variationalInequality_HyperplaneProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_VI_BOX_QI:
{
info = variationalInequality_common_setDefaultSolverOptions(options, solverId);
break;
}
default:
{
numerics_error("variationalInequality_setDefaultSolverOptions", "Unknown Solver");
}
}
return info;
}
int soclcp_setDefaultSolverOptions(SolverOptions* options, int solverId)
{
options->iparam = NULL;
options->dparam = NULL;
solver_options_nullify(options);
int info = -1;
switch(solverId)
{
case SICONOS_SOCLCP_NSGS:
{
info = soclcp_nsgs_setDefaultSolverOptions(options);
break;
}
/* case SICONOS_SOCLCP_NSGSV: */
/* { */
/* info = soclcp_nsgs_velocity_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_*/
/* { */
/* info = soclcp_proximal_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_TFP: */
/* { */
/* info = soclcp_TrescaFixedPoint_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_DSFP: */
/* { */
/* info = soclcp_DeSaxceFixedPoint_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_FPP: */
/* { */
/* info = soclcp_fixedPointProjection_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_EG: */
/* { */
/* info = soclcp_ExtraGradient_setDefaultSolverOptions(options); */
/* break; */
/* } */
case SICONOS_SOCLCP_VI_FPP:
{
info = soclcp_VI_FixedPointProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_SOCLCP_VI_EG:
{
info = soclcp_VI_ExtraGradient_setDefaultSolverOptions(options);
break;
}
/* case SICONOS_SOCLCP_HP: */
/* { */
/* info = soclcp_HyperplaneProjection_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_NSN_AC: */
/* { */
/* info = soclcp_AlartCurnier_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_NSN_FB: */
/* { */
/* info = soclcp_FischerBurmeister_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_QUARTIC: */
/* { */
/* info = soclcp_unitary_enumerative_setDefaultSolverOptions(options); */
/* break; */
/* } */
/* case SICONOS_SOCLCP_QUARTIC_NU: */
/* { */
/* info = soclcp_unitary_enumerative_setDefaultSolverOptions(options); */
/* options->solverId = SICONOS_SOCLCP_QUARTIC_NU; */
/* break; */
/* } */
default:
{
numerics_error("soclcp_setDefaultSolverOptions", "Unknown Solver");
}
}
return info;
}
int mixedLinearComplementarity_setDefaultSolverOptions(MixedLinearComplementarityProblem* problem, SolverOptions* pOptions)
{
solver_options_nullify(pOptions);
int info = -1;
switch (pOptions->solverId)
{
case SICONOS_MLCP_DIRECT_ENUM:
{
info = mixedLinearComplementarity_directEnum_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_PATH_ENUM:
{
info = mixedLinearComplementarity_pathEnum_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_DIRECT_PATH_ENUM:
{
info = mixedLinearComplementarity_directPathEnum_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_DIRECT_SIMPLEX:
{
info = mixedLinearComplementarity_directSimplex_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_DIRECT_PATH:
{
info = mixedLinearComplementarity_directPath_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_DIRECT_FB:
{
info = mixedLinearComplementarity_directFB_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_SIMPLEX:
{
info = mixedLinearComplementarity_simplex_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_PGS:
{
info = mixedLinearComplementarity_pgs_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_PGS_SBM:
{
info = mixedLinearComplementarity_pgs_SBM_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_RPGS:
{
info = mixedLinearComplementarity_rpgs_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_RPSOR:
{
info = mixedLinearComplementarity_rpsor_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_PATH:
{
info = mixedLinearComplementarity_path_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_ENUM:
{
info = mixedLinearComplementarity_enum_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_FB:
{
info = mixedLinearComplementarity_fb_setDefaultSolverOptions(problem, pOptions);
break;
}
case SICONOS_MLCP_PSOR:
{
info = mixedLinearComplementarity_psor_setDefaultSolverOptions(problem, pOptions);
break;
}
default:
{
numerics_error("mixedLinearComplementarity_setDefaultSolverOptions", "Unknown Solver");
}
}
return info;
}
int fc3d_setDefaultSolverOptions(SolverOptions* options, int solverId)
{
solver_options_nullify(options);
int info = -1;
switch (solverId)
{
case SICONOS_FRICTION_3D_NSGS:
{
info = fc3d_nsgs_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_NSGSV:
{
info = fc3d_nsgs_velocity_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_PROX:
{
info = fc3d_proximal_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_TFP:
{
info = fc3d_TrescaFixedPoint_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_ACLMFP:
{
info = fc3d_ACLMFixedPoint_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_SOCLCP:
{
info = fc3d_SOCLCP_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_DSFP:
{
info = fc3d_DeSaxceFixedPoint_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_FPP:
{
info = fc3d_fixedPointProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_EG:
{
info = fc3d_ExtraGradient_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_VI_FPP:
{
info = fc3d_VI_FixedPointProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_VI_EG:
{
info = fc3d_VI_ExtraGradient_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_HP:
{
info = fc3d_HyperplaneProjection_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_NSN_AC:
{
info = fc3d_nonsmooth_Newton_AlartCurnier_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_NSN_FB:
{
info = fc3d_nonsmooth_Newton_FischerBurmeister_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_NSN_NM:
{
info = fc3d_nonsmooth_Newton_NaturalMap_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_ONECONTACT_QUARTIC:
{
info = fc3d_unitary_enumerative_setDefaultSolverOptions(options);
break;
}
case SICONOS_FRICTION_3D_ONECONTACT_QUARTIC_NU:
{
info = fc3d_unitary_enumerative_setDefaultSolverOptions(options);
options->solverId = SICONOS_FRICTION_3D_ONECONTACT_QUARTIC_NU;
break;
}
default:
{
solver_options_set(options, solverId);
}
}
return info;
}
