public static void UpdateSizingFactors(this Building building, BuildingModel buildingModel)
{
if (building == null || buildingModel == null)
{
return;
}
List <Space> spaces = buildingModel.GetSpaces();
if (spaces == null || spaces.Count == 0)
{
return;
}
double heatingSizingFactor = double.NaN;
if (!buildingModel.TryGetValue(BuildingModelParameter.HeatingSizingFactor, out heatingSizingFactor))
{
heatingSizingFactor = double.NaN;
}
double coolingSizingFactor = double.NaN;
if (!buildingModel.TryGetValue(BuildingModelParameter.CoolingSizingFactor, out coolingSizingFactor))
{
coolingSizingFactor = double.NaN;
}
UpdateSizingFactors(building, spaces, heatingSizingFactor, coolingSizingFactor);
}
public static AnyOf <Ground, Outdoors, Adiabatic, Surface> ToLadybugTools_BoundaryCondition(this IPartition partition, BuildingModel buildingModel, Space space)
{
if (partition == null || buildingModel == null)
{
return(null);
}
if (partition is IHostPartition)
{
if (((IHostPartition)partition).Adiabatic())
{
return(new Adiabatic());
}
}
if (buildingModel.External(partition))
{
return(new Outdoors());
}
if (buildingModel.Underground(partition))
{
if (!buildingModel.Internal(partition))
{
return(new Ground());
}
}
int index_Adjacent = -1;
List <Space> spaces = null;
if (partition != null)
{
spaces = buildingModel.GetSpaces(partition);
if (spaces != null && spaces.Count != 0)
{
index_Adjacent = spaces.FindIndex(x => x.Guid != space.Guid);
index_Adjacent = buildingModel.UniqueIndex(spaces[index_Adjacent]);
}
}
if (index_Adjacent == -1)
{
return(null);
}
//boundaryConditionObjects have to be provided
//https://www.ladybug.tools/honeybee-schema/model.html#tag/surface_model
List <string> uniqueNames = new List <string>();
uniqueNames.Add(Query.UniqueName(partition, index_Adjacent));
uniqueNames.Add(Query.UniqueName(spaces[index_Adjacent]));
return(new Surface(uniqueNames));
}
public static List <Core.Result> AddResults(this SimulationData simulationData, BuildingModel buildingModel)
{
if (simulationData == null || buildingModel == null)
{
return(null);
}
List <Core.Result> result = null;
//get simulaton data from Tas for individal SAM Space
List <Core.Result> results = Convert.ToSAM(simulationData);
if (results == null)
{
return(result);
}
result = new List <Core.Result>(results);
Dictionary <System.Guid, List <SpaceSimulationResult> > dictionary = new Dictionary <System.Guid, List <SpaceSimulationResult> >();
List <Space> spaces = buildingModel.GetSpaces();
if (spaces != null && spaces.Count > 0)
{
foreach (Space space in spaces)
{
List <SpaceSimulationResult> spaceSimulationResults_Space = results.FindAll(x => x is SpaceSimulationResult && space.Name.Equals(x.Name)).ConvertAll(x => (SpaceSimulationResult)x);
dictionary[space.Guid] = spaceSimulationResults_Space;
if (spaceSimulationResults_Space != null && spaceSimulationResults_Space.Count > 0)
{
foreach (SpaceSimulationResult spaceSimulationResult in spaceSimulationResults_Space)
{
buildingModel.Add(spaceSimulationResult, space.Guid);
}
}
}
}
// get data data about SAM Zones like space GUID, Zone Category etc.
List <Zone> zones = buildingModel.GetZones();
if (zones != null && zones.Count > 0)
{
// Query Tas Zones, that can be linked with SAM Spaces
BuildingData buildingData = simulationData.GetBuildingData();
Dictionary <string, ZoneData> dictionary_ZoneData = Query.ZoneDataDictionary(buildingData);
// Our SAM Zones(list of Space GUIDs)
foreach (Zone zone in zones)
{
List <Space> spaces_Zone = buildingModel.GetSpaces(zone);
if (spaces_Zone == null || spaces_Zone.Count == 0)
{
continue;
}
double area = buildingModel.Sum(zone, SpaceParameter.Area);
double volume = buildingModel.Sum(zone, SpaceParameter.Volume);
double occupancy = buildingModel.Sum(zone, SpaceParameter.Occupancy);
List <ZoneData> zoneDatas = new List <ZoneData>();
foreach (Space space in spaces_Zone)
{
string name = space?.Name;
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
List <SpaceSimulationResult> spaceSimulationResults_Space;
if (!dictionary.TryGetValue(space.Guid, out spaceSimulationResults_Space) || spaceSimulationResults_Space == null || spaceSimulationResults_Space.Count == 0)
{
continue;
}
SpaceSimulationResult spaceSimulationResult = spaceSimulationResults_Space[0];
if (spaceSimulationResult == null || string.IsNullOrWhiteSpace(spaceSimulationResult.Reference))
{
continue;
}
ZoneData zoneData = dictionary_ZoneData[spaceSimulationResult.Reference];
if (zoneData == null)
{
continue;
}
zoneDatas.Add(zoneData);
}
int index;
double max;
//Cooling
ZoneSimulationResult zoneSimulationResult_Cooling = null;
if (buildingData.TryGetMax(zoneDatas.ConvertAll(x => x.zoneGUID), tsdZoneArray.coolingLoad, out index, out max) && index != -1 && !double.IsNaN(max))
{
zoneSimulationResult_Cooling = new ZoneSimulationResult(zone.Name, Assembly.GetExecutingAssembly().GetName()?.Name, zone.Guid.ToString());
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.MaxSensibleLoad, max);
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.MaxSensibleLoadIndex, index);
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.LoadType, LoadType.Cooling.Text());
List <SpaceSimulationResult> spaceSimulationResults_Zone = new List <SpaceSimulationResult>();
foreach (ZoneData zoneData in zoneDatas)
{
SpaceSimulationResult spaceSimulationResult_Temp = Create.SpaceSimulationResult(zoneData, index, LoadType.Cooling, SizingMethod.Simulation);
if (spaceSimulationResult_Temp == null)
{
continue;
}
spaceSimulationResults_Zone.Add(spaceSimulationResult_Temp);
}
if (spaceSimulationResults_Zone != null && spaceSimulationResults_Zone.Count != 0)
{
double airMovementGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.AirMovementGain);
if (!double.IsNaN(airMovementGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.AirMovementGain, airMovementGain);
}
double buildingHeatTransfer = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.BuildingHeatTransfer);
if (!double.IsNaN(buildingHeatTransfer))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.BuildingHeatTransfer, buildingHeatTransfer);
}
double equipmentSensibleGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.EquipmentSensibleGain);
if (!double.IsNaN(equipmentSensibleGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.EquipmentSensibleGain, equipmentSensibleGain);
}
double glazingExternalConduction = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.GlazingExternalConduction);
if (!double.IsNaN(glazingExternalConduction))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.GlazingExternalConduction, glazingExternalConduction);
}
double lightingGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.LightingGain);
if (!double.IsNaN(lightingGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.LightingGain, lightingGain);
}
double infiltrationGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.InfiltrationGain);
if (!double.IsNaN(infiltrationGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.InfiltrationGain, infiltrationGain);
}
double occupancySensibleGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.OccupancySensibleGain);
if (!double.IsNaN(occupancySensibleGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.OccupancySensibleGain, occupancySensibleGain);
}
double opaqueExternalConduction = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.OpaqueExternalConduction);
if (!double.IsNaN(opaqueExternalConduction))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.OpaqueExternalConduction, opaqueExternalConduction);
}
double solarGain = spaceSimulationResults_Zone.Sum(Analytical.SpaceSimulationResultParameter.SolarGain);
if (!double.IsNaN(solarGain))
{
zoneSimulationResult_Cooling.SetValue(ZoneSimulationResultParameter.SolarGain, solarGain);
}
}
}
if (!double.IsNaN(occupancy))
{
zoneSimulationResult_Cooling?.SetValue(ZoneSimulationResultParameter.Occupancy, occupancy);
}
if (!double.IsNaN(area))
{
zoneSimulationResult_Cooling?.SetValue(ZoneSimulationResultParameter.Area, area);
}
if (!double.IsNaN(volume))
{
zoneSimulationResult_Cooling?.SetValue(ZoneSimulationResultParameter.Volume, volume);
}
if (zoneSimulationResult_Cooling != null)
{
buildingModel.Add(zoneSimulationResult_Cooling, zone);
result.Add(zoneSimulationResult_Cooling);
}
//Heating
//ZoneSimulationResult zoneSimulationResult_Heating = null;
//if (buildingData.TryGetMax(zoneDatas.ConvertAll(x => x.zoneGUID), tsdZoneArray.heatingLoad, out index, out max) && index != -1 && !double.IsNaN(max))
//{
//zoneSimulationResult_Heating = new ZoneSimulationResult(zone.Name, Assembly.GetExecutingAssembly().GetName()?.Name, zone.Guid.ToString());
//zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.MaxSensibleLoad, max);
//zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.MaxSensibleLoadIndex, index);
//zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.LoadType, LoadType.Heating.Text());
//List<SpaceSimulationResult> spaceSimulationResults_Zone = new List<SpaceSimulationResult>();
//foreach (ZoneData zoneData in zoneDatas)
//{
// SpaceSimulationResult spaceSimulationResult_Temp = spaceSimulationResults.FindAll(x => x.LoadType() == LoadType.Heating).Find(x => x.Reference == zoneData.zoneGUID);
// if (spaceSimulationResult_Temp == null)
// continue;
// spaceSimulationResults_Zone.Add(spaceSimulationResult_Temp);
//}
//if (spaceSimulationResults_Zone != null && spaceSimulationResults_Zone.Count != 0)
//{
// //double senisbleLoad = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.Load);
// //if (!double.IsNaN(senisbleLoad))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.MaxSensibleLoad, senisbleLoad);
// //double airMovementGain = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.AirMovementGain);
// //if (!double.IsNaN(airMovementGain))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.AirMovementGain, airMovementGain);
// //double buildingHeatTransfer = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.BuildingHeatTransfer);
// //if (!double.IsNaN(buildingHeatTransfer))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.BuildingHeatTransfer, buildingHeatTransfer);
// //double glazingExternalConduction = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.GlazingExternalConduction);
// //if (!double.IsNaN(glazingExternalConduction))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.GlazingExternalConduction, glazingExternalConduction);
// //double infiltrationGain = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.InfiltrationGain);
// //if (!double.IsNaN(infiltrationGain))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.InfiltrationGain, infiltrationGain);
// //double opaqueExternalConduction = spaceSimulationResults_Zone.Sum(SpaceSimulationResultParameter.OpaqueExternalConduction);
// //if (!double.IsNaN(opaqueExternalConduction))
// // zoneSimulationResult_Heating.SetValue(ZoneSimulationResultParameter.OpaqueExternalConduction, opaqueExternalConduction);
//}
//}
//if (!double.IsNaN(occupancy))
// zoneSimulationResult_Heating?.SetValue(ZoneSimulationResultParameter.Occupancy, occupancy);
//if (!double.IsNaN(area))
// zoneSimulationResult_Heating?.SetValue(ZoneSimulationResultParameter.Area, area);
//if (!double.IsNaN(volume))
// zoneSimulationResult_Heating?.SetValue(ZoneSimulationResultParameter.Volume, volume);
//if (zoneSimulationResult_Heating != null)
//{
// adjacencyCluster.AddObject(zoneSimulationResult_Heating);
// adjacencyCluster.AddRelation(zone, zoneSimulationResult_Heating);
// result.Add(zoneSimulationResult_Heating);
//}
}
}
return(result);
}
public static HoneybeeSchema.Door ToLadybugTools(this IOpening opening, BuildingModel buildingModel, Space space)
{
if (opening == null || buildingModel == null)
{
return(null);
}
OpeningType openingType = opening.Type();
if (openingType == null)
{
return(null);
}
//Opaque Windows to be replaced by Doors
if (opening is Window && buildingModel.GetMaterialType(openingType.PaneMaterialLayers) != MaterialType.Opaque)
{
return(null);
}
IHostPartition hostPartition = buildingModel.GetHostPartition(opening);
int index = -1;
int index_Adjacent = -1;
List <Space> spaces = null;
if (hostPartition != null)
{
spaces = buildingModel.GetSpaces(hostPartition);
if (spaces != null && spaces.Count != 0)
{
index = spaces.FindIndex(x => x.Guid == space.Guid);
index = buildingModel.UniqueIndex(spaces[index]);
index_Adjacent = spaces.FindIndex(x => x.Guid != space.Guid);
index_Adjacent = buildingModel.UniqueIndex(spaces[index_Adjacent]);
}
}
HoneybeeSchema.AnyOf <Outdoors, Surface> anyOf = null;
if (index == -1 || index_Adjacent == -1)
{
anyOf = new Outdoors();
}
else
{
bool reversed = index_Adjacent < index;
List <string> uniqueNames = new List <string>();
uniqueNames.Add(Core.LadybugTools.Query.UniqueName(opening as SAMObject, index_Adjacent));
uniqueNames.Add(Query.UniqueName(hostPartition, index_Adjacent));
uniqueNames.Add(Query.UniqueName(spaces[index_Adjacent]));
anyOf = new Surface(uniqueNames);
}
Face3D face3D = Geometry.LadybugTools.Convert.ToLadybugTools(opening);
DoorEnergyPropertiesAbridged doorEnergyPropertiesAbridged = new DoorEnergyPropertiesAbridged(construction: Query.UniqueName(opening.Type(), !(index_Adjacent != -1 && index <= index_Adjacent)));
return(new HoneybeeSchema.Door(
identifier: Core.LadybugTools.Query.UniqueName(opening as SAMObject, index),
geometry: face3D,
boundaryCondition: anyOf,
properties: new DoorPropertiesAbridged(doorEnergyPropertiesAbridged),
displayName: opening.Name));
}
public static List <Space> UpdateDesignLoads(this BuildingModel buildingModel, TBDDocument tBDDocument)
{
if (tBDDocument == null || buildingModel == null)
{
return(null);
}
Building building = tBDDocument.Building;
if (building == null)
{
return(null);
}
List <Space> spaces = buildingModel.GetSpaces();
if (spaces == null || spaces.Count == 0)
{
return(spaces);
}
Dictionary <string, zone> zones = building.ZoneDictionary();
if (zones == null)
{
return(null);
}
List <Space> result = new List <Space>();
foreach (Space space in spaces)
{
string name = space?.Name;
if (string.IsNullOrEmpty(name))
{
continue;
}
zone zone;
if (!zones.TryGetValue(name, out zone) || zone == null)
{
continue;
}
result.Add(space);
space.SetValue(SpaceParameter.DesignHeatingLoad, zone.maxHeatingLoad);
space.SetValue(SpaceParameter.DesignCoolingLoad, zone.maxCoolingLoad);
buildingModel.Add(space);
List <SpaceSimulationResult> spaceSimulationResults = buildingModel.GetResults <SpaceSimulationResult>(space, Query.Source());
foreach (LoadType loadType in new LoadType[] { LoadType.Heating, LoadType.Cooling })
{
SpaceSimulationResult spaceSimulationResult = spaceSimulationResults?.Find(x => x.LoadType() == loadType);
if (spaceSimulationResult == null)
{
spaceSimulationResult = Create.SpaceSimulationResult(zone, loadType);
}
else
{
spaceSimulationResult.SetValue(Analytical.SpaceSimulationResultParameter.Area, zone.floorArea);
spaceSimulationResult.SetValue(Analytical.SpaceSimulationResultParameter.Volume, zone.volume);
spaceSimulationResult.SetValue(Analytical.SpaceSimulationResultParameter.DesignLoad, loadType == LoadType.Cooling ? zone.maxCoolingLoad : zone.maxHeatingLoad);
}
if (spaceSimulationResult != null)
{
buildingModel.Add(spaceSimulationResult, space);
}
}
}
return(result);
}
public static Face ToLadybugTools_Face(this IPartition partition, BuildingModel buildingModel, Space space)
{
Face3D face3D = Geometry.LadybugTools.Convert.ToLadybugTools(partition?.Face3D);
if (face3D == null)
{
return(null);
}
FaceType?faceType = partition.FaceType();
if (faceType == null || !faceType.HasValue)
{
return(null);
}
int index = -1;
int index_Adjacent = -1;
bool reverse = true;
List <Space> spaces = buildingModel.GetSpaces(partition);
if (spaces != null && spaces.Count != 0)
{
index = spaces.FindIndex(x => x.Guid == space.Guid);
index = buildingModel.UniqueIndex(spaces[index]);
index_Adjacent = spaces.FindIndex(x => x.Guid != space.Guid);
index_Adjacent = buildingModel.UniqueIndex(spaces[index_Adjacent]);
reverse = buildingModel.UniqueIndex(spaces[0]) != index;
}
AnyOf <Ground, Outdoors, Adiabatic, Surface> boundaryCondition = partition.ToLadybugTools_BoundaryCondition(buildingModel, space);
FaceEnergyPropertiesAbridged faceEnergyPropertiesAbridged = new FaceEnergyPropertiesAbridged();
if (partition is IHostPartition)
{
faceEnergyPropertiesAbridged.Construction = Query.UniqueName(((IHostPartition)partition).Type(), reverse);
}
Face face = new Face(Query.UniqueName(partition, index), face3D, faceType.Value, boundaryCondition, new FacePropertiesAbridged(faceEnergyPropertiesAbridged), partition.Name);
if (partition is IHostPartition)
{
List <IOpening> openings = ((IHostPartition)partition).GetOpenings();
if (openings != null && openings.Count != 0)
{
List <HoneybeeSchema.Aperture> apertures = new List <HoneybeeSchema.Aperture>();
List <HoneybeeSchema.Door> doors = new List <HoneybeeSchema.Door>();
foreach (IOpening opening in openings)
{
MaterialType materialType = MaterialType.Opaque;
OpeningType openingType = opening.Type();
if (openingType != null)
{
materialType = buildingModel.GetMaterialType(openingType.PaneMaterialLayers);
}
if (opening is Window && materialType != MaterialType.Opaque)
{
HoneybeeSchema.Aperture aperture = ((Window)opening).ToLadybugTools(buildingModel, space);
if (aperture != null)
{
apertures.Add(aperture);
}
}
else
{
HoneybeeSchema.Door door = opening.ToLadybugTools(buildingModel, space);
if (door != null)
{
doors.Add(door);
}
}
}
if (apertures != null && apertures.Count != 0)
{
face.Apertures = apertures;
}
if (doors != null && doors.Count != 0)
{
face.Doors = doors;
}
}
}
return(face);
}
public static Model ToLadybugTools(this BuildingModel buildingModel, double silverSpacing = Tolerance.MacroDistance, double tolerance = Tolerance.Distance)
{
if (buildingModel == null)
{
return(null);
}
BuildingModel architecturalModel_Temp = new BuildingModel(buildingModel);
architecturalModel_Temp.OffsetAperturesOnEdge(0.1, tolerance);
architecturalModel_Temp.ReplaceTransparentPartitions(0.1);
architecturalModel_Temp.UpdateMaterialsByMaterialLayerThickness(tolerance);
architecturalModel_Temp.UpdateMaterialsByHeatTransferCoefficients(true, true);
string uniqueName = Core.LadybugTools.Query.UniqueName(architecturalModel_Temp);
List <Room> rooms = null;
List <AnyOf <IdealAirSystemAbridged, VAV, PVAV, PSZ, PTAC, ForcedAirFurnace, FCUwithDOASAbridged, WSHPwithDOASAbridged, VRFwithDOASAbridged, FCU, WSHP, VRF, Baseboard, EvaporativeCooler, Residential, WindowAC, GasUnitHeater> > hvacs = null;
List <Space> spaces = architecturalModel_Temp.GetSpaces();
if (spaces != null)
{
hvacs = new List <AnyOf <IdealAirSystemAbridged, VAV, PVAV, PSZ, PTAC, ForcedAirFurnace, FCUwithDOASAbridged, WSHPwithDOASAbridged, VRFwithDOASAbridged, FCU, WSHP, VRF, Baseboard, EvaporativeCooler, Residential, WindowAC, GasUnitHeater> >();
rooms = new List <Room>();
Dictionary <double, List <IPartition> > dictionary_elevations = Geometry.Spatial.Query.ElevationDictionary(buildingModel.GetPartitions());
List <Level> levels = dictionary_elevations?.Keys.ToList().ConvertAll(x => Architectural.Create.Level(x));
for (int i = 0; i < spaces.Count; i++)
{
Space space = spaces[i];
if (space == null)
{
continue;
}
Room room = space.ToLadybugTools(architecturalModel_Temp, silverSpacing, tolerance);
if (room == null)
{
continue;
}
if (levels != null && levels.Count > 0)
{
double elevation_Min = Analytical.Query.MinElevation(buildingModel, space);
if (!double.IsNaN(elevation_Min))
{
double difference_Min = double.MaxValue;
Level level_Min = null;
foreach (Level level in levels)
{
double difference = System.Math.Abs(elevation_Min - level.Elevation);
if (difference < difference_Min)
{
difference_Min = difference;
level_Min = level;
}
}
room.Story = level_Min.Name;
}
}
InternalCondition internalCondition = space.InternalCondition;
if (internalCondition != null)
{
//Michal Idea of filtering Uncondition Spaces
string name_InternalCondition = internalCondition.Name;
if (name_InternalCondition == null || (name_InternalCondition != null && !name_InternalCondition.ToLower().Contains("unconditioned") && !name_InternalCondition.ToLower().Contains("external")))
{
IdealAirSystemAbridged idealAirSystemAbridged = new IdealAirSystemAbridged(string.Format("{0}__{1}", i.ToString(), "IdealAir"), string.Format("Ideal Air System Abridged {0}", space.Name));
hvacs.Add(idealAirSystemAbridged);
if (room.Properties == null)
{
room.Properties = new RoomPropertiesAbridged();
}
if (room.Properties.Energy == null)
{
room.Properties.Energy = new RoomEnergyPropertiesAbridged();
}
room.Properties.Energy.Hvac = idealAirSystemAbridged.Identifier;
}
}
rooms.Add(room);
}
}
List <Shade> shades = null;
List <Face> faces_Orphaned = null;
List <IPartition> partitions_Shade = buildingModel.GetShadePartitions();
if (partitions_Shade != null)
{
foreach (IPartition partition_Shade in partitions_Shade)
{
if (partitions_Shade == null)
{
continue;
}
Shade shade = partition_Shade.ToLadybugTools_Shade();
if (shade == null)
{
continue;
}
if (shades == null)
{
shades = new List <Shade>();
}
shades.Add(shade);
}
}
List <HostPartitionType> hostPartitionTypes = buildingModel.GetHostPartitionTypes();
List <OpeningType> openingTypes = buildingModel.GetOpeningTypes();
ConstructionSetAbridged constructionSetAbridged = Core.LadybugTools.Query.DefaultConstructionSetAbridged();
List <HoneybeeSchema.AnyOf <ConstructionSetAbridged, ConstructionSet> > constructionSets = new List <HoneybeeSchema.AnyOf <ConstructionSetAbridged, ConstructionSet> >();// { constructionSetAbridged };
List <AnyOf <OpaqueConstructionAbridged, WindowConstructionAbridged, WindowConstructionShadeAbridged, AirBoundaryConstructionAbridged, OpaqueConstruction, WindowConstruction, WindowConstructionShade, WindowConstructionDynamicAbridged, WindowConstructionDynamic, AirBoundaryConstruction, ShadeConstruction> > constructions = new List <AnyOf <OpaqueConstructionAbridged, WindowConstructionAbridged, WindowConstructionShadeAbridged, AirBoundaryConstructionAbridged, OpaqueConstruction, WindowConstruction, WindowConstructionShade, WindowConstructionDynamicAbridged, WindowConstructionDynamic, AirBoundaryConstruction, ShadeConstruction> >();
Dictionary <string, HoneybeeSchema.Energy.IMaterial> dictionary_Materials = new Dictionary <string, HoneybeeSchema.Energy.IMaterial>();
if (hostPartitionTypes != null)
{
foreach (HostPartitionType hostPartitionType in hostPartitionTypes)
{
List <MaterialLayer> materialLayers = hostPartitionType.MaterialLayers;
if (materialLayers == null)
{
continue;
}
constructions.Add(hostPartitionType.ToLadybugTools());
constructions.Add(hostPartitionType.ToLadybugTools(false));
foreach (MaterialLayer materialLayer in materialLayers)
{
IMaterial material = buildingModel.GetMaterial(materialLayer);
if (material == null)
{
continue;
}
if (dictionary_Materials.ContainsKey(material.Name))
{
continue;
}
HoneybeeSchema.Energy.IMaterial material_HoneybeeSchema = material.ToLadybugTools(materialLayer.Thickness, false);
if (material_HoneybeeSchema == null)
{
continue;
}
dictionary_Materials[material.Name] = material_HoneybeeSchema;
}
}
}
if (openingTypes != null)
{
foreach (OpeningType openingType in openingTypes)
{
List <MaterialLayer> materialLayers = openingType.PaneMaterialLayers;
if (materialLayers == null)
{
continue;
}
MaterialType materialType = buildingModel.GetMaterialType(materialLayers);
if (openingType is WindowType && materialType != MaterialType.Opaque)
{
WindowType windowType = (WindowType)openingType;
constructions.Add(windowType.ToLadybugTools_WindowConstructionAbridged());
constructions.Add(windowType.ToLadybugTools_WindowConstructionAbridged(false));
}
else
{
constructions.Add(openingType.ToLadybugTools());
constructions.Add(openingType.ToLadybugTools(false));
}
foreach (MaterialLayer materialLayer in materialLayers)
{
IMaterial material = buildingModel.GetMaterial(materialLayer);
if (material == null)
{
continue;
}
if (dictionary_Materials.ContainsKey(material.Name))
{
continue;
}
HoneybeeSchema.Energy.IMaterial material_HoneybeeSchema = material.ToLadybugTools(materialLayer.Thickness, false);
if (material_HoneybeeSchema == null)
{
continue;
}
dictionary_Materials[material.Name] = material_HoneybeeSchema;
}
}
}
Dictionary <System.Guid, ProgramType> dictionary_ProgramTypes = new Dictionary <System.Guid, ProgramType>();
if (spaces != null)
{
foreach (Space space in spaces)
{
InternalCondition internalCondition = space?.InternalCondition;
if (internalCondition == null)
{
continue;
}
if (dictionary_ProgramTypes.ContainsKey(internalCondition.Guid))
{
continue;
}
ProgramType programType = space.ToLadybugTools(buildingModel);
if (programType != null)
{
dictionary_ProgramTypes[internalCondition.Guid] = programType;
}
}
}
List <AnyOf <EnergyMaterial, EnergyMaterialNoMass, EnergyWindowMaterialGas, EnergyWindowMaterialGasCustom, EnergyWindowMaterialGasMixture, EnergyWindowMaterialSimpleGlazSys, EnergyWindowMaterialBlind, EnergyWindowMaterialGlazing, EnergyWindowMaterialShade> > materials = new List <AnyOf <EnergyMaterial, EnergyMaterialNoMass, EnergyWindowMaterialGas, EnergyWindowMaterialGasCustom, EnergyWindowMaterialGasMixture, EnergyWindowMaterialSimpleGlazSys, EnergyWindowMaterialBlind, EnergyWindowMaterialGlazing, EnergyWindowMaterialShade> >();
//HoneybeeSchema.Helper.EnergyLibrary.DefaultMaterials?.ToList().ForEach(x => materials.Add(x as dynamic));
dictionary_Materials.Values.ToList().ForEach(x => materials.Add(x as dynamic));
List <AnyOf <ScheduleRulesetAbridged, ScheduleFixedIntervalAbridged, ScheduleRuleset, ScheduleFixedInterval> > schedules = new List <AnyOf <ScheduleRulesetAbridged, ScheduleFixedIntervalAbridged, ScheduleRuleset, ScheduleFixedInterval> >();
//HoneybeeSchema.Helper.EnergyLibrary.DefaultScheduleRuleset?.ToList().ForEach(x => schedules.Add(x));
List <HoneybeeSchema.AnyOf <ProgramTypeAbridged, ProgramType> > programTypes = new List <HoneybeeSchema.AnyOf <ProgramTypeAbridged, ProgramType> >();
//HoneybeeSchema.Helper.EnergyLibrary.DefaultProgramTypes?.ToList().ForEach(x => programTypes.Add(x));
dictionary_ProgramTypes.Values.ToList().ForEach(x => programTypes.Add(x));
List <ScheduleTypeLimit> scheduleTypeLimits = new List <ScheduleTypeLimit>();
//HoneybeeSchema.Helper.EnergyLibrary.DefaultScheduleTypeLimit?.ToList().ForEach(x => scheduleTypeLimits.Add(x));
constructionSets.RemoveAll(x => x == null);
constructions.RemoveAll(x => x == null);
materials.RemoveAll(x => x == null);
ModelEnergyProperties modelEnergyProperties = new ModelEnergyProperties(constructionSets, constructions, materials, hvacs, null, programTypes, schedules, scheduleTypeLimits);
ModelProperties modelProperties = new ModelProperties(modelEnergyProperties);
Model model = new Model(uniqueName, modelProperties, buildingModel.Name, null, rooms, faces_Orphaned, shades);
model.AngleTolerance = Units.Convert.ToDegrees(Tolerance.Angle);// 2;
model.Tolerance = Tolerance.MacroDistance;
return(model);
}
