In the most recent update to the load combination generator, Wir haben das Innenleben des Moduls vereinfacht und die folgende Funktionalität hinzugefügt:

• Load combination generation is defined by a single .json file (Schema) für jeden Standard.
• Lastgruppen und -kombinationen können erstellt werden, ohne dass Lasten zuerst im S3D-Modellierungsraum zugewiesen werden müssen.
• Muster, die auf alten basieren “Erweitern Sie Windlasten” Kontrollkästchen, Arbeiten Sie nun mit beliebigen Lastfällen.

Nomenklatur

In der letzten Version des Lastkombinationsgenerators, der Lastfallname, der für viele Dinge verwendet wurde:

• Fungiert als eindeutige ID.
• Unterscheiden Sie zwischen Belastung super case und Lastfall, and always require one value in each (leading to bizarre ones like Eigengewicht: tot).
• Remain human readable, all the while remaining small enough for dropdown menus by contracting words (Verkehrslast: Q-dist-roof-floor).

In the most recent update, we have divided load case names into symbols, which will be small to be used to code and when space is limited (when naming the load combinations for example: 1.25D1 + 1.5Der + 1.5Ld + 0.5Sl + 0.5T.), und labels, which will aim to be very descriptive. Beide symbols und labels will have to be unique within a given standard. We will also allow Ladehüllen to be named the same as the load super case, usually for the default load case (most commonly used). The two examples used above would be split like this:

{“D”: “Dead”}
{“Ldr”: “Live - Concentrated, Roofs, Floor”}

Mit der symbol must be composed minimally of one uppercase letter, which defines the super case. Mit der super case is a new concept, used to group similar load cases that usually act together. Mit der super case label is given at the start of the load case label (before the dash). In the example above (Eurocode) the load case Ldr would be part of the L super case (named Live in the label), alongside other load cases like Ldd and Ldo. Hinter den Kulissen, bleibt die super case wird hauptsächlich zur Durchsetzung der Filterregeln verwendet, Das heißt, es wird bestimmt, welche Schemazeilen beibehalten und welche entfernt werden müssen.

Der erste Teil des Etiketts (before the dash) ist der Name des super case. Der zweite Teil ist eine Beschreibung, Verwenden Sie Kommas, um Kategorien von Unterkategorien zu trennen. Der zweite Teil ist optional, aber nur ein Lastfall kann die Vorgabe übernehmen super case Stelle.

Standardschemata-Zeilen

Jeder Standard hat eine Schema die alle möglichen Lastkombinationen für diese Norm vollständig definiert. Mit der Schema.json Datei ist ganz einfach, aber es kann ziemlich lang werden, insbesondere in Standards (wie Eurocode) die eine Vielzahl von Permutationen erfordern. Um ein einfaches Beispiel zu nehmen, Nehmen Sie die folgende Beispielanforderung.

1.2*D. + 1.5*L. + (0.5*S oder 0,5*W oder 0,5*T)

Um dies in unser umzuwandeln Schema, Wir müssen es in jede mögliche Permutation zerlegen:

1.2*D. + 1.5*L
1,2*D + 1.5*L. + 0.5*S
1,2*D + 1.5*L. + 0.5*W
1,2*D + 1.5*L. + 0.5*T
1,2*D + 1.5*L. + 0.5*S. + 0.5*W
1,2*D + 1.5*L. + 0.5*W. + 0.5*T
1,2*D + 1.5*L. + 0.5*T. + 0.5*S
1,2*D + 1.5*L. + 0.5*S. + 0.5*W. + 0.5*T.

Auf diese Weise wird einmal jede Lastkombination aufgelistet, Sie können das Schema erstellen, indem Sie die folgenden Schritte ausführen:

1. Verwenden Sie jeden Lastfallschlüssel und -koeffizienten, um ein Schemazeilenobjekt zu erstellen.
2. Benennen Sie jede Zeile mit einer eindeutigen Kennung (da dies ein Objekt sein wird). Die Konvention besteht darin, Bindestriche zu verwenden, um verschiedene Elemente des Namens zu trennen.
3. Eine Ebene höher, Gruppieren Sie die Zeilen nach Kriterien (Stärke, Wartungsfreundlichkeit, zufällig, etc.)

Das Endergebnis sollte in etwa so aussehen:

"Reihen": {
  "Stärke":{
    "A-1-u": {"D.": 1.40},
    "A-2a-u":{"D.": 1.25, "L.": 1.50, "Ls": 1.50},
    "A-2b-u":{"D.": 1.25, "L.": 1.50, "Ls": 1.50, "S.": 1.00},
    "A-2c-u":{"D.": 1.25, "S.": 1.50, "W.": 0.40},
    "A-3a-u":{"D.": 1.25, "S.": 1.50}
  }
}

Algorithmus zur Erzeugung von Lastkombinationen

Der Algorithmus durchläuft mehrere Schritte, um das endgültige Lastkombinationsobjekt zu generieren:

• Mit der Schema wie oben definiert ist erforderlich. Es wird an die Hauptfunktion zur Lastkombinationsgenerierung übergeben.
• Es wird ein Objekt erstellt, um die Anzahl zu gruppieren Ladehüllen durch Muster. Ein Träger, let’s look into a request for the load cases below:

2 Dead load case, with a merge pattern
4 Wind load cases, with an individual pattern
1 Snow load cases, with an individual pattern
2 Dead load cases, with a merge pattern

Grouping the Muster durch Lastfall will give the following object, which will be passed to the main load combination generation function.

input_by_case = 
  {
    "D.": {"verschmelzen": [2, 2], "Person": []},
    "W.": {"verschmelzen": [], "Person": [4]},
    "S.": {"verschmelzen": [], "Person": [1]}
  }

• The last two arguments are filtering objects, which allow for filtering by criteria or by schema key.
• Once it has all of the required arguments, the main load combination generation function is called. Diese Funktion durchläuft mehrere verschachtelte Schleifen, um jede erforderliche Kombination zu generieren, die in den folgenden Aufzählungspunkten erläutert werden, und in der folgenden Abbildung dargestellt.
  • Auf höchstem Niveau, Es durchläuft die Schemazeilen. In diesem Schritt wird jede Zeile daraufhin überprüft, ob sie beibehalten oder übersprungen werden soll, unter Verwendung der Filterobjekte und der spezifischen Logik, die im folgenden Abschnitt beschrieben werden.
  • In der ersten Schleife ist eine zweite verschachtelt, die jede angeforderte Schleife durchläuft Lastfall in der Schemazeile. Wenn gewünscht Lastfall existiert auch die Schemazeile (Anfragen werden im input_by_case-Objekt zusammengefasst), Dann gehen wir zum nächsten Level über.
  • In der zweiten Schleife ist eine dritte eingebettet, die alle möglichen Schleifen durchläuft Muster um zu sehen, ob darin Lastgruppen generiert werden können, und führt die Funktion aus, um sie zu benennen und zu generieren, wenn sie dies tun.
  • Sobald alle Lastfälle in der Schemazeile generiert und benannt wurden, sie werden neu kombiniert (neben ihren Koeffizienten) in eine oder mehrere Lastkombinationen aufgeteilt werden.

• Dieser Vorgang wird für jede Zeile des Schemas wiederholt, pushing all of the generated load combinations into the final load combination object.

It is worth nothing that all of the logic related to patterns is happening while inside a single schema row. Knowing this is important to understanding the behavior of patterns. The merge pattern, beispielsweise dem, does not allow merging anything other than the load case it is assigned to. This means that you cannot:

• Merge different load cases together, like trying to merge D1 and L1 load groups.
• Merge identical load cases on different rows of the input table. Ein Träger, in the example given in point #2 über, we are asked to generate 2 dead loads using the merge pattern on two separate rows. The end result combinations would then look like to something like this:

1.2*D1 + 1.2*D2 + 1.5*L.
1.2*D3 + 1.2*D4 + 1.5*L.
1.2*D1 + 1.2*D2 + 1.5*L. + 0.5*S.
1.2*D3 + 1.2*D4 + 1.5*L. + 0.5*S.
1.2*D1 + 1.2*D2 + 1.5*L. + 0.5*W.
1.2*D3 + 1.2*D4 + 1.5*L. + 0.5*T.

Auto filtering unnecessary load combinations

While the above algorithm is functional without any filtering, it can lead to redundant load combinations, which leads to extra computing time and redundant results. Take the following load combinations:

1.2*D. + 1.5*L
1,2*D + 1.5*L. + 0.5*S
1,2*D + 1.5*L. + 0.5*W
1,2*D + 1.5*L. + 0.5*T.

Wenn wir einen einzelnen Totlastfall haben, Diese vier Lastkombinationen führen zu identischen Lastkombinationen:

1.2*D
1,2*D
1,2*D
1,2*D

Um diese Situation zu vermeiden, Es werden vier Regeln verwendet, die jeweils einige geringfügige Ausnahmen enthalten. Zuerst, Werfen wir einen Blick auf die Regeln. Der Standardstatus besteht darin, dass die Kombination beibehalten wird und anhand der Regeln bestimmt wird, welche ausgeschlossen werden sollen.

Filtern nach Kriterien

This case is pretty self-explanatory. Wenn die criteria wird nicht verlangt, alle damit verbundenen Schemazeilen criteria werden verworfen.

Filtern nach Zeichen im Schemaschlüssel

Schema keys are usually comma separated pointers to the original reference. Ein Träger, in the NBCC example below, the key has three components:

• Ein: The first term is usually the main reference, reference the table in which this part of the loads are taken.
• 2b: The second term is usually a unique identifier for the load combination inside the table.
• u: The third term is usually reserved to indicate when a large number of load combinations are permuted with a slight modification. Ein Träger, Es kann anzeigen, ob die Eigenlasten in der Lastkombination günstig sind ( f ) oder ungünstig ( u ).

{
  "Stärke":{
    "A-2b-u":{"D.": 1.25, "L.": 1.50, "Ls": 1.50, "S.": 1.00},
  }
}

Für jeden dieser Begriffe kann eine Filterung im Schemaschlüssel durchgeführt werden. Ein Träger, if we want to filter by the third term, Wir können den folgenden Filter hinzufügen, Dadurch wird ein Filter-Dropdown-Menü für diesen Begriff erstellt:

"name_filters": {
  "Stärke": {
    "Eigengewicht": {
      "Position": 2,
      "Tooltip": "",
      "Artikel": {
        "Günstig": "f",
        "Ungünstig": "u"
      },
      "Standardwerte": ["Günstig", "Ungünstig"]
    }
  }
}

Alle möglichen Dropdown-Namen und zugehörigen Begriffe müssen unter „Artikel“ aufgeführt sein.. Es bleiben nur die Schemazeilen mit übereinstimmenden Symbolen erhalten. If it is required to keep a schema row independently of what is entered in the filter, the term can be left blank. Any schema key that does not contain all of the matching dropdown terms will be discarded.

Redundant combinations

If a schema row is not filtered out by the first two steps, it moves on to step number three. In diesem Schritt, the redundancy issue from the above example is addressed. Um dies zu tun, we need to look at two objects simultaneously, schema row and the sorted input_by_case object (see description above), which describes which load cases have been requested. If the schema row contains any super case which the input_by_case object does not, the load combination is removed. Take, beispielsweise dem, the following schema row:

"A-2a-u":{"D.": 1.25, "L.": 1.50, "S.": 1.50}

and the following input_by_case object:

input_by_case = 
{
  "D.": {"verschmelzen": [], "Person": [1]},
  "L.": {"verschmelzen": [], "Person": [4]}
}

In diesem Beispiel, the schema row contains a super case S which has not been requested. Keeping this row would lead to a load combination that would be identical to the load combination associated with the schema row below, so it is removed.

"A-1a-u":{"D.": 1.25, "L.": 1.50}

Exceptions

While this behavior is usually desirable, Es gibt Fälle, in denen das NICHT-Löschen einer Zeile bei fehlendem Lastfall zu einem viel einfacheren Schema führt. Ein Träger, Wenn wir horizontale Erdlasten haben, sollten diese zu jeder Schemakombination hinzugefügt werden, sind aber nicht immer vorhanden, Wir könnten alle Lastkombinationen kopieren und einfügen und den Schemaschlüssel für die neuen Zeilen mit einem Suffix wie „h“ für horizontale Erdlasten ändern. Alternative, Wir können einfach die horizontale Erdlast zu allen Fällen hinzufügen und in den Metadaten eine Keep-Ausnahme zum Lastfall hinzufügen. Auf diese Weise, wenn der Lastfall nicht angefordert wird, es wird nicht angezeigt, aber die Zeile bleibt weiterhin erhalten. Das Ergebnis sieht in der Meta-Eigenschaft des Schemas in etwa so aus:

"H.": {
  "Etikett": "Seitliche Erde - Ungünstig",
  "Rang": 1,
  "Ausnahmen": ["halten"],
  "alte_Etiketten": []
},

Überflüssige Kombinationen

Wenn eine Schemazeile durch die ersten drei Schritte nicht herausgefiltert wird, Es geht weiter zu Schritt Nummer vier. In diesem Schritt, das Problem, bestimmte Lastfälle zwischen dem Schema und den Anforderungen abzugleichen. Wenn eine Schemazeile und eine Anfrage übereinstimmende Superfälle haben, aber der konkret angeforderte Lastfall ist nicht im Schema enthalten, Die Zeile wird nicht beibehalten. Take, beispielsweise dem, the following schema row:

"A-2a-u":{"D.": 1.25, "Sl": 1.50}

und das folgende input_by_case:

input_by_case = 
{
  "D.": {"verschmelzen": [], "Person": [1]},
  "Sh": {"verschmelzen": [], "Person": [1]}
}

In diesem Beispiel, Sowohl die Schemazeile als auch die Anfrage haben übereinstimmende Superfälle. Jedoch, Die Anfrage erfordert eine Kombination mit Sh, was die Schemazeile nicht bereitstellt. So, Die Schemazeile wird nicht beibehalten.

Exceptions

Noch einmal, Dieses Verhalten ist normalerweise wünschenswert, kann aber zu Problemen führen. Ein solches Problem besteht darin, dass Standards Lastfälle haben, die einen Superfall gemeinsam haben, aber nicht gleichzeitig handeln. Ein Träger, in ASCE, Die Windlasten W und die Tornadolasten Wt wirken nicht gleichzeitig, obwohl sie den gleichen Superfall W haben. When we run into this problem, we can add an exception to switch to another super case before the code runs in the meta data. Hinter den Kulissen, the symbol following the “->” characters will be attributed to the load case, which will simulate the load cases acting in that super case. Das Ergebnis sieht in der Meta-Eigenschaft des Schemas in etwa so aus:

"Wt" : {
  "Etikett": "Wind - Tornado",
  "Rang": 8,
  "Ausnahmen": ["supercase->X."],
  "alte_Etiketten": []
},

In the case above, bleibt die super case “W.” will be swapped to “X.” before the code runs. This feature can also be used to send group load cases that have unique super case symbols together.