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; }
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; }
Malla* GeneraFromComsol_1::aplicar() { int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados ifstream in(archivo.c_str()); char line[MAXLINE]; in.getline(line,MAXLINE); string cx,cy,cz; float x,y,z; int num_puntos, num_caras; num_puntos=0; Nodos *nodos = new Nodos(); Nodo *nodo; while(true) { in.getline(line,MAXLINE); stringstream streamin(line); if (line[0]=='%') break; streamin >> x; streamin >> y; streamin >> 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; int indices[4], n_lados; num_caras=0; while(true) { indices[3]=-1; in.getline(line,MAXLINE); if (in.fail() || line[0]=='%') break; stringstream streamin(line); for(int i=0; i<4; i++) streamin >> indices[i]; if(indices[3] == -1) { n_triangulos++; n_lados = 3; } else { 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--) // por el bug 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 if(n_lados == 4) c = new Cuadrilatero(indice_puntos,indice_arcos); else c = new Cara(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(); } 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->setConcentracionTodos(1.0); malla->setConcentracionMax(1.0); malla->setConcentracionMin(0.0); malla->setNormales(); in.close(); //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); cout << endl; 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* GeneraCilindro::generaMallaCuadrilateros() { //Genero la medula. vector<Punto> medula; medula.push_back(Punto(0,0,0)); medula.push_back(Punto(0,altura,0)); int num_nodos = num_anillos * num_puntos; Nodos *nodos = new Nodos(); Nodo *nodo; Punto p; Vect v, v1, v2; double h,angulo; h = altura / num_anillos; angulo = 2*PI / num_puntos; for(int i=0; i<num_anillos; i++) { for(int j=0; j<num_puntos; j++) { p = Punto(cos(j*angulo)*radio,i*h-h/2,sin(j*angulo)*radio); v1 = Vect(p); v2 = Vect(0,i*h-h/2,0); v = v1 - v2; nodo = new Nodo(p); nodo->setNormal(v); //le seteamos su normal nodo->setConcentracion(0.0); // le seteamos su concentracion nodos->addNodo(nodo); } } 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->setMedula(medula); malla->setConcentracionMax(1.0); malla->setConcentracionMin(0.0); assert(malla->checkMalla(true) >= 0); return malla; }