feat(nonlinear-static-newton-raphson): step 1 - nonlinear-static-domain-contract

include/fesa/model/domain.h

@@ -74,6 +74,12 @@ class StepDefinition {
   const DomainCollectionView<ConcentratedNodalLoad>& ConcentratedLoads()
       const noexcept;
 
+  /// @brief Returns the approved static procedure identity.
+  StaticProcedureKind ProcedureKind() const noexcept;
+
+  /// @brief Reports whether this step uses the nonlinear static procedure.
+  bool IsNonlinearStatic() const noexcept;
+
   /// @brief Returns the static initial increment provenance value.
   double InitialIncrement() const noexcept;
 
@@ -103,6 +109,8 @@ class StepDefinition {
   std::vector<std::unique_ptr<Load>> loads_;
   LoadView loads_view_;
   DomainCollectionView<ConcentratedNodalLoad> concentrated_loads_view_;
+  StaticProcedureKind procedure_kind_;
+  bool nlgeom_;
   double initial_increment_;
   double time_period_;
   double minimum_increment_;

include/fesa/model/model_types.h

@@ -7,6 +7,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
+#include <utility>
 #include <vector>
 
 #include "fesa/core/diagnostic.h"
@@ -52,11 +53,59 @@ struct NodalLoad {
   SourceLocation location;
 };
 
-/// @brief Stores the approved single linear-static step definition.
+/// @brief Identifies the approved static procedure semantics for one step.
+enum class StaticProcedureKind {
+  kLinearSmallDisplacement,
+  kNonlinearFullNewton
+};
+
+/// @brief Stores the approved single static step definition.
 struct StaticStepDefinition {
+  /// @brief Creates a static step with its mapped procedure identity.
+  StaticStepDefinition(
+      std::string step_name,
+      std::vector<PrescribedDisplacementDefinition> step_boundaries,
+      std::vector<NodalLoad> step_loads,
+      StaticProcedureKind step_procedure_kind,
+      bool step_nlgeom,
+      double step_initial_increment,
+      double step_time_period,
+      double step_minimum_increment,
+      double step_maximum_increment,
+      SourceLocation step_location)
+      : name{std::move(step_name)},
+        boundaries{std::move(step_boundaries)},
+        loads{std::move(step_loads)},
+        procedure_kind{step_procedure_kind},
+        nlgeom{step_nlgeom},
+        initial_increment{step_initial_increment},
+        time_period{step_time_period},
+        minimum_increment{step_minimum_increment},
+        maximum_increment{step_maximum_increment},
+        location{std::move(step_location)} {}
+
+  /// @brief Creates a legacy linear static step definition.
+  StaticStepDefinition(
+      std::string step_name,
+      std::vector<PrescribedDisplacementDefinition> step_boundaries,
+      std::vector<NodalLoad> step_loads,
+      double step_initial_increment,
+      double step_time_period,
+      double step_minimum_increment,
+      double step_maximum_increment,
+      SourceLocation step_location)
+      : StaticStepDefinition(
+            std::move(step_name), std::move(step_boundaries),
+            std::move(step_loads),
+            StaticProcedureKind::kLinearSmallDisplacement, false,
+            step_initial_increment, step_time_period, step_minimum_increment,
+            step_maximum_increment, std::move(step_location)) {}
+
   std::string name;
   std::vector<PrescribedDisplacementDefinition> boundaries;
   std::vector<NodalLoad> loads;
+  StaticProcedureKind procedure_kind;
+  bool nlgeom;
   double initial_increment;
   double time_period;
   double minimum_increment;