// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- 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; }