pulo 0.1.1 → 0.1.2

data/lib/pulo/frames/frame_column.rb

@@ -0,0 +1,149 @@
+require 'descriptive_statistics'
+
+module Pulo
+  class FrameColumn
+
+    attr_reader :name,:formula, :formatter, :column_class, :column_unit
+    attr_accessor :width
+
+    def initialize(name,parent_frame,hidden,&formula)
+      @name=name
+      @parent_frame=parent_frame
+      @formula=formula
+      @cells=[]
+      #@recalc_required=block_given?
+      @value_column=!block_given?
+      @standard_formatter=lambda {|v| v.to_s }
+      @formatter=@standard_formatter
+      @hidden=hidden
+      @width=3
+      @column_class=NilClass
+      @column_unit=NilClass
+    end
+
+    def set_formula &formula
+      @formula=formula
+      #@recalc_required=true
+      @value_column=false
+    end
+
+    def column_number
+      @parent_frame.column_names[@name]
+    end
+
+    def column_class= (klass)
+      @column_class=klass
+      if @column_class.respond_to?(:quantity_name) and @formatter==@standard_formatter
+        @formatter=lambda {|q| q.to_s(nil,true)}
+      end
+    end
+    def column_unit=(klass)
+      @column_unit=klass
+    end
+    def formatter= (lamb)
+      @formatter=lamb
+    end
+    def hidden?
+      @hidden
+    end
+    def hidden=value
+      @hidden=value
+    end
+    def name= new_name
+      if @parent_frame.column_names[new_name]
+        @name=new_name
+      else
+        @parent_frame.rename_column @name,new_name
+      end
+    end
+
+    def append_row(cell)
+      @cells<<cell
+    end
+    def insert_row(row_no,cell)
+      @cells.insert(row_no,cell)
+    end
+
+    def values=(vals)
+      raise ArgumentError,"Wrong number of values given for column - need an array of #{@cells.count}" unless vals.count==@cells.count
+      vals.each_with_index do |val,index|
+        @cells[index].value=val
+      end
+    end
+
+    def recalc with_timing=false
+      t_start=Time.now
+
+      @column_class=NilClass
+      @parent_frame.rows.each do |row|
+        begin
+          row[column_number].value=@formula.call(row)
+          row[column_number].unset_error
+        rescue Exception => e
+          #raise "Exception '#{e}' occured calculating column: #{@name} row: #{row.row_number}"
+          warn "Warning! Exception '#{e}' occured calculating column: #{@name} row: #{row.row_number}"
+          row[column_number].set_error
+        end
+      end
+
+      if with_timing
+        puts "Recalc column '#{@name}' in: #{((Time.now-t_start)*1000).to_i} ms."
+      end
+    end
+
+    def [](index)
+      raise IndexError,"No row number #{index} defined." unless @cells[index]
+      @cells[index]
+    end
+
+    def lookup(value)
+      (@cells.find_all {|cell| cell.value==value}).map {|cell| cell.row}
+    end
+
+    def map!(&block)
+      @cells.each {|cell| cell.value=block.call(cell.value)}
+    end
+
+    def to_a
+      @cells.map {|cell| cell.value}
+    end
+
+    def value_column?
+      @value_column
+    end
+
+    def recalc_width
+      @width=@cells.take(30).map {|c| c.to_s.length}.max
+      @width||=0
+      @width=[@width,@name.length].max
+      @width=[@width,column_class.to_s.length+1].max
+    end
+
+    def to_s
+      "#{@name}: #{(@cells.map {|c| c.to_s}).join(', ')}"
+    end
+    def inspect
+      "Frame Column Object"
+    end
+
+    def descriptive_statistics
+      vals=self.to_a
+      if @column_class.respond_to?(:quantity_name)
+        vals=vals.map{|val| val.send(@column_unit.name).value}
+      end
+      stats=vals.descriptive_statistics
+      if @column_class.respond_to?(:quantity_name)
+        stats.map{|val|
+
+          if val[0]!=:number
+            [val[0],@column_class.new(val[1],@column_unit)]
+          else
+            [val[0],val[1]]
+          end
+
+        }.to_h
+      end
+    end
+
+  end
+end

data/lib/pulo/frames/frame_row.rb

@@ -0,0 +1,87 @@
+module Pulo
+  class FrameRow
+    attr_reader :cells
+    attr_accessor :row_number
+    def initialize(parent_frame, row_number)
+      @cells=[]
+      @parent_frame=parent_frame
+      @row_number=row_number
+    end
+
+    def append_column(cell)
+      @cells<<cell
+    end
+
+    def delete_column(index)
+      @cells.delete_at index
+    end
+
+    def [](column)
+      if column.is_a?(Integer)
+        raise IndexError,"No column number #{column} defined." unless @cells[column]
+        @cells[column]
+      else
+        @parent_frame[column][@row_number]
+      end
+    end
+
+    def previous_rows
+      Enumerator.new do |y|
+        for i in (0..(@row_number-1)).reverse_each
+          y.yield @parent_frame.rows[i]
+        end
+      end
+    end
+
+    def next_rows
+      Enumerator.new do |y|
+        for i in (@row_number+1)..@parent_frame.row_count-1
+          y.yield @parent_frame.rows[i]
+        end
+      end
+    end
+
+    def previous_row
+      if @row_number>0
+        @parent_frame.rows[@row_number-1]
+      else
+        nil
+      end
+    end
+
+    def next_row
+      if @row_number<@parent_frame.row_count
+        @parent_frame.rows[@row_number+1]
+      else
+        nil
+      end
+    end
+
+    def to_s
+      "row #{@row_number}:".ljust(9,' ') + " #{((@cells.select {|s| !s.column.hidden?}).map {|c| c.to_s}).join('  ')}"
+    end
+    def inspect
+      "Frame Row Object"
+    end
+
+    def to_a
+      @cells.map {|cell| cell.value}
+    end
+
+    def to_a_values
+      value_cells.map {|cell| cell.value}
+    end
+
+    def value_cells
+      @cells.find_all { |cell| cell.value_column?}
+    end
+
+    def to_h
+      Hash[@parent_frame.column_names.keys.to_a.zip(to_a)]
+    end
+
+    def first_row?
+      @row_number==0
+    end
+  end
+end

data/lib/pulo/helpers.rb

@@ -0,0 +1 @@
+# encoding: utf-8

data/lib/pulo/machine/hydraulics/pipe.rb

@@ -0,0 +1,71 @@
+module Pulo
+
+  class PipeTypes
+  attr_reader :pipe_types
+  def initialize
+    pipe_groups={
+        uPvc: {Chw: 150, density: Density.kilograms_per_cubic_meter(1800), unit_length: Length.meters(6)}
+    }
+    @pipe_types={
+        class6_160: {group: :uPvc, od: Length.millimeters(160.0), id: Length.millimeters(153.6), unit_cost: Value.dollars(50)},
+        class6_200: {group: :uPvc, od: Length.millimeters(200.0), id: Length.millimeters(192.2), unit_cost: Value.dollars(78)},
+        class6_250: {group: :uPvc, od: Length.millimeters(250.0), id: Length.millimeters(242.0), unit_cost: Value.dollars(105)},
+        class6_315: {group: :uPvc, od: Length.millimeters(315.0), id: Length.millimeters(302.6), unit_cost: Value.dollars(232)},
+        class6_355: {group: :uPvc, od: Length.millimeters(355.0), id: Length.millimeters(341.0), unit_cost: Value.dollars(326)},
+        class6_400: {group: :uPvc, od: Length.millimeters(400.0), id: Length.millimeters(384.4), unit_cost: Value.dollars(440)},
+        class6_450: {group: :uPvc, od: Length.millimeters(450.0), id: Length.millimeters(428.8), unit_cost: Value.dollars(610)},
+        class6_500: {group: :uPvc, od: Length.millimeters(500.0), id: Length.millimeters(476.4), unit_cost: Value.dollars(750)}
+    }
+    @pipe_types.values.each do |pt|
+      pt.merge!(pipe_groups[pt[:group]])
+    end
+  end
+end
+
+
+  class Pipeline
+
+  attr_reader :inside_cylinder,:outside_cylinder,:length
+  attr_reader :wall_thickness, :wall_area, :wall_volume,  :mass
+  attr_reader :pipe_type
+  attr_reader :wall_density
+  attr_reader :inlet_pressure,:outlet_pressure, :flow
+  attr_reader :friction_gradient, :static_head, :friction_head, :total_head, :flow_velocity, :hydraulic_power
+  attr_reader :cost
+
+  def initialize(args)
+
+    @pipe_type_ref=args[:pipe]
+    @pipe_type=PipeTypes.new().pipe_types[@pipe_type_ref]
+
+    @length=args[:length]
+    @cost=@length*@pipe_type[:unit_cost]/@pipe_type[:unit_length]
+    @inside_cylinder=Cylinder.new(diameter: @pipe_type[:id], length: @length)
+    @outside_cylinder=Cylinder.new(diameter: @pipe_type[:od], length: @length)
+    @wall_thickness=@outside_cylinder.radius-@inside_cylinder.radius
+    @wall_area=@outside_cylinder.area-@inside_cylinder.area
+    @wall_volume=@outside_cylinder.volume-@inside_cylinder.volume
+    @mass=@wall_volume*@pipe_type[:density]
+
+    args[:static_head] ? @static_head=args[:static_head] : @static_head=Length.meters(0)
+    args[:inlet_pressure] ? @inlet_pressure=args[:inlet_pressure] : @inlet_pressure=Pressure.pascals(0)
+    args[:outlet_pressure] ? @outlet_pressure=args[:outlet_pressure] : @outlet_pressure=Pressure.pascals(0)
+    @pressure_head=(@outlet_pressure-@inlet_pressure)/(Water.standard_density*Acceleration.standard_gravity)
+  end
+
+  def flow=(val)
+    @flow=val
+    @flow_velocity=@flow/inside_cylinder.area
+    head_for_flow()
+    @hydraulic_power=((@flow*Water.standard_density)*Acceleration.standard_gravity)*@total_head
+  end
+
+  def head_for_flow()
+    k=(@pipe_type[:Chw]**1.85)*@inside_cylinder.face.diameter.meters.value**4.87
+    @friction_gradient=Dimensionless.n(10.67*@flow.cubic_meter_per_second.value**1.85/k)
+    @friction_head=@length * @friction_gradient
+    @total_head=@friction_head+@static_head+@pressure_head
+  end
+end
+
+end

data/lib/pulo/machine/machines.rb

@@ -0,0 +1,10 @@
+require_relative './steam/water_steam'
+require_relative './steam/boiler'
+require_relative './steam/deaerator'
+require_relative './steam/boiler_deaerator'
+require_relative './steam/desuperheater'
+require_relative './steam/header'
+require_relative './steam/steam_process'
+require_relative './steam/steam_turbine'
+
+require_relative './mechanics/moments_of_inertia'

data/lib/pulo/machine/mechanics/moments_of_inertia.rb

@@ -0,0 +1,64 @@
+module Pulo
+  class MomentOfInertia
+    def self.point_mass(mass, distance)
+      mass*distance**2
+    end
+
+    #rod around its mid point
+    def self.rod(mass, length)
+      (mass*distance**2)/12.0
+    end
+
+    #rod around its mid point
+    def self.rod_end(mass, length)
+      (mass*length**2)/3.0
+    end
+
+    #hoop
+    def self.hoop(mass, radius)
+      (mass*radius**2)/2.0
+    end
+
+    #disc
+    def self.disc(mass, radius)
+      (mass*radius**2)/4.0
+    end
+
+    #cylindrical shell on its axis
+    def self.cylindrical_shell(mass, radius)
+      (mass*radius**2)
+    end
+
+    def self.cylinder(mass, radius, height)
+      (3*radius**2+height**2)*mass/12.0
+    end
+
+    def self.tube(mass, inner_radius,outer_radius)
+      (inner_radius**2+outer_radius**2)*mass/2.0
+    end
+
+    def self.spherical_shell(mass, radius)
+      (2*mass*radius**2)/3.0
+    end
+
+    def self.sphere(mass, radius)
+      (2*mass*radius**2)/5.0
+    end
+
+    def self.thick_spherical_shell(mass, inner_radius,outer_radius)
+      ((outer_radius**5-inner_radius**5)/(outer_radius**3-inner_radius**3))*(2*mass/5)
+    end
+
+    def self.cone(mass, radius, height)
+      (radius**2+4*height**2)*(3*mass/20)
+    end
+
+    #cuboid or plate of arbitrary depth (in direction of axis of rotation)
+    def self.cuboid(mass, width, height)
+      (height**2+width**2)*(mass/12)
+    end
+
+
+
+  end
+end

data/lib/pulo/machine/steam/boiler.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module Pulo
+  module Steam
+    class Boiler
+      attr_reader :feedwater, :steam, :blowdown
+      attr_reader :blowdown_rate, :combustion_efficiency
+      attr_reader :boiler_power, :fuel_power
+
+      def initialize(feedwater_pressure: nil,blowdown_rate: nil,combustion_efficiency:nil,steam_pressure: nil,
+                     steam_temperature: nil,fuel_power: nil,
+                     steam_massflow: nil,feedwater_massflow: nil)
+
+        raise "Need all parameters" unless
+            feedwater_pressure && blowdown_rate &&
+            combustion_efficiency && steam_pressure &&
+            (steam_temperature || fuel_power) &&
+            (steam_massflow || feedwater_massflow)
+
+        #steam_massflow=steam_massflow
+        @blowdown_rate=blowdown_rate
+        @combustion_efficiency=combustion_efficiency
+        @steam_temperature=steam_temperature
+        @feedwater_pressure=feedwater_pressure
+        @steam_pressure=steam_pressure
+        @fuel_power=fuel_power
+        #feedwater_massflow=feedwater_massflow
+
+        @blowdown=WaterSteam.new(pressure: @steam_pressure, quality: Dimensionless.new(0))
+        if steam_massflow
+          feedwater_massflow=steam_massflow/(1-@blowdown_rate)
+        else
+          steam_massflow=feedwater_massflow*(1-@blowdown_rate)
+        end
+
+        @blowdown.mass_flow=feedwater_massflow*@blowdown_rate
+        #@blowdown_power=@blowdown.specific_enthalpy*@blowdown_massflow
+
+        @feedwater=WaterSteam.new(pressure: @feedwater_pressure, quality: Dimensionless.new(0))
+        @feedwater.mass_flow=feedwater_massflow
+        #@feedwater_power=@feedwater.specific_enthalpy*@feedwater_massflow
+
+
+        if @steam_temperature
+          @steam=WaterSteam.new(pressure: @steam_pressure, temperature: @steam_temperature)
+          @steam.mass_flow=steam_massflow
+          #@steam_power=@steam.specific_enthalpy*@steam_massflow
+          @boiler_power=@steam.energy_flow + @blowdown.energy_flow - @feedwater.energy_flow
+          @fuel_power=@boiler_power/@combustion_efficiency
+        else
+          @boiler_power=@fuel_power*@combustion_efficiency
+          steam_power=@boiler_power-@blowdown.energy_flow+@feedwater.energy_flow
+          specific_enthalpy=steam_power/steam_massflow
+          @steam=WaterSteam.new(pressure: @steam_pressure, specific_enthalpy: specific_enthalpy)
+          @steam.mass_flow=steam_massflow
+          raise "Boiler not boiling!" if @steam.if97_region=="1"
+        end
+      end
+    end
+  end
+end