Final crit

The final crit is this Friday, 12th November. From our department, the staff will be Patrick Janssen, Cheah Kok Ming, Shinya Okuda, Huang Yi Chun. From the ETH group, the following people will be attending:

• Prof. Dr. Gerhard Schmitt
  http://www.arch.ethz.ch/~gschmitt/,  http://www.ia.arch.ethz.ch/
• Dr. Stefan Mueller
  http://www.arch.ethz.ch/~stefanmu/web/
• Gideon Aschwande (PhD candidate)

The crit will be taking place in Vis Lab (2nd floor, direclty opposite the Lift). A projector has been arranged.

• You need to pin up our drawings on Thursday 5pm in the DTS studio, 
• You need to move the boards to the Vis Lab on Friday morning using the lift. 
• You need to test your presentations on Friday morning so that we do not have technical problems during the presentation.
• You need to plan your presentation so that each member of the group participates in some way in the presentation.
• The final presentation will start at 2pm. You must all be present for all presentations. Each group will have a maximum of one hour for presentation and questions. However, I would suggest to keep the presentation short - maybe 20 minutes. Then we have about half an hour for discussion.

Crit list as follows:

1. Li Ran, Ye Hanyu
2. Yu Xiao Xuan, An Aram, Wang Bin
3. Nittin, Venkat, Vignesh
4. Chen Zengyuan, Lee Sian Chyun, Hui Tung Sing

Crit

The next crit has been moved back a few days - it will be on Wed 3rd November. For this crit, the focus is the simulations. We want to see iterative experiments, with simulation results. In order to be able to run the simulations, you will of course first need to have well defined building forms.

Food and drinks

Please remember that food and drinks are not allowed in the computer rooms. This is becoming a real problem lately - so eat your food outside, and keep the lab tidy and clean.

Agents

The agent group has found that using the DOP network is very slow. I have created a different method of setting up agent simulations that uses only SOP networks and it seems a lot faster (I have not tested the difference in speed yet). The way it works is that at each frame, you store (i.e. save in memory) some attributes for your geometry - usually this will be the position of the points (but may also include some other attributes if needed). These attributes can then be retrieved in the next frame, so that the agents can start from where they stopped in the previous frame.

Here are the nodes:

• phtj agents - has a 'store' and 'retrieve' nodes, for storing and retrieving attributes.

And here is an example file using these node:

• Example agents - some simple agent behaviours

Interim crit

Interim crit will be next Thursday - 21st October. All groups should have:

• their developmental diagram
• the houdini model of that diagram
• variants produced using the houdini model

The variants should be situated on the site. Use the site model to place the variants within the site context..

Each group should print 3 A1 presentation panels (minimum - more is also ok). Please also show your previous three panels from the last crit as well.

Latest version of Houdini

I have heard from the newsgroup hat the latest version of Houdini (11.0.483) has fixed the python problem with the AttribCreate node. So if you install this version, then the nodes I have created should work... I have not yet had time to test it.

phtj_urban has been updated

The phtj_urban otl has been updated. I have made various improvements here and there with most of the nodes. (I have not yet fixed the problem with version 11 - that is coming soon.)

• sky, day, and sun view factors - I have added an option to switch on or off point generation
• privacy, scenic and unobstructed view factors - I have add the option to switch on or off line generation

These options should make it easier to work with these nodes. Download and overwrite as usual.

Deadline for individual submission

The deadline for the individual submission is approaching, so it is time to focus on this and get it done. The deadline is Monday 27th September, 2pm.

There are some key things to remember, starting with the most important:

• Make sure that you iterate!!! The complexity of the form is less important. The most important thing is that you have iterations showing differing levels of performance. Make sure that you extract the data and plot the graphs as we did during the tutorials. We discussed three different types of graphs - 1) parameter sweeps, 2) pareto graphs, and 3) spider diagrams. Use these techniques to understand whether you are improving things, or making things worse. In order to iterate through large numbers of variants, use the animation tools (e.g. the stair CHOP) to develop and evaluate variants automatically.
• When you are considering you evaluation criteria, you need to choose at least two criteria. Try to choose criteria that conflict - for example maximise day VF and minimise sun VF. Then you need to decide what surfaces to analyze - just analyzing everything may not make sense. You will also need to consider carefully how to calculate some global values that represent the overall performance of each variant - do you take the average? or the area weighted average? or just the total? or do you calculate the percentage above a certain threshold?For example, for sun VF you may want to calculate the number of windows with a sun VF of more than 20%.
• Start with a very simple building form!!! I would suggest something like a slab, or a group of slabs, or a tower. Make sure that everything you generate is the right plot ratio. The proportions of these forms should be building like - e.g. don't make apartment blocks that are 30 meters deep. Start by varying these simple geometries and running simulations for these variants. Find the simple form with the best performance. Try to choose parameters that result in forms are still feasible - there is no point in simulating something that you already know will not work anyway. So if you have a slab apartment block, then there is no point in varying the depth much, since you already know that it is very constrained by daylight and ventilation issues.
• Then you can start to make the form more complex to try and improve performance even more. This usually means adding a few parameters to your simple form so that you can generate further variants. Run the simulations again to check if you were right - did performance get better or worse? If it got worse, then try something else but make sure you keep the bad results in your graphs. When making the form more complex, don't over do it - keep it manageable. And remember - we are only interested in the overall massing, and some general ideas of internal layout (e.g. lift cores, circulation) - so don't worry about the handrails...
• Some of you are exploring some more complex form generating techniques, like metaballs and L-systems. But even with these techniques, start simple. Use these techniques to generate a range of building forms, from very simple to more complex, and then simulate to test so that you can understand how performance changes with complexity. So, an L-system can make a straight tower, and a slab block... so start there.
• In order to come up with an idea for your simple form, you may decide to run some initial simulations as a way of understanding the site better. This may involve inserting some simple geometries into the site - e.g. a big cylinder or a big box  (these are not really building forms, since the plan is much too deep). Some of you have already done this and produced some interesting data. Now it is time to start inserting some buildings.

For the submission, you must 1) do a presentation, and 2) submit an A3 landscape booklet covering your presentation. You may also submit a CD with animations if you wish.

Associative Design

Here is an interesting example of using parametric and associative modeling techniques in design. It is from students in the Ber lager Institute.

• Associative Design  - YouTube video
• Peter Trummer - Head of Associative Desig
• Some discussion

Scenic View Factor

There was an error with the Scenic View node that has now been fixed. SO please re-download phtj_urban.otl again and overwrite the old file.

Here is a test file using the new node:

• Example 7 - evaluating scenic view factor

Site for design project

The project site is in Jurong East:

•  Design Project Site

Your task is to design a high-density mixed-use development. Currently, the plot ratio for the site is approximately 5. Our aim is to explore the possibility of a higher density environment. For your project, you will need to make a proposal with a plot ratio of 8. This will result in about one million square meters of floor space.

It will be up to you to decide the detailed program, but the mixed-use development should include commercial, residential, and retail.. The site includes both an MRT / LRT station and a Bus Interchange, and the movement of large flows of people will therefore be an important issue. Car parking will also need to be considered.

Here are some links for Jurong East:

• Image of URA proposal
• URA site
• YouTube video

An interesting comparison is the Elements Shopping centre in Hong Kong. Our site is about 12 Hectares, and the Hong Kong site is about 14 Hectares. The plot ratio for the Hong Kong site is also 8:

• Comparison of two sites
• Elements Shopping Centre

To start with, you will need to gather information about Jurong East, and create a digital site model that includes the existing and future proposed buildings around the site. This model should be created as a group exercise - please divide up the tasks to maximize efficiency.

You will then split into your groups and start developing proposals for the site. You will need to develop the proposals using some form of Iterative Virtual Prototyping, following on from the elective. As part of this process, you will need to define how you are going to evaluate the performance of your proposals.

Houdini Modelling 101 v3

Here is the Houdini Modelling 101 document in PDF format - so that you can click on the links. This is the same as the one that I handed out in class. (I can't remember if I have sent this link before - but here it is.)

• Houdini  Modelling 101

I will try and add some more stuff over the next few weeks and uplaod an updated version. The current version does not cover the 3 ways of managing variants : 1) takes, 2) channels, 3) chops. This will be added to the next version of this doc.

Example 5

Here are the example from last week

• Example 5 - the twisted tower, with some evaluations
• Example 6 -  the simple box, with two evaluations

The brief

Here is the brief for AR5953A Topics In Design Technology:

• The site is a large block (175m x 185m) based on a site in Marina Bay area. Please see the houdini file for more details. An abstract model of surrounding buildings has been generated using the densities from the URA 2008 plan.
• The task is to develop a proposal for a mixed-use urban morphology that is high density and that also provides good quality of life.
• Mixed-use in this case means office, residential, and commercial. The number of people working in the building should be equal to the number of people living in it.
• High density means an overall plot ratio of 13 (i.e. 420,000 sq meters). This is the plot ratio that has been set by the URA. Car parking should also be considered, and is not included in the area calculations.
• Good quality of life means thinking about various issues that make life enjoyable. These will include daylight, ventilation, views, privacy, open spaces, noise, etc. The importance of these issues will be different for residential, commercial , and office.

The aim of this brief is for you to demonstrate your own IVP design methodology. Therefore, the main focus is on the process rather than on the final outcome. You will need to show how you have used the IVP tools and techniques to achieve the final outcome.

Some other links:

• For more information on plot ratio
  http://www.ura.gov.sg/circulars/text/dcdgfahb_d0e127.htm#d0e144
• The URA development guidelines
  http://www.ura.gov.sg/circulars/text/dcdnrhb_d0e4.htm
• The general design guidelines for tall buildings should be followed
  Tall Buildings: A strategic design guide

Here are some key areas:

• Parking: 20 m2 per car
• Residential: 30 m2 per person
• Flat: 90 m2
• People per flat: 3.5 people
• Office: 20m2 per person
• Commercial: 7 m2 per flat

phtj_urban

Here are the otl files for the workshop today:

• phtj_urban
• phtj_utils

Copy it to one of your scanned otl folders on your computer .

Example 4 - towers

Here is the example from yesterday - the merging towers:

•  Example 4

This uses the 'metaball' node tocreate volumes that merge automatically to create complex surfaces.

Example 3

Here is the example from yesterday - the snake:

•  Example 3

This uses the 'switch' node to subdivide panels that are too big.

phtj_chops

Here is an otl file for the workshop today:

• phtj_chops

Copy it to one of your scanned otl folders on your computer - this will be explained in the workshop.

3D Buzz

For some other good beginners videos, have a look at 3D Buzz

• 3d Buzzz - Fundamentals
• 3d Buzz - How do I?

You will have to register first before you can watch any of the videos - registration is free.

Example 2

Here is the example from yesterday:

•  Example 2

Files

Here are some files from last week:

• Example1 - hip file and otl file (save them in the same place)
• Houdini Modelling 101 - version 3 (you can follow the web links)

Houdini

The version of Houdini we will be using is the apprentice version 10 or version 11.

Documentation

The documentation is all available online, as well as inside the software. For the online help:

• Houdini online docs

Videos

The first videos to watch are the ones included when you install Houdini. In Houdini, go to the menu, click Help > Start Here. This will open up your browser window, and there will be the various links, including some links to videos. The
"Introduction to Houdini UI" is the place to start.

• Introduction to Houdini UI

There are some excellent videos to help you learn Houdini. Many of these videos are for version 9, but if your are using version 10, that is OK - the interface is mostly the same in versions 9n and 10.

Peter Quint has also created some excellent videos to learn Houdini. These videos tend to be a bit easier for beginners, since they don't assume any prior knowledge.

• Peter Quint videos

On the Houdini Apprentice blog, there are some good videos to get started:

• Houdini Apprentice Blog videos
  
  • Introduction to Houdini's New User Interface
  • Introduction to Houdini's Node Based Workflow
  • View and Display Tools in Houdini 9
  • Working with Selection Modes
  • Working with Panes and Viewports
  • Working with Curves and Surfaces
  • Polygon Modeling with Subdivision Rendering

On the Houdini site there are also some other videos introducing the interface, which is useful for beginners.

• Houdini 9 Interface videos

And there are also some videos on specific tools:

• Surface Operations
• Copy Stamp
• Carve Tool
• Orient Objects to a Curve
• UV Texturing

There are also a set of commercial companies producing videos.

• CARDANFX
  
  • Free Videos
• 3D Buzz Houdini
  
  • H9 Fundamental Videos
  • How Do I... Videos
    

 The is a Houdini You Tube channel where the Houdini people regularly uoload videos, oftend highlighting the latest features of the software. So these videos are probably less useful for beginners, but great to see the amazing things that can be dione with Houdini.

• Houdini YouTube channel

Of course there is also some other stuff on YouTube. here are a few:

• AppleSoldier Houdini Videos on YouTube
• AppleShakeGuru videos on YouTube
• CARDANFX videos on YouTube

There are also a bunch of commercial training videos that are not free. See the list of companies here:

• Companies creating Houdini training videos

Ted Talk on IVP

Here is an interesting talk on Ted Talks

• Ted Talks: Build a tower, build a team

Welcome

Welcome to the start of the studio. Just to recap what we will be doing, here is the description of the studio.

The aim of this studio is to develop an iterative design methodology that consists of creating parametric models and evaluating variants generated by these models. You will be required to use advanced digital tools to develop an optimized design proposal that explores the trade-offs between multiple and conflicting evaluation criteria.

The semester will be split into two parts:

• Elective (AR5953): “Tools and Techniques for IVP”
• Week 1 to week 4: Mon, Wed and Thu afternoons
• Total 12 afternoons.Week 5: Assignment due, to be completed individually.

• Studio: (AR4103): “IVP Studio” 
• Week 5 to week 12: Mon, Wed and Thu afternoons
• Total 24 afternoons.Week 13: Final project due, to be completed in groups of three. All the students in the group will get the same grade.

For the elective, you will be introduced to the conceptual framework that is referred to as Iterative Virtual Prototyping. You will learn how to think about design in a new way. Rather than creating one design, you will be creating a digital process that is capable of automatically generating and evaluating large numbers of design variants. The main tool that you will use is called Houdini, developed by Sidefx. This tool is the most advanced procedural modeling tool that exists today, and you will be using it for both design development and design evaluation. You will also be linking to EnergyPlus and Radiance to run simulations of design performance.

For the studio, you will be working in groups of three, and you will sink or swim (or fly) as a group. You will be required to use the Iterative Virtual Prototyping methodology to develop a complex design proposal for a high-density mixed-use design for Jurong East MRT station. For the design, you will need to create a digital process that consists of both design development procedures and design evaluation procedures. For development, you need to explore how to parameterize your design ideas so that the right types of variants can be generated, and for evaluation, you need to identify key performance criteria that you would like to use for comparing design variants. At the final crit, you need to present the methodology used to arrive at the final design.

The end in sight

The end is not far away now - good luck with the final effort. Of course, the printer will be jammed so please try and give yourself as much time as possible. See you all on Thursday...

Just one more thing - I am still missing one more book - "New Geographies" - this was the one with the huge block of flats for 60,000 people...

• http://www.gsd.harvard.edu/academic/upd/agakhan/newgeographies/web_issue01.htm

Bug with pzp file fixed

I have fixed the pzp file - it is now working again.(It is the same as before - no changes.) You can download as usual:

• http://files.patrick.janssen.name/2010/pzp.zip 

Bug with pzp file

Just to let you know, the latest pzp file seems to have an error when you try and unzip it - I will fix it as soon as possible.

Exporting from Houdini

You can export from Houdini in a number of different ways - the easiest is probably the File SOP. (Remember that SOP you always have to delete when you create a geometry container - well finally it is useful.) I did a quick test importing to Rhino - the iges file format seems to work the best. If you are importing to other programs, you need to do some simple tests before you try and import you massive model.

• http://files.patrick.janssen.name/2010/export_to_rhino.hipnc

Privacy View Factor

I have finished the privacy evaluation node - I have called it Privacy View Factor. It calculates a privacy measure for each window. Privacy is affected only by overlooking from other windows. So it does not take into account people on the ground or the street, so I guess it is best for highrise.

The way it does this is that, for each window, it finds the worst neighbour - i.e. the one overlooking you the most. The worst neighbour is calculated based on the distance and the angles of the windows. The value is then converted to a percentage - 100% means complete privacy, while 0% means no privacy.

• http://files.patrick.janssen.name/2010/privacy_view_factor.zip

Random Delete

Many of you are now getting into the evaluation part, and you might be finding that the analysis is quite slow sometimes. If you have 20,000 windows, and you try the analyse Sky View Factor, you will probably get the dreaded 'Memory Allocation' error...

So you need to reduce the number of surfaces. If you have a lot of surfaces, then you can actually just select a random sample to analyse. As long as the selection is random, the results will still be representative of all the surfaces. So in the case of 20,000 windows, you can analyse just 10% or 20%.

To help you do this, I have created a Random Delete node:

• http://files.patrick.janssen.name/2010/random_delete.zip

Scenic View Factor

While helping Ying Ying this morning, I created another evaluation node, called Scenic View Factor. This node will allow you to input a set of points that identify scenic views. The inputs are as follows:

• Input 1: The faces you want to analyze
• Input 2: The obstructions that might block your view
• Input 3: The scenic view points.

 The node will then work out the number of scenic points that you can see from each face that is analyzed, and display the result as a colour and a percentage. So 100% means that you can see all the scenic points from that face, will 0% means that you can see none of them.

• http://files.patrick.janssen.name/2010/scenic_view_factor.zip

Triangular grids

Some of you need grids that are triangulated with equilateral triangles. Here is an otl to do it:

• http://files.patrick.janssen.name/2010/tri_grid.zip

Bad designs are good

During tutorials yesterday, we had a number of discussions about the importance of keeping your low performance designs.

You need to present all your variants, even if they are very low performance. You will have created developmental and evaluation processes. You will of course be hoping that the developmental process produces design variants which, when evaluated, have good or at least reasonable performance. But in the end, this may not be the case.... the performance may be terrible! But this does not matter - do not try and hide these designs. We are interested in the success of the process, not the success of the designs. And a process that highlights that your designs are weak is a good process... You can then try and change your developmental process to produce  better designs.

Crit next monday

This is a reminder that as stated in the schedule, we will have a crit next Monday. For this crit, the most important thing is to have a Pareto graph... we want to see a set of variants evaluated according to some criteria and plotted onto the Pareto graph for comparison.

Other things that you should also have are:

• developmental diagrams
• evaluation diagrams
• a map of your design process which shows what you have been doing in the last few weeks

ps I have recovered from the flu, so tutorials as usual today

Passive Zone Proportion (updated)

I have updated the Passive Zone Proportion node so that it now works much faster. Instead of 'brickering' polygons, I now use an offset, which is a lot faster. The inputs are also a bit simpler - no need to input the walls any more. Just the floor polygons will do. The node is in the same place as before:

• http://files.patrick.janssen.name/2010/pzp.zip

For those who still want access to the old node, it is here:

• http://files.patrick.janssen.name/2010/pzp_old.zip

Evaluation nodes

In order to help people started with their evaluation processes, I have been creating various evaluation nodes that that I have been uploading on the blog. So far, I have created the following nodes:

• Unobstructed Vision Area node for evaluating horizontal views 
• Passive Zone Proportion node for evaluating % passive floor area. This relates daylight levels inside the space.
• Sky View Factor node for evaluating % visible sky. This relates to levels of daylight and views (feeling of enclosure).
• Sun View Factor node for evaluating % of visible sun. This relates to solar radiation.

There are various other things that can be measured. I may add a few more nodes. There are also more advanced simulations using EnergyPlus and Radiance, but it is better to start with the simpler types of evaluations.

They key for you is to start thinking about how you might use such nodes in you evaluation. Also, try and figure out the process at a small scale - then, once you know what you are doing, scale it up. These evaluations can be slow, so don't just put thousands of polygons into one of these nodes and then wonder why it does not work. You will probably not be able to evaluate the whole 1 km2 in one go - you will need to break it down.

A number of people have asked about how to insert these evaluation nodes and the otl files. When I create a node, I typically create one or more otl files, and one hipnc file. The otl files contain the actual node, and the hipnc file is just an example of using the node. If you want to use one of these nodes in you file, you need to install the otls. First copy the otl's to the folder where you are working, and then in Houdini menu go to File > Install Digital Asset Library

Iterative Design Process

So far, most of you have been focusing on your developmental process that will be used to generate design variants. You will then need a way of comparing your variants. So at this stage, it is important to start working on your evaluation process. It is important that you identify at least two criteria for evaluation, so that you can plot your design variants on your pareto graphs.

At the end of semester, we will be focusing on the your iterative design process, rather than the final design. It is therefore vital that you have more than one iteration - preferable more than ten iterations. To do this, you need to have both a developmental process and an evaluation process.

Since the focus will be on the process, it is important not to get caught up with trying to solve everything. At the moment, many of you are trying first to solve everything before starting on your iterations - if you do this you will never get there. You need to start iterating as soon as possible - even if the iterations are based on a very simple developmental and evaluation processes. You can then gradually add in more complexity as you go, and only where it is really necessary. It is better to have a simple design idea where the iterative design process can be applied successfully, than a complex idea with only one or two iterations.

Sun View Factor

It has been very quite - not many requests. So in the meantime, I worked on another otl for evaluation. I have created a node called "Sun View factor". It is similar to the Sky View Factor node:

• For the Sky View Facto, it calculates the % of the sky dome that is visible from the centre of any face.
• For the Sun View Factor, it calculates the % of the sun dome that is visible from the centre of any face.

The sun dome is the area of sky where the sun may be at some point in the year. It is a slice of the sky dome. So , if you get a Sun View Factor of 100%, it means that the sun is always visible, 100% of the year.

The other thing I have added to the node, is the option to apply Lambert's cosine law. This will give a result that is more closely related to the amount of solar radiation hitting the face. Basically, when this law is applied, the calculation takes into account the fact that the sun hitting a face straight on is more intense than the sun is hitting a face obliquely. If you apply the Cosine Law, then the values you get will always be lower than without the law - often about half. So you will never get 100% - even for you roof.

Here is the node:

• http://files.patrick.janssen.name/2010/sun_view_factor.zip

If you right click on the node, and select Help, you will find some help for inputs and parameters.

The wave building

I have done an example of a building in a wave form - a number of you have had some questions about this.  I think it is also a useful example to look at, even if you are not doing wavy buildings.

You can change various parameters - one subnet generated the wave curve, and another subnet then offsets the curve. This offset was harder than it might first seem, since you have to try and avoid self intersecting forms. The example also displays the total floor area - which can be very useful.

• http://files.patrick.janssen.name/2010/wave.hipnc

Flu

I have been a bit unwell today, so I will work from home. I will  conduct tutorials etc from home all of tomorrow. If you have technical queries, then send me the file via email. If you want to have discussions, then we can phone or skype.

Passive Zone Proportion

I have created a Houdini node to calculate the Passive Zone Proportion (PZP), as described in the book "Energy and Environment in Architecture: A Technical Design Guide", by Nick Baker and Koen Steemers.

The PZP compares the floor area a certain distance from the facade to the total floor area. So for example, if you set the range to be 6 meters, then it will calculate the total % floor area that is 6 meters from the facade. This area of the floor is called the passive zone, since it has the potential to be passively lit and ventilated. 

Usually, the depth passive zone is assumed to be twice the floor to ceiling height. So if your space if 4 meters hight, the passive zone is the floor area 8 meters from the facade.

The node is a bit more flexible, and it allows you to enter multiple ranges. For example, if you enter "3, 6, 9", then it will calculate 4 values: 1) the percentage floor area between 0 and 3 meters from the facade, 2) the percentage between 3 and 6 meters, 3) the percentage between 6 and 9 meters, and 4) the percentage above 9 meters.

• http://files.patrick.janssen.name/2010/pzp.zip

Update

On Monday we came to the following overall breakdown of the 5 million square meters:

• Assume that there are 100,000 people working and living on our site. There will be some overlap between these groups - i.e. some people will be both working and living there. But there will also be some people who live there but work elsewhere, and some people who work there but live elsewhere. But I guess that it would be safe to assume that most of the 100,000 people who are living there will be working either within our site or close by somewhere in the CBD. This may affect how you approach the issue of parking. 
• For office, we can assume 20m2 per person. So for 100,000 people, we get 2 million square meters of office. You can assume that office space is fully air-conditioned. A key challenge will be daylight - how to make sure that offices get reasonable daylight.
• For living, we will need to break down the remaining 3 million square meters into 1) residential, and 2) other activities (shopping, recreation, etc). 
• In order to get some idea about the amount of space required for the other activities, we need to know the number of households. The current average for Singapore is 3.5 people per household, so that is 28,571 households. Lets round it up to 30,000 (since the overall trend is that households are getting smaller). Based on 30,000 households we can use Belinda's paper to calculate that we need about 0.2 million square meters. You need to think where to put this space - and how it relates to residential and office spaces.
• This leaves 2.8 million square meters for residential.  So if we assume 30,000 households, then we get 93 m2 per household. Note that this includes common circulation and any other common spaces in addition to the size of the actual flat. I am not sure what the percentage is - but lets say it around 14% - then we get the average floor area of the flat to be about 80 m2 for 3.5 people, which is about 23 m2 per person. This sounds reasonable. Note that this does not mean that all flats should be 80 m2 - there may be a mixture if different sizes. You can assume that the residential will be naturally ventilated, with AC being used only when it gets too hot.

Singapore stats

For statistics in Singapore, there is a good government site with some useful data here:

• http://www.singstat.gov.sg/stats/keyind.html

Sky View Factor (update)

I have updated the sky view factor otl - fixed some bugs

The link is the same as before:

• http://files.patrick.janssen.name/2010/svf.zip

Unobstructed Vision Area

The Unobstructed Vision Area (UVA) is a useful way of assessing how much view each window in the design gets. Here is an otl to calculate the UVA. This gives UVA as a percentage - 100% means that you have a 100% view, while 0% means you have no view at all (i.e. there is a wall directly in front of your window).

• http://files.patrick.janssen.name/2010/uva.zip

See Professor Edward Ng's paper on the use of UVA in Hong Kong.

• http://www.vickycheng.com/Research/Daylight%20for%20High%20Density%20Cities.pdf

Kees Christiaanse

"SITUATIONS" Urban Design Strategies and Resources by Kees Christiaanse on 01 March 2010 (Monday), 7pm at LR427

This lecture should be relevant to your project - so please make sure you attend. 

• http://en.wikipedia.org/wiki/Kees_Christiaanse

Belinda Yuen

Belinda Yuen from the Department of Real Estate has written an informative article about housing in Singapore. It also has some useful statistics:

• http://www.huduser.org/periodicals/cityscpe/vol11num1/cityscapevol11num1.pdf#page=9

(Note: it is the first article - page 3 to 18)

Sky View Factor

You need to start thinking about how to evaluate your urban morphologies. One interesting measure that is used a lot is called the 'Sky View Factor'. It is the percentage of visible sky that you can see from any point. 100% indicates that you can see the whole sky (i.e. a half dome), and 0% indicates that you can't see any sky.

I have created an otl for calculating SVF. Here it is.

• http://files.patrick.janssen.name/2010/svf.zip

Five million

I have created a Houdini file that generates some city layouts for a 1 km x 1 km square area, with 5 million sq meters of space. Here it is:

• http://files.patrick.janssen.name/2010/five_million.hipnc

Design project

Thanks all for the presentations on Firday. The issues that were raised will be looked into, particularly the various odd results that you got form some of the simulations.

Now for the next stage. Here is the brief:

• The site is one square kilometer (1km x 1km) in the Marina Bay area. Please see the houdini file for the exact location: http://files.patrick.janssen.name/2010/site.zip
• The task is to develop a proposal for a mixed-use urban morphology that is high density and that also provides good quality of life.
• Mixed-use in this case means that the number of people working in the area should be equal to the number of people living in the area.
• High density means an overall ratio of 5 (i.e. 5 million sq meters). This ratio is a little bit lower than the existing URA proposal for Marina Bay.
• Good quality of life means thinking about various issues that make life enjoyable. These will include daylight, ventilation, views, privacy, open spaces, good transport, noise, etc. The importance of these issues will be different for residential, commercial , and office.

For the site, you will need to consider how to connect to the 4 different edge conditions:

• North West: Shenton Way, Robinson Road and the CBD
• North East: Buildings on the Harbour Front, including The Sail
• South East: land to be developed at a later stage - plot ratio to be approximately 10.
• South West: ECP express way and container port.

Pareto graphs

For your variants, you need to plot out the results for cooling versus electric lighting, both in kWh/m2/year.

So for example 6, this would be as follows:

• Total building area = 7200.00 m2
• Simulation period = 22 days
• Cooling: District Cooling = 46914.56 kWh
• Therefore cooling = (46915 / 7200) * (356/22) = 105 kWh/m2/year
• Electricity: Interior Lighting = 1834.80 kWh
• Therefore lighting = (1834 / 7200) * (356/22) = 4 kWh/m2/year

On the pareto graph, you are trying to minimise both, so points closer to the origin are better.

You will notice immediately that the lighting cannot compete with the cooling. But this is only in terms of energy. There may be other reasons why you think daylight is important - e.g. the well-being of the office workers. So it is still valid to plot lighting against cooling, even though lighting uses much less energy.

Houdini links

Just came across some useful links:

Singapore user group (very new):

• http://www.facebook.com/group.php?gid=160618185680
  

odforce

• http://odforce.net/
• http://forums.odforce.net/index.php?/forum/19-modeling/

 3daet:

• http://www.3daet.com/cat/27/houdini/

 Houdini Tools

• http://www.houdinitools.com/
• http://www.fourthwall.ndo.co.uk/HT_Otls.html
  

 Houdini in Korean

• http://www.houdini.or.kr/
• http://cafe.naver.com/sidefx
  

Exercise 2

The objective of this exercise is to do a sketch design for an office building. The criteria are as follows:

The Site

• The plot is 85m x 170m, rotated at 45 deg, with the long axis in the NW - SE direction
• The site is surrounded on all sides by category 3/4/5  roads, with no other surrounding structures
• The site is somewhere in Singapore

The Developmental Constraints

• The maximum plot ratio is 13
  http://www.ura.gov.sg/circulars/text/dcdgfahb_d0e127.htm#d0e144
  
• The URA development guidelines apply
  http://www.ura.gov.sg/circulars/text/dcdnrhb_d0e4.htm
• The general design guidelines for tall buildings should be followed
  Tall Buildings: A strategic design guide
  

The Evaluation Criteria

• Maximise daylight autonomy
  Using EnergyPlus, see 'Daylighting:Controls'
  
• Minimise cooling load
  Using EnergyPlus, see 'ZoneHVAC:IdealLoadAirSystem'
  
• Maximise lettable floor area

BIG | Bjarke Ingels Group

BIG is coming to town! - this coming Friday January 29th, 2010 at 4pm LR 423 speaking on “Yes is More”. RSVP by 27 Jan 2010 to Clara at akicwkm@nus.edu.sg

Custom Python operators

Here is the script that we did today:

# Get the data
this_node_obj = hou.node(".") #this is the same as hou.pwd()
geom_obj = this_node_obj.geometry()
points_list = geom_obj.points()

# Find the average
average = [0,0,0]
for point_obj in points_list:
    average[0] = average[0] + point_obj.position()[0] # could use +=
    average[1] = average[1] + point_obj.position()[1]
    average[2] = average[2] + point_obj.position()[2]
num = len(points_list)
average = [average[0] / num, average[1] / num, average[2] / num]

# Save the data
new_point_obj = geom_obj.createPoint()
new_point_obj.setPosition(average)

Houdini Python parameter expressions

When scripting in Houdini, there are two languages that you can use. The old scripting language is called hscript, and the new one (gradually replacing hscript) is Python. When scripting in Python, there are many different places where you can insert Python scripts - the two most important are:

• Parameter expressions: these are Python scripts inside the parameter input fields. You can right click on an input filed, and select Expressions > Edit Expressions. You need to make sure that your scripting language is set to Python. These scripts are saved as part of you Houdini model, in you .hip (or .hipnc) file.
• Python operators: these are custom nodes implemented from scratch in Python. These are saved in .otl files, and can be used the same way as the built in nodes.

In yesterdays workshop, we focused on parameter expressions, and we wrote some expressions to find the average of a set of input points. Here is the script:

# Get the data
this_node = hou.node(".")
inputs = this_node.inputs()
first_input = inputs[0]
input_geometry = first_input.geometry()
points = input_geometry.points()

# Loop through add add up all the points
x = 0
for point in points:
    point_pos = point.position()
    x += point_pos[0]

# Divide the values by the number of points
num_points = len(points)
x = x / num_points

# Return the value
return x

The Houdini functions and classes are all in the hou module. When scripting in Houdini, the hou module is imported automatically, so there is no need to have 'import hou' in your scripts. The key ones to loo at from todays sessions are the following:

• hou.node() function
• hou.Node class
• hou.Node.inputs() method returns a tuple of input
  
• hou.SopNode class (which is a sub class of hou.Node)
• hou.SopNode.geometry() method returns the geometry data in a node object
  
• hou.Geometry class
• hou.Geometry.points() method returns all the point data  in a geometry object
  
• hou.Point class
• hou.Point.position() method returns the x,y,z position of the point object

In order to better understand what is going when using the Houdini classes above, review Python classes in one of the tutorials. For example, in the Instant Hacking  tutorial , scroll down to the last section "More Abstraction — Objects and Object-Oriented Programming". This gives a quick explanation of classes.

Python Introduction

I am doing a Introduction to Python workshop on monday morning 10am to 1pm.

This is mainly for the people who missed thePython workshops in week zero. However, for those who think they need a refresher, you can also come.

Please make sure that you have done these two tutorials before Monday morning:

• One Day of IDLE Toying 
• Instant Hacking 
  

Semester Schedule

•  Week 1 Mon 11 Jan: Studio intro, followed by Houdini intro
  

Exercise: Flying object

• Week 1 Thu 14 Jan: Houdini workshop
  
• Week 2 Mon 18 Jan: Houdini workshop
  
• Week 2 Thu 21 Jan: Houdini workshop
  
• Week 3 Mon 25 Jan: Presentation of exercise 1
  

Exercise: A room

• Week 3 Thu 27 Jan: Tutorials
• Week 4 Mon 01 Feb: Tutorials
  
• Week 4 Thu 04 Feb: Tutorials
• Week 5 Mon 08 Feb: Presentation of exercise 2
  

Project: design site and design brief

• Week 5 Thu 11 Feb: Introduction to design site and brief, followed by site visit
  

Recess week and non-studio week:

•  Recess week Mon 15 Feb
  
•  Recess week Thu 18 Feb
  
• Week 6 Mon 22 Feb: Non-studio week
  
• Week 6 Thu 25 Feb: Non-studio week

Project: the design idea:

• Week 7 Mon 01 Mar: Tutorials
• Week 7 Thu 04 Mar: Tutorials
• Week 8 Mon 08 Mar: Presentation (Interim crit 1)
  

Project: iterative design process:

• Week 8 Thu 11 Mar: Tutorials
• Week 9 Mon 15 Mar: Tutorials
• Week 9 Thu 18 Mar: Tutorials
• Week 10 Mon 22 Mar: Tutorials
• Week 10 Thu 25 Mar: Tutorials
• Week 11 Mon 29 Mar: Presentation (Interim crit 2)

Project: presentation production 

• Week 11 Thu 01 Apr: Tutorials
• Week 12 Mon 05 Apr: Drawing up
• Week 12 Thu 081 Apr: Drawing up

Hand in

• Week 13 Tue 13 Apr: Drawing Submission & Pin up 3pm to 4pm
• Week 13 Wed 14 Apr: Model Submission 3pm to 4pm
  
• Week 13 Thu 15 Apr: Crit Session
  
• Week 13 Fri 16 Apr: Crit Session

Exercise 1: Flying Object

The first exercise is an Iterative Physical Prototyping exercise. The aim of this exercise is to investigate the iterative design process using non-digital tools and techniques on a highly simplified design problem.

The problem is as follows:

• Design a flying object made of A4 paper. Your design must start with your core idea or concept for the design. This is your creative leap, a moment where past experience and intuition result in some new possibilities... Note that the flying object does not necessarily need to be a plane. It can be like a floating object, or it can spin as you drop it,... Some seeds float in the wind in interesting ways.
• Create a developmental diagram for the design. This diagram should specify parameters that can be vary within a certain range. Different designs can then be generated by specifying different values for the parameters.
  
• Create a evaluation diagram for the design. The evaluation diagram will specify certain performance criteria. These performance criteria can then be used to calculate the fitness of the design relative to other designs. Possible performance criteria could be distance travelled, time in the air, number of loops, maximum height, ... etc.
  

Once you have created your diagrams, you then need to start the process of generating and testing different design variants. After a while you may find that your original idea is not working so well, and that you have some new ideas. In such a case, you can update the diagrams, and then start generating and testing new variants.

The deadline for this exercise is Monday 25th January. This is a group exercise - so get into groups of 2 or 3. Your final presentation should focus on the process - so we want to see a series of diagrams, and for each diagram, a set of variants. Try and map out what happened, and why you made certain decisions.

Another aspect of this exercise is to start practicing generating clear diagrams. The diagrams need to be as clear and simple as possible. I.e.  - there should be nothing on the diagram that is superfluous. The best way to learn these type of graphic skills is to copy other people - look at other diagrams such as origami. Also, some architects also use diagrams in an interesting way - e.g. look at BIG | Bjarke Ingels Group

Some light reading

To get you into the right frame of mind, it may be useful to read the AD issue, called 'Programming Cultures'. It is accessible here:

• Programming Cultures ( July/August 2006)

Houdini Modelling 101 v2

I have created an introduction to modelling with Houdini for beginners. This is version 2, and I will update it every now and then. There will also be an introductio to Houdini Scripting coming soon.
This intro is to be used in conjunction with the videos available on line - not as a replacement. The intro focuses mainly on the concepts you need to get started with Houdini. It does not teach you in detail where to click and how to use specific tools.

• Houdini_Modelling_101_v2.pdf

Python and EnergyPlus

Here is the script from todays session. This script generates the IDF input file for EnergyPlus. Note that this script requires a base file, i.e. rather than generating the whole IDF file, the script only generates the surfaces and appends these to the base file. To run this script, you will have to make the base file - just open 1ZoneEvapCooler.idf, save it as base.idf, and delete all the BuildingSurface objects in this file.

#======================================================================
# Imports
#======================================================================


#======================================================================
# Functions
#======================================================================
#Function to write a ep surface
def write_ep_surface(
    idf_file, name, srf_type,
    const,zone,boundry,boundry_obj,
    sun_exp,wind_exp,view_fact,
    points):

    idf_file.write("! Building Surface\n")
    idf_file.write("BuildingSurface:Detailed,\n")
    idf_file.write("  "+name+",\n")
    idf_file.write("  "+srf_type+",\n")
    idf_file.write("  "+const+",\n")
    idf_file.write("  "+zone+",\n")
    idf_file.write("  "+boundry+",\n")    
    idf_file.write("  "+boundry_obj+",\n")
    idf_file.write("  "+sun_exp+",\n")
    idf_file.write("  "+wind_exp+",\n")   
    idf_file.write("  "+view_fact+",\n")
    idf_file.write("  "+str(len(points))+",\n")
    for counter in range(len(points)):
        point = points[counter]
        text_point = str(point[0])+","+str(point[1])+","+str(point[2])
        if counter < len(points)-1:
            idf_file.write("  "+text_point+",\n" )
        else:
            idf_file.write("  "+text_point+";\n\n" )
    
#======================================================================
# Main Script
#======================================================================
# Create a simple box
box = (
    (0,0,0),(15,0,0),(15,15,0),(0,15,0),
    (0,0,10),(15,0,10),(15,15,10),(0,15,10),    
    )

floor_points = (box[3], box[2], box[1], box[0])
wall1_points = (box[1], box[5], box[4], box[0])
wall2_points = (box[2], box[6], box[5], box[1])
wall3_points = (box[3], box[7], box[6], box[2])
wall4_points = (box[0], box[4], box[7], box[3])
roof_points = (box[4], box[5], box[6], box[7])

#Create the idf file
idf_file_1 = open("D:/box.idf", "w")
base_file = open("D:/base.idf", "r")
base_stuff = base_file.read()
idf_file_1.write(base_stuff)
idf_file_1.write("!- ========================= \n\n\n")

# Add the surfaces
write_ep_surface(idf_file_1,
                 "zn001:floor", "Floor", "FLOOR", "Main Zone", "Surface",
                 "zn001:floor", "NoSun", "NoWind", "1.00", floor_points)
write_ep_surface(idf_file_1,
                 "zn001:wall1", "Wall", "R13WALL", "Main Zone", "Outdoors",
                 "", "SunExposed", "WindExposed", "0.50", wall1_points)
write_ep_surface(idf_file_1,
                 "zn001:wall2", "Wall", "R13WALL", "Main Zone", "Outdoors",
                 "", "SunExposed", "WindExposed", "0.50", wall2_points)
write_ep_surface(idf_file_1,
                 "zn001:wall3", "Wall", "R13WALL", "Main Zone", "Outdoors",
                 "", "SunExposed", "WindExposed", "0.50", wall3_points)
write_ep_surface(idf_file_1,
                 "zn001:wall4", "Wall", "R13WALL", "Main Zone", "Outdoors",
                 "", "SunExposed", "WindExposed", "0.50", wall4_points)
write_ep_surface(idf_file_1,
                 "zn001:roof", "Roof", "ROOF31", "Main Zone", "Outdoors",
                 "", "SunExposed", "WindExposed", "0.00", roof_points)
#Close the file
idf_file_1.close()
base_file.close()

Two ways of looping

Here are two ways of looping...
Lets say you have a list like this:

x = ("a", "b", "c", "d")

One way to loop through the list is like this:

for item in x:
    print "item = ", item

Another way of looping is like this:

for counter in range(len(x)):
    print "item = ", x[counter]

Python and Radiance

Here is the script from todays session:

#======================================================================
# Imports
#======================================================================
import os
import random

#======================================================================
# Functions
#======================================================================
#Function to write a light
def write_material_light(rad_file, name, rgb_e):
    rad_file.write("# Light material\n")
    rad_file.write("void light " + name + "\n")
    rad_file.write("0\n")
    rad_file.write("0\n")
    rad_file.write("3 " +
               str(rgb_e[0])+ " "  +
               str(rgb_e[1]) + " " +
               str(rgb_e[2]) + " " + "\n\n")

def write_material_plastic(rad_file, name, rgb, spec, rough):
    rad_file.write("# Plastic material\n")
    rad_file.write("void plastic " + name + "\n")
    rad_file.write("0\n")
    rad_file.write("0\n")
    rad_file.write("5 " +
               str(rgb[0])+ " "  +
               str(rgb[1]) + " " +
               str(rgb[2]) + " " +
               str(spec) + " " +
               str(rough) + "\n\n")

def write_surf_sphere(rad_file, name, material, position, radius):
    rad_file.write("# Sphere \n")
    rad_file.write(material + " sphere " + name + "\n")
    rad_file.write("0\n")
    rad_file.write("0\n")
    rad_file.write("4 " +
               str(position[0])+ " "  +
               str(position[1]) + " " +
               str(position[2]) + " " +
               str(radius) + "\n\n")
#======================================================================
# Main script
#======================================================================

#Create the scene file
rad_file_1 = open("D:/scene.rad", "w")

write_material_light( rad_file_1, "mat_light_1", (100, 100, 100))
write_material_plastic( rad_file_1, "mat_red", (0.7, 0.05, 0.05), 0.05, 0.05)

for i in range(2):
    position = (random.random() * 5, random.random() * 5, random.random() * 5)
    radius = random.random()
    write_surf_sphere(rad_file_1, "light_"+str(i), "mat_light_1", position, radius)

for i in range(20):
    position = (random.random() * 5, random.random() * 5, random.random() * 5)
    radius = random.random()    
    write_surf_sphere(rad_file_1, "ball_"+str(i), "mat_red", position, radius)

rad_file_1.close()

#Run radiance using oconv and rpict

#os.system("C:/Radiance/bin/oconv D:/scene.rad > D:/scene.oct")
#os.system("C:/Radiance/bin/rpict -vp 10 10 10 -vd -10 -10 -10 -av .5 .5 .5 D:/scene.oct > D:/scene.pic")

#Run radiance using rad

rif_file_1 = open("D:/scene.rif", "w")
rif_file_1.write("ZONE = I  0 5 0 5 0 5\n")
rif_file_1.write("scene = D:/scene.rad\n")
rif_file_1.close()

os.system("C:/Radiance/bin/rad D:/scene.rif")

Python functions

Here is the example of creating a Python function from todays workshop:

rec1 = [20,2]
rec2 = [24,9]
rec3 = [6,2]

def area(rec):
    area = rec[0] * rec[1]
    print(area)
    return area

area1 = area(rec1)
area2 = area(rec2)
area3 = area(rec3)

print("===")

print(area1)
print(area2)
print(area3)

Learning Python

Python is the scripting language we will be using.  You can download Python for free and install it on your own computer. We will be using version 2.5.4

There is lots of online help for Python.There is a list of the most popular tutorials for beginners, and here are a few good ones:

• One Day of IDLE Toying 
• Instant Hacking  
• A Non-Programmer's Tutorial for Python

The standard Python docs are also useful. Although we are using version 2.5, we will use the documentation for 2.6. The 2.6 docs are formatted in a better way, so it makes our life easier:

• Tutorial
• Library Reference
• Language Reference

Houdini

The version of Houdini we will be using is the apprentice version 10.0.

The installation is straightforward - just download and keep clicking Next. The best way to get started with Houdini is through the videos - see the DDM site for more info.

Be warned - it is not a normal CAD system, so it takes time to understand how things are done.

EnergyPlus

The version of EnergyPlus we will be using is version 4.

If you are installing EnergyPlus on your own computer, then you should avoid folders with spaces in the path. For example, something like C:\EnergyPlusV4-0-0 is a good place (which is the default). When you have downloaded EnergyPlus, note that you will need to wait for a password to be emailed to you. This email can take a while - up to 24 hours.

The help docs are here: 

EnergyPlus Reference:

• Getting Started and Overview (PDF 501 KB)
• Input/Output Reference (PDF 6.90 MB)
• Output Details and Examples (PDF 1.33 MB)
• Engineering Reference (PDF 6.62 MB)
• Auxiliary Programs (PDF 1.11 MB)

Radiance

The version of Radiance that we need to use is the latest version  - 2.0 Beta.

When installing Radiance,  you don't need all the AutoCAD stuff. All you need is the Radiance for Windows Rendering Engine. If you are installing this on your own computer, then you should avoid folders with spaces in the path. For example, something like C:\Radiance is a good place.

For the help docs you also need to avoid all the stuff about AutoCAD. Here are the links to the most useful help docs:

Radiance Reference:

• Radiance Tutorial
  
• Radiance Reference Manual
  

Semester 2, 2010

So a new semester starts. Last semester, we explored the potential of scripting using Rhino and Ecotect. The result was a great set of projects...

For this semester, we will be continuing with a similar studio brief, focusing of teh Iterative Virtual Prototyping process. The idea of this is as follows:

1. Propose an design idea and encode it as an algorithmic design schema:

• Create a developmental diagram
• Create an evaluation diagram
• Encode the diagrams in the form of a script
• Parameterize the script
  

2. Generate and optimise variants based on the design schema:

• Develop a set of design variants by specifying parameters
• Evaluate the design variants using simulation software
• Feed the results from evaluation back to the next stage of development

However, we will be changing the tools. The scripting language will still be in Python, but...

• For the evaluation part, we will be moving away from Ecotect and focusing more on Radiance and EnergyPlus. (Part of the reason for this is that you have already completed YiChun's simulation module, and so you should already be familiar with these tools.)
• For the modelling part, we will be using Houdini. This is an advanced procedural modelling package that allows you to dynamically interact with your scripts. There is a free version of Houdini that can be used, called Houdini Apprentice.

For the vehicle, last semester the brief was for a high rise building in Singapore CBD. This semester the brief will be similar - more details will be given on the site and brief in due course.

We will start with a scripting workshop this week on Wednesday, Thursday, and Friday morning. So if you are in my studio, please come at 10am on Wednesday in Oceania.