La libreria HLF per C# fornisce numerose funzioni utili per la creazione di strutture in RFEM e RSTAB, alcune delle quali saranno utilizzate nel seguente esempio.
Per implementare il codice programmato, è necessario prima un collegamento al programma. Una delle porte disponibili deve essere specificata come indirizzo. L'indirizzo predefinito di RFEM/RSTAB è http://localhost:8081 . Se necessario, può essere modificato nelle opzioni del programma.
Nella fase successiva, è possibile creare vari oggetti come nodi, linee e aste utilizzando le funzioni disponibili nella libreria C#. La libreria include classi per tutti gli oggetti disponibili. In base ai parametri, le proprietà degli oggetti possono essere definite e specificate. Il numero di parametri può variare a seconda del caso d'uso.
Quanto segue mostra come gli oggetti possono essere definiti utilizzando l'esempio di un nodo:
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"
};
Die Definition von Linien, Flächen und anderen Objekten erfolgt analog. Es ist zu beachten, dass für bestimmte Attribute zusätzlich ein zugehöriges „Specified“-Attribut definiert und auf „true“ gesetzt werden muss.
Esempio pratico
Questo esempio mostra come creare una trave continua con un carico lineare costante. Il numero di campate, la campata della trave e l'entità del carico della linea possono essere impostati in modo variabile tramite input dell'utente.
Innanzitutto, le variabili richieste sono definite dall'utente nella console. Il programma verifica se l'input dell'utente è compatibile con il tipo di dati della rispettiva variabile. Se la voce è errata o vuota, nella console apparirà un messaggio di errore. Durante la programmazione, è stata prestata particolare attenzione al fatto che i numeri decimali possono essere inseriti utilizzando sia la notazione per punti che la notazione decimale per ridurre al minimo la suscettibilità all'errore.
Collegamento a RFEM/RSTAB
Il seguente codice tenta di stabilire una connessione con RFEM/RSTAB all'interno di un blocco try-catch:
var logger = LogManager.GetCurrentClassLogger();
string CurrentDirectory = Directory.GetCurrentDirectory ();
try
{
application_information ApplicationInfo;
try
{
// connect to RFEM6 or RSTAB9 application
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("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));
Per creare una connessione, il programma deve essere aperto prima di eseguire il codice. Dopo una connessione riuscita, le informazioni sul programma vengono visualizzate nella console e in RFEM/RSTAB viene creato un nuovo modello con un nome definito dall'utente.
Definizione degli oggetti di base
Nel passaggio successivo, è possibile definire il materiale e la sezione trasversale della trave continua. È importante che la descrizione corrisponda al nome memorizzato nella libreria dei materiali o delle sezioni trasversali di 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"
};
Mithilfe von Schleifen werden die verschiedenen Objekte (Knoten, Linien, Stäbe) erstellt und in Listen organisiert. Die Knoten werden in Abhängigkeit von der nutzerdefinierten Anzahl der Felder definiert und in die Liste „lineDefinitionNodes“ übergeben. Diese Liste dient später dazu, Linien anhand ihrer Definitionsknoten zu erstellen. Wenn ein RSTAB-Modell erstellt werden soll, dient sie zur Definition der Stäbe anhand ihrer Definitionsknoten. Bei Verwendung von RFEM werden die Stäbe dagegen über Linien definiert.
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
{
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 ++;
}
Nachdem alle Basisobjekte erstellt wurden, werden zwei verschiedene Knotenlager definiert. Das Knotenlager am ersten Knoten soll fest, die restlichen Lager verschieblich in X-Richtung ausgebildet werden. Die Definitionsknoten für die verschiedenen Lagertypen werden je in einer eigenen Liste zusammengefasst.
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);
Trasferimento di oggetti in RFEM
Per rendere disponibili gli oggetti creati in RFEM/RSTAB, è necessario prima trasferirli al programma. Dies erfolgt zwischen den beiden Funktionen „model.begin_modification“ und „model.end_modification“ mithilfe von objektspezifischen Funktionen der HLF-Bibliothek. Mithilfe von foreach-Schleifen werden alle Objekte eines Typs an das Programm übergeben.
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();
}
}
Definizione dei carichi
I casi di carico, le combinazioni di carico e le situazioni di progetto vengono creati in modo simile agli oggetti di base e quindi trasferiti al programma.
Quindi, è possibile creare il carico dell'asta, che è stato precedentemente specificato dall'utente:
SortedList<int, member_load> member_loads = new SortedList<int, member_load>();
int member_load_id = 1;
for (int i = 0; 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++;
}
Neben gleichmäßig verteilten Lasten sind unter anderem auch Trapez- und parabelförmige Lasten möglich.
Calcolo e output dei risultati
Mit der Funktion model.calculate(all) werden alle Berechnungen in RFEM durchgeführt.
Dopo un calcolo riuscito, i risultati in questo esempio vengono visualizzati nella console. Die HLF-Bibliothek für C# ermöglicht außerdem den Export von Ergebnissen in XML- oder CSV-Dateien.
Mit der Funktion model.save() kann das Modell schließlich in dem in Klammern angegebenen Dateipfad gespeichert werden:
//save the model before closing
model.save (CurrentDirectory +@"\TestModels\");
application.close_model (0, true);
Sommario
Nell'esempio mostrato, sono stati chiaritii vantaggi e la facile gestione della libreria C#. La struttura può essere adattata rapidamente per mezzo di voci definite dall'utente, il che consente di risparmiare molto tempo durante l'inserimento di sistemi strutturali in RFEM 6 e RSTAB 9. La libreria HLF per C# offre anche molte altre funzioni, che consentono la creazione di sistemi complessi.
.JPG?mw=350&hash=354dcaeb798219977d00c1979f12a0628654c9f0)
.jpg?mw=350&hash=91f398b559b26a6ac36fd7ecdf5e395e7b9b856d)
.png?mw=600&hash=49b6a289915d28aa461360f7308b092631b1446e)
