Attributes

Files

• BeamInsertionPointComponent.cs

  This file defines a Grasshopper component named `BeamInsertionPointComponent` within the FeMM framework, designed to modify beam attributes for structural analysis software like SAP2000. It allows users to specify an insertion point location (e.g., centroid or corners), define joint offsets for both ends of the beam, and configure transformation settings such as stiffness adjustment and section mirroring. The key components include input parameters for the base beam geometry, cardinal point selection, offset lists, coordinate system specification, and boolean flags for physical transformations. Upon execution, it validates that offset lists contain exactly three items before creating a new `GH_Beam` instance with the updated `InsertionPointModel` attribute attached. Finally, it outputs the modified beam object, enabling seamless integration into larger finite element modeling workflows.

• BeamModifiersComponent.cs

  This file defines a Grasshopper component named `BeamModifiersNameComponent` that applies specific structural property modifiers to beam elements for SAP/ETABS analysis. It accepts a primary beam input and optional numeric inputs for modifying area, shear areas, torsional constant, moments of inertia, mass, and weight. The core logic resides in the `SolveInstance` method, which retrieves these values and constructs a `BeamModifiersModel` object. This model is then added as an attribute to the input beam’s data structure before being passed to the output. Key components include the input/output parameter registration and the instantiation of the underlying `FeMM` domain models. Essentially, it serves as a bridge between the visual programming environment and the finite element modeling backend.

• BeamOutputStationsComponent.cs

  `BeamOutputStationsComponent.cs` is a Grasshopper plugin component designed to modify structural beam elements by defining specific output station attributes. It accepts a primary beam input, an integer for the minimum number of stations, and two optional boolean flags controlling station placement at intersections and point loads. The core logic constructs a `BeamOutputStationsModel` with these parameters and attaches it as an attribute to a copy of the input beam. This modified beam is then passed through as the sole output, enabling downstream analysis or design processes to respect these localized mesh constraints.

• BeamReleasesComponent.cs

  This file defines a Grasshopper component (`BeamReleasesComponent`) for the FeMM structural analysis plugin, designed to assign end releases to beam elements. It accepts a primary beam input along with optional numerical parameters defining axial, shear, and torsional/moment releases at both nodes. The component interprets these inputs to determine whether each degree of freedom is fixed, released, or partially restrained based on specific value conventions. Key components include the `SolveInstance` method that processes these inputs into a `BeamReleasesAttributeModel` and attaches it to the beam object. Finally, it outputs the modified beam with the newly applied release attributes, enabling precise control over boundary conditions in finite element models.

• BeamStringGroupComponent.cs

  This file defines `BeamStringGroupComponent`, a Grasshopper plugin component designed to attach string group attributes to structural beams within the FeMM (Finite Element Method for Mechanical) framework. It accepts a list of input beams and a single integer ID, then applies a specific string group attribute identified by that ID to each beam in the collection. The core logic resides in the `SolveInstance` method, which iterates through the input beams, creates new `GH_Beam` instances, and adds the configured `BeamStringGroupAttributeModel` to their attributes. Finally, it outputs the modified beams as a list for downstream processing. Key components include input/output parameter registration methods and the data processing loop that modifies the beam objects.

• BeamSupportComponent.cs

  This file defines a Grasshopper component named `BeamSupportComponent` within the FeMM framework, designed to assign structural support attributes to beam elements. It serves as a specialized tool for Finite Element Method (FEM) modeling by allowing users to define spring supports with varying types, such as simple springs or link properties. The component accepts multiple inputs including beam geometry, stiffness values, orientation angles, and coordinate systems to configure how the beam interacts with its supports. Key components include input parameter registration for flexible configuration, validation logic that dynamically checks required fields based on selected spring types, and data extraction methods to process these parameters. Ultimately, it outputs the modified beam object with the applied support attributes attached.

• BeamTaperComponent.cs

  `BeamTaperComponent.cs` is a Grasshopper plugin component designed to apply linear taper attributes to structural beam elements within the FeMM framework. It accepts a source `GH_Beam` and four numerical multipliers defining cross-section dimension changes at both the start and end points, along with alignment codes for X and Y axes. The core logic validates that the input beam is not mirrored, then instantiates a `BeamTaperAttributeModel` with the provided parameters. This attribute is added to a copy of the original beam, which is subsequently output as a modified `GH_Beam`. Key components include the input/output parameter registration methods and the `SolveInstance` method that orchestrates the data retrieval and model creation.

• ElementCoordinateSystemComponent.cs

  This file defines a Grasshopper component named `ElementCoordinateSystemComponent` that assigns a specific coordinate system to structural finite elements. It takes two inputs—a generic element and a coordinate system model—and outputs the modified element with the new orientation applied. The core logic in `SolveInstance` handles type-specific assignments for beams, plates, and nodes by creating copies of these objects and updating their `CoordinateSystem` property. If an unsupported element type is provided, it throws a runtime error to ensure data integrity. This component is part of the FeMM (Finite Element Method Modeling) toolkit, facilitating precise local axis definition for simulation setups.

• ElementIdComponent.cs

  `ElementIdComponent.cs` is a Grasshopper plugin component designed to assign custom user-defined IDs to finite element model entities such as beams, plates, and nodes. It accepts two inputs: the target geometric element and a string identifier, then validates that the ID is not empty and that the element does not already possess an assigned ID. Upon successful validation, it creates a new `ElementIdAttributeModel` and attaches it to the input element’s attributes collection before outputting the modified element. The component supports three specific data types (`GH_Beam`, `GH_Plate`, `GH_Node`) and rejects any other types with an error message. Key components include input/output parameter registration, type-specific handling logic in `SolveInstance`, and helper methods for checking existing attributes.

• FixedAxialForceComponent.cs

  This file defines `FixedAxialForceComponent`, a Grasshopper plugin component designed to apply a fixed axial force constraint to structural beams within the FeMM framework. It accepts four inputs: a target beam, a load case, the specific force value, and a solver weight for non-linear analysis iterations. The core logic resides in the `SolveInstance` method, which validates that the weight is positive before creating a new beam model. This new model attaches a `FixedAxialForceModel` instance representing the specified load condition. Finally, it outputs the modified beam object for further use in the simulation pipeline.

• FixedCompensationComponent.cs

  This file defines `FixedCompensationComponent`, a Grasshopper plugin component designed to modify beam geometry based on a target compensation percentage. It accepts a beam, a load case, and a compensation value to calculate a new beam length, effectively reducing or adjusting the beam's dimensions for non-linear analysis. The key components include input parameters for the beam, load case, compensation percentage, and solver weight, alongside an output providing the modified beam model. Internally, it computes the new length using the formula `original_length * (1 - value/100)` and attaches a `FixedLengthModel` to the beam’s loads. This facilitates parametric structural adjustments within a Finite Element Method Modeling (FeMM) workflow.

• FixedLengthComponent.cs

  This file defines the `FixedLengthComponent`, a Grasshopper plugin component designed to assign a fixed length attribute to structural beams. It accepts four inputs: a beam object, a load case, a target length value, and an optional solver weight. The core logic resides in the `SolveInstance` method, which validates that the weight is positive before creating a new `BeamModel`. This model is then augmented with a `FixedLengthModel` instance containing the specified constraints. Finally, the modified beam is output as the result for downstream processing within the Grasshopper definition.

• ForceDensityCableComponent.cs

  This file defines a Grasshopper component named `ForceDensityCableComponent` within the FeMM framework, designed to apply force density attributes to structural beams. It functions by accepting specific inputs—a beam geometry, a load case, a chord length, and an inverse ratio—to calculate fixed curvature cable properties. The core logic resides in the `SolveInstance` method, which creates a new beam instance and attaches a `ForceDensityModel` with curvature settings based on the provided parameters. Key components include input registration for geometric and physical data, output generation of the modified beam, and metadata definitions such as unique GUIDs and exposure levels. This tool essentially automates the assignment of specific force density analysis criteria to structural elements within a parametric design environment.

• ForceDensityComponent.cs

  `ForceDensityComponent.cs` is a Grasshopper plugin component designed to apply force density loads to structural beams within the FeMM framework. It accepts inputs for a beam, load case, value, and configuration options like projection type and solver weight, while allowing users to select between Force Density, Cable, or Membrane types. The core logic removes existing force density loads from the beam and replaces them with a new `ForceDensityModel` instance based on the provided parameters. Finally, it outputs the modified beam object, enabling seamless integration into non-linear structural analysis workflows.

• ForceDensityMembraneComponent.cs

  This file defines a Grasshopper plugin component named `ForceDensityMembraneComponent` within the FeMM (Finite Element Modeling for Membranes) framework. It functions as an attribute modifier that applies a specific force density load to structural beams for membrane analysis using a fixed curvature method. The key components include four input parameters: a target beam, a load case, a numerical value, and a type selection (Warp or Weft), which are processed in the `SolveInstance` method. Upon execution, it creates a modified beam object with the new `ForceDensityModel` attached and outputs the updated geometry. This allows users to integrate complex membrane loading conditions directly into their parametric structural workflows.

• GetElementIdComponent.cs

  This file defines a Grasshopper component named `GetElementIdComponent` within the FeMM framework, designed to extract identification data from structural elements like nodes, beams, plates, or links. It accepts a single generic element input and outputs two values: a user-assigned text ID and an internal numeric identifier used during model preprocessing. The core logic resides in the `SolveInstance` method, which uses pattern matching to identify the specific element type and retrieves corresponding attributes. If multiple IDs are found or no valid ID exists, it triggers runtime warnings or errors to ensure data integrity. Key components include input/output parameter registration, type-specific attribute extraction, and error handling for unsupported inputs or invalid ID formats.

• KeepPositionComponent.cs

  This file defines `KeepPositionComponent`, a Grasshopper plugin component designed for form-finding analysis within the FeMM framework. Its primary function is to lock specific nodes in place by attaching a weight attribute that restricts their movement during simulation. The component accepts two key inputs: a generic `Node` parameter and a `Weight` vector, which defaults to (1, 1, 1) to enforce full positional constraint across all axes. It validates that weight components are non-negative before creating a new node instance with the attached `NodeWeightAttributeModel`. Finally, it outputs this modified node, effectively preserving its original position while allowing other parts of the mesh to deform.

• LoadPatchTypeComponent.cs

  This file defines `LoadPatchTypeComponent`, a Grasshopper plugin component for the FeMM (Finite Element Method for Mechanics) framework that assigns load patch types to structural plates. It accepts inputs including a plate geometry, a load type enum, optional edge indices, and corresponding weights to configure how loads are distributed. The component performs extensive validation to ensure compatibility between the selected load type (e.g., Auto1-3, AngleSplit, Manual) and the input parameters, such as checking edge counts and element types. Upon successful validation, it creates a `LoadPatchTypeAttributeModel` and attaches it to a new copy of the input plate object. Additionally, the component dynamically updates its visual icon based on the selected load type to provide immediate user feedback. Finally, it exposes the modified plate as an output for downstream processing in the Grasshopper definition.

• LoadTransferComponent.cs

  This file defines a Grasshopper component named `LoadTransferComponent` within the FeMM framework, designed to manage load transfer attributes for structural analysis. It functions by accepting a beam object and a boolean flag as inputs, determining whether that specific frame should receive loads transferred from area objects. The core logic resides in the `SolveInstance` method, where it creates a new `LoadTransferModel` based on the input parameters and attaches this attribute data to the beam’s properties. Key components include input registration for the beam and transfer status, output handling for the modified beam, and integration with custom FeMM data types like `GH_Beam`. The component is categorized under FEMM attributes and exposes itself as a secondary exposure level in the Grasshopper interface.

• NodeConstraintComponent.cs

  `NodeConstraintComponent.cs` is a Grasshopper plugin component designed to apply specific structural constraints, such as diaphragm or body constraints, to finite element nodes. It functions by accepting two inputs: a target `GH_Node` and a `GH_FunctionDefinition` representing the constraint type. The core logic resides in the `SolveInstance` method, which validates the inputs and checks if the constraint model matches expected types like `NodeDiaphragmConstraintModel` or `NodeBodyConstraintModel`. Upon successful validation, it attaches the selected constraint to the node’s internal collection and outputs the modified node object. This tool streamlines the workflow for defining boundary conditions or special node behaviors within the FeMM (Finite Element Method Modeler) framework.

• NodeRestraintsComponent.cs

  This file defines a Grasshopper component named `NodeRestraintsComponent` used within the FeMM (Finite Element Method Modeler) plugin for structural analysis. Its primary function is to apply boundary conditions by attaching translation and rotation restraints to specific nodes in a finite element model. Key components include input parameters for the target node, boolean lists for translational and rotational constraints, optional freedom cases, and a coordinate system definition. The logic processes these inputs to populate a `NodeRestraintAttributeModel`, handling data validation and error checking before outputting the modified node with the applied attributes.

• NodeStiffnessComponent.cs

  This file defines `NodeStiffnessComponent`, a Grasshopper component within the FeMM (Finite Element Method for Masses) framework used to assign stiffness properties to structural nodes. It accepts inputs for translational and rotational stiffness vectors, optional freedom cases, and a coordinate system, allowing users to define how a node resists movement in specific directions. The core logic in `SolveInstance` validates these inputs, constructs a `NodeStiffnessAttributeModel` with the specified stiffness values, and attaches this attribute to the input node object. If no stiffness values are provided, it triggers a warning to ensure proper configuration before proceeding. Finally, it outputs the modified node containing the new stiffness attributes for use in subsequent simulation or analysis steps. Key components include input parameter registration for geometry and data types, validation logic to prevent empty solutions, and integration with the underlying FEM attribute models.

• PlateSupportComponent.cs

  This file defines a Grasshopper component named `PlateSupportComponent` that extends the `GH_Component` base class to facilitate Finite Element Method (FEM) modeling workflows. Its primary function is to apply specific support constraints, such as stiffness and directional freedom, to a given plate geometry within the simulation environment. Key components include input parameters for defining the target plate, support stiffness values, boolean flags for compression-only behavior, and optional freedom case configurations. The core logic resides in the `SolveInstance` method, which validates inputs, constructs a `PlateSupportAttributeModel`, and attaches these attributes to a new instance of the plate. Finally, the component outputs the modified plate with the applied support definitions, allowing for seamless integration into larger parametric structural analysis scripts.

• PlateTypeComponent.cs

  `PlateTypeComponent.cs` is a Grasshopper plugin component designed to define and modify plate specifications for ETABS structural analysis. It functions by accepting an existing `PlatePropertyModel`, a plate type integer, a specific slab subtype, and a boolean flag for one-way load distribution. The core logic resides in the `SolveInstance` method, which maps these inputs to enum values and creates a new, modified `PlatePropertyModel` instance. Key components include three input parameters (Plate Property, Type, Slab Type) and one output parameter that returns the updated plate object. This allows users to programmatically assign specific physical attributes to plate elements within a parametric design workflow.

• SuperElementComponent.cs

  This file defines a Grasshopper component named `SuperElementComponent` within the FeMM framework, designed to assign "Super-Element" attributes to structural model elements. It accepts two inputs: a geometric element (either a beam or plate) and a text string defining the super-element's name. The core logic resides in the `SolveInstance` method, which creates a `SuperElementAttributeModel` and attaches it to a copy of the input element based on its type. If the input is neither a beam nor a plate, the component throws a runtime error indicating an unsupported type. Finally, it outputs the modified element with the newly added attribute for downstream use in the simulation workflow.