Arch Workbench

This page is an attempt to collect ideas about parametric design in the field of architecture. Since it is a bit different than the mech engineering field, I want to define concepts a bit better before thinking about how to start implementing it... Feel free to add your ideas!

similar software

 * Revit


 * Archicad


 * Generative Components

file formats

 * STEP - already fully working in FreeCAD


 * IFC
 * http://forge.osor.eu/plugins/wiki/index.php?id=175&type=g an IFC sdk
 * http://www.bimserver.org/

general concepts

 * FreeCAD is perfect for the task. Designing with parametric objects will greatly reduce the only real problem I see in FreeCAD, which is dealing with thousands of objects. Everything needed is there already, like custom object types, custom properties, etc. The main difficulty, designing a general model for dealing with interaction between objects, is now potentially over, since FreeCAD introduced a dependency graph especially for that purpose.


 * BIM (building information modeling) is a concept invented by a couple of building parametric design software vendors, principally autodesk. It means that you don't project a building by drawing anymore, but by inserting information (parameters). The software would then produce a drawing automatically. This is totally bullshit hightly questionnable in my opinion and only a propaganda concept. Even in most advanced bim software around (Revit, Archicad and Microstation GC), you can't abstract the act of drawing unless you want to kill any creativity. The goal here is not to be the most automatic, but to keep flexible.


 * Mech enginnering parametric design is usually based on changes history and constraint solving. Those two concept have much less importance in building design, since you rarely want to crawl back in the steps you did (they are usually very simple), and keeping constraints like horizontality, angle, or distance, even if they are useful, is not as important as in mech design.


 * Arch parametric design is based on archetypes: wall, door/window, roof, slab, beam, are the basic ones. Outside them, what you'll mostly have are derivatives of those


 * It makes heavy use of assembly: for example several windows are grouped together to form a curtain wall


 * Relationship is the key. Elements are rarely very complex or require much modeling work, but they must often be transformed by the juxtaposition or inclusion of other elements. For example a wall is nothing else than a simple extrusion, but it must connect to other walls, or take a hole when a window is inserted into it. How to build that relationship model and how/where to store it is the big problem.


 * A problem of about all parametric building modeling software is that they rely heavily on those archetype objects. Creating new, not-in-the-library parts, is extremely hard (Archicad) or much easier (Revit) but always a bit of a problem, and there is always a big communication problem between "parametric" parts and "non-parametric" parts. Basically you only gain the full power of the software if you use parts that are made for the job. For example transforming a simple solid into a wall is extremely problematic.


 * An autodesk paper about Revit: http://images.autodesk.com/adsk/files/bim_parametric_building_modeling_jan07_1_.pdf this article is mostly a propaganda for Revit, and several concepts are IMHO unimportant, like "generated" 2d drawings vs the ability to modify your model in 2d, but it is interesting anyway.


 * Speed of object calculation is not a very big issue IMHO. Modifying an object shouldn't affect many other objects, and it is usually made in a phase of adjustments, so it's not so important to have lightning-speed updates. One important thing, though, is to always save the final shape of objects, so opening saved models should not require calculations. Before saving, everything should always be recomputed.


 * A state-of-the-art section tool is very important.


 * There is the problem of annotation. Where to draw dimensions? on the model? Directly on the svg sheet? Not very practical... This point must be investigated further.


 * A "parametric building" should be understood as a mix of relationship-capable objects (archetype-based) and other, non-archetype based. Transforming one object from one category to another should be feasible, and all should behave the same way under sectionning (and dimensioning).


 * A system for creating new components and assemblies, graphically if possible


 * An edit mode, so one can modify the original shape that generated the part.

about archetypes

 * All archetypes should always behave like object-oriented programming objects: You can make a new class based on another class.


 * All archetypes should be able to interact with common object. For this, probably common objects would need custom properties.


 * Walls should be defined by a simple wire (that would be extruded horizontally, then vertically), a planar shape (that would simply be added a thickness) or a solid (that would be done nothing). The result would always be a solid. Its parameters would therefore vary, depending of your data at the time of creation.


 * Walls should connect to crossing/touching walls


 * Walls could be made of different layers (materials). Same materials would connect together.


 * Walls don't really need a drawing tool. You make them easily by converting something else. But in that case, the draft module could gain a "double-line" tool.


 * Doors/Windows are quite simple objects, their parameter almost only concerns their internal look. But they must have a "box" that creates holes in other objects.


 * Beams and Slabs are simple too, but depending on their materials they must be able to connect to other slabs, beams and walls. Beams and slabs could also be joined into one single "structural" element. There are pillars too. All of them could be defined the same way as walls, by a wire, a shape or a solid. They could even be based on the same basis as walls...


 * Roofs are a special type of object, not very interesting in their own actually, but useful because it's painful to calculate a roof manually. Basically you need to create a shape based on a contour and inclination. Should be easy to do and to extend later to other roof types


 * Assemblies need to be defined further. They are basically made of other parts, that could be anything, shapes, windows, etc... and custom properties, such as array repetition, deformation (follow a shape?), etc.

Wall
Wall is vertical, follows a path on the ground or is extruded horizontally from a vertical surface, can be made of several layers (materials, each one with specific thickness), and can have a quantity of holes (subtractions) or appendices (unions). It should also connect to the other walls by same material. The vertical area and volumes must be calculated

Door/Window (Insert element)
Doors and windows are really the same thing, a totally object which can have a lot of parameters to define its shape, and an invisible volume that is used to cut openings through receiving walls. They are typically inserted into a wall, but not always. since they can differ much, they should be easy to design.

Roof
Roof is simply a handy way to calculate roof slope intersections

Slab
Slab is horizontal, made from extruding vertically a closed wire or face, should connect by material to other structural members, and can have a number of appendices (union) or holes subtraction), and layers (materials). The horizontal areas and volume must be calculated

Beam/Pillar (Structural element)
A closed wire or face extruded in any direction, can have a number of appendices (union) or holes subtraction).

Assembly
A group of windows that can be shaped as a whole

generic mechanisms

 * Dependency: windows must know which wall they are inserted, walls must know which window they contain, etc... See part booleans
 * Joints: walls must know which other wall connect to them and correctly connect their materials together. Moving a wall must therefore recalculate the neighbours. Establish a chart of possible joint types
 * Edge categories: some edges must not be drawn when they are between 2 objects of same material. Mark edges for choosing later how to render them.
 * Auto-grouping: Objects of a certain type go automatically into specific groups
 * "Window designer": An easy way to design parametric windows, based on profiles