bool MeshTablesVolume<PFP>::importTet(const std::string& filename, std::vector<std::string>& attrNames)
{
VertexAttribute<VEC3> position = m_map.template getAttribute<VEC3, VERTEX>("position") ;
if (!position.isValid())
position = m_map.template addAttribute<VEC3, VERTEX>("position") ;
attrNames.push_back(position.name()) ;
AttributeContainer& container = m_map.template getAttributeContainer<VERTEX>() ;
//open file
std::ifstream fp(filename.c_str(), std::ios::in);
if (!fp.good())
{
CGoGNerr << "Unable to open file " << filename << CGoGNendl;
return false;
}
std::string ligne;
// reading number of vertices
std::getline (fp, ligne);
std::stringstream oss(ligne);
oss >> m_nbVertices;
// reading number of tetrahedra
std::getline (fp, ligne);
std::stringstream oss2(ligne);
oss2 >> m_nbVolumes;
//reading vertices
std::vector<unsigned int> verticesID;
verticesID.reserve(m_nbVertices);
for(unsigned int i = 0; i < m_nbVertices; ++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size() == 0);
std::stringstream oss(ligne);
float x,y,z;
oss >> x;
oss >> y;
oss >> z;
// TODO : if required read other vertices attributes here
VEC3 pos(x,y,z);
unsigned int id = container.insertLine();
position[id] = pos;
verticesID.push_back(id);
}
// reading tetrahedra
m_nbFaces.reserve(m_nbVolumes*4);
m_emb.reserve(m_nbVolumes*12);
for (unsigned int i = 0; i < m_nbVolumes ; ++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size()==0);
std::stringstream oss(ligne);
int n;
oss >> n; // nb de faces d'un volume ?
m_nbFaces.push_back(4);
int s0,s1,s2,s3;
oss >> s0;
oss >> s1;
oss >> s2;
oss >> s3;
typename PFP::VEC3 P = position[verticesID[s0]];
typename PFP::VEC3 A = position[verticesID[s1]];
typename PFP::VEC3 B = position[verticesID[s2]];
typename PFP::VEC3 C = position[verticesID[s3]];
if (Geom::testOrientation3D<typename PFP::VEC3>(P,A,B,C) == Geom::UNDER)
{
int ui = s1;
s1 = s2;
s2 = ui;
}
m_emb.push_back(verticesID[s0]);
m_emb.push_back(verticesID[s1]);
m_emb.push_back(verticesID[s2]);
m_emb.push_back(verticesID[s3]);
}
fp.close();
return true;
}
bool MeshTablesVolume<PFP>::importTet(const std::string& filename, std::vector<std::string>& attrNames, float scaleFactor)
{
VertexAttribute<VEC3> positions = m_map.template getAttribute<VEC3, VERTEX>("position") ;
if (!positions.isValid())
positions = m_map.template addAttribute<VEC3, VERTEX>("position") ;
attrNames.push_back(positions.name()) ;
AttributeContainer& container = m_map.template getAttributeContainer<VERTEX>() ;
//open file
std::ifstream fp(filename.c_str(), std::ios::in);
if (!fp.good())
{
CGoGNerr << "Unable to open file " << filename << CGoGNendl;
return false;
}
std::string ligne;
unsigned int nbv, nbt;
// reading number of vertices
std::getline (fp, ligne);
std::stringstream oss(ligne);
oss >> nbv;
// reading number of tetrahedra
std::getline (fp, ligne);
std::stringstream oss2(ligne);
oss2 >> nbt;
//reading vertices
std::vector<unsigned int> verticesID;
verticesID.reserve(nbv);
for(unsigned int i = 0; i < nbv;++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size() == 0);
std::stringstream oss(ligne);
float x,y,z;
oss >> x;
oss >> y;
oss >> z;
// TODO : if required read other vertices attributes here
VEC3 pos(x*scaleFactor,y*scaleFactor,z*scaleFactor);
unsigned int id = container.insertLine();
positions[id] = pos;
verticesID.push_back(id);
}
m_nbVertices = nbv;
m_nbVolumes = nbt;
// lecture tetra
// normalement m_nbVolumes*12 (car on ne charge que des tetra)
m_nbFaces=nbt*4;
m_emb.reserve(nbt*12);
for (unsigned int i = 0; i < m_nbVolumes ; ++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size()==0);
std::stringstream oss(ligne);
int n;
oss >> n; // nb de faces d'un volume ?
m_nbEdges.push_back(3);
m_nbEdges.push_back(3);
m_nbEdges.push_back(3);
m_nbEdges.push_back(3);
int s0,s1,s2,s3;
oss >> s0;
oss >> s1;
oss >> s2;
oss >> s3;
m_emb.push_back(verticesID[s0]);
m_emb.push_back(verticesID[s1]);
m_emb.push_back(verticesID[s2]);
m_emb.push_back(verticesID[s1]);
m_emb.push_back(verticesID[s0]);
m_emb.push_back(verticesID[s3]);
m_emb.push_back(verticesID[s2]);
m_emb.push_back(verticesID[s1]);
m_emb.push_back(verticesID[s3]);
m_emb.push_back(verticesID[s0]);
m_emb.push_back(verticesID[s2]);
m_emb.push_back(verticesID[s3]);
}
fp.close();
return true;
}
bool MeshTablesVolume<PFP>::importTet(const std::string& filename, std::vector<std::string>& attrNames)
{
VertexAttribute<VEC3, MAP> position = m_map.template getAttribute<VEC3, VERTEX, MAP>("position") ;
if (!position.isValid())
position = m_map.template addAttribute<VEC3, VERTEX, MAP>("position") ;
attrNames.push_back(position.name()) ;
AttributeContainer& container = m_map.template getAttributeContainer<VERTEX>() ;
//open file
std::ifstream fp(filename.c_str(), std::ios::in);
if (!fp.good())
{
CGoGNerr << "Unable to open file " << filename << CGoGNendl;
return false;
}
std::string ligne;
// reading number of vertices
std::getline (fp, ligne);
std::stringstream oss(ligne);
oss >> m_nbVertices;
// reading number of tetrahedra
std::getline (fp, ligne);
std::stringstream oss2(ligne);
oss2 >> m_nbVolumes;
//reading vertices
std::vector<unsigned int> verticesID;
verticesID.reserve(m_nbVertices);
for(unsigned int i = 0; i < m_nbVertices; ++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size() == 0);
std::stringstream oss(ligne);
float x,y,z;
oss >> x;
oss >> y;
oss >> z;
// TODO : if required read other vertices attributes here
VEC3 pos(x,y,z);
unsigned int id = container.insertLine();
position[id] = pos;
verticesID.push_back(id);
}
// reading volumes
m_nbFaces.reserve(m_nbVolumes*4);
m_emb.reserve(m_nbVolumes*12);
unsigned int nbc = 0;
for (unsigned int i = 0; i < m_nbVolumes ; ++i)
{
do
{
std::getline (fp, ligne);
} while (ligne.size()==0);
std::stringstream oss(ligne);
int n;
oss >> n; // type of volumes
if(!oss.good())
{
oss.clear();
char dummy;
oss >> dummy; // type of volumes
oss >> dummy;
if(dummy == 'C')// connector
{
++nbc;
m_nbFaces.push_back(3);
int s0,s1,s2,s3;
oss >> s0;
oss >> s1;
oss >> s2;
oss >> s3;
//std::cout << "connector " << s0 << " " << s1 << " " << s2 << " " << s3 << std::endl;
m_emb.push_back(verticesID[s0]);
m_emb.push_back(verticesID[s1]);
m_emb.push_back(verticesID[s2]);
m_emb.push_back(verticesID[s3]);
}
}
int main(int argc, char **argv)
{
//*****************************SET PARAMETERS*************************************************
Parameters params(argc, argv, 0);
Parameters params2(argc, argv, 1);
//********************************************************************************************
//**********************READ DATA AND MAKE SOLUTION*******************************************
Solution* sol = constructSolution(params);
preprocesData(sol);
Solution* sol2 = constructSolution(params2);
preprocesData(sol2);
//*********************************************************************************************
//*****************************SET PARAMETERS*************************************************
if(sol->getNumberOfProcesses() * sol->getNumberOfMachines() <= 100 * 1000) {
params2.delta = params.delta = 40;
params2.nmb_iters_bpr = params.nmb_iters_bpr = 300;
params2.nmbRanges = params.nmbRanges = 7;
params2.rangeLength = params.rangeLength = sol->getNumberOfProcesses() / params.nmbRanges;
}
else {
params2.nmb_iters_bpr = params.nmb_iters_bpr = 100;
params2.nmbRanges = params.nmbRanges = 5;
params2.rangeLength = params.rangeLength = sol->getNumberOfProcesses() / params.nmbRanges;
params2.numberOfBestProcessesToConsiderShiftSwap =
params.numberOfBestProcessesToConsiderShiftSwap = 3;
params2.nmbLoops = params.nmbLoops = 2;
if(sol->getNumberOfProcesses() * sol->getNumberOfMachines() >= 20000 * 2000)
params2.nmbLoops = params.nmbLoops = 1;
}
params2.seedValue = params.seedValue + 1000;
//********************************************************************************************
if(sol->getNumberOfProcesses() * sol->getNumberOfMachines() <= 100 * 1000) // A instances
solveA(params, sol, params2, sol2);
else // B instances
solveB(params, sol, params2, sol2);
long timeToSleep = params.time_limit - (time(0) - params.programStartTime) - 3;
if (timeToSleep < 0)
timeToSleep = 0;
sleep(timeToSleep);
// Read Solutions From Files And Write a better one
sol->setOriginalLoadCostWeights();
sol2->setOriginalLoadCostWeights();
//cout << " sol->solutionFilename " << sol->solutionFilename << endl;
//cout << " sol2->solutionFilename " << sol2->solutionFilename << endl;
//cout << " sol->getCost() " << sol->getCost() << endl;
//cout << " sol2->getCost() " << sol2->getCost() << endl;
readSolutionFromFile( sol, sol->solutionFilename);
readSolutionFromFile(sol2, sol2->solutionFilename);
//cout << " after sol->getCost() " << sol->getCost() << endl;
//cout << " after sol2->getCost() " << sol2->getCost() << endl;
if ((sol->getCost() < sol2->getCost()) && (sol->checkConflict(false)))
sol->writeToFile(params.solution_filename);
else
sol2->writeToFile(params.solution_filename);
//remove solution files
ostringstream oss1(""); oss1 << "rm " << sol->solutionFilename;
system(oss1.str().c_str());
ostringstream oss2(""); oss2 << "rm " << sol2->solutionFilename;
system(oss2.str().c_str());
//*****************************************FILES (REMOVE THIS PART)********************************************************
/*fstream fileResults("results", ios::out | ios::app);
fileResults << setw(5) << params.seedValue << setw(30) << params.data_filename
<< setw(20) << sol->getCost()
<< setw(20) << sol2->getCost()
<< setw(20) << *(params.best_objective)
<< setw(15) << time(0) - params.programStartTime << endl;
// running times
fstream fileRunnungTimes("runnung_times", ios::out | ios::app);
fileRunnungTimes << setw(5) << setw(30) << params.data_filename << setw(20) << *(params.best_objective)
<< setw(20) << time(0) - params.programStartTime << endl;
// check solution with official checker
ostringstream oss("");
oss << "./checker " << params.data_filename << " " << params.initial_assignment_filename
<< " " << params.solution_filename;
oss << " >> checkerFile ";
system(oss.str().c_str());
*/
//*************************************************************************************************************************
return 0;
}
