 |
|
La
Pascalina -Pascaline en francés- es la primera
calculadora mecánica de la historia. Inventada por el gran pensador,
filósofo y matemático francés Blaise Pascal a la edad de diecinueve años
(1642). El aparato podía sumar y restar, y también multiplicar y dividir
mediante sumas o restas sucesivas. Pascal desarrolló el invento para
hacer más fácil la recaudación de los impuestos a su padre. La Pascalina
es antecesor directo de las calculadoras modernas y un hito en la
carrera computacional que llega hasta nuestros días.
 El
Proyecto Pascaline es un intento que comenzó desde
De Mecánica con la intención de aunar los
esfuerzos de técnicos con conocimientos de Estructuras, Geotecnia y Programación
para dar forma a un <<software libre para estructuras>>
con marcado carácter educacional. Realizar
programas de índole estructural, de carácter gratuito y cuyo código sea
accesible a todos.
Sabemos que muchos de los técnicos desarrollan, por
razones de trabajo o simplemente por afición, Hojas de Cálculo y
pequeños programas informáticos. Es muy complicado que estos programas
lleguen a tener un
nivel profesional, no sólo porque el trabajo se desarrolla de manera
individual lo que lo hace más lento, sino también porque no suelen tener
gran distribución y ello hace difícil el proceso de prueba y depuración.
Pensamos que juntando los esfuerzos podremos construir herramientas más
útiles.
No hay mucho más, por ahora, el proyecto es sólo una idea. De vosotros depende
que salga adelante.
Si conoces las Estructuras, la Geotecnia y (o) sabes programar, te
gusta el proyecto y quieres participar en él, escríbenos al Foro (formulario Pascaline)
o bien directamente inscríbete en nuestra
lista de distribución Pascaline. |
|

|
|
ÚLTIMA
VERSIÓN
PASCALINE:
- Bajar Pascaline (código
libre, ejecutable sólo con Python instalado) Versión del 10/12/2006
Download Pascaline last version (to run this
version you must have Python installed on your computer). 10/12/2006
Contenido del archivo comprimido: AUTHORS, COPYING, INSTALL, NEWS, README, asientos.py, georun.py,
geotecnia. py, muro.py, phundimiento.py, setup.py, utils.py
- Bajar Pascaline (ejecutable
para Windows) Versión muy antigua del 20/09/2006)
Download Pascaline (Windows executable). Very old
version, 20/09/2006
|
|
ENLACES RELACIONADOS:
-
Lista Pascaline
Si deseas participar en el proyecto el primer
paso es que te apuntes a nuestra lista.
-
www.Python.org
El sitio oficial de Python, el lenguaje de
programación utilizado en el Pascaline. Desde el podrás acceder a
todas las herramientas necesarias para probar y trabajar en el
Pascaline.
-
blog.rvburke.com
En el blog de Pachi (Rafael Villar Burke), uno de
los miembros fundadores de Pascaline. En él encontraréis una sección
dedicada al Proyecto Pascaline y otras interesantes sobre software
libre, programación, etc.
-
Pascaline en Solo Arquitectura
La Web <<Solo Arquitectura>> dedicó un espacio de
su Foro al Proyecto Pascaline. Desde aquí nuestro agradecimiento.
|
FORO PASCALINE
- Resumen Octubre 2006
(De gestodedios, Equipo Pascaline), 13/11/06
- Resumen de reunión en
Septiembre
(De gestodedios, Equipo Pascaline), 27/09/06
- Posible inclusión de programas
en Python
(De Jesús Torrecilla), 25/09/06
Comentarios:
De gestodedios, Equipo Pascaline, 25/09/06
Comentarios:
De Pachi, Equipo Pascaline, 2/06/06
- Resumen de lo visto en la
lista los últimos días (mediados de agosto)
(De gestodedios, Equipo Pascaline), 15/07/06
- <<georun.py>> una sencilla
interfaz para <<geotecnia.py>>
(De Pachi, equipo Pascaline), 10/07/06
Comentarios:
De Coya,
10/08/06
Comentarios:
De gestodedios, Equipo Pascaline, 10/08/06
- Comentarios
(De Lampur), 03/08/06
Comentarios:
De gestodedios, Equipo Pascaline, 03/08/06
Comentarios:
De Pachi, Equipo Pascaline, 12/06/06
- Primera función Pascaline
(De Coya, Equipo Pascaline), 15/06/06
Comentarios y nueva versión del
código:
De Pachi, Equipo Pascaline, 01/08/06
- Pascaline a principios de
Julio
(De gestodedios, Equipo Pascaline), 08/07/06
- Presentación y
comentarios
(De Kristian Edsberg), 08/07/06
- Sobre el Código Técnico como
Guía
(De gestodedios, Equipo Pascaline), 25/06/06
Comentarios:
De Álvaro R.,
27/06/06
Comentarios:
De gestodedios, Equipo Pascaline, 27/06/06
- Sobre la posibilidad de usar C/C++
(De Álvaro R.), 25/06/06
Comentarios:
De gestodedios, Equipo Pascaline, 25/06/06
Comentarios:
De Álvaro R.,
27/06/06
- Nuevas ideas para el
proyecto Pascaline tras reunión en Madrid
(De gestodedios, Equipo Pascaline), 25/06/06
- Resumen del Proyecto
Pascaline a mediados de Junio 2006
(De De Mecánica), 25/06/06
- Una idea sobre el esquema
del programa
(De Martin75), 16/06/06
- Comenzar...
(De Coya), 10/06/06
Comentarios:
De Pachi,
12/06/06
- Más ventajas de Python
(De Pachi), 05/06/06
Comentarios:
De De Mecánica,
06/06/06
- Algunos reparos a Python
(De Coya), 03/06/06
- Presentación. Sobre Python y
otras ideas
(De Pachi), 29/05/06
Comentarios:
De De Mecánica,
30/05/06
Comentarios:
De Coya,
02/06/06
- Sobre Free Pascal
(De Coya), 25/05/06
- Dudas sobre el GNU y la
compatibilidad Dev C++/Qt
(De De Mecánica), 21/05/06
- Presentación y Comentarios
(De Antonio Maestre), 19/05/06
Comentarios:
De De Mecánica,
19/05/06
Comentarios:
De Coya,
20/05/06
Comentarios:
De Álvaro R.,
21/05/06
- Resumen de lo comentado y
comienzo del Foro Pascaline
(De De Mecánica), 15/05/06
- Mayo 2006: Abrimos un
Foro Pascaline
- Octubre 2005: Anuncio
del Proyecto
|
ref. Pasc-1_13/11/06
Resumen Octubre 2006. Un año de Pascaline.
(De gestodedios, equipo Pascaline) 13/11/06 - España
Hola a todos los pascalines.
Hace ahora un año que nació la idea del Proyecto Pascaline, y echando la
vista atrás, basta para ello con leer este foro desde su inicio, creo
que no nos podemos quejar. Comenzamos con serios retrocesos y alguna que
otra vez estuvimos a punto de tirar la toalla. A la búsqueda de
colaboración surgió el foro, y a él se sumó Coya, amigo de la Web, y
luego Pachi y con él Python y un buen empujón al Proyecto. Luego
se pasaron algunos meses entre titubeos informáticos hasta que por fin
Coya se decidió a crear la primera función Pascaline... Acabamos de
estrenar nuevo logo: un bebé bajo un arco jugando con la Pascalina, la
máquina de calcular. Con Pascaline queremos aprender y educar en el
cálculo de estructuras.
Octubre fue un buen mes para el Proyecto Pascaline, especialmente
gracias a la incorporación al proyecto de Fredo y Jesús Torrecilla.
Ambos han contribuido con dos nuevos códigos. Fredo con un programa
sobre el cálculo de la presión de hundimiento basado en el DB-SE-C del
Código Técnico de la Edificación, en la línea del ya existente sobre el
cálculo del coeficiente de empuje activo. Por su parte, Jesús Torrecilla
ha implementado un código de cálculo matricial de barras
articuladas.
En la versión del Pascaline que os ofrecemos
actualmente (versión del 07/11/06) se ha incluido el programa de
cálculo de presiones de hundimiento. El programa de barras se está
revisando actualmente y todavía no se ha subido la primera versión, pero
pronto esperamos hacerlo.
El proyecto sigue adelante.
Seguimos esperando vuestras opiniones, pruebas y colaboración,
gestodedios, De Mecánica.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
¡Sin respuesta!
|
|
ref. Pasc-1_27/08/06
Resumen de reunión en Madrid en Septiembre.
(De gestodedios, equipo Pascaline) 15/08/06 - España
Hola a todos los pascalines.
Éste fin de
semana pasado nos hemos reunido Pachi y yo para comentar como iba el
proyecto Pascaline. Aprovechamos para ver rápidamente algo sobre
Mercurial y también sobre la programación con Python con la
librería gráfica GTK. Además tratamos algunas ideas que
quisieramos comunicaros a todos:
- Acordamos
reunirnos un poco más a menudo... quizás sería bueno una vez al mes.
Las reuniones, por ahora, son aquí en Madrid donde al menos estamos
dos. No sé si habrá más de un pascaline en alguna otra ciudad
para poder reunirse. Esperamos también que se vayan apuntando
algunos más para la próxima.
-
Pensamos que sería mejor dejar para más adelante la
presentación en sociedad del proyecto dado que todavía no tiene
cuerpo. Más adelante, si seguimos avanzando se plantearía darlo a
conocer en la universidad (tablón de anuncios, presentación a algún
profesor...) con miras a que participaran en él.
-
Tampoco pareció todavía necesario crear una Web propia
para Pascaline, por las mismas razones que antes.
- Se
habló de la licencia. El autor principal aparece reflejado en el
código. Los autores, todos los que han formado parte de modo activo
en el programa van en el archivo AUTHORS. Los que han colaborado con
alguna parte de código, idea, etc. aparecerán en un archivo
CONTRIBUTORS <<Contribuciones>> .
- No
sólo se necesita hacer código, o programar. Se puede participar
haciendo tutoriales, manuales, archivos (el README o el INSTALL que
vienen con el paquete están a falta de redactar). Se pueden diseñar
analíticamente los algoritmos y programas que luego otro programe.
-
Se pusieron en común algunos programas propios
(Punzonamiento, Coeficientes de acciones según CTE, Flexocompresión
en hormigón, etc.) que en un futuro se podrían incluir en
Pascaline. Se vieron algunas pequeñas herramientas fáciles de
implementar (cuantías, área de armaduras, balasto, etc.) que podrían
hacer Pascaline más <<apetecible>> al público. En esta línea
se pensó si la inclusión de hojas de cálculo podría también relanzar
el proyecto. Si bien se pensó que las hojas de cálculo son a largo
plazo inviables por lo difícil de su mantenimiento (control de
versiones) en equipo, se vio que seguramente servirían para dar a
conocer el proyecto a muchos técnicos, no sólo como usuarios sino
como diseñadores. Bastaría con dotarles de una mínima imagen
homogénea, una distribución conjunta, etc.
- Se recalcó que
somos conscientes de que el proyecto en sus inicios avanzará
lentamente y que serán pocos los que participen activamente. Dado
que se trata de un proyecto sin ánimo de lucro no se exige a nadie
nada: habrá veces que se avance y otras que se atasque. Lo ideal:
que el que participe se divierta, aprenda y que otros se puedan
beneficiar con su trabajo...
Seguimos esperando vuestras opiniones y colaboración,
gestodedios, De Mecánica.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
¡Sin respuesta!
|
|
ref. Pasc-1_24/09/06
Posible inclusión de programas en Python
(De Jesús Torrecilla) 24/09/06 - España
Hola a todos.
Tengo realizado un par de programas en
Python, uno de cálculo de estructuras articuladas (con interfaz gráfica
wxPython) y otro (en fase pre-Beta) de cálculo de secciones. Si os interesan, puedo liberarlos. Sólo habría que ver bajo qué licencia.
Jesús Torrecilla.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios
(De gestodedios, equipo Pascaline) 25/08/06 - España
Estimado Jesús:
En primer lugar agradecerte
tu generosidad. Claro que nos interesa, seguro que supone un
buen empuje al proyecto.
De todas maneras, lo que más
nos gustaría es que te unieras al proyecto, ya que estamos
necesitados de gente que conozca Python. Te animamos a que
te apuntes a nuestra lista de distribución:
http://pascaline.rvburke.com/listinfo.cgi/pascaline-rvburke.com
En cuanto a la licencia,
ahora estamos utilizando una GPL, pero podemos verlo
detenidamente. Espero que Pachi, que sabe algo más de esto
te pueda comentar sobre cómo podemos incluir tus programas
en Pascaline.
Saludos,
gestodedios, <<De
Mecánica>>.
|
|
Comentarios
(De Pachi, equipo Pascaline) 26/08/06 - España
Jesús, estaría genial que te unieses al proyecto. Seguro que
se puede sacar buen partido de lo que has hecho hasta ahora.
Tanto Coya como Ramón o yo mismo tenemos otros programas y
hojas de cálculo que hemos ido haciendo hasta el momento,
aunque la idea es intentar hacer algo conjuntamente poco a
poco, intentar construir una comunidad en torno a ello, y
ver si podemos hacer algo útil a medio plazo.
El código hasta ahora está publicado con licencia GPLv2
o posterior, y creo que esa es la más interesante, puesto
que asegura que los programas estarán públicamente
accesibles independientemente de los derroteros de la gente
que compone el proyecto, pero si prefieres otra licencia
podemos pensarlo y debatirlo.
Ayer nos reunimos Ramón y yo y comentamos que hay que
aclarar algo más la cuestión de las licencias, puesto que he
visto que en España no es posible la asignación de
copyright a entes que no tengan forma jurídica
consolidada (asociación, sociedad...), así que haremos una
asignación de copyright en cada módulo al autor
principal, y se extenderá en función de que haya otras
aportaciones principales a cada módulo. La asignación se
hace en cada módulo y en un archivo AUTHORS en el que
se enumeran los módulos y las personas que ostenten el
copyright correspondiente.
También habrá un fichero CONTRIBUTORS en el que
aparecerán las personas que hayan hecho contribuciones
puntuales al proyecto. Creo que así está todo más claro.
Esto, como el resto, se puede debatir en la lista. ¿Alguien
tiene alguna sugerencia al respecto?
De todos modos, en cuanto al copyright, hay que
recordar que lo importante es la licencia, en este caso la
GPL, que permite la copia, modificación y
distribución del programa siempre que el que reciba la copia
tenga los mismos derechos y pueda recibir el código, es
decir... no es posible <<secuestrar>> los programas en
exclusiva, salvo que no se distribuyan en absoluto. Creo que
esa es la máxima garantía de que las contribuciones que se
hagan al proyecto permanecerán como un patrimonio colectivo.
Para cambiar la licencia de cada módulo sería necesario que
los autores del mismo decidiesen publicarlo, adicionalmente,
con otra licencia.
Creo que con esto se puede ver más clara la situación
<<legal>> en la que quedaría el código aportado al proyecto.
Se trata de que cada cual reciba el reconocimiento a sus
aportaciones, tanto como autor si su aportación es
principal, como colaborador si ha sido menor, pero que el
conjunto sea utilizable en condiciones justas por
cualquiera.
Saludos,
Rafael Villar Burke.
|
|
ref. Pasc-1_15/08/06
Resumen de lo visto en la lista
Pascaline los últimos días (mediados de Agosto)
(De gestodedios, equipo Pascaline) 15/08/06 - España
Hola a todos los pascalines. Hago un breve resumen de los
temas que se han visto en la lista los últimos días, sin duda el debate
sobre temas de programación ha tomado el protagonismo:
- Se debate sobre la introducción de la programación orientada a
objetos. De hecho el módulo georun.py se ha modificado
introduciendo un objeto muro con sus métodos y propiedades, y se plantea
la creación de un objeto terreno.
- Se discute sobre la programación <<de arriba a abajo>> o <<de abajo a
arriba>>, es decir, si es mejor hacer un receso y plantear de nuevo
globalmente el proyecto Pascaline, analizando los objetos
necesarios; o seguir en esta línea de ida y vuelta en la que el código
se renueva constantemente.
- Se trataron aspectos sobre funcionamiento de parches y de test
unitarios. Sobre los parches se puede consultar el artículo en el Blog
de Pachi (http://blog.rvburke.com/2006/08/10/pequeno-curso-para-el-trabajo-con-parches).
Sobre test unitarios los enlaces y comentarios que también él nos
facilitó:
<<[1]
http://www.zope.org/Wikis/DevSite/Projects/ComponentArchitecture/Zope3Book/unittests.html
[2]
http://pyunit.sourceforge.net/pyunit.html
[3]
http://mail.python.org/pipermail/tutor/2001-September/008816.html
[4]
http://c2.com/cgi/wiki?TestDrivenDevelopment
[5]
http://www.onlamp.com/pub/a/python/2004/12/02/tdd_pyunit.html
[6]
http://www.onlamp.com/pub/a/python/2005/02/03/tdd_pyunit2.html
[1] usa Unittest, el módulo de Python para test unitarios, que tiene
su documentación en [2] (además de en la documentación de Python).
[3] presenta la técnica más rudimentaria del assertr. Como se puede
ver, Unittest simplemente sofistica algo más la técnica del assert...
En [4] se habla de una metodología en la que los test son casi lo más
importante. Para entender porqué son importantes los test.
[5] y [6] son dos artículos muy buenos que explican un poco todo este
asunto, con ejemplos concretos>>.
También éste proporcionado por Coya:
http://es.wikipedia.org/wiki/Prueba_unitaria
- Se trataron aspectos sobre el estilo de programación con Python con
objeto de conseguir cierta homogeneidad entre todos los que vayamos a
trabajar en el proyecto. También se recomendó alguna dirección:
http://www.python.org/dev/peps/pep-0008/
- Se entregaron nuevas versiones del geotecnia.py y del
georun.py . La última versión como siempre la tenéis en la
parte superior de ésta página.
Seguimos esperando vuestras opiniones y colaboración,
gestodedios, De Mecánica.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
¡Sin respuesta!
|
|
ref. Pasc-01_10/08/06
<<georun.py>>, una sencilla interfaz para <<geotecnia.py>>
(De Pachi, equipo Pascaline) 10/08/06 - España
Hola a todos.
Para animar un poco más el foro y para tener algún ejemplo más, aquí
mando un nuevo archivo que, cuando se ejecuta en un directorio que
contenga el anterior archivo geotecnia.py pide los valores necesarios
para calcular el empuje usando la función que se define en dicho módulo.
Es una interfaz de texto hecha a toda prisa, así que falta gran parte de
la validación de datos y, por supuesto, todavía no tenemos ningún test
del módulo que usa...
Como ideas para extender lo que tenemos se podría hacer:
- Implementar otro algoritmo para el cálculo del empuje y extender la
interfaz de texto para que pregunte cuál se desea usar.
- Hacer test que comprueben la validez de la función de empuje que hemos
definido ya.
- Validar los datos (estudiar dónde se valida, si en la interfaz o en la
función o en ambas y qué resultado produce cada caso).
Saludos,
Pachi.
Archivo
Pascaline: georun.py <<Revision: 0.1
2006-08-09>>
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios
(De Coya, equipo Pascaline) 10/08/06 - España
Hola Pachi.
Hola a todos los pascalines.
Siguiendo lo que comenas ahí va una función que incluye el
empuje activo.
Se trata simplemente de implementar la fórmula (6.1) de
DB-SE-C. La he incorporado como una función dentro del
módulo geotecnia.py.
He modificado la autoría por <<equipo Pascaline>>, dado que
ya hemos participado varios miembros. A continuación de la
línea de versión he añadido un comentario con el autor de la
última modificación.
Propongo una traducción del mensaje de software libre.
Añadí una comprobación:
# con este bucle comprobamos que el
programa no se para
# para ningún valor entero de
dato12,
for dato12 in range(0, 91):
datos1 = (90, dato12, 0, 0)
coeficiente_empuje_activo_CTE(*datos1)
El valor dato12 será el coeficiente de rozamiento. El nombre
de esta variable auxiliar es nemotécnico: dato 2 del
conjunto datos1. ¡Muy discutible!
Por otra parte, tal vez habría que hacer una comprobación
similar para todos los valores, pero hay dos problemas. El
primero, técnico, es que es tarda lo suyo. Si recorrer este
bucle le lleva un par de segundos, recorrer otros tres
bucles anidados supongo que será lento. No sé si esta manera
de comprobar es muy correcta. El segundo, coyuntural, es que
aún no están fijados los intervalos para las variables. Por
ahora no es un problema, porque lo más importante es saber
si es una buena práctica de depuración hacer las
comprobaciones a saco. Estas comprobaciones verifican que el
programa no se para, no que da resultados aceptables.
Un saludo,
Coya.
Archivo
Pascaline: geotecnia.py <<Revision: 0.3
2006-08-10>>
|
|
Comentarios
(De gestodedios, equipo Pascaline) 10/08/06 - España
Hola Pachi. Hola Coya.
Hola a todos los pascalines.
Simplemente quería comentar que a falta de unas <<Respuestas
a preguntas frecuentes>> (por ahora), quisiera dar unas
mínimas pautas para probar los módulos geotecnia.py y
georun.py.
Lo primero será guardar estos dos módulos en una carpeta de
vuestro ordenador. Esto se puede conseguir, por ejemplo,
seleccionando todo el texto del archivo y copiándolo a un
archivo .txt (geotecnia.txt y georun.txt) a los que después
le cambiamos la extensión a .py.
Por ahora no hemos hecho archivos ejecutables para Windows
por lo que para probar el programa tendréis que bajaros e
instalaros Python en vuestro equipo. Podéis
descargarlo de la dirección:
http://www.python.org/download/
Una vez descargado e instalado bastará con abrir el entorno
que viene con Python llamado IDLE (Python GUI).
Desde el IDLE con File-Open abrimos el archivo
georun.py. Una vez abierto desde Run-Run Module
ejecutamos el programa que pide el valor de los parámetros
en modo texto.

Saludos a todos, animaros a probar el módulo de cálculo del
empuje activo y no os olvidéis de reportarnos vuestras
observaciones y comentarios.
gestodedios,
<<De Mecánica>>.
|
|
ref. Pasc-01_03/08/06
Comentarios y algunos datos útiles
(De Lampur) 03/08/06 - España
Hola a todos.
Encuentro vuestro proyecto muy interesante. Aunque a corto plazo no me es posible colaborar en
él, es probable que a medio plazo sí.
Desde hace algún tiempo estoy buscando programas de cálculo de estructuras (por el método matricial) que se
puedan utilizar a nivel docente sin coste para los estudiantes.
He encontrado CESPLA y CESTRI (cálculo de estructuras planas y tridimensionales) de Juan Tomás Celigüeta (profesor de la Universidad de Navarra). Funciona muy bien pero no es de código abierto (al menos de momento). Se le puede pedir al autor que libere el código o como mínimo puede servir de modelo.
También he encontrado el STRUCEDIT (editor de estructuras) de Juan José Vidal. No tan depurado como los anteriores pero de código abierto. El problema es que está en
Java. Está colgado como proyecto en curso en:
http://javahispano.net/projects/strucedit
Me ha parecido que esta información os
podía ser de utilidad.
Saludos y adelante.
Lampur.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios
(De gestodedios, equipo Pascaline) 03/08/06 - España
Hola Lampur.
Sentimos que no te puedas incorporar al proyecto, de todas
maneras, puedes acceder a nuestra lista de distribución y
permanecer informado por si más adelante te <<picas>>:
http://pascaline.rvburke.com/listinfo.cgi/pascaline-rvburke.com
Agradecemos tus datos, algunos de los programas que comentas
ya los conocía, otros no. A diferencia de los programas que
aludes nosotros tenemos una circunstancia desfavorable en un
principio, que sin embargo a largo plazo nos ha de dar mucha
potencia. Se trata de que tenemos que trabajar en equipo y
no desarrollar algo a nivel personal.
Por otro lado, nosotros todavía no nos hemos planteado, al
menos no a corto plazo, crear un programa general de cálculo
matricial o bien por elementos finitos. En principio estamos
enfocando más el proyecto a desarrollar funciones útiles
para el cálculo en Estructuras y Geotecnia. Más adelante
intentaremos dar ese paso, pero si hay software en el
mercado en abundancia, si bien no libre, es acerca de este
tipo de cálculo.
Lo dicho, te esperamos,
gestodedios,
<<De Mecánica>>.
|
|
Comentarios
(De Pachi, equipo Pascaline) 09/09/06 - España
Lampur:
Algo que sería muy interesante, es que animases a los alumnos a implementar algunas partes del cálculo matricial. Si lo hacéis con
Python algún día Pascaline podría ser una herramienta más útil.
Creo que el esfuerzo de implementación tiene bastante interés académico y facilita comprender qué hacen las aplicaciones que están en el mercado, e, incluso, ver qué problemas tienen que resolver de cara a la velocidad de ejecución, heurísticas de cálculo, etc...
Saludos,
Pachi.
|
|
ref. Pasc-01_15/07/06
Primera función Pascaline
(De Coya, equipo Pascaline) 15/07/06 - España
¡La primera rutina de Pascaline!
Se trata de implementar la fórmula (6.3) del DB SE-C del CTE.
¿Por qué esta fórmula? Simplemente porque al leer el DB me hizo gracia.
Se trata, ante todo, de subir un programa para debatir sobre la
programación, pues este es el objetivo de este programa pilote sobre
empujes.
Tres cosas quisiera resaltar para el comentario.
En primer lugar, cuando estoy programando, suelo escribir órdenes de
salida por pantalla de las variables, de manera que sea fácil realizar
el seguimiento. Estas órdenes van seguidas de un comentario
#seguimiento, para que luego puedan ser eliminadas. No sé si esa es una
práctica correcta o si os parece engorrosa o superflua.
En segundo lugar, he empleado variables auxiliares (auxN) que no
representan nada, sino que simplemente atomizan una fórmula que, de otro
modo, sería ilegible en modo texto.
En tercer lugar, lo subo con cierta premura, sin revisar demasiado (o
casi nada), por la ilusión de ver algo de código en el aire.
Se admiten (como no) todo tipo de comentarios y sugerencias, así pues,
¡a rajar!
|
##################################
#coeficiente_empuje_activo_cte.py#
##################################
# Formulación del coeficiente de empuje activo (KA) según el
CTE
# Documento básico DB SE-C Cimientos
# Creación de la función 15-07-2006 # Última revisión 1.000
15-07-2006 #
# Parámetros:
# beta, pi_prima, delta, iota
# Variables locales:
# aux1, aux2, aux3, aux4, KA
from math
import
sin, radians
def
coeficiente_empuje_activo_CTE(beta,fi_prima,delta,iota):
print
'inicio de función'
#seguimiento
# adaptación de parámetros
print
'beta=',beta,',
fi_prima=',fi_prima,',
delta=',delta,',
iota= ',iota
#seguimiento
beta,fi_prima,delta,iota=radians(beta),radians(fi_prima),radians(delta),radians(iota)
print
'beta=',beta,',
fi_prima=',fi_prima,',
delta=',delta,',
iota= ',iota
#seguimiento
# implementacion de la fórmula (6.3)
del DB SE-C
aux1=sin(beta-fi_prima)/sin(beta)
aux2=sin(beta + delta)**0.5
aux3=(sin(delta + fi_prima)*sin(fi_prima-iota)/sin(beta-iota))**0.5
aux4=aux1/(aux2 + aux3)
aux5=aux4**2
print
'aux1= ',aux1,',
aux2= ',aux2,',
aux3= ',aux3,',
aux4= ',aux4
#seguimiento
print
'KA = aux5 = ',aux5
#seguimiento
print
'fin de función'
#seguimiento
return
aux5
if
__name__ == '__main__':
print
'inicio de la rutina de prueba
del módulo'
KA=coeficiente_empuje_activo_CTE(90,30,0,0)
print
'El coeficiente vale',
KA # seguimiento
print
'fin de la rutina de prueba del
módulo'
|
Saludos,
Coya.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios y nueva versión del código
(De Pachi, equipo Pascaline) 01/08/06 - España
Hola de nuevo :). Ya estoy de vuelta y con ganas de ir
avanzando.
> ¡La primera rutina de Pascaline!
¡Genial!
> Se trata de implementar la
fórmula (6.3) del DB SE-C del CTE.
> ¿Por qué esta fórmula?
Simplemente porque al leer el DB me hizo gracia.
Buen motivo :).
> Se trata, ante todo, de subir un
programa para debatir sobre la programación, pues este es el
objetivo de este programa pilote sobre empujes.
> Tres cosas quisiera resaltar para
el comentario.
> En primer lugar, cuando estoy
programando, suelo escribir órdenes de salida por pantalla
de las variables, de manera que sea fácil realizar el
seguimiento. Estas órdenes van seguidas de un comentario
#seguimiento, para que luego puedan ser eliminadas. No sé si
esa es una práctica correcta o si os parece engorrosa o
superflua.
Esto podemos pulirlo para no dejar el código tan sucio,
creando una función debug, con parámetro un nivel de aviso,
que imprima un mensaje si el nivel es inferior a uno dado.
De esta manera podemos eliminar la salida simplemente en
función de lo que necesitemos conocer.
> En segundo lugar, he empleado
variables auxiliares (auxN) que no representan nada, sino
que simplemente atomizan una fórmula que, de otro modo,
sería ilegible en modo texto.
Es, como muchas cosas, un asunto de gusto y de legibilidad.
Se puede usar la barra hacia atrás para saltar de línea en
medio de una expresión (\), aprovechando la existencia de
distintos términos. Yo prefiero usar por lo general el salto
de línea, aunque en este caso parece más claro lo que has
hecho.
> En tercer lugar, lo subo con
cierta premura, sin revisar demasiado (o casi nada), por la
ilusión de ver algo de código en el aire.
Eso es lo mejor en estos momentos. Mando los comentarios y
un archivo adjunto con el código tal como lo he dejado. Más
adelante, en cuanto tengamos algunos criterios básicos ya
más establecidos probablemente sea mejor comentar el código
en línea y adjuntar parches que hagan los cambios
propuestos.
> Se admiten (como no) todo tipo de
comentarios y sugerencias, así pues, ¡a rajar!
- Para empezar, es neceario saber que en Python se
usan 4 espacios para indentar el código, no
tabuladores, así que <<cuidadín>> con eso. Al ser
significativo el nivel de indentación hay que cuidar
que no se nos mezclen tabuladores y espacios.
- Por eso mismo es mejor insertar un archivo adjunto con el
código que incluirlo en línea en los mensajes. En el caso de
poner código en línea, se suelen separar los archivos con
algo así (ya que puede haber varios):
-------------
coeficiente_empuje_activo_cte.py -------------------
- La forma de poner los espacios entre parámetros de
funciones, en expresiones, etc. es importante para mantener
un estilo coherente y legible. En Python existe un
documento, llamado PEP-8 (Python Enhacement Proposal 8,
o, Propuesta de Mejora de Python 8) que trata de este
asunto (como lo de los espacios, tabuladores, criterios de
nombrado...)
http://www.python.org/dev/peps/pep-0008/
- El estilo habitual también desaconseja usar guiones bajos
en los nombres de módulos para evitar problemas en algunos
sistemas de archivos. Por eso deberíamos cambiar el nombre
del módulo. Probablemente empezar con geotecnia.py
puede estar bien. Ya moveremos las funciones a módulos más
específicos cuando sea necesario. Usar un nombre corto nos
ahorra problemas en sistemas de archivos limitados en ese
aspecto.
- Es importante escribir las cadenas de documentación del
módulo (archivo) y las funciones, con una primera línea
corta que resuma el contenido y una explicación posterior
más extensa. Es mejor documentar aquí que en medio del
código. Si faltan aclaraciones en el código es que está mal
abstraído (ya se nos darán casos...)
http://www.python.org/dev/peps/pep-0257/
En los casos triviales no es necesario repetir la
información.
- También es mejor separar la adaptación de parámetros en
diferentes líneas, en vez de usar asignación múltiple, al
menos para operaciones no triviales (podemos querer
comprobar límites más adelante, etc). Mejor no hacer una
optimización prematura del código (en este caso en cuanto a
compacidad) a costa de la legibilidad. En lenguajes menos
expresivos se intenta hacer demasiado en cada línea por pura
economía de espacio... en Python hay que relajarse un
poco en ese aspecto.
- En vez de usar aux5 como nombre de variable es mejor usar
Ka, por ser más significativo.
- He eliminado algunos mensajes de comprobación redundantes
(principio y final de la función dentro y fuera de la misma)
y he creado una función debug que manda los avisos
por pantalla en función del nivel de información que
deseemos. Con cambiar el valor de DEBUG_LEVEL controlamos la
información que saca en pantalla el programa, y no tenemos
que andar borrando o comentando zonas del código.
- Las cadenas con valores de variables intermedios se
formatean mejor con el operador %, que usa una cadena y una
tupla con las variables. Le podemos indicar el tipo, la
precisión y el número de decimales. Por ahora he usado %f
que es para valores en coma flotante. En
http://docs.python.org/lib/typesseq-strings.html hay más
información.
- Las funciones pueden tomar valores por defecto, tal como
se ve en la función debug, y que podemos aprovechar
para los parámetros de la función de cálculo del empuje
activo. Usar valores razonables puede ser interesante. Aquí
lo he añadido por ver la funcionalidad.
- Otra duda que surge es si el nombre de la función es
adecuado, ya que puede hacerse demasiado largo al usarlo en
una expresión si no tenemos una variable intermedia para él.
Por ahora vamos a seguir así... ya veremos qué nos pide el
cuerpo más adelante :).
- He añadido una declaración de la codificación del archivo
de código, para insertar acentos y caracteres especiales sin
problemas (ojo... es la codificación del archivo, no de la
salida...)
- Quedan por añadir test al código, comprobando las
condiciones de contorno, valores significativos, etc, así
como validación de los datos de entrada, mejor
documentación, y lo que se nos ocurra. Así que, !a
participar!
Otra opción es implementar otra función que use esta que
hemos hecho o una función alternativa para calcular el
empuje activo. Me parece más interesante lo primero, e ir
intentando hacer algo útil cuanto antes.
En fin... a ver si se anima esto :)
Saludos,
Pachi.
Archivo
Pascaline: geotecnia.py <<Revision: 0.2
2006-07-31>>
|
|
ref. Pasc-02_08/07/06
Pascaline a principios de Julio
(De gestodedios, equipo Pascaline) 08/07/06 - España
Hola a todos los pascalines. Hago un breve resumen de los últimos
temas:
- Pascaline utilizará como unidades las del sistema Internacional
(S.I.), era algo obvio pero no deja de ser interesante constatarlo.
Trataremos de sacar una tabla con las unidades a utilizar en el proyecto
de prueba sobre empujes.
- Trataremos de publicar un apartado de Preguntas Frecuentes para animar
a los visitantes del Foro a unirse al proyecto. Nuestro amigo Álvaro R.
trabaja sobre ello.
- Hemos abierto una lista de distribución para tener una comunicación
más eficaz que lo que este Foro puede permitir entre los pascalines.
Por ahora somos sólo cuatro, esperamos ser muchos. Para suscribirse a la
lista podéis ir a la dirección:
http://pascaline.rvburke.com/listinfo.cgi/pascaline-rvburke.com
Seguimos esperando vuestras opiniones y colaboración,
gestodedios, De Mecánica.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
¡Sin respuesta!
|
|
ref. Pasc-01_08/07/06
Presentación y comentarios
(De Ing. Kristian Edsberg) 08/07/06 - Argentina
La idea me parece genial, soy Ingeniero estructuralista y usuario de varios
softwares muy conocidos, apoyo la idea y sigo en contacto para colaborar en experiencias y valores de constantes a aplicar en mi
región (Nordeste Argentino).
¡Suerte !
Un abrazo,
Kristian Edsberg
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
¡Sin respuesta!
|
|
ref. Pasc-01_28/06/06
Sobre el Código Técnico como guía
(De gestodedios, equipo Pascaline) 28/06/06 - España
Hola a todos los pascalines.
Para arrancar con esto de los empujes sobre muros de contención propongo
partir de lo considerado en el nuevo Código Técnico de la Edificación (CTE).
Propongo a los pascalines hacer una lectura
(una lectura concienzuda, de estas de subrayar lo importante)
del artículo 6 del <<Documento Basico SE-C Cimientos>>
y analizar su aplicación y posible guía para el programa.
Para ir acotando el problema sugiero las siguientes cuestiones:
- ¿Trataremos sólo el empuje sólo aplicado a muros o también a pantallas
(continuas, de pilotes, tablestacas...)? Yo me inclino por comenzar
exclusivamente con muros.
- En el caso de muros ¿de una sola altura? De nuevo me inclino por no
complicarnos más en un principio.
- En el caso de muros ¿verticales? ¿con trasdós inclinado, quebrado?
Quizás incluir el caso inclinado que es común.
- ¿Se tendrán en cuenta cargas aparte de las propias de terreno? Me
inclino por considerar alguna más, como por ejemplo vehículos y
edificaciones próximas. Sería interesante contemplar el caso de
compactación pero es complicado.
- ¿Incluiremos tipos de terreno con parámetros definidos o por el
contrario será el usuario el que indique la densidad, el ángulo de
rozamiento, etc.? Sería interesante contar con ambas posibilidades.
- ¿Incluiremos el empuje del agua? Creo que es necesario.
- ¿Empuje activo, pasivo y en reposo? Creo que debería incluir todos
estos casos.
- ¿Un sólo tipo de terreno o varios estratos? Parece mejor comenzar sólo
con uno.
- ¿Cómo elegir las funciones del programa? Parece claro que para cada
coeficiente de empuje (kP, kA, Ko)
debería haber al menos una función. Igual para el cálculo de la ley de
empujes (σh) -parece interesante que como resultado se
pudiera obtener tanto la ley de empujes ¿gráfica y analíticamente? como
su resultante, ¿no?
-...
Esperamos vuestras opiniones y colaboración,
gestodedios, De Mecánica.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios
(De Álvaro R.) 01/07/06 - España
Saludos a todos ¿Qué tal?
He estado leyendo el foro con calma, también he aprovechado
para meditar sobre todo lo que comentáis, además he
descargado el entorno que me decíais (IDLE) y he comenzado a
probarlo, durante la próxima semana aprovecharé para
imprimir y leer el manual que recomienda Coya en el foro (<<El mejor documento de aprendizaje de
Python que he encontrado en la Web es un libro en
pdf escrito por Andrés Marzal e Isabel Gracia y está
editado por el Departamento de Lenguajes y Sistemas
Informáticos de la Universitat Jaume I. Se titula
Introducción a la Programación con Python y está en la
dirección:
http://marmota.act.uji.es/MTP/pdf/python.pdf. En la
misma Web hay más información sobre programación en Python y
en C>>)
Con respecto a lo de comenzar analizando empujes sobre
muros, creo que puede resultar sencillo y de paso nos
servirá para empezar a sacar conclusiones sobre la forma de
trabajo, efectivamente debemos de partir de lo dicho en el
CTE, Ramón yo comenzaría con muros ménsula rectos,
definiendo acciones como tierras (empuje activo), nivel
freático y sobrecargas además de acciones exteriores
puntuales, inicialmente con casos concretos para más
adelante generalizar el uso del programa a otros casos.
Comenzaré a enviar algunos ejemplos a finales de esta semana
a
gestodedios@demecanica.com para que los echen un
vistazo, espero sus comentarios.
Un saludo.
Álvaro R.
|
|
Comentarios
(De gestodedios, equipo Pascaline) 01/07/06 - España
Hola de nuevo, Álvaro.
Yo también estoy aprendiendo Python en mis pocos ratos
libres.
Esperamos tus ejemplos. Supongo que lo mejor será elaborar
una tabla o base de datos donde se reflejen los datos de
entrada y los resultados de todos los ejemplos que nos vayan
mandando. Algo fácil de manejar y actualizar, admito
sugerencias...
Un saludo,
gestodedios, De Mecánica.
|
|
ref. Pasc-01_24/06/06
Sobre la posibilidad de usar C/C++
(De Álvaro R.) 25/06/06 - España
Hola a todos, disculpar que tarde en contestar pero he estado bastante ocupado finiquitando algunas asuntos, veo que la gente sigue haciendo sus críticas y comentarios, con respecto a decidirnos con un lenguaje de programación sigo apostando por
C/C++, el motivo es que son varias las empresas que conozco y lo emplean para el desarrollo de programas comerciales de análisis de estructuras, si bien es cierto que es más complicado que otros permite el desarrollo de aplicaciones mucho más potentes (sobre todo a largo plazo), tiempo atrás Gestodedios me preguntabas si he trabajado con
Dev C++ en aplicaciones de ciertas dimensiones, siendo sincero, te
diré que no, pero he trabajado con gente que si lo a hecho obteniendo buenos resultados, otro de los motivos por los que apuesto por este lenguaje es que son ya muchas las publicaciones que existen, está mas que probada su solvencia y los resultados que con el se obtienen, no hace falta buscar mucho para darse cuenta de que por ejemplo tanto en el desarrollo de
Linux en sus orígenes como para sus aplicaciones es totalmente imprescindible (y esto quiere decir algo...), lo que implica que existan una enorme cantidad de compiladores como librerias de libre distribución, dado que este es uno de los objetivos que se persigue con Pascaline. Si bien es cierto que el uso de
C/C++ puede resultar inicialmente complicado, pero aquellos que ya saben programar aunque sea para hacer pequeñas aplicaciones tienen ya una parte importante del camino recorrido. Bueno espero nuevas críticas y comentarios, mediten sobre lo que les he comentado.
Un saludo,
Alvaro R.
Para unirte al Proyecto o
participar en el Foro
dirígete al
formulario Pascaline
|
|
Comentarios
(De gestodedios, equipo Pascaline) 25/06/06 - España
Hola de nuevo, Álvaro.
En este tiempo que estuviste ausente hicimos una elección y
tenemos que ser consecuentes y seguir con ella. En su
momento se analizaron aquí las diferentes ventajas de unos y
otros lenguajes y al final nos decidimos por Python,
no podemos cambiar las cosas a cada momento (lo cual no
significa que si en un futuro nos damos cuenta de que Python
es inviable, cambiemos). Por otro lado, sí se ha hablado de
integrar módulos en C/C++ cuando sea necesario.
Ahora, como se ha comentado en este foro, estamos comenzando
a planificar un primer módulo de prueba sobre Geotecnia,
concretamente acerca de empuje de tierras sobre estructuras
de contención, al que espero que te sumes.
Recibe un cordial saludo,
gestodedios, De Mecánica.
|
|
Comentarios
(De Álvaro R.) 28/06/06 - España
¿Qué tal?
Por supuesto que estoy dispuesto a unirme, no me preocupa
que el lenguaje elegido sea Python, aunque he de
deciros que lo ignoro por completo, pero bueno todo es
ponerse, a ver si leo con más calma el foro y me pongo al
día,
Un saludo,
Álvaro R.
|
|
ref. Pasc-01_25/06/06
Nuevas ideas para el Proyecto Pascaline tras reunión en Madrid
(De gestodedios, equipo Pascaline) 25/06/06 - España
Hola a todos los pascalines.
Tras un pequeño encuentro en Madrid el pasado Jueves 22, hemos llegado a
algunas conclusiones cara al proyecto que paso a resumir:
- En breve pondremos en funcionamiento una lista de distribución <<Pascaline>>
que sirva para po | |