Kontextabhängiges Berechnungsmodell in der Revit-API

Lernen Sie die neu entwickelte API im Kontext der analytischen Modellierung kennen.

Dieses Projekt ist Teil einer umfassenderen Revit-Initiative für analysegesteuertes Modellieren, die einen innovativen Ansatz für die analytische Modellierung vorstellt, durch den die allgemeinen Tragwerksmodellierungsfunktionen verbessert werden. Das Berechnungsmodell ist ein wichtiger Bestandteil der BIM-Daten und unterliegt den Arbeitsabläufen für die Zusammenarbeit innerhalb der Konstruktionsteams und über Projektteams hinweg. Daher erhalten Ingenieure mit dem neuen Funktionssatz und den neuen Verhaltensweisen in Revit folgende Möglichkeiten:

• Sie können die analytische Modellierung nutzen, um Ihre individuellen Entwurfsentscheidungen in Bezug auf Tragwerkselemente und Gebäude/Konstruktionen als ganze Systeme darzustellen.
• Sie können alle Arten von Konstruktionen analytisch darstellen.
• Sie können konsistente Berechnungsmodelle erstellen, um Tragwerksbemessungs-Jobs aus Revit-Modellen zu ermöglichen.
• Sie können einen vollständigen bidirektionalen Arbeitsablauf mit der Analysesoftware durchführen und dort vorgenommene Modelländerungen erfassen.
• Sie können das Berechnungsmodell bei Bedarf vor unerwarteten Änderungen schützen.
• Erstellen Sie mehrere Berechnungsmodelle, die verschiedene Analysetypen und -konfigurationen widerspiegeln.
• Die einfache analytische Modellierung lässt sich mit einer dedizierten Tragwerksberechnungssoftware replizieren. Hinzu kommen die Vorteile der parametrischen Modellierung und Zusammenarbeit, die eine BIM-Plattform ermöglichen.

Revit-Elemente mit neuer API

Neue API-Klassen

AnalyticalElement: Stellt die Basisklasse für alle analytischen Objekte dar. Es ersetzt AnalyticalModel.

•  Transform GetTransform () - Returns the transform which reflects Analytical Element orientation.

•  AnalyzeAs AnalyzeAs - This represents the Analyze As parameter assigned to Analytical Element.

•  Reference GetReference (AnalyticalModelSelector selector) - Returns a reference to a given curve within the Analytical Element.

• ElementId MaterialId - Defines the Material Id for the Analytical Element.

AnalyticalMember: Stellt ein lineares Element im Tragwerk-Berechnungsmodell dar. Es ersetzt AnalyticalModelStick und AnalyticalModelColumn.

• AnalyticalMember Create(Document aDoc,Curve curve) - Method which creates a new instance of an Analytical Member within the project.

• AnalyticalStructuralRole StructuralRole - The structural role assigned to the Analytical Member.

• Curve GetCurve () - Returns the curve of the Analytical Member.

• void SetCurve(Curve curve) - Sets the curve for the Analytical Member. This method disconnects elements from other analytical elements (if the end nodes are in the same position).

  
  
  

  If the user wants to move the corner, and keep the connection, there are other ways for achieving that such as ElementTransformUtils.moveElements.

•  bool IsValidCurve(Curve curve) - Verifies if the curve is valid for an Analytical Member.

•  void FlipCurve() - Flips the ends of the Analytical Member.

• StructuralSectionShape StructuralSectionShape - The structural section shape of the Analytical Member (read only).

•  ElementId SectionType - The id of the type from the structural family assigned to the Analytical Member.

•  double CrossSectionRotation - Cross-section rotation of the Analytical Member.

AnalyticalPanel: Stellt eine Fläche im Tragwerk-Berechnungsmodell dar. Es ersetzt AnalyticalModelSurface.

• AnalyticalPanel Create(Document aDoc, CurveLoop curveLoop) - Method which creates a new instance of an Analytical Panel within the project.

• CurveLoop GetOuterContour() - Returns the Curve Loop that defines the geometry of the Analytical Surface element.

• bool IsCurveLoopValid(CurveLoop profile) - Checks if curve loop is valid for Analytical Panel.

  • Um die Geometrie Analytische Schale zu ändern, sollten Benutzer das SketchEditScope-Framework verwenden. Dieses wurde durch eine neue Methode erweitert:

    •  void StartWithNewSketch(ElementId elementId) - Starts a sketch edit mode for an element which, at this moment, doesn't have a sketch.

  • Eine andere Möglichkeit zum Bearbeiten von Geometrie ist die folgende:

    • void SetOuterContour(CurveLoop outerContour) - Sets the Curve Loop that defines the geometry of the Analytical Surface element.

      
      
      

    • Wie bei AnalyticalMember wird durch Festlegen der Kontur für die analytische Schale die Verbindung mit anderen analytischen Elementen unterbrochen. Wenn der Benutzer die Ecke verschieben und die Verbindung beibehalten möchte, gibt es andere Möglichkeiten, dies zu erreichen, z. B. ElementTransformUtils.moveElements.

•  ISet<ElementId> GetAnalyticalOpeningsIds() - Returns the Analytical Openings Ids of the Analytical Panel.

• ElementId SketchId - Sketch associated to this Revit element.
  

• AnalyticalStructuralRole StructuralRole - Structural role assigned to the Analytical Panel.

AnalyticalOpening: Element, das eine Öffnung in einer analytischen Schale darstellt. Dies ist ein neues Objekt in der Revit-API (in früheren Versionen gab es kein separates Element für analytische Öffnungen).

• AnalyticalOpening Create(Document doc, CurveLoop curveLoop, ElementId panelId) - Method which creates a new instance of an Analytical Opening within the project.

• CurveLoop GetOuterContour () - Returns the Curve Loop that defines the geometry of the Analytical Surface element.
  

•  bool IsCurveLoopValidForAnalyticalOpening(CurveLoop loop, Document aDoc, ElementId panelId) - Checks if curve loop is valid for Analytical Opening.

  • Um die Geometrie analytischer Öffnungen zu ändern, verwenden Sie das SketchEditScope-Framework.
  • Eine andere Möglichkeit zum Ändern der Geometrie analytischer Öffnungen ist die folgende:

    •  void SetOuterContour(CurveLoop outerContour) - Sets the Curve Loop that defines the geometry of the Analytical Surface element.

• ElementId PanelId - ElementId of the host Analytical Panel.
  

•  ElementId SketchId - Sketch associated to this Revit element.

AnalyticalToPhysicalAssociationManager: Verwaltet die Verknüpfungen zwischen analytischen und physikalischen Elementen. Zuvor erkannten sich die Elemente selbst gegenseitig, und der Benutzer hatte keine Kontrolle über sie (die Verknüpfung konnte nicht geändert werden). Mit diesem neuen Ansatz kann die Verknüpfung bearbeitet werden. Die 1-1-Verknüpfung wird unterstützt, und Elemente können nicht gleichzeitig mehreren Verknüpfungen angehören.

•  AnalyticalToPhysicalAssociationManager GetAnalyticalToPhysicalAssociationManager(Document doc) Returns the AnalyticalToPhysicalAssociationManager for this
  document.

• void AddAssociation(ElementId analyticalElementId, ElementId physicalElementId) - Adds a new association between an analytical element and a physical element.

•  void RemoveAssociation(ElementId elementId) - This method will remove the association for the element with the given ElementId.

•  ElementId GetAssociatedElementId (ElementId elementId) - Returns id of the element which is associated with the given ElementId.

•  bool HasAssociation(ElementId id) - Verifies if the element has already defined an association.

AnalyticalNodeData: Enthält Informationen zum Verbindungsstatus der analytischen Knoten.

• AnalyticalNodeData GetAnalyticalNodeData ( Element element) - Returns AnalyticalNodeData associated with this element, if it exists.
  

• AnalyticalNodeConnectionStatus GetConnectionStatus () - Returns the Connections Status for an
  Analytical Node.

AnalyticalLinks, BoundaryConditions und Loads wurden migriert, sodass sie mit den neuen Elementen funktionieren. Die zugehörige API bleibt in den meisten Fällen unverändert. Für Loads wurden einige Verbesserungen vorgenommen.

Lasten

•  LineLoad.Create(Document aDoc,ElementId hostElemId, XYZ forceVector1, XYZmomentVector1, LineLoadType symbol).

•  LineLoad.Create(Document aDoc,ElementId hostElemId, int curveIndex, XYZ forceVector1, XYZ momentVector1, Structure.LineLoadType symbol).

•  LineLoad.IsValidHostId(Document doc, ElementId hostElemId).

•  AreaLoad.IsValidHostId(Document doc, ElementId hostElemId).

•  AreaLoad.Create(Document doc, ElementId hostElemId, XYZ forceVector1, AreaLoadType symbol).

•  PointLoad.Create(Document doc, ElementId hostElemId, AnalyticalElementSelector selector, XYZ forceVector, XYZ momentVector, AreaLoadTyp 
  symbol).

• PointLoad.IsValidHostId(Document doc, ElementId hostElemId).

Beispiele

Erstellen eines analytischen Elements

      using (Transaction transaction = new Transaction(document, "Create Analytical Member"))
               {
                  transaction.Start();
                  //create curve which will be assigned to the analytical member
                  Line line = Line.CreateBound(new XYZ(0, 0, 0), new XYZ(5, 0, 0));
                  //create the AnalyticalMember
                  AnalyticalMember analyticalMember = AnalyticalMember.Create(document, line);
                  analyticalMember.StructuralRole = AnalyticalStructuralRole.StructuralRoleBeam;
                  transaction.Commit();
                }

Erstellen einer analytischen Schale

 using (Transaction transaction = new Transaction(revitDoc, "Create Analytical Panel"))
         {
            transaction.Start();
            //create the curveLoop for the AnalyticalPanel element
            CurveLoop profileloop = new CurveLoop();
            profileloop.Append(Line.CreateBound(new XYZ(1, 1, 0), new XYZ(2, 1, 0)));
            profileloop.Append(Line.CreateBound(new XYZ(2, 1, 0), new XYZ(2, 2, 0)));
            profileloop.Append(Line.CreateBound(new XYZ(2, 2, 0), new XYZ(1, 2, 0)));
            profileloop.Append(Line.CreateBound(new XYZ(1, 2, 0), new XYZ(1, 1, 0)));
            //create the AnalyticalPanel 
            analyticalPanel = AnalyticalPanel .Create(revitDoc, profileloop);
            transaction.Commit();
          }

Hinzufügen einer neuen Verknüpfung zwischen einem physikalischen und einem analytischen Element

using (Transaction trans = new Transaction(doc, "AddAssociationBetweenPhysicalAndAnalyticalElements"))
 {
            trans.Start();
            ElementId analyticalElementId = ContextualAnalyticalModel.Utilities.GetSelectedObject(activeDoc, "Please select analytical element");
            ElementId physicalElementId = ContextualAnalyticalModel.Utilities.GetSelectedObject(activeDoc, "Please select physical element");
            //gets the AnalyticalToPhysicalAssociationManager for the current document
            AnalyticalToPhysicalAssociationManager analyticalToPhysicalManager = AnalyticalToPhysicalAssociationManager.GetAnalyticalToPhysicalAssociationManager(doc);
            if (analyticalToPhysicalManager == null)
               return Result.Failed;
            //creates a new association between physical and analytical elements
            analyticalToPhysicalManager.AddAssociation(analyticalElementId, physicalElementId);
            trans.Commit();
  }

Bearbeiten der Begrenzung für eine analytische Schale mithilfe des SketchEditScope-Frameworks

             // Start a sketch edit scope
             SketchEditScope sketchEditScope = new SketchEditScope(document, "Replace line with an arc");
               sketchEditScope.StartWithNewSketch(analyticalPanel.Id);
               using (Transaction transaction = new Transaction(document, "Modify sketch"))
               {
                  transaction.Start();
                  //replace a boundary line with an arc
                  Line line = null;
                  Sketch sketch = document.GetElement(analyticalPanel.SketchId) as Sketch;
                  if (sketch != null)
                  {
                     //find first line in the sketch profile
                    …..
                  }
  	              // Create arc
                  XYZ normal = line.Direction.CrossProduct(XYZ.BasisZ).Normalize().Negate();
                  XYZ middle = line.GetEndPoint(0).Add(line.Direction.Multiply(line.Length / 2));
                  Curve arc = Arc.Create(line.GetEndPoint(0), line.GetEndPoint(1), middle.Add(normal.Multiply(20)));
                  // Remove element referenced by the found line. 
                  document.Delete(line.Reference.ElementId);
                  // Model curve creation automatically puts the curve into the sketch, if sketch edit scope is running.
                  document.Create.NewModelCurve(arc, sketch.SketchPlane);
                  transaction.Commit();
               }
               sketchEditScope.Commit(new FailurePreproccessor());

Verschieben eines analytischen Knotens und Beibehalten der Verbindung

            // Create Analytical Panel
            AnalyticalPanel analyticalPanel = CreateAnalyticalPanel.CreateAMPanel(document);
            // Create the connected Analytical Member
            AnalyticalMember analyticalMember = CreateAnalyticalMember.CreateMember(document);
            // Select the node
            Reference eRef = activeDoc.Selection.PickObject(ObjectType.PointOnElement , "Select an Analytical Node");
          
            // Move the Analytical Node using ElementTransformUtils
            using (Transaction transaction = new Transaction(document, "Move node with ElementTransformUtils"))
            {
               transaction.Start();
               ElementTransformUtils.MoveElement(document, eRef.ElementId, new XYZ(-5, -5, 0));
               transaction.Commit();
            }

Abrufen von analytischen Flächenkonturpunkten

Mit der vorherigen Lösung:

    
      private List<XYZ> GetSurfaceContourPoints( Document doc, ElementId elementId )
      {
         	// Create point list, get list of curves from analytical model
         	List<XYZ> contourPoints = new List<XYZ>();
         	AnalyticalModel analyticalModel = (doc.GetElement(elementId) as AnalyticalModel);
         	IList<Curve> curves = analyticalModel.GetCurves(AnalyticalCurveType.RawCurves);
         
         	// Iterate over curves and make the desired processing   
         …...	
        	return contourPoints;
      }

Mit der neuen Lösung:

     
      private List<XYZ> GetSurfaceContourPoints( Document doc, ElementId elementId )
      {
         	// Create point list, get list of curves from analytical model
         	List<XYZ> contourPoints = new List<XYZ>();
         	AnalyticalPanel analyticalPanel = (doc.GetElement(elementId) as AnalyticalPanel);
          CurveLoop outerContour = analyticalPanel.GetOuterContour();
         
         	// Iterate over curves and make the desired processing 
          …...	
        	return contourPoints;
      }

Ruft das zugehörige analytische Element für ein physikalisches Element ab.

     
      AnalyticalElement GetAnalyticalElement(Element physicalElement)
      {
         AnalyticalElement analyticalElement = null;
         Document document = element.Document;
         AnalyticalToPhysicalAssociationManager assocManager = AnalyticalToPhysicalAssociationManager.GetAnalyticalToPhysicalAssociationManager(document);
         if (assocManager != null)
         {
            ElementId associatedElementId = assocManager.GetAssociatedElementId(physicalElement.Id);
            if (associatedElementId != ElementId.InvalidElementId)
            {
               Element associatedElement = document.GetElement(associatedElementId);
               if (associatedElement != null && associatedElement is AnalyticalElement)
               {
                  analyticalElement = associatedElement as AnalyticalElement;
               }
            }
         }
         return analyticalElement;
      }

Erstellen von Linien-Auflagerbedingungen

Mit der vorherigen Lösung:

       
        private BoundaryConditions CreateLineBC(Element hostElement)
        {
										    Document createDoc = hostElement.Document.Create;
 
             	// use Document.NewLineBoundaryConditions Method
              BoundaryConditions createdBC = 
                    createDoc.NewLineBoundaryConditions(hostElement.GetAnalyticalModel(), 0, 0, 0, 0, 0, 0, 0, 0);
 
            return createdBC;
        }

Mit der neuen Lösung:

      private BoundaryConditions CreateLineBC(Element hostElement)
      {
         Document createDoc = hostElement.Document.Create;

         // use Document.NewLineBoundaryConditions Method
         AnalyticalElement analyticalElement = GetAnalyticalElement(hostElement);
         BoundaryConditions createdBC =
                    createDoc.NewLineBoundaryConditions(analyticalElement, 0, 0, 0, 0, 0, 0, 0, 0);
         return createdBC;
      }