MeCheck2

Files

• BeamPropertyCompositeComponent.cs

  This file defines a Grasshopper component named `BeamPropertyCompositeComponent` used within the FeMM structural analysis framework to model composite steel-concrete beams. It aggregates inputs for concrete slab geometry, steel section profiles, respective material properties, and reinforcement details to calculate mechanical properties. The core logic homogenizes these materials using specific coefficients ($n_0$ for short-term and $n_\infty$ for long-term loads) to account for creep effects. Key components include input parameters for geometry and materials, optional toggles for including concrete or rebars in calculations, and output parameters providing distinct beam property models for immediate and infinite time phases. Ultimately, it generates standardized `GH_FunctionDefinition` objects that can be consumed by downstream analysis tools like MeCheck2.

• BeamSectionConcreteSlabComponent.cs

  This file defines a Grasshopper component named `BeamSectionConcreteSlabComponent` within the FeMM framework, specifically categorized under structural checks. It serves to model a concrete slab cross-section by accepting geometric and reinforcement inputs such as height, width, rebar areas, and concrete covers for both top and bottom layers. The component processes these six numeric parameters to instantiate a `SectionConcreteSlabModel` object, which encapsulates the defined section properties. Finally, it outputs this newly created model object as a generic data type for use in subsequent analysis or visualization steps within the Grasshopper definition.

• BeamSectionHPropertyComponent.cs

  This file defines a Grasshopper component named `BeamSectionHPropertyComponent` that extracts geometric properties from H-beam (I-section) structural models. It accepts various input types, including beam properties or sections, and validates that the input represents an I-section type before proceeding. The core logic invokes the `CalculateSection()` method to compute critical parameters such as area, centroid coordinates, moments of inertia, torsional constant, and specific dimensional attributes like flange widths and web thickness. These calculated values are then exposed as individual output parameters for downstream use in structural analysis workflows. The component ensures data integrity by throwing runtime errors if the input is invalid or not an I-section.

• BuildMeCheckModel.cs

  `BuildMeCheckModel.cs` is a Grasshopper component that consolidates multiple Finite Element Method (FEM) models into a single unified model while managing distinct construction phases. It accepts inputs for various FEM models and specific load combinations, assigning them to steel-only, infinite time, or instant time categories based on user selection. The component dynamically updates UI elements like value lists to reflect available super-elements and load cases extracted from the input data. Its primary function is to merge these disparate models into one cohesive structure for subsequent analysis checks. Key components include input parameter registration for models and load cases, dynamic GUI updates via `ComponentsHelper`, and logic for parsing and categorizing load cases by type and timing.

• CompositeBeamComponent.cs

  This file defines a Grasshopper component named `CompositeBeamComponent` that assigns composite cross-section properties to structural beams within the FeMM framework. It accepts an input beam, distinct section definitions for its start and end nodes, and optional group assignments as parameters. The core logic in `SolveInstance` creates a new `CompositeBeamModel` by inheriting geometric, attribute, load, and result data from the original beam while applying the specified mixed-section properties. Finally, it outputs the modified beam object wrapped in a custom Grasshopper data type (`GH_CompositeBeam`) for downstream use.

• CompositeBeamForceResultComponent.cs

  This file defines a Grasshopper component named `CompositeBeamForceResultComponent` that processes structural analysis results for composite beam sections. Its primary function is to extract specific internal force data from a `ResultBeamForces` input object and expose it as individual output parameters. The component accepts a generic force result as input and outputs the section name, ID, and key mechanical values including axial force (N), shear forces (V1, V2), torsion (T), and bending moments (M1, M2). A key operational detail is its automatic unit conversion during processing, dividing force values by 1000 to convert from Newtons to kilonewtons, and moment values by 1,000,000 to convert from Nmm to kNm. It belongs to the "Check2" subcategory within the FeMM framework and utilizes a unique GUID for identification in the Grasshopper environment.

• CompositeBeamLinearTensionAnalysisComponent.cs

  This file defines an obsolete Grasshopper component (`CompositeBeamLinearTensionAnalysisComponent_OBSOLETE`) for performing linear tension analysis on composite steel-concrete beams. It calculates stress and buckling results by processing input beam definitions, material properties, and load cases across different time phases (instantaneous vs. infinite). The key components include logic to handle homogenization coefficients for concrete creep effects and boolean flags to account for local instability in flanges and webs. It utilizes the `Maffeis.Checkers` library to solve reinforced concrete sections according Eurocode standards (EN1992/EN1993). Finally, it outputs detailed stress analysis results for three specific scenarios: only steel, infinite time, and total section behavior.

• CompositeBeamSelfTensionComponent.cs

  This file defines a Grasshopper component named `CompositeBeamSelfTensionComponent` that performs linear tension analysis on composite concrete sections. It accepts three inputs: a composite beam property object, a homogenization coefficient, and an applied strain value to simulate self-tension effects. The core logic calculates a homogenized factor based on material properties and uses the MC2010 section checker with EC2/EC3 standards to evaluate the section's stress state. Key components include the `SectionCheckerModelCode2010` for mechanical calculations and specific standard implementations like `StandardEN1992p11`. Finally, it outputs a structured result containing the self-tension analysis data for further use in the visual programming environment.

• CompositeBeamSlabStrainComponent.cs

  This file defines a Grasshopper component named `CompositeBeamSlabStrainComponent` that assigns a specific strain load to a composite beam. It functions as a data processing tool within the FeMM framework, taking an existing beam, a load case, and a numerical strain value as inputs. The core logic resides in the `SolveInstance` method, which creates a new `CompositeBeamSlabStrainModel` using the provided parameters and attaches it to the beam's loads collection. Key components include three input parameters (Beam, LoadCase, Strain) and one output parameter (the modified Beam). The component is categorized under structural checks and exposes a secondary icon for visual identification in the Grasshopper canvas.

• CompositeBeamTensionResultComponent.cs

  This file defines a Grasshopper component named `CompositeBeamTensionResultComponent` that processes linear tension analysis results for composite sections. It serves as a data extraction tool, accepting a single input of type `StressAnalysisResultMeCheck` and unpacking specific mechanical properties into individual output parameters. The key components include the registration of one input parameter and fourteen distinct outputs, such concrete strain, rebar stress, and steel stress/tau values at various structural points. Internally, the `SolveInstance` method validates the input data and maps these internal variables to the respective Grasshopper data access slots. This allows users in Rhino/Grasshopper to easily visualize or further analyze detailed stress states from complex composite beam calculations.

• CompositeSectionComponent.cs

  This file defines `CompositeSectionComponent_OBSOLETE`, a Grasshopper component for defining composite beam properties by combining concrete and steel sections. It serves as a deprecated tool within the FeMM framework, likely superseded by newer implementations due to its "OBSOLETE" naming. The component accepts inputs for geometry (concrete slab and steel I-section), material definitions for both materials plus reinforcement, and vertical offset parameters. Its primary function is to aggregate these inputs into a `CompositeBeamPropertyModel` and output a unified `GH_CompositeBeamProperty` data type. Key components include input registration methods that define specific data types like `GH_BeamSection` and custom `GH_Material` wrappers, alongside the core `SolveInstance` logic that instantiates the model.

• CompositeSectionGeometricPropertyComponent.cs

  This file defines a Grasshopper component named `CompositeSectionGeometricPropertyComponent` within the FeMM framework, designed to calculate geometric properties for composite beams. It accepts inputs including a composite beam property object, a homogenization coefficient (`n`), and boolean flags to include concrete, rebars, or steel sections in the calculation. The core logic resides in the `SolveInstance` method, which retrieves mechanical properties from a model, applies homogenization based on user parameters, and computes derived values like area and moments of inertia. The component outputs twelve distinct geometric parameters, such as centroid coordinates (xg, yg), second moments of area (Jxx, Jyy, J₁₁, J₂₂), and torsional constants. Key components include input registration for material inclusion toggles and output registration for detailed section properties. Ultimately, it serves as a computational tool for civil engineers to analyze cross-sectional characteristics of composite structural elements.

• CompositeSectionStiffenersComponent.cs

  This file defines a Grasshopper component named `CompositeSectionStiffenersComponent` that calculates geometric properties for stiffeners on composite beam sections. It functions by accepting user inputs such as beam length, stiffener spacing, width, and thickness, along optional flags for symmetry and rigid behavior. The key components include input parameter registration for these variables, validation logic to ensure positive values for critical dimensions, and the instantiation of a `CompositeSectionStiffeners` model object. Finally, it wraps this model in a custom Grasshopper data type (`GH_CompositeSectionStiffeners`) and outputs it for downstream use in the visual scripting environment.

• CreepAndShrinkageConcreteComponent.cs

  This file defines a Grasshopper component (`CreepAndShrinkageConcreteComponent`) that calculates time-dependent concrete deformation properties according to the EN1992 standard. It accepts structural and environmental inputs, such as concrete strength ($F_{ck}$), steel modulus, cross-sectional area, relative humidity, and member geometry, to compute key engineering coefficients. The core logic utilizes a `ConcreteMaterialEN1992` helper object to derive the creep coefficient ($\psi$) and various shrinkage strains (autogenous, drying, and total). Additionally, it outputs homogenization coefficients for both instantaneous and infinite-time loading scenarios. This tool enables structural engineers within a parametric design environment to assess long-term concrete behavior efficiently.

• PrintCheckImageAddCurveComponent.cs

  This file defines a Grasshopper component named `PrintCheckImageAddCurveComponent` that generates a graphical curve object for use within the FeMM plugin’s MeCheck2 module. It accepts paired lists of X and Y coordinate values, along with styling parameters like title, color, and line thickness, to construct a `GraphicCreator.Curve`. The component validates input data integrity, ensuring arrays are non-empty, equal in length, and contain at least two points before proceeding. Upon successful validation, it packages these inputs into a structured curve object and outputs it as a generic parameter. This allows users to programmatically define visual curves for reporting or checking purposes within the broader analysis workflow.

• PrintCheckImageMeCheckForceComponentBase.cs

  This file defines an abstract base class `PrintCheckImageMeCheckForceComponentBase` for a Grasshopper component designed to visualize and export structural force diagrams for finite element models. It serves as a foundation for generating graphical representations of super-element beam forces, allowing users to plot specific force components like axial load or bending moments against defined combinations. Key components include input parameters for FEM models, beam geometry, force data trees, and visualization settings such as color schemes, titles, and output file paths. The class implements custom attribute handling with a "Run" button to trigger solution updates and manages unit conversion constants for force calculations. By inheriting from `GH_Component`, it integrates seamlessly into Rhino’s visual scripting environment while providing extensible methods for registering inputs and processing instance data.

• PrintCheckImageMeCheckForceComponentV1_OBSOLETE.cs

  This file defines an obsolete Grasshopper component named `PrintCheckImageMeCheckForceComponentV1_OBSOLETE` within the FeMM namespace. It inherits from a base class and is explicitly marked as hidden (`GH_Exposure.hidden`) to prevent user visibility in the interface. The component serves no functional purpose, as its critical methods for registering inputs and handling data are implemented as empty stubs. It appears to be a deprecated placeholder or remnant from a previous version of the plugin, indicated by its "OBSOLETE" suffix and null implementations.

• PrintCheckImageMeCheckForceComponentV2.cs

  This file defines a Grasshopper component named `PrintCheckImageMeCheckForceComponentV2`, which inherits from a base class to manage specific visualization settings. Its primary function is to control the display of vertical marks and x-axis ticks/labels on force diagrams or similar graphical outputs within a structural analysis context. The key components include input parameters for toggling mark visibility (`Show Marks`) and defining custom X-axis positions for these marks (`Mark Positions`). It also implements standard Grasshopper interface methods like `RegisterInputMarks` and `GetInputMarks` to handle data access and parameter registration. Additionally, it specifies a unique GUID and sets its exposure level to "tertiary" for organization in the component palette.

• PrintCheckImageMeCheckResultComponentBase.cs

  This file defines an abstract base class for a Grasshopper component that generates visual check images for structural analysis results from the MeCheck plugin. It serves as a foundation for plotting super-element beam stresses, strains, and other force components against reference values or additional curves. Key components include input parameters for FEM models, stress result trees, specific force indices, and output paths, alongside helper methods for managing unit conversions and color schemes. The class utilizes the `SolveInstance` method to process hierarchical data structures into organized dictionaries for rendering graphics. It also incorporates UI elements like a "Run" button and supports optional features such as showing minimum/maximum combinations and custom marks.

• PrintCheckImageMeCheckResultComponentV1_OBSOLETE.cs

  This file defines an obsolete Grasshopper component class, `PrintCheckImageMeCheckResultComponentV1_OBSOLETE`, which inherits from a base implementation for handling check result images. It is part of the `FeMM.Grasshopper.Components.MeCheck2` namespace and is explicitly marked as hidden in the user interface via its `GH_Exposure` property. The component implements specific abstract methods like `GetInputMarks` and `RegisterInputMarks`, though their current implementations are empty stubs. Its primary purpose appears to be legacy support or backward compatibility within a larger plugin ecosystem, likely related to structural or engineering analysis visualization.

• PrintCheckImageMeCheckResultComponentV2.cs

  This file defines a Grasshopper component named `PrintCheckImageMeCheckResultComponentV2` that inherits from a base class to handle specific input parameters. Its primary function is to register and manage inputs for controlling the visual display of check results, specifically toggling vertical marks and defining custom X-axis tick positions. The key components include overridden methods `GetInputMarks` and `RegisterInputMarks`, which configure boolean and list-based data access for these visualization settings. It also establishes a unique GUID and sets the component's exposure level to tertiary within the FeMM.Grasshopper.Components.MeCheck2 namespace.

• PrintCheckImageMeCheckTaubComponentBase.cs

  This file defines an abstract base class for a Grasshopper component named "Print MeCheck τb," designed to generate visual check images for finite element model super-element beams. It processes FEM models, beam data, and result trees to create graphical plots that can be saved to a specified file path. Key components include input parameters for model data, force combinations, and display options like significant digits and title customization. The class utilizes a `GraphicCreator` helper to render the data and supports custom marks via abstract methods that derived classes must implement.

• PrintCheckImageMeCheckTaubComponentV1_OBSOLETE.cs

  This file defines an obsolete Grasshopper component named `PrintCheckImageMeCheckTaubComponentV1_OBSOLETE` within the `FeMM.Grasshopper.Components.MeCheck2` namespace. It inherits from a base class and is marked with a hidden exposure level, indicating it is no longer intended for public use or standard workflow integration. The class implements empty override methods for input registration and data access, suggesting it serves as a deprecated placeholder or stub. Its primary purpose appears to be maintaining backward compatibility or preserving historical GUIDs for a previously active plugin feature.

• PrintCheckImageMeCheckTaubComponentV2.cs

  This file defines a Grasshopper component named `PrintCheckImageMeCheckTaubComponentV2`, which inherits from a base class to handle specific visualization logic. It functions as a tertiary-level tool that controls the display of vertical marks and X-axis ticks/labels on an image, likely for structural analysis or checking purposes. The key components include input parameters for toggling mark visibility (`Show Marks`) and specifying optional custom positions (`Mark Positions`). The implementation overrides methods to register these inputs and retrieve their data during execution, ensuring compatibility with Windows platforms via platform attributes.

• SuperElementCheckComponentBase.cs

  This file defines `SuperElementCheckComponentBase`, an abstract base class for a Grasshopper component that performs structural checks on super-element beams within the FeMM framework. It serves as a foundational template for concrete implementations by defining common inputs like model data, beam lists, and instability flags, alongside outputs for stress results and shear forces. The class manages the core logic flow via the `SolveInstance` method, which validates inputs, retrieves super-elements from the model, and triggers specific check computations when activated. Key components include input parameter registration for geometric and material properties, output trees for detailed stress and force analysis, and state management variables to handle iterative calculations and persistent data caching.

• SuperElementCheckComponentV1_OBSOLETE.cs

  This file defines an obsolete Grasshopper component named `SuperElementCheckComponentV1_OBSOLETE`, which inherits from a base class for structural analysis checks. It serves no functional purpose in its current state, as all critical methods like input/output registration and data computation are implemented as empty stubs or return default values. The component is explicitly marked with `GH_Exposure.hidden` to keep it out of the user interface and includes a `NETCOREAPP` platform restriction attribute. Its primary role appears to be maintaining backward compatibility or serving as a placeholder within the `FeMM.Grasshopper.Components.MeCheck2` namespace.

• SuperElementCheckComponentV2.cs

  `SuperElementCheckComponentV2.cs` is a Grasshopper plugin component designed to calculate shear resistance for composite steel beams according to Eurocode 3 (EN 1993-1-1). It processes input data regarding beam geometry and stiffener configurations, utilizing the Maffeis library for structural analysis and standard compliance checks. Key components include logic for handling Class 4 section reductions with configurable iteration limits and algorithms that interpolate material properties along varying beam lengths. The component outputs a list of shear resistance (`Rd`) values for each defined beam segment.

• SuperElementFilterComponent.cs

  This file defines a Grasshopper component named `SuperElementFilterComponent` designed to filter structural beams based on their associated "Super-Element" attribute. It accepts two inputs: an FEM model and the specific name of a Super-Element, then extracts all beams belonging to that group from the model. The component dynamically updates connected ValueList components with available Super-Elements to facilitate user selection and validates the input against existing data. After filtering, it sorts the resulting beams by their internal Element ID to ensure consistent ordering before outputting them as a list. Key components include input validation logic, dynamic UI parameter population via `ComponentsHelper`, and sorting algorithms for the final beam collection.

• SuperElementSectionExtractorComponent.cs

  This file defines a Grasshopper component named `SuperElementSectionExtractorComponent` designed for structural engineering analysis within the FeMM framework. Its primary function is to extract detailed geometric and material data from super-element beams at specified distances, supporting both concrete and steel materials according to EN1992 and EN1993 standards. The component processes inputs such as the model, beam list, section distance, and load combination names to compute section properties while accounting for local instability conditions in webs and flanges. Key components include robust input validation, handling of composite section stiffeners, and the ability to save extracted data to a user-defined local path. It utilizes internal models like `ConcreteMaterialEN1992` and `SteelMaterialEN1993` to ensure code compliance and accurate mechanical calculations. Finally, it offers an autorun feature and manual execution via a custom button, integrating seamlessly into parametric design workflows for efficient data extraction.