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:
nodo nuovoNodo = nuovo()
{
no = nodeId,
coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
tipo_sistema_di_coordinate = tipo_sistema_di_coordinate_nodo.COordinate_sistema_cartesiane,
coordinate_system_typeSpecified = true,
commento = "nodo per trave"
};
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.
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
{
//connetti all'applicazione RFEM 6 o RSTAB 9
application = new ApplicationClient(Binding, Address);
}
catch (Exception exception)
{
if (application != zero)
{
if (Application.State != CommunicationState.Faulted)
{
application.Close();
logger.Error(exception, "È successo qualcosa:" + eccezione.Message);
}
else
{
application.Abort();
Recorder.Error(Exception, "Comunicazione con RFEM in errore:" + Exception.Message);
}
}
Console.WriteLine(exception.ToString());
}
finally
{
ApplicationInfo = application.get_information();
logger.Info("Nome: {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";
stringa modelloURL = "";
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.
materiale materialeConcrete = nuovo materiale
{
nr = 1,
nome = "C20/25 | EN 1992-1-1:2004/A1:2014"
};
Rettangolare della sezione della sezione = Nuova sezione
{
nr = 1,
materiale = materialeConcrete.no,
materialSpecified = vero,
tipo = tipo_sezione.TYPE_PARAMETERC_MASSIVE_I,
typeSpecified = true,
tipo_parametrizzazione = tipo_parametrizzazione_sezione.PARAMETERI_MASSIVE_I__MASSIVE_RECtangle__R_M1,
parametriization_typeSpecified = true,
nome = "R_M1 0.5/1.0"
};
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. In RFEM, tuttavia, le aste sono definite da linee.
Elencoordinato nodi = nuovo SortedList ();
int[] lineDefinitionNodes = new int[spanNumber + 1];
int nodeId = 1;
doppio xvettore = 0.0;
for (int i = 0; i < spanNumero + 1; i++)
{
nodo nuovoNodo = nuovo()
{
no = nodeId,
coordinates = new vector_3d() { x = xVector, y = 0.0, z = 0.0 },
tipo_sistema_di_coordinate = tipo_sistema_di_coordinate_nodo.COordinate_sistema_cartesiane,
coordinate_system_typeSpecified = true,
commento = "parte in calcestruzzo"
};
nodes.Add(nodeId, newNode);
lineDefinitionNodes [i] = nodeId;
xVettore = xVettore + campata;
IDnodo ++;
}
//crea linee
int lineId = 1;
Elencoordinato linee = nuovo SortedList ();
for (int i = 0; i < spanNumber; i++)
{
linea nuovaLinea = nuova()
{
no = lineId,
definizione_nodi = nuovo int[] { lineDefinitionNodes[i], lineDefinitionNodes[i + 1] },
comment = "Linee per travi",
tipo = tipo_linea.TYPE_POLYLINE,
typeSpecified = true,
};
lines.Add(lineId, newLine);
lineId ++;
}
Dopo aver creato tutti gli oggetti di base, vengono definiti due diversi vincoli esterni dei nodi. Il vincolo esterno del nodo al primo nodo dovrebbe essere definito come fisso, mentre i restanti vincoli dovrebbero essere mobili nella direzione X. I nodi di definizione per i vari tipi di vincolo sono riepilogati ciascuno in un elenco separato.
supporto_nodo supporto1 = nuovo()
{
nr = 1,
nodi = supportatiNodi1.ToArray(),
primavera = nuovo vettore_3d() { x = double.PositiveInfinity, y = double.PositiveInfinity, z = double.PositiveInfinity },
vincolo_rotazionale = nuovo vettore_3d() { x = double.PositiveInfinity, y = 0.0, z = double.PositiveInfinity }
};
vincolo esterno del nodo vincolo esterno2 = nuovo()
{
no = 2,
nodi = SupportedNodes2.ToArray(),
molla = nuovo vettore_3d() { x = 0.0, y = double.PositiveInfinity, z = double.PositiveInfinity },
vincolo_rotazionale = nuovo vettore_3d() { x = 0.0, y = 0.0, z = double.PositiveInfinity }
};
nodeSupports.Add(support1);
nodeSupports.Add(support2);
Trasferimento di oggetti in RFEM
Per rendere disponibili gli oggetti creati in RFEM/RSTAB, è necessario prima trasferirli al programma. Questo viene fatto tra due funzioni, cioè "model.begin_modification" e "model.end_modification", per mezzo delle funzioni specifiche degli oggetti della libreria HLF. I cicli Foreach vengono utilizzati per passare tutti gli oggetti di un tipo al programma.
try
{
model.begin_modification("Geometria");
model.set_material(materialConcrete);
model.set_section(sectionRectangle);
Foreach (KeyValuePair , elemento nodo nei nodi)
{
model.set_node (nodeItem.Value);
}
foreach (KeyValuePair lineItem nelle linee)
{
model.set_line (lineItem.Value);
}
foreach (KeyValuePair MemberItem nelle aste)
{
model.set_member(memberItem.Value);
}
foreach (var nodalSupport in nodalSupports)
{
model.set_nodal_support(nodalSupport);
}
}
catch (Exception exception)
{
model.cancel_modification();
logger.Error(exception, "Si è verificato qualcosa durante la creazione della geometria" + eccezione.Message);
throw;
}
finally
{
try
{
model.finish_modification();
}
catch (Exception exception)
{
logger.Error(exception, "Si è verificato un problema durante la modifica della geometria\n" + eccezione.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:
Elencoordinato aste_carichi = nuovo SortedList ();
int id_carico_asta = 1;
for (int i = 0; i < spanNumber; i++)
{
Member_load nuovoMemberLoad = nuovo()
{
no = i + 1,
Members_string = (i + 1).ToString(),
aste = new int[] {i + 1},
distribuzione_carico = distribuzione_carico_asta.LOAD_Distribution_Uniform,
load_distributionSpecificato = vero,
grandezza = carico dell'asta * 1.000,
grandezzaSpecificata=true,
load_is_over_total_length = vero,
load_is_over_total_lengthSpecified = true,
};
Member_loads.Add(i + 1, newMemberLoad);
id_carico_asta++;
}
Oltre ai carichi distribuiti uniformemente, sono possibili anche carichi trapezoidali e parabolici.
Calcolo e output dei risultati
Tramite la funzione model.calculate(all) tutti i calcoli vengono eseguiti 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:
//salva il modello prima della chiusura
model.save (CurrentDirectory +@"\TestModels\");
application.close_model (0, true);
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.
.png?mw=600&hash=49b6a289915d28aa461360f7308b092631b1446e)
