bool Node_Impl::isConnected(const ModelObject & modelObject)
{
if( auto mo = outletModelObject() ) {
if( modelObject.handle() == mo->handle() ) {
return true;
}
}
if( auto mo = inletModelObject() ) {
if( modelObject.handle() == mo->handle() ) {
return true;
}
}
return false;
}
unsigned ZoneHVACEquipmentList_Impl::coolingPriority(const ModelObject & equipment)
{
boost::optional<unsigned> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == equipment.handle() )
{
result = it->getUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence);
break;
}
}
OS_ASSERT(result);
return result.get();
}
WorkspaceExtensibleGroup ZoneHVACEquipmentList_Impl::getGroupForModelObject(const ModelObject & modelObject)
{
boost::optional<WorkspaceExtensibleGroup> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == modelObject.handle() )
{
result = it->cast<WorkspaceExtensibleGroup>();
break;
}
}
OS_ASSERT(result);
return result.get();
}
bool ModelObjectList_Impl::addModelObject(const ModelObject& modelObject ) {
WorkspaceExtensibleGroup eg = getObject<ModelObject>().pushExtensibleGroup().cast<WorkspaceExtensibleGroup>();
bool ok = eg.setPointer(OS_ModelObjectListExtensibleFields::ModelObject,modelObject.handle());
if( !ok ) {
getObject<ModelObject>().eraseExtensibleGroup(eg.groupIndex());
}
return ok;
}
bool ComponentData_Impl::registerObject(const ModelObject& object) {
IdfExtensibleGroup eg = pushExtensibleGroup(StringVector());
bool result = !eg.empty();
if (result) {
ModelExtensibleGroup meg = eg.cast<ModelExtensibleGroup>();
result = result && meg.setPointer(OS_ComponentDataExtensibleFields::NameofObject,
object.handle());
}
return result;
}
TEST_F(ModelFixture, Construction_Clone)
{
Model library;
// Create some materials
StandardOpaqueMaterial exterior(library);
AirGap air(library);
StandardOpaqueMaterial interior(library);
OpaqueMaterialVector layers;
layers.push_back(exterior);
layers.push_back(air);
layers.push_back(interior);
EXPECT_EQ(static_cast<unsigned>(3), library.getModelObjects<Material>().size());
Construction construction(layers);
ASSERT_EQ(static_cast<unsigned>(3), construction.layers().size());
// Clone into same model
ModelObject clone = construction.clone(library);
// Material ResourceObject instances are shared resources so they have not been cloned
EXPECT_EQ(static_cast<unsigned>(3), library.getModelObjects<Material>().size());
// New handle for cloned construction
EXPECT_FALSE(clone.handle() == construction.handle());
ASSERT_TRUE(clone.optionalCast<Construction>());
ASSERT_EQ(static_cast<unsigned>(3), clone.cast<Construction>().layers().size());
// Clone into a differnt model
Model model;
auto clone2 = construction.clone(model).cast<Construction>();
EXPECT_EQ(static_cast<unsigned>(3), model.getModelObjects<Material>().size());
EXPECT_EQ(static_cast<unsigned>(1), model.getModelObjects<Construction>().size());
// Make sure materials are still hooked up
ASSERT_EQ(static_cast<unsigned>(3), clone2.cast<Construction>().layers().size());
// Clone again
auto clone3 = construction.clone(model).cast<Construction>();
EXPECT_EQ(static_cast<unsigned>(3), model.getModelObjects<Material>().size());
EXPECT_EQ(static_cast<unsigned>(2), model.getModelObjects<Construction>().size());
// Make sure materials are still hooked up
ASSERT_EQ(static_cast<unsigned>(3), clone3.cast<Construction>().layers().size());
EXPECT_FALSE(clone2.handle() == clone3.handle());
}
void ZoneHVACEquipmentList_Impl::removeEquipment(const ModelObject & equipment)
{
std::vector<ModelObject> coolingVector = equipmentInCoolingOrder();
std::vector<ModelObject> heatingVector = equipmentInHeatingOrder();
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( std::vector<IdfExtensibleGroup>::iterator it = groups.begin();
it != groups.end();
++it )
{
boost::optional<WorkspaceObject> wo = it->cast<WorkspaceExtensibleGroup>().getTarget(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment);
OS_ASSERT(wo);
if( wo->handle() == equipment.handle() )
{
getObject<ModelObject>().eraseExtensibleGroup(it->groupIndex());
break;
}
}
coolingVector.erase(std::find(coolingVector.begin(),coolingVector.end(),equipment));
heatingVector.erase(std::find(heatingVector.begin(),heatingVector.end(),equipment));
unsigned priority = 1;
for( std::vector<ModelObject>::iterator it = coolingVector.begin();
it != coolingVector.end();
++it )
{
WorkspaceExtensibleGroup eg = getGroupForModelObject(*it);
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence,priority);
priority++;
}
priority = 1;
for( std::vector<ModelObject>::iterator it = heatingVector.begin();
it != heatingVector.end();
++it )
{
WorkspaceExtensibleGroup eg = getGroupForModelObject(*it);
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentHeatingorNoLoadSequence,priority);
priority++;
}
}
void ZoneHVACEquipmentList_Impl::addEquipment(const ModelObject & equipment)
{
unsigned count = this->equipment().size();
WorkspaceExtensibleGroup eg = getObject<ModelObject>().pushExtensibleGroup().cast<WorkspaceExtensibleGroup>();
bool ok = eg.setPointer(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipment,equipment.handle());
if( ok )
{
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentCoolingSequence,count + 1);
eg.setUnsigned(OS_ZoneHVAC_EquipmentListExtensibleFields::ZoneEquipmentHeatingorNoLoadSequence,count + 1);
}
else
{
getObject<ModelObject>().eraseExtensibleGroup(eg.groupIndex());
}
}
ScheduleRule::ScheduleRule(ScheduleRuleset& scheduleRuleset, const ScheduleDay& daySchedule)
: ParentObject(ScheduleRule::iddObjectType(), scheduleRuleset.model())
{
OS_ASSERT(getImpl<detail::ScheduleRule_Impl>());
bool result = setPointer(OS_Schedule_RuleFields::ScheduleRulesetName, scheduleRuleset.handle());
OS_ASSERT(result);
ModelObject clone = daySchedule.clone(scheduleRuleset.model());
result = setPointer(OS_Schedule_RuleFields::DayScheduleName, clone.handle());
OS_ASSERT(result);
if (OptionalScheduleTypeLimits limits = scheduleRuleset.scheduleTypeLimits()) {
clone.cast<ScheduleDay>().setScheduleTypeLimits(*limits);
}
this->setRuleIndex(std::numeric_limits<int>::max());
result = scheduleRuleset.setScheduleRuleIndex(*this, 0);
OS_ASSERT(result);
}
std::vector<ModelObject> getRecursiveChildrenAndResources(const ModelObject& object) {
std::set<Handle> resultSet;
std::pair<HandleSet::const_iterator,bool> insertResult;
std::vector<ModelObject> result;
resultSet.insert(object.handle());
result.push_back(object);
std::deque<ModelObject> objectQueue;
objectQueue.push_back(object);
while (objectQueue.size() > 0) {
ModelObject currentObject(objectQueue[0]);
objectQueue.pop_front();
// resources
for (const ResourceObject& resource : currentObject.resources()) {
insertResult = resultSet.insert(resource.handle());
if (insertResult.second) {
// new object
ModelObject mo = resource.cast<ModelObject>();
result.push_back(mo);
objectQueue.push_back(mo);
}
}
// children
OptionalParentObject opo = currentObject.optionalCast<ParentObject>();
if (opo) {
ParentObject currentParent(*opo);
for (const ModelObject& child : currentParent.children()) {
insertResult = resultSet.insert(child.handle());
if (insertResult.second) {
// new object
result.push_back(child);
objectQueue.push_back(child);
}
}
}
}
return result;
}
WorkspaceExtensibleGroup ModelObjectList_Impl::getGroupForModelObject(const ModelObject& modelObject)
{
boost::optional<WorkspaceExtensibleGroup> result;
std::vector<IdfExtensibleGroup> groups = extensibleGroups();
for( const auto & group : groups )
{
boost::optional<WorkspaceObject> wo = group.cast<WorkspaceExtensibleGroup>().getTarget(OS_ModelObjectListExtensibleFields::ModelObject);
OS_ASSERT(wo);
if( wo->handle() == modelObject.handle() )
{
result = group.cast<WorkspaceExtensibleGroup>();
break;
}
}
OS_ASSERT(result);
return result.get();
}
bool Connection_Impl::setTargetObject(ModelObject object)
{
return setPointer(openstudio::OS_ConnectionFields::TargetObject,object.handle());;
}
void Connection_Impl::setSourceObject(ModelObject object)
{
setPointer(openstudio::OS_ConnectionFields::SourceObject,object.handle());
}
bool ExternalInterfaceFunctionalMockupUnitImportToActuator_Impl::setActuatedComponentUnique(const ModelObject& modelObject) {
bool result = setPointer(OS_ExternalInterface_FunctionalMockupUnitImport_To_ActuatorFields::ActuatedComponentUniqueName, modelObject.handle());
return result;
}
bool RefrigerationSystem_Impl::setRefrigerationCondenser(const ModelObject& refrigerationCondenser) {
bool result = setPointer(OS_Refrigeration_SystemFields::RefrigerationCondenserName, refrigerationCondenser.handle());
return result;
}
