Você está na página 1de 15

Parametrização e auto-dimensionamento de um

componente estrutural: Cúpula

Marcelo Meloni Montefusco, Yopanan Rebello e Juarez Franco

8 de Dezembro de 2015

1 Resumo

Este trabalho parte da noção de conceitulização de mundos projetivos para


descrever e parametrizar sistemas estruturais em ambiente computacional
CAD. A princípio foi estudada o sistema estrutural do estádio olímpico de
Berlim, aplicando a lógica de primeira ordem e separando-os em componten-
tes e sub-conjuntos.
Após, estudamos componentes estruturais auto-dimensionáveis. Eles facili-
tam a vida do arquiteto e aproximam o projeto arquitetônico do estrutural.
Meu objeto de estudo foi a cúpula, cuja altura e espessura são calculadas
através do vão. No m encontrei um erro de singularidade que não atrapa-
lha em seu dimensionamento e mostrei como pode ser resolvido através da
divisão do meridiano pela metade.

2 Apresentação

Este artigo foi escrito como obra nal e apresentação dos resultados de uma
disciplina eletiva do curso de arquitetura e urbanismo da Unicamp nomeada
AU254: Modelagem geométrica parametrizável e análise de sistemas estru-
turais. Nesta, começamos estudando um sistema estrutural já existente e
declarando seus componentes e através de lógica de primeira ordem e da lei-
tura do "A lógica da arquitetura"de Mitchell [2]. Após, passamos para um
componente estrutural descrito no livro "A concepção estrutural e a arqui-
tetura"de Rebello [3].
A base computacional da qual esta implementação deriva foi desenvolvida
por Franco [1] durante sua pesquisa de pos-doutorado na COPPE-UFRJ e
na UNICAMP, com suporte nanceiro da FAPESP.

1
Figura 1: Estádio Olímpico de Berlim. Fonte: www.somewhereinberlin.de

3 Conceitualização de uma estrutura pré-existente:


Estádio Olímpico de Berlim

O estádio olímpico de Berilm foi projetado pelo arquiteto alemão Werner


March e construído entre os anos de 1934 e 1936, a m de ser utilizado nos
Jogos Olímpicos de 1936. Entretanto, fora uma modernização do estádio
que se tornou objeto do meu estudo: a cobertura feita com estruturas tu-
bulares, que foi adicionada durante a reestruturação do estádio para a Copa
do Mundo de Futebol de 2006. Esta, foi projetada arquitetonicamente pelo
grupo de arquitetos Von Gerkan, Marg and Partner e estruturalmente pelo
grupo de engenheiros Schlaich Bergermann and Partner.
A cobertura é sustentada por vigas espaciais treliçadas em balanço, compos-
tas de elementos tubulares, tendo uma altura maior próximo aos apoios e
se torna um único elemento tubular ao m do balanço. Já o revestimento é
feito de membrana imediatamente acima da arquibancada e painéis de vidro
também ao m do balanço.

3.1 Análise visual por Gestalt

As leis da Gestalt se aplicam a esta cobertura, com ênfase para as leis de


proximidade, semelhança e unidade. Em uma estrutura complexa como esta,
o grau de percepção visual depende da proximidade do observador aos ele-
mentos e a posição em que se encontra.
Na menor escala, quando observamos somente a vigas, temos uma per-
cepção diferente do todo. Vários elementos tubulares são utilizados e se en-

2
Figura 2: Vigas da cobertura. Fonte: VM BRASIL. Imagination & inspira-
ção

caixam, formando uma estrutura única e com uma forma delimitada. Neste
exemplo, se aplica a lei da unidade, e quando visto em uma escala maior,
não enxergamos mais elementos tubulares, mas sim a viga.
A lei da semelhança, em teoria, nos diz que objetos similares tendem a serem
agrupados visualmente dentro de um ambiente com objetos de caracteristicas
variadas. É exatamente o que acontece no estádio; Os elementos viga, mem-
brana e painel de vidro tendem a se agrupar visualmente por semelhança,
mesmo não estando necessariamente em contato uns com os outros.
Visto de longe, temos a percepção de unidade da cobertura como um todo.
Tanto os painéis de vidro, quanto a membrana, mesmo sendo divididos em
vários pedaços, tendem a serem vistos como um único objeto pela proximi-
dade. Visto de longe, todos os elementos da cobertura, vigas, membranas e
painéis formam uma ferradura, e a cobertura não é mais vista como elemen-
tos separados, mas como um sólido.

3.2 Universo de discurso

3.2.1 Componentes
Perl Tubular Metálico
Material(Perl) = metálico
Forma(Pilar) = tubular
cor(Perl) = prata
Denem barra1, barra2, barra3 e barra4

Membrana Translúcida
Material (Membrana) = tecido
Cor (Membrana) = bege

Painel de Vidro
Material(Painel) = vidro

3
Figura 3: Pilar e membrana. Foto original: [?]

Cor(Painel) = transparente

3.2.2 Subconjuntos
Pilar(barra1, barra2, barra2, barra2, barra2)
Face1(barra3, barra4, barra 3, barra4, membrana)
Face2(barra3, barra4, barra3, barra4, painel)

Treliça Espacial(perl, [...], perl)

3.3 Base de funções

4 Componente estrutural auto-dimensionável: Cú-


pula

Neste exercício da disciplina AU254, cada aluno deveria escolher um compo-


nente estrutural como objeto de estudo, que fosse contemplado pelo livro do
Yopanan Rebello [3], de onde conseguiríamos grande parte das informações
necessárias para criar um componente estrutural que se auto-dimensiona.
Um componente que se auto-dimensiona é interessante tanto para a arqui-
tetura quanto para engenharia, uma vez que une a concepção arquitetônica
à estrutura. O arquiteto pode projetar sabendo que o componente vai cor-
responder ao pré-dimensionamento recomendado para o material escolhido.
Este método não descarta a necessidade do diálogo entre arquitetos e en-

4
Tabela 1: Base de funções da cobertura do estádio
Função Declaração
F 01 ∃x −→ barra1(x)
F 02 ∃x −→ barra2(x)
F 03 ∀x∀y(barra1(x) ∧ barra2(y) −→ sobre(y, x))
F 04 ∀x∀y(barra1(x) ∧ barra2(y) −→ maior(x, y))
F 05 ∃x −→ barra3(x)
F 06 ∃x −→ barra4(x)
F 07 ∀x∀y(barra3(x) ∧ barra4(y) −→ adjacente(x, y))
F 08 ∀x∃y∃z(barra2(x) ∧ barra3(y) ∧ barra4(z) −→ sobre(y, x) ∧ sobre(z, x))
F 09 ∃x∃y∀z(barra3(x) ∧ barra4(y) ∧ barra2(z) −→ ¬sobre(x, z) ∧ ¬sobre(y, z))
F 10 ∀x∃y∃z∃w(f ace1(x) ∧ barra3(y) ∧ barra4(z) ∧ membrana(w) −→ contem(x, y, z, w))
F 11 ∀x∃y∃z∃w(f ace2(x) ∧ barra3(y) ∧ barra4(z) ∧ painel(w) −→ contem(x, y, z, w))

genheiros, mas garante que a forma desenhada no projeto arquitetônico se


aproxime ao máximo da exigida no projeto estrutural.

4.1 Processo

O componente estrutural que escolhi foi a cúpula de concreto, que é resultado


de uma associação contínua arco x arco se utilizando da rotação deste para
formar a cúpula. Para auto-dimensionar a estrutura utilizei a tabela, mos-
trada na gura 5, contida no livro do Yopanan para relacionar o diâmetro
da cúpula com a altura e espessura, e inserir em meu código C#.

4.1.1 Variáveis
Sabendo destas informações, deni as minhas variáveis de entrada: vão, va-
riação de altura e centro da base. A variação de espessura não foi incuída
levando em consideração que não é uma variável, mas sim diretamente pro-
porcional ao vão. Também um intervalo de valores de entrada possível; o
vão deverá estar no intervalo de [12000, 72000], tendo em vista que os dados
contidos na gura 5 só nos permitem dimensionar entre estes valores, e a
variação deverá estar no intervalo [0.0, 1.0]. Valores diferentes dos citados,
impossibilitarão a construção da cúpula.
Já as variáveis de saída são: "cúpula"e "superfície". A superfície, é aquela
gerada pela revolução do meridiano, sem extrudar; E a cúpula é o obje-
tivo maior, gerado pela extrusão da superfície, onde o valor de espessura é
retirado da gura 5.

4.1.2 Meridiano
O meridiano é o arco gerado pela secção vertical da cúpula, mas neste artigo
utilizaremos o caminho inverso, onde o meridiano é necessário para a cons-

5
Figura 4: Cúpula

Figura 5: Tabela de Diâmetro x Altura x Espessura. Fonte: REBELO, Y.


A concepção estrutural e a arquitetura

trução da cúpula. Para a construção do meridiano, precisamos de 3 pontos


(A, B, C ) que vão formar um arco. Todos os pontos usam como base as
coordenadas do centro de base ; os pontos A e C se alteram no eixo X so-

6
mando ou subtraindo a metade do vão, reespectivamente; o ponto B se altera
somente no eixo Z, somando a altura. Como podemos ver no pseudo-código.

4.2 Superfície

Tendo criado o arco, agora temos que criar a superfície da cúpula. Para
isso utilizamos o comando RevSurface, onde criamos uma linha que vai do
ponto centro da base até o ponto B para servir de eixo de rotação, e com ela
rotacionamos o meridiano para gerar uma superfície. Aqui o arco meridiano
deve ser transformado em curva para funcionamento do comando.

4.3 Cúpula

Por m, com a superfície gerada é feito um oset utilizando a espessura


calculada pela tabela na gura 5.

4.4 Singularidade

Figura 6: Singularidade na Cúpula

O componente funciona muito bem, exceto por um único ponto, existe


um erro de singularidade como podemos ver na gura 6. Para testar pos-
sibilidades de resolver este problema, programei visualmente a cúpula pelo
Grasshopper e pude constatar que a solução do problema está no arco. O
comando RevSurface gira 360◦ , e como o arco é "completo", quando rotacio-
nado, o ponto mais alto dele passa innitas vezes pelo mesmo lugar, gerando

7
este erro como podemos ver na gura 6 esta vilosidade superfície.
Para solucioná-lo, então, é simples: criar meio arco ao invés do "completo".
Assim, o arco não passa duas vezes no mesmo lugar e gera uma superfície
limpa como na gura X, sem a sombra na superfície.

Figura 7: Cúpula corrigida no Grasshopper

4.5 Universo de discurso

Cúpula
Material(Cúpula) = concreto
Forma(Cúpula) = semi-esfera
Meridiano
Origem(Meridiano) = Secção vertical da cúpula
Forma(Meridiano) = arco
Paralelo
Origem(Paralelo) = Secção horizontal da cúpula
Forma(Paralelo) = círculo

4.6 Pseudo-código

CÚPULA AUTO-DIMENSINÁVEL:
Declara variáveis de entrada: vão, variação de altura e centro de base;
Avalia consistência dos dados de entrada;
Define o valor de altura e espessura da cúpula, baseado nas tabelas e variação;

8
Cria 3 pontos utilizando o centro como referência:
A (centro.X - vão/2, centro.Y, centro.Z),
B (centro.X, centro.Y, centro.Z + altura),
C (centro.X + vão/2, centro.Y, centro.Z);
Interpola os 3 pontos em um arco "Meridiano";
Cria uma linha "Eixo" passando pelos pontos "Centro" e "B";
Cria um superfície de revolução rotacionando "meridiano" na linha "Eixo";
Extruda superfície pelo valor de espessura;

5 Discussão e conclusões

Esta disciplina foi realmente um desao, já que por mais que já tivesse con-
tato com programação visual, sabia muito pouco sobre sintaxe computaci-
onal. Entretanto, ao longo do semestre, com a ajuda do orientador Juarez
Franco, e das referências bibliográcas pude chegar a este resultado que con-
sidero satisfatório.
A conceitualização de uma estrutura pré-existente ajuda a notar a lógica
dos elementos que compõem os componentes e um sistema. A relação entre
componentes que formam o sistema podem ser descritos através da lógica de
primeira ordem.
O uso de componentes auto-dimensionáveis é muito útil para a arquitetura
e engenharia, facilitando a comunicação entre os dois universos. É essencial
para o arquiteto ter noções sobre estrutura, e os componentes gerados nessa
disciplina complementam o que pode ser estudado através do livro de Re-
belo.
A componente cúpula por mim programado resulta em uma forma pré-
dimensionada para uma cúpula feita de concreto, a partir do vão desejado.
A resultado nal tem um erro de singularidade que não feta sua eciência. A
solução para este problema é usar somente meio arco para gerar a superfície
de revolução; esta resolução pode ser tema para outro artigo complemen-
tando este.

6 Apendix

using System;
using System.Collections.Generic;

using Grasshopper.Kernel;
using Rhino.Geometry;

namespace Cupula
{
public class CupulaComponent : GH_Component

9
{
/// <summary>
/// Each implementation of GH_Component must provide a public
/// constructor without any arguments.
/// Category represents the Tab in which the component will appear,
/// Subcategory the panel. If you use non-existing tab or panel names,
/// new tabs/panels will automatically be created.
/// </summary>
public CupulaComponent()
: base("Cupula", "Cúpula",
"Cúpula",
"AU254", "Elementos Estruturais")
{
}

/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_Input
ParamManager pManager)
{
pManager.AddNumberParameter("Vão", "L", "Vão", GH_ParamAccess
.item);
pManager.AddNumberParameter("Variação de Altura Admissível",
"VH", "Variação admissível na altura da cúpula", GH_ParamAccess.item);
pManager.AddPointParameter("Centro de Base", "CB", "Centro
do paralelo de base da cúpula", GH_ParamAccess.item);
}

/// <summary>
/// Registers all the output parameters for this component.
/// </summary>
protected override void RegisterOutputParams(GH_Component.GH_Output
ParamManager pManager)
{
pManager.AddSurfaceParameter("Superfície", "S", "Superfície",
GH_ParamAccess.item);
pManager.AddSurfaceParameter("Cúpula", "C", "Cúpula",
GH_ParamAccess.item);
}

/// <summary>
/// This is the method that actually does the work.
/// </summary>

10
/// <param name="DA">The DA object can be used to retrieve data
from input parameters and
/// to store data in output parameters.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
// DECLARAR VARIÁVEIS DE ENTRADA
double vao = 0;
double variacao = 0;
Point3d pontoorigem = new Point3d();

// ATRIBUA VALORES ÀS VARIAVEIS DE ENTRADA


if (!DA.GetData(0, ref vao)) return;
if (!DA.GetData(1, ref variacao)) return;
if (!DA.GetData(2, ref pontoorigem)) return;

// CONSISTÊNCIA DOS DADOS DE ENTRADA


if (vao < 12000 || vao > 72000)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "este parâmetro
varia no intervalo [12000,72000]");
return;
}

if (variacao < 0 || variacao > 1)


{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "este parâmetro
varia no intervalo [0,1]");
return;
}
// DECLARE AS VARIAVEIS DE SAIDA
List<Surface> lstsuperficie = new List<Surface>();
List<Surface> lstcupula = new List<Surface>();

//ATRIBUIR VALORES AS VARIAVEIS DE SAIDA


Cupula minhacupula = new Cupula(ref vao, ref pontoorigem,
ref variacao);

// EXIBIR RESULTADOS
DA.SetData(0, minhacupula.srfcupula);
DA.SetData(1, minhacupula.srfespessura);
}

private class Cupula


{

11
// PROPRIEDADES DA CLASSE
public Plane baseSystem;
public Vector3d Zaxis;
public Vector3d Xaxis;
public Vector3d Yaxis;
public Surface srfcupula = null;
public Surface srfespessura = null;
public Point3d pontoorigem;

public double vao = 0;


public double v = 0;
public double h = 0;
public double e = 0;
public double minH = 0;
public double maxH = 0;
public double minE = 0;
public double maxE = 0;

// CONSTRUTOR
public Cupula(ref double vao2, ref Point3d pontoorigem,
ref double variacao)
{
v = variacao;
vao = vao2;

ALTURA();
ESPESSURA();
MERIDIANO();
}

// MÉTODOS
private void ALTURA()
{
double x = vao;
double x0 = 0.0;
double x1 = 0.0;
double y0 = 0.0;
double y1 = 0.0;

// CALCULE MINIMO
if (12000 < x && x <= 18000) { x0 = 12000; x1 = 18000;
y0 = 1750; y1 = 2000; }

12
if (18000 < x && x <= 45000) { x0 = 18000; x1 = 45000;
y0 = 2000; y1 = 5250; }
if (45000 < x && x <= 63000) { x0 = 45000; x1 = 63000;
y0 = 5250; y1 = 8500; }
if (63000 < x && x <= 72000) { x0 = 63000; x1 = 72000;
y0 = 8500; y1 = 10250; }
minH = y0 + (y1 - y0) / (x1 - x0) * (x - x0);

// CALCULE MÁXIMO
if (12000 < x && x <= 18000) { x0 = 12000; x1 = 18000;
y0 = 3500; y1 = 4250; }
if (18000 < x && x <= 27000) { x0 = 18000; x1 = 27000;
y0 = 4250; y1 = 6000; }
if (27000 < x && x <= 63000) { x0 = 27000; x1 = 63000;
y0 = 6000; y1 = 13000; }
maxH = y0 + (y1 - y0) / (x1 - x0) * (x - x0);

// CALCULE ALTURA
h = minH + v * (maxH - minH);
}

private void ESPESSURA()


{
//vao = eixo.Length;
double x = vao;
double x0 = 0.0;
double x1 = 0.0;
double y0 = 0.0;
double y1 = 0.0;

// CALCULE MINIMO
if (12000 < x && x <= 18000) { x0 = 3500; x1 = 4250;
y0 = 55; y1 = 62.5; }
if (18000 < x && x <= 27000) { x0 = 4250; x1 = 6000;
y0 = 62.5; y1 = 75; }
if (27000 < x && x <= 63000) { x0 = 6000; x1 = 13000;
y0 = 75; y1 = 125; }
minH = y0 + (y1 - y0) / (x1 - x0) * (x - x0);

// CALCULE MÁXIMO
if (12000 < x && x <= 18000) { x0 = 1750; x1 = 2000;
y0 = 55; y1 = 62.5; }
if (18000 < x && x <= 45000) { x0 = 2000; x1 = 5250;
y0 = 62.5; y1 = 100; }

13
if (45000 < x && x <= 63000) { x0 = 5250; x1 = 8500;
y0 = 100; y1 = 125; }
if (63000 < x && x <= 72000) { x0 = 8500; x1 = 10250;
y0 = 125; y1 = 137.5; }
maxH = y0 + (y1 - y0) / (x1 - x0) * (x - x0);

// CALCULE ESPESSURA
e = minH + v * (maxH - minH);
}

private void MERIDIANO()//(ref double vao, ref Point3d pontoorigem)


{
Point3d StartPoint = new Point3d();
Point3d MidPoint = new Point3d();
Point3d EndPoint = new Point3d();
StartPoint.X = pontoorigem.X - vao / 2.0;
EndPoint.X = pontoorigem.X + vao / 2.0;
MidPoint.Z = pontoorigem.Z + h;

Arc meridiano = new Arc(StartPoint, MidPoint, EndPoint);


Curve novomeridiano = meridiano.ToNurbsCurve();
Line eixo = new Line(pontoorigem, MidPoint);
srfcupula = RevSurface.Create(novomeridiano, eixo);
srfespessura = srfcupula.Offset(e, 0.01);
}
}
/// <summary>
/// Provides an Icon for every component that will be visible in
the User Interface.
/// Icons need to be 24x24 pixels.
/// </summary>

protected override System.Drawing.Bitmap Icon


{
get
{
// You can add image files to your project resources and
access them like this:
//return Resources.IconForThisComponent;
return null;
//return Cupula;
}
}

14
/// <summary>
/// Each component must have a unique Guid to identify it.
/// It is vital this Guid doesn't change otherwise old ghx files
/// that use the old ID will partially fail during loading.
/// </summary>
public override Guid ComponentGuid
{
get { return new Guid("{7f80660a-cc9a-4f6a-bcce-54f91ad90709}"); }
}
}
}

Referências

[1] J. M. S. Franco and E.M. Batista. Application of shape grammar to the


design of steel tubular spatial trusses. In Eighth International Conference
on Advances id Steel Structures, Lisboa, 2015.
[2] William J. Mitchell. A Logica Da Arquitetura. Ed. UNICAMP, São Paulo,
2008.
[3] Y.C.P. Rebello. A Concepção Estrutural e a Arquitetura. ed. Zigurate,
São Paulo, 2003.

15