AXISVM - Criação de um modelo simples utilizando o servidor COM do AXISVM

Pedro

Este artigo irá mostrar os passos para criar um modelo de viga simplesmente apoiada utilizando o servidor COM do AXISVM, com a linguagem de programação C# e o Visual Studio. O servidor COM pode ser utilizado para criar modelos, executar análises e recuperar resultados do AXISVM. Aqui, o C# é utilizado como exemplo; outras linguagens de programação podem ser utilizadas da mesma forma. Este artigo não abordará os passos para configurar o servidor COM. Consulte Configurar o servidor COM para obter o guia completo sobre a configuração.  

É criada uma aplicação simples em Windows Forms para obter as dimensões da viga e a magnitude da carga fornecidas pelo utilizador, criar uma viga simplesmente apoiada e executar a análise no AXISVM. Por fim, são apresentados e guardados os resultados, incluindo as reações, deslocamentos, forças e tensões, conforme ilustrado na imagem abaixo. 

Crie um novo modelo e guarde-o numa variável.

Após criar um objeto de AxisVMApplication, conforme mostrado no artigo anterior, a interface Models pode ser utilizada para obter o modelo atualmente aberto ou para criar um novo modelo no AXISVM. O Guia de Referência mostra que IAxisVMModels possui uma função chamada New() que pode ser utilizada para criar um novo modelo ou a propriedade item[int index] que pode ser utilizada para obter o modelo aberto. Conforme mostrado no trecho de código abaixo, a linha 1 cria um novo modelo e a linha 2 obtém o modelo criado e armazena-o numa variável chamada model.

axisVMApplication.Models.New();                         // Crie um novo modelo

IAxisVMModel model = axisVMApplication.Models.Item[1];  // guardá-lo na variável do modelo.

Alterar o sistema de unidades e o código de projeto nacional.

O próximo passo consiste em alterar o sistema de unidades e o código de projeto nacional. Para alterar o sistema de unidades, pode utilizar-se a função ChangeUnitSystem(string Name) da interface IAxisVMApplication. Os sistemas de unidades disponíveis estão listados no Guia de Referência. A linha 1 no trecho de código abaixo altera o sistema de unidades para as unidades da UE. O código de projeto pode ser alterado utilizando a propriedade model.Settings.NationalDesignCode da interface IAxisVMSettings. O Guia de Referência mostra o tipo de propriedade que deve ser fornecido à esquerda do nome da propriedade, conforme ilustrado na imagem abaixo. Para a propriedade NationalDesignCode, a propriedade fornecida deve ser do tipo ENationalDesignCode, conforme ilustrado na imagem abaixo. A linha 2 do trecho de código define o NationalDesignCode para o Eurocódigo. 

int unitId = axisVMApplication.ChangeUnitSystem("eu");               //Mude a unidade do sistema.

model.Settings.NationalDesignCode = ENationalDesignCode.ndcEuroCode; //  Mude o código.

Definir nós e uma linha.

O passo seguinte consiste em definir dois nós e um elemento de linha que ligue os dois nós. Para definir os nós, é necessário chamar a função Add ([in] double x, [in] double y, [in] double z) da interface IAxisVMNodes, passando as coordenadas XYZ do nó. O Guia de Referência indica que a função devolve o índice do nó, conforme ilustrado abaixo.

• A linha 1 no trecho de código adiciona um nó em (x=0, y=0, z=0), e a linha 2 adiciona outro em (x=beamLength, y=0, z=0). A linha 3 adiciona um elemento de linha que liga os dois nós. Isto pode ser feito utilizando a função Add ([in] long StartNode, [in] long EndNode, [in] ELineGeomType GeomType, [i/o] RLineGeomData GeomData) da interface IAxisVMLines. Conforme mostrado na imagem abaixo, o primeiro e o segundo parâmetros são os índices do primeiro e do segundo nós, respetivamente. O terceiro parâmetro é uma enumeração do tipo ELineGeomType, que determina o tipo da linha: reta ou arco circular. O quarto parâmetro é uma estrutura do tipo RLineGeomData; é utilizada para linhas de arco circular, o que não é relevante neste caso. A função devolve o índice da linha adicionada ou um código de erro se a operação não for bem-sucedida. 

int node1Id = model.Nodes.Add(0, 0, 0);               // Adicione o primeiro nó

int node2Id = model.Nodes.Add(beamLength, 0, 0);      // Adicione o segundo nó

int lineId = model.Lines.Add(node1Id, node2Id, ELineGeomType.lgtStraightLine, ref rLineGeomData); // Adicione linha.

Defina o material e a secção transversal.

A interface IAxisVMMaterials fornece várias funções para definir materiais, incluindo AddDialog, AddFromCatalog, AddFromCatalogFile e outras. Neste exemplo, a função AddFromCatalog é utilizada para adicionar material utilizando os materiais disponíveis no AXISVM, em que o primeiro parâmetro é o NationalDesignCode e o segundo parâmetro é o MaterialName fornecido como uma cadeia de caracteres. O nome exato do material deve ser fornecido tal como aparece na biblioteca de materiais do AXISVM. Aqui, a título de exemplo, é utilizado o betão C25/30 do Eurocódigo. A primeira linha do trecho de código abaixo mostra a definição do material. O método devolve o índice do material se a adição do material for bem-sucedida. À semelhança do IAxisVMMaterials, o IAxisVMCrossSections fornece vários métodos para definir secções transversais, tais como AddFromDialog, AddFromEditor e funções fornecidas especificamente para definir secções especiais. Aqui, a função AddRectangular é utilizada para definir uma secção transversal retangular. Conforme mostrado na imagem abaixo, o primeiro parâmetro é um nome único para a secção transversal, o segundo é a largura, o terceiro é a altura e o quarto é o ECrossSectionProcess para secções de aço, o que não é relevante neste exemplo. A segunda linha do trecho de código adiciona uma secção retangular à interface CrossSections do AXISVM. Se for bem-sucedida, a função devolve o índice da secção adicionada. As imagens abaixo mostram o material e a secção transversal adicionados ao AXISVM.

int materialId = model.Materials.AddFromCatalog(ENationalDesignCode.ndcEuroCode, "C25/30");  //Definir Material

int crossSectionId = model.CrossSections.AddRectangular("rectangle", width, height, ECrossSectionProcess.cspOther);   //Definir Secção-Transversal

Definir a linha como uma viga.

Após definir tanto o material como a secção transversal, o elemento de linha pode ser definido como uma viga utilizando a função DefineAsBeam da interface IAxisVMLine. A primeira linha do trecho de código obtém o elemento de linha previamente definido através da propriedade Item[int index] da interface IAxisVMLines e armazena-o na variável axisVMLine. A segunda linha utiliza a função DefineAsBeam para definir a viga utilizando o ID do material, o ID da secção transversal e os pontos de excentricidade da estrutura RPoint3d. Os pontos de excentricidade devem ser passados por referência.

IAxisVMLine axisVMLine = model.Lines.Item[lineId];

int beamId = axisVMLine.DefineAsBeam(materialId, crossSectionId, crossSectionId, ref startEndEccentricity, ref startEndEccentricity);

Pedro

Definir os apoios.

Os apoios nodais podem ser definidos utilizando a função AddNodalGlobal_V153 da classe IAxisVMNodalSupports. Conforme mostrado abaixo, a função requer dois argumentos: o objeto NodalSupportSpringParameters do tipo RNodalSupportSpringParams e o NodeId do tipo int. O RNodalSupportSpringParams é uma estrutura que contém outra estrutura do tipo RSpringParamIndexes. Os índices das molas devem ser fornecidos a RSpringParamIndexes para definir os apoios nas direções XYZ. As molas são definidas como molas de translação ou de rotação. Portanto, para definir os apoios, deve ser definida uma nova instância de RNodalSupportSpringParams, conforme mostrado na linha 2 do trecho de código, e os SpringParamIndexes nas direções (x, y, z, xx, yy e zz) devem ser definidos com os índices de mola apropriados. Os valores predefinidos Rigid-Translation e Rigid-Rotation do AxisVM podem ser obtidos utilizando model.SpringParams.IndexOfName(springName) com o nome da mola apropriado, conforme mostrado nas linhas 3-4. Por fim, o suporte pode ser adicionado utilizando AddNodalGlobal_V153, conforme mostrado na linha 5.

AxisVMNodalSupports axisVMNodalSupports = model.NodalSupports;

RNodalSupportSpringParams rNodalSupportSpring1 = new RNodalSupportSpringParams();

rNodalSupportSpring1.SpringParamIndexes.x = model.SpringParams.IndexOfName("Rigid - Translational");

rNodalSupportSpring1.SpringParamIndexes.yy = model.SpringParams.IndexOfName("Soft - Rotational");

int nodeSupport1 = axisVMNodalSupports.AddNodalGlobal_V153(ref rNodalSupportSpring2, node1Id);

Definir o peso próprio e a carga distribuída.

O peso próprio pode ser definido utilizando o método AddBeamSelfWeight da interface IAxisVMLoads, conforme mostrado na linha 2 abaixo. A função requer dois parâmetros: o LineId, que define a viga, e o LoadCaseId, que é igual a 1 para o primeiro caso de carga. Vários tipos de carga podem ser definidos utilizando a interface IAxisVMLoads, tais como AddBeamConcentrated, AddBeamDistributed, AddBeamStress ou AddBeamThermal. A título de exemplo, o AddBeamDistributed é utilizado aqui para definir uma carga distribuída que atua sobre a viga. Conforme mostrado na imagem abaixo, o AddBeamDistributed requer um parâmetro do tipo RLoadBeamDistributed, que é uma estrutura. Portanto, uma nova instância deve ser declarada conforme mostrado na linha 4, e as propriedades da carga distribuída devem ser atribuídas conforme mostrado nas linhas 5-12, incluindo DistributionType, LoadCaseID e LineID. qx1, qy1, qz1, qx2, qy2, qz2 são as magnitudes da carga distribuída nas direções x, y e z para o primeiro e o segundo pontos, respetivamente. Position1 e Position2 são as localizações do primeiro e do segundo pontos, respetivamente. O Guia de Referência fornece uma descrição completa de todas as propriedades incluídas na estrutura para definir a carga. Por fim, o RLoadBeamDistributed definido deve ser passado para a função para adicionar a carga distribuída. Se a carga for adicionada com sucesso, a função devolve o índice da carga.

// Adicionar o peso próprio.

int selfWeight=axisVMLoads.AddBeamSelfWeight(lineId, LoadCaseId);

// Definir carga distribuída

RLoadBeamDistributed rLoadBeam = new RLoadBeamDistributed(); //definir novo RLoadBeamDistributed

rLoadBeam.DistributionType = EBeamRibDistributionType.brdtLength; //distribuídos por comprimento ou projetados

rLoadBeam.LoadCaseId = loadCaseId;                          // ID do caso de carga

rLoadBeam.LineId = beamId;                                  // ID da viga

rLoadBeam.qz1 = -distributedLoad;                           // Magnitude da carga - primeiro ponto

rLoadBeam.qz2 = -distributedLoad;                           // Magnitude da carga - segundo ponto

rLoadBeam.Position1 = 0;                                    // Posição da carga - primeiro ponto

rLoadBeam.Position2 = length;                               // Posição da carga - segundo ponto

rLoadBeam.SystemGLR = ESystem.sysGlobal;                    // sistema de coordenadas das componentes da carga

// Aplicar a carga distribuída à viga.

int loadId = axisVMLoads.AddBeamDistributed(rLoadBeam);     // Aplicar a carga distribuída à viga.

O feixe criado.

As imagens abaixo mostram o resultado final da aplicação de todas as funções mencionadas anteriormente através da interface COM.

Guarde o modelo.

Antes de executar a análise, é importante guardar o modelo. Para tal, pode utilizar-se a função SaveToFile da classe IAxisVMModel. O primeiro parâmetro da função é o FileName, que corresponde ao nome do ficheiro guardado, e o segundo parâmetro é SaveResults, do tipo ELongBoolean, que indica se os resultados atualmente disponíveis são guardados ou não.

ELongBoolean modelSaveStatus = model.SaveToFile("model1", ELongBoolean.lbTrue);   //guarde o ficheiro

Executar a análise.

A interface IAxisVMCalculation permite executar vários tipos de análises, tais como análise linear, análise não linear, análise de flambagem, análise de vibração e outras. Aqui, a função LinearAnalysis2 é utilizada para executar uma análise linear. Conforme ilustrado na imagem abaixo, a função aceita três parâmetros; o primeiro é do tipo ECalculationUserInteraction para indicar se o utilizador deve interagir com o AxisVM durante a análise para responder a mensagens de aviso. O segundo é do tipo ELongBoolean para mostrar mensagens de erro no AxisVM. O terceiro parâmetro é ErrorList do tipo string e deve ser passado pela palavra-chave out para receber os erros, se houver, após a função ser executada. O trecho de código abaixo mostra como os parâmetros podem ser passados para a função. A função retornará ElongBoolean.lbTrue se a análise for concluída.

String errorList;     // Definir variável de cadeia de caracteres.

ELongBoolean analysisStatus = model.Calculation.LinearAnalysis2(ECalculationUserInteraction.cuiNoUserInteractionWithAutoCorrect, ELongBoolean.lbTrue, out errorList);

Pedro

Recuperar os resultados após a análise.

A interface IAxisVMResults disponibiliza várias funções para recuperar os resultados da análise. A interface inclui resultados relativos a deslocamentos, forças, tensões, cálculos de armadura, dimensionamento de aço e outros. Dentro da interface IAxisVMResults, existem interfaces para deslocamentos, forças e tensões com IAxisVMDisplacements, IAxisVMForces e IAxisVMStresses. Estas interfaces contêm várias funções e propriedades para extrair os resultados da base de dados do AxisVM. A título de exemplo, a IAxisVMDisplacements pode ser utilizada para extrair os deslocamentos da viga utilizando GetMemberDisplacementsByLoadCaseId. Vários parâmetros devem ser passados para a função, conforme mostrado na imagem abaixo, incluindo MemberID, LoadCaseID, LoadLevelOrModeShapeOrTimeStep, o Analysistype de EAnalysisType, WithReinforcement do tipo ELongBoolean e duas matrizes passadas com a palavra-chave out para deslocamentos e PosX do tipo RDisplacementValues e double, respetivamente. O LoadLevelOrModeShapeOrTimeStep é utilizado para outros tipos de análise, tais como análise não linear ou análise de encurvamento. Para análise linear, é igual a 1. As duas matrizes passadas com a palavra-chave «out» serão preenchidas com os resultados dos deslocamentos. As matrizes podem ser definidas e inicializadas utilizando a função C# Array.CreateInstance(Type type, int32 dimension), conforme mostrado nas linhas 1-2 no trecho de código abaixo. A função GetMemberDisplacementsByLoadCaseId devolve o número de secções transversais ao longo do comprimento da viga. A matriz de deslocamentos conterá o mesmo número de objetos RDisplacementValues que o número de secções transversais devolvidas. Os objetos contêm as componentes da deformação em cada secção transversal. A matriz PosX conterá as localizações das secções transversais ao longo do comprimento da viga. As matrizes começam com o índice 1. Funções semelhantes podem ser utilizadas para obter forças e tensões utilizando Forces.GetMemberForcesByLoadCaseId e Stresses.GetMemberStressesByLoadCaseId.

Array displacementResults = Array.CreateInstance(typeof(RDisplacementValues), 1); //Define array of type RDisplacementValues

Array crossSectionPositionsDisplacement = Array.CreateInstance(typeof(double), 1); //Define array of type double

int displacementResultStatus = model.Results.Displacements.GetMemberDisplacementsByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, ELongBoolean.lbFalse, out displacementResults, out crossSectionPositionsDisplacement);

Array forcesResults = Array.CreateInstance(typeof(RLineForceValues), 1);

Array crossSectionPositionsForces = Array.CreateInstance(typeof(double), 1);

int forcesResultStatus = model.Results.Forces.GetMemberForcesByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, out forcesResults, out crossSectionPositionsForces);

Array stressResults = Array.CreateInstance(typeof(RLineStressValues), 1);

Array crossSectionPositionsStress = Array.CreateInstance(typeof(double), 1);

int stressResultStatus = model.Results.Stresses.GetMemberStressesByLoadCaseId(beamId, loadCaseId, loadLevel, EAnalysisType.atLinearStatic, out stressResults, out crossSectionPositionsStress);



Os resultados obtidos podem ser apresentados no programa, tal como foi mostrado anteriormente, ou guardados num ficheiro de resultados, conforme ilustrado abaixo.

Alterar a visualização do modelo

A propriedade View do IAxisVMModel pode ser utilizada para ajustar a visualização no AxisVM, em que EView.vFront corresponde à direção X-Z, conforme indicado no Guia de Referência. A função FitInView() do IAxisVMModel pode ser utilizada para ajustar o modelo à visualização, conforme ilustrado no trecho de código abaixo.

model.View = EView.vFront;        // Mude a visão X-Z.

model.FitInView();                // Ajustar à vista.

Tratamento de erros.

Todas as interfaces possuem uma enumeração especial que contém a lista de códigos de erro e os seus significados, que podem ser recebidos durante a execução das funções. Por exemplo, a interface IAxisVMDisplacements contém uma enumeração EDisplacementError que inclui todos os erros possíveis que podem ser recebidos se for aplicada a função GetMemberDisplacementsByLoadCaseId. A função C# Enum.GetName(Type, Object) pode ser utilizada para obter o nome de cada código de erro, conforme mostrado abaixo.

Enum.GetName(typeof(EDisplacementError), errorCode);      // Obter o nome da enumeração.

The full project can be downloaded here.