Friday, November 30, 2007
Thursday, November 29, 2007
As I was finishing my tutorial on manually placing shade devices as part of Revit's model envelope, I stumbled across this rather interesting "feature" that was exhibited while translating geometry into the gbXML file format. But before I continue to describe that particular Revit to gbXML behavior I need to make a correction to a statement in my previous article where I was testing Revit's ability to model shading devices by using In-Place families.
"Shading devices, constructed or planted, exterior or interior, can be approximated in Revit's BIM model via the persnickety use of a variety of modeling objects, but within Revit Architecture there is no identifier that designates any such improvisation as a valid gbXML compliant Shade surface. Someone might ask, but what about using a roof or a slab family to create exterior shading devices? Sounds like a good idea, but unfortunately to export such an element, the same one should be a part of a room bounding enclosure."
I need to praise Kyle Bernhardt for pointing out that this statement needs to be revised as follows: In Revit Architecture one can use Floors or Walls (stick with generic) to represent the shading surfaces. The Walls and Floors that are of the System Family type will get exported, but if you attempt to model them as In-Place families they will be ignored.
This means that any articulated solid extrusion made as an In-Place Wall or Floor will not be exported to the gbXML file.
Nevertheless in order to successfully export the objects mimicking Shading surfaces into the gbXML file, the warning message stating that a particular Room Bounding element is ignored should be disregarded and one can proceed with saving a new gbXML file.
Now back to glazing.
In order to test the available Window families and their corresponding operational (descriptive) parameter within the Revit Building Model, place an array of different window families along one wall in a sample model in order to see if the translated output will properly identify these windows according to the Window Type identifiers that are outlined within gbXML schema version 0.34.
Those Window type identifiers are as follows:
When building a model, if you resort only to Window families for facade apertures it really does not make any difference what type (Casement, Fixed, Awning, Glider etc.,) is used, as all of those will be translated with the "OperableWindow" gbXML type identifier.
The opposite in this glazing interpretation is that all of the Wall Family based glazing (Curtain Walls, Storefronts) is always translated with the "FixedWindow" gbXML type identifier.
The ability to eloquently articulate glazing performance in any building submitted via gbXML for analysis can not be regarded as accurate if the designer does not have the utmost control over the ventilation character of glazed surfaces. Unfortunately, within Revit Architecture we do not have the capability to designate windows operational descriptor, which means that the Curtain Wall family based glazing will always be simulated as non operable, whilst the Window family based glazing will always be characterized as operable type glazing.
One quick way to remedy this is to identify an element's ID and use it's value to parse and edit the gbXML file before is submitted to Green Building Studio for further analysis.
To mimic the sentiment of people that are trying to use Revit Architecture for Building Performance Analysis, it is quintessential to make some functionality changes to Revit's Room Object and make it behave more like the eSpace objects in Autocad Architecture where all of the relevant gbXML type identifiers can be directly assigned to the analytical space and its bounding elements such are walls and openings.
(Read the entire article...)
Tuesday, November 27, 2007
(Read the entire article on marketwire)
Thursday, November 22, 2007
The Importance of LEED certification and its necessity for the creation of a sustainable built environment can be debated from several perspectives but considering the integration of real time evaluation tools should be a prerequisite for the creation of any expert system that will be used for instantaneous knowledge (code / rule) feedback.
I have to admit that, besides a few scheduling screen shots in Revit Architecture and some in articles that were relevant to AutoCAD architecture, I have not seen any serious attempt to tie in more closely any application with the concept of LEED credits take-offs or any LEED scheduling framework provided by the software manufacturers.
Now some of you could ask the question why this example is not available in Revit Architecture, and the answer to this is quite simple. I do not know how to make it work, and in this instance I will blame this on my own ignorance unless some one out there can actually explain to me why one has to calculate the area property of an room object as a result of volume by unbound height division as this, in spaces that have a sloped ceiling, will produce an unacceptable inconsistency.
So in order to have an interactive real time daylight factor analysis tool one should work with these ingredients:
Window use classification
Property Set Definition
Space style Property Set Definition
Display Theme for DF (Daylight Factor)
One not particularly customized schedule
And a few lines of VBS code slowly brewing in the background.
First we start by defining a window object classification category that defines any instance of a style as either an EXTERIOR or INTERIOR window, where only those that the user marks as EXTERIOR will contribute to the EQ8.1 calculation.
The second step is to define three different List Property Definitions whose values represent different window factors that are required for DF calculation. Those factors are:
GF – geometry factor
HF – height factor
TVmin – minimum visibility factor
TV – visibility factor
For the sake of differentiating from the OOTB Property Set Definition I decided to create two new PSD one for Window Styles and the other one for Window Objects.The object based one is labeled as 01_LEEDWindowObject and this is the one where the link to the Space Object is documented through the “WindowSpaceID” property definition while its relevance for DF calculation is established by the “001WinLocation” classification based property definition. The space based PSD is labeled as 01_LEEDWindowStyles and this is where the previously described window variables are hosted.
“LEED_GF”, “LEED_HF”, “LEED_TV” and “LEED_TVmin” are all style bound and this is where the associated space object reads the relevant values for its daylight formula.To visualize DF in real time I have included a basic Display Theme that is providing for a graphical feedback based on the calculated DF.
Tying all this together was executed within Space Objects PSD and in particular within the formula property definition that taps into two ADT libraries in order to make this work.
Set acadApp = GetObject(,"AutoCAD.Application.17.1")
Set AecBaseApplication = acadApp.GetInterfaceObject("AecX.AecArchBaseApplication.5.5")
Set SchBaseApplication = acadApp.GetInterfaceObject("AecX.AecScheduleApplication.5.5")
Set ActiveDoc = AecBaseApplication.ActiveDocument
DF_win = 0
DF = 0
PropValue_GF = 0
PropValue_HF = 0
PropValue_TV = 0
PropValue_TVmin = 0
WinArea = 0
For Each obj In ActiveDoc.ModelSpace
objName = TypeName(obj)
If objName = "IAecWindow" Then
Set objPropSets = SchBaseApplication.PropertySets(obj)
Set objPropSet = objPropSets.Item("01_LEEDWindowObjects")
objWinLocation = objPropSet.Properties.Item("_WindowLocation").value
objWinSpaceID = objPropSet.Properties.Item("_WindowSpaceID").value
If objWinLocation = "EXTERIOR" and objWinSpaceID = "[ObjectID]" Then
Set PropSets = SchBaseApplication.PropertySets(obj.Style)
Set PropSet = PropSets.Item("01_LEEDWindowStyles")
PropValue_H = objPropSet.Properties.Item("Height").value
PropValue_W = objPropSet.Properties.Item("Width").value
WinArea = (PropValue_H * PropValue_W) / 144
PropValue_TV = PropSet.Properties.Item("LEED_TV").value
PropValue_TVmin = PropSet.Properties.Item("LEED_TVmin").value
PropValue_GF = PropSet.Properties.Item("LEED_GF").value
PropValue_HF = PropSet.Properties.Item("LEED_HF").value
DF = DF + DF_win
RESULT = DF * 100
When both of these requirements are met than the set of relevant variables is accessed via SchBaseApplication object and are being channeled to DF_win formula that is being compounded within the primary loop to create the final DF value for this given Space Object.
In order to evaluate the final daylight value for a floor plan I have created a schedule that does it, but similar compounding and property extraction code could have been used to calculate the final result within a Space Object.
The prerequisites for this DF real time calculation method are the following:
ACA 2008 or ADT 2007 due to their capabilities to apply classifications to an AEC object and their use of List definitions.
This code can be retrofitted to operate within ADT 2006 and 2005 in a slightly less sophisticated way.
The code within a Space Object can not query window objects within a x-ref file and therefore both the envelope and spaces have to be part of a same construct, or a plain independent file. It is worth mentioning that the code within these customized SpaceObjects is taking a toll on ACA’s performance, but as I have tested it on a 60000 SF project with the acceptable performance the entire process can be even more streamlined during the initial design by having a zonal approach to DF evaluation.
After downloading this sample file the user should try to rescale the windows associated with their spaces and observe the change in color as the DF for this space crosses the threshold of 2%. It is worth noting that in order to create a window with the different performance values the existing style should be copied into a new style and those values should be adjusted within this new style based Property Definitions.
For any of you that have ever driven a certain French car, and you know the connotation, and especially those that were made between 1955 and 1979 by a company which I will not name but whose creation was closely connected with the architecture of Le Corbusier, you will understand my enthusiasm with this, not officially BIM like, Swiss army knife application that is still quite a useful BIM tool if you know which buttons to push. Thanks to the inspiring work of several people, like David Koch, Jimmy Bergmark, Jay Moore, Robin Capper and few others that are not yet ready to give up on the potential of embedded code within BIM compliant objects, this application proves that a good amount of intelligence can be placed behind a comprehensive BIM model.
For myself, I can not but wonder if ADSK is really listening, as I am quite sure that a few skilled programmers, and ADSK has enough of those, can crank out this code in a matter of minutes and have it become an integral part of the AutoCAD Architecture. The bigger picture is that ADSK should at least make an honest attempt to add the tools so needed in this “non BIM” application so that we can really take the full advantage of the outdated “object” technology.
This file includes all of the above described elements and I am encouraging you to test it on your own LEED projects. Being aware that there is a ton of room for improvement to this proposed code as well as that this can be far more efficient code if executed via VBA or VB, I am looking forward to get some constructive feedback.
Wednesday, November 21, 2007
Wednesday, November 14, 2007
When exporting a model into an ASCII compliant XML file or examining the same model via its VRML incarnation, one can quickly validate the integrity of the model translation, or manually modify the same file with a very basic text or XML editor. This to a certain extent can compensate for the current software shortcomings or one's unwillingness to purchase another $5K software package.
Let us see what the average user can do to enhance the quality of the preliminary model interpretation, and what are the basic elements of the gbXML file that we as architects should understand in order to approach schematic design modeling with realistic expectations. To do this, knowledge of BIM compliant model structure is the key component, and reflecting on how this model is put together will yield to greater appreciation for the simplicity of its analytical counterpart. The BIM model as such, appropriately so, is distilled down to its basic analytical geometry by treating each major construction component as a 2 dimensional surface (plane) with its associated information, and this associated information is what really distinguishes the building's components in their analytical environment.
The purpose of this geometrical interpretation is the functional and data rich translation of the somewhat superfluous BIM supporting platform geometry, and to emphasize the irony of information modeling, only the spatial components and functional labels of BIM model objects are conveyed to the simulation software. So instead of true information modeling that incorporates usable physical and temporal data ,the grunt work is done after the model is submitted and from that perspective that famous "Information - Cost" BIM diagram becomes somewhat questionable.
Once we establish this common understanding of BIM's model capacity we should find a way to manipulate the purpose built model and its information after it is being exported to gbXML.
Now let's get to the very basics and learn what are the "building blocks" of a gbXML file. Not to be surprised, but the basic Euclidean surfaces are what defines the space and consecutively the building within the analytical model, and those surfaces are defined as follows within the gbXML schema;
The short answer is not at all. Yes, indeed the basic building geometry focusing on slabs, roofs and walls will be generated as it defines the spatial boundary conditions, but several of the quintessential passive sustainable strategy elements get entirely neglected.
Shading devices, constructed or planted, exterior or interior, can be approximated in Revit's BIM model via the persnickety use of a variety of modeling objects, but within Revit Architecture there is no identifier that designates any such improvisation as a valid gbXML compliant Shade surface. Someone might ask, but what about using a roof or a slab family to create exterior shading devices? Sounds like a good idea, but unfortunately to export such an element, the same one should be a part of a room bounding enclosure, and besides extending slabs beyond the buildings envelope, the aperture shading definition does not comply with Revit Architecture's capacity for model translation to gbXML.
Following is the technique I use to circumvent the above described deficiency and append my own shading surfaces to the analytical model, and for its implementation a good XML editor and any VRML browser are must have tools. The editor I prefer (read free) is XML
As indicated in the previous article that was dealing with the ambiguous interpretation of different glazed opening types, in this one we will also rely on the gbXML surface type and its child object opening.
In order to manually indicate the location of a shading device, it is important to locate the surface which is hosting an opening, bringing us to an interesting modeling concept in which we assume that main building elevations are perpendicular to coordinate axis substituting for sides of the world and where by the convention we assume that North is in the positive Y direction. We can certainly model any structure to reflect its true site orientation and this would not pose a particular problem, but explicitly specifying building's orientation angle is something I like to avoid at this point, especially when considering the fact that GBS can rotate the world around any structure.
So go ahead and export your Revit Architecture model and make sure that all openings are properly translated by verifying their location within the VRML file. If you adapt the translated VRML file so that it can be used within the VRML client as shown in this example, it is quite easy to identify which opening's location will be used to manually place the new shading devices.
Cartesian point that determines the location of the child object in relationship to its parent.
To find the appropriate surface and the associated opening one should parse the gbXML file and look for the Surface-Opening Parent-Child pair. To verify its association with the original Revit's entity one should always compare CADObjectID value of the surface with the entity ID value in the model. Once you find this, look for the
This same point will be used to intentionally place the shade surface in relationship to the opening object. As we are examining the opening object ,it is worth taking a second look at Revit Architecture's translation of its window families into the gbXML file as some inconsistencies will become apparent. It is always up to the user to double check the interpreted definitions and manually modify the gbXML file in order to assure for the correct window operational type translation. One major improvement to Revit's gbXML output would be the ability to to pick the appropriate gbXML type definition and have it as a parameter within the relevant family, but circumventing this problem is a topic for the next post.
Confirm the type and the location of an opening with its vertices and its parent exterior wall surface. When this is done, adding a shade object is a relatively straightforward exercise, which consists of appending desired number of shading surfaces at the end of the gbXML file and naming them incrementally as shown in the example below.
While parsing the gbXML you will notice several definitions within the surface element such are "RectangularGeometry", "PlanarGeometry", "Azimuth", "CartesianPoint", and "Tilt" where the explanations for all of them are given within the gbXML schema, and the accompanying documentation.
So whether a shade device is aligned with an opening or located relatively to an exterior wall surface, all you have to do is to identify the opening vertices within a surface or the vertices of the surface itself, and use those to locate, orient and size the corresponding shade surface.
Save your gbXML file and submit it to the GBS web site under the same project name as the original file and compare the results. You will notice that specifying windows' operability value, as well as introducing the correctly placed shading device will make a difference in the total energy picture of your project.
As I mentioned in my previous article, it might be prudent to eliminate all of the unwanted shading surfaces that are artifacts of Revit's model to gbXML translation, and then introduce a new set of deliberately placed Shading Surfaces / Devices whose syntax is described below. Make sure that you assign an unique Surface ID and associated surfaceType as "Shade".
As indicated in this code example
Unfortunately the lack of an existing native gbXML editor makes this process labor intensive but the insight into the future performance of a new design, in my opinion, makes this entire exercise quite valuable.
Monday, November 12, 2007
Well, to see what parametric modeling looked like in 1962, and what is still to be desired after all these years, everyone that is mildly interested in BIM and BIM compliant applications should watch this video.
Saturday, November 10, 2007
Greenspace research has just release a new beta version of Demeter plug-in that expands the benefits of using Google SketchUp for preliminary design process. This plug-in provides the ability to perform the early energy design analysis within minutes, as well as the ability to import and export the gbXML files.
Some of the features are:
- Properties assignable to surfaces
- Enclosed space identification
- Boundary surfaces assignment
- Contiguity checking
- Integration with USA and UK version of Green Building Studio (This is BIG!!!)
- Import and export of gbXML files
- Direct export of SketchUp model for the Whole Building Energy analysis
The only question that remains to be answered in whether we are witnessing the rise of low cost BIM application and how effective is this more than welcome integration with Building Performance Analysis software.
Thursday, November 08, 2007
The Green Building Studio has recently announced the release of GBS Version 3.0. This new version is designed for architects to use on all their design schemes on each project to ensure every building they are designing is carbon neutral ready. Exciting new features include:
- Carbon Neutral Building Check – Automatically estimates the feasibility for each building to achieve carbon neutral status using local grid emission data. US EPA ENERGY STAR Score – Computing each building's US EPA ENERGY STAR score or Architecture 2030's targets.
- Water Use Analysis - Estimates the water needs, savings associated with efficiency measures, rain capture potential, and LEED credits for the building.
- Daylighting with Energy Savings – Automatically determines LEED Daylight Credit and room by room glaze factor analysis.
- Natural Ventilation Potential – Automatically determines if the building location and loads are well suited for naturally ventilating the building.
- Local Weather Data – Providing access to over 50,000 weather locations, ensuring the design team uses local hourly weather data within 9 miles (14km) of your building rather than selecting from the typical 230 airport locations.
- Onsite Renewable Energy – Automatically analyze every exterior surface to determine all the best performing photovoltaic surfaces. Discover annual energy generated for your building from a wind turbine.
- Corporate Accounts – Providing firm-wide management of users, building designs, building templates, and review of corporate wide CO2 emission, energy and water use analyses. Leverage key staff on every project no matter which office they are in.
- Passes Industry Standards – ANSI/ASHRAE Standard 140-2004, Qualified Software for Energy Policy Act of 2005, & Microsoft Platform Test for Hosted Solutions (Platform test was conducted independently by VeriTest).
See the video, which demonstrates how to design a building to be carbon neutral in five minutes using GBS Version 3.0!
Wednesday, November 07, 2007
Hear from industry leaders as they discuss the issues of design, technology, and methodology through their presentations. Parametric design tools and consequential manufacturing technology are allowing new forms of architectural and structural expression which are changing radically the world of the built environment....(link)
Monday, November 05, 2007
Click to see DWF model
What I tried to accomplish here is to visualize the thermal transfer data within this particular wall/window detail with a help of a really amazing free analytical tool the Steady State Heat Transfer, Therm 5.2. To achieve this I have modeled a fairly accurate window sill condition in AutoCAD Architecture, by using custom end caps and strategically placed Mass Element objects.
After cutting the section through this assembly and detailing it by using the Detail Component Manager , this drawing was exported to a DXF file for the purpose of bringing it in as the background into THERM 5.2. In this application, that is available from LBNL, the appropriate materials and boundary conditions were, so to speak, "painted" over the imported CAD underlay. This means that for every polygon that represents a different material in section we have to assign the appropriate material definition, and for those polygons / materials that are exposed either to the exterior or to the interior we need to assign the set of boundary conditions. In order to do the meaningful approximation, adiabatic boundary conditions are assigned where the top and bottom section cuts occur.
It is worth mentioning that even though THERM 5.2 comes with an extensive material library, you will still have to do your due diligence in order to define some of the missing construction materials, if approximation is not an option.
The pseudo IC thermal images can be exported into an image editor of your choice and applied as the bitmap within a ACAD/ACA material that will be mapped onto a Region object generated from 2D section object. After a few tweaks in respect to mapping of the newly created material thermal image is assigned as the diffuse map and its inverted B&W image as the opacity map. Enabled live section of this model has been exported as the DWF file for an easy share with anyone that is interested in the thermal performance of a building's envelope on any given project.
In this example even though the analytical data does not reside within BIM compliant model, we can use the very same model as a link to the external data and more effectively communicate or justify the design intent.