Module: BTAP::Resources::HVAC::Plant

Defined in:
lib/openstudio-standards/btap/hvac.rb

Defined Under Namespace

Classes: PlantTests

Class Method Summary collapse

Class Method Details

.add_1speed_cooling_tower(model) ⇒ Object

Create a one speed cooling tower. This routine does not attach cooling tower to condenser loop



501
502
503
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 501

def self.add_1speed_cooling_tower(model)
  return OpenStudio::Model::CoolingTowerSingleSpeed.new(model)
end

.add_adiabatic_pipe(model) ⇒ Object

Create new adiabatic pipe



470
471
472
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 470

def self.add_adiabatic_pipe(model)
  return OpenStudio::Model::PipeAdiabatic.new(model);
end

.add_air_loop(model) ⇒ Object

Add a new air loop to the model.



266
267
268
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 266

def self.add_air_loop(model)
  return OpenStudio::Model::AirLoopHVAC.new(model);
end

.add_biquad_curve(model) ⇒ Object

Create a new biquadratic performance curve



281
282
283
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 281

def self.add_biquad_curve(model)
  return OpenStudio::Model::CurveBiquadratic.new(model);
end

.add_boiler_hot_water_to_water_loop(model, water_loop, fuel_type = "NaturalGas") ⇒ Object

Add a hot water boiler to a water loop



199
200
201
202
203
204
205
206
207
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 199

def self.add_boiler_hot_water_to_water_loop(model,water_loop,fuel_type = "NaturalGas" )
  raise("Invalid Fuel Type #{fuel_type} entered. Please use the following valid entries #{OpenStudio::Model::BoilerHotWater::validFuelTypeValues()}") unless  OpenStudio::Model::BoilerHotWater::validFuelTypeValues().include?(fuel_type)
  #get default boiler from
  boiler = BTAP::OpenStudioLibrary.instance.library.getBoilerHotWaterByName("OS:Boiler:HotWater 1").get
  #clone object from library into current model.
  new_boiler = boiler.clone(model).to_BoilerHotWater.get
  water_loop.addSupplyBranchForComponent(new_boiler)
  return boiler
end

.add_chiller_electric_eir_to_water_loop(model, water_loop) ⇒ Object

Add a chiller to a water loop



221
222
223
224
225
226
227
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 221

def self.add_chiller_electric_eir_to_water_loop(model,water_loop )
  library_chiller = BTAP::OpenStudioLibrary.instance.library.getChillerElectricEIRByName("OS:Chiller:Electric:EIR 1").get
  #clone object fron library into current model.
  new_chiller = library_chiller.clone(model).to_ChillerElectricEIR.get
  water_loop.addSupplyBranchForComponent(new_chiller)
  return new_chiller
end

.add_const_fan(model, avail_sched) ⇒ Object

Add a new constant volume fan



271
272
273
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 271

def self.add_const_fan(model,avail_sched)
  return OpenStudio::Model::FanConstantVolume.new(model,avail_sched);
end

.add_cooling_tower_to_water_loop(model, water_loop) ⇒ Object

Add a cooling tower to a water loop



211
212
213
214
215
216
217
218
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 211

def self.add_cooling_tower_to_water_loop(model,water_loop )

  tower = BTAP::OpenStudioLibrary.instance.library.getCoolingTowerSingleSpeedByName("OS:CoolingTower:SingleSpeed 1").get
  #clone object fron library into current model.
  new_tower = tower.clone(model).to_CoolingTowerSingleSpeed.get
  water_loop.addSupplyBranchForComponent(new_tower)
  return tower
end

.add_cubic_curve(model) ⇒ Object

Create a new cubic curve



291
292
293
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 291

def self.add_cubic_curve(model)
  return OpenStudio::Model::CurveCubic.new(model);
end

.add_diffuser(model, avail_sched) ⇒ Object

Create a new diffuser



453
454
455
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 453

def self.add_diffuser(model, avail_sched)
  return OpenStudio::Model::AirTerminalSingleDuctUncontrolled.new(model,avail_sched);
end

.add_district_cooling_to_water_loop(model, water_loop) ⇒ Object

Add a district cooling to a water loop



238
239
240
241
242
243
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 238

def self.add_district_cooling_to_water_loop(model,water_loop )
  des = OpenStudio::Model::DistrictCooling.new(model)
  des.setNominalCapacity(1000000)
  water_loop.addSupplyBranchForComponent(des)
  return des
end

.add_district_heating_to_water_loop(model, water_loop) ⇒ Object

Add a district heating to a water loop



230
231
232
233
234
235
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 230

def self.add_district_heating_to_water_loop(model,water_loop )
  des = OpenStudio::Model::DistrictHeating.new(model);
  des.setNominalCapacity(1000000)
  water_loop.addSupplyBranchForComponent(des)
  return des
end

.add_economizer(model, air_loop, setEconomizerControlType = "FixedDryBulb", setEconomizerControlActionType = "ModulateFlow", setEconomizerMaximumLimitDryBulbTemperature = 28.0, setEconomizerMaximumLimitEnthalpy = 64000, setEconomizerMaximumLimitDewpointTemperature = 0.0, setEconomizerMinimumLimitDryBulbTemperature = -100.0) ⇒ Object 



579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 579

def self.add_economizer(
    model,
    air_loop,
    setEconomizerControlType = "FixedDryBulb",
    setEconomizerControlActionType = "ModulateFlow",
    setEconomizerMaximumLimitDryBulbTemperature = 28.0,
    setEconomizerMaximumLimitEnthalpy = 64000,
    setEconomizerMaximumLimitDewpointTemperature = 0.0,
    setEconomizerMinimumLimitDryBulbTemperature = -100.0
  )
  #Check to see if ERV can be applied. If there is no OA system, return false.
  oa_system = nil
  air_loop.supplyComponents.each do |supply_component|
    oa_system = supply_component.to_AirLoopHVACOutdoorAirSystem.get unless supply_component.to_AirLoopHVACOutdoorAirSystem.empty?
  end
  return false if oa_system.nil?
  #get ControllerOutdoorAir
  controller_oa = oa_system.getControllerOutdoorAir


  #set economizer to the requested control type
  controller_oa.setEconomizerControlType(setEconomizerControlType)

  #set economizer to control action type. Either "ModulateFlow" or "MinimumFlowWithBypass"
  controller_oa.setEconomizerControlActionType(setEconomizerControlActionType)

  #set maximum limit drybulb temperature
  controller_oa.setEconomizerMaximumLimitDryBulbTemperature(setEconomizerMaximumLimitDryBulbTemperature)

  #set maximum limit enthalpy
  controller_oa.setEconomizerMaximumLimitEnthalpy(setEconomizerMaximumLimitEnthalpy)

  #set maximum limit dewpoint temperature
  controller_oa.setEconomizerMaximumLimitDewpointTemperature(setEconomizerMaximumLimitDewpointTemperature)

  #set minimum limit drybulb temperature
  controller_oa.setEconomizerMinimumLimitDryBulbTemperature(setEconomizerMinimumLimitDryBulbTemperature)
  return controller_oa
end

.add_elec_baseboard(model) ⇒ Object

Create an electric baseboard



485
486
487
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 485

def self.add_elec_baseboard(model)
  return OpenStudio::Model::ZoneHVACBaseboardConvectiveElectric.new(model)
end

.add_elec_chiller(model, clg_cap_f_of_temp, eir_f_of_avail_to_nom_cap, eir_f_of_plr) ⇒ Object

Create an electric chiller. This differs from add_chiller_electric_eir_to_water_loop in that it does not connect the chiller to a water loop



491
492
493
494
495
496
497
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 491

def self.add_elec_chiller(model,clg_cap_f_of_temp,
    eir_f_of_avail_to_nom_cap,
    eir_f_of_plr)
  return OpenStudio::Model::ChillerElectricEIR.new(model,clg_cap_f_of_temp,
    eir_f_of_avail_to_nom_cap,
    eir_f_of_plr)
end

.add_elec_heating_coil(model, avail_sched) ⇒ Object

Create a new electric heating coil



475
476
477
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 475

def self.add_elec_heating_coil(model, avail_sched)
  return OpenStudio::Model::CoilHeatingElectric.new(model,avail_sched)
end

.add_erv(model, air_loop, autosizeNominalSupplyAirFlowRate = true, setNominalSupplyAirFlowRate = nil, setHeatExchangerType = 'Plate', setSensibleEffectivenessat100CoolingAirFlow = 0.76, setSensibleEffectivenessat75CoolingAirFlow = 0.81, setLatentEffectiveness100Cooling = 0.68, setLatentEffectiveness75Cooling = 0.73, setSensibleEffectiveness100Heating = 0.76, setSensibleEffectiveness75Heating = 0.81, setLatentEffectiveness100Heating = 0.68, setLatentEffectiveness75Heating = 0.73, setSupplyAirOutletTemperatureControl = true, setFrostControlType = 'None', setThresholdTemperature = 1.7, setInitialDefrostTimeFraction = 0.0, nominal_electric_power = 0.0, setEconomizerLockout = true) ⇒ Object

Adds an ERV to an airloop. Returns false if not possible.



511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 511

def self.add_erv(
    model,
    air_loop,
    autosizeNominalSupplyAirFlowRate = true,
    setNominalSupplyAirFlowRate = nil,
    setHeatExchangerType = 'Plate', # 'Rotary' or 'Plate'
    setSensibleEffectivenessat100CoolingAirFlow = 0.76,
    setSensibleEffectivenessat75CoolingAirFlow  = 0.81,
    setLatentEffectiveness100Cooling = 0.68,
    setLatentEffectiveness75Cooling = 0.73,
    setSensibleEffectiveness100Heating = 0.76,
    setSensibleEffectiveness75Heating = 0.81,
    setLatentEffectiveness100Heating = 0.68,
    setLatentEffectiveness75Heating = 0.73,
    setSupplyAirOutletTemperatureControl = true,
    setFrostControlType = 'None', # 'None', 'ExhaustAirRecirculation','ExhaustOnly','MinimumExhaustTemperature'
    setThresholdTemperature  = 1.7,
    setInitialDefrostTimeFraction = 0.0,
    nominal_electric_power = 0.0,
    setEconomizerLockout = true
  )

  #Check to see if ERV can be applied. If there is no OA system, return false.
  oa_system = nil
  air_loop.supplyComponents.each do |supply_component|
    oa_system = supply_component.to_AirLoopHVACOutdoorAirSystem.get unless supply_component.to_AirLoopHVACOutdoorAirSystem.empty?
  end
  return false if oa_system.nil?

  #Check to see if there is already an ERV.
  erv = nil
  air_loop.supplyComponents.each do |supply_component|
    erv = supply_component.to_HeatExchangerAirToAirSensibleAndLatent.get unless supply_component.to_HeatExchangerAirToAirSensibleAndLatent.empty?
  end
  #if no HRV, create one.
  if erv.nil?
    erv = OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.new(model)
    oa_node = oa_system.outboardOANode
    erv.addToNode(oa_node.get)
  end
  erv.setNominalSupplyAirFlowRate == setNominalSupplyAirFlowRate unless setNominalSupplyAirFlowRate.nil?
  erv.autosizeNominalSupplyAirFlowRate() if  autosizeNominalSupplyAirFlowRate == true
  raise("setHeatExchangerType for erv not correct") unless erv.setHeatExchangerType(setHeatExchangerType)
  raise("setSensibleEffectivenessat100CoolingAirFlow for erv not correct")  unless  erv.setSensibleEffectivenessat100CoolingAirFlow(setSensibleEffectivenessat100CoolingAirFlow)
  raise("setSensibleEffectivenessat75CoolingAirFlow for erv not correct")  unless  erv.setSensibleEffectivenessat75CoolingAirFlow(setSensibleEffectivenessat75CoolingAirFlow)
  raise("setLatentEffectivenessat100CoolingAirFlow for erv not correct")  unless  erv.setLatentEffectivenessat100CoolingAirFlow(setLatentEffectiveness100Cooling)
  raise("setLatentEffectivenessat75CoolingAirFlow for erv not correct")  unless  erv.setLatentEffectivenessat75CoolingAirFlow(setLatentEffectiveness75Cooling)
  raise("setSensibleEffectivenessat100HeatingAirFlow for erv not correct") unless  erv.setSensibleEffectivenessat100HeatingAirFlow(setSensibleEffectiveness100Heating)
  raise("setSensibleEffectivenessat75HeatingAirFlow for erv not correct")  unless  erv.setSensibleEffectivenessat75HeatingAirFlow(setSensibleEffectiveness75Heating)
  raise("setLatentEffectivenessat100HeatingAirFlow for erv not correct")  unless  erv.setLatentEffectivenessat100HeatingAirFlow(setLatentEffectiveness100Heating)
  raise("setLatentEffectivenessat75HeatingAirFlow for erv not correct") unless  erv.setLatentEffectivenessat75HeatingAirFlow(setLatentEffectiveness75Heating)
  setEconomizerLockout.to_bool ? erv.setString(23, "Yes") : erv.setString(23, "No")
  setSupplyAirOutletTemperatureControl.to_bool ? erv.setString(17, "Yes") : erv.setString(17, "No")
  raise("setFrostControlType for erv not correct")  unless   erv.setFrostControlType(setFrostControlType)
  raise("setInitialDefrostTimeFraction for erv not correct") unless   erv.setInitialDefrostTimeFraction(setInitialDefrostTimeFraction.to_f)
  raise("setNominalElectricPower for erv not correct")  unless   erv.setNominalElectricPower(nominal_electric_power)

  # Temporary solution, may need to fix later. 12/22/2013 Da
  #erv.setEconomizerLockout('Yes')
  #erv.setEconomizerLockout(true)
  #erv.setString(23, "Yes")

  #erv.setSupplyAirOutletTemperatureControl ('No')
  #erv.setSupplyAirOutletTemperatureControl (false)
  #erv.setString(17, "No")

  return erv
end

.add_gas_heating_coil(model, avail_sched) ⇒ Object

Create a direct-fired gas heating coil



480
481
482
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 480

def self.add_gas_heating_coil(model,avail_sched)
  return OpenStudio::Model::CoilHeatingGas.new(model,avail_sched)
end

.add_hrv(model) ⇒ Object

Create a heat recovery ventilator; this differs from add_erv in that it does not set hrv parameters



432
433
434
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 432

def self.add_hrv(model)
  return OpenStudio::Model::HeatExchangerAirToAirSensibleAndLatent.new(model);
end

.add_hw_baseboard_coil(model) ⇒ Object

Create a new hot water baseboard coil



448
449
450
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 448

def self.add_hw_baseboard_coil(model)
  return OpenStudio::Model::CoilHeatingWaterBaseboard.new(model);
end

.add_hw_boiler(model) ⇒ Object

Create a new hot water boiler; this differs from add_boiler_hot_water_to_water_loop in that it does not set boiler parameters (eg. fuel source) and does not connect it to a water loop



438
439
440
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 438

def self.add_hw_boiler(model)
  return OpenStudio::Model::BoilerHotWater.new(model);
end

.add_hydronic_cool_coil(model, avail_sched) ⇒ Object

Create a hydronic cooling coil



506
507
508
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 506

def self.add_hydronic_cool_coil(model,avail_sched)
  return OpenStudio::Model::CoilCoolingWater.new(model,avail_sched)
end

.add_hydronic_heating_coil(model, avail_sched) ⇒ Object

Add a hydronic heating coil



276
277
278
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 276

def self.add_hydronic_heating_coil(model,avail_sched)
  return OpenStudio::Model::CoilHeatingWater.new(model,avail_sched);
end

.add_oa_controller(model) ⇒ Object

Create a new outdoor air controller



411
412
413
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 411

def self.add_oa_controller(model)
  return OpenStudio::Model::ControllerOutdoorAir.new(model);
end

.add_OA_system(model, oa_controller) ⇒ Object

Create a new HVAC air loop outdoor air system



416
417
418
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 416

def self.add_OA_system(model,oa_controller)
  return OpenStudio::Model::AirLoopHVACOutdoorAirSystem.new(model,oa_controller);
end

.add_oareset_setpoint_mgr(model) ⇒ Object

Create a new outdoor air reset setpoint manager



443
444
445
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 443

def self.add_oareset_setpoint_mgr(model)
  return OpenStudio::Model::SetpointManagerOutdoorAirReset.new(model);
end

.add_onespeed_DX_coil(model, always_on) ⇒ Object

Create a new DX cooling coil with NECB curve characteristics



296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 296

def self.add_onespeed_DX_coil(model,always_on)

  #clg_cap_f_of_temp = OpenStudio::Model::CurveBiquadratic.new(model)
  clg_cap_f_of_temp = BTAP::Resources::HVAC::Plant::add_biquad_curve(model)
  clg_cap_f_of_temp.setCoefficient1Constant(0.867905)
  clg_cap_f_of_temp.setCoefficient2x(0.0142459)
  clg_cap_f_of_temp.setCoefficient3xPOW2(0.000554364)
  clg_cap_f_of_temp.setCoefficient4y(-0.00755748)
  clg_cap_f_of_temp.setCoefficient5yPOW2(3.3048e-05)
  clg_cap_f_of_temp.setCoefficient6xTIMESY(-0.000191808)
  clg_cap_f_of_temp.setMinimumValueofx(13.0)
  clg_cap_f_of_temp.setMaximumValueofx(24.0)
  clg_cap_f_of_temp.setMinimumValueofy(24.0)
  clg_cap_f_of_temp.setMaximumValueofy(46.0)

  #clg_cap_f_of_flow = OpenStudio::Model::CurveQuadratic.new(model)
  clg_cap_f_of_flow = BTAP::Resources::HVAC::Plant::add_quad_curve(model)
  clg_cap_f_of_flow.setCoefficient1Constant(1.0)
  clg_cap_f_of_flow.setCoefficient2x(0.0)
  clg_cap_f_of_flow.setCoefficient3xPOW2(0.0)
  clg_cap_f_of_flow.setMinimumValueofx(0.0)
  clg_cap_f_of_flow.setMaximumValueofx(1.0)

  #clg_energy_input_ratio_f_of_temp = OpenStudio::Model::CurveBiquadratic.new(model)
  clg_energy_input_ratio_f_of_temp = BTAP::Resources::HVAC::Plant::add_biquad_curve(model)
  clg_energy_input_ratio_f_of_temp.setCoefficient1Constant(0.116936)
  clg_energy_input_ratio_f_of_temp.setCoefficient2x(0.0284933)
  clg_energy_input_ratio_f_of_temp.setCoefficient3xPOW2(-0.000411156)
  clg_energy_input_ratio_f_of_temp.setCoefficient4y(0.0214108)
  clg_energy_input_ratio_f_of_temp.setCoefficient5yPOW2(0.000161028)
  clg_energy_input_ratio_f_of_temp.setCoefficient6xTIMESY(-0.000679104)
  clg_energy_input_ratio_f_of_temp.setMinimumValueofx(13.0)
  clg_energy_input_ratio_f_of_temp.setMaximumValueofx(24.0)
  clg_energy_input_ratio_f_of_temp.setMinimumValueofy(24.0)
  clg_energy_input_ratio_f_of_temp.setMaximumValueofy(46.0)

  #clg_energy_input_ratio_f_of_flow = OpenStudio::Model::CurveQuadratic.new(model)
  clg_energy_input_ratio_f_of_flow = BTAP::Resources::HVAC::Plant::add_quad_curve(model)
  clg_energy_input_ratio_f_of_flow.setCoefficient1Constant(1.0)
  clg_energy_input_ratio_f_of_flow.setCoefficient2x(0.0)
  clg_energy_input_ratio_f_of_flow.setCoefficient3xPOW2(0.0)
  clg_energy_input_ratio_f_of_flow.setMinimumValueofx(0.0)
  clg_energy_input_ratio_f_of_flow.setMaximumValueofx(1.0)

  # NECB curve modified to take into account how PLF is used in E+, and PLF ranges (> 0.7)
  clg_part_load_ratio = BTAP::Resources::HVAC::Plant::add_cubic_curve(model)
  clg_part_load_ratio.setCoefficient1Constant(0.0277)
  clg_part_load_ratio.setCoefficient2x(4.9151)
  clg_part_load_ratio.setCoefficient3xPOW2(-8.184)
  clg_part_load_ratio.setCoefficient4xPOW3(4.2702)
  clg_part_load_ratio.setMinimumValueofx(0.7)
  clg_part_load_ratio.setMaximumValueofx(1.0)


  return OpenStudio::Model::CoilCoolingDXSingleSpeed.new(model,
    always_on,
    clg_cap_f_of_temp,
    clg_cap_f_of_flow,
    clg_energy_input_ratio_f_of_temp,
    clg_energy_input_ratio_f_of_flow,
    clg_part_load_ratio);
end

.add_onespeed_DX_coil_heating(model, always_on) ⇒ Object

Create a new DX heating coil with NECB curve characteristics



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 360

def self.add_onespeed_DX_coil_heating(model,always_on)

  htg_cap_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
  htg_cap_f_of_temp.setCoefficient1Constant(0.729)
  htg_cap_f_of_temp.setCoefficient2x(0.031927)
  htg_cap_f_of_temp.setCoefficient3xPOW2(0.0001364)
  htg_cap_f_of_temp.setCoefficient4xPOW3(-0.000008748)
  htg_cap_f_of_temp.setMinimumValueofx(-20.0)
  htg_cap_f_of_temp.setMaximumValueofx(20.0)

  htg_cap_f_of_flow = OpenStudio::Model::CurveCubic.new(model)
  htg_cap_f_of_flow.setCoefficient1Constant(0.84)
  htg_cap_f_of_flow.setCoefficient2x(0.16)
  htg_cap_f_of_flow.setCoefficient3xPOW2(0.0)
  htg_cap_f_of_flow.setCoefficient4xPOW3(0.0)
  htg_cap_f_of_flow.setMinimumValueofx(0.5)
  htg_cap_f_of_flow.setMaximumValueofx(1.5)

  htg_energy_input_ratio_f_of_temp = OpenStudio::Model::CurveCubic.new(model)
  htg_energy_input_ratio_f_of_temp.setCoefficient1Constant(1.2183)
  htg_energy_input_ratio_f_of_temp.setCoefficient2x(-0.036117)
  htg_energy_input_ratio_f_of_temp.setCoefficient3xPOW2(0.0014204)
  htg_energy_input_ratio_f_of_temp.setCoefficient4xPOW3(-0.000026827)
  htg_energy_input_ratio_f_of_temp.setMinimumValueofx(-20.0)
  htg_energy_input_ratio_f_of_temp.setMaximumValueofx(20.0)

  htg_energy_input_ratio_f_of_flow = OpenStudio::Model::CurveQuadratic.new(model)
  htg_energy_input_ratio_f_of_flow.setCoefficient1Constant(1.3824)
  htg_energy_input_ratio_f_of_flow.setCoefficient2x(-0.4336)
  htg_energy_input_ratio_f_of_flow.setCoefficient3xPOW2(0.0512)
  htg_energy_input_ratio_f_of_flow.setMinimumValueofx(0.0)
  htg_energy_input_ratio_f_of_flow.setMaximumValueofx(1.0)

  htg_part_load_fraction = OpenStudio::Model::CurveCubic.new(model)
  htg_part_load_fraction.setCoefficient1Constant(0.3696)
  htg_part_load_fraction.setCoefficient2x(2.3362)
  htg_part_load_fraction.setCoefficient3xPOW2(-2.9577)
  htg_part_load_fraction.setCoefficient4xPOW3(1.2596)
  htg_part_load_fraction.setMinimumValueofx(0.7)
  htg_part_load_fraction.setMaximumValueofx(1.0)

  return OpenStudio::Model::CoilHeatingDXSingleSpeed.new(model,
    always_on,
    htg_cap_f_of_temp,
    htg_cap_f_of_flow,
    htg_energy_input_ratio_f_of_temp,
    htg_energy_input_ratio_f_of_flow,
    htg_part_load_fraction)
end

.add_pump_const_speed(model) ⇒ Object

Create a constant speed pump. This differs from add_pump_constant_speed in that it does not connect the pump to the water loop



459
460
461
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 459

def self.add_pump_const_speed(model)
  return OpenStudio::Model::PumpConstantSpeed.new(model);
end

.add_pump_constant_speed(model, water_loop) ⇒ Object

Add Constant Speed Pump



256
257
258
259
260
261
262
263
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 256

def self.add_pump_constant_speed(model,water_loop)
  library_pump = BTAP::OpenStudioLibrary.instance.library.getPumpConstantSpeedByName("Pump Constant Speed").get
  supply_inlet_node = water_loop.supplyInletNode()
  #clone object fron library into current model.
  new_pump = library_pump.clone(model).to_PumpConstantSpeed.get
  new_pump.addToNode(supply_inlet_node)
  return new_pump
end

.add_pump_var_speed(model) ⇒ Object

Create a variable speed pump. This differs from add_pump_variable_speed in that it does not connect the pump to the water loop



465
466
467
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 465

def self.add_pump_var_speed(model)
  return OpenStudio::Model::PumpVariableSpeed.new(model);
end

.add_pump_variable_speed(model, water_loop) ⇒ Object

Add Variable Speed Pump



246
247
248
249
250
251
252
253
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 246

def self.add_pump_variable_speed(model,water_loop)
  library_pump = BTAP::OpenStudioLibrary.instance.library.getPumpVariableSpeedByName("OS:Pump:VariableSpeed 1").get
  supply_inlet_node = water_loop.supplyInletNode()
  #clone object from library into current model.
  new_pump = library_pump.clone(model).to_PumpVariableSpeed.get
  new_pump.addToNode(supply_inlet_node)
  return new_pump
end

.add_quad_curve(model) ⇒ Object

Create a new quadratic curve



286
287
288
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 286

def self.add_quad_curve(model)
  return OpenStudio::Model::CurveQuadratic.new(model);
end

.add_sched_setpoint_mgr(model, temp_sched) ⇒ Object

Create a scheduled setpoint manager



426
427
428
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 426

def self.add_sched_setpoint_mgr(model,temp_sched)
  return OpenStudio::Model::SetpointManagerScheduled.new(model,temp_sched)
end

.add_sz_reheat_setpoint(model) ⇒ Object

Create a new single zone reheat setpoint manager



421
422
423
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 421

def self.add_sz_reheat_setpoint(model)
  return OpenStudio::Model::SetpointManagerSingleZoneReheat.new(model);
end

.add_water_loop(model) ⇒ Object

Add a new water loop to the model.



193
194
195
 
# File 'lib/openstudio-standards/btap/hvac.rb', line 193

def self.add_water_loop(model)
  return OpenStudio::Model::PlantLoop.new(model);
end