DYNAMO
DYNAMO DEL DÍA A DÍA
Dynamo
2
Dynamo del día a día
INDICE
INDICE ...................................................................................................................................................................................3
1. DYNAMO DEL DÍA A DÍA ................................................................................................................................................4
1.1 Crear niveles desde Dynamo .......................................................................................................................................4
1.2 Vistas y planos a partir de niveles ...............................................................................................................................7
1.3 Cambiar nombres de vistas o planos ....................................................................................................................... 11
1.4 Crear muestrario de tipos de muros de un proyecto ............................................................................................... 14
1.5 Contabilidad de muros. Ejemplares de cada tipo, longitud y área .......................................................................... 19
3
Dynamo
1. DYNAMO DEL DÍA A DÍA
Para acabar el curso y para reforzar la idea de que Dynamo no es algo que tiene que ver con
arquitecturas y formas raras (al menos no solo), sino para trabajar con él para tareas
cotidianas, vamos a ver toda una serie de ejemplos sencillos de cómo Dynamo nos puede
ayudar en nuestro día a día como profesionales.
1.1 Crear niveles desde Dynamo
Si bien con Revit podemos crear los niveles tranquilamente, a veces puede resultar tedioso
sobre todo cuando empezamos nuestro proyecto y tenemos bastantes o muchos niveles a
crear. Una idea que planteo siempre y sobre todo ahora que sabemos cómo exportar datos de
Excel a Revit, es tener una hoja de Excel con los niveles, sus nombres y cotas y exportarlos a
Revit. Con Excel es muy fácil cambiar los datos y tener un control efectivo de éstos.
Así que vamos a crear niveles desde Dynamo. Si en Dynamo nos vamos a
Revit>Elements>Level veremos que tenemos varias opciones en cuanto a la creación de
niveles voy a tomar en este caso ByElevationAndName como podemos ver en la Figura 1.
Figura 1: Un nodo que nos permite crear niveles a partir de sus nombre y cotas
Imaginemos que quiero crear 40 niveles, que vayan desde el nivel 0 hasta la planta 39.
Podríamos llamar a cada planta: Planta-0, Planta-1, Planta-2 y así sucesivamente. Pongamos
que cada planta está separada por 4 metros. Vamos a hacer un poco de Designscript para
trabajar más rápidos. Una forma de hacerlo es como en la Figura 2. Nos debería quedar como
en la Figura 3. Por supuesto siguen estando los dos niveles que aparecen por defecto en Revit
que los podemos borrar sin problemas.
4
Dynamo del día a día
Figura 2: Una manera de crear 40 niveles desde la Planta-0 hasta la Planta-39
Le hemos dicho a través de Designscript que queremos una secuencia de números que van
desde 0 hasta el número de plantas (40) y queremos que fueran de 4 en 4 (ya que esa es la
altura de entreplanta).
5
Dynamo
Por otro lado hemos concatenado con “Planta-“ (un string) + una secuencia de números que
van desde el 0 hasta el 39 (la planta final).
Figura 3: Los 40 niveles creados con su correspondiente nombre
Lo que hemos hecho está bien, sin embargo podríamos hacerlo más automático si
conseguimos que trabajen como funciones, como podemos apreciar en la Figura 4.
Figura 4: Una manera de automatizar y poder jugar con los sliders creando más o menos plantas, o mayor o menor
altura de entreplanta
6
Dynamo del día a día
La ventaja de este sistema es que podemos jugar con los sliders, creando más o menos
niveles, mayor o menor altura de entreplanta, etc. Os recomiendo que juguéis con los
deslizadores o sliders.
1.2 Vistas y planos a partir de niveles
Una vez que tenemos los niveles podríamos crear las vistas correspondientes a esos niveles.
Eso es fácil utilizando el nodo [Link] (ver Figura 5). Vemos que es cuestión
de segundos para ver las vistas en el navegador de proyectos como en la Figura 6.
Figura 5: Con [Link] creamos las vistas correspondientes a dichos niveles
7
Dynamo
Figura 6: Las vistas correspondientes a cada nivel en el navegador de proyectos
Quizás queremos ahora crear planos a partir de dichas vistas, un plano por cada vista. El nodo
clave en todo esto es [Link] que lo tenemos en la categoría
Revit. Lo que hace es generar planos a partir del nombre y número de plano que le queramos
dar, familia del bloque de título y la vista que lleve (ver Figura 7).
Figura 7: El nodo que crea planos dándole los nombres de planos, número, bloque de título y la vista que llevan
8
Dynamo del día a día
Así que vamos por partes. Primero nos pide el sheetName, para no complicarnos podríamos
darle exactamente el nombre de la vista como se puede apreciar en la Figura 8.
Figura 8: Conseguimos los nombres de los planos a partir de los nombres de las vistas creadas con anterioridad
Ahora vamos a por los números. Los números podrían tener un código tipo A-100, A-101, A-
102, etc. Para automatizar todo esto, tendríamos que pensar que quiero obtener los números
sin que tenga que escribirlos manualmente. Así que de nuevo vamos a utilizar los recursos de
Designscript. Primero vamos a contar el número de vistas porque la idea es que el número de
planos sea el mismo. Lo podemos hacer a través del nodo Count. Con esto podemos crear un
code block para que nos haga los números de planos empezando por A100, en función del
número de planos que necesitemos. El nodo podría quedarnos algo parecido al de la Figura 9.
Figura 9: Utilizando el nodo Count y concatenando podemos generar los números de planos que necesitamos
9
Dynamo
Ya tenemos los números y los conectamos con el input port que le corresponde. Ahora
tenemos que conseguir un bloque de título para nuestros planos. En este caso lo que voy a
hacer es cargar una familia (ya que no la tengo en el proyecto). Lo deberíamos encontrar en
nuestra biblioteca de familias, en Bloques de título. Por ejemplo cargo A1 métrico en el
proyecto. Si ahora voy a Dynamo, en Revit>Selection tenemos Family Types, del que
obtenemos un desplegable de las familias cargables que tenemos en nuestro proyecto. Lo
conectamos con el input port correspondiente. Solo queda conectar las vistas y lo deberíamos
ver como en la Figura 10 y la Figura 11.
Figura 10: Conectamos con los input port correspondientes obteniendo así los 40 planos con sus vistas
correspondientes
10
Dynamo del día a día
Figura 11: Como vemos hemos generado un montón de planos y cada uno tiene la vista que le corresponde
1.3 Cambiar nombres de vistas o planos
Pongamos por caso que utilizando el proyecto en el cual hemos creado los niveles, vistas y
planos, nos dicen que por ejemplo los nombres de los planos tienen que estar en mayúsculas.
Teniendo en cuenta que son (en nuestro caso) 40 planos, pues todo esto nos llevaría un
tiempo, con muchas posibilidades de equivocarnos. No hablemos ya del tedio de hacer algo tan
aburrido. La buena noticia es que si trabajamos un poquito con Dynamo, podemos crear una
rutina que la podamos utilizar en éste y en otros casos.
Lo primero que haríamos es en Dynamo ir a Revit>Selection>Categories y elegir Planos.
Después tenemos que conseguir todos los ejemplares de planos que tenemos en el proyecto,
como podemos ver en la Figura 12.
11
Dynamo
Figura 12: Utilizando estos dos nodos conseguimos todos los ejemplares de planos del proyecto
Ahora tenemos que obtener los nombres de planos de cada uno de ellos. Para eso,
utilizaremos el tan socorrido nodo GetParameterValueByName, que requiere que le des los
nombres del parámetro para obtener sus valores. Como en este caso el nombre del parámetro
literalmente es Nombre de plano, tenemos lo necesario para hacerlo (ver Figura 13).
Figura 13: Gracias a GetParameterValueByName conseguimos los nombres de los planos
12
Dynamo del día a día
Tenemos que pasar a mayúsculas, eso lo hacemos fácilmente a través del nodo
[Link], se refiere a upper case (mayúsculas). Lo conectamos y ya tenemos toda una
serie de strings en mayúsculas, como podemos ver en la Figura 14.
Figura 14: Con [Link] transformamos los strings de minúsculas a mayúsculas
Solo nos queda ahora sobrescribir esos nuevos nombres en mayúsculas. Para ello con
SetParameterByName podemos hacerlo sin ningún problema, ya que disponemos del nombre
del parámetro, los elementos y los valores (ver Figura 15).
Figura 15: Sobrescribimos los nombres en mayúsculas con SetParameterByName
13
Dynamo
Con todo esto tendríamos que ver el navegador y sus planos como aparece en la Figura 16.
Figura 16: Los nombres de los planos cambiados a mayúsculas
1.4 Crear muestrario de tipos de muros de un proyecto
Vamos a hacer un ejercicio ahora que va a enlazar con lo aprendido al principio del curso. Me
refiero al tema de geometría.
Imaginémonos que nos piden un muestrario o los muros ordenados de los muros que tenemos
cargados en un proyecto. Podría ser de cualquier otra cosa, pero con los muros es muy fácil
visualizarlo.
Vamos a hacerlo desde un proyecto nuevo empezado desde la plantilla de arquitectura.
Tenemos obviamente cargados toda una serie de tipos de muros, la idea es verlos
gráficamente.
Para ello vamos a ir a Element Type, ya que es la manera de encontrar las familias de sistema
cargadas en nuestro proyecto. En el desplegable encontramos WallType (tipo de muro). A
posteriori vamos a obtener todos los tipos de muro con All Elements of Type. Nos debería
quedar como en la Figura 17.
14
Dynamo del día a día
Figura 17: Obtenemos los tipos de muros cargados en el proyecto
Bien, lo que viene ahora es fundamental para entender el proceso. Vamos a crear una serie de
líneas que nos sirvan de base para crear una serie de muros (uno de cada tipo). El nodo que
permite crear muros a partir de líneas o curvas es [Link]. Necesitamos
viendo el nodo (Figura 18), las curvas o líneas, la altura que van a tener los muros, level o nivel
y los tipos de muros.
15
Dynamo
Figura 18: El nodo que nos permite crear muros a partir de líneas y altura
Empezamos entonces con las curvas. Tiene que haber tantas líneas como tipos de muros. Así
que vamos a trabajar de nuevo con los code blocks. La idea es que podamos controlar la
longitud que ocupan todos los muros alineados y por otro lado la anchura y altura de los
mismos.
Con Count puedo contar el número de tipos y que sean la base para crear ese mismo número
de puntos que generen el mismo número de líneas. Para que se entienda mejor y como una
imagen vale más que mil palabras, podemos referirnos a la Figura 19.
Podemos posteriormente generar otra serie de puntos que vayan en paralelo separados por la
anchura que tendrán esos muros como se puede ver en la Figura 20.
Ahora es muy fácil crear líneas a partir de puntos con ByStartPointEndPoint, ya que tenemos
una serie de puntos de inicio y otros de fin (Figura 21).
16
Dynamo del día a día
Figura 19: Con Count y un poco de Designscript creamos tantos puntos como tipos de muros
Figura 20: Con otro Number Slider y [Link] podemos crear otra serie de puntos en paralelo
17
Dynamo
Figura 21: Conseguimos a través de series de puntos crear una serie de líneas
Pues ya con esto tenemos las curvas para el nodo que crea muros a partir de curvas.
Necesitamos la altura, para ello utilizamos otro Number Slider, el nodo Level y por último los
tipos de muros. Debería quedarnos como en la Figura 22 y Figura 23.
Figura 22: Le damos los inputs necesarios para completar la definición
18
Dynamo del día a día
Figura 23: Los tipos de muros de nuestro proyecto alineados
1.5 Contabilidad de muros. Ejemplares de cada tipo, longitud y área
En el ejemplo anterior hemos sido capaces de ver los tipos de muros que tenemos cargados en
un proyecto. Sin embargo eso no quiere decir que sean los muros que hayamos utilizado en el
proyecto.
En este siguiente ejercicio vamos a centrarnos en los muros que tenemos en nuestro proyecto
para ver el número de ejemplares que tenemos de cada tipo, su longitud total o el área de
muros en función del tipo. Por supuesto podríamos sacar más datos, pero creo que con estos
nos podemos hacer una idea del potencial de Dynamo para contabilizar.
19
Dynamo
Primero de todo vamos a obtener todos los muros que tenemos en el proyecto de ejemplo que
lo encontramos en Archivo>Abrir>Archivos de ejemplo>rac_advanced_sample_project.rvt.
A estas alturas del curso no debería ser muy difícil obtener los muros que tenemos en nuestro
proyecto. Utilizando Categories, buscamos Muros y con All Elements of Category obtenemos
todos los ejemplares de dicha categoría, como podemos apreciar en la Figura 24.
Figura 24: Obtenemos todos los muros de nuestro proyecto
Ahora la idea es clasificar esos muros por el tipo de muro, de tal muro a lo mejor hay 10
ejemplares, de tal otro, tanto y así sucesivamente.
20
Dynamo del día a día
Hay un nodo que es estupendo para agrupar que es de lo que se trata, por key o por la clave
de nuestra agrupación. En nuestro caso la clave va a ser el nombre del tipo de muro. El nodo
que nos permite agrupar por clave es [Link]. Con [Link] podemos obtener
los nombres de los ejemplares (ver Figura 25). Teniendo los elementos (muros) y la clave o
key (nombres de tipos de muros) podemos agrupar fácilmente como podemos apreciar en la
Figura 26.
Figura 25: Con [Link] obtendremos los nombres de tipo de cada uno de los ejemplares
Figura 26: A través de [Link] podemos agrupar en función del tipo
21
Dynamo
Si nos fijamos en el output port unique keys obtenemos los tipos de muro que han sido
utilizados como podemos apreciar en la Figura 27.
Con esta agrupación podemos fácilmente ver cuantos ejemplares tengo de cada tipo. Lo
podemos conseguir con Count. Si nos fijamos nos da 8. Ese 8 parece que no nos sirve de
mucho ya que hace mención a los 8 distintos tipos de muro que tenemos. Lo que queremos es
que nos dé el número de ejemplares de cada uno de los 8 tipos de muros. Para ello fijémonos
de nuevo en el resultado de [Link].
Por debajo podemos apreciar que aparecen @L4 @L3 @L2 @L1. Son los niveles. Veremos
que es una manera de saber a qué niveles de nuestra lista nos referimos. Nos ha aparecido 8 y
eso es porque por defecto obtiene el nivel @L3, así que es como si hubiese contado
posicionándose en la vertical de @L3 y mirando a la derecha. Contabiliza 8. Pero si en el nodo
Count activo los niveles utilizando la flecha en el input port, veremos que puedo elegir otros
niveles como @L2. Con @L2 me posiciono en la vertical y veo lo que busco, el número de
ejemplares de cada tipo, como se puede ver en la Figura 28. No nos asustemos si ahora no lo
entendemos bien. Es normal y hay que hacer normalmente varias pruebas para pillarlo.
Figura 27: Podemos ver los tipos de muros que se han utilizado en el proyecto
22
Dynamo del día a día
Figura 28: Utilizando niveles podemos obtener (en este caso con @L2) los ejemplares de cada tipo
Bien, vamos ahora a contabilizar la longitud total de cada tipo de muro. Para ello, podemos
utilizar el tan socorrido nodo GetParameterValueByName, dándole el nombre del parámetro,
que en este caso es Longitud (ver Figura 29).
Figura 29: Utilizando Longitud conseguimos la longitud de cada uno de los muros
23
Dynamo
Tenemos las longitudes de cada uno de los ejemplares pero lo que queremos son las
longitudes totales por tipo. Para ello utilizaremos el nodo Sum (ver Figura 30). Podemos hacer
lo mismo con las áreas totales (ver Figura 31).
Figura 30: Utilizando [Link] podemos obtener las sumas totales de las longitudes de cada tipo de muro
Figura 31: Utilizando [Link] también podemos obtener las sumas totales de las áreas de cada tipo de muro
24
Dynamo del día a día
Por último podemos enviar todo esto a una hoja de datos de Excel, haciendo así relación con lo
aprendido en el capítulo anterior. Tenemos que utilizar entonces Data. ExportExcel para enviar
datos a Excel (ver Figura 32) o el nodo [Link] si estamos en una versión inferior a
la 2.0. El resto de la definición lo voy a hacer en la versión 1.3 pero que sepáis que es lo
mismo.
Figura 32: Con el nodo [Link] o [Link] enviamos datos de Revit a Excel
Creamos entonces desde Excel un nuevo archivo y a la hoja la podemos llamar Tipos de
muros. Consiguiendo el File Path, sheetName y el startRow y startCol, ya tenemos la base para
enviar los datos a Excel. Nos debería quedar como en la Figura 33.
Figura 33: El nodo [Link] (equivalente de [Link]) preparado para enviar los datos de muros.
25
Dynamo
Para dar los datos, vamos a crear previamente una lista con los encabezamientos. Por
ejemplo: Tipo de muro, Número, Longitud total y Área total. Así que podemos crear una lista
con dichos parámetros como strings. Una manera de hacerlo es abriendo corchetes y poniendo
cada parámetro entrecomillado separado por comas como se puede ver en la Figura 34 o bien
si estáis en versión inferior a la 2.0 abriendo y cerrando llaves.
Figura 34: Creamos una lista con los encabezamientos de nuestros parámetros, para ello abrimos y cerramos
corchetes (llaves si es en inferior a la 2.0)
Después vamos a crear una lista que recoja los tipos de muros, números de ejemplares,
longitudes totales y áreas totales. Para ello lo podemos hacer con [Link] como se puede
apreciar en la Figura 35.
26
Dynamo del día a día
Figura 35: Creamos una lista que recoja los datos obtenidos con anterioridad
La idea es que esos datos que vamos a exportar, tienen que estar colocados en filas. Así que
tenemos que utilizar Transpose, como se ve en la Figura 36.
27
Dynamo
Figura 36: Con transpose pasamos a tener una disposición en filas para Excel
Ahora vamos a colocar la lista con los encabezamientos por delante de las otras listas. Para
ello podemos utilizar [Link] como podemos ver en la Figura 37.
Ya solo nos queda conectarlo para verlo como aparece en la Figura 38. El resultado en Excel
se debería aproximar a lo que podemos ver en la Figura 39. Ahora si tenemos la definición de
fondo en automático, cada vez que hagamos cambios en el proyecto (añadir o quitar muros) lo
veremos automáticamente reflejada en la tabla.
28
Dynamo del día a día
Figura 37: Podemos utilizar [Link] para colocar los encabezamientos por delante
Figura 38: Podemos utilizar [Link] para colocar los encabezamientos por delante
29
Dynamo
Figura 39: Nuestra hoja de Excel como resultado
30
