Interfaz COM en VBA | 2.2 Creación de una barra

Sistema

'La licencia COM y el acceso al programa están bloqueados.
iApp.LockLicense

Recomendamos iniciar el controlador antes de bloquear la licencia; de lo contrario, RFEM permanece bloqueado en caso de error y solo se puede cerrar utilizando el Administrador de tareas. Como la interfaz ahora está lista para ser aplicada, puede obtener la interfaz para el modelo:

'Obtener interfaz para el primer modelo.
Dim iModelIs RFEM5.model
If iApp.GetModelCount> 0 Then
Conjunto iModel = iApp.GetModel (0)
Else
Err.Raise vbObjectError,"LoadModel ()","iApp.GetModelCount <1"
End If

Para un mejor manejo de los errores, puede comprobar si el modelo está realmente disponible (GetModelCount, en este caso) antes de recuperar el modelo. Incluso en el caso de otras interfaces, como la interfaz para casos de carga o cargas, puede indicar errores de una mejor manera.

Crear apoyos nodales

Se debe crear una viga de un solo vano y, debido a que la barra está a lo largo del eje x, la traslación x, y, z y la rotación alrededor de los ejes x y z también se deben bloquear en el nudo 1. El soporte en el Nodo 2 es similar al primero hasta la traducción libre en la dirección x. Antes de crear los soportes nodales, aún es necesario recuperar la interfaz para los datos del modelo. Al definir el apoyo, debe asegurarse de que, en el caso de los grados de libertad, un número mayor o igual que 0 se iguale con la liberación utilizando una constante elástica. Aquí, también se utilizan las unidades del SI; es decir, N/m o N/rad:

'Obtener interfaz para datos del modelo.
Dim iModelData Is RFEM5.iModelData
Conjunto iModelData = iModel.GetModelData ()

'Crear soportes nodales.
Dim cabeceras (0 To 1)Is RFEM5.NodalSupport
nodsups (0) .No = 1
nodsups (0) .nodeList = "1"
nodsups (0) .RestraintConstantX = -1
nodsups (0) .RestraintConstantY = 0 #
nodsups (0) .RestraintConstantZ = -1
nodsups (0) .SupportConstantX = -1
nodsups (0) .SupportConstantY = -1
nodsups (0) .SupportConstantZ = -1

nodsups (1) .No = 2
nodsups (1) .nodeList = "2"
nodsups (1) .RestraintConstantX = -1
nodsups (1) .RestraintConstantY = 0 #
nodsups (1) .RestraintConstantZ = -1
nodsups (1) .SupportConstantX = 0 #
nodsups (1) .SupportConstantY = -1
nodsups (1) .SupportConstantZ = -1

Si se produce algún problema, puede deberse a un tipo de datos incorrecto. Si se requiere el doble, la entrada entera puede causar errores. Por lo tanto, es necesario agregar una clave hash después del valor entero, para que se use como un valor doble.

Por supuesto, el soporte nodal debe transferirse nuevamente al modo de edición (PrepareModification/FinishModification):

'Transferencia de soportes nodales.
iModelData.PrepareModification
iModelData.SetNodalSupports nodsups
iModelData.FinishModification

Crear casos de carga

Para crear cargas, primero debe definir los casos de carga, exactamente como en RFEM. Al programar, los casos de carga se crean y transfieren primero, y solo después se pueden transferir las cargas utilizando las interfaces de los casos de carga. Primero, creamos los casos de carga:

'Obtener interfaz para cargas.
Dim iLoads Is RFEM5.iLoads
Conjunto iLoads = iModel.GetLoads

'Crear casos de carga.
Dim cajas de carga (0 To 2)Is RFEM5.LoadCase

cajas de carga (0) .Loading.No = 1
casos de carga (0) .SelfWeight = Verdadero
casos de carga (0) .ToSolve = Verdadero
loadcases (0) .SelfWeightFactor.X = 0
loadcases (0) .SelfWeightFactor.Y = 0
loadcases (0) .SelfWeightFactor.Z = 1
loadcases (0) .ActionCategory = Permanente

Hay tres casos de carga para crear: peso propio, nieve y carga impuesta. En la programación COM, todos los identificadores están en inglés. Por lo tanto, Permanente se usa para ActionCategory en el caso del caso de carga de peso propio. Para la propiedad SelfWeightFactor, puede establecer la dirección y el valor del peso propio. Sin embargo, esto solo se aplica si la propiedad de peso propio está establecida en Verdadero. Además, ToSolve también debe establecerse en True para incluir el caso de carga en el cálculo y asignar un número al caso de carga (.Loading.No). Los otros dos casos de carga se definen más fácilmente, ya que no hay peso propio:

cajas de carga (1) .Loading.No = 2
cajas de carga (1) .SelfWeight = Falso
cajas de carga (1) .ToSolve = Verdadero
loadcases (1) .ActionCategory = ShowHLowerThan1000

Cajas de carga (2). Carga. No = 3
cajas de carga (2) .SelfWeight = Falso
cajas de carga (2) .ToSolve = Verdadero
loadcases (2) .ActionCategory = ImposedCategoryA

'Transferir casos de carga.
iLoads.PrepareModification
iLoads.SetLoadCases loadcases
iLoads.FinishModification

La categoría ShowHLowerThan1000 se usa para la nieve por debajo de una altitud de 1000 m sobre el nivel del mar, e ImposedCategoryA se usa para la carga impuesta de la categoría A. Luego, los casos de carga se pueden transferir a RFEM. Sin embargo, para esto se usa la interfaz ILoads en lugar de la interfaz IModelData, ya que los datos del modelo ya no están relacionados; más bien, los datos de carga son.

Crear combinaciones de carga y resultado

Al crear combinaciones de carga o resultado, solo hay algunas diferencias. La razón de esto es que el método de cálculo y otras configuraciones solo se pueden aplicar después de crear la combinación de carga a través de la interfaz correspondiente. La definición se lleva a cabo como en RFEM. Para esto, puede usar el identificador LC (Load Case). Los diferentes separadores decimales y las letras mayúsculas y minúsculas no juegan un papel, y se aceptan ambas:

'Crear combinaciones de carga.
Dim cargadores (0 To 0) Is RFEM5.LoadCombination

loadcombs (0) .Loading.No = 1
loadcombs (0) .ToSolve = Verdadero
loadcombs (0) .Definition = "1,35 * lc1 + 1,5 * lc2 + 1,05 * lc3"

'Combinaciones de carga de transferencia.
iLoads.PrepareModification
iLoads.SetLoadCombinations loadcombs
iLoads.FinishModification

'Crear combinaciones de resultados.
Dim rescombs (0 To 0) Is RFEM5.ResultCombination

rescombs (0) .Loading.No = 1
rescombs (0) .Definition = "1,35 * lc1 + 0,75 * lc2 + 1,5 * lc3"

'Transferir combinaciones de resultados.
iLoads.PrepareModification
iLoads.SetResultCombinations rescombs
iLoads.FinishModification

Crear cargas

Como se mencionó anteriormente, las cargas ahora se transferirán utilizando las interfaces para los casos de carga. En nuestro ejemplo, no se crean cargas adicionales en el caso de carga 1; en el caso de carga 2, se aplica una carga distribuida trapezoidal; y el caso de carga 3 aplica una carga lineal constante y una carga en nudo. Aquí está el procedimiento para el caso de carga 2:

'Crear cargas.
'Cargar el caso 2.
Dim iLoadCase Is RFEM5.iLoadCase
Conjunto iLoadCase = iLoads.GetLoadCase (2, AtNo)
Como conocemos el número de caso de carga, se puede usar con AtNo al recuperar la interfaz:
'Crear cargas de miembros.
Dim memLoads () Is RFEM5.MemberLoad
ReDim memLoads (0 To 0)

En este caso, la matriz no se dimensiona en la inicialización, sino después, porque memLoads se debe usar nuevamente para Load Case 3. Esto tiene la ventaja de que el contenido se restablece a los valores predeterminados cuando se usa ReDim nuevamente. En ObjectList, puede seleccionar las barras para cargar, separadas por comas o conectadas con guiones. Además de los valores de carga para el inicio de la carga (Magnitud1) y el final de la carga (Magnitud2), la carga trapezoidal requiere la especificación de las distancias para el inicio de la carga (Distancia A) y el final (Distancia B). La propiedad RelativeDistances determina si se utilizarán datos absolutos (falsos) en m o datos relativos (verdaderos) de 0-1:

memLoads (0) .No = 1
memLoads (0) .ObjectList = "1"
memLoads (0) .Distribution = TrapezoidalType
memLoads (0) .Magnitud1 = 6000 #
memLoads (0) .Magnitud2 = 4000 #
memLoads (0) .RelativeDistances = Falso
memLoads (0) .DistanciaA = 0.2
memLoads (0) .DistanceB = 0.9

'Transferir cargas de miembros.
iLoadCase.PrepareModification
iLoadCase.SetMemberLoads memLoads
iLoadCase.FinishModification
Al transferir las cargas, se debe configurar la interfaz correcta; en este caso, la interfaz de ILoadCase. Las cargas del caso de carga 3 se definen de forma similar a la siguiente:
'Crear cargas nodales.
Dim nodalLoads (0 To 0) Is Carga Nodal
nodalLoads (0) .No = 1
nodalLoads (0) .nodeList = "2"
nodalLoads (0) .Component.Force.X = -15000
nodalLoads (0) .Component.Force.Y = 0
nodalLoads (0) .Component.Force.Z = 0
nodalLoads (0) .Component.Moment.X = 0
nodalLoads (0) .Component.Moment.Y = 0
nodalLoads (0) .Component.Moment.Z = 0

'Transferir cargas nodales.
iLoadCase.PrepareModification
iLoadCase.SetNodalLoads nodalLoads
iLoadCase.FinishModification

'Crear cargas de miembros.
ReDim memLoads (0 To 0)
memLoads (0) .No = 1
memLoads (0) .ObjectList = "1"
memLoads (0) .Distribution = UniformType
memLoads (0) .Magnitud1 = 5000 #

'Transferir cargas de miembros.
iLoadCase.PrepareModification
iLoadCase.SetMemberLoads memLoads
iLoadCase.FinishModification
Al cerrar el programa, se completa la rutina del controlador de errores y se desbloquea la licencia:
e: If Err.Number <> 0Then MsgBox Err.Description, , Err.Source

'La licencia COM está desbloqueada, el acceso al programa es posible de nuevo.
iModel.GetApplication.UnlockLicense

Resumen y vista general

Los procedimientos que se muestran en este artículo se basan en los dos artículos anteriores. Como ya se mencionó, la estructura es similar para todos los elementos. La excepción mencionada de lanzamientos de miembros no lineales o apoyos nodales se explicará en el siguiente artículo.