La bibliothèque HLF pour C# fournit de nombreuses fonctionnalités utiles pour la création de structures dans RFEM et RSTAB, dont certaines seront utilisées dans l'exemple suivant.
Pour implémenter le code programmé, une connexion au programme est d'abord requise. L'un des ports disponibles doit être spécifié comme adresse. L'adresse par défaut de RFEM/RSTAB est http://localhost:8081 . Si nécessaire, cela peut être modifié dans les options du programme.
À l'étape suivante, divers objets tels que des nœuds, des lignes et des barres peuvent être créés à l'aide des fonctions disponibles dans la bibliothèque C#. La bibliothèque comprend des classes pour tous les objets disponibles. Les propriétés des objets peuvent être définies et spécifiées à l'aide des paramètres. Le nombre de paramètres peut varier selon le cas d'utilisation.
Voici comment définir des objets à l'aide de l'exemple d'un nœud :
node newNode = new()
{
no = nodeId,
coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
coordinate_system_type = node_coordinate_system_type.COORDINATE_SYSTEM_CARTESIAN,
coordinate_system_typeSpecified = true,
comment = "node for beam"
};Les lignes, surfaces et autres objets sont définis de la même manière. Veuillez noter qu'un attribut « spécifié » correspondant doit être défini et réglé sur « vrai » pour certains attributs.
Exemple pratique
Cet exemple montre comment créer une poutre continue avec une charge linéique constante. Le nombre de travées, la travée de poutre et l'amplitude de la charge linéique peuvent être définis de manière variable via une entrée utilisateur.
Les variables requises sont d'abord définies par l'utilisateur dans la ligne de commande. Le programme vérifie si l'entrée de l'utilisateur est compatible avec le type de données de la variable respective. Si l'entrée est incorrecte ou vide, un message d'erreur s'affiche dans la ligne de commande. Lors de la programmation, des précautions particulières ont été prises pour s'assurer que les décimales peuvent être entrées à la fois par des points et des virgules afin de minimiser les risques d'erreur.
Connexion à RFEM/RSTAB
Le code suivant essaie d'établir une connexion avec RFEM/RSTAB dans un bloc try-catch :
var logger = LogManager.GetCurrentClassLogger();
string CurrentDirectory = Directory.GetCurrentDirectory();
try
{
information_application ApplicationInfo;
try
{
// connect to RFEM6 or RSTAB9 application
application = new ApplicationClient(Binding, Address);
}
catch (Exception exception)
{
if (application != null)
{
if (application.State != CommunicationState.Faulted)
{
application.Close();
logger.Error(exception, "Something happened:" + exception.Message);
}
else
{
application.Abort();
logger.Error(exception, "Communication with RFEM faulted:" + exception.Message);
}
}
Console.WriteLine(exception.ToString());
}
finally
{
ApplicationInfo = application.get_information();
logger.Info("Name: {0}, Version:{1}, Type: {2}, language: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
Console.WriteLine("Name: {0}, Version:{1}, Type: {2}, language: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
}
}
string modelName = "MyTestModel";
string modelUrl ="";
ModelClient model = new ModelClient(Binding, new EndpointAddress(modelUrl));Pour établir une connexion, le programme doit être ouvert avant d'exécuter le code. Une fois la connexion établie, les informations du programme sont affichées dans la ligne de commande et un nouveau modèle avec un nom défini par l'utilisateur est créé dans RFEM/RSTAB.
Définition des objets de base
À l'étape suivante, vous pouvez définir le matériau et la section de la poutre continue. Il est important que la description corresponde au nom enregistré dans la bibliothèque de matériaux ou de sections de RFEM.
material materialConcrete = new material
{
no = 1,
name = "C20/25 | EN 1992-1-1:2004/A1:2014"
};
section sectionRectangle = new section
{
no = 1,
material = materialConcrete.no,
materialSpecified = true,
type = section_type.TYPE_PARAMETRIC_MASSIVE_I,
typeSpecified = true,
type_parametrization = type_parametrization_section.PARAMETRIC_MASSIVE_I__MASSIVE_RECTANGLE__R_M1,
parametrization_typeSpecified = true,
name = "R_M1 0.5/1.0"
};À l'aide de boucles, divers objets (nœuds, lignes, barres) sont créés et organisés en listes. Les nœuds sont définis en fonction du nombre de travées défini par l'utilisateur et transférés dans la liste « lineDefinitionNodes ». La liste sera ensuite utilisée pour créer des lignes en fonction de leurs nœuds de définition. Lors de la création d'un modèle RSTAB, la liste est utilisée pour définir les barres en fonction de leurs nœuds de définition. Lorsque vous utilisez RFEM, les barres sont définies par des lignes.
SortedList<int, node> nodes = new SortedList<int, node>();
int[] lineDefinitionNodes = new int[spanNumber + 1];
int nodeId = 1;
double xVector = 0.0;
for (int i = 0; i < spanNumber + 1; i++)
{
node newNode = new()
{
no = nodeId,
coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
coordinate_system_type = node_coordinate_system_type.COORDINATE_SYSTEM_CARTESIAN,
coordinate_system_typeSpecified = true,
comment = "concrete part"
};
nodes.Add(nodeId, newNode);
lineDefinitionNodes[i] = nodeId;
xVector = xVector + span;
nodeId++;
}
// create lines
int lineId = 1;
SortedList<int, line> lines = new SortedList<int, line>();
for (int i = 0; i < spanNumber; i++)
{
line newLine = new()
{
no = lineId,
definition_nodes = new int[] { lineDefinitionNodes[i], lineDefinitionNodes[i + 1] },
comment = "lines for beams",
type = line_type.TYPE_POLYLINE,
typeSpecified = true,
};
lines.Add(lineId, newLine);
IDligne++;
}Une fois tous les objets de base créés, deux appuis nodaux différents sont définis. L'appui nodal sur le premier nœud doit être fixe, les appuis restants doivent être calculés sous forme de rouleaux dans la direction X. Les nœuds de définition pour les différents types d'appui sont chacun résumés dans une liste séparée.
nodal_support support1 = new()
{
no = 1,
nodes = supportedNodes1.ToArray(),
spring = new vector_3d() { x = double.PositiveInfinity, y = double.PositiveInfinity, z = double.PositiveInfinity },
rotational_restraint = new vector_3d() { x = double.PositiveInfinity, y = 0.0, z = double.PositiveInfinity }
};
nodal_support support2 = new()
{
no = 2,
nodes = supportedNodes2.ToArray(),
spring = new vector_3d() { x = 0.0, y = double.PositiveInfinity, z = double.PositiveInfinity },
rotational_restraint = new vector_3d() { x = 0.0, y = 0.0, z = double.PositiveInfinity }
};
nodalSupports.Add(support1);
nodalSupports.Add(support2);Transfert d'objets dans RFEM
Pour que les objets créés soient disponibles dans RFEM/RSTAB, vous devez d'abord les transférer dans le programme. Cette opération est effectuée entre deux fonctions, à savoir « model.begin_modification » et « model.end_modification », à l'aide des fonctions spécifiques à l'objet de la bibliothèque HLF. Les boucles Foreach sont utilisées pour transmettre tous les objets d'un type au programme.
try
{
model.begin_modification("Geometry");
model.set_material(materialConcrete);
model.set_section(sectionRectangle);
foreach (KeyValuePair<int, node> nodeItem in nodes)
{
model.set_node(nodeItem.Value);
}
foreach (KeyValuePair<int, line> lineItem in lines)
{
model.set_line(lineItem.Value);
}
foreach (KeyValuePair<int, member> memberItem in members)
{
model.set_member(memberItem.Value);
}
foreach (var nodalSupport in nodalSupports)
{
model.set_nodal_support(nodalSupport);
}
}
catch (Exception exception)
{
model.cancel_modification();
logger.Error(exception, "Something happened while creation of geometry" + exception.Message);
throw;
}
finally
{
try
{
model.finish_modification();
}
catch (Exception exception)
{
logger.Error(exception, "Something went wrong while finishing modification of geometry\n" + exception.Message + "\n");
model.reset();
}
}Définition des charges
Les cas de charge, les combinaisons de charges et les situations de calcul sont créés de la même manière que les objets de base, puis transférés dans le programme.
La charge de barre préalablement spécifiée par l'utilisateur peut ensuite être créée :
SortedList<int, member_load> member_loads = new SortedList<int, member_load>();
int member_load_id = 1;
for (int i = 0; i < spanNumber; i++)
{
member_load newMemberLoad = new()
{
no = i + 1,
members_string = (i + 1).ToString(),
members = new int[] { i + 1 },
load_distribution = member_load_load_distribution.LOAD_DISTRIBUTION_UNIFORM,
load_distributionSpecified = true,
magnitude = memberLoad * 1000,
magnitudeSpecified = true,
load_is_over_total_length = true,
load_is_over_total_lengthSpecified = true,
};
member_loads.Add(i + 1, newMemberLoad);
member_load_id++;
}En plus des charges uniformément réparties, des charges trapézoïdales et paraboliques sont également possibles.
Calcul et sortie des résultats
La fonction model.calculate(all) permet d'effectuer tous les calculs dans RFEM.
Après un calcul réussi, les résultats de cet exemple sont affichés dans la ligne de commande. La bibliothèque HLF pour C# permet également d'exporter les résultats dans des fichiers XML ou CSV.
Enfin, la fonction model.save() peut être utilisée pour enregistrer le modèle sous le chemin de fichier indiqué entre parenthèses :
//save the model before closing
model.save(CurrentDirectory + @"\testmodels\");
application.close_model(0, true);
Conclusion
L'exemple présenté montre clairement les avantages et la simplicité d'utilisation de la bibliothèque C#. La structure peut être rapidement adaptée à l'aide d'entrées définies par l'utilisateur, ce qui permet de gagner du temps lors de la saisie des systèmes structurels dans RFEM 6 et RSTAB 9. La bibliothèque HLF pour C# offre également de nombreuses autres fonctions permettant de créer des systèmes complexes.