# Welcome to Karamba3D The official guide to using Karamba3D 2.2.0 Karamba3D is an interactive, parametric engineering tool that allows you to perform quick and accurate Finite Element Analysis (FEA). It has been specially tailored to the needs of design professionals in the early design phases. Karamba3D is embedded in the parametric environment of Grasshopper in the 3d modelling program Rhino3D. This makes it easy to combine parameterized geometric models, Finite Element calculations and optimization algorithms like Galapagos, Octopus, Wallacei and many more. Karamba3D can also be used as a standalone .NET library for integrating Finite Element functionality into your scripts. Navigate through the following chapters below or in the menu on the left. This 2.2.0 manual is currently available in English. The Chinese manual is available for version 1.3.3. The Japanese manual (1.0.5) can be downloaded from our [website](https://karamba3d.com/resources/). ## Citing Karamba3D In case you use Karamba3D for your scientific work, please cite the following paper: > Preisinger, C. (2013), *Linking Structure and Parametric Geometry*. Architectural Design, 83: 110-113\ > DOI: 10.1002/ad.1564. ## Disclaimer Although being tested thoroughly Karamba3D probably contains errors – therefore no guarantee can be given that Karamba3D computes correct results. Use of Karamba3D is entirely at your own risk. Please read the [license agreement](https://karamba3d.com/license-agreement/) that comes with Karamba3D in case of further questions. This manual is written by Clemens Preisinger.\ Editing by Georg Lobe & Matthew Tam.\ Chinese translation by Lei Feng. # New in Karamba3D 2.2.0 {% embed url="" %} These are the new features of Karamba3D 2.2.0 * **"ShellSection"**-component for retrieving cross section forces and other results along arbitrary sections of shells (see section [3.6.15](/3-in-depth-component-reference/3.6-results/3.6.15-shell-sections)). * Additional types of loads for beam- and truss-elements (see section [3.2.2](/3-in-depth-component-reference/3.2-load/3.2.2-beam-loads)). The **"Imperfection"**- and "**Line-Load"**-option of the **"Loads"**-component were moved to the **"Beam Loads"**-component. The latter are now available as the more flexible **"Block"**-loads. * Line joints for shells (see section [3.4.3](/3-in-depth-component-reference/3.4-joint/3.4.3-line-joint)). * **"Cross Section Properties"**-component for calculating geometric properties of arbitrary cross sections (see section [3.9.17](/3-in-depth-component-reference/3.8-utilities/3.9.17-cross-section-properties)). * Membrane elements (see section [3.1.9](/3-in-depth-component-reference/3.1-model/3.1.9-mesh-to-shell#shells-and-membranes)) * A refined element selection component for retrieving elements via their identifier, color, cross section, material, characteristic length or type (see section [3.1.16](/3-in-depth-component-reference/3.1-model/3.1.16-select-elements)). * On-the-fly installation via YAK (see section [1.1](/1-introduction/a.2-installation#installation-via-the-yak-package-manager)) * Automatic generation of value-lists for several components (e.g. load-case input, degree of freedoms for input at supports,...). See section [2.1](/2-getting-started/2-getting-started-1/karamba3d-entities#graphical-user-interface). * Specification of color ranges via context-menu for the **"ModelView"**-, **"BeamView"**- and **"ShellView"**-components. * Rendering beams and shells with cross sections results in watertight meshes with normal vectors pointing outward. * Different types of strength hypotheses for bi-axial stress states and differentiation between tensile and compressive strength available for materials (see section [3.5.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). * The material database has been enlarged (see section [3.5.3](/3-in-depth-component-reference/3.4-material/3.4.3-read-material-table-from-file)). * Physical units of calculation and input quantities can be freely specified (see section [2.3](/2-getting-started/2-getting-started-1/2.3-physical-units#non-default-physical-units)). * **"Settings"**-component to update program options within Grasshopper (see section [3.0.1](/3-in-depth-component-reference/3.0-settings/3.0.1-settings)). * **"Optimize Cross Section"**-component (see section [3.6.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section)) * Cross section design according to Eurocode3: 'SwayFrame'-option added for more economic design of structures where buckling involves no sideways sway. * Input 'MaxDisp' can be supplied with a vector for specifying the length and direction component for limiting displacements. * **"ModelView"**-component: Input-plug 'DispDir' lets one specify a direction for selecting displacement-components to be displayed. When supplying a plane, displacements get projected onto it. See section [3.7.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview). * **"ShellLineResults"**-component: added display-option 'TransverseShear' for generating principal shear lines. See section [3.7.13](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells#transverse-shear). * Added 'Dofs' input-plug to **"PrescribedDisplacements"**- and **"Support"**-component.See sections [3.2.4](/3-in-depth-component-reference/3.2-load/3.2.3-prescribed-displacements) and [3.1.16](/3-in-depth-component-reference/3.1-model/3.1.16-support) respectively. * **"Shell View"**: Added cross section rendering without colors. See section [3.7.12](/3-in-depth-component-reference/3.6-results/3.6.11-shellview). * Load-cases identifiers: Names can be used instead of numbers. * **"JointAgent"**-component: the given criteria for joint placement are combined via 'and' instead of 'or'. See section [3.4.2](/3-in-depth-component-reference/3.4-joint/3.3.5-beam-joint-agent). * **"LineToBeam"**-component: it is now possible to input poly-lines and splines and derive the buckling length from these; multiple names can be given to beams. See section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam). * Import and export of models via Json or Bson (see section [3.8.2](/3-in-depth-component-reference/3.7-export/3.8.2-json-bson-export-and-import)) * The **"Element Query"**-component can now be used to get the mass, surface, volume or meshes of specified elements (see section [3.7.3](/3-in-depth-component-reference/3.6-results/3.7.3-element-query)). * **"Node Forces"**-component: Retrieves the truss or beam elements, their cross section forces and directions around a node (see section [3.7.11](/3-in-depth-component-reference/3.6-results/3.6.10-resultant-section-forces)). * In all result-components where formerly only element-identifiers could be input to specify elements for which to get results, the elements themselves can now be used. * **"Nodal Displacements"**- and **"Support"**-component: node-index or position can now be used to specify the node where to get results. See sections [3.7.4](/3-in-depth-component-reference/3.6-results/3.6.3-nodal-displacements) and [3.7.6](/3-in-depth-component-reference/3.6-results/3.6.5-reaction-forces). * **"Beam Displacements"**- and **"Beam Forces"**-component: The position of results along the beam can now be selected via parameter values. See sections [3.7.9](/3-in-depth-component-reference/3.6-results/3.6.8-beam-displacements) and [3.7.10](/3-in-depth-component-reference/3.6-results/3.6.9-beam-forces). * Scripting: It is now possible to attach user-data to all Karamba3D objects. See the example 'Karamba\Examples\TestExamples\Scripts\UserData.gh' in the Karamba3D installation folder. * Point-masses: The point-masses no longer enter the total mass as output by the **"Assemble"**-component. In this way it is easier to assess the mass of the structure. # 1.1 Installation These are the prerequisites for installing Karamba3D: * Rhino 6.0 (PC only), Rhino 7.0 or Rhino 8.0. * Grasshopper (version 2.2.0 of Karamba3D was tested on GH 1.0.0007) * Windows 10 or above / macOS 12 or above In case you do not have a [Rhino ](https://www.rhino3d.com/)license, download a fully featured, free trial version. Grasshopper is already integrated in Rhino. ## Installation via Installer Program (Windows) {% embed url="" %} [Download ](https://www.karamba3d.com/download/)one of the installers and double-click on the msi-file. The installation procedure lets you set the physical units used for calculation. By default Karamba3D assumes input to be in SI units (e.g. meters for point coordinates). You can switch to Imperial units either on installation or later on by editing the [“karamba.ini”](/troubleshooting/4.3.-miscellaneous-problems/4.1.6-changing-karamba.ini-file) file. Coordinates will then be interpreted to be in “feet”, force in “kips”, material strength in “ksi” and so on. {% hint style="info" %} Make sure to install the FULL version of Karamba3D if you wish to activate a PRO or EDU license at a later stage. {% endhint %} ![](/files/-MCkEXFfiEoifgWcPZwk) Upon successful installation you should see a Karamba3D tab when you open Grasshopper in Rhino. Additionally, as a default setting a shortcut to the installation folder will be placed on your desktop. Double-click on the Karamba3D desktop-icon will get you to the standard installation directory which is in the Plug-ins-folder of your Rhino installation directory. If Karamba3D does not show up, please refer to our [troubleshooting ](/troubleshooting/4.3.-miscellaneous-problems/4.3.1-installation-issues-1)guide. Karamba3D license can be activated as cloud or network licenses. Standalone licenses are only valid for workshops or universities. {% content-ref url="/pages/-MCkEPscNP\_GouaetMDP" %} [1.2.1 Cloud Licenses](/1-introduction/1.2-licenses/1.2.1-cloud-licenses) {% endcontent-ref %} {% content-ref url="/pages/-MCkEPsZl8HXNZYXsaNn" %} [1.2.4 Standalone Licenses](/1-introduction/1.2-licenses/1.2.4-standalone-licenses) {% endcontent-ref %} {% content-ref url="/pages/-MCkEPs\_LeHTa5tYcR3h" %} [1.2.2 Network Licenses](/1-introduction/1.2-licenses/1.2.2-network-licenses) {% endcontent-ref %} ## Installation via the YAK Package Manager (Windows & Mac) {% hint style="danger" %} Karamba3D can only be installed once - either with the installer file or with the PackageManager. Otherwise an [error message ](/troubleshooting/4.3.-miscellaneous-problems/4.3.1-installation-issues-1)will pop up. {% endhint %} {% embed url="" %} YAK is the Package Manager for Rhino. It can automatically download and install plug-ins required for a specific Grasshopper definition. Thus one possibility of installing Karamba3D is to open a GH definition with some Karamba3D components in it. Alternatively the package manager can be started in Rhino by typing 'PackageManager' in the command window. Make sure to activate 'Include pre-releases' in the window that pops-up. Under YAK Karamba3D comes as 'karambaGH' which installs the FULL version of Karamba3D.
The Package Manager installs Karamba3D under Windows to the folder ...\Users\\**YourUserName**\AppData\Roaming\McNeel\Rhinoceros\packages\7.0 - which is different from where it is placed by the msi-installer. When starting Grasshopper for the first time after a YAK-installation of Karamba3D, a window with copyright notice and terms and conditions will appear. Copyright notice and license agreement can be found on Windows under C:\ProgramData\Karamba3D\\. {% hint style="info" %} The path to Karamba3D depends on whether installation was done via the msi-installer or YAK. This means that scripts which make use of the Karamba3D API may be broken. In case of GH C# scripting components one needs to adapt the path via "Manage Assemblies..." in the components context menu. {% endhint %} {% hint style="warning" %} To run Karamba3D in Rhino8 for Mac, make sure to enable [Rosetta](/troubleshooting/4.3.-miscellaneous-problems/4.3.1-installation-issues-1). {% endhint %} ## Rhino6 and Rhino7 and Rhino8 in parallel You can install both the Rhino 6 and Rhino7 versions simultaneously. Simply run the installers one after the other. ## Silent Installation In order to install Karamba3D on remote machines “msiexec.exe” provides options to circumvent the graphical user-interface of the installer. Start the Windows CommandPrompt, navigate to where the Karamba3D-installer lies and type e.g. msiexec.exe /i karamba3d\_2\_0\_0\_RH6.msi /passive ADDLOCAL=DLLs,LicensePlugin,FullFeatures,SIUnits,LicensePublicKey,Tables,Examples in one line to install the full version of Karamba3D (“FullFeatures”) with SI-Units (“SIUnits”), cross section and material tables (“Tables”) and the example definitions (“Examples”). In order to get the free version and Imperial units substitute “FullFeatures” with “FreeFeatures” and “SIUnits” with “IMPUnits”. The static license can be supplied without graphical user interface (GUI) by renaming the license-file to “licensePRO.lic” and copying it to the “License”-folder under ...\Rhino\Plug-ins\Karamba. ## **Automate installation** The following files and folder will be copied to your machine during installation: * “karamba.dll” and “libiomp5md.dll” to C:\Windows. * “karambaCommon.dll”, “karamba.gha” and the Karamba-folder to the “Plug-ins”-folder of Rhino. The Karamba3D-folder contains material- and cross section libraries, examples, the karamba.ini- file and the license-folder. This is typically *C:\Program Files\Rhinoceros 6\Plug-ins* or *C:\Program Files\Rhino 6\Plug-ins.* * If not already present the C++ runtime libraries of Visual Studio 2019 will be copied to your machine. Karamba3D is installed for all users by default. In order to get Karamba3D running without the installer simply copy the above files and the Karamba3D-folder from one machine to the next.\ Unless deselected, the installer places a Karamba3D-icon on the desktop. Double-click on it to open the Karamba3D-folder. # 1.2 Licenses Besides the free and full version for non-commercial use only, there exists also a pro-version of Karamba3D for commercial use. The table below lists their main features. {% hint style="info" %} Those parts of this manual that apply to the Full or Pro versions only, are marked with a 🔷 icon. {% endhint %} | Karamba3d Version | Beam Elements | Shell Elements | Other Features | | ----------------- | ------------- | -------------- | -------------- | | Free | unlimited | unlimited | limited | | Full 🔷 | ≤ 20 | ≤ 50 | unlimited | | PRO 🔷 | unlimited | unlimited | unlimited | | EDU/LAB 🔷 | unlimited | unlimited | unlimited | PRO, EDU & LAB licenses can be purchased from our[ website](https://www.karamba3d.com/buy). Further information can be found on [features ](https://www.karamba3d.com/buy/buy-online/)& [license agreement](https://www.karamba3d.com/buy/license-agreement/). ## Activating Licenses Licenses can be installed as: 1. [Cloud licenses](/1-introduction/1.2-licenses/1.2.1-cloud-licenses): these require a Cloud Zoo account and allows you to use them from any device and/or share them with team members. Find out more on [Cloud Zoo Licenses](https://wiki.mcneel.com/rhino_accounts/home) on McNeel. 2. [Network licenses](/1-introduction/1.2-licenses/1.2.2-network-licenses) (PRO or LAB users only): also known as LAN Zoo; keeps your licenses on your private LAN server and lets you share them among the Rhino users on your network. Find out more on [LAN Licenses](https://wiki.mcneel.com/zoo/home) on McNeel. # 1.2.1 Cloud Licenses Guide to running Karamba3D with a cloud license. Find out more on [Cloud Zoo Licenses](https://wiki.mcneel.com/rhino_accounts/home) on McNeel. {% hint style="info" %} If you are looking to upgrade an existing standalone or network to the cloud, please email us at . {% endhint %} ## **Installation** ### 1. Load License Make sure you have Karamba3D for Rhino6 or above [installed](/1-introduction/a.2-installation#standard-installation). Type "**Karamba3DGetLicense"** in the Command line ![](/files/-MCkERwzK9x0C9MI88Kq) ### 2. Login into your Rhino3D account Login to your account at Rhino3D account. Cloud licenses are available on McNeel's [Cloud Zoo Licensing](https://www.rhino3d.com/en/6/new/licensing-and-administration#cloud-zoo) platform. Create an [account ](https://accounts.rhino3d.com/help)if you have not already done so. ![](/files/-MCkERx-G-beDOda58Ar) ### 3. Fetch license Karamba3D will try to fetch the license from the cloud. ![](/files/-MCkERx0DlKLAcaMXVML) If this it the first time installing a license, there will be no license found. Click **Add a License** to add your license. ![](/files/-MCkERx1nSaLLNcx0sdg) ### 4. Add License ![](/files/-MCkERx2-W74NnHNwh4R) * use Personal Licenses if installing an individual license for personal use * use [Team Licenses](/1-introduction/1.2-licenses/1.2.1-cloud-licenses#create-a-team) if installing for a company or institution. Team licenses can be shared amongst any group of people. ### 5. Enter the License Key You will have received an email with the license key. ![](/files/-MCkERx3icNNRIrW0f8w) ### 6. Check License Details Click on **View License Details** to see information about the license. It will display the type of license, the number of seats and the expiration date of the license. ![](/files/-MCkERx4xNvKMOCFJYl8) ### 7. Add License Click **Add License** and the license should be added to your account. ![](/files/-MCkERx5Flva-3othU01) ### 8. Check License Click on the license to check the status of the license ![](/files/-MCkERx6Xr6KVgRBcqDN) ### 10. Fetch License Go back to Rhino3d and click **Try Again** in the Licensing Window ![](/files/-MCkERx7lY80S2cFfl7p) ### 11. License Loaded The license will load and upon successful activation, the license information will be displayed in the Command Line ![](/files/-MCkERx8FQnv0AeQHBN3) ### **12. Check License Status** Open Grasshopper and place the **"License"**-component onto the grasshopper canvas and connect a panel to it. The panel displays the status and expiration of the license. ![](/files/-MCkEQkuRI0lbWN_RIOS) ### 13. Load License upon Startup The license has been successfully installed. Every time you open Rhino, you need to type **Karamba3DGetLicense** to load the license each time. This needs to be done before opening Grasshopper. ### 14. Automate License Load The Karamba3D license can simply be loaded by typing "**Karamba3DGetLicense"** each time Rhino loads, but this process can be automated in the **Tools/Options -> Rhino Options/General**.. Type "**Karamba3DGetLicense"** into the **Command Lists** textbox. The license will then be automatically loaded upon opening Rhino. ![](/files/-MCkERx90gf0DG-JAlmo) {% hint style="danger" %} Make sure to run the "**Karamba3DGetLicense"** command before opening Grasshopper otherwise the license will not be activated. {% endhint %} ## Releasing the License When pulling the license from the cloud for the first time, Rhino temporarily holds the license for a few days for offline use. You can manually release the license by logging out of your Rhino account. This will also release your Rhino license. {% hint style="info" %} To release the license, you will need to logout of your account by typing **"logout"**. {% endhint %} ## **Check License** Restart Rhino and your license should run. Upon successful installation of the license you should be able to open example files which have more than 20 beam elements or 50 shell elements. Double check if the license and correct Karamba3D version are installed by opening the below definition: {% file src="/files/7U2R5VBKiFSPPsTQGtNr" %} ![](/files/-MCkEQkvnBVKGa5rqCcS) ## Account administration ### Account Settings You can log into your [Rhino ](https://accounts.rhino3d.com/?controller=home)account to administer licenses and set up teams. ### Create a Team If you intend to share licenses with a other users, make sure to create a [Team ](https://accounts.rhino3d.com/?controller=groups)and add the licenses to the team. Read more on [McNeel](https://wiki.mcneel.com/rhino_accounts/create_team). ### License Management You can check the [licenses ](https://www.rhino3d.com/licenses?controller=home&_forceEmpty=true)installed on your personal or team accounts. All licenses can be administered here and live-usage can be checked. ### Add licenses You can add licenses by logging into your cloud account and proceed to the [Add Licenses](https://www.rhino3d.com/licenses/?controller=add_licenses) page. Read more on [McNeel](https://wiki.mcneel.com/rhino_accounts/add_licenses). # 1.2.2 Network Licenses Guide to running Karamba3D with a network license (PRO or LAB users only); also known as LAN Zoo. A network license can only be installed with the **McNeel Zoo 6 (or 7) License** network server (only for Rhino7 or Rhino6). Find out more on [LAN Licenses](https://wiki.mcneel.com/zoo/home) on McNeel. {% hint style="info" %} If you are updating an existing network license, simply skip to the [Upgrade ](#updatelicense)section. {% endhint %} {% hint style="info" %} For network licenses generated before 18/05/2020 please refer to this [guide](https://manual-1-3.karamba3d.com/1-introduction/1.2-licenses/1.2.2-network-licenses/1.2.2.1-network-license-archived). {% endhint %} ## **Installation on Server End** ### **1. Unblock License Package** Make sure you have Karamba3D [installed](/1-introduction/a.2-installation#standard-installation) and [Zoo6 (or above) ](https://wiki.mcneel.com/zoo/home)License Administrator installed. You will have received a license package upon purchasing the license. Make sure to **unblock** the license package before unpacking it. Right click on the file in Windows Explorer and go to **Properties**. If the file is blocked, there will be an option to **‘Unblock’** the file at the bottom of the Properties Window. You may need to adjust your Administrator or Security settings to be able to unblock the file. ![](/files/-MCkEaQnz31ABEMBZZss) ### **2. Unzip License Package** Unzip the contents of the network license package. It should contain the following files: * *ActivationKey.txt* * Karamba3D\_LicensePlugin\_Zoo6.dll * *README.txt* * *XXX\_License.lic* ![](/files/-MCkEaQpgoVXzeL6mOaw) ### **3. Zoo Administrator** Open the Zoo Administrator. You will need administrator rights to perform this installation. The Zoo Administrator needs to be first stopped before installing the license. Make sure you do not have any existing Kamba3D licenses installed (If you are updating an existing license see [below](/1-introduction/1.2-licenses/1.2.2-network-licenses#remove-existing-licenses)). Click on the **Stop** Icon. ![](/files/-MCkEaQs7GacAz1r6z8t) #### Remove Existing Licenses {% hint style="info" %} If you are updating an existing network license. {% endhint %} Select the Karamba3D license from the list of network licenses. Click the **Delete License** Icon. Make sure all users are not currently using the license otherwise you will not be able to remove them. ![](/files/-MCkEaQuuQRjhtJRJ4UJ) ### **4. Move License Files** Copy the **"Karamba3D\_LicensePlugin\_Zoo6.dll*****"*** *\*\*\_into \_C:\Program Files (x86)\Zoo 6\Plugins* folder.\ This can also be *C:\Program Files (x86)\Zoo 6.0\Plugins* folder. ![](/files/-MCkEaQv-oWfLCeDcWAM) ### **5. Start Zoo Service** Start the Zoo Service in the Zoo Administrator. Click on the **Start** Icon. ![](/files/-MCkEaQwXc4TO8dWi5I2) ### **6. Add License** Click on the **Add Product** **Icon** or select **Add** from the **Edit Menu**. ![](/files/-MCkEaQxSsQXgYSximgm) ### **7. Enter License Key** A window will pop up where you can select *"**Karamba3D\_ZooLicense"*** from the **Product type**. Enter your personal details for Registered owner and organisation. Both entries need to be filled in. The **Product license code** or **CD key** can be found in the **ActivationKey.txt** located in the ZIP package. This should be a **12 digit** code. Click **Add** and the license should now be loaded. ![](/files/-MCkEaQy_ikj2L7enRxi) If the "**Karamba\_ZooLicense"** is not listed in the dropdown menu, close and reopen the Zoo Administrator and check if the file is located in the correct folder. Make sure the Zoo License Server is updated. ### 8. License Loaded The license will be added and you will see the Karamba3D licenses in the list of Products. ![](/files/-MCkEaR0o09Ajz5zPtDQ) ### 9. Check License Status Double click on the license to check the license status. ![](/files/-MCkEaR2n5UGHIsHzdTk) ## Installation on Client End (User) After the license has been installed on the server, you need to install the license file for each user: ### 1. Run Rhino as Administrator Right click and select ***‘Run as Administrator’***. You will need to have administrator rights on your computer. ![](/files/-MCkEaR8Mf-RUkhMGENE) ### **2. Load Grasshopper** Type **"Grasshopper"** in the Command Line to load Grasshopper. ![](/files/-MCkEaR9maaPbg1hpz_3) ### **3. Locate License Component** Place (drag and drop) the **"License"**-component on the grasshopper canvas. This can be found in the Karamba3D tab. ![](/files/-MCkEZNbUIVzzILKXJ-F) ### **4. Load License** Right click on the red “**K**” icon or the **"License"** label. Select **"Load license file"** from the menu. ![](/files/-MCkEZNglWTbOQq4p6by) ### **5. Locate the License File** Locate the ***"XXX\_License.lic"*** that you received in the license package. Click **"Open"** to load the license. ![](/files/-MCkEZNhz4MPMls-Pk9z) ### **6. Load License** The license should be successfully copied. If the license does not load successfully, make sure that you have [unblocked ](/1-introduction/1.2-licenses/1.2.2-network-licenses#1-unblock-license-package)the files as well as opened Rhino as [administrator](/1-introduction/1.2-licenses/1.2.2-network-licenses#1-run-rhino-as-administrator). ![](/files/-MCkEZNiFFHAQCN0HUBf) ### **7. Restart Rhino** Close Rhino and Grasshopper and open Rhino once more, this time in standard mode. ### 8. Fetch the license Type "**Karamba3DGetLicense"** in the Command line ![](/files/-MCkERwzK9x0C9MI88Kq) ### 9. Load Zoo License A window should pop up. Select **"Use the Zoo"**. ![](/files/-MCkEaRCEb-E4m0e0oHj) ### 10. Locate Zoo Server Try to Detect the Zoo automatically. Often, you will need to enter the network name manually. Once the network has been found, click **Continue**. ![](/files/-MCkEaRD1vv5QxcyKDrS) ### 11. License Loaded The license will load from the zoo and the license information will be displayed in the Command Line. ![](/files/-MCkEaREjBAYa2uk2rab) ### **12. Check License Status** Open Grasshopper and place the **"License"**-component onto the canvas and connect a panel to it. The panel displays the status and expiration of the license. ![](/files/-MCkEaRFrdA11f1dLWxd) ### **13. Automate License Load** The Karamba3D license can simply be loaded by typing "**Karamba3DGetLicense"** each time Rhino loads, but this process can be automated in the **Tools/Options -> Rhino Options/General**. Type "**Karamba3DGetLicense"** into the **Command Lists** textbox. The license will then be automatically loaded upon opening Rhino. ![](/files/-MCkEaRGlMaLMFlHdlHN) {% hint style="success" %} Congratulations, the license has been successfully installed and you are free to use the full features of Karamba3D! {% endhint %} {% hint style="info" %} Make sure to run the "**Karamba3DGetLicense"** command opening Grasshopper. {% endhint %} ## **Check License** Upon successful installation of the license you should be able to open example files which have more than 20 beam elements or 50 shell elements. Double check if the license and correct Karamba3D version are installed by opening the below definition: {% file src="/files/7U2R5VBKiFSPPsTQGtNr" %} ![](/files/-MCkEQkvnBVKGa5rqCcS) ## **Perform a remote installation of the Zoo network license** ### Installation on Server End 1. On a test machine, install Karamba3D. 2. Run Rhino and Karamba3D. 3. When prompted for a Karamba3D license, enter the name of your Zoo server. 4. Close Rhino. 5. Open this folder in Explorer: *%allusersprofile%\McNeel\Rhinoceros\6.0\License Manager\Licenses* 6. In this folder you should see at least two .lic files. The '*55500d41-3a41-4474-99b3-684032a4f4df.lic'* file is for Rhino 6. The other ('06bb1e79-5456-47a1-ad6d-111118cd894b.lic') should be for Karamba3D. Note, the file name will make the Id of the Karamba3D plug-in (Tools > Options > Plug-ins) 7. When using the Zoo, the license file is plain text and can be viewed from Notepad. It can also be copied from machine to machine. {% hint style="info" %} Rhino 7 licenses are stored also in the Rhino 6 folder. {% endhint %} ### Installation on Client End So in addition to pushing out the required registry key, required by the Rhino licensing system to find the Zoo, copy the Karamba3D license folder - with the file 'licensePRO.lic' in it - to each machine.\ \ This is typically *C:\Program Files\Rhino 6\Plug-ins\Karamba\License* ![](/files/-MW3VWqRaUvpJ-tp6En3) Open Rhino, use "Karamba3DGetLicense" to request a license, and when prompted, enter your server name or IP address. ## Error Message: The product ID is not correct Should you receive the following error message, check that the licensePRO.lic file has been properly installed, and that you are directing to the correct IP address. ![](/files/-MW3VZgtZBbt1G9gsQbi) # 1.2.3 Temporary Licenses {% hint style="success" %} Get a free 1 month demo license on our [website](https://www.karamba3d.com/trial-license/). {% endhint %} ## **Licensing for Workshops/Training** We always encourage the use and exchange of Karamba3D with all users. Therefore we support workshops and training programs with Karamba3D licenses. We offer 1 month licenses for such purposes. {% hint style="info" %} Please send us an [email ](mailto:license@karamba3d.com)to inquire about the free workshop licenses. {% endhint %} ## **Licensing for University Courses** We support university courses by providing teachers and students with free 6 month educational licenses for the duration of the semester. We kindly ask that all requests for university licenses be done so by the instructors or professors. {% hint style="info" %} Apply as an instructor for a free [university license](https://karamba3d.com/get-started/university/) for your course. {% endhint %} # 1.2.4 Standalone Licenses Guide to running Karamba3D with a standalone license. {% hint style="danger" %} Standalone licenses are only supported for workshops and universities. {% endhint %} {% hint style="info" %} If you have already received your license file or downloaded a trial license from our website, proceed to [Step B](#3). {% endhint %} ## A. Locate "machine.id" file ### **A1. Locate License Component** Once Karamba3D has been successfully [installed](/1-introduction/a.2-installation#standard-installation), open Rhino and load Grasshopper. Place (drag and drop) the **"License"**-component on the grasshopper canvas. This can be found in the Karamba3D tab. ![](/files/-MCkEZNbUIVzzILKXJ-F) ### **A2. Save "machine-id" File** Place the **"License"**-component on the grasshopper canvas and right click on the red “**K**” icon or the **"License"** label. Select **"Save machine-id file"** from the menu. ![](/files/-MCkEZNcExuSI8nZhn6r) Save the ***"machine-id"*** file and name it according to your name *(‘FirstnameLastname.id’*). Do not use special characters.\ Send this ***"machine-id"*** file to[ license@karamba3d.com](mailto:license@karamba3d.com). ![](/files/-MCkEZNdefqSjqzy3ZTT) ## **B. Install License File** ### **B1. Receive License File** You will receive a return email within 1 working day with a *“**XXX\_License.lic**”* -file which turns your Karamba3D TRIAL installation into ***PRO*** or ***EDU*** version. Save this license file somewhere on your computer where you can easily find it. ### **B2. Unblock License Package** Make sure to **unblock** the license before installing it. Right click on the file in Windows Explorer and go to **Properties**. If the file is blocked, there will be an option to **‘Unblock’** the file at the bottom of the Properties Window. You may need to adjust your Administrator or Security settings to be able to unblock the file. ![](/files/-MCkEZNe2e1rt_Wz-yiA) ### **B3. Open Rhino** Make sure you open Rhino as administrator before installing the license (right click and select ***‘Run as Administrator’***). You will need to have administrator rights. ![](/files/-MCkEZNfVkWG5TgiTiR6) ### **B4. Load License File** Open Grasshopper and place the **"License"**-component on your Grasshopper canvas. Right-click on the red “**K**” icon or the **"License"** label of the **"License"**-component and select “***Load license file***“. ![](/files/-MCkEZNglWTbOQq4p6by) ### **B5. Locate the License File** Locate the ***"XXX\_License.lic"*** that you received in the license package. Click **"Open"** to load the license. ![](/files/-MCkEZNhz4MPMls-Pk9z) ### **B6. Load License** The license should be successfully copied. If the license does not load successfully, make sure that you have [unblocked ](https://github.com/karamba3d/K3D_Manual/tree/4cf01a4699e48462897cf4ad7e43e6208a95c1d4/1-introduction/1.1-licenses/1.1.2-network-licenses#1-unblock-license-package)the files as well as opened Rhino as [administrator](https://github.com/karamba3d/K3D_Manual/tree/4cf01a4699e48462897cf4ad7e43e6208a95c1d4/1-introduction/1.1-licenses/1.1.2-network-licenses#1-run-rhino-as-administrator). ![](/files/-MCkEZNiFFHAQCN0HUBf) ### **B7. Restart Rhino** Close Rhino and Grasshopper and open Rhino once more, this time in standard mode. ### **B8. Check License Status** The panel displays the status and expiration date of the license. ![](/files/-MCkEZNjx_2vx-2fD47Z) ## **License Load Error** Errors occur if you do not open Rhino as Administrator or if you do not unblock the file before loading it into Karamba3d. ![](/files/-MCkEZNkCuaDsEJ95QIK) ## **Manual installation in Explorer** Make sure Rhino is closed and that the ***"license.lic"***-file is unblocked. ![](/files/-MCkEZNlp95VqiWRyyBO) Rename the license-file to: ***"license.lic"*** and move (overwrite) it to the License folder of your Karamba3d installation. This can be: *C:\Program Files\Rhino 7\Plug-ins\Karamba or C:\Program Files\Rhino 6\Plug-ins\Karamba.* Renaming the license file to ***"licensePRO.lic"*** ensures that the file is not erased upon installing Karamba3D updates. ![](/files/-MCkEZNmHXDqY9Z4Fzss) ## **Check License** Restart Rhino and your license should run. Upon successful installation of the license you should be able to open example files which have more than 20 beam elements or 50 shell elements. Double check if the license and correct Karamba3D version are installed by opening the below definition: {% file src="/files/7U2R5VBKiFSPPsTQGtNr" %} ![](/files/-MCkEQkvnBVKGa5rqCcS) # 2 Getting Started If all goes well during installation you will notice upon starting Grasshopper (GH) that there is a new category called Karamba3D on the component panel. It consists of roughly ten subsections (see fig. 2.1). In case you do not see any icons select **“Draw All Components”** in Grasshopper's **“View”**-menu. The installation can be tested by placing a Karamba3D **“License”**-component on the canvas: it should not issue a warning or error. If not, see section [4.1.3](/troubleshooting/4.3.-miscellaneous-problems/licensing) for how to solve that issue. {% hint style="info" %} On Apple machines make sure to have Microsoft's [.NET Framework 4.5](https://www.microsoft.com/en-us/download/details.aspx?id=30653) in case of Rhino6 and [version 4.8](https://support.microsoft.com/en-us/topic/microsoft-net-framework-4-8-offline-installer-for-windows-9d23f658-3b97-68ab-d013-aa3c3e7495e0) in case of Rhino7. {% endhint %} ![Fig. 2.1: Category “Karamba3D” on the component panel](/files/-MgtXdSMCfSPJa280qCQ) These are the subsections which show up in the Karamba3D category: | Tab | Function | | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | License | The **“License”-**component contained in here delivers information regarding the current type of license and how to get a pro-version of Karamba3D | | Params | containers for Karamba3D objects like beams, loads, models, . . | | 1.Model | lets you create a basic models with default settings for cross sections and materials | | 2.Load | components for defining external forces | | 3.Cross Section | contains components to create and select cross sections for elements. | | 4.Materials | components for the definition and selection of materials | | 5.Algorithms | components for analyzing the structural model | | 6.Results | for the retrieval of calculation results | | 7.Export🔷 | for exporting Karamba3D-models to RStab or Robot via DStV-file | | 8.Utilities | contains some extra geometric functionality that makes it easier to handle and optimize models | | x1.ParamUI | components for controlling the display of models via parameter-input only | {% hint style="info" %} The colors of Karamba3D’s icons have a special meaning: black or white designates the entity or entities on which a component acts. Products of components get referenced by a blue symbol. {% endhint %} # 2.1: Karamba3D Entities Grasshopper (GH) is an object oriented, visual scripting environment. It provides items like points, curves, surfaces, . . . for geometric computing. The full range of geometric items can be inspected in the subcategory **“Geometry”** of the toolbar section **“Params”**. Karamba3D adds seven entities for building structural models: | Entity | Typology | | ------------- | --------------------------------------------------------------------------------------- | | Model | contains all the information related to a structure | | Element | can be a beam, truss, shell or spring | | Element Set | groups together elements in a given order, makes them accessible under a common name | | Joint | defines the connectivity between neighboring elements | | Load | external action which is imposed on the structure | | Cross-section | defines a structural element’s geometry in section | | Material | provides information regarding the physical behavior of what a cross section is made of | | Support | defines how a structure connects to the ground. | Karamba3D objects behave like GH entities. * They can be stored in containers (see the **“Params”** subcategory of the **“Karamba3D”** toolbar). * When converted into text by plugging them into a panel they provide textual output regarding their fundamental properties. ## Default Settings In order to build a structural model not all of the above entities need to be present. Karamba3D assumes default settings for materials and cross sections: * If no material is given, Karamba3D chooses steel (S235 according to EC3 with$$f\_{yk} = 23.5 kN/cm^2$$) for all cross sections. * For beams the default is a circular hollow cross sections (CHS) with an outer diameter of$$114.4mm$$and a wall thickness of $$4mm$$. The default thickness of shells amounts to $$10mm$$. ## Graphical User Interface Some Karamba3D components come with graphical user interface components like radio-buttons, drop-down lists and sub-menus. Sliders on Karamba3D components have a preset number-range. Double-click on the knob to change the precision and range to your specific need. In some cases the user can select between different options at a component input (e.g. the Load-Case at a result component, or the degrees of freedom at a support-component). To select these options via ValueList-components right-click on the Karamba3D-component and select "**Expand ValueLists**" from the context menu or plug a ValueList into the corresponding input-plug. The selection of dynamic content that depends on the upstream -model (e.g. selection of load-cases) works only after the component executed at least once. So one needs to connect the mandatory input-plugs before expanding dynamic value-lists. The ModelView-, BeamView- and ShellView-components provide a short-cut for selecting color-ranges for result display: Right-click on the components and select 'Colors' from the context menu. # 2.2: Setting up a Structural Analysis A simple structural analysis can be performed in Karamba3D in eight steps: 1. [Define the Model Elements](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.1-define-the-model-elements) 2. [View the Model](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.2-view-the-model) 3. [Add Supports](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.3-add-supports) 4. [Define Loads](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.4-define-loads) 5. [Choose an Algorithm ](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.5-choose-an-algorithm) 6. [Provide Cross Sections](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.6-provide-cross-sections) 7. [Specify Materials ](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.7-specify-materials) 8. [Retrieve Results](/2-getting-started/2-getting-started-1/setting-up-a-structural-analysis/2.2.8-retrieve-results) # 2.2.1: Define the Model Elements Straight lines form the basis of beam, truss and spring elements. Shells and slabs are based on meshes. Fig. 2.2.1.1 shows a definition which defines a single beam, assembles a model and displays it. The **“LineToBeam”**-component takes a **“Line”**-object as input and creates a beam element from it. Karamba3D assumes all geometry input to be in meters. Assigning names to elements can be a great help in case of working with large, complex structures. In fig. 2.2.1.1 the name “bart” is assigned to the new beam. {% hint style="info" %} Element identifiers need not be unique. This allows you to use them for grouping elements. {% endhint %} ![Fig. 2.2.1.1: A structural model with geometry only ](/files/-MCkEY2qQ-T_6XMlGAv-) The **“Assemble”**-component gathers the information in a model. When plugged into a panel, a model displays its basic features: **“c.Length”** stands for characteristic length and is calculated as the diagonal of the bounding box of the structure. In case of the beam there are two nodes which define one element. In the absence of material definitions Karamba3D automatically generates one default material. This is applied to the default beam cross section. In case of the presence of shells a second default cross section would show up. The model contains no loads, there is however a default load-case. {% hint style="info" %} A load-case corresponds to a scenario where a group of external actions impact a model. Think of e.g. wind which can hit a structure from several directions but not from all directions at once. Each wind direction would correspond to a load-case. {% endhint %} # 2.2.2: View the Model There are three components for controlling how a model is displayed in the Rhino viewport: | | | | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | | **“ModelView”** | sets the general display properties. These are stored in the model and stay valid until overwritten by a downstream **“ModelView”**-component. | | **“BeamView”** | lets you control the display properties specific for beams. Renders e.g. the cross section as a mesh. | | **“ShellView”** | contains the display-settings for shells. | Fig. 2.2.2.1 shows how the **“ModelView”**- and **“BeamView”**-component can be combined for rendering the beam model. In order to unfold the viewing components click on the black section headings on the components. In the **“Tags”** section of **“ModelView”** the **“Elements”** checkbox is on by default. This enables the display of the element's middle axis. When activated, the **“Node tags”**-option makes the node numbers show up. The nodes in a Karamba3D model are numbered starting with zero. The same applies to model elements. Showing their identifiers via **“Element Ids”** is sometimes more useful. ![ Fig. 2.2.2.1: “ModelView”- and “BeamView”-components are used to display a model](/files/-MCkEZPTDWIyk1wwOBHB) In case of more than one element the **“Assemble”**-component rigidly connects them if their nodes coincide. If working with imprecise geometry this can give unexpected results: although two elements may appear connected, there could be in fact inaccuracies in the node positions. A gap in a model usually has a large impact on its physical behavior. Enabling the display of node indexes can help to find such gaps, since there will be two node numbers in one place. # 2.2.3: Add Supports Supports define how a structure connects to the ground. They suppress translations or rotations at nodes. An activated button appears black and means either zero translation (T) in the direction of the global x-, y- or z-axis or zero rotation (R) about the corresponding global axis (or local axis if you input a plane). A node index or position can be used to specify the location of a support. Supply a plane as input for specifying locally oriented support conditions. {% hint style="info" %} Green arrows symbolize translational supports, purple circles stand in for rotational supports (see fig. 2.2.3.1). {% endhint %} ![ Fig. 2.2.3.1: Supports specify how a structure interacts with the ground](/files/-MCkE_3-a43YbGzMPH-m) For static analysis, a structure needs to be supported in such a way that it can not fly around freely. In three dimensional space, a rigid body has six modes of movement or degrees of freedom (DOFs): three translations and three rotations (see fig. 2.2.3.2). Thus there need to be at least six support conditions in a structural model to fix it. When a model or parts of it are moveable, the **“Analyze”**-component either refuses to calculate or returns huge displacements. Should you encounter a problem like this plug your model into the **“Eigen Modes”**-component. It can detect the rigid body movements which cause the problem. ![ Fig. 2.2.3.2: A body in space has six degrees of freedom (DOFs).](/files/-MCkERBi-R4LXw9qywEI) # 2.2.4: Define Loads ![ Fig. 2.2.4.1: A cantilever with a point-load at its tip](/files/-MCkEQDWUgYnCZ-sLdmr) In fig. 2.2.4.1 a point-load of 1 kilo Newton ($$kN$$) is added at the tip of the cantilever beam. A vector at the input-plug **“Force”** specifies direction and magnitude of the load: since the global Z-axis points upwards a load acting downwards has a negative z-component. {% hint style="info" %} The input-plug **“LCase”** can be used to set the number of the load case in which the load acts. This allows different load scenarios (e.g. wind from different directions) to be created. {% endhint %} ![Fig. 2.2.4.2: definitions of different load types](/files/-MCkEQDYfFvCiUE_Tifs) The dropdown list at the bottom of the **“Loads”**-component lets one choose between different types of loads as shown in fig. 2.2.4.2. Gravity loads (1) act on the whole structure. The location of point loads (2) can be specified by node index or position. Beam loads (3) act on elements given by element identifiers. Distributed loads on arbitrary meshes (4) get reduced to approximately statically equivalent node and beam loads. The directions of gravity and point-loads refer to the global coordinate system. The direction vector of beam- and mesh-loads can be specified relative to the global or local (relating to the element or mesh) coordinate system. # 2.2.5: Choose an Algorithm ![ Fig. 2.2.5.1: Deflection and stress-wise utilization of a cantilever beam with a point-load at its tip](/files/-MCkEZhxWSZRJZswhJ4o) Karamba3D offers various options of analyzing a structural model. The **“Analyze”** component (see fig. 2.2.5.1) calculates the deformation and stresses of a model under external loads. The **“Deformation”**-slider in the submenu **“Display Scales”** of the **“ModelView”**-component allows you to scale the graphical output of the displacements. The default magnification factor is 50. In case the numeric range of the **“Deformation”**-slider does not fit it can be adapted. {% hint style="info" %} A double-click on the knob of the slider invokes a window for adapting the slider settings. {% endhint %} In order to get the numbers which correspond to the colors of the utilization output a **“Legend”**-component is used in fig. 2.2.5.1. Dividing the normal stress in a point of the cantilever by the strength of its material gives the stress-wise utilization output of the **“BeamView”**-component. Negative values correspond to compression, positive values to tension. Stress-wise utilization can be misleading: slender beams under axial compression buckle and thus collapse before the compressive stresses reach the material strength. The **“Utilization”**-component includes stability and should be used in such cases. # 2.2.6: Provide Cross Sections There are two options for attaching cross sections to elements: 1. Directly at the component where the element is created as shown in fig. 2.2.6.1. 2. Via element names (“B” and “S” in fig. 2.2.6.2) or regular expression by plugging cross sections into the **“Assemble”**-component. ![Fig. 2.2.6.1: Definition of a cross section](/files/-MCkEZqZ4SVUq4zzjv1V) Fig. 2.2.6.1 shows how to attach a custom cross section to an element. It is an I-profile with a height and width of $$50cm$$ . The physical unit of any input- or output-value is mentioned in the help text which pops up when the mouse pointer hovers over the corresponding plug. {% hint style="info" %} Assignment via the **“Assemble”**-component overrides direct assignment in the element. {% endhint %} ![ Fig. 2.2.6.2: Definition of a cross section via element names](/files/-MCkEZqa5h3AZAiNTQu1) Fig**.** 2.2.6.2 shows hows cross sections can be defined by element names **“Elem|Id”**: definition of a beam cross section (1); definition of a shell cross section (2); selection of a cross section from the default cross section library (3). Arbitrary I-, hollow box, filled trapezoid and hollow circular cross sections can be defined for beams. Alternatively Karamba3D lets the user select a predefined standard cross section. In case of shells, it is possible to attach a different cross section to each element. The Karamba3D cross sections are available as multi-components: they can be accessed via the single component **“Cross Sections”**. The drop down menu lets one select the cross section type. {% hint style="info" %} Should you not assign a cross section to your beam or shell elements, the [default cross section ](/2-getting-started/2-getting-started-1/karamba3d-entities#default-settings)will be used. {% endhint %} # 2.2.7: Specify Materials Materials can be either defined by manually setting their mechanic properties or by selection from a library of predefined materials (see fig. 2.2.7.1 (3)). Materials attach to cross sections. There are two options for assigning materials: ![Fig. 2.2.7.1: Definition of materials via element names](/files/-MCkEYvJX8NkirenlCf3) 1. Assignment via the **“Assemble”**-component (see fig. 2.2.7.1). The **“Elem|Id”** input-plug specifies the names of the elements to which the material shall be attached. Alternatively a regular expression can be used to select elements. Leaving **“Elem|Id”** empty sets the material for all elements. Materials are not attached to elements directly but to the element’s cross section. 2. Direct input at the **“Cross Section”**-component like in fig. 2.2.7.2. ![ Fig. 2.2.7.2: Definition of a material directly at the "Element"-component](/files/-MCkEYvKFk2PeHr0mmAg) Fig. 2.2.7.1 shows how materials can be defined by element names **“Elem|Id”**: definition of an isotropic custom material (1); definition of an orthotropic custom material (2); selection of a material from the material library (3). {% hint style="info" %} Assignment via the **“Assemble”**-component overrides direct assignment in the cross section. {% endhint %} {% hint style="info" %} Should you not assign a material to your beam or shell elements, the [default material ](/2-getting-started/2-getting-started-1/karamba3d-entities#default-settings)will be used. {% endhint %} # 2.2.8: Retrieve Results ## Visualization ![Fig. 2.2.8.1: Three components for visualizing the model: “ModelView”, “BeamView” and “ShellView”](/files/-MCkEZKSaZXwwN2NzLKJ) Karamba3D offers three components for visualizing a structural model (see fig. 2.2.8.1): | | | | --------------- | -------------------------------------------------------------------------------------------------------------------------------- | | **“ModelView”** | sets the basic visualization properties like scaling factor of displacements, sizes of symbols, number of displayed load case, … | | **“BeamView”** | visualizes beams | | **“ShellView”** | visualizes shells | Each of these components contains submenus which can be expanded by clicking on the black caption bar. The numerical range of sliders can be set by double-clicking on their black knob. Visualization properties stick to the model and stay valid until they get overruled by another downstream visualization component. ## **Results** Structural response properties can be used to inform the model and e.g. optimize it. Fig. 2.2.8.2 shows some of the available options: nodal displacements (1), level of material utilization (2), resultant cross section forces (3) and reaction forces (4). ![Fig. 2.2.8.2: Retrieval of numerical results](/files/-MCkEZKUb2MkU8n84YoH) ## **Disassembling a Structural Model** In order to modify a model or retrieve e.g. cross section types after cross section optimization, Karamba3D lets you disassemble models, elements, cross sections and materials. The components **“Disassemble Model”**, **“Disassemble Element”**, **“Disassemble Cross Section”** and **“Disassemble Material”** let you dissect a structural model in great detail. # 2.3: Physical Units On installing Karamba3D one can specify the family of physical units to be used for input and results. The default option is metric (e.g. meters, centimeters, degree Celsius, Newtons, …) but Karamba3D can also deal with Imperial units (e.g. feet, inch, degree Fahrenheit, kiloponds, …). {% hint style="info" %} The set of units to be used can be changed any time by editing the [“karamba.ini”](broken://pages/-MCkEPuOOhTAZq37mVOn) file. {% endhint %} Depending on the family of units Karamba3D interprets geometric input either as meters or feet by default. The kind of physical units that components expect to receive shows up in the tool-tip which appears when the mouse pointer hovers over an input-plug. Changing the type of physical units during the creation of a GH definition may give rise to problems: The help text of Grasshopper components does not change dynamically. Switching from SI to Imperial Units leaves the help text of those components already placed on the canvas unaltered. The interpretation of the input values however changes. Opening a GH definition with a Karamba3D versions with differently set physical units entails the same problem. Karamba3D comes with databases for predefined cross sections and materials. The properties there are given in SI units. The same applies to physical constants (e.g. “gravity”) defined in the **“karamba.ini”**-file. Throughout the rest of this manual SI units will be used exclusively in order to ensure good readability. When specific differences exist between using Karamba3D with Imperial Units and SI units, this will be mentioned in the text. ## Non-default Physical Units In case of very small or very large models the default physical units may become cumbersome to work with. The "karamba.ini"-file contains three parameter settings to change the basic physical units which Karamba3D uses for internal calculation and geometry input from Rhino: "**UnitLength**", "**UnitForce**" and "**UnitMass**" (see fig. 2.3.1). Possible values for the unit-identifiers are listed in the karamba.ini-file as comments. All input- and output values will be converted to and fro these units. The units can be arbitrarily mixed - make sure however not to use imperial- and SI-units at the same time. As a short-cut for setting the unit for geometric input, the "Settings"-components provides a corresponding drop-down-list. In order that the settings-component gets executed before all others on loading the definition, one needs to select the settings-component and press Ctrl+B before saving. ![Fig. 2.3.1: snippet of the "karamba.ini"-file which sets the basic physical units.](/files/-MgyhAcEHJeLhMWgZxw_) \ The basic physical units serve for internal book-keeping and geometry input from Rhino. In order to change the physical units for input and output use the "CustomUnits"-parameter in "karamba.ini" (see fig. 2.3.2). This parameter expects a list of comma-separated terms of the form "'original unit'>'custom unit'". If handed over an empty list the default units apply. ![Fig. 2.3.2: Definition of custom physical units for input and ouput.](/files/-MgyktT_2upx-vKWp_VX) The new units apply to all Karamba3D components. The help-text of input- and output-plugs of existing components will not change however - only that of newly added ones. # 2.4: Quick Component Reference ## License | | | | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | -------------------------------------------------------------------------------------------- | | ![](https://blobscdn.gitbook.com/v0/b/gitbook-28427.appspot.com/o/assets%2F-LuZCfCiZy9f_PhDBBrS%2F-LyUTBNWt-0gzPYBIeG0%2F-LyUURkzIgZbzycGjrsc%2FKarambaIcon_LicenceInformation.png?alt=media\&token=aa5ced3f-3b3a-4ac1-8ad1-857760bd9df8) | **License** | Returns the program version, license information and can be used to manage the license file. | ## Params Karamba3D introduces seven new classes for defining structural models and corresponding containers: | | | | | -------------------------------- | ----------------- | ------------------------------------------------------ | | ![](/files/-MCkE_EjqSlPZxp85wdw) | **Cross-section** | Container for cross section objects | | ![](/files/-MCkE_EkoSUWmcLFR52P) | **Element** | Container for finite elements | | ![](/files/-MCkE_EljSAJoyIHz9Py) | **Element Set** | Container for ordered groups of elements | | ![](/files/-MCkE_EmdQ2dIAD6A8TZ) | **Joint** | Container for connectivity conditions between elements | | ![](/files/-MCkE_EnR4SK5bu5raQk) | **Load** | Container for load objects | | ![](/files/-MCkE_EoPhP1qy2MMtTR) | **Material** | Container for materials | | ![](/files/-MCkE_Ep6VyfWylcM_8x) | **Model** | Container for models | | ![](/files/-MCkE_EqWakSzcoEP-H1) | **Support** | Container for supports | ## Model This subcategory contains components for assembling a model, converting geometry into finite elements and defining support conditions. | | | | | -------------------------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_ErVdOt6QkU6tP6) | **Assemble Model** | Creates a finite element model by collecting given entities (points, beams, shells, supports, loads, cross sections, materials, . . . ). | | ![](/files/-MCkE_EsjCypCHoVV_-d) | **Disassemble Model** | Decomposes a model into its components. | | ![](/files/-MCkE_EtNGmT_W4m_kFZ) | **Modify Model** | Changes the model's nodal positions. | | ![](/files/-MCkE_EuC_pGxiZcsPIc) | **Connected Parts** | Returns groups of interconnected lines of the model. | | ![](/files/-MCkE_EvncznKBFjyUI-) | **Activate Element** | Activates the elements of a model according to the activation list. Uses the soft kill approach for inactive elements. | | ![](/files/-MCkE_Ew0fNR5tDGnS_4) | **Line to Beam** | Creates beams with default properties from given lines. Lines that meet at a common point result by default in rigidly connected elements. Karamba3D assumes input to be in meter or feet. | | ![](/files/-MCkE_ExAZzNgIPhREl7) | **Connectivity to Beam** | Creates beams with default properties from a given connectivity diagram. | | ![](/files/-MCkE_EyJ0rpWDUieGp2) | **Index to Beam** | Creates beams with default properties from given node indexes. | | ![](/files/-MCkE_Ez_ExFgdgvoccw) | **Mesh to Shell** | Creates shells with default properties from given meshes. Quad faces are split to triangles. | | ![](/files/-MCkE_F-BbzMpEiaz8sO) | **Modify Element** | Multi-component for modifying elements. Works either directly on an element or indirectly as an autonomous agent: | | ![](/files/-MCkE_F0wALCenS68DyD) |
  • Modify Beam (default)
| Modifies beams only | | ![](/files/-MCkE_F13YPynBEyaQZ0) |
  • Modify Shell
| Modifies shells only | | ![](/files/-MCkE_F2JJilKO33vnVn) | **Point-Mass** | Attaches a point mass to a node of given index or position. Does not result in additional weight, only translational inertia. | | ![](/files/-MCkE_F3FsJ2ZK6Rw-L0) | **Disassemble Element** | Decomposes elements into their components. | | ![](/files/-MCkE_F4_ta8c2UF1xEX) | **Make Beam-Set** 🔷 | Puts beams designated by their beam identifier into a group. | | ![](/files/-MCkE_F577UBF7eS2QzD) | **Orientate Elem** | Decomposes elements into their components: | | ![](/files/-MCkE_F63_K-G1Muy5lR) |
  • Beam (default)
| Sets the local Z-axis of beams according to a given vector and adds a rotation angle DAlpha about the longitudinal axis. Flips beam direction according to a given x-vector. | | ![](/files/-MCkE_F779tGPNa9wyur) |
  • Shell
| Sets the local X- and Z-orientation using global coordinates. | | ![](/files/-MCkE_F8RUroLxThXRvW) | **Select Element** | Selects elements according to a given identifier and puts all incoming elements in two groups: selected or rejected. The identifier may be the element index, name or a regular expression. | | ![](/files/-MCkE_F9uIoXPnTP_aXw) | **Support** | Creates supports at nodes of given node-indexes or node-coordinates. Lets you select translations/rotations which should be zero and the support orientation with respect to the global or a local coordinate system. | ## Load The components in this subcategory let one define and manipulate external actions which impact a structure. | | | | | -------------------------------- | ------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_FA6mcInRuiimby) | **Loads** | Multi-component for defining loads: | | ![](/files/-MCkE_FBfyNOuB-qK57P) |
  • Gravity (default)
| Creates gravity from a specified direction vector for given load-cases. | | ![](/files/-MCkE_FCavnhFq2K8hll) |
  • Point-Load
| Creates point loads at points of given index or position. | | ![](/files/-MCkE_FDSYiDaDL05JMs) |
  • Imperfection-Load
| Defines imperfections for beams under normal forces . | | ![](/files/-MCkE_FENKkbLHKCnt9Q) |
  • Initial Strain-Load
| Sets initial axial strains on beams. | | ![](/files/-MCkE_FFAqO9yTikAHCU) |
  • Temperature-Load
| Imposes a temperature difference on an element with respect to its initial temperature at construction. | | ![](/files/-MCkE_FG7HHWRjKCQ3vV) |
  • Line-Load on Element
| Creates a uniformly distributed load on a beam. | | ![](/files/-MCkE_FH37_xwr1iQy9a) |
  • MeshLoad Const
| Creates approximately equivalent point- and line-loads from a constant surface load on a mesh. The constant surface load is defined by one vector. | | ![](/files/-MCkE_FIaEmjhrX7nAM_) |
  • MeshLoad Var
| Creates approximately equivalent point- and line-loads from a variable surface load on a mesh. The variable surface load is defined by one vector for each mesh face. The longest list principle applies when the mesh-faces outnumber the load-vectors. | | ![](/files/-MCkE_FJo5VoWwVOnsIl) | **Disassemble Mesh Load** | Splits a mesh-load into corresponding line- and point-loads | | ![](/files/-MCkE_FKdrDi96TiZIhU) | **Prescribed Displacement** | Prescribes displacements at nodes of given node-indexes or node-coordinates. Select translations or rotations which should be prescribed. For load-cases with no displacements prescribed this will create a support. | ## Cross Section | | | | | -------------------------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_FLsEzR5Szvgiad) | **Cross Sections** | Multi-component for creating cross sections: | | ![](/files/-MCkE_FMBaxrS7BnNYJk) |
  • Box-Profile (default)
| Creates rectangular, trapezoid and triangular hollow cross sections. | | ![](/files/-MCkE_FNwjbG0HeUSKhi) |
  • Circular Hollow Profile
| Creates circular hollow cross sections. | | ![](/files/-MCkE_FOkZaiqYe7DTC1) |
  • I-Profile
| Creates I-shaped cross sections. | | ![](/files/-MCkE_FPWCey4edBhg9z) |
  • Shell Const
| Lets you set the height and material of a shell with constant cross section. | | ![](/files/-MCkE_FQGzjXjX3oWQJO) |
  • Shell Var
| Lets you set the height and material of each face of a shell. | | ![](/files/-MCkE_FRcg5PsbtJQ9BG) |
  • ShellRC Std Const
| A standard reinforced concrete cross section consists of four layers of orthogonal reinforcement. This component allows to define such a cross section which is constant throughout a shell. | | ![](/files/-MCkE_FSi3BFOjBxV-oK) |
  • ShellRC Std Var
| Same as above, lets one set the reinforced concrete cross section properties for each shell face separately. | | ![](/files/-MCkE_FTihhfW3M-3F_g) |
  • Spring-Cross Section
| Defines the spring stiffness of an element. | | ![](/files/-MCkE_FUgvutE5o93OG5) |
  • Trapezoid-Profile
| Creates filled rectangular, trapezoid and triangular cross sections. | | ![](/files/-MCkE_FVX8ZXXfDej6d1) | **Disassemble Cross Section** 🔷 | Retrieves properties of a cross section. | | ![](/files/-MCkE_FWhQh-ZRTihJBp) | **Beam-Joint Agent** 🔷 | Crawls around in the model and adds joints to beams on the basis of geometric relations. Is of type cross section. | | ![](/files/-MCkE_FXpUxnr9dJ2zLn) | **Beam-Joints** 🔷 | Adds hinges at the end-points of beams. Is of type cross sections. | | ![](/files/-MCkE_FYJ_dq9McsYiRj) | **Eccentricity on Beam** 🔷 | Sets the eccentricity of a cross section relative to the element axis in global coordinates. | | ![](/files/-MCkE_FZIfcBklgPQTMl) | **Eccentricity on Cross Section** 🔷 | Sets the eccentricity of a cross section relative to the element axis in local beam coordinates. | | ![](/files/-MCkE_F_iWN4na9x2vsh) | **Modify Cross Section** 🔷 | Multi-component for modifying cross sections. Works either directly on a cross section object or indirectly as an autonomous agent: | | ![](/files/-MCkE_FaA9z0JBUq_1xw) |
  • Modify Beam Cross Section (default) 🔷
| Modifies beam cross sections only. | | ![](/files/-MCkE_Fb2ZvJj67nifKn) |
  • Modify Shell Cross Section 🔷
| Modifies shell cross sections only. | | ![](/files/-MCkE_FcDRWhSHA45_Sn) | **Cross Section Range Selector** | Lets you select cross sections by country, shape, family or maximum depth or width. | | ![](/files/-MCkE_Fdp7Mb0PITODBw) | **Cross Section Matcher** | Returns for a cross section the best fitting cross section contained in a given list. The matched cross section is equal or better in all mechanical aspects at minimum weight. | | ![](/files/-MCkE_Fe6lR-C2J8PbGB) | **Cross Section Selector** | Lets you select cross sections by name, regular expression or index from a list of cross sections. | | ![](/files/-MCkE_Fffkq8PG8GHWuP) | **Generate Cross Section Table** | Converts a list of cross sections into a string which can be streamed as a csv-file and used as a cross section table. | | ![](/files/-MCkE_FgdgN6ijo_-mKE) | **Read Cross Section Table from File** | Reads cross section data from a csv-file. | ## **Material** | | | | | -------------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------- | | ![](/files/-MCkE_FhB5qR2AB0mhE2) | **Material Properties** | Sets the characteristic parameters of an isotropic or orthotropic material. | | ![](/files/-MCkE_Fi6gW33y-OGECZ) | **Material Selection** | Lets you select a material by name, regular expression or index from a list of materials. | | ![](/files/-MCkE_FjdGTkJFsI4evO) | **Read Material Table from File** | Reads a list of materials from a table given in csv-format. | | ![](/files/-MCkE_FktBkQ6hVVshEa) | **Disassemble Material** 🔷 | Outputs the physical properties of a material. | ## **Algorithms** | | | | | -------------------------------- | ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_Fl4zWtcVhAf6cg) | **Analyze** | Calculates the deflections of a given model using first order theory. | | ![](/files/-MCkE_FmqWBuIqn6zd3o) | **AnalyzeThII** 🔷 | Calculates the deflections of a given model including the effect of axial or in-plane forces. | | ![](/files/-MCkE_FnPTMmjluHdvqr) | **Analyze Nonlinear WIP** | Handles calculations involving large deformations. Is work in progress: the speed of convergence will be improved in future releases. Currently it works best for beams, but can also handle shell structures. | | ![](/files/-MCkE_Fo536em04SVaqR) | **Large Deformation Analysis** | Does an incremental geometrically non-linear analysis for loads in load case zero. Return displacements only, no stresses of cross section forces. | | ![](/files/-MCkE_FpyaRtXO9yrFZk) | **Buckling Modes** 🔷 | Calculates the buckling-modes and buckling load-factors of the given model under normal **f**orces . | | ![](/files/-MCkE_Fq_Xq9LumMtPyj) | **Eigen Modes** | Calculates the eigenmodes of the given model according to the special eigenvalue problem. | | ![](/files/-MCkE_Fr_uIlmPhkTRDe) | **Natural Vibrations** | Calculates the natural vibrations of the given model. | | ![](/files/-MCkE_Fs15ZbM-FwYsle) | **Optimize Cross Section** 🔷 | Iteratively selects optimum cross sections for beams, trusses and shells. | | ![](/files/-MCkE_Fto6INKyPHsDGt) | **BESO for Beams** | Optimizes the topology of beams in a structure by using Bi-directional Evolutionary Structural Optimization. | | ![](/files/-MCkE_FuhVBo6ORAusDQ) | **BESO for Shells** | Optimizes the topology of shells in a structure by using Bi-directional Evolutionary Structural Optimization. | | ![](/files/-MCkE_FvXLhvJBk0Z37b) | **Optimize Reinforcement** 🔷 | Performs reinforcement design for shells. It uses linear elastic cross section forces and the assumption of zero tensile concrete strength for determining reinforcement quantities. | | ![](/files/-MCkE_FwIkOZhhIIatup) | **Tension/Compression Eliminator** 🔷 | Removes beams or trusses under axial tension or compression. By default compression members will be removed. | ## Results | | | | | -------------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_Fx0ttTQDDkIhlY) | **Model View** | Lets you inspect the general properties of the model. | | ![](/files/-MCkE_FyJj8AIgS6vQQU) | **Deformation-Energy** | Retrieves deformation energies of the elements of the model. | | ![](/files/-MCkE_FzmH1EPY4RAKSP) | **Nodal Displacements** | Returns nodal displacements: translations in global x-, y-, and z-direction; rotations about the global x-, y- and z-axis. | | ![](/files/-MCkE_G-DMtiDc2qvywe) | **Principal Strains Approximation** | Approximates the principal strain directions from the model deformation at arbitrary points. | | ![](/files/-MCkE_G0kIR_CaF8QoYi) | **Reaction Forces** 🔷 | Returns reaction forces and moments at supports. | | ![](/files/-MCkE_G16RCwXs3jQErI) | **Utilization of Elements** 🔷 | Multi-component that returns the utilization of elements. “1” means 100%: | | ![](/files/-MCkE_G2Wk0N6YNbskKk) |
  • Utilization of Beams (default) 🔷
| The utilization of beams is calculated according to EC3 (see section [A.4](/appendix/a.4-background-information/a.4.6-approach-used-for-cross-section-optimization)). | | ![](/files/-MCkE_G3g-R3iPL7vo25) |
  • Utilization of Shells 🔷
| Returns the maximum Van Mises stress in each face of the shell. | | ![](/files/-MCkE_G4IYi6c1FLqH94) | **Beam View** | Lets you inspect beam properties: section forces, cross sections, displacement, utilization and stresses. Is to be plugged into the definition after the “ModelView”-component. | | ![](/files/-MCkE_G54AEiSC7u-gGV) | **Beam Displacements** 🔷 | Returns displacements along elements: translations in global x-, y-, and z-direction; rotations about the global x-, y- and z-axis. | | ![](/files/-MCkE_G6QMtdibb_K0iy) | **Beam Forces** | Retrieves section forces along beams and trusses. | | ![](/files/-MCkE_G7upiQsDcAa3iV) | **Beam Resultant Section Forces** | Retrieves resultant section forces of beams. | | ![](/files/-MCkE_G8j7Zwzom53xTG) | **Shell View** | Lets you inspect shell properties: displacement, utilization, principal stresses and Van Mises stress. Is to be plugged into the definition after the “ModelView”-component. | | ![](/files/-MCkE_G97ue7tAhFxaCZ) | **Line Results on Shells** | Multi-component for generating line results on shells: | | ![](/files/-MCkE_GADpMG2__oI68z) |
  • Force Flow (default)
| Computes flow lines for forces in given direction at user defined positions. | | ![](/files/-MCkE_GBptDhoOgNpiGD) |
  • Isolines
| Creates lines that connect points of same value for selected shell results (e.g. principal stresses, displacement, utilization, cross section thickness) at user defined positions. Also returns values and can thus be used for probing the shell state. | | ![](/files/-MCkE_GC6QJtKFElCJVy) |
  • PrincMoment
| Returns the principal moment lines that originate from user defined points on shells. | | ![](/files/-MCkE_GDdzAuBP81lIIk) |
  • PrincStress
| Outputs the principal stress directions in the center of each shell element. | | ![](/files/-MCkE_GEAYkG0zkGfSx-) | **Results Vectors on Shells** | Multi-component for generating vector results in each element of a shell: | | ![](/files/-MCkE_GFAE8e4H7GpLmL) |
  • PrincStress (default)
| Outputs the values of first and second principal stress on a given layer in the center of each shell element. | | ![](/files/-MCkE_GGv749iuWGNLrT) |
  • PrincForces
| Outputs the first and second principal normal forces and moments in the center of each shell face as vectors. | | ![](/files/-MCkE_GH9L_ySrO8xCZr) | **Shell forces** | Outputs the values of the local or principal normal forces and moments in the center of each shell element. | ## Expor**t** 🔷 | | | | | -------------------------------- | ----------------------------- | ----------------------------------------------------------------------------------- | | ![](/files/-MCkE_GIcTztCKJYd2CC) | **Export Model to RStab** 🔷 | Exports a model to RStab5, RStab6, RStab7, RStab8 or Robot by creating a DStV-file. | ## Utilities | | | | | -------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![](/files/-MCkE_GJICFwol0rc5HR) | **Closest Points** | Connects each node of one set to a given number of nearest neighbor nodes or neighbors within a specified distance of another set. | | ![](/files/-MCkE_GK9SoB3EpAqkkd) | **Closest Points Multi-dimensional** | Performs a multidimensional nearest neighbor search on two sets of vectors. | | ![](/files/-MCkE_GL5MVzgmbh5EbA) | **Cull Curves** | Inputs a data tree of straight lines and thins them out so that no lines in different branches are closer than a given limit distance. | | ![](/files/-MCkE_GMAtP9r22T0Fpi) | **Detect Collisions** | Counts the number of intersections between the model and a given mesh. | | ![](/files/-MCkE_GNSbMM344xF5I4) | **Get Cells from Lines** | Creates closed cells from a graph and vertices on a user supplied plane. | | ![](/files/-MCkE_GOqYZ90O-ojBqi) | **Line-Line Intersection** | Intersects given lines and returns resulting end-points and pieces. | | ![](/files/-MCkE_GPo9PzzdIVfkkX) | **Local Vector** | Transforms a vector from the global to a local coordinate system given by a plane. | | ![](/files/-MCkE_GQsyoHHfq2NtNB) | **Line-Mesh Intersection** 🔷 | Returns the points where given lines intersect given meshes. | | ![](/files/-MCkE_GRRE_KYrwQ2Hi8) | **Mesh Breps** | Takes multiple breps and generates a unified mesh from them. The algorithm takes account of common edges and insertion points. This lets one define positions for supports or point-loads on shells. | | ![](/files/-MCkE_GS71jCrvhcUmQZ) | **Principal States Transformation** 🔷 | Transforms given principal vectors of stresses, moments or in-plane forces to an arbitrary direction. | | ![](/files/-MCkE_GTqIipPAT44v3q) | **Remove Duplicate Lines** | Eliminates identical lines. | | ![](/files/-MCkE_GUcECFJO13JyHr) | **Remove Duplicate Points** | Eliminates identical points. | | ![](/files/-MCkE_GVjNO2m9qZTwIW) | **Simplify Model** | Changes a model by straightening the connecting elements between nodes that connect to more than two neighbor nodes. | | ![](/files/-MCkE_GWfTi9SiUFSGA4) | **Element Felting** 🔷 | Felts elements of a model by connecting them at their mutual closest points. | | ![](/files/-MCkE_GX1Wg7p4kxlw-V) | **Mapper** 🔷 | Applies mappings (like Simple Stitch) to a model. | | ![](/files/-MCkE_GYSUquvypGAZAE) | **Interpolate Shapes** 🔷 | Interpolates between a base geometry (0.0) and given shape(s) (1.0). | | ![](/files/-MCkE_GZxNQJ9gxi7Mmq) | **Stitch** 🔷 | Multi-component for defining modes of connection between sets of beams: | | ![](/files/-MCkE_G_-E3CWLLRMsia) |
  • Simple Stitch (default) 🔷
| Connects beam sets by a preset number of elements. | | ![](/files/-MCkE_GagXkwIqcOHDyW) |
  • Stacked Stitch 🔷
| Connects beam sets by a preset number of elements that do not intersect each other. | | ![](/files/-MCkE_Gb3MruhdtwU0LL) |
  • Proximity Stitch 🔷
| Connects beam sets by a preset number of elements whose maximum inclination can be controlled via min/max offset-limits from their starting point. | | ![](/files/-MCkE_GcdBH0fRqDnG9O) | **User Iso-Lines** | Creates iso-lines on a model based on user supplied nodal values. | | ![](/files/-MCkE_GdZ7jp7UAf1szp) | **User Stream-Lines** | Creates stream-lines on a model based on user supplied vectors at the nodes. | # 3.0 Settings The subsection **“Settings”** of Karamba3D contains two components: * **"Settings"**: can be used to modify the default behavior and appearance of Karamba3D * **"License"**: for checking the license status. # 3.0.1 Settings ## Default Program Settings On start-up, Karamba3D sets its default appearance and behavior according to the values listed in the **"karamba.ini"-**file. This file is located in the Karamba3D installation folder (double-click on the Karamba3D desktop icon to get there) and can be opened and manipulated with any text editor.\ The file starts with a description of the syntax rules for defining the default settings. Each paragraph that follows contains a description regarding meaning and effect of a specific property and its default value. Among other things these settings can be changed: * System of physical units ("SI" or "Imperial") * Limit distance for snapping together neighboring nodes * The value of the acceleration of gravity * Limit inclination for verticality * Number format and display properties of output values * Properties of the default materials * Colors used for displaying rendered calculation results * ... In case you want to keep your changes when upgrading from one version of Karamba3D to the next rename the initialization-file to **"karamba\_user.ini"**. This however incurs the risk, that newly introduced properties are missing. In such a case hard-wired default values take their place. {% hint style="info" %} Administrator rights may be needed to overwrite the original **"karamba.ini"**-file. {% endhint %} ## User-defined Settings The "Settings"-component offers a convenient way of changing the Karamba3D settings for one specific definition without manipulating the karamba.ini-file (see fig. 3.0.1.1). It takes the "karamba.ini"- or "karamba\_user.ini"-file as the starting point. The input-plug "Settings" expects a list of name and value pairs and sets the corresponding parameters for use in the current definition. The component outputs the updated settings-text on the right side. When plugged into a pannel and streamed to file this can be directly used as a valid karamba.ini-file. In order, that the settings-component gets executed before all others on loading the definition, one needs to select the settings-component and press Ctrl+B before saving (see ) - otherwise it might happen, that the changes take effect only after performing a recompute. ![Fig. 3.0.1.1: On-the-fly change of the number of legend colors via the Settings-component. ](/files/-MgzaWzVSLVHaDtGMCQf) The drop-down-list on the Settings-component provides a shortcut for setting the unit of length used for handling geometry imported from Rhino. The changes via the Settings-component do not affect the karamba.ini-file. # 3.0.2 License The "License"-component outputs details regarding the version and build number of the installed Karamba3D plug-in. The output also contains the license type and date of expiration of the license (see fig. 3.0.2.1). For questions regarding licenses see section [4.1.3: Licensing](/troubleshooting/4.3.-miscellaneous-problems/licensing). ![Fig. 3.0.2.1: The License-component returns information regarding version number ans license](/files/-MgzgPsLVF3CLyeTVLC4) # 3.1: Model The subsection **“1.Model”** of Karamba3D contains components for handling the basic aspects of a structural model. Read on to learn more about all aspects of creating a model. # 3.1.1: Assemble Model In order to calculate the behavior of a real world structure one needs to define its geometry, loads and supports. The component **“Assemble”** gathers all the necessary information and creates a structural model from it (see fig. 3.1.1.1). ![ Fig. 3.1.1.1: The “Assemble”-component gathers data and creates a model from it.](/files/-MCkEZUw8RXCIUUsRgK1) In case that some beams were defined by node indexes then these will refer to the list of points given at the **“Pt”**-input-plug: the first node in the list has index zero in the model, the next one index one, and so on. The **“Pt”**-input can also be used to give the model nodes a specific order. The value at the input-plug **“LDist”** defines the distance of points below which they will be merged to one. This helps in dealing with inaccurate geometry. The limit distance default value is $$5mm$$. {% hint style="info" %} By default, elements with coincident nodes get rigidly connected. {% endhint %} Snapping together of nodes does not apply to points given via the **“Pt”**-input-plug. This can be used for defining zero length springs – think e.g. of the bolt which connects the two pieces of a scissor mechanism. In such a case one can provide duplicate points via the **“Pt”**-input. Elements, which connect to these points do so in alternating fashion: the first element in the model connects to the first duplicate node, the elements after that to the second, and so on. The actual connection between the elements can be made via a spring with zero length as shown in fig. 3.1.1.2. The local axes of zero length spring elements correspond by default to the global coordinate system. In order to define zero length elements provide duplicate points at the **“Pt”**-input of the **“Assemble”**- and **“LineToBeam”**-component. Elements attach to these nodes in alternating fashion. ![Fig. 3.1.1.2: Zero length elements](/files/-MCkEZUxrAYMApN7Y-Fs) Cross sections of elements and materials can be defined either upon creating an element or at the **“Assemble”**-component. The latter option overrides the former and assigns cross sections and materials via element identifiers. Using regular expressions for selecting identifiers of elements provides a flexible means of attaching cross sections and materials to different parts of a model. The output-plug **“Mass”** renders the mass of the structure in kilogram and includes user specified point-masses. **“COG”** represents the position of the center of gravity. When being plugged into a panel the model prints basic information about itself: number of nodes, elements, and so on. At the start of the list the characteristic length of the model is given, which is calculated as the distance between opposing corners of its bounding box. # 3.1.2: Disassemble Model It is sometimes necessary to take apart existing models in order to 1. reassemble them in different configurations, 2. retrieve the results of e.g. a cross section optimization. The **“DisassembleModel”**-component can be used for decomposing a structural model into its components (see fig. 3.1.2.1). Resulting loads, supports and elements reference the nodes they connect to by position – regardless whether they were initially defined using coordinates or node-indexes. This allows to reuse parts of an old model and reassemble them in a new model where the node indexes have changed. At the **“CroSec”**- and **“Material”**-output only those cross sections and materials show up which were directly fed into the **“Assemble”**-component. In order to get all cross sections, it is necessary to disassemble the model elements. The cross section materials result from disassembling the cross sections. ![ Fig. 3.1.2.1: A model is decomposed into its components.](/files/-MCkEVpufe4D0PQaTlmX) {% file src="/files/lYZoWUGpkBYe7MY29TIM" %} # 3.1.3: Modify Model In case one wants to change the nodal positions of an existing model the **“DisassembleModel”**-component comes in handy. The **“Pt”**-input expects the list of new points to be used as the model's new nodal positions (see fig. 3.1.3.1). ![ Fig. 3.1.3.1: The “DisassembleModel”-component changes the nodal positions of model.](/files/-MCkERRQx_m9i9nGrErB) {% file src="/files/GnT2LVmI0ULbOEt7PwiF" %} # 3.1.4: Connected Parts When creating a model based on imprecise geometry or using a generative process, elements may not be connected to each other as desired. The **“Connected Parts”**-component (see fig. 3.1.4.1) takes a model as input and determines its connected parts. It considers beams and trusses only. Connected groups get listed in a data tree in descending order of group size. ![ Fig. 3.1.4.1: The “Connected Parts”-component](/files/-MCkEV60Fopr1njRvWUl) {% file src="/files/uR9w11HxKmP2WObIvScA" %} # 3.1.5: Activate Element The activation state of an element can be controlled with the **“Activate Element”**-component (see fig. 3.1.5.1). This component expects a model and a list of boolean values as input. The list of true/false values will be mapped to the activation status of the elements in the model. **“True”** corresponds to active, **“False”** to inactive. Section [3.5.9](/3-in-depth-component-reference/3.5-algorithms/3.5.9-beso-for-beams) shows, how the **“Activate Element”**-component enables one to view the solution history of the iterative **“BESO for Beams”**-algorithm. {% hint style="info" %} Karamba3D sets elements inactive by giving them a very weak material with zero weight. {% endhint %} {% file src="/files/RzBMYeuhquqPFXFw0LWR" %} ![ Fig. 3.1.5.1: Setting the activation state of all elements of a model with a list of boolean values.](/files/-MCkE_H1NpbQNRi7hpqW) # 3.1.6: Line to Beam Fig. 3.1.6.1 shows how the **“LineToBeam”**-component takes two lines as input, finds out how they connect and outputs beams as well as a set of unique points which are their end-points. Lines with end-points of identical index get automatically removed. Unless lines get removed, there is a one to one correspondence between the list of input lines and output beams. The **“LineToBeam”**-component accepts straight lines, polylines and splines as geometric input. Polylines get exploded into segments. Splines are intersected according to the parameters 'ToPAng', 'ToPTol' and 'ToPMinL' (see below for their meaning) . All coordinates are in meters (or feet in case of Imperial units). For Cross section design the buckling length assumed for the individual elements is of utmost importance. By default - when the input at **"SetBkl"** is 'True' - the distance between the end-points of a line, poly-line or spline forms the initial assumption for the buckling length of all thus created elements. An assumption for the buckling length is always given a negative sign but is taken as an absolute value in the design procedures. This assumption can be overridden via a ["ModifyBeam"-component](/3-in-depth-component-reference/3.1-model/3.1.10-modify-element#modify-beam) by the user by supplying a positive buckling length. In case that the simplified buckling length calculation done by Karamba3D (see section [3.6.8: Optimize Cross Section 🔷](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section)) leads to a larger value than the initial assumption then the larger value is applied. A User defined positive buckling length always wins over any assumptions. The **“Color”**-input lets one define a color for the rendering of elements. In order to display the colors activate the **“Elements”**-button in sub-menu **“Colors”** of the **“ModelView”**-component. In addition the option **“Cross section”** of the sub-menu **“Render Settings**” of the **“BeamView”**-component needs to be on. ![Fig. 3.1.6.1: The “LineToBeam”-component that turns two lines into beams](/files/-MjnaIKZ4kGGnKztZtO9) Elements can be given non-unique names via the **“Id”**-input . It takes a list of strings as identifiers for beams. The default value is an empty string. Each beam has a name by default: its zero based index in the model. Identifiers provide a useful means to group the beams in order to modify or display them. In case one wants to give multiple names to an element use the notation '&"id1"|"id2"|"id3"|...' or shorter '\&id1|id2|id3|...'. Similar to regular expressions this assigns the identifiers 'id1', 'id2', 'id3',... to a beam. Cross sections can be attached to elements with the **“CroSec”**-input. Cross section definitions via the **“Assemble”**-component override these settings. A click on the **“Options”** submenu heading reveals additional input-options of the **“LineToBeam”**-component: | Input | Property | | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **“Pts”** | The order in which points appear in the output node-list is random by default. However it is sometimes advantageous to identify certain points by their list index in order to put loads on them or to define supports. This can be achieved by feeding a list of coordinates into the **“Points”**-plug. They will be placed at the beginning of the output nodes-list. So in order that the end-points of the structure in fig. 3.1.6.1 have index 0 and 1 it is necessary to input a list of points with coordinates (0/0/0) and (8/0/0). | | **“New”** | If this plug has the value **“False”** only those lines will be added to the structure that start and end at one of the points given in the input points-list. | | **“Remove”** | If this option has the value **“True”** the **"LineToBeam"**-component checks for lines that lie on each other and merges such duplicates into one. This prevents an error that is hard to detect by visual inspection alone: Two lines on the same spot mean double member stiffness in the structural model. Alternatively apply the **“Remove Duplicate Lines”**-component from the Karamba3D utilities section on the list of incoming lines. This assures a one-to-one correspondence between lines and elements. | | **“LDist”** | Sets the limit distance for two points to be merged into one. Points supplied via lines count as identical if their distance is less than that given in **“LDist”**. The default value of **“LDist”** is $$5mm$$. The snapping of nodes does not apply to points supplied via the **“Pt”**-input-plug. The mechanism for attaching duplicate nodes to elements is identical to that used by the **“Assemble”**-component (see section [3.1.1](/3-in-depth-component-reference/3.1-model/3.1.1-assemble-model)). | | **“Z-Ori”** | The default orientation of beams and trusses is described in section [3.1.14](/3-in-depth-component-reference/3.1-model/3.1.14-orientate-element). The **“Z-Ori”**-input lets one define a non-standard direction for the local Z-axis. | | **“Bending”** | Allows to switch off the bending stiffness of beams. This turns them into trusses. For details see section [3.1.10](/3-in-depth-component-reference/3.1-model/3.1.10-modify-element). | | **"SetBklL"** | Set Buckling Length: If 'True' (the default) the buckling length in local Y- and Z- as well as for lateral torsional buckling is set as the distance between the endpoints of the input curve. If this length is smaller than the automatic estimate based on the connectivity of the element's endpoints it will be replaced by it. | | **"ToPAng"** | To Polyline Max Angle: For converting splines into polylines: Maximum angle (0 to pi) between tangents at adjacent vertices. | | **"ToPTol"** | To Polyline Tolerance: For converting splines into polylines: If tolerance = 0, the parameter is ignored. This parameter controls the maximum permitted value of the distance in the base unit for geometry input from the curve to the polyline. | | **"ToPMinL"** | To Polyline Min Edge-length: For converting splines into polylines: If maxEdgeLength = 0, the parameter is ignored. This parameter controls the maximum permitted edge length in the base unit for geometry input. | Beams that meet at a common point are by default connected rigidly in the structural model like they were welded together. See section [3.3.6](/3-in-depth-component-reference/3.4-joint/3.3.6-beam-joints) on how to define joints at the end of beams. The **“Info”** output-plug informs about the number of removed nodes and beams. In order to be of immediate use, beams come with a number of default properties. They can be seen in the top right string-output of fig. 3.1.6.1: **“active”** means that a beam will be included in the structural model. The default cross section is a circular hollow profile of diameter 114mm with a wall-thickness of 4mm. The default material is steel of grade “S235” according to Eurocode 3. {% file src="/files/eW6mxr2WmGcPRCLZI4u3" %} {% file src="/files/jbETb6GdrWjN1NvTY5dK" %} # 3.1.7: Connectivity to Beam In Grasshopper meshing algorithms can generate topological connectivity diagrams. With the help of the **“Connectivity to Beam”**-component these may be directly converted to beam-structures (see fig. 3.1.7.1). ![Fig. 3.1.7.1: The “Connectivity to Beam”-component turns connectivity diagrams into sets of beams](/files/-MCkEYSljixxAiFcEdOe) The input-plugs **“Z-Ori”**, **“Color”**, **“Id”** and **“CroSec”** have the same meaning as for the **“LineToBeam”**-component (see section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam)). # 3.1.8: Index to Beam Sometimes the initial geometry is already given as a set of points and two lists of node-indexes with one entry for each start- and end-point of beams respectively. In such a case it would be cumbersome to convert this information into geometric entities only for feeding it into the **“LineToBeam”**-component which reverses the previous step. The **“IndexToBeam”**-component (see fig. 3.1.8.1) accepts a pair of lists of node-indexes and produces beams with default properties from it. This speeds up model generation considerably for there is no need to compare nodes for coincident coordinates. ![Fig. 3.1.8.1: The “IndexToBeam”-component lets you directly define the connectivity information of beams](/files/-MCkEZZirfhMP1ieJZd9) The **“IndToBeam”**-component makes it possible to define elements with zero length. This proves useful in case you want to connect elements that touch each other but should not be rigidly connected (think of a scissor – see section [3.3.3](/3-in-depth-component-reference/3.3-cross-section/3.3.3-spring-cross-sections) about springs). The input-plugs **“Z-Ori”**, **“Color”**, **“Id”** and **“CroSec”** have the same meaning as for the **“LineToBeam”**-component (see section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam)). # 3.1.9: Mesh to Shell The **“MeshToShell”**-component takes a triangle or quad mesh and turns it into a group of shell or membrane elements (see fig. 3.1.9.1). Quads get automatically decomposed to triangles. Shell patches are rigidly connected when some of their nodes have the same index. Colors can be attached to shells via the **“Color”**-input. In order to enable the display of shell element colors, activate **“Elements”** in submenu **“Colors”** of the **“ModelView”**-component. In addition **“Cross section”** needs to be selected in the submenu **“Render Settings”** of the **“ShellView”**-component. Each patch of shells can be given an identifier via input **“Id”** for later reference when attaching custom material or cross section properties. By default shells have a thickness of $$1cm$$ and steel as their material. Use the **“CroSec”**-input to change that. Clicking on the **“Options”** submenu header further unfolds the component: The **“Pts”**- and **“LDist”**-input serve the same purpose as in the **“LineToBeam”**-component – see section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam). Additionally mesh faces with an area smaller than $$LDist^2 \cdot 0.1$$ get automatically removed. ![Fig. 3.1.9.1: The “MeshToShell”-component turns meshes into shells](/files/-Mgq2Jh2ToqyvOQNHxei) The shell elements used in Karamba3D resemble the TRIC-element devised by Argyris and coworkers (see [\[1\]](/appendix/bibliography), [\[2\]](/appendix/bibliography) for details). They are faceted (i.e. flat) elements. Karamba3D neglects transverse shear deformation in case of shell elements. ## Shells and Membranes In case of very thin shells the bending-stiffness can be neglected with respect to the in-plane stiffness. Thus one arrives at membrane elements with three translational degrees of freedom (dofs) per node. \ If "t" stands for the shell thickness then its bending stiffness is proportional to t³ whereas the in-plane stiffness varies with t. This leads to hugely different magnitues of entries in the element stiffness matrices and causes numerical problems in the solution procedure.\ Membrane elements result from the MeshToShell-component when the input-plug "Bending" is set to false. Flat assemblies of membrane elements have kinematic modes in transverse direction unless stabilized via positive $$N^{II}$$-values. # 3.1.10: Modify Element **“Modify Element”** is a multi-component which can be applied to shell-, beam- and truss elements. Use the drop-down list at the bottom of the component to select the type. By default Karamba3D assumes the cross-section of beams to be steel tubes with a diameter of 114mm and a wall-thickness of 4mm. Use the **“ModifyElement”**-component with **“Element Type”** set to **“Beam”** to set the beam properties according to your choice. Fig. 3.1.10.1 shows how this can be done. There are two variants for using the **“Modify Element”**-component: 1. Insert it in front of the “Assemble”-component and let element objects flow through it (see e.g. the modification of beams in fig. 3.1.10.1). By default the **“ModifyElement”**-component leaves all incoming elements unchanged. Several **“ModifyBeam”**-components may act consecutively on the same beam. 2. Create a stand-alone element-agent that can be fed into the **“Elem”**-input of the **“Assemble”**-component. The input-plug **“ShellId”** or **“BeamId”** let you select the elements to be modified. Use regular expressions to specify groups of elements. ![Fig. 3.1.10: Modification of the default element properties](/files/-MCkERhDnRwwSIXXNoNc) {% file src="/files/TvmND8vz2aAxdZdyaOj5" %} {% file src="/files/XDnaSquFnVAPMWE6xv26" %} {% file src="/files/Ar5Z2vAhubmIug9WSf3r" %} ## **Modify Beam** These element properties can be modified: ### Activation status of beams When input **“Active”** is set to false the corresponding beam is excluded from further calculations until **“Active”** is reset to true. See section [3.1.5](/3-in-depth-component-reference/3.1-model/3.1.5-activate-element) for an alternative way of setting a beam's activation state. ### Bending stiffness Beams resist normal forces and bending moments. Setting the **“Bending”**-input of the **“ModifyElement”**-component to **“False”** disables the bending stiffness and turns the corresponding beam into a truss. There exist reasons that motivate such a step: * Connections between beams that reliably transfer bending and normal force are commonly more expensive than those that carry normal force only. The design of connections heavily depends on the kind of material used: rigid bending connections in wood are harder to achieve than in steel. Yet rigid connections add stiffness to a structure and reduce its deflection. Therefore you are always on the safe side if you use truss elements instead of beams. * For slender beams i.e. beams with small diameter compared to their length the effect of bending stiffness is negligible compared to axial stiffness. Just think of a thin wire that is easy to bend but hard to tear by pulling. * Abandoning bending stiffness reduces computation time by more than half for each node with only trusses attached. * Karamba3D bases deflection calculations on the initial, undeformed geometry. Some structures like ropes are form-active. This means that when a rope spans between two points the deformed geometry together with the axial forces in the rope provide for equilibrium. This effect is not taken into account in Karamba3D first order theory (Th.I.) calculations. In such a case only the bending stiffness of the rope (which is very small) keeps it from deflecting indefinitely. One way to circumvent this lies in using a truss instead of a beam-element when doing first order analysis. The second possibility would be to reduce the specific weight of the rope to zero (see further below). The third possibility would be to start from a slightly deformed rope geometry and apply the external loads in small steps where the initial geometry of each step results from the deformed geometry of the previous one (see section [3.5.4](/3-in-depth-component-reference/3.5-algorithms/3.5.4-analyze-large-deformation)). Trusses only take axial forces. Therefore they do not prevent the nodes they are connected to from rotating. In case that only trusses attach to a node, Karamba3D automatically removes its rotational degrees of freedom. Otherwise the node could freely rotate which is a problem in static calculations. As soon as one beam with bending enabled connects to a node the node has rotational degrees of freedom. Bear this in mind when the **“Analysis”**-component turns red and reports a kinematic system. Transferring only axial forces means that a truss reduces a node's movability in one direction. A node that is not attached to a support has three translational degrees of freedom. Thus there must be three truss elements that do not lie in one plane for a node to be fixed in space. ### Height and Thickness of Cross-sections **“Height”** – which in case of circular tubes is equivalent to the outer diameter D – and wall-thickness of a cross-section influence a beams axial and bending stiffness. Karamba3D expects both input values to be given in centimeter. The cross-section area is linear in both diameter and thickness whereas the moment of inertia grows linearly with thickness and depends on $$D^3$$ for e.g. full rectangular sections and on $$D^2$$ for e.g. I-profiles and box sections. So in case of insufficient bending stiffness it is much more effective to increase a beams height (or diameter) than increasing its wall thickness. ### Local and Global Eccentricity of the Beam Axis The input-plugs **“EcceLoc”** and **“EcceGlo”** serve to set the eccentricity of the beam-axis with respect to the connection line between its endpoints. Both expect a three dimensional vector. **“EcceLoc”** refers the eccentricity to the local, **“EcceGlo”** to the global coordinate system. Eccentricities of beams can also be defined via the **“Eccentricity on Beam”**-component (see section [3.3.7](/3-in-depth-component-reference/3.3-cross-section/3.3.7-eccentricity-on-beam-eccentricity-on-cross-section)). ### Orientation of the Beam Lets you define the orientation of a beam. Works analogously to the orientate-beam-component (see section [3.1.14](/3-in-depth-component-reference/3.1-model/3.1.14-orientate-element)). ### Buckling property for cross section optimization Buckling can be turned off for cross section optimization. This lets you simulate pre-tensioned, slender elements without having to really pretension them. The necessary pretension force is roughly the negative value of the largest compressive axial normal force of all load cases. ### Buckling length in local beam directions For doing cross section optimization it is necessary to know a beam’s buckling length. Karamba3D approximates it using the algorithm described in section [3.5.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section). For cases of system buckling this approximation does not lie on the safe side. The input-plugs **“BklLenY”**, **“BklLenZ”** and **“BklLenLT”** allow to specify the buckling length of a beam for its local Y- and Z- axis respectively as well as for lateral torsional buckling. When specified, these values override those from the buckling length calculation of Karamba3D. The value **“lg”** sets the distance of transverse loads from the center of shear of the cross section. It defaults to zero. Positive values mean that the loads point towards the shear center and thus act destabilizing for lateral torsional buckling. The property **“lg”** influences the beams utilization with respect to lateral torsional buckling according to Eurocode 3. ### Second order theory normal force $$N^{II}$$ Axial normal forces influence the stiffness of a beam in second order theory (Th.II) calculations. If compressive they lower, in case of tension they increase its bending stiffness. Think of a guitar string which vibrates at a higher frequency (i.e. is stiffer) under increased tension. In Karamba3D the normal force which impacts stiffness -$$N^{II}$$- is independent from the normal force which actually causes stresses in the cross section$$N$$. This enables one to superimpose second order theory results on the safe side by choosing $$N^{II}$$ as the largest compressive force$$N$$of each beam. {% file src="/files/kSm076ob0Z0FaVpHlTzP" %} ## **Modify Shell** ### Height Sets a uniform cross section height throughout the shell. ### Second order theory normal force $$N^{II}$$ As for beams, $$N^{II}$$for shells specifies the in-plane normal force which impacts stiffness in case of second order theory calculations. It is a force per unit of length assumed to be of same magnitude in all directions. {% file src="/files/h42DEhYHVVpaIO7dur4j" %} # 3.1.11: Point-Mass Karamba3D is capable of calculating the natural vibration modes and frequencies of structures (see section [3.5.7](/3-in-depth-component-reference/3.5-algorithms/3.5.7-natural-vibrations)). For results to match reality the inertia properties of a structure need to be modelled correctly. Masses of elements (e.g. beams, trusses, shells) are automatically taken care of. All other items need to be included via point-masses. {% hint style="info" %} Be aware of the fact that masses defined with the **“Point-Mass”**-component do not have a weight but inertia only! They also do not add to the mass of a model as output at the **"Assemble"**-component. {% endhint %} Thus they effect only the calculation of natural frequencies. The “Point-Mass” component expects a mass in kilogram at its input-plug **“Mass”** (see fig. 3.1.11.1). Nodes where masses shall sit can be identified by supplying node indexes or positions (just like for point-loads). Point masses get displayed as green spheres. Their diameters result from the volume calculated as mass divided by density. The latter defaults to $$7850kg/m^3$$ (steel) and can be provided at the input-plug-**“rho”**. ![Fig. 3.1.11.1: Vibration mode of beam with point mass in the middle](/files/-MCkE_9c2YJjQZQnrfLv) {% file src="/files/C8wMe3eRe8hFmLzqS8dB" %} # 3.1.12: Disassemble Element When interested in the information contained in a beam or shell element feed it into the **“DisassembleElement”**-component (see fig. 3.1.12.1). The component contains several subsections which can be unfolded by clicking on the dark menu header. ![ Fig. 3.11.12.1: A beam decomposed into its individual parts](/files/-MCkEW3vNx5HN13yqS5H) {% hint style="info" %} The output of "BklLenY", "BKlLenZ" and "BklLenLT" may contain negative values: A negative sign indicates that the corresponding length-value was automatically calculated and not set by the user (see section [3.6.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section) regarding the assumptions used for the automatic calculation of the buckling length).\ In all calculations the absolute values for the buckling length will be used. {% endhint %} {% file src="/files/rDH6InPmzXXWjkb07vFw" %} {% file src="/files/T1MoxIkazb9MHoJxjuoC" %} {% file src="/files/vYyM0HOQ9iAvNkBCRznr" %} # 3.1.13: Make Beam-Set 🔷 The **“Make Beam-Set”**-component provides a practical way for grouping different elements under one identifier (see fig. 3.1.13.1). Beam-sets need not be disjoint. The **“Beam Id”**-plug expects a list of strings with beam-identifiers, beam indexes, other beam-set-identifiers or a regular expression. Regular expressions have “&” as their first character by definition. **“Set Id”** expects a string which serves as identifier of the new set of beams. ![ Fig. 3.1.13.1: Beam-sets can be used to group beams](/files/-MCkE_s1tBBca8hHka3v) The group of beams defined by a set can be used for defining geometric mappings. In this context a beam-set represents a polygon of straight segments. The order of the elements in the set is defined by the order in which they were entered into the set. Such polygons can be split at an arbitrary position (see e.g. section [3.8.15](/3-in-depth-component-reference/3.8-utilities/3.8.15-connecting-beams-with-stitches#simple-stitch)). **“MinSLen”** (minimum segment length) lets you set the minimum length which may result from such a split. In case of potentially smaller segments the intersection point snaps to its nearest neighbor. In order to group a structure visually, beam-sets can be given different colors. These colors show when **“Cross section”** is enabled in the **“BeamView”-**component’s **“Render Settings”** (see section [3.6.7](/3-in-depth-component-reference/3.6-results/3.6.7-beamview)) and the option **“Elements”** in the submenu **“Colors”** of the **“ModelView”**-component is on. The identifier of a beam-set can be used anywhere instead of a beam identifier. In order to be registered with the model, beam-sets need to be fed into the **“Set”** input-plug of the **“Assemble”**-component. {% file src="/files/Mo4duEpMyELqvlQi4mnf" %} {% file src="/files/vAPgtERq9xf73TrMFQMo" %} {% file src="/files/jUVu4aqwG3H4N8NWddKg" %} # 3.1.14: Orientate Element **“Orientate Element”** is a multi-component where the drop-down list under **“Element Type”** lets one select between beams and shells. ## **Orientate Beam** In Karamba3D the default orientation of the local coordinate system of a beam or truss follows these conventions: * The local X-axis (of red color) is the beam axis and points from starting-node to end-node. * The local Y-axis (green) is at right angle to the local X-axis and parallel to the global XY-plane. This specifies the local Y-axis uniquely unless the local X-axis is perpendicular to the XY-plane. If this is the case, the local Y-axis is chosen parallel to the global Y-axis. The default criteria for verticality is, that the z-component of the unit vector in axial direction is larger or equal to $$0.999 999 995$$. This value can be changed in the ["karamba.ini"](broken://pages/-MCkEPuOOhTAZq37mVOn) file via the “limit\_parallel” property. * The local Z-axis (blue) follows from the local X- and Y-axis so that the three of them form a right-handed coordinate system. ![ Fig. 3.1.14.1: Controlling the orientation of local beam coordinate system](/files/-MCkEa0OfqdQMR2glw_a) The local coordinate system affects the direction of locally defined loads and the orientation of the element’s cross section. Use the **“Orientate Beam”-**component to set the local coordinate system (see fig. 3.1.14.1): * The input plug **“X-axis”** accepts a vector. The local X-axis will be oriented in such a way that its angle with the given vector is less than 90 degree. This allows to give a consistent orientation to a group of beams. * The local Y-axis lies in the plane which is defined by the local X-axis and the vector plugged into the **“Y-axis”**-input. If the Y-axis is parallel to the beam axis it is not applicable to the element. * If no vector is supplied at the **“Y-axis”**-input or the given Y-axis is not applicable, then the local Z-axis of the beam lies in the plane which is defined by the local X-axis and the vector plugged into the “Z-axis”-input. * **“Alpha”** represents an additional rotation angle (in degree) of the local Z-axis about the local X-axis. In order to control the orientation of a beam, the **“Orientate Beam”**-component can be applied in two ways: 1. **“Flow-through”**: Plug it in between a **“LineToBeam”**- and an **“Assemble”**-component. The changes will be applied to all beam elements which pass through it. In case of shell elements the output is “Null”. 2. **“Agent”:** Specify beams by identifier via input **“BeamId”** and plug the resulting beam-agent directly into the **“Elem”**-input of the **“Assemble”**-component. This method allows to harness the power of regular expressions for selecting elements (see section [3.1.15](/3-in-depth-component-reference/3.1-model/3.1.15-select-beam)). {% file src="/files/EVROWEGE81sTPjjJrg8Q" %} {% file src="/files/SVhzdA4K4I2Qmltv2eet" %} {% file src="/files/IzixwAMei1x9YMhh8JE6" %} ## **Orientate Shell** For shells the default orientation of their local coordinate systems can be seen in fig. 3.1.14.2. The following convention applies: The local x-axis is parallel to the global x-direction unless the element normal is parallel to the global x-direction. In that case the local x-axis points in the global y-direction. The local z-axis is always perpendicular to the shell element and its orientation depends on the order of the vertices of the underlying mesh face: If the z-axis points towards ones nose, the order of the face vertices is counter-clockwise (See fig. 6.17 in [\[12\]](/appendix/bibliography) for an unforgettable way of remembering the right-hand rule of rotation.). ![ Fig. 3.1.14.2: Default orientation of the local shell coordinate systems](/files/-MCkEa0QGVJRBkOqFJYi) The **“Orientate Shell”**-component lets one control local x- and z- directions of the faces which make up a shell: **“X-Oris”** and **“Z-Oris”** inputs expect lists of direction vectors, one for each mesh face. In case the number of vectors does not match the number of faces the longest list principle applies. Infeasible directions (e.g. a prescribed z-vector which lies in the plane of an element) get ignored. Regarding the application of the **“Orientate Shell”**-component the same two options (**“flow-through”** or **“agent”**) exist as for the **“Orientate Beam”**-component. ![ Fig. 3.1.14.3: User defined orientation of the local shell coordinate systems](/files/-MCkEa0R02CqURGCOLTu) {% file src="/files/BX7dHOHHhdcniILtMRdx" %} {% file src="/files/E0vslMip2Rcc4K5uHo5A" %} # 3.1.15: Dispatch Elements All structural elements can be given identifiers, i.e. names. Names are case sensitive and need to start with a letter or underscore. After the first initial letter numbers and letters may follow. Names need not be unique: Two elements can have the same name without Karamba3D complaining. Each element has a default identifier: its index. This is the reason why it is not allowed to have an integer number as an element identifier. Fig. 3.1.15.1 shows how a list of elements can be split into two data trees using their identifiers. The **“Dispatch Elements"**-component expects a list of elements in **“Elems”** as well as a list of identifiers or regular expressions in **“Id”**. Regular expressions need to be prefixed by a “&”. They represent a very mighty selection tool. In fig. 3.1.15.1 one can see three use-cases: * “&.\[1-2]”: a “.” matches any character; “\[1-2]” matches one character in the range of “1” to “2”. This is equivalent to “\[12]”. * “\&b.”: matches any identifier that starts with “b” followed by an arbitrary character. * “&.\[13]”: matches any identifier that starts with an arbitrary character followed either by “1” or “3”. ![Fig. 3.1.15.1: Elements can be selected by using their identifiers](/files/-MjnozcZXiGCm-UQ00Cg) There are two output-plugs on the **“Select Beam”**-component: **“SElem”** renders the selected elements which match the selection criteria, **“RElem”** returns the rest. The entries of the **“SElem”** and **“RElem”** output data remember their spot in the original list of elements. Joining them results in the original order of elements. # 3.1.16: Select Elements Use the **"Select Elements"**-component for getting element with specific properties. The resulting elements can later on used to retrieve results or calculate their mass, surface, volume or meshes (see component "Element Query"). Fig. 3.1.16.1. shows how this works: the input-plugs 'ElemIds', 'Colors', 'CrosSecs', 'Materials', 'LenInter' and 'ElemTypes' can be supplied with lists of element identifiers, element colors, cross sections, materials, length intervals and type indexes. The values in each input-plug form criteria via 'OR'. in fig. 3.1.16.1 the selected elements may have purple or red color for example. The individual input-plugs are connecte via 'AND': in the image below the selected element needs to be named 'Membrane\_D' and be of color red or purple and needs to be either a membrane or shell and so on. in case of shells and membranes the length refers to the diagonal of their axis aligned bounding box. For 1-D Elements it is simply their length. The element types are indexed starting with zero. Right-click on the component-icon and select 'Expand ValueLists' to make the Value-list input appear. ![Fig. 3.1.16.1: Selection of elements via identifiers, colors, cross sections, materials, size and type.](/files/-MjnvMuPa9Cmg61MWDsx) {% file src="/files/gHq03LYKhO46ra3fzqBu" %} {% file src="/files/ZlB0DbEdncdHAecNMLQI" %} {% file src="/files/YcnyQtTxrYbZ8OZpwK72" %} {% file src="/files/T5olZTf2ljU4XPrSFoQB" %} # 3.1.17: Support Without supports a structure would have the potential to freely move around in space. This is not desirable in case of most buildings. Thus there should always be enough supports so that the structure to be calculated can not move without deforming i.e. exhibits no rigid body modes. When defining the supports for a structure one has to bear in mind, that in three dimensional space a body has six degrees of freedom (DOFs): three translations and three rotations (see fig. 3.1.17.1). The structure must be supported in such a way that none of these is possible without invoking a reaction force at one of the supports. Otherwise Karamba3D either refuses to calculate the deflected state or renders very large displacements. Sometimes you get results from moveable structures although you should not: The reason for this lies in the limited accuracy of computer-calculations which leads to round-off errors. Sometimes one is tempted to think that if there act no forces in one direction – consider e.g. a plane truss – then there is no need for corresponding supports. That is wrong: What counts is the possibility of a displacement. ![Fig. 3.1.17.1: Metaphor for the six degrees of freedom of a body in three-dimensional space](/files/-MCkERBi-R4LXw9qywEI) Errors in defining support conditions are easy to detect with Karamba3D: In section [3.5.6](/3-in-depth-component-reference/3.5-algorithms/3.5.6-eigen-modes) it is shown how to calculate the Eigen-modes of a structure. This kind of calculation works even in cases of moveable structures: rigid body modes – if present – correspond to the first few eigenmodes. Fig. 3.1.17.2 shows a simply supported beam. The **“Support”**-component takes as input either the index or the coordinates of the point to which it applies. ![Fig. 3.1.17.2: Define the position of supports by node-index or position](/files/-Mhs2siJVhWajIqdui2j) By default the coordinate system for defining support conditions is the global one. This can be changed by defining a plane and feeding it into the **“Plane”**-input plug of the **“Support”**-component. Six small circles on the component indicate the type of fixation: The first three correspond to translations in global x, y and z-direction, the last stand for rotations about the global x, y and z-axis. Filled circles indicate fixation which means that the corresponding degree of freedom is zero. The state of each circle can be changed by clicking on it. In addition to the radio bottons the supported degrees of freedom can also be specified parametrically using the input-plug **"Dofs"**. It expects a list of integer values where the numbers '0' to '5' stand for Tx to Rx. Right-click on the component and select 'Expand ValueLists' to get a ValueList-component as shown in fig. 3.1.17.2. The string output of the component lists node-index or nodal coordinate, an array of six binaries corresponding to its six degrees of freedom and the number of load-case to which it applies. Supports apply to all load cases by default. Supports cause reaction forces. These can be visualized by activating **“Reactions”** in the **“Display Scales”** section of the **“ModelView”**-component (see section[ 3.6.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview)). They show as arrows with numbers in green – representing forces – and purple – representing moments. The numbers either mean$$kN$$in case of forces or $$kNm$$ when depicting moments. The orientation of the moment arrows corresponds to the screw-driver convention: They rotate about the axis of the arrow anti-clockwise when looked at in such a way that the arrow head points towards the observer. (See fig. 6.17 in [\[12\]](/appendix/bibliography) for an unforgettable way of remembering the right-hand rule of rotation.). From the support-conditions in fig. 3.1.17.2 one can see that the structure is a simply supported beam: green arrows symbolize locked displacements in the corresponding direction. The translational movements of the left node are completely fixed. At the right side two supports in y- and z-direction block rotations about the global y- and z-axis. The only degree of freedom left is rotation of the beam about its longitudinal axis. Therefore it has to be blocked at one of the nodes. In this case it is the left node where a purple circle indicates the rotational support. ![Fig. 3.1.17.3: Influence of support conditions – undeformed and deflected geometry](/files/-MCkERBmpLAKFfQd_pWf) The displacement boundary conditions may influence the structural response significantly. Fig. 3.1.17.3 shows an example for this: Left: All translations fixed at supports, Right: One support moveable in horizontal direction. When calculating e.g. the deflection of a chair, support its legs in such a way that no excessive constraints exist in horizontal direction – otherwise you underestimate its deformation. The more supports one applies the stiffer the structure and the smaller the deflection under given loads. In order to arrive at realistic results introduce supports only when they reliably exist. By default the size of the support symbols is set to approximately $$1.5m$$. The slider with the heading **“Support”** on the **“ModelView”**-component lets you scale the size of the support symbols. Double click on the knob of the slider in order to set the value range. {% file src="/files/V9ycLjn6M5w1Y3D9Ycqu" %} {% file src="/files/GfKFMbGAbRH0JAjS4GHl" %} {% file src="/files/p1cjLBUBRmmSkawVerwx" %} # 3.2: Load This chapter contains information regarding defining loads, disassembling mesh loads and setting prescribed displacements for supports. # 3.2.1: General Loads Currently Karamba3d offers these general types of loads: gravity-, point-, imperfection-, pretension-, temperature-loads, constant mesh-loads, variable mesh-loads and prescribed displacements at supports. For beam and truss elements additional options exist (see section Beam Loads). The types of loads discribed in this section apply to all types of elements.\ An arbitrary number of point-, mesh-, etc.-loads and one gravity-load may be combined to form a load-case of which again an arbitrary number may exist. Fig. 3.2.1.1 shows the definition of loads with the help of the **“Loads”** multi-component. On the bottom of the **“ModelView”**-component (see section [3.6.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview)) there is a drop-down-list (unfold it by clicking on the **“Result-case Selection”**-menu header) which can be used to select single load-cases for display. Select **“–all–”** in order to view all existing load-definitions of all load-cases simultaneously. Use the force-slider to scale the size of the load-symbols (double-clicking on its knob lets you change the value range and its current value). ![Fig. 3.2.1.1: Simply supported beam with five loads](/files/-MCkEaSKSxZ00ag08Ljq) ## **Gravity** It is the default setting when you place a **“Loads”**-component on the canvas. Each load case may contain zero or one definition for the vector of gravity. In this way one can e.g. simulate the effect of an earthquake by applying a certain amount of gravity in horizontal direction. For Vienna, which has medium earthquake loads, this amounts to approximately 14 % of gravity that a building has to sustain in horizontal direction. In areas with severe earthquake loads this can rise to 100 % (the value however also depends on the stiffness properties of the structure and underlying soil). Gravity applies to all active elements in the structural model for which the specific weight gamma (see section [3.4.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)) is not zero. The gravity vector defines the direction in which gravity shall act. A vector of length one corresponds to gravity as encountered on earth. When working in SI-units Karamba3D assumes a value of $$10m/s^2$$ for the acceleration of gravity. In case of Imperial units $$g = 9.8066352 m/s^2$$ is used. Otherwise the conversion from pound mass to pound force does not work. The value of $$g$$ can be set in the [“karamba.ini”](broken://pages/-MCkEPuOOhTAZq37mVOn)-file, which resides in the Karamba3D installation folder. {% file src="/files/1cVU5CyyYm2miuMonurR" %} ## **Point-Load** The component **“Point-Load”** lets you define loads on nodes. These get attached by node-index or coordinate. In order to find out the index of a specific node enable the **“node tag”**-checkbox in the **“ModelView”**-component. Feed a corresponding list of items into the **”Pos|Ind”**-plug (quite analogous to the **“Support”**-component). See section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam) on how to predefine the index of specific nodes or node-position. Point-loads can be either forces ($$kN$$) or moments ($$kNm$$). Feed a force- or moment-vector into the **“Force”** or **“Moment”** input-plug. Its components define the force or moment in global x-, y- and z-direction. When set to **“True”** the boolean input **“Local?”** makes loads and moments follow the nodal rotations in large displacement calculations (see section [3.5.4](/3-in-depth-component-reference/3.5-algorithms/3.5.4-analyze-large-deformation)). Plugging a point-load into a panel component gives the following information: Node-index where the load gets applied or position, force-vector, moment vector, the number of load case to which it belongs and whether the load is tied to the nodal coordinate system. By default point loads will be put into load case zero. Any positive number fed into the **“LCase”**-plug defines the load case to which the corresponding load will be attributed. A value of $$-1$$ signals that the load acts in all existing load cases. Be cautious in case of nodes where only truss- or membrane-elements attach: these nodes do not possess rotational degrees of freedom. A moment load will therefore have no effect and gets automatically removed from the structure. For more information on loads and some typical values see section [A.2.3](/appendix/a.4-background-information/a.4.3-tips-for-designing-statically-feasible-structures#table-a-3-2-loads-for-typical-scenarios). {% file src="/files/1jehHnU9dfwAZLZDa3nd" %} {% file src="/files/4KhSDDg93l8LIaMKsOny" %} ## ~~**Imperfection-Load**~~ With Karamba3D 2.2.0 this load option was moved to the "Beam Loads"-component (see section [3.2.2](/3-in-depth-component-reference/3.2-load/3.2.2-beam-loads)). ## **Initial Strain-Load** Karamba3D lets you define initial strains. Fig. 3.2.1.3 shows a beam with both ends fixed, subject to a positive initial constant strain and curvature. The unit of dimension of the pretension which gets fed into the **“Eps0”** plug is $$mm/m$$. {% hint style="info" %} A positive value means that the element gets longer. {% endhint %} ![ Fig. 3.2.1.3: Member under initial strains fixed at both ends and support reactions](/files/-MCkEaSYA1_oYgeDNapB) Applying initial strain to an element is not the same as applying a pair of opposite forces or moments at its endpoints: In case of initial strain, the axial force in the element depends on its boundary conditions: If the structure to which it connects is very stiff then the resulting axial force will be $$N = -\epsilon \_0 \cdot A \cdot E$$. In fig. 3.2.1.3 the supports are rigid, the elements cross section $$A = 25 cm^2$$, Young’s Modulus $$E = 21000 kN/cm^2$$ and $$\epsilon \_0 = 0.00015$$. This results in an axial force of $$N = -78.75 kN$$ and shows up as horizontal support reactions. When the rest of the structure does not resist, then a pretension-load merely results in lengthening or shortening the corresponding element. The **“Kappa0”**-input is a vector of curvature values with respect to the local element axes. A positive component value signifies an anti-clockwise rotation about the corresponding axis. The input plug **“ElemIds”** defines the elements where the load acts and **“LCase”** the load-case. {% file src="/files/qCvxpRZQb6HnWag0kuSN" %} {% file src="/files/oA5U8PIq6ou8nNIKesAH" %} {% file src="/files/4JMn8MUeT7uGgEstkQh6" %} {% file src="/files/frPmCyHNtyRaOysvJGL8" %} {% file src="/files/Rod86MBOA9zc0HCU4DvJ" %} {% file src="/files/95sGe8IsOEienksoINRa" %} {% file src="/files/wZS6hFPLONBJkrLIAEEm" %} {% file src="/files/mDUvjgebNpamGaOLDnTH" %} {% file src="/files/slNGqWKuJZU5MNCV7F81" %} {% file src="/files/POLlpfjzEHs33WkfzpSS" %} {% file src="/files/aWjTVIiP0Ny6MuF3heX8" %} {% file src="/files/jSIHtlARBKeeinIlTuEc" %} ## **Temperature-Load** The definition of temperature loads works analogously to defining pretension loads (see section [3.2.1](/3-in-depth-component-reference/3.2-load/3.2.1-loads#initial-strain-load)). The coefficient of thermal expansion (see section [3.4.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)) characterizes the response of a material to temperature changes. ![ Fig. 3.2.1.4: Temperature load on a member which is fixed at both ends](/files/-MCkEaS_R2NRIYOf4Ad7) ## ~~**Line-Load on Element**~~ With Karamba3D 2.2.0 this load option was moved to the "Beam Loads"-component (see section [3.2.2](/3-in-depth-component-reference/3.2-load/3.2.2-beam-loads)) where it is available as **'Block'**-load. ## **Mesh-Load: Const and Variable** ### Mesh The **“MeshLoad”**-component can be used to transform surface loads into equivalent node- or element-loads. This lets you define life-loads on floor slabs, moving loads on bridges (see example “Bridge.ghx” in the [examples ](https://www.karamba3d.com/examples/)collection on the Karamba3D web-site), snow on roofs, wind-pressure on a facade, etc.. The mesh where the load is applied and the underlying structure do not need to be connected. It needs to be fed into the **“Mesh”**-input-plug. ### Vec There exist two types of mesh-loads: 1. **“MeshLoad Const”**: for loads which are constant throughout the mesh. 2. **“MeshLoad Var"**: lets one set specific load-values for each face of the mesh. These two variants differ with respect to the data-structure expected at the input **“Vec”** and **“Vecs”** respectively: Either a single vector for specifying a constant load or a list of vectors. In the latter case the list items are applied to the mesh-faces based on the longest list principle. In what follows the **“MeshLoad Const”**-variant will be depicted but everything mentioned there applies to **“MeshLoad Var”** also. ![Fig. 3.2.1.6: Simply supported beam with line-loads from a mesh load](/files/-MCkEaSbmLhg9BK7U5fj) Fig. 3.2.1.6 left side shows a simply supported beam and a mesh which consists of two rectangular faces. Each face covers one half of the beam and has a width of $$2m$$ perpendicular to the beam axis. With a distributed load of $$1kN/m^2$$ in negative global Z-direction a uniformly distributed load of 2 $$kN/m$$ results. ### Pos In order to define structure nodes where equivalent point-loads may be generated, plug a list of their coordinates into the **“Pos”**-plug. These need to correspond to existing nodes – otherwise the Assembly-component turns red. Offending nodes will be listed in its run-time error message. By default all points of the structure are included. Uncheck **“Point loads”** to avoid point-loads. ### BeamIds With the input-plug **“BeamIds”**, groups of elements can be specified on which equivalent loads shall be generated. By default all beams of the model are included. In case no beam loads shall be included uncheck the **“Line loads”** button on the **“Generation”** submenu. The procedure for calculating nodal loads and uniformly distributed beam loads from surface loads consists of the following steps: First Karamba3D calculates the resultant load on each face of the given mesh. Then the resultant load of each face gets evenly distributed among its three or four vertices. The second step consists of distributing the vertex-loads among the nodes of the structure. In order to arrive at beam loads additional helper-nodes along their axes get generated. The mutual distance of those is chosen equal to a third of the mean edge length of the given mesh. Each mesh vertex transfers its load to the nearest node. In case that there are several nodes within a radius of less than **“LDist”** as set at the Assemble-component (see section [3.1.1](/3-in-depth-component-reference/3.1-model/3.1.1-assemble-model)) the vertex load gets evenly distributed among them. The loads received by the helper-nodes along beam axes get summed up and divided by the element length. This results in the approximately equivalent uniformly distributed load which is placed on the element. From the procedure described, one can see that a crude mesh may lead to a locally incorrect distribution of loads. In the system shown in fig. 3.2.1.6 the points closest to the vertices are the element’s end-points. Therefore the helper nodes along the beam-axis do not receive a share in the mesh-load and thus no line-load results. ![Fig. 3.2.1.7: Simply supported beam with point loads from a mesh load](/files/-MCkEaSg_7GI20-SQu4d) Fig. 3.2.1.7 shows a similar setting as in fig. 3.2.1.6. The difference lies in the refined mesh with more vertices along the beam axis. Now loads from the mesh vertices get distributed also to the helper nodes along the element axis. This leads to the generation of a uniform line-load. ### LCase Set the **“LCase”**-input to the index of the load case in which the surface load shall act. Indexing of load-cases starts with zero, “−1” is short for all load cases. ### Orientation The right side of fig. 3.2.1.7 shows what data the **“MeshLoad const”**-component collects: The input-plug **“Vec”** expects a vector which specifies the surface load. Its physical unit is kilo Newton per square meter $$kN/m^2$$. The orientation of the load-vector depends on the checkbox selected under **“Orientation”** (see also fig. 3.2.1.8): * **"local to mesh”**: The convention for local coordinate systems for local loads corresponds to that given in section [3.1.14](/3-in-depth-component-reference/3.1-model/3.1.14-orientate-element#orientate-shell): The local x-axis is parallel to the global x-direction unless the mesh-face normal is parallel to the global x-direction. In that case the local x-axis points in the global y-direction. The local z-axis is always perpendicular to the mesh-face and its orientation depends on the order of the vertices: If the z-axis points towards ones nose, the order of the face vertices is counter-clockwise. This means a surface load with components only in Z-direction acts like wind pressure or suction. * **“global”**: The force-vector is oriented according to the global coordinate system. This makes the surface load behave like additional weight on the mesh plane. * **“global proj.”**: The force-vector is oriented according to the global coordinate system. The corresponding surface load is distributed on the area that results from projecting the mesh-faces to global coordinate planes. In such a way the action of snow load can be simulated. ![ Fig. 3.2.1.8: Orientation of loads on mesh: (a) local; (b) global; (c) global projected to global plane](/files/-MCkEaSl5Yc1PDDOYQ5B) ### Generation By default, the **“MeshLoad const”**-component creates point- and line-loads. The radio-buttons in the submenu **“Generation”** can be used to disable the first or the latter. {% file src="/files/ci4XjGYCErGXkQpYiFhm" %} {% file src="/files/lBMrXAVeTDa3zAJXRIme" %} {% file src="/files/WFBmEAweZfxqmIc8hdr2" %} {% file src="/files/oe090P0MjLInxqTxLMGs" %} {% file src="/files/Mc4bOlgc7a2VjY8awX5R" %} # 3.2.2: Beam Loads The group of loads described in this section works on beams and - with some limitations - on truss elements. The latter are considered as shear rigid with hinges at their ends: Beam-loads on trusses transform into transverse forces at their end-points.\ All beam load-components feature the "BeamID"- and "LCase"-input-plug: * "BeamId" determines the element on which to apply the load. A regular expression like '&"id1"|"id2"|...' selects multiple elements. * "LCase" specifies the name of the load's load-case. The parameter "t" serves to specify the load-position along elements: t=0 refers to the starting point, t=1 to the end-point. Karamba3D offers these types of beam-loads: ## Concentrated Load Use the 'Concentrated'-option to specify forces and moments at arbitrary positions along the element. Vectors 'Force' and 'Moments' let one set the direction and size of the corresponding external loads. Fig 3.2.2.1 shows a cantilever with a span of 3m under a concentrated transverse load of 1kN. The load sits at a distance of 0.75 x 3.00 = 2.25m from the supports and causes a linear bending moment diagram. ![Fig 3.2.2.1: Cantilever beam with concentrated transverse load: support reactions and My-diagram](/files/-MgoFep0X47oH3BLvzeA) The radio buttons in the sub-menu 'Orientation' determine the reference coordinate system of the 'Force'- and 'Moment'-vectors: either local to the element or global. {% file src="/files/6e2VSHSsOzxmhjQIh7nC" %} {% file src="/files/C7YJ86dkctEwHWVhiOag" %} ## Block Load Fig. 3.2.2.2 shows the application of uniformly distributed transverse loads an on a cantilever beam. The span of the cantilever is two meters. The loads act between t0=0.25 and t1=0.75. With the default values t0=0 and t1=1 distributed block-loads cover the whole beam length. The graphical output in fig. 3.2.2.2 shows the support reactions well as the bending-moment-diagram (in orange) for My. In combination with the radio buttons in sub-menu "Orientation" the vectors at the input-plugs "Force" and "Moment" sets the external loads to be applied - see fig. 3.1.2.8 for the meaning of the different types of orientation. ![Fig. 3.2.2.2: Cantilever beam with constant transverse load: support reactions and My-diagram](/files/-Mgo80JEx_uy8BX1ZTV2) There are limitations for distributed rotational loads: In case they rotate about the element's local Y- or Z-direction they need to be specified over the whole length. This does not apply to distributed torsional moments when the Orientation is set to 'Local to element'. The input-plug **“BeamId”** receives the identifier of the beam on which the load shall act. Multiple beams can be specified via a regular expression (e.g. '&"id1"|"id2"...'). See section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam) for how to attach identifiers to beams. By default beams are named after their index in the FE-model. There are three options for the orientation of the load: **“local to element”**, **“global”** and **“global proj.”**. Their meaning corresponds to the options available for mesh-loads (see fig. 3.2.1.8). The input-plug **“LCase”** which designates the load case defaults to “0”. {% file src="/files/9Ieg1gW1xceVLuiTXJl8" %} {% file src="/files/uNX1r4CTK4onxXbHfq3o" %} {% file src="/files/bSj69KCQrh0IakdUub6U" %} {% file src="/files/ofpP2za4zzFLjw6KwhZ5" %} {% file src="/files/ISHK0mLFWknN3CRP5XBl" %} ## Gap Load With Gap-loads it is possible to prescribe rotation or displacement discuntinuities at arbitrary element-positions. When using unit vectors are used, the resulting displacement shapes represent influence lines (see e.g. ). Fig 3.2.2.3 shows a fully fixed beam under a translational gap load of 0.1m in local z-direction. The displaced shape shows, that in order to maximize the shear force Vz at the location of the gap-load one should place transverse external loads either to the left or right side of the gap only. ![Fig. 3.2.2.3: Fully fixed beam with gap-load wz=0.1\[m\]](/files/-MgoJhuUMVNc5dgEaVNY) {% file src="/files/HI0ZrnyYzHEdZIQIf7ur" %} {% file src="/files/zxJ6AL9HY5M7QnqM8uiw" %} {% file src="/files/ijYprcUVV7q9yys6RTLm" %} ## Imperfection There exists no such thing as an ideally straight column positioned perfectly vertical. The deviation of a real column from its ideal counterpart is called imperfection. This term comprises geometric and material imperfections. The **“Imperfection”** variant of the **“Loads”** multi-component allows to specify geometric imperfections (see fig. 3.2.2.4). **“psi0”** takes the vector of the initial inclination of the beam axis about the axes of the local element coordinate system in radians. With **“kappa0”** one can specify the initial curvature. A positive component of curvature means that the rotation of the middle axis about the corresponding local coordinate axis increases when moving in longitudinal beam direction. Small inclinations and curvatures are assumed. ![Fig. 3.2.2.4: Imperfection Loads](/files/-MCkEaSVQk5XlgYX-8Gn) \ In fig. 3.2.2.4 one can see displacements and reaction forces of an initially straight beam with a second order theory normal force of $$N^{II} = 10 kN$$, an initial inclination of $$0.1 rad$$ about the local y-axis and an initial curvature of $$0.1 rad/m$$. Imperfection loads do not add directly to the beam displacements. They act indirectly and only in the presence of a normal force $$N^{II}$$. An initial inclination $$\psi\_0$$ causes transverse loads $$\psi\_0 \cdot N^{II}$$ at the elements endpoints. An initial curvature $$\kappa\_0$$ results in a uniformly distributed line load of magnitude $$\kappa\_0 \cdot N^{II}$$ and transverse forces at the elements endpoints that make the overall resultant force zero. For details see e.g. [\[10\]](/appendix/bibliography). {% file src="/files/x5rljjMVrCbw205hIoDd" %} ## Polylinear Load Distributed loads consisting of an arbitrary number of linear segments can be defined via the "Polylinear" option (see fig. 3.2.2.5). The input-plug "Dir" specifies the direction of the load. The vector supplied there gets scaled to unity and has no impact on the load magnitudes. The latter get set by lists of values connected to the "Force" or "Moment" inputs. For each value supplied there needs to be a corresponding location parameter "ts". In case there are more location parameters than force or moment-values the longest list principle applies like in fig. 3.2.2.5. ![Fig. 3.2.2.5: Cantilever beam under poly-linear transverse distributed load](/files/-MgoaLxnxqzA-0e1Kpj8) In case of subsequent identical t-values and different corresponding load-values a step in the distributed load results. {% file src="/files/4tdyMpVdfR8pHl9zFLrT" %} ## Trapezoidal Load The 'Trapezoidal'-option makes it more convenient to specify trapezoidal loads as compared to 'Polylinear'. Teh parameter input is simlar to that of block-loads. The four parameters t0, t1, t2 and t3 specify the trapezoids shape. ![Fig. 3.2.2.6: Cantilever beam under trapezoidal transverse distributed load](/files/-MgoeRFPJ3VXaje65MKy) {% file src="/files/dfDV55iD5waWd2w2WK5l" %} # 3.2.3: Disassemble Mesh Load The procedure for distributing mesh-loads on a structure can be computationally heavy. The **“Disassemble Mesh Load”**-component lets one freeze a mesh-load. It returns the point- and element-loads which were originally generated for reuse with another structure (see fig. 3.2.3.1). One has to make sure that the parts of the geometry on which the original mesh-load acted did not change too much. Point-loads are defined using their position, element-loads refer to their elements via element-index. In order to reuse the latter, the corresponding element-indexes of the new and old model need to match. ![ Fig. 3.2.3.1: The “Disassemble Mesh Load”-component splits mesh-loads into point- and element-loads](/files/-MCkE_EMQsrBkQiW9s9h) {% file src="/files/u2KU9qozJWqzEoOgxSwk" %} # 3.2.4: Prescribed displacements Supports as described in section [3.1.16](/3-in-depth-component-reference/3.1-model/3.1.16-support) are a special case of displacement boundary conditions: They set the corresponding degree of freedom of a node to zero. The more general **“Prescribed Displacement”**-component lets you preset arbitrary displacements at nodes. Fig. 3.2.4.1 shows a beam with prescribed, clockwise rotations at both end-points. {% hint style="info" %} The term “displacement” as used throughout this manual includes translations and rotations. {% endhint %} The **“PreDisp”**-component resembles the **“Support”**-component to a large degree: Nodes where displacement conditions apply can be selected via node-index or nodal coordinates. The **“Plane”**-plug can be used to define an arbitrarily oriented coordinate system for the application of support conditions. In order to find out the index of a specific node enable the **“node tag”**-checkbox in the **“ModelView”**-component. Input-plug **“LCase”** lets you set the index of the load-case in which displacements shall have a specified value. The default value is “−1” which means that the displacement condition is in place for all load-cases. It is not possible to have displacement boundary conditions active in one load-case and completely disabled in others: For load-cases not mentioned in **“LCase”** the **“PreDisp”**-component will act like a simple support with fixed degrees of freedom equal to zero. ![Fig. 3.2.4.1: Deflection of a beam under predefined displacements at its end-supports](/files/-Mhs5i3oHqHw8iLGQe5e) The **“Trans”**- and **“Rot”**-input-plugs expect vectors. They define nodal translations and rotations either in global coordinates or in the coordinate system defined by the plane fed into the **“Plane”**-input plug. Translations are to be given in meter (or feet), rotations in degree. The X-component of the rotation vector describes a rotation about the coordinate systems X-axis. A positive value means that the node rotates counter-clockwise if the X-axis points towards you. Analog definitions apply to rotations about the Y- and Z-axis. Karamba3D is partly based on the assumption of small deflections. Thus be aware that large prescribed displacements and rotations give rise to incorrect results in case of geometric linear calculations. For approximating effects due to large displacements see e.g. section [3.5.4](/3-in-depth-component-reference/3.5-algorithms/3.5.4-analyze-large-deformation). Displacements can only be prescribed if the corresponding displacement degree of freedom is removed from the structural system. This means you have to activate the corresponding button in the Conditions-section of the **“PreDisp”**-component. The first three buttons stand for translations the last three for rotations. In addition to the radio bottons the prescribed degrees of freedom can also be specified parametrically using the input-plug **"Dofs"**. It expects a list of integer values where the numbers '0' to '5' stand for Tx to Rx. Right-click on the component and select 'Expand ValueLists' to get a ValueList-component as shown in fig. 3.2.4.1. {% hint style="info" %} Only those components of the **“Trans”**- and **“Rot”**-vectors take effect which correspond to activated supports. {% endhint %} # 3.3: Cross Section Karamba3D offers cross section definitions for beams, shells and springs. They can be generated with the “Cross Sections” multi-component. Use the drop-down list on the bottom to chose the cross section type. The dimensions of each cross section may be defined manually or by reference to a list of cross sections (see section [3.3.10](/3-in-depth-component-reference/3.3-cross-section/3.3.10-cross-section-selector)). ![ Fig. 3.3.1: Cantilever with four different kinds of cross section](/files/-MCkE_1b0HeeV2XZd87f) Cross sections can be plugged directly into the components for creating elements (**“LineToBeam”**, **“MeshToShell”**, …). Alternatively when fed into an **“Assemble”**-component (see fig. 3.3.1) they act on the elements whose identifiers match the string given via **“Elem|Id”**. In case an element is provided at the **“Elem|Id”**-input, its identifier is used for attaching the cross section to elements. A cross section added via the **“Assemble”**-component overrides a cross section provided directly at an element-creation-component. The indirect cross section specification through the **“Assemble”**-component has the advantage that elements can be specified using regular expressions. Upon assembly all element identifiers are compared to the **“Elem|Id”** entry of a cross section. In case of a match the cross section is attached to the element. An empty string – which is the default value – signifies that the cross section shall be applied to all elements. If two cross sections refer to the same element then that which gets processed later by the assemble-component wins. It makes no sense to attribute beam cross sections to shells and vice versa – Karamba3D ignores any such attempts. {% file src="/files/SDnerMED0TuhEAn4U4GQ" %} {% file src="/files/ouRLqwXsXFKYsyZ7syTw" %} # 3.3.1: Beam Cross Sections Karamba3D offers five basic types of beam cross section: * circular tube – the default * hollow box section * filled trapezoid section * I-profile ![ Fig. 3.3.1: Cantilever with four different kinds of cross section](/files/-MCkE_1b0HeeV2XZd87f) Fig. 3.3.1 shows a cantilever with cross section properties defined directly at the **“LineToBeam”**-component. Without eccentricities defined, the beam axis always coincides with the centroid of a cross section. Changing e.g the upper flange width of an I-section therefore results in a slight movement of the whole section in the local Z-direction. In case the position of e.g. the upper side of a cross section needs to be fixed, specify an eccentricity. This can be done either via a specific component (see section [3.3.7](/3-in-depth-component-reference/3.3-cross-section/3.3.7-eccentricity-on-beam-eccentricity-on-cross-section)) or through the input-plug **“Ecce-loc”**. Provide a vector there in order to move the cross sections relative to the beam axis. The given eccentricity is relative to the local coordinate system of the beam. The resulting position of the centroid can be retrieved from the **“Disassemble Cross Section”**-component (see section [3.3.4](/3-in-depth-component-reference/3.3-cross-section/3.3.4-disassemble-cross-section)). Apart from the input-plugs that define the cross section geometry, the **“Elem|Id”**- and the **“Ecce-loc”**-input there are: | | | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **“Family”** | Each cross section belongs to a family. When doing cross section optimization (see section [3.5.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section)), Karamba3D selects only profiles that belong to the same family as the original section. Families can be composed of arbitrary section types | | **“Name"** | The identifier of a cross section – need not be unique. Enable **“CroSec names”** in **"ModelView"**s **“RenderSettings”**-submenu in order to view them. | | **“Color”** | Lets one define a color for a cross section. In order to see it enable **“Cross sections”** in submenu **“Colors”** of the **“ModelView”**-component and activate **“CroSec section”** in submenu **“Render Settings”** of the **“BeamView”**-component. | | **“Material”** | Sets the material of the cross section. Indirect material assignments via the **“Assemble”**-component override direct definition of the cross section material. | # 3.3.2: Shell Cross Sections In Karamba3D there are four different kinds of shell cross sections: | | | | ----------------------- | --------------------------------------------------------------------------------------------------------------- | | **"Shell Const”** | For shells with constant thickness and material over all mesh faces. | | **“Shell Var”** | Lets one specify the thickness and material of each face of the shell-mesh individually. | | **“ShellRC Std Const”** | This allows to specify a standard (Std) reinforced concrete(RC) cross section which is constant over the shell. | | **"ShellRC Std Var”** | The same as above but lets one choose the reinforced concrete properties differently for each element. | ## **Constant and Variable Shell Cross Sections** The components **“Shell Const”** and **“Shell Var”** only differ in the data structures expected at the inputs **“Material(s)”** and **“Height(s)”**. In case of **“Shell Const”** these are data items. The **“Shell Var”**-variant expects two lists. The descriptions below refer to the **“Shell Var”**-component. Fig. 3.3.2.1 shows a shell consisting of two elements. Triangular meshes form the basis for defining a shell geometry (see section [3.1.9](/3-in-depth-component-reference/3.1-model/3.1.9-mesh-to-shell)) and specify the sequence of faces (i.e. shell elements). The list of element thicknesses in fig. 3.3.2.1 corresponds to that order. Be aware of the fact that meshes containing quads will be automatically triangulated. In case that there are more mesh faces than thickness specifications, the last item ($$6cm$$ in this case) acts as the default value. The same holds for the supplied list of materials. Make sure to graft the **“Materials”**- and **“Heights”**-input when you want to define a list of shell cross sections. Otherwise one cross section results where one would expect several. For the **“Shell Const”** definition no data tree manipulation is necessary in such a case. ![Fig. 3.3.2.1: Shell made up of two elements with different thicknesses](/files/-MCkESBDflYaqt9ihted) When rendering the shell cross sections (see fig. 3.3.2.1) thicknesses get linearly interpolated between the nodes. The cross section height at each node results from the mean thickness of shell elements attached to it. The input-plugs **“Family”**, **“Name”**, **“Color”** and **“Materials”** have the same meaning as described in section [3.3.1](/3-in-depth-component-reference/3.3-cross-section/3.3.1-beam-cross-sections). ## **Constant and Variable Reinforced Concrete Shell Cross Sections** The design of reinforced concrete cross sections in Karamba3D is based on linear elastic cross section forces. The **“Optimize Reinforcement”**-component takes these and computes the necessary reinforcement assuming cracked concrete cross sections. Thus defining reinforced concrete cross sections does not alter the mechanical behavior of the structure. They rather serve as input to the reinforcement design procedure. Similar to shell cross sections there exist two variants of components for reinforced cross sections: | | | | ----------------------- | -------------------------------------------------------------------------------------------------------------- | | **“ShellRC Std Const”** | For shells with constant height, material and reinforcement. It saves the user thoughts about data trees. | | **“ShellRC Std Var”** | This component allows to specify different heights, materials and reinforcement for each face of a shell mesh. | Further below variant two will be explained. The **“ShellRC Std Const”**-component works similar to the variable-variant. The only difference are the data structures expected at the inputs. ![Fig. 3.3.2.2: Shell made up of two elements with different properties](/files/-MCkESBE6idAGhjrD_2w) Fig. 3.3.2.2 shows the definition for a reinforced concrete shell with two faces with different thicknesses, materials and reinforcement definitions. The geometry corresponds to that of fig. 3.3.2.1. A standard reinforced concrete cross sections consists of five layers: Layer zero is the concrete cross section. The layers one to four correspond to reinforcement. The top layer (with respect to where the local z-axis points to) comes first, the bottom layer last. Their orientation with respect to layer zero is 0°, 90°, 90° and 0°. Besides the standard inputs of cross sections (**“Family”**, **“Name”**, **“Elem|Id”** and **“Color”**) the **“ShellRC Std Var”**-component offers these: | | | | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **“Materials-Concr”** | Expects a list of materials to be used for the concrete cross section. The items of this list get mapped to the shell elements according to the longest list principle. “C30/37” according to Eurocode 2 represents the default concrete. | | **“Heights”** | Heights of the concrete cross sections for each shell face. The longest list principle applies. The default height is$$20cm$$. | | **“Materials-Reinf”** | List of materials to be used as reinforcement for each element – by default “BSt 500” according to Eurocode 2 with a characteristic strength of $$50 kN/cm^2$$. Again the longest list principle applies. | | **“Areas”** | Expects a data-tree with a maximum of four entries per branch. The values define the minimum reinforcement for each layer. The physical unit is centimeter. Thus the areas of the reinforcement bars need to be divided by their mutual distance in order to arrive at an equivalent plate thickness. The layer thicknesses default to $$0cm$$. | | **“Covers”** | Input here a data-tree with four values per branch. These specify the position of the reinforcement layers with respect to the upper and lower side of the concrete cross sections. Positive values give the distance from the upper, negative values the distance from the lower side towards the interior. Without any input the covers default to $$3.5cm$$, $$4.5cm$$, $$-4.5cm$$ and $$-3.5cm$$. | | **“Dirs”** | Reinforcement layers can be given an angle with respect to the local shell coordinate system. A positive value rotates in anti-clockwise direction about the local z-axis. A value of zero – which is the default – aligns the first and last layer with the local x-axis. The angle of rotation can be specified for each shell face individually. | With the input-plug **“LayerInd”** of the **“ShellView”**-component one can select specific layers for visual inspection and results retrieval. {% file src="/files/FwzU64jZJ86SzxU4fL1M" %} {% file src="/files/u42rT17tCyyNw2TrVOIC" %} # 3.3.3: Spring Cross Sections Springs allow you to directly define the stiffness relation between two nodes via spring constants. Each node has six degrees of freedom (DOFs): three translations and three rotations. Using the **“Cross Sections”** multi-component with **“Cross Section”** set to **“Spring”** lets one couple these DOFs by means of six spring-constants. A relative movement $$u\_{i,rel}$$ between two nodes thus leads to a spring force $$F\_i = c\_i \cdot u\_{i,rel}$$. In this equation $$u\_{i,rel}$$ stands for a relative translation or rotation in any of the three possible directions x, y, z, $$c\_i$$ is the spring stiffness. In Karamba3D the latter has the meaning of kilo Newton per meter $$kN/m$$ in case of translations and kilo Newton meter per radiant $$kNm/rad$$ in case of rotations. The input-plugs **“Ct”** and **“Cr”** expect to receive vectors with translational and rotational stiffness constants respectively. Their orientation corresponds to the local beam coordinate system to which they apply. In case of zero-length springs this defaults to the global coordinate system but can be changed with the **“OrientateBeam”**-component. In case one wants to realize a rigid connection between two nodes the question arises as to which spring stiffness should be selected. A value too high makes the global stiffness matrix badly conditioned and can lead to a numerically singular stiffness matrix. A value too low results in unwanted relative displacements. So you have to find out by trial and error which value gives acceptable results. ![Figure 3.3.3.1: Spring fixed at one end and loaded by a point load on the other](/files/-MCkEYcQDpy36YTnQ_XN) Fig. 3.3.3.1 shows a peculiarity one has to take into account when using springs: They are unaware of the relative position of their endpoints. This is why the load on the right end of the spring does not evoke a moment at the left, fixed end of the spring. {% file src="/files/jng7DwT8tGSLb8KYDTJ0" %} {% file src="/files/Ch5a2GJPgvXunbepYpDB" %} {% file src="/files/4NN0kjYjz3AIbjtc1a8d" %} {% file src="/files/ESGSWp7EnsWmP1XevcpU" %} # 3.3.4: Disassemble Cross Section 🔷 In some cases (e.g. after optimizing cross sections) it may be necessary to retrieve the properties of a cross section. Use the **“Disassemble Cross Section”**-component for that (see fig. 3.3.4.1). Unfold the component sub-sections by clicking on the dark section headers. ![Fig. 3.3.4.1: “Disassemble Cross Section”-component - Properties of a given cross section can be retrieved ](/files/-MCkE_ZXe0qPhNxeGu7r) # 3.3.5: Eccentricity on Beam and Cross Section 🔷 ![Fig. 3.3.5.1: Beam positioned eccentrically with respect to the connection line of its two end-nodes](/files/-MCkEZ3j78u2dzaBKvN-) Cross section forces of beam and truss elements relate to the line that connects the cross section centroids. When a cross section changes, chances are high that also the position of its centroid shifts. In case of elements predominantly loaded by bending moments, such a shift can normally be neglected. In the presence of normal forces however – e.g. when considering columns – changes in the centroid position lead to additional bending moments that may be decisive for a members cross section design. In Karamba3D there exist two components that can be used to take care of eccentricities (see fig. 3.3.5.1): One works on beams, the other on cross sections. When both variants of definition coincide for an element, then the eccentricities get combined. This enables one to define families of cross sections of different size with e.g. the position of their upper sides at one level. The definition of a local eccentricity for cross sections with a **“Eccent-CroSec”**-component is straight forward: The **“EcceLoc”**-input plug expects a vector that defines the offset with respect to the local beam axes. Values are in centimeters. **“x”** represents the longitudinal beam axis, **“y”** is horizontal or parallel to the global Y-axis, **“z”** points vertically upwards (see section [3.1.14](/3-in-depth-component-reference/3.1-model/3.1.14-orientate-element#orientate-beam)). Cross sections with eccentricities can be stored in cross section tables using the **“Generate Cross Section Table”**-component and thus be made reusable in other projects. The **“Eccent-Beam”**-component has one additional input-plug as compared to the cross section variant: **“EcceGlo”** lets one define beam eccentricities ($$cm$$) with respect to the global coordinate system. {% file src="/files/wNpkObWuzqBFrcsFxP2f" %} {% file src="/files/dDXmeRr5mzyndVIb1t2B" %} {% file src="/files/3XuM6MEUOxQownieiJrX" %} # 3.3.6: Modify Cross Section 🔷 In Karamba3D cross section properties fall into four categories: | | | | ----------------- | ---------------------------------------------------------------------------------------------------------------- | | **“General”** | parameter which set the name, family, color, material and element identifier | | **“Geometry”** | properties that determine the cross section size and eccentricity | | **“Deformation”** | these parameters influence the elastic behavior of a structure | | **“Resistance”** | properties which are used by cross section design procedures in order to determine the load-bearing capabilities | The meaning of the input-values in the menu sections "Deformation" and "Resistance" are given in the help-texts associated to each input-plug. The **“Modify Cross Section”**-component allows to change these properties. Two operation modes exist for this component: **Flow through:** When a Cross section is provided as input, the result on the left side is the same cross section by default. Only those properties get changed, for which values are supplied as input. **Agent:** The cross sections which shall be modified can be selected via the **“Elem-Ids”**-input. It is possible to apply regular expressions. The resulting cross section agent is of type **“Cross Section”** and gets active when being plugged into an **“Assemble”**-component. ![Fig. 3.3.6.1: ModifyCroSec Component](/files/-MCkEY8kkE37SyRmfnWl) Fig. 3.3.6.1: the definition of a simply supported beam under uniform load. A **“Modify CroSec”**-component can be used to impose shear rigidity in local z-direction on a cross section. Now the calculated maximum displacement coincides with the result of the formula without shear effects. Textbook formulas for calculating the maximum displacement of such a system usually neglect the influence of shear-deformations. In order to make a cross section nearly rigid in shear the **“Modify Cross Section”**-component is used to set the shear area $$A\_z$$ to a very large value. In case the height or thickness of a cross section is changed along with deformation- or resistance parameters, the evaluation proceeds from top to bottom: First, all parameters get updated according to the new cross section dimensions, these may then be overwritten by new values for deformation of resistance properties. The drop-down list at the bottom of the component allows to switch between beam- and shell-cross sections. {% file src="/files/DJti6J43ppNszyv3Fa79" %} # 3.3.7: Cross Section Range Selector The cross section library that comes with Karamba3D contains roughly 22 000 profiles. In order to reduce the amount of information the list can be shortened by applying selection criteria on it using the **“Cross Section Range Select”** component (see fig. 3.3.7.1). The input-plugs **“maxH”** and **“maxW”** let you limit the list according to maximum cross section height and width. The submenu which unfolds when clicking on the black **“select”**-bar offers further options for narrowing the search: country of origin, general shape and family name. ![ Fig. 3.3.7.1: Selection of a range of cross sections from among a given list](/files/-MCkEZp5dwhWxzY9eKVU) In case one does not supply a list of cross sections at the **“CroSec”** input-plug, the cross section table that comes with Karamba3D is used by default. # 3.3.8: Cross Section Selector The component **“CroSecSelect”** deals with selecting cross sections by name or index from a list of cross sections. Provide the name(s) or index(es) of desired cross sections in the **“Name|Ind”**-plug. Cross section names are not case sensitive. All characters coming after “#” count as remark. It is possible to use regular expressions for selection (these start with “&”). List indexes start from zero. **“CroSecSelect**” lets you specify beams via the **“Elems|Ids”**-plug which shall be assigned a specific cross section. The **“Assemble”**-component sets the cross-sections of these elements accordingly. Alternatively, cross sections can be directly plugged into the element-creation-components. In case one does not supply a list of cross sections at the **“CroSec”**-input-plug, the cross section table that comes with Karamba3D is used by default. ![Fig. 3.3.8.1: Cantilever with four different cross sections taken from the standard cross section table](/files/-MCkEZArx42Z-xJ-GSOe) {% file src="/files/lDIi7MV7ePe9agYxSEI2" %} {% file src="/files/g0vUasKhH0VGmLkJG1RC" %} # 3.3.9: Cross Section Matcher Use the **“Cross Section Matcher”**-component in case you want to find the first profile from a given list that provides equal or higher resistance compared to a given custom profile (see fig. 3.3.9.1). The **“CSMatch”**-component takes a cross section and a list of cross sections as input. Traversing the list starting from the first element it proceeds until an appropriate profile is found which is returned as the result. ![Fig. 3.3.9.1: The “Cross Section Matcher”-component returning a standard profile for a custom profile](/files/-MCkEYiQqTg_NMb_INjE) {% file src="/files/PdKEgiFra3FIwlVH15Qm" %} # 3.3.10: Generate Cross Section Table ![Fig. 3.3.10.1: The “Cross Section Matcher”-component returning a standard profile for a custom profile.](/files/-MCkE_6TyU3jltVZZ8JG) An entry in a cross section table consists of a row which contains: * "country": country of origin * “family”: name of the group to which the cross section belongs (see section [3.3.1](/3-in-depth-component-reference/3.3-cross-section/3.3.1-beam-cross-sections)) * “name”: name of the specific cross section (see section [3.3.1](/3-in-depth-component-reference/3.3-cross-section/3.3.1-beam-cross-sections)) * a “shape” field which defines the basic cross section type: * “I”: I-section * “\[]”: hollow box section * “V”: trapezoid, filled section * “O”: circular tube * "S”: spring * “Sh”: shell * geometric properties which are used for drawing the cross section * area, moments of inertia, etc. that define the cross section's mechanical behavior. Can be independently defined from the cross section geometry {% hint style="info" %} A **“#”** in the first column means that the corresponding row serves as a comment. {% endhint %} The **“GenCSTable”**-component takes a cross section (or a list of cross sections) as input and returns the equivalent table of data as a string. The physical units used for output are always metric. When plugged into a panel the information can be streamed to a file which then constitutes a valid cross section table. Karamba3D reads the data of cross section tables only once. So in order that changes in a table take effect, restart Grasshopper. It is possible to save the table data in different formats via the component's context menu (right-click on the component icon to make it appear). The menu item "Save cross section table to file" leads to a "save"- dialog where the drop down list "Save as type" allows to select between bin-, dat- and csv-format. The binary format (.bin) is recommended for large tables since it loads fast. However bin-files are not readable in text editors. # 3.3.11: Read Cross Section Table from File ![Fig. 3.3.11.1: List of cross sections generated from the standard cross section table](/files/-MCkE_lZW00kbrOMuwVR) Predefined cross sections stored in a csv- or bin-database can be used to generate lists of cross sections via the **“ReadCSTable”**-component (see fig. 3.3.11.1). It works along the same lines as the **“ReadMatTable”** (see section [3.4.3](/3-in-depth-component-reference/3.4-material/3.4.3-read-material-table-from-file)) component. When given no path to a valid table **“ReadCSTable”** uses the list of cross sections comes with Karamba3D and is situated in “…/Grasshopper/Libraries/Karamba/CrossSectionValues.bin”. This table contains definitions for a range of standard steel profiles. Depending on the given file extension the data is expected to be either in binary format (“.bin”) or comma separated values (“.csv”). The former has the advantage of fast processing, the latter can be viewed and extended using a text editor or OpenOffice. In csv-files “#” is used to mark the rest of a line as comment. The physical units are always assumed to be metric – irrespective of the user settings at installation. In case of an entry in a csv-file in the first column which is not a “#”, the cross section properties get calculated based on the geometric dimensions of the cross section. In case of a deviation between the given and the calculated values of more than 10 % a warning is output at the **“Info”**-plug. When opening the Karamba3D installation folder (double-click on the Karamba3D desktop icon for that) you will find three differently named cross section tables: “CrossSectionValues.bin” and “CrossSectionValues\_sortedForHeight.bin” contain cross sections sorted according to increasing height. In “CrossSectionValues\_sortedForWeight.bin” the area and thus weight per unit of length determines a cross sections relative position within a family. When doing cross section optimization (see section [3.5.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section)) those two sorting options lead to different results. Depending on external requirements they result in structures of minimum cross section height or structural weight. # 3.4: Joint # 3.4.1: Beam-Joints 🔷 A structure usually consists of a large number of load bearing elements that need to be joined together. When rigidly connected, such a joint has to transfer three section forces (one axial force, two shear forces) and three moments (one torsional and two bending moments). Depending on the type of material such full connections are sometimes (e.g. for wood) hard to achieve, costly and bulky. A solution to this problem consists in introducing hinges. ![Fig. 3.4.1.1: Beam fixed at both supports with a fully disconnected joint at one end](/files/-MCkESfQZHseB9els-jv) Fig. 3.4.1.1 shows a beam under dead weight with fully fixed boundary conditions at both end-points. At the right end the joint (which is in fact no joint any more) completely dissociates the beam from the support there. The result is a cantilever. The symbols for joints resemble that for supports: pink arrows represent translational joints, white circles symbolize moment hinges. In Karamba3D joints are realized by inserting a spring between the endpoint of a beam and the node to which it connects. This necessitates sufficient support conditions at the actual nodes to prevent them from freely moving around. See for example the right node in fig. 3.4.1.1 which has to be fully fixed – otherwise the system would be kinematic. The **“Beam-Joint”**-component allows to define hinges at a beam’s starting- and end-node. A list of beam-identifiers lets you select the beams where the joint definition shall apply. Filled circles mean that the corresponding degrees of freedom represent joints. **“T”** stands for translation, **“R”** for rotation. Feed the resulting cross-section into the **“Joint”**-plug of the **“Assemble”**-component. The orientation of the axes of the joints corresponds to the local coordinate system of the beam they apply to. Sometimes the stiffness of connections lies between fully fixed and zero. With the input-plugs **“Ct-start”** and **“Cr-start”** it is possible to set the stiffness of the hinge in translation $$(kN/m)$$ and rotation$$(kNm/rad)$$ respectively at the start of the element. **“Ct-end”** and **“Cr-end”** provide the same functionality for the end-point. In order to make the definition of hinges accessible to optimization the input-plugs **“Dofs-start”** and **“Dofs-end”** can be used to set hinges at the beams endpoints with a list of numbers. Integers in the range from 0 to 5 signify degrees of freedom to be released in addition to those specified manually with the radio-buttons. {% file src="/files/I9NpOjZxRTu5SMyYuTqC" %} {% file src="/files/bOgvwvWw8zknMDBg2o9y" %} {% file src="/files/haFB9BcRhbbTRQ4mMcja" %} {% file src="/files/IsDBHrvIzP2oA4YTaIO9" %} {% file src="/files/Q3RhxX3Z7d5O2XR3Kqm7" %} {% file src="/files/gD6zDiJWzv0HpkOo5ZPU" %} {% file src="/files/4wHCtYZzmXcf0Fc3JC9F" %} {% file src="/files/qIbMu0TCTgK9mk7ftbtO" %} # 3.4.2: Beam-Joint Agent 🔷 ![Fig. 3.4.2.1: Defining a hinge based on geometric relations using a “Beam-Joint Agent”-component](/files/-MCkE_VrLfIVuI4O-B3r) The **“Beam-Joint Agent”**-component creates hinges on beams based on geometric relations. Fig. 3.3.2.1 shows three different but equivalent possibilities for defining a joint. The element or the group of elements where the joint(s) shall be placed is set by providing a list of element identifiers at the **“AtElemsIds”** input-plug. Upon assembly, the beam-joint agent tests the model-elements and places hinges when **all** of the following conditions - in case specified by the user - apply: * The node on the at-element connects to an element whose identifier is listed in the **“ToElemIds”** input. * The node on the at-element connects to a node which has a number listed in the **“ToNodeInd”** input. * The node on the at-element lies on one of the geometric items supplied in **“ToGeom”**. This can be points, curves, planes, breps or meshes. The tolerance for two geometric items touching in space is **“LDist”** as defined on model assembly (see section [3.1.1](/3-in-depth-component-reference/3.1-model/3.1.1-assemble-model)). The meaning of **“Ct”**, **“Cr”** and **“Dofs”** is analogous to that of the Beam-Joints-component featured in section [3.4.1](/3-in-depth-component-reference/3.4-joint/3.3.6-beam-joints). {% file src="/files/Or6oXVgpA6Pep3dS5Vkr" %} {% file src="/files/B8YgkbHqp356dZ0I9Ew8" %} {% file src="/files/1yHI6Wq3tMOmQOSxZCMM" %} # 3.4.3: Line-Joint The "Line-Joint"-component lets one specify linear hinges inside or at the boundary of shell-patches. ![Fig. 3.4.3.1: Line-joint symbolized by a purple line between two shell patches "A" and "B"](/files/-MgplL81abIByBtKOXlP) Fig. 3.4.3.1 shows an example which involves two shell patches "A" and "B" made up of two shell elements each. Patch "A" is fully fixed on one side and connects to "B" via a linear joint symbolized by a purple line. Shell "B" can rotate about the joint's X-axis given by the read arrow on the purple line. The "Line-Joint"-component provides these inputs to specify the non-rigid connections between shells: * "J-Curve": A line-like curve which connects the nodes of shell which are part of the line-joint. The direction of the curve specifies the joint's X-direction. * "AtElemId": Identifier of the shell patch on which the joints shall be specified. The default is an empty string which signifies that the joijnt is potentially attached to all shells in the model. * "Y-Ori": sets the joint's local Y-axis. It points towards the shell patch on which the joint shall be attached. When "Joints" is enabled in the "ModelView"-component the Y-axis appears as a green arrow on the hinge line. * "Z-Ori": In case the joint's Y-direction is (0,0,0) or parallel to the joint-line direction, the joint's tripod gets created via the joint-line's X-direction and the Z-orientation. The joint gets attached to those elements which the joints Y-axis points to. The Z-axis is symbolized by a blue arrow when displayed via the ModelView-component. * "DAlpha": Maximum angle \[deg] between a mesh-face and the Y-Ori for adding a line-joint to it. * "Ct": Vector of translational spring stiffness of the line-joint.Values take effect only, if the corresponding DOF is set to hinged in the "Dofs"-input of via the radio buttons in the submenu "Joint definition". * "Cr": Vector of rotational spring stiffness. Is analogous to "Ct". * "Dofs": List of degree of freedom indexes (0:Tx, 1:Ty, 2:Tz, 3:Rx, 4:Ry, 5:Rz) to be released in addition to those selected via the check-boxes in the sub-menu "Joint definition". Add a 'ValueList'-component for easy selection or use 'Expand ValueLists' from the component's context menu. The radio-buttons under "Joint definition" signify released joint DOFs when enabled. In order to see the joint's local coordinate system enable "Joints" in the "Display Scales"-submenu of the "ModelView"-component. The "Local axes"-slider in the same submenu can be used to scale the arrows. {% file src="/files/4eeehJjwGqhg6cEBjXJZ" %} {% file src="/files/xuQu89MqUaxW5pF5aAbk" %} {% file src="/files/bKi8MXxw2oyQABc28H47" %} # 3.5: Material There are two ways for defining materials in Karamba3D: Either select a material by name from a list of materials (see section [3.4.2](/3-in-depth-component-reference/3.4-material/3.4.2-material-selection)) or set mechanical material properties manually (see below). {% hint style="info" %} The Appendix (see section [A.2.1](/appendix/a.4-background-information/a.4.1-basic-properties-of-materials)) contains additional information on mechanical properties of materials. {% endhint %} Materials constitute a property of cross sections. There are two ways of attaching materials to cross sections: 1. In order to directly assign a material to a cross section, plug it into the corresponding cross section creation component. This is overridden by indirect material definitions via the **“Assemble”** component as described below. 2. Materials (like cross sections) may be plugged into the **“Assemble”** component. They know about the elements (or element sets) they apply to by their **“Elems|Ids”** property: This is a list of strings containing element identifiers (see section [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam)) or regular expressions that match a group of element identifiers (element-ids). Upon assembly each element-id is compared to all **“Elems|Ids”** entries of a material. In case they match the material is attached to the element. An empty string – which is the default value – signifies that the material shall be applied to all elements. # 3.5.1: Material Properties The component **“MatProps”** lets one directly define isotropic and orthotropic materials. Use the dropdown menu at the bottom of the component to chose between ortho- and isotropic materials. ## **Isotropic Material Properties** ![Fig. 3.5.1.1: Definition of the properties of two isotropic materials via the “Material Properties” component](/files/-Mgu6Ps56ZRCVP4aeA57) In Fig. 3.5.1.1 selection of the second material from the resulting list can be made (bottom right component) or selection from the default material table (top right component). Material isotropy means that the material’s behaviour does not change with direction. Karamba3D uses the following parameters to characterize an isotropic material (see fig. 3.5.1.1): | | | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Family"** | Family name of the material (e.g. “steel”); is used for selecting materials from a list. | | **"Name"** | Name of the material (e.g. “S235”); serves as identification when selecting materials from a list. | | **"Elem\|Id"** | An element with an identifier, a string containing an identifier or a regular expression that depicts the elements that shall have the specified material. | | **"Color"** | Color of the material. In order to see it, enable **“Materials”** in submenu **“Colors”** of the **“ModelView”**-component, then enable **“Cross section”** in submenu **“Render Settings”** of the **“BeamView”**- and/or **“ShellView”**-component. | | **"E"** | Young’s Modulus ($$kN/cm^2$$): characterizes the stiffness of the material. | | **"G12"** | In-plane shear modulus ($$kN/cm^2$$): In case of isotropic materials the following constraint applies: $$E/3\
v\_{12} ​is the in-plane lateral contraction coefficient (also called Poisson’s ratio): In casev\_{12}=-1(the default) the approximate formula of Huber \[8] is applied to v\_{21}​ calculated from​E\_1, E\_2 and G\_{12}:
v\_{12}​=\frac{E\_1}{2.G\_{12}}​​−\sqrt{\frac{E\_2}{​E\_1}}​​ ​

| | **"G31"** | Transverse shear modulus in the first direction ($$kN/cm^2$$) | | **"G32"** | Transverse shear modulus in the second direction ($$kN/cm^2$$) | | **"gamma"** | Specific weight ( $$kN/m^3$$ ) | | **"alphaT1"** | Coefficient of thermal expansion in the first direction ( $$1/°C$$ ) | | **"alphaT2"** | Coefficient of thermal expansion in the second direction ( $$1/°C$$ ) | | "**ft1"** | Tensile strength of the material ($$kN/cm^2$$) in the first direction - a positive value | | "**ft2"** | Tensile strength of the material ($$kN/cm^2$$) in the second direction - a positive value | | **"fc1"** | Compressive strength of the material ($$kN/cm^2$$) in the first direction - a negative value | | **"fc2"** | Compressive strength of the material ($$kN/cm^2$$) in the second direction - a negative value | | **"t12"** | Shear strength ($$kN/cm^2$$) between first and second material direction. | | **"F12"** | Tsai-Wu interaction coefficient | | **"S-Hypo"** | Index of the strength hypothesis to be used. Use 'Expand ValueLists' from the components context menu for selecting between these options: 0: Von Mises, 1: Tresca, 2: Rankine, 3:TsaiWu | {% file src="/files/8iJvbFymJiTgLFDss5zm" %} {% file src="/files/qoYvs2g3uNAJHlBVcTlO" %} # 3.5.2: Material Selection The **“Material Selection”**-component in the menu subsection **“Material”** lets you select a material by family, name or index from a given list of materials (see fig. [3.4.1.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties#isotropic-material-properties) or fig. [3.4.3.2](/3-in-depth-component-reference/3.4-material/3.4.3-read-material-table-from-file)). Input the list of materials via the plug **“Mat”**. In case no list of materials is supplied, the material table that comes with Karamba3D is used. The input-plug **“Name|Ind”** expects either the zero-based list index of the selected material or its name. The names of materials are not case sensitive. A “#” in a material name means that the rest of the line is a comment. “&” starts a regular expression – in that case material names are case sensitive. For quick access materials may be selected via the drop down lists **“Family”** and **“Name”**, which unfold when clicking on the components **“Select”** bar. These two entries serve as additional criteria which act on the list of materials selected through the **“Name|Ind”** input. The inputs **“Elem|Id”** and **“Color”** have the same meaning as in the **“Material Properties”**-component (see section[ 3.4.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). Any element identifiers already present in a material get overwritten by the values input via **“Elem|Id”**. Without a color supplied at input **“Color”** the original material color persists. {% file src="/files/zjYgQFrSYBSXYVfDIM9k" %} # 3.5.3: Read Material Table from File ![Fig. 3.5.3.1: Partial view of the default data base of materials](/files/-Mgya3izvOQUBiQCJyJF) Karamba3D comes with a table of predefined materials. The csv-file “Materialproperties.csv” resides in the Karamba3D installation-folder. By default the **“ReadMatTable”**-component takes this file and creates a list of materials from it. These are available at the output-plug “Material”. The data-base currently holds properties for: * steel * wood * hardwood * coniferous timber * glulam timber * aluminum * concrete * lightweight concrete * reinforcement steel There exist different types of steel, concrete etc.. The generic term “concrete” for example will result in the selection of an everyday type of concrete - a C25/30 according to Eurocode 2. More specific descriptions may be given: Have a look at the data-base in order to get an overview. Material properties specified via table are assumed to be in SI units. They get automatically converted when used in the context of Imperial units. ![Fig. 3.5.3.2: List of materials resulting from the “ReadMatTable”-component](/files/-Mgyb91OMJGApipznXWe) Fig. 3.5.3.1 shows examples of how to define isotropic materials via table. SI units are used irrespective of user settings. Automatic conversion ensures compatibility with Imperial units. In case of orthotropic materials, the item in column “D” needs to be set to something different from “iso”. The order of orthotropic material parameters which follow from column “E” onward correspond to that of the **“Material Property”**-component: $$E\_1$$, $$E\_2$$, $$G\_{12}$$,$$\nu\_{12}$$,$$G\_{31}$$, $$G\_{32}$$,$$\gamma$$,$$\alpha\_{T1}$$,$$\alpha\_{T2}$$,$$f\_{t1}$$,$$f\_{t2}$$,$$f\_{c1}$$, $$f\_{c2}$$, $$t\_{12}$$, $$F\_{12}$$, **"S\_Hypo"** and **“Color”**. The extension .csv stands for “comma separated value”. The file can be opened with any text editor and contains the table entries separated by semicolons. It is preferable however to use OpenOffice or Excel (both can read and write csv-files): They render the data neatly formatted (see fig. 3.5.3.1). Make sure to have a “.” and not a “,” set as your decimal separator. In some countries “.” is used to separate thousands which then needs to be adapted as well. The setting may be changed under Windows via “regional settings” in “system settings”. All lines in the table that start with “#” are comments. Feel free to define your own materials. The file path to the materials data-base can be changed in two ways: first right-click on the component and hit **“Select file path to material definitions”** in the context menu that pops up. Second plug a panel with a file path into **“Path”**. Relative paths are relative to the directory where your definition lies. # 3.5.4: Disassemble Material 🔷 ![Fig. 3.5.4.1: The “Disassemble Material”-component gives access to all material properties](/files/-MCkEUbyeMi1xQ1doBk1) In case one wants to retrieve the parameters which define a material, the **“Disassemble Material”**-component does the job (see fig. 3.5.4.1). It can be applied to isotropic and orthotropic materials alike. In order to be valid for both types of materials, the outputs **“E1/2”**, **“G31/2”**, **“alphaT1/2”** and **“fy1/2”** return lists of numbers instead of single items. For isotropic materials these lists contain one member only. In case of orthotropic materials two numbers are present, corresponding to the first and second material direction respectively. {% file src="/files/oBuo1JNQ20k34sXqSWET" %} # 3.6: Algorithms Karamba3D offers various options of analyzing a structural model. Here all the algorithm components will be explained in greater detail. # 3.6.1: Analyze With geometry, supports and loads defined, the structural model is ready for processing. The **“Analyze”**-component computes the mechanical response for each load case and adds this information to the model. The algorithm behind the **“Analyze”-**component neglects the change of length in axial or in-plane direction which accompanies lateral deformations. This is justified in case of displacements which are small with respect to the dimensions of a beam of shell. For dealing with situations where this condition does not hold, geometric non-linear calculations need to be used (see sections [3.5.3](/3-in-depth-component-reference/3.5-algorithms/3.5.3-analyze-nonlinear-wip) and [3.5.4](/3-in-depth-component-reference/3.5-algorithms/3.5.4-analyze-large-deformation)). In case of the presence of second order normal forces ($$N^{II}$$, see below) their influence on structural stiffness is taken into account. Those $$N^{II}$$-forces do not get updated by the **“Analyze”**-component. Use the **“AnalyzeThII”** for that. ![Fig. 3.6.1: Deflection of simply supported beam under single load in mid-span and axial, compressive load](/files/-MCkE_mDfJm4ftVFQ93t) Fig. 3.6.1 shows a deflected beam with two load-cases. An axial load acts in load-case zero, a transverse load in mid-span in load-case one. The analysis component not only computes the model deflections but also outputs the maximum nodal displacement (in centimeter), the maximum total force of gravity (in kilo Newton, if gravity is set) and the structure's internal deformation energy for each load case - section [3.6.2](/3-in-depth-component-reference/3.6-results/3.6.2-deformation-energy) contains details on work and energy. These values can be used to rank structures in the course of a structural optimization procedure: the more efficient a structure, the smaller the maximum deflection, the amount of material used and the value of the internal elastic energy. Real structures are designed in such a way that their deflection does not impair their usability. See section [A.2.3](/appendix/a.4-background-information/a.4.3-tips-for-designing-statically-feasible-structures) for further details. Maximum deflection and elastic energy both provide a benchmark for structural stiffness, yet from different points of view: The value of elastic energy allows to judge a structure as a whole; The maximum displacement returns a local peak value. In order to view the deflected model use the **“ModelView”**-component (see section [3.6.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview)) and select the desired load case in the menu **“Result Case”**. Looking at fig. 3.6.1 one notices that only beam center axes are shown. In order to see beams or shells in a rendered view, add a **“BeamView”**- or **“ShellView”**-component after the **“ModelView”**. See sections [3.6.7](/3-in-depth-component-reference/3.6-results/3.6.7-beamview) and [3.6.11](/3-in-depth-component-reference/3.6-results/3.6.11-shellview) for details. # 3.6.2: AnalyzeThII 🔷 Axial forces in beams and in-plane forces in shells influence the structural stiffness. Compressive forces decrease a structure’s stiffness, tensile forces increase it. The influence of compressive forces on displacements and cross section forces may be neglected as long as their absolute value is less than 10% of the buckling load. In Karamba3D distinction is made between normal forces $$N$$ which cause stresses in the members and normal forces $$N^{II}$$ which result in second order effects (see also [\[10\]](/appendix/bibliography)). At first sight this concept seems weird. How can there be two kinds of normal forces in the same beam? Well, in reality there can’t. In a computer program it is no problem: stresses get calculated as $$\sigma = N/A$$ and $$N^{II}$$ is used for determining second order effects only. The advantage is, that in the presence of several load-cases one can chose for each element the largest compressive force as $$N^{II}$$. This gives a lower limit for the structure's stiffness. A re-evaluation of the load-cases using these $$N^{II}$$ values leads to a structural response which is too soft. However the different load-cases may then be safely superimposed. Use the **“AnalyzeThII”**-component for automatically determining the normal forces $$N^{II}$$ from cross section forces $$N\_{x} \cdot N ^{II}$$influences a structure's stiffness which in turn impacts the distribution of cross section forces $$N\_x$$. Thus an iterative procedure with repeated updates of $$N^{II}$$-forces needs to be applied. ![Fig 3.6.2: Deflection of simply supported beam under single load in mid-span and axial compressive load](/files/-MCkETPLHdJTgfgA2DCP) Fig. 3.6.2 shows the same system as in fig. [3.5.1](/3-in-depth-component-reference/3.5-algorithms/3.5.1-analyze). This time with results according to first and second order theory. When comparing the transverse deflections in load-case two one can see that the maximum deflection increased from $$0.24\[m]$$ to $$0.28\[m]$$ due to the effect of the axial compressive load. The **“AnalyzeThII”**-component features the following input-plugs: | | | | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Model to be considered | | **"LC"** | Number of load-case from which to take the normal force $$N^{II}$$ which cause second order theory effects. If set to −1 (the default) the minimum normal force of all load-cases is considered | | **"RTol"** | The determination of $$N^{II}$$ is an iterative process. The value of **“RTol”** is the upper limit of displacement increments from one iteration to the next. | | **"MaxIter"** | Supply here the maximum number of iterations for determining $$N^{II}$$. The default is 50. In case **“RTol”** can not be reached within the preset number of iterations the component turns orange. | | **"NoTenNII"** | Tension forces increase the stiffness of a structure. Setting **“NoTenNII”** to **“True”** limits $$N^{II}$$ to negative values. | The normal forces $$N^{II}$$ get attached to the model and will be considered in all further analysis steps. They impact the results of the **“Analyze”**-, **“Buckling Modes”**-, **“Natural Vibrations”**- and **“Optimize Cross Sections”**-components. For imperfection loads $$N^{II}$$-forces have a direct impact on the applied loads. Use the **“NII”** button in submenu **“Tags”** of the **“ModelView”**-component to display $$N^{II}$$-forces. {% file src="/files/OvoDpLlJOq5AfWdDqpDl" %} # 3.6.3: Analyze Nonlinear WIP Linear structural behaviour means that if one changes the external loads by a factor$$f$$ also the physical response quantities (displacements, cross section forces, stresses, …) change by that factor. This has the pleasant effect, that the impact of different loads can be superimposed. Thus it is not necessary to recalculate the model for each possible combination of external loads. For real structures the assumption of linear behaviour is an approximation – a good one in many cases. There are two mayor sources of non-linearity: * Physical non-linearity: Comes into play when materials leave the linear elastic range (e.g. concrete that cracks, steel that yields, …) * Geometric non-linearity: Takes effect when * lateral displacements get so large, that their effect on the axial (in case of e.g. beams) or in-plane (think of shells) deformation can not be neglected any more, * a nodal rotation$$\alpha$$reaches such a value, that the difference between $$\alpha$$ and $$\tan(\alpha)$$ gains importance. {% hint style="info" %} The **“Analyze Nonlinear WIP”**-component lets one deal with geometric non-linearity. It is work-in-progress. This means that especially for shells the algorithms may not converge within acceptable time for some structures. If however a result is returned, then it is sound. {% endhint %} With the **“Analyze Nonlinear WIP”**-component one can chose from three variants of iterative solution algorithms. Each of these has different benefits and liabilities which will be explained below. The algorithms are based on the assumption of small strains, but allow arbitrarily large displacements. The target of all three algorithms is to find a displacement state, where the external loads and the internal forces are in equilibrium. Starting from a known initial displacement state, one has to guess how the structure deforms under the given loads. This guess leads to a second displacement state where the internal and external forces usually do not match. The remaining imbalance forms the basis of a next prediction regarding the change of displacements and so on. Equilibrium is reached when the residual-force or change of displacements falls below a given threshold. The three algorithms offered by the **“Analyze Nonlinear WIP”**-component differ in how they predict the displacement increments. ## **Dynamic Relaxation** ![Fig. 3.5.3.1: Dynamic relaxation method option of the “Analyze Nonlinear WIP”-component.](/files/YRefFSq6sLdJ7R4k9WFw) Fig**.** 3.5.3.1 shows a cantilever beam with a bending moment load about the local y-axis at its tip. It consists of 20 beam elements. For calculating its response the **“DynamicRelaxation”**-option is used. This algorithm predicts the next move of a structure based on the direction of the residual forces acting on each node. It is a robust procedure which converges to equilibrium quite reliably but sometimes needs a large number of iterations to do so. This component offers the following input-plugs: | | | | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure to be analyzed. | | **"nLoadSteps"** | Number of load-cases which shall act as load-steps. The default is 1. When setting it to e.g. 2 it means that the algorithm starts with finding equilibrium for load-case 0. After that, the loads of load-case 0 remain in place and the loads of load-case 1 are added in order to arrive at the final stage. This allows to model a loading history. The remaining load-cases get added to the final stage separately and under the assumption of small displacements. In the case of an active bending structure the first load-cases serve as those which cause the deformed structure, whereas the rest of the load-cases constitute additional actions on the deformed configuration like wind- or live-load. The scaling factor for displacements in the **“Display Scales”** submenu of the **“ModelView”**-component acts only on the loading-steps for which small displacements are assumed. The large deformation share of the total displacements does not get scaled and is displayed in real size. | | **"nLoadIncs"** | Number of increments per load-case (the default is 5). External loads get applied in several steps. In case of structures with nearly linear behaviour, the number of increments can be set to a small number. For highly non-linear problems a larger value can be advantageous. The smaller the load-increments, the easier it is for the algorithm to find equilibrium. The number of iterations usually decreases with increasing number of load-steps (and thus decreasing step size). The overall performance can however suffer if the number of load-steps is set to a number which is too high for the given type of structural behaviour. | | **"maxEquiIter"** | Sets the maximum number of equilibrium iterations per load-increment and thus sets a limit on computation time. It defaults to 200. | | **"EquiTol"** | Tolerance for the iterative change of residual forces and displacements relative to their incremental change in the current load-step. The default value is $$1E-7$$. | | **"maxLimitIter"** | The range of problems which can be tackled using the dynamic relaxation (DR) algorithm as implemented in Karamba3D is limited to stable structures. In case of phenomena like buckling or snap-through, equilibrium states may exist beyond the point of initial instability. They are however hard to reach due to their often large distance from the last known stable configuration. In such a case the DR-algorithm does not converge to an equilibrium state within the maximum number of equilibrium iterations. It then tries to close in on the point of assumed instability by halving the load-increment which led to divergence. By proceeding in this manner, the so called limit load can be determined with arbitrary precision. **“maxLimitIter”** sets an upper limit on the number of limit-load-iterations which is equal to 200 by default. Sadly, divergence can also be caused by numerical problems in the algorithm. Thus the limit-load-factor as determined by the **“Analyze Nonlinear WIP”**-component constitutes only a lower limit estimation. | | **"LimitTol"** | Sets the minimum load-increment threshold for calculating the limit-load. | | **"StepSizeFac"** | A factor for scaling the predicted displacement increments of the DR-algorithm. | During a non-linear calculation lots of things can happen. In order to get an idea about why and where something went wrong, the DR variant of the **“DynamicRelaxation”**-option produces the following output: | | | | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure with calculated displacements, stresses and internal forces. | | **"Disp"** | Maximum displacement reached in centimeter. | | **"Energy"** | Deformation energy stored in the structure in $$kN m$$ . | | **"Info"** |

Details regarding the solution process. It outputs five columns of text:

  • “Factor”: The factor of the loads of the current load-step.
  • “Step”: The current load-step
  • “Iter”: Counts the number of iterations for the current load-increment.
  • “Disp.Err”: Outputs the ratio of the sum of iterative changes of the nodal displacements with respect to the change of displacements of the first iteration in the current load-increment
  • “Force.Err”: Outputs the ratio of the sum of iterative changes of the residual forces with respect to the current load-increment.
| | **"Lambdas"** | Informs about the load-factors for which equilibrium could be reached. | ## **Newton-Raphson Method** In practice, dynamic relaxation(DR) procedures are used for highly non-linear problems like numerical crash-tests of cars, bolts being shot into a wall, …. The reason is, that implementing non-linear effects as DR code is relatively easy. This ease of implementation comes at the cost of high computational effort: Many iterations are necessary to reach equilibrium with acceptable accuracy. The way out of this is to invest more effort in a better prediction of the displacement increments. In DR-methods the residual forces at the nodes form the basis of predicting the next position of a node. Methods like the Newton-Raphson- or Arc-Length-method use a stiffness matrix for producing displacement predictions. There the computational cost per iteration is higher, but the number of iterations can be made much smaller as compared to DR-methods. With a consistent stiffness matrix quadratic convergence can be achieved under optimal conditions. This means that for the iterative displacement- and force-errors the number of zeros after the decimal separator doubles in each iteration. For the **“Analyze Nonlinear WIP”**-component this is not yet the case and one reason for the “work in progress”-label. Details on the Newton-Raphson- or Arc-Length methods can be found in [\[6\]](broken://pages/-M9XuRDLyIWACDdqcL2-) on page 102 ff. and 214 ff.**.** ![Fig. 3.5.3.2: Newton-Raphson method option of the “Analyze Nonlinear WIP”-component](/files/bmXL1axjNgL6sJMk1NnT) Fig. 3.5.3.2 shows the same cantilever beam as before, this time analyzed with the **“NewtonRaphson”**-option. The Newton-Raphson variant of the **“Analyze Nonlinear WIP”**-component comes with nearly the same input- and output-plugs as the DR-version. The only difference is the missing **“StepSizeFac”**-input. Since Newton-Raphson procedures have the same limitation with respect to unstable structures as DR-methods, an interval halving strategy for closing in on limit-points is applied as before. ## **Arc-Length Method** ![Fig. 3.5.3.3: Arc-Length method option of the “Analyze Nonlinear WIP”-component](/files/uUw0TOOC5JVgRY5jRgqR) For many structures reaching a first point of instability is not yet the end of the story. Especially thin plate and shell structures show large load bearing reserves when considering their post-buckling behavior. The Arc-Length-method can be used for these kinds of situations. Fig. 3.5.3.3 shows the calculation of a truss structure which snaps through from an unstable state to a stable post-buckling configuration. The first two inputs of the **“Arclength”**-component have the same meaning as before. Here a description of how the rest of the input-plugs controls the solution process: | | | | -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"IniLoadFac"** | The displacement of the structure under the external load multiplied by **“IniLoadFac”** serves as a first estimate for the target deformation increments. | | **"MaxEquiIter"** | The maximum number of iterations per load increment. | | **"TargetEquiIter"** | Sets the number of increments to be used in each increment. Is used to scale the load-increments accordingly. | | **"EquiTol"** | The tolerance for out of balance forces and displacement changes from one iteration to the next. | | **"MaxLoadInc"** | Maximum number of load iterations. | # 3.6.4: Large Deformation Analysis Before the advent of digital modelling people like Heinz Isler, Antoni Gaudi or Sergio Musmeci helped themselves with physical models for generating curved geometries. A popular method was to use the shape of meshes or elastic membranes hanging from supports. ![Fig. 3.6.4.1: Structure resulting from large deflection analysis with the “LaDeform”-component](/files/-MCkEYlznB7XhZNIp3Wy) In Karamba3D the behaviour of hanging models can be simulated with the help of the **“Analyze Large Deformation”**-component. Fig. 3.6.4.1 shows a geometry derived from an initially flat mesh under evenly distributed point-loads. The algorithm behind the **“Analyze Large Deformation”**-component handles geometric non-linearity by an incremental approach only: All external loads get applied in steps. After each step the model geometry updates to the deflected state. The more and the smaller the steps, the better the approximation of geometric non-linearity. This purely incremental method however incurs an unavoidable drift from the exact solution. For form-finding this error is negligible in most cases. The methods available under the **“Analyze Nonlinear WIP”**-component (see section [3.5.3](/3-in-depth-component-reference/3.5-algorithms/3.5.3-analyze-nonlinear-wip)) do not suffer from this lack of accuracy, since they apply an incremental-iterative approach. Yet they normally require more computational effort to arrive at a similar shape as the algorithm behind the **“Analyze Large Deformation”**-component. ![Fig. 3.6.4.2: Catenary resulting from point loads that do not change their direction when displaced](/files/-MCkEYm0B35vwu9zDGo-) Fig. 3.6.4.2 shows a simply supported beam under the action of uniformly distributed point loads. Due to its slenderness axial stiffness by far outweighs bending stiffness. Thus the deflected shape corresponds to a rope under self weight. The **“LaDeform”** component has three input-plugs: | | | | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure to be deformed. **“LaDeform”** uses load-case 0 for calculating the deflected shape. | | **"Inc"** | Number of increments for applying the loads. | | **"MaxDisp"** |

Maximum displacement to be reached in meter. When supplied with a value, the incremental deflection in each step is scaled to . This enables Karamba3D to handle problems with overly large deflections at the beginning of the incremental procedure. Think of an initially straight rope: Due to its negligible bending stiffness it tends to deform tremendously in the first loading step.

With no value supplied in “MaxDisp” external loads get incremented proportionally in each step. Aside from cases like mentioned above this results in an approximation of the structure's real deflections under the given loads.

| ![Fig. 3.6.4.3: Pneumatic form resulting from point loads that rotate along with the points they apply to](/files/-MCkEYm1_YUUY0lQ-iDs) In fig. 3.6.4.2 the point loads are defined with respect to the global coordinate system: The input-plug **“Local?”** at the point-load component is set to “False”. Fig. 3.6.4.3 shows what happens if one changes that property to “True”: The point-loads co-rotate with the points they apply to. This leads to a pneumatic shape. The same happens for locally defined line-loads. The two output plugs of the **“LaDeform”**-component supply the deflected model and the maximum deflection reached in the calculation. The local coordinate system of each element gets updated along with its positions. By default an elements local Y-axis is taken parallel to the global X-Y-plane. If an element reaches a vertical position however, its default coordinate system flips – the Y-axis is then taken parallel to the global Y-axis. This may lead to unwanted results when using line-loads which flip along with the local coordinate system. It is possible to avoid this by defining local axes via the **“OrientateBeam”**-component. The deflected model contains no information regarding internal forces or stresses. The reason for this is that, owing to the purely incremental approach, these properties would be utterly inaccurate. {% file src="/files/no5HgI0Gq3NfgnikcEXd" %} {% file src="/files/TQWyyRp8fPhkbbD8pUqa" %} {% file src="/files/H1vsDBSKF9fC1bMeJyPM" %} {% file src="/files/MgJ3sebB38s3RzE1lz90" %} {% file src="/files/Ib4AJWpP944iCRdYH4Jw" %} {% file src="/files/I0CxSJJf8FITw8R6KZ1i" %} # 3.6.5: Buckling Modes 🔷 ![Fig. 3.6.5.1: Beam and shell model of a cantilever: shape and load-factors of the first buckling mode](/files/-MCkE_vQis8JKye6ugW7) Axial forces in beams and trusses as well as in-plane forces in shells change the element response under transverse load. Tension stiffens, compression has a softening effect. Slender columns or thin shells may fail due to buckling before the stresses in the cross section reach the material strength. Stability analysis therefore plays an important role in structural design. When doing cross section optimization with the **“Optimize Cross Section”**-component, the design formulas applied take account of buckling, based on the buckling length of the members. By default local buckling of individual elements is assumed. So-called global buckling occurs if a structural sub-system consisting of several elements (like e.g. a truss) loses stability. Global buckling can be checked with the **“Buckling Modes”**-component (see fig. 3.6.5.1). The **“Buckling Modes”**-component expects these input parameters: | | | | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure with second order normal forces $$N^{II}$$ defined. These forces can either be taken from a second order theory calculation (like in fig. 3.5.5.1) or specified via a **“Modify Element”**-component. | | **"FromInd"** | Index of the first buckling mode to be determined. The default is 1. This is also normally the only buckling shape of interest, since it corresponds to the mode of failure. | | **"NModes"** | Number of buckling modes to be calculated. The default is 1. | | **"MaxIter"** | The determination of the buckling modes is an iterative procedure. **“MaxIter”** sets the maximum number of iterations. | | **"Eps"** | Represents the convergence criteria. For convergence the iterative change of the norm of the displacements needs to fall below that value. | The model which comes out on the right side lists the computed buckling-modes as result-cases. The buckling shapes get scaled, so that their largest displacement component has the value 1. **“BLFacs”** returns the buckling load factors which are assumed to be non-negative. When multiplied with those factors the current normal forces $$N^{II}$$ would lead to an unstable structure. The buckling load factors are listed in ascending order. The calculation of buckling factors assumes small deflections up to the point of instability. This may not always be the case. # 3.6.6: Eigen Modes ![Fig. 3.6.6.1: Left: 14th eigen-mode with strain display enabled. Right: EigenMode-component in action](/files/-MCkET8Np1PnlZdAaQ2H) Karamba3D’s “EigenMode”-component allows to calculate eigenmodes and corresponding eigenvalues of structures (see fig. 3.6.6.1). The input parameters are a model, the index of the first eigenmode to be computed and the number of desired eigenmodes. The model which comes out on the right side lists the computed eigenmodes as result-cases. Thus they can be superimposed using the **“ModelView”**-component for form-finding or structural optimization. All loads which were defined on the input model get discarded. The determination of eigenshapes can take some time in case of large structures or many modes to be calculated. Grasshopper has no **“Cancel”**-button. Therefore you should save your model before activating the component. The number of different eigenmodes in a structure equals the number of degrees of freedom. In case of beams there are six degrees of freedom per node, with only trusses attached, a node possesses three degrees of freedom. Fig. 3.6.6.2 shows the first nine eigenmodes of a triangular beam mesh that is fixed at its lower corners. In the upper left corner of fig. 3.6.6.2 one sees the undeformed shape. The higher the index of an eigenmode the more folds it exhibits. The eigenvalues represent a measure for the resistance of a structure against being deformed to the corresponding eigenform. Values of zero or nearly zero signal rigid body modes. In case that the **“Analyze”**- or **“AnalyzeThII”**-components complain about a kinematic structure the eigenforms can be used to detect those kinematic modes. Again the displacements of the eigenmodes get scaled such that the largest displacement-component corresponds to 1. ![Fig. 3.6.6.2: Undeformed geometry (upper left corner) and the first nine eigen-modes of the structure](/files/-MCkET8OdWq8H7dCUfUm) {% file src="/files/VRhTsEzOi3y3m0NP2JOO" %} {% file src="/files/G6h8uhiHYfGzwKYUTp5m" %} # 3.6.7: Natural Vibrations In case you want to know how and at which frequency a structure vibrates use the **“NaturalVibrations”**-component. Fig. 3.6.7.1 shows a simply supported steel beam IPE100 of length$$10m$$with a point-mass at mid-span in its 24th natural vibration mode. The mass of beams and trusses enters the calculation of natural vibrations with the values derived from their material weight. Karamba3D uses consistent mass matrices for beam elements. For truss and shell elements a lumped approach is applied. At nodes additional masses (see section [3.1.11](/3-in-depth-component-reference/3.1-model/3.1.11-point-mass)) can be defined to simulate the effect of e.g. concrete slabs (these normally make up the majority of mass in high-rises) in an approximate manner. These masses are assumed to have translational inertia only. Karamba3D scales the resulting vibration modes $$\vec {v\_i}$$ in such a way that their largest component is 1. They get attached to a model as result-cases which can be viewed via a **“ModelView”**-component. The calculation of modal mass and participation factors are based on the modal displacements as scaled in the above described manner. ![Fig. 3.6.7.1: Natural vibration mode of a simply supported steel beam with a point-mass at mid-span.](/files/-MCkEU7N8avth1lDafPb) {% file src="/files/X3z91Gu9Thvw7eDevjMY" %} # 3.6.8: Optimize Cross Section 🔷 Use the **"Optimize Cross Section"**-component for the automatic selection of the most appropriate cross sections for beams and shells. It takes into account the cross sections load bearing capacity and optionally limits the maximum deflection of the structure. ![Fig. 3.6.8.1: Cross section optimization with the "OptiCroSec"-component on a simply supported beam.](/files/-MhrigEAKhv6p0SYbxFA) Figure 3.6.8.1 shows a typical set-up. The initial structure consisted of I-sections of type HEA100 which have a height and width of $$100mm$$. They could not sustain the given load: The resulting bending stresses would lie way beyond the yield stress of the assumed material which is steel S235 with $$f\_y = 23.5 kN/cm²$$. First the **"OptiCroSec"**-component determines the cross section of each element in such a way that their load-bearing capacity is sufficient for all load-cases. In order to achieve this, Karamba3D uses the following procedure: 1. Determination of section forces at "nSamples" points along all beams using the initial cross section. 2. For each element or given set of elements: selection of the first sufficient entry from the family to which each cross section belongs. 3. If no changes were necessary in step two or the maximum number of design iterations is reached, the algorithm stops. Otherwise it returns to step one using the cross sections selected in step two. In statically indeterminate structures the section forces depend on the stiffness (i.e. cross section and materials) of the members. This necessitates the iterative procedure described above. ![Fig. 3.6.8.2: Cross section optimization with the "OptiCroSec"-component on a cantilevering wall. ](/files/-MhrknjR2HVkQE7jB1jS) In fig. 3.6.8.2 one can see the example of a cantilever idealized with shell elements: The optimization results in thicker shell elements at the top and bottom edge of the built-in side. The "CroSecs"-input of the **"OptiCroSec"**-component consists of a family of constant shell cross sections. For shells the mechanical utilization is calculated as the maximum comparative stress in a point divided by the material strength. The comparative strength depends on the strength hypotheses chosen for the material (see section [3.5.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). In case of steel the Von Mises comparative stress applies. For cross section optimization of shells the same procedure applies as for beams. Starting with the first item of a cross section family the algorithm tests all members and stops when a cross section is encountered for which the utilization is less than a pre-set value which is "1" by default. This corresponds to 100%. After ensuring safety against structural failure a second, optional step follows where Karamba3D tries to reach a user supplied maximum deflection. Behind the scenes Karamba3D iteratively adapts temporarily the strength of the materials. This may lead to uneconomic results in case of structures where the maximum displacement occurs in a small region, whereas the rest of the structure shows a much smaller deformation. In order that the iterative adaption for the maximum displacement works, the number of design iterations should be chosen appropriately -- five is normally sufficient. Building codes prescribe different levels of safety against reaching maximum displacement and load bearing limits. When using external loads at ultimate limit state level one should keep in mind that this is approximately 1.4 times the loads used to check maximum displacement requirements. Thus one way of designing structures in Karamba3D is to limit material utilization to $$1/1.4 \approx 0.7$$ under characteristic loads and use the resulting displacements directly for usability design. When the given loads surpass the load bearing capacity of the biggest cross section available in a cross section family, Karamba3D issues a warning via the "Info" output-plug (see fig. 3.6.8.2). There is no guarantee, that the iteration procedure for finding the optimal cross sections eventually converges. One can check the results via the "Utilization of Elements"-component. It applies the same procedure as the "OptiCroSec"-component for assessing elements according to Eurocode 3 and consider the load-bearing capacity of the whole cross section. The utilization-output of the "ModelView"-component only shows the ratio between the stress in a point of a cross section and the material strength there. Effects like buckling under compression are not considered. This is why the utilization as displayed by the "ModelView"-component may deviate from the results of the "Utilization of Elements"-component. Due to the lower-bound theorem of plasticity, the structure will be sufficient for the given loads at any iteration step -- although some elements may show over-utilization -- provided that the material is sufficiently plastic (like e.g. steel). With increasing number of iterations the static system tends to become more and more statically determinate. The profile selection procedure assumes that the cross sections of a family are ordered: starting with your most favorite and descending to the least desired cross section. In the cross section table "CrossSectionValues.bin" that comes with Karamba3D all families are ranked according to their height. The cross section with the smallest height comes first, the one with the largest height last. When using cross section area as sorting criteria, structures of minimum weight (and thus approximately cost) result. See section [3.3.11](/3-in-depth-component-reference/3.3-cross-section/3.3.13-read-cross-section-table-from-file) for how to switch between minimum height and minimum weight design. Ordering the profiles by area may lead to structures where the cross section heights vary significantly from one beam to the next. In order to check whether a given beam cross section is sufficient, Karamba3D applies a procedure for steel beams according to Eurocode 3 (EN 1993-1-1) (see [\[5\]](/appendix/bibliography) for details). The interaction values for the cross section forces $$k\_{yy}$$*,* $$k\_{yz}$$and so on get calculated according to EN 1993-1-1 appendix B. The values $$C\_{my}$$*and* $$C\_{mz}$$are limited to a minimum of 0.9 by default. This means that sideways sway initiates buckling which is on the safe side in case of non-sway frames. When the input-plug "SwayFrame" is set to 'False' the limit of 0.9 does not apply. The design procedure takes account of normal force, biaxial bending, torsion and shear force. For more details see section [A.2.6](/appendix/a.4-background-information/a.4.6-approach-used-for-cross-section-optimization) and the master thesis of Jukka Mäenpää [\[9\]](/appendix/bibliography). It is possible to switch off the influence of buckling for single members or set user defined values for the buckling length (see section [3.1.10: Modify Element](/3-in-depth-component-reference/3.1-model/3.1.10-modify-element#buckling-property-for-cross-section-optimization)). The adverse effect of compressive normal forces in a beam can be taken into account globally (see section [3.6.5](/3-in-depth-component-reference/3.5-algorithms/3.5.5-buckling-modes)) or locally on the level of individual members. The procedure applied in Karamba3D for cross section optimization works on member level. A crucial precondition for this method to deliver useful results is the determination of a realistic buckling length $$l\_b$$of an element. For this the following simplification -- which is not always on the safe side -- is applied: Starting from the endpoints of an element, proceeding to its neighbors, the first nodes are tracked that connect to more than two elements. The buckling length is determined as the distance between these two nodes. It lies on the safe side in case of endpoints held by the rest of the structure against translation. When beams are members of a larger part that buckles (e.g. a girder of a truss) then the applied determination of buckling length produces unsafe results! One should always check this by calculating the global buckling modes (see section [3.6.5](/3-in-depth-component-reference/3.5-algorithms/3.5.5-buckling-modes)). In case of a free end the buckling length is doubled. Compressive normal forces in slender beams reduce their allowable maximum stress below the yield limit. Visualizing the level of utilization with the "ModelView"-component will then show values below 100% in the compressive range. The design procedure applied in Karamba3D takes lateral torsional buckling into account. An elements lateral torsional buckling length is calculated in the same way as for conventional buckling. The buckling length for lateral torsional buckling can be set manually via the property "BklLenLT" of the "Modify Beam"-component. In the course of cross section optimization Karamba3D checks the cross sections for local buckling and issues a warning if necessary. The check for local buckling uses the classification of cross sections into classes 1 to 4 according to EN 1993-1-1. Class 4 cross sections are susceptible to local buckling. During the optimization of cross sections normal forces$$N\_{II}$$are not updated. In order to include second order theory effects either set$$N\_{II}$$manually or use "AnalysisThII" (see section [3.6.2](/3-in-depth-component-reference/3.5-algorithms/3.5.2-analyzethii)) to determine$$N\_{II}$$iteratively. The **"OptiCroSec"**-component provides the following set of input-plugs: | | | | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure to be optimized. | | **"ElemIds"** | Identifiers of elements that should be optimized. If not specified, optimization is carried out for the entire model. | | **"GroupIds"** | List of identifiers of groups of elements that take part in cross section design and shall have uniform cross section. One can use the names of element sets and regular expressions for defining groups. | | **"CroSecs"** | Cross section-list that contains families of cross sections ordered from most favorite to least desired. Family membership of cross sections is given via their “family” property. | | **"MaxUtil"** | Target value of the element utilization where 1.0 means full utilization - the default. In some situations (e.g. early stage design) loads or geometry can not be fully specified. Then it makes sense to keep some structural reserves for later phases by setting this value to less than 1.0. When working with characteristic loads this value should be less than 0.7. | | **"MaxDisp"** |

For usability of a structure it is necessary to put a limit on its maximum deflection. This can be done using the “MaxDisp”-plug. By default its value is −1 which means that the maximum deflection is not considered for cross section design. If given as a vector, the displacement components in the direction of the vector shall be smaller than its given length.
When working with design loads keep in mind that those are roughly a factor of “1.4” above the level to be considered for usability.

| In order to see all input-plugs click on the **“Settings”**-button to unfold the rest of the component: | | | | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"ULSIter"** | Maximum number of design iterations for sufficient load bearing capacity in the ultimate limit state (ULS). The default value is five. | | **"DispIter"** | Maximum number of iterations used to reach the maximum displacement criteria in case there is one. The design iterations for maximum displacement come after those for load bearing capacity. | | **"nSamples"** | Number of points along beams at which their utilization is determined. The default is three. | | **"Elast"** | If set to “True” (the default) cross section design is done within the elastic range. This means that under given loads the maximum resulting stress in a cross section has to lie below the yield stress$$f\_y$$of the material. In case of materials with high ductility (like steel) the plastic capacity of cross sections can be exploited. Depending on the cross section shape the plastic capacity is 10 % to 20 % higher than the elastic capacity. Set **“Elast”** to “False” in order to activate plastic cross section design. When enabling plastic cross section design do not be surprised that the **“ModelView”** reports utilization-levels beyond 100 %. The reason is that Karamba3D assumes linear elastic material behavior. | | **"gammaM0"** | Material safety factor according to EN 1993-1-1 in case that failure is not initiated by buckling. This applies in case of tensile normal force or zero buckling length. Its default value is 1.0. In some European countries this factor lies above **1.0**. The default value of gammaM0 can be set in the karamba.ini-file. | | **"gammaM1"** | Material safety factor according to EN 1993-1-1 in case that buckling initiates failure. This applies in case of compressive normal force and non-zero buckling length. The default value again lies at **1.1** - may be specified differently in your national application document of EN 1993-1-1. The default value of gammaM1 can be set in the karamba.ini-file. **Attention: in Karamba3D 1.3.3 the default value of gammaM1 was 1.0!** | | **"SwayFrame"** | This flag inidicates whether parts of the structure are susceptible to sideways sway blucking. By default its value is 'True' which results in cross section dimensions which lie on the safe side. | On the output side the **“Model”**-plug renders the structure with optimized cross sections. Check the **“Info”**-plug in order to see whether any problems occurred during optimization. The **“Mass”**-output informs you about the overall mass of the optimized structure. **“Disp”**- and **“Energy”**-plugs return the maximum displacement and internal energy of the structure after the last cross section design iteration. The aim of the design procedure applied in Karamba3D is to render plausible cross section choices. Be aware that it builds upon assumptions like the correct determination of buckling lengths. {% file src="/files/Ex4WhaCxIjGpCRe5Fuwa" %} {% file src="/files/jvxB8DHACTIB3zqb1PGI" %} {% file src="/files/2A3Jws4PY21uTkKDhPgT" %} {% file src="/files/ZwpUlAt0z8he4o5Sd4Wc" %} {% file src="/files/hV4F8OPcxGdUJOb5ggO6" %} {% file src="/files/qbPV4cjAK4YcKS3KlSUh" %} {% file src="/files/YSWSwpzU4nT6pcfrylZ8" %} {% file src="/files/hQhsl5olJbm5b5YTAs3v" %} {% file src="/files/gW2VZ8VPvvHF00bx5UPY" %} {% file src="/files/BuiR77dNw3CYfFPStcLB" %} {% file src="/files/XeVzamo8FBFuTI6OVbNS" %} {% file src="/files/Vrv3yReyrAgDHGq4uyYL" %} {% file src="/files/nGRvxR5gm4gyyYti2vgb" %} {% file src="/files/LWBGk80wmlaw4OMHsmDd" %} {% file src="/files/05nPhRKkrfBH1pPYBauN" %} {% file src="/files/7XAPsYL4BTyog8tcumYQ" %} {% file src="/files/8jMblkHgYTv8Zqe9ti03" %} {% file src="/files/Bc2xq1WDLIg4ZHcK27kl" %} {% file src="/files/P4vFEADBWw0Bhgt9klZB" %} {% file src="/files/htcKOinaojPKHkcE3q3L" %} # 3.6.9: BESO for Beams Evolutionary structural optimization (ESO) constitutes a method of topology optimization which was pioneered by Y.M. Xie and G.P. Steven. The underlying principle is simple: One starts from a given volume made up from structural elements on predefined supports and with preset loads acting on it. Calculating the structural response will show that there are regions which carry more of the external load than others. Now one removes a number of those elements of the structure that are least strained and thus least effective. Again the response of the now thinned out model is determined, under-utilized elements removed and so on. This iterative procedure stops when a target volume or number of remaining structural elements is reached. ![Fig. 3.6.9.1: Cantilever with initially regular mesh after application of the “BESO for Beams”-component](/files/-MCkEYhu_4_D0y66gB4I) The above algorithm can be viewed as a way of tracing the internal force flow through a structure and removing those elements that do not form part of it. Fig. 3.6.9.1 shows a cantilever after applying the **“BESO for Beams”**-component on it. The algorithm works on beam and truss elements only. For shells a separate component exists (see section [3.5.10](/3-in-depth-component-reference/3.5-algorithms/3.5.10-beso-for-shells)). ![Fig. 3.6.9.2: Triangular mesh of beams before (a) and after (b) applying the “BESO for Beams”-component](/files/-MCkEYhvFcXi1lXy76cD) Fig. 3.6.9.2 shows the **“BESO for Beams”**-component at work. On the left side one can see the initial geometry which is a triangular mesh derived from a surface. There exist two load cases with loads acting in the plane of the structure in horizontal and vertical direction respectively. Three corner nodes of the structure are held fixed. The right picture shows the optimized structure reduced to 45 % of its initial mass in the course of 20 design iterations. ## Here the description of the input parameters: | | | | ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Receives the model to be processed. | | **"ElemIds"** |

There are two alternatives concerning this input parameter:

  • No input: The whole of the structure will be included in the optimization procedure.
  • The input consists of a list of strings: All elements whose identifiers match take part.
| | **"LCases"** | List of load cases to be considered. Zero is the index of the first load case. Considering the total effect of several load cases amounts to adding up their individual influences on an element. | | **"TargetRatio"** | Ratio of the target mass of beam- or truss elements to the initial mass of beams/trusses in a structure. When determining the initial mass all beam- or truss- elements of the structure – irrespective of state of activation – count. In the target structure only active elements contribute to its mass. This enables one to apply BESO-components in series. Depending on the activation status of the model elements, applying **“BESO for Beams”** will lead to an increase or decrease in the number of active elements. The activation status of individual elements can be set by means of the **“ModifyBeam”**- and **“ActivateModel”**-components. | | **"MaxChangeIter"** | Number of iterations within which the target mass of the structure should be reached. If the number of iterations is selected too low then it may occur that single beams get disconnected from the main structure and they seem to fly. The reason for this lies in the fact that Karamba3D applies a so called soft-kill approach for thinning out the structure: Elements are not removed but simply given small stiffness values. This ensures that structural response can be calculated under all circumstances. | | **"MaxConvIter"** | Maximum number of additional iterations for convergence after the structures mass has reached its target value using **“MaxChangeIter”** iterations. | | **"GroupIds"** | Expects a list of strings. Elements that match a given list entry take part in the optimization and belong to one group. They get collectively activated or deactivated during force path finding. A structure may consist of active and non-active elements. The initial state of a group is determined by the state of the majority of its elements. Groups need not be disjoint. | ## By clicking on the “Settings” bar you can unfold the following input-plugs: Factors for weighting forces/moments: The **“BESO for Beams”**-component lets you select weighting factors for the different force and bending components in an element. The weight of an element is determined on the basis of the density of deformation energy induced by individual cross section force components. Multiplication by the corresponding user given weighting factor and adding up the component contributions results in the element weight. The weight of groups results from the average of their members. These are the available weighting factors: * **“WTension”**: factor for axial tension force * **“WCompr.”**: factor for axial compression force * **“WShear”**: factor for resultant shear force * **“WMoment”**: factor for resultant moments **"BESOFac"**: Say in each iteration step there needs to be a mass of $$n\[kg]$$ removed in order to meet the structure's target mass in the given $$nChangeIter$$ number of iterations. With $$BESOFac = m$$ there will be $$(m+1) \cdot n$$ active elements moved to the pool of inactive elements. An evaluation of the structure's response follows. In a second step $$m \cdot n$$ members get flipped from inactive to active so that the balance is right again. This adds a bi-directional component to the process which often leads to improved results. **“MinDist”**: In some cases one wishes to limit the number of elements that get added or removed in a certain area. **“MinDist”** lets you select the minimum distance in meter between the endpoints of elements that may be changed in one iteration. **“WLimit”**: At the end of the BESO-process it often occurs that a small fraction of the elements is much less utilized than the average. **“WLimit”** lets you remove those elements whose weight is below **“WLimit”** times the average weight of elements. ## On the right side of the **“BESOBeam”**-component these output-plugs exist: | | | | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Max.disp"** | Maximum displacement of the resulting model from among all load cases. | | **"Model"** | Structure with element activation according to the force path found. | | **"Hist"** | A data tree which contains for each iteration step a list of boolean values that signify whether an element is active (true) or inactive (false). The boolean values map directly on the model elements. Using a **“Tree Branch”**-component with a slider connected to a **“Activate Model”**-component (see section [3.1.5](/3-in-depth-component-reference/3.1-model/3.1.5-activate-element)) lets you inspect the history of the BESO-process (see fig. 3.6.9.2). | | **"Is active"** | Renders a list of “True”/“False” values – one for each element. “True” signals that the corresponding element is part of the final structure (i.e. active). Otherwise it contains a “False” entry. | | **"Weights"** | List of element or group weights in ascending order in the final structure. This can be used as a qualitative check of the result: The more evenly distributed the weights, the better utilized the structure. There will always be force concentrations around supports and external loads which show up as sharp peaks. A good way of visualization is to use a **“Quick Graph”**-component (see fig. 3.6.9.2). | {% file src="/files/pqhtIc7RqT9ryrecgqC9" %} {% file src="/files/r97q6XIGLDReqm2jcTNQ" %} {% file src="/files/r97q6XIGLDReqm2jcTNQ" %} {% file src="/files/KsKYlbeEX1gGIpPrB1jw" %} {% file src="/files/hvk0GX1mwaSos41A3OZ0" %} {% file src="/files/5yYznJszVGCABne14o8t" %} # 3.6.10: BESO for Shells An in-depth description of the BESO for shells algorithm used in Karamba3D can be found in [\[7\]](/appendix/bibliography). Fig. 3.6.10.1 shows an example which starts off from a rectangular wall which supports two point-loads at each of its upper corners. The result of the BESO procedure is the X-shaped structure shown on the left side. ![Fig. 3.6.10.1: BESO for a rectangular plate under two corner loads](/files/-MCkESuxev-7E4kbzN_F) These are the main parameters that control the optimization process: | | " | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Model to be optimized | | **"ElemIds"** | List of identifiers of shells that take part in the optimization. In case of an empty list (the default) all shells are included. | | **"LCases"** | List of load cases to be considered. Zero is the index of the first load case. Considering the total effect of several load cases amounts to adding up their individual influences on an element. | | **"TargetRatio"** | Ratio of the target mass to the initial mass of the shells in a structure. When determining the initial mass all shell elements of the structure – irrespective of state of activation – count. In the target structure only active elements contribute to its mass. This enables one to apply BESO-components in series. | | **"MaxIter"** | Maximum number of iterations | Under the submenu **“Settings”** these additional options can be used to further customize the optimization procedure: | | | | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"ER"** | Is short for evolutionary ratio and defines the ratio between the volumes $$V\_i$$ and $$V\_{i+1}$$ of the optimized structure in two consecutive steps: $$V\_{i+1} = V{i} \cdot (1\pm ER)$$. The sign of “ER” depends on whether elements shall be added or removed. In case that $$ER<0$$ – which is the default –$$ER$$is set automatically: $$ER = (1-TargetRatio)/MaxIter + AR\_{max}/2$$. In case that **“ER”** is too small, the target mass of the optimized structure can not be reached within **“MaxIter”** steps. | | **"ARmax"** | The ratio between maximum number of elements to be added per step and all shell elements. | | **"Nhist"** | Number of iterations between those steps which are used for calculating the convergence criteria. | | **"Conv"** | Relative change of the mass between two iterations $$N\_{hist}$$ cycles apart below which convergence is assumed. | | **"Rmin"** | In order to avoid the formation of checkerboard patterns a filter scheme is used for calculating the fitness of individual elements (see [\[7\]](/appendix/bibliography), section 3.3.2). $$R\_{min}$$ defines the radius of influence in meters for determining the element sensitivity. It is thus important to choose this value according to the mean element size. If $$R\_{min} <0$$ (the default) then $$R\_{min}$$ is set equal to the characteristic element length which is calculated as $$(totalArea/numberOfElements)^{0.5} \cdot 2$$. | | **"Rexp"** | Determines how the strain energy at nodes within the distance $$R\_{min}$$ of the element center is weighted for calculating an elements sensitivity. The weight is determined as $$w =(R\_{ij}/\sum R\_{ij})^{R\_{exp}}$$. Here $$R\_{ij}=R\_{min}-R$$ with $$R$$ being the distance between a sample node and the center of the element. $$\sum R\_{ij}$$ is the sum of the center distances of all nodes closer than $$R\_{min}$$ to the element center. | | **"KillThick"** | The BESO for shell procedure makes use of a so called “soft kill”-approach. Instead of removing elements from the model they are made very soft by reducing their thickness. With the input-plug **“KillThick”** a value other than the default 0.00001 m can be selected. | The output-plugs of the **“BESOShell”**-component return the following data: | | | | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Model which results from the BESO optimization. | | **"ModelHist"** | List of intermediate models – one for each iteration step of the BESO procedure. | | **"CHist"** | History of the volume weighted compliance of the structure which drives the BESO procedure. When fed into a **“Quick Graph”** component one can check whether the BESO procedure converged: at the end the chart should be horizontal. If that is not the case try a smaller **“ER”**-value. | | **"VHist"** | List of values which chart the development of the volume of the shells to be optimized. | | **"Info"** | Returns information regarding the solution process in case something goes wrong. | {% file src="/files/xMEltg7uq1nUMIzOFHDE" %} {% file src="/files/oZkOlMhTfTab60znMWkq" %} # 3.6.11: Optimize Reinforcement 🔷 The **“Optimize Reinforcement”**-component calculates reinforcement quantities for arbitrary shells. The algorithm is based on the sandwich model approach of Marti (see [\[6\]](/appendix/bibliography) or [\[4\]](/appendix/bibliography)). Each load-case is considered separately and the maximum reinforcement of all load-cases is chosen. ![Fig. 3.6.11.1: Calculation of reinforcement quantities for a 1mx1m plate and an in-plane tensile 50kN load](/files/-MCkEZW0zCXjeXVy2_Cg) Fig. 3.6.11.1 shows a rectangular plate of size$$1m$$by$$1m$$with a uniform tensile line-load of $$50kN/m$$ which translates to two point-loads of $$25kN$$each. The first step consists of defining a reinforced concrete cross section via a **“Cross Section”**-component (see section [3.3.2](/3-in-depth-component-reference/3.3-cross-section/3.3.2-shell-cross-sections)). The definition of reinforcement layers does not impact the displacements or cross section forces of the model. It merely forms the basis for calculating reinforcement quantities using linear elastic cross section forces. For reinforcement design it is assumed that the material in layer zero (usually concrete) has no tensile and infinite compressive strength. Since the latter is a simplification, one should assure a sufficient height of the concrete cross section by using the **“Optimize Cross Section”**-component first. The input-plugs of the **“Optimize Reinforcement”**-component are similar to those of the **“Optimize Cross Section”**-component: | | | | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Structure for doing reinforcement design | | **"ElemIds"** | Identifiers of elements for which reinforcement quantities should be calculated. If not specified, optimization is carried out for all reinforced concrete cross sections. | | **"GroupdIds"** | List of identifiers of groups of elements that take part in reinforced cross section design and shall have uniform reinforcement. | | **"MaxUtil"** | Target value of the reinforcement utilization where 1.0 means full utilization - the default. | Under the submenu **“Settings”** reside two plugs which let you specify the partial safety factors for concrete (**“gammaMc”**) and steel (**“gammaMs”**). The former exists for future use, since currently concrete is assumed to be infinitely strong in compression. The latter is set to 1.15 which constitutes the standard value according to Eurocode 2 (see [\[3\]](/appendix/bibliography)). The output of **“Optimize Reinforcement”** comprises these plugs: | | | | ------------ | -------------------------------------------------------------- | | **"Model"** | Structure with optimized reinforcement | | **"Info"** | Warnings regarding the reinforcement design process | | **"Mass"** | Total mass of reinforcement after optimization in kilograms | | **"Disp"** | Maximum displacement of the structure for each load-case | | **"Energy"** | Elastic deformation energy of the structure for each load-case | The **“ShellView”**-component lets one display the thickness of the reinforcement layers and the stresses there (see fig. 3.6.11.1). The input-plug **“LayerInd”** sets the index of the layer to be displayed. The concrete cross section has index zero, index one corresponds to the top-, index four to the bottom-most reinforcement layer. The Z-direction of the local coordinate system points to the top of the cross section. The entry **“Local layer axes”** under **“Display Scales”** in the component **“ModelView”** lets one enable, disable and scale the arrows of the local coordinate system. In the example of fig. 3.6.11.1 the default reinforcement material BSt500 with a characteristic yield strength of $$f\_{y,k}=50kN/cm^2$$ leads to a necessary amount of reinforcement of $$a\_s = \frac{50kN \cdot 1.15}{2 \cdot 50kN/cm^2}$$. This is equivalent to a layer thickness of 0.00575 cm. The “2” in the denominator results from the fact that there are two reinforcement layers (of index one and four) which point in the direction of the tensile force. {% file src="/files/PgUHk4hF3oWN0j55MY1V" %} {% file src="/files/ftJvXVIPLVGPCKOn0YTc" %} # 3.6.12: Tension/Compression Eliminator 🔷 This component was programmed by Robert Vierlinger The **“Tension/Compression Eliminator”**-component removes elements from a model based on the sign of their axial force. ![Fig. 3.6.12.1: The “Tension/Compression Eliminator”-component](/files/-MCkEaMHxr-GJSwzUf2D) These are the available input parameters: | | | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **"Model"** | Structure to be processed. | | **"MaxIter"** | The removal of tensile or compressive elements works in an iterative fashion. The procedure stops either when no changes occur from one step to another or if the maximum number of iterations **“MaxIter”** is reached. | | **"BeamInds"** | Indexes of the elements that may be removed in the course of the procedure. By default the whole structure is included. | | **"LC"** | You can specify a special load case to consider. The default is 0. | | **"Compr"** | If “True”, then only members under compression will be kept. Otherwise only members under tension will survive. This value is “False” by default. | Elements selected for removal are assigned a negligible stiffness (i.e. a soft-kill approach is used). {% file src="/files/CleMSeyLhLeSdWwWluwW" %} {% file src="/files/9nEv0hkkcxTdyTAvLSBq" %} # 3.7: Results The results category consists of three sections. The first contains components that apply to a structure in general. Components of the second and third category apply specifically to beams and shells respectively. # 3.7.1: ModelView The **“ModelView”**-component of the **“Results”** subsection controls the general display properties of the structural model (see fig. 3.7.1.1). More specific visual properties that relate to beam and shell elements can be defined with the **“BeamView”** and **“ShellView”**-component. The viewing options get stored in the model. Settings of view-components thus stick with the model and remain valid further down the data-stream until changed by another view-component. When adding a **“ModelView”** to the definition it is sometimes a good idea to turn off the preview of all other components so that they do not interfere. Clicking on the black menu headings unfolds the **“ModelView”**-component and unveils widgets for tuning the model display. Each of these will be explained further below. The range and current value of the sliders may be set by double-clicking on their knob. ![ Fig. 3.7.1.1: Partial view of a model](/files/-MhrtIrZxypCiP7TqZn-) The **“ModelView”**-component features six plugs on its left side: | | | | | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Expects the model to be displayed. | | | **"DispDir"** | If the input is a vector it specifies the direction of the displacement component to be displayed. Alternatively one can supply a plane to project the displacements on it. By default the resultant displacements are shown. | | | **"R-Factors"** |

There exist two options for scaling the deflection output. First there is a slider entitled “Deformation” in the menu “Display Scales” that lets you do quick fine-tuning on the visual output (see below). Second option: the input-plug “R-Factors” which accepts a list of numbers that “ModelView” uses to scale the displacement-output. Its default value is 1.0. Each item in the list applies to a result-case. If the number of items in this list and the number of result-cases do not match then the last number item is copied until there is a one to one correspondence.

This option for scaling displacements can be used in the course of form-finding operations: The “def.Model”-plug at the right side of the “ModelView” (see below) outputs the model with displaced geometry which can be used for further processing.
Selecting item “–all–” on the drop-down-list for the selected load case results in a superposition of all load cases with their corresponding scaling factor.

| | | **"ResCase"** | Lets one select the visible result-case. The value in **“ResCase”** will be added to the result-case selected in the drop-down-list of **“ModelView”**. **“—all—”** at the drop-down-list and **“ResCase”** set to 0 result in the first result-case to be displayed. If the resulting number is larger than the number of available result-cases the **“ModelView”** turns red. If the resulting value is smaller than 0 (the default) all result-cases are superimposed. The possibility of using a number-slider for selecting load-cases makes life easier in case that there are many of them. | | | **"Colors"** |

Color plots for e.g. stresses use a color spectrum from blue to white to red by default. One can customize the color range by handing over a list of RGB-values to the “Colors”-plug. There have to be at least four colors given. The first color is used for values below, the last color for values above the current number range. The remaining colors get distributed over the number range (see fig. 3.7.1.2). The colors are centered on zero if zero is part of the number range. Otherwise the colors spread evenly between lower and upper numerical limit. In case you want to change the coloring defaults, set them in the “karamba.ini”-file. There it is also possible to switch off the centering around zero by setting “center\_color\_range\_on\_zero” to false.

Alternatively it is possible to select from a list of color-ranges via the component's context menu: right-click on the component, go to item 'Colors' and select a color range.

| | | **"Ids\|Breps"** |

This plug lets one select those parts of a model which shall be displayed. It expects a list of strings or Breps. The default value is an empty string which means that all of the model shall be visible. As one can see in fig. 3.7.1.1 it is possible to input regular expressions. These must start with the character “&” and adhere to the conventions for regular expressions as used in C#. The identifier of each element of the model is compared to each item of the given string list. In case a list entry matches the element identifier the element will be displayed. Fig. 3.7.1.1 contains four examples of “Id” lists: The first would limit visibility to element “A”, the second to element “B”. The third is a regular expression which matches elements “A” or “C”. The fourth matches elements “A” to “C”.
Alternatively one can plug closed Breps into the “Ids | Breps”-plug. In that case only those elements get displayed which lie inside one of the volumes with at least one of their end-nodes.

| ![ Fig. 3.7.1.2: Color plot of strains with custom color range](/files/-MCkEY8rmxYixQrqQ4yx) There are five output plugs on the **"ModelView"**-component: | | | | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **“Model”** | Is the model which was fed in on the left side with viewing options attached. | | **“defMesh”** | You can get the mesh of the shells and beam cross sections of the deformed model for further processing. It is a list of meshes with each item corresponding to one shell or beam. | | **“defAxes"** | Delivers the axes of the beams of the deformed structure as interpolated 3rd degree nurb-splines. Use the Length/Subdivision slider to set the number of interpolation points. | | **"defModel”** | When there are results available from a statical calculation, deflections are scaled and added to the node coordinates of the original model so that the **"defModel"**-output contains the deformed geometry. | ## **The “Display Scales”-submenu** ![Fig. 3.7.1.3: Local axes of cantilever composed of two beams, reaction force and moment at support](/files/-MCkEY8scxP4URzDN4tX) The **“Display Scales”**-submenu contains check boxes and sliders to enable/disable and scale displacements, reaction forces at supports, load-symbols, support-symbols, local coordinate systems and symbols for joints at the endpoints of elements. The displacement scale influences the display and the output at the **"defModel"**-plug. It has no effect on stresses, strains, etc.. The colors of the local coordinate axes red, green, blue symbolize the local X-, Y-, and Z-axis. ## **The “Render Settings”-submenu** The slider entitled **“Length/Segment\[m]”** lets one control the distance at which beam results (displacements, forces, moments, etc.) are plotted (see [3.6.7](/3-in-depth-component-reference/3.6-results/3.6.7-beamview)). It also sets the number of control points that are used for the **“defAxes”**-output and for displaying. In some cases the color display of results gets distorted by the presence of stress concentrations or utilization peeks. They make much of the structure look unstrained with some small patches of color where the peeks are. The **“Upper Result Threshold”**- and **“Lower Result Threshold”**-sliders let you eliminate these extreme values. In case of the **“Upper Result Threshold”**-slider a value of x% sets the upper boundary value of the color range in such a way that x% of the actual value range is below. For the lower threshold it is vice versa. Values in the model beyond the given thresholds are given special colors to make them easily recognizable. By default the result threshold values given above refer to the value range in percent. Sometimes it turns out to be practical to prescribe absolute values as thresholds (e.g. the yield stress of a material). The radio button group “Result Threshold as” can be used to switch between relative and absolute thresholds. Limiting the value range of utilization values can be confusing: If the result thresholds are given in percent, then setting the lower threshold to zero and the upper to 100 displays the full range of utilization values. If the result thresholds are given as absolute values then a lower threshold of −100 and an upper threshold of 100 limit the color range to the areas where the material resistance is sufficient. ## **The “Colors”-submenu** Here one can enable the display of element-, cross section- and material-colors. See sections [3.1.6](/3-in-depth-component-reference/3.1-model/3.1.6-line-to-beam), [3.3.1](/3-in-depth-component-reference/3.3-cross-section/3.3.1-beam-cross-sections) or [3.4.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties) for how to set them. In order to to visualize the colors enable **"Cross section"** under **"Render Settings"** of the "**BeamView"-** or "**ShellView"**-component. ## **The “Tags”-submenu** The **“Structure Tags”** menu contains checkboxes for adding visual information to parts of the model: | | | | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **"Node tags"** | attaches node-indexes to nodes | | **"Element tags"** | attaches element-indexes to elements | | **"Element Ids"** | displays the element identifiers | | **"Elements"** | if enabled the **“defAxes”** output-plug emits the axis of the deformed elements as lines and shows them on the Rhino-canvas. | | **"CroSec names"** | displays the name of the cross-section of each element | | **"Material names"** | displays the name of the material of each element | | **"Eccentricities"** | visualizes beam eccentricities as blue lines at the end-points if active. | | **"Load values"** | adds the numerical values of loads or point masses to the corresponding symbols | | **"NII"** | prints the value of second order theory normal forces $$N^{II}$$ for all elements where it is not equal to zero. For the meaning of $$N^{II}$$ see section [3.5.2](/3-in-depth-component-reference/3.5-algorithms/3.5.2-analyzethii) | ## **The “Result-Case”-submenu** The **“Result-Case”** menu contains a drop-down list from which one can choose the result-case which should be displayed. When used on a model with loads, the result-cases are equivalent to load-cases. After a buckling-modes, eigenmodes or natural frequency calculation the result-cases contain buckling-, eigen- or natural modes respectively. By default it is set to **“—all—”** which means that the results of all result-cases are superimposed. Define displacement-factors by feeding a corresponding list of numbers into the **“R-Factor”** input-plug. The **“Result-Case”**-selection sets the result-case to be queried for some shell results-components placed further downstream (e.g. **“Force Flow Lines on Shells”**, **“Principal Stress Lines on Shells”**, …). {% file src="/files/0fF8zIQh6rEU3DPUpH7e" %} {% file src="/files/qdYVKwH4Y6BXDro6vQJZ" %} {% file src="/files/9XT2AOWfgIuWbcRhrdou" %} {% file src="/files/zULbSKpKwcGNKWTAMBko" %} # 3.7.2: Deformation-Energy In mechanics, energy is equal to force times displacement parallel to its direction. Think of a rubber band: If you stretch it, you do work on it. This work gets stored inside the rubber and can be transformed into other kinds of energy. You may for example launch a small toy airplane with it: Then the elastic energy in the rubber gets transformed into kinetic energy. When stretching an elastic material the force to be applied at the beginning is zero and then grows proportionally to the stiffness and the increase of length of the material. The mechanical work is equal to the area beneath the curve that results from drawing the magnitude of the applied force over its corresponding displacement. In case of linear elastic materials this gives a rectangular triangle with the final displacement forming one leg and the final force being its other leg. From this one sees, that for equal final forces the elastic energy stored in a material decreases with decreasing displacements which corresponds to increasing stiffness. ![Fig. 3.7.2.1: Simply supported beam under axial and transversal point-load](/files/-Mk71KKbtFpuYhgoXniq) Via the input **“Elems|Ids”** one can supply identifiers od elements of those parts for which the deformation energy shall be calculated. An empty list means that all elements are considered. The **“LCase”**-input lets one select the load-case for which results shall be retrieved. The structure of the data trees returned from the **“D-Energy”**-component (see fig. 3.7.2.1) contains one branch per element. A list of axial deformation energy and bending energy for each element is displayed. In case of shells the branches contain the in-plane or bending energy of each face of the shell. {% file src="/files/9vYq6P7M243AUoCbERc7" %} {% file src="/files/FDyOwNELF1kvBw5arRli" %} # 3.7.3: Element Query The **"Element Query"**-component lets one determine the mass, surface area and the volume of a given set of elements (see fig 3.7.3.1). These and the corresponding model need to be supplied as input at the 'Model'- and 'Elems'-input plugs. The 'Select Elements'-component (see section [3.1.16](/3-in-depth-component-reference/3.1-model/3.1.16-select-elements)) offers a flexible way of grouping elements.\ In case of shell and membrane elements the surface area is the sum of upper and lower boundary. For beams the the outer surface are will be returned - the interior of e.g. tubes is not counted. The meshes of the elements are water tight and come with caps by default. In case this is not desired, set 'with\_caps' to 'False' in the 'karamba.ini'-file. ![Fig 3.7.3.1: Information retrieval regarding elements via the 'Element query'-component](/files/-Mjo5sbZuva4IttKYCVQ) {% file src="/files/Wur4nrDpo62CvNXGXb64" %} # 3.7.4: Nodal Displacements ![Fig. 3.7.4.1: Simply supported beam under axial and transverse point-load](/files/-Mk74J-1hx1eczm7zhTx) The **“NodeDisp”**-component lists the displacements of nodes for the load cases specified via the **“LCase”**-input. Nodes can be selected via position or index. In case mising input there, results for all nodes will be listed in the order of the corresponding node indexes. Two lists consisting of vectors make up the output at the plugs **“Trans”** and **“Rot”**. For each node there is a vector which contains the three nodal translations or rotations (see fig. 3.7.4.1) respectively. A list of nodal displacements is displayed: vectors with translations and rotations for each node and load case. The vectors refer to the global coordinate system. Their units are meter or radiant. A positive rotation say about the global X-axis means that the node rotates counter clockwise for someone who looks at the origin of the coordinate system with the X-axis pointing towards him or her. # 3.7.5: Principal Strains Approximation ![Fig. 3.7.5.1: Approximation of principal strains in a grid of beams.](/files/-MCkEaChYYYiBoZ_BNC6) Karamba3D includes shell elements from which principal stress lines can be retrieved (see section [3.7.12)](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells). In case of single layer grid shells made up of beams the **"Approximate Principal Strains"**-component can be used to determine the approximate principal strain directions of such structures (see fig. 3.7.5.1). It works on arbitrary sets of deformed points. The calculation of principal strains is based on the assumption of a continua. When applied to nodes connected with linear elements the result can thus only result in a qualitative picture -- therefore the term "Approximate". The **"Approximate Principal Strains"**-component expects as input a reference model (input-plug **"Model"**) and the same model in a deformed configuration (input-plug **"def.Model"**). The deformed model can be the output of a **"ModelView"**-component. Hand over a list of points to the input-plug **"Point"** where principal strain directions shall be computed. For each point in this list the following two steps are applied: First those three nodes of the reference model that do not lie on a line and have minimum distance to the given point are determined. Second the strains in the sides of the thus found triangle determine the principal strain directions -- plane stress is assumed. The conversion of first (output-plug **"VT1"**) and second principal strains (output-plug **"VT2"**) to vectors occurs in such a way that they align with the average displacement of the triangle that defines the corresponding strain-state. The size of the vectors emanating from **"VT1"** and **"VT2"** can be scaled by providing a factor in the input-plug **"Scale"**. The principal strains are tangents to the principal stress lines of a structure. Use e.g. Daniel Hambleton's **"SPM Vector Components"** (see [http://www.grasshopper3d.com/group/spmvectorcomponents](http://www.grasshopper3d.com/group/spmvectorcomponents})) to retrieve these lines from the strain-vector-field. {% file src="/files/sJ6968FtpFffLJ42VQoy" %} {% file src="/files/aQE8tmxhlbWeD7KuGQw2" %} # 3.7.6: Reaction Forces 🔷 ![Fig. 3.7.6.1: Reaction forces and moments for two load-cases](/files/-Mk77N8woMyZF3_OGtIh) The **“Reaction Forces”**-component gives access to the support forces and moments. It expects a model at its input-plug and returns via **“RF”** and **“RM”** a list containing reaction forces in $$kN$$ and reaction moments in $$kN m$$ as three dimensional vectors. Specific supports can be selected via the **"Pos|Inds"**-input: either specify node indexes or positions. In case no input is provided, results for all supports will be output. The input-plug **“LCase”** sets the load-case index for which the results shall be output. All support reactions are ordered in such a way that the indexes of the nodes they attach to form an ascending sequence. In case of locally oriented supports, reaction forces refer to the local coordinate system. **“Pos”** returns the position of the supports in the same order as the results. **“SumRF”** and **“SumRM”** offer the possibility to check the resultant reaction moments and forces of each load-case. {% file src="/files/HKt8fVE6xXxjKVGUcGsB" %} # 3.7.7: Utilization of Elements 🔷 Use the **“Utilization of Elements”**-component in order to get the level of utilization for each element. It comes as a multi-component where the drop-down list on the bottom decides whether the utilization of shell of beam elements shall be returned. With beam-utilization selected, the utilization output of shell patches will be output as zero - and vice versa. This serves to maintain the one to one relationship between elements and results. The sequence of element results corresponds to the sequence of elements. The input-plug **“Model”** expects an analyzed model. With **“Elems|Ids”** it is possible to limit the range of elements which shall be considered. Accepted input are element identifiers or elements themselves. By default the component returns results for all elements. The **“LCase”**-input selects the load-case to be used for calculating the utilization. By default it is set to “-1” which means that the maximum utilization of all load-cases will be returned. ## **Utilization of Beams** ![Fig. 3.7.7.1: Beam under two load-cases: Utilization of the cross sections](/files/-Mk79rqWmZmrWedYpNiT) Fig. 3.7.7.1 shows the utilization component for beams. In case of shells, the utilization output value is zero. The meaning of the input-plugs **“nSamples”**, **“Elast”**, **“gammaM0”**, **“gammaM1”** and **"SwayFrame"** exactly corresponds to that of the **“Optimize Cross Section”** (see section [3.5.8](/3-in-depth-component-reference/3.5-algorithms/3.5.8-optimize-cross-section)). The algorithm for determining an element's utilization is the same as that underlying the cross section optimization procedure. Set the input-plug **“Details?”** to **“True”** in order to get intermediate values of the utilization calculation at the output-plug **“Details”**. For large structures the generation of the detailed output may take some time. Utilization numbers for beams rendered by this component (output-plug **“Util”**) and the **“ModelView”** show differences – especially for compressive axial forces: The **“ModelView”**-component returns the ratio of stress to strength as the level of utilization, whereas the “Utilization of Elements”-component also includes buckling. See for example the two utilization entries on the in fig. 3.7.7.1: The second load case (i.e. number “1”) is made up of an axial load acting in the middle of the beam. As both ends are axially fixed, one beam is in tension, one in compression. The absolute value of the normal force in both elements is the same. Yet the beam under compression has a utilization of 0.26, the one under tension only 0.05. “1” means 100 %. The output-plugs **“sig-max”** and **“sig-min”** return the minimum and maximum stress in each beam. In order to diagnose the reason why a specific beam shows over-utilization the output-plugs **“Util-N”**, **“Util-Vy”**, **“Util-Vz”**, **“Util-Mt”**, **“Util-My”** and **“Util-Mz”** return the contribution of each cross section force component to the overall utilization. When enabled via **“Details?”** the output-plug **“Details”** renders a detailed account of intermediate values used for the calculation of the element’s utilization according to EN 1993-1-1 [\[5\]](/appendix/bibliography). ## **Utilization of Shells** ![Fig. 3.7.6.2: Utilization of a shell consisting of two elements](/files/-Mk7CqNxY7qTKQ5-_x5p) The utilization calculated for shells (see fig. 3.7.6.2) is the ratio between the tensile or compressive strength and the material's comparative stress in each face of the shell. The strength criteria applied for evaluating the comparative stress can be 'VonMises', 'Tresca', 'Rankine' and for orthotropic materials 'TsaiWu' (see section [3.5.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). The sign of the comparative stress is determined by the sign or the principal stress with the largest absolute value. In case of different strength values for the tensile and compressive regime, the Von Mises stress gets calculate from the scaled principal stresses: tensile principal stresses get divided by the tensile strength, compressive tensile stresses by the compressive strength. The same procedure applies to the TsaiWu-comparative stress.\ The output-plug **“Util”** lists the utilization of each element of the shell in the same order as the mesh-faces are listed in the mesh which underlies the shell geometry. In case of beams or trusses, 0 is output as utilization. # Examples {% file src="/files/mSNoVoBNl9e3zz10HFjT" %} {% file src="/files/NjyVDA7mfaZFzlvRHgsG" %} {% file src="/files/u4R0RPdZIlMQqRZqMRmj" %} {% file src="/files/uqLYa0w6dDSatHcI1zvR" %} {% file src="/files/CgBznn8VCW8heYI68FtF" %} {% file src="/files/fT87kARRqabyt3JCrjXS" %} # 3.7.8: BeamView ![Fig. 3.7.8.1: Display of utilization and bending moments of cantilever beam](/files/-Mk7Id-pUdCkExLXBayn) The **“BeamView”** component controls the display options related to beams and trusses (see fig. 3.7.8.1). This concerns the rendering of cross section forces, resultant displacements, utilization of material and axial stress. ## **The “Render Settings”-submenu** When activated, **“Cross section”**, **“Displacement”**, **“Utilization”** and **“Axial Stress”** result in a rendered view of the model. Utilization is calculated as the ratio between the normal stress at a point and the strength of the corresponding material. Shear and buckling are not considered. ![Fig. 3.7.8.2: Left: “Cross section”-option enabled. Right: “Axial Stress” enabled.](/files/-MCkEZGFU8S2DjwipxSQ) The color range of the results starts at the minimum value and stretches to the maximum. You can define individual color ranges for all result quantities in the "karamba.ini"-file. Alternatively it is possible to select from a list of color-ranges via the component's context menu: right-click on the component, go to item 'Colors' and select a color range. A **“Legend”**-component lets you inspect the meaning of the colors. The mesh of the rendered image is available at the **“Mesh”**-output of the **“BeamView”**-component. Two sliders control the mesh-size of the rendered beams: First **“Length/Segment”** of **“ModelView”** determines the size of sections along the middle axis of the beams. Second “Faces/Cross section” of **“BeamView”** controls the number of faces per cross-section. For rendering circular hollow cross sections the number of **“Faces/Cross section”** is multiplied by six in order to get a smooth visual result. ![Fig. 3.7.8.3: Mesh of beams under dead weight with upper and lower results threshold set to 53% and 50% ](/files/-MCkEZGGGxVtC_Ou8hB2) It is instructive to see which parts of a beam are under tension or compression. Activate the **“Axial Stress”**-checkbox in menu **“Render Settings”** in order to display the stresses in longitudinal beam direction. Red (like brick) means compression, blue (like steel) tension. In some models there may exist small regions with high stresses with the rest of the structure having comparatively low stress levels. This results in a stress rendering that is predominantly white and not very informative. With the sliders for **“Upper Result Threshold”** and **“Lower Result Threshold”** of the **“ModelView”** you can set the range of the color-scale (see section [3.6.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview#the-tags-submenu)). Result values beyond the upper limit appear yellow, below the lower threshold green (see fig. 3.7.8.3). ## **Display of cross section forces and moments** ![Fig. 3.7.8.4: Moment My about the local Y-Axis and shear force Vz. ](/files/-Mk7OexEIGMUf5SX07_w) The **“Section Forces”** sub-menu lets you plot section forces and moments as curves, meshes and with or without values attached. All generated curves and meshes get appended to the **“BeamView”**-component's **“Curves”** and **“Mesh”** output. The graphical representation is oriented according to the local coordinate axes of the beam and takes the deflected geometry as its base. The subscript of bending moments indicates the local axis about which they rotate, for shear forces it is the direction in which they act (see also fig. 3.7.8.4). The cross section forces refer to the section which is defined by the element's local coordinate system. In fig. 3.7.8.4 the cross section forces need to be applied to the right side of the beam to be in equilibrium with the external point load since the local X-direction points to the left side. The size of the cross section forces diagrams can be scaled separately for forces and moments by the two sliders in the "SectionForces"-menu. Customize the mesh-colors of the cross section forces diagrams via "karamba.ini". The slider **“Length/Subdivision”** in sub-menu **“Render Settings”** of the **“ModelView”**-component controls the number of interpolation points. # 3.7.9: Beam Displacements 🔷 ![Fig. 3.7.9.1: Translations and rotations along the first beam element](/files/-Mk7SwLpH_rb0ixViep2) In case you want to know how displacements change over the length of a beam use the **“Beam Displacements”**-component (see fig. 3.7.9.1). A list of displacements along the axis results: three components of translations and rotations in the local element coordinate system for each section and load case. The **“Beams|Ids”**, **“LCase”**, **"ts”** input-plugs work analogously to those of the **“Beam Forces”**-component (see section [3.7.10](/3-in-depth-component-reference/3.6-results/3.6.9-beam-forces)). The sequence of element results corresponds to the sequence of beams. # 3.7.10: Beam Forces Sometimes it is desirable to have section forces and moments represented as components in the direction of the local axes of the cross section. Use the **“Beam Forces”**-component in such a case.Its output plugs comprise the force components in local directions (see fig. 3.7.10.1). The sequence of element results corresponds to the sequence of beams. The cross section forces refer to the positive side of the beam section which is the side whose normal vector is the element's local X-axis. ![Fig. 3.7.10.1: Orientation of cross section forces of a beam (torsional moment Mx not displayed here)](/files/-MCkEZATk-1rAhG214_P) A list of normal forces, shear forces and moments for all elements and all load cases is returned as displayed in fig. 3.7.10.2. **“LCase”** and **“Beams|Ids”** input can be used to limit the results to a specific load-case of a subset of the beams in the model. The default value of **"LCase"** outputs results for the first load-case. Right-click on the component and select "Expand ValueLists" to get a ValueList-component for selecting ammong the available load-cases.\ Beams can be given via their element identifier, a regular expression for identifier selection or the elements themselves. No input at the **“Beams|Ids”**-input defaults to all elements. The input parameter **"ts"** can be given a list of parameter values between zero and one. Zero corresponds to the beam's starting point, one to its endpoint. By default results at the beginning and at the end are output. ![Fig. 3.7.10.2: Normal force “N”, shear force “V” and moment “My”](/files/-Mk7XxbG-E4k0OImKS4w) {% file src="/files/M23ETF6M2KzLonEYi6Tm" %} # 3.7.11: Node Forces For the design of connections between beam- and truss-elements the output of the **"Node Forces"**-component offers a god starting point. In Fig 3.7.11.1 one can see the results for a node to which six beams with eccentricities connect. The first input on the left side is the model for which to retrieve the results. The node in question can be specified either via coordinate of node index. The input-plug **"Plane"** lets the user define a plane of reference for the output directions **"Dir"** and the cross section forces **"Fs"** and moments **"Ms"**. The latter applies only in case that the **"Local?"**-input receives 'False' - which is the default.\ If not specified the default reference plane is equivalent to the global coordinate system. Via the **"LCase"**-input one can specify the load-case for which to retrieve the cross section forces. If set to 'True' the **"Local?"**-input makes the output forces and moments in **"Fs"** and **"Ms"** refer to the local element coordinate system. This can be useful in some cases. Then however the sum of forces and moments and externa nodal loads does not add up to zero. ![Fig 3.7.11.1: Cross section forces around a node with eccentric beams attached.](/files/-Mk6sSCrg4gxaVrJss3X) On the component's output-side one gets the list of beam- or truss-elements that connect to the node. The order of the unit-vectors in the **"Dir"**-List corresponds to that of the elements in **"Elems"**. They point in the direction parallel to the elements but away from the node. By forming the dot-product between an element's local X-axis and the vector in the **"Dir"**-List one sees whether the element's starting- or end-point connects to a node. The output **"Fs"** contains vectors of cross section forces Nx, Vy, and Vz - again in the order of output elements in **"Elems"**. The moment vectors **"Ms"** - they contain Mx, My and Mz - refer to the position directly at the node. They get transformed to the element's reference line so beam eccentricities do not affect them. In this way they add up to zero (see fig. 3.7.11.1) in the absence of external nodal moment-loads. {% file src="/files/pvvLRK1Mn0QmroO2JxpO" %} # 3.7.12: ShellView ![Fig. 3.7.12.1: Utilization on a deformed shell](/files/-Mhs90w9kJKf6qyJ3KuR) The **“ShellView”**-component works like the **“BeamView”**-component (see section [3.6.7](/3-in-depth-component-reference/3.6-results/3.6.7-beamview)) and controls the display of shell results. Fig. 3.7.12.1 shows the resultant displacement of a shell. Shell cross sections may consist of several layers (see section [3.3.2](/3-in-depth-component-reference/3.3-cross-section/3.3.2-shell-cross-sections)). The layer with index “0” spans the whole cross section height by default, the other layers can be used to e.g. specify reinforcement layers. With the **“LayerInd”**-input, which defaults to “0”, one can specify the cross section layer to be displayed. In order to set the location inside a layer one has to specify a fiber: “1” corresponds to the upper boundary, “−1” to the lower boundary of a layer. The local z-axis points to the upper boundary. Since the shell layers may have arbitrary orientations, it is often useful to display their local coordinate systems. This can be done with the **“Local layer axes”**-radio button under the **“Display Scales”**-submenu. The slider there allows to adapt the size of the coordinate system arrows. The color range of the results starts at the minimum value and stretches to the maximum. You can define individual color ranges for all result quantities in the "karamba.ini"-file. Alternatively it is possible to select from a list of color-ranges via the component's context menu: right-click on the component, go to item 'Colors' and select a color range. A **“Legend”**-component lets you inspect the meaning of the colors. Under the sub-menu **“Render Settings”** one can choose from the following rendering options which always refer to the currently set layer: | | | | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Cross section"** | Shows the upper and lower surface of the current layer and adds them to the output at the **“Mesh”**-output plug. There are strips at the sides so that a closed volume results. The output meshes are welded together by default for to speed up their display. Set 'weld\_shell\_meshes\_for\_output' in the karamba.ini-file to false to get the meshes one by one. | | **"Thickness"** | Similar to "Cross section": adds colors at the vertices to indicate the thickness of the shell elements. The vertex colors result from the mean thickness of the faces they are connected to. | | **"Utilization"** | Renders the material utilization. The utilization is calculated as the ratio between the material strength and the material's equivalent stress (see section [3.5.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). A negative sign results if the negative value of the second principal stress is larger than the first principal stress. The output comprises two meshes symbolizing the utilization values on the top and bottom layer. | | **"Displacement"** | Colors the shell according to the resultant displacement. | | **"Princ. Stress 1"** | Visualizes the resultant value of the first principal stress in the current fiber of the current layer. The fiber can be set with the **“Position of results”** slider (see below). | | **"Princ. Stress 2"** | Displays the resultant value of the second principal stress in the current fiber. | | **"Equivalent Stress"** | Renders the equivalent stress in the current layer and position. Its value depends on the strength hypothesis chosen for the shell layer's material (see section [3.5.1](/3-in-depth-component-reference/3.4-material/3.4.1-material-properties)). | | **"Position of results"** | Sets the position within the current shell layer where results are calculated. A value of 1 corresponds to the upper, −1 to the lower boundary of the current layer. | | **"Princ. Stress 1-2"** | Enables or disables and scales the vector display of principal stresses in the current fiber of the current layer. Use the “Result Threshold” sliders in the **“Display Scales”**-menu of the **“ModelView”**-component to thin them out if necessary. | # 3.7.13: Line Results on Shells ## **Line Results on Shells** This multi-component generates force-flow-lines, iso-lines, principal moment- or stress-lines. ## **Force Flow Lines on Shells** ![Fig. 3.7.13.1: Cantilever consisting of triangular shell elements: Flow lines of force in horizontal direction](/files/-MCkEYP2k3r7l67dADvA) Force flow (FF) lines or load paths (as they are also sometimes called) illustrate the load distribution in structures [\[11\]](/appendix/bibliography)). There is a loose analogy between those force flow (FF) lines and streamlines in hydromechanics: The law of conservation of mass in hydromechanics is matched by the static conditions of equilibrium in a specified direction. If there are two FF-lines the resultant force between those in a predefined direction stays constant. Consider e.g. the cantilever in fig. 3.7.13.1 for which the force flow in horizontal direction is described by the red lines. At the supports the force flow lines run nearly horizontal at the upper and lower side where the normal stresses from the supports reach their maximum and thus dominate the resultant force. They gradually curve down to the neutral axis where the shear stresses constitute the only contribution to horizontal forces. Aside from resulting in nice line drawings those force flow lines can be practical as well [\[11\]](/appendix/bibliography): * FF-lines form eddies in ineffective (with respect to the given force direction) parts of a structure or reverse their direction there. * In case you want to strengthen a structure with linear elements (e.g. fibers) align them with FF-lines to get the most effective layout. FF-lines are not the same as principal stress lines because the latter lack the property of constant force between adjacent lines. The **“Shell Force Flow Lines”**-component lets you create force flow lines in arbitrary points of shells (see fig. 3.7.13.1). The load-case considered is that defined in the nearest upstream **“ModelView”**-component. There exist seven input plugs: | | | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **"Model"** | The model from which you want to create FF-lines. By default the results of all load-cases get superimposed with factor “1”. Use a **“ModelView”**-component to select specific load-cases or to impose load-factors other than “1”. | | **"Layer"** | In case of bending, the stress state of shells and therefore the FF-lines change over the cross section height. A value of “-1” denotes the lower “1” the upper shell surface and “0” the middle layer. The default value in “0”. | | **"ForceDirs"** | Expects a vector or list of vectors that defines the principal force direction. This direction gets projected on each element in order to define the local force flow. Elements perpendicular to the **“ForceDir”**-vector are skipped. Multiple such directions can be defined for different regions. | | **"ForceDirPos"** | For each vector in **“ForceDirs”** a position can be defined. The force direction at an arbitrary point on the shell corresponds to the **“ForceDir”**-vector with the closest **“ForceDirPos”**. | | **"Source"** | Defines points on the shell where FF-lines shall originate. You can feed points on or near the shell into this plug. It is also possible to use lines that intersect the shell. In case of multiple intersections there will be the same number of FF-lines. | | **"Seg-L"** | Intended length of the segments of the resulting FF-lines. Is 0.5 m by default. A negative value means that only INT(abs(Seg-L)) line segments will be drawn. | | **"dA"** | This parameter sets the accuracy with which the FF-lines get determined: It is the maximum differential angle between to adjacent pieces of a FF-line. If this criteria results in pieces of length smaller than **“Seg-L”** then they will be joined before sent to the output-plug **“Line”**. By default this value is set to 5°. | | **"theta"** | Here you can define an angle between the FF-lines and those lines output at the **“Line”**-output plug. The angle is in degree and defaults to zero. | The output of the **“ShellFFlow”**-component consists of lines arranged in a data tree. The right-most dimension contains the branches of each flow-path: In case of a e.g. a plane there are two branches that originate from the given intersection point. In case of T-like shell topologies this number can grow to three and larger. ## **Isolines on Shells** The **“Isolines on Shells”**-component lets you do two things: First draw contour lines on shells that connect points of equal principal stresses, principal moments, utilization, resultant displacements or shell thickness (see fig. 3.7.13.2). Second query results in arbitrary points of the shell. ![Fig. 3.7.13.2: Lines of equal second principal stress on a cantilever](/files/-MCkEYP5vvYl3wwYIaiW) The input-plugs **“Model”**, **“Layer”** and **“Seg-L”** have the same meaning as for the **“Force Flow Lines on Shells”**-component (see section [3.6.12](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells#force-flow-lines-on-shells)). In terms of placing iso-lines on the structure the input **“Vals|Pts|Lines”** offers the following options: | | | | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **"Vals"** | In case a list of numbers is supplied, iso-lines at these levels will be created. See the context help of the input-plug for the physical unit to use. One can e.g. use the **“Legend T”**-output of the **“ShellView”**-component after removing the first and last item from the list. | | **"Pts"** | Iso-lines will start at the closest projection of the given points on the shell. | | **"Lines"** | The intersection points of the given lines and the shells serve as seeds of iso-lines. | The load-case to examine as well as load-case factors can be set with a **“ModelView”**-component plugged into the definition ahead of the **“Isolines on Shells”**-component. By default all load-cases get superimposed using unit load-factors. Isolines are straight lines within each shell face. This may result in slightly rugged poly-lines. Set the **“Smooth”**-input plug to “True” in order to flatten them out. The **“Line”**-output-plug will then return splines instead of lists of line-like curves. They result from using the calculated iso-points as control-points. For curved shell geometries this has the disadvantage that those splines no longer stay exactly on the shell surface. This may give you a hard time trying to intersect different groups of such lines. In the “property”-submenu one can select the result-value to be displayed: first or second principal stress (**“Sig1”**, **“Sig2”**), first or second principal bending moments (**“m1”**, **“m2”**), utilization (**“Util”**), resultant displacement (**“Disp”**) or shell thickness (**“Thick”**). The **“Lines”**-output data-structure corresponds to that of the **“Force Flow Lines on Shells”**-component. Each number in the output-plug **“Value”** corresponds to one piece of iso-line from the **“Lines”**-output. ## **Principal Moment Lines on Shells** Works like the “Principal Stress Lines on Shells” component (see section [3.6.12](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells#principal-stress-lines-on-shells)). Instead of principal stress lines it returns principal moment lines. ## Transverse Shear Works like the “Principal Stress Lines on Shells” component (see section [3.6.12](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells#principal-stress-lines-on-shells)). Instead of principal stress lines it returns in-plane principal shear lines. They result from integrating the transverse shear directions. These result from applying the transverse shear forces vx and vx in the shell's local X- and Y-direction. See [\[13\]](/appendix/bibliography) and[ \[14\]](/appendix/bibliography) for details. ## **Principal Stress Lines on Shells** ![Fig. 3.7.13.3: Principal stress lines: they are tangent to the first and second principal stress direction](/files/-MCkEYP8FmGs63e7HlFn) Principal stress (PS) lines are tangent to the principal stress directions (see fig. 3.7.13.3). In the case of a cantilever they either run parallel or at right angle to the free boundaries. In the middle where normal stresses due to bending vanish, first and second principal stress lines intersect the middle axis at 45°. The meaning of the input-plugs of the **“Principal Stress Lines on Shells”**-component correspond to that of the **“Force Flow Lines on Shells”**-component (see section [3.6.12](/3-in-depth-component-reference/3.6-results/3.6.12-line-results-on-shells#force-flow-lines-on-shells) for details). On the output side **“Lines1”** and **“Lines2”** hold the first and second principal stress lines in data trees: the right-most dimension holds a list of lines that represent a part of a PS-line. There are usually two parts per line that start off to either side of the starting point. In case of more complicated topologies there can be more than two parts. These parts populate the second dimension from the right. {% file src="/files/MFA9Ce8iDnlvGCNiOov3" %} {% file src="/files/9Jr0jRUH4TCvh1yvw4mU" %} {% file src="/files/Xp8ADWdYU27QitHtLwSA" %} # 3.7.14: Result Vectors on Shells ## **Principal Force Directions on Shells** ![Fig. 3.7.14.1: Cantilever analyzed as shell structure: directions of second principal normal forces](/files/-MCkEa6UwlbyX3hM9_m3) The “Principal Force Directions on Shells”-component lets you retrieve principal normal forces and moments at element centers (see fig. 3.7.14.1). All shells of a model get considered by default. Use the input-plug **“ElemIds”** to select a subset. Results refer to the selected load-case at the nearest upstream **“ModelView”**-component. The order of all result lists corresponds to the order of faces in the mesh used to generate the shell. Output-plug **“P”** lists the coordinates of the element centers where the normal forces and bending moments were calculated. **“N1-Vec”**, **“N2-Vec”**, **“M1-Vec”** and **“M2-Vec”** deliver the first and second principal normal force and moment directions as vectors. Their length corresponds to the absolute value of the corresponding quantity in kilo Newton per meter (for forces) or kilo Newton meter per meter (for moments). The output plugs **“N1-Val”**, **“N2-Val”**, **“M1-Val”** and **“M2-Val”** return the values of the principal normal forces and moments. ## **Principal Stress Directions on Shells** ![Fig. 3.7.14.2: Triangular mesh of shell elements and principal stress directions at their centers](/files/-MCkEa6WQ2QQDcW5miDZ) This components provides the same results as the **“Princ. Stress 1-2”** option of the **“ShellView”**-component (see fig. 3.7.14.2). The output-plug **“P”** renders the positions of the elements centers. **“Sig1-Vec”** and **“Sig2-Vec”** return vectors for the first and second principal stresses there. **“Sig1-Val”** and **“Sig2-Val”** output the values of the first and second principal stresses. Thin out results by setting **“Result Threshold”** of **“ModelView”** (needs to be upstream of the data-flow) to a value of less than 100 %. Like for isoline and force-flow lines a specific load case or superimposition of load cases can be set via **“ModelView”**. By default all load-case results get added up using unit load factors. # 3.7.15: Shell Forces With the **“Shell Forces”**-component one can retrieve principal or local shell cross section forces. Use the drop-down-list at the bottom of the component to switch between **“Principal”** and **“Local”**. ## **Principal Shell Forces** Sometimes it is of interest to know the value of principal normal forces and moments on shells. In such cases the **“Shell Forces”**-component for principal forces comes in handy. The order of all result lists corresponds to the order of faces in the mesh used to generate the shell, which is the same order as the **“Principal Force Directions on Shells”**-component. Thus the element centers returned there can be used in combination with the numeric results. Distributed normal forces are negative in case of compression. Positive bending moments result in tension on the upper side of a shell. The upper side of a shell element is defined by a positive value of the local Z-axis. When in doubt about the orientation of your shell elements enable the preview of local element axes in the **“ModelView”**-component (see section [3.6.1](/3-in-depth-component-reference/3.6-results/3.6.1-modelview)). The output-plugs **“vx”** and **“vy”** return transverse shear forces along lines parallel to the shells local x- and y-axis. ## **Local Shell Forces** When setting the result type to **“Local”** the shell cross section forces in local coordinate directions will be output. See section [3.1.14](/3-in-depth-component-reference/3.1-model/3.1.14-orientate-element#orientate-shell) on how to change the local coordinate systems of shells. {% file src="/files/gllbMIYdWiaF7ZQcd3fJ" %} # 3.7.16 Results at Shell Sections The 'Shell-Section'-component lets you determine forces, stresses and displacements of a shell along arbitrary poly-lines. The "Shell Section"-component comes as a multi-component where the drop-down menu at the bottom selects between the different response properties: forces, stresses and displacements. These inputs form the basis for results retrieval: | | | | ----------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | |

"Model"

|

The input-plug 'Model' receives an evaluated, structural model.

| |

"ShellIds"

|

List of identifiers to specify the shells for which to get results. If not provided all shells potentially contribute response data.

| |

"LCase"

|

Specifies the load-case of interest - the first by default. Use "Expand ValueLists" from the context menu for selection via ValueList-component.

| | **"Pl"** | Expects a poly-line which gets mapped onto the shells and thus defines the section. | | **"D"** | Projection direction of the above poly-line on the shell. | Besides results specific to the evaluation type, the component provides these outputs (see Fig. 3.7.16.1): | | | | ---------------- | ----------------------------------------------------------------------------------------------------------------------- | | **"Model"** | Same model as on the input-side for further processing. | | **"Pl"** | Poly-line of the section on the shell. | | **"indices\_f"** | The index of the mesh-face of each segment of the above poly-line. | | **"Mesh"** | Mesh of the diagram which displays the result values along the shell section when the user selects the option "filled". | | **"Curve"** | Line-segments that indicate the result amplitudes along the section. | ### Results Depending on the result type, the output-plugs of this sub-menu give access to numerical results. In case of distributed forces and stresses there is one value per face. For displacements there results one value per face-edge. ### Display Results Use this sub-menu to specify and adapt the rendering of results in the Rhino viewport. By default the result diagrams consists of curves that connect the value points painted in the normal direction of the shell elements (see output-plug "Curve"). Distributed forces and stresses show as column diagrams with one column per face. Beatify these diagrams with the option 'Smooth': values then get interpolated at the element edges. The "Mesh" output-plug delivers the graphical outcome for further processing.\ If you want to see numbers at the result points enable them via the radio button "Numbers". The slider "Text height" can be used to scale their display size.\ Depending on the type of results, one or more sliders set the value to length factor for the result diagrams.\ A set of radio-buttons at the bottom of the sub-menu let's one select result components to be displayed. In case you wonder why nothing is displayed check whether at least on of those buttons has been enabled. ### Display Axes A shell section comes with its own local coordinate system. Enable its display in the sub-menu "Display axes" by clicking on the 'Local axes' button. The tangential direction (red) points in the direction of the cutting line and inherits its orientation from the poly-line used to define the section in the first place. The Z-direction (blue) points in the direction of the shell elements local Z-axis. Green arrows depict the section's normal-direction and forms with the section's Y- and Z-directions a right-handed coordinate system. ![Fig. 3.7.16.1: Section through a shell consisting of two elements.](/files/-MdRXQAn_Mh2UT6U5FXD) ## Shell Section Forces The result type "forces" retrieves distributed normal-, shear-forces and bending moments. The force and bending moment components have two indices: the first one depicts the plane on which the force or moment causes stresses, the second index represents the direction of the stress vector. "t" stands for tangential direction, "n" for the normal direction of the section. The image in figure 3.7.16.2 displays the bending moments which cause normal stresses in tangential direction to the section. ![Fig. 3.7.16.2: Bending moment diagram along the middle axis of a simply supported shell-strip.](/files/-Mdvibo1jGoAqte1RSsA) In case of the transverse shear components the index indicates the plane in which the shear stresses get added up. In the above example the component Vt gives the customary, linear distribution of shear forces with the maxima at the supports. ### Shell Section Stresses The section stresses display works similar to the one for forces. Since stresses may change over the plate thickness, one needs to specify the layer-position where to retrieve results (see fig. 3.7.16.3). In case of reinforced concrete cross sections there may be several shell layeres with different stresses to be selected via the "LayerInd" input-plut. \ The figure below shows what happens if result smoothing is disabled: there is one result column for each face. Instead of one poly-line several line-segments show up at the "Curve" output.\ For the meaning of the "n" and "t" see the above paragraph. ![Fig. 3.7.16.3: Normal stress in tangential direction of the section at the bottom of the plate](/files/-MdvlDzjHtuDgw6LPKvQ) ### Shell Section Displacements This lets you retrieve displacements at the element edges in global X-, Y- or Z-direction. Additionally resultant displacement can be output via the "DispLen"-option. ![Fig. 3.7.16.4: Displacement diagram along a shell section.](/files/-MePOfORP-OEdbQUzyqo) {% file src="/files/nbF9QPnXG3AIYDd6rQFF" %} {% file src="/files/mUVtkHMW8SADixB05usJ" %} {% file src="/files/0m2zWm1PH0bZtCRNWwZY" %} # 3.8: Export 🔷 Karamba3D is not meant to be a substitute for a full blown structural engineering finite element software package. Instead it aims at providing flexibility in testing different structural designs that the more traditional FE-applications lack. We therefore started to implement interfaces to those traditional civil engineering packages. At the moment Karamba3D supports data exchange with RStab5, RStab6, RStab7, RStab8 and Robot. With [GeometryGym ](https://geometrygym.wordpress.com/)it is possible to export Karamba3D model data to IFC. --- [Next Page](/llms-full.txt/1)