// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::execute()
{
int err = 0;
std::stringstream ss;
SurfaceMeshDataContainer* sm = getSurfaceMeshDataContainer();
dataCheck(false, 1, 1, 1);
if(getErrorCondition() < 0)
{
return;
}
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
std::string parentPath = MXAFileInfo::parentPath(getOutputFile());
if(!MXADir::mkdir(parentPath, true))
{
std::stringstream ss;
ss << "Error creating parent path '" << parentPath << "'";
notifyErrorMessage(ss.str(), -1);
setErrorCondition(-1);
return;
}
DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = sm->getVertices();
DREAM3D::SurfaceMesh::FaceListPointer_t trianglePtr = sm->getFaces();
// Get the Labels(GrainIds or Region Ids) for the triangles
Int32ArrayType::Pointer faceLabelsPtr = boost::dynamic_pointer_cast<Int32ArrayType>(sm->getFaceData(DREAM3D::FaceData::SurfaceMeshFaceLabels));
int32_t* faceLabels = faceLabelsPtr->GetPointer(0);
// Store all the unique Spins
std::set<int> uniqueSpins;
for (int i = 0; i < trianglePtr->GetNumberOfTuples(); i++)
{
uniqueSpins.insert(faceLabels[i*2]);
uniqueSpins.insert(faceLabels[i*2+1]);
}
FILE* f = fopen(m_OutputFile.c_str(), "wb");
ScopedFileMonitor fileMonitor(f);
err = writeHeader(f, nodesPtr->GetNumberOfTuples(), trianglePtr->GetNumberOfTuples(), uniqueSpins.size()-1);
err = writeNodes(f);
err = writeTriangles(f);
err = writeGrains(f);
setErrorCondition(0);
notifyStatusMessage("Complete");
return;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void GoldfeatherReader::execute()
{
int err = 0;
std::stringstream ss;
setErrorCondition(err);
SurfaceMeshDataContainer* m = getSurfaceMeshDataContainer();
if(NULL == m)
{
setErrorCondition(-999);
notifyErrorMessage("The Voxel DataContainer Object was NULL", -999);
return;
}
setErrorCondition(0);
FILE* f = fopen(m_InputFile.c_str(), "r");
if (NULL == f)
{
setErrorCondition(-999);
notifyErrorMessage("Error opening Input file", getErrorCondition());
return;
}
ScopedFileMonitor fileMonitor(f);
int nNodes = 0;
fscanf(f, "%d\n", &nNodes);
dataCheck(false, nNodes, 1, 1);
// Allocate the Nodes, Normals, curvatures and principal direction vectors
DREAM3D::SurfaceMesh::VertListPointer_t nodesPtr = DREAM3D::SurfaceMesh::VertList_t::CreateArray(nNodes, DREAM3D::VertexData::SurfaceMeshNodes);
nodesPtr->initializeWithZeros();
DREAM3D::SurfaceMesh::Vert_t* nodes = nodesPtr->GetPointer(0);
DoubleArrayType::Pointer normalsPtr = DoubleArrayType::CreateArray(nNodes, 3, DREAM3D::VertexData::SurfaceMeshNodeNormals);
double* normals = normalsPtr->GetPointer(0);
DoubleArrayType::Pointer pcurv1Ptr = DoubleArrayType::CreateArray(nNodes, 1, "Principal_Curvature_1");
double* pcurv1 = pcurv1Ptr->GetPointer(0);
DoubleArrayType::Pointer pcurv2Ptr = DoubleArrayType::CreateArray(nNodes, 1, "Principal_Curvature_2");
double* pcurv2 = pcurv2Ptr->GetPointer(0);
DoubleArrayType::Pointer pDirection1Ptr = DoubleArrayType::CreateArray(nNodes, 3, "Principal_Direction_1");
double* pDirection1 = pDirection1Ptr->GetPointer(0);
DoubleArrayType::Pointer pDirection2Ptr = DoubleArrayType::CreateArray(nNodes, 3, "Principal_Direction_2");
double* pDirection2 = pDirection2Ptr->GetPointer(0);
float x, y, z, n0, n1, n2, p1, p2;
for(int n = 0; n < nNodes; ++n)
{
fscanf(f, "%f %f %f %f %f %f %f %f\n", &x, &y, &z, &n0, &n1, &n2, &p1, &p2);
nodes[n].pos[0] = x;
nodes[n].pos[1] = y;
nodes[n].pos[2] = z;
normals[n*3+0] = n0;
normals[n*3+1] = n1;
normals[n*3+2] = n2;
pcurv1[n] = p1;
pcurv2[n] = p2;
// Read the next line of the data which is the principal direction vectors
fscanf(f, "%f %f %f %f %f %f\n", &x, &y, &z, &n0, &n1, &n2);
pDirection1[n*3+0] = x;
pDirection1[n*3+1] = y;
pDirection1[n*3+2] = z;
pDirection2[n*3+0] = n0;
pDirection2[n*3+1] = n1;
pDirection2[n*3+2] = n2;
}
m->setVertices(nodesPtr);
m->addVertexData(normalsPtr->GetName(), normalsPtr);
m->addVertexData(pcurv1Ptr->GetName(), pcurv1Ptr);
m->addVertexData(pcurv2Ptr->GetName(), pcurv2Ptr);
m->addVertexData(pDirection1Ptr->GetName(), pDirection1Ptr);
m->addVertexData(pDirection2Ptr->GetName(), pDirection2Ptr);
int nTriangles = 0;
err = fscanf(f, "%d\n", &nTriangles);
if (err < 0)
{
off_t fpos;
fpos = ftell(f);
setErrorCondition(-876);
notifyErrorMessage("Error Reading the number of Triangles from the file", getErrorCondition());
return;
}
DREAM3D::SurfaceMesh::FaceListPointer_t trianglesPtr = DREAM3D::SurfaceMesh::FaceList_t::CreateArray(nTriangles, DREAM3D::FaceData::SurfaceMeshFaces);
trianglesPtr->initializeWithZeros();
DREAM3D::SurfaceMesh::Face_t* triangles = trianglesPtr->GetPointer(0);
DataArray<int32_t>::Pointer faceLabelPtr = DataArray<int32_t>::CreateArray(nTriangles, 2, DREAM3D::FaceData::SurfaceMeshFaceLabels);
faceLabelPtr->initializeWithZeros();
int32_t* faceLabels = faceLabelPtr->GetPointer(0);
DoubleArrayType::Pointer triNormalsPtr = DoubleArrayType::CreateArray(nTriangles, 3, DREAM3D::FaceData::SurfaceMeshFaceNormals);
double* triNormals = triNormalsPtr->GetPointer(0);
for(int t = 0; t < nTriangles; ++t)
{
fscanf(f, "%f %f %f %f %f %f", &x, &y, &z, &n0, &n1, &n2);
triangles[t].verts[0] = x;
triangles[t].verts[1] = y;
triangles[t].verts[2] = z;
// triangles[t].tIndex = t;
faceLabels[t*2] = 0;
faceLabels[t*2+1] = 1;
triNormals[t*3+0] = n0;
triNormals[t*3+1] = n1;
triNormals[t*3+2] = n2;
}
m->setFaces(trianglesPtr);
m->addFaceData(faceLabelPtr->GetName(), faceLabelPtr);
m->addFaceData(triNormalsPtr->GetName(), triNormalsPtr);
/* Let the GUI know we are done with this filter */
notifyStatusMessage("Complete");
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void AbaqusSurfaceMeshWriter::execute()
{
int32_t err = 0;
setErrorCondition(err);
dataCheck();
if(getErrorCondition() < 0) { return; }
DataContainer::Pointer sm = getDataContainerArray()->getDataContainer(getSurfaceMeshFaceLabelsArrayPath().getDataContainerName());
// Make sure any directory path is also available as the user may have just typed
// in a path without actually creating the full path
QFileInfo fi(getOutputFile());
QDir parentPath = fi.path();
if(!parentPath.mkpath("."))
{
QString ss = QObject::tr("Error creating parent path '%1'").arg(parentPath.absolutePath());
setErrorCondition(-8005);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
TriangleGeom::Pointer triangleGeom = sm->getGeometryAs<TriangleGeom>();
// Store all the unique Spins
std::set<int32_t> uniqueSpins;
for (int64_t i = 0; i < triangleGeom->getNumberOfTris(); i++)
{
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2]);
uniqueSpins.insert(m_SurfaceMeshFaceLabels[i * 2 + 1]);
}
FILE* f = fopen(m_OutputFile.toLatin1().data(), "wb");
ScopedFileMonitor fileMonitor(f);
err = writeHeader(f, triangleGeom->getNumberOfVertices(), triangleGeom->getNumberOfTris(), uniqueSpins.size() - 1);
if(err < 0)
{
QString ss = QObject::tr("Error writing header for file '%1'").arg(m_OutputFile);
setErrorCondition(-8001);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeNodes(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing nodes for file '%1'").arg(m_OutputFile);
setErrorCondition(-8002);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeTriangles(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing triangles for file '%1'").arg(m_OutputFile);
setErrorCondition(-8003);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
err = writeFeatures(f);
if(err < 0)
{
QString ss = QObject::tr("Error writing Features for file '%1'").arg(m_OutputFile);
setErrorCondition(-8004);
notifyErrorMessage(getHumanLabel(), ss, getErrorCondition());
return;
}
notifyStatusMessage(getHumanLabel(), "Complete");
}
int main(int argc, char *argv[]) {
if (argc <= 3) {
fprintf( stderr, "Usage: %s time word file1 file2 ...\n", argv[0]);
exit(1);
}
noFiles = 0;
int TIME = atoi(argv[1]);
char* word = argv[2];
numFiles = argc-3;
//files
pid_t temp[numFiles];
pidsFile = temp;
unsigned i;
for(i = 0; i < numFiles; i++) {
pidsFile[i] = fork();
if(pidsFile[i] < 0) {
fprintf(stderr, "Error while forking\n");
exit(1);
}
else if (pidsFile[i] > 0) {
//PARENT
}
else {
//SON
searchWord(argv[i+3], word);
}
}
pidFileMonitor = fork();
if(pidFileMonitor < 0) {
fprintf(stderr, "Error while forking\n");
exit(1);
}
//child process
else if(pidFileMonitor > 0) {
//parent process
}
else {
//child process
char* files[numFiles];
for(i = 0;i<numFiles;i++)
files[i] = argv[i+3];
fileMonitor(files);
}
struct sigaction action;
// prepare the 'sigaction struct'
action.sa_handler = handler;
sigemptyset(&action.sa_mask);
action.sa_flags = 0;
// install the handler
if (sigaction(SIGUSR1,&action,NULL)<0 || sigaction(SIGUSR2,&action,NULL)<0 || sigaction(SIGCHLD,&action,NULL) < 0) {
fprintf(stderr, "Error while instaling handlers...");
exit(1);
}
while(TIME > 0 && noFiles == 0)
TIME = sleep(TIME);
noFiles = 1;
if(noFiles == 1)
processHandler();
return 0;
}
int main (int argc, char* argv[]){
//Primero se debe definir un parser que lee desde la linea de comandos o un archivo
eoParser parser(argc, argv);
//Se definen los parametros, se leen desde el parser y le asigna el valor
//Datos necesarios del escenario de prueba
double _min = parser.createParam((double)(0.0), "ValorMinimo", "Delimitacion area de trabajo",'M',"Parametros Escenario").value();
double _max = parser.createParam((double)(20.0), "ValorMaximo", "Delimitacion area de trabajo",'S',"Parametros Escenario").value();
unsigned int NoAnclas = parser.createParam((unsigned int)(10), "Anclas", "Numero de nodos anclas",'A',"Parametros Escenario").value();
unsigned int nodos = parser.createParam((unsigned int)(100), "Nodos", "Total de nodos",'N',"Parametros Escenario").value();
double radio = parser.createParam((double)(5), "Radio", "Radio de comunicacion",'R',"Parametros Escenario").value();
double DisReal[200][200];
double vecAnclas[NoAnclas*2];
//Configuracion parametros algoritmo
unsigned int POP_SIZE = parser.createParam((unsigned int)(100), "PopSize", "Tamano de la poblacion",'P',"Parametros Algoritmo").value();
unsigned int numberGeneration = parser.createParam((unsigned int)(1000), "MaxGen", "Criterio de parada, Numero maximo de generaciones",'G',"Parametros Algoritmo").value();
unsigned int Nc = parser.createParam((unsigned int)(2), "Nc", "Constante del operador SBX",'C',"Parametros Algoritmo").value();
double Pcruza = parser.createParam((double)(0.87), "Pcruza", "Probabilidad de cruzamiento SBX",'X',"Parametros Algoritmo").value();
double Pmutation = parser.createParam((double)(0.85), "Pmutacion", "Probabilidad de mutacion de la encapsulacion de SVN y Swap",'Y',"Parametros Algoritmo").value();
double Pmutation1 = parser.createParam((double)(0.85), "Pmutacion1", "Probabilidad de mutacion de SVN",'Z',"Parametros Algoritmo").value();
double Pmutation2 = parser.createParam((double)(0.5), "Pmutacion2", "Probabilidad de mutacion de Swap",'W',"Parametros Algoritmo").value();
double sizeTorneo = parser.createParam((double)(8), "SizeTorneo", "Tamano del torneo para seleccion de individuos",'L',"Parametros Algoritmo").value();
double sizeElist = parser.createParam((double)(2), "SizeElist", "Cantidad de individuos que se conservan",'B',"Parametros Algoritmo").value();
double sizeTorneo1 = parser.createParam((double)(2), "SizeTorneo1", "Tamano del torneo para seleccion de individuos del elitismo",'Q',"Parametros Algoritmo").value();
//Parametros de guardado
unsigned int setGeneracion = parser.createParam((unsigned int)(100), "setGeneracion", "Cada cuantas generaciones se guarda la poblacion",'T',"Guardar Datos").value();
unsigned int setTime = parser.createParam((unsigned int)(0), "setTime", "Cada cuantos segundos se guarda la configuracion",'I',"Guardar Datos").value();
//Grafica
std::string InPut = parser.createParam(std::string("Estadistica.txt"), "Input", "Archivo que contiene el Fitness, Media, DevStand",'o',"Salida - Grafica").value();
bool graficaGnuplot = parser.createParam((bool)(0), "Gnuplot", "Grafica el Fitness y Media, 0 desactivado y 1 activado",'g',"Salida - Grafica").value();
//Termina la ejecucion al consultar la ayuda
if (parser.userNeedsHelp())
{
parser.printHelp(std::cout);
exit(1);
}
//Verifica el ingreso de las probabilidades
if ( (Pcruza < 0) || (Pcruza > 1) ) throw std::runtime_error("Pcruza Invalido");
if ( (Pmutation < 0) || (Pmutation > 1) ) throw std::runtime_error("Pmutation encapsulación Invalido");
if ( (Pmutation1 < 0) || (Pmutation1 > 1) ) throw std::runtime_error("Pmutation de SVN Invalido");
if ( (Pmutation2 < 0) || (Pmutation2 > 1) ) throw std::runtime_error("Pmutation de Swap Invalido");
//Parametro de tiempo
struct timeval ti, tf;
double tiempo;
/**CARGAR EL ESCENARIO**/
//Escenario
//Lee desde archivo
escenario *pEscenario = new escenario(nodos, NoAnclas);
//Matriz de distancia
for (int i=0; i<nodos ; i++)
{for (int j=0; j<nodos; j++)DisReal[i][j] = pEscenario->obtenerDisRSSI(i,j);}
//Posicion Nodos anclas
for (int i=0 ; i<NoAnclas*2 ; i++)vecAnclas[i] = pEscenario->obtenerAnclas(i);
/**--------------------------------------------------------------**/
//Define la representación (Individuo)
Individuo cromosoma;
//Para la inicialización del cromosoma, primero se debe definir como se generaran los genes
//Se utilizara un generador uniforme, (valor min, valor max)
eoUniformGenerator<double> uGen(_min, _max);
//Crear el inicializador para los cromosomas, llamado random
IndiInit random(nodos*2,uGen);
//Generar una subclase de la clase de la función de evaluación
localizacionEvalPenal Fitness;
//Criterio de parada
eoGenContinue<Individuo> parada(numberGeneration);
//Es otro criterio de parada en el cual se define el minimo de generaciones y cuantas generaciones sin mejoras
//eoSteadyFitContinue<Individuo> parada(10,2);
/** CRUZA **/
// Generar los limites para cada gen
std::vector<double> min_b;
std::vector<double> max_b;
for(int i=0; i<nodos*2; i++) {
min_b.push_back(_min);
max_b.push_back(_max);
}
eoRealVectorBounds bounds(min_b, max_b);
//Inicializar operador de cruce SBX
individuoCruza crossover(bounds, Nc);
//Cargar cantidad nodos anclas al operador
crossover.setNoAnclas(NoAnclas);
/** MUTACION **/
//Subclase de mutacion paper IEEE
individuoMutacion mutationA(NoAnclas,numberGeneration,nodos,_min,_max);
//Mutacion incluida en EO, permite llegar mas rapido a un fitness de 600
individuoMutacion0 mutationB;
//Combina operadores de mutacion con su respectivo peso
eoPropCombinedMonOp<Individuo> mutation(mutationA,Pmutation1);
mutation.add(mutationB, Pmutation2);
//Define un objeto de encapsulación (it contains, the crossover, the crossover rate, the mutation and the mutation rate) -> 1 line
eoSGATransform<Individuo> encapsulacion(crossover, Pcruza, mutation, Pmutation); //0.87
//Define el método de selección, selecciona un individuo por cada torneo (en el parentesis se define el tamaño del torneo)
eoDetTournamentSelect<Individuo> torneo(sizeTorneo);
//Define un "eoSelectPerc" con el torneo como parametro por defecto (permite seleccionar el mejor individuo)
eoSelectPerc<Individuo> seleccion(torneo);
//Define una estrategia de reemplazo por cada generación
//eoGenerationalReplacement<Individuo> reemplazo;
////Otra estrategia de reemplazo con elitismo
eoElitism<Individuo> reemplazo(sizeElist,false); //antes 0.6
//Para utilizar eoElitism se define un eoDetTournamentTruncate para seleccionar los individuos para el elitismo
eoDetTournamentTruncate<Individuo> Trunca(sizeTorneo1);// antes 2
//Define una poblacion de Individuos
eoPop<Individuo> poblacion;
//Cargar la matriz de distancias, cantidad nodos anclas y total de nodos
Fitness.guardarDisReal(DisReal, NoAnclas, nodos, radio);
//Cargar posiciones nodos anclas
Fitness.guardarAnclas(vecAnclas);
//Llena la población y evalua cada cromosoma
for(int i=0 ; i<POP_SIZE ; i++)
{
random(cromosoma);
Fitness(cromosoma);
poblacion.push_back(cromosoma);
}
//Imprime la población
//poblacion.printOn(std::cout);
//Imprime un salto de linea
std::cout<< std::endl;
//Contenedor de clases
eoCheckPoint<Individuo> PuntoChequeo(parada);
//Cargar el valor de la generacion actual al operador de mutación
//Se inicializa el contador de generaciones
eoIncrementorParam<unsigned> generationCounter("Gen.");
//Se carga el contador de generaciones al operador de mutación
mutationA.setGen(& generationCounter);
//Se carga el contador de generaciones al objeto eoCheckpoint para contar el número de generaciones
PuntoChequeo.add(generationCounter);
/** Guardar datos de la población en archivos **/
//Genera un archivo para guardar parametros
eoState estado;
//Guardar todo lo que necesites a la clase hija estado
estado.registerObject(poblacion);
//estado.registerObject(parser);
//Guarda el tiempo de ejecucion desde la primera generacion
eoTimeCounter time;
PuntoChequeo.add(time);
//Define cada cuantas generaciones se guarda la poblacion
eoCountedStateSaver GuardarEstado(setGeneracion,estado,"generacion");
//Siempre se debe agregar a la clase hija de eoCheckPoint para que se ejecute en cada generacion
PuntoChequeo.add(GuardarEstado);
//Guardar algunas estadisticas de la poblacion
//Muestra el mejor fitness de cada generación
eoBestFitnessStat<Individuo> Elmejor("Mejor Fitness");
//La media y stdev
eoSecondMomentStats<Individuo> SegundoStat;
//Se agrega al eoCheckPoint
PuntoChequeo.add(Elmejor);
PuntoChequeo.add(SegundoStat);
// Guarda los parametros a un archivo
eoFileMonitor fileMonitor("stats.xg", " ");
PuntoChequeo.add(fileMonitor);
fileMonitor.add(generationCounter); //Numero de generaciones
fileMonitor.add(time); //Tiempo total de ejecucion desde la primera generacion
fileMonitor.add(Elmejor); //Mejor fitness
fileMonitor.add(SegundoStat); //Media y desviacion estandar
///** Grafica **/
// eoFileMonitor fileMonitor1(InPut, " ");
// fileMonitor1.add(Elmejor); //Mejor fitness
// fileMonitor1.add(SegundoStat); //Media y desviacion estandar
// PuntoChequeo.add(fileMonitor1); //Agrega al checkpoint
// GnuplotMonitor grafica(InPut,graficaGnuplot); //Grafica el fitness y la media
// grafica.setGen(& generationCounter); //Carga la generacion
// PuntoChequeo.add(grafica);
///**------------------------------------------**/
// Incializa el algoritmo genetico secuencial
eoEasyEA<Individuo> algoritmo(PuntoChequeo, Fitness, seleccion, encapsulacion, reemplazo, Trunca);
//Tiempo inicial
gettimeofday(&ti, NULL);
//Corre el algoritmo en la poblacion inicializada
algoritmo(poblacion);
//Tiempo Final
gettimeofday(&tf, NULL);
std::cout << std::endl;
//Imprime el mejor cromosoma
poblacion.best_element().printOn(std::cout);
std::cout << std::endl;
std::cout << std::endl;
//Imprime el tiempo de ejecución del algoritmo
tiempo = (tf.tv_sec - ti.tv_sec)*1000 + (tf.tv_usec - ti.tv_usec)/1000.0;
std::cout <<"Tiempo de ejecucion en milisegundos: " << tiempo << std::endl;
std::cout << std::endl;
//Se grafica el error y todos los nodos
std::string filename="generacion";
graphError error(filename, setGeneracion, numberGeneration, nodos, NoAnclas, _max);
std::cout << std::endl;
return EXIT_SUCCESS;
}
