DYNAMO

NODOS Y LISTAS
Dynamo

2
 Nodos y listas

INDICE

INDICE ...................................................................................................................................................................................3

1. NODOS Y LISTAS .......................................................................................................................................................4

1.1 Nodos.............................................................................................................................................................................5
1.2 Paquetes..................................................................................................................................................................... 10
1.3 Listas ........................................................................................................................................................................... 12

3
 Dynamo

1. NODOS Y LISTAS

Pues una vez que nos hemos introducido en el programa y conocemos su interfaz, vamos a
hablar de nodos y listas. Los nodos son esas pilas que ya hemos visto y que son pedacitos de
codigo. Haciendo una analogía con el lenguaje son como palabras que necesitan de otras
palabras para formar una frase. En este caso hablaremos de una definición.

Si hay un concepto que me gustaría que quedase claro es el de listas. Todo lo demás es
importante, pero entender las listas y cómo funcionan es probablemente, el más fundamental
de todos los conceptos que vamos a explicar a lo largo del curso. Con las listas básicamente
podemos controlar varios elementos a la vez. En la figura 1 podemos ver como se ha
generado una lista con 10 puntos. A lo largo de esta parte del módulo hablaremos de maneras
de generarlas y de otro concepto fundamental: encaje o lacing.

Figura 1: Una lista de puntos

4
 Nodos y listas

1.1 Nodos

Entonces vamos a por los nodos. Como decíamos en la introducción, los nodos son estas pilas
de color gris que vamos a encontrar en la Librería de nodos. Esos nodos se van conectando
con otros nodos a través de conectores o wires generando definiciones. En la figura 2
podemos apreciar las distintas partes de un nodo cualquiera, en este caso de un punto.

Figura 2: Un nodo y sus partes principales

Como vemos el nodo tiene dos partes principales (las demás las iremos viendo poco a poco):

 Input ports: el puerto donde vienen a desembarcar los inputs, en resumidas cuentas
donde llegan los inputs.

 Output ports: el puerto o puertos donde se embarcan los outputs, es decir de donde
salen los outputs.

En este ejemplo (en el nodo Point.ByCoordinates) los input ports nos están pidiendo que les
demos una (o varias) coordenadas en X, en Y y en Z. De los output ports saldrá el output o
resultado con el punto o puntos.

5
 Dynamo

Vemos que en este caso ha generado un punto y lo vemos por debajo, el punto es el (0,0,0) y
eso es así porque en ese nodo en concreto si no le damos ningún input en concreto va a dar
como resultado un punto (0,0,0). La manera de saber que es lo que hace por defecto, es pasar
por encima de cada uno de los input ports como vemos en la figura 3.

Figura 3: Pasando por encima de cualquiera de los input ports vemos que nos da en este caso un valor por defecto

Si ahora quisiéramos hacer un punto distinto de (0,0,0) tenemos que añadir otros nodos en
este caso nodos de número. Los encontramos como podemos apreciar en la figura 4 en
Core>Input>Number como en este caso estamos creando el punto (5,5,7) conecto el Number 5
con el input port X e Y, y el Number 7 con el output port Z.

Os puede pasar que no veáis el resultado debajo del nodo, solo tenéis que pasar el cursor por
la parte inferior del nodo y veréis dicho resultado. Si queréis fijarlo, os aparecerá una especie
de chincheta, solo tenéis que clicar con el botón izquierdo y ya está.

6
 Nodos y listas

Muy bien, ya hemos sido capaces de generar un punto, vamos a por más ahora. Pongamos por
caso que queramos hacer una línea. Lógicamente si tenemos dos puntos podemos crear una
línea. Si queremos que esa línea se forme a partir de los puntos anteriores (0,0,0) y (5,5,7),
solo tenemos que generar esos puntos y buscar otro nodo (de línea) que a partir de esos dos
puntos nos genere una línea. Ese nodo lo tenemos en: Geometry>Line>ByStartPointEndPoint
como vemos en la figura 5. Podemos apreciar que cuando vamos a buscar un nodo que nos
haga una línea nos vamos a encontrar con varias posibilidades. En este caso he escogido este
nodo porque lo que quiero es una línea cuyo punto de inicio sea el (0,0,0) y el final sea el
(5,5,7).

Figura 4: Creamos el punto (5,5,7)

7
 Dynamo

Figura 5: Con los dos puntos y el nodo ByStartPointEndPoint creamos una línea

Si nos fijamos podemos apreciar que vemos la línea como resultado geométrico y eso es
porque el nodo o los nodos tienen que ver con geometría.

Ya hemos visto entonces los números o numbers. Vamos a ver otros dos tipos de nodos
fundamentales, me estoy refiriendo a los Strings y a Boolean (figura 6). Los dos los tenemos
en Core>Input en versiones anteriores a la 2.0 y desde ésta en Input>Basic

8
 Nodos y listas

Figura 6: Dos tipos de nodos fundamentales: String y Boolean

 Strings: son cadenas de caracteres, para que nos entendamos: texto.

 Boolean: funcionan como un interruptor (on/off) para ciertos nodos y tienen dos
posibilidades: True o False. Esos valores se suelen utilizar para comparar datos, como
en el ejemplo en la figura 7.

Figura 7: Comparación de dos números, la pregunta es si 3 es menor que 5 y la respuesta es True

9
 Dynamo

Como podéis apreciar he utilizado un nodo que me sirve para preguntar si un input es menor
que el otro (3 de 5) y el resultado es true.

Otra cosa que habréis notado, es que utilizo un nodo llamado Watch, que me permite ver
fácilmente los outputs o resultados. Lo tenéis en: Core>View>Watch en anteriores a la 2.0 y
desde ésta en Display>Watch

1.2 Paquetes

Los paquetes o packages complementan a los nodos que tenemos en Dynamo por defecto, o
en el built in. Tenemos que pensar en Dynamo como en un programa beta que está
continuamente mejorando. Aparecen nuevas versiones y se va enriqueciendo a medida que
pasa el tiempo. Sin embargo, algunas de las funcionalidades del built in o de los nodos que nos
aparecen por defecto se nos pueden quedar cortos y para eso vienen en nuestro rescate los
packages o paquetes de nodos.

Estos paquetes o packages contienen nodos también que enriquecen nuestra experiencia en
Dynamo. Están creados por programadores u otros y están disponibles de manera gratuita
pudiendo incorporarlos a nuestra biblioteca de nodos en todo momento.

Algunos de los más populares son Lunchbox, Clockwork, Archi-Lab o Spring nodes entre
otros. Conviene que nos los descarguemos porque muchos de estos nodos son muy útiles.

Como podéis apreciar en la imagen de la siguiente página (figura 8) mi interfaz es muy

Para descargarlos obviamente tenéis que estar conectados pudiendo descargarlos desde la
propia interfaz. Nos vamos a la barra de herramientas y de ahí a Paquetes>Buscar un paquete.
Una vez ahí me aparecen una serie de posibilidades, puedo buscar o bien me puedo ir a
Ordenar y que se me presenten los paquetes en función de si son más descargados, con más
votos, etc.

10
 Nodos y listas

Otra forma de buscar y de descargarlos es a través de la web: www.dynamopackages.com

Figura 8: Los paquetes que he ido incorporando a mi biblioteca de nodos debajo de Add-ons

Pongamos que quiero descargarme un paquete que se llama Optimo, para ello me voy a dónde
encontrábamos los paquetes y desde ahí le daré a la flecha para abajo (Figura 9)

Figura 9: Descargando el paquete Optimo (v.1.3)

Observaremos que una vez descargado, nos lo encontramos en la biblioteca de nodos y ya

11
 Dynamo

1.3 Listas

Como ya hemos comentado, este apartado de listas es probablemente la parte más importante
del curso (no la más difícil, entiéndanme bien). De la misma forma que en la vida real podemos
hacer nuestras listas de cualquier cosa, pues aquí en Dynamo lo mismo. Las listas nos
permiten controlar varios elementos a la vez y cómo las manejemos va a ser fundamental para
crear nuestras definiciones.

La manera más fácil de hacer una lista es a través de un nodo llamado List.Create que lo
encontramos en: Core>List>List.Create o List>Generate a partir de la 2.0.

Con él voy a hacer una lista muy sencilla con alguno de los elementos que ya hemos dado.

Figura 10: Un ejemplo de lista de tres elementos con strings y un número.

Como podemos apreciar en la figura 10 podemos crear una lista muy sencilla. En este caso de
tres elementos y mezclando números y strings. Como necesitamos una lista con esos tres
elementos (tres items), he ido añadiendo con el signo + más items hasta tener tres en el nodo.

12
 Nodos y listas

Si observamos bien, nos aparece cada elemento de la lista acompañado por un número
llamado index o índice que nos habla de la posición de dicho elemento en la lista. En Dynamo
el primer elemento siempre será el de índice 0. Todo esto es así en Dynamo así como en otros
programas.

En otros casos quizás lo que queramos hacer son secuencias como en el caso de la imagen
siguiente. Las podemos hacer buscando Sequence que lo encontramos en:
Core>List>Sequence o List>Generate a partir de la 2.0. (figura 11):

Figura 11: Una secuencia de 10 elementos que empiezan en 3 y van de 2 en 2

Como podemos apreciar es una secuencia sencilla a la que le hemos dado un 3 al primer
elemento o start, 10 como amount o cantidad (número de elementos), así como 2 al step o
diferencia entre cada elemento.

13
 Dynamo

La cosa se puede empezar a complicar si creamos listas anidadas. Podemos tomar la

Figura 12: Listas anidadas o nested lists. En este caso una lista final de 10 sublistas de 3 elementos cada una

Ahora vamos a un caso práctico. Queremos crear una serie de líneas a través de unas
secuencias de puntos, así que es sólo cuestión de crear las secuencias, que serán las
coordenadas para crear nuestros puntos. A través de Line.ByStartPointEndPoint generaremos
una serie de líneas como las de la imagen (Figura 13).

14
 Nodos y listas

No está mal. Ahora bien, nos podremos fijar que si tenemos una secuencia de 10 puntos y la
otra de 13, al final nos hace 10 líneas. ¿Y eso por qué? Pues porque por así decirlo, Dynamo
tiene tendencia a hacer lo más simple y de menos esfuerzo: diez líneas. Si nos ponemos por
encima del nodo Line.ByStartPointEndPoint veremos que con el botón derecho tenemos una
opción llamada Encaje. Por defecto está en Más corto (así que coge la opción más corta) crea
tantos outputs como inputs haya en la lista más corta (10). Si nos vamos a Más largo, creará
tantos outputs como inputs haya en la lista más larga (13) así que creará 13 líneas. Si por
último le damos a Con Producto vectorial, serán tantos los outputs como la multiplicación de los
inputs (10x13=130) así que creará 130 líneas (Figura 14).

Figura 13: Líneas con Encaje más corto (10)

15
 Dynamo

Figura 14: Líneas con Encaje Producto vectorial (130 líneas)

16