I am working on a parametric design model for timber-concrete composite (TCC) slabs with notch connector verification in Grasshopper/Karamba.
Background – Design procedure:
According to DIN CEN/TS 19103, the verification of TCC systems requires internal forces from two different system states to be superimposed:
t = 0 (short-term behaviour): Calculation using full (unreduced) stiffnesses
t = ∞ (long-term behaviour): Calculation using creep-reduced stiffnesses (e.g. E·A, E·I of the composite cross-section components reduced accordingly)
For ULS and SLS verifications, the design internal forces are obtained by combining the results of individual load cases from both system states. A typical result combination looks like this:
E = 0.35 · [Self-weight concrete | t=0] + 1.0 · [Self-weight concrete | t=∞] + … (eg. LK5100 in my attached gh. file)
Since identical load cases applied to the t=0 and t=∞ systems yield different internal forces due to the differing stiffnesses, the results from both systems must be superimposed with load-case-specific factors.
My question:
Is it possible in Karamba to superimpose internal forces from two separate analysis models (same geometry and loads, but different stiffnesses) with load-case-specific factors to form a result combination? The Karamba Version i am working with is Version 2.2.0.180-230616. Maybe a newer version provides a component that would solve this issue?
Any hints or experience with this would be greatly appreciated.
at the moment (Karamba3D 3.1.6xxxx) it is not possible to combine the results of of two separate analysis models in a load case combination.
We plan to have modifiers for material properties (see here) in the next mayor release.
thank you for the quick reply! Good to know that material modifiers are planned for the next major release – that would solve the problem elegantly.
In the meantime, I was thinking about a manual workaround: would it be possible to extract the internal forces (e.g. bending moments My, shear forces Vz, normal forces N) from two separate Karamba models as lists, and then simply superimpose them element-by-element in GHPython – applying the respective combination factors – to obtain the design internal forces?
My idea would be something like:
Run model t=0 → extract internal force lists per load case
Run model t=∞ (same geometry, creep-reduced stiffnesses) → extract internal force lists per load case
In GHPython: E_d = factor_1 · N_t0[i] + factor_2 · N_tinf[i] for each position i
Is there a recommended way to extract internal forces as clean numerical lists from a Karamba model – e.g. via the “Beam Forces” component or through scripting? And are the result lists always in the same order across two independently assembled models with identical geometry, so that element-by-element addition is reliable?
/// <summary>
/// retrieve section forces along all elements which are active and of linear type.
/// </summary>
/// <param name="model">model with calculated displacements.</param>
/// <param name="elementsIDs">list of identifiers of elements for which to retrieve results.</param>
/// <param name="elementsGUIDs">list of guids of elements for which to retrieve results.</param>
/// <param name="resultSelection">name of load-case for which to retrieve results.</param>
/// <param name="ts">Parameter values (0 smaller than t smaller than 1) where to retrieve results along the beam.</param>
/// <param name="forces">translational forces: list-structure: element, position, state min/max.</param>
/// <param name="moments">rotational displacements: list-structure: element, position, state min/max.</param>
/// <param name="governingLoadCases">list of governing load cases.</param>
/// <param name="governingLoadCaseInds">list of governing load case indexes.</param>
/// <param name="elementInds">list of element indexes for which results are returned.</param>
public static void solve(
Model model,
List<string> elementsIDs,
List<Guid> elementsGUIDs,
string resultSelection,
List<double> ts,
out List<List<List<Vector3>>> forces,
out List<List<List<Vector3>>> moments,
out List<List<List<LoadCase>>> governingLoadCases,
out List<List<List<int>>> governingLoadCaseInds,
out List<int?> elementInds)
{
The order within th model should be stable for identical geometry. You should do a model disassemble - assemble step to be sure.
