Definitions

Files

• BeamModifiersNameComponent.cs

  This file defines a Grasshopper component named `BeamModifiersNameComponent` within the FeMM (Finite Element Method Manager) framework, specifically tailored for SAP/ETABS structural analysis. It serves to create named beam modifiers by accepting a string name and optional numerical factors for various cross-sectional properties like area, shear areas, torsional constant, inertia, mass, and weight. The key components include input parameter registration for these physical attributes and a `SolveInstance` method that aggregates them into a `BeamModifierNamedModel`. Finally, it packages this model into a `GH_FunctionDefinition` object, outputting it as a single generic data item for use in downstream definition workflows.

• BeamReleasesNamedSetComponent.cs

  This file defines a Grasshopper component named `BeamReleasesNamedSetComponent` that allows users to define specific beam end releases for finite element analysis. It accepts an optional name and up to twelve numeric inputs representing axial, shear, torsion, and moment release values for both the starting and ending nodes of a beam element. The component processes these inputs by checking which parameters were provided and populating a dictionary to track their presence. It then constructs a `BeamReleasesNamedModel` object using these values and corresponding vector representations for forces and moments. Finally, it outputs this model wrapped in a `GH_FunctionDefinition` as a single "Named release" output parameter. This tool is designed for structural engineers to precisely specify boundary conditions or hinge behaviors at beam ends within a parametric modeling workflow.

• CombinationsTableComponent.cs

  This file defines a Grasshopper component named `CombinationsTableComponent` that generates and manages lists of structural load combinations from input load cases. It processes two primary inputs—Load Cases and optional Freedom Cases—to produce a resulting list of Load Combinations. Key components include custom serialization logic using Newtonsoft.Json to persist state during file saves/loads, and change-detection mechanisms that trigger recalculation only when inputs differ from previous states. The component also features a custom UI attribute class (`LoadCombinationsTableAttributes`) to control the visual layout, resizing limits, and parameter positioning within the Grasshopper canvas.

• ConstrainBodyComponent.cs

  This file defines a Grasshopper component named `ConstrainBodyComponent` within the FeMM framework, designed to apply body constraints to finite element models. It accepts optional inputs for translational and rotational restraints (Ux/Uy/Uz and Rx/Ry/Rz) as either boolean flags or displacement values, along with an optional local coordinate system. The core logic processes these inputs to populate a `NodeBodyConstraintModel`, handling type casting and validating that displacement inputs are not used for constraint definitions. By default, it assumes a global coordinate system if none is provided. Finally, it outputs the resulting constrained body definition as a generic data item for downstream use in simulation workflows.

• ConstraintDiaphragmComponent.cs

  This file defines a Grasshopper component named `ConstraintDiaphragmComponent` within the FeMM (Finite Element Method for Meshes) plugin framework. Its primary function is to create and define a diaphragm constraint for structural analysis by accepting user inputs for a name, axis orientation, and an optional coordinate system. The component utilizes the `NodeDiaphragmConstraintModel` to encapsulate these parameters into a specific data structure that represents the physical constraint. Key components include input registration for text, integer enumeration values, and optional coordinate systems, alongside an output port that passes the resulting generic definition object downstream. This enables users in a visual programming environment to programmatically assign rigid plane behavior to nodes in a finite element model.

• CoordinateSystemComponent.cs

  This file defines a Grasshopper plugin component named `CoordinateSystemComponent` that creates custom 3D coordinate systems within the Rhino environment. It accepts four inputs: a text name, and three points defining the origin and orientation vectors (P1 and P2). The core logic in the `SolveInstance` method aggregates these inputs to instantiate a `CoordinateSystemModel` object. Finally, it outputs this model wrapped in a `GH_FunctionDefinition` for use in downstream definitions. Key components include standard Grasshopper parameter registration methods and specific FeMM domain models for handling the geometric data.

• FreedomCaseCombinationComponent.cs

  This file defines a Grasshopper component named `FreedomCaseCombinationComponent` within the FeMM framework, designed to aggregate structural load cases into a single combination definition. It accepts three inputs: a text name for the combination, a list of freedom case objects, and a corresponding list of numerical coefficients that scale each case. The core logic iterates through these inputs to populate a dictionary where keys are case models and values are their summed weighted contributions, handling cases where fewer coefficients are provided than cases by defaulting missing values to zero. Finally, it wraps the resulting model into a generic output parameter (`GH_Combination`) for downstream use in the visual programming environment. Key components include input registration for names and lists, a solving instance that manages the accumulation logic, and standard Grasshopper metadata like GUID and icon exposure.

• FreedomCaseComponent.cs

  This file defines the `FreedomCaseComponent`, a Grasshopper plugin component within the FeMM framework that creates structural freedom cases. It functions by accepting a single text input for the case name and outputting a corresponding `GH_FreedomCase` data object. The core logic resides in the `SolveInstance` method, which instantiates a `FreedomCaseModel` using the provided name and wraps it for Grasshopper compatibility. Key components include parameter registration for inputs/outputs, a unique GUID for identification, and custom icon support for visual clarity in the canvas.

• GroupComponent.cs

  This file defines a Grasshopper component named `GroupComponent` within the FeMM framework, designed to create logical group definitions for structural analysis. It inherits from `GH_Component` and accepts two inputs: a mandatory text name and an optional parent group reference. The core logic resides in the `SolveInstance` method, which instantiates a `GroupModel` using these inputs and outputs it as a generic `GH_Group` data type. Key components include parameter registration methods that define the input/output structure and specific overrides for exposure level, icon display, and unique GUID identification. Ultimately, this script facilitates the organization of load cases or structural elements into hierarchical groups within the Grasshopper environment.

• LinearStaticLoadCaseSAPComponent.cs

  This file defines a Grasshopper component named `LoadCaseLinearStaticSAPComponent` for the FeMM plugin, designed to create linear static load cases for SAP2000 analysis. It accepts inputs such as a case name, an optional initial reference case, and lists of load patterns with corresponding scale factors. The component validates these inputs to ensure they are properly formatted before constructing a `LoadCaseLinearStaticSAPModel` object. It handles initialization logic by either starting from zero conditions or inheriting stiffness states from a previous nonlinear case. Finally, it outputs the defined load case as a generic data item for use in subsequent structural analysis workflows.

• LoadCaseComponent.cs

  `LoadCaseComponent.cs` is a Grasshopper plugin component that defines structural load cases for finite element analysis. It accepts three inputs: a name, a boolean flag for applying gravity to non-structural mass, and an integer specifying the load pattern type. The `SolveInstance` method validates these inputs, automatically enforcing constraints for "Dead" load cases while allowing custom configurations for others. If the non-structural mass flag is enabled, it configures specific gravity direction and value parameters within the underlying `LoadCaseModel`. Finally, it outputs the constructed load case object as a generic GH_Case data type for downstream use in the simulation workflow.

• LoadCaseConstructionStageComponent.cs

  This file defines a Grasshopper component named `LoadCaseConstructionStageComponent` that creates a specific type of load case for staged construction analysis within the FeMM framework. Its primary function is to assemble a `StageConstructionLoadCaseModel` by combining a user-defined name, a list of input construction stages, and optional initial conditions or save options. Key components include four input parameters: the load case name, a list of construction stages, an integer-based enum for save options, and an optional initial load case reference. The core logic resides in the `SolveInstance` method, which validates inputs, initializes the model with the specified properties, and maps the input stage data into the final object. Finally, it outputs the constructed `GH_Case` object for use in subsequent simulation steps.

• LoadCaseConstructionStageOperationComponent.cs

  This file defines a Grasshopper component (`LoadCaseConstructionStageOperationComponent`) that configures specific structural analysis operations for construction stages. It serves as a data definition tool, allowing users to specify how loads and structural properties change over time through various operation codes like adding/removing structures or modifying section properties. The key components include seven input parameters (operation code, object type, name, age, type, name reference, and scale factor) that validate against each other to ensure logical consistency. Upon validation, the component aggregates these inputs into a strongly typed `OperationModel` object. Finally, it outputs this structured model item, which can be consumed by other components in the FeMM simulation pipeline to define temporal structural behavior.

• LoadCaseConstructionStagePhaseComponent.cs

  This file defines a Grasshopper component named `LoadCaseConstructionStagePhaseComponent` that creates a construction stage phase definition for structural analysis. It functions by aggregating a list of construction operations, a duration in days, and output saving preferences to construct a specific `ConstructionStage` object. The key components include four input parameters (Operations, Duration, SaveOutput, Output Name) and one output parameter that delivers the finalized Construction Stage Phase data type. The core logic resides in the `SolveInstance` method, which maps these inputs into a `StageConstructionLoadCaseModel.ConstructionStage` instance before wrapping it in a Grasshopper-compatible generic type. This component is part of the FeMM plugin’s definitions category, facilitating staged construction simulations within Rhino/Grasshopper workflows.

• LoadCaseResponseSpectrumComponent.cs

  This file defines a Grasshopper component named `LoadCaseResponseSpectrumComponent` that creates a Response Spectrum Load Case definition for structural analysis. It aggregates various input parameters, including modal combination methods (CQC, SRSS), GMC factors, eccentricity ratios, and damping constants, to configure the load case properties. The component processes these inputs by validating them against specific model types and combining them into a `LoadCaseResponseSpectrumModel` instance. Its primary function is to output a structured `GH_Case` object representing the defined response spectrum load case for use in downstream simulation workflows.

• LoadCaseResponseSpectrumLoadComponent.cs

  This file defines a Grasshopper component (`LoadCaseResponseSpectrumLoadComponent`) for the FeMM structural analysis framework, specifically designed to create response spectrum load cases. It accepts inputs such as load direction (e.g., U1, R2), a response spectrum function definition, a scale factor, an optional coordinate system, and a rotation angle to fully configure seismic or dynamic load parameters. The component processes these inputs to instantiate a `LoadCaseResponseSpectrumLoadModel` object, handling validation to ensure a valid response spectrum function is provided. If successful, it wraps this model in a `GH_Case` object and outputs it; otherwise, it reports an error and returns an empty case. Key components include input parameter registration for directional and geometric data, instance solving logic that maps Grasshopper data types to internal models, and integration with the FeMM common models for structural definitions.

• LoadCombinationComponent.cs

  This file defines a Grasshopper component named `LoadCombinationComponent` that aggregates individual load cases into a unified load combination for structural analysis. It accepts inputs for the combination name, a list of load case objects, their corresponding numerical coefficients, and a type selector (e.g., Linear Add, Envelope, SRSS). The core logic iterates through the provided load cases and coefficients to populate a `LoadCaseCombinationModel`, handling missing coefficients by defaulting them to zero. Finally, it assigns the selected combination type to the model and outputs the resulting `GH_Combination` object. This tool is essential for defining how various structural loads interact according specific engineering standards within the FeMM framework.

• PlateModifiersNameComponent.cs

  This file defines a Grasshopper component named `PlateModifiersNameComponent` that creates named plate modifiers for structural analysis software like SAP or ETABS. It accepts an identifier string and optional numerical multipliers for various plate forces, moments, shear, mass, and weight. The key components include input registration for these twelve parameters, all of which are optional with default values set to 1.0. The core logic resides in the `SolveInstance` method, which aggregates these inputs into a `PlateModifierNamedModel` object. Finally, it outputs this model wrapped in a `GH_FunctionDefinition` for use in downstream simulation workflows.

• StagedConstructionCombinationsComponent.cs

  This file defines a Grasshopper component for Rhino that creates specific "Staged Construction Combinations" within the FeMM structural analysis framework. It functions by taking a staged construction model, a name, and parallel lists of load and freedom case combinations as inputs. The component validates these inputs to ensure data integrity, specifically checking that combination lists are non-empty and match in length. It then constructs a `StagedConstructionCombinationModel` object, filtering the input lists to include only valid load or freedom case models. Finally, it outputs the newly created model as a single result for use in subsequent simulation steps.

• StagedConstructionComponent.cs

  This file defines a Grasshopper component named `StagedConstructionComponent` within the FeMM framework, designed to configure specific stages for finite element analysis. It functions by accepting inputs such as stage names, beam groups, and various boolean flags controlling morphing, node fixing, and rotation resets. The core logic aggregates these parameters into a `StagedModel` object, which encapsulates the configuration details for the simulation stage. Additionally, it interacts with load combination data by updating internal load case lists from connected components. Finally, the component outputs the constructed `StagedModel` wrapped in a generic definition type for downstream use.

• StoryBaseElevationComponent.cs

  This file defines a Grasshopper component named `StoryBaseElevationComponent` within the FeMM framework, designed to set the base elevation for structural stories intended for use in ETABS. It accepts a single numeric input representing the height and outputs a generic `GH_FunctionDefinition` containing a `StoryBaseElevationModel`. The core logic resides in the `SolveInstance` method, which retrieves the input value, instantiates the model with that elevation, and passes it downstream as structured data. Key components include standard Grasshopper interface methods like `RegisterInputParams`, `RegisterOutputParams`, and specific metadata properties such as the unique `ComponentGuid` and exposure level. Essentially, it acts as a simple data wrapper to define a fundamental structural parameter for further analysis workflows.

• StoryComponent.cs

  This file defines `StoryComponent`, a Grasshopper plugin component used to define structural stories for use in ETABS analysis. It accepts four inputs: the story's name, height, an optional master story flag, and an optional splice height. The core logic resides in the `SolveInstance` method, which aggregates these inputs into a `StoryModel` object. This model is then wrapped in a `GH_FunctionDefinition` and passed as the single output parameter. The component is categorized under "Definitions" and has tertiary exposure, indicating it is a supporting tool rather than a primary workflow element.