void ZoneHVACComponent_Impl::removeFromAirLoopHVAC()
{
if( boost::optional<AirLoopHVAC> t_airLoopHVAC = airLoopHVAC() ) {
boost::optional<Node> t_inletNode = inletNode();
OS_ASSERT(t_inletNode);
boost::optional<Node> t_outletNode = outletNode();
OS_ASSERT(t_outletNode);
unsigned targetPort = t_outletNode->connectedObjectPort(t_outletNode->outletPort()).get();
ModelObject targetModelObject = t_outletNode->connectedObject(t_outletNode->outletPort()).get();
t_outletNode->disconnect();
t_outletNode->remove();
Model t_model = model();
t_model.connect( t_inletNode.get(), t_inletNode->outletPort(),
targetModelObject, targetPort );
std::vector<AirTerminalSingleDuctInletSideMixer> terminalMixers =
subsetCastVector<AirTerminalSingleDuctInletSideMixer>(t_airLoopHVAC->demandComponents(t_airLoopHVAC->demandInletNode(),t_inletNode.get()));
if( ! terminalMixers.empty() ) {
if( boost::optional<Node> secondaryNode = terminalMixers.front().secondaryAirInletNode() ) {
secondaryNode->disconnect();
secondaryNode->remove();
}
}
}
}
void ZoneHVACComponent_Impl::removeFromThermalZone()
{
boost::optional<ThermalZone> thermalZone = this->thermalZone();
boost::optional<AirLoopHVAC> airLoopHVAC = this->airLoopHVAC();
Model m = this->model();
if( airLoopHVAC ) {
removeFromAirLoopHVAC();
} else if( thermalZone ) {
ZoneHVACComponent mo = getObject<ZoneHVACComponent>();
if( auto t_inletNode = inletNode() ) {
t_inletNode->disconnect();
t_inletNode->remove();
}
if( auto t_outletNode = outletNode() )
{
t_outletNode->disconnect();
t_outletNode->remove();
}
}
auto thisObject = this->getObject<ModelObject>();
for( auto & thermalZone : m.getConcreteModelObjects<ThermalZone>() ) {
std::vector<ModelObject> equipment = thermalZone.equipment();
if( std::find(equipment.begin(),equipment.end(),thisObject) != equipment.end() ) {
thermalZone.removeEquipment(thisObject);
break;
}
}
}
boost::optional<AirLoopHVAC> ZoneHVACComponent_Impl::airLoopHVAC() const
{
if( boost::optional<Node> node = inletNode() ) {
return node->airLoopHVAC();
}
return boost::none;
}
bool AirTerminalSingleDuctVAVHeatAndCoolNoReheat_Impl::addToNode(Node & node)
{
Model _model = node.model();
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
boost::optional<ThermalZone> thermalZone;
if( boost::optional<PortList> portList = outlet->optionalCast<PortList>() )
{
thermalZone = portList->thermalZone();
}
if( thermalZone || (outlet->optionalCast<Mixer>() && node.airLoopHVAC()) )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<Splitter> splitter = inlet->optionalCast<Splitter>() )
{
boost::optional<ModelObject> sourceModelObject = inlet;
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
Node inletNode(_model);
_model.connect( sourceModelObject.get(),
sourcePort.get(),
inletNode,
inletNode.inletPort() );
_model.connect( inletNode,
inletNode.outletPort(),
this->getObject<ModelObject>(),
this->inletPort() );
_model.connect( this->getObject<ModelObject>(),
outletPort(),
node,
node.inletPort() );
if( thermalZone )
{
AirTerminalSingleDuctVAVHeatAndCoolNoReheat mo = this->getObject<AirTerminalSingleDuctVAVHeatAndCoolNoReheat>();
thermalZone->addEquipment(mo);
}
return true;
}
}
}
}
}
return false;
}
bool EvaporativeFluidCoolerSingleSpeed_Impl::addToNode(Node& node)
{
Model _model = node.model();
if( boost::optional<PlantLoop> _plantLoop = node.plantLoop() )
{
PlantLoop plantLoop = _plantLoop.get();
if( plantLoop.supplyComponent(node.handle()) )
{
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
if( outlet->optionalCast<ConnectorMixer>() )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<ConnectorSplitter> splitter = inlet->optionalCast<ConnectorSplitter>() )
{
boost::optional<ModelObject> sourceModelObject = inlet;
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
Node inletNode(_model);
_model.connect( sourceModelObject.get(),
sourcePort.get(),
inletNode,
inletNode.inletPort() );
_model.connect( inletNode,
inletNode.outletPort(),
this->getObject<ModelObject>(),
this->inletPort() );
_model.connect( this->getObject<ModelObject>(),
outletPort(),
node,
node.inletPort() );
return true;
}
}
}
}
}
}
}
return false;
}
boost::optional<IdfObject> ForwardTranslator::translatePlantEquipmentOperationSchemes( PlantLoop & plantLoop )
{
IdfObject operationSchemes(IddObjectType::PlantEquipmentOperationSchemes);
m_idfObjects.push_back(operationSchemes);
operationSchemes.setName(plantLoop.name().get() + " Operation Schemes");
// Lambda does what the name suggests, create setpoint operation schemes.
// This is for any component that has a setpoint manager on its outlet node
auto createSetpointOperationScheme = [&](PlantLoop & plantLoop) {
const auto & t_setpointComponents = setpointComponents(plantLoop);
if( ! t_setpointComponents.empty() ) {
Schedule alwaysOn = plantLoop.model().alwaysOnDiscreteSchedule();
IdfObject setpointOperation(IddObjectType::PlantEquipmentOperation_ComponentSetpoint);
setpointOperation.setName(plantLoop.name().get() + " Setpoint Operation Scheme");
m_idfObjects.push_back(setpointOperation);
setpointOperation.clearExtensibleGroups();
IdfExtensibleGroup eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,setpointOperation.iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,setpointOperation.name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
for( auto setpointComponent : t_setpointComponents )
{
boost::optional<IdfObject> _idfObject = translateAndMapModelObject(setpointComponent);
OS_ASSERT(_idfObject);
IdfExtensibleGroup eg = setpointOperation.pushExtensibleGroup();
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::EquipmentObjectType,_idfObject->iddObject().name());
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::EquipmentName,_idfObject->name().get());
if( const auto & t_inletNode = inletNode(plantLoop,setpointComponent) ) {
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::DemandCalculationNodeName,t_inletNode->name().get());
}
if( const auto & t_outletNode = outletNode(plantLoop,setpointComponent) ) {
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::SetpointNodeName,t_outletNode->name().get());
}
if( auto value = flowrate(setpointComponent) ) {
eg.setDouble(PlantEquipmentOperation_ComponentSetpointExtensibleFields::ComponentFlowRate,value.get());
} else {
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::ComponentFlowRate,"Autosize");
}
auto t_componentType = componentType(setpointComponent);
switch(t_componentType)
{
case ComponentType::HEATING :
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Heating");
break;
case ComponentType::COOLING :
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Cooling");
break;
default :
eg.setString(PlantEquipmentOperation_ComponentSetpointExtensibleFields::OperationType,"Dual");
break;
}
}
}
};
Schedule alwaysOn = plantLoop.model().alwaysOnDiscreteSchedule();
bool applyDefault = true;
// If any operation schemes are defined in the model then don't apply default operation schemes
if( auto coolingLoadScheme = plantLoop.plantEquipmentOperationCoolingLoad() ) {
auto _scheme = translateAndMapModelObject(coolingLoadScheme.get());
OS_ASSERT(_scheme);
auto eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
applyDefault = false;
}
if( auto heatingLoadScheme = plantLoop.plantEquipmentOperationHeatingLoad() ) {
auto _scheme = translateAndMapModelObject(heatingLoadScheme.get());
OS_ASSERT(_scheme);
auto eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
applyDefault = false;
}
if( auto primaryScheme = plantLoop.primaryPlantEquipmentOperationScheme() ) {
auto _scheme = translateAndMapModelObject(primaryScheme.get());
OS_ASSERT(_scheme);
auto eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,_scheme->iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,_scheme->name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
createSetpointOperationScheme(plantLoop);
applyDefault = false;
}
if( applyDefault ) {
// If we get here then there must not be any operation schemes defined in the model
// and we should go ahead and create default schemes.
const auto & t_heatingComponents = heatingComponents( plantLoop );
if( ! t_heatingComponents.empty() ) {
IdfObject heatingOperation(IddObjectType::PlantEquipmentOperation_HeatingLoad);
heatingOperation.setName(plantLoop.name().get() + " Heating Operation Scheme");
m_idfObjects.push_back(heatingOperation);
heatingOperation.clearExtensibleGroups();
IdfObject plantEquipmentList(IddObjectType::PlantEquipmentList);
plantEquipmentList.setName(plantLoop.name().get() + " Heating Equipment List");
plantEquipmentList.clearExtensibleGroups();
m_idfObjects.push_back(plantEquipmentList);
IdfExtensibleGroup eg = heatingOperation.pushExtensibleGroup();
eg.setDouble(PlantEquipmentOperation_HeatingLoadExtensibleFields::LoadRangeLowerLimit,0.0);
eg.setDouble(PlantEquipmentOperation_HeatingLoadExtensibleFields::LoadRangeUpperLimit,1E9);
eg.setString(PlantEquipmentOperation_HeatingLoadExtensibleFields::RangeEquipmentListName,plantEquipmentList.name().get());
eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,heatingOperation.iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,heatingOperation.name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
for( auto heatingComponent : t_heatingComponents ) {
if( const auto & idfObject = translateAndMapModelObject(heatingComponent) ) {
IdfExtensibleGroup eg = plantEquipmentList.pushExtensibleGroup();
eg.setString(PlantEquipmentListExtensibleFields::EquipmentObjectType,idfObject->iddObject().name());
eg.setString(PlantEquipmentListExtensibleFields::EquipmentName,idfObject->name().get());
}
}
}
const auto & t_coolingComponents = coolingComponents( plantLoop );
if( ! t_coolingComponents.empty() ) {
IdfObject coolingOperation(IddObjectType::PlantEquipmentOperation_CoolingLoad);
coolingOperation.setName(plantLoop.name().get() + " Cooling Operation Scheme");
m_idfObjects.push_back(coolingOperation);
coolingOperation.clearExtensibleGroups();
IdfObject plantEquipmentList(IddObjectType::PlantEquipmentList);
plantEquipmentList.setName(plantLoop.name().get() + " Cooling Equipment List");
plantEquipmentList.clearExtensibleGroups();
m_idfObjects.push_back(plantEquipmentList);
IdfExtensibleGroup eg = coolingOperation.pushExtensibleGroup();
eg.setDouble(PlantEquipmentOperation_CoolingLoadExtensibleFields::LoadRangeLowerLimit,0.0);
eg.setDouble(PlantEquipmentOperation_CoolingLoadExtensibleFields::LoadRangeUpperLimit,1E9);
eg.setString(PlantEquipmentOperation_CoolingLoadExtensibleFields::RangeEquipmentListName,plantEquipmentList.name().get());
eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,coolingOperation.iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,coolingOperation.name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
for( auto coolingComponent : t_coolingComponents ) {
if( const auto & idfObject = translateAndMapModelObject(coolingComponent) ) {
IdfExtensibleGroup eg = plantEquipmentList.pushExtensibleGroup();
eg.setString(PlantEquipmentListExtensibleFields::EquipmentObjectType,idfObject->iddObject().name());
eg.setString(PlantEquipmentListExtensibleFields::EquipmentName,idfObject->name().get());
}
}
}
const auto & t_uncontrolledComponents = uncontrolledComponents( plantLoop );
if( ! t_uncontrolledComponents.empty() ) {
IdfObject uncontrolledOperation(IddObjectType::PlantEquipmentOperation_Uncontrolled);
uncontrolledOperation.setName(plantLoop.name().get() + " Uncontrolled Operation Scheme");
m_idfObjects.push_back(uncontrolledOperation);
uncontrolledOperation.clearExtensibleGroups();
IdfObject plantEquipmentList(IddObjectType::PlantEquipmentList);
plantEquipmentList.setName(plantLoop.name().get() + " Uncontrolled Equipment List");
plantEquipmentList.clearExtensibleGroups();
m_idfObjects.push_back(plantEquipmentList);
uncontrolledOperation.setString(PlantEquipmentOperation_UncontrolledFields::EquipmentListName,plantEquipmentList.name().get());
auto eg = operationSchemes.pushExtensibleGroup();
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeObjectType,uncontrolledOperation.iddObject().name());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeName,uncontrolledOperation.name().get());
eg.setString(PlantEquipmentOperationSchemesExtensibleFields::ControlSchemeScheduleName,alwaysOn.name().get());
for( auto uncontrolledComponent : t_uncontrolledComponents ) {
if( const auto & idfObject = translateAndMapModelObject(uncontrolledComponent) ) {
IdfExtensibleGroup eg = plantEquipmentList.pushExtensibleGroup();
eg.setString(PlantEquipmentListExtensibleFields::EquipmentObjectType,idfObject->iddObject().name());
eg.setString(PlantEquipmentListExtensibleFields::EquipmentName,idfObject->name().get());
}
}
}
createSetpointOperationScheme(plantLoop);
}
return operationSchemes;
}
bool AirTerminalSingleDuctParallelPIUReheat_Impl::addToNode(Node & node)
{
Model _model = node.model();
if( boost::optional<ModelObject> outlet = node.outletModelObject() )
{
boost::optional<ThermalZone> thermalZone;
if( boost::optional<PortList> portList = outlet->optionalCast<PortList>() )
{
thermalZone = portList->thermalZone();
}
if( thermalZone || (outlet->optionalCast<Mixer>() && node.airLoopHVAC()) )
{
if( boost::optional<ModelObject> inlet = node.inletModelObject() )
{
if( boost::optional<Splitter> splitter = inlet->optionalCast<Splitter>() )
{
boost::optional<ModelObject> sourceModelObject = inlet;
boost::optional<unsigned> sourcePort = node.connectedObjectPort(node.inletPort());
if( sourcePort && sourceModelObject )
{
Node inletNode(_model);
ModelObject thisObject = getObject<ModelObject>();
_model.connect( sourceModelObject.get(),
sourcePort.get(),
inletNode,
inletNode.inletPort() );
_model.connect( inletNode,
inletNode.outletPort(),
thisObject,
inletPort() );
_model.connect( thisObject,
outletPort(),
node,
node.inletPort() );
if( thermalZone )
{
Node secondaryInletNode(_model);
PortList exhaustPortList = thermalZone->exhaustPortList();
_model.connect( exhaustPortList,
exhaustPortList.nextPort(),
secondaryInletNode,
secondaryInletNode.inletPort() );
_model.connect( secondaryInletNode,
secondaryInletNode.outletPort(),
thisObject,
secondaryAirInletPort() );
ModelObject mo = this->getObject<ModelObject>();
thermalZone->addEquipment(mo);
}
if( auto airLoopHVAC = node.airLoopHVAC() ) {
auto schedule = airLoopHVAC->availabilitySchedule();
setFanAvailabilitySchedule(schedule);
}
return true;
}
}
}
}
}
return false;
}
