Conversion d'une nervure en modèle surfacique avec poutre résultante par VBA

La modélisation d'une nervure basée sur une surface avec une poutre résultante est bien plus complexe que la création d'une barre de type nervure. Une nervure basée sur une barre doit donc être convertie en un modèle de surface (poutre résultante incluse) à l'aide du programme EXCEL-VBA ci-dessous.

Pour effectuer cette opération, les étapes sont les suivantes :

1. Lecture des paramètres de la nervure (section, orientation, etc.)
2. Création d'une surface pour la nervure
3. Création d'une poutre résultante
4. Suppression de la nervure

Zwei identische Modelle mit Stäben vom Typ Rippe

Des exemples tirés du code source complet sont donnés dans cet article et celui-ci peut être téléchargé au bas de cette page.

Lecture des paramètres de la nervure

L'utilisateur peut sélectionner la nervure à convertir à partir de l'interface du logiciel grâce à la fonction EnableSelections. Tant que la fonction EnableSelections est activée par la commande true, seuls les éléments sélectionnés dans RFEM sont lus. La barre sélectionnée est lue comme suit :

'   get interface of active model
Set iMod = iApp.GetActiveModel
        
'   get interface of (structural) model data
Dim iModData As RFEM5.IModelData2
Set iModData = iMod.GetModelData
        
'   get selected member
iModData.EnableSelections True

Dim mems() As RFEM5.Member
Dim selMem As RFEM5.Member
mems = iModData.GetMembers
selMem = mems(0)

iModData.EnableSelections False

Les paramètres suivants sont requis pour la modélisation de la nervure :

• Section de la nervure, numéros des surfaces et largeurs efficaces
• Orientation des nervures
• Matériau de la nervure

Dans RFEM, une nervure est un type de barre. Pour effectuer la programmation via l'interface COM, cela signifie que les données d'une nervure doivent être extraites via deux interfaces différentes : une pour la barre et une pour la nervure. L'interface pour la nervure peut être appelée via la fonction IModelData.GetRib. La fonction GetRib attend le numéro de la nervure contenu dans la barre via Member.RibNo.

'   get parameters of rib
'   #####################
Dim iRb As RFEM5.IRib
Set iRb = iModData.GetRib(selMem.RibNo, AtNo)

Dim selRb As RFEM5.Rib
selRb = iRb.GetData

Dim rbCrsc As RFEM5.RibCrossSection
rbCrsc = iRb.GetRibCrossSection

L'interface avec la nervure comporte deux éléments différents : les données générales de la nervure via la structure de la nervure et les données de la section de la nervure via RibCrossSection. Rib contient les numéros de surface, la position de la nervure et les largeurs efficaces. RibCrossSection contient la description et les dimensions de la section interne de la nervure, également utilisée par RF-CONCRETE Members (ITCU).

Une orientation, disponible via le système d'axes local de la barre, est également requise. L'accès au système d'axes se fait via l'interface avec la barre. La fonction IMemer.GetLocalCoordinateSystem renvoie la structure à CoordinateSystem.

Dim cosy As RFEM5.CoordinateSystem
cosy = iModData.GetMember(selMem.no, AtNo).GetLocalCoordinateSystem(0#).GetData

GetLocalCoordinateSystem a toujours besoin de la position x de la barre, qui a été définie sur 0,0 ou au début. Outre les paramètres mentionnés ci-dessus, le matériau de la barre est également requis et peut être obtenu via la section de la barre.

Dim selCrsc As RFEM5.CrossSection
selCrsc = iModData.GetCrossSection(selMem.StartCrossSectionNo, AtNo).GetData

Création d'une surface pour la nervure

Le logiciel a été créé uniquement pour les nervures droites du côté z+. La nervure pouvant également être oblique, il faut créer la surface à l'aide de l'orientation de barre. La variable cosy du système d'axes de barre local inclut le vecteur de direction pour l'axe z local cosy.Axis avec ses trois valeurs x, y et z. Ce vecteur est normalisé de sorte qu'il indique la distance et la direction du bord inférieur de la nervure une fois multiplié par la hauteur de la nervure. Pour les lignes de contour de la surface de la nervure, ce vecteur est multiplié par la hauteur de la nervure et ajouté aux nœuds de début et de fin. On obtient ainsi les deux nœuds d'extrémité de la ligne du bord inférieur de la nervure surfacique. La hauteur de la nervure inclut également la moitié de l'épaisseur de la largeur efficace. À des fins de simplification, seule l'épaisseur de surface du premier côté (-y, dans le système d'axes local) de la section de nervure est utilisée (UpperLeftFlangeThickness). Une fois les nœuds disponibles, on peut générer les lignes de contour et la surface de la nervure.

'   create/calculate nodes
'   ######################
Dim nodes() As RFEM5.Node
nodes = selNodes
nodes(0).no = index_n + 1
nodes(1).no = index_n + 2
Dim h_rib As Double
h_rib = (rbCrsc.Depth - rbCrsc.UpperLeftFlangeThickness / 2)
nodes(0).X = nodes(0).X + h_rib * cosy.AxisZ.X
nodes(0).Y = nodes(0).Y + h_rib * cosy.AxisZ.Y
nodes(0).Z = nodes(0).Z + h_rib * cosy.AxisZ.Z
nodes(1).X = nodes(1).X + h_rib * cosy.AxisZ.X
nodes(1).Y = nodes(1).Y + h_rib * cosy.AxisZ.Y
nodes(1).Z = nodes(1).Z + h_rib * cosy.AxisZ.Z

'   create lines
'   ############
Dim lines(0 To 2) As RFEM5.RfLine
lines(0).no = index_l + 1
lines(1).no = index_l + 2
lines(2).no = index_l + 3
lines(0).NodeList = str(selNodes(0).no) + "," + str(nodes(0).no)
lines(1).NodeList = str(selNodes(1).no) + "," + str(nodes(1).no)
lines(2).NodeList = str(nodes(0).no) + "," + str(nodes(1).no)

'   create surface
'   ##############
Dim surf As RFEM5.Surface
surf.BoundaryLineCount = 4
surf.BoundaryLineList = str (selLine.no) + "," + str (lignes (0) .no) + "," + str (lignes (2) .no) + "," + str (lignes (1). non)
surf.Comment = "rib"
surf.GeometryType = PlaneSurfaceType
surf.MaterialNo = selCrsc.MaterialNo
surf.Thickness.Type = ConstantThicknessType
surf.Thickness.Constant = rbCrsc.WebThickness
surf.StiffnessType = StandardStiffnessType
surf.no = index_s + 1

Les variables index_n, index_l, index_s contiennent chacune le dernier index de l'élément correspondant de RFEM. La détermination des indices se trouve dans le code source téléchargeable.

Conversion de la nervure avant en surface

Création d'une poutre résultante

La poutre résultante, comme la nervure, est composée de deux éléments : la structure standard Member et les données additionnelles ResultBeam. Les données additionnelles ne peuvent être modifiées que via l'interface avec la barre, de sorte que la barre doit d'abord être créée, puis les données peuvent être transférées via l'interface IMember. Comme la barre doit généralement être excentrée, les nœuds de début et de fin sont créés directement dans le centre de cisaillement sans excentrement de barre. L'excentricité est enregistrée dans RibCrossSection. Les nœuds de début et de fin de la nervure d'origine peuvent ainsi être copiés et utilisés comme base. Les vecteurs de direction y et z du système d'axes de barre local permettent de déplacer les nœuds copiés à l'emplacement adéquat. La poutre résultante doit également avoir une section, qui est copiée à partir de la nervure d'origine, pour pouvoir effectuer un autre calcul par la suite. La description de la section est ensuite importée à partir de RibCrossSection et le contenu de la fonction CrossSection.TextID doit être effacé. Sinon cette fonction est utilisée pour la création de la section au lieu de la chaîne à partir de CrossSection.Description.

'       create nodes for result member and calculate eccentricity
Dim resNodes() As RFEM5.Node
resNodes = selNodes

resNodes(0).no = index_n + 3
resNodes(1).no = index_n + 4
resNodes(0).X = selNodes(0).X + rbCrsc.Eccentricity.Z * cosy.AxisZ.X + rbCrsc.Eccentricity.Y * cosy.AxisY.X
resNodes(0).Y = selNodes(0).Y + rbCrsc.Eccentricity.Z * cosy.AxisZ.Y + rbCrsc.Eccentricity.Y * cosy.AxisY.Y
resNodes(0).Z = selNodes(0).Z + rbCrsc.Eccentricity.Z * cosy.AxisZ.Z + rbCrsc.Eccentricity.Y * cosy.AxisY.Z
resNodes(1).X = selNodes(1).X + rbCrsc.Eccentricity.Z * cosy.AxisZ.X + rbCrsc.Eccentricity.Y * cosy.AxisY.X
resNodes(1).Y = selNodes(1).Y + rbCrsc.Eccentricity.Z * cosy.AxisZ.Y + rbCrsc.Eccentricity.Y * cosy.AxisY.Y
resNodes(1).Z = selNodes(1).Z + rbCrsc.Eccentricity.Z * cosy.AxisZ.Z + rbCrsc.Eccentricity.Y * cosy.AxisY.Z

'       create line
Dim resLine As RFEM5.RfLine
resLine.no = index_l + 4
resLine.NodeCount = 2
resLine.Type = PolylineType
resLine.NodeList = str(resNodes(0).no) & "," & str(resNodes(1).no)

'       create cross section
Dim resCrsc As RFEM5.CrossSection
resCrsc = selCrsc
resCrsc.description = rbCrsc.description
resCrsc.no = index_c + 1
resCrsc.TextID = ""

'       create member
Dim resMem As RFEM5.Member
resMem.LineNo = resLine.no
resMem.no = index_m + 1
resMem.Type = ResultBeamType
resMem.StartCrossSectionNo = resCrsc.no
resMem.Rotation = selMem.Rotation

'   send data to RFEM
'   ####################
iModData.PrepareModification

    iModData.SetNodes nodes
    iModData.SetLines lines
    iModData.SetSurface surf
    iModData.SetNodes resNodes
    iModData.SetLine resLine
    iModData.SetCrossSection resCrsc
    iModData.SetMember resMem

iModData.FinishModification

Une fois la barre (nœuds, lignes, section et surface) créée, les paramètres de la poutre résultante doivent être déterminés et transférés. Une poutre résultante intègre les efforts internes d'autres éléments (barres, surfaces, solides) et les transforme en efforts internes de barre en fonction de leur position. Il existe deux méthodes de base pour inclure les éléments adéquats dans une poutre résultante. On peut spécifier les éléments à intégrer et limiter la plage d'intégration à l'aide d'un solide (cylindre ou pavé droit). Dans ce cas, le numéro de la nouvelle surface et les numéros des surfaces des largeurs efficaces, si elles sont disponibles, sont utilisées. Le pavé droit est sélectionné comme zone d'intégration et peut être défini (visualisé localement) dans les directions +/- y et +/- z. Les valeurs de RibCrossSection sont à nouveau utilisées. Si une largeur efficace est manquante, une largeur d'intégration doit être utilisée afin que le plancher au-dessus de la nervure soit correctement intégré. La largeur supplémentaire doit donc être égale à la moitié de l'épaisseur de la surface.

'   set result beam parameters
'   ##########################
Dim resBeam As RFEM5.ResultBeam
Dim iResBeam As RFEM5.IResultBeam
Set iResBeam = iModData.GetMember(resMem.no, AtNo).GetExtraData
resBeam = iResBeam.GetData

'       set integrated elements
If selRb.SurfaceNoSide1 Then
    resBeam.IncludeSurfaces = str(selRb.SurfaceNoSide1) & ","
End If
If selRb.SurfaceNoSide2 Then
    resBeam.IncludeSurfaces = resBeam.IncludeSurfaces & str(selRb.SurfaceNoSide2) & ","
End If
resBeam.IncludeSurfaces = resBeam.IncludeSurfaces & str(surf.no)

'       set integration area
resBeam.Integrate = WithinCuboidGeneral
Dim resBeamParam(0 To 3) As Double
'   +y, -y, +z, -z
If selRb.WidthSide2 Then
    resBeamParam(0) = selRb.WidthSide2 - rbCrsc.Eccentricity.Y
Else
    resBeamParam(0) = 0.5 * rbCrsc.WebThickness - rbCrsc.Eccentricity.Y
End If
If selRb.WidthSide1 Then
    resBeamParam(1) = selRb.WidthSide1 + rbCrsc.Eccentricity.Y
Else
    resBeamParam(1) = 0.5 * rbCrsc.WebThickness + rbCrsc.Eccentricity.Y
End If
resBeamParam(2) = rbCrsc.Depth
resBeamParam(3) = rbCrsc.Depth

resBeam.Parameters = resBeamParam

'       send new result beam parameters to RFEM
iModData.PrepareModification
iResBeam.SetData resBeam
iModData.FinishModification

Suppression de la nervure

La nouvelle nervure ayant été créée à partir des surfaces, l'ancienne barre peut désormais être supprimée. La fonction DeleteObjects de l'interface IModelData permet de supprimer n'importe quel objet. Il faut à nouveau utiliser un bloc Prepare/Finishmodification en raison de la modification des éléments.

'   Remove Rib
'   ##########
iModData.PrepareModification
iModData.DeleteObjects MemberObject, str(selMem.no)
iModData.FinishModification

Résumé

Les nervures utilisées en tant que barres ne sont pas toujours suffisantes dans le cas d'un modèle complexe. Notre logiciel permet de créer facilement une nervure sous forme de barre, mais aussi de modéliser et d'afficher une nervure à partir de surfaces de façon plus détaillée. Si des aspects tels que les interfaces avec une barre (IMember) sont souvent bien connus, cet article technique présente l'interface IRib, qui sert notamment à accéder à la section de la nervure. Les informations données ici peuvent également être utilisées pour lire le système d'axes locaux d'une barre et créer la surface de la nervure à l'aide d'un calcul vectoriel.

Comparaison des résultats du moment M-y de la nervure de barre et de la nervure de surface

Perspectives

Ces opérations peuvent être effectuées de manière encore plus précise dans le logiciel. On peut par exemple considérer la position de la nervure (haut, bas, milieu). Il y a également la possibilité d'appliquer la méthode décrite aux nervures à section variable ou même aux nervures sur des lignes courbes.