Revit Structure API

Before we start
LiveMeeting and conference call - how to
Expand to full screen mode
Press ESC to return
Introduction
Full Screen Mode
Provide feedback
Real-time Q&A
Mute phone *6
This conference is muted, so you cannot hear anybody else than me talking, and cannot provide feedback through the phone conference. We will unmute it and open it up for general discussion and questions and answers at the end. Meanwhile, written questions can be entered in the live meeting console and will be answered in real-time during the presentation by my colleagues. Thank you very much for that support! Since I will be switching back and forth between these slides and live demonstrations in Revit and Visual Studio, I will set my computer to low resolution and full screen mode to reduce bandwidth and speed up the display. This means I will not see the live meeting console and the feedback panel. My colleagues will be monitoring the livemeeting console and also answering questions online. We will post the materials from this presentation together with the audio recording.
About the Presenter
Jeremy originally joined Autodesk in 1988 as the technology evangelist responsible for European developer support. In this capacity, he wrote articles, consulted, lectured on AutoCAD application programming techniques, and supported AutoCAD application developers in Europe, the U.S., Australia, and South Africa. He was a cofounder of ADGE (AutoCAD Developer Group Europe) and a prolific author on AutoCAD application development. He left Autodesk in 1994 to work as an HVAC application developer, then rejoined the company in 2005.
Jeremy graduated with a MA in mathematics and physics in Marburg, Germany, in 1984, and worked first as a teacher and translator of both computer and human languages, then as a C++ programmer. He is fluent in five European languages, vegetarian, has four kids, plays the flute, likes theatre improvisation and loves sports and climbing.
Jeremy Tammik
Developer Technical Services
EMEA
Autodesk SARL
Introduction
It is my pleasure to work in for the Autodesk Developer Network, ADN, in the AEC workgroup.
ABCs of Revit Programming
Prerequisite
Knowledge of Revit API basics
Basic Revit API recordings are available
DevTV Introduction to Revit 2008 Programming
http://adn.autodesk.com/adn/servlet/item?siteID=4814862&id=10194238&linkID=4901650
Revit API 2009 Introduction webcast (May 6, 2008)
Public
Developer Center > API Training and Consulting > Schedule
http://download.autodesk.com/media/adn/Revit2009APIWebcast_06May2008.zip
ADN
ADN web site > Revit product > Knowledgebase > Whitepapers and Training Videos
http://adn.autodesk.com/adn/servlet/item?siteID=4814862&id=11255592&linkID=4901650
Introduction
This course assumes basic knowledge of Revit programming. We will not cover basics such as how to define an external command, add menus, use filtering, etc. VSTA is also not covered.  If you are not familiar with the basic Revit API and have missed Revit API Introduction course we had last week, a recording is available on the ADN web site as well as on the developer center training schedule page. The download link is on the right side of the page.
Agenda
Revit 2009 API News
Analysis Link
Overview - workflow, rac versus rst, physical versus analytical model
RstLabs - analysis link requirements and labs
RstLink - sample analysis link application
Rebar
Revit Structure rebar workflow
Generate and extract rebar and its information
Detailing
Generate views and sheets
Import and export dwg and other external file formats
Add text, dimensioning and annotation
Introduction
Our discussion here proceeds in three steps. First, look at the workflow and how it is supported by Revit Structure or RST. Secondly, walk through a series of labs related to extracting and analysing the data managed by RST. Finally, we will look at a sample application linking RST with an external application. In this case, the external stress analysis package is simulated by AutoCAD.
Revit 2009 API News
Revit 2009 API News Highlights
See "Getting Started Revit API 2009.doc"
Directory "API Changes"
Conversion from struct to class
Some method signature changes
Element iteration and filtering
Element batch creation: family instance, room, wall, grid, area, text
Performance improvements: creation, SuspendUpdating
Element parameter access: get by name, get map
New family properties: LoadedSymbols, FamilyCategory
Print Manager, rendering and material properties
VSTA
Set name of symbol
Family instance placement on faces
FBX for 3DS, DWFx 2D and 3D export
RoofType, RoofBase, FootprintRoof, ExtrusionRoof
Status bar message when prompting to pick elements
Volume calculation settings
New element categories: curtain systems, curtain wall mullions, roofs
View crop box settings access
Introduction
Revit Stucture API News
Rebar API Changes
Significant new functionality for modeling concrete reinforcement bars
New rebar element object model
Rebar element is now an instance of a shape
RebarShape is analogous to a Revit family
Different implementation and behaviour
Rebar shape objects are shipped as content
New ones can be created using the NewRebarShape() method
NewRebar() has two versions
Specify a RebarShape and a location
Specify a curve array, similar to 2008
Reinforcement
Loads, creation of hosted loads
Introduction
Analysis Link Overview
Completing the Building Information Model
Building Information Modeling (BIM) - The creation and use of coordinated, internally consistent, computable information about a building project in design and construction
Image Courtesy of DDB Architectural International Ltd.
BUILDING
INFORMATION
MODELING
Overview
Building information modeling (BIM) is the creation and use of coordinated, consistent, computable information about a building project in design that yields reliable digital representations of the building - representations used for design decision-making, production of high-quality construction documents, performance predictions, cost-estimating and construction planning, and, eventually, for managing and operating the facility. The focus of this presentation is on the structural part of it with Revit Structure.
Revit Structure Target Projects
Buildings -
Any Type, any Size, any Complexity
made of any kind of Materials
Overview
Even if structural engineers can design any type of structures including bridges, tunnels, plants etc., RST focuses on building design. It does not mean that a user cannot design other type of structures, but the marketing that we do, the training and documentation materials that we provide are positioning RST on building design.
Current Analysis Process
Overview
Currently, the analysis of a building involves a lot of manual data transfer with accompanying loss of information and additional cost. The aim of Revit and its building information model and Revit Structure and its linked physical and analytical model is to preserve more information, support communication between all parties involved, and reduce cost.
Structural Market Definition
Designer
Structural
Analysis
Construction
Documentation
Engineer
Drafter
Contractor
Steel Detailer
Fabrication and
Shop Drawings
Overview
The structural industry is extremely fragmented. We segment is into 2 parts: design and fabrication. The design is composed of 2 tasks (analysis and construction drawings) done by 3 actors and the fabrication focuses on shop drawings.
Tasks and User Focus
Designer
Engineer
Drafter
Revit Structure Focus
Construction
Documentation
Contractor
Steel Detailer
Fabrication and
Shop Drawings
Fabrication
Structural
Analysis
Modeling
Overview
The focus that we have for RST is on the design part only where we do modeling for drawings and analysis. We do not do analysis.
Issues to Address
Problems addressed by Revit Structure
Same information is duplicated for different tasks
Lack of coordination tools
Between drafters and engineers
Between architects and engineers
Lack of standard software modelling platform
How are these problems addressed?
Overview
Introduction
Overview
Revit Structure is used by a structural engineer to manage and combine data from several different sources:
Architectural data, the building design, which can come from Revit Architecture, but also from other Autodesk or non-Autodesk products.
Analysis data for stress analysis in external packages.
Details which are designed based on the analysis results.
Structural BIM Workflow: The 4 Cs
ARCHITECTS
STRUCTURAL
ENGINEERS
BUILDERS
FABRICATORS
Coordination
Calculations
Construction Documents
Construction
Overview
In the context of the structural BIM, we focus on four C's which require significant coordination between architects, structural engineers, fabricators and builders:
Coordination
Calculations
Construction Documents
Construction
Developers and ADN partners can develop applications for each of the four Cs:
- Coordination with other disciplines
Using the rich information in RST and process it against other disciplines
Calculations or Analysis
Link analysis and design applications
Construction documentations
Focus on local standards
Automation
Construction
Use the information downstream for fabrication
Application Development  Opportunities
Integration of analysis and design software
Automatic modeling
Reinforcement
Framing
Connections (Steel, precast)
Portal frames
Bridge/tunnels
Special structures (towers, retaining walls)
Data exchange (with other AutoCAD based applications)
Scheduling
Drawing automation
...
Overview
As the API is becoming more and more robust, there are many areas of opportunity to port existing applications to RST or to develop new ones.
The API is a great way to automate repetitive manual tasks such as reinforcement, framing modeling. There is also an opportunity to create dedicated Revit families and to drive their generation with the API such as steel connections. You can also imagine building wizard type applications that generate civil structures including soil, geometry reinforcement etc. The API is also built so you can link the RST model to your existing application and complete what RST does not do such as local standard drawings or schedules. With the API you can drive an application to generate a dwg file and then import it automatically in RST.
Application Development  Opportunities
Integration of analysis and design software
Automatic modeling
Reinforcement
Framing
Connections (Steel, precast)
Portal frames
Bridge/tunnels
Special structures (towers, retaining walls)
Data exchange (with other AutoCAD based applications)
Scheduling
Drawing automation
...
Overview
Today we will focus on the three highlighted areas.
Comparison with Revit Architecture
General User Interface
Command organization
Category filtering
Functionality added
Analytical model (generation and adjustment)
Load modelling
API specific model and load objects
Rebar modelling
Composite metal deck
Graphical column schedule
...
Overview
Revit Architecture and Structure have a lot of common features. The differences are visible in the user interface in the command organisation and the category filtering. Some structure-specific functionality has been added.
Comparison with Revit Architecture
Functionality removed
Reflected ceiling plans
Room related functionalities
Model text
...
Overview
Some functionality has also been removed.
Analytical Model
Structural analysis model differs from drawing model
Revit Structure solves this problem
Physical model is used for drawings, coordination and construction
Analytical model is the simplified model used for analysis
Overview
The most important problem of the structural industry is the fact that the information used for structural analysis is physically different than the one used for drawings. Revit Structure solves this problem. The physical model is the model that we use for drawings, coordination and construction, and the analytical model is the simplified model used for analysis.
Some examples show the discrepancies between the analytical and physical models.
For example, consider a plan view where the walls need to be aligned for the analysis and the beams need to join the centre of columns to end of walls.
Another example is an elevation where the analytical model is horizontally projected even if the physical model of the beam has a slope.
Finally, consider a situation where the physical model of the beam is curved and the analytical model is segmented.
Revit Structure maintains the coordination between the 2 models and will keep the analytical model of each element connected.
As a third party analysis developer, you just need to work with the analytical model.
What is in the analytical model?
Members that need to participate in the analysis
Geometry (location)
Sections
Materials
Release conditions
Reference to level (optional)
Loads
Load cases
Load combinations
Point, line, area loads
Boundary conditions
Support data
Overview
In this presentation, we explain how to access all this information.
Analytical vs Physical Model
Overview
Revit Structure combines the physical model which drives the modeling and documentation process with the analytical model which drives the analysis process and export to third party analysis software.
The Revit Structure analytical model can be adjusted for analysis purposes while the physical model stays accurate for documentation.
Analytical vs Physical Model
Overview
Here are examples of different cases highlighting the difference between the physical and the analytical models and the need for flexibility in linking the two:
The end points of two beams may are not at the same location. We want to the end points of their analytical models to be located at the same point. An engineer decides to move the end of one beam.
Remodelling an old historic building, walls may not be straight. An engineer decides to approximate them by planes for analysis.
Two walls with different thicknesses but aligned analytical planes.
A wall with a parapet that does not need to be included in the analysis.
Adjusting the location of analytical columns horizontally.
The cases are taken from AE_CD_RST2008/Analysis_workflows/Analysis_Workflows.pdf.
Data Exchange Workflow
Geometry
Physical
Analytical
Loads
Connectivity
Material
Project parameters
Overview
In general, we start off with a physical model. This can be used to automatically generate the analytical one. The analytical model is exported to an external analysis package, which adds its own data. As a result of the analysis, the analytical model may be modified, resulting in changes in the physical model as well. New changes may be added in the physical model as well. All of these processes may continue over many iterations.
The example presented displays the following steps:
RST defines the physical model, analytical model composed of geometry, loads, connectivity (release and boundary conditions), material properties, project parameters. This is information is accessible via the API
In the analysis software we get the analytical model
Analytical model initializes specific properties not present in RST (here they are symbolized with X and Y) and the user can change them. We can do an analysis, delete specific members, change sections and then the analysis software updates the RST model
Changes can be add, delete, create, and move members and also add new properties to RST members
If we select a column and duplicate it, it will have the Y parameter that was defined in 3)
So the next time we round trip the data to the 3rd party, we retrieve the Y parameter.
Analysis Requirements
Extract the analytical model geometry
Extract the load cases, load combinations, loads
Extract release and boundary conditions
Update the model with changes and new and deleted elements
Add load cases and load combinations
Add loads and reactions
Add project information, shared parameters
Add shared parameters on structural objects
Overview
Now we understand the structural workflow and its needs, we can start looking at the API features provided to address these needs.
Here is an overview of the typical requirements for implementing a link to an external analysis package using the RST API.
In the following slides, we will look at the Revit samples and a series of labs demonstrating how to address these issues one by one.
Finally, the results of these labs will be integrated into the sample link application.
Adding local parameters to Revit
Shared parameters
Can be defined in an external file
Can be added with the API
Can be defined per element
Can be project specific, e.g. building codes
Templates
Can contain specific information such as load combinations
Overview
Here are some different strategies for a third party application to add new properties in the database.
Analytical model access
How to get the ...
... thickness of a wall with multiple layers?
SDK sample TestWallThickness
... analytical model of an in-place family?
SDK sample AnalyticalViewer
... analytical model defined in an external family?
SDK sample AnalyticalViewer
... multiple analytical segments of a curved beam?
Tessellate the underlying curve
Overview
Here are some typical frequently asked questions and examples on how to solve them.
Useful Revit SDK Samples
Parameters
BrowseBindings
CreateShared
FireRating
InvisibleParam
Analytical Model
AnalyticalSupportData_Info
AnalyticalViewer
BoundaryConditions
InplaceFamilyAnalyticalModel3D
Loads
RotateFramingObjects
SlabProperties
SpanDirection
Overview
Currently, information on how to combine Revit API calls to achieve certain complex tasks is contained mainly in the SDK samples. Here is a list of some of the Revit SDK samples which address areas related to structure.
Revit Structure Analysis Labs
Revit Structure Analysis Labs
Loads
1-1	Load cases, natures, combinations, usages
1-2	Point, line and area loads
1-3	Load parameters and modification
1-4	Load symbols
1-5	Creating load objects
Structure
2-1	Columns
2-2	Framing
2-3	Foundations
2-4	Structural standard family instances
2-5	Structural system family instances: walls, floors, footings
Analytical Model
3	Analytical model
RstLabs
In the section, we demonstrate step by step how to implement the functionality required for an application linking Revit Structure with an external analysis package. The first group of labs addresses access and modification of load data, the second examines the building structure, and the third addresses the entire analytical model.
Load Grouping Objects
Load Cases
Load Natures
Load Combinations
Load Usages
Lab 1-1
To retrieve load case, nature, combination and usage objects, simply filter for the corresponding object class LoadCase, LoadNature, LoadCombination and LoadUsage
To create new objects, use the Autodesk.Revit.Creation.Document methods NewLoadCase(), NewLoadCombination(), NewLoadNature(), NewLoadUsage() accessible through ActiveDocument.Create
RstLabs
This first lab extracts and lists the load cases, natures, combinations and usages defined in the Revit model.
Loads Grouping Code
Retrieve objects
public static List<Element> GetAllLoadNatures( Application app )
{
List<Element> a = new List<Element>();
Filter filterType = app.Create.Filter.NewTypeFilter( typeof( LoadNature ) );
app.ActiveDocument.get_Elements( filterType, a );
return a;
}
Create objects
ActiveDocument.Create.
LoadCase NewLoadCase( string name, LoadNature nature, Category category );
LoadNature NewLoadNature( string name )
LoadUsage NewLoadUsage( string name )
LoadCombination NewLoadCombination( string name, int typeInd, int stateInd, 
  double[] factors, LoadCaseArray cases, LoadCombinationArray combinations,
LoadUsageArray usages )
RstLabs
Loads Grouping Demo
RstLabs
Todo: add image of model.
To run the demo, install and compile RstLabs, add Lab 1-1 to Revit.ini, start Revit, and select the external command.
[ExternalCommands]
ECCount=1
ECName1=RS Lab1-1 Load Natures, Cases and Combinations
ECDescription1=Lab1_1...
ECClassName1=RSSolvedLabsCode.Lab1_1
ECAssembly1=C:\a\j\adn\rst\rst_api\RSSolvedLabsCode\bin\RSSolvedLabsCode.dll
Access to Load Objects
Point Loads
Line Loads
Area Loads
Lab 1-2
Shows how to access all load objects using the base or specific classes
All three load classes are derived from LoadBase
Creation through NewAreaLoad (3 overloads), NewLineLoad (2), NewPointLoad
RstLabs
Lab 1-2 shows how to access all load objects using the base or specific classes. All three load classes are derived from LoadBase. They are creation through NewAreaLoad() (3 overloads), NewLineLoad() (2), and NewPointLoad().
Retrieve Load Objects
public static void GetAllSpecificLoads(
Application app,
ref ElementSet pointLoads,
ref ElementSet lineLoads,
ref ElementSet areaLoads )
{
List<Element> a = new List<Element>();
Filter filterTypeLoad = app.Create.Filter.NewTypeFilter( typeof( LoadBase ), true );
app.ActiveDocument.get_Elements( filterTypeLoad, a );
foreach( Element elem in a )
{
if( elem is PointLoad )
{
pointLoads.Insert( elem );
}
else if( elem is LineLoad )
{
lineLoads.Insert( elem );
}
else if( elem is AreaLoad )
{
areaLoads.Insert( elem );
}
}
}
RstLabs
Just like in the preceding lab, we iterate over all Revit elements and pick out the object types of interest. For each load type object, a number of properties are defined for extracting and modifying data.
Load Objects Demo
RstLabs
Todo: add image of model.
Open RstLabs.rvt to obtain a model with a few predefined loads.
Run the external command Lab 1-2 after adding RstLabs.dll to Revit.ini.
Load Object Parameters
Lab 1-3
Shows more details about loads, this time from selected objects
How to access load parameters
How to modify load objects
Dim iter As ElementSetIterator = doc.Selection.Elements.ForwardIterator
While iter.MoveNext
Dim elem As Revit.Element = iter.Current
If TypeOf elem Is PointLoad Then
ListAndModifyPointLoad(CType(elem, PointLoad))
ElseIf TypeOf elem Is LineLoad Then
ListAndModifyLineLoad(CType(elem, LineLoad), app)
ElseIf TypeOf elem Is AreaLoad Then
ListAndModifyAreaLoad(CType(elem, AreaLoad), app)
End If
End While
RstLabs
Lab 1-3 continues the exploration about loads.
Get Parameter by Display Name
New in 2009: direct parameter access by display name
Parameter para = elem.get_Parameter( name );
Some parameters are accessible via display name only
Using BuiltInParameter enum is language independent
elem.get_Parameter( BuiltInParameter.LOAD_IS_REACTION )
RstLabs
Some element parameters can be accessed via display name only. In general, we try to use the BuiltInParameter enum to access parameters whenever possible, since it is language independent.
Point Load Parameters
Equivalent
LOAD_IS_REACTION	"Is Reaction"
LOAD_CASE_ID	"Load Case"
Similar
LOAD_USE_LOCAL_COORDINATE_SYSTEM	"Orient to"
Built-in only
LOAD_USE_LOCAL_COORDINATE_SYSTEM_HOSTED
LOAD_IS_CREATED_BY_API
Display name only
"Fz"
RstLabs
Parameters vary from Revit version to version.
Other Load Parameters
See list of 59 load-relevant built-in parameters at end of Labs1.vb
LOAD_ALL_NON_0_LOADS
LOAD_AREA_AREA
LOAD_AREA_FORCE_FX1
LOAD_AREA_FORCE_FX2
LOAD_AREA_FORCE_FX3
LOAD_AREA_FORCE_FY1
LOAD_AREA_FORCE_FY2
LOAD_AREA_FORCE_FY3
LOAD_AREA_FORCE_FZ1
LOAD_AREA_FORCE_FZ2
LOAD_AREA_FORCE_FZ3
LOAD_ARROW_SEPARATION
LOAD_ATTR_AREA_FORCE_SCALE_FACTOR
LOAD_ATTR_FORCE_ARROW_TYPE
LOAD_ATTR_FORCE_SCALE_FACTOR
LOAD_ATTR_LINEAR_FORCE_SCALE_FACTOR
LOAD_ATTR_MOMENT_ARROW_ARC
LOAD_ATTR_MOMENT_ARROW_LINE
LOAD_ATTR_MOMENT_SCALE_FACTOR
LOAD_CASE_CATEGORY
LOAD_CASE_ID
LOAD_CASE_NAME
LOAD_CASE_NATURE
LOAD_CASE_NATURE_TEXT
LOAD_CASE_NUMBER
LOAD_COMBINATION_FACTOR
LOAD_COMBINATION_NAME
LOAD_COMBINATION_STATE
LOAD_COMBINATION_TYPE
LOAD_COMMENTS
LOAD_COMMENT_TEXT
LOAD_DESCRIPTION
LOAD_FORCE_FX
LOAD_FORCE_FY
LOAD_FORCE_FZ
LOAD_IS_CREATED_BY_API
LOAD_IS_PROJECTED
LOAD_IS_REACTION
LOAD_IS_UNIFORM
LOAD_LINEAR_FORCE_FX1
LOAD_LINEAR_FORCE_FX2
LOAD_LINEAR_FORCE_FY1
LOAD_LINEAR_FORCE_FY2
LOAD_LINEAR_FORCE_FZ1
LOAD_LINEAR_FORCE_FZ2
LOAD_LINEAR_LENGTH
LOAD_MOMENT_MX
LOAD_MOMENT_MX1
LOAD_MOMENT_MX2
LOAD_MOMENT_MY
LOAD_MOMENT_MY1
LOAD_MOMENT_MY2
LOAD_MOMENT_MZ
LOAD_MOMENT_MZ1
LOAD_MOMENT_MZ2
LOAD_NATURE_NAME
LOAD_USAGE_NAME
RstLabs
LOAD_USE_LOCAL_COORDINATE_SYSTEM
LOAD_USE_LOCAL_COORDINATE_SYSTEM_HOSTED
Here is a full list of parameters relevant to loads given in the comment at the end of Labs1.vb.
Point Load Properties
LoadBase
HostElement
LoadCaseName
LoadCategoryName
LoadNatureName
PointLoad
Force
Moment
Point
Explore
Help file
Debugger
RvtMgdDbg
Reflection
RstLabs
Some of the values accessible through parameters are also exposed directly as properties on the object class.
Whenever you are looking for a specific property, you will need to explore the Revit API and one or more suitable sample models to determine what exactly you are looking for and how to access it.
More Point Load Properties
RvtMgdDbg
Available with source code on ADN
RstLabs
Modify Load Demo
// Scale Fz by factor 2
Parameter paramFz = ptLd.get_Parameter( "Fz" );
double Fz_old = paramFz.AsDouble();
paramFz.Set( 2.0 * Fz_old );
RstLabs
In "RS Labs.rvt", select a point, line and area load, then run the external command for Lab 1-3.
One new property in 2008 is the HostElement. Many other properties are also available. Here is an example of a line load element.
Load Symbols
Lab 1-4
Retrieve load symbols aka types available in the project
Determine load symbol family
One utility for all load symbols (point, line and area)
Another one specifically for point loads
Load symbols are system families, not standard ones
RstLabs
Retrieve Load Symbols
In 2008
Iterate over Elements
Pick out Symbol instances
Check for structural loads category
Now
Make use of new classes LoadTypeBase, PointLoadType, LineLoadType,  AreaLoadType
Search for the base class instead of the category
public static List<Element> GetAllLoadSymbols( Application app )
{
List<Element> a = new List<Element>();
Filter filter = app.Create.Filter.NewTypeFilter( typeof( LoadTypeBase ), true );
app.ActiveDocument.get_Elements( filter, a );
return a;
}
RstLabs
Determine Load Symbol Family
No dedicated classes
Examine family name parameter
BuiltInParameter.SYMBOL_FAMILY_NAME_PARAM 
equals "Point Loads", "Line Loads", "Area Loads"
RstLabs
Creating Load Objects
Lab 1-5
Show how to create a new Load object, specifically PointLoad
One as reaction, simulating analysis result
One as standard external load
Also show how to
Set a selected symbol for this new load
Assign the load to a selected load case
RstLabs
Lab 1-5 shows how to create a new load object, specifically a point load. It creates two new point loads by calling NewPointLoad() with somewhat arbitrary parameters. One as reaction, simulating an analysis result, the other is a standard external load. It also shows how to set a selected symbol for this new load and assign the load to a selected load case. To assign a selected symbol to it, all point load symbols in the document are retrieved and the user is allowed to select one of them. Its id is then assigned to the newly created point load ELEM_TYPE_PARAM. Similarly, to assign a load case, all load cases are retrieved and displayed and the selected one's id is assigned to the LOAD_CASE_ID parameter.
Point Load Creation
Create
Signature changed in 2009
Revit.Creation.Document.NewPointLoad( reference As Reference,
force As XYZ, moment As XYZ, isReaction As Boolean,
symbol As PointLoadType, plane As SketchPlane ) As PointLoad
Revit.Creation.Document.NewPointLoad ( point As XYZ,
force As XYZ, moment As XYZ, isReaction As Boolean, _
symbol As PointLoadType, plane As SketchPlane ) As PointLoad
Assign Symbol
Iterate over all point load symbols
Assign selected one's id to parameter
BuiltInParameter.ELEM_TYPE_PARAM
Assign Load Case
Iterate over all load cases
Assign selected one's id to parameter
BuiltInParameter.LOAD_CASE_ID
RstLabs
Structure Load Creation 
What's new in 2009
Load creation methods
Revit.Creation.Document.NewPointLoad( reference As Reference,
force As XYZ, moment As XYZ, isReaction As Boolean,
symbol As PointLoadType, plane As SketchPlane ) As PointLoad
Added a load type and sketch plane argument
Optional, can be null (Nothing in VB) = Default load type
Point (Line/Area) LoadType and *LoadTypeSet objects added
Supports creation of hosted loads
Overloads for assignment of a host element or geometry reference of a host element to create the hosted loads
NewPointLoad(), NewLineLoad() and NewAreaLoad()
RstLabs
Revit Structure has enhanced load elements by adding their symbols. In the API, parameters used for load creation have changed: all load creation methods now take an optional load type and sketch plane argument.  Both of these arguments are optional and can be supplied null (Nothing in VB) to use the default load type for the category of load being created.
Point(Line/Area)LoadType and Point(Line/Area)LoadTypeSet objects are added.
In addition, the Autodesk Revit API now supports creation of hosted loads.  Several overloads have been added for NewPointLoad(), NewLineLoad() and NewAreaLoad() permitting assignment of a host element or geometry reference of a host element to create the hosted loads.
Columns and Framing
Structural Elements
Standard families
Lab 2-1
Retrieve all structural 'line segment' or 'stick' elements
Columns belong to a separate standard family
Others such as beam, brace, joist, etc. belong to the framing standard family
RstLabs
The next section explores accessing and modifying structural elements and their data in RST.
Select all columns
Select all standard family instances for category OST_StructuralColumns
BuiltInCategory bicSc = BuiltInCategory.OST_StructuralColumns;
List<Element> columns = RacUtils.GetAllStandardFamilyInstancesForACategory( app, bicSc );
. . .
public static List<Element> GetAllStandardFamilyInstancesForACategory(
Application app,
BuiltInCategory bic )
{
List<Element> elements = new List<Element>();
Filter filterType = app.Create.Filter.NewTypeFilter( typeof( FamilyInstance ) );
Filter filterCategory = app.Create.Filter.NewCategoryFilter( bic );
Filter filterAnd = app.Create.Filter.NewLogicAndFilter( filterType, filterCategory );
app.ActiveDocument.get_Elements( filterAnd, elements );
return elements;
}
RstLabs
To select all columns in the model, we once again use filtering to select all standard family instances for category OST_StructuralColumns. We can display generic element and column properties such as element id, symbol name, structural type and analytical model type.
Select all framing elements
Select all standard family instances for category OST_StructuralFraming
Dim catStructuralFraming As Category = doc.Settings.Categories.Item(BuiltInCategory.OST_StructuralFraming)
Dim frmEls As ElementSet = RBUtils.GetAllStandardFamilyInstancesForACategory(app, catStructuralFraming.Name)
sMsg = "There are " & frmEls.Size & " Structural FRAMING elements:" & vbCrLf
Dim frmEl As FamilyInstance
For Each frmEl In frmEls
sMsg += "  Id=" & frmEl.Id.Value.ToString & " Type=" & frmEl.Symbol.Name & _
" Struct.Usage=" & frmEl.StructuralUsage.ToString & _
" Struct.Type=" & frmEl.StructuralType.ToString & _
" Analytical Type=" & frmEl.AnalyticalModel.GetType.Name & vbCrLf
Next
MsgBox(sMsg)
RstLabs
Foundations
Structural Elements
Foundations standard family
Lab 2-2
Retrieve structural foundation elements
May not be needed for analysis package
Alternative approach retrieves all standard family instances having structural usage, i.e., having an analytical model
RstLabs
Foundations are structural elements and also make use of a standard family. Lab 2-2 demonstrates how to retrieve all structural foundation elements. This may not be required for every analysis package. An alternative approach would be to retrieve all standard family instances having structural usage, i.e., having an analytical model.
Retrieve Foundations
Get all standard structural foundation elements
Category OST_StructuralFoundation
Excludes 'Wall Foundation' System Type under 
'Structural Foundations' category in the Browser
These belong to 'Continuous Footing' system family, Lab 2-3
Excludes 'Foundation Slab' System Type under 
'Structural Foundations' category in the Browser
These are internally implemented as Revit 'Floor' system family, Lab 2-3
RstLabs
To retrieve all foundations in the model, we can use the same approach as above, getting all standard structural foundation elements, using the category OST_StructuralFoundation. This excludes the 'Wall Foundation' system type under 'Structural Foundations' category in the browser, because these belong to the 'Continuous Footing' system family, and also the 'Foundation Slab' system type under the 'Structural Foundations' category in the browser, which are internally implemented as Revit 'Floor' system family. These are examined in Lab 2-3.
Retrieve Structural Family Instances
Alternative approach
Select all standard family instances with an analytical model
Filter filter = app.Create.Filter.NewTypeFilter( typeof( FamilyInstance ) );
List<Element> instances = new List<Element>();
app.ActiveDocument.get_Elements( filter, instances );
string sMsg = "All structural family instances (generic check):";
foreach( FamilyInstance fi in instances )
{
//
// note that instead of looping through and checking for a
// non-null analytical model, we might also be able to use some
// other criterion that can be fed straight into the Revit API
// filtering mechanism, such as structural usage:
//
if( null != fi.AnalyticalModel )
{
sMsg += "\r\n  " + RstUtils.StructuralElementDescription( fi );
}
}
RstLabs
As an alternative approach, we can also iterate over the document elements and select all FamilyInstance objects having an analytical model.
Walls, Floors, Footings
Structural Elements
System families
Wall, Floor (Slab), Continuous Footing
Lab 2-3
Retrieve structural elements from these system families
Not all instances will have analytical model (user-definable!)
RstLabs
The structural elements walls, floors, and footings also all make use of system families, specifically Wall, Floor (Slab), and Continuous Footing, respectively. Lab 2-3 shows how to retrieve all structural elements from each of these system families. Please note that some instances may not have an analytical model, since this property is user definable.
Analytical Model
Abstract API base class
AnalyticalModel
Specific derived classes
Wall	AnalyticalModelWall
Floor	AnalyticalModelFloor
Cont.Footing	AnalyticalModel3D
Column, Framing	AnalyticalModelFrame
Foundation	AnalyticalModelLocation
RstLabs
The analytical model makes use of a separate little class hierarchy derived from the abstract base class AnalyticalModel. It defines specialised derived classes for various structural elements.
Retrieve Structural Walls
Retrieve all Wall elements having an analytical model
Filter filterWall = app.Create.Filter.NewTypeFilter( typeof( Wall ) );
List<Element> walls = new List<Element>();
app.ActiveDocument.get_Elements( filterWall, walls );
ElementSet elems = app.Create.NewElementSet();
foreach( Wall w in walls )
{
if( null != w.AnalyticalModel )
{
elems.Insert( w );
}
}
Same for ContFooting elements
RstLabs
To retrieve all Wall elements having an analytical model, we perform the normal Revit document elements iteration, pick out wall elements, and check for the presence of an analytical model using the Wall.AnalyticalModel property. The same approach can be used for ContFooting elements.
Retrieve Structural Floors
Retrieve all Floor elements having a non-empty analytical model
Filter filterFloors = app.Create.Filter.NewTypeFilter( typeof( Floor ) );
List<Element> floors = new List<Element>();
app.ActiveDocument.get_Elements( filterFloors, floors );
ElementSet elems = app.Create.NewElementSet();
foreach( Floor f in floors )
{
AnalyticalModel anaMod = f.AnalyticalModel;
if( null != anaMod )
{
//
// For floors, looks like we need to have additional check:
// for non-structural floors anaMod is NOT null, but it IS empty!
//
AnalyticalModelFloor floorAnaMod = anaMod as AnalyticalModelFloor;
if( 0 < floorAnaMod.Curves.Size )
{
elems.Insert( f );
}
}
}
RstLabs
A similar approach as for walls can also be used for floor elements. However, in the case of floors, the analytical model may well be non-null, but still be empty, so we need to add an additional check that the number of curves in it, given by AnalyticalModelFloor.Curves.Size, is actually greater than zero.
Analytical Model
Investigate geometry contained in model
Lab 3
Retrieve detailed analytical model geometry for selected elements, depending on the family and/or category
RstLabs
Lab 3 implements some code to investigate the geometry contained in the analytical model. It retrieves detailed analytical model geometry for selected elements, depending on their family and/or category.
Retrieve Analytical Model
Iterate over selected elements
Wall
Floor
ContFooting
FamilyInstance with category
OST_StructuralColumns
OST_StructuralFraming
OST_StructuralFoundation
Get AnalyticalModel and list
Curves
Support data - cf. AnalyticalSupportData_Info SDK sample
RstLabs
Retrieve Analytical Model
RstLabs
Structural Analysis Link
Structural Analysis Link
Introduction
Export and import
Practical examples
Sample application
RstLink
Now we have assembled all the tools we might need, let us put them together into an actual Revit Structure Analysis link application. First we discuss some general questions regarding applications linking Revit with external programs, followed by some practical examples.
Analysis Link Introduction
There are MANY ways in which the link can be designed
There are MANY implementation scenarios concerning
Which structural elements are passed between the applications
Which kind of model changes are automatically supported in either of them
It is up to the particular 3rd party package and its implementer to design, code and document the link
Revit Structure API provides the tools to do this
RST does not pre-determine the design of the link application
RstLink
There are many different implementation scenarios in which it might be useful to link a Revit building model with some external data, both RST-specific for analysis as we are discussing here, and also generic for other situations. Obviously, there are also many ways in which such a link can be designed.
For the RST analysis link, we need to decide which structural elements are passed between the applications and what kind of model changes are automatically supported in either of them.
It is obviously up to the individual third party package and its implementer to design, code and document the link. The Revit Structure API provides the required tools to do this, and does not pre-determine the design of the link application in any way.
Analysis Link Export
Data export from Revit to 3rd party A&D application
Use a custom Revit external command to export relevant data
App's native file/DB format â€” typically proprietary
App's neutral file/DB format â€” typically public
Public neutral file/DB format supported by the app
Intermediate file/DB format purpose-designed for the link
...
The choice depends on the combination of technical, functional, commercial and political requirements...
RstLink
For data export from Revit to a third party A&D application, one will generally use a custom Revit external command to export relevant data. The format used for this communication is once again completely up to the implementer, and could be any one of the following.
Analysis Link Import
Define another custom Revit external command
The choice of options and reasoning is basically the same as for the export
The chosen file format need not be the same as for the export, though typically it would be
RstLink
For importing the updated and modified data from the external application back into Revit, one would generally define another custom Revit external command. The choice of options and reasoning is basically the same as for the export. The chosen file format does not need to be the same as for the export, though typically it would be.
Practical Examples
RstLink
Simple demonstration application
MidasLink
Simple but real
FireRating
Minimal generic Revit
RDBLink
Generic Revit BIM, not RST specific
Commercial Software
RstLink
Practical Example
AutoCAD 2008 simulates A&D 3rd party app
AutoCAD.NET API utilities used on the 'other' side
Xdata used to store Revit Structure specific info on standard AutoCAD entities
AutoCAD Dynamic Properties COM API used for the link-specific UI within AutoCAD
Intermediate, purpose designed XML
Used in both directions
For simplicity, based on .NET SOAP serialization
Custom .NET neutral classes utilized by both sides' export/import commands
RstLink
We have implemented a custom designed practical example of a Revit Structure analysis link application called RstLink to accompany this presentation. We use AutoCAD 2008 with an AutoCAD.NET plug-in to simulate the external third party analysis and design application and extended entity data, also known as xdata, to store Revit Structure specific information on standard AutoCAD entities. We use the AutoCAD Dynamic Properties COM API and the Object Property Manager OPM for the link-specific user interface within AutoCAD.
AutoCAD.NET API utilities used on the 'other' side
Xdata used to store Revit Structure specific info on standard AutoCAD entities
AutoCAD Dynamic Properties COM API used for the link-specific UI within AutoCAD
The data exchange in both directions between the Revit model and the A&D simulation in AutoCAD is implemented using an intermediate, custom designed XML format. For simplicity, the XML format is based on .NET SOAP serialization. Some neutral custom .NET classes are utilised by both sides' export and import commands.
Used in both directions
For simplicity, based on .NET SOAP serialization
Custom .NET neutral classes utilized by both sides' export/import commands
Before running the demo, the following applications need to be present:
RstLink - helper dll shared by both acad and revit client
RSLinkRevitClient - command implementations
RSLinkRevitApp - external application
RSLinkAcadClient - AutoCAD client
RSLinkAcadClientDynProps - dynamic Revit properties for AutoCAD objects
Here are possible steps to run the demo:
Set up Revit.ini to load either the client or the external application or both.
Open or create a sample model in Revit Structure.
Run the export command. You are prompted for a file location. A dialogue box pops up, reporting the number of exported elements.
Start up AutoCAD and load the client and the dynamic property application.
This can be achieved automatically by setting up AutoCAD to start in the RVT sample directory and placing an acad.lsp file there containing:
(defun s::startup()
(command "_netload" "RSLinkAcadClient.dll")
(princ "\nAutoCAD RSLink client loaded.")
(arxload "RSLinkAcadClientDynProps.arx")
(princ "\nAutoCAD RSLink dynamic properties loaded.")
(princ)
)
If it does not load automatically, you can load it manually by calling
(load "C:/a/j/adn/revit/rst_api/RVT/acad.lsp")
with the appropriate full path, and then call
(s::startup).
The commands defined by the AutoCAD client are RSImport, RSExport and RSMakeMember.
Use RSImport to load the xml file just exported from Revit.
Modify some cross sections in the model using the OPM, simulating modifications made by the A&D application, and optionally RSMakeMember to add some new elements.
Use RSExport to write the model back out again.
Back in Revit, use the import command to read the modifications and update the Revit model accordingly. Dialogue boxes are displayed to report the number of elements imported and modified. Note that the column types were swapped. Currently, the new elements defined by RsMakeMember are ignored.
RstLink Modules
RstLink
Helper dll shared by both acad and revit client
RSLinkRevitClient
Revit command implementations
RSLinkImport, RSLinkExport
RSLinkRevitApp
Revit external application
RSLinkAcadClient
AutoCAD client
RSImport, RSExport, RSMakeMember
RSLinkAcadClientDynProps
Dynamic Revit properties for AutoCAD objects
RstLink
RstLink Revit Export
RstLink
RstLink AutoCAD Import
Invoke RSImport command
RstLink
Modify Cross Section
Edit dynamic properties
Change cross section
RstLink
Add new Members and Data
Invoke RSMakeMember command
RstLink
Import Modified Data into RST
RSExport from AutoCAD
Import into Revit
Column type was swapped
New elements are ignored
RstLink
Another Practical Example
MidasLink
Subscription only module
Source code for 2008 available on ADN
Source code for 2009 still to come
Search for "MidasLink"
http://adn.autodesk.com/adn/servlet/item?siteID=4814862&id=9628885&linkID=4901650
Includes
Analysis package executable
Documentation
Source code
Installer
RstLink
MidasLink is a Revit Structure add-in program that exports and imports the Revit model to and from the MIDAS/Gen structure analysis application. The source code is provided to help developers integrating analysis programs with Revit Structure. The compiled add-in is available to Revit Structure subscription customers.
Analysis Software
ADAPT
www.adaptsoft.com/releases.php
RISA
www.risatech.com/partner/revit_structure.asp
RAM
www.bentley.com/structural
CSC
MIDAS - MidasLink subscription module)
ROBOBAT - recently acquired by Autodesk
http://www.extensions4revit.com/n/e4r
Analysis Partners site:
http://usa.autodesk.com/adsk/servlet/item?id=8447050&siteID=123112
RstLink
Here is an overview of some other available analysis link packages. An up-to-date list is available on the analysis partners site. Robot Millennium is an analysis software by Robobat, which is recently acquired by Autodesk.
Rebar
Sample and API feature walkthrough in the rebar and detailing workflow context
Revit Structure Rebar Workflow
Revit Structure 3D
Object Model
Physical Model
Analytical Model
3D Rebar Model
User
Input
3rd Party
Analysis
Design
Concrete Drawings
Specific Rebar Details
Specific Rebar Details
Shop
Drawing
Typical Rebar Details
3D Design
QTO
User
Input
User
Input
Manual
Automated
Rebar
Working with reinforcements in Revit Structure involves two phases. The initial phase is the building analysis, which may result in design changes. In the second phase, reinforcements are added, analysed, and detailed. Both phases may include multiple iterations. Many of the tasks required can be automated. This is where our applications can save a lot of time, effort, and eliminate sources for errors.
The central hub is the Revit Structure three-dimensional object model which integrates the physical and analytical models used respectively for the building design and analysis. The 3D rebar model is integrated in this database. The physical model is used to generate concrete drawings including rebar specific details. The rebar model can be used to generate rebar specific details and quantity takeoffs. The analytical model is used to connect to third party analysis and design packages, which in turn can help define the rebar model.
The 3D Rebar Model
Revit Structure has a 3D rebar model composed of
Single bars
Sets (array of bars with rules)
Area reinforcement for slabs and walls
Path reinforcement for slabs
3D rebar model can be generated
Manually by user
Loaded from a group that defines a cage
Generated with the API from analysis and design software or from macros
Advantages of 3D rebar model
Quantities
Complex layout
Automatic reinforcement drawings
Basic scheduling
Scheduling is specific to each country
Opportunity for third party developers to use the 3D rebar model to generate DWG schedules and import them back as a drafting view in Revit Structure
Rebar
Relationship Between Topics
Rebar
Generate rebar and define rebar shape
Extract rebar information
Truss
Detailing
Generate a section view
Generate a drafting view
Create a sheet
Import and export external file formats (e.g., dwg)
Add text, dimensioning and annotations
Rebar
Here are some relationships between these rebar topics and the rebar workflow: after the structural framing analysis part is done, an engineer will take the values of the load and stress information for each element and design the rebar for each element. You design the size of the column, number of rebars, and number of rib-bars. Based on this information, a rebar can be generated externally. It may need modification, which requires extraction and analysis of existing information. The extracted information may also be used for estimation purposes. To show the rebar placement in a column or beam, you need a section view. The Revit SDK samples CreateSimpleAreaRein and CreateComplexAreaRein generate reinforcement elements, and can be used to demonstrate the kinds of section view required. For structure detailing, we need a drafting view where we may want to import a dwg file. Adding text, annotations and dimensioning is further typical detailing functionality. Some of the items listed here are general, but especially useful as part of the rebar workflow for structural detailing. The underlined topics are new or updated in Revit 2009.
Generate Beam or Column Rebar
Changed in 2009
Sample: Reinforcement
Create reinforcement bars in selected non-reinforced concrete beam or column
Beam rebar: top, bottom or transverse
Column rebar: transverse or vertical
Class
Autodesk.Revit.Elements.Rebar
Methods
Rebar
// rebar creation in 2008:
Rebar r = doc.Create.NewRebar( rebarType, startHook, endHook, m_hostObject,
ref origin, ref normal, curves, (int)startOrient, (int)endOrient );
// two overloaded functions in 2009
// useExistingShapeIfPossible, createNewShape
// demonstrated in NewRebar sample
Rebar r = doc.Create.NewRebar( RebarStyle.Standard, rebarType, startHook, endHook,
m_hostObject, normal, curves, (int)startOrient, (int)endOrient, false, true );
r = doc.Create.NewRebar( barShape, barType, m_rebarHost, origin, xVec, yVec );
We can use the Revit SDK sample Reinforcement to demonstrate the creation of new reinforcement elements. It creates a bar set in a selected concrete beam or column element  that does not have any reinforcement. Three kinds of beam rebar are created: top, bottom and transverse rebar. Two kinds of column rebar are created: transverse and vertical. It uses the Autodesk.Revit.Creation.Document.NewRebar() method to create rebar for the selected host. The NewRebar() method expects two parameters RebarBarType and RebarHookType. Suitable values for these two parameters can be retrieved by iterating the active document elements.
[MH] This sample shows how to create Rebar in concrete element (Beam or Column) which does not have any reinforcement. The method used to create Rebar, Create.NewRebar, has been changed in 2009.  The first argument RebarStyle.Standard is an enumeration value - you can choose either standard/stirrupTie (stirrup or tie bar). The style affects the bend radius and the set of allowable hooks. It also affects the rebar instance auto-constraining behavior. ...
Reinforcement Implementation
FrameReinMakerFactory class manages all the work
Precondition checks
Is the selected object a beam or column?
Is it made of concrete?
Does it already contain any rebar elements?
Create a corresponding FrameReinMaker and the reinforcement rebars
Host-dependant working classes
BeamFramReinMaker and ColumnFramReinMaker
GeomUtil
Basic geometric utility methods
GeometrySupport
Base class for BeamGeometrySupport and ColumnGeometrySupport, manages the solid of beam or column, the extend or sweep path of the beam or column, the beam or column direction vector, lists to store the edges and points, the transformation etc.
ParameterUtil
Utility methods find or set certain parameter
Rebar
Generate Rebar Demo
Ensure only one beam or column is selected
Retrieve all rebar types and all hook types
Retrieve and analyse member geometry
Run worker method
Rebar
This is demonstrated by the sample Reinforcement. The sample can create rebar for both beam and column.
Register the command:
[ExternalCommands]
ECCount = 	16
ECName16=Rebar - Reinforcement
ECClassName16 = Revit.SDK.Samples.Reinforcement.CS.Command
ECAssembly16 = C:\a\lib\revit\2008\sdk\Samples\Reinforcement\CS\bin\Debug\Reinforcement.dll
ECDescription16 = Create bar set in a selected concrete element (beam or column) that does not have any reinforcement.
Draw a Concrete Beam or Column elements without any reinforcement and select it.
Please make sure the beam or column section size is big enough, e.g. for column it can be 24x32.
Run the command.
Set the parameters for the rebar in the pop up dialog.
Click Ok, Rebar for the selected element (Beam or Column) will be created.
If you want to debug, this can be done from SDKSamples10.0.sln.
Rebar API Enhancement in 2009
Rebar is an instance of RebarShape in 2009
Added
Revit.Symbols.RebarShape - topological layout of rebar
Revit.Symbols.RebarShapeDefinition(ByArc/BySegments) 
- helper class to define RebarShape
Revit.Symbols.RebarCoverType - rebar cover setting, name and value pair
Revit.Elements.RebarHostData - helper class to access to a host cover setting
Changed
Revit.Symbols.RebarType - cleaned up, no new functionality
Samples: NewRebar
Rebar
RebarHostData and RebarCoverType: Clear cover is now associated with individual faces of valid rebar hosts. Access to the cover settings of a host is through the Autodesk.Revit.Elements.RebarHostData object. A simpler, less powerful mechanism for accessing the same settings is provided through parameters. Cover is defined by a named offset distance, modeled as an element Autodesk.Revit.Symbols.RebarCoverType.
NewRebar Sample
Rebar
Create a Rebar
Define a custom Rebar shape
NewRebar Sample (cont.)
Rebar
Instructions under
NewRebar/CS/Customize RebarShapes Step by step
Arc with radius(*)
(*) known issues - places rebar out side of a host objects both in UI and API
Collection of straight segments
Arc with chord length (*)
Lapped circle (*)
NewRebar Sample (cont.)
Rebar
RebarShapeDefinitionBySegments
Create a RebarShape
RebarShape myShape = rvtDoc.Create.NewRebarShape()
Create a RebarShapeDef
RebarShapeDefinitionBySegment myDef 
  = myShape.NewDefinitionBySegments(segmentCount)
Add shared parameters by external def
myDef.AddParamater( externalDef, value )
Add constraints to shape definition
myDef.AddConstraintToSegment
myDef.AddConstraintParallelToSegment
myDef.AddBendDefaultRadius
myDef.SetSegmentFixedDirection
myDef.AddListingDimentionBendToBend
Set Hook to RebarShape 
myShape.set_HookAngle
myShape.set_HookOrientation
ExternalDefinition
The parameter. To obtain this object, the following calls are required: Application.OpenSharedParameterFile(); Parameters.DefinitionFile.Groups.get_Item() or .create(); and Parameters.DefinitionGroup.Definitions.get_Item() or .create().
Generate Floor or Wall Rebar
Changed in 2009
Sample: NewPathReinforcement
Create path reinforcement
Class
Autodesk.Revit.Elements.Rebar
Method
Rebar
XYZ p1, p2; Line curve;
CurveArray curves = m_appCreator.NewCurveArray();
for( int i = 0; i < points.Count - 1; ++i )
{
p1 = new XYZ( points[i].X, points[i].Y, points[i].Z );
p2 = new XYZ( points[i + 1].X, points[i + 1].Y, points[i + 1].Z );
curve = rvtDoc.CreateNewLine( ref p1, ref p2, true );
curves.Append( curve );
}
// type is no longer needed, default is used in 2009:
return rvtDoc.Create.NewPathReinforcement( m_host, curves, flip );
We can use the Revit SDK sample NewPathReinforcement to demonstrate how to create a new PathReinforcement element through the API. The PathReinforcement host is a floor or a wall. The method used is
NewPathReinforcement( PathReinforcementType, Element, CurveArray, bool );
We can use Document.Create.NewPathReinforcementType() method to create a  PathReinforcementType if there is none in current document. The Element argument is the host of the PathReinforcement. The CurveArray stores its path. The Boolean value indicates which side of the path the PathReinforcement is located on.
To run the sample, draw a Structure wall or slab, select it, and run this command. Draw the path of PathReinforcement you want to create. You can click right mouse button to finish drawing. Click the "Preview" button to preview the path reinforcement to be created. Select or unselect the "Flip" check box to create the PathReinforcement on the left or right side of the path. Click the "Create" button to create the PathReinforcement. You can clean and redraw the sketch of the path using the "Clean" button. Here is the central code snippet given an array of points defining the path.
Extract Rebar Information
AreaReinParameters Sample
Provides starting point
Extended to list rebar information
Uses built-in parameters
BarDescriptions Sample
AreaReinforcement has a BarDescription property
Same functionality as above
Generic Tools
BuiltInParameterChecker
RvtMgdDbg
Rebar
All the generic data extraction and debugging utilities such as RvtMgdDbg and BuiltInParameterChecker can be used to read parameters and other information from a rebar element.
In addition, the Revit SDK sample AreaReinParameters shows how to use the API to display and modify AreaReinforcement parameters. We have expanded the sample to list rebar elements and their parameters as well in a separate command RebarParas. The enhanced sample is included in the presentation material.
Another sample for extracting rebar information is the BarDescriptions sample. It shows how to find all BarDescriptions in the project, display their properties in a DataGridView, and export their parameter information to an external comma delimited *.csv file. BarDescription is a property of an AreaReinforcement element, so some AreaReinforcement elements should be drawn first.
Some rebar information is accessible through built-in parameters and can be determined using BuiltInParameterChecker, some is accessible only through hard-coded localised parameter names. The AreaReinParameters sample only works with floor or wall area reinforcements, not with rebar. Not all rebar parameters are accessible as built-in parameters. We can however retrieve almost all necessary information with its instance parameters, hence the RebarParas enhancement.
Rebar Information Demo
Rebar
Register the command:
[ExternalCommands]
ECName32 = RebarParas
ECClassName32 = Revit.SDK.Samples.AreaReinParameters.CS.RebarParas
ECAssembly32 = C:\Revit\SDK\Samples\AreaReinParameters\CS\bin\Debug\AreaReinParameters.dll
ECDescription32 = Show parameters of a rebar
Select a rebar.
Run this command.
Truss
Truss
New in 2009
RST, C#
Create a truss of a selected truss type
Change beam types
Edit the profile of the truss
Truss
Detailing
Detailing
Detailing
Generate a section view
Generate a drafting view
Create a sheet
Import and export external file formats, e.g. dwg
Add text, dimensioning and annotations
Enhanced standard Revit SDK samples
Included in normal Revit 2009 SDK distribution
Detailing
Generate Section View
Demonstrate creation of a Detail View
Using NewViewSection()
Creates detail view across the midpoint of selected element
Works on linear elements such as slab, wall and beam
Create and initialise a bounding box
Detailing
// create a BoundingBoxXYZ and set the Max and Min properties:
BoundingBoxXYZ m_box = new BoundingBoxXYZ();
m_box.Enabled = true;
m_box.Max = new XYZ(LENGTH, LENGTH, 0);
m_box.Min = new XYZ(-LENGTH, -LENGTH, -HEIGHT);
// setting the Transform property is the most important thing.
// it defines the origin and the directions RightDirection,
// UpDirection and ViewDirection) of the created view:
Transform transform = GenerateTransform();
if (null == transform)
{
return false;
}
m_box.Transform = transform;
// Create a section view, pass the bounding box.
ViewSection section = m_project.Create.NewViewSection(m_box);
The Revit SDK sample CreateViewSection demonstrates the creation of a detail view. Given a linear element such as a wall, floor or beam, it generates a section view across the midpoint of the element using the NewViewSection() method. It performs the following steps:
Retrieve the selected linear element
Generate a BoundingBoxXYZ instance to be used in NewViewSection()
Set its Max and Min properties
Generate a Transform instance for the BoundingBoxXYZ Transform property, which defines the origin and directions of the created view, including RightDirection, UpDirection and ViewDirection
Create the section view using the BoundingBoxXYZ.
The NewViewSection method takes a parameter of type BoundingBoxXYZ. The key part of the code is actually to create the box. And the key part for the box is to create its transform matrix. The actual matrix generated depends on the selected element type. Separate implementations are provided for beam, floor and wall. These are called from within GenerateTransform().
Generate Section View Demo
Detailing
Use the Revit SDK sample CreateViewSection to demonstrate this.
Register the command:
ECName19=Rebar - CreateViewSection
ECClassName19=Revit.SDK.Samples.CreateViewSection.CS.Command
ECAssembly19=C:\a\lib\revit\2008\sdk\Samples\CreateViewSection\CS\bin\Debug\CreateViewSection.dll
ECDescription19=Create a section view across the mid point of the selected wall, floor or beam
Launch Revit Structure 2008.
Open the project Rebar.rvt.
Select a beam or column with rebar.
Execute the external command.
Note that a new section view is added to the detail views in the project explorer.
Generate Drafting View
Code
Document doc = commandData.Application.ActiveDocument;
// Create a drafting view
ViewDrafting drafting = doc.Create.NewViewDrafting();
Detailing
The NewViewDrafting() method does not take any parameters. It creates an empty drawing view. We have added a second external command CreateDraftingView to the Revit SDK sample CreateViewSection to demonstrate this.
Import DWG
Import
Detailing
DWGImportOptions opts = new DWGImportOptions();
opts.Placement = ImportPlacement.Centered; // Origin, Center, Shared
// other possible options.
opts.ColorMode = ImportColorMode.Preserved; // BlackAndWhite, Inverted, Preserved
//opts.CustomScale = 1;
opts.OrientToView = true; // true or false
opts.ThisViewOnly = false; // imports dwg, dgn, and dxf into active view only?
opts.Unit = ImportUnit.Default;
opts.View = m_revitApp.ActiveDocument.ActiveView;
opts.VisibleLayersOnly = false; // true or false
Revit.Element newElement = new Revit.Element();
rvtDoc.Import( dbox.FileName, opts, ref newElement );
Importing and exporting DWG files is demonstrated by the Revit SDK sample ImportExportDWG. It shows how to export the current project to dwg files and import a dwg file into Revit. It also demonstrates how to and provides a user interface to set up the import and export options appropriately. To run it, start up Revit, open a suitable project, and execute the command.
To export, check the radio button "Export". In the next dialog, specify the file name to export as, set the common options and click the "Option..." button to set the lower priority options; click the "Select..." button to select multi-views to export. Then click the "Save" button to perform the export.
To import, check the radio button "Import". In the next dialog, specify the file to import from and set the other options. Then click the "Open" button to perform the import.
The last parameter of the Import() method is an element. It is not neccessary to create a new element prior calling the Import() method. You can simply pass a variable of type Element and it can be null. This provides a possibility to return the element that was just imported, so that it can be accessed and modified after the import. For example, if you import an image, the import method gives you no scaling nor rotating options. If you would need this functionality, you can achieve it by manipulating the image after the import.
Export DWG
Export
Detailing
opts dwgExportOptions = new DWGExportOptions();
opts.ExportingAreas = false; // export room and areas
opts.FileVersion = ACADVersion.R2007; // acad file version
opts.LayerMapping = "AIA"; // layer standard: AIA/CP83/BS1192/ISO13567
opts.LineScaling = LineScaling.ModelSpace; // or PaperSpace/ViewScale
opts.MergedViews = true;
opts.PropOverrides = PropOverrideMode.NewLayer; // or ByLayer/ByEntity
opts.SharedCoords = true;
opts.TargetUnit = ExportUnit.Millimeter;
opts.ExportOfSolids = SolidGeometry.ACIS;
exported = rvtDoc.Export( folder, name, views, opts );
Import and export DWG Demo
Detailing
We use the Revit SDK sample ImportExportDWG to demonstrate this.
Register the command:
ECName21=ImportAndExportForDWG
ECClassName21=Revit.SDK.Samples.ImportAndExportForDWG.CS.Command
ECAssembly21=C:\a\lib\revit\2008\sdk\Samples\ImportExportDWG\CS\bin\Debug\ImportAndExportForDWG.dll
ECDescription21=Export current project to dwg files and import a dwg file into revit
Open Revit application and execute the command.
To export, check the radio button "export". In the next dialog, specify the file name to export as, set the common options and click "Option..." button to set the lower priority options, click "Select..." button to select multi-views to export. Then click "Save" button to perform export.
To import, check the radio button "import". In the next dialog, specify the file to import from and set the other options. Then click "Open" button to perform import
I exported the level 1 in the attached test revit project.
ImportExport
All, C#
ImportExportDWG was enhanced to handle additional file formats
Export - dwg, 2D and 3D dwf and dwfx, gbxml and FBX
Import - dwg and image file
New API classes added
Detailing
One sample was changed after beta1 build.
The ImportExportDWG sample was renamed to ImportExport in the RTM build.
More file formats rather than just DWG format were supported in this sample. That is why the DWG suffix has been removed from the sample name.
This sample is written in C# and applies to all Revit platforms.
The changed name was changed from ImportExportDwg to ImportExport. It supports not only DWG format but also DWF, FBX, and gbXml.
More specifically, it demonstrates how to export the current Revit model to ... and import ... into ...
Many import/export related classes are used in the sample. For example, ...
Instructions:
1. Open Revit application and execute the command.
2. To export, check the radio button "export", select the format to export and click "OK" button. The 3D DWF(x) and fbx formats will be available only when current view is a 3D view.
3. To export dwg or 2D DWF(x) formats Specify the file name to export to, set the common options and click "Option..." button to set the lower priority options, click "Select..." button to select multi-views to export. Then click "Save" button to perform export.
4. To export 3D DWF(x), gbxml or fbx formats
Specify the file name to export to and click "Save" button to perform export.
[NOTE]To export fbx format successfully, the Revit render appearance library must have been installed.
To import, check the radio button "import" and click "OK" button. The image format will be available only when current view is not 3D view.
To import dwg format, Specify the dwg file to import and set the other options. Then click "Open" button to perform import.
To Import image format, Specify the image file to import and click "Open" button to perform import.
Create New dimensioning
Create a dimension between two references
CreateDimensions sample
Detailing
XYZ p1 = newLine.get_EndPoint(0);
p1.X += 5;
p1.Y += 5;
XYZ p2 = newLine.get_EndPoint(1);
p2.X += 5;
p2.Y += 5;
Line newLine2 = app.Create.NewLine( ref p1, ref p2, true );
// set the references
. . .
// create a dimention
Dimension newDimension = rvtDoc.Create.NewDimension(
rvtDoc.ActiveView, newLine2, referenceArray );
New dimenioning can be generated through the API using the NewDimension() method. Searching globally through all the samples discovers one single instance of this method, in the CreateDimensions sample. This sample adds a command taking a selection of basic structural walls and adds dimensioning from the start to the end of each. Dimensioning is created between graphical references stored in a ReferenceArray instance. The key part is the creation of the reference array. Once the reference array has been set up, the creation of the dimensioning is simple.
Dimensioning Reference Array
Create a reference array for a structural wall
Detailing
ReferenceArray referenceArray = new ReferenceArray();
Options options = rvtApp.Create.NewGeometryOptions();
options.ComputeReferences = true;
options.View = rvtDoc.ActiveView;
Revit.Geometry.Element geomElem = wallTemp.get_Geometry(options);
GeometryObjectArray geoObjectArray = geomElem.Objects;
for (int j = 0; j < geoObjectArray.Size; j++)
{
GeometryObject geoObject = geoObjectArray.get_Item(j);
Curve curve = geoObject as Curve;
if (null != curve)
{
//find the two upright lines beside the line
if (Validata(newLine, curve as Line))
{
referenceArray.Append(curve.Reference);
}
if (2 == referenceArray.Size)
{
break;
}
}
}
For the basic wall, the location line of the wall is used to discover the two vertical edges at each end of one side of the wall. Some calculation and comparison work needs to be done in order to find the two right reference lines. For each of these two curves, a reference is added to the reference array. Note that the geometry options for obtaining the wall geometry have options.ComputeReferences set to true.
Dimension Creation Tips
Extend the sample to work with other elements than structural wall
Architectural wall cannot get reference from edge
Use face instead - not all geometry has reference
Detailing
Solid solid = geoObject as Solid;
if(null != solid)
{
FaceArrayIterator faceItor = solid.Faces.ForwardIterator();
while (faceItor.MoveNext())
{
PlanarFace face = faceItor.Current as PlanarFace;
if (null != face)
{
// find the two upright lines beside the line.
// NOTE: overloading this function. We pick up the face in term of its Normal.
if (Validata(newLine, face.Normal))
{
referenceArray.Append(face.Reference);
}
if (2 == referenceArray.Size)
{
break;
// . . .
Rebar dimensioning
Extending the sample to work with rebar
Need to dig into geometry elements ...
SPR #125909  API wish: create dimension between a column edge and a rebar center
Detailing
// get rebar reference
if (m_rebar != null)
{
Revit.Geometry.Element gelement = m_rebar.get_Geometry(options);
GeometryObjectArray geoObjectArray = gelement.Objects;
// enum the geometry element
for (int j = 0; j < geoObjectArray.Size; j++)
{
GeometryObject geoObject = geoObjectArray.get_Item(j);
Line line = geoObject as Line;
if (line != null && line.Reference != null)
{
referenceArray.Append(line.Reference);
}
}
}
Add Tags
Simple Tag sample in RvtMgdDbg's Test Framework
Detailing
if( elem is Rebar )
{
// Cast to Rebar and get its first curve
Revit.Elements.Rebar rebar = elem as Rebar;
Revit.Geometry.Curve curve = rebar.Curves.get_Item(0);
// Create a rebar tag at the first end point of the first curve
IndependentTag tag = revitDoc.Create.NewTag(
view,                          // view to place the tag
rebar,                         // host object to tag
true,                          // have a leader?
TagMode.TM_ADDBY_CATEGORY,     // mode by category, multi-category or material
TagOrientation.TAG_HORIZONTAL, // orientation: vertical/horizontal
curve.get_EndPoint(0) );       // location point
}
The NewTag method signature and its parameters:
public IndependentTag NewTag(
   View dbview,
   Element objelem,
   bool leader,
   TagMode tagmode,
   TagOrientation tagorientation,
   XYZ pnt
);
Parameters
dbview
The view in which the dimension is to be visible.
objelem
The host object of tag
leader
whether have leader
tagmode
the mode of tag. Add by Category, add by Multi-Category and add by material
tagorn
The Orientation of the Tag
pnt
The position of the Tag
I used category tag mode and horizontal tag orientation here.
Add Text
Detailing
if( elem is Rebar )
{
// cast to Rebar and get its first curve
Revit.Elements.Rebar rebar = elem as Rebar;
Revit.Geometry.Curve curve = rebar.Curves.get_Item(0);
// calculate arguments
Revit.Geometry.XYZ origin = curve.get_EndPoint(0);
origin.X += curve.Length * 10; // draw the text at the right size
Revit.Geometry.XYZ baseVec = new Revit.Geometry.XYZ(1,0,0);
Revit.Geometry.XYZ upVec = new Revit.Geometry.XYZ(0,0,1);
double textSize = curve.Length / 10;
double lineWidth = curve.Length / 50;
string strText = "This is " + rebar.Category.Name + " : " + rebar.Name;
// create the text
Revit.Elements.TextNote text = revitDoc.Create.NewTextNote(
view, origin, baseVec, upVec, textSize, lineWidth,
Revit.Enums.TextAlignFlags.TEF_ALIGN_CENTER
| Revit.Enums.TextAlignFlags.TEF_ALIGN_MIDDLE, strText );
text.Width = curve.Length * 10; // set the width of the text
}
public TextNote NewTextNote(
   View pView,
   XYZ origin,
   XYZ baseVec,
   XYZ upVec,
   double textSize,
   double lineWidth,
   TextAlignFlags textAlign,
   string strText
);
Parameters
pView
Current DBView
origin
origin of the TextNote
baseVec
baseVec parameter of the TextNote.
upVec
upVec parameter of the TextNote.
textSize
text size.
lineWidth
line width of the out rectangle.
textAlign
align style.
strText
text.
TextNote is just text. The textSize parameter of the NewTextNote method is actually not used and can be ignored Tao says 'Our developer has confirmed that this param is no use at all for the internal behavior has been changed. The actual size value comes from Font (family type). So this param should be removed. Our developer will fix it.'
Learning More
Online Help and SDK Samples
DevTV Introduction to Revit 2008 Programming
http://adn.autodesk.com/adn/servlet/item?siteID=4814862&id=10194238&linkID=4901650
Recording of Revit 2009 Programming Introduction Webcast
http://adn.autodesk.com/adn/servlet/index?siteID=4814862&id=5475217&linkID=4901650
http://www.adskconsulting.com/adn/cs/api_course_sched.php
Discussion Groups
http://discussion.autodesk.com  > Revit API
API Training Classes
http://www.autodesk.com/apitraining
Autodesk Developer Network
http://www.autodesk.com/joinadn
DevHelp Online for ADN members
http://adn.autodesk.com/
Learning More
www.autodesk.com\devcamp2008
Thank you very much!
Thank you for your interest and attention!