GlobalFrictionContactProblem* from_fclib_global(const struct fclib_global* fclib_problem)
{
GlobalFrictionContactProblem* problem;
problem = malloc(sizeof(GlobalFrictionContactProblem));
problem->dimension = fclib_problem->spacedim;
problem->mu = fclib_problem->mu;
problem->q = fclib_problem->f;
problem->b = fclib_problem->w;
problem->numberOfContacts = fclib_problem->H->n / fclib_problem->spacedim; /* cf fclib spec */
problem->M = newNumericsMatrix();
problem->M->storageType = 2; /* sparse */
problem->M->size0 = fclib_problem->M->m;
problem->M->size1 = fclib_problem->M->n;
problem->M->matrix2 = newNumericsSparseMatrix();
problem->M->matrix2->triplet=(CSparseMatrix*)fclib_problem->M;
problem->M->matrix0 = NULL;
problem->M->matrix1 = NULL;
problem->H = newNumericsMatrix();
problem->H->storageType = 2; /* sparse */
problem->H->size0 = fclib_problem->H->m;
problem->H->size1 = fclib_problem->H->n;
problem->H->matrix2 = newNumericsSparseMatrix();
problem->H->matrix2->triplet=(CSparseMatrix*)fclib_problem->H;
problem->H->matrix0 = NULL;
problem->H->matrix1 = NULL;
return problem;
}
NumericsMatrix* duplicateNumericsMatrix(NumericsMatrix* mat)
{
NumericsMatrix* M = newNumericsMatrix();
void* data;
int size0 = mat->size0;
int size1 = mat->size1;
M->storageType = mat->storageType;
switch (mat->storageType)
{
case NM_DENSE:
data = malloc(size0*size1*sizeof(double));
break;
case NM_SPARSE_BLOCK:
data = malloc(sizeof(SparseBlockStructuredMatrix));
break;
case NM_SPARSE:
data = malloc(sizeof(CSparseMatrix));
break;
default:
printf("createNumericsMatrix :: storageType value %d not implemented yet !", mat->storageType);
exit(EXIT_FAILURE);
}
fillNumericsMatrix(M, mat->storageType, size0, size1, data);
return M;
}
NumericsMatrix* createNumericsMatrix(int storageType, int size0, int size1)
{
NumericsMatrix* M = newNumericsMatrix();
void* data;
switch (storageType)
{
case NM_DENSE:
data = malloc(size0*size1*sizeof(double));
break;
case NM_SPARSE_BLOCK:
data = newSBM();
break;
case NM_SPARSE:
data = newNumericsSparseMatrix();
break;
default:
printf("createNumericsMatrix :: storageType value %d not implemented yet !", storageType);
exit(EXIT_FAILURE);
}
fillNumericsMatrix(M, storageType, size0, size1, data);
return M;
}
FrictionContactProblem* from_fclib_local(const struct fclib_local* fclib_problem)
{
FrictionContactProblem* problem;
problem = malloc(sizeof(FrictionContactProblem));
problem->dimension = fclib_problem->spacedim;
problem->mu = fclib_problem->mu;
problem->q = fclib_problem->q;
problem->numberOfContacts = fclib_problem->W->m / fclib_problem->spacedim; /* cf fclib spec */
problem->M = newNumericsMatrix();
problem->M->storageType = 1; /* sparse */
problem->M->size0 = fclib_problem->W->m;
problem->M->size1 = fclib_problem->W->n;
problem->M->matrix0 = NULL;
problem->M->matrix1 = newSBM();
problem->M->matrix1->block = NULL;
problem->M->matrix1->index1_data = NULL;
problem->M->matrix1->index2_data = NULL;
sparseToSBM(problem->dimension, (CSparseMatrix*)fclib_problem->W, problem->M->matrix1);
return problem;
}
int relay_newFromFile(RelayProblem* problem, FILE* file)
{
int n = 0;
int i;
CHECK_IO(fscanf(file, "%d\n", &n));
problem->size = n;
problem->M = newNumericsMatrix();
newFromFile(problem->M, file);
problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
for (i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
}
problem->lb = (double *) malloc(problem->M->size1 * sizeof(double));
for (i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->lb[i])));
}
problem->ub = (double *) malloc(problem->M->size1 * sizeof(double));
for (i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->ub[i])));
}
return 1;
}
NumericsMatrix* createNumericsMatrixFromData(int storageType, int size0, int size1, void* data)
{
NumericsMatrix* M = newNumericsMatrix();
fillNumericsMatrix(M, storageType, size0, size1, data);
return M;
}
void siconos_io(Archive& ar, LinearComplementarityProblem& v, unsigned int version)
{
SERIALIZE(v, (size), ar);
if(Archive::is_loading::value)
{
v.q = (double *) malloc(v.size * sizeof(double));
v.M = newNumericsMatrix();
}
SERIALIZE(v, (M), ar);
SERIALIZE_C_ARRAY(v.size, v, q, ar);
}
int globalFrictionContact_newFromFile(GlobalFrictionContactProblem* problem, FILE* file)
{
int nc = 0, d = 0;
int info = 0;
CHECK_IO(fscanf(file, "%d\n", &d), &info);
problem->dimension = d;
CHECK_IO(fscanf(file, "%d\n", &nc), &info);
problem->numberOfContacts = nc;
problem->M = newNumericsMatrix();
info = newFromFile(problem->M, file);
if (info) goto fail;
problem->H = newNumericsMatrix();
info = newFromFile(problem->H, file);
if (info) goto fail;
problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
for (int i = 0; i < problem->M->size1; ++i)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])), &info);
}
problem->b = (double *) malloc(problem->H->size1 * sizeof(double));
for (int i = 0; i < problem->H->size1; ++i)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->b[i])), &info);
}
problem->mu = (double *) malloc(nc * sizeof(double));
for (int i = 0; i < nc; ++i)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->mu[i])), &info);
}
fail:
problem->env = NULL;
problem->workspace = NULL;
return info;
}
void siconos_io(Archive& ar, FrictionContactProblem& p, const unsigned int file_version)
{
SERIALIZE(p, (dimension)(numberOfContacts), ar);
if (Archive::is_loading::value)
{
p.q = (double *) malloc(p.dimension * p.numberOfContacts * sizeof(double));
p.mu = (double *) malloc(p.numberOfContacts * sizeof(double));
p.M = newNumericsMatrix();
}
SERIALIZE(p, (M), ar);
SERIALIZE_C_ARRAY(p.dimension * p.numberOfContacts, p, q, ar);
SERIALIZE_C_ARRAY(p.dimension, p, mu, ar);
}
int linearComplementarity_newFromFile(LinearComplementarityProblem* problem, FILE* file)
{
int n = 0;
int i;
CHECK_IO(fscanf(file, "%d\n", &n));
problem->size = n;
problem->M = newNumericsMatrix();
newFromFile(problem->M, file);
problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
for (i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
}
return 1;
}
int main(void)
{
printf("========= Starts Numerics tests for NumericsMatrix ========= \n");
int i, nmm = 4 ;
NumericsMatrix ** NMM = (NumericsMatrix **)malloc(nmm * sizeof(NumericsMatrix *)) ;
for (i = 0 ; i < nmm; i++)
{
NMM[i] = newNumericsMatrix();
}
int info = test_BuildNumericsMatrix(NMM);
if (info != 0)
{
printf("Construction failed ...\n");
return info;
}
printf("Construction ok ...\n");
info = test_NM_row_prod_no_diag_non_square(NMM[2], NMM[3]);
printf("End of Sub-Prod no diag Non Square...\n");
if (info != 0) return info;
/* free memory */
for (i = 0 ; i < nmm; i++)
{
freeNumericsMatrix(NMM[i]);
free(NMM[i]);
}
free(NMM);
printf("========= End Numerics tests for NumericsMatrix ========= \n");
return info;
}
int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)
{
DEBUG_PRINT("Start -- int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)\n");
int n = 0;
int nc = 0;
int i;
CHECK_IO(fscanf(file, "%d\n", &n));
problem->n = n;
CHECK_IO(fscanf(file, "%d\n", &nc));
problem->nc = nc;
problem->M = newNumericsMatrix();
/* fix: problem->M->storageType unitialized ! */
newFromFile(problem->M, file);
problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
for(i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
}
problem->coneIndex = (unsigned int *) malloc((nc+1) * sizeof(unsigned int));
for(i = 0; i < nc+1; i++)
{
CHECK_IO(fscanf(file, "%d ", &(problem->coneIndex[i])));
}
problem->mu = (double *) malloc(nc * sizeof(double));
for(i = 0; i < nc; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->mu[i])));
}
DEBUG_PRINT("End -- int secondOrderConeLinearComplementarityProblem_newFromFile(SecondOrderConeLinearComplementarityProblem* problem, FILE* file)\n");
return 0;
}
FrictionContactProblem* from_fclib_local(const struct fclib_local* fclib_problem)
{
FrictionContactProblem* problem;
problem = malloc(sizeof(FrictionContactProblem));
problem->dimension = fclib_problem->spacedim;
problem->mu = fclib_problem->mu;
problem->q = fclib_problem->q;
problem->numberOfContacts = fclib_problem->W->m / fclib_problem->spacedim; /* cf fclib spec */
problem->M = newNumericsMatrix();
problem->M->storageType = 1; /* sparse */
problem->M->size0 = fclib_problem->W->m;
problem->M->size1 = fclib_problem->W->n;
problem->M->matrix0 = NULL;
problem->M->matrix1 = newSBM();
problem->M->matrix1->block = NULL;
problem->M->matrix1->index1_data = NULL;
problem->M->matrix1->index2_data = NULL;
CSparseMatrix W;
W.nzmax = (csi) fclib_problem->W->nzmax;
W.m = (csi) fclib_problem->W->m;
W.n = (csi) fclib_problem->W->n;
if (fclib_problem->W->nz == -1)
{
/* compressed colums */
W.p = (csi*) malloc(sizeof(csi)*(W.n+1));
int_to_csi(fclib_problem->W->p, W.p, (unsigned) (W.n+1));
}
else if (fclib_problem->W->nz == -2)
{
/* compressed rows */
W.p = (csi*) malloc(sizeof(csi)*(W.m+1));
int_to_csi(fclib_problem->W->p, W.p, (unsigned) (W.m+1));
}
else
{
/* triplet */
W.p = (csi*) malloc(sizeof(csi)*W.nzmax);
int_to_csi(fclib_problem->W->p, W.p, (unsigned) W.nzmax);
}
W.i = (csi*) malloc(sizeof(csi)*W.nzmax);
int_to_csi(fclib_problem->W->i, W.i, (unsigned) W.nzmax);
W.x = fclib_problem->W->x;
W.nz = fclib_problem->W->nz;
sparseToSBM(problem->dimension, &W, problem->M->matrix1);
free(W.p);
free(W.i);
return problem;
}
int main(int argc, char* argv[])
{
// Problem Definition
int info = -1;
int NC = 1;//Number of contacts
int Ndof = 9;//Number of DOF
// Problem Definition
double M11[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
double M22[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
double M33[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
/* double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
double H00[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
double H20[9] = { -1, 0, 0, 0, -1, 0, 0, 0, -1};
/* double H[27] = {1, 0, 0, 0, 0, 0, -1, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, -1, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, -1}; */
double q[9] = { -3, -3, -3, -1, 1, 3, -1, 1, 3};
double b[3] = {0, 0, 0};
double mu[1] = {0.1};
/* DSCAL(9,-1.0,q,1); */
/* int NC = 3;//Number of contacts */
/* int Ndof = 9;//Number of DOF */
/* double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double H[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double q[9] = {-1, 1, 3, -1, 1, 3, -1, 1, 3}; */
/* double b[9] = {0, 0, 0,0, 0, 0,0, 0, 0 }; */
/* double mu[3] = {0.1,0.1,0.1}; */
int k;
int m = 3 * NC;
int n = Ndof;
GlobalFrictionContactProblem numericsProblem;
globalFrictionContact_null(&numericsProblem);
numericsProblem.numberOfContacts = NC;
numericsProblem.dimension = 3;
numericsProblem.mu = mu;
numericsProblem.q = q;
numericsProblem.b = b;
numericsProblem.M = newNumericsMatrix();
NumericsMatrix *MM = numericsProblem.M;
MM->storageType = NM_SPARSE_BLOCK;
MM->size0 = Ndof;
MM->size1 = Ndof;
MM->matrix1 = newSBM();
SparseBlockStructuredMatrix *MBlockMatrix = MM->matrix1;
MBlockMatrix->nbblocks = 3;
double * block[3] = {M11, M22, M33};
MBlockMatrix->block = block;
MBlockMatrix->blocknumber0 = 3;
MBlockMatrix->blocknumber1 = 3;
unsigned int blocksize[3] = {3, 6, 9} ;
MBlockMatrix->blocksize0 = blocksize;
MBlockMatrix->blocksize1 = blocksize;
MBlockMatrix->filled1 = 4;
MBlockMatrix->filled2 = 3;
size_t index1_data[4] = {0, 1, 2, 3} ;
size_t index2_data[3] = {0, 1, 2} ;
MBlockMatrix->index1_data = index1_data;
MBlockMatrix->index2_data = index2_data;
numericsProblem.H = newNumericsMatrix();
NumericsMatrix *HH = numericsProblem.H;
HH->storageType = 1;
HH->size0 = Ndof;
HH->size1 = 3 * NC;
HH->matrix1 = (SparseBlockStructuredMatrix*)malloc(sizeof(SparseBlockStructuredMatrix));
SparseBlockStructuredMatrix *HBlockMatrix = HH->matrix1;
HBlockMatrix->nbblocks = 2;
double * hblock[3] = {H00, H20};
HBlockMatrix->block = hblock;
HBlockMatrix->blocknumber0 = 3;
HBlockMatrix->blocknumber1 = 1;
unsigned int blocksize0[3] = {3, 6, 9} ;
unsigned int blocksize1[1] = {3} ;
HBlockMatrix->blocksize0 = blocksize0;
HBlockMatrix->blocksize1 = blocksize1;
HBlockMatrix->filled1 = 4;
HBlockMatrix->filled2 = 2;
size_t hindex1_data[4] = {0, 1, 1, 2} ;
size_t hindex2_data[3] = {0, 0} ;
HBlockMatrix->index1_data = hindex1_data;
HBlockMatrix->index2_data = hindex2_data;
FILE * foutput = fopen("Example_GlobalFrictionContact_SBM.dat", "w");
globalFrictionContact_printInFile(&numericsProblem, foutput);
fclose(foutput);
// Unknown Declaration
double *reaction = (double*)calloc(m, sizeof(double));
double *velocity = (double*)calloc(m, sizeof(double));
double *globalVelocity = (double*)calloc(n, sizeof(double));
// Solver Options
SolverOptions * numerics_solver_options = (SolverOptions *)malloc(sizeof(SolverOptions));
// char solvername[10]= "NSGS";
/*\warning Must be adpated for future globalFrictionContact3D_setDefaultSolverOptions*/
gfc3d_setDefaultSolverOptions(numerics_solver_options, SICONOS_GLOBAL_FRICTION_3D_NSGS);
numerics_solver_options->dparam[0] = 1e-14;
numerics_solver_options->iparam[0] = 100000;
//Driver call
info = gfc3d_driver(&numericsProblem,
reaction , velocity, globalVelocity,
numerics_solver_options);
solver_options_delete(numerics_solver_options);
free(numerics_solver_options);
// Solver output
printf("\n");
for (k = 0 ; k < m; k++) printf("velocity[%i] = %12.8e \t \t reaction[%i] = %12.8e \n ", k, velocity[k], k , reaction[k]);
for (k = 0 ; k < n; k++) printf("globalVelocity[%i] = %12.8e \t \n ", k, globalVelocity[k]);
printf("\n");
free(reaction);
free(velocity);
free(globalVelocity);
// freeSBM(MM->matrix1);
// freeSBM(HH->matrix1);
free(MM->matrix1);
MM->matrix1 = NULL;
free(HH->matrix1);
HH->matrix1 = NULL;
freeNumericsMatrix(MM);
freeNumericsMatrix(HH);
free(MM);
free(HH);
gfc3d_free_workspace(&numericsProblem);
/* while (1) sleep(60); */
return info;
}
int main(int argc, char* argv[])
{
// Problem Definition
int info = -1;
int NC = 1;//Number of contacts
int m = 3;
int n = 9;
double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1
};
double H[27] = {1, 0, 0, 0, 0, 0, -1, 0, 0,
0, 1, 0, 0, 0, 0, 0, -1, 0,
0, 0, 1, 0, 0, 0, 0, 0, -1
};
double q[9] = { -3, -3, -3, -1, 1, 3, -1, 1, 3};
double b[3] = {0, 0, 0};
double mu[1] = {0.1};
/* int NC = 3;//Number of contacts */
/* int Ndof = 9;//Number of DOF */
/* double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double H[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double q[9] = {-1, 1, 3, -1, 1, 3, -1, 1, 3}; */
/* double b[9] = {0, 0, 0,0, 0, 0,0, 0, 0 }; */
/* double mu[3] = {0.1,0.1,0.1}; */
int i = 0, k = 0;
GlobalFrictionContactProblem numericsProblem;
globalFrictionContact_null(&numericsProblem);
numericsProblem.numberOfContacts = NC;
numericsProblem.dimension = 3;
numericsProblem.mu = mu;
numericsProblem.q = q;
numericsProblem.b = b;
numericsProblem.M = newNumericsMatrix();
NumericsMatrix *MM = numericsProblem.M ;
MM->storageType = NM_DENSE;
MM->matrix0 = M;
MM->size0 = n;
MM->size1 = n;
numericsProblem.H = newNumericsMatrix();
NumericsMatrix *HH = numericsProblem.H;
HH->storageType = NM_DENSE;
HH->matrix0 = H;
HH->size0 = n;
HH->size1 = m;
/* FILE * foutput = fopen("Example_GlobalFrictionContact.dat", "w"); */
/* globalFrictionContact_printInFile(&numericsProblem, foutput ); */
/* fclose(foutput); */
// Unknown Declaration
double *reaction = (double*)calloc(m, sizeof(double));
double *velocity = (double*)calloc(m, sizeof(double));
double *globalVelocity = (double*)calloc(n, sizeof(double));
// Numerics and Solver Options
NumericsOptions numerics_options;
numerics_options.verboseMode = 1; // turn verbose mode to off by default
SolverOptions * numerics_solver_options = (SolverOptions *)malloc(sizeof(SolverOptions)) ;
//char solvername[10]= "NSGS";
/*\warning Must be adpated for future globalFrictionContact3D_setDefaultSolverOptions*/
gfc3d_setDefaultSolverOptions(numerics_solver_options, SICONOS_GLOBAL_FRICTION_3D_NSGS);
numerics_solver_options->dparam[0] = 1e-14;
numerics_solver_options->iparam[0] = 100000;
//Driver call
i = 0;
info = gfc3d_driver(&numericsProblem,
reaction , velocity, globalVelocity,
numerics_solver_options, &numerics_options);
deleteSolverOptions(numerics_solver_options);
// Solver output
printf("\n");
for (k = 0 ; k < m; k++) printf("velocity[%i] = %12.8e \t \t reaction[%i] = %12.8e \n ", k, velocity[k], k , reaction[k]);
for (k = 0 ; k < n; k++) printf("globalVelocity[%i] = %12.8e \t \n ", k, globalVelocity[k]);
printf("\n");
free(numerics_solver_options);
free(reaction);
free(velocity);
free(globalVelocity);
free(numericsProblem.M);
free(numericsProblem.H);
gfc3d_free_workspace(&numericsProblem);
return info;
}
int fc2d_tolcp(FrictionContactProblem* problem, LinearComplementarityProblem * lcp_problem)
{
if (problem->dimension != 2)
{
numerics_error("fc2d_tolcp", "Dimension of the problem : problem-> dimension is not compatible or is not set");
return 1;
}
int nc = problem->numberOfContacts;
lcp_problem->size = 3 * nc ;
lcp_problem->M = newNumericsMatrix();
lcp_problem->M->size0 = 3 * nc ;
lcp_problem->M->size1 = 3 * nc ;
lcp_problem->M->storageType = 0;
lcp_problem->M->matrix1 = NULL;
lcp_problem->M->matrix2 = NULL;
lcp_problem->M->internalData = NULL;
lcp_problem->M->matrix0 = (double*)malloc(lcp_problem->size * lcp_problem->size * sizeof(double));;
lcp_problem->q = (double*)malloc(lcp_problem->size * sizeof(double));
int n = 2 * nc;
int i, j;
for (i = 0; i < nc; i++)
{
for (j = 0; j < nc; j++)
{
/* first Column */
lcp_problem->M->matrix0[3 * i + 3 * j * lcp_problem->size] =
problem->M->matrix0[2 * i + 2 * j * n] - problem->mu[i] * problem->M->matrix0[2 * i + (2 * j + 1) * n] ; // compute W_NN-mu W_NT
lcp_problem->M->matrix0[3 * i + 1 + 3 * j * lcp_problem->size] =
problem->M->matrix0[(2 * i + 1) + 2 * j * n] - problem->mu[i] * problem->M->matrix0[(2 * i + 1) + (2 * j + 1) * n] ; // compute W_TN-mu W_TT
if (i == j)
{
lcp_problem->M->matrix0[3 * i + 2 + 3 * j * lcp_problem->size] = 2.0 * problem->mu[i];
}
else
{
lcp_problem->M->matrix0[3 * i + 2 + 3 * j * lcp_problem->size] = 0.0;
}
/* second Column */
lcp_problem->M->matrix0[3 * i + (3 * j + 1)*lcp_problem->size] =
problem->M->matrix0[2 * i + (2 * j + 1) * n] ; // set W_NT
lcp_problem->M->matrix0[3 * i + 1 + (3 * j + 1)*lcp_problem->size] =
problem->M->matrix0[(2 * i + 1) + (2 * j + 1) * n] ; // set WTT
if (i == j)
{
lcp_problem->M->matrix0[3 * i + 2 + (3 * j + 1)*lcp_problem->size] = -1.0;
}
else
{
lcp_problem->M->matrix0[3 * i + 2 + (3 * j + 1)*lcp_problem->size] = 0.0;
}
/* Third Column */
lcp_problem->M->matrix0[3 * i + (3 * j + 2)*lcp_problem->size] = 0.0;
if (i == j)
{
lcp_problem->M->matrix0[3 * i + 1 + (3 * j + 2)*lcp_problem->size] = 1.0;
}
else
{
lcp_problem->M->matrix0[3 * i + 1 + (3 * j + 2)*lcp_problem->size] = 0.0;
}
lcp_problem->M->matrix0[3 * i + 2 + (3 * j + 2)*lcp_problem->size] = 0.0;
}
}
for (i = 0; i < nc; i++)
{
lcp_problem->q[3 * i ] = problem->q[2 * i];
lcp_problem->q[3 * i + 1] = problem->q[2 * i + 1];
lcp_problem->q[3 * i + 2] = 0.0;;
}
return 0;
}
int main(void)
{
printf("========= Starts Numerics tests for NumericsMatrix ========= \n");
int i, nmm = 4 ;
NumericsMatrix ** NMM = (NumericsMatrix **)malloc(nmm * sizeof(NumericsMatrix *)) ;
NumericsMatrix ** Mread = (NumericsMatrix **)malloc(nmm * sizeof(NumericsMatrix *)) ;
for (i = 0 ; i < nmm; i++)
{
NMM[i] = newNumericsMatrix();
Mread[i] = newNumericsMatrix();
}
int info = test_BuildNumericsMatrix(NMM);
if (info != 0)
{
printf("Construction failed ...\n");
return info;
}
printf("Construction ok ...\n");
/* Test of various I/O functions */
for (i = 0 ; i < nmm; i++)
{
printf("test on NMM[%i]\n", i);
NM_display(NMM[i]);
displayRowbyRow(NMM[i]);
FILE * foutput = fopen("testprintInfile.dat", "w");
printInFile(NMM[i], foutput);
fclose(foutput);
FILE * finput = fopen("testprintInfile.dat", "r");
readInFile(NMM[i], finput);
fclose(finput);
FILE * finput2 = fopen("testprintInfile.dat", "r");
newFromFile(Mread[i], finput2);
fclose(finput2);
char filename[50] = "testprintInfileName.dat";
printInFileName(NMM[i], filename);
readInFileName(NMM[i], filename);
printf("end of test on NMM[%i]\n", i);
}
for (i = 0 ; i < nmm; i++, i++)
{
FILE * foutput2 = fopen("testprintInfileForScilab.dat", "w");
printInFileForScilab(NMM[i], foutput2);
fclose(foutput2);
}
/* free memory */
for (i = 0 ; i < nmm; i++)
{
freeNumericsMatrix(NMM[i]);
free(NMM[i]);
freeNumericsMatrix(Mread[i]);
free(Mread[i]);
}
free(NMM);
free(Mread);
printf("========= End Numerics tests for NumericsMatrix ========= \n");
return info;
}
int main(int argc, char* argv[])
{
// Problem Definition
int info = -1;
int NC = 2;//Number of contacts
int Ndof = 12;//Number of DOF
// Problem Definition
double M11[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
double M22[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
double M33[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
double M44[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; // Warning Fortran Storage
/* double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
double H00[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
double H20[9] = { -1, 0, 0, 0, -1, 0, 0, 0, -1};
double H11[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
double H31[9] = { -1, 0, 0, 0, -1, 0, 0, 0, -1};
/* double H[27] = {1, 0, 0, 0, 0, 0, -1, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, -1, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, -1}; */
double q[12] = { -3, -3, -3, -3, -3, -3, -1, 1, 3, -10, 1, 3};
double b[6] = {0, 0, 0, 0, 0, 0};
double mu[2] = {0.1, 0.1};
/* DSCAL(9,-1.0,q,1); */
/* int NC = 3;//Number of contacts */
/* int Ndof = 9;//Number of DOF */
/* double M[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double H[81] = {1, 0, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 1, 0, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 1, 0, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 1, 0, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 1, 0, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 1, 0, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 1, 0, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 1, 0, */
/* 0, 0, 0, 0, 0, 0, 0, 0, 1}; */
/* double q[9] = {-1, 1, 3, -1, 1, 3, -1, 1, 3}; */
/* double b[9] = {0, 0, 0,0, 0, 0,0, 0, 0 }; */
/* double mu[3] = {0.1,0.1,0.1}; */
int i, j, k;
int m = 3 * NC;
int n = Ndof;
GlobalFrictionContactProblem NumericsProblem;
NumericsProblem.numberOfContacts = NC;
NumericsProblem.dimension = 3;
NumericsProblem.mu = mu;
NumericsProblem.q = q;
NumericsProblem.b = b;
NumericsProblem.M = newNumericsMatrix();
NumericsMatrix *MM = NumericsProblem.M;
MM->storageType = 1;
MM->size0 = Ndof;
MM->size1 = Ndof;
MM->matrix1 = newSBM();
MM->matrix0 = NULL;
SparseBlockStructuredMatrix *MBlockMatrix = MM->matrix1;
MBlockMatrix->nbblocks = 4;
double * block[4] = {M11, M22, M33, M44};
MBlockMatrix->block = block;
MBlockMatrix->blocknumber0 = 4;
MBlockMatrix->blocknumber1 = 4;
int blocksize[4] = {3, 6, 9, 12} ;
MBlockMatrix->blocksize0 = blocksize;
MBlockMatrix->blocksize1 = blocksize;
MBlockMatrix->filled1 = 5;
MBlockMatrix->filled2 = 4;
size_t index1_data[5] = {0, 1, 2, 3, 4} ;
size_t index2_data[4] = {0, 1, 2, 3} ;
MBlockMatrix->index1_data = index1_data;
MBlockMatrix->index2_data = index2_data;
NumericsProblem.H = newSBM();
NumericsMatrix *HH = NumericsProblem.H;
HH->storageType = 1;
HH->size0 = Ndof;
HH->size1 = 3 * NC;
HH->matrix1 = (SparseBlockStructuredMatrix*)malloc(sizeof(SparseBlockStructuredMatrix));
HH->matrix0 = NULL;
SparseBlockStructuredMatrix *HBlockMatrix = HH->matrix1;
HBlockMatrix->nbblocks = 4;
double * hblock[4] = {H00, H11, H20, H31};
HBlockMatrix->block = hblock;
HBlockMatrix->blocknumber0 = 4;
HBlockMatrix->blocknumber1 = 2;
int blocksize0[4] = {3, 6, 9, 12} ;
int blocksize1[3] = {3, 6, 9} ;
HBlockMatrix->blocksize0 = blocksize0;
HBlockMatrix->blocksize1 = blocksize1;
HBlockMatrix->filled1 = 5;
HBlockMatrix->filled2 = 4;
size_t hindex1_data[5] = {0, 1, 2, 3, 4} ;
size_t hindex2_data[4] = {0, 1, 0, 1} ;
HBlockMatrix->index1_data = hindex1_data;
HBlockMatrix->index2_data = hindex2_data;
printSBM(HBlockMatrix);
// Unknown Declaration
double *reaction = (double*)malloc(m * sizeof(double));
double *velocity = (double*)malloc(m * sizeof(double));
double *globalVelocity = (double*)malloc(n * sizeof(double));
for (k = 0 ; k < m; k++)
{
velocity[k] = 0.0;
reaction[k] = 0.0;
}
for (k = 0 ; k < n; k++) globalVelocity[k] = 0.0;
// Numerics and Solver Options
SolverOzptions numerics_solver_options;
numerics_solver_options.filterOn = 0;
numerics_solver_options.isSet = 1;
// strcpy(numerics_solver_optionslverName,"NSGS_WR");
// strcpy(numerics_solver_optionslverName,"NSGS");
// strcpy(numerics_solver_optionslverName,"NSGSV_WR");
numerics_solver_optionslverId = SICONOS_FRICTION_3D_NSGS;
numerics_solver_options.iSize = 5;
numerics_solver_options.iparam = (int*)malloc(numerics_solver_options.iSize * sizeof(int));
int ii ;
for (ii = 0; ii < numerics_solver_options.iSize; ii++)
numerics_solver_options.iparam[ii] = 0;
numerics_solver_options.dSize = 5;
numerics_solver_options.dparam = (double*)malloc(numerics_solver_options.dSize * sizeof(double));
for (ii = 0; ii < numerics_solver_options.dSize; ii++)
numerics_solver_options.dparam[ii] = 0;
int nmax = 100; // Max number of iteration
int localsolver = 0; // 0: projection on Cone, 1: Newton/AlartCurnier, 2: projection on Cone with local iteration, 2: projection on Disk with diagonalization,
double tolerance = 1e-10;
double localtolerance = 1e-12;
numerics_solver_options.iparam[0] = nmax ;
numerics_solver_options.iparam[4] = localsolver ;
numerics_solver_options.dparam[0] = tolerance ;
numerics_solver_options.dparam[2] = localtolerance ;
//Driver call
info = primalFrictionContact3D_driver(&NumericsProblem,
reaction , velocity, globalVelocity,
&numerics_solver_options);
// Solver output
printf("\n");
for (k = 0 ; k < m; k++) printf("velocity[%i] = %12.8e \t \t reaction[%i] = %12.8e \n ", k, velocity[k], k , reaction[k]);
for (k = 0 ; k < n; k++) printf("globalVelocity[%i] = %12.8e \t \n ", k, globalVelocity[k]);
printf("\n");
free(reaction);
free(velocity);
free(globalVelocity);
// freeSBM(MM->matrix1);
// freeSBM(HH->matrix1);
free(MM->matrix1);
free(HH->matrix1);
free(MM);
free(HH);
free(numerics_solver_options.iparam);
free(numerics_solver_options.dparam);
/* while (1) sleep(60); */
return info;
}
GlobalFrictionContactProblem* from_fclib_global(const struct fclib_global* fclib_problem)
{
GlobalFrictionContactProblem* problem;
problem = malloc(sizeof(GlobalFrictionContactProblem));
problem->dimension = fclib_problem->spacedim;
problem->mu = fclib_problem->mu;
problem->q = fclib_problem->f;
problem->b = fclib_problem->w;
problem->numberOfContacts = fclib_problem->H->n / fclib_problem->spacedim; /* cf fclib spec */
problem->M = newNumericsMatrix();
problem->M->storageType = 2; /* sparse */
problem->M->size0 = fclib_problem->M->m;
problem->M->size1 = fclib_problem->M->n;
problem->M->matrix2 = newNumericsSparseMatrix();
problem->M->matrix0 = NULL;
problem->M->matrix1 = NULL;
CSparseMatrix * M = (CSparseMatrix*)malloc(sizeof(CSparseMatrix));
M->nzmax = (csi) fclib_problem->M->nzmax;
M->m = (csi) fclib_problem->M->m;
M->n = (csi) fclib_problem->M->n;
M->x = fclib_problem->M->x;
if (fclib_problem->M->nz == -1)
{
/* compressed colums */
problem->M->matrix2->csc= M;
problem->M->matrix2->triplet=NULL;
problem->M->matrix2->trans_csc=NULL;
M->nz = (csi) fclib_problem->M->nz;
M->p = (csi*) malloc(sizeof(csi)*(M->n+1));
int_to_csi(fclib_problem->M->p, M->p, (unsigned) (M->n+1));
}
else if (fclib_problem->M->nz == -2)
{
/* compressed rows */
M->nz = (csi) fclib_problem->M->nz;
M->p = (csi*) malloc(sizeof(csi)*(M->m+1));
int_to_csi(fclib_problem->M->p, M->p, (unsigned) (M->m+1));
/* since problem->M->matrix2->csr does not exist, we need
to fill transform M into a triplet or csc before returning
*/
fprintf(stderr, "from_fclib_local not implemented for csr matrices.\n");
exit(EXIT_FAILURE); ;
}
else
{
/* triplet */
problem->M->matrix2->triplet=M;
problem->M->matrix2->csc=NULL;
problem->M->matrix2->trans_csc=NULL;
M->nz = (csi) fclib_problem->M->nz;
M->p = (csi*) malloc(sizeof(csi)*M->nzmax);
int_to_csi(fclib_problem->M->p, M->p, (unsigned) M->nzmax);
}
M->i = (csi*) malloc(sizeof(csi)*M->nzmax);
int_to_csi(fclib_problem->M->i, M->i, (unsigned) M->nzmax);
problem->H = newNumericsMatrix();
problem->H->storageType = 2; /* sparse */
problem->H->size0 = fclib_problem->H->m;
problem->H->size1 = fclib_problem->H->n;
problem->H->matrix2 = newNumericsSparseMatrix();
problem->H->matrix0 = NULL;
problem->H->matrix1 = NULL;
CSparseMatrix * H = (CSparseMatrix*)malloc(sizeof(CSparseMatrix));;
H->nzmax = (csi) fclib_problem->H->nzmax;
H->m = (csi) fclib_problem->H->m;
H->n = (csi) fclib_problem->H->n;
H->nz = (csi) fclib_problem->H->nz;
H->x = fclib_problem->H->x;
if (fclib_problem->H->nz == -1)
{
/* compressed colums */
problem->H->matrix2->csc= H;
problem->H->matrix2->triplet=NULL;
problem->H->matrix2->trans_csc=NULL;
H->p = (csi*) malloc(sizeof(csi)*(H->n+1));
int_to_csi(fclib_problem->H->p, H->p, (unsigned) (H->n+1));
}
else if (fclib_problem->H->nz == -2)
{
/* compressed rows */
fprintf(stderr, "from_fclib_local not implemented for csr matrices.\n");
exit(EXIT_FAILURE); ;
}
else
{
/* triplet */
problem->H->matrix2->triplet=H;
problem->H->matrix2->csc=NULL;
problem->H->matrix2->trans_csc=NULL;
H->p = (csi*) malloc(sizeof(csi)*H->nzmax);
int_to_csi(fclib_problem->H->p, H->p, (unsigned) H->nzmax);
}
H->i = (csi*) malloc(sizeof(csi)*H->nzmax);
int_to_csi(fclib_problem->H->i, H->i, (unsigned) H->nzmax);
return problem;
}
int gfc3d_LmgcDriver(double *reaction,
double *velocity,
double *globalVelocity,
double *q,
double *b,
double *mu,
double *Mdata,
unsigned int nzM,
unsigned int *rowM,
unsigned int *colM,
double* Hdata,
unsigned int nzH,
unsigned int *rowH,
unsigned int *colH,
unsigned int n,
unsigned int nc,
int solver_id,
int isize,
int *iparam,
int dsize,
double *dparam,
int verbose,
int outputFile,
int freq_output)
{
/* NumericsMatrix M, H; */
NumericsMatrix * M =newNumericsMatrix();
M->storageType = 2; /* sparse */
M->size0 = n;
M->size1 = n;
NumericsMatrix * H =newNumericsMatrix();
H->storageType = 2;
H->size0 = M->size0;
H->size1 = 3 * nc;
NumericsSparseMatrix * SM =newNumericsSparseMatrix();
M->matrix2 = SM;
SM->triplet = (CSparseMatrix * )malloc(sizeof(CSparseMatrix));
CSparseMatrix * _M = SM->triplet;
SM->origin = NS_TRIPLET;
csi * _colM = alloc_memory_csi(nzM, colM);
csi * _rowM = alloc_memory_csi(nzM, rowM);
_M->nzmax = nzM;
_M->nz = nzM;
_M->m = M->size0;
_M->n = M->size1;
_M->p = (csi *) _colM;
_M->i = (csi *) _rowM;
double * _Mdata = alloc_memory_double(nzM, Mdata);
_M->x = _Mdata;
DEBUG_PRINTF("_M->n=%li\t",_M->n);
DEBUG_PRINTF("_M->m=%li\n",_M->m);
NumericsSparseMatrix * SH =newNumericsSparseMatrix();
H->matrix2 = SH;
SH->triplet = (CSparseMatrix * )malloc(sizeof(CSparseMatrix));
CSparseMatrix * _H = SH->triplet;
SH->origin = NS_TRIPLET;
csi * _colH = alloc_memory_csi(nzH, colH);
csi * _rowH = alloc_memory_csi(nzH, rowH);
_H->nzmax = nzH;
_H->nz = nzH;
_H->m = H->size0;
_H->n = H->size1;
_H->p = _colH;
_H->i = _rowH;
double * _Hdata = alloc_memory_double(nzH, Hdata);
_H->x = _Hdata;
for (int i=0; i< _M->nz; ++i)
{
_M->p[i] --;
_M->i[i] --;
/* DEBUG_PRINTF("%d -> %d,%d\n", i, _M->p[i], _M->i[i]); */
}
for (int i=0; i< _H->nz; ++i)
{
_H->p[i] --;
_H->i[i] --;
/* DEBUG_PRINTF("%d -> %d,%d\n", i, _H->p[i], _H->i[i]); */
}
GlobalFrictionContactProblem * problem =(GlobalFrictionContactProblem*)malloc(sizeof(GlobalFrictionContactProblem));
problem->dimension = 3;
problem->numberOfContacts = nc;
problem->env = NULL;
problem->workspace = NULL;
problem->M = M;
problem->H = H;
problem->q = q;
problem->b = b;
problem->mu = mu;
SolverOptions numerics_solver_options;
gfc3d_setDefaultSolverOptions(&numerics_solver_options, solver_id);
int iSize_min = isize < numerics_solver_options.iSize ? isize : numerics_solver_options.iSize;
for (int i = 0; i < iSize_min; ++i)
numerics_solver_options.iparam[i] = iparam[i];
int dSize_min = dsize < numerics_solver_options.dSize ? dsize : numerics_solver_options.dSize;
for (int i=0; i < dSize_min; ++i)
numerics_solver_options.dparam[i] = dparam[i];
/* solver_options_print(&numerics_solver_options); */
/* FILE * file = fopen("toto.dat", "w"); */
/* globalFrictionContact_printInFile(problem, file); */
/* fclose(file); */
int rinfo = gfc3d_driver(problem,
reaction,
velocity,
globalVelocity,
&numerics_solver_options);
/* FILE * file1 = fopen("tutu.dat", "w"); */
/* globalFrictionContact_printInFile(problem, file1); */
/* fclose(file1); */
if(outputFile == 1)
{
/* dump in C format */
}
else if (outputFile == 2)
{
/* dump in Numerics .dat format */
}
else if (outputFile == 3)
{
#ifdef WITH_FCLIB
fccounter++;
if (fccounter % freq_output == 0)
{
char fname[256];
snprintf(fname, sizeof(fname), "LMGC_GFC3D-i%.5d-%i-%.5d.hdf5", numerics_solver_options.iparam[7], nc, fccounter);
printf("Dump LMGC_GFC3D-i%.5d-%i-%.5d.hdf5.\n", numerics_solver_options.iparam[7], nc, fccounter);
/* printf("ndof = %i.\n", ndof); */
FILE * foutput = fopen(fname, "w");
int n = 100;
char * title = (char *)malloc(n * sizeof(char *));
strncpy(title, "LMGC dump in hdf5", n);
char * description = (char *)malloc(n * sizeof(char *));
snprintf(description, n, "Rewriting in hdf5 through siconos of %s in FCLIB format", fname);
char * mathInfo = (char *)malloc(n * sizeof(char *));
strncpy(mathInfo, "unknown", n);
globalFrictionContact_fclib_write(problem,
title,
description,
mathInfo,
fname);
fclose(foutput);
}
#else
printf("Fclib is not available ...\n");
#endif
}
freeNumericsMatrix(M);
freeNumericsMatrix(H);
free(M);
free(H);
free(problem);
/* free(_colM); */
/* free(_colH); */
/* free(_rowM); */
/* free(_rowH); */
return rinfo;
}
int mixedLinearComplementarity_newFromFile(MixedLinearComplementarityProblem* problem, FILE* file)
{
int info = 0;
assert(file);
if (! problem)
{
fprintf(stderr, "Numerics, MixedLinearComplementarityProblem printInFile failed, NULL input.\n");
exit(EXIT_FAILURE);
}
int i, j;
int st1, st2;
CHECK_IO(fscanf(file, "%d\n", &st1));
problem->isStorageType1 = st1;
CHECK_IO(fscanf(file, "%d\n", &st2));
problem->isStorageType2 = st2;
int n ;
CHECK_IO(fscanf(file, "%d\n", &n));
problem->n = n;
int m;
CHECK_IO(fscanf(file, "%d\n", &m));
problem->m = m;
if (problem->isStorageType1)
{
int * blocksRows = (int *)malloc((n + m + 1) * sizeof(int));
int nbBlocks = 0;
CHECK_IO(fscanf(file, "%d ", &(blocksRows[nbBlocks])));
while (blocksRows[nbBlocks] < (n + m))
{
nbBlocks++;
CHECK_IO(fscanf(file, "%d ", &(blocksRows[nbBlocks])));
}
problem->blocksRows = (int *)malloc((nbBlocks + 1) * sizeof(int));
//CHECK_IO(fscanf(file,"\n"));
for (i = 0; i <= nbBlocks; i++)
{
problem->blocksRows[i] = blocksRows[i];
}
free(blocksRows);
problem->blocksIsComp = (int *)malloc((nbBlocks) * sizeof(int));
//fprintf(file,"\n");
for (i = 0; i < nbBlocks; i++)
{
CHECK_IO(fscanf(file, "%d ", &(problem->blocksIsComp[i])));
}
//fprintf(file,"\n");
problem->M = newNumericsMatrix();
newFromFile(problem->M, file);
problem->q = (double *) malloc(problem->M->size1 * sizeof(double));
for (i = 0; i < problem->M->size1; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->q[i])));
}
//fprintf(file,"\n");
/* return 1; */
/* if (problem->isStorageType2) */
/* { */
/* printf("Numerics, MixedLinearComplementarityProblem printInFile only Storage1 has been printed.\n"); */
/* } */
}
if (problem->isStorageType2)
{
problem->A = (double*)malloc(n * n * sizeof(double));
problem->B = (double*)malloc(m * m * sizeof(double));
problem->C = (double*)malloc(n * m * sizeof(double));
problem->D = (double*)malloc(m * n * sizeof(double));
problem->a = (double*)malloc(n * sizeof(double));
problem->b = (double*)malloc(m * sizeof(double));
for (i = 0; i < problem->n; i++)
{
for (j = 0; j < problem->n; j++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->A[i + j * n])));
}
/* CHECK_IO(fscanf(file,"\n")); */
}
for (i = 0; i < problem->m; i++)
{
for (j = 0; j < problem->m; j++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->B[i + j * m])));
}
/* fprintf(file,"\n"); */
}
for (i = 0; i < problem->n; i++)
{
for (j = 0; j < problem->m; j++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->C[i + j * n])));
}
/* fprintf(file,"\n"); */
}
for (i = 0; i < problem->m; i++)
{
for (j = 0; j < problem->n; j++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->D[i + j * m])));
}
/* fprintf(file,"\n"); */
}
for (i = 0; i < problem->n; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->a[i])));
}
/* fprintf(file,"\n"); */
for (i = 0; i < problem->m; i++)
{
CHECK_IO(fscanf(file, "%lf ", &(problem->b[i])));
}
}
return info;
}