Sections

Files

• BeamProperty2RevitGeometricComponent.cs

  This file defines a Grasshopper component named `BeamProperty2RevitGeometricComponent` that acts as an interface between the FeMM structural analysis environment and Revit. It takes a single input of a `BeamPropertyModel` object and extracts its geometric and material metadata to populate a standardized naming convention table. The component outputs various textual identifiers, such as section names and material families, alongside numerous numerical parameters defining beam dimensions like height, width, flange thickness, and web properties. Key components include the `SolveInstance` method which processes the input data via `NamingConventionHelper`, and specific output ports for both general attributes and detailed cross-sectional geometry. Essentially, it translates internal beam property data into a structured format suitable for generating corresponding Revit family types.

• BeamSectionAngleComponent.cs

  This file defines `BeamSectionAngleComponent`, a Grasshopper plugin component for creating structural angle sections within the FeMM framework. It accepts geometric inputs like width, height, thicknesses, and fillet radius to configure an angle section model. The component also supports optional parameters for mirroring the section (creating double angles) and defining a gap between them. Upon execution, it populates a `SectionModel` with these values and calculates the resulting cross-section properties. Finally, it outputs the generated beam section as a generic Grasshopper data type for further structural analysis or modeling.

• BeamSectionBrepComponent.cs

  This file defines a Grasshopper component named `BeamSectionBrepComponent` that processes 3D brep inputs to create structural beam sections. It validates that all input brep faces are planar and coplanar, then extracts their boundary loops as 2D polylines. The component transforms these geometry points into a local 2D coordinate system to handle potential holes in the cross-section. Using the Maffeis library, it constructs 2D shapes from the outer boundary and any internal hole boundaries. Finally, it wraps this geometric data into a `SectionModel` and outputs a custom `GH_BeamSection` object for further finite element analysis or modeling tasks.

• BeamSectionCComponent.cs

  This file defines `BeamSectionCComponent`, a Grasshopper plugin component for creating C-channel beam cross-sections within the FeMM framework. It accepts geometric inputs such as width, height, flange and web thicknesses, along optional mirroring settings to create double sections. The core logic resides in the `SolveInstance` method, which constructs a `SectionModel` object and triggers its internal calculation methods. Finally, it outputs the resulting section data as a `GH_BeamSection` type for downstream use.

• BeamSectionGenericComponent.cs

  This file defines a Grasshopper component named `BeamSectionGenericComponent` within the FeMM framework, designed to create generic beam cross-sections. It functions by accepting twelve specific geometric and mechanical input parameters, such as area, second moments of inertia, torsion constants, and shear properties. The core logic resides in the `SolveInstance` method, which retrieves these values, validates their presence, and maps them into a `SectionModel` object. This model is then encapsulated into a `GH_BeamSection` data type for downstream use in finite element analysis workflows. Key components include the input registration for all section properties and the output generation of the finalized section object.

• BeamSectionHollowCircleComponent.cs

  This file defines a Grasshopper component named `BeamSectionHollowCircleComponent` within the FeMM framework, designed to create hollow circular beam sections. It accepts two numeric inputs—Diameter and Thickness—to define the geometric properties of the section. The core logic resides in the `SolveInstance` method, which instantiates a `SectionModel`, sets its type to HollowCircle, and triggers automatic calculation of sectional properties. The component outputs a generic `GH_BeamSection` object containing these calculated results for use in downstream simulations or analyses. Key components include input parameter registration for dimensions, the instantiation of the underlying structural model, and adherence to Grasshopper’s standard component lifecycle methods like icon and GUID definition.

• BeamSectionHollowRectComponent.cs

  This file defines a Grasshopper component named `BeamSectionHollowRectComponent` within the FeMM framework, designed to create hollow rectangular beam cross-sections. It accepts five numerical inputs: height, base width, horizontal thickness, vertical thickness, and an optional fillet radius. The core logic resides in the `SolveInstance` method, where it instantiates a `SectionModel` with these parameters and triggers its calculation engine. Finally, the component wraps the resulting model into a custom `GH_BeamSection` data type and outputs it for downstream use in structural analysis workflows.

• BeamSectionIComponent.cs

  This file defines a Grasshopper component named `BeamSectionIComponent` that creates an I-beam structural section model. It accepts seven geometric inputs, including flange widths, heights, thicknesses, and fillet radius, to define the beam's cross-section geometry. The core logic instantiates a `SectionModel` with these parameters, sets its type to "I", and triggers internal calculations via `CalculateSection()`. The processed data is then wrapped in a custom `GH_BeamSection` object and output for use in downstream simulations or visualizations. Key components include input parameter registration, instance solving logic, and integration with the FeMM framework’s common models.

• BeamSectionSolidCircleComponent.cs

  This file defines a Grasshopper component named `BeamSectionSolidCircleComponent` within the FeMM framework, designed to model solid circular beam cross-sections. It accepts a single input parameter, the diameter "D", and processes this value to generate a corresponding section object. The core logic resides in the `SolveInstance` method, which creates a `SectionModel` with the specified type and dimensions, then calls `CalculateSection()` to compute relevant geometric properties. Finally, it wraps the result in a `GH_BeamSection` data type and outputs it for use in downstream analysis or modeling tasks.

• BeamSectionSolidRectComponent.cs

  This file defines a Grasshopper component named `BeamSectionSolidRectComponent` that creates a solid rectangular beam cross-section. It takes two numeric inputs, Height (D) and Base (B), to define the geometric dimensions of the section. The core logic resides in the `SolveInstance` method, which constructs a `SectionModel` object with these parameters and triggers its calculation method. The component then wraps this model into a `GH_BeamSection` data type for output. Key components include input/output parameter registration methods and the specific GUID ensuring unique identification within the Grasshopper environment. This facilitates parametric structural analysis workflows by standardizing how rectangular sections are defined and passed through the simulation pipeline.

• BeamSectionTComponent.cs

  This file defines `BeamSectionTComponent`, a custom Grasshopper component for Rhino that creates T-shaped structural beam sections. It serves as a user interface node within the FeMM plugin, allowing users to input geometric parameters such as flange width, thickness, total height, web thickness, and fillet radius. The core logic resides in the `SolveInstance` method, which retrieves these five numeric inputs and instantiates a `SectionModel` object configured with the T-section type. This model automatically calculates section properties before wrapping the result in a `GH_BeamSection` data type for output. Key components include the parameter registration methods for defining inputs/outputs, the calculation engine via `SectionModel.CalculateSection()`, and unique identifiers like the ComponentGuid for Grasshopper integration.

• CableSectionComponent.cs

  This file defines a Grasshopper component named `CableSectionComponent` that generates a solid circular beam section model for finite element analysis. It accepts four numerical inputs: diameter, equivalent area, equivalent density, and equivalent modulus. The core logic constructs a `SectionModel` object with these properties, specifically configuring it to use equivalent values rather than calculating them from geometry alone. After populating the model, it calls `CalculateSection()` to finalize the physical properties. Finally, the component wraps this data into a `GH_BeamSection` output and exposes it via the standard Grasshopper interface.

• CustomSectionConfigComponent.cs

  This file defines a Grasshopper component (`CustomSectionConfigComponent`) that configures how custom structural sections are interpreted for analysis. It serves as a configuration hub, accepting integer inputs to specify geometric approximations (e.g., "Generic," "Geometry," or specific rectangular/RHS models) for various steel and concrete section types like I-beams, T-sections, and built-up shapes. Key components include input parameters for distinct section categories (Steel/Concrete), a custom attribute class for visual labeling, and logic to aggregate these settings into a single output configuration object. The component essentially translates user-selected interpretation methods into a structured data format for downstream processing.

• Nomenclature2BeamPropertyComponent.cs

  This file contains a commented-out Grasshopper component class named `Nomenclature2BeamPropertyComponent`, which was designed to translate Maffeis naming conventions into beam property data. It functions as a data lookup tool, accepting a specific section name string and retrieving the corresponding structural properties from a defined database. The key components include input/output parameter registration methods that define the text-based input and generic output, along with a `SolveInstance` method that executes the logic using `NamingConventionHelper`. The code also features standard Grasshopper metadata such as icon handling, exposure level, and a unique GUID for component identification. Since the entire class is wrapped in comments, this appears to be legacy or disabled code within the FeMM Grasshopper plugin ecosystem.

• Nomenclature2RevitGeometricComponent.cs

  This file defines a Grasshopper component named `Nomenclature2RevitGeometricComponent` that translates Maffeis steel section names into detailed geometric properties. It accepts a single text input representing a section name and queries a database to retrieve corresponding profile data. The component outputs numerous parameters, including material families, Revit/Tekla family names, and specific dimensional attributes like height, width, flange thickness, and web dimensions. Its primary function is to bridge nomenclature with physical geometry for BIM workflows, ensuring accurate data transfer between design and fabrication tools.

• NomenclaturePropertiesComponent.cs

  This file defines a Grasshopper component named `NomenclaturePropertiesComponent` that extracts specific property values from structural section profiles. It accepts either a direct section object or its Maffeis nomenclature name as input, alongside the target property name to query. The core logic uses reflection to iterate through all properties of the resolved profile object, matching the requested name against available attributes. If a match is found, it outputs the specific value; otherwise, it returns null. Additionally, it generates a comprehensive list of all available properties and their current values for the given profile. This tool facilitates dynamic data inspection and property extraction within parametric design workflows involving FeMM sections.

• SectionGeometricComponent.cs

  This file defines a Grasshopper component named `SectionGeometricComponent` that extracts geometric properties from structural section data. It accepts a single input of type `GH_BeamSection` and outputs various textual identifiers (like name and type) alongside numerous numeric parameters representing specific cross-sectional dimensions. The core logic in the `SolveInstance` method maps internal `SectionModel` types—such as I-beams, T-sections, angles, and hollow profiles—to standardized output variables prefixed with "ME_". This allows users to access detailed geometric attributes for finite element modeling or analysis within the Rhino/Grasshopper environment. Key components include input/output registration methods, a conditional switch-case structure for different section shapes, and integration with the FeMM framework's data models.

• SectionGeometricPropertyComponent.cs

  This file defines a Grasshopper component named `SectionGeometricPropertyComponent` within the FeMM plugin, designed to extract and output geometric properties of structural beam sections. It accepts a single input parameter containing a `GH_BeamSection` object and computes various cross-sectional characteristics such as area, centroid coordinates, moments of inertia, section moduli, radii of gyration, and torsional constants. The component processes these values by accessing the underlying `SectionModel` data, though the implementation contains redundant conditional logic that appears to handle both generic and composite section types identically. Key components include the registration of one input and thirteen output parameters, along with the core computation logic in the `SolveInstance` method. Ultimately, it serves as a data extraction tool for structural analysis workflows, converting complex section objects into discrete numerical outputs for further use in simulations or design checks.