Archive for the ‘Uncategorized’ Category

Hanging Chain Simulaiton Tool

Monday, November 28th, 2011

Hanging Model of Colonia Güell, Gaudi, source: http://www.rolfdieternill.de/pictures/tragwerkslehre082_Page_3.jpg

This “Simulation Design Tool” is inspired by Gaudi’s work. It turns neshes into so called Particle Spring Systems that act similar to physical hanging chain models.
The resulting “funicular shapes” represent structures performing well as tension systems – or, when inverted – as pressure structures.

The most simple system is a single haning chain as shown in the following video. The segmented line sinks and approximates a catenary shape.

To start a simulation, a B-net is drawn. Using the subdivision tools in the context menu the shape is subdivided to create panels.

Attaching a PhysicsSpringSystem to this B-net, turns it into a Particle Spring System. The vertices of the Net become particles and the edges connecting them turn into elastic springs. When starting the simulation, the system relaxes and starts moving. Changing the gravity moves the particles up or down.

Using the sliders on the right, additional constraints can be applied to the system. They act as additional forces on each panel, trying to planarize it or qualizing its edges’ or diagonals’ length. The system autommatically balances all applied forces.

When re-editing the underlying B-net, the simulation adopts. Changes in edges’ length are translated into changes of spring restlengths. Fixpoints will move along automatically.

Attaching a PhysicsMeshExtrusion to the simulation B-net creates a thickened shell. The thickness of the shell is informed by the spring forces in the system. The higher the imbedded forces, the thicker the shell. This is a relative assignment and the minimum and maximum thickness are controled by sliders.

The shape can be modified locally by using one of the specialist tools. They allow control over local spring forces (relaxing or tightening) and over local vertex weight.

Share

Morphogenetic Studio at Aarhus School of Architecture 2010-2011

Saturday, January 29th, 2011

Morphogenetic Studio is an experimental investigation of form generating processes through digital as well as analogue tools. The studio takes its starting point in an exploration of how relations between the general and the specific might be challenged by digital design techniques. Architects have of course always been interested in how general principles could be unfolded in specific design solutions informed by specific contextual conditions, but digital tools offer new ways of investigating these questions through the use of scripting and parametrically controlled models.  Digital models also offer new ways of linking design and realisation processes, which is another core interest of the studio. Morphogenetic Studio investigates these questions with an emphasis on spatial and tectonic potentials and possibilities.

 The studio is based on an integration of architectural teaching and research in the field of digital tectonics and algorithmic design.  The goal is to create an environment that is rooted in specific research subjects and which can generate products that reflect the research and at the same time can become a part of it.

Final installations

101015-London-3

101015-London-3

101015-London-3

101015-London-3

101015-London-3

Exhibition and Presentation

101015-London-3

101015-London-3

101015-London-3

 

 Final books and videos 

 
.interference by Bjarke Schødt, Mathias Meldgaard, Thomas Bang & Troels Holm | Make Your Own Book

 

 
MORPHOGENESIS OF ANT SWARM INTELLIGENCE by Christine Hauge Ringsmose, Agnija Rubene, Mikkel Horsbøl Lauridsen & Tobias Theil Konishi | Make Your Own Book

 

Morphogenesis Of Ant Swarm Intelligence from Tobias Theil Konishi on Vimeo.

Morphogenetic Studio // Cell Structures by Kristoffer Rauff, Lars Borgen, Annica Carina Tomasdotter Ekdahl, Anne Winther Worm | Make Your Own Book
 

Students:

  • Lars Borgen,
  • Annica Carina Tomasdotter Ekdahl,
  • Kristoffer Rauff,
  • Anne Winther Worm,
  • Troels Holm,
  • Thomas Bang Madsen,
  • Mathias Meldgaard,
  • Bjarke Lehmann Schødt
  • Nikolaj Bogensee Johansen,
  • Ragnar Zachariasen,
  • Tatiana Mukhina
  • Tobias Theil Konishi,
  • Mikkel Horsbøl Lauridsen,
  • Christine Hauge Ringsmose,
  • Agnija Rubene
  • Anita Vårbo Berglund,
  • Pelle Hviid Andersen,
  • Mateusz Bartczak

 

Teachers: 

  • Claus Peder Pedersen,
  • Niels Martin Larsen,
  • Sebastian Gmelin
Share

Parametric Objects in B-processor

Monday, May 24th, 2010

The first attempts to create curved objects in B-processor lead to the following conclusions:

  • Any curved object will need a series of input parameters usually called control vertices, control polygon or control mesh
  • This input is used to compute the curve from an algorithm
  • There is a desire to change the parameters after the curve was computed. This means the object should provide the flexibility to redraw itself once an input parameter changed.

It was discussed that this problem could be described more generally as a parametric object providing the following functionality and parameters:

  • The object is a group of elements: geometrical input, additional parameters, a script (i.e. the algorithm computing a curve) and the resulting geometry
  • The script would be run each time of the input parameters (geometrical or additional) is changed.
  • Rerunning the script recomputes the resulting geometry. In the case of B-processor this means to delete the previous result and redraw the geometry. It was discussed to only redraw local changes instead of the complete geometry but this will rather be a later optimization.
  • All element parts are organized within the object browser as children of the main geometry object, allowing the user easy access.
  • The geometry parameters of the object will be realized using the existing B-net functionality.
  • The attached scripts should be Java scripts to allow full functionality and access to all methods and properties. In a second step a scripting languages “B-script” could be implemented, allowing the creation of simple scripts.
  • The object should be set up very flexibly, i.e. an object should be allowed to create new objects or being the input for other objects (lofts, sweeps…)

100519 parametric objects

Share

Uniform Nonrational B-Splines in B-Processor

Tuesday, May 4th, 2010

Implementation in B-Processor / Java:
public static class UniformNonrationalBSpline extends Command {
  private Space net;
  /**
   * Constructs a frame command
   * @param net Space
   */
  public UniformNonrationalBSpline(Space net) {
    this.net = net;   
    parameters.put(“subdivisions”, 5.0);
    parameters.put(“UNRBSname”, “Unifrom Nonrational BSpline”);
  }
  /**
   *
{@inheritDoc}
   */
  public String title() {
    return “Unifrom Nonrational BSpline”;
  }
  //bring edges in order
  public static List<Edge> order(List<Edge> edges) {
      LinkedList<Edge> ordered = new LinkedList();
      if (edges.size() > 0) {
       Edge first = edges.get(0);
          ordered.add(first);
          edges.remove(0);
          while (edges.size()>0) {
           for (int i = 0; i < edges.size(); i++) {
            search:
            if (edges.get(i).contains(ordered.get(ordered.size()-1).to)) {
             //check direction
             if (!edges.get(i).from.equals(ordered.get(ordered.size()-1).to)) {
              Vertex temp = edges.get(i).to;
              edges.get(i).to = edges.get(i).from;
              edges.get(i).from = temp;
             }
             //add at end of Linked list
             ordered.add(edges.get(i));
             edges.remove(i);
             break search;
            } else if (edges.get(i).contains(ordered.get(0).from)) {
           //check direction
             if (!edges.get(i).to.equals(ordered.get(ordered.size()-1).from)) {
              Vertex temp = edges.get(i).to;
              edges.get(i).to = edges.get(i).from;
              edges.get(i).from = temp;
             }
             // add at beginning of Linked List
             ordered.add(0, edges.get(i));
             edges.remove(i);
             break search;
            }
           }
          }
      }
      return ordered;
    }
 
  public Vertex unrbsCalc(List<Vertex> gConst, double t) {
   Vertex blend = new Vertex(0,0,0);
   if (gConst.size()==4) {
    double[] tempCalc = new double[4];
    tempCalc[0] = ((1-t)*(1-t)*(1-t))/6;
    tempCalc[1] = (3*t*t*t-6*t*t+4)/6;
    tempCalc[2] = (-3*t*t*t+3*t*t+3*t+1)/6;
    tempCalc[3] = (t*t*t)/6;
    for (int i=0; i<=3; i++) {
     blend.x = blend.x + tempCalc[i]*gConst.get(i).x;
     blend.y = blend.y + tempCalc[i]*gConst.get(i).y;
     blend.z = blend.z + tempCalc[i]*gConst.get(i).z;
    }
    System.out.println(blend.x);
   }
 return blend;
  }
  /** {@inheritDoc} */
  @Override
  public void evaluate() {
    String UNRBSname = (String) parameters.get(“UNRBSname”);
    double subdiv = parameters.getDouble(“subdivisions”);
   
    List<Vertex> vertices = new ArrayList(net.getVertices());
    List<Edge> edges = new ArrayList(net.getEdges());
    List<Vertex> orderPoints = new ArrayList();
    List<Vertex> curvePoints = new LinkedList();
    if (vertices.size()>=3) {
     LinkedList<Edge> nEdges = new LinkedList();
     nEdges = (LinkedList) order(edges);
     // write into List
     for (int i=0; i<nEdges.size(); i++) {
      orderPoints.add(nEdges.get(i).from);
     }
     orderPoints.add(nEdges.get(nEdges.size()-1).to);
     // make Spline go through endpoints
     for (int i=0; i<=2; i++) {
      orderPoints.add(orderPoints.get(orderPoints.size()-1));
      orderPoints.add(0,orderPoints.get(0));
     }
     
     // create space object to draw new elements
  Space result = Space.createUnion(UNRBSname);
 // calculate Uniform Nonrational Spline Curve
  for (int i=3; i<= orderPoints.size()-2; i++) {
   for (int t=0; t<subdiv; t++) {
    curvePoints.add(unrbsCalc(orderPoints.subList(i-3, i+1),t/subdiv));
   }
  }
  // draw Spline Curve
  for (int i=1;i<curvePoints.size()-1;i++) {
   result.add(new Edge(curvePoints.get(i-1),curvePoints.get(i)));
  }
  
  
  net.getOwner().add(result);
    }
  }
}
Share

Approval of biannual evaluation No. 1 concerning the period September 2009 – March 2010

Thursday, March 25th, 2010

At its meeting on 23 March 2010 the Research Board approved Sebastian Gmelin’s first biannual evaluation and his PhD-plan without further comments.

Share

Research Plan

Friday, March 12th, 2010

The research plan for this project was now handed in for approval with the research committee of the Aarhus School of Architecture.
It contains the following chapters and sections and can be downloaded as a pdf at the bottom of this post.

1 Abstract

2 Definitions

2.1 Building Information Modelling (BIM)
2.2 B-processor
2.3 Project title

3 Project description

3.1 Hypothesis
3.1.1 BIM software can be used as an intuitive and intelligent design tool
3.1.2 Material elasticity can be used to simply and cheaply build double curved surfaces
3.1.3 Elastic deformation simulation can be integrated in BIM software as intuitive design tools
3.1.4 Further parameters can be used for design tools in a similar way
3.2 Problem
3.2.1 Complex geometry – design to production
3.2.2 B-processor – curved surfaces

4 Objective

4.1 Simulation methods
4.1.1 Input
4.1.2 CAD tool
4.1.3 Output
4.2 Optimization methods
4.2.1 Input
4.2.2 CAD tool
4.2.3 Output

5 Research structure

5.1 Curved geometries and their computational representation (research module 1)
5.2 Simulation parameters (research module 2)
5.3 B-processor and Java scripting (research module 3)
5.4 Case studies
5.4.1 Material Elasticity
5.4.2 Structural Systems
5.4.3 Selfshading surfaces
5.4.4 Space solving
5.4.5 Acoustic surfaces

6 Context

6.1 Practical relevance and reason for double curvature
6.2 Research context
6.2.1 Chair of Digital Fabrication (Prof. Gramazio and Prof. Kohler) ETH, Zurich
6.2.2 Chair of CAAD (Computer Aided Architectural Design, Prof. Hoverstadt) ETH, Zurich
6.2.3 Centre for Information Technology and Architecture, CITA (Mette Ramsgard Thomsen), Copenhagen

7 Education background and interest in complex geometry

8 Supervision

8.1 Work and research setup
8.2 Supervision extent

9 Courses and Conferences

9.1 Courses / Workshops
9.1.1 bips, digitale byggeri, samarbejde
9.1.2 Masterclass Ecotect
9.1.3 Philosophy of Science
9.1.4 Digital Crafting Workshops
9.1.5 Future courses
9.2 Conferences
9.2.1 Main conferences
9.2.2 Additional regular conferences

10 Time Schedule

10.1 Research modules
10.2 teaching
10.3 conferences and courses
10.4 Thesis

11 Conclusion

Nomenclature

List of Figures

Bibliography

Share

Update to research plan

Monday, November 2nd, 2009

Added diagrams to the research plan page.
http://www.gmelin.li/PhD/research-plan/

Share

research on basic elasticity calculation

Monday, September 28th, 2009

Refreshed my crude knowledge on elasticity calculations…

 

090927 research elasticity 01
090927 research elasticity 01

 

 

090927 research elasticity 02
090927 research elasticity 02

 

 

090927 research elasticity 03
090927 research elasticity 03

 

 

090927 research elasticity 04
090927 research elasticity 04

 

 

090927 research elasticity 05
090927 research elasticity 05

 

 

090927 research elasticity 06
090927 research elasticity 06

 

 

090927 research elasticity 07
090927 research elasticity 07

 

 Weblinks:

http://en.wikipedia.org/wiki/Young_modulus

http://en.wikipedia.org/wiki/Poisson%27s_ratio

http://en.wikipedia.org/wiki/Hooke_law

http://en.wikipedia.org/wiki/Shear_modulus

 

 
Share