Loads

Files

• BeamDistributedLoadComponent.cs

  This file defines `BeamDistributedLoadComponent`, a Grasshopper plugin component designed to assign distributed loads to structural beams within the FeMM (Finite Element Method for Modeling) framework. It accepts inputs such as the target beam, load case, load type schema, coordinate system, and directional vectors to configure specific load patterns like uniform or trapezoidal distributions. The component dynamically updates its user interface, including input options and visual icons, based on the selected load type and coordinate system settings. Its primary function is to validate these inputs and generate a modified beam object containing the defined distributed load data. Key components include dynamic parameter registration, real-time validation logic, and integration with custom FeMM data types for structural analysis workflows.

• BeamDistributedMomentComponent.cs

  This file defines a Grasshopper component for applying distributed moment loads to structural beams within the FeMM finite element modeling framework. It accepts inputs such as the target beam, load case, and specific schema parameters (like P1, PA, PB) to define the load distribution type and geometry. The component validates these inputs against various load schemas, updating its visual icon dynamically to reflect the selected configuration. It also checks for potential conflicts, such as warnings if non-structural mass acceleration is enabled in the connected load case. Finally, it processes the data to modify the beam object with the specified distributed moment and outputs the updated beam.

• BeamGradientLoadComponent.cs

  `BeamGradientLoadComponent.cs` is a Grasshopper plugin component designed to apply gradient loads to structural beams within the FeMM finite element modeling framework. It functions by accepting an existing beam, a load case, and two numeric values representing load intensities on local axes 1 and 2 as inputs. The core logic creates a `BeamGradientLoadModel` using these parameters and attaches it to a copy of the input beam. Finally, it outputs the modified beam containing the newly defined gradient load for further processing in the simulation workflow.

• BeamNSMassComponent.cs

  This file defines a Grasshopper component named `BeamNSMassComponent` within the FeMM framework, designed to assign non-structural mass properties to structural beams. It functions by taking a beam geometry and a load case as inputs, then applying specific mass distributions based on user-selected schemas (such as point masses or distributed loads). Key components include input parameters for mass values at various locations (P1, PA, PB, P2), position ratios, dynamic factors, and offset vectors. The component validates these inputs against the selected schema type, providing runtime warnings if required data is missing or invalid. Finally, it outputs the modified beam with the applied non-structural mass attributes integrated into the specified load case model.

• BeamPointLoadComponent.cs

  `BeamPointLoadComponent.cs` is a Grasshopper plugin component designed to apply point force loads to structural beams within the FeMM finite element analysis framework. It accepts inputs for a target beam, a load case, an optional local coordinate system, and specific force magnitudes (P1/P2/P3 or PX/PY/PZ) along with a distance ratio `a`. The core logic in `SolveInstance` validates these inputs, constructs a `BeamPointLoadModel`, and attaches it to the beam object before outputting the modified geometry. Key components include dynamic input renaming based on the selected coordinate system and runtime warnings for invalid parameters like non-structural mass flags. This tool facilitates the parametric definition of concentrated forces for structural simulation workflows.

• BeamPointMomentComponent.cs

  `BeamPointMomentComponent.cs` is a Grasshopper plugin component designed to apply point moment loads to structural beams within the FeMM (Finite Element Method for Mechanics) framework. It accepts inputs for a beam, load case, optional coordinate system, and specific moment magnitudes along with their position ratio. The core logic in `SolveInstance` validates these inputs, constructs a `BeamPointLoadModel` with the specified moment data, and attaches it to the beam's load collection. Key components include dynamic input parameter naming that adjusts based on whether a local or global coordinate system is used, ensuring clarity for users applying moments in different axes. The component outputs the modified beam object, allowing it to be chained into further structural analysis workflows.

• BeamPreLoadComponent.cs

  This file defines `BeamPreLoadComponent`, a Grasshopper plugin component for the FeMM framework that applies pre-load conditions to structural beams. It accepts inputs for a target beam, a load case, and specific parameters defining whether the preload is tension or strain along with its magnitude. The core logic in `SolveInstance` validates these inputs, creates a `BeamPreLoadModel`, and attaches it to the beam's load collection. Key components include input registration for generic beam/load case data, integer-based type selection (0 for Tension, 1 for Strain), and output of the modified beam object. The component also includes safety checks, such as warning users if non-structural mass acceleration is active in the connected load case.

• NodeDisplacementLoadComponent.cs

  This file defines a Grasshopper component named `NodeDisplacementLoadComponent` within the FeMM framework, designed to apply displacement boundary conditions to finite element models. It accepts inputs for a specific node, a load case, and optional global translation and rotation vectors to define the displacement magnitude. The core logic validates that at least one displacement vector is provided before creating a `NodeDisplacementLoadModel` instance. This load data is then attached to the input node's collection of loads, effectively modifying the node object. Finally, the component outputs the updated node, allowing it to be passed to subsequent analysis or definition steps in the Grasshopper script.

• NodeLoadComponent.cs

  `NodeLoadComponent.cs` is a Grasshopper plugin component designed to apply force loads to specific nodes within a Finite Element Method (FEM) model. It accepts inputs for a target node, load case, and a 3D force vector, while optionally allowing the user to define a local coordinate system for the load direction. The core logic creates a `NodeForceLoadModel`, assigns it to the specified node's load collection, and outputs the modified node object. Key components include input parameter registration for flexible data types and a solution method that handles both global and custom coordinate systems. This tool facilitates the automated definition of structural loads in computational engineering workflows.

• NodeMomentComponent.cs

  This file defines a Grasshopper component named `NodeMomentComponent` within the FeMM (Finite Element Method Modeler) framework. It functions to assign a specific moment vector to a structural node, optionally defining its direction via a local coordinate system or defaulting to global axes. Key components include input parameters for the target node, load case, moment vector, and an optional coordinate system, which are processed in the `SolveInstance` method to create a `NodeMomentLoadModel`. The component then attaches this load definition to the node’s data structure and outputs the modified node. This allows users to programmatically apply rotational loads to finite element models within a visual scripting environment.

• NodeNSMassComponent.cs

  This file defines `NodeNSMassComponent`, a Grasshopper plugin component for Rhino that assigns non-structural mass to specific nodes within a Finite Element Model (FEM) workflow. It functions by accepting five inputs: the target node, the load case, the mass value, a dynamic factor, and an optional spatial offset. The core logic in `SolveInstance` constructs a `NodeNSMassModel` using these parameters and attaches it to the node's existing load collection. This modified node is then passed through as the single output, allowing for sequential data flow in visual programming scripts. Key components include input parameter registration, data validation via `IGH_DataAccess`, and integration with custom FeMM data types like `GH_Node` and `GH_Case`.

• NodeTemperatureComponent.cs

  This file defines a Grasshopper component named `NodeTemperatureComponent` within the FeMM framework, designed to apply temperature loads to finite element models. It serves as a specialized tool for structural analysis workflows by accepting inputs for a specific node, load case, temperature type, and numerical value. The component processes these inputs to create a `NodeTemperatureLoadModel` instance and attaches it to the specified node's load collection. Key components include input registration for node and load parameters, an enumeration-based selector for temperature types, and the core logic in `SolveInstance` that modifies the node object. Finally, it provides custom iconography and a unique GUID to ensure proper identification within the Grasshopper environment.

• PlateLoadUniformToFrameComponent.cs

  This file defines a Grasshopper component named `PlateLoadUniformToFrameComponent` within the FeMM framework, designed to assign uniform pressure loads from plates to frame elements for SAP analysis. It accepts inputs for a target plate, load case, magnitude, direction, and distribution type, allowing users to specify how the load is applied relative to local or global axes. The core logic resides in the `SolveInstance` method, where it constructs a `PlateLoadUniformToFrameModel` object by mapping input parameters to specific load data properties. A key feature is its handling of coordinate systems, particularly validating that gravity-based distributions do not conflict with local coordinate systems. Finally, it outputs the modified plate object containing the newly attached load definition, enabling seamless integration into structural modeling workflows.

• PlateNSMassComponent.cs

  `PlateNSMassComponent.cs` is a Grasshopper plugin component designed to assign non-structural mass loads to finite element plates within the FeMM framework. It accepts inputs for a target plate, load case, surface mass value, dynamic factor, and an optional offset vector. The core logic creates a `PlateNSMassModel` instance using these parameters and attaches it to the plate's existing loads collection. Finally, it outputs the modified plate object, allowing users to propagate the updated structural data downstream in their simulation workflow.

• PlatePreStressComponent.cs

  `PlatePreStressComponent.cs` is a Grasshopper plugin component designed to assign prestress loads to finite element plates within the FeMM framework. It accepts an input plate, a load case, and scalar values for local X, Y, and Z directions to define the prestress vector. The component constructs a `PlatePreStressModel` using these inputs and attaches it to the plate's load collection. Finally, it outputs the modified plate object with the applied prestress defined in the local coordinate system.

• PlatePressureComponent.cs

  `PlatePressureComponent.cs` is a Grasshopper plugin component that assigns pressure loads to finite element plates within the FeMM framework. It functions by taking input parameters such as a target plate, load case, optional coordinate system, face selection, and pressure value to generate a modified output plate with the applied load. Key components include input registration for geometric and data types, and a `SolveInstance` method that validates inputs, constructs a `PlatePressureModel`, and attaches it to the plate’s load collection. The class inherits from `GH_Component` and utilizes custom FeMM data types like `GH_Plate` and `GH_Case` to ensure compatibility with the simulation environment.