osut 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6bbbc6887949cfd0d1aed5c460d993196fa86d1a13f366f7f852e418aa9457a0
-  data.tar.gz: b38eaa81d84a79655adb10a06bb1fa299ffff60051d187f2b36bad38fa4d78e0
+  metadata.gz: 2491bf7ed2ed4277ccfe4087a661660e720bd7f417b1e51f3c1f81715e53193f
+  data.tar.gz: 7c07191bf8cb725fdb9a04e15269aa6431fd7aa66955b9b99b2c1d61929033c6
 SHA512:
-  metadata.gz: 1eb2cd49987ce2a4bf7a6a9fe0ed7048bc78dce644aa88e68173861ce4e52fc2bfe59bb3c4a7b353426a1bfa30f45af102ca3e509ac91945b82673545f1a4d4d
-  data.tar.gz: bb8075d22d660b3f177716463baf3bc2b0e788269dc05f60086272dc5fec193b93a207f94500fa26cf8d786fdcd3810c0d3defb50eca4c39b3a05cf7c8d2412c
+  metadata.gz: ed0ad6091cf8bd858a1b3de7c17b4e13fd21816871c1dc8bf539d4b7b03f232dfa1621d3e6a839eebde9a779d7562e9c56e04bf10a52c417d884ebba7128e9c0
+  data.tar.gz: 5be1c0c83a39becabf70d6202916b4012ca1923b2102084515dfccae765e9fffc5e4db27787523a1a7694a852e15029176216d1fff255e0653baba97c399eacd

data/.github/workflows/pull_request.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   test_300x:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Check out repository
       uses: actions/checkout@v2
@@ -23,7 +23,7 @@ jobs:
         docker exec -t test bundle exec rake
         docker kill test
   test_321x:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Check out repository
       uses: actions/checkout@v2
@@ -39,7 +39,7 @@ jobs:
         docker exec -t test bundle exec rake
         docker kill test
   test_330x:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Check out repository
       uses: actions/checkout@v2
@@ -55,7 +55,7 @@ jobs:
         docker exec -t test bundle exec rake
         docker kill test
   test_340x:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - name: Check out repository
       uses: actions/checkout@v2
@@ -70,3 +70,19 @@ jobs:
         docker exec -t test bundle update
         docker exec -t test bundle exec rake
         docker kill test
+  test_351x:
+    runs-on: ubuntu-22.04
+    steps:
+    - name: Check out repository
+      uses: actions/checkout@v2
+    - name: Run Tests
+      run: |
+        echo $(pwd)
+        echo $(ls)
+        docker pull nrel/openstudio:3.5.1
+        docker run --name test --rm -d -t -v $(pwd):/work -w /work nrel/openstudio:3.5.1
+        docker exec -t test pwd
+        docker exec -t test ls
+        docker exec -t test bundle update
+        docker exec -t test bundle exec rake
+        docker kill test

data/.gitignore

@@ -8,4 +8,6 @@ _yardoc
 doc/
 rdoc
 
+spec/files/osms/out/
+
 .DS_Store

data/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, Denis Bourgeois
+Copyright (c) 2022-2023, Denis Bourgeois
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/lib/osut/utils.rb

@@ -1,6 +1,6 @@
 # BSD 3-Clause License
 #
-# Copyright (c) 2022, Denis Bourgeois
+# Copyright (c) 2022-2023, Denis Bourgeois
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -41,6 +41,8 @@ module OSut
   ERR  = OSut::ERROR     #     flag invalid .osm inputs (then exit via 'return')
   FTL  = OSut::FATAL     #                            not currently used in OSut
   NS   = "nameString"    #                OpenStudio IdfObject nameString method
+  HEAD = 2.032           # standard 80" door
+  SILL = 0.762           # standard 30" window sill
 
   # This first set of utilities (~750 lines) help distinguishing spaces that
   # are directly vs indirectly CONDITIONED, vs SEMI-HEATED. The solution here
@@ -59,7 +61,7 @@ module OSut
   #       cooling system of sufficient size to maintain temperatures suitable
   #       for HUMAN COMFORT:
   #         - COOLED: cooled by a system >= 10 W/m2
-  #         - HEATED: heated by a system e.g., >= 50 W/m2 in Climate Zone CZ-7
+  #         - HEATED: heated by a system, e.g. >= 50 W/m2 in Climate Zone CZ-7
   #         - INDIRECTLY: heated or cooled via adjacent space(s) provided:
   #             - UA of adjacent surfaces > UA of other surfaces
   #                 or
@@ -89,7 +91,7 @@ module OSut
   # response to the exterior ambient temperature by the provision, either
   # DIRECTLY or INDIRECTLY, of heating or cooling [...]". Although criteria
   # differ (e.g., not sizing-based), the general idea is sufficiently similar
-  # to ASHRAE 90.1 (e.g., heating and/or cooling based, no distinction for
+  # to ASHRAE 90.1 (e.g. heating and/or cooling based, no distinction for
   # INDIRECTLY conditioned spaces like plenums).
   #
   # SEMI-HEATED spaces are also a defined NECB term, but again the distinction
@@ -109,16 +111,16 @@ module OSut
   # processes. As discussed in greater detail elswhere, methods are developed to
   # rely on zoning info and/or "intended" temperature setpoints.
   #
-  # For an OpenStudio model (OSM) in an incomplete or preliminary state, e.g.
-  # holding fully-formed ENCLOSED spaces without thermal zoning information or
-  # setpoint temperatures (early design stage assessments of form, porosity or
-  # envelope), all OSM spaces will be considered CONDITIONED, presuming
-  # setpoints of ~21°C (heating) and ~24°C (cooling).
+  # For an OpenStudio model in an incomplete or preliminary state, e.g. holding
+  # fully-formed ENCLOSED spaces without thermal zoning information or setpoint
+  # temperatures (early design stage assessments of form, porosity or envelope),
+  # all OpenStudio spaces will be considered CONDITIONED, presuming setpoints of
+  # ~21°C (heating) and ~24°C (cooling).
   #
-  # If ANY valid space/zone-specific temperature setpoints are found in the OSM,
-  # spaces/zones WITHOUT valid heating or cooling setpoints are considered as
-  # UNCONDITIONED or UNENCLOSED spaces (like attics), or INDIRECTLY CONDITIONED
-  # spaces (like plenums), see "plenum?" method.
+  # If ANY valid space/zone-specific temperature setpoints are found in the
+  # OpenStudio model, spaces/zones WITHOUT valid heating or cooling setpoints
+  # are considered as UNCONDITIONED or UNENCLOSED spaces (like attics), or
+  # INDIRECTLY CONDITIONED spaces (like plenums), see "plenum?" method.
 
   ##
   # Return min & max values of a schedule (ruleset).
@@ -139,6 +141,7 @@ module OSut
     res = { min: nil, max: nil }
 
     return invalid("sched", mth, 1, DBG, res)     unless sched.respond_to?(NS)
+
     id = sched.nameString
     return mismatch(id, sched, cl, mth, DBG, res) unless sched.is_a?(cl)
 
@@ -186,6 +189,7 @@ module OSut
     res = { min: nil, max: nil }
 
     return invalid("sched", mth, 1, DBG, res)     unless sched.respond_to?(NS)
+
     id = sched.nameString
     return mismatch(id, sched, cl, mth, DBG, res) unless sched.is_a?(cl)
 
@@ -218,6 +222,7 @@ module OSut
     res      = { min: nil, max: nil }
 
     return invalid("sched", mth, 1, DBG, res)     unless sched.respond_to?(NS)
+
     id = sched.nameString
     return mismatch(id, sched, cl, mth, DBG, res) unless sched.is_a?(cl)
 
@@ -231,9 +236,11 @@ module OSut
     end
 
     return empty("'#{id}' values", mth, ERR, res) if vals.empty?
+
     ok = vals.min.is_a?(Numeric) && vals.max.is_a?(Numeric)
     log(ERR, "Non-numeric values in '#{id}' (#{mth})")                 unless ok
     return res                                                         unless ok
+
     res[:min] = vals.min
     res[:max] = vals.max
 
@@ -248,19 +255,21 @@ module OSut
   # @return [Hash] min: (Float), max: (Float)
   # @return [Hash] min: nil, max: nil (if invalid input)
   def scheduleIntervalMinMax(sched = nil)
-    mth      = "OSut::#{__callee__}"
-    cl       = OpenStudio::Model::ScheduleInterval
-    vals     = []
-    prev_str = ""
-    res      = { min: nil, max: nil }
+    mth  = "OSut::#{__callee__}"
+    cl   = OpenStudio::Model::ScheduleInterval
+    vals = []
+    res  = { min: nil, max: nil }
 
     return invalid("sched", mth, 1, DBG, res)     unless sched.respond_to?(NS)
+
     id = sched.nameString
     return mismatch(id, sched, cl, mth, DBG, res) unless sched.is_a?(cl)
+
     vals = sched.timeSeries.values
-    ok = vals.min.is_a?(Numeric) && vals.max.is_a?(Numeric)
+    ok   = vals.min.is_a?(Numeric) && vals.max.is_a?(Numeric)
     log(ERR, "Non-numeric values in '#{id}' (#{mth})")                 unless ok
     return res                                                         unless ok
+
     res[:min] = vals.min
     res[:max] = vals.max
 
@@ -289,6 +298,7 @@ module OSut
     res = { spt: nil, dual: false }
 
     return invalid("zone", mth, 1, DBG, res)     unless zone.respond_to?(NS)
+
     id = zone.nameString
     return mismatch(id, zone, cl, mth, DBG, res) unless zone.is_a?(cl)
 
@@ -369,6 +379,7 @@ module OSut
     end
 
     return res if zone.thermostat.empty?
+
     tstat       = zone.thermostat.get
     res[:spt]   = nil
 
@@ -427,6 +438,7 @@ module OSut
 
           sched.getScheduleWeeks.each do |week|
             next if week.winterDesignDaySchedule.empty?
+
             dd = week.winterDesignDaySchedule.get
             next unless dd.values.empty?
 
@@ -479,6 +491,7 @@ module OSut
     res = { spt: nil, dual: false }
 
     return invalid("zone", mth, 1, DBG, res)     unless zone.respond_to?(NS)
+
     id = zone.nameString
     return mismatch(id, zone, cl, mth, DBG, res) unless zone.is_a?(cl)
 
@@ -546,6 +559,7 @@ module OSut
     end
 
     return res if zone.thermostat.empty?
+
     tstat       = zone.thermostat.get
     res[:spt]   = nil
 
@@ -604,6 +618,7 @@ module OSut
 
           sched.getScheduleWeeks.each do |week|
             next if week.summerDesignDaySchedule.empty?
+
             dd = week.summerDesignDaySchedule.get
             next unless dd.values.empty?
 
@@ -691,10 +706,13 @@ module OSut
     cl  = OpenStudio::Model::Space
 
     return invalid("space", mth, 1, DBG, false)     unless space.respond_to?(NS)
+
     id = space.nameString
     return mismatch(id, space, cl, mth, DBG, false) unless space.is_a?(cl)
+
     valid = loops == true || loops == false
     return invalid("loops", mth, 2, DBG, false)     unless valid
+
     valid = setpoints == true || setpoints == false
     return invalid("setpoints", mth, 3, DBG, false) unless valid
 
@@ -714,11 +732,11 @@ module OSut
     unless space.spaceType.empty?
       type = space.spaceType.get
       return type.nameString.downcase == "plenum"                            # C
+    end
 
-      unless type.standardsSpaceType.empty?
-        type = type.standardsSpaceType.get
-        return type.downcase == "plenum"                                     # C
-      end
+    unless type.standardsSpaceType.empty?
+      type = type.standardsSpaceType.get
+      return type.downcase == "plenum"                                       # C
     end
 
     false
@@ -751,6 +769,7 @@ module OSut
       next unless l.numericType.get.downcase == "discrete"
       next unless l.unitType.downcase == "availability"
       next unless l.nameString.downcase == "hvac operation scheduletypelimits"
+
       limits = l
     end
 
@@ -771,6 +790,7 @@ module OSut
     # Seasonal availability start/end dates.
     year  = model.yearDescription
     return  empty("yearDescription", mth, ERR) if year.empty?
+
     year  = year.get
     may01 = year.makeDate(OpenStudio::MonthOfYear.new("May"),  1)
     oct31 = year.makeDate(OpenStudio::MonthOfYear.new("Oct"), 31)
@@ -850,9 +870,11 @@ module OSut
     ok = schedule.setScheduleTypeLimits(limits)
     log(ERR, "'#{nom}': Can't set schedule type limits (#{mth})")      unless ok
     return nil                                                         unless ok
+
     ok = schedule.defaultDaySchedule.addValue(time, val)
     log(ERR, "'#{nom}': Can't set default day schedule (#{mth})")      unless ok
     return nil                                                         unless ok
+
     schedule.defaultDaySchedule.setName(dft)
 
     unless tag.empty?
@@ -861,12 +883,15 @@ module OSut
       ok = rule.setStartDate(may01)
       log(ERR, "'#{tag}': Can't set start date (#{mth})")              unless ok
       return nil                                                       unless ok
+
       ok = rule.setEndDate(oct31)
       log(ERR, "'#{tag}': Can't set end date (#{mth})")                unless ok
       return nil                                                       unless ok
+
       ok = rule.setApplyAllDays(true)
       log(ERR, "'#{tag}': Can't apply to all days (#{mth})")           unless ok
       return nil                                                       unless ok
+
       rule.daySchedule.setName(day)
     end
 
@@ -874,7 +899,7 @@ module OSut
   end
 
   ##
-  # Validate if default construction set holds a base ground construction.
+  # Validate if default construction set holds a base construction.
   #
   # @param set [OpenStudio::Model::DefaultConstructionSet] a default set
   # @param bse [OpensStudio::Model::ConstructionBase] a construction base
@@ -890,17 +915,23 @@ module OSut
     cl2 = OpenStudio::Model::ConstructionBase
 
     return invalid("set", mth, 1, DBG, false)         unless set.respond_to?(NS)
+
     id = set.nameString
     return mismatch(id, set, cl1, mth, DBG, false)    unless set.is_a?(cl1)
     return invalid("base", mth, 2, DBG, false)        unless bse.respond_to?(NS)
+
     id = bse.nameString
     return mismatch(id, bse, cl2, mth, DBG, false)    unless bse.is_a?(cl2)
+
     valid = gr == true || gr == false
     return invalid("ground", mth, 3, DBG, false)      unless valid
+
     valid = ex == true || ex == false
     return invalid("exterior", mth, 4, DBG, false)    unless valid
+
     valid = typ.respond_to?(:to_s)
     return invalid("surface typ", mth, 4, DBG, false) unless valid
+
     type = typ.to_s.downcase
     valid = type == "floor" || type == "wall" || type == "roofceiling"
     return invalid("surface type", mth, 5, DBG, false) unless valid
@@ -959,6 +990,7 @@ module OSut
 
     return mismatch("model", model, cl1, mth)           unless model.is_a?(cl1)
     return invalid("s", mth, 2)                         unless s.respond_to?(NS)
+
     id   = s.nameString
     return mismatch(id, s, cl2, mth)                    unless s.is_a?(cl2)
 
@@ -966,8 +998,10 @@ module OSut
     log(ERR, "'#{id}' construction not defaulted (#{mth})")            unless ok
     return nil                                                         unless ok
     return empty("'#{id}' construction", mth, ERR)      if s.construction.empty?
+
     base = s.construction.get
     return empty("'#{id}' space", mth, ERR)             if s.space.empty?
+
     space = s.space.get
     type = s.surfaceType
     ground = false
@@ -1043,12 +1077,14 @@ module OSut
     cl  = OpenStudio::Model::LayeredConstruction
 
     return invalid("lc", mth, 1, DBG, 0.0)             unless lc.respond_to?(NS)
+
     id = lc.nameString
     return mismatch(id, lc, cl, mth, DBG, 0.0)         unless lc.is_a?(cl)
 
     ok = standardOpaqueLayers?(lc)
     log(ERR, "'#{id}' holds non-StandardOpaqueMaterial(s) (#{mth})")   unless ok
     return 0.0                                                         unless ok
+
     thickness = 0.0
     lc.layers.each { |m| thickness += m.thickness }
 
@@ -1113,11 +1149,14 @@ module OSut
     cl2 = Numeric
 
     return invalid("lc", mth, 1, DBG, 0.0)             unless lc.respond_to?(NS)
+
     id = lc.nameString
+
     return mismatch(id, lc, cl1, mth, DBG, 0.0)        unless lc.is_a?(cl1)
     return mismatch("film", film, cl2, mth, DBG, 0.0)  unless film.is_a?(cl2)
     return mismatch("temp K", t, cl2, mth, DBG, 0.0)   unless t.is_a?(cl2)
-    t += 273.0                                                         # °C to K
+
+    t += 273.0                                             # °C to K
     return negative("temp K", mth, DBG, 0.0)               if t < 0
     return negative("film", mth, DBG, 0.0)                 if film < 0
 
@@ -1127,6 +1166,7 @@ module OSut
       # Fenestration materials first (ignoring shades, screens, etc.)
       empty = m.to_SimpleGlazing.empty?
       return 1 / m.to_SimpleGlazing.get.uFactor                     unless empty
+
       empty = m.to_StandardGlazing.empty?
       rsi += m.to_StandardGlazing.get.thermalResistance             unless empty
       empty = m.to_RefractionExtinctionGlazing.empty?
@@ -1167,6 +1207,7 @@ module OSut
     i   = 0                                                           # iterator
 
     return invalid("lc", mth, 1, DBG, res)             unless lc.respond_to?(NS)
+
     id   = lc.nameString
     return mismatch(id, lc, cl1, mth, DBG, res)        unless lc.is_a?(cl)
 
@@ -1221,6 +1262,7 @@ module OSut
 
     return mismatch("model", model, cl1, mth, DBG, res) unless model.is_a?(cl1)
     return invalid("group", mth, 2, DBG, res) unless group.respond_to?(NS)
+
     id = group.nameString
     return mismatch(id, group, cl2, mth, DBG, res) unless group.is_a?(cl2)
 
@@ -1244,10 +1286,10 @@ module OSut
     cl2 = Numeric
 
     return mismatch("vector", v, cl1, mth, DBG, v) unless v.is_a?(cl1)
-    return mismatch("x", v.x, cl2, mth, DBG, v)    unless v.x.respond_to?(:to_f)
-    return mismatch("y", v.y, cl2, mth, DBG, v)    unless v.y.respond_to?(:to_f)
-    return mismatch("z", v.z, cl2, mth, DBG, v)    unless v.z.respond_to?(:to_f)
-    return mismatch("m", m, cl2,  mth, DBG, v)     unless m.respond_to?(:to_f)
+    return mismatch("x",    v.x, cl2, mth, DBG, v) unless v.x.respond_to?(:to_f)
+    return mismatch("y",    v.y, cl2, mth, DBG, v) unless v.y.respond_to?(:to_f)
+    return mismatch("z",    v.z, cl2, mth, DBG, v) unless v.z.respond_to?(:to_f)
+    return mismatch("m",      m, cl2, mth, DBG, v) unless m.respond_to?(:to_f)
 
     OpenStudio::Vector3d.new(m * v.x, m * v.y, m * v.z)
   end
@@ -1266,6 +1308,7 @@ module OSut
 
     valid = pts.is_a?(cl1) || pts.is_a?(Array)
     return mismatch("points", pts, cl1, mth, DBG, v)      unless valid
+
     pts.each { |pt| mismatch("pt", pt, cl2, mth, ERR, v)  unless pt.is_a?(cl2) }
     pts.each { |pt| v << OpenStudio::Point3d.new(pt.x, pt.y, 0) }
 
@@ -1311,23 +1354,29 @@ module OSut
     ft    = OpenStudio::Transformation.alignFace(p1)
     ft_p1 = flatZ( (ft.inverse * p1)         )
     return  false                                                if ft_p1.empty?
+
     cw    = OpenStudio.pointInPolygon(ft_p1.first, ft_p1, TOL)
     ft_p1 = flatZ( (ft.inverse * p1).reverse )               unless cw
     ft_p2 = flatZ( (ft.inverse * p2).reverse )               unless cw
     ft_p2 = flatZ( (ft.inverse * p2)         )                   if cw
     return  false                                                if ft_p2.empty?
+
     area1 = OpenStudio.getArea(ft_p1)
     area2 = OpenStudio.getArea(ft_p2)
     return  empty("#{i1} area", mth, ERR, a)                     if area1.empty?
     return  empty("#{i2} area", mth, ERR, a)                     if area2.empty?
+
     area1 = area1.get
     area2 = area2.get
     union = OpenStudio.join(ft_p1, ft_p2, TOL2)
     return  false                                                if union.empty?
+
     union = union.get
     area  = OpenStudio.getArea(union)
     return  empty("#{i1}:#{i2} union area", mth, ERR, a)         if area.empty?
+
     area = area.get
+
     return false                                     if area < TOL
     return true                                      if (area - area2).abs < TOL
     return false                                     if (area - area2).abs > TOL
@@ -1376,25 +1425,33 @@ module OSut
     ft_p2 = flatZ( (ft.inverse * p2)         )
     return  false                                                if ft_p1.empty?
     return  false                                                if ft_p2.empty?
+
     cw    = OpenStudio.pointInPolygon(ft_p1.first, ft_p1, TOL)
     ft_p1 = flatZ( (ft.inverse * p1).reverse )               unless cw
     ft_p2 = flatZ( (ft.inverse * p2).reverse )               unless cw
     return  false                                                if ft_p1.empty?
     return  false                                                if ft_p2.empty?
+
     area1 = OpenStudio.getArea(ft_p1)
     area2 = OpenStudio.getArea(ft_p2)
     return  empty("#{i1} area", mth, ERR, a)                     if area1.empty?
     return  empty("#{i2} area", mth, ERR, a)                     if area2.empty?
+
     area1 = area1.get
     area2 = area2.get
     union = OpenStudio.join(ft_p1, ft_p2, TOL2)
     return  false                                                if union.empty?
+
     union = union.get
     area  = OpenStudio.getArea(union)
     return empty("#{i1}:#{i2} union area", mth, ERR, a)          if area.empty?
+
     area = area.get
     return false                                                 if area < TOL
 
+    delta = (area - area1 - area2).abs
+    return false                                                 if delta < TOL
+
     true
   end
 
@@ -1408,19 +1465,22 @@ module OSut
   # @return [OpenStudio::Point3dVector] offset points if successful
   # @return [OpenStudio::Point3dVector] original points if invalid input
   def offset(p1 = [], w = 0, v = 0)
-    mth   = "TBD::#{__callee__}"
+    mth   = "OSut::#{__callee__}"
     cl    = OpenStudio::Point3d
     vrsn  = OpenStudio.openStudioVersion.split(".").map(&:to_i).join.to_i
 
     valid = p1.is_a?(OpenStudio::Point3dVector) || p1.is_a?(Array)
     return  mismatch("pts", p1, cl1, mth, DBG, p1)  unless valid
     return  empty("pts", mth, ERR, p1)                  if p1.empty?
+
     valid = p1.size == 3 || p1.size == 4
     iv    = true if p1.size == 4
     return  invalid("pts", mth, 1, DBG, p1)         unless valid
     return  invalid("width", mth, 2, DBG, p1)       unless w.respond_to?(:to_f)
+
     w     = w.to_f
     return  p1                                          if w < 0.0254
+
     v     = v.to_i                                      if v.respond_to?(:to_i)
     v     = 0                                       unless v.respond_to?(:to_i)
     v     = vrsn                                        if v.zero?
@@ -1432,16 +1492,19 @@ module OSut
       ft     = OpenStudio::Transformation::alignFace(p1)
       ft_pts = flatZ( (ft.inverse * p1) )
       return   p1                                       if ft_pts.empty?
+
       cw     = OpenStudio::pointInPolygon(ft_pts.first, ft_pts, TOL)
       ft_pts = flatZ( (ft.inverse * p1).reverse )   unless cw
       offset = OpenStudio.buffer(ft_pts, w, TOL)
       return   p1                                       if offset.empty?
+
       offset = offset.get
       offset =  ft * offset                             if cw
       offset = (ft * offset).reverse                unless cw
 
       pz = OpenStudio::Point3dVector.new
       offset.each { |o| pz << OpenStudio::Point3d.new(o.x, o.y, o.z ) }
+
       return pz
     else                                                  # brute force approach
       pz     = {}
@@ -1626,6 +1689,589 @@ module OSut
     end
   end
 
+  ##
+  # Validate whether an OpenStudio planar surface is safe to process.
+  #
+  # @param s [OpenStudio::Model::PlanarSurface] a surface
+  #
+  # @return [Bool] true if valid surface
+  def surface_valid?(s = nil)
+    mth = "OSut::#{__callee__}"
+    cl = OpenStudio::Model::PlanarSurface
+
+    return mismatch("surface", s, cl, mth, DBG, false) unless s.is_a?(cl)
+
+    id   = s.nameString
+    size = s.vertices.size
+    last = size - 1
+
+    log(ERR, "#{id} #{size} vertices? need +3 (#{mth})")        unless size > 2
+    return false                                                unless size > 2
+
+    [0, last].each do |i|
+      v1  = s.vertices[i]
+      v2  = s.vertices[i + 1]                                  unless i == last
+      v2  = s.vertices.first                                       if i == last
+      vec = v2 - v1
+      bad = vec.length < TOL
+
+      # As is, this comparison also catches collinear vertices (< 10mm apart)
+      # along an edge. Should avoid red-flagging such cases. TO DO.
+      log(ERR, "#{id}: < #{TOL}m (#{mth})")                              if bad
+      return false                                                       if bad
+    end
+
+    # Add as many extra tests as needed ...
+    true
+  end
+
+  ##
+  # Add sub surfaces (e.g. windows, doors, skylights) to surface.
+  #
+  # @param model [OpenStudio::Model::Model] a model
+  # @param s [OpenStudio::Model::Surface] a model surface
+  # @param subs [Array] requested sub surface attributes
+  # @param clear [Bool] remove current sub surfaces if true
+  # @param bfr [Double] safety buffer (m), when ~aligned along other edges
+  #
+  # @return [Bool] true if successful (check for logged messages if failures)
+  def addSubs(model = nil, s = nil, subs = [], clear = false, bfr = 0.005)
+    mth = "OSut::#{__callee__}"
+    v   = OpenStudio.openStudioVersion.split(".").join.to_i
+    cl1 = OpenStudio::Model::Model
+    cl2 = OpenStudio::Model::Surface
+    cl3 = Array
+    cl4 = Hash
+    cl5 = Numeric
+    min = 0.050 # minimum ratio value ( 5%)
+    max = 0.950 # maximum ratio value (95%)
+    no  = false
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Exit if mismatched or invalid argument classes.
+    return mismatch("model", model, cl1, mth, DBG, no) unless model.is_a?(cl1)
+    return mismatch("surface",   s, cl2, mth, DBG, no) unless s.is_a?(cl2)
+    return mismatch("subs",   subs, cl3, mth, DBG, no) unless subs.is_a?(cl3)
+    return no                                          unless surface_valid?(s)
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Clear existing sub surfaces if requested.
+    nom = s.nameString
+
+    unless clear == true || clear == false
+      log(WRN, "#{nom}: Keeping existing sub surfaces (#{mth})")
+      clear = false
+    end
+
+    s.subSurfaces.map(&:remove) if clear
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Allowable sub surface types ... & Frame&Divider enabled
+    #   - "FixedWindow"             | true
+    #   - "OperableWindow"          | true
+    #   - "Door"                    | false
+    #   - "GlassDoor"               | true
+    #   - "OverheadDoor"            | false
+    #   - "Skylight"                | false if v < 321
+    #   - "TubularDaylightDome"     | false
+    #   - "TubularDaylightDiffuser" | false
+    type  = "FixedWindow"
+    types = OpenStudio::Model::SubSurface.validSubSurfaceTypeValues
+    stype = s.surfaceType # Wall, RoofCeiling or Floor
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Fetch transform, as if host surface vertices were to "align", i.e.:
+    #   - rotated/tilted ... then flattened along XY plane
+    #   - all Z-axis coordinates ~= 0
+    #   - vertices with the lowest X-axis values are "aligned" along X-axis (0)
+    #   - vertices with the lowest Z-axis values are "aligned" along Y-axis (0)
+    #   - Z-axis values are represented as Y-axis values
+    tr = OpenStudio::Transformation.alignFace(s.vertices)
+
+    # Aligned vertices of host surface, and fetch attributes.
+    aligned = tr.inverse * s.vertices
+    max_x   = aligned.max_by(&:x).x
+    max_y   = aligned.max_by(&:y).y
+    mid_x   = max_x / 2
+    mid_y   = max_y / 2
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Assign default values to certain sub keys (if missing), +more validation.
+    subs.each_with_index do |sub, index|
+      return mismatch("sub", sub, cl4, mth, DBG, no) unless sub.is_a?(cl4)
+
+      # Required key:value pairs (either set by the user or defaulted).
+      sub[:id        ] = ""     unless sub.key?(:id        ) # "Window 007"
+      sub[:type      ] = type   unless sub.key?(:type      ) # "FixedWindow"
+      sub[:count     ] = 1      unless sub.key?(:count     ) # for an array
+      sub[:multiplier] = 1      unless sub.key?(:multiplier)
+      sub[:frame     ] = nil    unless sub.key?(:frame     ) # frame/divider
+      sub[:assembly  ] = nil    unless sub.key?(:assembly  ) # construction
+
+      # Optional key:value pairs.
+      # sub[:ratio     ] # e.g. %FWR
+      # sub[:head      ] # e.g. std 80" door + frame/buffers (+ m)
+      # sub[:sill      ] # e.g. std 30" sill + frame/buffers (+ m)
+      # sub[:height    ] # any sub surface height, below "head" (+ m)
+      # sub[:width     ] # e.g. 1.200 m
+      # sub[:offset    ] # if array (+ m)
+      # sub[:centreline] # left or right of base surface centreline (+/- m)
+      # sub[:r_buffer  ] # buffer between sub/array and right-side corner (+ m)
+      # sub[:l_buffer  ] # buffer between sub/array and left-side corner (+ m)
+
+      sub[:id] = "#{nom}|#{index}" if sub[:id].empty?
+      id       = sub[:id]
+
+      # If sub surface type is invalid, log/reset. Additional corrections may
+      # be enabled once a sub surface is actually instantiated.
+      unless types.include?(sub[:type])
+        log(WRN, "Reset invalid '#{id}' type to '#{type}' (#{mth})")
+        sub[:type] = type
+      end
+
+      # Log/ignore (optional) frame & divider object.
+      unless sub[:frame].nil?
+        if sub[:frame].respond_to?(:frameWidth)
+          sub[:frame] = nil if sub[:type] == "Skylight" && v < 321
+          sub[:frame] = nil if sub[:type] == "Door"
+          sub[:frame] = nil if sub[:type] == "OverheadDoor"
+          sub[:frame] = nil if sub[:type] == "TubularDaylightDome"
+          sub[:frame] = nil if sub[:type] == "TubularDaylightDiffuser"
+          log(WRN, "Skip '#{id}' FrameDivider (#{mth})") if sub[:frame].nil?
+        else
+          sub[:frame] = nil
+          log(WRN, "Skip '#{id}' invalid FrameDivider object (#{mth})")
+        end
+      end
+
+      # The (optional) "assembly" must reference a valid OpenStudio
+      # construction base, to explicitly assign to each instantiated sub
+      # surface. If invalid, log/reset/ignore. Additional checks are later
+      # activated once a sub surface is actually instantiated.
+      unless sub[:assembly].nil?
+        unless sub[:assembly].respond_to?(:isFenestration)
+          log(WRN, "Skip invalid '#{id}' construction (#{mth})")
+          sub[:assembly] = nil
+        end
+      end
+
+      # Log/reset negative numerical values. Set ~0 values to 0.
+      sub.each do |key, value|
+        next if key == :id
+        next if key == :type
+        next if key == :frame
+        next if key == :assembly
+
+        return mismatch(key, value, cl5, mth, DBG, no) unless value.is_a?(cl5)
+        next if key == :centreline
+
+        negative(key, mth, WRN) if value < 0
+        value = 0.0             if value.abs < TOL
+      end
+    end
+
+    # --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- #
+    # Log/reset (or abandon) conflicting user-set geometry key:value pairs:
+    #   :head       e.g. std 80" door + frame/buffers (+ m)
+    #   :sill       e.g. std 30" sill + frame/buffers (+ m)
+    #   :height     any sub surface height, below "head" (+ m)
+    #   :width      e.g. 1.200 m
+    #   :offset     if array (+ m)
+    #   :centreline left or right of base surface centreline (+/- m)
+    #   :r_buffer   buffer between sub/array and right-side corner (+ m)
+    #   :l_buffer   buffer between sub/array and left-side corner (+ m)
+    #
+    # If successful, this will generate sub surfaces and add them to the model.
+    subs.each do |sub|
+      # Set-up unique sub parameters:
+      #   - Frame & Divider "width"
+      #   - minimum "clear glazing" limits
+      #   - buffers, etc.
+      id         = sub[:id]
+      frame      = 0
+      frame      = sub[:frame].frameWidth unless sub[:frame].nil?
+      frames     = 2 * frame
+      buffer     = frame + bfr
+      buffers    = 2 * buffer
+      dim        = 0.200 unless (3 * frame) > 0.200
+      dim        = 3 * frame if (3 * frame) > 0.200
+      glass      = dim - frames
+      min_sill   = buffer
+      min_head   = buffers + glass
+      max_head   = max_y - buffer
+      max_sill   = max_head - (buffers + glass)
+      min_ljamb  = buffer
+      max_ljamb  = max_x - (buffers + glass)
+      min_rjamb  = buffers + glass
+      max_rjamb  = max_x - buffer
+      max_height = max_y - buffers
+      max_width  = max_x - buffers
+
+      # Default sub surface "head" & "sill" height (unless user-specified).
+      typ_head = HEAD # standard 80" door
+      typ_sill = SILL # standard 30" window sill
+
+      if sub.key?(:ratio)
+        typ_head = mid_y * (1 + sub[:ratio])     if sub[:ratio] > 0.75
+        typ_head = mid_y * (1 + sub[:ratio]) unless stype.downcase == "wall"
+        typ_sill = mid_y * (1 - sub[:ratio])     if sub[:ratio] > 0.75
+        typ_sill = mid_y * (1 - sub[:ratio]) unless stype.downcase == "wall"
+      end
+
+      # Log/reset "height" if beyond min/max.
+      if sub.key?(:height)
+        unless sub[:height].between?(glass, max_height)
+          sub[:height] = glass      if sub[:height] < glass
+          sub[:height] = max_height if sub[:height] > max_height
+          log(WRN, "Reset '#{id}' height to #{sub[:height]} m (#{mth})")
+        end
+      end
+
+      # Log/reset "head" height if beyond min/max.
+      if sub.key?(:head)
+        unless sub[:head].between?(min_head, max_head)
+          sub[:head] = max_head if sub[:head] > max_head
+          sub[:head] = min_head if sub[:head] < min_head
+          log(WRN, "Reset '#{id}' head height to #{sub[:head]} m (#{mth})")
+        end
+      end
+
+      # Log/reset "sill" height if beyond min/max.
+      if sub.key?(:sill)
+        unless sub[:sill].between?(min_sill, max_sill)
+          sub[:sill] = max_sill if sub[:sill] > max_sill
+          sub[:sill] = min_sill if sub[:sill] < min_sill
+          log(WRN, "Reset '#{id}' sill height to #{sub[:sill]} m (#{mth})")
+        end
+      end
+
+      # At this point, "head", "sill" and/or "height" have been tentatively
+      # validated (and/or have been corrected) independently from one another.
+      # Log/reset "head" & "sill" heights if conflicting.
+      if sub.key?(:head) && sub.key?(:sill) && sub[:head] < sub[:sill] + glass
+        sill = sub[:head] - glass
+
+        if sill < min_sill
+          sub[:ratio     ] = 0 if sub.key?(:ratio)
+          sub[:count     ] = 0
+          sub[:multiplier] = 0
+          sub[:height    ] = 0 if sub.key?(:height)
+          sub[:width     ] = 0 if sub.key?(:width)
+          log(ERR, "Skip: invalid '#{id}' head/sill combo (#{mth})")
+          next
+        else
+          sub[:sill] = sill
+          log(WRN, "(Re)set '#{id}' sill height to #{sub[:sill]} m (#{mth})")
+        end
+      end
+
+      # Attempt to reconcile "head", "sill" and/or "height". If successful,
+      # all 3x parameters are set (if missing), or reset if invalid.
+      if sub.key?(:head) && sub.key?(:sill)
+        height = sub[:head] - sub[:sill]
+
+        if sub.key?(:height) && (sub[:height] - height).abs > TOL
+          log(WRN, "(Re)set '#{id}' height to #{height} m (#{mth})")
+        end
+
+        sub[:height] = height
+      elsif sub.key?(:head) # no "sill"
+        if sub.key?(:height)
+          sill = sub[:head] - sub[:height]
+
+          if sill < min_sill
+            sill   = min_sill
+            height = sub[:head] - sill
+
+            if height < glass
+              sub[:ratio     ] = 0 if sub.key?(:ratio)
+              sub[:count     ] = 0
+              sub[:multiplier] = 0
+              sub[:height    ] = 0 if sub.key?(:height)
+              sub[:width     ] = 0 if sub.key?(:width)
+              log(ERR, "Skip: invalid '#{id}' head/height combo (#{mth})")
+              next
+            else
+              sub[:sill  ] = sill
+              sub[:height] = height
+              log(WRN, "(Re)set '#{id}' height to #{sub[:height]} m (#{mth})")
+            end
+          else
+            sub[:sill] = sill
+          end
+        else
+          sub[:sill  ] = typ_sill
+          sub[:height] = sub[:head] - sub[:sill]
+        end
+      elsif sub.key?(:sill) # no "head"
+        if sub.key?(:height)
+          head = sub[:sill] + sub[:height]
+
+          if head > max_head
+            head   = max_head
+            height = head - sub[:sill]
+
+            if height < glass
+              sub[:ratio     ] = 0 if sub.key?(:ratio)
+              sub[:count     ] = 0
+              sub[:multiplier] = 0
+              sub[:height    ] = 0 if sub.key?(:height)
+              sub[:width     ] = 0 if sub.key?(:width)
+              log(ERR, "Skip: invalid '#{id}' sill/height combo (#{mth})")
+              next
+            else
+              sub[:head  ] = head
+              sub[:height] = height
+              log(WRN, "(Re)set '#{id}' height to #{sub[:height]} m (#{mth})")
+            end
+          else
+            sub[:head] = head
+          end
+        else
+          sub[:head  ] = typ_head
+          sub[:height] = sub[:head] - sub[:sill]
+        end
+      elsif sub.key?(:height) # neither "head" nor "sill"
+        head = typ_head
+        sill = head - sub[:height]
+
+        if sill < min_sill
+          sill = min_sill
+          head = sill + sub[:height]
+        end
+
+        sub[:head] = head
+        sub[:sill] = sill
+      else
+        sub[:head  ] = typ_head
+        sub[:sill  ] = typ_sill
+        sub[:height] = sub[:head] - sub[:sill]
+      end
+
+      # Log/reset "width" if beyond min/max.
+      if sub.key?(:width)
+        unless sub[:width].between?(glass, max_width)
+          sub[:width] = glass      if sub[:width] < glass
+          sub[:width] = max_width  if sub[:width] > max_width
+          log(WRN, "Reset '#{id}' width to #{sub[:width]} m (#{mth})")
+        end
+      end
+
+      # Log/reset "count" if < 1.
+      if sub.key?(:count)
+        if sub[:count] < 1
+          sub[:count] = 1
+          log(WRN, "Reset '#{id}' count to #{sub[:count]} (#{mth})")
+        end
+      end
+
+      sub[:count] = 1 unless sub.key?(:count)
+
+      # Log/reset if left-sided buffer under min jamb position.
+      if sub.key?(:l_buffer)
+        if sub[:l_buffer] < min_ljamb
+          sub[:l_buffer] = min_ljamb
+          log(WRN, "Reset '#{id}' left buffer to #{sub[:l_buffer]} m (#{mth})")
+        end
+      end
+
+      # Log/reset if right-sided buffer beyond max jamb position.
+      if sub.key?(:r_buffer)
+        if sub[:r_buffer] > max_rjamb
+          sub[:r_buffer] = min_rjamb
+          log(WRN, "Reset '#{id}' right buffer to #{sub[:r_buffer]} m (#{mth})")
+        end
+      end
+
+      centre  = mid_x
+      centre += sub[:centreline] if sub.key?(:centreline)
+      n       = sub[:count     ]
+      h       = sub[:height    ] + frames
+      w       = 0 # overall width of sub(s) bounding box (to calculate)
+      x0      = 0 # left-side X-axis coordinate of sub(s) bounding box
+      xf      = 0 # right-side X-axis coordinate of sub(s) bounding box
+
+      # Log/reset "offset", if conflicting vs "width".
+      if sub.key?(:ratio)
+        if sub[:ratio] < TOL
+          sub[:ratio     ] = 0
+          sub[:count     ] = 0
+          sub[:multiplier] = 0
+          sub[:height    ] = 0 if sub.key?(:height)
+          sub[:width     ] = 0 if sub.key?(:width)
+          log(ERR, "Skip: '#{id}' ratio ~0 (#{mth})")
+          next
+        end
+
+        # Log/reset if "ratio" beyond min/max?
+        unless sub[:ratio].between?(min, max)
+          sub[:ratio] = min if sub[:ratio] < min
+          sub[:ratio] = max if sub[:ratio] > max
+          log(WRN, "Reset ratio (min/max) to #{sub[:ratio]} (#{mth})")
+        end
+
+        # Log/reset "count" unless 1.
+        unless sub[:count] == 1
+          sub[:count] = 1
+          log(WRN, "Reset count (ratio) to 1 (#{mth})")
+        end
+
+        area  = s.grossArea * sub[:ratio] # sub m2, including (optional) frames
+        w     = area / h
+        width = w - frames
+        x0    = centre - w/2
+        xf    = centre + w/2
+
+        if sub.key?(:l_buffer)
+          if sub.key?(:centreline)
+            log(WRN, "Skip #{id} left buffer (vs centreline) (#{mth})")
+          else
+            x0     = sub[:l_buffer] - frame
+            xf     = x0 + w
+            centre = x0 + w/2
+          end
+        elsif sub.key?(:r_buffer)
+          if sub.key?(:centreline)
+            log(WRN, "Skip #{id} right buffer (vs centreline) (#{mth})")
+          else
+            xf     = max_x - sub[:r_buffer] + frame
+            x0     = xf - w
+            centre = x0 + w/2
+          end
+        end
+
+        # Too wide?
+        if x0 < min_ljamb || xf > max_rjamb
+          sub[:ratio     ] = 0 if sub.key?(:ratio)
+          sub[:count     ] = 0
+          sub[:multiplier] = 0
+          sub[:height    ] = 0 if sub.key?(:height)
+          sub[:width     ] = 0 if sub.key?(:width)
+          log(ERR, "Skip: invalid (ratio) width/centreline (#{mth})")
+          next
+        end
+
+        if sub.key?(:width) && (sub[:width] - width).abs > TOL
+          sub[:width] = width
+          log(WRN, "Reset width (ratio) to #{sub[:width]} (#{mth})")
+        end
+
+        sub[:width] = width unless sub.key?(:width)
+      else
+        unless sub.key?(:width)
+          sub[:ratio     ] = 0 if sub.key?(:ratio)
+          sub[:count     ] = 0
+          sub[:multiplier] = 0
+          sub[:height    ] = 0 if sub.key?(:height)
+          sub[:width     ] = 0 if sub.key?(:width)
+          log(ERR, "Skip: missing '#{id}' width (#{mth})")
+          next
+        end
+
+        width  = sub[:width] + frames
+        gap    = (max_x - n * width) / (n + 1)
+        gap    = sub[:offset] - width if sub.key?(:offset)
+        gap    = 0                    if gap < bfr
+        offset = gap + width
+
+        if sub.key?(:offset) && (offset - sub[:offset]).abs > TOL
+          sub[:offset] = offset
+          log(WRN, "Reset sub offset to #{sub[:offset]} m (#{mth})")
+        end
+
+        sub[:offset] = offset unless sub.key?(:offset)
+
+        # Overall width (including frames) of bounding box around array.
+        w  = n * width + (n - 1) * gap
+        x0 = centre - w/2
+        xf = centre + w/2
+
+        if sub.key?(:l_buffer)
+          if sub.key?(:centreline)
+            log(WRN, "Skip #{id} left buffer (vs centreline) (#{mth})")
+          else
+            x0     = sub[:l_buffer] - frame
+            xf     = x0 + w
+            centre = x0 + w/2
+          end
+        elsif sub.key?(:r_buffer)
+          if sub.key?(:centreline)
+            log(WRN, "Skip #{id} right buffer (vs centreline) (#{mth})")
+          else
+            xf     = max_x - sub[:r_buffer] + frame
+            x0     = xf - w
+            centre = x0 + w/2
+          end
+        end
+
+        # Too wide?
+        if x0 < bfr || xf > max_x - bfr
+          sub[:ratio     ] = 0 if sub.key?(:ratio)
+          sub[:count     ] = 0
+          sub[:multiplier] = 0
+          sub[:height    ] = 0 if sub.key?(:height)
+          sub[:width     ] = 0 if sub.key?(:width)
+          log(ERR, "Skip: invalid array width/centreline (#{mth})")
+          next
+        end
+      end
+
+      # Initialize left-side X-axis coordinate of only/first sub.
+      pos = x0 + frame
+
+      # Generate sub(s).
+      sub[:count].times do |i|
+        name = "#{id}:#{i}"
+        fr   = 0
+        fr   = sub[:frame].frameWidth if sub[:frame]
+
+        vec  = OpenStudio::Point3dVector.new
+        vec << OpenStudio::Point3d.new(pos,               sub[:head], 0)
+        vec << OpenStudio::Point3d.new(pos,               sub[:sill], 0)
+        vec << OpenStudio::Point3d.new(pos + sub[:width], sub[:sill], 0)
+        vec << OpenStudio::Point3d.new(pos + sub[:width], sub[:head], 0)
+        vec = tr * vec
+
+        # Log/skip if conflict between individual sub and base surface.
+        vc = vec
+        vc = offset(vc, fr, 300) if fr > 0
+        ok = fits?(vc, s.vertices, name, nom)
+        log(ERR, "Skip '#{name}': won't fit in '#{nom}' (#{mth})") unless ok
+        break                                                      unless ok
+
+        # Log/skip if conflicts with existing subs (even if same array).
+        s.subSurfaces.each do |sb|
+          nome = sb.nameString
+          fd   = sb.windowPropertyFrameAndDivider
+          fr   = 0                     if fd.empty?
+          fr   = fd.get.frameWidth unless fd.empty?
+          vk   = sb.vertices
+          vk   = offset(vk, fr, 300) if fr > 0
+          oops = overlaps?(vc, vk, name, nome)
+          log(ERR, "Skip '#{name}': overlaps '#{nome}' (#{mth})") if oops
+          ok = false                                              if oops
+          break                                                   if oops
+        end
+
+        break unless ok
+
+        sb = OpenStudio::Model::SubSurface.new(vec, model)
+        sb.setName(name)
+        sb.setSubSurfaceType(sub[:type])
+        sb.setConstruction(sub[:assembly])               if sub[:assembly]
+        ok = sb.allowWindowPropertyFrameAndDivider
+        sb.setWindowPropertyFrameAndDivider(sub[:frame]) if sub[:frame] && ok
+        sb.setMultiplier(sub[:multiplier])               if sub[:multiplier] > 1
+        sb.setSurface(s)
+
+        # Reset "pos" if array.
+        pos += sub[:offset] if sub.key?(:offset)
+      end
+    end
+
+    true
+  end
+
   ##
   # Callback when other modules extend OSlg
   #

data/lib/osut/version.rb

@@ -1,6 +1,6 @@
 # BSD 3-Clause License
 #
-# Copyright (c) 2022, Denis Bourgeois
+# Copyright (c) 2022-2023, Denis Bourgeois
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -29,5 +29,5 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 module OSut
-  VERSION = "0.2.7".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/osut.rb

@@ -1,6 +1,6 @@
 # BSD 3-Clause License
 #
-# Copyright (c) 2022, Denis Bourgeois
+# Copyright (c) 2022-2023, Denis Bourgeois
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: osut
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors:
 - Denis Bourgeois
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-21 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oslg
@@ -90,7 +90,7 @@ licenses:
 - BSD-3-Clause
 metadata:
   homepage_uri: https://github.com/rd2/osut
-  source_code_uri: https://github.com/rd2/osut/tree/v0.2.7
+  source_code_uri: https://github.com/rd2/osut/tree/v0.3.0
   bug_tracker_uri: https://github.com/rd2/osut/issues
 post_install_message:
 rdoc_options: []