La biblioteca de características de alto nivel (HLF) para C# proporciona numerosas características útiles para crear estructuras en RFEM y RSTAB, algunas de las cuales se usarán en el siguiente ejemplo.
Para implementar el código programado, primero se requiere una conexión al programa. Se debe especificar uno de los puertos disponibles como dirección. La dirección predeterminada de RFEM/RSTAB es http://localhost:8081 . Si es necesario, se puede modificar en las opciones del programa.
En el siguiente paso, se pueden crear varios objetos como nudos, líneas y barras utilizando las funciones disponibles en la biblioteca en C#. La biblioteca incluye clases para todos los objetos disponibles. En función de los parámetros, se pueden definir y especificar las propiedades de los objetos. El número de parámetros puede variar según el caso de uso.
A continuación se muestra cómo se pueden definir los objetos usando el ejemplo de un nudo:
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"
};Las líneas, las superficies y otros objetos se definen de la misma forma. Tenga en cuenta que se debe definir un atributo "Specified" correspondiente y establecerlo en "true" para ciertos atributos.
Ejemplo práctico
Este ejemplo le muestra cómo crear una viga continua con una carga lineal constante. El número de vanos, la luz del vano de la viga y la magnitud de la carga lineal se pueden establecer de forma variable mediante la entrada del usuario.
Primero, las variables requeridas son definidas por el usuario en la línea de comandos. El programa comprueba si la entrada del usuario es compatible con el tipo de datos de la variable respectiva. Si la entrada es incorrecta o está vacía, aparece un mensaje de error en la línea de comandos. En la programación, se tuvo especial cuidado para asegurar que los decimales se puedan introducir tanto con puntos como con comas para minimizar la propensión a errores.
Conexión con RFEM/RSTAB
El siguiente código intenta establecer una conexión con RFEM/RSTAB dentro de un bloque try-catch:
var logger = LogManager.GetCurrentClassLogger();
string CurrentDirectory = Directory.GetCurrentDirectory();
try
{
application_information ApplicationInfo;
try
{
// conexión con la aplicación de RFEM6 o RSTAB9
application = new ApplicationClient(Binding, Address);
}
catch (Exception exception)
{
if (application != zero)
{
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("Nombre: {0}, versión:{1}, tipo: {2}, idioma: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
Console.WriteLine("Nombre: {0}, versión:{1}, tipo: {2}, idioma: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
}
}
string modelName = "MyTestModel";
string modelUrl ="";
ModelClient model = new ModelClient(Binding, new EndpointAddress(modelUrl));Para establecer una conexión, el programa debe estar abierto antes de ejecutar el código. Después de una conexión exitosa, la información del programa se muestra en la línea de comandos y se crea un nuevo modelo con un nombre definido por el usuario en RFEM/RSTAB.
Definición de objetos básicos
En el siguiente paso, puede definir el material y la sección de la viga continua. Es importante que la descripción se corresponda con el nombre almacenado en la biblioteca de materiales o en la biblioteca de secciones 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,
parametrization_type = section_parametrization_type.PARAMETRIC_MASSIVE_I__MASSIVE_RECTANGLE__R_M1,
parametrization_typeSpecified = true,
name = "R_M1 0.5/1.0"
};Con la ayuda de bucles, se crean y organizan varios objetos (nudos, líneas, barras) en listas. Los nudos se definen en función del número de vanos definido por el usuario y se transfieren a la lista "lineDefinitionNodes". La lista se usará más tarde para crear líneas basadas en sus nudos de definición. Al crear un modelo de RSTAB, la lista se usa para definir las barras según sus nudos de definición. Cuando se usa RFEM, las barras se definen mediante líneas.
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++;
}
// crear líneas
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);
lineId++;
}Una vez creados todos los objetos base, se definen dos apoyos en nudo diferentes. El apoyo en nudo en el primer nudo debe estar fijo, los apoyos restantes se deben calcular como apoyos móviles en la dirección X. Los nudos de definición para los distintos tipos de apoyo se resumen cada uno en una lista separada.
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);Transferencia de objetos a RFEM
Para que los objetos creados estén disponibles en RFEM/RSTAB, primero se deben transferir al programa. Esto se hace entre dos funciones, es decir "model.begin_modification" y "model.end_modification", por medio de funciones específicas del objeto de la biblioteca de HLF. Los bucles for-each se usan para transferir todos los objetos de un tipo al programa.
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();
}
}Definición de cargas
Los casos de carga, las combinaciones de carga y las situaciones de proyecto se crean de forma similar a los objetos básicos y luego se transfieren al programa.
Luego, se puede crear la carga de barras, que fue especificada previamente por el usuario:
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++;
}Además de las cargas uniformemente distribuidas, también son posibles las cargas trapezoidales y parabólicas.
Cálculo y salida de resultados
Mediante la función model.calculate(all) se ejecutan todos los cálculos en RFEM.
Después de un cálculo exitoso, los resultados de este ejemplo se muestran en la línea de comandos. La biblioteca de HLF para C# también permite la exportación de resultados en archivos XML o CSV.
Finalmente, la función model.save() se puede usar para guardar el modelo en la ruta del archivo indicada entre paréntesis:
//guardar el modelo antes de cerrar
model.save(CurrentDirectory + @"\testmodels\");
application.close_model(0, true);
Conclusión
En el ejemplo que se muestra, se aclaran las ventajas y el manejo fácil de la biblioteca en C#. La estructura se puede adaptar rápidamente mediante entradas definidas por el usuario, lo que ahorra mucho tiempo al introducir sistemas estructurales en RFEM 6 y RSTAB 9. La biblioteca de HLF para C# también ofrece muchas otras funciones, lo que permite la creación de sistemas complejos.