1705x

001773

Dipl.-Ing. Thomas Günthel

18. Oktober 2022

Webservice Tool für Wassersackbildung in C#

Die API für RFEM 6, RSTAB 9 und RSECTION beruht auf dem Konzept der Webservices. Um einen guten Einstieg in die Thematik zu bekommen, soll im folgenden Artikel ein weiterführendes Beispiel in C# erläutert werden.

Das Beispiel ist die Berechnung der Wasserlast auf einem Träger, welche durch die Durchbiegung des Trägers zunimmt. Für eine größere Flexibilität soll der Nutzer den/die Träger auswählen können. Des Weiteren sollen zusätzliche Lasten auf das Dach, welche unabhängig von der Wasserlast im gleichen Lastfall angesetzt werden, nicht verändert werden. Folgende Randbedingungen sind bekannt/werden angesetzt:

Wasserhöhe über dem unverformten System
Einzugsbreite des Stabes für die Flächenlast
Lastfallnummer des Lastfalls, bei dem die Last angelegt werden soll
Flächenlast des Wassers pro m Wasserstand (10000 N/m³)
Ein Bezeichner zur Identifizierung der Flächenlasten

Im Programm werden daher folgende Variablen angelegt:

double h_water = 0.1;   //  height of water over undeformed system in [m]
double w_ref = 2;       //  reference width for surface load in [m]
int load_case_no = 1;   //  number of load case where the load is applied
string water_accu_comment = "water accumulation";  //  identification string
double std_magnitude = 10000;   //  surface load per water height in [N/m^3]

Für die Umsetzung muss das Programm folgende Elemente enthalten:

Selektierte Stäbe herausfiltern
Wasserlasten aus früheren Durchläufen löschen
Neue Lasten anlegen
Berechnung starten
Durchbiegung ermitteln
Wieder zu Schritt 3 und aus Verformungen neue Lasten erzeugen
Iterationen so lange wiederholen, bis ein Grenzwert erreicht wird

Neben diesen Funktionen werden auch die Anbindung an Programm und Modell, diverse try-catch-Blöcke und andere Standardelemente benötigt, auf die hier aber nicht näher eingegangen werden soll. Diese Elemente sind dann im Quellcode enthalten, welcher unterhalb des Artikels heruntergeladen werden kann.

1. Selektierte Stäbe herausfiltern

Zuerst werden Informationen zu allen selektierten Objekten über die Funktion get_all_selected_objects geholt. Das erhaltene Array enthält Elemente vom Typ object_location, welche z. B. den Typ, die Nummer und die übergeordnete "Eltern" Objektnummer enthalten. In der folgenden Schleife werden dann die Nummern aller Objekte vom Typ E_OBJECT_TYPE_MEMBER (also alle Stabnummern) extrahiert und im Array mem_noes_sel gespeichert.

//  get selected objects
object_location[] obj_locs = model.get_all_selected_objects();

//  extract members
int[] mem_noes_sel = new int[0];
foreach(object_location obj_loc in obj_locs)
{
	if(obj_loc.type == object_types.E_OBJECT_TYPE_MEMBER)
	{
		Array.Resize(ref mem_noes_sel, mem_noes_sel.Length + 1);
		mem_noes_sel[mem_noes_sel.Length-1] = obj_loc.no;
	}
}

2. Wasserlasten aus früheren Durchläufen löschen

Mithilfe der Stabnummern ist es jetzt möglich, die zugehörigen Stablasten aus allen Stablasten herauszufiltern. Dafür wird eine Schleife über die Stablastnummern verwendet. Innerhalb dieser Schleife werden dann die Daten zur Stablast geholt, deren Stabnummern auf Übereinstimmung mit den selektierten Stabnummern überprüft und bei einem Treffer die entsprechende Stablast gelöscht:

KB 001773 | Webservice Tool für Wassersackbildung in C#

C# Werkzeug zur Ermittlung von Wasserlasten - Filterung von Lasten über den Kommentar

//  delete all water_accu loads
//      get all memberload numbers
int[] mem_load_noes = model.get_all_object_numbers(object_types.E_OBJECT_TYPE_MEMBER_LOAD, load_case_no);

//  loop through all member loads of the load case
foreach(int mem_load_no in mem_load_noes)
{
	//  get member load
	member_load mem_load = model.get_member_load(mem_load_no, load_case_no);

	if(mem_load.comment == water_accu_comment)
	{
		//  loop through the members of the member load
		for(int i= 0; i < mem_load.members.Length; i++)
		{
			//  loop through the members of the member load
			for (int j = 0; j < mem_noes_sel.Length; j++)
			{
				if(mem_load.members[i] == mem_noes_sel[j])
				{
					//  delete member load
					model.delete_object(object_types.E_OBJECT_TYPE_MEMBER_LOAD, mem_load_no, load_case_no);
				}
			}
		}

		
	}

}

Damit keine anderen Stablasten überschrieben werden, wird als Nächstes die letzte verwendete Stablastnummer ausgelesen:

//  get last load number
int no_offset = model.get_nth_object_number(object_types.E_OBJECT_TYPE_MEMBER_LOAD,0, load_case_no) + 1;

Als nächstes erfolgt das Anlegen der neuen Stablasten, was bereits ein Bestandteil der do-while-Iterationsschleife ist. Diese Schleife ist wie folgt aufgebaut:

do
{
	//  reset delta deformation
	delta_def = 0;
	
	//  apply load
	model.begin_modification("Loads");
	
    //  create member loads for each member
	...
    
    model.finish_modification();
    ...
    
	//  calculate load case
	...


	//  get member end deformations
	...

//  check criterion
} while (delta_def > 0.0001);

Für den Abbruch der Iterationsschleife, wurde die Änderung der Verformung gewählt, welche beim Filtern der Ergebnisse bestimmt wird. Wenn alle Verformungen gegenüber der Verformung im vorigen Durchlauf weniger als 0,0001m (sprich 0,1mm) abweichen, wird die Schleife abgebrochen.

3. Neue Lasten anlegen

Als Lasttyp wird eine Trapezlast in globaler z-Richtung gewählt, welche am Anfang und am Ende des Stabes unterschiedliche Werte haben kann. Zu beachten ist, dass für alle zu übertragenden Parameter die zugehörigen "Specified" Variable auf "true" gesetzt werden muss. Dies ist notwendig, damit nicht alle Parameter einer Klasse übertragen werden müssen und so die zu übertragende Datenmenge gering gehalten werden kann. Der Wert der Last berechnet sich aus der Anfangshöhe "h_water" (wurde vorgegeben) und der zusätzlichen Knotenverformung an dieser Stelle. Diese Höhe in [m] wird mit "std_magnitude" in [N/m³] und der Einzugsbreite in [m] multipliziert, damit erhält man eine Linienlast in [N/m]:

//  create member loads for each member
for (int i = 0; i < mem_noes_sel.Length; ++i)
{
	member_load mem_load = new member_load();
	mem_load.no = no_offset + i;
	mem_load.comment = water_accu_comment;
	mem_load.members = new int[] { mem_noes_sel[i] };

	mem_load.distance_a_is_defined_as_relative = true;
	mem_load.distance_a_is_defined_as_relativeSpecified = true;
	mem_load.distance_a_relative = 0.0;
	mem_load.distance_a_relativeSpecified = true;

	mem_load.distance_b_is_defined_as_relative = true;
	mem_load.distance_b_is_defined_as_relativeSpecified = true;
	mem_load.distance_b_relative = 1.0;
	mem_load.distance_b_relativeSpecified = true;

	mem_load.load_direction = member_load_load_direction.LOAD_DIRECTION_GLOBAL_Z_OR_USER_DEFINED_W_TRUE;
	mem_load.load_directionSpecified = true;

	mem_load.load_type = member_load_load_type.LOAD_TYPE_FORCE;
	mem_load.load_typeSpecified = true;
	mem_load.load_distribution = member_load_load_distribution.LOAD_DISTRIBUTION_TRAPEZOIDAL;
	mem_load.load_distributionSpecified = true;
	
    mem_load.magnitude_1 = std_magnitude * ((h_water + mem_end_defs[i,0]) * w_ref);
	mem_load.magnitude_1Specified = true;
	mem_load.magnitude_2 = std_magnitude * ((h_water + mem_end_defs[i,1]) * w_ref);
	mem_load.magnitude_2Specified = true;

	model.set_member_load(load_case_no, mem_load);
                                        
}

Für das Übertragen der Last wird die Funktion set_member_load verwendet. Damit die Lasten zugeordnet werden können, wird als Kommentar die Zeichenkette water_accu_comment verwendet. In den folgenden Iterationen werden die Lasten auch nicht mehr gelöscht, sondern durch Angabe der Lastnummer werden diese beim erneuten Übertragen überschrieben. Der Kommentar wird daher nur zum Filtern und Löschen der Lasten beim erneuten Start der Anwendung benötigt. Des Weiteren wurde für die Angabe der Last ein relativer Bezug gewählt, welcher allerdings von 0-100% reicht.

Im nächsten Schritt wird die Berechnung angestoßen. Dazu wird zuerst ein Feld mit Objekten vom Typ calculate_specific_loading angelegt. Dieses Feld beinhaltet alle zu berechnenden Lastfälle/Lastkombinationen. Im konkreten Fall wird nur ein Element vom Typ Lastfall angelegt mit der vorgegebenen Lastfallnummer load_case_no:

//  calculate load case
calculate_specific_loading[] csl = new calculate_specific_loading[1];
csl[0] = new calculate_specific_loading();
csl[0].no = load_case_no;
csl[0].type = case_object_types.E_OBJECT_TYPE_LOAD_CASE;

model.calculate_specific(csl, true);

Nachdem die Ergebnisse zur Verfügung stehen, müssen die globalen Verformungen am Anfang und am Ende jedes Stabes herausgefiltert werden. Über die Funktion get_results_for_members_global_deformations werden zunächst alle globalen Stabverformungen des vorgegebenen Lastfalls und von den selektierten Stäben geholt. Der Aufbau der Ergebnisse ist der gleiche wie in der entsprechenden Tabelle in RFEM 6. Eine Variante ist das Auslesen der Stablänge und der Vergleich der x-Stelle des Ergebnisses. Eine andere Variante nutzt die vergebene Beschreibung (description) und den Fakt, dass nach allen x-Stellen die Extrema folgen. Diese Variante wurde gewählt und wenn das erste Mal "Extrema" in description auftritt, wird der vorige Index verwendet um damit die letzte x-Stelle des Stabes zu finden. Da die erste Stelle des Stabes auch den ersten Eintrag betrifft, muss hier keine weitere Filterung stattfinden:

//  get member end deformations
for (int i = 0; i < mem_noes_sel.Length; ++i)
{
    members_global_deformations_row[] mem_defs_glbl = model.get_results_for_members_global_deformations(case_object_types.E_OBJECT_TYPE_LOAD_CASE, load_case_no, mem_noes_sel[i]);

    //  take start point
    //      calculate delta deformation
    if (Math.Abs(mem_end_defs[i, 0] - mem_defs_glbl[0].row.displacement_z) > delta_def)
        delta_def = Math.Abs(mem_end_defs[i, 0] - mem_defs_glbl[0].row.displacement_z);

    mem_end_defs[i, 0] = mem_defs_glbl[0].row.displacement_z;
    
    //  get deformation on end point
    for (int j = 0; j < mem_defs_glbl.Length; ++j)
    {
        if (mem_defs_glbl[j].description == "Extremes")
        {
            //      calculate delta deformation
            if (Math.Abs(mem_end_defs[i, 1] - mem_defs_glbl[j - 1].row.displacement_z) > delta_def)
                delta_def = Math.Abs(mem_end_defs[i, 1] - mem_defs_glbl[j - 1].row.displacement_z);

            mem_end_defs[i, 1] = mem_defs_glbl[j - 1].row.displacement_z;
            break;
        }
    }
}

Neben dem Ermitteln der Verformungen, wird auch die Variable "delta_def" berechnet, welche für das Abbruchkriterium verwendet wird. Es wird zuerst die Differenz aus dem Verformungswert der vorigen Iteration (am Anfang null) und dem aktuellen Wert gebildet. Von der Differenz wird der absolute Wert genommen und dann das Maximum gesucht. Wie bereits zuvor in der Beschreibung der Iterationsschleife gezeigt, wird dann bei einem Wert kleiner als 0,0001m (sprich 0,1mm) abgebrochen.

Im angehängten Video können Sie zum einen den Lastfilter und zum anderen die Iterationsschritte bis zum Abbruch sehen. Am Ende wird die gefundene Last dargestellt.

C# Werkzeug zur Ermittlung von Wasserlasten - Resultierende Last

Die Webservice Schnittstelle bietet zahllose Möglichkeiten zur Modifizierung von Elementen in RFEM 6/RSTAB 9, aber auch das Auslesen der Ergebnisse. Damit lassen sich viele verschiedene Projekte realisieren. Das hier gezeigte Programm beinhaltet von vielen verschiedenen Elementen einen ersten Schritt: