static void simulate_mappoints(void)
{
Construction *construction;
constructionCount.shuffle();
for (int i = 0; i < constructionCount.size(); i++)
{
construction = constructionCount[i];
if (construction)
{
construction->trade();
construction->update();
}
}
for(std::list<Vehicle*>::iterator it = Vehicle::vehicleList.begin();
it != Vehicle::vehicleList.end();
std::advance(it,1))
{
if((*it)->alive)
{
(*it)->update();
}
/*
if(rand()%50 == 1)
{
delete *it;
break;
}
*/
}
}
void Preprocessor::new_window()
{
Construction *cn = new Construction();
this->window()->hide();
cn->show();
}
TEST_F(EnergyPlusFixture,ReverseTranslator_WindowConstruction)
{
StrictnessLevel level(StrictnessLevel::Draft);
IddFileType iddFileType(IddFileType::EnergyPlus);
Workspace workspace(level,iddFileType);
IdfObject glazing(IddObjectType::WindowMaterial_Glazing);
IdfObject gas(IddObjectType::WindowMaterial_Gas);
glazing.setName("Glazing Material");
gas.setName("Gas Material");
IdfObject construction(IddObjectType::Construction);
ASSERT_EQ(0u,construction.numExtensibleGroups());
EXPECT_FALSE(construction.pushExtensibleGroup(StringVector(1u,glazing.name().get())).empty());
EXPECT_FALSE(construction.pushExtensibleGroup(StringVector(1u,gas.name().get())).empty());
EXPECT_FALSE(construction.pushExtensibleGroup(StringVector(1u,glazing.name().get())).empty());
IdfObjectVector objects;
objects.push_back(glazing);
objects.push_back(gas);
objects.push_back(construction);
EXPECT_EQ(3u,workspace.addObjects(objects).size());
ReverseTranslator reverseTranslator;
Model model = reverseTranslator.translateWorkspace(workspace);
ASSERT_EQ(1u, model.getModelObjects<Construction>().size());
Construction mConstruction = model.getModelObjects<Construction>()[0];
EXPECT_EQ(3u,mConstruction.layers().size());
EXPECT_EQ(2u, model.getModelObjects<FenestrationMaterial>().size());
}
boost::optional<IdfObject> ForwardTranslator::translateConstruction( Construction & modelObject )
{
IdfObject construction( openstudio::IddObjectType::Construction );
m_idfObjects.push_back(construction);
for (LifeCycleCost lifeCycleCost : modelObject.lifeCycleCosts()){
translateAndMapModelObject(lifeCycleCost);
}
construction.setName(modelObject.name().get());
MaterialVector layers = modelObject.layers();
unsigned fieldIndex = 1;
for(unsigned layerIndex = 0; layerIndex < layers.size(); ++layerIndex ) {
Material material = layers[layerIndex];
translateAndMapModelObject(material);
construction.setString(fieldIndex++, material.name().get());
}
return boost::optional<IdfObject>(construction);
}
TEST_F(ModelFixture,ResourceObject_Clone) {
Model original;
Construction construction(original);
construction.standardsInformation();
StandardOpaqueMaterial material(original);
bool ok = construction.setLayers(MaterialVector(1u,material));
EXPECT_TRUE(ok);
EXPECT_EQ(3u,original.numObjects()) << original;
EXPECT_EQ(1u,construction.numLayers()) << construction;
// clone into original
Construction newConstruction = construction.clone(original).cast<Construction>();
// self cloned
EXPECT_FALSE(newConstruction == construction);
EXPECT_TRUE(newConstruction.model() == construction.model());
// child cloned
EXPECT_EQ(2u,original.getModelObjects<StandardsInformationConstruction>().size()) << original;
EXPECT_FALSE(newConstruction.standardsInformation() == construction.standardsInformation());
EXPECT_EQ(2u,original.getModelObjects<StandardsInformationConstruction>().size()) << original;
// resource not cloned
EXPECT_EQ(1u,newConstruction.numLayers());
EXPECT_TRUE(newConstruction.layers() == construction.layers());
EXPECT_EQ(5u,original.numObjects()) << original;
// clone into new model
Model newModel;
newConstruction = construction.clone(newModel).cast<Construction>();
EXPECT_FALSE(newConstruction.model() == construction.model());
EXPECT_EQ(3u,newModel.numObjects()) << newModel;
EXPECT_EQ("Material 1",newConstruction.layers()[0].name().get());
// clone again -- object and child added again, resource reused
Construction anotherNewConstruction = construction.clone(newModel).cast<Construction>();
EXPECT_FALSE(anotherNewConstruction == newConstruction);
EXPECT_EQ(5u,newModel.numObjects()) << newModel;
EXPECT_EQ("Material 1",anotherNewConstruction.layers()[0].name().get());
// change resource data
newConstruction.layers()[0].setName("Material with Changed Data");
// clone again -- all added again
anotherNewConstruction = construction.clone(newModel).cast<Construction>();
EXPECT_EQ(8u,newModel.numObjects()) << newModel;
EXPECT_EQ("Material with Changed Data",newConstruction.layers()[0].name().get());
EXPECT_EQ("Material 1",anotherNewConstruction.layers()[0].name().get());
}
void connect_transport(int originx, int originy, int w, int h)
{
// sets the correct TYPE depending on neighbours, => gives the correct tile to display
static const short power_table[16] = {
0, 1, 0, 2,
0, 3, 0, 4,
1, 1, 5, 6,
7, 8, 9, 10
};
static const short table[16] = {
0, 0, 1, 2,
0, 0, 3, 4,
1, 5, 1, 6,
7, 8, 9, 10
};
Construction *cstr = 0;
/* Adjust originx,originy,w,h to proper range */
if (originx <= 0)
{
originx = 1;
w -= 1 - originx;
}
if (originy <= 0)
{
originy = 1;
h -= 1 - originy;
}
if (originx + w >= world.len())
{ w = world.len() - originx;}
if (originy + h >= world.len())
{ h = world.len() - originy;}
for (int y = originy; y < originy+h; ++y)
{
for (int x = originx; x < originx+w; ++x)
{
// First, set up a mask according to directions
cstr = world(x, y)->construction;
int mask = 0;
switch (world(x, y)->getGroup())
{
case GROUP_POWER_LINE:
{
bool far = false;
int mwh = -1;
world(x,y)->reportingConstruction->deneighborize();
/* up -- (ThMO) */
mwh = world(x, y-1)->reportingConstruction?
world(x, y-1)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
if ((far = ((y > 1) && (world(x, y-1)->is_water() || world(x, y-1)->is_transport()))))
{
mwh = world(x, y-2)->reportingConstruction?
world(x, y-2)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
}
if(mwh != -1)
{
if (far) //suspended cables
{
//opposite edge
if (!world(x, y-2)->reportingConstruction->countPowercables(1))
{
world(x, y-1)->flags |= FLAG_POWER_CABLES_0;
cstr->link_to(world(x,y-2)->reportingConstruction);
mask |=8;
}
}
else
{
cstr->link_to(world(x,y-1)->reportingConstruction);
mask |=8;
}
}
else
{ world(x, y-1)->flags &= ~FLAG_POWER_CABLES_0;}
/* left -- (ThMO) */
mwh = world(x-1, y)->reportingConstruction?
world(x-1, y)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
if((far = ((x > 1) && (world(x-1, y)->is_water() || world(x-1, y)->is_transport()))))
{
mwh = world(x-2, y)->reportingConstruction?
world(x-2, y)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
}
if(mwh != -1)
{
if (far) //suspended cables
{
//opposite edge
if ( !world(x-2, y)->reportingConstruction->countPowercables(2) )
{
cstr->link_to(world(x-2,y)->reportingConstruction);
world(x-1, y)->flags |= FLAG_POWER_CABLES_90;
mask |=4;
}
}
else
{
cstr->link_to(world(x-1,y)->reportingConstruction);
mask |=4;
}
}
else
{ world(x-1, y)->flags &= ~FLAG_POWER_CABLES_90;}
/* right -- (ThMO) */
mwh = world(x+1, y)->reportingConstruction?
world(x+1, y)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
if ((far = ((x < world.len() - 2) && (world(x+1, y)->is_water() || world(x+1, y)->is_transport()))))
{
mwh = world(x+2, y)->reportingConstruction?
world(x+2, y)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
}
if(mwh != -1)
{
if (far) //suspended cables
{
//opposite edge
if ( !world(x+2, y)->reportingConstruction->countPowercables(4) )
{
cstr->link_to(world(x+2,y)->reportingConstruction);
world(x+1, y)->flags |= FLAG_POWER_CABLES_90;
mask |=2;
}
}
else
{
cstr->link_to(world(x+1,y)->reportingConstruction);
mask |=2;
}
}
else
{ world(x+1, y)->flags &= ~FLAG_POWER_CABLES_90;}
/* down -- (ThMO) */
mwh = world(x, y+1)->reportingConstruction?
world(x, y+1)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;
if ((far = (y < world.len() - 2) && (world(x, y+1)->is_water() || world(x, y+1)->is_transport())))
{
mwh = world(x, y+2)->reportingConstruction?
world(x, y+2)->reportingConstruction->tellstuff(Construction::STUFF_MWH, -2):-1;}
if(mwh != -1)
{
if (far) //suspended cables
{
//opposite edge
if ( !world(x, y+2)->reportingConstruction->countPowercables(8) )
{
cstr->link_to(world(x,y+2)->reportingConstruction);
world(x, y+1)->flags |= FLAG_POWER_CABLES_0;
mask |=1;
}
}
else
{
cstr->link_to(world(x,y+1)->reportingConstruction);
mask |=1;
}
}
else
{ world(x, y+1)->flags &= ~FLAG_POWER_CABLES_0;}
cstr->type = power_table[mask];
break;
}
case GROUP_TRACK:
if (check_group(x, y - 1) == GROUP_TRACK
|| check_group(x, y - 1) == GROUP_ROAD
|| (check_group(x, y - 1) == GROUP_RAIL && //rail crossing
check_group(x, y - 2) == GROUP_TRACK))
{ mask |= 2;}
if (check_group(x - 1, y) == GROUP_TRACK
|| check_group(x - 1, y) == GROUP_ROAD
|| (check_group(x - 1, y) == GROUP_RAIL && //rail crossing
check_group(x - 2, y) == GROUP_TRACK))
{ mask |= 1;}
switch (check_topgroup(x + 1, y))
{
case GROUP_RAIL:
if(check_group(x + 2, y) != GROUP_TRACK)
{ break;}
case GROUP_ROAD:
case GROUP_TRACK:
case GROUP_TRACK_BRIDGE:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 4;
break;
}
switch (check_topgroup(x, y + 1))
{
case GROUP_RAIL:
if(check_group(x, y + 2) != GROUP_TRACK)
{ break;}
case GROUP_ROAD:
case GROUP_TRACK:
case GROUP_TRACK_BRIDGE:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 8;
break;
}
// A track section between 2 bridge sections
// in this special case we use a pillar bridge section with green
if ((check_group(x, y-1) == GROUP_TRACK_BRIDGE && (
check_group(x, y+1) == GROUP_TRACK_BRIDGE || check_group(x, y+2) == GROUP_TRACK_BRIDGE))
|| (check_group(x, y+1) == GROUP_TRACK_BRIDGE && (
check_group(x, y-1) == GROUP_TRACK_BRIDGE || check_group(x, y-2) == GROUP_TRACK_BRIDGE)))
{ cstr->type = 11;}
else if ((check_group(x-1, y) == GROUP_TRACK_BRIDGE && (
check_group(x+1, y) == GROUP_TRACK_BRIDGE || check_group(x+2, y) == GROUP_TRACK_BRIDGE))
|| (check_group(x+1, y) == GROUP_TRACK_BRIDGE && (
check_group(x-1, y) == GROUP_TRACK_BRIDGE || check_group(x-2, y) == GROUP_TRACK_BRIDGE)))
{ cstr->type = 12;}
// Set according bridge entrance if any
else if (check_group(x, y-1) == GROUP_TRACK_BRIDGE)
{ cstr->type = 13;}
else if (check_group(x-1, y) == GROUP_TRACK_BRIDGE)
{ cstr->type = 14;}
else if (check_group(x, y+1) == GROUP_TRACK_BRIDGE)
{ cstr->type = 15;}
else if (check_group(x+1, y) == GROUP_TRACK_BRIDGE)
{ cstr->type = 16;}
else if (check_group(x+1, y) == GROUP_RAIL &&
check_group(x-1, y) == GROUP_RAIL &&
check_group(x, y+1) == GROUP_TRACK &&
check_group(x, y-1) == GROUP_TRACK)
{
railConstructionGroup.placeItem(x,y);
cstr = world(x,y)->construction;
cstr->type = 21;
y = originy;
}
else if (check_group(x, y+1) == GROUP_RAIL &&
check_group(x, y-1) == GROUP_RAIL &&
check_group(x+1, y) == GROUP_TRACK &&
check_group(x-1, y) == GROUP_TRACK)
{
railConstructionGroup.placeItem(x,y);
cstr = world(x,y)->construction;
cstr->type = 22;
x = originx;
}
else
{ cstr->type = table[mask];}
//only brige entrances (and bridges) are transparent
if (cstr->type >= 11 && cstr->type <= 12)
{ cstr->flags |= FLAG_TRANSPARENT;}
else
{ cstr->flags &= (~FLAG_TRANSPARENT);}
break;
case GROUP_TRACK_BRIDGE:
// Bridge neighbour priority
if (check_group(x, y-1) == GROUP_TRACK_BRIDGE || check_group(x, y+1) == GROUP_TRACK_BRIDGE
|| check_group(x, y-1) == GROUP_TRACK || check_group(x, y+1) == GROUP_TRACK)
{
mask |= 2;
cstr->type = 0;
}
else if (check_group(x-1, y) == GROUP_TRACK_BRIDGE || check_group(x+1, y) == GROUP_TRACK_BRIDGE
|| check_group(x-1, y) == GROUP_TRACK || check_group(x+1, y) == GROUP_TRACK)
{
mask |= 1;
cstr->type = 1;
}
else //a lonely bridge tile
{ cstr->type = 1;}
cstr->flags |= FLAG_TRANSPARENT;
break;
case GROUP_ROAD:
if (check_group(x, y - 1) == GROUP_ROAD
|| check_group(x, y - 1) == GROUP_TRACK
|| (check_group(x, y - 1) == GROUP_RAIL && //rail crossing
check_group(x, y - 2) == GROUP_ROAD))
{ mask |= 2;}
if (check_group(x - 1, y) == GROUP_ROAD
|| check_group(x - 1, y) == GROUP_TRACK
|| (check_group(x - 1, y) == GROUP_RAIL && //rail crossing
check_group(x - 2, y) == GROUP_ROAD))
{ mask |= 1;}
switch (check_topgroup(x + 1, y))
{
case GROUP_RAIL:
if(check_group(x + 2, y) != GROUP_ROAD)
{ break;}
case GROUP_TRACK:
case GROUP_ROAD:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 4;
break;
}
switch (check_topgroup(x, y + 1))
{
case GROUP_RAIL:
if(check_group(x, y + 2) != GROUP_ROAD)
{ break;}
case GROUP_TRACK:
case GROUP_ROAD:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 8;
break;
}
// A road section between 2 bridge sections
// in this special case we use a pillar bridge section with green
if ((check_group(x, y-1) == GROUP_ROAD_BRIDGE && (
check_group(x, y+1) == GROUP_ROAD_BRIDGE || check_group(x, y+2) == GROUP_ROAD_BRIDGE))
|| (check_group(x, y+1) == GROUP_ROAD_BRIDGE && (
check_group(x, y-1) == GROUP_ROAD_BRIDGE || check_group(x, y-2) == GROUP_ROAD_BRIDGE)))
{ cstr->type = 11;}
else if ((check_group(x-1, y) == GROUP_ROAD_BRIDGE && (
check_group(x+1, y) == GROUP_ROAD_BRIDGE || check_group(x+2, y) == GROUP_ROAD_BRIDGE))
|| (check_group(x+1, y) == GROUP_ROAD_BRIDGE && (
check_group(x-1, y) == GROUP_ROAD_BRIDGE || check_group(x-2, y) == GROUP_ROAD_BRIDGE)))
{ cstr->type = 12;}
// Build bridge entrance2
else if (check_group(x, y-1) == GROUP_ROAD_BRIDGE)
{ cstr->type = 13;}
else if (check_group(x-1, y) == GROUP_ROAD_BRIDGE)
{ cstr->type = 14;}
else if (check_group(x, y+1) == GROUP_ROAD_BRIDGE)
{ cstr->type = 15;}
else if (check_group(x+1, y) == GROUP_ROAD_BRIDGE)
{ cstr->type = 16;}
// Build bridge entrance1
else if (check_group(x, y-2) == GROUP_ROAD_BRIDGE && check_group(x, y-1) == GROUP_ROAD)
{ cstr->type = 17;}
else if (check_group(x-2, y) == GROUP_ROAD_BRIDGE && check_group(x-1, y) == GROUP_ROAD)
{ cstr->type = 18;}
else if (check_group(x, y+2) == GROUP_ROAD_BRIDGE && check_group(x, y+1) == GROUP_ROAD)
{ cstr->type = 19;}
else if (check_group(x+2, y) == GROUP_ROAD_BRIDGE && check_group(x+1, y) == GROUP_ROAD)
{ cstr->type = 20;}
else if (check_group(x+1, y) == GROUP_RAIL &&
check_group(x-1, y) == GROUP_RAIL &&
check_group(x, y+1) == GROUP_ROAD &&
check_group(x, y-1) == GROUP_ROAD)
{
railConstructionGroup.placeItem(x,y);
cstr = world(x,y)->construction;
cstr->type = 23;
y = originy;
}
else if (check_group(x, y+1) == GROUP_RAIL &&
check_group(x, y-1) == GROUP_RAIL &&
check_group(x+1, y) == GROUP_ROAD &&
check_group(x-1, y) == GROUP_ROAD)
{
railConstructionGroup.placeItem(x,y);
cstr = world(x,y)->construction;
cstr->type = 24;
x = originx;
}
else
{ cstr->type = table[mask];}
if(cstr->type >= 11 && cstr->type <= 16)
{ cstr->flags |= FLAG_TRANSPARENT;}
else
{ cstr->flags &= (~FLAG_TRANSPARENT);}
break;
case GROUP_ROAD_BRIDGE:
// Bridge neighbour priority
if (check_group(x, y-1) == GROUP_ROAD_BRIDGE || check_group(x, y+1) == GROUP_ROAD_BRIDGE)
{ cstr->type = 0;}
else if (check_group(x-1, y) == GROUP_ROAD_BRIDGE || check_group(x+1, y) == GROUP_ROAD_BRIDGE)
{ cstr->type = 1;}
else if (check_group(x, y-1) == GROUP_ROAD || check_group(x, y+1) == GROUP_ROAD)
{ world(x, y)->construction->type = 0;}//2
else if (check_group(x-1, y) == GROUP_ROAD || check_group(x+1, y) == GROUP_ROAD)
{ world(x, y)->construction->type = 1;}//3
else
{ cstr->type = 1;}
cstr->flags |= FLAG_TRANSPARENT;
break;
case GROUP_RAIL:
if (check_group(x, y - 1) == GROUP_RAIL)
{ mask |= 2;}
if (check_group(x - 1, y) == GROUP_RAIL)
{ mask |= 1;}
switch (check_topgroup(x + 1, y)) {
case GROUP_RAIL:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 4;
break;
}
switch (check_topgroup(x, y + 1)) {
case GROUP_RAIL:
case GROUP_COMMUNE:
case GROUP_COALMINE:
case GROUP_OREMINE:
case GROUP_INDUSTRY_L:
case GROUP_INDUSTRY_H:
case GROUP_RECYCLE:
case GROUP_TIP:
case GROUP_PORT:
case GROUP_COAL_POWER:
mask |= 8;
break;
}
// A rail section between 2 bridge sections
// in this special case we use a pillar bridge section with green
if ((check_group(x, y-1) == GROUP_RAIL_BRIDGE && (
check_group(x, y+1) == GROUP_RAIL_BRIDGE || check_group(x, y+2) == GROUP_RAIL_BRIDGE))
|| (check_group(x, y+1) == GROUP_RAIL_BRIDGE && (
check_group(x, y-1) == GROUP_RAIL_BRIDGE || check_group(x, y-2) == GROUP_RAIL_BRIDGE)))
{ cstr->type = 11;}
else if ((check_group(x-1, y) == GROUP_RAIL_BRIDGE && (
check_group(x+1, y) == GROUP_RAIL_BRIDGE || check_group(x+2, y) == GROUP_RAIL_BRIDGE))
|| (check_group(x+1, y) == GROUP_RAIL_BRIDGE && (
check_group(x-1, y) == GROUP_RAIL_BRIDGE || check_group(x-2, y) == GROUP_RAIL_BRIDGE)))
{ cstr->type = 12;}
// Build bridge entrance2
else if (check_group(x, y-1) == GROUP_RAIL_BRIDGE)
{ cstr->type = 13;}
else if (check_group(x-1, y) == GROUP_RAIL_BRIDGE)
{ cstr->type = 14;}
else if (check_group(x, y+1) == GROUP_RAIL_BRIDGE)
{ cstr->type = 15;}
else if (check_group(x+1, y) == GROUP_RAIL_BRIDGE)
{ cstr->type = 16;}
// Build bridge entrance1
else if (check_group(x, y-2) == GROUP_RAIL_BRIDGE && check_group(x, y-1) == GROUP_RAIL)
{ cstr->type = 17;}
else if (check_group(x-2, y) == GROUP_RAIL_BRIDGE && check_group(x-1, y) == GROUP_RAIL)
{ cstr->type = 18;}
else if (check_group(x, y+2) == GROUP_RAIL_BRIDGE && check_group(x, y+1) == GROUP_RAIL)
{ cstr->type = 19;}
else if (check_group(x+2, y) == GROUP_RAIL_BRIDGE && check_group(x+1, y) == GROUP_RAIL)
{ cstr->type = 20;}
//railroad crossings
else if (check_group(x+1, y) == GROUP_TRACK &&
check_group(x-1, y) == GROUP_TRACK)
{ cstr->type = 22; }
else if (check_group(x, y+1) == GROUP_TRACK &&
check_group(x, y-1) == GROUP_TRACK)
{ cstr->type = 21; }
else if (check_group(x+1, y) == GROUP_ROAD &&
check_group(x-1, y) == GROUP_ROAD)
{ cstr->type = 24; }
else if (check_group(x, y+1) == GROUP_ROAD &&
check_group(x, y-1) == GROUP_ROAD)
{ cstr->type = 23; }
else
{ cstr->type = table[mask];}
if(cstr->type >= 11 && cstr->type <= 16)
{ cstr->flags |= FLAG_TRANSPARENT;}
else
{ cstr->flags &= (~FLAG_TRANSPARENT);}
break;
case GROUP_RAIL_BRIDGE:
// Bridge neighbour priority
if (check_group(x, y-1) == GROUP_RAIL_BRIDGE || check_group(x, y+1) == GROUP_RAIL_BRIDGE
|| check_group(x, y-1) == GROUP_RAIL || check_group(x, y+1) == GROUP_RAIL)
{ cstr->type = 0;}
else if (check_group(x-1, y) == GROUP_RAIL_BRIDGE || check_group(x+1, y) == GROUP_RAIL_BRIDGE
|| check_group(x-1, y) == GROUP_RAIL || check_group(x+1, y) == GROUP_RAIL)
{ cstr->type = 1;}
else
{ cstr->type = 1;}
cstr->flags |= FLAG_TRANSPARENT;
break;
/* // now handled by desert_water_frontiers
case GROUP_WATER:
if ( ((y > 0) && (world(x, y-1)->getGroup() == GROUP_PORT))
|| check_water(x, y - 1))
{ mask |= 8;}
if ( ((x > 0) && (world(x - 1, y)->getGroup() == GROUP_PORT))
|| check_water(x - 1, y))
{ mask |= 4;}
if (check_water(x + 1, y))
{ mask |= 2;}
if (check_water(x, y + 1))
{ mask |= 1;}
world(x, y)->type = mask;
break;
*/
} /* end switch */
} /* end for y*/
} /* end for x*/
}
TEST_F(ModelFixture, Construction_AddObjects) {
IdfFile idfFile; // OpenStudio Idd is default
// Can still use name references directly in IdfObjects. Will get turned into pointer/by handle
// references on import into Workspace.
IdfObject object(IddObjectType::OS_Construction);
object.setName("Exterior Wall");
unsigned index = OS_ConstructionFields::SurfaceRenderingName + 1;
object.setString(index,"M01 100mm brick"); ++index;
object.setString(index,"M15 200mm heavyweight concrete"); ++index;
object.setString(index,"I02 50mm insulation board"); ++index;
object.setString(index,"F04 Wall air space resistance"); ++index;
object.setString(index,"G01a 19mm gypsum board"); ++index;
idfFile.addObject(object);
object = IdfObject(IddObjectType::OS_Material);
object.setName("M01 100mm brick");
object.setString(OS_MaterialFields::Roughness,"MediumRough");
object.setDouble(OS_MaterialFields::Thickness,0.1016);
object.setDouble(OS_MaterialFields::Conductivity,0.89);
object.setDouble(OS_MaterialFields::Density,1920.0);
object.setDouble(OS_MaterialFields::SpecificHeat,790.0);
idfFile.addObject(object);
object = IdfObject(IddObjectType::OS_Material);
object.setName("M15 200mm heavyweight concrete");
object.setString(OS_MaterialFields::Roughness,"MediumRough");
object.setDouble(OS_MaterialFields::Thickness,0.2032);
object.setDouble(OS_MaterialFields::Conductivity,1.95);
object.setDouble(OS_MaterialFields::Density,2240.0);
object.setDouble(OS_MaterialFields::SpecificHeat,900.0);
idfFile.addObject(object);
object = IdfObject(IddObjectType::OS_Material);
object.setName("I02 50mm insulation board");
object.setString(OS_MaterialFields::Roughness,"MediumRough");
object.setDouble(OS_MaterialFields::Thickness,0.0508);
object.setDouble(OS_MaterialFields::Conductivity,0.03);
object.setDouble(OS_MaterialFields::Density,43.0);
object.setDouble(OS_MaterialFields::SpecificHeat,1210.0);
idfFile.addObject(object);
object = IdfObject(IddObjectType::OS_Material_AirGap);
object.setName("F04 Wall air space resistance");
object.setDouble(OS_Material_AirGapFields::ThermalResistance,0.15);
idfFile.addObject(object);
object = IdfObject(IddObjectType::OS_Material);
object.setName("G01a 19mm gypsum board");
object.setString(OS_MaterialFields::Roughness,"MediumSmooth");
object.setDouble(OS_MaterialFields::Thickness,0.019);
object.setDouble(OS_MaterialFields::Conductivity,0.16);
object.setDouble(OS_MaterialFields::Density,800.0);
object.setDouble(OS_MaterialFields::SpecificHeat,1090.0);
idfFile.addObject(object);
// first add to a workspace
Workspace workspace(StrictnessLevel::Draft, IddFileType::OpenStudio);
workspace.addObjects(idfFile.objects());
EXPECT_EQ(workspace.numObjects(), idfFile.numObjects());
ASSERT_EQ(1u, workspace.getObjectsByType(IddObjectType::OS_Construction).size());
WorkspaceObject workspaceObject = workspace.getObjectsByType(IddObjectType::OS_Construction)[0];
ASSERT_EQ(8u, workspaceObject.numFields());
for (int i = 3; i < 8; ++i){
EXPECT_FALSE(workspaceObject.isEmpty(i)) << "Index " << i << " is empty for:" << std::endl << workspaceObject;
}
// now add to a model
Model model;
model.addObjects(idfFile.objects());
EXPECT_EQ(model.numObjects(), idfFile.numObjects());
ASSERT_EQ(1u, model.getModelObjects<Construction>().size());
Construction construction = model.getModelObjects<Construction>()[0];
ASSERT_EQ(8u, construction.numFields());
for (int i = 3; i < 8; ++i){
EXPECT_FALSE(construction.isEmpty(i)) << "Index " << i << " is empty for:" << std::endl << construction;
}
ASSERT_EQ(5u, construction.layers().size());
std::vector<Material> layers = construction.layers();
for (int i = 0; i < 5; ++i){
EXPECT_TRUE(layers[i].name()) << "Layer " << i << " has no name:" << std::endl << layers[i];
}
}
