Interface COM em VBA | 2.2 Criação de uma barra

Sistema

'A licença COM e o acesso ao programa estão bloqueados.
iApp.LockLicense

Recomendamos iniciar o manipulador antes de bloquear a licença; caso contrário, o RFEM permanece bloqueado em caso de erro e só pode ser fechado com o Gestor de tarefas. Como a interface está pronta para ser aplicada, é possível obter a interface para o modelo:

'Obter interface para o primeiro modelo.
Escuro iModel As RFEM5.model
If iApp.GetModelCount> 0 Então
Definir iModel = iApp.GetModel (0)
Else
Err.Raise vbObjectError, "LoadModel ()","iApp.GetModelCount <1"
End If

Para um melhor tratamento de erros, pode verificar se o modelo está realmente disponível (GetModelCount, neste caso) antes de o recuperar. Mesmo no caso de outras interfaces, tais como a interface para casos de carga ou cargas, pode indicar erros de uma forma melhor.

Criar apoios de nó

Deve ser criada uma viga de vão único e, uma vez que a barra se encontra ao longo do eixo x, a translação x, y, z e a rotação em torno dos eixos x e z têm de ser bloqueadas no nó 1 também. O apoio no nó 2 é semelhante ao primeiro até a tradução livre na direção x. Antes de criar os apoios nodais, ainda é necessário recuperar a interface para os dados do modelo. Ao definir o apoio, deve certificar -se de que, no caso de graus de liberdade, um número maior ou igual a 0 é equalizado com a libertação através de uma constante de mola. Aqui, as unidades SI também são utilizadas; ou seja, N/m ou N/rad:

'Obter interface para os dados do modelo.
Escuro iModelData As RFEM5.iModelData
Definir iModelData = iModel.GetModelData ()

'Criar apoios nodais.
Escuro nodsups (0 To 1)As 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

Se ocorrerem problemas, estes podem ser causados pelo tipo de dados incorreto. Se for necessário o dobro, a entrada do número inteiro pode causar erros. Assim, é necessário adicionar uma chave hash após o valor inteiro, para que seja utilizada como um valor duplo.

Claro que, o apoio nodal tem de ser transferido para o modo de edição novamente (PrepareModification/FinishModification):

'Transferir apoios nodais.
iModelData.PrepareModification
iModelData.SetNodalSupports nodsups
iModelData.FinishModification

Criar casos de carga

Para criar cargas, tem de definir primeiro os casos de carga, exatamente como no RFEM. Ao programar, os casos de carga são criados e transferidos primeiro e só depois as cargas podem ser transferidas utilizando as interfaces dos casos de carga. Primeiro, criamos os casos de carga:

'Obter interface para cargas.
Escuro iLoads As RFEM5.iLoads
Definir iLoads = iModel.GetLoads

'Criar casos de carga.
Escuro casos de carga (0 To 2) As RFEM5.LoadCase

loadcases (0) .Loading.No = 1
loadcases (0) .SelfWeight = Verdadeiro
loadcases (0) .ToSolve = Verdadeiro
loadcases (0) .SelfWeightFactor.X = 0
loadcases (0) .SelfWeightFactor.Y = 0
loadcases (0) .SelfWeightFactor.Z = 1
loadcases (0) .ActionCategory = Permanente

Existem três casos de carga a serem criados: peso próprio, neve e carga imposta. Na programação COM, todos os identificadores estão em inglês. Portanto, Permanent é utilizado para ActionCategory no caso de caso de carga de peso próprio. Para a propriedade SelfWeightFactor, pode definir a direção e o valor do peso próprio. No entanto, estas aplicam-se apenas se a propriedade de peso próprio estiver definida como True. Além disso, o ToSolve também tem de ser definido como True para incluir o caso de carga no cálculo e atribuir um número ao caso de carga (.Loading.No). Os outros dois casos de carga são definidos mais facilmente, uma vez que não existe peso próprio:

loadcases (1) .Loading.No = 2
loadcases (1) .SelfWeight = Falso
loadcases (1) .ToSolve = Verdadeiro
loadcases (1) .ActionCategory = ShowHLowerThan1000

loadcases (2) .Loading.No = 3
loadcases (2) .SelfWeight = Falso
loadcases (2) .ToSolve = Verdadeiro
loadcases (2) .ActionCategory = ImposedCategoryA

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

A categoria ShowHLowerThan1000 é utilizada para neve abaixo de uma altitude de 1.000 m acima do nível do mar e a categoria ImposedCategoryA é utilizada para a carga imposta da categoria A. Depois, os casos de carga podem ser transferidos para o RFEM. No entanto, a interface ILoads é utilizada para isso em vez da interface IModelData, uma vez que os dados do modelo já não são considerados; em vez disso, são os dados de carga.

Criar combinações de carga e de resultados

Ao criar combinações de carga ou de resultados, existem apenas algumas diferenças. A razão para isto é que o método de cálculo e outras configurações só podem ser aplicadas após a criação da combinação de carga através da interface correspondente. A definição é realizada como no RFEM. Para isso, pode utilizar o identificador LC (Caso de carga). Os diferentes separadores decimais e as letras maiúsculas e minúsculas não desempenham uma função, sendo ambos aceites:

'Criar combinações de carga.
Escuro pentes de carga (0 To 0) As RFEM5.LoadCombination

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

'Transferir combinações de carga.
iLoads.PrepareModification
iLoads.SetLoadCombinations loadcombs
iLoads.FinishModification

'Criar combinações de resultados.
Escuro rescombs (0 To 0) As RFEM5.ResultCombination

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

'Transferir combinações de resultados.
iLoads.PrepareModification
iLoads.SetResultCombinations rescombs
iLoads.FinishModification

Criar cargas

Como mencionado acima, as cargas serão agora transferidas utilizando as interfaces para casos de carga. Em nosso exemplo, nenhuma carga adicional é criada no caso de carga 1; no caso de carga 2, é aplicada uma carga trapezoidal distribuída; e o caso de carga 3 aplica uma carga linear constante e uma carga nodal. Aqui está o procedimento para o caso de carga 2:

'Criar cargas.
'Caso de carga 2.
Escuro iLoadCase As RFEM5.iLoadCase
Definir iLoadCase = iLoads.GetLoadCase (2, AtNo)
Uma vez que sabemos o número do caso de carga, este pode ser utilizado com AtNo ao obter a interface:
'Criar cargas de barra.
Escuro memLoads () As RFEM5.MemberLoad
ReDim memLoads (0 To 0)

Neste caso, a matriz não é dimensionada na inicialização, mas depois porque os memLoads devem ser utilizados novamente para o Caso de Carga 3. Isto tem a vantagem de o conteúdo ser reiniciado para os valores padrão quando utilizar o ReDim novamente. Em ObjectList, pode selecionar as barras a serem carregadas, separadas por vírgulas ou ligadas por hífenes. Além dos valores de carga para o início da carga (Magnitude1) e o final da carga (Magnitude2), a carga trapezoidal requer a especificação das distâncias para o início da carga (DistânciaA) e o final (DistânciaB). A propriedade RelativeDistances determina se os dados absolutos (False) em m ou relativos (True) de 0‑1 serão utilizados:

memLoads (0) .No = 1
memLoads (0) .ObjectList = "1"
memLoads (0) .Distribution = TrapezoidalType
memLoads (0) .Magnitude1 = 6000 #
memLoads (0) .Magnitude2 = 4000 #
memLoads (0) .RelativeDistances = Falso
memLoads (0) .DistanceA = 0.2
memLoads (0) .DistanceB = 0,9

'Transferir cargas de barra.
iLoadCase.PrepareModification
iLoadCase.SetMemberLoads memLoads
iLoadCase.FinishModification
Ao transferir as cargas, deve ser definida a interface correta; neste caso, a interface ILoadCase. As cargas do caso de carga 3 são definidas da seguinte forma:
'Criar cargas nodais.
Escuro nodalLoads (0 To 0) As NodalLoad
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 nodais.
iLoadCase.PrepareModification
iLoadCase.SetNodalLoads nodalLoads
iLoadCase.FinishModification

'Criar cargas de barra.
ReDim memLoads (0 To 0)
memLoads (0) .No = 1
memLoads (0) .ObjectList = "1"
memLoads (0) .Distribution = UniformType
memLoads (0) .Magnitude1 = 5000 #

'Transferir cargas de barra.
iLoadCase.PrepareModification
iLoadCase.SetMemberLoads memLoads
iLoadCase.FinishModification
Ao fechar o programa, a rotina de tratamento de erros é concluída e a licença é desbloqueada:
e: If Número de erro <> 0 Então MsgBox Err.Description,, Err.Source

'A licença COM está desbloqueada, o acesso ao programa é possível novamente.
iModel.GetApplication.UnlockLicense

Resumo e perspetiva

Os procedimentos apresentados neste artigo são baseados nos dois artigos anteriores. Como já foi mencionado, a estrutura é semelhante para todos os elementos. A exceção mencionada nas libertações de barras não lineares ou nos apoios nodais será explicada no próximo artigo.