ModelObject AirTerminalSingleDuctParallelPIUReheat_Impl::clone(Model model) const
{
AirTerminalSingleDuctParallelPIUReheat modelObjectClone = StraightComponent_Impl::clone(model).cast<AirTerminalSingleDuctParallelPIUReheat>();
modelObjectClone.setString(modelObjectClone.secondaryAirInletPort(),"");
// clone coil
HVACComponent coil = this->reheatCoil();
HVACComponent coilClone = coil.clone(model).cast<HVACComponent>();
modelObjectClone.setReheatCoil(coilClone);
// clone fan
HVACComponent fan = this->fan();
HVACComponent fanClone = fan.clone(model).cast<HVACComponent>();
modelObjectClone.setFan(fanClone);
return modelObjectClone;
}
void AirTerminalSingleDuctParallelPIUReheat_Impl::setFan( HVACComponent & hvacComponent )
{
bool isTypeCorrect = false;
if( hvacComponent.iddObjectType() == IddObjectType::OS_Fan_ConstantVolume )
{
isTypeCorrect = true;
}
if( isTypeCorrect )
{
setPointer(OS_AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanName,hvacComponent.handle());
}
}
PortList::PortList(const HVACComponent& comp)
: ModelObject(PortList::iddObjectType(),comp.model())
{
OS_ASSERT(getImpl<detail::PortList_Impl>());
getImpl<detail::PortList_Impl>()->setHVACComponent(comp);
}
// Some plant components air in a containingHVACComponent() and it is that
// container which needs to go on the plant operation scheme. Here is a filter to
// figure that out.
HVACComponent operationSchemeComponent(const HVACComponent & component) {
boost::optional<HVACComponent> result;
switch(component.iddObject().type().value())
{
case openstudio::IddObjectType::OS_WaterHeater_Mixed :
{
auto waterHeater = component.cast<WaterHeaterMixed>();
if( auto hpwh = waterHeater.containingZoneHVACComponent() ) {
result = hpwh;
}
break;
}
case openstudio::IddObjectType::OS_WaterHeater_Stratified :
{
auto waterHeater = component.cast<WaterHeaterStratified>();
if( auto hpwh = waterHeater.containingZoneHVACComponent() ) {
result = hpwh;
}
break;
}
default:
{
break;
}
}
if( result ) {
return result.get();
}
return component;
}
void AirTerminalSingleDuctParallelPIUReheat_Impl::setReheatCoil( HVACComponent & hvacComponent )
{
bool isTypeCorrect = false;
if( hvacComponent.iddObjectType() == IddObjectType::OS_Coil_Heating_Electric )
{
isTypeCorrect = true;
}
else if( hvacComponent.iddObjectType() == IddObjectType::OS_Coil_Heating_Gas )
{
isTypeCorrect = true;
}
else if( hvacComponent.iddObjectType() == IddObjectType::OS_Coil_Heating_Water )
{
isTypeCorrect = true;
}
if( isTypeCorrect )
{
setPointer(OS_AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilName,hvacComponent.handle());
}
}
bool ZoneHVACTerminalUnitVariableRefrigerantFlow_Impl::setSupplyAirFan(const HVACComponent & component)
{
return setPointer(OS_ZoneHVAC_TerminalUnit_VariableRefrigerantFlowFields::SupplyAirFan,component.handle());
}
void ControllerWaterCoil_Impl::setWaterCoil( const HVACComponent & comp )
{
auto result = setPointer(OS_Controller_WaterCoilFields::WaterCoilName,comp.handle());
OS_ASSERT(result);
}
bool ZoneHVACUnitHeater_Impl::setHeatingCoil(const HVACComponent & heatingCoil)
{
bool result = setPointer(OS_ZoneHVAC_UnitHeaterFields::HeatingCoilName, heatingCoil.handle());
return result;
}
bool ZoneHVACUnitHeater_Impl::setSupplyAirFan(const HVACComponent& HVACComponent)
{
bool result = setPointer(OS_ZoneHVAC_UnitHeaterFields::SupplyAirFanName, HVACComponent.handle());
return result;
}
bool AirTerminalSingleDuctConstantVolumeFourPipeBeam_Impl::setHeatingCoil(const HVACComponent& coilHeatingFourPipeBeam) {
bool result = setPointer(OS_AirTerminal_SingleDuct_ConstantVolume_FourPipeBeamFields::HeatingCoilName, coilHeatingFourPipeBeam.handle());
if (!result) {
if ( !coilHeatingFourPipeBeam.optionalCast<CoilHeatingFourPipeBeam>() ) {
LOG(Error, "Cannot set the heating coil to something else than CoilHeatingFourPipeBeam for " << briefDescription());
}
}
return result;
}
bool HVACComponent_Impl::removeFromLoop( const HVACComponent & systemStartComponent,
const HVACComponent & systemEndComponent,
unsigned componentInletPort,
unsigned componentOutletPort )
{
auto _model = model();
auto thisObject = getObject<HVACComponent>();
if( systemStartComponent.model() != _model ) return false;
if( systemEndComponent.model() != _model ) return false;
auto inletComponent = connectedObject( componentInletPort );
auto outletComponent = connectedObject( componentOutletPort );
auto inletComponentOutletPort = connectedObjectPort( componentInletPort );
auto outletComponentInletPort = connectedObjectPort( componentOutletPort );
if( ! inletComponent ) return false;
if( ! outletComponent ) return false;
if( ! inletComponentOutletPort ) return false;
if( ! outletComponentInletPort ) return false;
auto inletNode = inletComponent->optionalCast<Node>();
auto outletNode = outletComponent->optionalCast<Node>();
boost::optional<Splitter> splitter;
boost::optional<Mixer> mixer;
if( inletNode ) {
if( auto mo = inletNode->inletModelObject() ) {
splitter = mo->optionalCast<Splitter>();
}
}
if( outletNode ) {
if( auto mo = outletNode->outletModelObject() ) {
mixer = mo->optionalCast<Mixer>();
}
}
if( systemStartComponent.handle() == inletComponent->handle()
&& systemEndComponent.handle() == outletComponent->handle() ) {
// This component is between the systemStartComponent and the systemEndComponent
// ie. the supply or demand inlet or outlet Nodes,
// or the oa system end points on either the relief or inlet air streams.
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
_model.connect( inletComponent.get(), inletComponentOutletPort.get(),
outletComponent.get(), outletComponentInletPort.get() );
return true;
} else if( systemEndComponent.handle() == outletComponent->handle() ) {
// Here the systemEndComponent is immediately downstream of this component,
// but there are other components (besides systemStartComponent) upstream.
boost::optional<ModelObject> newInletComponent;
boost::optional<unsigned> newInletComponentOutletPort;
// Make sure we don't end up with two nodes next to each other after this component is removed
if( inletNode && outletNode ) {
newInletComponent = inletNode->inletModelObject();
newInletComponentOutletPort = inletNode->connectedObjectPort(inletNode->inletPort());
OS_ASSERT(newInletComponent);
OS_ASSERT(newInletComponentOutletPort);
} else {
newInletComponent = inletComponent;
newInletComponentOutletPort = inletComponentOutletPort;
}
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
// inletNode->remove() would have failed if we did it before the disconnect
if( inletNode && outletNode ) {
inletNode->remove();
}
_model.connect( newInletComponent.get(), newInletComponentOutletPort.get(),
outletComponent.get(), outletComponentInletPort.get() );
return true;
} else if( splitter && mixer ) {
// If the component is the only component (except nodes) between a splitter mixer pair
OS_ASSERT(inletNode);
OS_ASSERT(outletNode);
int i = splitter->branchIndexForOutletModelObject(inletNode.get());
int j = mixer->branchIndexForInletModelObject(outletNode.get());
OS_ASSERT(i == j);
splitter->removePortForBranch(i);
mixer->removePortForBranch(i);
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
inletNode->remove();
outletNode->remove();
if( ! splitter->lastOutletModelObject() )
{
Node newNode(_model);
_model.connect(splitter.get(),splitter->nextOutletPort(),newNode,newNode.inletPort());
_model.connect(newNode,newNode.outletPort(),mixer.get(),mixer->nextInletPort());
}
return true;
} else {
boost::optional<ModelObject> newOutletComponent;
boost::optional<unsigned> newOutletComponentInletPort;
if( inletNode && outletNode ) {
newOutletComponent = outletNode->outletModelObject();
newOutletComponentInletPort = outletNode->connectedObjectPort(outletNode->outletPort());
}
if( ! newOutletComponent ) newOutletComponent = outletComponent;
if( ! newOutletComponentInletPort ) newOutletComponentInletPort = outletComponentInletPort;
_model.disconnect(thisObject,componentInletPort);
_model.disconnect(thisObject,componentOutletPort);
// outletNode->remove() would have failed if we did it before the disconnect
if( inletNode && outletNode ) {
outletNode->remove();
}
model().connect( inletComponent.get(), inletComponentOutletPort.get(),
newOutletComponent.get(), newOutletComponentInletPort.get() );
return true;
}
return false;
}
boost::optional<IdfObject> ForwardTranslator::translateAirTerminalSingleDuctParallelPIUReheat( AirTerminalSingleDuctParallelPIUReheat & modelObject )
{
OptionalModelObject temp;
OptionalString optS;
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject _airDistributionUnit(openstudio::IddObjectType::ZoneHVAC_AirDistributionUnit);
_airDistributionUnit.setName(modelObject.name().get() + " Air Distribution Unit");
m_idfObjects.push_back(_airDistributionUnit);
IdfObject idfObject(openstudio::IddObjectType::AirTerminal_SingleDuct_ParallelPIU_Reheat);
idfObject.setName(modelObject.name().get());
m_idfObjects.push_back(idfObject);
HVACComponent coil = modelObject.reheatCoil();
boost::optional<IdfObject> _reheatCoil = translateAndMapModelObject(coil);
HVACComponent fan = modelObject.fan();
boost::optional<IdfObject> _fan = translateAndMapModelObject(fan);
std::string fanOutletNodeName = modelObject.name().get() + " Fan Outlet";
std::string mixerOutletNodeName = modelObject.name().get() + " Mixer Outlet";
boost::optional<std::string> inletNodeName;
boost::optional<std::string> secondaryAirInletNodeName;
boost::optional<std::string> outletNodeName;
if( boost::optional<ModelObject> inletModelObject = modelObject.inletModelObject() )
{
if( boost::optional<Node> inletNode = inletModelObject->optionalCast<Node>() )
{
inletNodeName = inletNode->name().get();
}
}
if( boost::optional<ModelObject> outletModelObject = modelObject.outletModelObject() )
{
if( boost::optional<Node> outletNode = outletModelObject->optionalCast<Node>() )
{
outletNodeName = outletNode->name().get();
}
}
if( boost::optional<Node> secondaryInletNode = modelObject.secondaryAirInletNode() )
{
if( secondaryInletNode )
{
secondaryAirInletNodeName = secondaryInletNode->name().get();
}
}
if( outletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::OutletNodeName,outletNodeName.get());
}
if( inletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::SupplyAirInletNodeName,inletNodeName.get());
}
if( secondaryAirInletNodeName )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::SecondaryAirInletNodeName,secondaryAirInletNodeName.get());
}
// Populate fields for AirDistributionUnit
if( outletNodeName )
{
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirDistributionUnitOutletNodeName,outletNodeName.get());
}
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalObjectType,idfObject.iddObject().name());
_airDistributionUnit.setString(ZoneHVAC_AirDistributionUnitFields::AirTerminalName,idfObject.name().get());
// MixerName
IdfObject _mixer(IddObjectType::AirLoopHVAC_ZoneMixer);
_mixer.setName(modelObject.name().get() + " Mixer");
m_idfObjects.push_back(_mixer);
_mixer.clearExtensibleGroups();
_mixer.setString(AirLoopHVAC_ZoneMixerFields::OutletNodeName,mixerOutletNodeName);
IdfExtensibleGroup eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,fanOutletNodeName);
if( inletNodeName )
{
eg = _mixer.pushExtensibleGroup();
eg.setString(AirLoopHVAC_ZoneMixerExtensibleFields::InletNodeName,inletNodeName.get());
}
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ZoneMixerName,_mixer.name().get());
// FanName
if( _fan || _fan->name() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanName,_fan->name().get());
if( secondaryAirInletNodeName )
{
_fan->setString(Fan_ConstantVolumeFields::AirInletNodeName,secondaryAirInletNodeName.get());
}
_fan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,fanOutletNodeName);
}
// ReheatCoilName
if( _reheatCoil && _reheatCoil->name() )
{
// Reheat Coil Name
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilName,_reheatCoil->name().get());
// Reheat Coil Type
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilObjectType,_reheatCoil->iddObject().name());
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ReheatCoilAirInletNodeName,mixerOutletNodeName);
if( outletNodeName && inletNodeName )
{
if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_reheatCoil->setString(Coil_Heating_GasFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_reheatCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,outletNodeName.get());
}
else if( _reheatCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_reheatCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,mixerOutletNodeName);
_reheatCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,outletNodeName.get());
}
}
}
// AvailabilityScheduleName
Schedule availabilitySchedule = modelObject.availabilitySchedule();
boost::optional<IdfObject> _availabilitySchedule = translateAndMapModelObject(availabilitySchedule);
if( _availabilitySchedule && _availabilitySchedule->name() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::AvailabilityScheduleName,_availabilitySchedule->name().get());
}
// MaximumPrimaryAirFlowRate
if( modelObject.isMaximumPrimaryAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumPrimaryAirFlowRate,"Autosize");
}
else if( (value = modelObject.maximumPrimaryAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumPrimaryAirFlowRate,value.get());
}
// MaximumSecondaryAirFlowRate
if( modelObject.isMaximumSecondaryAirFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumSecondaryAirFlowRate,"Autosize");
}
else if( (value = modelObject.maximumSecondaryAirFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumSecondaryAirFlowRate,value.get());
}
// MinimumPrimaryAirFlowFraction
if( modelObject.isMinimumPrimaryAirFlowFractionAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumPrimaryAirFlowFraction,"Autosize");
}
else if( (value = modelObject.minimumPrimaryAirFlowFraction()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumPrimaryAirFlowFraction,value.get());
}
// FanOnFlowFraction
if( modelObject.isFanOnFlowFractionAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanOnFlowFraction,"Autosize");
}
else if( (value = modelObject.fanOnFlowFraction()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::FanOnFlowFraction,value.get());
}
// MaximumHotWaterorSteamFlowRate
if( modelObject.isMaximumHotWaterorSteamFlowRateAutosized() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumHotWaterorSteamFlowRate,"Autosize");
}
else if( (value = modelObject.maximumHotWaterorSteamFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MaximumHotWaterorSteamFlowRate,value.get());
}
// MinimumHotWaterorSteamFlowRate
if( (value = modelObject.minimumHotWaterorSteamFlowRate()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::MinimumHotWaterorSteamFlowRate,value.get());
}
// HotWaterorSteamInletNodeName
if( boost::optional<CoilHeatingWater> coil = modelObject.reheatCoil().optionalCast<CoilHeatingWater>() )
{
if( boost::optional<ModelObject> mo = coil->waterInletModelObject() )
{
if( boost::optional<Node> node = mo->optionalCast<Node>() )
{
idfObject.setString(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::HotWaterorSteamInletNodeName,node->name().get());
}
}
}
// ConvergenceTolerance
if( (value = modelObject.convergenceTolerance()) )
{
idfObject.setDouble(AirTerminal_SingleDuct_ParallelPIU_ReheatFields::ConvergenceTolerance,value.get());
}
return _airDistributionUnit;
}
bool ZoneHVACEnergyRecoveryVentilator_Impl::setExhaustAirFan(const HVACComponent& exhaustAirFan) {
bool result = setPointer(OS_ZoneHVAC_EnergyRecoveryVentilatorFields::ExhaustAirFanName, exhaustAirFan.handle());
return result;
}
bool ZoneHVACEnergyRecoveryVentilator_Impl::setHeatExchanger(const HVACComponent& hxAirToAirSensibleAndLatent) {
bool result = setPointer(OS_ZoneHVAC_EnergyRecoveryVentilatorFields::HeatExchangerName, hxAirToAirSensibleAndLatent.handle());
return result;
}
boost::optional<double> flowrate(const HVACComponent & component)
{
boost::optional<double> result;
switch(component.iddObject().type().value()) {
case openstudio::IddObjectType::OS_Boiler_HotWater :
{
auto boiler = component.cast<BoilerHotWater>();
result = boiler.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_WaterHeater_Mixed :
{
auto waterHeater = component.cast<WaterHeaterMixed>();
result = waterHeater.useSideDesignFlowRate();
break;
}
case openstudio::IddObjectType::OS_WaterHeater_Stratified :
{
auto waterHeater = component.cast<WaterHeaterStratified>();
result = waterHeater.useSideDesignFlowRate();
break;
}
case openstudio::IddObjectType::OS_DistrictHeating :
{
break;
}
case openstudio::IddObjectType::OS_Chiller_Electric_EIR :
{
auto chiller = component.cast<ChillerElectricEIR>();
result = chiller.referenceChilledWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_Chiller_Absorption_Indirect :
{
auto chiller = component.cast<ChillerAbsorptionIndirect>();
result = chiller.designChilledWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_Chiller_Absorption :
{
auto chiller = component.cast<ChillerAbsorption>();
result = chiller.designChilledWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_ThermalStorage_Ice_Detailed :
{
break;
}
case openstudio::IddObjectType::OS_DistrictCooling :
{
break;
}
case openstudio::IddObjectType::OS_CoolingTower_SingleSpeed :
{
auto tower = component.cast<CoolingTowerSingleSpeed>();
result = tower.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_CoolingTower_VariableSpeed :
{
auto tower = component.cast<CoolingTowerVariableSpeed>();
result = tower.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_CoolingTower_TwoSpeed:
{
auto tower = component.cast<CoolingTowerTwoSpeed>();
result = tower.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_EvaporativeFluidCooler_SingleSpeed:
{
auto mo = component.cast<EvaporativeFluidCoolerSingleSpeed>();
result = mo.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_FluidCooler_SingleSpeed:
{
auto mo = component.cast<FluidCoolerSingleSpeed>();
result = mo.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_FluidCooler_TwoSpeed:
{
auto mo = component.cast<FluidCoolerTwoSpeed>();
result = mo.designWaterFlowRate();
break;
}
case openstudio::IddObjectType::OS_GroundHeatExchanger_Vertical :
{
auto hx = component.cast<GroundHeatExchangerVertical>();
result = hx.maximumFlowRate();
break;
}
case openstudio::IddObjectType::OS_GroundHeatExchanger_HorizontalTrench :
{
auto hx = component.cast<GroundHeatExchangerHorizontalTrench>();
result = hx.designFlowRate();
break;
}
case openstudio::IddObjectType::OS_HeatExchanger_FluidToFluid :
{
auto hx = component.cast<HeatExchangerFluidToFluid>();
result = hx.loopSupplySideDesignFlowRate();
break;
}
case openstudio::IddObjectType::OS_SolarCollector_FlatPlate_PhotovoltaicThermal :
{
auto mo = component.cast<SolarCollectorFlatPlatePhotovoltaicThermal>();
result = mo.designFlowRate();
break;
}
case openstudio::IddObjectType::OS_SolarCollector_FlatPlate_Water :
{
auto mo = component.cast<SolarCollectorFlatPlateWater>();
result = mo.maximumFlowRate();
break;
}
case openstudio::IddObjectType::OS_SolarCollector_IntegralCollectorStorage :
{
auto mo = component.cast<SolarCollectorIntegralCollectorStorage>();
result = mo.maximumFlowRate();
break;
}
case openstudio::IddObjectType::OS_PlantComponent_TemperatureSource :
{
auto mo = component.cast<PlantComponentTemperatureSource>();
result = mo.designVolumeFlowRate();
break;
}
case openstudio::IddObjectType::OS_HeatPump_WaterToWater_EquationFit_Cooling :
{
auto mo = component.cast<HeatPumpWaterToWaterEquationFitCooling>();
result = mo.ratedLoadSideFlowRate();
break;
}
case openstudio::IddObjectType::OS_HeatPump_WaterToWater_EquationFit_Heating :
{
auto mo = component.cast<HeatPumpWaterToWaterEquationFitHeating>();
result = mo.ratedLoadSideFlowRate();
break;
}
default:
{
break;
}
}
return result;
}
bool HVACComponent_Impl::addToNode(Node & node,
const HVACComponent & systemStartComponent,
const HVACComponent & systemEndComponent,
unsigned componentInletPort,
unsigned componentOutletPort)
{
Model _model = model();
ModelObject thisModelObject = getObject<ModelObject>();
if( node.model() != _model ) return false;
if( systemStartComponent.model() != _model ) return false;
if( systemEndComponent.model() != _model ) return false;
if( (node == systemEndComponent) && (node.inletModelObject().get() == systemStartComponent) ) {
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
// If systemStartComponent is not a node we need to insert one so that there
// is a node between systemStartComponent and this component we are adding
// This situation occurs in the oa system relief stream.
if( ! systemStartComponent.optionalCast<Node>() ) {
Node newNode(_model);
_model.connect(oldSourceModelObject,oldOutletPort,
newNode,newNode.inletPort());
oldOutletPort = newNode.outletPort();
oldSourceModelObject = newNode;
}
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, componentInletPort );
_model.connect( thisModelObject, componentOutletPort,
oldTargetModelObject, oldInletPort );
return true;
} else if( (node == systemStartComponent) && (node.outletModelObject().get() == systemEndComponent) ) {
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
unsigned oldOutletPort = node.outletPort();
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
// If systemEndComponent is not a node we need to insert one so that there
// is a node between systemEndComponent and this component we are adding
// This situation occurs in the oa system outdoor air stream.
if( ! systemEndComponent.optionalCast<Node>() ) {
Node newNode(_model);
_model.connect(newNode,newNode.outletPort(),
oldTargetModelObject,oldInletPort);
oldInletPort = newNode.inletPort();
oldTargetModelObject = newNode;
}
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, componentInletPort );
_model.connect( thisModelObject, componentOutletPort,
oldTargetModelObject, oldInletPort );
return true;
} else if( node == systemEndComponent ) {
unsigned oldOutletPort = node.connectedObjectPort( node.inletPort() ).get();
unsigned oldInletPort = node.inletPort();
ModelObject oldSourceModelObject = node.connectedObject( node.inletPort() ).get();
ModelObject oldTargetModelObject = node;
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
thisModelObject, componentInletPort );
_model.connect( thisModelObject, componentOutletPort,
oldTargetModelObject, oldInletPort );
return true;
} else {
unsigned oldOutletPort = node.outletPort();
unsigned oldInletPort = node.connectedObjectPort( node.outletPort() ).get();
ModelObject oldSourceModelObject = node;
ModelObject oldTargetModelObject = node.connectedObject( node.outletPort() ).get();
Node newNode( _model );
_model.connect( oldSourceModelObject, oldOutletPort,
thisModelObject, componentInletPort );
_model.connect( thisModelObject, componentOutletPort,
newNode, newNode.inletPort() );
_model.connect( newNode, newNode.outletPort(),
oldTargetModelObject, oldInletPort );
return true;
}
return false;
}
ComponentType componentType(const HVACComponent & component)
{
switch(component.iddObject().type().value())
{
case openstudio::IddObjectType::OS_Boiler_HotWater :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_WaterHeater_Mixed :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_WaterHeater_Stratified :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_DistrictHeating :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_Chiller_Electric_EIR :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_Chiller_Absorption_Indirect :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_Chiller_Absorption :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_ThermalStorage_Ice_Detailed :
{
return ComponentType::BOTH;
}
case openstudio::IddObjectType::OS_DistrictCooling :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_CoolingTower_SingleSpeed :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_CoolingTower_VariableSpeed :
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_CoolingTower_TwoSpeed:
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_EvaporativeFluidCooler_SingleSpeed:
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_FluidCooler_SingleSpeed:
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_FluidCooler_TwoSpeed:
{
return ComponentType::COOLING;
}
case openstudio::IddObjectType::OS_GroundHeatExchanger_Vertical :
{
return ComponentType::BOTH;
}
case openstudio::IddObjectType::OS_GroundHeatExchanger_HorizontalTrench :
{
return ComponentType::BOTH;
}
case openstudio::IddObjectType::OS_HeatExchanger_FluidToFluid :
{
return ComponentType::BOTH;
}
case openstudio::IddObjectType::OS_SolarCollector_FlatPlate_PhotovoltaicThermal :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_SolarCollector_FlatPlate_Water :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_SolarCollector_IntegralCollectorStorage :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_PlantComponent_TemperatureSource :
{
return ComponentType::BOTH;
}
case openstudio::IddObjectType::OS_HeatPump_WaterToWater_EquationFit_Heating :
{
return ComponentType::HEATING;
}
case openstudio::IddObjectType::OS_HeatPump_WaterToWater_EquationFit_Cooling :
{
return ComponentType::COOLING;
}
default:
{
return ComponentType::NONE;
}
}
}
bool ZoneHVACLowTempRadiantVarFlow_Impl::setCoolingCoil(HVACComponent& coolingCoil)
{
bool result = setPointer(OS_ZoneHVAC_LowTemperatureRadiant_VariableFlowFields::LowTempRadiantVariableFlowCoolingCoilName, coolingCoil.handle());
return result;
}
boost::optional<IdfObject> ForwardTranslator::translateZoneHVACPackagedTerminalAirConditioner(
ZoneHVACPackagedTerminalAirConditioner & modelObject )
{
boost::optional<std::string> s;
boost::optional<double> value;
IdfObject idfObject(IddObjectType::ZoneHVAC_PackagedTerminalAirConditioner);
m_idfObjects.push_back(idfObject);
// Name
std::string baseName = modelObject.name().get();
idfObject.setName(baseName);
std::string mixedAirNodeName = baseName + " Mixed Air Node";
std::string coolingCoilOutletNodeName = baseName + " Cooling Coil Outlet Node";
std::string heatingCoilOutletNodeName = baseName + " Heating Coil Outlet Node";
std::string reliefAirNodeName = baseName + " Relief Air Node";
std::string oaNodeName = baseName + " OA Node";
// AvailabilityScheduleName
if( boost::optional<Schedule> schedule = modelObject.availabilitySchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AvailabilityScheduleName,_schedule->name().get());
}
}
// AirInletNodeName
boost::optional<std::string> airInletNodeName;
if( boost::optional<Node> node = modelObject.inletNode() )
{
if( (s = node->name()) )
{
airInletNodeName = s;
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirInletNodeName,s.get());
}
}
// AirOutletNodeName
boost::optional<std::string> airOutletNodeName;
if( boost::optional<Node> node = modelObject.outletNode() )
{
if( (s = node->name()) )
{
airOutletNodeName = s;
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::AirOutletNodeName,s.get());
}
}
// OutdoorAirMixerObjectType
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerObjectType,
modelObject.outdoorAirMixerObjectType());
// OutdoorAirMixerName
std::string oaMixerName = modelObject.name().get() + " OA Mixer";
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirMixerName,oaMixerName);
IdfObject _outdoorAirMixer(IddObjectType::OutdoorAir_Mixer);
_outdoorAirMixer.setName(oaMixerName);
m_idfObjects.push_back(_outdoorAirMixer);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::MixedAirNodeName,mixedAirNodeName);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::OutdoorAirStreamNodeName,oaNodeName);
IdfObject _oaNodeList(openstudio::IddObjectType::OutdoorAir_NodeList);
_oaNodeList.setString(0,oaNodeName);
m_idfObjects.push_back(_oaNodeList);
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReliefAirStreamNodeName,reliefAirNodeName);
if(airInletNodeName)
{
_outdoorAirMixer.setString(OutdoorAir_MixerFields::ReturnAirStreamNodeName,airInletNodeName.get());
}
// SupplyAirFlowRateDuringCoolingOperation
if( modelObject.isSupplyAirFlowRateDuringCoolingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringCoolingOperation,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateDuringCoolingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringCoolingOperation,value.get());
}
// SupplyAirFlowRateDuringHeatingOperation
if( modelObject.isSupplyAirFlowRateDuringHeatingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringHeatingOperation,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateDuringHeatingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateDuringHeatingOperation,value.get());
}
// SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isSupplyAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,"Autosize");
}
else if( (value = modelObject.supplyAirFlowRateWhenNoCoolingorHeatingisNeeded()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFlowRateWhenNoCoolingorHeatingisNeeded,value.get());
}
// OutdoorAirFlowRateDuringCoolingOperation
if( modelObject.isOutdoorAirFlowRateDuringCoolingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringCoolingOperation,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateDuringCoolingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringCoolingOperation,value.get());
}
// OutdoorAirFlowRateDuringHeatingOperation
if( modelObject.isOutdoorAirFlowRateDuringHeatingOperationAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringHeatingOperation,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateDuringHeatingOperation()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateDuringHeatingOperation,value.get());
}
// OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded
if( modelObject.isOutdoorAirFlowRateWhenNoCoolingorHeatingisNeededAutosized() )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded,"Autosize");
}
else if( (value = modelObject.outdoorAirFlowRateWhenNoCoolingorHeatingisNeeded()) )
{
idfObject.setDouble(ZoneHVAC_PackagedTerminalAirConditionerFields::OutdoorAirFlowRateWhenNoCoolingorHeatingisNeeded,value.get());
}
// SupplyAirFanObjectType
HVACComponent supplyAirFan = modelObject.supplyAirFan();
if( boost::optional<IdfObject> _supplyAirFan = translateAndMapModelObject(supplyAirFan) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanObjectType,_supplyAirFan->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanName,_supplyAirFan->name().get());
if( airOutletNodeName )
{
if( _supplyAirFan->iddObject().type() == IddObjectType::Fan_ConstantVolume )
{
_supplyAirFan->setString(Fan_ConstantVolumeFields::AirInletNodeName,heatingCoilOutletNodeName);
_supplyAirFan->setString(Fan_ConstantVolumeFields::AirOutletNodeName,airOutletNodeName.get());
}
}
}
// HeatingCoilObjectType
HVACComponent heatingCoil = modelObject.heatingCoil();
if( boost::optional<IdfObject> _heatingCoil = translateAndMapModelObject(heatingCoil) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::HeatingCoilObjectType,_heatingCoil->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::HeatingCoilName,_heatingCoil->name().get() );
if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Water )
{
_heatingCoil->setString(Coil_Heating_WaterFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_WaterFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Gas )
{
_heatingCoil->setString(Coil_Heating_GasFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_GasFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
else if( _heatingCoil->iddObject().type() == IddObjectType::Coil_Heating_Electric )
{
_heatingCoil->setString(Coil_Heating_ElectricFields::AirInletNodeName,coolingCoilOutletNodeName);
_heatingCoil->setString(Coil_Heating_ElectricFields::AirOutletNodeName,heatingCoilOutletNodeName);
}
}
// CoolingCoilObjectType
HVACComponent coolingCoil = modelObject.coolingCoil();
boost::optional<IdfObject> _coolingCoil;
if( boost::optional<CoilCoolingDXSingleSpeed> dxCoil = coolingCoil.optionalCast<CoilCoolingDXSingleSpeed>() )
{
_coolingCoil = translateCoilCoolingDXSingleSpeedWithoutUnitary(dxCoil.get());
m_map.insert(std::make_pair(coolingCoil.handle(),_coolingCoil.get()));
}
else
{
_coolingCoil = translateAndMapModelObject(coolingCoil);
}
if( _coolingCoil )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::CoolingCoilObjectType,_coolingCoil->iddObject().name() );
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::CoolingCoilName,_coolingCoil->name().get() );
if( _coolingCoil->iddObject().type() == IddObjectType::Coil_Cooling_DX_SingleSpeed )
{
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirInletNodeName,mixedAirNodeName);
_coolingCoil->setString(Coil_Cooling_DX_SingleSpeedFields::AirOutletNodeName,coolingCoilOutletNodeName);
}
}
// FanPlacement
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::FanPlacement,modelObject.fanPlacement());
// SupplyAirFanOperatingModeScheduleName
if( boost::optional<Schedule> schedule = modelObject.supplyAirFanOperatingModeSchedule() )
{
if( boost::optional<IdfObject> _schedule = translateAndMapModelObject(schedule.get()) )
{
idfObject.setString(ZoneHVAC_PackagedTerminalAirConditionerFields::SupplyAirFanOperatingModeScheduleName,_schedule->name().get());
}
}
return idfObject;
}
bool PortList_Impl::setHVACComponent(const HVACComponent & hvacComponent)
{
return setPointer(OS_PortListFields::HVACComponent,hvacComponent.handle());
}