I don’t know what’s the matter with people: they don’t
learn by understanding, they learn by some other way—
by rote or something. Their knowledge is so fragile!
—Richard Feynman

Esta entrada del blog me recordará de forma efectiva que tengo que seguir la recomendación de mi asesor y leer libros de Feynman

Saludos!

La suma de Riemann consiste básicamente en trazar un número finito de rectangulos dentro de un área irregular, calcular el área de cada uno de los rectangulos y sumarlos. El problema de este método de integración numérica es que al sumar las áreas se obtiene un margen de error muy grande.

Fuente: Wikipedia

Últimamente estuve trabajando en un programa para resolver cuestiones de integración numéricamente ya que fue una de las encomiendas de mi asesor el Dr. Jesus Manzanares creo que este es un “Baby Step” que nos llevara a resolver algo mucho mas complejo, creí que era relevante incluir la descripción de la integración numérica por lo que incluí la definición de wikipedia que es buena,

Cabe complementar un poco la definición y agregar que entre mas rectangulos se le agreguen al problema la aproximación de la solución es mucho mas exacta, y de acuerdo a pruebas hechas llegando a 100 ó poco mas de esa cantidad se logra tener una aproximación de la solución bastante aceptable

Bueno creo que ya fue demasiada teoría aunque realmente la teoría nunca es suficiente, a continuación se presenta una implementación en web de la Suma de Riemann, para tener información mas amplia de como realizar un programa en web puedes visitar el post ¿Como portar una aplicacion existente a una solucion web?

La aplicación esta diseñada para resolver 3 tipos de integrales, las siguientes:

Donde el rango de la integral es totalmente parametrizable en la implementacion, y en donde para realizar la integración numérica se deberá hacer una sumatoria, a continuación se enlista el código en C++ de la implementación, seguido de la aplicación en sí corriendo en web.

/*
 * File:   NumericalIntegral.cpp
 * Author: Yohan Jasdid
 *
 * Created on October 15, 2011, 4:36 PM
 */
#include
#include
#include
#include

#include
#include
#include
#include
#include
#include

#include "getpost.h"
#include "json/reader.h"
#include "json/writer.h"
#include "json/elements.h"

using namespace std;
using namespace json;

string exec(char* cmd);
void ReturnError(string error);

/**
 * Main function
 * @return
 */
int main()
{
    map  Post;
    initializePost(Post);   //notice that the variable are passed by reference!

    cout << "content-type: application/json" << endl << endl;

    string userData;
    string message = "";
    if (Post.find("UserData") != Post.end())
    {
        userData = Post["UserData"].c_str();
    }
    else
    {
        ReturnError("Some requiered parameters were not provided, try again.
");
        return 1;
    }

    Object objDocument;
    try
    {
        std::istringstream jsonData(userData);
        Reader::Read(objDocument, jsonData);

        // Get and parse parameters
        String jsonSX = objDocument["SX"];
        String jsonEX = objDocument["EX"];
        String jsonN = objDocument["N"];
        String jsonFnc = objDocument["Fnc"];

        double start_x = atof(jsonSX.Value().c_str());
        double end_x = atof(jsonEX.Value().c_str());
        double interval = end_x - (start_x);
        double max_n = atof(jsonN.Value().c_str());
        int fnction = atoi(jsonFnc.Value().c_str());

        // We must generate a unique ID for naming our data graph file
        char uuidgen[] = "uuidgen";
        string uuid = exec(uuidgen);

        // Define files and folders
        string gpFolder = "../gnuplot/";
        string gpDataFile = gpFolder + uuid + ".dat";          // data file
        string gpGraphFile =  gpFolder + uuid + ".png";        // graph file
        string gpCommandFile =  gpFolder + uuid + ".gnuplot";  // gnuplot command file

        // Create data file
        ofstream gpData;
        gpData.open((gpDataFile).c_str());
        if(!gpData)
        {
            ReturnError("** Failed to create the graph file.
");
            return 1;
        }

        // search for all n..
        stringstream data;
        for (double i = 1; i         {
            double n = i;
            double delta_x = interval / n;
            double x_i = start_x;
            double total = 0.0;
            double function = 0.0;

            for (double j = 1; j             {
                x_i = x_i + delta_x;
                switch (fnction)
                {
                    case 1:
                        function = x_i * x_i;
                        break;
                    case 2:
                        function = x_i * x_i * x_i;
                        break;
                    case 3:
                        function = cos(x_i);
                        break;
                }
                total = total + ((function) * delta_x);
            }

            data << data << i << " " << total << endl;
            gpData << i << " " << total << "\n";
        }
        gpData.close();

        // We must build a gnuplot commands file
        ofstream gpCommands;
        gpCommands.open((gpCommandFile).c_str());
        if(!gpCommands)
        {
            ReturnError("** Failed to create the graph file.
");
            return 1;
        }

        gpCommands << "set title 'Integral Numerica'" << "\n";
        gpCommands << "set term png small" << "\n";
        gpCommands << "set output " << "'" << gpGraphFile << "'" << "\n";
        gpCommands << "set nokey" << "\n";
        gpCommands << "plot '" << gpDataFile << "' using 1:2 with lines" << "\n";
        gpCommands.close();

        // Execute gnuplot and generate graph
        string commds = "gnuplot '" + gpCommandFile + "'";
        char *cmds = (char*)commds.c_str();
        exec(cmds);

        // Results ***
        // Build a json object to return as response of the request
        message += "Calculations finished without errors.
";
        Object objResponse;
        objResponse["Error"] = String("");
        objResponse["Message"] = String(message.c_str());
        objResponse["DataFile"] = String(gpDataFile.c_str());
        objResponse["CommandFile"] = String(gpCommandFile.c_str());
        objResponse["GraphFile"] = String(gpGraphFile.c_str());
        objResponse["PlainData"] = String(data.str());

        std::stringstream jsonStream;
        Writer::Write(objResponse, jsonStream);
        cout << jsonStream.str();
    }
    catch (exception& e)
    {
        ReturnError("** Something went wrong, please report this problem to the system administrator.
");
        return 1;
    }
    return 0;
}

/**
 * @brief Returns an error in json format
 * @error The error description to be returned
 *
 * This method executes a bash command using a pipe and a buffer to capture the
 * result of the execution, then return the execution to client code.
 */
void ReturnError(string error)
{
  Object objResponse;
  objResponse["Error"] = String(error.c_str());

  std::stringstream jsonStream;
  Writer::Write(objResponse, jsonStream);
  cout << jsonStream.str();
}

/**
 * @brief Executes a shell command
 * @param cmd The command to execute
 * @return The result of the execution
 *
 * This method executes a bash command using a pipe and a buffer to capture the
 * result of the execution, then return the execution to client code.
 */
string exec(char* cmd)
{
    FILE* pipe = popen(cmd, "r");
    if (!pipe)
        return "ERROR";

    char buffer[128];
    string result = "";
    while(!feof(pipe))
    {
        if(fgets(buffer, 128, pipe) != NULL)
            result += buffer;
    }
    pclose(pipe);

    // remove carriage return (new lines)
    result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
    return result;
}

Los resultados del programa muestran la resolución de la integral numérica para un numero de particiones (n) dado, que son los rectángulos a resolver y sumar, entre mayor sea el número de rectángulos mayor sera la exactitud del resultado, a continuación se muestran los resultados para n=5, n=50 y n=100.

N=5

N=50

N=100

Como se puede ver en los resultados anteriores el resultado converge rápidamente con el resultado real lo cual es bueno ya que se puede obtener una aproximación muy decente utilizando el poder de procesamiento y la fuerza bruta de la computadora..

Como punto final se anexa a continuación la implementación de dicha integral numérica donde se puede jugar con los parámetros de entrada para obtener un resultado deseado y su gráfica correspondiente.

enjoy!

pd. Que tiempos los de Monterrey!…

enjoy!

http://www.youtube.com/watch?v=o0H2IZLc9dY

Aqui les dejo un escrito de mi buen amigo Erick que en ese entonces me envió al correo y lo recordé de pronto por habermelo encontrado por accidente..

Saludos a Erick y toda la banda que nos frecuentabamos en ese entonces..

pd.. veré si puedo recuperar los cortometrajes que se hicieron en aquellos tiempos..

La  Cacería: por Erick Mendoza Peña

En una noche fría y de tinieblas donde solo se pueden escuchar los chillidos de las criaturas nocturnas, se enfrentan un cazador y su presa, una bruja que a lo largo de los años ha hecho mucho mal…

-por fin estas en mis manos diana…

-crees que podrás vencer, mas estas muy equivocado pues aquí

Vas a perecer…

-suficiente…

Dijo el cazador y lanzo un disparo de su arma

-acaso eso es todo lo que puedes hacer…

-en el nombre de mi señor te ordeno que te rindas y perdonare tu vida…

-y yo te digo a ti que en el nombre de los 776 de la primera generación que yo no me apiadare ni de tu alma…

-no puedes hacer nada pues yo me revisto con la armadura de Jehová…

Se escucho un estruendo y los cielos empezaron a llorar…

-y la palabra de mi dios es mas cortante que cualquier espada de dos filos penetrando carne, hueso, tuétano y espíritu…

En ese momento la bruja sintió dolor en su alma pues no solo estaban los estragos físicos sino que una guerra espiritual y un confrontamiento muy fuerte estaba sucediendo…

-si quieres vivir tendrás que huir.

-el que teme huye, mas a que he de temer si mi dios es conmigo…

El espíritu del caballero de la antigua orden era fuerte y no temía a nada, mientras que el espíritu que yacía en la bruja se retorcía y debilitaba, pues escrito esta que los demonios creen en dios y tiemblan y mientras continuaba el combate espiritual el caballero se iba acercando poco a poco a la bruja, quien cada vez se veía mas amenazada pues su magia no surtía gran efecto en el y no podía encontrar duda o temor en su corazón…

-ciertamente eres valiente y confías en tu dios caballero, ¡mas tu señor no te ha dado autoridad para matar!…

-el deber de un caballero es exterminar la maldad y los medios no importan, ya sea que te redimas o que mueras con mi hoja…

-debes saber que ninguno de nuestra raza se da jamás por vencido…

-y conocerán mi nombre como el señor cuando desate mi ira sobre ellos…

El caballero continuo avanzando poco a poco mientras la bruja retrocedía y se exhaustaba lentamente.

-ya no tienes a donde huir bruja, acepta al señor y deja que tu alma sea perdonada para que puedas llegar a la gloria de Dios…

-ese no es el destino de mi raza y tu lo sabes…

-pues la salvación es por gracia para que nadie se glorié por tanto es para todos… que así sea…

Estando a unos cuantos metros de ella desenvaino su espada, se disponía a darle el golpe de muerte cuando en ese momento ella conjuro a uno de los espíritus de los garuo o como se les conoce mejor en el léxico común “licántropos”.

-espíritu de la noche dame un protector pues temo sentir la ira de este señor

y  en ese momento como de la nada apareció la bestia…

-déjala en paz…

Grito la bestia con gran furia…

-pues he aquí que os doy potestad de hollar sobre serpientes y potestades… y tu no eres excepción alguna… pues eres un espíritu demoníaco por lo tanto caerás ante el nombre de Jehová rey de reyes y dios de dioses…

-suficiente mortal… te desollare y me alimentare con tus entrañas…

El caballero se preparo para una feroz batalla de la cual solo saldría vivo sino dudaba de que su señor estaba con el… en un enfrentamiento que pocos ojos han presenciado se manifestó una gran batalla en la cual enviados de Dios y Satanás eran los contendientes…

-tu raza de garous es tan maldita y despreciada como la de Aradia y la de los cainitas…

ni si quiera se pueden soportar entre ustedes… sus guerras particulares han llegado a mi raza durante mucho tiempo y ahora nosotros los hijos de Dios estamos reclamando lo que nos corresponde… pues ustedes espíritus inmundos solo nos han envidiado pues el nos ha favorecido de entre toda la creación… envidia y malicia es lo único que existe en sus corazones desde el nacimiento del hombre le han envidiado… pero ahora en el nombre de dios todos ustedes están cayendo…

Pues desde el principio el señor dijo que nosotros los mallugaremos en la cabeza y ustedes nos mallugaran en el calcañar…

-tu raza es tan débil que tienen que mantenerse con eso para poder sobrevivir…

-tu veneno no sirve pues mi señor dice que comeremos cosa mortífera y no nos hará daño… ahora prepárate para volver de donde viniste…

-es hora de acabar con toda tu alarderia caballero…

el lobo arremetió feroz contra el caballero quien fue herido por sus garras, mas eso no fue suficiente pues en menos tiempo del que su enemigo lo imagino, la espada del cazador atravesó el pecho de la bestia dejándola sin aliento , así con un garuo muerto y sangre en su cuerpo el cazador se dirigía a su principal presa… mas la noche aun era joven y lloraba la caída de uno de sus hijos pues ya eran pocos… mas el joven cazador también comprendió que no debía morir pues los de su orden también eran pocos…

-muy bien bruja aceptas a dios en tu vida y le pedirás perdón?

-creo que no caballero, pero no dudes en hacer tu deber pues ya estoy cansada y la noche llora, mi raza se extingue y debilita, pero solo te haré una pregunta antes de que uses tu hoja, que vas a hacer cuando ya no existan los de mi raza o la raza de los garou y de los cainitas…

-me temo que ese día no llegara, pero si acaso llegase a pasar solo viviré hasta reunirme con mi dios…

-valiente cazador gloriosa es tu noche pues has acabado con dos de los hijos de la oscuridad…

-no hay gloria en mis actos sino en mi Dios quien me da la fuerza y a quien ruego por tu alma…

-que así sea cazador…

El caballero hizo una pequeña oración y después de eso clavo su espada en el frágil corazón de una bruja… la noche se estremeció y en medio de un bosque estaban los cuerpos de dos criaturas de las tinieblas…

-perdóname señor pues he pecado…

y entonces se retiro del lugar…

Saludos

Download (PPT, 999KB)

Introducción

La creciente demanda por soluciones accesibles y fáciles de utilizar desde internet ha motivado el desarrollo y la migración de cada vez mas sistemas a ambientes online lo que implica un incremento en la complejidad de los desarrollos actuales e inversión de tiempo en la curva de aprendizaje y adopción de nuevas tecnologías.

Con esto en mente, se trata de plasmar una forma sencilla y directa en forma de tutorial paso a paso de como hacer esta transformación tratando de disminuir en la medida de lo posible la complejidad agregada a los desarrollos así como el tiempo invertido para lograr dicha transformación.

Para la mejor organización del presente documento, se han establecido varias etapas donde se irán definiendo detalladamente y de forma incremental cada uno de los pasos para lograr la transformación de desarrollos actuales a soluciones en linea.

Requerimientos y Definiciones

Es bien sabido que en base a las tecnologías empleadas en los desarrollos actuales se eligen las tecnologías que se pueden utilizar en la transformación del desarrollo actual a solución en linea ya que por lo regular la plataforma y los lenguajes de programación involucrados en los desarrollos están directamente relacionados con las tecnologías web a utilizar para la transformación.

Requerimientos

A continuación se presenta una breve descripción de los requerimientos para la conversión, así como también se enlistan los paradigmas, técnicas y estándares a utilizar en todo el proceso.

• Plataforma: Se ha establecido que la plataforma sobre la cual debe de ejecutarse la solución sea de tipo linux, este es un sistema operativo muy robusto y flexible que permite la utilización de una gran variedad de tecnologías tanto en linea como de forma local. Existe una gran diversidad de “sabores” o distribuciones en el mercado y las diferencias entre versiones destaca mayormente en cuanto a sistemas de resolución de dependencias, sistemas de instalación, paquetes disponibles y gustos, pero todos comparten el corazón de la plataforma, el kernel. Las instrucciones de instalación funcionan tanto para Ubuntu como para Debian que han sido las plataformas elegidas por su estabilidad y madurez.
• Servidor Web: Para ejecutar una aplicación en linea se necesita un servidor web que se encargue de atender las peticiones generadas por parte de los usuarios y sea capaz de procesar y producir resultados visibles al código que realizo la petición, se ha elegido Apache como servidor web ya que es robusto, flexible y permite exponer una gran variedad de tecnologías en linea.
• CGI: La tecnología de preferencia para dar soporte en linea a C++ y Fortran es CGI (Common Gateway Interface) protocolo de extensión que funciona en conjunto con el servidor web y permite la ejecución de código C++ y Fortran mediante peticiones HTTP de Apache, para utilizar  correctamente CGI se deben realizar algunas modificaciones al código fuente actual tanto para extraer datos de las peticiones web así como para retornar resultados al navegador o al código que hizo la peticion.
• Perl: Perl (Practical Extracting and Reporting Languaje) es un lenguaje de programación interpretado, dinámico y de alto nivel que se ejecuta del lado del servidor y hace que ciertas rutinas de programación sean mas fáciles de escribir, se ha utilizado dicho lenguaje para facilitar y simplificar ciertas rutinas que se detallan mas adelante.
• gnuplot: gnuplot es una utileria portable orientada a la consola para graficar, utiliza una gran variedad de herramientas como lineas, puntos, cajas, contornos, vectores, superficies etc, para utilizar esta herramienta en una solución online se tendrá que hacer uso de técnicas personalizadas las cuales se enlistan mas adelante.

Instalación de software

En la presente sección se presentan los comandos de instalación y las librerías necesarias para crear el ambiente funcional para ejecutar aplicaciones web de forma local, se asume que se tiene una plataforma ya instalada de tipo linux para lo cual se recomienda instalar Ubuntu o Debian por ser flexible y robusto.

• Compiladores y Herramientas: De inicio se procede a instalar los compiladores básicos para dar soporte a programas de Fortran y C++ utilizando la consola de linux, los comandos requeridos se enlistan en el orden antes mencionado.

$sudo apt-get install gfortran
$sudo apt-get install build-essential

• Perl: Se procede a instalar Perl, que es uno de los lenguajes que se utilizan del lado del servidor para dar soporte de graficos online, se instala mediante el siguiente comando.

$sudo apt-get install perl

• Servidor Web Apache: A continuación se procede a instalar el servidor web apache el cual se encarga de dar soporte a las peticiones de los programas clientes, se instala mediante el siguiente comando.

$sudo apt-get install apache2

Una vez instalado, se debe reiniciar el servidor Apache para asegurarse de que se ha instalado correctamente.

$/etc/init.d/apache2 restart

Una vez que se tiene Apache, se debe instalar el soporte para CGI y Perl con el siguiente comando

$sudo apt-get install libapache2-mod-perl2

Y se reinicia Apache para que este reconozca los cambios agregados.

$/etc/init.d/apache2 restart

A continuación, se procede a configurar el usuario con el que Apache se ejecuta, por default Apache se ejecuta con el usuario (www-data) pero se quiere cambiar este comportamiento ya que esta planeado crear archivos desde los programas CGI lo que causaria que estos se crearan con el usuario default (www-data) y esto seria un problema al momento de tratar de leer dichos archivos por cuestiones de permisos y seguridad, para cambiar el usuario default se tendrá que editar uno de los archivos de configuración de Apache con el siguiente comando.

$sudo nano /etc/apache2/envvars

Donde nano es el programa de edición de preferencia, se puede usar gedit, vi etc. dependiendo de los gustos, el programa de edición muestra a continuación el archivo de configuracion de Apache, una vez mostrado se procede a buscar el usuario con el que Apache se ejecuta, algo similar a lo siguiente.

export APACHE_RUN_USER=www-data
export APACHE_RUN_GROUP=www-data

Una vez identificado el usuario con el que Apache se ejecuta se procede a reemplazar el usuario por el usuario actual, es buena practica que en vez de reemplazar las lineas anteriores con el usuario nuevo sean creadas dos nuevas lineas y las anteriores simplemente sean comentadas, el resultado seria similar a lo siguiente.

#export APACHE_RUN_USER=www-data
#export APACHE_RUN_GROUP=www-data
export APACHE_RUN_USER=[usuario]
export APACHE_RUN_GROUP=[usuario]

Una vez teniendo hechos los cambios y guardado el archivo de configuración se procede a reiniciar el servidor web para asegurarse de que el servidor funciona correctamente con las modificaciones introducidas.

$/etc/init.d/apache2 restart

A continuación y una vez configurado el usuario con que apache se ejecuta, se define una carpeta especializada la cual sera utilizada para albergar los archivos que contienen la lógica CGI así como los archivos que se ejecutan como programas cliente tipicamente en un navegador, dicha carpeta se debe crear dentro de la carpeta del usuario actual y es necesaria para evitar problemas de permisos y seguridad al momento de estar creando y probando el código CGI modificado del desarrollo actual, también, dentro de la carpeta publica se debe crear un directorio el cual contendrá los archivos de datos y de comandos que se generaran automáticamente, la carpeta se llama gnuplot, las carpetas antes mencionadas se crean con los siguientes comandos.

$sudo mkdir /home/[usuario]/public_html
$sudo mkdir /home/[usuario]/public_html/cgi-bin
$sudo mkdir /home/[usuario]/public_html/gnuplot

Donde (public_html) es un nombre opcional el cual es totalmente modificable, una vez que se tienen definidas y creadas las carpetas se procede a configurar nuevamente Apache para que reconozca dichas carpetas como contenedores de archivos públicos, para lograr esto, se debe editar otro archivo de configuración de Apache con el siguiente comando.

$sudo nano /etc/apache2/sites-available/default

Con dicho comando se tendrá visible el archivo de configuración de Apache, y se procede a buscar el siguiente apartado en donde se encuentra la seccion ”ScriptAlias” para modificar la ruta default por la nueva creada en pasos anteriores (cgi-bin), el apartado es similar al siguiente.

ScriptAlias /cgi-bin/ /var/www/cgi-bin/
<Directory "/var/www/cgi-bin/">
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    Order allow, deny
    Allow from all
</Directory>

Una vez modificada la ruta donde [usuario] es el usuario actual el resultado es similar a lo siguiente.

ScriptAlias /cgi-bin/ /home/[usuario]/public_html/cgi-bin/
<Directory "/home/[usuario]/public_html/cgi-bin/">
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    Order allow, deny
    Allow from all
</Directory>

El siguiente paso es agregar el soporte para que sean identificadas las tecnologías CGI y Perl en el directorio actual, por lo que se agrega .AddHandler cgi- script .cgi .pl ”justo debajo de las opciones para finalizar con algo similar a lo siguiente.

ScriptAlias /cgi-bin/ /home/[usuario]/public_html/cgi-bin/
<Directory "/home/[usuario]/public_html/cgi-bin/">
    AllowOverride None
    Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
    AddHandler cgi-script .cgi .pl
    Order allow, deny
    Allow from all
</Directory>

Una vez terminadas las modificaciones para la carpeta (cgi-bin) se procede a configurar el ”Document Root”que es el directorio raiz que contendra los archivos públicos y para el cual se definió la ruta en pasos anteriores (public html), esta vez el apartado a modificar es similar a lo siguiente.

DocumentRoot /var/www/
<Directory/>
    Options FollowSymLinks
    AllowOverride None
</Directory>
<Directory /var/www/>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride None
    Order allow, deny
    allow from all
</Directory>

Se modifica la ruta de tal forma que la nueva ruta apunte a la carpeta que se creo anteriormente para nuestro directorio publico de archivos, al final se tendrá algo similar a lo siguiente.

DocumentRoot /home/[usuario]/public_html/
<Directory/>
    Options FollowSymLinks
    AllowOverride None
</Directory>
<Directory /home/[usuario]/public_html/>
    Options Indexes FollowSymLinks MultiViews
    AllowOverride None
    Order allow, deny
    allow from all
</Directory>

Una vez modificados y guardados los archivos de configuración, se reinicia Apache para verificar que los cambios introducidos a los archivos de configuración son correctos.

$/etc/init.d/apache2 restart

gnuplot: Una vez finalizada la instalación y configuración de apache, se procede a instalar gnuplot como ultimo paquete necesario para terminar el ambiente funcional y ejecutar aplicaciones en linea localmente, para instalar gnuplot se debe descargar primero de la siguiente direccion  (http://www.gnuplot.info/) cabe mencionar que en caso de que se tenga instalado el paquete “Octave” no sera necesario instalar gnuplot ya que Octave lo instala por default, en caso de no tenerlo y una vez descargado y descomprimido, se ejecutan los siguientes comandos para instalarlo.

$./configure
$make
$make install

Estandares, Técnicas y Paradigmas

A continuación se enlistan los estándares, técnicas y paradigmas que se utilizan a lo largo del proceso de transformación de una aplicación tradicional a una solución en linea, se recomienda utilizar este tipo de practicas y librerías para que el software producido sea de alta calidad y lo mas estandarizado posible.

Paradigma Cliente-Servidor

El paradigma Cliente-Servidor consiste en que un programa Cliente realiza peticiones a un programa Servidor el cual realiza un trabajo y al final regresa un resultado al programa Cliente, en este caso el programa Cliente es la pagina web que contiene la solución en linea y el cual hace uso de JavaScipt para realizar peticiones al programa Servidor pudiendo también enviar parámetros y todo tipo de información para que el programa Servidor utilice en su proceso de calculo.

El programa Servidor en este caso se define como los programas C++ o Fortran modificados que se quieren tener en linea, este programa servidor es expuesto a Internet por medio de el servidor web y se encarga de atender las peticiones del programa cliente, cabe mencionar que en una solución típica el programa servidor atiende peticiones de muchos programas clientes y la capacidad de numero de clientes soportados depende del la infraestructura con que el programa servidor dispone.

JQuery

JQuery (http://jquery.com/) es una librería JavaScipt que simplifica la forma de manipular e interactuar con los objetos contenidos en HTML, tiene grandes ventajas y aplicaciones, se ha decidido utilizar esta librería para transformar de manera mas dinámica la iteraccion con los usuarios en las aplicaciones cliente que se ejecutan desde el navegador.

AJAX

AJAX (Asynchronous JavaScript and XML) Es un grupo de técnicas y métodos que se ejecutan del lado del cliente y que sirven para hacer llamados a código del lado del servidor de una manera asíncrona, usualmente este grupo de técnicas abarcan mas de una tecnología que en un escenario común se mezclan para lograr un objetivo, se ha decidido utilizar este grupo de técnicas utilizando la librería JQuery para hacer que los llamados a los programas CGI modificados sean de manera asíncrona y esto no impacte en otras partes del código cliente.

JSON

JSON (JavaScript Object Notation – http://www.json.org/) Es un formato ligero utilizado para intercambio de datos entre programas Cliente-Servidor el cual hace que los datos intercambiados entre programas sean fácilmente interpretados por personas, JSON es independiente de plataformas y muchos de los usuarios que lo utilizan lo consideran como un estándar para intercambio de datos entre diversas tecnologías y programas.

Serialización

Es el proceso mediante el cual se transforma un objeto de un programa para ser transmitido fácilmente por Internet o para ser almacenado en disco, en este caso la serializacion se usa para codificar los objetos JSON de tal manera que estos puedan transmitirse por Internet en forma de peticiones al programa servidor el cual también utiliza esta técnica para devolver un resultado al programa cliente una vez que ha completado y procesado la peticion, cabe mencionar que al proceso de decodificar y regenerar el objeto una vez recibido por el programa se le llama deserializacion.

Getpost y Cajun

Getpost y Cajun son librerías que se utilizan en C++ para hacer que el desarrollo sea mas rápido y robusto, la funcion de Getpost es la de extraer fácilmente información o parámetros contenidos en las peticiones que son enviadas desde el programa cliente al programa servidor, dicha información permite la iteraccion dinámica entre programas, por otro lado, Cajun nos permite regenerar los objetos JSON y deserializarlos en C++, esta librería es necesaria ya que por decisión se ha utilizado el estandar de comunicación JSON y una de las maneras mas sencillas de cumplir con este requisito es utilizando esta sencilla librería.

UUID

UUID (Universally Unique Identifier) Es un identificador estándar definido por la OSF (Open Software Foundation) y consiste en la construcción de una llave única haciendo uso de una serie de reglas que aseguran que dicho identificador no se repita en todo el mundo, se hace uso de este estándar para definir identificadores únicos a lo largo de la transformación.

Transformaciones

Se inician las transformaciones en el programa tradicional en C++ con el que ya se cuenta, este programa se transformara de manera tal que recibirá, atenderá y procesara peticiones, las cuales contendrán datos, es decir, contendrán parámetros que el programa utilizara, este programa tradicional se convertirá en el programa ”Servidor deberá modificarse para recibir cuatro parámetros de entrada por parte del cliente, na, nb, fa y fb.

Programa Servidor

Se ha utilizado una libreria sencilla llamada getpost.h la cual sirve de ayuda en el procesamiento de datos en las peticiones que recibirá el programa Servidor, también se ha utilizado Cajun como herramienta de regeneración y creación de objetos JSON. Para iniciar se agrega la cabecera de las librerías para poder utilizarlas en el desarrollo actual.

#include "getpost.h"
#include "json/reader.h"
#include "json/writer.h"
#include "json/elements.h"

A continuación se modifica el método main para utilizar Getpost, recuperar los datos de la petición y utilizarlos en variables locales.

  map <string,string> Post;
  initializePost(Post);   //notice that the variable are passed by reference!

Notese que se utiliza el método InitializePost(Post); en donde Post es el tipo de petición que se estará esperando del lado del servidor, después, se establece que el resultado de nuestro desarrollo actual estará en formato JSON, es decir, que la nueva aplicación servidor utilizara un objeto JSON para responder a las peticiones.

cout << "content-type: application/json" << endl << endl;

Y finalmente se define la manera de extraer la información de la petición para utilizarla en el programa servidor utilizando el método ”find” de la librería.

  string userData;
  string message = "";
  if (Post.find("UserData") != Post.end())
  {
     userData = Post["UserData"].c_str();
  } else
  {
     ReturnError("Some requiered parameters were not provided, try again. <br />");
     return 1;
  }

Con este código ya se cuenta con un objeto JSON que esta asignado a la variable userData y que proviene de la petición POST del programa cliente, el siguiente paso sera el de extraer y regenerar el objeto JSON utilizando Cajun como se muestra a continuación.

  Object objDocument;
  try
   {
      std::istringstream jsonData(userData);
      Reader::Read(objDocument, jsonData);

  String jsonNa = objDocument["Na"];
  String jsonNb = objDocument["Nb"];
  String jsonFa = objDocument["Fa"];
  String jsonFb = objDocument["Fb"];

  double na, nb, fa, fb;
  na = atof(jsonNa.Value().c_str());  //na        = 2.3495;
  nb = atof(jsonNb.Value().c_str());  //nb        = 1.4595;
  fa = atof(jsonFa.Value().c_str());  //fa        = 0.5;
  fb = atof(jsonFb.Value().c_str());  //fb        = 0.5;

Notese como utilizando el Reader de Cajun se lee el objeto y automáticamente se deserializa y se regenera en un objeto document de Cajun para después asignar ahora si a variables locales los valores enviados desde el cliente.

Una vez que se tienen las variables locales definidas con los valores que el cliente ha enviado, el proceso de calculo de la ecuación en el programa tradicional ocurre y no hay ninguna modificacion o transformación necesaria en este código, diciéndolo de otra manera, todo el código que hace las operaciones importantes de calculo, resolución de ecuaciones u otro tipo de operacaciones complejas prácticamente NO se modifica a lo largo de la transformación por lo que el tiempo invertido de desarrollo de la funcionalidad clave de la aplicación permanece siendo el mismo.

Uno de los cambios no menos importante en cuestiones de transformaciones a soluciones en linea es la concurrencia, la concurrencia se refiere a múltiples procesos accediendo a un mismo recurso, pueden surgir problemas de concurrencia debido a que en aplicaciones en linea existen una cantidad indefinida de programas clientes accesando simultáneamente a un mismo programa servidor y este atendiendo peticiones de todos estos programas cliente, por lo que si no se tiene esto presente al momento de hacer la transformación podrían aparecer problemas como por ejemplo el tratar de escribir simultáneamente un mismo archivo al mismo tiempo, o el tratar de grabar al mismo tiempo en una columna de la misma fila de una tabla en una base de datos, entre otros.

En el caso de esta transformación se debe tener en cuenta que el programa tradicional genera datos los cuales son escritos a disco en forma de un archivo ASCII, el nombre del archivo siempre es el mismo actualmente por lo que existen riesgos de concurrencia conforme vaya aumentando el numero de clientes que accesan al programa servidor simultáneamente, para solucionar esto se necesita idear una forma creativa para prevenir riesgos de este tipo por lo que se opta por generar un nombre de archivo ÚNICO el cual cada petición independiente utilizara sin ningún riesgo de acceso por parte de otra petición, para concretar esta idea se hará uso del estándar UUID para generar identificadores únicos que serán utilizados como los nombres de los archivos de datos para mitigar el riesgo de concurrencia.

La técnica utilizada para hacer uso del estándar UUID es haciendo uso de la herramienta de linux llamada “uuidgen” que se encarga de construir y regresar como resultado un nuevo identificador UUID, para poder establecer comunicación con la consola de linux y hacer uso de esta valiosa herramienta en linea, habrá que utilizar un código especial que ejecute comandos de la consola de linux y recupere los resultados como se muestra a continuación.

Primero agregamos la definición a la función que se definió para ejecutar comandos de la siguiente forma.

std::string exec(char* cmd);

Para despues agregar la funcion que hace el trabajo de ejecutar el comando.

std::string exec(char* cmd)
{
    FILE* pipe = popen(cmd, "r");
    if (!pipe)
        return "ERROR";

    char buffer[128];
    std::string result = "";
    while(!feof(pipe))
    {
        if(fgets(buffer, 128, pipe) != NULL)
                result += buffer;
    }

    pclose(pipe);
    result.erase(std::remove(result.begin(), result.end(), '\n'), result.end()); // remove carriage return (new lines)
    return result;
}

Y para finalizar agregamos el código que llama a la función a para pedir un nuevo UUID y utilizarlo como nombre de archivo de datos.

  // We must generate a unique ID for naming our data graph file
  char uuidgen[] = "uuidgen";
  string uuid = exec(uuidgen);

Otra cosa que se ha agregado en la transformación es que se ha definido una carpeta especial que contendrá todos los archivos de datos generados por nuestro programa servidor, la carpeta de datos lleva por nombre ”gnuplot” deberá estar ubicada en el ”Document Root”, a continuación se define el código para la ubicación de la carpeta y el nombre del archivo de datos generado.

  string gpFolder = "../gnuplot/";
  string gpDataFile =  uuid + ".dat";

A continuación y debido a que se estara utilizando el programa gnuplot como graficador en linea, se debe de crear un archivo con los comandos que gnuplot ejecutara de la siguiente manera.

  string gpCommandFile =  uuid + ".gnuplot";
  ofstream gpCommands;
  gpCommands.open((gpFolder + gpCommandFile).c_str());
  if(!gpCommands)
  {
    ReturnError("** Failed to create the graph file. <br />");
    return 1;
  }

  gpCommands << "set terminal png small" << "\n";
  gpCommands << "set title 'Graph by GnuPlot'" << "\n";
  gpCommands << "set nokey" << "\n";
  gpCommands << "plot '" << gpFolder << gpDataFile << "' u 3:1 w p" << "\n";
  gpCommands.close();

Y para finalizar se debe construir un objeto JSON que sera enviado de regreso al código que realizo la petición para informar de los resultados del procesamiento del programa servidor, este objeto debe de contener por definición lo siguiente:

1. Una cadena de error en caso de que haya ocurrido algún error en la ejecución
2. Una cadena de mensaje adicional que envía la aplicación servidor al cliente
3. El UUID único que se genero para el proceso de esta peticion independiente
4. Un enlace al archivo de datos generado por la aplicación servidor
5. Un enlace al archivo de comandos que gnuplot ejecuto en el proceso

  string linkToData = "<a href='/gnuplot/" + gpDataFile + "'>Download Data File</a><br />";
  string linkToCommands = "<a href='/gnuplot/" + gpCommandFile + "'>Download Command File</a><br />";
  message += "Calculations finished without errors. <br />";

  // this is the script response
  Object objResponse;
  objResponse["Error"] = String("");
  objResponse["Message"] = String(message.c_str());
  objResponse["GraphID"] = String(uuid.c_str());
  objResponse["LinkToData"] = String(linkToData.c_str());
  objResponse["LinkToCommands"] = String(linkToCommands.c_str());

  std::stringstream jsonStream;
  Writer::Write(objResponse, jsonStream);
  cout << jsonStream.str();

#!/usr/bin/perl -w
use strict;
use CGI qw(:standard);
use CGI::Pretty qw( :html3 );
use CGI::Carp qw(fatalsToBrowser);

# define some variables
my ( $gp_file ) = ( param('gp_id') );

unless ($gp_file)
{
  die "ERROR: gp_file parameter required";
}

plot();

# call gnuplot
sub plot
{
   print header("image/PNG");
   #my $graph = `gnuplot ../gnuplot/$gp_file.gnuplot`;
   print $graph;
}

<div id="divError" />

<div id="divDataContainer">
	<label>Na: </label>
	<input type='text' id='txtNa' maxlength="6" size="5" />
	<label>Nb: </label>
	<input type='text' id='txtNb' maxlength="6" size="5" />
	<label>Fa: </label>
	<input type='text' id='txtFa' maxlength="6" size="5" />
	<label>Fb: </label>
	<input type='text' id='txtFb' maxlength="6" size="5" />
</div>

<div id="divCopyright">
	&copy; 2011 Software developed by <a href="http://www.phoxonics.com">phoxonics</a>
</div>

<div id="divActions">
	<input type='button' value='Clear' id='btnClearData' />
	<input type='button' value='Process..' id='btnProcessData' />
</div>

<div id="divImageResult">
   <table>
      <tr><td><div id="divLinks" /></td></tr>
      <tr><td><img id="imgResult" /></td></tr>
   </table>
</div>

<div id="divStatus" />

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.5/jquery.min.js"></script>

<script type="text/javascript">
$(document).ready(function()
{
	$.ajaxSetup({
		  type: "POST",
		  async: true,
	      timeout: 5000,
	      contentType: "application/x-www-form-urlencoded; charset=utf-8",
		  data: "{}"
		});

/* Clear data */
    $("#btnClearData").click(function ()
	{
		$('#txtNa').val("");
		$('#txtNb').val("");
		$('#txtFa').val("");
		$('#txtFb').val("");

		$('#divStatus').empty();
		$('#divImageResult').empty();
	});

	/* Process data */
    $("#btnProcessData").click(function ()
	{
		if (!IsDataValid())
		{
			return false;
		}

		var data =
		{
		    'Na': $('#txtNa').val(),
		    'Nb': $('#txtNb').val(),
		    'Fa': $('#txtFa').val(),
		    'Fb': $('#txtFb').val()
		};

		$('#divStatus').empty();
		$('#divStatus').append("<br />Started ajax request..<br />");
		$.ajax({
		     type: "POST",
	        url:  "cgi-bin/BlackBoxWeb.cgi",
	        data: "UserData=" + JSON.stringify(data),
			  contentType: "application/json; charset=utf-8",
	        dataType: "json",
	        beforeSend: function (obj)
	        {
	        	$('#divStatus').append("Before send..<br />");
	        },
	        complete: function (obj, status)
	        {
	        	$('#divStatus').append("Completed..<br />");
	            if (status == "success")
	            {
	            	$('#divStatus').append("With success..<br />");
	            }
	        },
	        error: function (obj, status, obj2)
	        {
	        	$('#divStatus').append("Error calling server: " + obj + "-" + status + "<br />");
	        },
	        success: function(data)
	        {
            if (data.Error != "")
            {
				   $("#divError").css(color) = "red";
    	        	$("#divError").text(data.Error);
				   return false;
            }

	        	$("#divStatus").append(data.Message);
	        	$("#divLinks").append(data.LinkToData);
	        	$("#divLinks").append(data.LinkToCommands);			   

				var d = new Date();
				var cache = d.getTime();
				$('#imgResult').attr("src", "cgi-bin/gnuplot.pl?gp_id=" + data.GraphID + "&cache=" + cache);
	        }
		});
	});

 	/* Checks if we have a valid matrix */
	function IsDataValid()
	{
		var data =
		{
		    'Na': $('#txtNa').val(),
		    'Nb': $('#txtNb').val(),
		    'Fa': $('#txtFa').val(),
		    'Fb': $('#txtFb').val()
		};

		for (name in data)
		{
		    if (ValidateDecimal(data[name]) == false)
			{
		    	alert("The value for " + name + ": " + data[name] + " is not valid, please fix it and try again.");
		    	return false;
		    }
		}

		return true;
	}

	/* Validate decimal */
	function ValidateDecimal(str)
	{
    	str = alltrim(str);
    	return /^[-+]?[0-9]+(\.[0-9]+)?$/.test(str);
	}

	/* all trim */
	function alltrim(str)
	{
    	return str.replace(/^\s+|\s+$/g, '');
    }

});
</script>

#!/bin/bash
#
#  Compile the BLACKBOX solution.
#

# Compile C++ program
g++ BlackBoxWeb.cpp
if [ $? -ne 0 ]; then
  echo "Errors executing g++ -c BlackBox.cpp"
  exit
fi

# Rename the generated file to CGI
mv a.out BlackBoxWeb.cgi

# Clean logic
#rm BlackBoxWeb.o

echo "Ended script flow"

#  Terminate.
exit

$sudo chmod +x BlackBox.cgi

http://localhost/BlackBoxWeb.html

Conclusiones

Se ha presentado una forma sencilla de transformar desarrollos tradicionales en soluciones en linea, se incluyeron simples deniciones y conceptos que se utilizan en todo el proceso de transformacion de un programa para que funcione en un ambiente web, tambien, se presentaron instrucciones y comandos para congurar un ambiente web y toda la conguracion que esto implica.

Se detallaron tecnicas, estandares y paradigmas que deberian ser utilizados y tener en cuenta al momento de realizar una transformacion de este tipo, se describio la forma de evitar problemas en soluciones en linea y las diferencias principales entre una solucion tradicional y una solucion web, se presento una forma novedosa y creativa de gracar sin dejar de utilizar el software tradicional para este tipo de cuestiones y se incluyeron los detalles de la transformacion en forma de codigo fuente y la manera en que se hace uso de una gran variedad de tecnologias que interactuan entre si de manera estandar para lograr un n comun.

Al nal el usuario puede distinguir claramente entre una aplicacion tradicional y una aplicacion web, asi como de todo lo que implica el exponer la aplicacion tradicional a un ambiente en linea, tambien, el usuario ahora entiende las enormes ventajas de tener una solucion en linea y la posibilidad de atender multiples clientes simultaneamente por un programa servidor.

Enjoy!

Primero que nada quiero dar las gracias a mi asesor y amigo, el Dr. Jesus Manzanares Martinez por su post y sus felicitaciones, me considero afortunado de tener la oportunidad de contar con un asesor con tanto nivel intelectual, académico y humano que me guíe en los estudios de doctorado que actualmente estoy realizando,

Enseguida quiero replicar tal cual el post de el Dr. Manzanares ya que es algo que deberia quedar grabado tambien en este mi espacio,

¡Publican su primer artículo de doctorado!

Los entusiastas jugadores de ajedrez Damian Moctezuma Enriquez y Yohan Jasdid Viveros Rodriguez han publicado el primer artículo en su Doctorado en Nanotecnología que cursan en la Universidad de Sonora.

Cabe destacar que es un gran gusto felicitar a Yohan por este medio, ya que el fue el creador de nuestra querida pagina ”ajedrezensonora.com”.

El articulo ”Existence of a giant hypersonic elastic mirror in porous silicon superlattices” ha sido publicado en la prestigiosa  revista ”Applied Physics Letters”, la cual tiene un alto factor de impacto. Este factor de impacto seria un equivalente ajedrecístico al ”rating” de la publicación, y en esos términos, estaríamos hablando de niveles de ”gran maestro”. Sin lugar a dudas, este trabajo esta entre las cinco  publicaciones más importantes de la Universidad de Sonora en este 2011.

? Como podemos explicar el contenido de este articulo ? Mas propiamente, ?como nos gustaría contarle a un amigo ajedrecista como vemos este artículo ?.

Pues la cosa se puede contar  más o menos así. Un científico en Canadá publicó en el 2009  (en la misma revista) una serie de experimentos con los cuales demostraba que el podía construir unos ciertos materiales. Digamos que cada uno de estos materiales son materiales A, B, C, etc. Eureka!, con imaginación podemos pensar que cada uno de estos materiales son… ¡como piezas de ajedrez! Y si son piezas de ajedrez…, pues se pueden hacer combinaciones.

Pues la publicación es una cierta variante en donde combinamos piezas para hacer algo impresionante: un espejo perfecto para ondas elásticas.

Claro que ya metidos en nuestra perspectiva, aun nos quedan muchas cosas en el tintero. Muchas combinaciones por descubrir. Nuevas configuraciones que explorar. Muchas divertidas variantes por analizar…

Así que enhorabuena por este primer logro a nuestros aprendices de doctores en ciencia y les deseamos muchos mas éxitos.

Liga al preprint

Gracias de Nuevo!
Saludos!
Yohan

Te dedico este Poema:

EL DULCE SABOR DE UNA MUJER EXQUISITA

‘Una mujer exquisita no es aquella que más hombres tiene a sus pies, si no aquella que tiene uno solo que la hace realmente feliz.Una mujer hermosa no es la más joven, ni la más flaca, ni la que tiene el cutis más terso o el cabello más llamativo, es aquella que con tan sólo una franca y abierta sonrisa y un buen consejo puede alegrarte la vida.

Una mujer valiosa no es aquella que tiene más títulos, ni más cargos académicos, es aquella que sacrifica su sueño temporalmente por hacer felices a los demás.

Una mujer exquisita no es la más ardiente (aunque si me preguntan a mí, todas las mujeres son muy ardientes…Los que estamos fuera de foco somos los hombres)

Una mujer interesante no es aquella que se siente halagada al ser admirada por su belleza y elegancia, es aquella mujer firme de carácter que puede decir NO.

Y un HOMBRE……..UN HOMBRE EXQUISITO es aquel que valora a una mujer así………….. Que se siente orgulloso de tenerla como compañera…. Que sabe tocarla como un músico virtuosísimo toca su amado instrumento… Que lucha a su lado compartiendo todos sus roles, desde lavar platos y atender tripones, hasta devolverle los masajes y cuidados que ella le prodigó antes…

La verdad, compañeros hombres, es que las mujeres en eso de ser ‘Muy machas’ nos llevan gran recorrido… ¡Qué tontos hemos sido -y somos- cuando valoramos el regalo solamente por la vistosidad de su empaque…

¡Tonto y mil veces tonto el hombre que come basura en la calle, teniendo un exquisito manjar en casa’.

Por ultimo pongo unas fotos de nuestra velada, me gusto mucho como la pasamos, con la música, el delicioso sabor de un corte fino y por supuesto con tu compania

F  E  L  I  C  I  D  A  D  E  S !!!

TE AMO!

Introduccion

A medida que la tecnología avanza, nuevos lenguajes de programación han aparecido en el mercado, se han popularizado los lenguajes de alto nivel debido a que las grandes empresas han hecho disponible una cantidad muy grande de librerías y frameworks para facilitar el desarrollo en aplicaciones de media complejidad en donde solo se requiere la manipulación de datos y reglas de negocio sencillas, este no ha sido el caso de las aplicaciones cientificas y matemáticas debido a la gran demanda de recursos de procesamiento que este tipo de aplicaciones requieren. Teniendo esto en cuenta y pensando en las bondades que Fortran ofrece para aplicaciones de tipo cientifico, un gran numero de personas entre cientificos, investigadores, matemáticos, académicos entre otros han adoptado el lenguaje de programación Fortran como su lenguaje primario para aplicaciones que resuelven problemas matemáticos complejos y que requieren una gran cantidad de procesamiento, muchas de estas aplicaciones se han hecho disponibles para resolver cuestiones complejas y han sido probadas a lo largo de los anos por lo que se tiene la confianza de que son rutinas robustas y que proveen al usuario con los resultados deseados.

Es de ahí de donde surge la necesidad de buscar la manera de invocar rutinas de Fortran desde C++, C++ se ha convertido en un lenguaje de programacion que puede combinar aspectos tanto de alto nivel como de bajo nivel, es un lenguaje muy flexible y poderoso el cual también soporta el paradigma de la programación orientada a objetos lo que lo hace mas atractivo para desarrollos modernos.

Con la comunicación de los lenguajes C++ y Fortran, se logra proveer al usuario con los resultados y las capacidades de ambos mundos, sin contar con que se agiliza el tiempo de desarrollo ya que se vuelve innecesario re programar las subrutinas ya hechas en Fortran, se promueve la reutilizacion de código y se aprovecha mejor las inversiones de desarrollo que ya se hicieron en ese lenguaje.

Limitaciones

Hay cuestiones que se deben tener en cuenta al momento de tratar de invocar un lenguaje desde otro lenguaje, las grandes limitaciones que impiden que esto sea posible se enlistan a continuación:

1. Manejo de Interrupciones
2. Manejo de Entradas / Salidas
3. Manejo de memoria asignada dinamicamente

Estas cuestiones solo las podrá contener uno de los dos programas que se van a enlazar debido a la naturaleza de ellas, pero afortunadamente la mayoria de las subrutinas o librerías disponibles en el mercado cuentan con un muy buen diseño por lo que los puntos anteriores no son un problema, un gran numero de rutinas numéricas y de resolución de ecuaciones integran un buen diseño en sus estructuras lo que las hace altamente re utilizables tanto desde un mismo lenguaje como desde lenguajes externos.

Algunas Diferencias entre C++ y Fortran

A continuación se muestran algunas diferencias entre lenguajes C++ y Fortran asi como también la manera correcta de manejar estas diferencias para poder tener éxito invocando un lenguaje desde otro.

• Parámetros: Una de las grandes diferencias a tener en cuenta cuando se quiere construir una interface entre C++ y Fortran es que C++ pasa los parámetros comunes por valor en donde Fortran pasa dichos parámetros por Referencia esto significa que al momento de definir las subrutinas que serán llamadas desde C++ habrá que definir y pasarle a las rutinas de Fortran los parámetros por Referencia para que estas puedan funcionar, pasar un parámetro por referencia significa pasar la dirección de memoria donde este parámetro se encuentra localizado en vez del valor del parámetro como C++ lo hace por defecto.
• Nombre de la Subrutina: Otro de los aspectos a tener en cuenta en la construcción de la interface C++-Fortran son los nombres de las subrutinas, una de las cuestiones que el compilador de fortran realiza al momento de generar los objetos a partir del código fuente es que agrega un guion bajo a todas las subrutinas, esto se tiene que tener presente ya que al momento de definir la subrutina de Fortran que sera invocada se tendrá que concatenar un guion bajo a la subrutina ya que de otra forma C++ no sera capaz de llamar la subrutina ya que en el proceso de compilación /’esta cambio de nombre.
• Tipo de Datos: Los tipos de datos en C++ y Fortran NO son similares, por lo que se tendrá que encontrar el tipo de datos equivalente de C++ cuando se llama una subrutina de Fortran, esto se refiere a que si los tipos de datos no concuerdan en capacidad habra errores al momento de hacer el llamado desde C++ a Fortran, en la siguiente sección se incluye una tabla de equivalencias de tipos de datos entre C++ y Fortran esta sera sumamente necesaria para definir las subrutinas Fortran que serán invocadas.
• Orden en Arreglos: Es importante notar que el orden en que se almacenan los valores en los arreglos cambia de acuerdo al lenguaje que se este utilizando, pero esto se puede manejar de manera sencilla cambiando en orden de las posiciones del arreglo, es decir Arr(i,j) en Fortran seria en C++ algo similar a Arr[j][i].
• Indice en Arreglos: Es importante recordar que los indices de los arreglos y matrices en Fortran empiezan con el uno a diferencia de C++ el cual empieza con el cero, es decir, que si en Fortran se dene una matriz de una longitud de n elementos entonces los indices de dicha matriz irán de 1 a n a diferencia de C++ en donde los indices serian de 0 a n-1.

extern

extern es una palabra reservada de C++ la cual nos permite hacer uso de rutinas definidas en otros lenguajes, el requerimiento mas importante para a utilización de rutinas escritas en diferentes lenguajes es que se defina la función que se va a utilizar con la palabra reservada “extern”, de esta forma el compilador (conoce) el tipo de datos que va a enviar a la funcion externa.

Ejemplo, C++ llama a Fortran

El ejemplo sencillo que se expondrá a continuación consiste en llamar a una rutina bien conocida de Fortran la cual se encarga de calcular los eigenvalores de una matriz dada, lo interesante de este ejemplo es que se estará llamando a dicha rutina desde un programa hecho en C++ y se mostrara la manera de hacer el enlace entre los dos lenguajes, a continuación se enlista la definición del encabezado para la subrutina de Fortran.

subroutine cg(nm,n,ar,ai,wr,wi,matz,zr,zi,fv1,fv2,fv3,ierr)
c
      integer n,nm,is1,is2,ierr,matz
      double precision ar(nm,n),ai(nm,n),wr(n),wi(n),zr(nm,n),zi(nm,n),
     x       fv1(n),fv2(n),fv3(n)
c
c     this subroutine calls the recommended sequence of
c     subroutines from the eigensystem subroutine package (eispack)
c     to find the eigenvalues and eigenvectors (if desired)
c     of a complex general matrix.

c
c ... omitido por simplicidad
c

Una vez que se tiene la subrutina a llamar de fortran y de acuerdo a la tabla de equivalencias que se definió en la parte de arriba, se utiliza la palabra clave extern para declarar esta función desde dentro de la rutina C++ como se muestra a continuación.

//  Interfaces to FORTRAN77 routines.
//  The names now have underscores appended, and
//  scalar parameters are passed by reference.
//  The EXTERN statement used here stops C++ from "name mangling", which
//  would have destroyed the correspondence between the symbolic names
//  of the subroutines as recorded in the C++ and FORTRAN77 compiled codes.
//
extern "C" {
  void cg_ (int *nr, int *nc, double ar[CONST_ROWS][CONST_COLS], double ai[CONST_ROWS][CONST_COLS], double wr[],
    double wi[], int *flag, double zr[CONST_ROWS][CONST_COLS], double zi[CONST_ROWS][CONST_COLS], double fv1[],
    double fv2[], double fv3[], int *ierr);
}

Utilizando la tabla de equivalencia de tipos se determinan los tipos de cada parámetro que la subrutina de Fortran esta esperando a su similar en C++ y tomando en cuenta las reglas para poder hacer el llamado se define el tipo de datos y en caso de ser escalar se define que se pasara por referencia y no por valor ya que el comportamiento de fortran es manejar referencias en vez de valores, también, notese como se le ha agregado un guion bajo al nombre de la subrutina de fortran en la definición extern, esto debido a que el compilador Fortran como se ha mencionado anteriormente al momento de compilar y generar el objeto le agrega de forma automática este tipo de prefijo al nombre de la subrutina por lo que es necesario para que el compilador C++ pueda comunicarse con Fortran.

A continuación se muestra como se construye una matriz y se pasa a fortran tomando en cuenta los indices así como el orden en que se pasa la matriz, se muestra como enviar parámetros escalares por referencia, y la manera de hacer el llamado a nuestra función extern para obtener un resultado.

int main ( )
{
  cout << "content-type: text/html" << endl << endl;
  cout << "<html><body>" << endl;
  cout << "<h1>*** Program that calls a Fortran subroutine ***</h1>" << endl << endl;  

  int ierr, flag, i, j;
  flag = 0;              // no need extra results from [cg_] fortran subroutine 

  double ar[ROWS][COLS], ai[ROWS][COLS], zr[ROWS][COLS], zi[ROWS][COLS];
  double wr[ROWS], wi[ROWS];
  double fv1[ROWS], fv2[ROWS], fv3[ROWS];

  for (i = 0; i < ROWS; i++)
  {
    for (j = 0; j < COLS; j++)
    {
      ar[j][i] = (i + 1) + (j + 1);  // (+1) this is because of fortran indexes changes
      ai[j][i] = 0.0;
      zr[j][i] = 0.0;
      zi[j][i] = 0.0;
    }
  }

  // print matrix
  cout << "+ Matrix to pass to Fortran" << "<br />";
  cout << "<p>";
  for (i = 0; i < ROWS; i++)
  {
    for (j = 0; j < COLS; j++)
    {
      cout << ar[i][j] << "  ";
    }
    cout << "<br />";
  }
  cout << "</p>";

  cout << "EIGEN BlackBox:" << "<br />";
  cout << "  Combination C++ and FORTRAN77 version." << "<br />";
  cout << "  Demonstrate how a C++ main program can call" << "<br />";
  cout << "  a FORTRAN77 library." << "<br />";

  int rows, cols;  // we have to pass the COLS and ROWS by reference to fortran
  rows = ROWS;
  cols = COLS;

  cg_ (&rows, &cols, ar, ai, wr, wi, &flag, zr, zi, fv1, fv2, fv3, &ierr);

  // results
  cout << "<br />";
  cout << "Results: " << "<br />" << wr[0] << "<br />" <<  wr[1] << "<br />" << wr[2] << "<br />" << wr[3] << "<br />";

  cout << "<br />";
  cout << "EIGEN BlackBox: " << "<br />";
  cout << "  Normal end of execution. " << "<br />";
  cout << "<br />";

  cout << "</body></html>" << "<br />";
  return 0;
}

Como se puede observar en el ejemplo, los resultados calculados de la función son accesibles a través de el vector wr, los cuales son mostrados en pantalla al finalizar la ejecución del programa, en el siguiente listado se muestran los comandos que se tienen que ejecutar para compilar y hacer el enlace de los programas C++ y Fortran y la manera de ejecutar la solución final.

#!/bin/bash
#
#  Compile the FORTRAN90 library.
#
gfortran -c eigen_f.f
if [ $? -ne 0 ]; then
  echo "Errors executing gfortran -c eigen_f.f"
  exit
fi
#
#  Compile the C++ main program.
#
g++ -c eigen_c_cgi.cpp
if [ $? -ne 0 ]; then
  echo "Errors executing g++ -c eigen_c.C"
  exit
fi
#
#  Link the main program and library.
#  OR, you can use the G++ command to link,
#  if you include the -lgfortran library,
#
g++ eigen_c_cgi.o eigen_f.o -lgfortran
if [ $? -ne 0 ]; then
  echo "Errors executing gcc -c eigen_c.c"
  exit
fi
#
#  Run the program.
#
mv a.out eigen_c_cgi.cgi
#./eigen_c_cgi > eigen_c_cgi_output.txt
#
#  Clean up.
#
rm eigen_f.o
rm eigen_c_cgi.o
rm eigen_c_cgi
echo "Test output written to eigen_c_cgi_output.txt"
#
#  Terminate.
#
exit

Como se puede observar en el script anterior, el primer paso a dar sera el de compilar la librería Fortran a la que se quiere acceder, a continuacion se debe compilar el programa principal el cual llamara a su vez a la rutina Fortran para finalmente hacer el enlace entre los programas compilados de de Fortran y C++ utilizando para esto el compilador g++, una vez que se tiene un resultado del enlace anterior este se re nombra y ejecuta y los resultados de la ejecución son enviados a un archivo de texto para mayor comodidad, por ultimo se borran los objetos generados en el proceso se imprime una etiqueta final y el script queda listo para otra ejecución si fuese necesaria.

Para compilar, linkear y ejecutar el programa solo se deben ejecutar el script bash con los siguientes comandos, (el primero le da permiso de ejecucion al archivo).

chmod +x eigenfunc.sh
sh eigenfunc.sh

Y a continuación se enlistan los resultados de la ejecución.

Started ajax request..
Before send..

+ Matrix to pass to Fortran
2   3   4   5
3   4   5   6
4   5   6   7
5   6   7   8   

EIGEN BlackBox:
Combination C++ and FORTRAN77 version.
Demonstrate how a C++ main program can call
a FORTRAN77 library.

Matrix Eigenvalues:
20.9545
-0.954451
-8.14465e-17
-8.14465e-17

Matrix Reduced Frequency Eigenvalues:
7.28546
nan
nan
nan

EIGEN BlackBox:
Normal end of execution. 

Completed..
With success..

Conclusiones

En esta sección se ha presentado una forma sencilla de hacer una relacion entre C++ y Fortran para hacer posible el compartir lógica entre ambos lenguajes, con esto, se ha logrado el tener una alternativa para cuando se quieren aprovechar rutinas tanto matemáticas como científicas así como librerías desarrolladas por terceros en un lenguaje y utilizarlas desde otro.

Cabe mencionar que este procedimiento es similar y aplicable a otros lenguajes con pocas modificaciones, lo que tal vez se exponga en un apartado futuro, también, cabe mencionar que en futuros apartados se describirá cuales son las ventajas de utilizar Fortran frente a C++ en cierto tipo de desarrollos y aprovechar esas bondades por medio del enlace de estos lenguajes.

Existen tres tipos de fuentes en Meep que se enlistan a continuación:

• Fuente Continua: Se refiere a una onda continua puede ser prendida o apagada y tiene propiedades como frecuencia, tiempo de inicio, tiempo final y ancho.
• Fuente Gaussiana: Un pulso gaussiano que basicamente es el derivado en el tiempo de la función gaussiana, tiene propiedades como la frecuencia, el ancho, el tiempo de inicio y el numero de corte.
• Fuente Custom: Es donde el usuario especifica una función como fuente y tiene propiedades como tiempo de inicio y tiempo final.

A continuación se enlistan los cambios necesarios para agregar una fuente continua y al mismo tiempo utilizando la figura geométrica de la punta para ver el comportamiento y la tendencia de la onda,

Primero que nada se declara la fuente continua para lo cual se define la frecuencia, el ancho, el tiempo de inicio y el tiempo final, el código correspondiente se enlista a continuación:

	double freq = 0.5, fwidth = 0.5;
	double start_time = 0, end_time = 100;
	continuous_src_time src(freq, fwidth, start_time, end_time);

Una vez que se tiene declarada la fuente continua con todos sus parámetros, se procede a agregar la fuente a la clase field que contiene la estructura general en donde a su vez contiene la malla y la función para la geometría, para agregar la fuente en forma de punto en el componente Ez se utiliza el siguiente código:

	field.add_point_source(Ez, src, vec(2, -4.5));

En la declaración se define el componente, en este caso Ez, a continuación la fuente continua que ya se había declarado y para finalizar se define un punto en donde la fuente vivirá por medio de un vector.

A continuación se define el archivo HDF5 en donde se guardaran todos los datos para después generar imágenes o videos a partir de los datos,  la manera en que Meep funciona es que utiliza todo un mecanismo interno para por medio de una serie de herramientas generar datos en formato HDF5, dichos datos contienen el epsilon de cada material en cada punto de la malla, dichos datos y por medio de algunas utilerias del MIT son convertidos a distintos formatos para volverse gráficos, a continuación se enlista el código para definir un archivo personalizado de HDF5 por medio de la librería de Meep:

	h5file *h5_file = field.open_h5file("ez", h5file::WRITE, "", true);

Los parámetros que se definen para crear y abrir el archivo en formato HDF5 son: primero el nombre del archivo, el modo en que el archivo se abrirá, un prefijo para el archivo y si se define un identificador de tiempo.

A continuación se define el ciclo de tiempo que generara los datos HDF5 y la forma en que se guardan en el archivo que se acaba de crear:

	while (field.time() < field.last_source_time())
	{
		field.output_hdf5(Ez, grid_vol.surroundings(), h5_file, true, false, "");
		field.step();
	}

El ciclo básicamente le dice a la clase field que haga pequeños pasos por default de .1 en C++ desde el tiempo de inicio de la simulación definido y hasta el tiempo final, dentro del ciclo se define un output en donde se especifica el componente, el volumen, el archivo que se acaba de crear en modo de escritura, una bandera para definir si se agregan los datos o se crean un archivo HDF5 cada vez, si se tendrá soporte de precisión y por ultimo algún prefijo deseado.

A continuación se enlista el código de la simulación completo:

#include <meep.hpp>
#include <iostream>
using namespace meep;

double PuntaObject(const vec &p)
{
    if ((p.x() >= 0 && p.x() <= 4) && (p.y() >= -4 && p.y() <= 8))
    {
    	if (p.x() == 2 && p.y() == 4)
    		return 1.0;

    	// define area for end point
    	if (p.y() >= 4)
    	{
        	if (p.x() <= (p.y()/2)-2)
        		return 1.0;

        	if (p.x() >= (p.y()/2)-(p.y()-6))
        		return 1.0;
    	}

    	return 8.0;
    }
    return 1.0;
}

int main(int argc, char **argv)
{
    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep
    double resolution = 10;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 30 + pml_thickness;
    const double y = 30 + pml_thickness;

	grid_volume grid_vol = vol2d(x, y, resolution);  // 30x30 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

	structure strct(grid_vol, PuntaObject, pml(pml_thickness));  // structure punta
	fields field(&strct);
	field.use_real_fields();     // this is for optimization purposes
	field.output_hdf5(Dielectric, grid_vol.surroundings());

	double freq = 0.5, fwidth = 0.5;
	double start_time = 0, end_time = 100;
	continuous_src_time src(freq, fwidth, start_time, end_time);
	field.add_point_source(Ez, src, vec(2, -4.5));

	h5file *h5_file = field.open_h5file("ez", h5file::WRITE, "", true);
	while (field.time() < field.last_source_time())
	{
		field.output_hdf5(Ez, grid_vol.surroundings(), h5_file, true, false, "");
		field.step();
	}
	return 0;
}

Para ejecutar la simulación anterior es necesario crear un shell script en donde se especifican algunos paquetes que ayudaran en la conversión de datos en formato HDF5 a formato de imagen asi como tambien hara todo el compilado del codigo anterior y la generacion de la animacion para obtener los resultados deseados, para el caso anterior y suponiendo que el programa se llama _punta.cpp se crea el siguiente archivo bash:

make _punta.dac
./_punta.dac

h5ls eps-000000.00.h5
h5ls ez-000000.00.h5
h5topng -Zc dkbluered eps-000000.00.h5
h5topng -t 0:1999 -R -Zc dkbluered -a yarg -A eps-000000.00.h5 ez-000000.00.h5
convert ez-000000.00.t*.png ez-000000.00.mpg

rm eps-000000.00.h5
rm ez-000000.00.h5
rm _punta.dac
rm ez-000000.00.t*.png

El shell script anterior compila el programa C++ mediante la instrucción make y crea un archivo de ejecución con extensión “.dac” la cual se ejecuta en la siguiente instrucción, a continuación se utiliza un comando propio de el paquete h5utils desarrollado también por el MIT, el comando h5ls enlista el tamaño del dataset creado que vive en el archivo con extensión H5 y en formato HDF5 este enlistado es solamente con fines informativos, a continuación se ejecuta el comando h5topng el cual como describe su nombre hace una conversión de los datos en formato HDF5 a una imagen en formato PNG,

Despues, se utilizan los datos de la geometría asi como los datos de el campo generado para generar una serie de archivos en formato PNG que representan una imagen en el tiempo en cada uno de los pasos de la simulación, después se utiliza un paquete llamado ImageMagick para convertir la serie de imágenes creadas en formato de video y se finaliza removiendo archivos que ya no serán utilizados al final de la simulación ya que lo que nos interesa por ahora es el video.

Para concluir con la ejecución del programa Meep creado, se debe ejecutar el shell script que hara todo el trabajo de escribir todos esos comandos por nosotros con la siguiente instrucción, suponiendo que nuestro script se llame _punta.sh.

chmod +x _punta.sh
sh _punta.sh

Listo!, el video resultante de la simulacion anterior se enlista a continuacion:

http://www.youtube.com/watch?v=lSjUKYDrB-0

Enjoy!

Considere el siguiente diagrama:

La simulacion sencilla que se quiere lograr es simplemente dibujar una figura geométrica de una Punta en un plano X, Y, dicho plano X, Y representara el área de la malla en la que se estará trabajando, imagine que se quiere dibujar una Punta en el centro del plano, para proceder con dicha geometría se siguen los pasos sugeridos en el post anterior.

Primero que nada se inicializa la función MPI, esto es necesario aunque no se tenga contemplado hacer cálculos en paralelo

    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep

Después, se definen algunas variables de resolucion y se define que que se utilizara un PML para el área de frontera de la malla, en esta simulación no es necesario hacer esto pero de todas formas se definirá ya que en la mayoría de las simulaciones se necesitara una condición de frontera que absorba las ondas electromagnéticas

    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 40 + pml_thickness;
    const double y = 20 + pml_thickness;

Después, se crea el Volumen que contiene el tamaño de la malla y la resolución y se especifica que el origen de la malla sera exactamente en el centro, esto se tiene que definir de esta forma ya que en C++ el origen por default de la malla se encuentra ubicado en a partir de la parte positiva del plano, es decir, la coordenada 0,0 estará en la esquina izquierda inferior.

	grid_volume grid_vol = vol2d(x, y, resolution);  // 40x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

Después, se define la estructura en donde se agrega una referencia al Volumen o malla que se ha creado, también se agrega una referencia con la función que define la geometría que se estará dibujando y por ultimo se le agrega el PML que se definió, esto con la finalidad de definir condiciones de frontera con un material de absorción perfecto aunque esto no es necesario en esta simulación se define por cuestiones ilustrativas ya que la mayoría de las simulaciones contendrán algun tipo de excitación en donde se requerirá contar con un material de absorción en los limites del volumen que nos de la ilusión de continuidad infinita en el campo electromagnético.

	structure struct_punta(grid_vol, PuntaObject, pml(pml_thickness));  // structure punta

Después, se define un Field que esta vinculado con la estructura y se agrega una instrucción de optimizacion, cabe mencionar que esta instrucción de optimizacion no esta dada por default en Meep C++ contrariamente a lo que ocurre con Scheme.

	fields field_punta(&struct_punta);
	field_punta.use_real_fields();     // this is for optimization purposes

Por ultimo, se define el nombre del archivo en estandard HDF5 a generar, es decir, el archivo en donde se escribiran todos los datos de la simulacion en el estandar H5, y se finaliza indicandole a Meep que escriba todos los datos de la simulacion en dicho archivo por medio del objeto Field.

	h5file *h5_file = field_punta.open_h5file("punta", h5file::WRITE, "", true);
	field_punta.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");

Una de las partes importantes de un programa Meep es la funcion en donde se definen las geometrias, en este caso la función se ve de la siguiente manera:

double PuntaObject(const vec &p)
{
    if ((p.x() >= 0 && p.x() <= 4) && (p.y() >= -4 && p.y() <= 8))
    {
    	if (p.x() == 2 && p.y() == 4)
    		return 0.0;

    	// define area for end point
    	if (p.y() >= 4)
    	{
        	if (p.x() <= (p.y()/2)-2)
        		return 0.0;

        	if (p.x() >= (p.y()/2)-(p.y()-6))
        		return 0.0;
    	}

    	return 12.0;
    }
    return 0.0;
}

La forma en que la función de la geometría trabaja es la siguiente: Meep hace un barrido internamente punto por punto en donde evalúa si dicho punto se encuentra en la ecuación que se define dentro de esta función, si el punto pertenece al rango de puntos dentro de la función Meep asignara un epsilon de material definido dentro de la condicional, de otra forma Meep asignara el epsilon de material que se le especifique al final de la función, con esta metodología se puede dibujar prácticamente cualquier cosa.

A continuación se enlista el código de la geometría completo:

/*
 * _punta.cpp
 *
 * In order to run a simulation using the MEEP C++ interface, the following steps are necessary:
 * initialize mpi(argc, argv); // do this even for non-MPI Meep
 * create a meep::volume
 * create a meep::structure using that volume
 * create a meep::fields object
 * add some kind of excitation.
 * time step the code. Of course, you'll have to create measurements and output whatever data
 * you are interested in as well.
 *
 *  Created on: Jul 22, 2011
 *      Author: ubuntu
 */

#include
#include
using namespace meep;

double PuntaObject(const vec &p)
{
    if ((p.x() >= 0 && p.x() <= 4) && (p.y() >= -4 && p.y() <= 8))
    {
    	if (p.x() == 2 && p.y() == 4)
    		return 0.0;

    	// define area for end point
    	if (p.y() >= 4)
    	{
        	if (p.x() <= (p.y()/2)-2)
        		return 0.0;

        	if (p.x() >= (p.y()/2)-(p.y()-6))
        		return 0.0;
    	}

    	return 12.0;
    }
    return 0.0;
}

int main(int argc, char **argv)
{
    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep
    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 40 + pml_thickness;
    const double y = 20 + pml_thickness;

	grid_volume grid_vol = vol2d(x, y, resolution);  // 40x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

	structure struct_punta(grid_vol, PuntaObject, pml(pml_thickness));  // structure punta
	fields field_punta(&struct_punta);
	field_punta.use_real_fields();     // this is for optimization purposes

	h5file *h5_file = field_punta.open_h5file("punta", h5file::WRITE, "", true);
	field_punta.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");
	return 0;
}

Para ejecutar la simulación anterior es necesario crear un shell script en donde se especifican algunos paquetes que ayudaran en la conversión de datos en formato HDF5 a formato de imagen asi como tambien hara todo el compilado del codigo anterior para obtener los resultados deseados, para el caso del bloque y suponiendo que nuestro programa se llama _bloque.cpp se crea el siguiente archivo bash:

make _punta.dac
./_punta.dac

h5ls punta-000000.00.h5
h5topng -Zc dkbluered punta-000000.00.h5

rm punta-000000.00.h5
rm _punta.dac

El shell script anterior compila el programa C++ mediante la instrucción make y crea un archivo de ejecución con extensión ”.dac” la cual se ejecuta en la siguiente instrucción, a continuación se utiliza un comando propio de el paquete h5utils desarrollado también por el MIT, el comando h5ls enlista el tamaño del dataset creado que vive en el archivo con extensión H5 y en formato HDF5 este enlistado es solamente con fines informativos, a continuación se ejecuta el comando h5topng el cual como describe su nombre hace una conversión de los datos en formato HDF5 a una imagen en formato PNG, y se finaliza removiendo archivos que ya no serán utilizados al final de la simulación ya que lo que nos interesa por ahora es la imagen.

Para concluir con la ejecución del programa Meep creado, se debe ejecutar el shell script que hara todo el trabajo de escribir todos esos comandos por nosotros con la siguiente instrucción, suponiendo que nuestro script se llame _punta.sh.

chmod +x _punta.sh
sh _punta.sh

Listo!, la simulacion nos arrojara el diagrama esperado que se anexa a continuacion:

Enjoy!

Considere el siguiente diagrama:

La simulacion sencilla que se quiere lograr es simplemente dibujar una figura geométrica de un rectángulo y cortarlo en un plano X, Y, dicho plano X, Y representara el área de la malla en la que se estará trabajando, imagine que se quiere dibujar un rectángulo con un corte en el centro del plano, para proceder con dicha geometría se siguen los pasos sugeridos en el post anterior.

Primero que nada se inicializa la función MPI, esto es necesario aunque no se tenga contemplado hacer cálculos en paralelo

    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep

Después, se definen algunas variables de resolucion y se define que que se utilizara un PML para el área de frontera de la malla, en esta simulación no es necesario hacer esto pero de todas formas se definirá ya que en la mayoría de las simulaciones se necesitara una condición de frontera que absorba las ondas electromagnéticas

    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 40 + pml_thickness;
    const double y = 20 + pml_thickness;

Después, se crea el Volumen que contiene el tamaño de la malla y la resolución y se especifica que el origen de la malla sera exactamente en el centro, esto se tiene que definir de esta forma ya que en C++ el origen por default de la malla se encuentra ubicado en a partir de la parte positiva del plano, es decir, la coordenada 0,0 estará en la esquina izquierda inferior.

	grid_volume grid_vol = vol2d(x, y, resolution);  // 40x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

Después, se define la estructura en donde se agrega una referencia al Volumen o malla que se ha creado, también se agrega una referencia con la función que define la geometría que se estará dibujando y por ultimo se le agrega el PML que se definió, esto con la finalidad de definir condiciones de frontera con un material de absorción perfecto aunque esto no es necesario en esta simulación se define por cuestiones ilustrativas ya que la mayoría de las simulaciones contendrán algun tipo de excitación en donde se requerirá contar con un material de absorción en los limites del volumen que nos de la ilusión de continuidad infinita en el campo electromagnético.

	structure struct_fiberend(grid_vol, FiberObject, pml(pml_thickness));  // structure fiber

Después, se define un Field que esta vinculado con la estructura y se agrega una instrucción de optimizacion, cabe mencionar que esta instrucción de optimizacion no esta dada por default en Meep C++ contrariamente a lo que ocurre con Scheme.

	fields field_fiberend(&struct_fiberend);
	field_fiberend.use_real_fields();     // this is for optimization purposes

Por ultimo, se define el nombre del archivo en estandard HDF5 a generar, es decir, el archivo en donde se escribiran todos los datos de la simulacion en el estandar H5, y se finaliza indicandole a Meep que escriba todos los datos de la simulacion en dicho archivo por medio del objeto Field.

	h5file *h5_file = field_fiberend.open_h5file("fiberend", h5file::WRITE, "", true);
	field_fiberend.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");

Una de las partes importantes de un programa Meep es la funcion en donde se definen las geometrias, en este caso la función se ve de la siguiente manera:

double FiberObject(const vec &p)
{
    if ((p.x() >= -10 && p.x() <= 10) && (p.y() >= 0 && p.y() <= 5))
    {
    	if (p.x() >= 5 && p.y() <= p.x()-5)
    		return 0.0;
    	else
    		return 12.0;
    }
    return 0.0;
}

La forma en que la función de la geometría trabaja es la siguiente: Meep hace un barrido internamente punto por punto en donde evalúa si dicho punto se encuentra en la ecuación que se define dentro de esta función, si el punto pertenece al rango de puntos dentro de la función Meep asignara un epsilon de material definido dentro de la condicional, de otra forma Meep asignara el epsilon de material que se le especifique al final de la función, con esta metodología se puede dibujar prácticamente cualquier cosa.

A continuación se enlista el código de la geometría completo:

/*
 * _fiberend.cpp
 *
 * In order to run a simulation using the MEEP C++ interface, the following steps are necessary:
 * initialize mpi(argc, argv); // do this even for non-MPI Meep
 * create a meep::volume
 * create a meep::structure using that volume
 * create a meep::fields object
 * add some kind of excitation.
 * time step the code. Of course, you'll have to create measurements and output whatever data
 * you are interested in as well.
 *
 *  Created on: Jul 22, 2011
 *      Author: ubuntu
 */

#include
#include
using namespace meep;

double FiberObject(const vec &p)
{
    if ((p.x() >= -10 && p.x() <= 10) && (p.y() >= 0 && p.y() <= 5))
    {
    	if (p.x() >= 5 && p.y() <= p.x()-5)
    		return 0.0;
    	else
    		return 12.0;
    }
    return 0.0;
}

int main(int argc, char **argv)
{
    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep
    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 40 + pml_thickness;
    const double y = 20 + pml_thickness;

	grid_volume grid_vol = vol2d(x, y, resolution);  // 40x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

	structure struct_fiberend(grid_vol, FiberObject, pml(pml_thickness));  // structure fiber
	fields field_fiberend(&struct_fiberend);
	field_fiberend.use_real_fields();     // this is for optimization purposes

	h5file *h5_file = field_fiberend.open_h5file("fiberend", h5file::WRITE, "", true);
	field_fiberend.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");
	return 0;
}

Para ejecutar la simulación anterior es necesario crear un shell script en donde se especifican algunos paquetes que ayudaran en la conversión de datos en formato HDF5 a formato de imagen asi como tambien hara todo el compilado del codigo anterior para obtener los resultados deseados, para el caso del bloque y suponiendo que nuestro programa se llama _bloque.cpp se crea el siguiente archivo bash:

make _fiberend.dac
./_fiberend.dac

h5ls fiberend-000000.00.h5
h5topng -Zc dkbluered fiberend-000000.00.h5

rm fiberend-000000.00.h5
rm _fiberend.dac

El shell script anterior compila el programa C++ mediante la instrucción make y crea un archivo de ejecución con extensión ”.dac” la cual se ejecuta en la siguiente instrucción, a continuación se utiliza un comando propio de el paquete h5utils desarrollado también por el MIT, el comando h5ls enlista el tamaño del dataset creado que vive en el archivo con extensión H5 y en formato HDF5 este enlistado es solamente con fines informativos, a continuación se ejecuta el comando h5topng el cual como describe su nombre hace una conversión de los datos en formato HDF5 a una imagen en formato PNG, y se finaliza removiendo archivos que ya no serán utilizados al final de la simulación ya que lo que nos interesa por ahora es la imagen.

Para concluir con la ejecución del programa Meep creado, se debe ejecutar el shell script que hara todo el trabajo de escribir todos esos comandos por nosotros con la siguiente instrucción, suponiendo que nuestro script se llame _fiberend.sh.

chmod +x _fiberend.sh
sh _fiberend.sh

Listo!, la simulacion nos arrojara el diagrama esperado que se anexa a continuacion:

Agregando unos poco cambios en la función de la geometría se puede obtener un triangulo facilmente:

double FiberObject(const vec &p)
{
    if ((p.x() >= -10 && p.x() <= 10) && (p.y() >= 0 && p.y() <= 5))
    {
    	if (p.x() >= 5 && p.y() <= p.x()-5)
    		return 12.0;
    	else
    		return 0.0;
    }
    return 0.0;
}

Y el resultado se vería de la siguiente manera:

Enjoy!

Considere el siguiente diagrama:

La simulacion sencilla que se quiere lograr es simplemente dibujar una figura geométrica de un cilindro en un plano X, Y, dicho plano X, Y representara el área de la malla en la que se estará trabajando, imagine que se quiere dibujar un cilindro en el centro del plano, para proceder con dicha geometría se siguen los pasos sugeridos en el post anterior.

Primero que nada se inicializa la función MPI, esto es necesario aunque no se tenga contemplado hacer cálculos en paralelo

    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep

Después, se definen algunas variables de resolucion y se define que que se utilizara un PML para el área de frontera de la malla, en esta simulación no es necesario hacer esto pero de todas formas se definirá ya que en la mayoría de las simulaciones se necesitara una condición de frontera que absorba las ondas electromagnéticas

    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 20 + pml_thickness;
    const double y = 20 + pml_thickness;

Después, se crea el Volumen que contiene el tamaño de la malla y la resolución y se especifica que el origen de la malla sera exactamente en el centro, esto se tiene que definir de esta forma ya que en C++ el origen por default de la malla se encuentra ubicado en a partir de la parte positiva del plano, es decir, la coordenada 0,0 estará en la esquina izquierda inferior.

	grid_volume grid_vol = vol2d(x, y, resolution);  // 20x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

Después, se define la estructura en donde se agrega una referencia al Volumen o malla que se ha creado, también se agrega una referencia con la función que define la geometría que se estará dibujando y por ultimo se le agrega el PML que se definió, esto con la finalidad de definir condiciones de frontera con un material de absorción perfecto aunque esto no es necesario en esta simulación se define por cuestiones ilustrativas ya que la mayoría de las simulaciones contendrán algun tipo de excitación en donde se requerirá contar con un material de absorción en los limites del volumen que nos de la ilusión de continuidad infinita en el campo electromagnético.

	structure struct_cylinder(grid_vol, Cylinder, pml(pml_thickness));  // structure cylinder

Después, se define un Field que esta vinculado con la estructura y se agrega una instrucción de optimizacion, cabe mencionar que esta instrucción de optimizacion no esta dada por default en Meep C++ contrariamente a lo que ocurre con Scheme.

	fields field_cylinder(&struct_cylinder);
	field_cylinder.use_real_fields();     // this is for optimization purposes

Por ultimo, se define el nombre del archivo en estandard HDF5 a generar, es decir, el archivo en donde se escribiran todos los datos de la simulacion en el estandar H5, y se finaliza indicandole a Meep que escriba todos los datos de la simulacion en dicho archivo por medio del objeto Field.

	h5file *h5_file = field_cylinder.open_h5file("cylinder", h5file::WRITE, "", true);
	field_cylinder.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");

Una de las partes importantes de un programa Meep es la funcion en donde se definen las geometrias, en este caso la función se ve de la siguiente manera:

double Cylinder(const vec &p)
{
	double width = 4.0;
	double x2 = p.x() * p.x();
	double y2 = p.y() * p.y();
	double r = sqrt(x2 + y2);

	if (r <= width)
		return 12.0;

	return 1.0;
}

La forma en que la función de la geometría trabaja es la siguiente: Meep hace un barrido internamente punto por punto en donde evalúa si dicho punto se encuentra en la ecuación que se define dentro de esta función, si el punto pertenece al rango de puntos dentro de la función Meep asignara un epsilon de material definido dentro de la condicional, de otra forma Meep asignara el epsilon de material que se le especifique al final de la función, con esta metodología se puede dibujar prácticamente cualquier cosa.

A continuación se enlista el código de la geometría completo:

/*
 * _cylinder.cpp
 *
 * In order to run a simulation using the MEEP C++ interface, the following steps are necessary:
 * initialize mpi(argc, argv); // do this even for non-MPI Meep
 * create a meep::volume
 * create a meep::structure using that volume
 * create a meep::fields object
 * add some kind of excitation.
 * time step the code. Of course, you'll have to create measurements and output whatever data
 * you are interested in as well.
 *
 *  Created on: Jul 22, 2011
 *      Author: yohan
 */

#include <meep.hpp>
#include <iostream>
using namespace meep;

double Cylinder(const vec &p)
{
	double width = 4.0;

	double x2 = p.x() * p.x();
	double y2 = p.y() * p.y();
	double r = sqrt(x2 + y2);

	if (r <= width)
		return 12.0;

	return 1.0;
}

int main(int argc, char **argv)
{
    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep
    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 20 + pml_thickness;
    const double y = 20 + pml_thickness;

	grid_volume grid_vol = vol2d(x, y, resolution);  // 20x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

	structure struct_cylinder(grid_vol, Cylinder, pml(pml_thickness));  // structure cylinder
	fields field_cylinder(&struct_cylinder);
	field_cylinder.use_real_fields();     // this is for optimization purposes

	h5file *h5_file = field_cylinder.open_h5file("cylinder", h5file::WRITE, "", true);
	field_cylinder.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");
	return 0;
}

Para ejecutar la simulación anterior es necesario crear un shell script en donde se especifican algunos paquetes que ayudaran en la conversión de datos en formato HDF5 a formato de imagen asi como tambien hara todo el compilado del codigo anterior para obtener los resultados deseados, para el caso del bloque y suponiendo que nuestro programa se llama _bloque.cpp se crea el siguiente archivo bash:

make _cylinder.dac
./_cylinder.dac

h5ls cylinder-000000.00.h5
h5topng -Zc dkbluered cylinder-000000.00.h5

rm cylinder-000000.00.h5
rm _cylinder.dac

El shell script anterior compila el programa C++ mediante la instrucción make y crea un archivo de ejecución con extensión ”.dac” la cual se ejecuta en la siguiente instrucción, a continuación se utiliza un comando propio de el paquete h5utils desarrollado también por el MIT, el comando h5ls enlista el tamaño del dataset creado que vive en el archivo con extensión H5 y en formato HDF5 este enlistado es solamente con fines informativos, a continuación se ejecuta el comando h5topng el cual como describe su nombre hace una conversión de los datos en formato HDF5 a una imagen en formato PNG, y se finaliza removiendo archivos que ya no serán utilizados al final de la simulación ya que lo que nos interesa por ahora es la imagen.

Para concluir con la ejecución del programa Meep creado, se debe ejecutar el shell script que hara todo el trabajo de escribir todos esos comandos por nosotros con la siguiente instrucción, suponiendo que nuestro script se llame _cylinder.sh.

chmod +x _cylinder.sh
sh _cylinder.sh

Listo!, la simulacion nos arrojara el diagrama esperado que se anexa a continuacion:

Agregando unos poco cambios en la función de la geometría se puede obtener un anillo facilmente:

double Cylinder(const vec &p)
{
	double width = 2.0;
	double inner_radius = 3.0;
	double outer_radius = inner_radius + width;

	double x2 = p.x() * p.x();
	double y2 = p.y() * p.y();
	double r = sqrt(x2 + y2);
	if ((r > inner_radius) && (r <= outer_radius))
		return 12;

	return 1.0;
}

Y el resultado se vería de la siguiente manera:

Enjoy!

Considere el siguiente diagrama:

La simulacion sencilla que se quiere lograr es simplemente dibujar una figura geométrica de un bloque en un plano X, Y, dicho plano X, Y representara el área de la malla en la que se estará trabajando, imagine que se quiere dibujar un bloque o cuadro de 2X2 en el centro del plano, para proceder con dicha geometría se siguen los pasos sugeridos en el post anterior.

Primero que nada se inicializa la función MPI, esto es necesario aunque no se tenga contemplado hacer cálculos en paralelo

    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep

Después, se definen algunas variables de resolucion y se define que que se utilizara un PML para el área de frontera de la malla, en esta simulación no es necesario hacer esto pero de todas formas se definirá ya que en la mayoría de las simulaciones se necesitara una condición de frontera que absorba las ondas electromagnéticas

    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 20 + pml_thickness;
    const double y = 20 + pml_thickness;

Después, se crea el Volumen que contiene el tamaño de la malla y la resolución y se especifica que el origen de nuestra malla sera exactamente en el centro, esto se tiene que definir de esta forma ya que en C++ el origen por default de la malla se encuentra ubicado en a partir de la parte positiva del plano, es decir, la coordenada 0,0 estará en la esquina izquierda inferior.

	grid_volume grid_vol = vol2d(x, y, resolution);  // 20x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

Después, se define la estructura en donde se agrega una referencia al Volumen o malla que se ha creado, también se agrega una referencia con la función que define la geometría que se estará dibujando y por ultimo se le agrega el PML que se definió, esto con la finalidad de definir condiciones de frontera con un material de absorción perfecto aunque esto no es necesario en esta simulación se define por cuestiones ilustrativas ya que la mayoría de las simulaciones contendrán algun tipo de excitación en donde se requerirá contar con un material de absorción en los limites del volumen que nos de la ilusión de continuidad infinita en el campo electromagnético.

	structure struct_block(grid_vol, Block, pml(pml_thickness));  // structure block

Después, se define un Field que esta vinculado con la estructura y se agrega una instrucción de optimizacion, cabe mencionar que esta instrucción de optimizacion no esta dada por default en Meep C++ contrariamente a lo que ocurre con Scheme.

	fields field_block(&struct_block);
	field_block.use_real_fields();     // this is for optimization purposes

Por ultimo, se define el nombre del archivo en estandard HDF5 a generar, es decir, el archivo en donde se escribiran todos los datos de la simulacion en el estandar H5, y se finaliza indicandole a Meep que escriba todos los datos de la simulacion en dicho archivo por medio del objeto Field.

	h5file *h5_file = field_block.open_h5file("block", h5file::WRITE, "", true);
	field_block.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");

Una de las partes importantes de un programa Meep es la funcion en donde se definen las geometrias, en este caso la función se ve de la siguiente manera:

double Block(const vec &p)
{
	if ((p.x() >= -2 && p.x() = -2 && p.y()
            return 6.0;
	return 1.0;
}

La forma en que la función de la geometría trabaja es la siguiente: Meep hace un barrido internamente punto por punto en donde evalúa si dicho punto se encuentra en la ecuación que se define dentro de esta función, si el punto pertenece al rango de puntos dentro de la función Meep asignara un epsilon de material definido dentro de la condicional, de otra forma Meep asignara el epsilon de material que se le especifique al final de la función, con esta metodología se puede dibujar prácticamente cualquier cosa.

A continuación se enlista el código de la geometría completo:

/*
 * _block.cpp
 *
 * In order to run a simulation using the MEEP C++ interface, the following steps are necessary:
 * initialize mpi(argc, argv); // do this even for non-MPI Meep
 * create a meep::volume
 * create a meep::structure using that volume
 * create a meep::fields object
 * add some kind of excitation.
 * time step the code. Of course, you'll have to create measurements and output whatever data
 * you are interested in as well.
 *
 *  Created on: Jul 22, 2011
 *      Author: yohan
 */

#include
#include
using namespace meep;

double Block(const vec &p)
{
	if ((p.x() >= -2 && p.x() = -2 && p.y()
          return 6.0;

	return 1.0;
}

int main(int argc, char **argv)
{
    meep::initialize mpi(argc, argv);   // Do this even for non-MPI Meep
    double resolution = 20;             // pixels per distance
    const double pml_thickness = 1.0;
    const double x = 20 + pml_thickness;
    const double y = 20 + pml_thickness;

	grid_volume grid_vol = vol2d(x, y, resolution);  // 20x20 2d cell
	grid_vol.center_origin();                        // set the origin as the center of cell

	structure struct_block(grid_vol, Block, pml(pml_thickness));  // structure block
	fields field_block(&struct_block);
	field_block.use_real_fields();     // this is for optimization purposes

	h5file *h5_file = field_block.open_h5file("block", h5file::WRITE, "", true);
	field_block.output_hdf5(Dielectric, grid_vol.surroundings(), h5_file, false, false, "");
	return 0;
}

Para ejecutar la simulación anterior es necesario crear un shell script en donde se especifican algunos paquetes que ayudaran en la conversión de datos en formato HDF5 a formato de imagen asi como tambien hara todo el compilado del codigo anterior para obtener los resultados deseados, para el caso del bloque y suponiendo que nuestro programa se llama _bloque.cpp se crea el siguiente archivo bash:

make _block.dac
./_block.dac

h5ls block-000000.00.h5
h5topng -Zc dkbluered block-000000.00.h5

rm block-000000.00.h5
rm _block.dac

El shell script anterior compila el programa C++ mediante la instrucción make y crea un archivo de ejecución con extensión ”.dac” la cual se ejecuta en la siguiente instrucción, a continuación se utiliza un comando propio de el paquete h5utils desarrollado también por el MIT, el comando h5ls enlista el tamaño del dataset creado que vive en el archivo con extensión H5 y en formato HDF5 este enlistado es solamente con fines informativos, a continuación se ejecuta el comando h5topng el cual como describe su nombre hace una conversión de los datos en formato HDF5 a una imagen en formato PNG, y se finaliza removiendo archivos que ya no serán utilizados al final de la simulación ya que lo que nos interesa por ahora es la imagen.

Para concluir con la ejecución del programa Meep creado, se debe ejecutar el shell script que hara todo el trabajo de escribir todos esos comandos por nosotros con la siguiente instrucción, suponiendo que nuestro script se llame _bloque.sh.

chmod +x _bloque.sh
sh _bloque.sh

Listo!, la simulacion nos arrojara el diagrama esperado que se anexa a continuacion:

Agregando una condicional en la función Block se puede fácilmente agregar un nuevo bloque en una coordenada distina a la inicial, el código se vería de esta forma:

double Block(const vec &p)
{
	if ((p.x() >= -2 && p.x() <= 2) && (p.y() >= -2 && p.y() <= 2))
		return 6.0;
	if ((p.x() >= -8 && p.x() <= -4) && (p.y() >= 5 && p.y() <= 9))
		return 6.0;

	return 1.0;
}

Y el resultado se vería de la siguiente manera:

Y por que no?? mejor agregamos 5 bloques solo por diversion!

double Block(const vec &p)
{
	if ((p.x() >= -2 && p.x() <= 2) && (p.y() >= -2 && p.y() <= 2))
		return 6.0;
	if ((p.x() >= -8 && p.x() <= -4) && (p.y() >= 5 && p.y() <= 9))
		return 6.0;
	if ((p.x() >= -8 && p.x() <= -4) && (p.y() >= -9 && p.y() <= -5))
		return 6.0;
	if ((p.x() >= 4 && p.x() <= 7) && (p.y() >= -9 && p.y() <= -5))
		return 6.0;
	if ((p.x() >= 4 && p.x() <= 7) && (p.y() >= 5 && p.y() <= 9))
		return 6.0;

	return 1.0;
}

Enjoy!

1. Inicializar la función de MPI, esto se tendra que hacer aunque no se este planeado paralelizar
2. Crear un Volume
3. Crear una Estructura utilizando el Volume creado
4. Agregar Fields utilizando la estructura creada
5. Agregar Fuentes, Flujos y Detectores
6. Correr la simulacion

Conceptos Fundamentales

Volume: El objeto Volume es un area tipo cuadrada en donde toda la simulación ocurrirá, existen dos tipos de Volumen, el Grid_Volume y en Volume la diferencia es que el Grid_Volume es un area de pixeles en donde se almacena la resolución, la cantidad de pixeles, el origen y el Volumen relacionado.

Structure: El objeto Structure contiene información estructural de la simulación como los valores dieléctricos en puntos específicos o información sobre la polarización , la estructura debe conocer ciertos valores como la resolución de la malla a utilizar etc.

Fields: Basicamente el objeto Fields es el que se encarga de la mayoria del trabajo y en donde toda la animacion se desarrolla, tambien es el encargado de generar todos los datos pertenecientes a la simulacion.

Fuentes: Existen diversas definiciones para las fuentes, entre ellas figuran la fuente gausiana, la fuente continua y la fuente puntual, generalmente las fuentes se utilizan utilizando el objeto Field y definiendo un tiempo sobre el cual se ejecutara dicha fuente.

Saltos de Tiempo: Generalmente los saltos de tiempo se definen automáticamente por Meep.

Condiciones de Frontera: Meep soporta PML (Perfectlty Matched Layer) que a grandes rasgos consta de un material perfecto que absorbe las ondas electromagneticas y sin ningun tipo de refleccion en todas las frecuencias y angulos, el PML da la ilusion de una condicion de propagacion perfecta del campo electromangetico fuera de las fronteras del Volumen de la malla.

En esta sección se han descrito algunos de los conceptos fundamentales para realizar simulaciones sencillas, este articulo se estará actualizando mientras se avance sobre el desarrollo de simulaciones mas complejas  y resulte la necesidad de definir mas conceptos.

No se hable mas y veamos algo de codigo.. a continuacion enlisto un programa sencillo, solamente para probar que se ejecuta correctamente utilizando Meep..

#include
using namespace meep;

int main(int argc, char **argv)
{
	initialize mpi(argc, argv);	// do this even for non-MPI Meep
	double resolution = 20;		// pixels per distance
	grid_volume v = vol2d(5,10, resolution);  // 5x10 2d cell
	structure s(v, eps, pml(1.0));
	fields f(&s);

	f.output_hdf5(Dielectric, v.surroundings());
	double freq = 0.3, fwidth = 0.1;
	gaussian_src_time src(freq, fwidth);
	f.add_point_source(Ey, src, vec(1.1, 2.3));
	while (f.time() < f.last_source_time())
	{
		f.step();
	}

	f.output_hdf5(Hz, v.surroundings());
	return 0;
}

double eps(const vec &p)
{
	if (p.x() < 2 && p.y() < 3)
		return 12.0;
	return 1.0;
}

Los pasos para ejecutar el programa anterior son los siguientes:

• Primero que nada se crea un archivo que se llame overview.cpp con el codigo C++ anterior
• Se navega al directorio del Meep que se ha bajado y compilado anteriormente, usualmente el directorio se llamara “meep-1.1.1″ ya que es la version actual de Meep
• Se navega a la carpeta tests y movemos el programa que hemos creado hacia esta carpeta
• A continuacion se enlista en programa overview.sh que es un shell script que tambien se debe colocar en la carpeta tests

make overview.dac
./overview.dac

h5ls eps-000000.00.h5
h5topng -Zc dkbluered eps-000000.00.h5

rm eps-000000.00.h5
rm overview.dac

• Por ultimo abrimos la consola en modo de “root” para despues ceder permisos de ejecucion al bash scripty ejecutarlo como se muestra a continuacion

su root
chmod +x overview.sh
sh overview.sh

Al final de la ejecucion de el script anterior deberiamos haber llegado al resultado que es la imagen que enseguida agrego en la parte de abajo, si se ha llegado a este punto significa que tenemos el ambiente idoneo para empezar a programar en C++ utilizando Meep, de otra forma se debera hacer una verificacion de todos los pasos anteriores hasta llagar a este resultado.

En este escrito se agregaron ciertos programas para verificar el correcto funcionamiento de la instalacion Meep, se utilizaron algunos comandos de la libreria del Meep para generar una imagen de la simulacion y se verifico que todo funcione como se esperaba, en los siguientes posts se estara viendo a detalle cada parte de la cual se constituye un programa de simulacion Meep utilizando C++,

Enjoy!

Saludos!

#########################################################################################################
### This package contains an informational list of packages which are
### considered essential for building Debian packages.  This package also
### depends on the packages on that list, to make it easy to have the
### build-essential packages installed.

apt-get install build-essential

#########################################################################################################
### BLAS (Basic Linear Algebra Subroutines) is a set of efficient
### routines for most of the basic vector and matrix operations.
### They are widely used as the basis for other high quality linear
### algebra software, for example lapack and linpack.  This
### implementation is the Fortran 77 reference implementation found
### at netlib.

apt-get install libblas3gf libblas-test libblas-dev libblas-doc

##########################################################################################################
### LAPACK version 3.X is a comprehensive FORTRAN library that does
### linear algebra operations including matrix inversions, least
### squared solutions to linear sets of equations, eigenvector
### analysis, singular value decomposition, etc. It is a very
### comprehensive and reputable package that has found extensive
### use in the scientific community.

apt-get install liblapack3gf liblapack-test liblapack-doc liblapack-pic liblapack-dev

##########################################################################################################
### harminv is a free library to solve the problem of harmonic inversion,
### given a discrete-time, finite-length signal that consists of a sum of
### finitely-many sinusoids (possibly exponentially decaying) in a given
### bandwidth, it determines the frequencies, decay constants, amplitudes, and
### phases of those sinusoids.

apt-get install libharminv2 harminv libharminv-dev

##########################################################################################################
### Guile is a Scheme implementation designed for real world programming,
### providing a rich Unix interface, a module system, an interpreter, and
### many extension languages.  Guile can be used as a standard #! style
### interpreter, via #!/usr/bin/guile, or as an extension language for
### other applications via libguile.

apt-get install guile-1.8 guile-1.8-libs guile-1.8-dev

##########################################################################################################
### libctl is a free Guile-based library implementing flexible control files for
### scientific simulations. It was written to support the MIT Photonic-Bands
### program, but will hopefully prove useful in other programs too.

apt-get install libctl3 libctl-dev libctl-doc

##########################################################################################################
### Open MPI is a project combining technologies and resources from several other
### projects (FT-MPI, LA-MPI, LAM/MPI, and PACX-MPI) in order to build the best
### MPI library available. A completely new MPI-2 compliant implementation, Open
### MPI offers advantages for system and software vendors, application developers
### and computer science researchers.

apt-get install openmpi-bin libopenmpi-dev openmpi-doc libopenmpi-dbg openmpi-common openmpi-checkpoint libopenmpi1.3

##########################################################################################################
### HDF5 (Hierarchical Data Format 5) is a file format for storing
### scientific data. These tools allow to convert other formats to
### HDF5 and to visualize HDF5 files. They include:
###  - h5topng, which extracts a 2d slice of an HDF5 file and
###    outputs a corresponding image in PNG format;
###  - h5totxt, which extracts 2d slices and outputs comma-delimited
###    text (suitable for import into a spreadsheet);
###  - h5fromtxt, which converts simple text input into
###    multi-dimensional numeric HDF5 datasets;
###  - h5fromh4, which converts HDF4 data to HDF5;
###  - h5tovtk, which converts HDF5 files to VTK files for
###    visualization with VTK-aware programs;
###  - h5read, a plugin for the Octave numerical language.

apt-get install h5utils hdf5-tools libhdf5-doc libhdf5-serial-1.8.4 libhdf5-serial-dev hdfview

##########################################################################################################
### ATLAS is an approach for the automatic generation and optimization of
### numerical software. Currently ATLAS supplies optimized versions for the
### complete set of linear algebra kernels known as the Basic Linear Algebra
### Subroutines (BLAS), and a subset of the linear algebra routines in the
### LAPACK library.

apt-get install libatlas3gf-base libatlas-doc libatlas-dev libatlas-test libatlas-base-dev

##########################################################################################################
### MPB - The MIT Photonic-Bands package is a free program for computing the band
### structures (dispersion relations) and electromagnetic modes of periodic
### dielectric structures, on both serial and parallel computers. It was
### developed by Steven G. Johnson at MIT in the Joannopoulos Ab Initio
### Physics group, and designed to study photonic crystal structures.

apt-get install mpb mpb-doc

##########################################################################################################
### This library computes Fast Fourier Transforms (FFT) in one or more dimensions.
### It is extremely fast. This package contains the shared library version of the
### fftw libraries in double precision.

apt-get install fftw2 libfftw3-3 fftw-docs fftw-dev

##########################################################################################################
### The GNU Scientific Library (GSL) is a collection of routines for
### numerical analysis.  The routines are written from scratch by the GSL
### team in C, and present a modern API for C programmers, while allowing
### wrappers to be written for very high level languages.

apt-get install libgsl0ldbl libgsl0-dbg gsl-bin libgsl0-dev gsl-ref-html

##########################################################################################################
### Meep (or MEEP) is a free finite-difference time-domain (FDTD) simulation
### software package developed at MIT to model electromagnetic systems.
### Its features include:
###   * Simulation in 1d, 2d, 3d, and cylindrical coordinates.
###   * Dispersive (including loss/gain) and nonlinear (Kerr & Pockels) materials.
###     Magnetic permeability and electric/magnetic conductivities.
###   * PML absorbing boundaries and/or perfect conductor and/or Bloch-periodic
###     boundary conditions.
###   * Exploitation of symmetries to reduce the computation size .
###     even/odd mirror symmetries and 90/180 degree rotations.
###   * Complete scriptability - either via a Scheme scripting front-end
###     (as in libctl and MPB), or callable as a C++ library.
###   * Field output in the HDF5 standard scientific data format, supported by
###     many visualization tools.
###   * Arbitrary material and source distributions.
###   * Field analyses including flux spectra, frequency extraction, and energy
###     integrals; completely programmable.
###   * Multi-parameter optimization, root-finding, integration, etcetera
###     (via libctl).

apt-get install meep libmeep6 libmeep-dev

##########################################################################################################
### these are used to create the Makefiles and configure scripts,
### and to build shared libraries.

apt-get install autoconf autoconf-doc automake pkg-config libtool libtool-doc latex2html

##########################################################################################################
### SWIG is a compiler that makes it easy to integrate C and C++ code
### with other languages including Perl, PHP, Tcl, Ruby, Python, Java,
### Guile, Mzscheme, Chicken, OCaml, Pike, and C#.

apt-get install swig swig-doc swig-examples

##########################################################################################################

Una vez que se han instalado todos los paquetes anteriores necesarios para que Meep funcione en modo de desarrollo (de entre los cuales se encuentra un interesante visor de formato hdf5) se procede a descargar el software para poder compilarlo, aunque ya se tienen los paquetes del meep instalados la idea de descargar el código fuente, compilarlo y ejecutar los programas desde ahí es bastante atractiva y a mi punto de vista flexible, teniendo en cuenta que se estaran programando las simulaciones directamente desde el core de la libreria, cabe mencionar que todos los paquetes anteriores se instalaran como librerías compartidas lo que nos da la ventaja de tener “Intellisense” si se estan haciendo programas utilizando el Eclipse por ejemplo, la direccion de descarga de el código fuente del meep es la siguiente:

http://ab-initio.mit.edu/meep/meep-1.1.1.tar.gz

Una vez descargado se descomprime a algún directorio deseado, ya que se tiene extraido se navega en la consola hasta el directorio del Meep, el directorio se llamara meep-1.1.1 que es la versión actual de la herramienta, y después de eso se ejecuta el script de configuración de la herramienta estando en el directorio antes mencionado con el siguiente comando.

./configure

El script de la herramienta hace una serie de chequeos para ver si se tienen todos los paquetes instalados y en este caso imprimirá mensajes de estado en la consola similares a los siguientes:

checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... no
checking for mawk... mawk
checking whether make sets $(MAKE)... yes
checking whether to enable maintainer-specific portions of Makefiles... no
checking for g++... g++
checking for C++ compiler default output file name... a.out
checking whether the C++ compiler works... yes
checking whether we are cross compiling... no
checking for suffix of executables...
checking for suffix of object files... o
checking whether we are using the GNU C++ compiler... yes
checking whether g++ accepts -g... yes
checking for style of include used by make... GNU
checking dependency style of g++... gcc3
checking build system type... i686-pc-linux-gnu
checking host system type... i686-pc-linux-gnu
checking for gcc... gcc
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for C++ compiler vendor... gnu
checking whether C++ compiler accepts -malign-double... yes
checking whether C++ compiler accepts -fstrict-aliasing... yes
checking whether C++ compiler accepts -ffast-math... yes
checking for gcc architecture flag...
checking for x86 cpuid 0 output... d:756e6547:6c65746e:49656e69
checking for x86 cpuid 1 output... 206a7:3100800:1dbae3bf:bfebfbff
checking whether C++ compiler accepts -march=pentium2... yes
checking for gcc architecture flag... -march=pentium2
checking whether C++ compiler accepts -O3 -malign-double -fstrict-aliasing -march=pentium2... yes
checking for a sed that does not truncate output... /bin/sed
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent libraries... pass_all
checking for ar... ar
checking for strip... strip
checking for ranlib... ranlib
checking command to parse /usr/bin/nm -B output from gcc object... ok
checking how to run the C preprocessor... gcc -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for dlfcn.h... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking for objdir... .libs
checking if gcc supports -fno-rtti -fno-exceptions... no
checking for gcc option to produce PIC... -fPIC -DPIC
checking if gcc PIC flag -fPIC -DPIC works... yes
checking if gcc static flag -static works... yes
checking if gcc supports -c -o file.o... yes
checking if gcc supports -c -o file.o... (cached) yes
checking whether the gcc linker (/usr/bin/ld) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking whether stripping libraries is possible... yes
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... no
checking whether to build static libraries... yes
checking for ld used by g++... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking whether the g++ linker (/usr/bin/ld) supports shared libraries... yes
checking for g++ option to produce PIC... -fPIC -DPIC
checking if g++ PIC flag -fPIC -DPIC works... yes
checking if g++ static flag -static works... yes
checking if g++ supports -c -o file.o... yes
checking if g++ supports -c -o file.o... (cached) yes
checking whether the g++ linker (/usr/bin/ld) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking for latex2html... latex2html
checking for sin in -lm... yes
checking for fftw_plan_dft_1d in -lfftw3... no
checking for fftw_create_plan in -ldfftw... no
checking for fftw_create_plan in -lfftw... yes
checking for pkg-config... /usr/bin/pkg-config
checking for harminv >= 1.1... yes
checking HARMINV_CFLAGS...
checking HARMINV_LIBS... -lharminv
checking mpb.h usability... no
checking mpb.h presence... no
checking for mpb.h... no
checking for cblas_cgemm... yes
checking for gsl_sf_bessel_Jn in -lgsl... yes
checking for deflate in -lz... yes
checking for H5Pcreate in -lhdf5... yes
checking hdf5.h usability... yes
checking hdf5.h presence... yes
checking for hdf5.h... yes
checking for guile-config... guile-config
checking if linking to guile works... yes
checking for scm_make_smob_type... yes
checking for SCM_SMOB_PREDICATE... no
checking for SCM_SMOB_DATA... no
checking for SCM_NEWSMOB... no
checking how to activate readline in Guile... ice-9 readline
checking for libctl dir... /usr/share/libctl3
checking for gen-ctl-io... gen-ctl-io
checking for ctl_get_vector3 in -lctl... yes
checking ctl.h usability... yes
checking ctl.h presence... yes
checking for ctl.h... yes
checking whether libctl version is at least 3.0.3... ok
checking for basename in -lgen... no
checking for feenableexcept... yes
checking whether feenableexcept declaration is usable... yes
checking whether to catch and ignore SIGFPE signals... no
checking whether time.h and sys/time.h may both be included... yes
checking sys/time.h usability... yes
checking sys/time.h presence... yes
checking for sys/time.h... yes
checking for BSDgettimeofday... no
checking for gettimeofday... yes
checking for cblas_ddot... yes
checking for cblas_daxpy... yes
checking for C/C++ restrict keyword... __restrict
configure: creating ./config.status
config.status: creating Makefile
config.status: creating meep-pkgconfig
config.status: creating src/Makefile
config.status: creating tests/Makefile
config.status: creating examples/Makefile
config.status: creating libctl/Makefile
config.status: creating libctl/meep.scm
config.status: creating config.h
config.status: config.h is unchanged
config.status: executing depfiles commands
config.status: executing libtool commands

Se asegura de que el script de configuración no marque ningún ”warning” para proceder con la compilación, en este caso no aparecerá ninguno ya que ya se han instalado todos los paquetes necesarios previamente..

Por ultimo se procede a hacer el compilado de la herramienta para generar los ejecutables con la siguientes instrucciones:

make
make install

En este punto ya se tiene el parque de diversiones listo para utilizarse! , en el siguiente post se hara el primer programa de simulacion sencillo mediante C++ para probar todo el nuevo entorno que se acaba de instalar, tal vez sea prudente hacer otro post con informacion de la instalacion de un entorno de desarrollo amigable como C++, se da por asentado que el lector interesado esta utilizando una plataforma Linux basada en Debian..