结构工程

以下各节介绍了仅与Revit的结构工程功能相关的API功能：

  • 结构模型元素-讨论仅与Revit的结构工程功能相关的特定元素及其属性。

  • AnalyticalModel -讨论与分析模型相关的类，如AnalyticalModel、RigidLink和AnalyticalModelSupport。

  • AnalyticalLink -讨论在分析梁和柱之间创建新的分析链接。

  • 荷载-讨论荷载设置和三种荷载。

您的分析链接-为希望将Revit链接到某些Structural Analysis应用程序的API用户提供建议。

本章包含一些高级主题。如果您不熟悉Revit Platform API，请先阅读基本部分，如“入门”、“元素要素”、“参数”等。

  • 本节中的主题
    • 结构模型元素
    • 分析模型
      在结构工程中，分析模型是结构物理模型的工程描述。
    • 荷载
      以下部分确定荷载设置并讨论荷载限制指南。
    • Analysis Link分析链接
    • Analytical Links

结构模型元素

结构模型元素实际上是支撑结构的元素，如柱、钢筋、桁架等。以下部分介绍如何操作这些元素。

本节中包含的模型元素特定于Revit的结构工程功能。有关其他结构元素类的详细信息，请参见“墙、楼板、屋顶和洞口”和“族”中的相应部分。

本节中的主题

  • 结构柱、梁和支撑
  • 桁架
  • 加强
    Revit API提供了用于管理有效主体（如混凝土柱、梁、墙、基础和结构楼板）中的钢筋（如钢筋、钢筋或钢筋网）的类。
  • 边界条件
  • 板

结构柱、梁和支撑

结构柱、梁和支撑

结构柱、梁和支撑元素都由FamilyInstance类表示。它们由StructuralType属性区分。

代码区域29-1：柱、梁和支撑的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public void GetStructuralType(FamilyInstance familyInstance)
{
    string message = "";
    switch (familyInstance.StructuralType)
    {
        case StructuralType.Beam:
            message = "FamilyInstance is a beam.";
            break;
        case StructuralType.Brace:
            message = "FamilyInstance is a brace.";
            break;
        case StructuralType.Column:
            message = "FamilyInstance is a column.";
            break;
        case StructuralType.Footing:
            message = "FamilyInstance is a footing.";
            break;
        default:
            message = "FamilyInstance is non-structural or unknown framing.";
            break;
    }

    TaskDialog.Show("Revit",message);
}

可以使用类别过滤出与结构柱、梁和支撑对应的FamilySymbol对象。结构梁和支撑的类别为BuiltInCategory.OST_StructuralFraming。结构柱的类别为BuiltInCategory.OST_StructuralColumns。

代码区域29-2：使用BuiltInCategory.OST_StructuralFraming

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public void GetBeamAndColumnSymbols(Document document)
{
    List<FamilySymbol> columnTypes = new List<FamilySymbol>();
    List<FamilySymbol> framingTypes = new List<FamilySymbol>();
    FilteredElementCollector collector = new FilteredElementCollector(document);
    ICollection<Element> elements = collector.OfClass(typeof(Family)).ToElements();

    foreach(Element element in elements)
    {
        Family family = element as Family;
        Category category = family.FamilyCategory;
        if (null != category)
        {
            ISet<ElementId> familySymbolIds = family.GetFamilySymbolIds();
            if ((int)BuiltInCategory.OST_StructuralColumns == category.Id.IntegerValue)
            {
                foreach (ElementId id in familySymbolIds)
                {
                    FamilySymbol symbol = family.Document.GetElement(id) as FamilySymbol;
                    columnTypes.Add(symbol);
                }
            }
            else if ((int)BuiltInCategory.OST_StructuralFraming == category.Id.IntegerValue)
            {
                foreach (ElementId id in familySymbolIds)
                {
                    FamilySymbol symbol = family.Document.GetElement(id) as FamilySymbol;
                    framingTypes.Add(symbol);
                }
            }
        }
    }

    string message = "Column Types: ";
    foreach (FamilySymbol familySymbol in columnTypes)
    {
        message += "\n" + familySymbol.Name;
    }

    TaskDialog.Show("Revit",message);
}

可以使用FamilyInstance.ExtensionUtility属性获取和设置梁缩进属性。如果此属性返回null，则无法修改梁缩进。

BeamSystem

BeamSystem提供对梁系统的完全访问和编辑能力。可以获取和设置其所有属性，例如BeamSystemType、BeamType、Direction和Level。方向不限于一条边。它可以设置为与BeamSystem在同一平面上的任何XYZ坐标。

注意：在UI中或通过API更改了Elevation属性后，不能更改StructuralBeam AnalyticalModel。在下图中，梁系统高程更改为10英尺后，分析模型线仍保留在原始位置。

图156：改变梁系统标高

桁架

桁架

桁架类表示Revit中的所有桁架类型。TrussType属性指示桁架的类型。

代码区域29-7：在两个柱上创建桁架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
Truss CreateTruss(Autodesk.Revit.DB.Document document, FamilyInstance column1, FamilyInstance column2)
{
    Truss truss = null;
    using (Transaction transaction = new Transaction(document, "Add Truss"))
    {
        if (transaction.Start() == TransactionStatus.Started)
        {
            //sketchPlane
            XYZ origin = new XYZ(0, 0, 0);
            XYZ xDirection = new XYZ(1, 0, 0);
            XYZ yDirection = new XYZ(0, 1, 0);
            XYZ zDirection = new XYZ(0, 0, 1);
            Plane plane = Plane.Create(new Frame(origin, xDirection, yDirection, zDirection));
            SketchPlane sketchPlane = SketchPlane.Create (document, plane);

            //new base Line - use line that spans two selected columns
            AnalyticalModel frame1 = column1.GetAnalyticalModel() as AnalyticalModel;
            XYZ centerPoint1 = (frame1.GetCurve() as Line).GetEndPoint(0);

            AnalyticalModel frame2 = column2.GetAnalyticalModel() as AnalyticalModel;
            XYZ centerPoint2 = (frame2.GetCurve() as Line).GetEndPoint(0);

            XYZ startPoint = new XYZ(centerPoint1.X, centerPoint1.Y, 0);
            XYZ endPoint = new XYZ(centerPoint2.X, centerPoint2.Y, 0);
            Autodesk.Revit.DB.Line baseLine = null;

            try
            {
                baseLine = Line.CreateBound(startPoint, endPoint);
            }
            catch (System.ArgumentException)
            {
                throw new Exception("Selected columns are too close to create truss.");
            }

            // use the active view for where the truss's tag will be placed; View used in
            // NewTruss should be plan or elevation view parallel to the truss's base line 
            Autodesk.Revit.DB.View view = document.ActiveView;

            // Get a truss type for the truss
            FilteredElementCollector collector = new FilteredElementCollector(document);
            collector.OfClass(typeof(FamilySymbol));
            collector.OfCategory(BuiltInCategory.OST_Truss);

            TrussType trussType = collector.FirstElement() as TrussType;

            if (null != trussType)
            {
                truss = Truss.Create(document, trussType.Id, sketchPlane.Id, baseLine);
                transaction.Commit();
            }
            else
            {
                transaction.RollBack();
                throw new Exception("No truss types found in document.");
            }
        }
    }
            
    return truss;
}

加强

Revit API提供了用于管理有效主体（如混凝土柱、梁、墙、基础和结构楼板）中的钢筋（如钢筋、钢筋或钢筋网）的类。

本节中的主题

  • Rebar 钢筋
    Rebar类表示用于加强适当元素（如混凝土梁、柱、板或基础）的钢筋。
  • 钢筋连接器
    钢筋连接器用于连接相邻钢筋。
  • 区域和路径钢筋
    Revit API提供了表示Revit结构要素中的面积钢筋和路径钢筋的类。
  • 织物增强
    钢筋网是一层由焊接钢丝网制成的钢筋网，并置于混凝土板或墙内。
  • 钢筋容器
    钢筋容器是表示一个主体中钢筋聚合的元素。此元素只能通过API创建。
  • 钢筋设置
    有关模型中钢筋的几个设置在文档级别进行控制，并通过文档的ReinfocementSettings类进行访问。
  • 钢筋舍入
    钢筋修圆是编制施工图的重要内容。钢筋长度公差小于行业或当地标准通常被视为不适用于指定钢筋。

钢筋

Rebar 类表示用于加固合适元素（如混凝土梁、柱、板或基础）的钢筋。

创建钢筋

您可以使用以下三种静态 Rebar 方法之一创建钢筋对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static Rebar Rebar.CreateFromCurves(
        Document doc,
        RebarStyle style,
        RebarBarType rebarType,
        RebarHookType startHook,
        RebarHookType endHook,
        Element host,
        XYZ norm,
        IList<Curve> curves,
        RebarHookOrientation startHookOrient,
        RebarHookOrientation endHookOrient,
        bool useExistingShapeIfPossible,
        bool createNewShape
);//在项目中创建 Rebar 元素的新实例。所有曲线都必须属于由法线和原点定义的平面。
1
2
3
4
5
6
7
8
9
public static Rebar Rebar.CreateFromRebarShape(
        Document doc,
        RebarShape rebarShape,
        RebarBarType rebarType,
        Element host,
        XYZ origin,
        XYZ xVec,
        XYZ yVec
);//创建一个新的 Rebar 作为 RebarShape 的实例。该实例将具有 RebarShape 中的默认形状参数，其位置基于形状定义中形状的边界框。在计算形状的边界框之前，将从形状中删除钩子。如果在文档中可以找到合适的钩子，它们将被任意分配。
1
2
3
4
5
6
7
8
9
10
11
12
public static Rebar Rebar.CreateFromCurvesAndShape(
        Document doc,
        RebarShape rebarShape,
        RebarBarType rebarType,
        RebarHookType startHook,
        RebarHookType endHook,  
        Element host,
        XYZ norm,
        IList<Curve> curves,
        RebarHookOrientation startHookOrient,
        RebarHookOrientation endHookOrient
);//在项目中创建 Rebar 元素的新实例。该实例将具有 RebarShape 中的默认形状参数。所有曲线都必须属于由法线和原点定义的平面。

第一个版本从描述钢筋的曲线数组创建钢筋，而第二个版本根据 RebarShape 和位置创建 Rebar 对象。第三个版本从曲线数组中基于 RebarShape 创建钢筋。

使用 CreateFromCurves（） 或 CreateFromCurvesAndShape（） 方法时，参数 RebarBarType 和 RebarHookType 在文档的 RebarBarTypes 和 RebarHookTypes 属性中可用。

以下代码说明了如何创建具有特定布局的 Rebar。

代码区域 29-8：创建具有特定布局的钢筋

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Rebar CreateRebar(Autodesk.Revit.DB.Document document, FamilyInstance column, RebarBarType barType, RebarHookType hookType)
{
    // Define the rebar geometry information - Line rebar
    LocationPoint location = column.Location as LocationPoint;
    XYZ origin = location.Point;
    XYZ normal = new XYZ(1, 0, 0);
    // create rebar 9' long
    XYZ rebarLineEnd = new XYZ(origin.X, origin.Y, origin.Z + 9);
    Line rebarLine = Line.CreateBound(origin, rebarLineEnd);

    // Create the line rebar
    IList<Curve> curves = new List<Curve>();
    curves.Add(rebarLine);

    Rebar rebar = Rebar.CreateFromCurves(document, Autodesk.Revit.DB.Structure.RebarStyle.Standard, barType, hookType, hookType,
                        column, origin, curves, RebarHookOrientation.Right, RebarHookOrientation.Left, true, true);

    if (null != rebar)
    {
        // set specific layout for new rebar as fixed number, with 10 bars, distribution path length of 1.5'
        // with bars of the bar set on the same side of the rebar plane as indicated by normal
        // and both first and last bar in the set are shown
        rebar.GetShapeDrivenAccessor().SetLayoutAsFixedNumber(10, 1.5, true, true, true);
    }

    return rebar;
}

注意：有关创建钢筋元素的更多示例，请参见 Revit SDK 附带的钢筋和 NewRebar 示例应用程序。

下表列出了 Parameter REBAR_ELEM_LAYOUT_RULE的整数值：

表 59：钢筋布局规则

Value 值 0 1 2 3 4
描述 None 固定数量 最大间距 带间距的数字 最小净间距

The Rebar.GetShapeDrivenAccessor().ScaleToBox（） 方法提供了一种同时设置所有形状参数的方法。该行为类似于放置 Rebar 的 UI。

RebarHostData 和 RebarCoverType

明确保护层与有效钢筋主体的各个面关联。可以通过Autodesk.Revit.Elements.RebarHostData对象访问主体的保护层设置。通过参数提供了一种更简单、功能更弱的访问相同设置的机制。

Cover 由命名为偏移的距离定义，建模为 Autodesk.Revit.DB.Structure.RebarCoverType 的元素。

编号

钢筋是可以通过Revit API控制其编号的元素类别之一。NumberingSchema和NumberingSchemaType类可用于定义钢筋元素的组织方式，以便对其进行编号/标记。每个NumberingSchema控制一种特定类型的元素的编号。NumberingSchema的元素也是元素，并且每个Revit文档中的每种类型始终只有一个。所有内置编号架构的可用类型都在NumberingSchemaTypes类中枚举。

属于特定模式（例如NumberingSchemaTypes.StructuralNumberingSchemas.Rebar）的元素（例如Rebar）按顺序组织和编号。序列是共享相同编号分区的元素的集合，编号分区由它们各自的分区参数（NUMBER_PARTITION_PARAM）值定义。编号序列必须至少包含一个元素。换句话说，一旦存在至少一个元素，其分区参数具有不同于其他元素（在相同的编号模式中）的值，则建立序列。如果最后一个元素被删除（删除或移动到不同的序列），那么空序列将不再存在。

元素在创建时（基于当时的编号分区值）被分配给序列，方法是显式修改元素的Partition参数或使用AssignElementsToSequence（）方法。AssignElementsToSequence（）方法优于显式更改Partition参数，因为该方法会立即将更改应用于序列和元素编号，而更改的参数仅在当前事务关闭后生效。

除了直接或间接更改元素的Partition参数外，还可以使用NumberingSchema类的方法重新组织编号序列。MoveSequence（）方法将现有序列的所有元素移动到架构中尚不存在的新序列，从而有效地重命名所有受影响元素上的Partition参数。方法的作用是：在应用匹配策略的同时，从一个序列中删除所有元素，并将它们追加到另一个现有序列的元素中。方法MergeSequences（）接受所有指定序列的元素，并将它们全部移动到新创建的序列中。所有合并的元素将重新编号，并根据需要根据匹配算法进行匹配。

下面的示例使用MoveSequence（）方法在两个编号序列中交换Rebar的编号。

代码区域：交换号码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
/// <summary>
/// This method uses multiple moving operations to swap numbers
/// for Rebars in two numbering sequences. The sequences are
/// identified by the names of two numbering partitions.
/// </summary>
/// <param name="document">Document to modify</param>
/// <param name="part1">Name of the partition of one numbering sequence</param>
/// <param name="part2">Name of the partition of another numbering sequence</param>
private void SwapNumberingSequences(Document document, string part1, string part2)
{
    // Obtain a schema object for a particular kind of elements 
    NumberingSchema schema = NumberingSchema.GetNumberingSchema(document,NumberingSchemaTypes.StructuralNumberingSchemas.Rebar);

    using (Transaction transaction = new Transaction(document))
    {
        // Changes to numbering sequences must be made inside a transaction
        transaction.Start("Swap Numbering Sequences");

        // We will use a temporary partition for the swap operation,
        // for the move operation only works if the target partition 
        // does not exist yet in the same numbering schema.
        // (We assume this TEMPORARY partition does not exist.)
        string tempPartition = "TEMPORARY";

        // Step 1
        // First we move all elements from one sequence into 
        // a partition we know does not exist. This action will
        // create the temporary partition and remove the original
        // one (part1).
        schema.MoveSequence(part1, tempPartition);

        // Step 2
        // With the sequence in partition 'part1' removed
        // we can now move elements from the second sequence to it.
        // This action will re-create a sequence in partition 'part1'
        // and remove the sequence in partition 'part2'
        schema.MoveSequence(part2, part1);

        // Step 3
        // Finally, we can move elements 'parked' in the temporary
        // sequence to partition 'part2', for that partition was
        // removed in the previous step and thus can now be created
        // again. The temporary partition will be automatically 
        // removed upon completing this step.
        schema.MoveSequence(tempPartition, part2);

        transaction.Commit();
    }
}

不同序列中的元素独立地编号，这意味着即使元素不同，在两个序列中也可能存在具有相同编号的元素。同样，在两个或更多个序列中可能存在完全相同的元素，其具有不同的数字。然而，在每个编号序列内，任何两个相同的元素将总是具有相同的编号，而不同的元件在编号序列内将永远不具有相同的编号。

创建后，Escape元素始终自动编号。每个新元素将获得一个递增的更大的数字。但是，与同一序列中的现有元素匹配的新元素将被分配相同的编号。元素将尽可能长时间地保留其分配的编号。这意味着，例如，如果删除了以前创建的某些钢筋图元，则所有剩余图元（在相同编号序列中）将保留其编号，这可能会导致相应编号序列中出现间隙。对于不需要空位的序列，可以通过调用RemoveGaps（）来移除空位。

下面的示例通过删除编号序列中的任何剩余间隙并设置每个序列的起始编号以使序列中的编号不重叠来合并钢筋元素上的编号。

代码区域：Consolidate Rebar Numbers

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
private void ConsolidateRebarNumbers(Document document)
{
    // Obtain a schema object for a particular kind of elements 
    NumberingSchema schema = NumberingSchema.GetNumberingSchema(document,NumberingSchemaTypes.StructuralNumberingSchemas.Rebar);

    // Collect the names of partitions of all the numbering sequences currently contained in the schema
    IList<string> sequences = schema.GetNumberingSequences();

    using (Transaction transaction = new Transaction(document))
    {
        // Changes to numbers must be made inside a transaction
        transaction.Start("Consolidate Rebar Numbers");

        // First we make sure numbers in all sequences are consecutive
        // by removing possible gaps in numbers. Note: RemoveGaps does
        // nothing for a sequence where there are no gaps present.

        // We also want to find what the maximum range of numbers is
        // of all the sequences (the one the widest span of used numbers)
        int maxRange = 0;

        foreach (string name in sequences)
        {
            schema.RemoveGaps(name);

            // Here we use First() from the Linq extension.
            // There is always at least one range in every sequence,
            // and after gaps are closed there is exactly one range.
            IntegerRange range = schema.GetNumbers(name).First();  
            int rangeSpan = 1 + (range.High - range.Low);
            if (rangeSpan > maxRange)
            {
                maxRange = rangeSpan;
            }
        }

        // Next we give sequences different start numbers
        // starting with 100 and then stepping by at least
        // the maximum range we found in the previous step
        int startNumber = 100;

        // We round the range up to the closest 100
        int step = 100 * (int)((maxRange + 99) / 100.0);

        foreach (string name in sequences)
        {
            schema.ShiftNumbers(name, startNumber);
            startNumber += step;
        }

        transaction.Commit();
    }
}

数字被存储为每个编号元素上的编号参数的值。通过查询NumberingSchema.NumberingParameterId属性获取参数的ID。可以通过查询相应编号元素的参数来获得编号的值。该值是只读的，因此无法设置;它始终根据编号分区中元素的关系以及每个元素编号顺序中的匹配策略计算。

尽管编号总是自动分配给模式的所有元素，但ChangeNumber（）方法为程序员提供了一种方法，只要新编号在编号序列中是唯一的，就可以显式地覆盖特定编号。调用者指定一个要更改的数字和一个要应用的新值，前提是该值在同一编号序列中还不存在。

分布类型

Rebar.DistributionType属性可用于修改钢筋集的类型。钢筋集可以是“均匀”或“可变长度”，对于均匀分布类型：所有钢筋参数与集中的第一个钢筋相同。对于可变长度分布类型：考虑到集合中第一个钢筋的约束，钢筋参数可以变化（主要是长度）。

Rebar.GetParameterValueAtIndex() 方法的作用是：获取位于指定索引处的条形图的参数值。仅接受0和NumberOfBarPositions-1之间的值。如果DistributionType为Uniform，则无论索引如何，返回的ParameterValue都相同。如果DistributionType为VaryingLength，则返回的ParameterValue在给定索引处计算。

边界条件

边界条件

有三种类型的边界条件：

  • Point 点
  • Curve 曲线
  • Area 区域

使用以下代码检索类型和相关的几何信息：

代码区域29-9：获取边界条件类型和几何形状

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public void GetInfo_BoundaryConditions(BoundaryConditions boundaryConditions)
{
    string message = "BoundaryConditions : ";

    boundaryConditions.GetBoundaryConditionsType();
    switch (boundaryConditions.GetBoundaryConditionsType())
    {
        case BoundaryConditionsType.Point:
            XYZ point = boundaryConditions.Point;
            message += "\nThis BoundaryConditions is a Point Boundary Conditions.";
            message += "\nLocation point: (" + point.X + ", "
                        + point.Y + ", " + point.Z + ")";
            break;
        case BoundaryConditionsType.Line:
            message += "\nThis BoundaryConditions is a Line Boundary Conditions.";
            Curve curve = boundaryConditions.GetCurve();
            // Get curve start point
            message += "\nLocation Line: start point: (" + curve.GetEndPoint(0).X + ", "
                    + curve.GetEndPoint(0).Y + ", " + curve.GetEndPoint(0).Z + ")";
            // Get curve end point
            message += ";  end point:(" + curve.GetEndPoint(1).X + ", "
                    + curve.GetEndPoint(1).Y + ", " + curve.GetEndPoint(1).Z + ")";
            break;
        case BoundaryConditionsType.Area:
            message += "\nThis BoundaryConditions is an Area Boundary Conditions.";
            IList loops = boundaryConditions.GetLoops();
            foreach (CurveLoop curveLoop in loops)
            {
                foreach (Curve areaCurve in curveLoop)
                {
                    // Get curve start point
                    message += "\nCurve start point:(" + areaCurve.GetEndPoint(0).X + ", "
                            + areaCurve.GetEndPoint(0).Y + ", " + areaCurve.GetEndPoint(0).Z + ")";
                    // Get curve end point
                    message += "; Curve end point:(" + areaCurve.GetEndPoint(1).X + ", "
                            + areaCurve.GetEndPoint(1).Y + ", " + areaCurve.GetEndPoint(1).Z + ")";
                }
            }
            break;
        default:
            break;
    }

    TaskDialog.Show("Revit",message);
}

板

板

Slab（结构楼板）和Slab Foundation都由Floor类表示，并由IsFoundationSlab属性区分。

板跨方向由API中的IndependentTag类表示，可用方式如下：

图157：板跨方向

使用NewSlab（）创建板时，不会自动创建跨方向。也没有办法直接创建它们。

“楼板”复合结构图层“结构桥面”属性由以下属性公开：

  • CompoundStructuralLayer.DeckUsage
  • DeckProfile

属性在以下对话框中列出：

img

图158：楼板复合结构层属性

分析模型

在结构工程中，分析模型是结构物理模型的工程描述。

以下结构图元具有结构杆件分析模型：

  • Structural Columns 结构柱
  • Structural Framing elements (such as beams and braces)
    结构框架图元（如梁和支撑）
  • Structural Floors 结构楼板
  • Structural Footings 结构基础
  • Structural Walls 结构墙

可以使用GetAnalyticalModel（）方法获得元素的AnalyticalModel。请注意，新创建的结构图元的AnalyticalModel在再生发生之前不可用。根据图元的族，AnalyticalModel可能不存在。如果AnalyticalModel值不适用于图元的族，则GetAnalyticalModel（）方法返回null。在使用这个类之前检查这个值。AnalyticalModel由以下信息组成：

  • 元素相对于分析的位置
  • 参数信息，包括投影、硬点、近似和刚性连接
  • 支持信息
  • 手动和自动调整信息
  • 分析偏移

在专业中提供特定选项：

  • AnalyticalModelStick -表示结构框架梁、结构框架支撑和结构柱的分析模型。
  • AnalyticalModelColumn - AnalyticalModelStick的子类，表示结构柱的分析模型。
  • AnalyticalModelSurface - 表示结构楼板、结构基础底板和结构墙的分析模型。

分析位置

根据与AnalyticalModel相对应的元素类型，可以通过以下三种方法之一来获得元素相对于分析的位置：GetPoint（）、GetCurve（）或GetCurves（）。

请注意，从这些方法检索的曲线没有设置其“引用”（Reference）特性。因此，它们不能用于Curve.GetEndPointReference（）等方法。相反，您可以通过构造包含必要信息的AnalyticalModelModel对象来获取对曲线及其端点的引用，如下例所示。

代码区域29-10：获取分析曲线的参考

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public bool GetReferenceData(FamilyInstance familyInst)
{
        AnalyticalModel analyticalModelFrame = familyInst.GetAnalyticalModel();
        Curve analyticalCurve = analyticalModelFrame.GetCurve();
        if (null != analyticalCurve)
        {
                // test the stable reference to the curve.
                AnalyticalModelSelector amSelector = new AnalyticalModelSelector(analyticalCurve);
                amSelector.CurveSelector = AnalyticalCurveSelector.WholeCurve;
                Reference curveReference = analyticalModelFrame.GetReference(amSelector);

                // test the stable reference to the start point of the curve
                amSelector.CurveSelector = AnalyticalCurveSelector.StartPoint;
                Reference startPointReference = analyticalModelFrame.GetReference(amSelector);

                // test the stable reference to the start point of the curve
                amSelector.CurveSelector = AnalyticalCurveSelector.EndPoint;
                Reference endPointReference = analyticalModelFrame.GetReference(amSelector);
        }

        return true;
}

GetPoint()

如果AnalyticalModel可以由单个点（即Structural Footing）表示，则此方法将返回该点。否则，它将引发Autodesk.Revit.Exceptions.InapplicableDataException。IsSinglePoint（）方法可用于确定AnalyticalModel是否可由单个点表示。

下面的示例演示如何获取结构基础的分析位置。

代码区域29-11：获取结构基脚的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// retrieve and iterate current selected element
UIDocument uidoc = commandData.Application.ActiveUIDocument;
ElementSet selection = uidoc.Selection.Elements;
foreach (Element e in selection)
{
        // if the element is structural footing
        FamilyInstance familyInst = e as FamilyInstance;
        if (null != familyInst && familyInst.StructuralType == StructuralType.Footing)
        {
                AnalyticalModel model = familyInst.GetAnalyticalModel();
                // structural footing should be expressable as a single point
                if (model.IsSinglePoint() == true)
                {
                        XYZ analyticalLocationPoint = model.GetPoint();
                }
        }
}

GetCurve()

如果AnalyticalModel可以由单个曲线（即Structural Column或Structural Framing）表示，则此方法将返回该Curve。否则，它将引发Autodesk. Revit. Exceptions. InapplicableDataException。IsSingleCurve（）方法可用于确定AnalyticalModel是否可由单条曲线表示。

代码区域29-12：获取结构柱的曲线

1
2
3
4
5
6
7
8
9
10
11
12
13
public void GetColumnCurve(FamilyInstance familyInst)
{
        // get AnalyticalModel from structural column
        if (familyInst.StructuralType == StructuralType.Column)
        {
                AnalyticalModel modelColumn = familyInst.GetAnalyticalModel();
                // column should be represented by a single curve
                if (modelColumn.IsSingleCurve() == true)
                {
                        Curve columnCurve = modelColumn.GetCurve();
                }
        }
}

GetCurves()

此方法需要获取由多条曲线定义的AnalyticalModel的曲线，但可用于所有情况。如果AnalyticalModel可以由单个曲线表示，则该方法将返回仅包含一条曲线的List。如果AnalyticalModel可以由单个点表示，则此方法将返回包含该点的长度几乎为0的Curve。此方法将AnalyticalCurveType枚举作为参数。可能的值为：

  • RawCurves - 生成的基础分析模型曲线
  • ActiveCurves - 屏幕上显示的曲线（不包括刚性链接）
  • ApproximatedCurves - 使用直线段近似的曲线

The following values related to Rigid Links are also available. See the Rigid Links section later in this chapter for more information.
也可以使用与刚性链接相关的以下值。有关详细信息，请参见本章后面的“刚性连杆”部分。

  • RigidLinkHead -梁的端点0（头部）处的刚性连杆
  • RigidLinkTail - 梁末端1（尾部）的刚性连杆
  • AllRigidLinks - 所有刚性连杆曲线。端点0（头部）处的刚性连杆将位于第一个条目中。末端1（尾部）的刚性连杆将位于最后一个条目中。

GetLoops()

对于结构墙、楼板和楼板，建议使用AnalyticalModelSurface类。使用GetLoops（）方法可以基于AnalyticalLoopType参数检索曲面的一组CurveLoop对象。可能的值为：

  • All - 所有分析回路
  • External - 在所有其他循环之外循环。
  • Internal - 位于另一个循环内部的循环。在多个嵌套循环的情况下，这将返回除了最外部循环之外的所有循环。
  • Filled - 内部已填充的循环。在多个嵌套循环的情况下，这将返回最外部的循环，并从外部循环到内部循环。在视图中，返回的回路显示为实体的外部轮廓。
  • Void - 内部为空的循环。在多个嵌套循环的情况下，这将返回一系列循环，从第二个最外部开始，每隔一个标题进入最内部。在视图中，返回的回路显示为开口的外部轮廓。下面的示例演示了如何将AnalyticalModelSurface用于结构墙，以获取所有选定墙的外边缘并显示其坐标。

代码区域29-13：获取结构墙的曲线

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// retrieve and iterate current selected element
UIDocument uidoc = commandData.Application.ActiveUIDocument;
ICollection selectedIds = uidoc.Selection.GetElementIds();
Document document = uidoc.Document;
foreach (ElementId id in selectedIds)
{
    Element e = document.GetElement(id);
    Wall aWall = e as Wall;
    if (null != aWall)
    {
        // get AnalyticalModelSurface from Structural Wall
        AnalyticalModelSurface modelWall = aWall.GetAnalyticalModel() as AnalyticalModelSurface;
        if (null == modelWall)
        {
            // Architecture wall doesn't have analytical model
            continue;
        }

        // get wall curves
        StringBuilder wallString = new StringBuilder();
        wallString.AppendLine("Wall curves:");
        IList wallCurveLoops = modelWall.GetLoops(AnalyticalLoopType.External);
        foreach (CurveLoop curveloop in wallCurveLoops)
        {
            CurveLoopIterator itr = curveloop.GetCurveLoopIterator();
            itr.Reset();
            while (itr.MoveNext())
            {
                Curve wallCurve = itr.Current;
                wallString.AppendLine(String.Format("{0}, {1}", wallCurve.GetEndPoint(0).ToString(), wallCurve.GetEndPoint(1).ToString()));
            }
        }

        TaskDialog.Show("Wall Analytical Model", wallString.ToString());
    }
}

局部坐标系

AnalyticalModelStick和AnalyticalModelSurface元素的局部坐标系的方向可以通过调用重载的GetLocalCoordinateSystem（）方法作为变换获得。对于AnalyticalModelSurface，此方法的重载（不带参数）将返回整个模型的局部坐标系方向的变换，而带XYZ点的重载将返回描述曲面上指定点处的局部坐标系的变换。指定的点必须位于分析模型的表面上，否则Revit将引发异常。

当在AnalyticalModelStick类上调用GetLocalCoordinateSystem（）时，您可以可选地调用GetLocalCoordinateSystem（double），传递沿着曲线的距离，该距离由可以在0和1之间变化的参数表示（例如，0.5表示沿着参数化曲线的中点）。也可以调用GetLocalCoordinateSystem（XYZ point），其约束条件与在AnalyticalModelSurface上调用时相同，即指定的点必须位于沿着分析模型。Face.Evaluate或Curve.Evaluate可用于获取位于曲面上或沿曲线沿着的XYZ点。

参数信息

AnalyticalModel提供对刚性链接、投影和近似等参数信息的访问。

刚性连杆

刚性连杆将梁的分析模型连接到柱的分析模型。使用CanHaveRigidLinks（）方法和AnalyticalModel.RigidLinksOption属性确定刚性链接是否适用于AnalyticalModel。此外，还可以使用HasRigidLinksWith（）确定AnalyticalModel是否具有与特定图元的刚性链接。

通过使用AnalyticalModel.GetCurves（）方法指定AnalyticalCurveType选项RigidLinkHead和RigidLinkTail，可以检索末端链接。或者，将AnalyticalModel.GetRigidLink（）与AnalyticalModel对象一起使用。

结构梁的AnalyticalModel方法GetCurve（）和GetCurves（）之间的一个区别是，GetCurves（）包括单个Curve以及结构梁RigidLink Curve（如果存在）。将AnalyticalCurveType.RigidLinkHead或AnalyticalCurveType.RigidLinkTail枚举值传递给GetCurves（）方法，以获取梁头部或尾部的RigidLink。

虽然不能直接创建刚性连接（因为它不是独立对象），但可以使用梁和/或柱的分析模型上的RigidLinksOption属性来创建刚性连接。梁的刚性连接选项将替代柱的选项。

对于结构梁，RigidLinksOption属性可以具有以下值：

  • AnalyticalRigidLinksOption.Enabled - 将形成刚性链接
  • AnalyticalRigidLinksOption.Disabled -将不形成刚性链接
  • AnalyticalRigidLinksOption.FromColumn - 可以形成刚性连接，具体取决于相应结构柱的值。

对于结构柱，RigidLinksOption属性可以具有以下值：

  • AnalyticalRigidLinksOption.Enabled - 将形成刚性连接，除非相应的结构梁的设置替代。
  • AnalyticalRigidLinksOption.Disabled - 除非相应结构梁的设置替代，否则不会形成刚性连接。

注意：除了设置正确的值外，要创建刚性连杆，图元还必须重叠。

对齐、投影和延伸

子类AnalyticalModelSurface、AnalyticalModelStick和AnalyticalModelColumn具有支持检查和操作结构元素的对齐、投影和延伸的专用成员。以下代码示例显示如何更改AnalyticalModelSurface或AnalyticalModelStick的投影。

代码区域：更改AnalyticalModelStick投影

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void ChangeBeamProjection(FamilyInstance familyInstance)
{
    AnalyticalModelStick ams = familyInstance.GetAnalyticalModel() as AnalyticalModelStick;
    if (ams != null)
    {
        // Change the Z projection for the end of the beam
        StickElementProjectionZ orgEndProj = ams.GetProjectionZ(AnalyticalElementSelector.EndOrTop);
        StickElementProjectionZ newEndProj = StickElementProjectionZ.Bottom;
        using (Transaction tran = new Transaction(familyInstance.Document, "ChangeProjection"))
        {
            tran.Start();
            ams.SetProjection(AnalyticalElementSelector.EndOrTop, ElementId.InvalidElementId, newEndProj);
            tran.Commit();
        }

        TaskDialog.Show("AnalyticalModelStick", "AnalyticalModelStick ID: " + ams.Id + "; \nOriginal ProjectionZ value was: " + orgEndProj + "; \nNew ProjectionZ value: " + newEndProj);
    }
}

代码区域：更改AnalyticalModel曲面投影

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/// 
/// Change the Z projection for all surface elements to BottomOrExterior
/// 
public void ChangeSurfaceProjections(Document document)
{
    FilteredElementCollector collector = new FilteredElementCollector(document);
    IList elements = collector.WherePasses(new ElementClassFilter(typeof(AnalyticalModelSurface))).WhereElementIsNotElementType().ToElements();
    if (elements.Count > 0)
    {
        using (Transaction tran = new Transaction(document, "Change Surface Projections"))
        {
            tran.Start();
            foreach (AnalyticalModelSurface ams in elements)
            {
                SurfaceElementProjectionZ orgEndProj = ams.ProjectionZ;
                SurfaceElementProjectionZ newEndProj = SurfaceElementProjectionZ.BottomOrExterior;
                ams.ProjectionZ = newEndProj;
            }
            tran.Commit();
        }
    }
}

下一个示例演示如何设置柱的顶部拉伸。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/// 
/// Change the top extension for the column to Reference Level
/// 
public void ChangeColumnTopExtension(FamilyInstance column)
{
    AnalyticalModelColumn amc = column.GetAnalyticalModel() as AnalyticalModelColumn;
    if (amc != null)
    {
        using (Transaction tran = new Transaction(column.Document, "Change Top Extension"))
        {
            tran.Start();

            StickElementExtension orgTopExt = amc.TopExtension;
            StickElementExtension newTopExt = StickElementExtension.ReferenceLevel;
            amc.TopExtension = newTopExt;

            TaskDialog.Show("AnalyticalModelColumn", "AnalyticalModelColumn ID: " + amc.Id + "; \nOriginal TopExtension value was: " + orgTopExt + "; \nNew TopExtension value: " + newTopExt);

            tran.Commit();
        }
    }
}

近似

当AnalyticalModel由曲线而不是直线定义时（即对于弯曲梁），近似值（由直线组成）可能更可取。AnalyticalModel有几种与曲线近似相关的方法。如果CanApproximate（）返回true，请使用Approximate（）方法在非近似（曲线）分析模型和近似（仅由直线组成）分析模型之间切换。切换到近似后，使用GetCurves（）获取近似曲线的直线。

近似将基于近似偏差值（GetApproximationDeviation（））和使用硬点参数（UsesHardPoints（））。这些值也有相应的Set方法。近似偏差限制平滑曲线与由近似生成的线段之间的距离。硬点是弯曲梁上其他结构元素接触的位置。将此参数设置为true时，将强制分段分析模型在附着到曲梁的杆件端点处具有节点

AnalyzeAs

可以通过AnalyticalModel检索和设置Analyze As参数。此参数向分析程序指示应如何分析元素，或元素是否为NotForAnalysis。由于GetAnalyzeAs（）和SetAnalyzeAs（）使用的AnalyzeAs枚举包含用于不同类型元素的枚举值，因此并非所有值都适用于所有分析模型。使用IsAnalyzeAsValid（）方法确定特定值是否适用于分析模型。

手动调节

结构杆件分析模型的几何图形也可以相对于它所连接的图元进行调整（假设SupportsManualAdjustment（）方法返回true）。使用AnalyticalModel.ManuallyAdjust（）方法相对于另一个图元调整分析模型。

代码区域29-14：相对于另一个图元调整分析模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Pick the source analytical line to adjust to
Selection sel = app.ActiveUIDocument.Selection;
Reference refAnalytical = sel.PickObject(ObjectType.Element, "Please Pick the source analytical line to adjust to");
AnalyticalModel aModel = doc.GetElement(refAnalytical) as AnalyticalModel;
Curve aCurve = aModel.GetCurve();

// Get the reference of the start point
AnalyticalModelSelector aSelector = new AnalyticalModelSelector(aCurve);
aSelector.CurveSelector = AnalyticalCurveSelector.StartPoint;
Reference refSource = aModel.GetReference(aSelector);

// Pick the source analytical line to be adjusted
Reference refAnalytical2 = sel.PickObject(ObjectType.Element, "Please pick the source analytical line to be adjusted");
AnalyticalModel aModel2 = doc.GetElement(refAnalytical2) as AnalyticalModel;

// Get the reference of the start point
Curve aCurve2 = aModel2.GetCurve();
AnalyticalModelSelector aSelector2 = new AnalyticalModelSelector(aCurve2);
aSelector2.CurveSelector = AnalyticalCurveSelector.StartPoint;
// Can be adjusted to the middle of the line if WholeCurve is used
Reference refTarget = aModel2.GetReference(aSelector2);

// Adjust the analytical line
aModel.ManuallyAdjust(refSource, refTarget, true);

AnalyticalModel还提供了一些方法，用于确定分析模型是否已被手动调整，以及将其重置回相对于其相应物理模型的原始位置。此外，GetManualAdjustmentMatchedElements（）方法检索元素Id的集合，分析模型已根据这些元素Id进行了调整。

分析偏移

调整分析模型的另一种方法是使用偏移。设置分析偏移与手动调整分析模型不同。分析偏移是应用于整个分析模型的基本偏移，独立于任何其他图元。AnalyticalModel具有获取和设置分析偏移以及确定是否可以更改分析偏移的方法（CanSetAnalyticalOffset（））。

分析模型支撑

括每个支撑的优先级（如果多个图元提供支撑）以及提供支撑的点、曲线或面。以下示例说明如何在不同条件下使用AnalyticalModelSupport对象。

楼板和结构梁支撑信息

在草图模式下绘制板时，请选择设计栏上的“拾取支座”。如下图所示，板有三个支撑梁。通过迭代板的AnalyticalModelSupports集合，可以获得三个梁以及CurveSupport AnalyticalSupportType。

img图160：楼板和结构梁支撑信息

地板和墙壁支撑信息

通过拾取墙作为支撑来绘制板后，无法从楼板的AnalyticalModelSupport集合中获取墙。相反，Floor在Wall的AnalyticalModelSupports集合中可用。

img图161：地板和墙壁支撑信息

结构柱、梁和支撑支撑信息

在下图中，水平梁有三个点支撑–两个结构柱和一个结构支撑。支撑有三个点支撑–两个结构柱和一个结构梁。两个柱都没有支撑元件。

img
图162：StructuralElements支撑信息

梁系统和墙支撑信息

虽然在绘制BeamSystem时可以拾取墙作为支撑，但由于BeamSystem没有AnalyticalModel属性，因此无法直接获得其支撑信息。解决方案是调用GetBeamIds（）方法，以检索Beams的AnalyticalModelSupport集合。

img

图163：梁系统和墙支撑信息

墙基础和墙支撑信息

对于具有条形基础的墙，该墙具有可用于条形基础的CurveSupport。可以使用AnalyticalModel.GetCurves（）方法获得支撑曲线。在下面的示例中，曲线中有两个圆弧。

img
图164：墙基础和墙支撑信息

独立基础和结构柱支撑信息

结构柱可以将独立基脚作为点支撑。在这种情况下，基脚可以随支撑的结构柱移动。具有OST_StructuralFoundation类别的FamilyInstance的ElementId可从AnalyticalModelSupport.GetSupportingElement（）方法获得。通常，支撑点是从AnalyticalModel.GetCurve（）方法检索的曲线的底部点。在从GetPoint（）方法获得独立基脚FamilyInstance和AnalyticalModel Point后，也可以使用该选项。

img
图165：独立基础（FamilyInstance)和结构柱支撑信息

分析杆件力

AnalyticalModelStick类可以在杆元素的每一端存储六个内力。在每个端部处，可以存储3个平移力和3个旋转（力矩）力。这些杆件力可以表示模型上的一组特定载荷的结果，也可以表示用于连接设计的设计力。与荷载工况或组合无关。杆件力对应于分析杆模型（位于梁、支撑和柱上）的UI的“杆件力”属性。

这些力由PermanerForces类表示，该类提供获取和设置所有6个力分量（3个力，3个力矩）的访问权限，并通过Start属性指示对象是表示杆件起点处的力还是表示杆件终点处的力：对于起点和终点力，设置为true;对于终点力，设置为false。

开始和结束力和力矩都存储为由力或力矩的分量值组成的XYZ向量。例如，在一个示例中，力。X表示沿X方向作用的力的值。

阅读杆力

可以通过调用方法AnalyticalModelStick. GetForces（）来访问与分析模型一起存储的杆件力，该方法返回最小计数为零、最大计数为2（每端一个）的GetForces对象列表。如果没有为成员存储成员力，则列表将为空，如果只有一端指定了力，则列表将仅包含一个MemberForces对象。请注意，在UI中设置为“Released”或通过AnalyticalModleStick.SetReleases（）设置为true（已释放）的任何力或力矩方向在通过AnalyticalModleStick. GetReleaserForces（）查询时将报告为0.0。（释放的力或力矩不能抵抗释放方向上的力或力矩。）

设置构件力

可以通过调用重载的SetForceForces（）方法之一来在AnalyticalModelStick上设置成员力。SetBumerForces（）将用新提供的杆件力覆盖任何现有杆件力。

对于当前释放的任何力或力矩方向，UI和AnalyticalModelStick. GetReleases（）都将返回这些值为零，但如果您通过AnalyticalModelStick. SetReleases（）方法设置它们，它们将被保留，以便如果用户稍后清除释放，或者您通过AnalyticalModelStick.SetReleases（）清除释放，则将报告先前设置的值。

移除杆件力

Member forces for AnalyticalModelSticks may be removed for both ends at once or only for an individual end. To remove all AnalyticalModelSticks的杆件力可以同时从两端删除，也可以仅从单个端删除。若要移除元素的所有成员力，请调用AnalyticalModelStick. RemoveAllModelerForces（）。若要仅移除起点或终点的杆件力，请调用AnalyticalModelStick. RemoveModelerForces（）并指示要移除的终点。

荷载

以下部分确定荷载设置并讨论荷载限制指南。

加载设置

API可以访问“设置”对话框”荷载工况“和”荷载组合“选项卡上的所有功能。

以下属性可从相应的LoadCase BuiltInParameter中获得：

表60荷载工况特性和参数

**Property ** **BuiltInParameter **
Case Number LOAD_CASE _NUMBER
Nature LOAD_CASE_NATURE
Category LOAD_CASE_CATEGORY

LOAD_CASE_CATEGORY参数返回ElementId。下表标识了类别和元素ID值之间的映射。

表61：载荷工况类别

Load Case Category 荷载工况类别 BuiltInCategory
Dead Loads 恒载 OST_LoadCasesDead
Live Loads 活荷载 OST_LoadCasesLive
Wind Loads 风荷载 OST_LoadCasesWind
Snow Loads 雪荷载 OST_LoadCasesSnow
Roof Live Loads 屋顶活荷载 OST_LoadCasesRoofLive
Accidental Loads 偶然荷载 OST_LoadCasesAccidental
Temperature Loads 温度荷载 OST_LoadCasesTemperature
Seismic Loads 地震荷载 OST_LoadCasesSeismic

创建荷载和荷载组合

下面的类有一个或多个静态Create（）方法来创建相应的类：

  • LoadUsage
  • LoadNature
  • LoadCase
  • LoadCombination
  • PointLoad
  • LineLoad
  • AreaLoad

因为它们都是Element子类，所以可以使用Document.Delete（）删除它们。

荷载组合是通过静态方法LoadCombination.Create（）创建的，该方法有两个重载。第一种方法只接受对要在其中创建加载组合的文档的引用和新组合名称的字符串。第二个函数接受这些参数加上LoadCombinationType和LoadCombinationState。LoadCombinationType可以是Combination（直接荷载组合）或Envelope（多个荷载工况或组合的效应包络）。

LoadCombinationState可以是Serviceability或Ultimate。如果荷载组合代表结构上的服务荷载水平，则使用“可服务性”。这通常用于设计或检查构件挠度或其他可用性标准，如许用应力设计方法。如果荷载组合表示荷载抗力系数设计方法中通常使用的结构上的极限荷载状态或系数荷载状态，请使用极限荷载。

创建LoadCombination后，需要使用LoadComponents填充它，LoadComponents包含荷载组合及其系数。LoadComponents通过调用LoadCombination.SetComponents（）添加到LoadCombination中，并带有组件列表，如下面的代码片段所示。
注意：请确保组件列表不涉及其本身。下面的示例演示如何创建荷载组合，以及如何查找或创建用于设置荷载组合构件的荷载工况和荷载性质。

代码区域：创建新的LoadCombination

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
LoadCombination CreateLoadCombinationLoadCaseLoadUsageLoadNatureAndLoadComponent(Document document)
{
    // Create a new load combination
    LoadCombination loadCombination = LoadCombination.Create(document, "DL1 + RAIN1", LoadCombinationType.Combination, LoadCombinationState.Ultimate);
    if (loadCombination == null)
        throw new Exception("Create new load combination failed.");

    // Get all existing LoadCase
    FilteredElementCollector collector = new FilteredElementCollector(document);
    ICollection collection = collector.OfClass(typeof(LoadCase)).ToElements();

    // Find LoadCase "DL1"
    LoadCase case1 = null;
    foreach (Element e in collection)
    {
        LoadCase loadCase = e as LoadCase;
        if (loadCase.Name == "DL1")
        {
            case1 = loadCase;
            break;
        }
    }

    // Get all existing LoadNature
    collector = new FilteredElementCollector(document);
    collection = collector.OfClass(typeof(LoadNature)).ToElements();

    // Find LoadNature "Dead"
    LoadNature nature1 = null;
    foreach (Element e in collection)
    {
        LoadNature loadNature = e as LoadNature;
        if (loadNature.Name == "Dead")
        {
            nature1 = loadNature;
            break;
        }
    }

    // Create LoadNature "Dead" if not exist
    if (nature1 == null)
        nature1 = LoadNature.Create(document, "Dead");

    // Create LoadCase "DL1" if not exist
    if (case1 == null)
        case1 = LoadCase.Create(document, "DL1", nature1.Id, LoadCaseCategory.Dead);

    // Create LoadNature "Rain"
    LoadNature nature2 = LoadNature.Create(document, "Rain");
    if (nature2 == null)
        throw new Exception("Create new load nature failed.");

    // Create LoadCase "RAIN1"
    LoadCase case2 = LoadCase.Create(document, "RAIN1", nature2.Id, LoadCaseCategory.Snow);
    if (case1 == null || case2 == null)
        throw new Exception("Create new load case failed.");

    // Create LoadComponents - they consist of LoadCases or nested LoadCombination and Factors
    List components = new List();
    components.Add(new LoadComponent(case1.Id, 2.0));
    components.Add(new LoadComponent(case2.Id, 1.5));

    // Add components to combination
    loadCombination.SetComponents(components);

    // Create LoadUsages
    LoadUsage usage1 = LoadUsage.Create(document, "Frequent");
    LoadUsage usage2 = LoadUsage.Create(document, "Rare");

    if (usage1 == null || usage2 == null)
        throw new Exception("Create new load usage failed.");

    // Add load usages to combination
    loadCombination.SetUsageIds(new List() {usage1.Id, usage2.Id});

    // Give the user some information
    TaskDialog.Show("Revit", string.Format("Load Combination ID='{0}' created successfully.", loadCombination.Id.IntegerValue));

    return loadCombination;
}

您还可以通过使用LoadCombination.GetComponents（）修改案例、组件、性质等，进行修改，然后再次调用LoadCombination.SetComponents（）。可以通过调用LoadCombination. GetUsageIds（）来修改LoadCombination的LoadUsages，以获取LoadUsage Ids的列表，修改该列表，然后再次调用SetUsageIds（）。下面的代码示例演示如何修改现有的LoadCombination。

代码区域：修改荷载组合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
void ModifyLoadCombinationLoadCaseLoadUsageLoadNatureAndLoadComponent(Document document, LoadCombination loadCombination)
{
    // Change name of LoadCombination
    loadCombination.Name = "DL2 + RAIN1";

    // Get any LoadCase from combination
    // Combination can have assigned LoadCase or other (nested) LoadCombination so we need to filter out any LoadCombination
    LoadCase case1 = null;
    IList caseAndCombinationIds = loadCombination.GetCaseAndCombinationIds();
    foreach (ElementId id in caseAndCombinationIds)
    {
        Element element = document.GetElement(id);
        if (element is LoadCase)
        {
            case1 = (LoadCase)element;
            break;
        }
        else if (element is LoadCombination)
        {
            continue;
        }
    }

    if (case1 == null)
        throw new Exception("Can't get LoadCase.");

    // Change case name and number
    case1.Name = "DL2";
    if (LoadCase.IsNumberUnique(document, 3))
    {
        case1.Number = 3;
    }

    // Create load nature
    LoadNature liveNature = LoadNature.Create(document, "Dead nature");
    if (liveNature == null)
        throw new Exception("Create new load nature failed.");

    // Change nature category and ID for case
    case1.SubcategoryId = new ElementId(BuiltInCategory.OST_LoadCasesDead);
    case1.NatureId = liveNature.Id;

    //Change factor for case1
    IList components = loadCombination.GetComponents();
    foreach (LoadComponent loadComponent in components)
    {
        if (loadComponent.LoadCaseOrCombinationId == case1.Id)
        {
            loadComponent.Factor = 3.0;
        }
    }

    loadCombination.SetComponents(components);

    // Remove one usage from combination
    IList usages = loadCombination.GetUsageIds();
    usages.RemoveAt(0);
    loadCombination.SetUsageIds(usages);

    // Give the user some information
    TaskDialog.Show("Revit", string.Format("Load Combination ID='{0}' modified successfully.", loadCombination.Id.IntegerValue));
}

LoadCase和LoadNature类中没有Duplicate（）方法。若要实现此功能，必须首先创建一个新的LoadCase（或LoadNature）对象，然后从现有的LoadCase（或LoadNature）复制相应的属性和参数。 以下是演示在VB.NET中创建点荷载的最小示例代码：

代码区域：新PointLoad

1
2
3
4
5
6
7
8
'Define the location at which the PointLoad is applied. 
Dim point As New XYZ(0, 0, 4)
'Define the 3d force. 
Dim force As New XYZ(0, 0, -1)
'Define the 3d moment. 
Dim moment As New XYZ(0, 0, 0)

Dim pointLoad As PointLoad = pointLoad.Create(document, point, force, moment, Nothing, Nothing)

分析链接

使用Revit，在创建物理模型时会自动生成结构分析模型。分析模型将链接到结构分析应用程序，物理模型将通过Revit API根据结果自动更新。一些第三方软件开发商已经为其结构分析应用程序提供了双向链接。其中包括：

The key to linking Revit to other analysis applications is to set up the mapping relationship between the objects in different object models. That means the difficulty and level of the integration depends on the similarity between the two object models.
将Revit链接到其他分析应用程序的关键是设置不同对象模型中的对象之间的映射关系。这意味着集成的难度和水平取决于两个对象模型之间的相似性。

For example, during the product design process, design a table with at least the first two columns in the object mapping in the following table: one for the Revit API and the other for the structural analysis application, shown as follows:
例如，在产品设计过程中，设计一个表，其中至少包含下表中对象映射的前两列：一列用于Revit API，另一列用于结构分析应用程序，如下所示：

表62：Revit和Analysis应用程序对象映射

Revit API Analysis Application 分析应用 Import to Revit 导入到Revit
StructuralColumn 结构柱 Column 柱 NewStructuralColumn 新建结构柱
Property: 属性：
…
Location 位置 Read-only; 只读;
Parameter: 参数名称：
…
Analyze as 分析为 Editable; 可编辑;
AnalyticalModel: 分析模型：
…
Profile 轮廓 Read-only; 只读;
RigidLink Read-only; 只读;
…
Material: 材质：
…

分析链接是连接2个独立分析节点的图元，具有固定状态等属性。在建模过程中，Revit可以根据某些规则自动创建从分析梁到分析柱的分析链接。也可以在Revit UI中或使用Revit API手动创建。

在Revit API中，分析链接由AnalyticalLink类表示。固定度值可从其关联的AnalyticalLinkType获得。

下面的示例演示了如何读取文档中的所有AnalyticalLinks，并显示一个汇总自动生成和手动创建的AnalyticalLinks数量的TaskDialog。

代码区域：阅读分析链接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void ReadAnalyticalLinks(Document document)
{
    FilteredElementCollector collectorAnalyticalLinks = new FilteredElementCollector(document);
    collectorAnalyticalLinks.OfClass(typeof(AnalyticalLink));

    IEnumerable alinks = collectorAnalyticalLinks.ToElements().Cast();
    int nAutoGeneratedLinks = 0;
    int nManualLinks = 0;
    foreach (AnalyticalLink alink in alinks)
    {
        if (alink.IsAutoGenerated() == true)
            nAutoGeneratedLinks++;
        else
            nManualLinks++;
    }
    string msg = "Auto-generated AnalyticalLinks: " + nAutoGeneratedLinks;
    msg += "\nManually created AnalyticalLinks: " + nManualLinks;
    TaskDialog.Show("AnalyticalLinks", msg);
}

静态方法AnalyticalLink.Create（）创建一个新的分析链接。不是直接连接两个元素，而是在两个集线器之间创建连接。Hub类表示两个或多个Autodesk Revit元素之间的连接。 以下示例在两个选定的FamilyInstance对象之间创建新的分析链接。它使用一个过滤器来查找模型中的所有中心点，然后GetHub（）方法搜索中心点以查找引用每个FamilyInstance的AnalyticalModel的ID的中心点。

代码区域：创建新的AnalyticalLink

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public void CreateLink(Document doc, FamilyInstance fi1, FamilyInstance fi2)
{
    FilteredElementCollector hubCollector = new FilteredElementCollector(doc);
    hubCollector.OfClass(typeof(Hub));  //Get all hubs
    ICollection allHubs = hubCollector.ToElements();
    FilteredElementCollector linktypeCollector = new FilteredElementCollector(doc);
    linktypeCollector.OfClass(typeof(AnalyticalLinkType));
    ElementId firstLinkType = linktypeCollector.ToElementIds().First();  //Get the first analytical link type.
    // Get hub Ids from two selected family instance items
    ElementId startHubId = GetHub(fi1.GetAnalyticalModel().Id, allHubs);
    ElementId endHubId = GetHub(fi2.GetAnalyticalModel().Id, allHubs);
    Transaction tran = new Transaction(doc, "Create Link");
    tran.Start();
    //Create a link between these two hubs.
    AnalyticalLink createdLink = AnalyticalLink.Create(doc, firstLinkType, startHubId, endHubId);    tran.Commit();
}

//Get the first Hub on a given AnalyticalModel element
private ElementId GetHub(ElementId hostId, ICollection allHubs)
{
    foreach (Element ehub in allHubs)
    {
        Hub hub = ehub as Hub;
        ConnectorManager manager = hub.GetHubConnectorManager();
        ConnectorSet connectors = manager.Connectors;
        foreach (Connector connector in connectors)
        {
            ConnectorSet refConnectors = connector.AllRefs;
            foreach (Connector refConnector in refConnectors)
            {
                if (refConnector.Owner.Id == hostId)
                {
                    return hub.Id;
                }
            }
        }
    }
    return ElementId.InvalidElementId;
}

注：翻译自Revit API Developers Guide