public static List <Core.Result> AddResults(this SimulationData simulationData, AdjacencyCluster adjacencyCluster)
{
if (simulationData == null || adjacencyCluster == 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 <Guid, List <SpaceSimulationResult> > dictionary = new Dictionary <Guid, List <SpaceSimulationResult> >();
List <Space> spaces = adjacencyCluster.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)
{
List <SpaceSimulationResult> spaceSimulationResults_Existing = adjacencyCluster.GetResults <SpaceSimulationResult>(space, Query.Source())?.FindAll(x => x.LoadType() == spaceSimulationResult.LoadType());
if (spaceSimulationResults_Existing != null && spaceSimulationResults_Existing.Count != 0)
{
adjacencyCluster.Remove(spaceSimulationResults_Existing);
if (spaceSimulationResults_Existing[0].TryGetValue(Analytical.SpaceSimulationResultParameter.DesignLoad, out double designLoad))
{
spaceSimulationResult.SetValue(Analytical.SpaceSimulationResultParameter.DesignLoad, designLoad);
}
}
adjacencyCluster.AddObject(spaceSimulationResult);
adjacencyCluster.AddRelation(space, spaceSimulationResult);
}
}
foreach (Core.Result result_Temp in results)
{
PanelSimulationResult panelSimulationResult = result_Temp as PanelSimulationResult;
if (panelSimulationResult == null)
{
continue;
}
if (!panelSimulationResult.TryGetValue(PanelSimulationResultParameter.ZoneName, out string zoneName) || !space.Name.Equals(zoneName))
{
continue;
}
adjacencyCluster.AddObject(panelSimulationResult);
adjacencyCluster.AddRelation(space, panelSimulationResult);
}
}
}
// get data data about SAM Zones like space GUID, Zone Category etc.
List <Zone> zones = adjacencyCluster.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 = adjacencyCluster.GetSpaces(zone);
if (spaces_Zone == null || spaces_Zone.Count == 0)
{
continue;
}
double area = adjacencyCluster.Sum(zone, SpaceParameter.Area);
double volume = adjacencyCluster.Sum(zone, SpaceParameter.Volume);
double occupancy = adjacencyCluster.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)
{
adjacencyCluster.AddObject(zoneSimulationResult_Cooling);
adjacencyCluster.AddRelation(zone, zoneSimulationResult_Cooling);
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 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);
}
//Pull/Convert data for Spaces (in Tas they call them Zones) but not for SAM Zones (in Tas ZoneGroups)
public static List <Core.Result> ToSAM(SimulationData simulationData)
{
//buildingData is is yearly dynamic simulation data
BuildingData buildingData = simulationData?.GetBuildingData();
if (buildingData == null)
{
return(null);
}
List <ZoneData> zoneDatas = Query.ZoneDatas(buildingData);
if (zoneDatas == null || zoneDatas.Count == 0)
{
return(null);
}
Dictionary <string, Tuple <CoolingDesignData, double, int, HeatingDesignData, double, int> > designDataDictionary = Query.DesignDataDictionary(simulationData);
List <List <Core.Result> > results = Enumerable.Repeat <List <Core.Result> >(null, zoneDatas.Count).ToList();
foreach (KeyValuePair <string, Tuple <CoolingDesignData, double, int, HeatingDesignData, double, int> > keyValuePair in designDataDictionary)
{
int index = zoneDatas.FindIndex(x => x.zoneGUID == keyValuePair.Key);
if (index == -1)
{
continue;
}
ZoneData zoneData_BuildingData = zoneDatas[index];
if (zoneData_BuildingData == null)
{
continue;
}
SizingMethod sizingMethod = SizingMethod.Undefined;
ZoneData zoneData_Cooling = zoneData_BuildingData;
CoolingDesignData coolingDesignData = keyValuePair.Value.Item1;
double coolingLoad = keyValuePair.Value.Item2;
int coolingIndex = keyValuePair.Value.Item3;
if (coolingDesignData != null)
{
sizingMethod = SizingMethod.CDD;
zoneData_Cooling = coolingDesignData.GetZoneData(zoneData_BuildingData.zoneNumber);
}
else
{
sizingMethod = SizingMethod.Simulation;
}
ZoneData zoneData_Heating = zoneData_BuildingData;
SpaceSimulationResult spaceSimulationResult_Cooling = Create.SpaceSimulationResult(zoneData_Cooling, coolingIndex, LoadType.Cooling, sizingMethod);
if (spaceSimulationResult_Cooling != null && coolingDesignData != null)
{
spaceSimulationResult_Cooling.SetValue(SpaceSimulationResultParameter.DesignDayName, coolingDesignData.name);
}
HeatingDesignData heatingDesignData = keyValuePair.Value.Item4;
double heatingLoad = keyValuePair.Value.Item5;
int heatingIndex = keyValuePair.Value.Item6;
if (heatingDesignData != null)
{
sizingMethod = SizingMethod.HDD;
zoneData_Heating = heatingDesignData.GetZoneData(zoneData_BuildingData.zoneNumber);
}
else
{
sizingMethod = SizingMethod.Simulation;
}
SpaceSimulationResult spaceSimulationResult_Heating = Create.SpaceSimulationResult(zoneData_Heating, heatingIndex, LoadType.Heating, sizingMethod);
if (spaceSimulationResult_Heating != null && heatingDesignData != null)
{
spaceSimulationResult_Heating.SetValue(SpaceSimulationResultParameter.DesignDayName, heatingDesignData.name);
}
if (spaceSimulationResult_Cooling != null || spaceSimulationResult_Heating != null)
{
Dictionary <Analytical.SpaceSimulationResultParameter, object> dictionary = Query.Overheating(zoneData_BuildingData, simulationData.firstDay, simulationData.lastDay);
results[index] = new List <Core.Result>();
if (spaceSimulationResult_Cooling != null)
{
foreach (KeyValuePair <Analytical.SpaceSimulationResultParameter, object> keyValuePair_Temp in dictionary)
{
spaceSimulationResult_Cooling.SetValue(keyValuePair_Temp.Key, keyValuePair_Temp.Value);
}
results[index].Add(spaceSimulationResult_Cooling);
}
if (spaceSimulationResult_Heating != null)
{
foreach (KeyValuePair <Analytical.SpaceSimulationResultParameter, object> keyValuePair_Temp in dictionary)
{
spaceSimulationResult_Heating.SetValue(keyValuePair_Temp.Key, keyValuePair_Temp.Value);
}
results[index].Add(spaceSimulationResult_Heating);
}
}
if (spaceSimulationResult_Cooling != null)
{
if (!spaceSimulationResult_Cooling.TryGetValue(Analytical.SpaceSimulationResultParameter.LoadIndex, out int loadIndex))
{
continue;
}
List <PanelSimulationResult> panelSimulationResults = zoneData_Cooling.ToSAM_PanelSimulationResults(loadIndex);
if (panelSimulationResults == null)
{
continue;
}
foreach (PanelSimulationResult panelSimulationResult in panelSimulationResults)
{
panelSimulationResult.SetValue(Analytical.PanelSimulationResultParameter.LoadType, LoadType.Cooling.ToString());
results[index].Add(panelSimulationResult);
}
}
if (spaceSimulationResult_Heating != null)
{
if (!spaceSimulationResult_Heating.TryGetValue(Analytical.SpaceSimulationResultParameter.LoadIndex, out int loadIndex))
{
continue;
}
List <PanelSimulationResult> panelSimulationResults = zoneData_Heating.ToSAM_PanelSimulationResults(loadIndex);
if (panelSimulationResults == null)
{
continue;
}
foreach (PanelSimulationResult panelSimulationResult in panelSimulationResults)
{
panelSimulationResult.SetValue(Analytical.PanelSimulationResultParameter.LoadType, LoadType.Heating.ToString());
results[index].Add(panelSimulationResult);
}
}
}
List <Core.Result> result = new List <Core.Result>();
foreach (List <Core.Result> spaceSimulationResults_Temp in results)
{
if (spaceSimulationResults_Temp != null)
{
result.AddRange(spaceSimulationResults_Temp);
}
}
return(result);
}
public static List <Core.Result> UnmetHours(string path_TSD, string path_TBD, double margin = 0.5)
{
if (string.IsNullOrWhiteSpace(path_TSD) || !File.Exists(path_TSD))
{
return(null);
}
if (string.IsNullOrWhiteSpace(path_TBD) || !File.Exists(path_TBD))
{
return(null);
}
Dictionary <TBD.Profiles, Dictionary <string, double[]> > temperatureSetPointDictionary = null;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD, true))
{
temperatureSetPointDictionary = sAMTBDDocument.TBDDocument?.Building?.TemperatureSetPointDictionary(TBD.Profiles.ticLL, TBD.Profiles.ticUL);
sAMTBDDocument.Close();
}
if (temperatureSetPointDictionary == null || temperatureSetPointDictionary.Count == 0)
{
return(null);
}
Dictionary <tsdZoneArray, Dictionary <string, double[]> > yearlyValues = null;
Dictionary <string, SpaceSimulationResult> dictionary_SpaceSimulationResult = null;
AdjacencyClusterSimulationResult adjacencyClusterSimulationResult = null;
using (SAMTSDDocument sAMTSDDocument = new SAMTSDDocument(path_TSD, true))
{
BuildingData buildingData = sAMTSDDocument.TSDDocument?.SimulationData?.GetBuildingData();
if (buildingData != null)
{
adjacencyClusterSimulationResult = Create.AdjacencyClusterSimulationResult(buildingData);
yearlyValues = sAMTSDDocument.TSDDocument?.SimulationData?.GetBuildingData()?.YearlyValues(new tsdZoneArray[] { tsdZoneArray.dryBulbTemp, tsdZoneArray.occupantSensibleGain });
dictionary_SpaceSimulationResult = new Dictionary <string, SpaceSimulationResult>();
foreach (KeyValuePair <string, ZoneData> keyValuePair in buildingData.ZoneDataDictionary())
{
dictionary_SpaceSimulationResult[keyValuePair.Key] = Create.SpaceSimulationResult(keyValuePair.Value);
}
}
}
Dictionary <string, bool[]> dictionary_Heating = null;
Dictionary <string, bool[]> dictionary_Cooling = null;
if (yearlyValues != null && yearlyValues.Count != 0)
{
dictionary_Heating = Compare(temperatureSetPointDictionary[TBD.Profiles.ticLL], yearlyValues[tsdZoneArray.dryBulbTemp], margin, LoadType.Heating);
if (dictionary_Heating == null)
{
return(null);
}
dictionary_Cooling = Compare(temperatureSetPointDictionary[TBD.Profiles.ticUL], yearlyValues[tsdZoneArray.dryBulbTemp], margin, LoadType.Cooling);
if (dictionary_Cooling == null)
{
return(null);
}
}
Dictionary <string, bool[]> dictionary_OccupantSensibleGain = new Dictionary <string, bool[]>();
foreach (KeyValuePair <string, double[]> aKeyValuePair in yearlyValues[tsdZoneArray.occupantSensibleGain])
{
dictionary_OccupantSensibleGain.Add(aKeyValuePair.Key, aKeyValuePair.Value.ToList().ConvertAll(x => x > 0).ToArray());
}
List <Core.Result> result = new List <Core.Result>();
foreach (KeyValuePair <string, SpaceSimulationResult> keyValuePair in dictionary_SpaceSimulationResult)
{
SpaceSimulationResult spaceSimulationResult = keyValuePair.Value;
if (spaceSimulationResult == null)
{
continue;
}
if (dictionary_OccupantSensibleGain.TryGetValue(keyValuePair.Key, out bool[] occupantSensibleGain))
