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

Artículo técnico

Este artículo fue traducido por el Traductor de Google Ver texto original

La Parte 2.1 de la serie de artículos sobre la interfaz COM describió la creación y modificación de elementos en un ejemplo de una barra. En la tercera parte, estos elementos centrales se utilizan de nuevo para crear apoyos en nudo, cargas, combinaciones de carga y combinaciones de resultados. De este modo, se ampliará el modelo creado en la segunda parte. Por lo tanto, los elementos explicados en la Parte 1 y Parte 2.1 no se describen de nuevo.

Figura 01 - Sistema
Tenue iApp Como RFEM5.Aplicación
Establecer iApp = GetObject (, "RFEM5.Aplicación")
Luego, se inicia la rutina de manejo de errores y se bloquea la licencia:
'Error al manejar la rutina.
En caso de error, vaya a

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

Se recomienda iniciar la rutina antes de bloquear la licencia, de lo contrario, RFEM permanece bloqueado en caso de error y solo se puede finalizar a través del Administrador de tareas. Como la interfaz ahora está lista para usar, puede obtener la interfaz para el modelo:

'Obtener interfaz para el primer modelo.
Tenue iModel Como RFEM5.model
Si iApp.GetModelCount> 0 Entonces
Establecer iModel = iApp.GetModel (0)
Else
Err.Raise vbObjectError, "LoadModel ()", "iApp.GetModelCount <1"
End If

Para un mejor manejo de errores, tiene sentido verificar si un modelo está disponible antes de obtener el modelo (aquí GetModelCount). De esta forma, los errores también se pueden indicar mejor para otras interfaces, como casos de carga o cargas.

Crear soporte nodal

Se debe crear una viga de un solo tramo y dado que el miembro corre a lo largo del eje x, la traslación x, y, z y la rotación alrededor de xy sobre z deben estar bloqueadas en el nodo 1. El soporte en el nodo 2 es similar al primero excepto por la traducción libre en la dirección x. Antes de crear los soportes nodales, debe obtener la interfaz para los datos del modelo. Al definir el soporte, asegúrese de que un número mayor o igual a 0 sea igual a una liberación con resorte constante para los grados de libertad. Nuevamente, se utilizan unidades SI, es decir, N/mo N/rad:

'Obtener interfaz para datos del modelo.
Tenue iModelData Como RFEM5.iModelData
Establecer iModelData = iModel.GetModelData ()

'Crear soporte nodal.
Tenue cabeceras (0 A 1) Como 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 hay algún problema, puede deberse al tipo de datos incorrecto. Si se requiere el doble, una especificación entera puede conducir a errores. Entonces es necesario agregar un hash después del valor entero para que se use como un valor doble.

Por supuesto, el soporte nodal debe transferirse nuevamente en el modo de edición (PrepararModificación/FinalizarModificación) después:

'Transferencia de apoyo ganglionar.
iModelData.PrepareModification
iModelData.SetNodalSupports nodsups
iModelData.FinishModification

Crear casos de carga

Para crear cargas, primero debe definir un caso de carga, como en RFEM. Esta estructura significa que los casos de carga se crean y transfieren primero durante la programación, y luego las cargas solo se pueden transferir utilizando las interfaces de casos de carga. Primero, para crear los casos de carga:

'Obtener interfaz para cargas.
Tenue iLoads Como RFEM5.iLoads
Establecer iLoads = iModel.GetLoads

'Crear casos de carga.
Tenue cajas de carga (0 A 2) Como RFEM5.LoadCase

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

Queremos crear tres casos de carga: Carga muerta, nieve y carga útil. Los identificadores dentro de la programación COM son todos en inglés. Por lo tanto, para el caso de carga de peso propio, Permanente se utiliza para ActionCategory. Utilice la propiedad SelfWeightFactor para establecer la dirección y el valor del peso propio. Sin embargo, solo se aplican si la propiedad SelfWeight está establecida en True. De lo contrario, ToSolve todavía debe establecerse en True para que también se calcule el caso de carga y se asigne un número para el caso de carga (.Loading.No). Los otros dos casos de carga son aún más simples en su definición porque allí no se usa el peso propio:

Cajas de carga (1). Carga. No = 2
cajas de carga (1) .SelfWeight = Falso
cajas de carga (1) .ToSolve = Cierto
loadcases (1) .ActionCategory = ShowHLowerThan1000

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

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

Para nieve por debajo de una altura de 1,000 m sobre el nivel del mar, se usa la categoría ShowHLowerThan1000 y para la categoría de carga A, ImposedCategoryA. Posteriormente, los casos de carga se pueden transferir a RFEM. Sin embargo, no se usa la interfaz IModelData para esto, sino la interfaz ILoads, porque ya no son datos de modelo, sino datos de carga.

Crear combinaciones de carga y combinaciones de resultados

Al crear ambas variantes, solo hay algunas diferencias. Esto se debe principalmente al hecho de que la teoría de cálculo y otras configuraciones solo se pueden llevar a cabo después de crear la combinación de carga a través de la interfaz correspondiente. La definición es la misma que en RFEM y puede utilizar los identificadores en inglés LC (Load Case) y LF (Load Case). Además, los diferentes separadores decimales y el caso no son significativos y se aceptan:

'Crear combinaciones de carga.
Tenue cargadores (0 A 0) Como RFEM5.Carga de carga

loadcombs (0) .Loading.No = 1
loadcombs (0) .ToSolve = Cierto
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.
Tenue rescombs (0 A 0) Como 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 ya se mencionó, las cargas ahora se transfieren a través de las interfaces de los casos de carga. En el ejemplo, no se crean cargas adicionales en el caso de carga 1, se aplica una carga de línea trapezoidal en el caso de carga 2, y se aplican una carga de línea constante y una carga nodal en el caso de carga 3. Aquí está el procedimiento para el caso de carga 2:

'Crear cargas.
'Caso de carga 2.
Tenue iLoadCase Como RFEM5.iLoadCase

Establecer iLoadCase = iLoads.GetLoadCase (2, AtNo)
Dado que se conoce el número de caso de carga, se puede utilizar al buscar la interfaz con AtNo:
'Crear cargas de miembros.
Tenue memLoads () Como RFEM5.MemberLoad
ReDim memLoads (0 A 0)

En este caso, dado que memLoads se va a reutilizar para el caso de carga 3, la matriz no se dimensiona durante la inicialización, sino solo después. Esto tiene la ventaja de que el contenido se restablece a los valores predeterminados cuando se vuelve a utilizar ReDim. En ObjectList, selecciona los miembros para la carga, separados por una coma o un guión. En el caso de una carga trapezoidal, se deben especificar las distancias para el inicio (Distancia A) y el final (Distancia B) además de los dos valores de carga para el inicio (Magnitud1) y el final (Magnitud2) de la carga. La propiedad RelativeDistances determina si se utilizan especificaciones absolutas (falsas) en m o especificaciones relativas (verdaderas) 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 datos, es necesario prestar atención a la interfaz correcta, aquí la interfaz ILoadCase. Las cargas para el caso de carga 3 se definen de forma análoga de la siguiente manera:
'Crear cargas nodales.
Tenue nodalLoads (0 A 0) Como 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 A 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 final del programa, se completa la rutina de manejo de errores y se desbloquea la licencia:
e: Si Número de error <> 0 Entonces MsgBox Err.Description ,, Err.Source

'Se libera la licencia COM, se puede acceder nuevamente al programa.
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ó allí, la estructura es similar para todos los elementos. La excepción de los lanzamientos finales de miembros no lineales o apoyos nodales mencionados allí será el tema del próximo artículo.

Descargas

Enlaces

Contacte con nosotros

Contacte con Dlubal Software

¿Tiene preguntas o necesita asesoramiento?
Contacte con nosotros a través de nuestro servicio de asistencia gratuito por correo electrónico, chat o fórum, o encuentre varias soluciones sugeridas y consejos útiles en nuestra página de preguntas más frecuentes (FAQ).

+34 911 438 160

info@dlubal.com

RFEM Programa principal
RFEM 5.xx

Programa principal

Software de ingeniería estructural de análisis por elementos finitos (AEF) para sistemas estructurales planos o espaciales compuestos de barras, placas, muros, láminas, sólidos y elementos de contacto

Precio de la primera licencia
3.540,00 USD
RFEM Otros
RF-COM 5.xx

Módulo adicional

Interfaz programable (API) basada en tecnología COM

Precio de la primera licencia
580,00 USD