Il Prossimo Giovedì 20 Gennaio 2011 alle ore 18:00
alle  presso la sede dell'ISTITUTO QUASAR
via Nizza, 152 - Roma

si terrà la lecture Cloud Design, in cui saranno presentati
progetti e lavori compiuti anche durante le attività di Tecniche Parametriche
di progettazione 2008-2011. Siete tutti invitati a partecipare, e intervenire!

cloud design
la lecture indaga l'evoluzione dei metodi di progettazione e produzione, che a partire da presupposti e provocazioni tecnologiche conduce alla evoluzione dei profili professionali e umani. Non si tratta, quindi, solo di riconoscere nuove forme di autorialità nel cloud computing per produrre spimes e strutturare gruppi allargati e flessibili di produzione, ma progettare per le nuove forme organizzative, usando flessibilità e negoziazione come forme espressive e il networking sui server di progettazione come strumento operativo.
Per passare dal solipsistico parametric modeling al "parametric being".

Cari ragazzi,
tra i temi che molti di voi stanno esplorando, discussi più volte al corso,
c'è la variazione dei componenti costruttivi. Di seguito vi segnalo diverse
tecniche:

1. Revit 2010 - "Power Copy" script

Lo script, usato tra gli altri progetti, per la Lampada Nagashima,
è stato sviluppato durante lo scorso anno per permettere di effettuare
copie "intelligenti" di un componente, che ad ogni passo, permettesse anche
di variare dei parametri. L'ultimo esempio che pubblichiamo qui, sviluppato
da Stefano Guarnieri per il progetto Calatrava/superficie rigata di Valeria Vitale



Il vantaggio di questa tecnica è che permette di schedulare i valori dei parametri
(come si vede dalla immagine qui sopra, dove ogni componente ha dimensioni leggibili)


2. Revit 2011 - Componenti adattativi e Reporting Parameters

L'intento che lo script 2011 si prefiggeva è stato, nel frattempo "raggiunto" dallo sviluppo
software, come accade sempre più spesso nel recente panorama in cui cresce la capacità
di scripting da parte degli "utenti" e dei progettisti impegnati nella implementazione reale
nell'attività progettuale e realizzativa.

In particolare le funzioni, nuove, che permettono un controllo analogo sono
i componenti adattativi e i Reporting Parameters (Parametri di rapporto).

Del componente adattivo si è detto a lezione, paragonandolo a tutti gli altri sistemi
di controllo e produzione della variazione, primo tra tutti Generative Components,
software nato col nome di Custom Objects e precursore del settore, a cui si aggiungono
le "User Feature" di molti software di progettazione meccanica e, in ultimo, le diverse
opzioni concesse dal plug-in di Rhino Grasshopper.


Biennale di Venezia, 2010

I progetti che si occupano nel corso di questo tema sono, al momento, quello di
Lorenzo Catena, che mima il progetto di SHoP per la copertura del centro Post-Katryna
nei pressi New Orleans:



E quello, parallelo in corso di sviluppo, di Ivo Petri

A questa nuova modalità concessa da Revit, per lavorare questi temi su base eminentemente grafica,
si somma la necessità di controllare matematicamente le geometrie di progetto. Su questo tema,
si sono svolti incontri con il contributo del prof. Corrado Falcolini, del Dipartimento di Matematica, che ha
anche dato un contributo al Seminario "Forma e disegno nell'architettura del sei e settecento".

Sul tema del controllo matematico delle geometrie in Revit con metodi grafici, si è interessato
Giuseppe Di Fabio, citando anche il lavoro di "The Revit Kid":



Giuseppe è ora impegnato nella produzione di variazioni architettoniche del tema
di una copertura/portico a generatrici pseudo-sinusoidali.

Al tema della variazione architettonica di un componente
lucernario/copertura, infine si sta interessanto Elena Valik,
che a partire da un progetto per una piccola pensilina, e alla
parametrizzazione di un lucernario come pattern basato su tre punti,
sta ora passando alla produzione di vari componenti di chiusura orizzontale
per un sistema di copertura e lucernari a modulo triangolare variabile




Aspettiamo ora da Elena gli aggiornamenti del lavoro di parametrizzazione
e le sue applicazioni architettoniche.


Sostanzialmente i lavori di questa sezione richiamano i due possibili
contesti per un lavoro architettonico sulla variazione:

1 .  serie
la produzione di pezzi autonomi (o di design) con geometria variata nella serie.
Il paradigma della mass customization che abbiamo no inquadrato negli anni
in quello Beyond IKEA

2. pezzi unici
la produzione di oggetti architettonici fatti da componenti dalla geometria
variabile, a cui fanno riferimento moltissimi progetti della contemporaneità
e quelli prodotti nel Laboratorio di Tecniche Parametriche 2011.


Ha senso, però, in fondo, parlare in questi termini di distinzione?
Non si tratta anche di cambiare un pò il modo di progettare e renderlo più "diffuso"?
Figlio di questa "nuova standardizzazione fatta di pezzi diversi"? A questo tema è ispirata
la pubblicazione, e il concetto collegato, di versioning ipotizzato da SHoP Architects.

A voi, ora fare le vostre riflessioni parallele ai progetti che elaborerete.

Buon lavoro!





 

Store_Selections - It builds some virtual boxes, where recovering the past selections to compare each other

Random_Selection_Panels - It picks, accidentally, a number of panels between the selected, equal to the chosen percentage

Set_Color_In_View - It changes the color of the edges of each type, in the active view

Bridge_Of_The_ Peace - It places points in the space, following the shape of the roof of a bridge - Conceptual mass

Physical_ID - Before it loads a family in the .rvt, then it creates and rotates some istances of it

S.A.T.: the Truss - Writing and reading of text files to interact with other softwares

Setting_Line_Color - This code allows to set the color of all the lines within the document

Shape_Discovering - This code shows, by listing, the relationship between points and 3D snapped model lines - Conceptual mass

Line_By_Selected_Points - This code creates a line joining two selected points - Conceptual mass

Get_Nodes - This code lists some features of a Structural Frame (columns and beams) - Project Based

Naming_ReferencePoints  - This code allows to assign a "personal id" number to each reference point in the Comment Field - Conceptual mass

New_Caledonia -  This sample creates new family instances along an arc (inspired by Renzo Piano's project)

--
All the examples require Login to download the files

Titolo Aggiornamentoordinamento crescente Creazione Nuovi commenti tags Autore
10_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
11_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
1_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
11_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
4_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
5_6 pavimentazione .jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
3-7_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
1_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
2_pavimentazione.jpg 6 anni 4 mesi fa 14 anni 3 settimane fa Immagine Elena Valik
5parapetto.jpg 6 anni 4 mesi fa 14 anni 1 mese fa Immagine Miguel Reyna

Pagine

 

Thanks to prof. Todesco for his vital help.

FileInfo t = new FileInfo(@"C:\Documents and Settings\Gguarnieri\Documenti\Desktop\TrussData.txt");
            StreamWriter Tex = t.CreateText();
            Tex.WriteLine("BARS LIST");
            Tex.Write(Tex.NewLine);
            Tex.Write("{0}_________", "ID");
            Tex.Write("{0}_________", "lenght");
            Tex.Write("{0}_________", "from node");
            Tex.Write("{0}_________", "to node");
            Tex.Write(Tex.NewLine);
            Tex.Write("-----------------------------------------------------------------------------------------");
            Tex.Write(Tex.NewLine);
 
            SetVertici vertici = new SetVertici();
            double ConvMeter = 0.3048;
            int approx = 2;
            int numBars = 0;
            Level level=null;
            ElementIterator levelIter = Application.ActiveDocument.get_Elements(typeof(Level));
            levelIter.Reset();
            while (levelIter.MoveNext())
            {
                Level level1 = levelIter.Current as Level;
                if (level1.Elevation > 0)
                {
                    level = level1;
                }
            }
            ElementIterator elemIter = Application.ActiveDocument.get_Elements(typeof(FamilyInstance));
            elemIter.Reset();
            
            while (elemIter.MoveNext())
            {
               
                FamilyInstance FamInst = elemIter.Current as FamilyInstance;
                StructuralType StructType = FamInst.StructuralType;
                Location Loc = FamInst.Location;
                ElementId ElemId = FamInst.Id; 
                
                string familyName = FamInst.Name;
                string NameFam = ElemId.Value.ToString();
                int giunto = 0;
                Vertice v = null;
 
                if (familyName == "cone")
                    {
                        giunto = 1;
                        LocationPoint point = Loc as LocationPoint;
                        v = vertici.getVertice(point.Point,giunto);
                        
                        
                    }
                    else if (familyName == "cylinder")
                    {
                        giunto = 2;
                        LocationPoint point = Loc as LocationPoint;                        
                        v = vertici.getVertice(point.Point,giunto);
                        
                     
                    }
 
                else if (StructType == StructuralType.Beam || StructType == StructuralType.Brace)
                {
                    
                    numBars = ++numBars;
                    LocationCurve CurveLoc = Loc as LocationCurve;
                    Curve curve = CurveLoc.Curve;
 
                    XYZ StartPoint = curve.get_EndPoint(0);
                    XYZ EndPoint = curve.get_EndPoint(1);
 
 
                    Vertice v0 = vertici.getVertice(StartPoint, giunto);
                    string id0 = v0.id.ToString();
 
                    Vertice v1 = vertici.getVertice(EndPoint, giunto);
                    string id1 = v1.id.ToString();
 
                    
                    
                    string lenght = (Math.Round((curve.Length) * ConvMeter, approx)).ToString();
 
 
                    string data = String.Format(" {0}      {1,16}     {2,15}     {3,20}", NameFam, lenght, id0,id1);
                    Tex.WriteLine(data);
                   
                    Tex.WriteLine("-----------------------------------------------------------------------------------------");
                    
                   
                }
                else if(StructType== StructuralType.Column)
                {
                    
                    numBars = ++numBars;                    
                    LocationPoint point = Loc as LocationPoint;
                    Vertice v0 = vertici.getVertice(point.Point, giunto);
                    string id0 = v0.id.ToString();
                    Vertice v1 = vertici.getVertice(v0.x,v0.y,level.Elevation,giunto);
                    string id1 = v1.id.ToString();
 
                    string lenght = (Math.Round((v0.distance(v1)) * ConvMeter, approx)).ToString();
                    
                    string data = String.Format(" {0}      {1,16}     {2,15}     {3,20}", NameFam, lenght, id0, id1);
                    Tex.WriteLine(data);
 
                    Tex.WriteLine("-----------------------------------------------------------------------------------------");
                }
                
            }
 
 
 
            Tex.Write(Tex.NewLine);
            Tex.WriteLine("NODES LIST");
            Tex.Write(Tex.NewLine);
            Tex.Write("{0}_________", "NUMBER");
            Tex.Write("{0,5}_________", "X");
            Tex.Write("{0,5}_________", "Y");
            Tex.Write("{0,5}_________", "Z");
            Tex.Write("{0,5}_________", "JOINT");
            Tex.Write(Tex.NewLine);
            Tex.Write("-----------------------------------------------------------------------------------------");
            Tex.Write(Tex.NewLine);
            for (int i = 0; i < vertici.Count(); i++)
            {
                
                Vertice v = vertici.at(i);
                string giunto = "";
                if (v.joint == 0)
                {
                    giunto = "unknown";
                }
                else if (v.joint == 1)
                {
                    giunto = "cone";
                }
                else if (v.joint == 2)
                {
                    giunto = "cylinder";
                }
 
 
                Tex.Write("{0,3}", v.id.ToString());
                Tex.Write("{0,20}", (Math.Round((v.x) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", (Math.Round((v.y) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", (Math.Round((v.z) * ConvMet, approx)).ToString());
                Tex.Write("{0,20}", giunto);
                Tex.Write(Tex.NewLine);
                Tex.Write("-----------------------------------------------------------------------------------------");
                Tex.Write(Tex.NewLine);
            }
 
            Tex.Write(Tex.NewLine);
            Tex.Write("{0,10}_________", "BARS number");
            Tex.Write("{0,10}_________", numBars.ToString());
            Tex.Write("{0,10}_________", "NODES number");
            Tex.Write("{0,10}_________", vertici.Count().ToString());
 
            Tex.Close();     
          }           
 
 
public class SetVertici
    {
 
        List<Vertice> vertici = new List<Vertice>();
 
        public Vertice getVertice(double x, double y, double z, int joint)
        {
            Vertice posizione = new Vertice(x, y, z, joint);
      
            Vertice piuVicino = null;
            double distanza2Minima = 0;
            
            for (int i = 0; i < vertici.Count(); i++)
            {
           
                double distanza2 = vertici[i].distance2(posizione);
                int giuntoVero = vertici[i].joint;
                if (giuntoVero != 0 && distanza2<5)
                {
                    posizione.joint = giuntoVero;
                }
 
                if (piuVicino == null || distanza2 < distanza2Minima)
                {
                    piuVicino = vertici[i];
                    distanza2Minima = distanza2;
                }
            }
           
            if (piuVicino != null && distanza2Minima < 1)
            {
                piuVicino.joint = posizione.joint;
                return piuVicino;
            }
           
 
            posizione.id = vertici.Count();
            vertici.Add(posizione);
 
 
            return posizione;
        }
 
        public Vertice getVertice(Autodesk.Revit.Geometry.XYZ coords,int tipoGiunto)
        {
            return getVertice(coords.X, coords.Y, coords.Z,tipoGiunto);
        }
        public int Count()
        {
            return vertici.Count();
        }
 
        public Vertice at(int index)
        {
            return vertici[index];
        }
 
    }
 
 
public class Vertice
    {
   
        double _x;
        double _y;
        double _z;
        int _id;
        int _joint;
        
        
 
        public Vertice(double x, double y, double z, int TipoGiunto)
        {
            _x = x;
            _y = y;
            _z = z;
            _id = -1;
            _joint = TipoGiunto;
        }
 
      
        public double x
        {
            get { return _x; }
 
        }
 
        public double y
        {
            get { return _y; }
 
        }
 
 
        public double z
        {
            get { return _z; }
 
        }
        
        public double distance2(Vertice v)
        {
            return Math.Pow(v.x - _x, 2) + Math.Pow(v.y - _y, 2) + Math.Pow(v.z - _z, 2);
        }
 
      
        public double distance(Vertice v)
        {
            return Math.Sqrt(distance2(v));
        }
 
        public int id
        {
            get { return _id; }
            set { _id = value; }
        }
 
        public int joint
        {
            get { return _joint; }
            set { _joint = value; }
        }
    }

[ 2011 ]  l'evoluzione dei metodi di progettazione e produzione,  a partire da presupposti e provocazioni tecnologiche conduce alla evoluzione dei profili professionali e umani. Non si tratta, quindi, solo di riconoscere nuove forme di autorialità nel cloud computing per produrre spimes e strutturare gruppi allargati e flessibili di produzione, ma progettare per le nuove forme organizzative, usando flessibilità e negoziazione come forme espressive e il networking sui server di progettazione come strumento operativo.

Per passare dal solipsistico parametric modeling al "parametric being".

"tesi iniziale"

 
 
 
questa relazione deve essere vista come una tesi di un LAVORO INCOMPLETO, un work in progress.
Questa “tesi iniziale” ha come scopo quello di chiarire quelli che sono stati i passaggi fondamentali nel processo di progettazione, può essere visto come un piccolo riepilogo del lavoro svolto utile per capire quelli che sono gli obiettivi perseguiti di volta in volta, e dare la possibilità un domani a chiunque di potersi “interessare” e quindi rendere usufruibile il lavoro da me svolto.
 
Dalla prima consegna, studio della forma: si è voluto creare una pensilina "resistente per forma", applicando quelli che sono i principi della meccanica dei gusci in c.a. , superfici spesse anche due centimetri che riescono a coprire grandi luci, il massimo dell'ottimizzazione dei costi. Illustri esponenti di questa ricerca sono stati i vari Torroja, Candela e soprattutto Isler, ma anche altri. Questa ricerca è andata avanti fino agli anni '50 poi soppiantata dalle tensostrutture. Comunque ancora oggi queste strutture vengono studiate grazie anche all' apporto degli elaboratori, l' obbiettivo è quello di "ricerca di minimo" raggiunto grazie a software tipo Matlab.
 
 
in alto a destra edifici di Torroja, in alto a sinistra ed in basso Isler (metodo della membrana inversa)
 
 
 
Felix Candela e i suoi imitatori (Calatrava)
 
 
 
 
    
 
la forma progettata per la pensilina è simile a quella di Gaudì, hanno la stessa sezione ad andamento sinusoidale, mentre per l'altra sezione nell' edificio di Gaudì si nota una semplice lineare, per la pensilina invece è stata adottata una quadratica.   la superficie matematica di Gaudì è del tipo   t*sin(x)  mentre quella della pensilina è  (t^2)*sin(x)
 
 
Una volta stabilita la forma, si è pensato ad una tecnologia più consona alle dimensioni dell'oggetto. Innanzitutto si è divisa in sezioni la superficie, e per ognuna di queste sezioni è stata prevista una struttura portante.  I materiali presi in considerazione sono due, legno e acciaio. Possiamo dire che l' acciaio è "subordinato" al legno. Per un'otttimizzazione dei costi s'è pensato di realizzare gli elementi in legno di forma e misura uguali, lasciando all'acciaio il compito, attraverso i giunti, di variazione. Da cui si capisce che l'elemento variabile saranno i soli giunti d'acciaio.
 
 
 
goal: creazione di questa superficie in revit
 
 
 
 

       

 
 
 
 
Come prima consegna mi sono proposto di cercare un modo per realizzare la superficie vista in precedenza. Il metodo di seguito illustrato denota tutti i limiti dovuti alla scarsa conoscenza del software, cosciente del fatto che ci siano soluzioni al problema molto meno laboriose della mia e quindi più eleganti, comunque ho provato a ragionare su variazioni di sezione da cui ne scaturisce una variazione di forma dell’oggetto.
 
 
 
 
 
Ho pensato di realizzare dei piani quotati paralleli fra loro, i quali rappresentano delle sezioni dell'oggetto/superficie. Dopo aver quotato ogni sezione per larghezza e altezza, ho assegnato dei parametri a questi. Si può notare come nel nome di ogni parametro si riconosca il numero progressivo della sezione e la dimensione (h=altezza, l=larghezza)
 
 
 
 
 
In seguito ho dato delle distanze progressive "d" ad ogni sezione, rispetto alla prima sezione. una volta costruiti i quadrilateri ho fatto l'estrusione per sezioni.
 
 
 
 
 
 
 
Di seguito ho iniziato a far variare l'altezza di ogni sezione in funzione della distanza di questa dalla prima. Al variare della distanza progressiva varia l'altezza dell'oggetto.
 
 
 
 
 
 
 
 
Stessa cosa per la larghezza, sempre funzione dipendente della distanza progressiva.Ora con questo metodo, per lo sviluppo nei prossimi giorni, cercherò di impostare la curva prima citata. Qui di seguito un piccolo studio in excel:
 
 
 
 
 
il diagramma xz è una semplice sin(x) mentre l'altro è una parabola x.^2, l'obiettivo che si vuole raggiungere è quello di disegnare sulle varie sezioni la funzione sin(x), e poi parametrizzare l'altezza di ogni sezione creando la dipendenza di questa rispetto alla distanza progressiva.
 
 
 
capire come arrivare a disegnare una funzione matematica in revit. grazie al tutorial di “the revit kid” ciò è stato possibile.
 
 
Qui di seguito delle immagini che testimoniano lo studio fatto per arrivare alla sezione variabile dell'oggetto/superficie:
Controllo tangente. Non potendo disegnare una funzione in questo programma, si può adottare una procedura un pò laboriosa, tramite la quale però, si raggiunge l'obbiettivo. La soluzione è nell'imporre ad una spline la tangenza in alcuni punti, da cui, si capisce che controllando la derivata prima, si controlla la funzione. Nell’immagine per comodità sono state prese solo tre tangenti, di queste, la prima a sinistra è quella col valore più elevato, andando verso destra abbiamo una graduale diminuzione, rispettivamente un mezzo ed un quarto della prima. 
 
 
 

 

 

Il valore della prima a sinistra corrisponde al valore dell'arcotangente tra due misure di cui una fissata.Si capisce che aumentando o diminuendo il valore della misura non fissata varia il rapporto fra le due, quindi il valore dell'arcotangente (prima tangente a sinistra) e di conseguenza il valore delle altre due tangenti.

 

 

 

 

 

 

 

 

 

 

il passo successivo è stato quello di studiare i componenti

 

Una volta stabilita la forma, si è pensato ad una possibile tecnologia, il più appropriata possibile alle dimensioni dell'oggetto. Innanzitutto si è divisa in sezioni la superficie, e per ognuna di queste sezioni è stata prevista una struttura portante.  I materiali presi in considerazione sono due, legno e acciaio. Possiamo dire che l' acciaio è "subordinato" al legno. Per un'otttimizzazione dei costi s'è pensato di realizzare gli elementi in legno di forma e misura uguali, lasciando all'acciaio il compito, attraverso i giunti, di variazione. Si capisce che l'elemento variabile saranno i soli giunti d'acciaio.

 

 

 

 

 

 

 

 

 

Si nota dall’immagine come i giunti d'acciaio siano molto grandi e quindi non economici, sarebbe bene farne un'uso parsimonioso dell'acciaio, lasciando quindi viti, dadi e componenti ammorsanti, e pensare i giunti in legno ricavati magari attraverso un'operazione di nesting.

 

 

 

 

 

 

 

 

 

 

NESTING:

 

 

 

Pagine

Theme by Danetsoft and Danang Probo Sayekti inspired by Maksimer