int main (int argc, char *argv[])
{
int status;
char sysdir[GMS_SSSIZE], msg[GMS_SSSIZE];
const char defsysdir[] = "c:\\Program Files\\GAMS23.5";
if (argc > 1) {
if(strlen(argv[1]) >= GMS_SSSIZE) {
printf("*** Your system directory (argument 1) cannot exceed 255 characters\n");
exit(1);
}
strncpy(sysdir, argv[1], sizeof(sysdir));
}
else
strncpy(sysdir, defsysdir, sizeof(sysdir));
printf("Loading objects from GAMS system directory: %s\n", sysdir);
/* Create objects */
if (! gamsxCreateD (&Gptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gamsx object: %s\n", msg);
return 1;
}
if (! gdxCreateD (&Xptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gdx object: %s\n", msg);
return 1;
}
if (! optCreateD (&Optr, sysdir, msg, sizeof(msg))) {
printf("Could not create opt object: %s\n", msg);
return 1;
}
if ((status=WriteModelData("demanddata.gdx"))) {
printf("Model data not written\n");
goto TERMINATE;
}
if ((status=CallGams(sysdir))) {
printf("Call to GAMS failed\n");
goto TERMINATE;
}
if ((status=ReadSolutionData("results.gdx"))) {
printf("Could not read solution back\n");
goto TERMINATE;
}
TERMINATE:
optFree(&Optr);
gdxFree(&Xptr);
gamsxFree(&Gptr);
return status;
}
void lcp_gams(LinearComplementarityProblem* problem, double *z, double *w, int *info, SolverOptions* options)
{
assert(problem);
assert(problem->size > 0);
assert(problem->M);
assert(problem->q);
/* Handles to the GAMSX, GDX, and Option objects */
gamsxHandle_t Gptr = NULL;
idxHandle_t Xptr = NULL;
optHandle_t Optr = NULL;
optHandle_t solverOptPtr = NULL;
int status = 0;
char sysdir[GMS_SSSIZE], model[GMS_SSSIZE], msg[GMS_SSSIZE];
const char defModel[] = SPACE_CONC(GAMS_MODELS_SHARE_DIR, "/lcp.gms");
const char defGAMSdir[] = GAMS_DIR;
SN_Gams_set_dirs(options->solverParameters, defModel, defGAMSdir, model, sysdir, "/lcp.gms");
/* Create objects */
if (! gamsxCreateD (&Gptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gamsx object: %s\n", msg);
return;
}
if (! idxCreateD (&Xptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gdx object: %s\n", msg);
return;
}
if (! optCreateD (&solverOptPtr, sysdir, msg, sizeof(msg))) {
printf("Could not create solver opt object: %s\n", msg);
return;
}
if (! optCreateD (&Optr, sysdir, msg, sizeof(msg))) {
printf("Could not create opt object: %s\n", msg);
return;
}
char gdxFileName[GMS_SSSIZE];
char solFileName[GMS_SSSIZE];
const char* base_name = GAMSP_get_filename(options->solverParameters);
if (base_name)
{
strncpy(gdxFileName, base_name, sizeof(gdxFileName));
}
else
{
strncpy(gdxFileName, "lcp", sizeof(gdxFileName));
}
strncpy(solFileName, gdxFileName, sizeof(solFileName));
strncat(solFileName, "_sol", sizeof(solFileName));
strncat(gdxFileName, ".gdx", sizeof(gdxFileName));
strncat(solFileName, ".gdx", sizeof(solFileName));
getGamsOpt(Optr, sysdir);
optSetStrStr(Optr, "User1", gdxFileName);
optSetStrStr(Optr, "User2", solFileName);
getGamsSolverOpt(solverOptPtr, sysdir, "path");
optSetDblStr(solverOptPtr, "convergence_tolerance", options->dparam[0]);
optWriteParameterFile(solverOptPtr, "path.opt");
idxOpenWrite(Xptr, gdxFileName, "Siconos/Numerics NM_to_GDX", &status);
if (status)
idxerror(status, "idxOpenWrite");
if ((status=NM_to_GDX(Xptr, "M", "M matrix", problem->M))) {
printf("Model data not written\n");
goto TERMINATE;
}
if ((status=NV_to_GDX(Xptr, "q", "q vector", problem->q, problem->size))) {
printf("Model data not written\n");
goto TERMINATE;
}
if (idxClose(Xptr))
idxerror(idxGetLastError(Xptr), "idxClose");
if ((status=CallGams(Gptr, Optr, sysdir, model))) {
printf("Call to GAMS failed\n");
goto TERMINATE;
}
/************************************************
* Read back solution
************************************************/
idxOpenRead(Xptr, solFileName, &status);
if (status)
idxerror(status, "idxOpenRead");
if ((status=GDX_to_NV(Xptr, "sol", z, problem->size))) {
printf("Model data not read\n");
goto TERMINATE;
}
if (idxClose(Xptr))
idxerror(idxGetLastError(Xptr), "idxClose");
TERMINATE:
optFree(&Optr);
optFree(&solverOptPtr);
idxFree(&Xptr);
gamsxFree(&Gptr);
*info = status;
}
static int globalFrictionContact3D_AVI_gams_base(GlobalFrictionContactProblem* problem, double *reaction, double *velocity, SolverOptions* options, const char* solverName)
{
assert(problem);
assert(problem->numberOfContacts > 0);
assert(problem->M);
assert(problem->q);
/* Handles to the GAMSX, GDX, and Option objects */
gamsxHandle_t Gptr = NULL;
idxHandle_t Xptr = NULL;
optHandle_t Optr = NULL;
optHandle_t solverOptPtr = NULL;
int status;
char sysdir[GMS_SSSIZE], model[GMS_SSSIZE], msg[GMS_SSSIZE];
const char defModel[] = SPACE_CONC(GAMS_MODELS_SHARE_DIR, "/fc_vi.gms");
const char defGAMSdir[] = GAMS_DIR;
int size = problem->dimension*problem->numberOfContacts;
NumericsMatrix Htmat;
fillNumericsMatrix(&Htmat, NM_SPARSE, problem->H->size0, problem->H->size1, NULL);
SN_Gams_set_dirs(options->solverParameters, defModel, defGAMSdir, model, sysdir, "/fc_vi.gms");
/* Create objects */
if (! gamsxCreateD (&Gptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gamsx object: %s\n", msg);
return 1;
}
if (! idxCreateD (&Xptr, sysdir, msg, sizeof(msg))) {
printf("Could not create gdx object: %s\n", msg);
return 1;
}
if (! optCreateD (&Optr, sysdir, msg, sizeof(msg))) {
printf("Could not create opt object: %s\n", msg);
return 1;
}
if (! optCreateD (&solverOptPtr, sysdir, msg, sizeof(msg))) {
printf("Could not create opt object: %s\n", msg);
return 1;
}
getGamsSolverOpt(solverOptPtr, sysdir, solverName);
optSetDblStr(solverOptPtr, "convergence_tolerance", options->dparam[0]);
// strncpy(msg, "./", sizeof(deffile));
strncpy(msg, solverName, sizeof(msg));
strncat(msg, ".opt", sizeof(msg));
optWriteParameterFile(solverOptPtr, msg);
FILE* f = fopen("jams.opt", "w");
if (f)
{
char contents[] = "subsolveropt 1";
fprintf(f, contents);
fclose(f);
}
else
{
printf("Failed to create jams.opt!\n");
}
getGamsOpt(Optr, sysdir);
if (strcmp(solverName, "path"))
{
optSetStrStr(Optr, "emp", solverName);
}
idxOpenWrite(Xptr, "fc3d_avi.gdx", "Siconos/Numerics NM_to_GDX", &status);
if (status)
idxerrorR(status, "idxOpenWrite");
DEBUG_PRINT("GFC3D_AVI_GAMS :: fc3d_avi.gdx opened");
if ((status=NM_to_GDX(Xptr, "M", "M matrix", problem->M))) {
printf("Model data not written\n");
goto TERMINATE;
}
DEBUG_PRINT("FC3D_AVI_GAMS :: M matrix written");
if ((status=NM_to_GDX(Xptr, "H", "H matrix", problem->H))) {
printf("Model data not written\n");
goto TERMINATE;
}
DEBUG_PRINT("FC3D_AVI_GAMS :: H matrix written");
NM_copy_to_sparse(problem->H, &Htmat);
cs_fkeep(NM_csc(&Htmat), &SN_rm_normal_part, NULL);
cblas_dcopy(size, problem->b, 1, reaction, 1);
for (unsigned i = 0; i < size; i += 3)
{
reaction[i] = 0.;
}
if ((status=NM_to_GDX(Xptr, "Ht", "Ht matrix", &Htmat))) {
printf("Model data not written\n");
goto TERMINATE;
}
if ((status=NV_to_GDX(Xptr, "q", "q vector", problem->q, size))) {
printf("Model data not written\n");
goto TERMINATE;
}
if ((status=NV_to_GDX(Xptr, "b", "b vector", problem->b, size))) {
printf("Model data not written\n");
goto TERMINATE;
}
if ((status=NV_to_GDX(Xptr, "bt", "bt vector", reaction, size))) {
printf("Model data not written\n");
goto TERMINATE;
}
if (idxClose(Xptr))
idxerrorR(idxGetLastError(Xptr), "idxClose");
if ((status=CallGams(Gptr, Optr, sysdir, model))) {
printf("Call to GAMS failed\n");
goto TERMINATE;
}
/************************************************
* Read back solution
************************************************/
idxOpenRead(Xptr, "fc3d_avi_sol.gdx", &status);
if (status)
idxerrorR(status, "idxOpenRead");
if ((status=GDX_to_NV(Xptr, "reaction", reaction, size))) {
printf("Model data not read\n");
goto TERMINATE;
}
if ((status=GDX_to_NV(Xptr, "velocities", reaction, size))) {
printf("Model data not read\n");
goto TERMINATE;
}
if (idxClose(Xptr))
idxerrorR(idxGetLastError(Xptr), "idxClose");
TERMINATE:
optFree(&Optr);
optFree(&solverOptPtr);
idxFree(&Xptr);
gamsxFree(&Gptr);
freeNumericsMatrix(&Htmat);
return status;
}
