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;
}
int SN_gams_solve(unsigned iter, optHandle_t Optr, char* sysdir, char* model, const char* base_name, SolverOptions* options, SN_GAMS_gdx* gdx_data)
{
assert(gdx_data);
SN_GAMS_NM_gdx* mat_for_gdx = gdx_data->mat_for_gdx;
SN_GAMS_NV_gdx* vec_for_gdx = gdx_data->vec_for_gdx;
SN_GAMS_NV_gdx* vec_from_gdx = gdx_data->vec_from_gdx;
char msg[GMS_SSSIZE];
int status;
gamsxHandle_t Gptr = NULL;
idxHandle_t Xptr = NULL;
gmoHandle_t gmoPtr = NULL;
double infos[4] = {0.};
/* Create objects */
DEBUG_PRINT("FC3D_AVI_GAMS :: creating gamsx object\n");
if (! gamsxCreateD (&Gptr, sysdir, msg, sizeof(msg))) {
fprintf(stderr, "Could not create gamsx object: %s\n", msg);
return 1;
}
DEBUG_PRINT("FC3D_AVI_GAMS :: creating gdx object\n");
if (! idxCreateD (&Xptr, sysdir, msg, sizeof(msg))) {
fprintf(stderr, "Could not create gdx object: %s\n", msg);
return 1;
}
DEBUG_PRINT("FC3D_AVI_GAMS :: creating gmo object\n");
if (! gmoCreateD (&gmoPtr, sysdir, msg, sizeof(msg))) {
fprintf(stderr, "Could not create gmo object: %s\n", msg);
return 1;
}
/* create input and output gdx names*/
char gdxFileName[GMS_SSSIZE];
char solFileName[GMS_SSSIZE];
// char paramFileName[GMS_SSSIZE];
strncpy(gdxFileName, base_name, sizeof(gdxFileName));
strncpy(solFileName, base_name, sizeof(solFileName));
strncat(solFileName, "_sol", sizeof(solFileName) - strlen(solFileName) - 1);
strncat(gdxFileName, ".gdx", sizeof(gdxFileName) - strlen(gdxFileName) - 1);
strncat(solFileName, ".gdx", sizeof(solFileName) - strlen(solFileName) - 1);
// strncat(paramFileName, ".txt", sizeof(paramFileName));
/* XXX ParmFile is not a string option */
// optSetStrStr(Optr, "ParmFile", paramFileName);
// setDashedOptions("filename", gdxFileName, paramFileName);
optSetStrStr(Optr, "User1", gdxFileName);
optSetStrStr(Optr, "User2", solFileName);
idxOpenWrite(Xptr, gdxFileName, "Siconos/Numerics NM_to_GDX", &status);
if (status)
idxerrorR(status, "idxOpenWrite");
DEBUG_PRINT("FC3D_AVI_GAMS :: fc3d_avi-condensed.gdx opened\n");
while (mat_for_gdx)
{
char mat_descr[30];
assert(mat_for_gdx->name);
assert(mat_for_gdx->mat);
snprintf(mat_descr, sizeof(mat_descr), "%s matrix", mat_for_gdx->name);
if ((status=NM_to_GDX(Xptr, mat_for_gdx->name, mat_descr, mat_for_gdx->mat))) {
fprintf(stderr, "Model data for matrix %s not written\n", mat_for_gdx->name);
infos[1] = (double)-ETERMINATE;
goto fail;
}
DEBUG_PRINTF("GAMSlink :: %s matrix written\n", mat_for_gdx->name);
mat_for_gdx = mat_for_gdx->next;
}
while (vec_for_gdx)
{
char vec_descr[30];
assert(vec_for_gdx->name);
assert(vec_for_gdx->vec);
assert(vec_for_gdx->size > 0);
snprintf(vec_descr, sizeof(vec_descr), "%s vector", vec_for_gdx->name);
if ((status=NV_to_GDX(Xptr, vec_for_gdx->name, vec_descr, vec_for_gdx->vec, vec_for_gdx->size))) {
fprintf(stderr, "Model data for vector %s not written\n", vec_for_gdx->name);
infos[1] = (double)-ETERMINATE;
goto fail;
}
DEBUG_PRINTF("FC3D_AVI_GAMS :: %s vector written\n", vec_for_gdx->name);
vec_for_gdx = vec_for_gdx->next;
}
if (idxClose(Xptr))
idxerrorR(idxGetLastError(Xptr), "idxClose");
// cp(gdxFileName, "fc3d_avi-condensed.gdx");
if ((status=CallGams(Gptr, Optr, sysdir, model))) {
fprintf(stderr, "Call to GAMS failed\n");
infos[1] = (double)-ETERMINATE;
goto fail;
}
/************************************************
* Read back solution
************************************************/
idxOpenRead(Xptr, solFileName, &status);
if (status)
idxerrorR(status, "idxOpenRead");
while (vec_from_gdx)
{
assert(vec_from_gdx->name);
assert(vec_from_gdx->vec);
assert(vec_from_gdx->size > 0);
double* data = vec_from_gdx->vec;
unsigned size = vec_from_gdx->size;
/* GAMS does not set a value to 0 ... --xhub */
memset(data, 0, size*sizeof(double));
if ((status=GDX_to_NV(Xptr, vec_from_gdx->name, data, size))) {
fprintf(stderr, "Model data %s could not be read\n", vec_from_gdx->name);
infos[1] = (double)-ETERMINATE;
goto fail;
}
vec_from_gdx = vec_from_gdx->next;
}
if ((status=GDX_to_NV(Xptr, "infos", infos, sizeof(infos)/sizeof(double)))) {
fprintf(stderr, "infos could not be read\n");
infos[1] = (double)-ETERMINATE;
goto fail;
}
if (idxClose(Xptr))
idxerrorR(idxGetLastError(Xptr), "idxClose");
options->iparam[TOTAL_ITER] += (int)infos[2];
options->iparam[LAST_MODEL_STATUS] = (int)infos[0];
options->iparam[LAST_SOLVE_STATUS] = (int)infos[1];
options->dparam[TOTAL_TIME_USED] += infos[3];
printf("SolveStat = %d, ModelStat = %d\n", (int)infos[1], (int)infos[0]);
gmoGetModelStatusTxt(gmoPtr, (int)infos[0], msg);
DEBUG_PRINTF("%s\n", msg);
gmoGetSolveStatusTxt(gmoPtr, (int)infos[1], msg);
DEBUG_PRINTF("%s\n", msg);
fail:
idxFree(&Xptr);
gamsxFree(&Gptr);
gmoFree(&gmoPtr);
return (int)infos[1];
}
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;
}
