ADFC Misc El Libro

ADFC – El libro 1
ADFC
El libro
ADFC – El libro 2
Índice de contenido
Prólogo............................................................................................................................................5
Los autores......................................................................................................................................7
Capítulo 0. Guía del lector..........................................................................................8
Visión general del libro..................................................................................................................9
Recursos en la web.........................................................................................................................9
Ficha del proyecto........................................................................................................................10
Capítulo 1. Introducción al proyecto........................................................................12
Introducción a los CFD como herramienta de diseño..............................................................13
Objetivos del presente proyecto..................................................................................................14
Ámbito de aplicación del proyecto.............................................................................................15
Implantación informática............................................................................................................17
Licencia del Software...................................................................................................................18
Requisitos de Hardware..............................................................................................................30
Requisitos de Software................................................................................................................31
Capítulo 2. Teoría y algoritmos usados....................................................................32
Resolución de la ecuación de Poisson en 2D mediante Elementos Finitos..............................33
Cálculo de divergencias mediante Elementos Finitos...............................................................38
Transporte Puro (Método de las Características Modificadas)...............................................40
Algoritmo de búsqueda SLALG básico.....................................................................................43
Algoritmo de búsqueda SLALG extendido...............................................................................47
Transporte y Difusión..................................................................................................................52
Navier-Stokes................................................................................................................................55
Modelo de turbulencia Smagorinky...........................................................................................63
Condiciones de Contorno Slip....................................................................................................68
Condiciones de contorno evaluables en tiempo de ejecución (CCETE).................................70
Seguimiento de particulas fluidas...............................................................................................74
Cálculo de los coeficientes de Drag y Lift..................................................................................75
Anexo: Matrices dispersas...........................................................................................................77
Anexo: Resolución de sistemas de ecuaciones lineales mediante Gradiente Conjugado.......82
Anexo: Cálculo de integrales en un elemento finito 2D mediante Newton-Cotes..................84
Anexo: Integración por coordenadas baricéntricas..................................................................88
ADFC – El libro 3
Anexo: Tabla de funciones base del triángulo 2D.....................................................................89

Anexo: tabla de funciones base del tetraedro 3D......................................................................90
Anexo: Matriz de masas..............................................................................................................92
Anexo: Matriz de rigidez.............................................................................................................95
Anexo: Matrices de divergencia...............................................................................................100
Anexo: formato del archivo de mallado...................................................................................101
Bibliografía...............................................................................................................102
Capítulo 3. Cálculos realizados...............................................................................103
Validación del Solver.................................................................................................................104
Problema 2D-1: cilindro circular diámetro unidad a Reynolds 100.....................................105
Mallado utilizado.....................................................................................................................106
Cálculo del Drag, Lift y Strouhal a Reynolds 100...................................................................108
Curvas de presión y gradiente de velocidad a Reynolds 100...................................................109
Presión y campo de velocidades a Reynolds 100....................................................................111
Problema 2D-2: emisión de torbellinos en el cilindro circular diámetro unidad a diversos
números de Reynolds.................................................................................................................113
Transporte de tinta..................................................................................................................115
Calle de torbellinos a Reynolds 1, 30, 50, 60, 100.................................................................116
Problema 2D-3: evolución del coeficiente Drag en función del Reynolds para el cilindro
diámetro unidad.........................................................................................................................122
Mallados utilizados..................................................................................................................123
Curvas obtenidas.....................................................................................................................126
Problema 2D-4: Validación túnel de viento RUSVAL...........................................................127
Componente X de la velocidad en la vertical del centro del valle...........................................129
Presión y campo de velocidades..............................................................................................131
Problema 2D-5: Montaña Askervein.......................................................................................133
Comparación del Fractional Speed-Up Ratio..........................................................................136
Campo de velocidades.............................................................................................................137
Problema 3D-1: Esfera 3D diámetro unidad a Reynolds 100................................................138
Flujo estacionario axisimétrico................................................................................................140
ADFC – El libro 4
Coeficientes de Drag y Lift......................................................................................................142

Número de Strouhal................................................................................................................143
Flujo estacionario no axisimétrico...........................................................................................145
Estela oscilante........................................................................................................................151
Número de Strouhal................................................................................................................154
Capítulo 4. Tutoriales..............................................................................................155
Introducción...............................................................................................................................157
Instalación del GiD....................................................................................................................158
Instalación de ADFC v3.0 ........................................................................................................160
Compilar ADFC v3.x ................................................................................................................160
Resolución de un caso sencillo: un cilindro a Reynolds 100...................................................161
Simulación de un corte orográfico 2D......................................................................................169
Seguimiento de partículas fluidas.............................................................................................173
Introduction................................................................................................................................176
GiD installation..........................................................................................................................177
ADFC v3.x Installation..............................................................................................................179
Compiling ADFC v3.x ..............................................................................................................179
Solving an easy case: 2D cylinder at Reynolds 100.................................................................180
Simulación de un corte orográfico 2D......................................................................................188
Seguimiento de partículas fluidas.............................................................................................192
Capítulo 5. Documentación para desarrolladores.................................................194
Introducción...............................................................................................................................196
Primer contacto..........................................................................................................................197
Plantilla Array<tipo>.................................................................................................................199
Clase MatrizDispersa.................................................................................................................200
ADFC – El libro 5
Prólogo
ADFC es un solver de las ecuaciones de Navier-Stokes que simula el comportamiento
de fluidos newtonianos incompresibles en dominios 2D y 3D. Este tipo de programas
recibe el nombre de Computer Fluid Dynamics.
El proyecto ADFC nació a comienzos de 1999 cuando Leo González Gutiérrez fundó
un grupo de alumnos de ingeniería industrial en el ICAI, con el propósito de realizar
investigaciones en el campo de los CFD.
Alejandro Rodríguez Gallego fue uno de los integrantes del grupo, desarrollando un
pequeño solver de la ecuación de Poisson en Java. Este programa permitía llevar a
cabo secillas simulaciones de casos de fluido potencial en 2D. En los años posteriores
se fue completando el programa, aumentando su potencia de cálculo con nuevos
algoritmos.
Durante el curso académico 1999-2000 el ICAI apoyó el desarrollo mediante una beca
de colaboración otorgada por el departamento de Fluidos y Calor. En el curso
siguiente, la beca pasó al cargo de la consultora DyTA que estaba interesada en
aplicar el programa para llevar a cabo simulaciones de cortes orográficos.
Finalmente, el curso 2000-2001 se empleó en redactar el proyecto final de carrera, y
mejorar enormemente la capacidad del código traduciéndolo a C++. Al final del curso
ADFC – El libro 6
y una vez se entregó el proyecto, se publicó en Sourceforge bajo la licencia pública
general GNU.
Ya en el 2003, la Asociación de Ingenieros del ICAI otorga el premio al mejor
proyecto final de carrera del área de ingeniería industrial a Alejandro Rodríguez
Gallego por ADFC.

ADFC – El libro 7
Los autores
Leo Miguel González Gutiérrez

INGENIERO INDUSTRIAL DEL ICAI. ESPECIALIDAD MECÁNICA.
Universidad Pontificia de Comillas (ICAI).1990-1996.
LICENCIADO EN CIENCIAS FÍSICAS. ESPECIALIDAD TEÓRICA.

Universidad Autónoma de Madrid (UAM).
DOCTOR POR LA UNIVERSIDAD POLITÉCNICA DE MADRID.

Escuela Técnica Superior de Ingenieros Navales. Octubre 2001
D. Leo Miguel González Gutiérrez, D. Luis Pérez Rojas, D. Jesús Valle

Cabezas, D. Antonio Souto Iglesias.
Título: ."LA SIMULACIÓN EN LA FORMACIÓN HIDRODINÁMICA".Fecha: 18-19 Mayo
2000
Proceedings de las XXXVII SESIONES TÉCNICAS DE INGENIERÍA NAVAL Bilbao
Mayo 2000
D. Luis Pérez Rojas, D. Antonio Souto Iglesias, D. Leo Miguel González

Gutiérrez.
Título: "LOS CFD(COMPUTATIONAL FLUID DYNAMICS) EN EL DISEÑO DE BUQUES.
APORTACIONES DE LA E.T.S.I.N.(U.P.M.)"
Junio del 2001.IPEN Journal
Alejandro Rodríguez Gallego

Ingeniero Industrial del ICAI (Univ. Pontificia Comillas)
ADFC – El libro 8
Capítulo 0. Guía del lector

ADFC – El libro 9
Visión general del libro

Este libro abarca mucha materia, por lo que está dividido en cinco capítulos:
• Capítulo 0. Guía del lector: este capítulo ofrece una visión general de la organización del
libro y de los recursos web dedicados al proyecto.
• Capítulo 1. Introducción al proyecto: describe brevemente lo que son los CFD (Computer
Fluid Dynamics) y su ámbito de aplicación.
• Capítulo 2. Teoría y algoritmos usados: una exhaustiva descripción de los diferentes
algoritmos y métodos numéricos empleados en el software. Las descripciones están ordenadas
de forma que los conceptos se introducen de forma progresiva, asentándose cada una en temas
ya expuestos previamente. Los anexos del final, incluyen una serie de apéndices y tablas con
fórmulas útiles en el planteamiento del problema.
• Capítulo 3. Cálculos realizados: este capítulo contiene validaciones 2D y 3D que se llevaron
a cabo para contrastar los resultados simulados con casos reales, que van desde simulación de
flujos en torno a cilindros y a esferas, a cortes orográficos y ensayos de túnel de viento.
• Capítulo 4. Tutoriales: recopilación de documentos que introducen al usuario a los diferentes
aspectos del uso del programa.
• Capítulo 5. Documentación para desarrolladores: este capítulo está orientado a todos
aquellos desarrolladores que deseen incorporarse al desarrollo de ADFC o pretendan
aprovechar partes del código existente en sus propias aplicaciones.
Recursos en la web
Las últimas versiones del código fuente, los ejecutables, la documentación y el material multimedia
puede descargarse desde la página web dedicada a este proyecto en Sourceforge:
Sourceforge: http://www.sourceforge.net
Ficha técnica Proyecto: http://www.sourceforge.net/projects/adfc
Página web: http://adfc.sourceforge.net
Ante cualquier duda o consulta relacionada con el proyecto, puede ponerse en contacto con el
equipo de desarrolladores en la siguiente dirección:
Email: adfc-devel@lists.sourceforge.net
ADFC – El libro 10
Ficha del proyecto

El programa ADFC nació como un proyecto final de carrera que se presentó en la Escuela Técnica
Superior de Ingeniería Industrial ICAI (Universidad Pontificia Comillas). La ficha del proyecto
original se adjunta a continuación:
CREACIÓN DE UN TÚNEL DE VIENTO VIRTUAL

Autor: Rodríguez Gallego, Alejandro.
Director: González Gutiérrez, Leo Miguel.
Entidad Colaboradora: ICAI - Universidad Pontificia Comillas.
RESUMEN DEL PROYECTO

La meta general que se pretende alcanzar en el presente proyecto es el desarrollo de un software que
permita llevar a cabo ensayos fluidodinámicos en un ordenador, sirviendo de ayuda a todos los
profesionales e investigadores que necesiten un túnel de viento en su trabajos e investigaciones. Para
ello se ha escrito un programa capaz de resolver las ecuaciones de Navier-Stokes para flujo viscoso
incompresible en geometrías 2D y 3D.
La herramienta informática diseñada proporciona abundante información acerca de los problemas

que resuelve: campos de velocidad y presión, divergencia de la velocidad, coeficientes de resistencia
y sustentación de objetos, transporte de contaminantes, curvas de presión y gradiente de velocidad
en el contorno de objetos y distribución de la turbulencia.
Se pueden definir problemas de forma flexible y tratar geometrías complejas mediante el uso de
mallas desestructuradas y la amplia gama de condiciones de contorno soportadas: condición Dirichlet
sobre el campo de velocidades, condición Neutral Boundary Condition aguas abajo, perfiles
parabólico y logarítmico de velocidad, realimentación, condición Slip de deslizamiento y efecto
Magnus.
Para resolver las ecuaciones de Navier-Stokes se emplea un gradiente conjugado diferencial y,

cuando es necesario, un modelo de turbulencia Smagorinsky. Las discretizaciones espacial y
temporal se llevan a cabo mediante el método de los elementos finitos y el método de las
características respectivamente. Los mallados con los que se trabaja están compuestos por elementos
finitos 2D Taylor-Hood o tetraedros cuadráticos 3D, respetando así la condición Babushka-Brezzi.
El código desarrollado se encarga de los métodos de cálculo y de la resolución del problema, pero
otros procesos fundamentales como son la definición de la geometría, mallado de ésta y
procesamiento de los datos deberán correr a cargo de otros programas. En nuestro caso, el código
está preparado para trabajar con el pre/postprocesador mallador GiD desarrollado por el Centro
Internacional de Métodos Numéricos en Ingeniería (CIMNE), dependiente de la Universidad
Politécnica de Cataluña.
En la resolución de un problema de Navier-Stokes el código utiliza diferentes módulos internos para

calcular problemas de Stokes, problemas elípticos de Laplace y Poisson, divergencia de campos
vectoriales, problemas de transporte puro y problemas de transporte-difusión.
Las operaciones matriciales se realizan mediante técnicas de almacenamiento disperso, permitiendo

un gran ahorro de memoria RAM sin el cual no se podría hacer frente computacionalmente a los
sistemas de ecuaciones lineales que surgen en el proceso de simulación. Para calcular su solución, se
ha desarrollado un solver de sistemas de ecuaciones lineales que emplea un gradiente conjugado
algebraico con precondicionador de Cholesky incompleto.
Se han programado dos versiones distintas del código, una en lenguaje Java totalmente
multiplataforma, con entorno gráfico y soporte para red; y otra en C++ optimizada para minimizar el
uso de RAM y el tiempo de proceso.
Para finalizar se llevó a cabo un exhaustivo proceso de validación frente a experimentos presentes en
la bibliografía: cilindros circulares, esferas, valle V3 y la montaña escocesa Askervein.
Capítulo 1. Introducción al proyecto

Introducción a los CFD como herramienta de diseño

Desde el punto de vista matemático, las ecuaciones que describen el comportamiento de un fluido
son conocidas desde el siglo XIX, aunque su grado de complejidad las hacía irresolubles de forma
analítica para todos los casos con algún interés práctico.
En la actualidad, gracias al desarrollo de los códigos de Dinámica de Fluidos Computacional

(Computational Fluid Dynamics, en inglés), las ecuaciones pueden resolverse de forma aproximada
por métodos numéricos proporcionando abundante información.
A pesar de esto, las limitaciones de estos métodos como por ejemplo la dependencia de la solución
obtenida del mallado o la creciente inestabilidad de la solución al elevar el número de Reynolds, no
han permitido desbancar a los ensayos experimentales en túnel de viento.
El creciente interés por los CFD radica en dos problemas de los ensayos experimentales:
• Elevados costes en lo que a infraestructuras y fabricación de modelos se refiere,
provocando que su empleo sea inviable en proyectos con presupuestos modestos.
• Gran dificultad para definir un proceso sistemático de optimización del diseño a partir de
los datos suministrados por los experimentos.
Las herramientas de CFD proporcionan un valiosa orientación acerca de la influencia de una amplia
gama de parámetros en las primeras fases de realización de un proyecto, y con un coste muchísimo
menor. Esta información, que puede aprovecharse en las etapas posteriores de diseño, no puede de
momento sustituir a las conclusiones de los ensayos experimentales de los modelos finales.
El uso de estas herramientas informáticas requiere una nueva filosofía en los proyectos de ingeniería
a la hora de optimizar diseños. Muchas veces los investigadores son capaces de intuir la influencia
que ciertas modificaciones en el diseño tendrán en el resultado final, pero no disponen de medios
para juzgar objetivamente los efectos de las innovaciones. Las herramientas de CFD permiten
evaluar estas modificaciones a partir de los resultados de los cálculos realizados, y de hecho permiten
obtener mucha más información que un experimento tradicional.
Esta gran cantidad de información requiere llevar a cabo un esfuerzo adicional para conseguir una
exposición inteligible de las cantidades calculadas y en este campo la representación gráfica de datos
es una ayuda fundamental para un mejor aprovechamiento de las herramientas de CFD.
De cualquier forma los ensayos de túnel de viento siguen siendo imprescindibles para validar los
códigos CFD.
Objetivos del presente proyecto

La meta general que se pretende en el presente proyecto final de carrera es el desarrollo de un
software que permita llevar a cabo ensayos fluidodinámicos en un ordenador, sirviendo de ayuda a
todos los profesionales e investigadores que necesiten un túnel de viento en su trabajos e
investigaciones.
Imágenes Videos
Preprocesador
Geometría
Mallador Postprocesador
Mallado
Solución
Solver ADFC
Lista de puntos
a observar
(objetivo del proyecto)
Resistencia y sustentación
Valores puntuales
Curvas de presión y grad. velocidad
etc.
Editor de textos Hoja de Cálculo
Gráficas
El código desarrollado se encarga de los métodos de cálculo y de la resolución del problema, pero
otros procesos fundamentales como son la definición de la geometría, mallado de ésta y
procesamiento de los datos deberán correr a cargo de otros programas. En nuestro caso, el código
está preparado para trabajar con el pre/postprocesador mallador GiD1 desarrollado por el Centro
Internacional de Métodos Numéricos en Ingeniería (CIMNE2), dependiente de la Universidad
Politécnica de Cataluña.
El túnel de viento virtual basado en el método de los elementos finitos permite resolver las
ecuaciones de Navier-Stokes para fluidos incompresibles en geometrías 2D y 3D, proporcionando la
mayor parte de los resultados necesarios para el diseño ingenieril. Entre ellos destacamos:
1 http://gid.cimne.upc.es
2 http://www.cimne.upc.es
• Distribución del campo de velocidades

• Distribución del campo de presiones
• Coeficientes de resistencia y sustentación de objetos
• Divergencia de la velocidad
• Transporte de contaminantes
• Curvas de presión y gradiente de velocidad en el contorno de objetos
• Distribución de la turbulencia
• Seguimiento de partículas
Para una mejor definición de las geometrías, se emplean mallas desestructuradas y una amplia gama
de condiciones de contorno:
• Condición Dirichlet sobre el campo de velocidades
• Condición Neutral Boundary Condition aguas abajo
• Perfiles parabólico y logarítmico de velocidad para simular viento
• Realimentación del campo fluido
• Condición Slip de deslizamiento
• CCDETE (Condiciones de Contorno Dirichlet Evaluadas en Tiempo de Ejecución)
La elección del método de los elementos finitos como base para resolver los problemas de dinámica
de fluidos computacional se fundamenta en varios factores:
• El método, como ya comentamos, es independiente de la geometría. Se puede aplicar a
dominios de forma arbitraria y a condiciones de contorno también arbitrarias.
• Posibilidad de utilización de mallados desestructurados, pudiendo trabajar con geometrías
muy complejas.
• Robustez: el modo de obtener la solución del sistema de ecuaciones da lugar a un esquema
estable en normas adecuadas, y por lo tanto insensible antes singularidades y distorsiones
en la malla a diferencia de los métodos de diferencias finitas.
• Fundamentación matemática: el método de los elementos finitos goza de una sólida
fundamentación matemática debido al extenso trabajo que se ha realizado sobre cálculo
variacional y teoría de ecuaciones diferenciales en derivadas parciales.
• Facilidad de llevar a cabo un refinamiento local del mallado, permitiendo centrar la
atención y obtener más información en zonas concretas.
Ámbito de aplicación del proyecto

Las posibles aplicaciones del software abarcan una amplísima gama de problemas ingenieriles.
Diferentes ejemplos de aplicación pueden ser:
• Estudios de aerodinámica y resistencia al avance de formas como alas de avión en régimen
subsónico o vehículos terrestres. La resistencia al avance es un factor fundamental en el
diseño de vehículos porque es determinante a la hora de escoger el motor y su potencia
nominal, teniendo gran repercusión sobre el consumo de combustible y la economía de
servicio.
• Búsqueda del emplazamiento óptimo para parques eólicos. Del estudio de cortes
orográficos se obtiene información acerca de los lugares con una velocidad del viento más
elevada, obteniendo una mayor producción de energía eléctrica.
• El número de Strouhal de un fluido que incide de forma perpendicular a un cable es
determinante para calcular la frecuencia a la que vibrará el conductor al verse sometido a
viento transversal (galope).
• Dentro de la ingeniería naval, se puede simular el comportamiento de sumergibles.
• Puede estudiarse el comportamiento de fluidos incompresibles dentro de turbomáquinas, y
optimizar de esta forma sus álabes.
Implantación informática
Durante todas las etapas del desarrollo del software se ha intentado satisfacer cuatro requisitos:
• Elaborar un código totalmente multiplataforma, que pueda ejecutarse en cualquier
combinación de arquitectura de hardware y sistema operativo.
• Emplear técnicas modernas de programación, como por ejemplo la Programación
Orientada a Objetos (POO).
• Maximizar la claridad y la comprensión del código, dotándolo de abundamentes
comentarios y documentación.
• Enmarcar el desarrollo dentro de la filosofía GNU3. Tanto el código elaborado como la
mayor parte de las herramientas empleadas en su diseño se distribuyen gratuitamente bajo
la licencia pública GPL4 u OpenSource5. Ejemplos de herramientas GNU empleadas son:
sistema operativo Linux, compilador GCC de C++, entorno gráfico KDE, entorno
integrado de desarrollo (IDE) KDevelop, depurador gráfico DDD, generador de
documentación Doxygen...
Se han elaborado dos versiones del software: una escrita en Java6, lenguaje creado por Sun
Microsystems7 con el lema de una portabilidad total, y otra versión en ANSI C++ buscando el mayor
rendimiento posible en lo que a velocidad de proceso y consumo de memoria RAM se refiere.
La versión en Java fue la primera cronológicamente. Se escogió este lenguaje dada su sencillez y
robustez, pudiendo centrar los esfuerzos más en los métodos numéricos que en la complejidad de la
programación. Una vez se consiguió un programa estable y convenientemente validado, pasó a
primer plano la necesidad de obtener el mayor rendimiento posible en lo que a uso de memoria RAM
y tiempo de proceso se refiere. Por ello se reescribió el código enteramente en C++.
El modelo de ingeniería de software [PRESS02] que se ha seguido durante las distintas etapas de
desarrollo ha sido el modelo evolutivo incremental, básicamente por su sencillez.
Este modelo incremental combina elementos del modelo lineal secuencial con la filosofía interactiva
de construcción de prototipos. Básicamente aplica secuencias lineales de forma escalonada mientras
progresa en el tiempo, entregando el software en partes pequeñas pero utilizables, denominadas
3 http://www.gnu.org
4 Véase el pliego de condiciones para una versión en castellano de la licencia GPL.
5 http://www.opensource.org
6 http://www.java.sun.com
7 http://www.sun.com
incrementos. Cada incremento se construye sobre el anterior.
Calendario
Incremento 1
Análisis Diseño Código Prueba
Incremento 2
Incremento 3
Desarrollo
Licencia del Software

A continuación se reproduce de forma íntegra la Licencia Pública General GNU, que regirá la copia
y distribución del paquete de software desarrollado.
Licencia Pública GNU
Esta es la conocida GNU Public License (GPL), versión 2 (de junio de 1.991), que cubre la mayor
parte del software de la Free Software Foundation, y muchos más programas.
Los autores de esta traducción son:
• Jesús González Barahona
• Pedro de las Heras Quirós
NOTA IMPORTANTE:
Esta es una traducción no oficial al español de la GNU General Public License. No ha
sido publicada por la Free Software Foundation, y no establece legalmente las
condiciones de distribución para el software que usa la GNU GPL. Estas condiciones se
establecen solamente por el texto original, en inglés, de la GNU GPL. Sin embargo,
esperamos que esta traducción ayude a los hispanohablantes a entender mejor la GNU
GPL.
IMPORTANT NOTICE:
This is an unofficial translation of the GNU General Public License into Spanish. It was
not published by the Free Software Foundation, and does not legally state the
distribution terms for software that uses the GNU GPL--only the original English text of
the GNU GPL does that. However, we hope that this translation will help Spanish
speakers understand the GNU GPL better.
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, EEUU
Se permite la copia y distribución de copias literales de este documento, pero no se permite su
modificación.
Preámbulo
Las licencias que cubren la mayor parte del software están diseñadas para quitarle a usted la libertad
de compartirlo y modificarlo. Por el contrario, la Licencia Pública General de GNU pretende
garantizarle la libertad de compartir y modificar software libre, para asegurar que el software es libre
para todos sus usuarios. Esta Licencia Pública General se aplica a la mayor parte del software del la
Free Software Foundation y a cualquier otro programa si sus autores se comprometen a utilizarla.
(Existe otro software de la Free Software Foundation que está cubierto por la Licencia Pública
General de GNU para Bibliotecas). Si quiere, también puede aplicarla a sus propios programas.
Cuando hablamos de software libre, estamos refiriéndonos a libertad, no a precio. Nuestras Licencias
Públicas Generales están diseñadas para asegurarnos de que tenga la libertad de distribuir copias de
software libre (y cobrar por ese servicio si quiere), de que reciba el código fuente o que pueda
conseguirlo si lo quiere, de que pueda modificar el software o usar fragmentos de él en nuevos
programas libres, y de que sepa que puede hacer todas estas cosas.
Para proteger sus derechos necesitamos algunas restricciones que prohiban a cualquiera negarle a
usted estos derechos o pedirle que renuncie a ellos. Estas restricciones se traducen en ciertas
obligaciones que le afectan si distribuye copias del software, o si lo modifica.
Por ejemplo, si distribuye copias de uno de estos programas, sea gratuitamente, o a cambio de una
contraprestación, debe dar a los receptores todos los derechos que tiene. Debe asegurarse de que
ellos también reciben, o pueden conseguir, el código fuente. Y debe mostrarles estas condiciones de
forma que conozcan sus derechos.
Protegemos sus derechos con la combinación de dos medidas:
1. Ponemos el software bajo copyright y
2. le ofrecemos esta licencia, que le da permiso legal para copiar, distribuir y/o modificar el
software.
También, para la protección de cada autor y la nuestra propia, queremos asegurarnos de que todo el
mundo comprende que no se proporciona ninguna garantía para este software libre. Si el software se
modifica por cualquiera y éste a su vez lo distribuye, queremos que sus receptores sepan que lo que
tienen no es el original, de forma que cualquier problema introducido por otros no afecte a la
reputación de los autores originales.
Por último, cualquier programa libre está constantemente amenazado por patentes sobre el software.
Queremos evitar el peligro de que los redistribuidores de un programa libre obtengan patentes por su
cuenta, convirtiendo de facto el programa en propietario. Para evitar esto, hemos dejado claro que
cualquier patente debe ser pedida para el uso libre de cualquiera, o no ser pedida.
Los términos exactos y las condiciones para la copia, distribución y modificación se exponen a
continuación.
Términos y condiciones para la copia, distribución y modificación
1. Esta Licencia se aplica a cualquier programa u otro tipo de trabajo que contenga una nota
colocada por el tenedor del copyright diciendo que puede ser distribuido bajo los términos de esta
Licencia Pública General. En adelante, «Programa» se referirá a cualquier programa o trabajo que
cumpla esa condición y «trabajo basado en el Programa» se referirá bien al Programa o a
cualquier trabajo derivado de él según la ley de copyright. Esto es, un trabajo que contenga el
programa o una proción de él, bien en forma literal o con modificaciones y/o traducido en otro
lenguaje. Por lo tanto, la traducción está incluida sin limitaciones en el término «modificación».
Cada concesionario (licenciatario) será denominado «usted».
Cualquier otra actividad que no sea la copia, distribución o modificación no está cubierta por esta
Licencia, está fuera de su ámbito. El acto de ejecutar el Programa no está restringido, y los
resultados del Programa están cubiertos únicamente si sus contenidos constituyen un trabajo
basado en el Programa, independientemente de haberlo producido mediante la ejecución del
programa. El que esto se cumpla, depende de lo que haga el programa.
2. Usted puede copiar y distribuir copias literales del código fuente del Programa, según lo has
recibido, en cualquier medio, supuesto que de forma adecuada y bien visible publique en cada
copia un anuncio de copyright adecuado y un repudio de garantía, mantenga intactos todos los
anuncios que se refieran a esta Licencia y a la ausencia de garantía, y proporcione a cualquier otro
receptor del programa una copia de esta Licencia junto con el Programa.
Puede cobrar un precio por el acto físico de transferir una copia, y puede, según su libre albedrío,
ofrecer garantía a cambio de unos honorarios.
3. Puede modificar su copia o copias del Programa o de cualquier porción de él, formando de esta
manera un trabajo basado en el Programa, y copiar y distribuir esa modificación o trabajo bajo los
términos del apartado 1, antedicho, supuesto que además cumpla las siguientes condiciones:
a. Debe hacer que los ficheros modificados lleven anuncios prominentes indicando que los ha
cambiado y la fecha de cualquier cambio.
b. Debe hacer que cualquier trabajo que distribuya o publique y que en todo o en parte
contenga o sea derivado del Programa o de cualquier parte de él sea licenciada como un
todo, sin carga alguna, a todas las terceras partes y bajo los términos de esta Licencia.
c. Si el programa modificado lee normalmente órdenes interactivamente cuando es
ejecutado, debe hacer que, cuando comience su ejecución para ese uso interactivo de la
forma más habitual, muestre o escriba un mensaje que incluya un anuncio de copyright y
un anuncio de que no se ofrece ninguna garantía (o por el contrario que sí se ofrece
garantía) y que los usuarios pueden redistribuir el programa bajo estas condiciones, e
indicando al usuario cómo ver una copia de esta licencia. (Excepción: si el propio
programa es interactivo pero normalmente no muestra ese anuncio, no se requiere que su
trabajo basado en el Programa muestre ningún anuncio).
Estos requisitos se aplican al trabajo modificado como un todo. Si partes identificables de ese
trabajo no son derivadas del Programa, y pueden, razonablemente, ser consideradas trabajos
independientes y separados por ellos mismos, entonces esta Licencia y sus términos no se aplican
a esas partes cuando sean distribuidas como trabajos separados. Pero cuando distribuya esas
mismas secciones como partes de un todo que es un trabajo basado en el Programa, la
distribución del todo debe ser según los términos de esta licencia, cuyos permisos para otros
licenciatarios se extienden al todo completo, y por lo tanto a todas y cada una de sus partes, con
independencia de quién la escribió.
Por lo tanto, no es la intención de este apartado reclamar derechos o desafiar sus derechos sobre
trabajos escritos totalmente por usted mismo. El intento es ejercer el derecho a controlar la
distribución de trabajos derivados o colectivos basados en el Programa.
Además, el simple hecho de reunir un trabajo no basado en el Programa con el Programa (o con
un trabajo basado en el Programa) en un volumen de almacenamiento o en un medio de
distribución no hace que dicho trabajo entre dentro del ámbito cubierto por esta Licencia.
4. Puede copiar y distribuir el Programa (o un trabajo basado en él, según se especifica en el
apartado 2, como código objeto o en formato ejecutable según los términos de los apartados 1 y
2, supuesto que además cumpla una de las siguientes condiciones:
a. Acompañarlo con el código fuente completo correspondiente, en formato electrónico, que
debe ser distribuido según se especifica en los apartados 1 y 2 de esta Licencia en un
medio habitualmente utilizado para el intercambio de programas, o
b. Acompañarlo con una oferta por escrito, válida durante al menos tres años, de
proporcionar a cualquier tercera parte una copia completa en formato electrónico del
código fuente correspondiente, a un coste no mayor que el de realizar físicamente la
distribución del fuente, que será distribuido bajo las condiciones descritas en los apartados
1 y 2 anteriores, en un medio habitualmente utilizado para el intercambio de programas, o
c. Acompañarlo con la información que recibiste ofreciendo distribuir el código fuente
correspondiente. (Esta opción se permite sólo para distribución no comercial y sólo si
usted recibió el programa como código objeto o en formato ejecutable con tal oferta, de
acuerdo con el apartado b anterior).
Por código fuente de un trabajo se entiende la forma preferida del trabajo cuando se le hacen
modificaciones. Para un trabajo ejecutable, se entiende por código fuente completo todo el código
fuente para todos los módulos que contiene, más cualquier fichero asociado de definición de
interfaces, más los guiones utilizados para controlar la compilación e instalación del ejecutable.
Como excepción especial el código fuente distribuido no necesita incluir nada que sea distribuido
normalmente (bien como fuente, bien en forma binaria) con los componentes principales
(compilador, kernel y similares) del sistema operativo en el cual funciona el ejecutable, a no ser
que el propio componente acompañe al ejecutable.
Si la distribución del ejecutable o del código objeto se hace mediante la oferta acceso para
copiarlo de un cierto lugar, entonces se considera la oferta de acceso para copiar el código fuente
del mismo lugar como distribución del código fuente, incluso aunque terceras partes no estén
forzadas a copiar el fuente junto con el código objeto.
5. No puede copiar, modificar, sublicenciar o distribuir el Programa excepto como prevé
expresamente esta Licencia. Cualquier intento de copiar, modificar sublicenciar o distribuir el
Programa de otra forma es inválida, y hará que cesen automáticamente los derechos que te
proporciona esta Licencia. En cualquier caso, las partes que hayan recibido copias o derechos de
usted bajo esta Licencia no cesarán en sus derechos mientras esas partes continúen cumpliéndola.
6. No está obligado a aceptar esta licencia, ya que no la ha firmado. Sin embargo, no hay hada más
que le proporcione permiso para modificar o distribuir el Programa o sus trabajos derivados.
Estas acciones están prohibidas por la ley si no acepta esta Licencia. Por lo tanto, si modifica o
distribuye el Programa (o cualquier trabajo basado en el Programa), está indicando que acepta
esta Licencia para poder hacerlo, y todos sus términos y condiciones para copiar, distribuir o
modificar el Programa o trabajos basados en él.
7. Cada vez que redistribuya el Programa (o cualquier trabajo basado en el Programa), el receptor
recibe automáticamente una licencia del licenciatario original para copiar, distribuir o modificar el
Programa, de forma sujeta a estos términos y condiciones. No puede imponer al receptor ninguna
restricción más sobre el ejercicio de los derechos aquí garantizados. No es usted responsable de
hacer cumplir esta licencia por terceras partes.
8. Si como consecuencia de una resolución judicial o de una alegación de infracción de patente o por
cualquier otra razón (no limitada a asuntos relacionados con patentes) se le imponen condiciones
(ya sea por mandato judicial, por acuerdo o por cualquier otra causa) que contradigan las
condiciones de esta Licencia, ello no le exime de cumplir las condiciones de esta Licencia. Si no
puede realizar distribuciones de forma que se satisfagan simultáneamente sus obligaciones bajo
esta licencia y cualquier otra obligación pertinente entonces, como consecuencia, no puede
distribuir el Programa de ninguna forma. Por ejemplo, si una patente no permite la redistribución
libre de derechos de autor del Programa por parte de todos aquellos que reciban copias directa o
indirectamente a través de usted, entonces la única forma en que podría satisfacer tanto esa
condición como esta Licencia sería evitar completamente la distribución del Programa.
Si cualquier porción de este apartado se considera inválida o imposible de cumplir bajo cualquier
circunstancia particular ha de cumplirse el resto y la sección por entero ha de cumplirse en
cualquier otra circunstancia.
No es el propósito de este apartado inducirle a infringir ninguna reivindicación de patente ni de
ningún otro derecho de propiedad o impugnar la validez de ninguna de dichas reivindicaciones.
Este apartado tiene el único propósito de proteger la integridad del sistema de distribución de
software libre, que se realiza mediante prácticas de licencia pública. Mucha gente ha hecho
contribuciones generosas a la gran variedad de software distribuido mediante ese sistema con la
confianza de que el sistema se aplicará consistentemente. Será el autor/donante quien decida si
quiere distribuir software mediante cualquier otro sistema y una licencia no puede imponer esa
elección.
Este apartado pretende dejar completamente claro lo que se cree que es una consecuencia del
resto de esta Licencia.

9. Si la distribución y/o uso de el Programa está restringida en ciertos países, bien por patentes o por
interfaces bajo copyright, el tenedor del copyright que coloca este Programa bajo esta Licencia
puede añadir una limitación explícita de distribución geográfica excluyendo esos países, de forma
que la distribución se permita sólo en o entre los países no excluidos de esta manera. En ese caso,
esta Licencia incorporará la limitación como si estuviese escrita en el cuerpo de esta Licencia.
10.La Free Software Foundation puede publicar versiones revisadas y/o nuevas de la Licencia
Pública General de tiempo en tiempo. Dichas nuevas versiones serán similares en espíritu a la
presente versión, pero pueden ser diferentes en detalles para considerar nuevos problemas o
situaciones.
Cada versión recibe un número de versión que la distingue de otras. Si el Programa especifica un
número de versión de esta Licencia que se refiere a ella y a «cualquier versión posterior», tienes la
opción de seguir los términos y condiciones, bien de esa versión, bien de cualquier versión
posterior publicada por la Free Software Foundation. Si el Programa no especifica un número de
versión de esta Licencia, puedes escoger cualquier versión publicada por la Free Software
Foundation.
11.Si quiere incorporar partes del Programa en otros programas libres cuyas condiciones de
distribución son diferentes, escribe al autor para pedirle permiso. Si el software tiene copyright de
la Free Software Foundation, escribe a la Free Software Foundation: algunas veces hacemos
excepciones en estos casos. Nuestra decisión estará guiada por el doble objetivo de de preservar
la libertad de todos los derivados de nuestro software libre y promover el que se comparta y
reutilice el software en general.
Ausencia de Garantía
12.Como el programa se licencia libre de cargas, no se ofrece ninguna garantía sobre el
programa, en todas la extensión permitida por la legislación aplicable. Excepto cuando se
indique de otra forma por escrito, los tenedores del copyright y/u otras partes proporcionan
el programa «tal cual», sin garantía de ninguna clase, bien expresa o implícita, con inclusión,
pero sin limitación a las garantías mercantiles implícitas o a la conveniencia para un propósito
particular. Cualquier riesgo referente a la calidad y prestaciones del programa es asumido por
usted. Si se probase que el Programa es defectuoso, asume el coste de cualquier servicio,
reparación o corrección.
13.En ningún caso, salvo que lo requiera la legislación aplicable o haya sido acordado por
escrito, ningún tenedor del copyright ni ninguna otra parte que modifique y/o redistribuya el
Programa según se permite en esta Licencia será responsable ante usted por daños,
incluyendo cualquier daño general, especial, incidental o resultante producido por el uso o la
imposibilidad de uso del Programa (con inclusión, pero sin limitación a la pérdida de datos o
a la generación incorrecta de datos o a pérdidas sufridas por usted o por terceras partes o a
un fallo del Programa al funcionar en combinación con cualquier otro programa), incluso si
dicho tenedor u otra parte ha sido advertido de la posibilidad de dichos daños.
FIN DE TÉRMINOS Y CONDICIONES
Apéndice: Cómo aplicar estos términos a sus nuevos programas.
Si usted desarrolla un nuevo Programa, y quiere que sea del mayor uso posible para el público en
general, la mejor forma de conseguirlo es convirtiéndolo en software libre que cualquiera pueda
redistribuir y cambiar bajo estos términos.

Para hacerlo, añada los siguientes anuncios al programa. Lo más seguro es añadirlos al principio de
cada fichero fuente para transmitir lo más efectivamente posible la ausencia de garantía. Además
cada fichero debería tener al menos la línea de «copyright» y un indicador a dónde puede encontrarse
el anuncio completo.
<una línea para indicar el nombre del programa y una rápida idea de qué hace.>
Copyright (C) 19aa <nombre del autor>
Este programa es software libre. Puede redistribuirlo y/o modificarlo bajo los términos de la Licencia Pública
General de GNU según es publicada por la Free Software Foundation, bien de la versión 2 de dicha Licencia
o bien (según su elección) de cualquier versión posterior.
Este programa se distribuye con la esperanza de que sea útil, pero SIN NINGUNA GARANTÍA, incluso sin
la garantía MERCANTIL implícita o sin garantizar la CONVENIENCIA PARA UN PROPÓSITO
PARTICULAR. Véase la Licencia Pública General de GNU para más detalles.
Debería haber recibido una copia de la Licencia Pública General junto con este programa. Si no ha sido así,
escriba a la Free Software Foundation, Inc., en 675 Mass Ave, Cambridge, MA 02139, EEUU.
Añada también información sobre cómo contactar con usted mediante correo electrónico y postal.
Si el programa es interactivo, haga que muestre un pequeño anuncio como el siguiente, cuando
comienza a funcionar en modo interactivo:
Gnomovision versión 69, Copyright (C) 19aa nombre del autor
Gnomovision no ofrece ABSOLUTAMENTE NINGUNA GARANTÍA. Para más detalles escriba «show w».
Los comandos hipotéticos «show w» y «show c» deberían mostrar las partes adecuadas de la
Licencia Pública General. Por supuesto, los comandos que use pueden llamarse de cualquier otra
manera. Podrían incluso ser pulsaciones del ratón o elementos de un menú (lo que sea apropiado
para su programa).
También deberías conseguir que su empleador (si trabaja como programador) o tu Universidad (si es
el caso) firme un «renuncia de copyright» para el programa, si es necesario. A continuación se ofrece
un ejemplo, altere los nombres según sea conveniente:
Yoyodyne, Inc. mediante este documento renuncia a cualquier interés de derechos de copyright con respecto
al programa Gnomovision (que hace pasadas a compiladores) escrito por Pepe Programador.
<firma de Pepito Grillo>, 20 de diciembre de 1996
Pepito Grillo, Presidente de Asuntillos Varios.
Esta Licencia Pública General no permite que incluya sus programas en programas propietarios. Si
su programa es una biblioteca de subrutinas, puede considerar más útil el permitir el enlazado de
aplicaciones propietarias con la biblioteca. Si este es el caso, use la Licencia Pública General de
GNU para Bibliotecas en lugar de esta Licencia.

Requisitos de Hardware
Dada la naturaleza multiplataforma del código desarrollado, éste puede ejecutarse sobre cualquiera
de las arquitecturas más comunes existentes en el mercado. A continuación se enumeran las
características de un equipo considerado óptimo:
Microprocesador Familia Intel o AMD a 1.400 Mhz

Memoria RAM 256 Mbytes para casos 2D
512 Mbytes para casos 3D
Disco Duro 20 Gbytes
Tarjeta gráfica Aceleradora 3D
Monitor 17 pulgadas
La elección de la cantidad de memoria RAM puede realizarse empleando la siguiente gráfica que, de
forma aproximada, muestra la correlación entre el número de nodos del mallado y la memoria
empleada:
Consumo de RAM
550
500
450
400
Mbytes de RAM
350
300
250
200
150
100
Nodos 3D
Nodos 2D
50
0
0 100 200 300 400 500 600
miles de nodos
Requisitos de Software
La aplicación desarrollada está escrito en Java y en C++, siendo totalmente multiplataforma. Esta
característica le permite ejecutarse sobre cualquier equipo informático existente en el mercado,
siempre que éste posea una versión del Java Runtime Environment (para la versión en Java) o un
compilador ANSI C++ (para crear un ejecutable a partir de los fuentes en C++).
Sistema Operativo Cualquiera de 32 bits

• Linux
• Windows 95, 98, Millenium, 2000 y XP
Máquina Virtual Java Java Runtime Environment 1.4 o superior
Compilador ANSI C++
• GNU GCC
• Microsoft Visual Studio
Capítulo 2. Teoría y algoritmos usados

Resolución de la ecuación de Poisson en 2D mediante Elementos Finitos
Para resolver la ecuación de Poisson en dos dimensiones con condiciones de contorno tipo Dirichlet
homogéneas, el planteamiento general del problema es el siguiente:

2
−∇ u= f en  
u  x , y=0 en  x , y ∈
En principio nos vamos a restringir a una geometría bidimensional cuadrada, pero como se verá más
adelante es fácil generalizarlo a dominios más complicados pero siempre conexos o multiplemente
conexos.
Por lo tanto, el dominio va a ser un cuadrado de lado L:

={ x , y :[ L ,0] x [0, L]} 
Para obtener una buena idea de la exactitud del método se resolverá un problema con solución
analítica exacta de modo que se pueda saber cuanto se aproxima a esta solución exacta.
2
Se supone f =2     

L
sen
x
L
sen
y
L
Es sencillo comprobar que con esta f y las condiciones de contorno, la solución exacta de la ecuación
de Poisson es u=sen    
x
L
sen
y
L
A continuación se procede a discretizar el problema mediante la técnica de los Elementos Finitos. Se

define un espacio de Hilbert L 2  que es un espacio vectorial donde los vectores son funciones
de cuadrado integrable y donde se ha definido un producto escalar.
Se define el producto escalar de vectores en L 2  como 〈 f , g 〉= ∫ f  x g  xdx

2
Se supone que u y f del problema de Poisson son vectores de L  .
Por otro lado, se define unos espacios de Hilbert aproximados donde los vectores son polinomios
dependientes de un número h de parámetros. A este nuevo espacio se le denomina L 2h  y la
expresión de u y f en él es:
L 2  L 2h 
h
u  u h=∑ u i  i
i=1
h
f  f h=∑ f i i
i=1
Donde i son las funciones base y los coeficientes ui y f i son los valores de las funciones u
y f en el nodo i-ésimo.
Los nodos son una serie de puntos que se toman en el dominio al discretizarlo mediante el método
de Galerkin. Estos nodos ayudarán a definir las funciones base.
Sea x
i
un punto del dominio  de forma que: x i= x i1, x i2 
Sea  j una función base, de forma que valga 1 en el nodo j y 0 en los demás.  j  xi  =ij
variando de cero a uno de forma lineal.
Ejemplo unidimensional: =[0,1]
2
x0 x1 x2 x3 x4 x5
x0 x1 x2 x3 x4 x5
{ }
 2  x  =1
2
2 verifica
 2  x j  =0
para j≠2
Ejemplo Bidimensional: =[0,1] x [1,0]
23
{ }
 23  x 23  =1
 23 verifica
23  x j =0
para j≠23
Así se pueden definir las coordenadas baricéntricas de un elemento finito lineal triangular, que
resultarán coincidir con las funciones base:
x 2= x 21, x 22 
e
3 3 3
x = x x 
1, 2
x 1= x 11, x12
i  x =ij lineales. Estas funciones son idénticas a las funciones base, y para el caso
j
Se definen
de un elemento 2D, se pueden definir como los siguientes polinomios en  x 1, x 2 .

∀ x∈e , ∃{1  x  , 2  x  , 3  x} coordenadas baricéntricas.
 1=1011 x 112 x 2 Los coeficientes i se pueden hallar planteando las nueve ecuaciones
2= 2021 x 1 22 x 2 que aparecen al imponer que los  verifiquen las condición:
3 =3031 x 132 x 2
i  x j =ij
Particularizando para el triángulo de referencia:
r El triángulo de referencia será muy útil

para integrar en él funciones. Cualquier
elemento 2D triangular arbitrariamente
0,1 1=1−r−s colocado puede transformarse en él
2=r mediante el correspondiente Jacobiano.
3=s
Los puntos de Gauss para integrar sólo
están definidos en el triángulo de
0,0 referencia.
1,0 s
Se toma la ecuación de Poisson, se multiplica por los  j y se integra en 
−∇ 2 u= f Con esta condición en la frontera
 j ∣ = =0
D
−∫ ∇ u  j d =∫ f  j d 
2
 
Aplicando el teorema de Green al primer miembro de la ecuación resulta:

Siendo el teorema de Green:
∫  j ∇ u d −∫ ∇  j ∇ u d =−∫ f  j d 
   ∇   j ∇ u  = j ∇ 2 u∇ u ∇  j
y se aplica después Gauss en el primer término.
∫  j ∇ u d =0

porque se han definido las funciones base de forma
que  j ∣ = =0
D
Esta ecuación constituye el problema exacto en formulación

∫ ∇  j ∇ u d =∫ f  j d  integral.
 
Pasando a la formulación aproximada, expuesta con anterioridad:

Recordando la aproximación:
∫ u i ∇  j ∇ i d =∫ f i i  j d  L 2  L 2h 

 
h
u  u h=∑ u i  i
i=1
h
f  f h=∑ f i i
Como ui y fi son valores constantes en cada nodo: i=1
u i∫ ∇  j ∇ i d = f i ∫ i  j d 

 

a i , j  matriz de rigidez b i , j  matriz de masas
Queda un sistema lineal de ecuaciones a resolver:
[ [] ] [ [] ]
∫ ∇ 1 ∇ 1 d   ∫ ∇ 1 ∇ N d  u1 ∫ 1 1 d   ∫ 1  N d  f1
   
⋮ ⋱ ⋮ ⋮ = ⋮ ⋱ ⋮ ⋮
uN fN
∫ ∇ N ∇ 1 d   ∫ ∇  N ∇ N d  ∫ N 1 d   ∫ N N d 
   
Donde ambas matrices son conocidas junto con el vector f. El sistema de ecuaciones lineales
resultante se puede resolver aplicando un gradiente conjugado.
Cálculo de divergencias mediante Elementos Finitos
Para el cálculo de la divergencia de un campo vectorial (típicamente la velocidad), se empleará la

formulación variacional de forma análoga a como se ha resuelto la ecuación de Poisson en el capítulo
anterior. El problema al que nos enfrentamos es:
∇⋅u=a en  
Siendo a la divergencia del campo vectorial u.

Partiendo de la ecuación anterior se multiplica por funciones base lineales  lj y se integra en el
dominio  :
∇⋅u =a
∫ ∇⋅u lj d =∫ a lj d 

 
∂u ∂u ∂u
∫ ∂ x x lj d ∫ ∂ yy lj d ∫ ∂ z z lj d =∫ a lj d 
   
Por otro lado se definen unos espacios de Hilbert aproximados donde los vectores son polinomios
dependientes de un número h de parámetros. A este nuevo espacio se le denomina L 2h  y la
expresión de u y a en él es:
L 2  L 2h 
h
u  uh =∑ u i  qi
i=1
h
 a h =∑ a i  i
l
a
i=1
l q
Donde i son funciones base lineales, i son funciones base cuadráticas, y los coeficientes
ui y a i son los valores de las funciones u y a en el nodo i-ésimo. Nótese que la velocidad está
definida en los nodos cuadráticos del mallado, mientras que la divergencia del campo solamente lo
está en los nodos lineales. Esto provocará que aparezcan en el planteamiento matrices no simétricas,
que llamaremos matrices de divergencia:
q q q
∂ i l ∂ i l ∂i l
u xi ∫  j d u y i ∫  j d  u z i∫  j d  =a k ∫ k  j d 
l l
 ∂x
  ∂ y
  ∂z
 

Diver x Diver y Diver z Masaslineal
Las matrices de divergencia X, Y y Z (una por cada componente espacial que tengamos) tienen
tantas filas como nodos lineales (NL) y tantas columnas como nodos cuadráticos (NC):
[ ]
q q
∂ ∂
∫ ∂ x1 l1 d   ∫ ∂ xNC l1 d 
 
Diver x = ⋮ ⋱ ⋮
q q
∂ ∂
∫ ∂ x1 lNL d   ∫ ∂ xNC lNL d 
 
[ ]
q q
∂ ∂
∫ ∂ y1 l1 d   ∫ ∂ yNC l1 d 
 
Diver y = ⋮ ⋱ ⋮
q q
∂ ∂
∫ ∂ y1 lNL d   ∫ ∂ yNC lNL d 
 
[ ]
q q
∂ ∂
∫ ∂ z1 l1 d   ∫ ∂ zNC l1 d 
 
Diver z = ⋮ ⋱ ⋮
q q
∂ ∂
∫ ∂ z1 lNL d   ∫ ∂ zNC lNL d 
 
Transporte Puro (Método de las Características Modificadas)
El método modificado de las características [ALLI] permite integrar los términos convectivos en las
ecuaciones de transporte-difusión de manera sencilla y eficiente, con poca carga computacional.
Dc Ecuación del transporte puro.
=0
Dt
La idea consiste en calcular en el instante t n qué puntos estarán en los nodos en el instante t n+1. De
esta forma se lleva a cabo un transporte de las propiedades del fluido del instante t n al t n+1 sin
necesidad de deformar ni regenerar la malla.
t n-1
tn
Algoritmo
La notación X(x, tn+1 ; t) indica la posición en el instante t de una partícula fluida que alcanza el
punto x en el instante tn+1. La trayectoria de dicha partícula satisface:
{ }
dX
 x , t n1 ; t =u  X  x ,t n1 ; t  , t 
dt
X  x , t n1 ; t n1= x
cumpliendo además:
t n1 El primer término es denominado pie de la

X  x , t n1 ;t n =x− ∫ u  X  x ,t n1 ;t t  dt característica.
tn
La integral se notará en adelante como i
i
Cálculo de alfa
El cálculo de i es un proceso iterativo que a continuación vamos a describir:
i= xi −X  x , t n 1 ;t n 
Aproximando la integral por la regla del punto medio, se obtiene:
i= t⋅u  X i  xi , t n1 ; t n1 / 2 , t n1/ 2 O  t 3  (I)
Siendo Xi(xi, tn+1; tn+1/2) el punto medio del arco que une los puntos  x i , t n1  y
 X i  xi , t n1 ; t n  , t n  .
i
X i  x i , t n1 ; t n1/ 2 = xi − O  t 2 (II)
2
y:
1
 2
u  X i  x i ,t n1 ; t n1 /2  , t n1/ 2 =u x i− i , t n1/ 2 O t 
 2  (III)
 1
Sustituyendo (I) y (II) se obtiene la expresión para calcular i :

1

i= t⋅u x i− i , t n1 /2 O t 3
 2 
1 
La velocidad en (III) se evalúa en el instante t n+1/2. Para ello se empleala fórmula de Adams-
Bashforth:
3 1
u  x , t n1/ 2 = u  x , t n − u  x , t n−1 O  t 2
2 2
Resultando, finalmente, el siguiente algoritmo iterativo:
0
i = t⋅  3
2
1
u xi , t n− u xi , t n−1
2 
i
 k1
= t⋅  3
2
1  k 1 1 k 
u x i −  i ,t n − u  x i−  i , t n−1 
2 2 2 
Se itera hasta que se satisfaga el siguiente criterio de convergencia:
k  k 
e i =i −i
k  k 
e =max∣e i ∣
1
Quedando el error acotado por la expresión: e
k 1
  t⋅e k 
4
Extrapolar mediante polinomio de orden 2

Una alternativa al método es elevar el grado de aproximación de la fórmula de Adams-Bashforth: en
vez de emplear una extrapolación lineal, usar una parábola:
15 10 3
u  x , t n1/ 2 = u x , t n − u  x , t n−1  u x , t n−2O  t 3 
8 8 8
Esto nos obliga a considerar también el instante t n-2, pero el coste es computacionalmente
despreciable.
En la gráfica de Drag y Lift se puede observar como ambas extrapolaciones producen resultados
idénticos en amplitud y Strouhal en régimen permanente, pero la parabólica tiene un transitorio
mucho mayor que la lineal.
Algoritmo de búsqueda SLALG básico
El algoritmo iterativo SLALG (Search and Locate ALGorithm) se emplea para buscar y localizar un
punto (x,y) dado dentro de una malla y encontrar qué elemento lo contiene [ALLI2]. Su uso está
enmarcado generalmente en el cálculo del pie de las características: a lo largo de este proceso los
nodos se desplazan siguiendo la curva característica de la velocidad, pudiendo traspasar los límites
del elemento que originalmente lo contenía. Para saber qué elemento los contiene en su nueva
ubicación es necesario aplicar este método de búsqueda.
Tras la aplicación del método de las características un nodo se desplaza hasta

otra ubicación en un elemento distinto.
El algoritmo es de naturaleza iterativa, realizando un salto de elemento por iteración, partiendo del
elemento original que contenía el nodo hasta que se encuentre el elemento que lo contiene
actualmente. A continuación se muestra un ejemplo de como funciona el algoritmo:
Partiendo de la situación descrita en la imagen anterior, se itera sucesivas veces en

busca de la nueva posición del nodo realizando saltos desde el elemento actual a
sus colindantes.
Partiendo de un elemento dado, la forma de discernir a cual de los tres elementos colindantes saltar
es transformar las coordenadas del punto (x,y) al sistema de referencia del elemento (r,s) y con estos
valores mediante sencillas consideraciones geométricas escoger por qué arista saltar.
1
r
y 3
2
x 1 2
s
Elemento arbitrariamente colocado. Espacio de referencia del elemento.
Las coordenadas en el sistema de referencia del elemento se calculan mediante el método de

Newton, invirtiendo la relación biyectiva que existe entre el elemento de referencia y el elemento
arbitrariamente colocado en el espacio. En el caso de considerar elementos lineales, basta un solo
paso para obtener la solución y equivale a una simple transformación afín:
El método de Newton:
 j
F j : 
3 3
F 1j r , s≡x=∑ xi 1 r , s F 2j r , s≡ y=∑ yi 1 r , s
i =1 i =1
El algoritmo iterativo es el siguiente:
[ ]
−1
k k k k
∂ F 1 r , s  ∂ F 1  r , s 
[ ][ ]
r k1
sk 1
k
= rk 
s
∂r ∂s
∂ F 2 r , s  ∂ F 2 r k , s k 
∂r
k k
∂r
[ x−F 1 r k , s k 
y−F 2  r k , sk  ]
La transformación afín equivalente para elementos lineales es la siguiente, resolviéndose en un solo
paso:
[] [
x
=
1 x 2− x1
y  y 2− y 1
x 3− x1
y 3− y 1 ][ ] [ ]
r
s
x
 1
y1
= x 2− x1  y 3− y 1− x3 −x 1 y 2− y 1 
El siguiente diagrama muestra cómo se decide que salto tomar. En el caso del nodo A, se saltaría al
elemento colindante por la izquierda (en el espacio de referencia del elemento). Si es el nodo B, se
escogería el elemento colindante por abajo. Para seguir buscando el nodo C habría que saltar en
diagonal.
Las líneas azules indican los límites de las fronteras para cada tipo de salto y se corresponden con las
bisectrices de los ángulos que forman las aristas del elemento. Estas tres bisectrices dividen el
dominio en tres regiones, que denominaremos region12, region13 y region23. La numeración se
corresponde con los índices de los nodos que forman la arista que limita con esa región concreta.
Nodo A 3
Nodo C
Salto a región 23
Salto a región 13
1 2
Salto a región 12
Nodo B
El algoritmo podría detallarse en un diagrama de flujo como este:
E=E 0
 x , y r ,s
Sí
Encontrado dentro ?
salto Sí
E=E 12
1−2
salto Sí
E=E 23
2−3
E=E 13
Algoritmo de búsqueda SLALG extendido

El algoritmo iterativo SLALG tal y como lo hemos descrito tiene un serio inconveniente cerca de los
contornos del mallado: dependiendo de multitud de factores (geometría, salto de tiempo, ...) puede
darse el caso de que el pie de la característica caiga fuera del mallado, traspasando las fronteras de
éste.
¡No se puede!
En esta gráfica vemos como al caer el pie de la característica fuera del mallado no es posible realizar el
último salto. No se puede encontrar un elemento que contenga al pie.
Lo que ocurre entonces es que, al saltar de elemento en elemento buscando el pie, nos
encontraremos en el último paso ante la imposibilidad de saltar a un elemento colindante que no
existe. ¿Qué hacer entonces? La solución más sencilla es proyectar de forma perpendicular a la arista
del contorno y asignarle al pie los valores del campo fluido que hay en esa posición.
proyección
El pie de la característica se lleva a la frontera del mallado mediante una proyección

perpendicular a la arista.
Si al proyectar en perpendicular dicha proyección cae fuera de la arista del elemento, se lleva el
punto al vértice más cercano:
proyección
Si la proyección en perpendicular cae fuera de la arista, se lleva al vértice más cercano.
La definición del algoritmo SLALG del capítulo anterior junto con la idea de proyectar los nodos
que caen fuera del dominio sobre los contornos es suficiente para programar de forma satisfactoria el
método de las características. Sin embargo aún se puede refinar más el método:
2
5
4
6
3
4
7
Mejor
Mal
Es posible que con el SLALG clásico lleguemos a una situación como ésta, donde al buscar el pie de la
característica detenemos la búsqueda ante la primera arista del contorno que nos corta el paso (4º salto, en
rojo). Puede verse con claridad como el camino en color verde nos lleva a un elemento final mucho mejor, en
el cual podemos proyectar el pie sobre su arista con mayor precisión (7º salto).
Para ello vamos a ampliar el algoritmo SLALG para hacer frente a situaciones de este tipo: cuando al
proyectar el nodo sobre la arista éste cae fuera del segmento entre los dos nodos que la forman, en
vez de llevarlo al vértice más cercano vamos a realizar un nuevo salto intentanto llegar a una
solución mejor.
También va a ser necesario incluir un mecanismo para evitar que el algoritmo salte de forma
indefinida entre dos elementos en una situación como esta:
El nodo entre las líneas punteadas provoca una sucesión infinita de saltos de un
elemento a otro por encontrarse entre las dos perpendiculares a las aristas.
Este nuevo algoritmo tal y como lo hemos descrito es muy robusto y permite, sin grandes
complicaciones, garantizar soluciones óptimas cerca de los límites de un mallado 2D. El algoritmo
completo, en pseudocódigo, viene detallado en la siguiente página. Una implementación en C++
puede encontrarla en caracteristicas_2d.cpp.
Variables:
• E = elemento actual
• E0 = elemento inicial de la búsqueda
• previo = elemento desde donde hemos saltado al elemento actual.
Procedimientos:
• colindante(arista) = devuelve el elemento colindante que tiene en común con el elemento
actual la arista arista.
• saltoViable(arista) = ∃colindante(arista) y colindante(arista) <> previo
• saltar(arista) = { previo ← E; E ← colindante(arista); }
• proyectar(r, s, arista) = llevar (r, s) a la arista arista de forma perpendicular, o al
vértice del extremo si cae más alla del segmento.
• encontrado(r, s, elemento) = final del algoritmo. El pie se ha encontrado en las
coordenadas (r, s) del elemento elemento.
Etiquetas:
• iterar
Algoritmo:
E ← E0
previo ← {∅}
iterar:
(r,s) ← (x,y) convirtiendo al sistema de coordenadas del elemento E.
si (r,s) ∈ E entonces encontrado(r,s,E)
si (r,s) ∈ region12 entonces
{
si saltoViable(arista12) entonces saltar(arista12) y volver a iterar:
si r<0 y saltoViable(arista13) entonces saltar(arista13) y volver a iterar:
si r>1 y saltoViable(arista23) entonces saltar(arista23) y volver a iterar:
proyectar(r,s,arista12)
encontrado(r,s,E)
}
{
si r<0 y saltoViable(arista13) entonces saltar(arista13) y volver a iterar:
si r>1 y saltoViable(arista12) entonces saltar(arista12) y volver a iterar:
encontrado(r,s,E)
}
{
si s<0 y saltoViable(arista12) entonces saltar(arista12) y volver a iterar:
si s>1 y saltoViable(arista23) entonces saltar(arista23) y volver a iterar:
encontrado(r,s,E)
}
Transporte y Difusión
La ecuación del Transporte y Difusión es la que rige el comportamiento de todas aquellas

propiedades que evolucionan en el seno de un campo fluido. Por ejemplo, el comportamiento de una
gota de tinta en un vaso, o de un contaminante en una red de abastecimiento de agua potable, se
rigen por la siguiente ecuación:
Dc
= ∇ 2 c
Dt
Su resolución implica los siguientes dos pasos o etapas:

1. Transporte puro, mediante el método de las características. Este paso es el encargado de mover
cada uno de los nodos de la malla, hallando el valor de la magnitud c en el instante tn+1 en función
de su posición y valor en el instante tn.
Dc
=0
Dt
2. Resolución del siguiente problema elíptico, que se obtiene partiendo de la ecuación original del
transporte difusión e integrándola:
Dc
= ∇ 2 c
Dt
t n1 t n1
∫ D c= ∫  ∇ 2 c dt
tn tn
n1 n 1 2 n1 1 2 n
c −c =   t ∇ c −   t ∇ c
2 2
A continuación se agrupan los términos del instante de tiempo tn+1 y tn y se aplica la formulación
débil:
1 1
c n1−   t ∇ 2 c n1=c n   t ∇ 2 c n
2 2
∫

 c
n1 1 2 n1
−  t ∇ c
2  
n 1
2 
 j d =∫ c    t ∇ c  j d 
2 n

Finalmente, se discretiza c mediante el uso de funciones base:
c =∑ c i c =∑ c
n n n1 n1
i
[ M ij 
t
2 ] [
Rij c n1= M ij −
t
2
Rij cn
]
Donde el primer corchete es la matriz de coeficientes de un sistema lineal de ecuaciones con
incógnita cn+1 y el término derecho de la ecuación es perfectamente conocido y se corresponde a la

columna de términos independientes del sistema.
Las matrices Mij y Rij son la matriz de masas y rigidez respectivamente.
M ij =∫ i  j d  Rij =∫ ∇ i ∇  j d 
 
El algoritmo, de forma esquemática:
D cn Transporte
=0
Dt
[ M ij 
t
2 ] [
Rij c n1= M ij −
t
2
Rij cn
] Difusión
n = n+1
Para probar el correcto funcionamiento de nuestro código, se ha resuelto el siguiente problema:

0,05
Ai = −0,54,95t 

0,25
Bi = −0,50,75 t 

0,5
C i= −0,375

−A −B −C
0,1 e 0,5 e e
i i i
V i  , t = −A −B −C
e e e
i i i
Donde el valor inicial de los nodos es:

V  x , y ,0=V i  x ,0⋅V i  y ,0
Y el valor de las condiciones de contorno, variables con el tiempo:
V  x , y , t=V i  x , t⋅V i  y , t
Este problema se puede interpretar como el comportamiento de dos frentes confluyentes.

Navier-Stokes
Las ecuaciones de Navier-Stokes describen el comportamiento de todos los fluidos. Particularizadas

para el caso de fluidos newtoniano incompresibles en régimen laminar (bajo número de Reynolds)
quedan reducidas a:
Ecuaciones de Navier-Stokes Condiciones contorno:
 0 : contorno con velocidad fija (entrada).
D u
 = f −∇ p ∇ u
2
Dt u∣ =valor
o
∇⋅u=0  1 : salida del fluido sin tensión. También

denominada condición NBC.
ij n j ∣  =0
1
Ecs. de Navier-Stokes adimensionalizadas
también puede expresarse como:
D u 1  i 2
= 2 f −∇ p ∇ u ∂ u
Dt Fr Re  −n p=0
∂n
∇⋅u=0
La resolución de las ecuaciones de Navier-Stokes no es trivial debido a:

• Son un problema de naturaleza no lineal.
• La ecuación de incompresibilidad.
• El sistema de ecuaciones en derivadas parciales está acoplado por el término no lineal
 u⋅∇  u , la ecuación de incompresibilidad y, en algunos casos, por las condiciones de
contorno empleadas.
Su resolución se lleva a cabo mediante un algoritmo [GLOW] que implica resolver, en varias etapas,
diversos problemas elípticos y de transporte, empleando para la discretización espacial elementos
finitos del tipo Taylor-Hood. Para respetar la condición Babushka-Brezzi emplear elementos de
naturaleza lineal y cuadrática de forma simultánea.
t
s 4
10
3 8
1 7 3
s
5 5
6 6
r
r
1 4 2
Elemento Taylor-Hood 2D Elemento Taylor-Hood 3D
El algoritmo, que a continuación se describe en detalle, incluye para cada salto un esquema de paso
fraccionado: para resolver las ecuaciones de Navier-Stokes, se realiza un problema de trasporte
puro y a continuación un problema de Stokes.
Planteamiento equivalente:
Transporte puro
D u
=0
Dt
Ecs. de Navier-Stokes adimensionalizadas
Problema de Stokes
D u 1  1
= 2 f −∇ p ∇ 2 u  u − ∇ 2 u =
1 
f −∇ p
Dt Fr Re
Fr 2
∇⋅u=0 ∇⋅u=0
y finalmente, desarrollando:
 t
u n1−u n=  ∇ 2 u n1−∇ 2 u n −∇ p n1
2
n1
∇⋅u =0
El algoritmo consta una primera etapa o fase previa donde se calcula la solución y una etapa final
que se encarga de garantizar la adivergencia de la solución recién calculada, mediante un proceso
iterativo.
1 transporte
1 eliptico
u0 , p 0 1 divergencia
t t
1 poisson
t=t1
1 elíptico
um , pm
t t
1 divergencia
1 poisson
m=m1 0
En la primera etapa, es necesario resolver un problema elíptico, una divergencia y un problema de

Poisson, mientras que en el segundo paso, se resuelve un problema elíptico, una divergencia, un
Poisson y además se calculan dos integrales en el dominio.
A continuación se desglosa de forma esquemática el paso previo (nótese que  es la inversa del
número de Reynolds y que  es igual al paso de tiempo):
ut0 , p t0  t 2 t o uo∣ entrada=1

ut −ut −1=  ∇ u −∇ 2 u t−1 −∇ pt
2
uo∣ resto=0
r o=∇⋅u to
∂ o
o =0
∂n
−∇ 2  o=r o
1  o=0

g o = r o o
2
o=g o
Y la etapa iterativa posterior:
um , pm 0
t t  t 2 t
utm−utm−1=  ∇ um −∇ 2 u t−1
m  −∇  m
t
u o∣  =0
2 0
r m=∇⋅u m
∫ rm g m d 

m =
∫ r m m d 

p m1= pm −m  m
u m1=u m −m um
r m1=r m−m r m ∂ m
o =0
∂n
−∇ 2  m=r m
1  m=0
g m1=g m −m  
r  m
2 m 
Criterio de Sí
convergencia: t=t1
∫ rm1 g m1 d  ∫ r m1 g m 1 d 


≤ No 
∫ ro go d  m =
∫ r m gm d 


 m1=g m 1 m  m
El paso previo desglosado en detalle

A continuación detallaremos cada uno de los pasos y lo comentaremos en detalle:
1. Transporte Puro
Mediante el método de las características buscaremos los pies de las características.
D uto
=0
Dt
2. Primer problema elíptico
o uo∣ entrada=1
 t 2 t
t
u −u =
t −1
 ∇ u −∇ 2 u t−1 −∇ pt
2
uo∣ resto=0
En forma matricial.
t
[ D ]=[ masas ] [ rigidez ]
2Re
t
[ E ]=[ masas ] − [ rigidez ]
2Re
[ D ] u tx =[ E ] u t−1 t −1
x [ divergencia x ] po  t Fmasica x
[ D ] u ty =[ E ] uty−1 [ divergencia y ] pto−1 t Fmasica y

[ D ] u tz =[ E ] u tz−1 [ divergencia z ] pto−1 t Fmasica z
Y resolvemos estos tres últimos sistemas de ecuaciones lineales.
t
3. Divergencia r o=∇⋅u o
En forma matricial:
[ masas lineal ] r o=[ divergencia x ] u tx [ divergencia y ] u ty [ divergencia z ] utz
y se resuelve este nuevo sistema.
4. Problema de Poisson
∂ o
o =0
∂n
2
−∇  o=r o
1  o=0
Este problema de Poisson se resuelve como se indicó en el capítulo dedicado al cálculo de estos
problemas.
[ rigidez ] 0=[ masas ] r 0
5. Operaciones vectoriales

g o = r o o
2
 o=g o
Simples operaciones vectoriales.
La etapa iterativa desglosada en detalle

Los pasos que componen la etapa iterativa son prácticamente idénticos en planteamiento a los del
paso previo:
1. Primer problema
 t 2 t 0 u o∣  =0
utm−utm−1=
2
 m  −∇  m
∇ um −∇ 2 u t−1 t
0
Este problema es idéntico al del paso previo, excepto en que no se lleva a cabo un transporte
puro:
t
2Re
t
2Re
[ D ] u mx =[ E ] u m−1
x [ divergencia x ]  m−1
o [ D ] u my =[ E ] u m−1
y [ divergencia y ]  to−1
[ D ] u mz =[ E ] u m−1
z [ divergencia z ]  to−1
2. Divergencia
r m=∇⋅u m
En forma matricial:
[ masas lineal] rm=[ divergencia x ] u mx [ divergencia y ] u my [ divergenciaz ] u mz

y se resuelve este nuevo sistema.
3. Cociente de integrales
∫ rm g m d 

m =
∫ rm m d 

Las integrales en el dominio se calcula de la forma explicada en el capítulo correspondiente.
p m1= pm −m  m
u m1=u m −m um
r m1=r m−m r m
Operaciones vectoriales simples.
5. Problema de Poisson
∂ m
o =0
∂n
−∇ 2  m=r m
1  m=0
6. Se plantea el siguiente sistema de ecuaciones lineales:
[ rigidez ] m=[ masas ] r m
g m1=g m −m
 
r   m
2 m 
8. Convergencia
Para el criterio de convergencia calculamos la siguiente integral:
∫ r m 1 g m1 d 

≤
∫ ro g o d 

• Si se satisface esta condición, se hace t=t+1 y comienza otro paso previo.

• En caso contrario, se realizan las dos operaciones siguientes:
∫ r m1 g m 1 d 

m =
∫ r m gm d 

 m1=g m 1 m  m
y se vuelve a iterar.
La razón de ser de la etapa iterativa posterior es refinar la solución conseguida en el paso previo para
hacerla lo más adivergente posible.
Modelo de turbulencia Smagorinky
Hasta ahora se ha introducido una metodología para resolver las ecuaciones de Navier-Stokes
incompresibles en régimen laminar. La existencia y unicidad de solución para estas ecuaciones solo
puede asegurarse bajo una serie de restricciones que se resumen en que el número de Reynolds tiene
que ser bajo. Al elevar su valor, las soluciones se vuelven inestables y puede darse alguna de las
siguientes situaciones:
• Existencia de una única solución.
• Sistemas estacionarios con más de una solución, con gran dependencia de las condiciones
iniciales.
• Más de una solución, alguna de ellas no estacionaria. La situación estacionaria final tiene
una gran dependencia de las condiciones iniciales.
• Un flujo caótico plenamente desarrollado, con atractores extraños, denominado flujo
turbulento.
En un flujo turbulento la escala a la que tienen lugar los fenómenos que lo provocan es muy pequeña,
resultando imposible recogerlos fielmente en un mallado con los medios informáticos actuales. Una
correlación aproximada entre el tamaño de elemento necesario y el número de Reynolds es la
siguiente:
Tamaño de elemento necesario:
1
h≈ 3/4
Re
A la izquierda se muestra un boceto de cómo los
fenómenos turbulentos (en azul) al ser más pequeños que
el tamaño de elemento pasan totalmente desapercibidos y
es imposible recogerlos en el modelo.
Ante la imposibilidad técnica de resolver flujos turbulentos, se han desarrollado modelos

matemáticos basados en criterios estadísticos que permiten con mallados menos refinados obtener
soluciones que den los valores medios de las propiedades del fluido. Estas formulaciones son de
enorme interés ya que en la mayoría de los problemas de ingeniería no es necesario conocer
exactamente la distribución de la velocidad y la presión, si no que dichos valores medios

proporcionan toda la información necesaria.
velocidad
Gráfica que muestra como, por ejemplo, la
velocidad del fluido se puede descomponer en
v un valor medio al que se le suma una
componente aleatoria.
v=v v '
tiempo
Si en las ecuaciones de Navier-Stokes se sustituyen los términos de velocidad y presión por la suma
de un valor medio y una componente aleatoria, se obtiene lo siguiente:
v=vv ' A estas igualdades se las denomina

p= p p ' descomposición de Reynolds.

∂v i
∂t

∂ vi v j 
∂ xj
− ∂
∂ vi ∂ v j

∂ x j ∂ x j ∂ xi


∂p
∂ xi
=fi
∂vj
=0 Ecuaciones de Navier-Stokes para régimen laminar.
∂xj

∂v i
∂t

∂ vi v j 
∂ xj
− ∂
∂ vi ∂v j

∂ x j ∂ x j ∂ xi


∂p
∂ xi
=fi
∂vj
=0 Ecuaciones de Navier-Stokes al sustituir en ellas la descomposición de Reynolds.
∂xj
∂ v j vi  ∂  v j vi  ∂ v ' j v ' i  Expandiendo este término e introduciéndolo de

=  nuevo en las ecuaciones de Navier-Stokes, se pueden
∂xj ∂ xj xj

I  identificar todas las variables que aparecen en
régimen laminar con las medias en régimen
turbulento, a excepción del término (I) adicional.
∂  v ' j v ' i  ∂ ijR
= Este término se puede expresar en función del tensor
xj ∂xj
de tensiones de Reynolds, también denominado
tensor de tensiones turbulentas ijR

∂v i
∂t

∂ v i v j 
∂ xj


∂v ' i v ' j 
∂xj
− ∂
∂ vi ∂ v j

∂ x j ∂ x j ∂ xi
R


∂p
∂ xi
=fi

∂  ij
∂xj
∂vj
=0 Ecuaciones de Navier-Stokes para régimen turbulento.
∂xj
La aparición de este nuevo término en las ecuaciones requiere que sea modelado de alguna manera,
siendo la propuesta más conocida la de suponer que las tensiones turbulentas son proporcionales al
gradiente de las velocidades medias:
2 Hipótesis para modelar el tensor de tensiones

ijR=2 T  ij − K ij
3 turbulentas, denominada Hipótesis de
v'i v 'i Boussinesq.
K=
2 K es la energía cinética de las fluctuaciones.
ij =

1 ∂ vi ∂ v j

2 ∂ x j ∂ xi 
2 Ecuaciones de Navier-Stokes para régimen
∂v i ∂ vi v j  ∂ vi ∂ p
  −T   =f i turbulento.
∂t ∂ xj ∂ x 2j ∂ x i
Se han eliminado las marcas “-” sobre los valores
∂vj
=0 promediados y se ha incluido el término k en la
∂xj
presión, por lo que no es necesaria su
determinación.
Sobre la base de la modelización anterior del tensor de Reynolds, el problema de incorporar los
efectos de la turbulencia se reduce a encontrar la distribución de viscosidad turbulenta T que
aparece en las ecuaciones de Navier-Stokes. Hay que señalar que ésta no es una propiedad del
fluido, sino que depende del estado local de la turbulencia.
Descripción del modelo

Este modelo es un caso sencillo de los modelos LES (Large Eddy Simulation). La base de estos
modelos es modelar los movimientos más pequeños que no pueden recogerse en la malla y resolver
directamente los movimientos turbulentos de escala mayor.
Para incorporar los efectos de la turbulencia se necesita conocer la distribución de la viscosidad

turbulenta en el fluido. Smagorinsky propone la siguiente fórmula:
T =C  h 2e  2ij ij
ij =

1 ∂ vi ∂ v j

2 ∂ x j ∂ xi
2
 2 2 2
       
2  ij ij =2

∂u
∂x
2
∂v
∂y

∂u
∂y

∂v
∂x
2
∂ u ∂v
∂ y ∂x
en dos dimensiones
La viscosidad turbulenta t está definida en cada nodo del mallado y se incorpora en las
ecuaciones de Navier-Stokes de la siguiente forma:
Navier-Stokes original, cálculo de las matrices [D] y [E]
t
2 Re
t
2Re
Navier-Stokes con modelo Smagorinsky, cálculo de las matrices [D] y [E]
[ Dij ]=[ masasij ] 

t 1
2 Re

i  j
2 [ rigidez ij ]
[ E ij ]=[ masasij ]− 
t 1
2 Re
  j
 i
2 [ rigidez ij ]
opcionalmente la t que aparece en el cálculo de la matriz [D] puede ser la del instante anterior transportada
mediante:
Dt
=0
dt
Condiciones de Contorno Slip
Una importante novedad del solver ADFC es introducir la posibilidad de imponer condiciones de
contorno slip en los problemas.
La condición de contorno slip consiste en imponer que el fluido
u⋅n =0
tenga un cierto deslizamiento sobre la pared, despreciando la capa
∂ ut límite y asumiendo impenetrabilidad en las superficies sólidas.
=
∂n u: velocidad del fluido.
u⋅n =u t n: dirección normal a la superficie.
ut: componente tangencial de la velocidad.
Cuando se trabaja a Reynolds muy altos o con geometrías muy grandes, la capa límite se vuelve tan
fina que su espesor es del mismo orden o más pequeño incluso que el tamaño del elemento típico.
Bajo estas circunstancias, al imponer condiciones de contorno Dirichlet típicas en una superficie,
aparecerá una capa límite falsa mucho más grande que la real, y desvirtuará el resultado:
La línea roja muestra la altura de
Real Sin slip Con slip
la primera fila de elementos.
Como puede observarse, es
imposible simular capas límite
más finas que el tamaño de
elemento.
Nótese que en en caso con slip, no se verifica la condición de no-deslizamiento (velocidad nula en la
pared) y se desprecia la capa límite.
La forma de implementar un esquema slip de grado 1 es muy sencillo: Los nodos de la pared los
consideraremos Dirichlet, pero su valor no será constante, sino que se irá cambiando con el tiempo
de forma que se consiga anular la derivada de la velocidad respecto la normal. Para ello, partiendo de
un nodo ni nos desplazaremos una distancia  en dirección normal a la superficie y copiaremos el
valor de la velocidad en ese punto sobre el nodo ni. Este nuevo valor de la velocidad será
considerado como Dirichlet fijo en la siguiente iteración. Al copiar el valor debemos asegurarnos que
es tangente a la superficie.
Ui
Dti
Nodo Ni
t 1 El próximo valor Dirichlet es el valor de la velocidad a una

Di = u r i  ni⋅t ⋅t distancia de la superficie.
Condiciones de contorno evaluables en tiempo de ejecución (CCETE)

A raíz de la inclusión en la versión 3.10 del solver de un intérprete de funciones matemáticas en
tiempo de ejecución, todas las condiciones de contorno pueden ahora ser introducidas como una
expresión matemática que es evaluada en todos los pasos temporales, actualizando los valores de los
contornos en función de múltiples variables como la posición espacial, instante temporal...
Las posibilidades que le ofrece esta potente característica son enormes y de hecho
condiciones de contorno como los antiguos efecto Magnus y perfiles de velocidad
ahora se realizan mediante este interprete matemático.
La forma de definir una condición de contorno mediante una expresión matemática es muy sencilla:
en el menú del GiD seleccione “Data/Conditions” y en el diálogo que se abre puede introducir
expresiones en los mismos campos que antes aceptaban valores reales. La única limitación es que no
se pueden emplear espacios en blanco en las ecuaciones.
A modo de ejemplo, el efecto Mágnus sobre un cilindro centrado en el origen de

coordenadas (0,0) se describiría mediante las siguientes ecuaciones:
 y i − x j
vel=
 x y
2 2
 x y
2 2
que expresadas en el lenguaje interpretado serían:

velocidad X y/sqrt(x*x+y*y)
velocidad Y -x/sqrt(x*x+y*y)
¡No se olvide de no introducir espacios en blanco!
En el diálogo Conditions puede observar cómo se está a punto de asignar una condición de contorno sobre la
velocidad con valores que se calculan en tiempo de ejecución. En concreto las expresiones que aparecen en los
campos sirven para simular un efecto Magnus sobre el cilindro.
El lenguaje que se emplea en el intérprete es muy sencillo: soporta las funciones matemáticas más
comunes y echando un vistazo al código fuente del solver se puede ampliar su repertorio con
sencillez. A continuación listamos las funciones que están implementadas en este momento:
cos(ángulo) Función trigonométrica coseno, ángulo en radianes.
exp(potencia) Exponencial, devuelve e potencia
in(mínimo, valor, máximo) Devuelve 1 si mínimo < valor < máximo, 0 en caso contrario.
log(real) Logaritmo base e.
pow(base, exponente) exponente
Eleva base al exponente exponente., es decir base
sin(ángulo) Función trigonométrica seno, ángulo en radianes.
sqrt(radicando) Calcula la raíz cuadrada de radicando.
tan(ángulo) Función trigonométrica tangente, ángulo en radianes.
La función in(minimo, valor, maximo) está especialmente indicada a la hora de

definir funciones a trozos. Por ejemplo, en el caso de un perfil parabólico de la
forma:
[ ]
0.57
u=
 
z
6,45
si z≤6,45
u=1.0 si z6,45
lo puede definir en dos trozos así:
pow(z/6.45,0.57)*in(0,z,6.45)+1.0*in(6.45,z,1000)
donde 1000 es un valor auxiliar, lo suficientemente alejado del dominio de interés.
Y en la siguiente tabla se incluyen todas las variables soportadas:

e Base de los logaritmos neperianos.
pi Número 
t Instante de tiempo actual (en tiempo de simulación).
x Coordenada x del nodo actual.
y Coordenada y del nodo actual.
z Coordenada z del nodo actual.
Tenga especial cuidado en asegurarse de que los argumentos que reciben las
funciones matemáticas son válidos en todos los nodos de contorno y en todo instante
de tiempo: una argumento negativo en una raíz cuadrada o en un logaritmo, por
ejemplo, causarán un fallo que interrumpirá inevitablemente la simulación en curso.
Más ejemplos de CCETE

En este apartado enumeraremos varios ejemplos de CCETE's (Condiciones de contorno Evaluables
en Tiempo de Ejecución) para que pueda emplearlos en sus simulaciones:
1. Perfil Parabólico: un perfil parabólico tiene gran utilidad para simular la capa límite de la
atmósfera terrestre en un corte orográfico. Evidentemente min, max y pot no forman parte del
lenguaje y debe sustituirlos por los parámetros concretos del perfil que desee.
[ ]
pot
u=
 z−min
max−min  si min≤z≤max
u=1.0 si zmax
(pow((z-min)/(max-min),pot)-1)*in(min,z,max)+1
2. Perfil Logarítmico: un perfil logaritmico tiene gran utilidad para simular la capa límite de la
atmósfera terrestre en un corte orográfico. Evidentemente min y max no forman parte del
lenguaje y debe sustituirlos por los parámetros concretos del perfil que desee.
[ ]
log y /min
u= si min≤z≤max
log max/min
u=1.0 si zmax
(log(y/min)/log(max/min)-1)*in(min,z,max)+1
3. Efecto Magnus: ésta es una condición de contorno que se aplica sobre cilindros giratorios. El
módulo de la velocidad sobre la superficie es V.
y
V x= V
 x  y2
2
−x
V y= V
 x 2 y 2
Vx: V*y/sqrt(x*x+y*y)
Vy: -V*x/sqrt(x*x+y*y)
4. Entrada suave del fluido: si desea que el fluido en el instante inicial no entre de golpe sino que
alcance progresivamente una velocidad V al paso de T segundos, le será útil la siguiente
expresión.
V x=t∗V /T si tT
Vx=V si tT
(1-in(0,t,T)*(1-t/T))*V
5. Más...
Seguimiento de particulas fluidas

...
Cálculo de los coeficientes de Drag y Lift

A continuación desarrollaremos las expresiones para obtener los valores de los coeficientes de
resistencia (drag) y sustentación (lift) en un cilindro circular 2D.
Para un cilindro, el drag vale:

2
Fx
C D=
1 2
U∞ D
=
1 2
1
 U∞ D
∫
0
 − p n t
∂u
∂n 
⋅1,0 d 
2 2
a continuación se procede a expresarlo en función de la presión y velocidad adimensional:
2 2 adim
adim 2 ∂u
C D=∫ −2 p n⋅1,0d  ∫ 1,0⋅  d 
0 Re 0 ∂r
donde se necesita calcular el valor del vector normal a la superficie:
∂ ∂
=x 2 y 2−R 2 ⇒ =2 x =2 y
∂x ∂y
∣∇ ∣= 4 x2 4 y 2=2  x 2 y 2
n =
2x
,
2 x y 2 x y
2 2
2y
2 2
=
x
 x y 

2 2
, 2 2
y
 x y  
nx ny
y el vector tangente será perpendicular:
 
y −x
t = ,
 x y 
  x y
2 2 2 2
tx ty
las derivadas de las dos componentes de este vector respecto x e y son:

∂n x y2 ∂ ny −x y
= =
∂ x  x 2 y 2 3 /2 ∂ x  x 2 y 2 3/ 2
∂n x −x y ∂ ny x2
= =
∂ y  x 2 y 2 3 /2 ∂ y  x 2 y 2 3/ 2
La velocidad se puede descomponer en sus dos componentes radial y angular:
u = u x ,u y 
u r=u⋅n =u x⋅n x u y⋅n y
u =u⋅t =u x⋅t x u y⋅t y =u x⋅n y −u y⋅n x
Interesan las derivadas de la componente angular respecto a x e y:
∂u  ∂ ux ∂n ∂ u ∂ nx
= n y u x y − y n x u y
∂x ∂x ∂x ∂x ∂x
∂u  ∂ u x ∂n y ∂ u y ∂ nx
= n y u x − n x u y
∂y ∂y ∂y ∂y ∂y
por lo tanto:
∂ u ∂ u ∂ u
= ⋅n x  ⋅n
∂r ∂x ∂y y
Sustituyendo en la expresión del drag y tomando puntos de integración equidistantes por el
perímetro del cilindro:
 
nodos nodos adim
−4 r 4r ∂ u
C D=
nodos
∑ p
adim
i n xi 
nodos⋅R e
∑ n xi ∂r
i=1 i=1 i
y de forma análoga para el lift:
 
nodos nodos adim
−4  r 4r ∂ u
C L=
nodos
∑ p
adim
i n yi
nodos⋅R e
∑ n yi ∂r
i=1 i=1 i
Anexo: Matrices dispersas
Las matrices dispersas o ralas (sparse matrix) son matrices con un elevado número de elementos
nulos. Este tipo de matrices es muy frecuente en los cálculos algebraicos de los métodos numéricos,
por ello es importante encontrar un método adecuado para almacenarlas y operar con ellas.
 
1 2 0 0 0 3 0 0
Esta matriz tiene 64 elementos, de los cuales sólo 16 son diferentes
2 1 0 0 0 0 0 0
0 0 −3 0 0 0 0 0 de cero. Se está desaprovechando el 75% de la RAM empleada para
0 0 0 2 9 0 7 0 almacenarla.
0 0 0 9 5 0 0 0
3 0 0 0 0 1 0 0
0 0 0 7 0 0 2 0
0 0 0 0 0 0 0 −6
Otra desventaja que tienen las matrices dispersas es que se pierde mucho tiempo operando con ellas.
Gran número de operaciones son innecesarias por afectar a elementos nulos.
  
1 2 0 0 0 3 0 0 3
En este producto matriz-vector se realizan 64
2 1 0 0 0 0 0 0 −4
0 0 −3 0 0 0 0 0 2 multiplicaciones y 57 sumas. De ellas, 96 afectarán a
0 0 0 2 9 0 7 0 8 elementos nulos y serán una pérdida de tiempo.
⋅
0 0 0 9 5 0 0 0 −7
3 0 0 0 0 1 0 0 5
0 0 0 7 0 0 2 0 1
0 0 0 0 0 0 0 −6 −9
Buscamos una nueva forma de representar matrices, que permita almacenarlas de forma más
eficiente y realizar operaciones matriciales comunes con rapidez.
El método de las matrices dispersas trabaja con tres vectores que denominaremos con los nombres
que se emplean en el código fuente:
boolean simetrica: variable booleana que indica si la matriz se almacenó teniendo en cuenta la simetría.
Array<int> elem: contiene el valor de los elementos no nulos. Así elem[n] es el valor del elemento no nulo
n-ésimo.
Array<int> jpos: jpos[n] indica en qué columna se encuentra el elemento no nulo n-ésimo. (también se
denomina NNVI)
Array<int> ipos: ipos[n] indica en qué posición de elem y jpos comienzan los elementos de la fila n-ésima.
De esta forma, el contenido de la fila n-ésima de la matriz dispersa estará contenido entre ipos[n] y
ipos[n+1]-1. (también se denomina NVPN)
Almacenando de forma dispersa la matriz del ejemplo:
 
simetrica:
1 2 0 0 0 3 0 0
false
2 1 0 0 0 0 0 0
0 0 −3 0 0 0 0 0 elem[]:
0 0 0 2 9 0 7 0 1 2 3 2 1 -3 2 9 7 9 5 3 1 7 2 -6
0 0 0 9 5 0 0 0 jpos[]:
3 0 0 0 0 1 0 0 0 1 6 0 1 2 3 4 6 3 4 0 5 3 6 7
0 0 0 7 0 0 2 0
ipos[]:
0 0 0 0 0 0 0 −6
0 3 5 6 9 11 13 15 16
En el ejemplo se ha empleado un código de color para diferenciar datos referidos a filas pares e
impares. La numeración de filas, columnas e índices de posición en vectores empiezan en cero: el
primer elemento de un vector o matriz es el matriz[0] (como en C/C++). Si la matriz tiene n filas, el
vector ipos contiene n+1 elementos de forma que este último elemento indica el final de los vectores
elem y jpos.
Como el propósito principal de este método es ahorrar memoria, también es una buena idea
aprovecharse de la condición de simetría de las matrices: si se almacena solo la triangular inferior o
la superior se consigue un importante ahorro añadido. A continuación hemos repetido el ejemplo,
pero almacenando solo la triangular inferior. Nótese que cada fila se almacena empezando por el
elemento de la diagonal: así elem[ipos[n]] es el elemento Mn,n.
 
Almacenamos solo la matriz triangular inferior:
1       
simetrica:
2 1      
true
0 0 −3     
elem[]:
0 0 0 2    
1 1 2 -3 2 5 9 1 3 2 7 -6
0 0 0 9 5   
3 0 0 0 0 1   jpos[]:
0 0 0 7 0 0 2  0 0 1 2 3 3 4 0 5 3 6 7
0 0 0 0 0 0 0 −6 ipos[]:
0 1 3 4 5 7 9 11 12
El último elemento de ipos[] nos dice que el tamaño es 12.
A continuación se incluye código en Java para realizar operaciones matriciales básicas con matrices
simétricas. El código generalmente es válido también para trabajar con matrices no simétricas.
Empezaremos indicando como calcular la fila y la columna en la matriz triangular inferior de un
elemento conocida su posición en elem[].
int getColumna(int n)
{ return jpos[n]; }
int getFila(int n)
{
for(int k=1; k<ipos.length; k++)
if(ipos[k] > n) return k-1;
// si llega aquí, error.

}
La operación inversa no es complicada: se busca la posición en elem conociendo la fila i y la

columna j en la matriz dispersa. Una vez obtenida, se devuelve el valor del elemento. Si la matriz es
simétrica nos aseguramos de que i y j acceden a la matriz triangular inferior.
public double leeElemento(int i, int j)

{
if(simetrica && (i < j)) // Solo nos interesa la triangular inferior.
{ int t = i; i = j; j = t; }
// buscamos a lo largo de la fila i el elemento en la columna j

for(int n=ipos[i]; n<ipos[i+1]; n++)
if(jpos[n]==j) return(elem[n]);
// Si no lo hemos encontrado es que es un nulo

return 0.0;
}
Multiplicar una matriz dispersa por un escalar es trivial: basta multiplicar todos los elementos de
elem por dicho valor.
public void multiplica(double factor)

{
for(int j=0; j<elem.length; j++)
elem[j] *= factor;
La operación de multiplicación matriz por vector también resulta sencilla y muy rápida, pero tiene
una pequeña complicación cuando tratamos con una matriz simétrica: en este caso el recorrer una
fila de la triangular implica recorrer la fila hasta la diagonal y completar el recorrido por la columna
(ya que solo se ha almacenado la triangular), así que se hacen esas dos operaciones a la vez.
  
1 2 0 0 0 3 0 0 3
En negrita y cursiva la fila que multiplica elemento a
2 1 0 0 0 0 0 0 −4
0 0 −3 0 0 0 0 0 2 elemento al vector columna.
0 0 0 2 9 0 7 0 ⋅ 8
0 0 0 9 5 0 0 0 −7
3 0 0 0 0 1 0 0 5
0 0 0 7 0 0 2 0 1
0 0 0 0 0 0 0 −6 −9
  
Cuando la matriz se almacena en RAM
1        3
aprovechando su simetría, no se dispone de la fila
2 1       −4
completa: solo hasta la diagonal. Los demás
0 0 −3      2
elementos se toman de la columna empleando una
0 0 0 2     ⋅ 8
0 0 0 9 5    −7 especie de rebote en la diagonal.
3 0 0 0 0 1   5 Obsérvese como por el nuevo camino los valores
0 0 0 7 0 0 2  1 son los mismos que en la matriz anterior.
0 0 0 0 0 0 0 −6 −9
public double[] multiplica(double[] vector, int tamfila)

{
double resultado[] = new double[tamfila];
if(simetrica)
{
for(int i=0; i<resultado.length; i++)
resultado[i] = 0.0;
// recorremos filas
int j;
for(int i=0; i<resultado.length; i++)
{
// La diagonal solo implica 1 operación.
resultado[i] += elem[ipos[i]] * vector[i];
// recorremos la fila, productos dobles

for(int l = ipos[i]+1; l < ipos[i+1]; l++)
{
j = jpos[l];
resultado[i] += elem[l] *
vector[j];
resultado[j] += elem[l] *
vector[i];
}
}
}
else // caso asimétrica
{
for(int i=0; i<resultado.length; i ++)
{
resultado[i] = 0.0;
for(int k=ipos[i]; k<ipos[i+1]; k++)

resultado[i]
+=elem[k]*vector[jpos[k]];
}
}
return resultado;
}
Todas las operaciones necesarias con matrices dispersas se encuentran en la clase Java del código
fuente balrog.fluidos.util.Matriz y en el fichero C++ sparse_matrix.cpp.
Anexo: Resolución de sistemas de ecuaciones lineales mediante Gradiente

Conjugado
En el proceso de simulación de campos fluidodinámicos es necesario resolver gran número de

sistemas de ecuaciones lineales con un elevado número de incógnitas con gran rapidez.
Un buen método para resolver sistemas de ecuaciones lineales es el Gradiente Conjugado, que aquí
emplearemos con un precondicionador de Cholesky Incompleto. Para que el sistema de ecuaciones
lineales se pueda resolver mediante este método, la matriz de coeficientes del sistema debe ser
simétrica y definida positiva.
El sistema lineal tiene la forma: [ M ]⋅x =b

Y el gradiente conjugado básicamente responde al siguiente algoritmo:
[ N ]=Precondicionador [M ] La misión de la matriz [N] es conseguir rebajar el número de condición
de la matriz de coeficientes [M]. Más adelante se comentará diferentes
métodos para calcularla.
x0=0
s0 =[ N ]⋅r0
p0= s0
Y aquí comienza un bucle k=0, 1, 2, 3, ..., n:
rk⋅sk
a=
pk⋅ [ A]⋅ pk 
x k 1=x k a⋅pk
rk⋅rk
=
b⋅b
Si conv se ha alcanzado una solución xk con suficiente precisión. En caso
contrario:
r k 1 =rk −a⋅ [ A]⋅ pk 

s k 1 =[N ]⋅r k 1
r k1⋅r k 1
c=
rk⋅rk
p k 1 =s k1c⋅pk
y vuelta a empezar el bucle, con k=k+1.
La convergencia del método es tanto mejor cuanto más reduzca la matriz [N] del precondicionador
el número de condición del sistema.
El cálculo exacto de la inversa de la matriz de coeficientes no es computacionalmente viable porque

si se tiene una matriz [M] dispersa de tamaño NxN, muy grande, se la puede almacenar en
memoria gracias a eliminar de su estructura los elementos nulos, pero su inversa con toda certeza no
tendrá un número de nulos tan elevado y sus necesidades de almacenamiento en memoria RAM
serán excesivas.
Los dos precondicionadores más usados son:

• Jacobi: se hace la matriz [N] igual a una matriz que contenga exclusivamente las inversas
de los elementos existentes en la diagonal de [M]. Es muy es sencillo de programar, la
generación de [N] es rapidísima pero no acelera demasiado la convergencia del gradiente
conjugado.
• Cholesky incompleto: se lleva a cabo una descomposición de Cholesky sobre la matriz
[M], de forma que se obtienen las siguientes matrices:
[ M ]=[ L]⋅[ D ]⋅[ L]t
Se denomina incompleto porque se impone a la matriz [L] que tenga la misma estructura
de nulos que la matriz [M], obligándola de esta forma a comportarse como si fuera una
matriz dispersa.
Evidentemente [L] y [M] no tienen la misma estructura, por lo que se introducen errores
en el cálculo de la inversa. De todas formas, es un precondicionador muy bueno, que
consigue convergencias muy rápidas. La descomposición de Cholesky es bastante lenta,
pero tiene la ventaja de que si la matriz de coeficientes de usa en la resolución de varios
sistemas de ecuaciones, la matriz [L] se puede reutilizar.
Anexo: Cálculo de integrales en un elemento finito 2D mediante Newton-

Cotes
La integración en un elemento finito triangular colocado de forma arbitraria en el espacio es algo

relativamente complicado, por lo que conviene antes de integrar transformar el dominio de
integración a uno que coloque el elemento coincidente con los ejes coordenados.
Aplicando un cambio de coordenadas lineal de (x,y) a (u,v), se obtiene:
1
r
3
y
2
1 2
s x
Fe
x= AuB vC Con A, B, C, D, E y F constantes propias de cada

y=D uE vF elemento.
Siendo: Imponiendo que (x1,y1) sea el punto (0,0) transformado,

(x2,y2) el (1,0) y (x3,y3) el (0,1) se obtienen los valores de
A= x 2−x 1 D= y 2− y 1
las constantes.
B=x 3−x 1 E= y 3− y1
C= x1 F = y1 Se denomina a esta transformación afín Fe.
x=F e x =B e⋅x b e

El Jacobiano de la transformación, necesario para integrar, resulta ser igual a dos veces el área del
elemento:
[ ]
∂ x u , v ∂ x u , v 
∣J∣=Det ∂u
∂ y u , v 
∂v
∂ y  u , v B E [ ]
=Det A D = x 2− x1  y 3− y 1− y 2− y 1 x 3−x 1 
∂u ∂v
La inversa de la matriz Jacobiana también resultará útil:
T
[J] =
−1  Adj [ J ]
∣J∣
= [
1 D −B
∣J ∣ −C A ]
A continuación se resuelve la integral de una función f(x,y) polinómica de primer grado:
∬ f x , yd 

∬ C 1 xC 2 yC 3 dxdy=∬ C 1 uC 2 vC 3 ∣J∣du dv

 

La integral en el elemento de la función escalar f(x,y) se realiza pasando de dominio  al dominio

transformado.
En el cambio de coordenadas aparece el Jacobiano, recién calculado.
Realizando la integración:
∬ C 1 uC 2 vC 3 ∣J∣du dv


1 1−u
∫ du ∫ dv C 1 uC 2 vC 3 ∣J∣= 6 1 6 2  2 3

0 0
 C C C
∣J∣
Generalmente lo que conocemos es el valor de la función integrando en los nodos del mallado, así
que a partir de esos valores despejaremos los coeficientes C1, C2 y C3.
f 1= f 0,0=C 3 Despejando el valor de los coeficientes de f(x,y):
f 2= f 1,0=C 1C 3
f 3= f 0,1=C 2C 3 C 1= f 2− f 1
C 2= f 3− f 1
C 3= f 1
Y finalmente, sustituyendo:
∬ f  x , y dxdy =  C1 C 2 C3
6
 
6 2
S

∣J∣=  f 1 f 2 f 3
3
Resultado final, siendo S la superficie del elemento finito, y f1, f2 y f3 los valores de la función a
integrar en los nodos del elemento.
Este método es generalizable a funciones f(x,y) polinómicas de orden superior (es normal hasta de
orden 3) y a otros dominios, como pueden ser cuadrados o tetraedros. Es preferible emplear un
paquete de cálculo simbólico para llevar a cabo los cálculos, sobre todo cuando la geometría se
complica o el grado de la función polinómica a integrar se eleva. Este problema planteado en
Mathematica ocuparía unas pocas líneas:
Definimos la función polinómica a integrar.

F1[u_,v_]:=A u + B v + C
Calculamos la integral y sustituimos los coeficientes por valores de la función en puntos

conocidos.
Simplify[ReplaceAll[
Integrate[Integrate[F1[u,v], {v,0,1-u}], {u,0,1}],
Solve[ f1==F1[0,0] && f2==F1[1,0] && f3 == F1[0,1] , {A,B,C}]]]
f 1  f 2 f 3
Resultado: (falta multiplicar por 2 veces el area del elemento)
6
f1,f2,f3 son los vértices del elemento.
De la misma forma se puede calcular para un polinomio de grado 2. No se repetirán los cálculos,
bastante tediosos, pero sí se dará la solución y su planteamiento en Mathematica:
Definimos la función polinómica a integrar.

F2[u_,v_]:=A u^2 + B v^2 +C u v + D u +E v + F
Calculamos la integral y sustituimos los coeficientes por valores de la función en puntos

conocidos.
Simplify[ReplaceAll[
Integrate[Integrate[F2[u,v], {v,0,1-u}], {u,0,1}],
Solve[ F2[0,0]==f1 && F2[1,0]==f2 && F2[0,1]==f3
&& F2[1/2,0]==f4 && F2[1/2,1/2]==f5 && F2[0,1/2]==f6, {A,B,C,D,E,F}]]]
f 4 f 5 f 6
Resultado: (falta multiplicar por 2 veces el area del elemento)
6
f4,f5,f6 son los puntos medios de los lados.
A continuación se enumeran las fórmulas de integración de Newton-Cotes para varios dominios y

grados.
Para lineas,  polinómica grado 1:

∣e∣
∫e  x d = 2  12 
Para lineas,  polinómica grado 3:
∣e∣ x1 x2

∫e  x d = 6  14 122  donde x 12=
2
Para triángulos,  polinómica grado 1:
∣e∣ ∣e∣ x1 x2 x3

∫e  x d = 3  123 = 3 123 donde x 123 =
3
∣e∣
∫e  x d = 3  456 
∣e∣
∫e  x d = 3 [ 3  123 8  456 27 123]
Para tetraedros,  polinómica grado 1:
∣e∣
∫e  x d = 4  1234 
Para tetraedros,  polinómica grado 2:
∣e∣ x1 x2 x3 x4

∫e  x d = 4 [ 16 1234  1234  ] donde x 1234 =
4
Anexo: Integración por coordenadas baricéntricas
Para integrar cualquier expresión de la forma:
∬ i  j d 
∂ ∂  j
∬ ∂ x i d
k ∂ xl
o similar se puede recurrir a la fórmula de integración de las coordenadas baricéntricas:

m !m !m !
∫  m1  m2 mn1 d = m m1 m
1 2 n1 2 n1
n!
n!∣e∣
1 2 n1
n: dimensión del elemento (1 para lineal, 2 para plano, 3 para volumen)

∣e∣: longitud, área o volumen del elemento.
Los pasos a seguir son reducir en primer lugar la expresión a términos en función de i (coordenadas
baricéntricas) y a continuación integrar uno a uno cada uno de los sumandos.
Anexo: Tabla de funciones base del triángulo 2D s
Para un elemento lineal:

5
6
1 = 1 1 =1−r −s ∂ 1 ∂ 2 ∂ 3
 2=2  2=r =−1 =1 =0
∂r ∂r ∂r
r
3 =3 3 =s ∂ 1 ∂ 2 ∂ 3 1 2
4
=−1 =0 =1
∂s ∂s ∂s
Para un elemento cuadrático:

1 = 1 2 1−1 1 =1−r−s1−2 r−2 s 
 2=2 2  2−1  2=r 2 r −1
3 =3 2 3−1 3 =s 2 s−1
 4=4 1 2  4=4 1−r −s r
5 =4 2 3 5 =4 r s
6 =4 1  3 6 =4 1−r −s s
∂ 1 ∂ 2 ∂ 3
=4 r4 s−3 =4 r −1 =0
∂r ∂r ∂r
∂ 4 ∂ 5 ∂ 6
=4−8 r−4 s =4 s =−4 s
∂r ∂r ∂r
∂ 1 ∂ 2 ∂ 3
=4 r4 s−3 =0 =4 s−1
∂s ∂s ∂s
∂ 4 ∂ 5 ∂ 6
=−4 r =4 r =4−4 r −8 s
∂s ∂s ∂s
En elementos lineales y cuadráticos:
∂r E ∂ r −B A= x 2−x 1
= =
∂ x ∣J ∣ ∂ y ∣J ∣ B=x 3−x 1
∂ s −D ∂s A D= y 2− y 1
= =
∂ x ∣J ∣ ∂ y ∣J ∣ E= y 3− y 1
∂1 y 2 − y 3 ∂ 2 y 3− y 1 ∂ 3 y 1 − y 2
= = =
∂x ∣J∣ ∂x ∣J∣ ∂x ∣J∣
∂1 x 3− x 2 ∂ 2 x 1−x 3 ∂ 3 x 2− x1
= = =
∂y ∣J∣ ∂y ∣J∣ ∂y ∣J∣
∣J∣=Det A
B [ E]
D = x − x  y − y − y − y  x −x 
2 1 3 1 2 1 3 1
Anexo: t abla de funciones base del tetraedro 3D
t
Para un elemento lineal: 4
1 = 1 1 =1−r −s−t
 2=2  2=r 10
8
3 =3 3 =s
9
 4=4  4=t
1 7 3
∂1 ∂ 2 ∂ 3 ∂ 4 s
=−1 =1 =0 =0
∂r ∂r ∂r ∂r 5
∂1 ∂ 2 ∂ 3 ∂ 4 6
=−1 =0 =1 =0
∂s ∂s ∂s ∂s 2
∂1 ∂ 2 ∂ 3 ∂ 4
=−1 =0 =0 =1 r
∂t ∂t ∂t ∂t
La transformación de coordenadas es:
{ }
[ ]
x= X 21 r X 31 s X 41 t x 1 ∂x ∂x ∂x
y=Y 21 r Y 31 sY 41 t y 1 ∂r ∂s ∂t
[ ]
z=Z 21 rZ 31 sZ 41 t z 1
x 2− x1 x3 −x 1 x 4−x 1
[ J ]= ∂ y ∂y ∂y
= y 2− y 1 y3 − y1 y 4− y 1
∂r ∂s ∂t
Aij =a i−a j z 2− z 1 z 3 −z 1 z 4−z 1
∂z ∂z ∂z
∂r ∂s ∂t
[ ][
∂r ∂r ∂r
∂x ∂y ∂z
]
Y 31 Z 41−Y 41 Z 31 X 41 Z 31− X 31 Z 41 X 31 Y 41− X 41 Y 31
1
[J] = ∂s ∂s ∂s
−1
= Y Z −Y Z X 21 Z 41− X 41 Z 21 X 41 Y 21− X 21 Y 41
∂x ∂y ∂ z 6∣e∣ 41 21 21 41
Y 21 Z 31−Z 21 Y 31 X 31 Z 21− X 21 Z 31 X 21 Y 31− X 31 Y 21
∂t ∂t ∂t
∂x ∂y ∂z
∣J∣=6∣e∣=X 31 Y 41 Z 21 X 41 Y 21 Z 31  X 21 Y 31 Z 41− X 41 Y 31 Z 21 − X 21 Y 41 Z 31−X 31 Y 21 Z 41
Las derivadas de las coordenadas baricéntricas:

∂1
∂x
=− 
∂ 2 ∂ 3 ∂ 4

∂x ∂ x

∂x  ∂ 1
∂y
=−∂ 2 ∂ 3 ∂ 4

∂y ∂y ∂y
  ∂ 1
∂z
=− 
∂ 2 ∂ 3 ∂ 4
∂z

∂z

∂z 
∂ 2 Y 31 Z 41−Y 41 Z 31 ∂ 2 X 41 Z 31−X 31 Z 41 ∂ 2 X 31 Y 41 − X 41 Y 31
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J ∣
∂ 3 Y 41 Z 21−Y 21 Z 41 ∂ 3 X 21 Z 41−X 41 Z 21 ∂ 3 X 41 Y 21 − X 21 Y 41
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J∣
∂ 4 Y 21 Z 31−Y 31 Z 21 ∂ 4 X 31 Z 21−X 21 Z 31 ∂ 4 X 21 Y 31 − X 31 Y 21
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J ∣
Para un elemento cuadrático:

1 = 1 2 1−1 5 =4 1  2
 2=2 2  2−1 6 =4 2 3
3 =3 2 3−1 7 =4 1  3
 4=4  2 4−1 8 =4 1  4
9 =4 2 4
10=4 3  4
Anexo: Matriz de masas
La matriz de masas para un elemento triangular lineal se define como:
[ ]
∬e 1 1 d  ∬e 1 2 d  ∬e 1 3 d 
M ij = ∬ 2 1 d  ∬  2  2 d  ∬  2  3 d 
e e e
∬e 3 1 d  ∬e 3 2 d  ∬e 3 3 d 
Operando: s
[ ]
1 1 1
3
6 12 12
1 1 1
M ij=∣e∣
12 6 12
1 1 1
12 12 6
r
Para su obtención solo es necesario realizar dos 1 2
integrales, ya que todos los cálculos para obtener los 9 elementos se reducen a uno de esos dos
casos:
• Integral de una función base por sí misma (elementos de la diagonal):

1  x , y =1  x , y 1  x , y
∣e∣
∬e 1 1 d =∬e 1 d =3 [ 1  0.5 , 0 1  0.5 , 0.5 1  0 , 0.5  ]=
=
3 4[
∣e∣ 1
0 =]
1 ∣e∣
4 6
• Integral de una función base por otra (resto de elementos):

12  x , y = 1  x , y  2  x , y
∣e∣
∬e 1 2 d =∬e 12 d =3 [ 12  0.5 , 0  12  0.5 , 0.5 12  0 , 0.5 ]=
=
3 4[
∣e∣ 1
]
00 =
∣e∣
12
La matriz de masas para un elemento triangular s
cuadrático (Taylor-Hood) se define como: 3
[∬e 1 1 d  ∬e 1 6 d 
]
⋯
M ij = ⋮ ⋱ ⋮ 6
5
∬e 6 1 d  ⋯ ∬e 6 6 d 
r
Operando: 1 4 2
[ ]
1 −1 −1 −1
0 0
30 180 180 45
−1 1 −1 −1
0 0
180 30 180 45
−1 −1 1 −1
0 0
180 180 30 45
M ij =∣e∣
−1 8 4 4
0 0
45 45 45 45
−1 4 8 4
0 0
45 45 45 45
−1 4 4 8
0 0
45 45 45 45
La matriz de masas para un elemento tetraédrico lineal se define como:
[∬e 1 1 d  ∬e 1 4 d 
]
⋯
M ij = ⋮ ⋱ ⋮
∬e 4 1 d  ⋯ ∬e 4 4 d 
t
Operando: 4
[ ]
1 1 1 1
10
10 20 20 20 8
1 1 1 1
9
M ij=∣e∣ 20 10 20 20
1 1 1 1 La 1 7 3
20 20 10 20 s
1 1 1 1 5
20 20 20 10 6
Por su parte, la matriz de masas para un r

elemento tetraédrico cuadrático se define como:
[ ∬e 1 1 d  ∬e 1 10 d 
]
⋯
M ij = ⋮ ⋱ ⋮
∬e 10 1 d  ⋯ ∬e 10 10 d 
Operando:
[ ]
Con las siguientes equivalencias:
D E E E F G F F G G
A = 8/105
E D E E F F G G F G
E E D E G F F G G F B = 4/105
E E E D G G G F F F C = 2/105
D = 1/70
M ij =∣e∣ F F G G A B B B B C
E = 1/420
G F F G B A B C B B
F G F G B B A B C B F = -1/105
F G G F B C B A B B G = -1/70
G F G F B B C B A B
G G F F C B B B B A
Anexo: Matriz de rigidez
La matriz de rigidez para un elemento triangular lineal se define como:
[ ]
∬e ∇ 1 ∇ 1 d  ∬e ∇ 1 ∇ 2 d  ∬e ∇ 1 ∇ 3 d 
Rij = ∬ ∇ 2 ∇ 1 d  ∬ ∇ 2 ∇ 2 d  ∬ ∇ 2 ∇ 3 d 
e e e
∬e ∇ 3 ∇ 1 d  ∬e ∇ 3 ∇ 2 d  ∬e ∇ 3 ∇ 3 d 
s
Operando:
3
[ ]
r 11 r 12 r 13
Rij =∣e∣ r 12 r 22 r 23
r 13 r 23 r 33
r

r ij =
∂ i ∂  j ∂i ∂  j
∂x ∂x

∂y ∂y  1 2
Los valores de las derivadas parciales ya están calculados en el apéndice de funciones base:
∂1 y 2 − y 3 ∂ 2 y 3− y 1 ∂ 3 y 1− y 2
= = =
∂x ∣J∣ ∂x ∣J∣ ∂x ∣J∣
∂1 x 3− x 2 ∂ 2 x 1−x 3 ∂ 3 x 2− x1
= = =
∂y ∣J∣ ∂y ∣J∣ ∂y ∣J∣
∣J∣= x 2−x 1  y 3− y 1 − y 2− y 1  x3− x1 
La matriz de rigidez para un elemento triangular cuadrático (Taylor-Hood) se define

como:
[ ∬e ∇ 1 ∇ 1 d  ∬e ∇ 1 ∇ 6 d 
]
⋯
Rij = ⋮ ⋱ ⋮
s
∬e ∇ 6 ∇ 1 d  ⋯ ∬e ∇ 6 ∇ 6 d 
3
5
6
r
1 4 2
Operando:
[ ]
r 11 r 12 r 13 r 14 r 15 r 16
r 12 r 22 r 23 r 24 r 25 r 26
r r 23 r 33 r 34 r 35 r 36
Rij = 13
r 14 r 24 r 34 r 44 r 45 r 46
r 15 r 25 r 35 r 45 r 55 r 56
r 16 r 26 r 36 r 46 r 56 r 66
A continuación detallamos los valores elemento a elemento:
r 11=∣e∣  ∂1 ∂1 ∂ 1 ∂ 1


∂x ∂ x ∂ y ∂ y  1
r 12=− ∣e∣
3 ∂ 1 ∂ 2 ∂1 ∂2
∂x ∂x

∂y ∂y 
r 22=∣e∣  ∂ 2 ∂ 2 ∂ 2 ∂  2
∂ x ∂x

∂y ∂y  1
r 13=− ∣e∣
3 ∂ 1 ∂ 3 ∂ 1 ∂ 3

∂x ∂x ∂y ∂y 
r 33=∣e∣  ∂3 ∂ 3 ∂ 3 ∂  3

∂x ∂x ∂y ∂y  1
r 23=− ∣e∣
3 ∂2 ∂3 ∂2 ∂ 3

∂x ∂ x ∂ y ∂ y 
8
r 44= ∣e∣
3 
∂ 1 ∂ 2 ∂ 1 ∂ 2 ∂ 1 ∂1 ∂ 1 ∂1 ∂ 2 ∂2 ∂2 ∂ 2
  
∂ x ∂ x ∂ y ∂ y ∂x ∂x ∂ y ∂ y ∂ x ∂x
 
∂y ∂ y 
8
r 55= ∣e∣
3 
∂2 ∂ 3 ∂ 2 ∂ 3 ∂ 2 ∂2 ∂2 ∂ 2 ∂ 3 ∂ 3 ∂ 3 ∂ 3
 
∂x ∂ x ∂ y ∂ y ∂ x ∂x
 
∂y ∂y ∂x ∂x ∂y ∂y
 
8
r 66= ∣e∣
3 
∂1 ∂3 ∂1 ∂3 ∂1 ∂1 ∂1 ∂ 1 ∂3 ∂3 ∂3 ∂3
 
∂x ∂ x ∂ y ∂ y ∂x ∂x
 
∂ y ∂ y ∂x ∂x

∂y ∂y 
4
r 45= ∣e∣
3  
∂2 ∂ 1 ∂ 2 ∂3

∂x ∂ x ∂x

∂x   
∂x ∂ x ∂ y ∂ y ∂ y ∂ y
 
∂  ∂ 3 ∂ 2 ∂  1 ∂  2 ∂  3
2 1
∂  ∂ 3
2 1
∂y ∂y  
4
r 46= ∣e∣
3  
∂1 ∂ 1 ∂ 2 ∂3
∂x ∂x

∂x

∂x   
∂x ∂ x ∂ y ∂ y ∂ y ∂ y
 
∂  ∂ 3 ∂ 1 ∂ 1 ∂ 2 ∂ 3
2 2
∂  ∂ 3
2 2
∂y ∂y  
4
r 56= ∣e∣
3  
∂ 3 ∂ 1 ∂ 2 ∂ 3

∂ x ∂x ∂ x ∂ x
 2 
∂x ∂x
 
∂y ∂y ∂y ∂y 
∂ 1 ∂ 2 ∂ 3 ∂ 1 ∂ 2 ∂ 3
 2
∂y ∂y 
∂ 1 ∂ 2

4
r 14=r 24 = ∣e∣
3 
∂ 1 ∂2 ∂1 ∂2
∂ x ∂x

∂y ∂y 
4
r 16=r 36 = ∣e∣
3 
∂1 ∂ 3 ∂1 ∂ 3

∂x ∂x ∂y ∂ y 
4
r 25=r 35= ∣e∣
3 
∂ 2 ∂3 ∂2 ∂3
∂ x ∂x

∂y ∂y 
La matriz de rigidez para un elemento tetraédrico lineal se define como:
[ ∬e ∇ 1 ∇ 1 d  ∬e ∇ 1 ∇ 4 d 
]
⋯
Rij = ⋮ ⋱ ⋮
∬e ∇ 4 ∇ 1 d  ⋯ ∬e ∇ 4 ∇ 4 d 
t
Operando: 4
[ ]
r 11 r 12 r 13 r 14
10
r r 22 r 23 r 24
Rij = 12 8
r 13 r 23 r 33 r 34
9
r 14 r 24 r 34 r 44
1 7 3
s

r ij =
∂i ∂  j ∂i ∂ j ∂ i ∂  j
∂x ∂x
 
∂ y ∂ y ∂ z ∂z  5
6
Los valores de las derivadas parciales están calculados en

r
detalle en el apéndice de funciones base:
∂1
∂x
=− 
∂ 2 ∂ 3 ∂ 4

∂x ∂ x

∂x  ∂ 1
∂y
=− 
∂ 2 ∂ 3 ∂ 4

∂y ∂y ∂y
  ∂ 1
∂z
=−
∂z 
∂ 2 ∂ 3 ∂4

∂z

∂z 
∂2 Y 31 Z 41−Y 41 Z 31 ∂ 2 X 41 Z 31−X 31 Z 41 ∂2 X 31 Y 41− X 41 Y 31
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J ∣
∂3 Y 41 Z 21−Y 21 Z 41 ∂ 3 X 21 Z 41−X 41 Z 21 ∂ 3 X 41 Y 21− X 21 Y 41
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J∣
∂4 Y 21 Z 31−Y 31 Z 21 ∂ 4 X 31 Z 21−X 21 Z 31 ∂4 X 21 Y 31− X 31 Y 21
= = =
∂x ∣J ∣ ∂y ∣J∣ ∂z ∣J ∣
La matriz de rigidez para un elemento tetraédrico cuadrático se define como:
[ ∬e ∇ 1 ∇ 1 d  ∬e ∇ 1 ∇ 10 d 
]
⋯
Rij = ⋮ ⋱ ⋮
∬e ∇ 10 ∇ 1 d  ⋯ ∬e ∇ 10 ∇ 10 d 
Operando:
[ ]
r 1,1 ⋯ r 1,10 t
Rij = ⋮ ⋱ ⋮ 4
r 10,1 ⋯ r 10,10
10
 
8
∂  i ∂ j ∂ i ∂  j ∂ i ∂ j
r ij =  
∂ x ∂x ∂y ∂y ∂z ∂z 9
1 7 3
s
La expresión desarrollada de los 100 elementos que
5
componen esta matriz de rigidez se encuentra en el 6
código fuente: 2
• balrog/fluidos/mallado/MasasRigidez3D.j
r
ava
• masas_rigidez_3d_cuadraticas.cpp.
Anexo: Matrices de divergencia
Las matrices de divergencia se emplean en la resolución de las ecuaciones de Navier-Stokes y

tienen la particularidad de trabajar con funciones base lineales y cuadráticas simultáneamente. El
superíndice l servirá para indicar funciones base lineales, y la q cuadráticas.
Existen tantas matrices de divergencia como la dimensión del problema (dos en 2D y tres en 3D). En
el plano tendremos por una lado la matriz Dx con derivadas parciales en x, y Dy con derivadas
parciales en y.
Se definen como las siguientes matrices 3x6 (no son simétricas):
[ ]
∂ q1 ∂q2 ∂q5 ∂ q6
∬e  ∂ x d 
l
1 ∬e  ∂ x d  ⋯
l
1 ∬e  ∂ x d 
l
3 ∬e  ∂ x d 
l
1
q q q q
∂1 l ∂ 2 l ∂ 5 l ∂6
D x = ∬e l2 d ∬e 2 ∂ x d  ⋯
 ∬e 3 ∂ x d 
 ∬e 2 ∂ x d 

∂x
q q q q
l ∂ 1 l ∂ 2 l ∂ 5 l ∂6
∬e 3 ∂ x d  ∬e 3 ∂ x d  ⋯ ∬e 3 ∂ x d  ∬e 3 ∂ x d 
[ ]
∂q1 ∂ q2 ∂ 5q ∂ q6
∬e l1
∂y
d ∬e 1l ∂y
d ⋯ ∬e l3∂y
d ∬e l1 ∂y
d
q q q q
l ∂ 1 l ∂ 2 l ∂ 5 l ∂ 6
D y = ∬e  2 d ∬e 2 ∂ y d  ⋯ ∬e 3 ∂ y d  ∬e 2 ∂ y d 
∂y
q q q q
l ∂ 1 l ∂ 2 l ∂ 5 l ∂ 6
∬e 3 ∂ y d 
 ∬e 3 ∂ y d  ⋯
 ∬e 3 ∂ y d 
 ∬e 3 ∂ y d 

La expresión desarrollada de los elementos que componen estas matrices de divergencia se

encuentra en el código fuente:
• balrog/fluidos/mallado/Divergencia2D.java y Divergencia3D.java
• divergencia2d.cpp y divergencia3d.cpp
Anexo: formato del archivo de mallado
Una de las entradas fundamentales del solver es el archivo con la descripción de la malla y las
condiciones de contorno. Este archivo contiene texto ASCII y puede generarse a partir del mallador
GiD o mediante cualquier programa escrito por el usuario. El formato de este archivo es sencillo e
intuitivo:
<dimension> <totalNodosCuadraticos>
{ <numeroNodo> <coordenadaX> <coordenadaY> [ <coordenadaZ>] }
{ <numeroElem> <nodo1> <nodo2> ... <nodo6> [ <nodo7> ... <nodo10> ] }
{ <numeroNodo> <IMPONER_VELOCIDAD> <valorX> <valorY> [ <valorZ> ]}

{ <numeroNodo> <SALIDA_DEL_FLUIDO> }
{ <numeroNodo> <MAGNUS> <omega> <omega> [ <omega> ] }
{ <numeroNodo> <DESLIZAMIENTO> <valorX> <valorY> [ <valorZ> ] }
{ <numeroNodo> <PERFIL_PARABOLICO> <valorX> <valorY> [ <valorZ> ] }
{ <numeroNodo> <DRAG_LIFT> }
{ <numeroNodo> <TINTA> }
Los saltos de línea pueden ser estilo Unix o Windows. A continuación incluimos los códigos que
identifican las condiciones de contorno:
IMPONER_VELOCIDAD 0
SALIDA_DEL_FLUIDO 1
MAGNUS 2
DESLIZAMIENTO 3
PERFIL_PARABOLICO 4
DRAG_LIFT 5
TINTA 10
Bibliografía
Algunos de los libros y artículos empleados:
• [ALLI] ALLIEVI, A. y BERMEJO, R.: Finite Element modified method of characteristic for
the Navier-Stokes equations. International journal of numerical methods in fluids. 2000.
• [ALLI2] ALLIEVI, A. y BERMEJO, R: A Generalized Particle Search-Locate Algorithm for
Arbitrary Grids. Journal of Computational Physics. 1997.
• [CUV85] CUVELIER, SEGAL, y VAN ESTEENHOVEN, A. A.: The finite element method
and Navier-Stokes equation. Delft, Enidhoven, 1985.
• [GLOW] DEAN, E. J. y GLOWINSKI, R.: Numerical Simulation of incompresible viscous flow.
• [DIM68] DIMOPOULOS, H. G. y HANRATTY, T. J.: Velocity gradients at the wall for flow
around a cylinder for Reynolds numbers between 60 and 360. Journal of Fluid Mechanics, 1968.
• [FIN99] FINNEMORE, E. J. Y FRANZINI, J. B.: Mecánica de fluidos con aplicaciones en
ingeniería. Mc Graw Hill, 1999.
• [GAR99] GARCÍA ESPINOSA, J.: Un método de Elementos Finitos para Análisis
Hidrodinámico de Estructuras Navales. 1999.
• [JOH99] JOHNSON, T. A. y PATEL, V. C. Flow past a sphere up to a Reynolds number of
300. Journal of Fluid Mechanics, Cambridge, 1999.
• [MAU00] MAURIZI, A.: Numerical simulation of turbulent flows over 2-D valleys using three
versions of the k-ℇ closure model. Journal of Wind Engineering, 2000.
• [PRESS02] PRESSMAN, R. S.: Ingeniería del software, un enfoque práctico. Mc Graw-Hill.
2002.
• [ZDR97] ZDRAVKOVICH, M. M.: Flow around circular cilinders. Vol 1: Fundamentals.
Oxford University Press, 1997.
• VVAA: Documentación becarios Dpto. De Fluidos y Calor. ICAI. 2000.
Capítulo 3. Cálculos realizados

Validación del Solver
En este capítulo se contrastarán los resultados obtenidos mediante ADFC con medidas
experimentales. En este momento es donde el túnel de ensayos virtual debe demostrar que, bajo
ciertas condiciones y premisas, es capaz de sustituir al túnel de ensayos experimental con el
consiguiente ahorro económico y de tiempo, convirtiéndose en una gran ayuda para el investigador.
Aunque el solver puede hacer frente a cualquier tipo de geometría por compleja que sea gracias al
uso de mallas desestructuradas, nos hemos centrado en cilindros circulares y esferas por ser las
geometrías más estudiadas en los ensayos experimentales. Una vez el solver haya sido validado y
demuestre la exactitud de sus resultados en estos casos sencillos, podrá ser usado en problemas más
complejos.
Para la validación de los resultados obtenidos en 2D en torno a cilindros, nos hemos centrado en el
libro [ZDR97] y en el artículo [DIM68], mientras que para validar la esfera 3D se empleó empleado
[JOH99]. Las directrices para validar el modelo de turbulencia se obtuvieron de [MAU00], en
concreto de los resultados experimentales en el valle V3. Para finalizar, los datos de la montaña
Askervein se obtuvieron de la validación del programa ADMS 3.

Problema 2D-1: cilindro circular diámetro unidad a Reynolds 100
Este primer ensayo se simula un cilindro circular de diámetro unidad en el que incide un fluido con
número de Reynolds = 100, habiendo definido este número adimensional como :
⋅D⋅U ∞
R e=

Esta geometría es muy sencilla y existen multitud de ensayos experimentales contra los que validar
los resultados que obtengamos [ZDR97] [DIM68]. Esto es equivalente al problema donde un
cilindro se desplaza con velocidad adimensional unidad inmerso en un fluido. A continuación se
muestra un croquis de la geometría a estudiar:
36
Dirichlet u=1,0
13,1 uds.
NBC ij n j=0
27
D=1
El dominio es un rectángulo de 36 unidades de largo por 27 de ancho, estando el centro del cilindro
separado 13,1 unidades de la entrada del fluido. En lo que a condiciones de contorno se refiere, el
cilindro tiene condiciones Dirichlet con velocidad nula, la entrada y las paredes superior e inferior
Dirichlet con valor (1, 0) y la salida se encuentra a la derecha con condición NBC.
A las paredes inferior y superior se les asigna velocidad U∞=(1, 0) porque al estar a 13 unidades de
distancia de la superficie del cilindro, están lo suficientemente lejos como para no a apreciar ninguna
perturbación en el flujo debido al cilindro.
La superficie del cilindro tiene condiciones Dirichlet nulas porque el número de Reynolds es
suficientemente bajo y la capa límite es suficientemente amplia. Ello obliga a un mallado cuidadoso
de la superficie.
Mallado utilizado
Para correr este caso se empleó un mallado 2D de 86.059 nodos y 42.865 elementos. El tamaño de
elemento típico en la superficie del cilindro es de 0,03 unidades, y la región que ocupa la estela está
mallado con un tamaño de 0,1. El salto de tiempo t empleado es 0,1. A continuación se incluye una
imagen global y un detalle del cilindro.
Mallado empleado con 86.059 nodos y 42.865 elementos. El lugar en el que evoluciona la calle de torbellinos de Von Karman
se malló con especial cuidado.
La región más cercana al del cilindro se malló con un tamaño de elemento de 0,03.
Cálculo del Drag, Lift y Strouhal a Reynolds 100
Los valores de los coeficientes de resistencia y sustentación en régimen permanente son:
Valor medio Amplitud

Drag 1,4 ±0,01
Lift 0 ±0,235
Su evolución con el tiempo se puede observar a continuación:
Cilindro 2D (D=1, Re=100)

2
1,8
1,6
1,4
1,2
CD y CL
0,8 Drag
Lift
0,6
0,4
0,2
-0,2
-0,4
0 25 50 75 100 125 150 175 200
tiempo
A la vista de la gráfica se puede calcular también el número de Strouhal ya que el movimiento del
fluido es periódico y por lo tanto es fácil determinar su frecuencia de oscilación. Entre los 75 y los
150 segundos tienen lugar 12,5 oscilaciones:
St=
v D
=
 
12,5
75
⋅1
=0,1667
V infiniteo 1
Otro método alternativo para calcular el Strouhal es aplicar la transformada de Fourier a las curvas
de Drag y Lift en régimen permanente.

Curvas de presión y gradiente de velocidad a Reynolds 100
La siguientes tablas muestran el valor de la presión y gradiente de velocidad en la periferia del
cilindro. El eje de abcisas recorre desde 0º hasta 180º en sentido horario. La línea muestra los
resultados de la simulación y los triángulos valores experimentales extraídos de la bibliografía
[ZDR97]. Como la curva de presión y la de gradiente de velocidad varían con el tiempo, lo que aquí
se recoge son valores medios en régimen permanente. La adimensionalización de estos valores es
como sigue:
Presión adimensional Gradiente de velocidad adimensional
preal v real
C p= C gv =
P 2Re
Curva de presión, cilindro diámetro 1, Reynolds 100

1,5
0,5
ADFC
Experimental
Cp
- 0,5
-1
- 1,5
0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190
posic ión a lo largo del períme tro [ºgrados]

Gradiente de velocidad, cilindro diámetro 1 Reynolds 100

1,3
1,2
1,1
0,9
0,8
0,7 ADFC
Experimental
Cgv
0,6
0,5
0,4
0,3
0,2
0,1
- 0,1
- 0,2
0 10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190
posición a lo largo del perímetro [ºgrados]

Presión y campo de velocidades a Reynolds 100
A continuación se incluyen imágenes del postproceso donde se aprecia la distribución de presiones
en el seno del fluido y el campo de velocidades (componentes X e Y).
Valor de la presión.
Componente X del campo de velocidades.

Componente Y del campo de velocidades.

Problema 2D-2: emisión de torbellinos en el cilindro circular diámetro unidad
a diversos números de Reynolds
Para el caso del cilindro circular de diámetro unidad, los torbellinos adoptan diferentes
configuraciones en función del número de Reynolds del fluido:
• Re<1: el flujo entorno al cilindro es totalmente viscoso, de forma que no hay separación
de la capa límite ni formación de torbellinos.
• 2<Re<30: la capa límite se separa simétricamente a ambos lados del cilindro, formando
dos grandes torbellinos simétricos y estacionarios.
• 30<Re<60: los torbellinos aumentan de longitud para disipar su energía rotacional.
• 60<Re: este es el valor límite a partir del cual se desprenden los torbellinos al alcanzar una
longitud excesiva para seguir manteniendo contacto con el cilindro. Son arrastrados aguas
abajo por la corriente formando la calle de torbellinos de Von Kármán, que consiste en
una fila doble de torbellinos intercalados en la estela del cilindro.
Para realizar la simulación se escogió una geometría idéntica a la del estudio del cilindro circular para
Reynolds 100, pero con un mallado mucho más refinado en la estela. A continuación se muestra un
croquis de la geometría empleada:

36
13,1 uds.
NBC ij n j=0
27
D=1
de la superficie.
Mallado utilizado
Para correr este caso se empleó un mallado 2D de 86.059 nodos y 42.865 elementos. El tamaño de
elemento típico en la superficie del cilindro es de 0,03 unidades, y la región que ocupa la estela está
mallado con un tamaño de 0,1. El salto de tiempo t empleado es 0,1. A continuación se incluye una
imagen global y un detalle del cilindro.
Mallado empleado con 86.059 nodos y 42.865 elementos. El lugar en el que evoluciona la calle de torbellinos de Von Karman
se malló con especial cuidado.
La región más cercana al del cilindro se malló con un tamaño de elemento de 0,03.
Transporte de tinta
Para obtener imágenes que revelen la forma y disposición de los torbellinos se emplea la opción del
solver para realizar transporte de tinta. El solver permite dos tipos de transporte de tinta: uno que
consiste en introducir frentes de contaminante a lo largo de una línea recta perpendicular a la
dirección del flujo para ver como evoluciona, y otro que “mancha” de tinta una zona determinada del
mallado, dejando un rastro a medida que avanza el fluido.
Tanto en una modalidad como en la otra, en cada salto de tiempo de la resolución de las ecuaciones
de Navier-Stokes se resuelve un problema adicional de transporte puro para la concentración de este
contaminante. Siendo c dicha concentración, se verifica que:

=0
dt Se mancha una región permanentemente. Así se
c∣  =c0
1
∀t obtienen imágenes de las calles de torbellinos.

=0
dt Se introducen frentes periódicos cada
c∣  =c0 si t = t , 2  t , 3  t ,
2
intervalo especificado de tiempo.
2={∀ x , y/ x min xx max }
Calle de torbellinos a Reynolds 1, 30, 50, 60, 100
Las imágenes obtenidas mediante transporte de tinta muestran las calles de torbellinos de Von
Kármán con gran precisión y son idénticas a las de la bibliografía [ZDR97].

Reynolds 1. Flujo totalmente viscoso.

Reynolds 30. La capa límite se desprende formando dos torbellinos estacionarios.

Reynolds 50. Los torbellinos ganan longitud.

Reynolds 60. Comienzan a aparecer oscilaciones.

Reynolds 100. Calle de torbellinos de Von Kármán.

Problema 2D-3: evolución del coeficiente Drag en función del Reynolds para
el cilindro diámetro unidad
Para el caso del cilindro circular de diámetro unidad, el coeficiente de Drag experimenta variación en
función del número de Reynolds.
Para realizar la simulación se escogió una geometría idéntica a la del estudio del cilindro circular para
Reynolds 100. A continuación se muestra un croquis de la geometría empleada:
36
13,1 uds.
NBC ij n j=0
27
D=1
de la superficie.
Mallados utilizados
Para correr este caso se emplearon diferentes mallados para de esta forma poner de relieve la
dependencia que las soluciones, a alto número de Reynolds, tienen con el mallado.
Mallado “número 2” empleado con 12.345 nodos y 6.057 elementos. Tamaño de malla en la superficie del cilindro 0,03 y paso
de tiempo 0,01.
de tiempo 0,03.
de tiempo 0,05.
de tiempo 0,07.
de tiempo 0,15.
Curvas obtenidas
Para calcular las curvas que se muestran a continuación, se han realizado varias simulaciones para
cada mallado, variando el número de Reynolds en cada una. Se puede observar como para número
de Reynolds alto el haz de curvas se abre y las soluciones muestran una alta dependencia del
mallado.
De todas formas, el mallado y el salto temporal deben guardar las siguientes relaciones para obtener
unos resultados óptimos:
Tamaño de elemento Salto de tiempo

1 h
 h≤ 3/4 t≤
Re 10
Claramente se ve que para alto Reynolds las exigencias se vuelven tan elevadas que es imposible
satisfacerlas computacionalmente. Al mantener en las curvas el mallado y el salto de tiempo
constante, es normal que a medida que se eleva el número de Reynolds, las soluciones empeoren.
Coeficiente de Drag
3
CD experiment al
2,75 CD (2)
CD (3)
2,5
CD (4)
CD(8)
2,25
CD(9)
2
1,75
Cd
1,5
1,25
0,75
0,5
0,25
0
1 10 100 1000 10000 100000
Reynolds
Problema 2D-4: Validación túnel de viento RUSVAL
El experimento US EPA RUSVAL de túnel de viento para flujo turbulento sobre modelos 2D con
forma de valle, se ideó para comparar tres versiones distintas de modelos de turbulencia k-ℇ. Se
proponen dos geometrías diferentes, denominadas V3 y V4. Una descripción detallada se recoge en
[MAU00].
La geometría con más interés y la que se emplea para validar resultados del programa es la V3, cuyo
esquema se muestra a continuación:
Fluido
-2a -a -a/2 0 +a/2 +a
H 2 a
Donde el suelo cumple: z= x y =3
a2 H
Los parámetros reales empleados en el experimento fueron:
Parámetro Real Valor

H 0,117 m
a 0,351 m
U∞ 4,0 m/seg
Aire en condiciones estándar
En el ensayo se obtuvieron medidas experimentales de velocidad media horizontal, ángulo del flujo y
energía cinética turbulenta en las verticales de los puntos con coordenadas
x x
=−0.5 , 0.0, 0.5 y 1.0 siendo =0.0 el punto más bajo del valle.
a a
Mallado utilizado
Para la simulación de este caso se empleó un mallado con 17.700 nodos y 8.675 elementos, mallando
el obstáculo con una tamaño de elemento de 0,1. A continuación se muestra una imagen global del
mallado y el valle en detalle.
El mallado utilizado cuenta con 17.700 nodos y 8.675 elementos.

Detalle del valle, mallado en su superficie con un tamaño de elemento de 0,1 unidades.
Componente X de la velocidad en la vertical del centro del valle
Se tomó como longitud característica la profundidad H del valle y como velocidad característica la
U'. De esta forma, los parámetros a emplear en la simulación son:
Parámetro Adimensional Valor

Hadim 1
aadim 3
u∞ 1
Reynolds 44000
Modelo Turbulencia Smagorinsky
t 0,3
 slip 0,0005
A la entrada del túnel de viento colocaremos un perfil parabólico estándar con la forma:
[ ]
0.15 siendo z la altura desde el suelo
u=
z
7
si z≤7 expresada en unidades
u=1.0 si z7 adimensionales.
x
La siguiente gráfica compara el perfil de velocidad horizontal obtenido en =0.0 con el
a
experimental:
Ux en geometría V3, x/a=0.0

1,2
0,8
0,6
0,4
S imulación
0,2 Experiment al
- 0,2
- 0,4
0,5 2 3,5 5 6,5 8 9,5 11 12,5 14 15,5 17 18,5 20 21,5 23 24,5 26 27,5 29 30,5 32
Presión y campo de velocidades
A continuación se presentan imágenes del postproceso donde se aprecia el campo de velocidades y la
presión en el seno del fluido.
Presión del fluido en un instante de tiempo.
Componente X del campo de velocidades en un instante de tiempo.

Componente Y del campo de velocidades en un instante de tiempo.

Problema 2D-5: Montaña Askervein
Askervein es una montaña de 116 metros de altitud situada en la costa oeste de la isla de South Uist
en los Outer Hebrides de Escocia. Durante septiembre y octubre de 1983 se realizaron medidas de la
velocidad del viento en diversos puntos de la montaña.
En lo que a topografía se refiere, la montaña Askervein se encuentra relativamente aislada y su
cúspide está situada a 126 metros sobre el nivel del mar. La rugosidad de su superficie es baja,
debida fundamentalmente a hierba, suelo ligeramente pedregoso y algún pequeño lago.
Las medidas de la velocidad del viento se realizaron a lo largo de una línea recta orientada en
dirección 210º (considerando el Norte como 0º y midiendo en sentido horario):
Parámetro Valor
Velocidad del viento 5 m/s
Altura de las mediciones 10 m sobre la superficie
Dirección 210º
Altura capa límite 800 m
Aire en condiciones estándar
Los resultados obtenidos se expresaron en función del fractional speed-up ratio que se expresa de la
siguiente forma:
Donde:
V Z '   S es el fractional speed-up ratio

 S= −1
V RS Z ' V  Z '  es la velocidad medida en un punto
V RS Z '  es la velocidad tomada como referencia
La adimensionalización del problema se realizó en función de la altura de la montaña y de la
velocidad del viento, resultando la siguiente tabla de parámetros adimensionales:
Parámetro Adimensional Valor

Altura de la montaña 1
u∞ 1
Reynolds 62500000
Modelo Turbulencia Smagorinsky
t 0,05
 slip 0,0005
A la entrada del dominio se colocó un perfil parabólico estándar con la forma:
[ ]
siendo z la altura desde el suelo
u=0.0 si z0
0.57

z expresada en unidades
u= si z≤6,45
6,45 adimensionales.
u=1.0 si z6,45
Mallado utilizado
Para la simulación de este caso se empleó un mallado con 17.543 nodos y 8.506 elementos, mallando
la superficie de la montaña con una tamaño de elemento de 0,1. A continuación se muestra una
imagen global del mallado y de la montaña en detalle.
Mallado global del corte orográfico. En total hay 17.543 nodos y 8.506 elementos.
Detalle de la montaña, mallada con un tamaño de elemento de 0.1.

Comparación del Fractional Speed-Up Ratio
A continuación se incluye una gráfica comparativa entre los resultados obtenidos mediante
simulación y mediante medidas experimentales:
Fractional Speed-Up Ratio

2
1,8
Experimental
1,6
Simulado
1,4
1,2
ratio
0,8
0,6
0,4
0,2
0
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34
Distancia (adimensional)
Campo de velocidades
A continuación se presentan imágenes del postproceso donde se aprecia el campo de velocidades del
viento en torno al obstáculo.
Componente X del campo de velocidades en un instante de tiempo.
Componente Y del campo de velocidades en un instante de tiempo.

Problema 3D-1: Esfera 3D diámetro unidad a Reynolds 100
En este caso se simulará una esfera de diámetro unidad en la que incide un fluido con número de
Reynolds = 100. Esta geometría es muy sencilla y existen multitud de ensayos experimentales
[JOH99] contra los que validar los resultados que obtengamos.
A continuación se muestra un croquis de la geometría a estudiar:
9,6 ud
2,4 ud
ud
72
6,
NBC  ij n j =0
Dirichlet u=1,0


6,72 ud
El dominio es un paralelepípedo de 9,6 unidades de largo por 6,72 de ancho, estando el centro de la
esfera separado 2,4 unidades de la entrada del fluido. En lo que a condiciones de contorno se refiere,
la esfera tiene condiciones Dirichlet con velocidad nula, la entrada y las paredes superior, inferior y
laterales Dirichlet con valor (1, 0) y la salida se encuentra a la derecha con condición NBC.
Tanto las paredes como la entrada tienen condición de velocidad (1,0) porque se supone que se
encuentran lo suficientemente lejos como para que el fluido en ellas no advierta la perturbación que
produce la esfera.
A la esfera se le asigna condición de contorno Dirichlet nula debido a que el Reynolds es

de su superficie.
Mallado utilizado
Se utilizó un mallado 3D con 207.677 nodos y 151.298 elementos tetraédricos, mientras que el t
empleado fue de 0,08 unidades temporales. A continuación se adjunta un corte tridimensional del
mallado mediante el plano XY.
Mallado empleado para simular la esfera 3D.

Flujo estacionario axisimétrico
La principal característica de este ensayo es la aparición de una estela tras la esfera perfectamente
simétrica. A continuación se muestran imágenes de la componente X de velocidad y de transporte de
tinta en los planos XY y XZ que pasan por el centro de la esfera.
Componente X de la velocidad, en el plano XY que pasa por el centro de la esfera.

Instante t=28 seg.
Componente X de la velocidad, en el plano XZ que pasa por el centro de la esfera.

Instante t=28 seg.
Transporte de Tinta, en el plano XY que pasa por el centro de la esfera.

Instante t=28 seg.
Transporte de Tinta, en el plano XZ que pasa por el centro de la esfera.

Instante t=28 seg.
Presión, en el plano XZ que pasa por el centro de la esfera.

Instante t=28 seg.
Coeficientes de Drag y Lift
Los coeficientes de Drag y Lift de este ensayo son los siguientes:
C L=0,05±0,02
C D=0,55
Fluido
C S =−0,02±0,02
Número de Strouhal
Drag y Lift Esfera 3D (D=1, Re=100)

1,1
0,9
0,8
0,7
Cs, Cl, Cs
0,6 CD
CS
0,5
CT
0,4
0,3
0,2
0,1
- 0,1
23 23,5 24 24,5 25 25,5 26 26,5 27
tiempo
fluido es periódico y por lo tanto se puede obtener su frecuencia de oscilación. En 3,44 segundos
tienen lugar 21,5 oscilaciones:
St=
v D
=
21,5
3,44  
⋅1
=6,25
V infiniteo 1
En este caso se simulará una esfera de diámetro unidad en la que incide un fluido con número de
A continuación se muestra un croquis de la geometría a estudiar:

9,6 ud
2,4 ud
ud
72
6,
NBC  ij n j =0


6,72 ud
produce la esfera.
de su superficie.
Mallado utilizado
Flujo estacionario no axisimétrico
La principal característica de este ensayo es la aparición de una estela tras la esfera que no es
axisimétrica, a diferencia de la obtenida a Reynolds 100. Este fenómeno se obtiene en un rango de
números de Reynolds que va desde 200 a 270 aproximadamente. A continuación se muestran
imágenes de la componente X de velocidad y de transporte de tinta en los planos XY y XZ que
pasan por el centro de la esfera.


En este plano el flujo es simétrico.

En este plano la estela muestra una clara asimetría (desplazada hacia abajo).

En este plano el flujo es simétrico.

En este plano el flujo no es simétrico (desplazado hacia abajo)
C L=0,055
C D=0,643
Fluido
C S =0,008
En este caso se simula una esfera de diámetro unidad en la que incide un fluido con número de
A continuación mostramos un croquis de la geometría a estudiar:

9,6 ud
2,4 ud
ud
72
6,
NBC  ij n j =0


6,72 ud
produce la esfera.
de su superficie.
Mallado utilizado

Estela oscilante
A Reynolds 400, tras la esfera se forma una estela oscilante. A continuación se muestran imágenes
de la componente X de velocidad y de transporte de tinta en los planos XY y XZ que pasan por el
centro de la esfera en el instante t=77,7 segundos de la simulación.

Instante t=77,7 seg.




Presión, en el plano XY que pasa por el centro de la esfera.

C L=0,04±0,02
C D=0,56
Fluido
C S =−0,03±0,02
Número de Strouhal
fluido es periódico y por lo tanto se puede obtener su frecuencia de oscilación. En 30,62 segundos
tienen lugar 3,5 oscilaciones:
St=
v D =
3,5
30,62⋅1
=0,114
V infiniteo 1
Capítulo 4. Tutoriales
ADFC Navier-Stokes Solver Manual

(versión 3.0)
ficha ténica: http://www.sourceforge.net/projects/adfc

página web: http://adfc.sourceforge.net
email: alrog@users.sourceforge.net
Introducción
Este breve tutorial le iniciará en el uso conjunto del GiD y ADFC. El documento no pretende ser
una documentación exhaustiva acerca del mallador: le recomendamos que visite la página web de
CIMNE8, donde existe abundante información.
Tanto el desarrollo del programa como de la propia documentación se llevan a cabo de forma
continua: visite la página web con frecuencia para conseguir las versiones más actualizadas del
código y de este documento.
Para cualquier duda o sugerencia, no dude en enviar un email a:

Lista de correo ADFC adfc-devel@lists.sourceforge.net
Instalación del GiD

Para instalar el GiD, debe obtenerse el archivo de instalación desde la web del CIMNE. El GiD es un
programa comercial y se debe adquirir una licencia para su uso. Sin embargo, se puede obtener de la
página web una licencia completa por 30 días con fines de evaluación. El desarrollo del solver ADFC
no está vinculado en absoluto con el CIMNE, y de hecho nos gustaría hacer nuestro programa
compatible con el mayor número de malladores y postprocesadores posibles. Consulte con nosotros
la posibilidad de adaptarlo a alguno de su interés.
1. El GiD es un programa comercial: se puede instalar 2. Tras aceptar la licencia del software, escogeremos la
una versión con fines de evaluación y posteriormente ubicación del programa. ¡Recuerde el directorio! Le
actualizarla a la versión completa. será necesario para instalar ADFC.
3. La instalación debe ser la completa. 4. A continuación procederá a copiar archivos.

5. La primera vez que lo ejecutemos, nos pedirá que 6. El GiD ya está listo para ser usado. En pantalla
introduzcamos el número de serie que nos facilitarán en tenemos el rotor y el estator de un motor.
la web del CIMNE.
Instalación de ADFC v3.0

Para instalar el ADFC necesitará bajarse el archivo zip desde Sourceforge9. El archivo zip contiene
un directorio adfc.gid que debe copiar en el subdirectorio ProblemTypes del GiD.
Este directorio contiene una serie de archivos auxiliares necesarios para interconectar el mallador
GiD con nuestro solver. Una vez haya descomprimido el archivo, el GiD lo reconocerá y aparecerá
en el menú “Data/Problem Type/adfc”.
Por su parte, el ejecutable se encuentra en el directorio bin. Escoja el que se corresponda con su
sistema operativo: adfc3.exe es el ejecutable para plataformas Windows y adfc3 el ejecutable Linux.
Compilar ADFC v3.x

Si desea usar el programa en otra plataforma diferente a las soportadas deberá compilarlo. También
le recomendamos compilarlo de nuevo si tiene problemas con cualquiera de los ejecutables que se
distribuyen.
Para compilar el programa en Unix o Linux, vaya al directorio src y escriba en la linea de comandos
make. Si todo va bien, se creará el ejecutable. Si hubiera problemas, quizás sea necesario retocar
manualmente el archivo makefile. Ante cualquier problema que pueda surgirle a la hora de portar el
programa no dude en ponerse en contacto con nosotros: nos interesa en gran medida hacer ADFC lo
más robusto y portable posible.
9 La ficha técnica se encuentra en http://www.sourceforge.net/projects/adfc

Resolución de un caso sencillo: un cilindro a Reynolds 100

Una vez el solver y el mallador estén correctamente instalados en su sistema, puede comenzar a
resolver casos. A continuación describiremos paso a paso el preproceso, resolución y postproceso
de un caso sencillo: el conocido cilindro de diámentro unidad a Reynolds 100.
Comenzaremos a definir el problema seleccionando

Antes de nada, asegurarnos que el problem type está
nuestro problem type en el menú "Data/Problem
correctamente copiado en el directorio del GiD.
Type/adfc"
En primer lugar indicaremos al GiD que queremos mallar para resolver con el ADFC, seleccionando
en el menú “Data/Problem Type/adfc”. A continuación definiremos el mallado introduciendo por
teclado o ratón las rectas y puntos que definen el contorno de la geometría a estudiar.
El cilindro, como ya hemos comentado, será de diámetro unidad y centrado en el origen. La región
de estudio será un rectángulo de 20 unidades de largo por 9 de alto, conteniendo al cilindro. Por lo
tanto, los puntos a considerar serán:
Coordenada X Coordenada Y
-0.5 0
0 0.5
0.5 0
0 -0.5
-4.5 4.5
15.5 4.5
15.5 -4.5
-4.5 -4.5
La creación de puntos se lleva a cabo en el menú, mediante la opción "Geometry/Create/Point".

Los puntos se pueden introducir por teclado, introduciendo las coordenadas X e Y separadas por un
espacio y pulsando la tecla retorno tras cada punto, o haciendo click con el ratón en pantalla (muy
poco preciso).
Para unir el contorno rectilíneo con lineas rectas, vamos a "Geometry/Create/Line" e iremos
haciendo click en los sucesivos puntos. Al finalizar, pulsaremos la tecla escape.
A medida que introduzcamos las coordenadas de los Con el comando "Geometry/Create/Line" podemos
puntos, estos aparecerán en pantalla. definir las líneas que limitarán las regiones.
La creación del cilindro es algo más delicada. Aunque se puede crear de forma sencilla como una
forma predefinida, la definiremos paso a paso para que de esta manera aprenda cómo hacer frente a
otras formas más complejas. Iremos a la opción "Geometry/Create/Arc", función que permite
definir un arco a partir de 3 puntos. El cilindro lo trazaremos como dos semicírculos, el O-N-E y el
E-S-O (haciendo una analogía con los puntos cardinales). El GiD en todo momento muestra un
breve texto de ayuda en el parte inferior de la pantalla.
Una vez tengamos el contorno perfectamente definido, pasaremos a indicarle al GiD cómo es la
región de estudio. Como ésta tiene un hueco, la definiremos en dos etapas: primero el rectángulo y
posteriormente le sustraeremos el cilindro.
El rectángulo lo definimos mediante "Geometry/Create/NURBS Surface/By Contour"

seleccionando las cuatro líneas que definen la región y pulsando la tecla escape. La región aparecerá
en rosa. Aunque aparece dibujada algo más pequeña y deplazada para poderla distinguir de las líneas
que la componen, está correctamente definida.
Para añadir el hueco, iremos a "Geometry/Edit/Hole NURBS Surface" y seleccionaremos la

superficie (el rectángulo rosa, no el perímetro azul) y los dos arcos que limitan el hueco. Al pulsar
escape, podremos ver el resultado.
Ya hemos definido todas las líneas de la geometría. Primero hacemos una región rectangular.
Tras sustraer el cilindro, la geometría está

completamente definida.
LLegados a este punto, tenemos la geometría perfectamente definida. Ha terminado, por tanto, el
preproceso. Ahora pasaremos a generar el mallado.
Uno de los primeros pasos será definir el tipo de elemento. Para ello seleccionaremos en el menú
"Meshing/Quadratic Elements/Quadratic" y "Meshing/Element Type/Triangular". Así,
seleccionaremos elementos triangulares 2D Taylor-Hood.
Antes de generar la malla vamos a establecer las condiciones de contorno: indicaremos en el GiD
por dónde tiene que entrar el fluido, con qué perfil de velocidades, cuáles son paredes rígidas y por
dónde saldrá con tensión nula. La idea en este problema es que el fluido entre por la izquierda, con
un perfil de velocidades unitario, y salga por la derecha. Tanto el cilindro como las paredes superior
e inferior serán paredes rígidas, donde estableceremos la condición de rodadura o de velocidad cero.
Abriremos el diálogo Conditions desde el menú "Data/Conditions". En la parte superior del

diálogo hay tres iconos, representando condiciones de contorno sobre nodos, líneas y superficies.
Seleccionaremos líneas.
Tipo ValorX Descripción

Set_speed 1.0 Entrada de fluido, perfil uniforme (1.0, 0.0)
Set_speed 0.0 Pared superior
Set_speed 0.0 Pared inferior
Set_speed 0.0 Cilindro
Downstream NBC 0.0 Salida del fluido por la derecha.
El tipo Set_speed impone una condición Dirichlet sobre el campo de velocidades. La velocidad del
fluido en dichos puntos será (Valor, 0.0). El tipo Downstream_NBC se impone en aquellos nodos
en los que el fluido sale sin tensión.
Para asignar una condición a una línea, emplearemos el botón "Assign". Tras pulsarlo,
seleccionaremos todas las líneas que deseemos agregar a esa condición. Al finalizar se pulsará
escape.
Podemos comprobar que las condiciones están correctamente asignadas usando la función
"Draw/Draw Conditions Field/Type" .
En el menú "Data/Conditions" abriremos el diálogo

Podemos ver si las condiciones son correctas usando el
desde el que estableceremos las condiciones de contorno
botón "Draw/Colors" del diálogo.
del problema.
Solo falta crear la malla. Seleccionando en el menú "Meshing/Generate" generaremos una nueva.
El programa nos pedirá confirmación para descartar el mallado anterior (diremos que sí) y nos pedirá
el tamaño de elemento. Dejaremos el que esté por defecto. La malla resultante se ve claramente que
es muy basta y necesita un refinado importante.
Vamos a indicarle al GiD que malle más fino entorno al cilindro. Para ello seleccionaremos
"Meshing/Asign unstruct. sizes/Lines" e introduciremos un tamaño de 0.05. Cuando nos pregunte
a qué líneas asignar dicho tamaño, escogeremos los dos arcos que forman el cilindro y pulsaremos
escape. Si mallamos de nuevo con "Meshing/Generate" y el mismo tamaño de elemento por
defecto, veremos que la malla es mucho más fina en la zona que nos interesa. Con el zoom (icono de
la lupa) podemos observar más de cerca la malla.
A continuación haremos que la transición del tamaño de elemento sea más suave. En
"Utilities/Preferences" abriremos un diálogo e iremos a la pestaña "Meshing". En ella hay una
barra de desplazamiento horizontal, con el título de "Unstructured size transitions". Este valor
indica lo rápido que el GiD varía el tamaño de los elementos. Escogeremos una transición más suave,
por ejemplo 0.4. Mallando de nuevo obtendremos el resultado óptimo que buscábamos. Para obtener
una malla mejor, conviene introducir un tamaño medio de elemento menor, por ejemplo 0.5 (En el
diálogo que aparece nada más pulsar sobre "Meshing/Generate").
Mallando con los parámetros por defecto obtenemos un Asignando al cilindro un tamaño de elemento menor,
resultado muy basto. Intentaremos refinarlo. conseguimos refinar la malla alrededor de él.
El mallado final. 7502 nodos y 3662 elementos. Si no

A continuación indicaremos al GiD que haga las
consigue estas cifras no se preocupe. Será adecuado si
transiciones con mayor suavidad.
tiene un aspecto parecido.
¡Hemos acabado el preproceso y el mallado! Antes de lanzar el solver iremos a menú

“Data/Problem Data” y recorreremos las pestañas configurando los últimos parámetros de la
resolución. Los valores por defecto son adecuados, compruebe sobre todo los siguientes:
Pestaña Parámetro Valor

NavierStokes Reynolds_number 100
NavierStokes Time_steps 2000
NavierStokes Steps_between_saving 10
NavierStokes Time_step_length 0
A continuación guardaremos nuestro trabajo mediante "Files/Save" (formato GiD). El nombre del
archivo puede ser cualquiera con no más de 8 caracteres (limitación que solo afecta a plataformas
Windows), en este caso introducimos "tutorial" y se creará una carpeta “tutorial.gid” que contendrá
todos los archivos. Para que ADFC pueda leer los datos, necesitamos grabar un Calculation File.
Para ello seleccionaremos en el menú “Files/Import Export/Write Calculation File” y crearemos
un fichero con nombre “tutorial” dentro de la carpeta del problema, “tutorial.gid”.
Configuramos parámetros del solver. Grabamos el Calculation File.
A continuación lanzaremos el solver: las versiones 3.00 y siguientes sólo soportan modo consola, así
que deberá invocarlas a través de la línea de comandos. La forma de invocar es la siguiente:
<adfc3.exe | adfc3> -gid <ruta_al_calculation_file>
Por ejemplo, en Windows :

c:\gid61\adfc.gid\adfc3.exe -gid c:\mallados\tutorial.gid\tutorial
O de forma similar en Linux:

/home/user/adfc3.exe -gid /home/user/tutorial.gid/tutorial
La simulación tardará sobre un cuarto de hora en completarse, dependiendo del equipo. Interrúmpala
cuando quiera, si desea ver los resultados cuanto antes.
Para iniciar el postproceso lanzar el postprocesador con "Files/Postprocess" o seleccionándolo

directamente en la ventana que aparecerá al terminar los cálculos. Aparecerá un diálogo en pantalla
indicando el progreso de la carga de datos desde disco.
Seleccionando "Windows/View Results" podremos escoger el step o instante, el view o modo de

visión (escogeremos Contour Fill), el resultado (seleccionaremos SPEED) y la componente
(escogeremos, por ejemplo, SPEED_X).
En View Results, podremos escoger paso de tiempo, Aspecto de la componente X de la velocidad, en el

método de representación, resultado, componente... instante 48.5 segundos.
Las posibilidades del GiD como pre/postprocesador son enormes, este ejemplo solo es pequeña
muestra de su funcionalidad. Le recomendamos que lea la documentación del GiD en su página web.
Simulación de un corte orográfico 2D
artículo en construcción
Una de las principales aplicaciones del programa ADFC es la simulación del comportamiento del
viento sobre diferentes relieves con el fin de situar el emplazamiento óptimo para parques eólicos.
Un ejemplo detallado y con valores experimentales es el Problema 2D-5: Montaña Askervein
recogido en el capítulo Cálculos del Proyecto Final de Carrera.
A lo largo de este tutorial vamos a enumerar detalladamente todos los pasos necesarios para simular
un corte orográfico mediante ADFC.
Adimensionalización y parámetros del problema

Antes de definir la geometría en el mallador GiD, debemos escoger el valor de la longitud
característica D del problema, que típicamente se hace igual a la altura del obstáculo principal. Este
valor nos permitirá adimensionalizar todas las distancias, expresándolas mediante la siguiente
expresión:
L real Expresión para adimensionalizar

l adim = distancias.
D
En lo que a la velocidad del viento se refiere, también debemos definir una velocidad característica
V y de igual forma, expresar todas las demás velocidades en función de ella:
U real Expresión para adimensionalizar

u adim = velocidades.
V
Generalmente esta velocidad característica se hace igual a la velocidad máxima del viento en la
geometría a estudio, la cual se suele alcanzar en las capas más altas de la atmósfera.
velocidad característica
dirección del viento

perfil de entrada
salida del fluido

característica
longitud
suelo
Esquema de la geometría de un corte orográfico 2D. Hay que destacar la longitud característica y la velocidad
característica, necesarias para adimensionalizar.
Todos los valores que recibe ADFC (mallado, condiciones de contorno...) deben estar expresados en
magnitudes adimensionales y, de la misma forma, todos los valores que devuelve también lo estarán.
A modo de ejemplo, si queremos simular un corte de 5 Km de longitud, con un obstáculo de 100 m
de altura máxima y una velocidad máxima del viento de 10 m/s, escogeremos como longitud
característica 100 m y velocidad característica 10 m/s, de forma que en el mallado
adimensionalizado la altura pasa a ser 1, la longitud 50 y la velocidad máxima del viento 1.
Para definir el régimen del fluido debemos calcular el número de Reynolds. Este parámetro
adimensional tiene la siguiente expresión:
 DV Expresión del número de Reynolds.

R e=

Aquí es donde entran en juego las propiedades del fluido:  es la densidad y  es la viscosidad
cinemática del aire, ambos parámetros calculados a la presión y temperatura de estudio. D y V son
respectivamente la longitud característica y la velocidad característica.
Condiciones de contorno
Existen cuatro zonas diferenciadas en el contorno, cada una con sus propias características:
IMPONER_VELOCIDAD
V=1.0
SALIDA_DEL_FLUIDO
PERFIL_ENTRADA
L=1.0
DESLIZAMIENTO DESLIZAMIENTO
Boceto que indica la localización de cada condición de contorno en el mallado. Se indica también la altura del
obstáculo y la velocidad máxima de viento ya adimensionalizadas.
• Entrada: la entrada del fluido típicamente posee un perfil parabólico o logarítmico

consecuencia de la capa límite terrestre. Su configuración se realiza desde el menú
“Data/Problem Data” del GiD y se imponen mediante la condición SET_SPEED.
• Suelo: el hecho de trabajar con geometrías de grandes dimensiones y números de Reynolds
muy altos provoca que la capa límite sea tan reducida que no es posible recogerla en el
mallado. Imponer velocidad nula en el suelo en estas circunstancias sería un error ya que
falsearía en gran medida el resultado. Por ello, hay que imponer la condición SLIP, de la
que se pueden especificar el slip y el factor de fricción.
• Techo: la parte superior del mallado, por estar lo suficientemente alejada del suelo,
suponemos que tiene velocidad horizontal constante e igual a 1,0 adimensional (la velocidad
máxima en reales). Para ello se usa la condición SET_SPEED.
• Salida: para la salida se usa la condición DOWNSTREAM_NBC.
Modelos de turbulencia
Actualmente hay dos modelos implantados en ADFC:
• Modelo Smagorinsky: este modelo es el más tosco, pero tiene a su favor ser más rápido y
estable.
• Modelo K-Epsilon: es sin duda el más exacto, pero es más lento e inestable por estár
todavía en fase de desarrollo.
Seguimiento de partículas fluidas

Para seguir la posicion de partículas en el seno del fluido, hay que completar los siguientes campos
en el archivo PRB:
• Use Particles: hay que seleccionarlo para activar el seguimiento de partículas.

• Particles Intro X, Y, Z: coordenadas del punto donde se introducen partículas.
• Particles Step Interval: numero de pasos de tiempo entre partículas. Por ejemplo, si el paso
de tiempo es de 0.08 segundos, si usamos un valor de 50 introducimos partículas cada 4
segundos.
• Particles Max Distance: cuando una partícula se aleje esta distancia del punto Particles Intro
(X, Y, Z) sera destruida. Debe ajustarse de forma que ninguna partícula salga fuera del mallado.
El programa generara una serie de archivos llamados <nombre_problema>.part.<tiempo> donde

<tiempo> es el instante en el que la partícula es introducida. Se crea un archivo por cada partícula.
El formato interno es sencillo: cada fila representa la posiciín de la partícula en un instante concreto,
de forma que la primera columna es el instante (segundos), y las otras tres las coordenadas X, Y y Z
de la partícula.
Ejemplo
Para un cilindro 2D de diámetro unidad, centrado en el origen de coordenadas, Reynolds 100 y con
los parámetros indicados en la imagen del PRB anterior:
t=96 seg.
El formato de los archivos es muy sencillo, siendo una tabla ASCII con 4 columnas. Usando
cualquier hoja de cálculo (OpenOffice, StarOffice, Excel...) pueden generarse imágenes como la
anterior.
Notas
• El algoritmo soporta hasta un máximo de 64 particulas simultáneas dentro del fluido. Este valor
es bastante amplio, ya que en las pruebas que he realizado nunca he sobrepasado las 9 partículas a
la vez. Si se necesita, no hay problema es ampliarlo (y recompilar el programa).
• Cualquier duda: Alejandro R. <alrog@users.sourceforge.net>
ADFC Navier-Stokes Solver Manual

(version 3.0)
Project page: http://www.sourceforge.net/projects/adfc

home: http://adfc.sourceforge.net
email: adfc-devel@lists.sourceforge.net
Introduction
This brief tutorial will introduce you to using ADFC solver and GiD pre/postprocessor. It is not
intended to be an exhaustive document about GiD: for further information check the CIMNE web
page10, where you will find many information.
As we are continuously improving software and documentation, please consider this as an

“evergreen” document and check regularly our web page for new versions of this tutorial.
Don't hesitate to sending doubts or request to:

ADFC Team list adfc-devel@lists.sourceforge.net
GiD installation
In order to install GiD in your computer, you must download the installation file from CIMNE
webpage. GiD is commercial software, so you will need a license to use it but, in spite of that, you
can obtain from its web page a 30-days free evaluation license. ADFC team is not related with
CIMNE in anyway: we are willing to make our solver compatible with as many meshers as possible,
so if you know a mesher that would fit for your purposes, let us know and provide us with enough
documentation to work on compatibility.
1. GiD is commercial software but it can be installed 2. After license agreement, you will be prompted for an
and used for a 30 days evaluation period. In order to do installation folder. Remember this directory! You will
so, you will need a license that can be freely downloaded need it to install ADFC.
from its web page.
3. You have to choose complete installation 4. Afterwards, file copy will begin.
5. When it is executed for the first time, you will have to 6. GiD is ready for use! You can see an example we have
introduce the serial number you got from CIMNE just loaded.
webpage.
ADFC v3.x Installation

In order to install ADFC you need to download from Sourceforge11 the most recent zip file available.
This file contains a folder named adfc.gid that you have to extract into ProblemTypes GiD subfolder.
This folder contains a bundle of auxiliar files that are needed to communicate GiD with the solver.
As soon as you extract the content of the file to the proper path, GiD will recognize it and add an
specific entry to its menu “Data/Problem Type/adfc”.
On the other hand, the bin folder contains the ADFC executables. You should choose the right one
for your platform and operating system.
Compiling ADFC v3.x

If you wish to use ADFC on a platform not supported by us or you have applied changes to its
source code, you will need to recompile it. As ADFC is written in standard C++ and it is not linked
against any uncommon library, everything should go smoothly.
In order to compile the program under UNIX or Linux, open a shell, browse to the src folder and
run the command make. This will generate an executable for your platform. In very strange cases
you will need to modify the makefile manually. Please, don't hesitate to contacting us about any
problem or doubt you have: we are very interested in making ADFC as robust and portable as
possible.
11 La ficha técnica se encuentra en http://www.sourceforge.net/projects/adfc

Solving an easy case: 2D cylinder at Reynolds 100

At this point, the solver and the mesher are properly installed on your sistem. Below it is described
step by step the preprocess, solving and postprocess of an easy case: the well-known 2D cylinder at
Reynolds 100.
The first step is to indicate GiD that you wish to use the
Firstly, let's check that the problem type is correctly
ADFC problem type, in the menu "Data/Problem
installled inside GiD directory.
Type/adfc"
The first step is to indicate GiD that you wish to mesh a geometry for ADFC solver, choosing in the
menu “Data/Problem Type/adfc”. Afterwards, you are going to define the geometry through the
mouse and the keyboard, introducing point coordinates, lines and surfaces.
The cylinder has a 1 unit diammeter and will be placed in the coordinate origin. The domain will be a
rectangle 20 units long and 9 units wide. Therefore, you will need to define all these points:
X coordinate Y coordinate
-0.5 0
0 0.5
0.5 0
0 -0.5
-4.5 4.5
15.5 4.5
15.5 -4.5
-4.5 -4.5
Point creation is performed by selecting in the menu the option "Geometry/Create/Point". Points
can be introduced through the keyboard, just typing their X and Y coordinates delimited by
whitespaces and pressing enter key after each one. This can also be performed using the mouse and
clicking directly on the window, but it is extremely unaccurate and we disencourage that.
The next step is to connect the points with straight lines and define the rectangular boundary. You
can accomplish it with the menu option "Geometry/Create/Line" and by clicking on the 4 vertex of
the rectangle. When you are finished, press scape.
As you introduce the coordinate values, points will With the option "Geometry/Create/Line" you can
appear in the screen. define the straight lines that surround the domain.
Cylinder creation is a bit more complicated. Even though circular shapes can be easily created with a
predefined function in GiD, this tutorial will show how to use curvilinear arcs so you will learn how
to face more complex geometries which may not be predefined in the mesher. Choose the option
"Geometry/Create/Arc"which allows you the define an arc with three points. Cylinder will consist
on two semicircunferences: one right-up-left and the other left-down-right. GiD will always show a
brief help text in the status bar.
At this point, you have the boundaries properly defined, so the next step is to tell GiD how the
domain is. As there is a hole in it (the cylinder) you will define the rectangle firstly and then sustract
the cylinder from it.
Rectangle is defined through the option "Geometry/Create/NURBS Surface/By Contour"

highlighting the four lines that define the region and pressing scape. A new pink rectangle will appear
indicating that the region was successfully created.
In order to add the hole, choose "Geometry/Edit/Hole NURBS Surface" and select the previously
defined rectangular region (the pink rectangle) and then the two arcs that define the hole. Pressing
scape will update the region and the hole will be added to it.
You have just defined al geometry lines. Firstly, define the rectangular region.
After substracting the cylinder from it, the geometry is

completely defined.
At this point, geometry is perfectly defined so preprocess is finished. Now you will define boundary
conditions, meshing parameters and some solver specific configuration.

GiD can mesh using several types of elements. ADFC uses Taylor-Hood triangles in 2D cases, so
you will need to choose int the menu "Meshing/Quadratic Elements/Quadratic" and
"Meshing/Element Type/Triangular".
Just before generating the mesh, you have to set boundary conditions: where the fluid enters the
domain, which is the downstream exit, which walls are rigid and so on. For this case, the fluid enters
from the left side, with an homogeneous speed profile and exits through the opposite side on the
right. The upper and lower walls, as well as the cylinder, will be static rigid walls, so you will set on
them zero speed.
Open the Conditions dialog window by selecting it from the menu “Data/Conditions". On the top
of the dialog there are three icons, representing boundary conditions over nodes, lines and surfaces.
You need line conditions in this 2D case.
Type X Value Description

Set_speed 1.0 Fluid entrance, homogeneous speed profile (1,0)
Set_speed 0.0 Upper wall
Set_speed 0.0 Lower wall
Set_speed 0.0 Cylinder
Downstream NBC 0.0 Fluid downstream exit
Set_speed type applies a Dirichlet condition to the speed field. Speed on that places will be equal to
the values you indicate in the dialog. Downstream_NBC type is set on the exit of the fluid so it can
pass through that place without tension.
In order to assign a condition to a line, you have to click the button "Assign". After pressing it, you
can choose all the lines you wish to add to this boundary type. When you are finish just press scape.
You can check that all conditions were set properly by choosing the option "Draw/Draw
Conditions Field/Type” in the dialog.
The menu item "Data/Conditions" open the dialog You can check if the conditions were properly set by
window used to set boundary conditions. choosing "Draw/Colors" .
Only mesh generation is left. If you choose "Meshing/Generate" in the menu you will generate a
new one. GiD will ask you to confirm that you wish to overwrite the previous one (yes, of course)
and will prompt you for the average element size. Let's use the default one: as you can see, the
generated mesh is too coarse and requires tunning.
In order to tell GiD which places require more detailed meshing select "Meshing/Asign unstruct.
sizes/Lines" and introduce a 0.05 size in the dialog. When GiD asks for which lines to assign that
mesh size to, select the boundaries of the cylinder and press scape. If you mesh again, with
"Meshing/Generate" and the same default element size, mesh will have a better look. The zoom
(magnifying glass icon) you can see the mesh in greater detail.
Now let's force GiD to perform smoother element size transitions in the mesh. Select
"Utilities/Preferences" which opens a dialog window and then click on the "Meshing" tab. There
you will find an horizontal scrollbar labeled "Unstructured size transitions". This value tells GiD
how fast element size can change. Choose a smoother one, a value like 0.4 will be a good choice.
Meshing again you will get the nice result you were looking for.
Default meshing parameters may result on a very coarse Assigning to the cylinder a smaller element size will
mesh. improve the mesh around it.
The final mesh! 7502 nodes and 3662 elements. Don't

Afterwards we can force GiD to perform smoother
worry if you don't achieve this values... it should be fine
element size transitions.
if your mesh looks more or less like this one.
Preprocess and meshing is finished! Just before launching the solver, you will need to configure some
CFD specific values in the menu “Data/Problem Data”. Those values are passed directly to ADFC
by the GiD. Default values will fit well, but check these important ones:
Tab Parameter Value

NavierStokes Reynolds_number 100
NavierStokes Time_steps 2000
NavierStokes Steps_between_saving 10
NavierStokes Time_step_length 0
Let's save your work with the menu item "Files/Save" (GiD format). If possible, don't use a
filename longer than 8 characters (this limitation only affect some older version of GiD running
under Windows). "tutorial" would be fine, and a folder named “tutorial.gid” will be created,
containing several archives in it. As ADFC cannot read this file format, you will need to generate a
Calculation File. In order to do so, click in the menu “Files/Import Export/Write Calculation
File” and create a file called “tutorial” with no extension in the previously used folder “tutorial.gid”.
Solver parameter configuration. Saving Calculation File.
Solver is launched within a terminal or console. In the command line, just write the following
command:
<adfc3.exe | adfc3> -gid <path_to_calculation_file>
For example, Windows platform:

c:\gid61\adfc.gid\adfc3.exe -gid c:\mallados\tutorial.gid\tutorial
Under Linux:
/home/user/adfc3.exe -gid /home/user/tutorial.gid/tutorial
Depending on your hardware, solving may take more or less time to complete. You can abort a
solving process when you like, pressing Ctrl-C in the console, but you will be able to posprocess a
running one if you like.
Postprocess is started by selecting "Files/Postprocess". A dialog window will appear while data is
loaded from disk.
In "Windows/View Results" you can choose which instant or step to visualize, which view to use
(choose Contour Fill), which result (SPEED) and component (SPEED_X, for example).
“View Results” allows you to choose which time step to

Speed X component, at time 48.5 seconds.
visualize, view, result, component...
GiD and ADFC have huge capabilities... this is just a small demo of them. We encourage you to
check ADFC documentation and GiD webpage.
Simulación de un corte orográfico 2D
artículo en construcción
Una de las principales aplicaciones del programa ADFC es la simulación del comportamiento del
viento sobre diferentes relieves con el fin de situar el emplazamiento óptimo para parques eólicos.
Un ejemplo detallado y con valores experimentales es el Problema 2D-5: Montaña Askervein
recogido en el capítulo Cálculos del Proyecto Final de Carrera.
A lo largo de este tutorial vamos a enumerar detalladamente todos los pasos necesarios para simular
un corte orográfico mediante ADFC.
Adimensionalización y parámetros del problema

Antes de definir la geometría en el mallador GiD, debemos escoger el valor de la longitud
característica D del problema, que típicamente se hace igual a la altura del obstáculo principal. Este
valor nos permitirá adimensionalizar todas las distancias, expresándolas mediante la siguiente
expresión:
L real Expresión para adimensionalizar

l adim = distancias.
D
En lo que a la velocidad del viento se refiere, también debemos definir una velocidad característica
V y de igual forma, expresar todas las demás velocidades en función de ella:
U real Expresión para adimensionalizar

u adim = velocidades.
V
Generalmente esta velocidad característica se hace igual a la velocidad máxima del viento en la
geometría a estudio, la cual se suele alcanzar en las capas más altas de la atmósfera.
velocidad característica

perfil de entrada
salida del fluido

característica
longitud
suelo
Esquema de la geometría de un corte orográfico 2D. Hay que destacar la longitud característica y la velocidad
característica, necesarias para adimensionalizar.
Todos los valores que recibe ADFC (mallado, condiciones de contorno...) deben estar expresados en
magnitudes adimensionales y, de la misma forma, todos los valores que devuelve también lo estarán.
A modo de ejemplo, si queremos simular un corte de 5 Km de longitud, con un obstáculo de 100 m
de altura máxima y una velocidad máxima del viento de 10 m/s, escogeremos como longitud
característica 100 m y velocidad característica 10 m/s, de forma que en el mallado
adimensionalizado la altura pasa a ser 1, la longitud 50 y la velocidad máxima del viento 1.
Para definir el régimen del fluido debemos calcular el número de Reynolds. Este parámetro
adimensional tiene la siguiente expresión:
 DV Expresión del número de Reynolds.

R e=

Aquí es donde entran en juego las propiedades del fluido:  es la densidad y  es la viscosidad
cinemática del aire, ambos parámetros calculados a la presión y temperatura de estudio. D y V son
respectivamente la longitud característica y la velocidad característica.
Condiciones de contorno
Existen cuatro zonas diferenciadas en el contorno, cada una con sus propias características:
IMPONER_VELOCIDAD
V=1.0
SALIDA_DEL_FLUIDO
PERFIL_ENTRADA
L=1.0
DESLIZAMIENTO DESLIZAMIENTO
Boceto que indica la localización de cada condición de contorno en el mallado. Se indica también la altura del
obstáculo y la velocidad máxima de viento ya adimensionalizadas.
• Entrada: la entrada del fluido típicamente posee un perfil parabólico o logarítmico

consecuencia de la capa límite terrestre. Su configuración se realiza desde el menú
“Data/Problem Data” del GiD y se imponen mediante la condición SET_SPEED.
• Suelo: el hecho de trabajar con geometrías de grandes dimensiones y números de Reynolds
muy altos provoca que la capa límite sea tan reducida que no es posible recogerla en el
mallado. Imponer velocidad nula en el suelo en estas circunstancias sería un error ya que
falsearía en gran medida el resultado. Por ello, hay que imponer la condición SLIP, de la
que se pueden especificar el slip y el factor de fricción.
• Techo: la parte superior del mallado, por estar lo suficientemente alejada del suelo,
suponemos que tiene velocidad horizontal constante e igual a 1,0 adimensional (la velocidad
máxima en reales). Para ello se usa la condición SET_SPEED.
• Salida: para la salida se usa la condición DOWNSTREAM_NBC.
Modelos de turbulencia
Actualmente hay dos modelos implantados en ADFC:
• Modelo Smagorinsky: este modelo es el más tosco, pero tiene a su favor ser más rápido y
estable.
• Modelo K-Epsilon: es sin duda el más exacto, pero es más lento e inestable por estár
todavía en fase de desarrollo.
Seguimiento de partículas fluidas

Para seguir la posicion de partículas en el seno del fluido, hay que completar los siguientes campos
en el archivo PRB:
• Use Particles: hay que seleccionarlo para activar el seguimiento de partículas.

• Particles Intro X, Y, Z: coordenadas del punto donde se introducen partículas.
• Particles Step Interval: numero de pasos de tiempo entre partículas. Por ejemplo, si el paso
de tiempo es de 0.08 segundos, si usamos un valor de 50 introducimos partículas cada 4
segundos.
• Particles Max Distance: cuando una partícula se aleje esta distancia del punto Particles Intro
(X, Y, Z) sera destruida. Debe ajustarse de forma que ninguna partícula salga fuera del mallado.
El programa generara una serie de archivos llamados <nombre_problema>.part.<tiempo> donde

<tiempo> es el instante en el que la partícula es introducida. Se crea un archivo por cada partícula.
El formato interno es sencillo: cada fila representa la posiciín de la partícula en un instante concreto,
de forma que la primera columna es el instante (segundos), y las otras tres las coordenadas X, Y y Z
de la partícula.
Ejemplo
Para un cilindro 2D de diámetro unidad, centrado en el origen de coordenadas, Reynolds 100 y con
los parámetros indicados en la imagen del PRB anterior:
t=96 seg.
El formato de los archivos es muy sencillo, siendo una tabla ASCII con 4 columnas. Usando
cualquier hoja de cálculo (OpenOffice, StarOffice, Excel...) pueden generarse imágenes como la
anterior.
Notas
• El algoritmo soporta hasta un máximo de 64 particulas simultáneas dentro del fluido. Este valor
es bastante amplio, ya que en las pruebas que he realizado nunca he sobrepasado las 9 partículas a
la vez. Si se necesita, no hay problema es ampliarlo (y recompilar el programa).
• Cualquier duda: Alejandro R. <alrog@users.sourceforge.net>
Capítulo 5. Documentación para

desarrolladores
ADFC 3.x por dentro

detalles de la implantación
ficha ténica: http://www.sourceforge.net/projects/adfc

página web:http://adfc.sourceforge.net
Introducción
El propósito de este documento es describir de la forma más clara posible el funcionamiento interno
del solver ADFC. Como este programa se distribuye bajo licencia GNU, esperamos que esta guía
anime y sirva de ayuda a todas aquellas personas interesadas en reutilizar código, ampliarlo o
modificarlo según sus necesidades.
Este documento se centrará exclusivamente en los detalles de la implantación informática en C++.
Para una descripción más exhaustiva de los algoritmos y métodos numéricos empleados desde un
punto de vista más matemático y físico, recomendamos la lectura del proyecto final de carrera:
Creación de un túnel de viento virtual12

Univ. Pontificia Comillas, E.T.S.I. ICAI
Alejandro Rodríguez Gallego
Una vez más, nos gustaría ofrecer toda clase de ayuda a las personas interesadas en el solver. Para
cualquier duda o sugerencia, no dude en enviar un email a:
Leo Miguel González Gutiérrez leo.gonzalez@iit.upco.es

Alejandro Rodríguez Gallego alrog@users.sourceforge.net
12 Se puede descargar en formato PDF en: http://www.sourceforge.net/projects/adfc

Primer contacto
En su versión 3.x, el código fuente del solver consta de aproximadamente 25 archivos en C++, 6
archivos de cabecera y 1 archivo makefile. En principio está escrito en estricto ANSI C++, por lo
que debería ser totalmente portable. El programa ha compilado perfectamente en los siguientes
compiladores: GCC 2.9, GCC 3.0, Dev-C++ 4.9 y Microsoft Visual C++ 6.0.
A continuación enumeramos los archivos de cabecera:
adfc.h Archivo de cabecera principal, contiene todas las definiciones de las

clases.
array.h Plantilla para el manejo de vectores de cualquier tipo.
revision.h Archivo autogenerado, contiene el número de revisión.
tokenizer.h Archivo de cabecera para el tokenizer (en desarrollo).
vector_cola.h Plantillas para el manejo de vectores que funcionan como colas,
incrementando su tamaño.
vector_cola_2d.h
Y a continuación los fuentes:
backup.cpp Copias de seguridad del estado del solver, para evitar perder los datos
ante un bloque, fallo suministro eléctrico, etc.
caracteristicas2d.cpp Método de las características generalizado, versiones 2D y 3D.
caracteristicas3d.cpp
cargar_problema_navierstokes.cpp Carga datos desde los archivos GiD.
divergencia_2d.cpp Construye las matrices de divergencia a partir de los datos del
mallado.
divergencia_3d.cpp
draglift.cpp Cálculo de los coeficientes de resistencia y sustentación.
gradiente_conjugado.cpp Resuelve sistemas de ecuaciones lineales mediante un gradiente
conjugado algebraico con precondicionador de Cholesky incompleto.
inicializa_navierstokes.cpp Contienen todo el código relacionado con el solver de las ecuaciones
de Navier-Stokes.
resolver_navierstokes.cpp
k-epsilon.cpp Modelo de turbulencia K-Epsilon.
main.cpp Inicio del programa.
masas_rigidez_2d_cuadraticas.cpp Construye las matrices de masas y rigidez para problemas 2D, tanto
la versión lineal como la cuadrática.
masas_rigidez_2d_lineales.cpp
masas_rigidez_3d_cuadraticas.cpp Construye las matrices de masas y rigidez para problemas 3D, tanto
la versión lineal como la cuadrática.
masas_rigidez_3d_lineales.cpp
matriz_dispersa.cpp Clase para almacenar y manipular matrices dispersas.

nvi.cpp Genera los vectores NNVI y NVPN a partir de los datos geométricos
del mallado 2D o 3D.
observador.cpp Realiza un seguimiento de las propiedades del campo fluido en
puntos determinados, generando tablas que pueden ser importadas en
una hoja de cálculo.
operaciones_mallado.cpp Operaciones relacionadas con la manipulación de mallas.
perfil_entrada.cpp Crea diferentes perfiles de velocidad para la entrada del fluido.
slip.cpp Implanta la condición de contorno slip o deslizamiento.
smagorinsky.cpp Modelo de turbulencia Smagorinsky.
tokenizer.cpp Base para un pequeño lenguaje interpretado (en desarrollo).
Plantilla Array<tipo>
Esta plantilla sirve para almacenar en RAM cualquier clase de vector. Es una de las incorporaciones
más recientes al código y con ella se persigue eliminar, en la medida de lo posible, el uso de
punteros.
La plantilla Array<tipo> se ha diseñado para ser lo más transparente posible, y gracias a la
sobrecarga del operador operator[] su uso no se diferencia del de un vector clásico. Sus ventajas
son una mayor sencillez y claridad en el código, junto con una gestión de la memoria RAM más
eficiente (evitando las pérdidas de memoria al olvidarse uno de liberar un puntero).

Clase MatrizDispersa
Generalmente los métodos numéricos suelen desembocar en la resolución de enormes sistemas de
ecuaciones lineales con gran número de ecuaciones y de incógnitas. Para llegar a este punto siempre
es necesario almacenar en memoria y manipular con cierta soltura grandes matrices de coeficientes.
La forma más común de trabajar con estas matrices es emplear técnicas de almacenamiento disperso.
ADFC emplea esta clase para llevar a cabo todas las operaciones matriciales.
A continuación se incluye la lista de métodos públicos de la clase, tal y como se describe en el
archivo de cabecera principal adfc.h:
~MatrizDispersa();
MatrizDispersa(int, int, int, Array<DBL> &, Array<int> &, Array<int> &);
MatrizDispersa(int, int, int, Array<int> &, Array<int> &);
MatrizDispersa(MatrizDispersa &, int);
void aplicaFactor(DBL);
void asignaElemento(int, int, DBL);
void cero();
int devuelveTotalFilas();
int devuelveTotalColumnas();
DBL leeElemento(int, int);
void lumping(Array<DBL> &);
void multiplica(Array<DBL> &, Array<DBL> &);
DBL productoEscalarDeProductoMatricial(Array<DBL> &, Array<DBL> &);
void sumaElemento(int, int, DBL);
void sumaParalela(int, int, DBL, MatrizDispersa &, DBL);
void sumaMatriz(MatrizDispersa &, DBL);
void volcarEnArchivo(char *, char *);
void sumaMatrizConMuTurbulenta(MatrizDispersa&, MatrizDispersa&, DBL , DBL,
Array<DBL> &);
MatrizDispersa(int afilas, int acolumnas, int msimetrica, Array<DBL> &aelem,
Array<int> &aipos, Array<int> &ajpos);
em

ADFC Misc El Libro

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ADFC Misc El Libro

Uploaded by

Copyright:

Available Formats

ADFC – El libro 1

Anexo: Tabla de funciones base del triángulo 2D.....................................................................89

Coeficientes de Drag y Lift......................................................................................................142

ADFC es un solver de las ecuaciones de Navier-Stokes que simula el comportamiento

de fluidos newtonianos incompresibles en dominios 2D y 3D. Este tipo de programas

recibe el nombre de Computer Fluid Dynamics.

un grupo de alumnos de ingeniería industrial en el ICAI, con el propósito de realizar

investigaciones en el campo de los CFD.

pequeño solver de la ecuación de Poisson en Java. Este programa permitía llevar a

se fue completando el programa, aumentando su potencia de cálculo con nuevos

de colaboración otorgada por el departamento de Fluidos y Calor. En el curso

siguiente, la beca pasó al cargo de la consultora DyTA que estaba interesada en

aplicar el programa para llevar a cabo simulaciones de cortes orográficos.

Finalmente, el curso 2000-2001 se empleó en redactar el proyecto final de carrera, y

y una vez se entregó el proyecto, se publicó en Sourceforge bajo la licencia pública

Ya en el 2003, la Asociación de Ingenieros del ICAI otorga el premio al mejor

proyecto final de carrera del área de ingeniería industrial a Alejandro Rodríguez

Gallego por ADFC.

Leo Miguel González Gutiérrez

LICENCIADO EN CIENCIAS FÍSICAS. ESPECIALIDAD TEÓRICA.

DOCTOR POR LA UNIVERSIDAD POLITÉCNICA DE MADRID.

D. Leo Miguel González Gutiérrez, D. Luis Pérez Rojas, D. Jesús Valle

D. Luis Pérez Rojas, D. Antonio Souto Iglesias, D. Leo Miguel González

Alejandro Rodríguez Gallego

Capítulo 0. Guía del lector

Visión general del libro

Ficha del proyecto

CREACIÓN DE UN TÚNEL DE VIENTO VIRTUAL

RESUMEN DEL PROYECTO

La herramienta informática diseñada proporciona abundante información acerca de los problemas

Para resolver las ecuaciones de Navier-Stokes se emplea un gradiente conjugado diferencial y,

En la resolución de un problema de Navier-Stokes el código utiliza diferentes módulos internos para

Las operaciones matriciales se realizan mediante técnicas de almacenamiento disperso, permitiendo

Capítulo 1. Introducción al proyecto

Introducción a los CFD como herramienta de diseño

En la actualidad, gracias al desarrollo de los códigos de Dinámica de Fluidos Computacional

Objetivos del presente proyecto

Editor de textos Hoja de Cálculo

• Distribución del campo de velocidades

Ámbito de aplicación del proyecto

incrementos. Cada incremento se construye sobre el anterior.

Análisis Diseño Código Prueba

Análisis Diseño Código Prueba

Análisis Diseño Código Prueba

Licencia del Software

y distribución del paquete de software desarrollado.

Licencia Pública GNU

parte del software de la Free Software Foundation, y muchos más programas.

Los autores de esta traducción son:

• Jesús González Barahona

• Pedro de las Heras Quirós

Esta es una traducción no oficial al español de la GNU General Public License. No ha

sido publicada por la Free Software Foundation, y no establece legalmente las

speakers understand the GNU GPL better.

Copyright (C) 1989, 1991 Free Software Foundation, Inc.

675 Mass Ave, Cambridge, MA 02139, EEUU

Se permite la copia y distribución de copias literales de este documento, pero no se permite su

de compartirlo y modificarlo. Por el contrario, la Licencia Pública General de GNU pretende

conseguirlo si lo quiere, de que pueda modificar el software o usar fragmentos de él en nuevos

obligaciones que le afectan si distribuye copias del software, o si lo modifica.

forma que conozcan sus derechos.

Protegemos sus derechos con la combinación de dos medidas:

1. Ponemos el software bajo copyright y

reputación de los autores originales.