Tutorial per WebService e API in C#

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.

Intervallo di porte del server WebService in RFEM 6

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:

1. code.csharp#

nodo nuovoNodo = nuovo()
{

1. no = nodeId,
2. coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
3. tipo_sistema_di_coordinate = tipo_sistema_di_coordinate_nodo.COORDINATE_SYSTEM_CARTESIAN,
4. coordinate_system_typeSpecified = true,
5. commento = "nodo per trave"

};

1. /codice#

Linee, superfici e altri oggetti sono definiti allo stesso modo. Si noti che un attributo "Specificato" corrispondente deve essere definito e impostato su "vero" per determinati attributi.

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.

Esempio di input della console C #

Collegamento a RFEM/RSTAB

Il seguente codice tenta di stabilire una connessione con RFEM/RSTAB all'interno di un blocco try-catch:

1. code.csharp#

var logger = LogManager.GetCurrentClassLogger();
string CurrentDirectory = Directory.GetCurrentDirectory ();
try
{

1. application_information ApplicationInfo;

1. try
2. {
3. //collega all'applicazione RFEM6 o RSTAB9
4. application = new ApplicationClient(Binding, Address);
5. }
6. catch (Exception exception)
7. {
8. if (application != zero)
9. {
10. if (Application.State != CommunicationState.Faulted)
11. {
12. application.Close();
13. logger.Error(exception, "È successo qualcosa:" + eccezione.Message);
14. }
15. else
16. {
17. application.Abort();
18. logger.Error(exception, "Comunicazione con RFEM errata:" + eccezione.Message);
19. }
20. }
21. Console.WriteLine(exception.ToString());
22. }
23. finally
24. {
25. ApplicationInfo = application.get_information();
26. logger.Info("Nome: {0}, Version:{1}, Type: {2}, language: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
27. Console.WriteLine("Name: {0}, Version:{1}, Type: {2}, language: {3} ", ApplicationInfo.name, ApplicationInfo.version, ApplicationInfo.type, ApplicationInfo.language_name);
28. }

}

string modelName = "MyTestModel";
stringa modelloUrl ="";
ModelClient model = new ModelClient(Binding, new EndpointAddress(modelURL));

1. /codice#

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.

1. code.csharp#

materiale materialeConcrete = nuovo materiale
{

1. nr = 1,
2. nome = "C20/25 | EN 1992-1-1:2004/A1:2014"

};

sezione sezioneRettangolo = nuova sezione
{

1. nr = 1,
2. materiale = materialeConcrete.no,
3. materialSpecified = vero,
4. tipo = tipo_sezione.TYPE_PARAMETRIC_MASSIVE_I,
5. typeSpecified = true,
6. tipo_parametrizzazione = tipo_parametrizzazione_sezione.PARAMETRIC_MASSIVE_I__MASSIVE_RECTANGLE__R_M1,
7. parametriization_typeSpecified = true,
8. nome = "R_M1 0.5/1.0"

};

1. /codice#

Con l'aiuto di loop, vari oggetti (nodi, linee, aste) vengono creati e organizzati in elenchi. I nodi sono definiti in base al numero di campate definito dall'utente e trasferiti all'elenco "lineDefinitionNodes". L'elenco sarà successivamente utilizzato per creare linee in base ai loro nodi di definizione. Quando si crea un modello RSTAB, l'elenco viene utilizzato per definire le aste in base ai loro nodi di definizione. Quando si utilizza RFEM, le aste sono definite tramite linee.

1. code.sharp#

SortedList nodes = new SortedList();
int[] lineDefinitionNodes = new int[spanNumber + 1];
int nodeId = 1;
doppio xVector = 0.0;

for (int i = 0; i < spanNumero + 1; i++)
{

1. nodo nuovoNodo = nuovo()
2. {
3. no = nodeId,
4. coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
5. tipo_sistema_di_coordinate = tipo_sistema_di_coordinate_nodo.COORDINATE_SYSTEM_CARTESIAN,
6. coordinate_system_typeSpecified = true,
7. commento = "parte in calcestruzzo"
8. };
9. nodes.Add(nodeId, newNode);
10. lineDefinitionNodes[i] = nodeId;
11. xVettore = xVettore + campata;
12. nodeId++;

}

//crea linee
int lineId = 1;
SortedList righe = new SortedList();

for (int i = 0; i
{

1. linea nuovaLinea = nuova()
2. {
3. no = lineId,
4. definizione_nodi = nuovo int[] { lineDefinitionNodes[i], lineDefinitionNodes[i + 1] },
5. comment = "linee per travi",
6. tipo = tipo_linea.TYPE_POLYLINE,
7. typeSpecified = true,
8. };
9. lines.Add(lineId, newLine);
10. lineId ++;

}

1. /codice#

Dopo che tutti gli oggetti di base sono stati creati, vengono definiti due diversi vincoli esterni dei nodi. Il vincolo esterno del nodo sul primo nodo dovrebbe essere fissato; i restanti vincoli esterni dovrebbero essere progettati come rulli in direzione X. I nodi di definizione per i vari tipi di vincolo sono riepilogati ciascuno in un elenco separato.

1. code.csharp#

vincolo_supporto_nodale1 = nuovo()
{

1. nr = 1,
2. nodi = supportatiNodi1.ToArray(),
3. primavera = nuovo vettore_3d() { x = double.PositiveInfinity, y = double.PositiveInfinity, z = double.PositiveInfinity },
4. vincolo_rotazionale = nuovo vettore_3d() { x = double.PositiveInfinity, y = 0.0, z = double.PositiveInfinity }

};

supporto_nodale support2 = nuovo()
{

1. no = 2,
2. nodi = supportatiNodi2.ToArray(),
3. molla = nuovo vettore_3d() { x = 0.0, y = double.PositiveInfinity, z = double.PositiveInfinity },
4. vincolo_rotazionale = nuovo vettore_3d() { x = 0.0, y = 0.0, z = double.PositiveInfinity }

};

nodalSupports.Add(support1);
nodalSupports.Add(support2);

1. /codice#

Trasferimento di oggetti in RFEM

Per rendere disponibili gli oggetti creati in RFEM/RSTAB, è necessario prima trasferirli al programma. Questo viene fatto tra le due funzioni "model.begin_modification" e "model.end_modification", utilizzando le funzioni specifiche degli oggetti della libreria HLF. Tutti gli oggetti di un tipo vengono trasferiti al programma utilizzando i cicli foreach.

1. code.csharp#

try
{

1. model.begin_modification("Geometria");
2. model.set_material(materialConcrete);
3. model.set_section(sectionRectangle);

1. foreach (KeyValuePair nodeItem in nodes)
2. {
3. model.set_node (nodeItem.Value);
4. }
5. foreach (KeyValuePair lineItem in lines)
6. {
7. model.set_line(lineItem.Value);
8. }
9. foreach (KeyValuePair MemberItem nelle aste)
10. {
11. model.set_member(memberItem.Value);
12. }
13. foreach (var nodalSupport in nodalSupports)
14. {
15. model.set_nodal_support(nodalSupport);
16. }

}
catch (Exception exception)
{

1. model.cancel_modification();
2. logger.Error(exception, "Si è verificato qualcosa durante la creazione della geometria" + eccezione.Message);
3. throw;

}
finally
{

1. try
2. {
3. model.finish_modification();
4. }
5. catch (Exception exception)
6. {
7. logger.Error(exception, "Si è verificato un problema durante la modifica della geometria\n" + eccezione.Message + "\n");
8. model.reset();
9. }

}

1. /codice#

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:

1. code.csharp#

SortedList aste_loads = new SortedList();
int id_carico_asta = 1;

for (int i = 0; i
{

1. Member_load nuovoMemberLoad = nuovo()
2. {
3. no = i + 1,
4. Members_string = (i + 1).ToString(),
5. aste = new int[] { i + 1 },
6. distribuzione_carico = distribuzione_carico_asta.LOAD_DISTRIBUTION_UNIFORM,
7. load_distributionSpecificato = vero,
8. grandezza = carico dell'asta * 1000,
9. grandezzaSpecificata = vero,
10. load_is_over_total_length = vero,
11. load_is_over_total_lengthSpecified = true,
12. };
13. Member_loads.Add(i + 1, newMemberLoad);
14. id_carico_asta++;

}

1. /codice#

Oltre ai carichi distribuiti uniformemente, sono possibili anche carichi trapezoidali e parabolici.

Calcolo e output dei risultati

La funzione model.calculate(all) viene utilizzata per eseguire tutti i calcoli in RFEM.

Dopo un calcolo riuscito, i risultati in questo esempio vengono visualizzati nella console. La libreria HLF per C#consente anche l'esportazione dei risultati in file XML o CSV.

Infine, la funzione model.save() può essere utilizzata per salvare il modello nel percorso del file indicato tra parentesi:

1. code.csharp#

//salva il modello prima della chiusura
model.save (CurrentDirectory +@"\TestModels\");
application.close_model (0, true);

1. /codice#

WebService & API C#- Risultati

Conclusione

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.