void ncp_newton_FBLSA(NonlinearComplementarityProblem* problem, double *z, double* F, int *info, SolverOptions* options)
{
functions_LSA functions_FBLSA_ncp;
init_lsa_functions(&functions_FBLSA_ncp, &FB_compute_F_ncp, &ncp_FB);
functions_FBLSA_ncp.compute_H = &FB_compute_H_ncp;
functions_FBLSA_ncp.compute_error = &FB_compute_error_ncp;
set_lsa_params_data(options, problem->nabla_F);
newton_LSA(problem->n, z, F, info, (void *)problem, options, &functions_FBLSA_ncp);
}
void mlcp_newton_FB(MixedLinearComplementarityProblem* problem, double *z, double *w, int *info , SolverOptions* options)
{
functions_LSA functions_FBLSA_mlcp;
init_lsa_functions(&functions_FBLSA_mlcp, &FB_compute_F_mlcp, (compute_F_merit_ptr)&mlcp_FB);
functions_FBLSA_mlcp.compute_H = &FB_compute_H_mlcp;
functions_FBLSA_mlcp.compute_error = &FB_compute_error_mlcp;
set_lsa_params_data(options, problem->M);
newton_LSA(problem->n + problem->m, z, w, info, (void *)problem, options, &functions_FBLSA_mlcp);
}
void mcp_newton_FBLSA(MixedComplementarityProblem2* problem, double *z, double* Fmcp, int *info , SolverOptions* options)
{
functions_LSA functions_FBLSA_mcp;
init_lsa_functions(&functions_FBLSA_mcp, &FB_compute_F_mcp, &mcp_FB);
functions_FBLSA_mcp.compute_H = &FB_compute_H_mcp;
functions_FBLSA_mcp.compute_error = &FB_compute_error_mcp;
set_lsa_params_data(options, problem->nabla_Fmcp);
newton_LSA(problem->n1 + problem->n2, z, Fmcp, info, (void *)problem, options, &functions_FBLSA_mcp);
}
void lcp_newton_minFB(LinearComplementarityProblem* problem, double *z, double *w, int *info , SolverOptions* options)
{
functions_LSA functions_minFBLSA_lcp;
init_lsa_functions(&functions_minFBLSA_lcp, &FB_compute_F_lcp, &lcp_FB);
functions_minFBLSA_lcp.compute_H = &FB_compute_H_lcp;
functions_minFBLSA_lcp.compute_error = &FB_compute_error_lcp;
functions_minFBLSA_lcp.compute_RHS_desc = &lcp_min;
functions_minFBLSA_lcp.compute_H_desc = &min_compute_H_lcp;
set_lsa_params_data(options, problem->M);
newton_LSA(problem->size, z, w, info, (void *)problem, options, &functions_minFBLSA_lcp);
}
void fc3d_nonsmooth_Newton_AlartCurnier2(
FrictionContactProblem* problem,
double *reaction,
double *velocity,
int *info,
SolverOptions *options)
{
assert(problem);
assert(reaction);
assert(velocity);
assert(info);
assert(options);
assert(problem->dimension == 3);
assert(options->iparam);
assert(options->dparam);
assert(problem->q);
assert(problem->mu);
assert(problem->M);
assert(!options->iparam[4]); // only host
AlartCurnierParams acparams;
switch (options->iparam[10])
{
case 0:
{
acparams.computeACFun3x3 = &computeAlartCurnierSTD;
break;
}
case 1:
{
acparams.computeACFun3x3 = &computeAlartCurnierJeanMoreau;
break;
};
case 2:
{
acparams.computeACFun3x3 = &fc3d_AlartCurnierFunctionGenerated;
break;
}
case 3:
{
acparams.computeACFun3x3 = &fc3d_AlartCurnierJeanMoreauFunctionGenerated;
break;
}
}
fc3d_nonsmooth_Newton_solvers equation;
equation.problem = problem;
equation.data = (void *) &acparams;
equation.function = &nonsmoothEqnAlartCurnierFun;
/*************************************************************************
* START NEW STUFF
*/
size_t problemSize = problem->M->size0;
size_t _3problemSize = problemSize + problemSize + problemSize;
FC3D_Newton_data opaque_data;
opaque_data.problem = problem;
opaque_data.equation = &equation;
opaque_data.rho = (double*)calloc(problemSize, sizeof(double));
for (size_t i = 0; i < problemSize; ++i) opaque_data.rho[i] = 1.;
opaque_data.Ax = (double*)calloc(_3problemSize, sizeof(double));
opaque_data.Bx = (double*)calloc(_3problemSize, sizeof(double));
opaque_data.normq = cblas_dnrm2(problemSize, problem->q, 1);
opaque_data.AwpB_data_computed = false;
functions_LSA functions_AC;
init_lsa_functions(&functions_AC, &FC3D_compute_F, &FC3D_compute_F_merit);
functions_AC.compute_H = &FC3D_compute_AWpB;
functions_AC.compute_error = &FC3D_compute_error;
functions_AC.get_set_from_problem_data = NULL;
set_lsa_params_data(options, problem->M);
newton_LSA_param* params = (newton_LSA_param*) options->solverParameters;
params->check_dir_quality = false;
options->iparam[SICONOS_IPARAM_LSA_SEARCH_CRITERION] = SICONOS_LSA_GOLDSTEIN;
// options->iparam[SICONOS_IPARAM_LSA_SEARCH_CRITERION] = SICONOS_LSA_ARMIJO;
/*************************************************************************
* END NEW STUFF
*/
if(options->iparam[SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY] == SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY_VI_EG_NSN)
{
SolverOptions * options_vi_eg =(SolverOptions *)malloc(sizeof(SolverOptions));
fc3d_VI_ExtraGradient_setDefaultSolverOptions(options_vi_eg);
options_vi_eg->iparam[0] = 50;
options_vi_eg->dparam[0] = sqrt(options->dparam[0]);
options_vi_eg->iparam[SICONOS_VI_IPARAM_ERROR_EVALUATION] = SICONOS_VI_ERROR_EVALUATION_LIGHT;
fc3d_VI_ExtraGradient(problem, reaction , velocity , info , options_vi_eg);
solver_options_delete(options_vi_eg);
free(options_vi_eg);
newton_LSA(problemSize, reaction, velocity, info, (void *)&opaque_data, options, &functions_AC);
}
else if (options->iparam[SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY] == SICONOS_FRICTION_3D_NSN_HYBRID_STRATEGY_NO)
{
newton_LSA(problemSize, reaction, velocity, info, (void *)&opaque_data, options, &functions_AC);
}
else
{
numerics_error("fc3d_nonsmooth_Newton_AlartCurnier","Unknown nsn hybrid solver");
}
free(opaque_data.rho);
free(opaque_data.Ax);
free(opaque_data.Bx);
}