void AlmacenaToComsol_1::aplicar(Malla *malla, string filename){ //Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje. setlocale(LC_NUMERIC, "POSIX"); FILE *archivo_x = fopen(filename.c_str(),"w"); char separador1[32] = "% Coordinates\n"; fprintf(archivo_x,"%s",separador1); Nodos *nds = malla->getNodos(); Caras *crs = malla->getCaras(); Nodo *nodo; int* nuevoIndiceNodos=new int[nds->getNumNodos()]; int nlinea=0; for(int i=0; i<nds->getNumNodos(); i++) { nodo = nds->getNodo(i); if(nodo != NULL) { fprintf(archivo_x,"%f %f %f\n",nodo->getPunto()->getX(),nodo->getPunto()->getY(),nodo->getPunto()->getZ()); nuevoIndiceNodos[i]=nlinea; nlinea++; } } char separador2[32] = "% Elements (triangular)\n"; fprintf(archivo_x,"%s",separador2); Cara *c; vector<int> ind_nodos; for(int i=0; i<crs->getNumCaras(); i++) { c = crs->getCara(i); if(c != 0) { ind_nodos = c->getNodos(); //Nota: Se invierte el orden de insercion de los puntos, para que las normales queden seteadas correctamente. //ya que en el archivo cms_1 los nodos estan al reves, dejando las normales hacia adentro. fprintf(archivo_x,"%d %d %d\n",nuevoIndiceNodos[ind_nodos[2]]+1,nuevoIndiceNodos[ind_nodos[1]]+1,nuevoIndiceNodos[ind_nodos[0]]+1); } } delete nuevoIndiceNodos; fclose(archivo_x); setlocale(LC_NUMERIC, ""); }
Malla* GeneraFromArchivosXYZU::aplicar() { int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados //Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje. setlocale(LC_NUMERIC, "POSIX"); FILE *arch_x = fopen(archivo_x.c_str(),"r"); FILE *arch_y = fopen(archivo_y.c_str(),"r"); FILE *arch_z = fopen(archivo_z.c_str(),"r"); FILE *arch_u = fopen(archivo_u.c_str(),"r"); char line[50]; char cx[16]; char cy[16]; char cz[16]; int num_puntos, num_caras; float x,y,z,nx,ny,nz,u; fscanf(arch_x,"%s %s\n",line,line); fscanf(arch_y,"%s %s\n",line,line); fscanf(arch_z,"%s %s\n",line,line); fscanf(arch_u,"%s %s\n",line,line); num_puntos=0; Nodos *nodos = new Nodos(); Nodo *nodo; while(true) { fscanf(arch_x,"%s %s %s\n",cx,cy,cz); fscanf(arch_y,"%s %s %s\n",cx,cy,cz); fscanf(arch_z,"%s %s %s\n",cx,cy,cz); fscanf(arch_u,"%s %s %s\n",cx,cy,cz); if(strcmp(cx,"%") == 0) { break; } sscanf(cx,"%f",&x); sscanf(cy,"%f",&y); sscanf(cz,"%f",&z); nodo = new Nodo(Punto(x,y,z)); nodos->addNodo(nodo); num_puntos++; } map<pair<int,int>,int> ind_arcos; map<pair<int,int>,int>::iterator iter1; map<pair<int,int>,int>::iterator iter2; vector<int> indice_puntos; vector<int> indice_arcos; Arcos *arcos = new Arcos(); Caras *caras = new Caras(); Cara *c; int indice; char *token; int indices[4]; int n_lados; num_caras=0; while(true) { fgets(line, 50, arch_x); fgets(line, 50, arch_y); fgets(line, 50, arch_z); fgets(line, 50, arch_u); if(strpbrk("%",line) != NULL) { break; } token = strtok(line," "); for(int i=0; i<3; ++i) { sscanf(token,"%d",&indices[i]); token = strtok(NULL, " "); } if(token == NULL) { // Caso triángulos n_triangulos++; n_lados = 3; } else { // Caso cuadriláteros sscanf(token,"%d",&indices[3]); n_cuadrilateros++; n_lados = 4; } //Nota: Por bug en los archivos de entrada, debo invertir el orden para que las normales queden bien. //for(int i=n_lados-1; i>=0; --i) // invertido por bug archivo entrada for(int i=0; i<n_lados; ++i) // así debiera ser indice_puntos.push_back(indices[i]-1); for(int j=0; j<n_lados; j++) { int ind1 = indice_puntos[j]; int ind2 = indice_puntos[int(fmod(j+1,n_lados))]; pair<int,int> pr1(ind1,ind2); pair<int,int> pr2(ind2,ind1); iter1 = ind_arcos.find(pr1); iter2 = ind_arcos.find(pr2); if(iter1 != ind_arcos.end()) indice_arcos.push_back(iter1->second); else if(iter2 != ind_arcos.end()) indice_arcos.push_back(iter2->second); else { indice = arcos->addArco(new Arco(ind1,ind2)); indice_arcos.push_back(indice); ind_arcos.insert(make_pair(pr1,indice)); nodos->addArcoNodo(ind1,indice); nodos->addArcoNodo(ind2,indice); } } if(n_lados == 3) c = new Triangulo(indice_puntos,indice_arcos); else // n_lados == 4 c = new Cuadrilatero(indice_puntos,indice_arcos); int ind_cara = caras->addCara(c); num_caras++; for(int j=0; j<n_lados; j++) { arcos->setCaraArco(indice_arcos[j],ind_cara); nodos->addCaraNodo(indice_puntos[j],ind_cara); } indice_puntos.clear(); indice_arcos.clear(); } float max_concentracion = 0; float min_concentracion = 999999999; for(int i=0; i<num_puntos; i++) { fscanf(arch_x,"%f\n",&nx); fscanf(arch_y,"%f\n",&ny); fscanf(arch_z,"%f\n",&nz); fscanf(arch_u,"%f\n",&u); if(u < min_concentracion) { min_concentracion = u; } if(u > max_concentracion) { max_concentracion = u; } Vect normal = Vect(nx,ny,nz); nodos->getNodo(i)->setNormal(normal); nodos->getNodo(i)->setConcentracion(u); } cout << "max_concentracion = " << max_concentracion << endl; cout << "min_concentracion = " << min_concentracion << endl; Malla *malla = 0; if(n_cuadrilateros == 0) malla = new MallaTriangulos(nodos,arcos,caras); else if(n_triangulos == 0) malla = new MallaCuadrilateros(nodos,arcos,caras); else malla = new Malla(nodos,arcos,caras); malla->setConcentracionMax(max_concentracion); malla->setConcentracionMin(min_concentracion); fclose(arch_x); fclose(arch_y); fclose(arch_z); fclose(arch_u); setlocale(LC_NUMERIC, ""); //Chequeamos consistencia topologica. int V=malla->getNumNodos(); int E=malla->getNumArcos(); int F=malla->getNumCaras(); cout << "Numero de nodos=" << V << endl; cout << "Numero de arcos=" << E << endl; cout << "Numero de caras=" << F << endl; if (V-E+F==2 || V-E+F==0) cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl; else cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V(" << V << ")-E(" << E << "+F("<< F << ")=" << V-E+F << " y deberia ser V-E+F=2" << endl; assert(malla->checkMalla(true) >= 0); return malla; }
/* * Genera una malla de triángulos desde un archivo en formato MatLab. * El archivo se divide en cuatro grupos de filas: primero todas las * coordenadas x, luego todas las coordenadas z, luego las coordenadas y * y finalmente las concentraciones en los nodos. */ Malla* GeneraFromMatLab::generaMallaTriangulos() { //Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje. setlocale(LC_NUMERIC, "POSIX"); FILE *mat = fopen(archivo.c_str(),"r"); float flt; if(num_anillos == 0) { FILE *mat2 = fopen(archivo.c_str(),"r"); if(num_puntos == 0) { num_puntos = 90; } int num = 0; while(fscanf(mat2,"%f\n",&flt) != EOF) { num++; } num_anillos = num/(4*num_puntos); fclose(mat2); } int num_nodos = num_anillos * num_puntos; // número de nodos de la malla Nodos *nodos = new Nodos(); Nodo *nodo; Punto p; double max_concentracion = 0.0; double min_concentracion = 99999999.0; // Generamos los nodos de la malla, con la información en el archivo. for(int j=0; j<4; j++) { for(int i=0; i<num_nodos; i++) { fscanf(mat,"%f\n",&flt); if(j == 0) { p = Punto(flt,0,0); nodo = new Nodo(p); nodos->addNodo(nodo); } //Invierto Y y Z para que se despliegue correctamente en la aplicacion. else if(j == 1) { Punto aux=nodos->getNodo(i)->getPunto(); aux.setZ(flt); nodos->getNodo(i)->setPunto(aux); } else if(j == 2) { Punto aux=nodos->getNodo(i)->getPunto(); aux.setY(flt); nodos->getNodo(i)->setPunto(aux); } else { if(flt < min_concentracion) { min_concentracion = flt; } if(flt > max_concentracion) { max_concentracion = flt; } nodos->getNodo(i)->setConcentracion(flt); } } } // ahora formamos los arcos y caras. Arco *a; Arcos *arcos = new Arcos(); Cara *c; Caras *caras = new Caras(); int ind_cara1, ind_cara2, ind_arco; int n1, n2, n3, n4; int a1, a2, a3; vector<int> ind_nodos; vector<int> ind_arcos; for(int i=0; i<(num_anillos-1); i++) { for(int j=0; j<num_puntos; j++) { ind_nodos.clear(); ind_arcos.clear(); //se deben generar 2 caras. //cara1: n1 n2 n3 //cara2: n1 n3 n4 n1 = int(fmod(num_puntos*i+j,num_nodos)); n4 = int(fmod(num_puntos*(i+1)+j,num_nodos)); if(j == num_puntos-1) { n2 = n1-num_puntos+1; n3 = n4-num_puntos+1; } else { n2 = int(fmod(num_puntos*i+j+1,num_nodos)); n3 = int(fmod(num_puntos*(i+1)+j+1,num_nodos)); } ind_nodos.push_back(n3); ind_nodos.push_back(n2); ind_nodos.push_back(n1); a1 = 3*(i*num_puntos+j); if(i == num_anillos-2) { a1 = 3*i*num_puntos+4*j; } a2 = a1+1; a3 = a1+2; ind_arcos.push_back(a1); ind_arcos.push_back(a2); ind_arcos.push_back(a3); c = new Triangulo(ind_nodos,ind_arcos); ind_cara1 = caras->addCara(c); nodos->addCaraNodo(n1,ind_cara1); nodos->addCaraNodo(n2,ind_cara1); nodos->addCaraNodo(n3,ind_cara1); ind_nodos.clear(); ind_arcos.clear(); ind_nodos.push_back(n4); ind_nodos.push_back(n3); ind_nodos.push_back(n1); a1 = 3*(i*num_puntos+j)+2; if(i == num_anillos-2) { a1 = 3*i*num_puntos+4*j+2; } a2 = 3*(i+1)*num_puntos+3*j; if(i == num_anillos-3) { a2 = 3*(i+1)*num_puntos+4*j; } else if(i == num_anillos-2) { a2 = a1+1; } a3 = a1 - 4; if(i == num_anillos-2) { if(j==0) { a3 = a1+4*(num_puntos-1)-1; } else { a3 = a1-5; } } else { if(j==0) { a3 = a1+3*(num_puntos-1)-1; } } ind_arcos.push_back(a1); ind_arcos.push_back(a2); ind_arcos.push_back(a3); c = new Triangulo(ind_nodos,ind_arcos); ind_cara2 = caras->addCara(c); nodos->addCaraNodo(n1,ind_cara2); nodos->addCaraNodo(n3,ind_cara2); nodos->addCaraNodo(n4,ind_cara2); int ind_cara3 = -1; if(i != 0) { ind_cara3 = ind_cara1-(2*num_puntos)+1; } a = new Arco(n1,n2,ind_cara1,ind_cara3); ind_arco = arcos->addArco(a); nodos->addArcoNodo(n1,ind_arco); nodos->addArcoNodo(n2,ind_arco); ind_cara3 = ind_cara1+3; if(j == num_puntos-1) { ind_cara3 = ind_cara1-2*(num_puntos-1)+1; } a = new Arco(n2,n3,ind_cara1,ind_cara3); ind_arco = arcos->addArco(a); nodos->addArcoNodo(n2,ind_arco); nodos->addArcoNodo(n3,ind_arco); a = new Arco(n1,n3,ind_cara1,ind_cara2); ind_arco = arcos->addArco(a); nodos->addArcoNodo(n1,ind_arco); nodos->addArcoNodo(n3,ind_arco); if(i == num_anillos-2) { if(j == num_puntos-1) { a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+1,num_nodos)),ind_cara2,-1); ind_arco = arcos->addArco(a); nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco); nodos->addArcoNodo(int(fmod(n1+1,num_nodos)),ind_arco); } else { a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+num_puntos+1,num_nodos)),ind_cara2,-1); ind_arco = arcos->addArco(a); nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco); nodos->addArcoNodo(int(fmod(n1+num_puntos+1,num_nodos)),ind_arco); } } } } Malla *malla = new MallaTriangulos(nodos,arcos,caras); malla->setConcentracionMax(max_concentracion); malla->setConcentracionMin(min_concentracion); malla->setNormales(); fclose(mat); setlocale(LC_NUMERIC, ""); //Chequeamos consistencia topologica. int V=malla->getNumNodos(); int E=malla->getNumArcos(); int F=malla->getNumCaras(); cout << "Numero de nodos=" << V << endl; cout << "Numero de arcos=" << E << endl; cout << "Numero de caras=" << F << endl; if (V-E+F==2 || V-E+F==0) cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl; else cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl; assert(malla->checkMalla(true) >= 0); return malla; }
Malla* GeneraFromMatLab::generaMallaCuadrilateros() { //Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje. setlocale(LC_NUMERIC, "POSIX"); FILE *mat = fopen(archivo.c_str(),"r"); float flt; if(num_anillos == 0) { FILE *mat2 = fopen(archivo.c_str(),"r"); if(num_puntos == 0) { num_puntos = 90; } int num = 0; while(fscanf(mat2,"%f\n",&flt) != EOF) { num++; } num_anillos = num/(4*num_puntos); fclose(mat2); } int num_nodos = num_anillos * num_puntos; // número de nodos de la malla Nodos *nodos = new Nodos(); Nodo *nodo; Punto p; double max_concentracion = 0.0; double min_concentracion = 99999999.0; // Generamos los nodos de la malla, con la información en el archivo. for(int j=0; j<4; j++) { for(int i=0; i<num_nodos; i++) { fscanf(mat,"%f\n",&flt); if(j == 0) { p = Punto(flt,0,0); nodo = new Nodo(p); nodos->addNodo(nodo); } else if(j == 1) { Punto aux=nodos->getNodo(i)->getPunto(); aux.setZ(flt); nodos->getNodo(i)->setPunto(aux); } else if(j == 2) { Punto aux=nodos->getNodo(i)->getPunto(); aux.setY(flt); nodos->getNodo(i)->setPunto(aux); } else { if(flt < min_concentracion) { min_concentracion = flt; } if(flt > max_concentracion) { max_concentracion = flt; } nodos->getNodo(i)->setConcentracion(flt); } } } Arco *a; Arcos *arcos = new Arcos(); Cara *c; Caras *caras = new Caras(); int ind_cara, ind_arco; int n1, n2, n3, n4; vector<int> ind_nodos; vector<int> ind_arcos; for(int i=0; i<(num_anillos-1); i++) { for(int j=0; j<num_puntos; j++) { ind_nodos.clear(); ind_arcos.clear(); // Orden: n1 n2 n3 n4 <-> SE SO NO NE n1 = int(fmod(num_puntos*i+j,num_nodos)); n4 = int(fmod(num_puntos*(i+1)+j,num_nodos)); if(j == num_puntos-1) { n2 = n1-num_puntos+1; n3 = n4-num_puntos+1; } else { n2 = int(fmod(num_puntos*i+j+1,num_nodos)); n3 = int(fmod(num_puntos*(i+1)+j+1,num_nodos)); } // Orden inverso para tener normal saliente ind_nodos.push_back(n4); ind_nodos.push_back(n3); ind_nodos.push_back(n2); ind_nodos.push_back(n1); if(i == num_anillos-2) { if(j == 0) { ind_arcos.push_back(2*(n1-1)+3*num_puntos); } else { ind_arcos.push_back(2*n1+j-2); } ind_arcos.push_back(2*n1+j); ind_arcos.push_back(2*n1+j+1); ind_arcos.push_back(2*(n1+1)+j); } else { if(j == 0) { ind_arcos.push_back(2*(n1+num_puntos)-1); } else { ind_arcos.push_back(2*n1-1); } ind_arcos.push_back(2*n1); ind_arcos.push_back(2*n1+1); if(i == num_anillos-3) { ind_arcos.push_back(2*n1+2*num_puntos+j); } else { ind_arcos.push_back(2*n1+2*num_puntos); } } c = new Cuadrilatero(ind_nodos,ind_arcos); ind_cara = caras->addCara(c); nodos->addCaraNodo(n1,ind_cara); nodos->addCaraNodo(n2,ind_cara); nodos->addCaraNodo(n3,ind_cara); nodos->addCaraNodo(n4,ind_cara); int ind_cara2 = -1; if(i != 0) { ind_cara2 = ind_cara-num_puntos; } a = new Arco(n1,n2,ind_cara,ind_cara2); ind_arco = arcos->addArco(a); nodos->addArcoNodo(n1,ind_arco); nodos->addArcoNodo(n2,ind_arco); ind_cara2 = ind_cara+1; if(j == num_puntos-1) { ind_cara2 = ind_cara-num_puntos+1; } a = new Arco(n2,n3,ind_cara,ind_cara2); ind_arco = arcos->addArco(a); nodos->addArcoNodo(n2,ind_arco); nodos->addArcoNodo(n3,ind_arco); if(i == num_anillos-2) { if(j == num_puntos-1) { a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+1,num_nodos)),ind_cara,-1); ind_arco = arcos->addArco(a); nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco); nodos->addArcoNodo(int(fmod(n1+1,num_nodos)),ind_arco); } else { a = new Arco(int(fmod(n1+num_puntos,num_nodos)),int(fmod(n1+num_puntos+1,num_nodos)),ind_cara,-1); ind_arco = arcos->addArco(a); nodos->addArcoNodo(int(fmod(n1+num_puntos,num_nodos)),ind_arco); nodos->addArcoNodo(int(fmod(n1+num_puntos+1,num_nodos)),ind_arco); } } } } Malla *malla = new MallaCuadrilateros(nodos,arcos,caras); malla->setConcentracionMax(max_concentracion); malla->setConcentracionMin(min_concentracion); malla->setNormales(); fclose(mat); setlocale(LC_NUMERIC, ""); //Chequeamos consistencia topologica. int V=malla->getNumNodos(); int E=malla->getNumArcos(); int F=malla->getNumCaras(); cout << "Numero de nodos=" << V << endl; cout << "Numero de arcos=" << E << endl; cout << "Numero de caras=" << F << endl; if (V-E+F==2 || V-E+F==0) cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl; else cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl; assert(malla->checkMalla(true) >= 0); return malla; }
void AlmacenaToXYZU::aplicar(Malla *malla, string filename){ //Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje. setlocale(LC_NUMERIC, "POSIX"); int posextension=filename.rfind("."); string nombrefile=filename.substr(0,posextension); string extension=filename.substr(posextension+1,filename.length()); if (posextension==0){ nombrefile=filename; extension="txt"; } stringstream archivox; stringstream archivoy; stringstream archivoz; stringstream archivou; archivox << nombrefile << "_nx." << extension; archivoy << nombrefile << "_ny." << extension; archivoz << nombrefile << "_nz." << extension; archivou << nombrefile << "_u." << extension; FILE *archivo_x = fopen(archivox.str().c_str(),"w"); FILE *archivo_y = fopen(archivoy.str().c_str(),"w"); FILE *archivo_z = fopen(archivoz.str().c_str(),"w"); FILE *archivo_u = fopen(archivou.str().c_str(),"w"); char separador1[32] = "% Coordinates\n"; fprintf(archivo_x,"%s",separador1); fprintf(archivo_y,"%s",separador1); fprintf(archivo_z,"%s",separador1); fprintf(archivo_u,"%s",separador1); Nodos *nds = malla->getNodos(); Caras *crs = malla->getCaras(); Nodo *nodo; int* nuevoIndiceNodos=new int[nds->getNumNodos()]; int nlinea=0; for(int i=0; i<nds->getNumNodos(); i++) { nodo = nds->getNodo(i); if(nodo != NULL) { fprintf(archivo_x,"%f %f %f\n",nodo->getPunto()->getX(),nodo->getPunto()->getY(),nodo->getPunto()->getZ()); fprintf(archivo_y,"%f %f %f\n",nodo->getPunto()->getX(),nodo->getPunto()->getY(),nodo->getPunto()->getZ()); fprintf(archivo_z,"%f %f %f\n",nodo->getPunto()->getX(),nodo->getPunto()->getY(),nodo->getPunto()->getZ()); fprintf(archivo_u,"%f %f %f\n",nodo->getPunto()->getX(),nodo->getPunto()->getY(),nodo->getPunto()->getZ()); nuevoIndiceNodos[i]=nlinea; nlinea++; } } char separador2[32] = "% Elements (triangular)\n"; fprintf(archivo_x,"%s",separador2); fprintf(archivo_y,"%s",separador2); fprintf(archivo_z,"%s",separador2); fprintf(archivo_u,"%s",separador2); Cara *c; vector<int> ind_nodos; for(int i=0; i<crs->getNumCaras(); i++) { c = crs->getCara(i); if(c != 0) { ind_nodos = c->getNodos(); fprintf(archivo_x,"%d %d %d\n",nuevoIndiceNodos[ind_nodos[0]]+1,nuevoIndiceNodos[ind_nodos[1]]+1,nuevoIndiceNodos[ind_nodos[2]]+1); fprintf(archivo_y,"%d %d %d\n",nuevoIndiceNodos[ind_nodos[0]]+1,nuevoIndiceNodos[ind_nodos[1]]+1,nuevoIndiceNodos[ind_nodos[2]]+1); fprintf(archivo_z,"%d %d %d\n",nuevoIndiceNodos[ind_nodos[0]]+1,nuevoIndiceNodos[ind_nodos[1]]+1,nuevoIndiceNodos[ind_nodos[2]]+1); fprintf(archivo_u,"%d %d %d\n",nuevoIndiceNodos[ind_nodos[0]]+1,nuevoIndiceNodos[ind_nodos[1]]+1,nuevoIndiceNodos[ind_nodos[2]]+1); } } char separador_x[32] = "% Data (nx)\n"; char separador_y[32] = "% Data (ny)\n"; char separador_z[32] = "% Data (nz)\n"; char separador_u[32] = "% Data (u)\n"; fprintf(archivo_x,"%s",separador_x); fprintf(archivo_y,"%s",separador_y); fprintf(archivo_z,"%s",separador_z); fprintf(archivo_u,"%s",separador_u); for(int i=0; i<nds->getNumNodos(); i++) { nodo = nds->getNodo(i); // cout << nodo->imprimir() << endl; if(nodo != NULL) { fprintf(archivo_x,"%f\n",nodo->getNormal()->getPunto().getX()); fprintf(archivo_y,"%f\n",nodo->getNormal()->getPunto().getY()); fprintf(archivo_z,"%f\n",nodo->getNormal()->getPunto().getZ()); fprintf(archivo_u,"%f\n",nodo->getConcentracion()); } } delete nuevoIndiceNodos; fclose(archivo_x); fclose(archivo_y); fclose(archivo_z); fclose(archivo_u); setlocale(LC_NUMERIC, ""); }