int get_indice_nodo(Nodos& nodos, int v) {
int n = nodos.size();
for (int i = 0; i < n; i++) {
if (nodos[i].numero == v) {
return i;
}
}
return -1;
}
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, "");
}
vector<int> resolver(int n, Grafo G, Nodos nodos) {
// Ordeno a los nodos segun su grado
std::sort(nodos.begin(), nodos.end(), orden());
vector<bool> visitado(n, false);
vector<int> cidm;
cidm.reserve(n);
for(int u = 0; u < n ; u++){
if(visitado[nodos[u].numero] == false){
visitado[nodos[u].numero] = true;
cidm.push_back(nodos[u].numero);
for (list<int>::iterator itAdyU=G[nodos[u].numero].begin(); itAdyU != G[nodos[u].numero].end(); ++itAdyU) {
int j = *itAdyU;
cout << j << endl ;
visitado[j] = true;
}
}
}
return cidm;
}
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;
}
/*
* 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* 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;
}
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, "");
}
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;
}
