structuraid_core 0.1.3 → 0.2.1

data/lib/structuraid_core/design_codes/nsr_10/rc/reduction_factor.rb

@@ -0,0 +1,82 @@
+module StructuraidCore
+  module DesignCodes
+    module NSR10
+      module RC
+        class ReductionFactor
+          include DesignCodes::Utils::CodeRequirement
+          use_schema DesignCodes::Schemas::RC::ReductionFactorSchema
+
+          CONTROL_STRENGTH_CASES = %i[
+            compression_controlled
+            tension_controlled
+            transition_controlled
+            crushing_controlled
+            shear_nonseismic_controlled
+            torsion_controlled
+            corbel_bracket_controlled
+            strud_and_tie_controlled
+          ].freeze
+
+          MAX_STRAIN_BEFORE_TRANSITION = 0.002
+          MIN_STRAIN_AFTER_TRANSITION = 0.005
+
+          CODE_REFERENCE = 'NSR-10 C.9.3.2'.freeze
+
+          def call
+            unless CONTROL_STRENGTH_CASES.include?(strength_controlling_behaviour)
+              raise UnrecognizedValueError.new(strength_controlling_behaviour, :strength_controlling_behaviour)
+            end
+
+            return tension_controlled_factor if strength_controlling_behaviour == :tension_controlled
+            return compression_controlled_factor if strength_controlling_behaviour == :compression_controlled
+            return crushing_controlled_factor if strength_controlling_behaviour == :crushing_controlled
+            if %i[
+              shear_nonseismic_controlled
+              torsion_controlled
+              corbel_bracket_controlled
+              strud_and_tie_controlled
+            ].include?(strength_controlling_behaviour)
+              return shear_nonseismic_controlled_factor
+            end
+
+            transition_controlled_factor
+          end
+
+          private
+
+          def shear_nonseismic_controlled_factor
+            0.75
+          end
+
+          def crushing_controlled_factor
+            0.65
+          end
+
+          def tension_controlled_factor
+            0.90
+          end
+
+          def compression_controlled_factor
+            return 0.75 if is_coil_rebar
+
+            0.65
+          end
+
+          def transition_controlled_factor
+            raise MissingParamError, :strain unless strain
+
+            transition_controlled_by_strain
+          end
+
+          def transition_controlled_by_strain
+            return compression_controlled_factor if strain < MAX_STRAIN_BEFORE_TRANSITION
+            return tension_controlled_factor if strain > MIN_STRAIN_AFTER_TRANSITION
+
+            transition_rate = is_coil_rebar ? 50 : 250 / 3
+            compression_controlled_factor + (strain - MAX_STRAIN_BEFORE_TRANSITION) * transition_rate
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/schemas/rc/footings/bending_reinforcement_ratio_schema.rb

@@ -0,0 +1,24 @@
+module StructuraidCore
+  module DesignCodes
+    module Schemas
+      module RC
+        module Footings
+          class BendingReinforcementRatioSchema
+            include DesignCodes::Utils::SchemaDefinition
+
+            required_params %i[
+              design_compression_strength
+              design_steel_yield_strength
+              width
+              effective_height
+              flexural_moment
+              capacity_reduction_factor
+            ]
+
+            optional_params []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/schemas/rc/footings/one_way_shear_capacity_schema.rb

@@ -0,0 +1,22 @@
+module StructuraidCore
+  module DesignCodes
+    module Schemas
+      module RC
+        module Footings
+          class OneWayShearCapacitySchema
+            include DesignCodes::Utils::SchemaDefinition
+
+            required_params %i[
+              design_compression_strength
+              width
+              effective_height
+              light_concrete_modification_factor
+            ]
+
+            optional_params []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/schemas/rc/footings/punching_critical_section_perimeter_schema.rb

@@ -0,0 +1,23 @@
+module StructuraidCore
+  module DesignCodes
+    module Schemas
+      module RC
+        module Footings
+          class PunchingCriticalSectionPerimeterSchema
+            include DesignCodes::Utils::SchemaDefinition
+
+            required_params %i[
+              column_section_length_1
+              column_section_length_2
+              column_absolute_location
+              column_label
+              footing
+            ]
+
+            optional_params []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/schemas/rc/minimum_steel_cover_schema.rb

@@ -0,0 +1,32 @@
+module StructuraidCore
+  module DesignCodes
+    module Schemas
+      module RC
+        class MinimumSteelCoverSchema
+          include DesignCodes::Utils::SchemaDefinition
+
+          required_params %i[
+            concrete_casting_against_soil
+            environment_exposure
+          ]
+
+          optional_params %i[
+            maximum_rebar_diameter
+            structural_element
+          ]
+
+          enum :structural_element, %i[
+            slab
+            wall
+            joist
+            beam
+            column
+            shell thin_shell
+            tensor_joint
+            pedestal
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/schemas/rc/reduction_factor_schema.rb

@@ -0,0 +1,17 @@
+module StructuraidCore
+  module DesignCodes
+    module Schemas
+      module RC
+        class ReductionFactorSchema
+          include DesignCodes::Utils::SchemaDefinition
+
+          required_params %i[strength_controlling_behaviour]
+          optional_params %i[
+            strain
+            is_coil_rebar
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/design_codes/utils/schema_definition.rb

@@ -10,15 +10,9 @@ module StructuraidCore
 
         module ClassMethods
           def validate!(params)
-            required.each do |required_param|
-              raise DesignCodes::MissingParamError, required_param if params[required_param].nil?
-            end
-
-            optional.each do |optional_param|
-              raise DesignCodes::MissingParamError, optional_param if params[optional_param].nil?
-            rescue DesignCodes::MissingParamError => e
-              Warning.warn(e.message)
-            end
+            validate_required_params!(params)
+            validate_optional_params!(params)
+            validate_enum_params!(params)
 
             true
           end
@@ -40,8 +34,38 @@ module StructuraidCore
             @optional
           end
 
+          def enum_params
+            @enum_params
+          end
+
           private
 
+          def validate_required_params!(params)
+            required.each do |required_param|
+              raise DesignCodes::MissingParamError, required_param if params[required_param].nil?
+            end
+          end
+
+          def validate_optional_params!(params)
+            optional.each do |optional_param|
+              raise DesignCodes::MissingParamError, optional_param if params[optional_param].nil?
+            rescue DesignCodes::MissingParamError => e
+              Warning.warn(e.message)
+            end
+          end
+
+          def validate_enum_params!(params)
+            enum_params&.each do |enum_param|
+              param_name = enum_param[:name]
+              param_value = params[param_name]
+              next if param_value.nil? && optional.include?(param_name)
+
+              if enum_param[:values].none?(param_value)
+                raise DesignCodes::UnrecognizedValueError.new(param_name, param_value)
+              end
+            end
+          end
+
           def required_params(params)
             @required = params
           end
@@ -49,6 +73,11 @@ module StructuraidCore
           def optional_params(params)
             @optional = params
           end
+
+          def enum(param_name, values)
+            @enum_params = []
+            @enum_params << { name: param_name, values: }
+          end
         end
       end
     end

data/lib/structuraid_core/elements/column/rectangular.rb

@@ -2,13 +2,14 @@ module StructuraidCore
   module Elements
     module Column
       class Rectangular < Base
-        attr_reader :length_x, :length_y, :height, :material
+        attr_reader :length_1, :length_2, :height, :material, :label
 
-        def initialize(length_x:, length_y:, height:, material:)
-          @length_x = length_x.to_f
-          @length_y = length_y.to_f
+        def initialize(length_1:, length_2:, height:, material:, label: nil)
+          @length_1 = length_1.to_f
+          @length_2 = length_2.to_f
           @height = height.to_f
           @material = material
+          @label = label&.to_sym
         end
       end
     end

data/lib/structuraid_core/elements/footing.rb

@@ -1,14 +1,29 @@
 module StructuraidCore
   module Elements
+    # A footing is a structural element that transfers load from a column to the soil.
     class Footing < Base
       attr_accessor :length_1, :length_2, :height, :material, :cover_lateral, :cover_top, :cover_bottom
       attr_reader :longitudinal_top_reinforcement_length_1,
                   :longitudinal_bottom_reinforcement_length_1,
                   :longitudinal_top_reinforcement_length_2,
-                  :longitudinal_bottom_reinforcement_length_2
+                  :longitudinal_bottom_reinforcement_length_2,
+                  :coordinates_system
 
       VALID_SECTIONS = %i[length_1 length_2].freeze
 
+      # @param length_1 [Float] The length of the footing in the direction of the main section
+      # @param length_2 [Float] The length of the footing in the direction perpendicular to the main section
+      # @param height [Float] The height of the footing
+      # @param material [Materials::Concrete] The material of the footing. It must be concrete
+      # @param cover_lateral [Float] The lateral cover of the footing
+      # @param cover_top [Float] The top cover of the footing
+      # @param cover_bottom [Float] The bottom cover of the footing
+      # @param longitudinal_top_reinforcement_length_1 [Reinforcement::StraightLongitudinal] The longitudinal reinforcement in the direction of the main section
+      # @param longitudinal_bottom_reinforcement_length_1 [Reinforcement::StraightLongitudinal] The longitudinal reinforcement in the direction of the main section
+      # @param longitudinal_top_reinforcement_length_2 [Reinforcement::StraightLongitudinal] The longitudinal reinforcement in the direction perpendicular to the main section
+      # @param longitudinal_bottom_reinforcement_length_2 [Reinforcement::StraightLongitudinal] The longitudinal reinforcement in the direction perpendicular to the main section
+      #
+      # @return [Footing] the footing
       def initialize(
         length_1:,
         length_2:,
@@ -36,10 +51,16 @@ module StructuraidCore
         @main_section = :length_1
       end
 
+      # Computes the horizontal area of the footing
+      # @return [Float] The horizontal area of the footing
       def horizontal_area
-        @length_1 * @length_2
+        length_1 * length_2
       end
 
+      # Computes the effective height of the footing for each direction and for either top or bottom reinforcement
+      # @param section_direction [Symbol] The direction of the section. See VALID_SECTIONS
+      # @param above_middle [Boolean] Whether the reinforcement is above the middle of the footing
+      # @return [Float] The effective height of the footing
       def effective_height(section_direction:, above_middle:)
         case section_direction
         when :length_1
@@ -49,8 +70,54 @@ module StructuraidCore
         end
       end
 
+      # Sets the coordinates system of the footing
+      # @param coordinates_system [Engineering::Locations::CoordinatesSystem] A coordinates system instance
+      # @return [Engineering::Locations::CoordinatesSystem] The coordinates system of the footing
+      def add_coordinates_system(coordinates_system)
+        @coordinates_system = coordinates_system
+      end
+
+      # Adds a column's location to the footing. If the column's location is already in the footing's coordinates system, it returns the existing location.
+      # @param column_location [Engineering::Locations::Absolute] The column's absolute location
+      # @param column_label [String, Symbol] The column's label
+      # @return [Engineering::Locations::Relative] The column's relative location
+      def find_or_add_column_location(column_location, column_label)
+        label = "column_#{column_label}"
+        relative_location_vector = column_location.to_vector - coordinates_system.anchor_location.to_vector
+        coordinates_system.find_or_add_location_from_vector(relative_location_vector, label:)
+      end
+
+      # Computes the vertices location of the footing's perimeter horizontally and adds them to the footing's coordinates system
+      def add_vertices_location
+        vertices_locations_vectors.each do |label, vector|
+          coordinates_system.find_or_add_location_from_vector(vector, label:)
+        end
+      end
+
+      # Evaluates if a relative location is inside the footing's perimeter. It works only for horizontal locations (z = 0)
+      # @param location [Engineering::Locations::Relative] The relative location to evaluate
+      # @return [Boolean] Whether the location is inside the footing's perimeter
+      def inside_me?(location)
+        inside_axis_2 = location.value_2 >= -0.5 * length_2 && location.value_2 <= 0.5 * length_2
+        inside_axis_1 = location.value_1 >= -0.5 * length_1 && location.value_1 <= 0.5 * length_1
+
+        inside_axis_1 && inside_axis_2
+      end
+
       private
 
+      def vertices_locations_vectors
+        half_length_1 = 0.5 * length_1
+        half_length_2 = 0.5 * length_2
+
+        {
+          'vertex_top_right' => Vector[half_length_1, half_length_2, 0],
+          'vertex_top_left' => Vector[-half_length_1, half_length_2, 0],
+          'vertex_bottom_left' => Vector[-half_length_1, -half_length_2, 0],
+          'vertex_bottom_right' => Vector[half_length_1, -half_length_2, 0]
+        }
+      end
+
       def aspect_ratio
         @length_1 / @length_2
       end

data/lib/structuraid_core/engineering/analysis/footing/base.rb

@@ -0,0 +1,17 @@
+module StructuraidCore
+  module Engineering
+    module Analysis
+      module Footing
+        class Base
+        end
+      end
+    end
+  end
+end
+
+require_relative 'utils/basic_geometry'
+require_relative 'utils/centroid'
+require_relative 'utils/one_way_shear'
+require_relative 'utils/one_way_moment'
+require_relative 'centric_isolated'
+require_relative 'centric_combined_two_columns'

data/lib/structuraid_core/engineering/analysis/footing/centric_combined_two_columns.rb

@@ -0,0 +1,99 @@
+require 'byebug'
+
+module StructuraidCore
+  module Engineering
+    module Analysis
+      module Footing
+        class CentricCombinedTwoColumns < Base
+          include Utils::BasicGeometry
+          include Utils::Centroid
+          include Utils::OneWayShear
+          include Utils::OneWayMoment
+
+          def initialize(footing:, loads_from_columns:, section_direction:)
+            if ORTHOGONALITIES.none?(section_direction)
+              raise Engineering::Analysis::SectionDirectionError.new(section_direction, ORTHOGONALITIES)
+            end
+
+            @footing = footing
+            @loads_from_columns = loads_from_columns
+            @section_direction = section_direction
+          end
+
+          def build_geometry
+            add_loads_to_coordinates_system
+            align_coordinates_system_with_loads
+            add_vertices_location_to_coordinates_system
+          end
+
+          def reaction_at_first_column
+            -(solicitation * @footing.horizontal_area + reaction_at_second_column)
+          end
+
+          def reaction_at_second_column
+            local_length_1 = length_border_to_first_column
+            local_length_2 = length_first_column_to_second_column
+            local_length_3 = length_second_column_to_border
+
+            (solicitation_load / 2 / local_length_2) * (local_length_1**2 - (local_length_2 + local_length_3)**2)
+          end
+
+          private
+
+          attr_reader :footing, :section_direction, :loads_from_columns
+
+          def coordinates_system
+            footing.coordinates_system
+          end
+
+          def align_coordinates_system_with_loads
+            last_load_location_label = "load_#{loads_from_columns.last.label}"
+            aligner_vector = coordinates_system.find_location(last_load_location_label).to_vector
+            coordinates_system.align_axis_1_with(vector: aligner_vector)
+          end
+
+          def add_loads_to_coordinates_system
+            centroid = absolute_centroid
+
+            loads_from_columns.each do |load_from_column|
+              coordinates_system.find_or_add_location_from_vector(
+                load_from_column.location.to_vector - centroid.to_vector,
+                label: "load_#{load_from_column.label}"
+              )
+            end
+          end
+
+          def add_vertices_location_to_coordinates_system
+            footing.add_vertices_location
+          end
+
+          def length_border_to_first_column
+            load_location_label = "load_#{loads_from_columns.first.label}"
+            load_location_vector = coordinates_system.find_location(load_location_label).to_vector
+            vertex_location_vector = coordinates_system.find_location('vertex_top_left').to_vector
+
+            (load_location_vector - vertex_location_vector)[0].abs
+          end
+
+          def length_first_column_to_second_column
+            first_load_location_label = "load_#{loads_from_columns.first.label}"
+            first_load_location_vector = coordinates_system.find_location(first_load_location_label).to_vector
+
+            last_load_location_label = "load_#{loads_from_columns.last.label}"
+            last_load_location_vector = coordinates_system.find_location(last_load_location_label).to_vector
+
+            (last_load_location_vector - first_load_location_vector)[0].abs
+          end
+
+          def length_second_column_to_border
+            load_location_label = "load_#{loads_from_columns.last.label}"
+            load_location_vector = coordinates_system.find_location(load_location_label).to_vector
+            vertex_location_vector = coordinates_system.find_location('vertex_top_right').to_vector
+
+            (vertex_location_vector - load_location_vector)[0].abs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/engineering/analysis/footing/centric_isolated.rb

@@ -2,7 +2,7 @@ module StructuraidCore
   module Engineering
     module Analysis
       module Footing
-        class CentricIsolated
+        class CentricIsolated < Base
           ORTHOGONALITIES = %i[length_1 length_2].freeze
 
           def initialize(footing:, load_from_column:, section_direction:)

data/lib/structuraid_core/engineering/analysis/footing/utils/basic_geometry.rb

@@ -0,0 +1,36 @@
+module StructuraidCore
+  module Engineering
+    module Analysis
+      module Footing
+        module Utils
+          module BasicGeometry
+            ORTHOGONALITIES = %i[length_1 length_2].freeze
+
+            def solicitation_load
+              solicitation * orthogonal_length
+            end
+
+            private
+
+            def section_length
+              footing.public_send(section_direction)
+            end
+
+            def orthogonal_length
+              footing.public_send(orthogonal_direction)
+            end
+
+            def orthogonal_direction
+              orthogonal = ORTHOGONALITIES - [@cut_direction]
+              orthogonal.last
+            end
+
+            def solicitation
+              -loads_from_columns.sum(&:value) / @footing.horizontal_area
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/engineering/analysis/footing/utils/centroid.rb

@@ -0,0 +1,33 @@
+module StructuraidCore
+  module Engineering
+    module Analysis
+      module Footing
+        module Utils
+          module Centroid
+            def absolute_centroid
+              Engineering::Locations::Absolute.new(
+                value_x: moment_yy / total_load,
+                value_y: moment_xx / total_load,
+                value_z: loads_from_columns.first.location.value_z
+              )
+            end
+
+            private
+
+            def moment_yy
+              loads_from_columns.sum { |load| load.value * load.location.value_x }
+            end
+
+            def moment_xx
+              loads_from_columns.sum { |load| load.value * load.location.value_y }
+            end
+
+            def total_load
+              loads_from_columns.sum(&:value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/structuraid_core/engineering/analysis/footing/utils/one_way_moment.rb

@@ -0,0 +1,63 @@
+module StructuraidCore
+  module Engineering
+    module Analysis
+      module Footing
+        module Utils
+          module OneWayMoment
+            def moment_at(x_distance)
+              return [] if x_distance > section_length
+
+              moment = [
+                moment_stretch_1(x_distance),
+                moment_stretch_2(x_distance),
+                moment_stretch_3(x_distance)
+              ].select(&:nonzero?)
+              return [0] if moment.empty?
+
+              moment
+            end
+
+            def maximum_moment
+              moment_at(moment_inflection_point)
+            end
+
+            def moment_inflection_point
+              -reaction_at_first_column / solicitation_load
+            end
+
+            private
+
+            def moment_stretch_1(x_distance)
+              return 0.0 if x_distance > length_border_to_first_column
+
+              0.5 * solicitation_load * x_distance**2
+            end
+
+            def moment_stretch_2(x_distance)
+              local_length_1 = length_border_to_first_column
+              local_length_2 = length_first_column_to_second_column
+              return 0.0 if x_distance < local_length_1 || x_distance > local_length_1 + local_length_2
+
+              0.5 * solicitation_load * x_distance**2 + reaction_at_first_column * (x_distance - local_length_1)
+            end
+
+            def moment_stretch_3(x_distance)
+              return 0.0 if x_distance < length_border_to_first_column + length_first_column_to_second_column
+
+              0.5 * solicitation_load * x_distance**2 + reaction_1_moment(x_distance) + reaction_2_moment(x_distance)
+            end
+
+            def reaction_1_moment(x_distance)
+              reaction_at_first_column * (x_distance - length_border_to_first_column)
+            end
+
+            def reaction_2_moment(x_distance)
+              local_length_2 = length_first_column_to_second_column
+              reaction_at_second_column * (x_distance - length_border_to_first_column - local_length_2)
+            end
+          end
+        end
+      end
+    end
+  end
+end