public static SpaceSimulationResult SpaceSimulationResult(this ZoneData zoneData, LoadType loadType)
{
if (zoneData == null)
{
return(null);
}
string name = zoneData.name;
string reference = zoneData.zoneGUID;
double area = zoneData.floorArea;
double volume = zoneData.volume;
SpaceSimulationResult result = Analytical.Create.SpaceSimulationResult(name, Query.Source(), reference, volume, area, loadType, 0);
ParameterSet parameterSet = ParameterSet_SpaceSimulationResult(ActiveSetting.Setting, zoneData);
if (parameterSet != null)
{
result.Add(parameterSet);
}
result.SetValue(SpaceSimulationResultParameter.ZoneGuid, zoneData.zoneGUID);
return(result);
}
public static SpaceSimulationResult ToSAM_SpaceSimulationResult(this TAS3D.Zone zone)
{
if (zone == null)
{
return(null);
}
SpaceSimulationResult result = new SpaceSimulationResult(zone.name, Assembly.GetExecutingAssembly().GetName()?.Name, zone.GUID);
result.SetValue("Color", Core.Convert.ToColor(zone.colour));
result.SetValue("Description", zone.description);
result.SetValue("External", zone.external);
result.SetValue("Is Used", zone.isUsed);
result.SetValue(Analytical.SpaceSimulationResultParameter.Area, zone.floorArea);
result.SetValue(Analytical.SpaceSimulationResultParameter.Volume, zone.volume);
return(result);
}
private static SpaceSimulationResult SpaceSimulationResult_Heating(float load_Simulation, int index_Simulation, ZoneData zoneData_Simulation, float load_DesignDay, int index_DesignDay, ZoneData zoneData_DesignDay)
{
if (float.IsNaN(load_Simulation) || float.IsNaN(load_DesignDay))
{
return(null);
}
if (load_Simulation == 0 && load_DesignDay == 0)
{
SpaceSimulationResult result = SpaceSimulationResult(zoneData_Simulation, LoadType.Heating);
if (zoneData_DesignDay != null)
{
double dryBulbTemp = zoneData_DesignDay.GetHourlyZoneResult(1, (short)tsdZoneArray.dryBulbTemp);
result.SetValue(Analytical.SpaceSimulationResultParameter.DryBulbTempearture, dryBulbTemp);
double resultantTemp = zoneData_DesignDay.GetHourlyZoneResult(1, (short)tsdZoneArray.resultantTemp);
result.SetValue(Analytical.SpaceSimulationResultParameter.ResultantTemperature, resultantTemp);
}
return(result);
}
int index = -1;
ZoneData zoneData = null;
SizingMethod sizingMethod = SizingMethod.Undefined;
if (load_Simulation > load_DesignDay)
{
sizingMethod = SizingMethod.Simulation;
index = index_Simulation;
zoneData = zoneData_Simulation;
}
else
{
sizingMethod = SizingMethod.HDD;
index = index_DesignDay;
zoneData = zoneData_DesignDay;
}
return(SpaceSimulationResult(zoneData, index, LoadType.Heating, sizingMethod));
}
public static SpaceSimulationResult SpaceSimulationResult(this TBD.zone zone, LoadType loadType)
{
if (zone == null || loadType == LoadType.Undefined)
{
return(null);
}
string name = zone.name;
string reference = zone.GUID;
double area = zone.floorArea;
double volume = zone.volume;
double designLoad = loadType == LoadType.Cooling ? zone.maxCoolingLoad : zone.maxHeatingLoad;
SpaceSimulationResult result = new SpaceSimulationResult(name, Query.Source(), reference);
result.SetValue(Analytical.SpaceSimulationResultParameter.Area, area);
result.SetValue(Analytical.SpaceSimulationResultParameter.Volume, volume);
result.SetValue(Analytical.SpaceSimulationResultParameter.DesignLoad, designLoad);
result.SetValue(Analytical.SpaceSimulationResultParameter.LoadType, loadType.Text());
return(result);
}
public static SpaceSimulationResult ToSAM_SpaceSimulationResult(this TSD.ZoneData zoneData, IEnumerable <SpaceDataType> spaceDataTypes = null)
{
SpaceSimulationResult result = new SpaceSimulationResult(zoneData.name, Assembly.GetExecutingAssembly().GetName()?.Name, zoneData.zoneGUID);
result.SetValue("Zone Number", zoneData.zoneNumber);
result.SetValue("Description", zoneData.description);
result.SetValue("Convective Weighting Factors Count", zoneData.nConvWeightingFactors);
result.SetValue("Radiat Weighting Factors Count", zoneData.nRadWeightingFactors);
result.SetValue(Analytical.SpaceSimulationResultParameter.Area, zoneData.floorArea);
result.SetValue(Analytical.SpaceSimulationResultParameter.Volume, zoneData.volume);
result.SetValue("Convective Common Ratio", zoneData.convectiveCommonRatio);
result.SetValue("Radiat Common Ratio", zoneData.radiantCommonRatio);
ParameterSet parameterSet = Create.ParameterSet_SpaceSimulationResult(ActiveSetting.Setting, zoneData);
if (spaceDataTypes != null)
{
foreach (SpaceDataType spaceDataType in spaceDataTypes)
{
List <double> values = zoneData.AnnualZoneResult <double>(spaceDataType);
if (values == null)
{
continue;
}
JArray jArray = new JArray();
values.ForEach(x => jArray.Add(x));
parameterSet.Add(spaceDataType.Text(), jArray);
}
}
result.Add(parameterSet);
result.SetValue(SpaceSimulationResultParameter.ZoneGuid, zoneData.zoneGUID);
return(result);
}
public static double OccupiedHours25Percentage(SpaceSimulationResult spaceSimulationResult)
{
if (spaceSimulationResult == null)
{
return(double.NaN);
}
if (!spaceSimulationResult.TryGetValue(SpaceSimulationResultParameter.OccupiedHours25, out int occupiedHours25))
{
return(double.NaN);
}
if (!spaceSimulationResult.TryGetValue(SpaceSimulationResultParameter.OccupiedHours, out int occupiedHours))
{
return(double.NaN);
}
if (occupiedHours == 0)
{
return(0);
}
return((System.Convert.ToDouble(occupiedHours25) / System.Convert.ToDouble(occupiedHours)) * 100);
}
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);
}
//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);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
int index;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run))
{
run = false;
}
if (!run)
{
return;
}
index = Params.IndexOfInputParam("_pathTasTSD");
if (index == -1)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
string path_TSD = null;
if (!dataAccess.GetData(index, ref path_TSD) || string.IsNullOrWhiteSpace(path_TSD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
index = Params.IndexOfInputParam("_pathTasTBD");
if (index == -1)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
string path_TBD = null;
if (!dataAccess.GetData(index, ref path_TBD) || string.IsNullOrWhiteSpace(path_TBD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
index = Params.IndexOfInputParam("_analyticalObject");
if (index == -1)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
Core.SAMObject sAMObject = null;
if (!dataAccess.GetData(index, ref sAMObject) || sAMObject == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
bool unmetHours = false;
index = Params.IndexOfInputParam("_runUnmetHours_");
if (index != -1)
{
if (!dataAccess.GetData(index, ref unmetHours))
{
unmetHours = true;
}
}
double unmetHoursMargin = 0.5;
index = Params.IndexOfInputParam("_unmetHoursMargin_");
if (index != -1)
{
if (!dataAccess.GetData(index, ref unmetHoursMargin))
{
unmetHoursMargin = 0.5;
}
}
AdjacencyCluster adjacencyCluster = null;
if (sAMObject is AdjacencyCluster)
{
adjacencyCluster = new AdjacencyCluster((AdjacencyCluster)sAMObject);
}
else if (sAMObject is AnalyticalModel)
{
adjacencyCluster = ((AnalyticalModel)sAMObject).AdjacencyCluster;
}
List <Core.Result> results = null;
if (adjacencyCluster != null)
{
results = Analytical.Tas.Modify.AddResults(path_TSD, adjacencyCluster);
if (unmetHours)
{
List <Core.Result> results_UnmetHours = Analytical.Tas.Query.UnmetHours(path_TSD, path_TBD, unmetHoursMargin);
if (results_UnmetHours != null && results_UnmetHours.Count > 0)
{
foreach (Core.Result result in results_UnmetHours)
{
if (result is AdjacencyClusterSimulationResult)
{
adjacencyCluster.AddObject(result);
results.Add(result);
}
else if (result is SpaceSimulationResult)
{
SpaceSimulationResult spaceSimulationResult = (SpaceSimulationResult)result;
List <SpaceSimulationResult> spaceSimulationResults = Analytical.Tas.Query.Results(results, spaceSimulationResult);
if (spaceSimulationResults == null)
{
results.Add(spaceSimulationResult);
}
else
{
spaceSimulationResults.ForEach(x => Core.Modify.Copy(spaceSimulationResult, x, SpaceSimulationResultParameter.UnmetHourFirstIndex, SpaceSimulationResultParameter.UnmetHours, SpaceSimulationResultParameter.OccupiedUnmetHours));
}
}
}
}
}
adjacencyCluster = Analytical.Tas.Modify.UpdateDesignLoads(path_TBD, adjacencyCluster);
if (sAMObject is AdjacencyCluster)
{
sAMObject = adjacencyCluster;
}
else if (sAMObject is AnalyticalModel)
{
sAMObject = new AnalyticalModel((AnalyticalModel)sAMObject, adjacencyCluster);
}
}
index = Params.IndexOfOutputParam("analyticalObject");
if (index != -1)
{
dataAccess.SetData(index, sAMObject);
}
index = Params.IndexOfOutputParam("zoneSimulationResultsHeating");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is ZoneSimulationResult && ((ZoneSimulationResult)x).LoadType() == LoadType.Heating));
}
index = Params.IndexOfOutputParam("spaceSimulationResultsHeating");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is SpaceSimulationResult && ((SpaceSimulationResult)x).LoadType() == LoadType.Heating));
}
index = Params.IndexOfOutputParam("zoneSimulationResultsCooling");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is ZoneSimulationResult && ((ZoneSimulationResult)x).LoadType() == LoadType.Cooling));
}
index = Params.IndexOfOutputParam("spaceSimulationResultsCooling");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is SpaceSimulationResult && ((SpaceSimulationResult)x).LoadType() == LoadType.Cooling));
}
index = Params.IndexOfOutputParam("panelSimulationResultsCooling");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is PanelSimulationResult && Analytical.Query.LoadType(((PanelSimulationResult)x)) == LoadType.Cooling));
}
index = Params.IndexOfOutputParam("panelSimulationResultsHeating");
if (index != -1)
{
dataAccess.SetDataList(index, results?.FindAll(x => x is PanelSimulationResult && Analytical.Query.LoadType(((PanelSimulationResult)x)) == LoadType.Heating));
}
index = Params.IndexOfOutputParam("_adjacencyClusterSimulationResultCooling");
if (index != -1)
{
dataAccess.SetData(index, results?.Find(x => x is AdjacencyClusterSimulationResult && Analytical.Query.LoadType(((AdjacencyClusterSimulationResult)x)) == LoadType.Cooling));
}
index = Params.IndexOfOutputParam("adjacencyClusterSimulationResultHeating");
if (index != -1)
{
dataAccess.SetData(index, results?.Find(x => x is AdjacencyClusterSimulationResult && Analytical.Query.LoadType(((AdjacencyClusterSimulationResult)x)) == LoadType.Heating));
}
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, SpaceSimulationResult spaceSimulationResult, Document document, ConvertSettings convertSettings)
{
if (spaceSimulationResult == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(spaceSimulationResult.Guid);
if (result != null)
{
return(result);
}
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
if (adjacencyCluster != null)
{
List <Space> spaces_SAM = adjacencyCluster.GetRelatedObjects <Space>(spaceSimulationResult);
if (spaces_SAM != null)
{
foreach (Space space_SAM in spaces_SAM)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, spaceSimulationResult);
if (space_Revit == null)
{
space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space_SAM);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == space_SAM.Name);
}
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => space_SAM.Name.EndsWith(x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString()) && space_SAM.Name.StartsWith(x.get_Parameter(BuiltInParameter.ROOM_NUMBER)?.AsString()));
}
if (space_Revit == null)
{
continue;
}
if (result == null)
{
result = new List <Autodesk.Revit.DB.Mechanical.Space>();
}
result.Add(space_Revit);
}
}
}
if (result == null)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, spaceSimulationResult);
if (space_Revit == null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == spaceSimulationResult.Name);
}
if (space_Revit != null)
{
result = new List <Autodesk.Revit.DB.Mechanical.Space>()
{
space_Revit
}
}
;
}
if (result == null)
{
return(result);
}
if (convertSettings.ConvertParameters)
{
foreach (Autodesk.Revit.DB.Mechanical.Space space in result)
{
Core.Revit.Modify.SetValues(space, spaceSimulationResult);
Core.Revit.Modify.SetValues(space, spaceSimulationResult, ActiveSetting.Setting);
Modify.SetValues(space, spaceSimulationResult, ActiveSetting.Setting, spaceSimulationResult.LoadType(), convertSettings?.GetParameters());
}
}
convertSettings?.Add(spaceSimulationResult.Guid, result);
return(result);
}
}
public static SpaceSimulationResult SpaceSimulationResult(this ZoneData zoneData, int index, LoadType loadType, SizingMethod sizingMethod)
{
if (zoneData == null || index == -1 || loadType == LoadType.Undefined)
{
return(null);
}
string name = zoneData.name;
string reference = zoneData.zoneGUID;
double area = zoneData.floorArea;
double volume = zoneData.volume;
float dryBulbTemp = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.dryBulbTemp);
float resultantTemp = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.resultantTemp);
float load = zoneData.GetHourlyZoneResult(index, loadType == LoadType.Cooling ? (short)tsdZoneArray.coolingLoad : (short)tsdZoneArray.heatingLoad);
float infVentGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.infVentGain);
float airMovementGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.airMovementGain);
float buildingHeatTransfer = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.buildingHeatTransfer);
float externalConductionGlazing = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.externalConductionGlazing);
float externalConductionOpaque = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.externalConductionOpaque);
float spaceHumidityRatio = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.humidityRatio);
SpaceSimulationResult result = null;
if (loadType == LoadType.Heating)
{
result = Analytical.Create.SpaceSimulationResult(name, Query.Source(), reference, volume, area, LoadType.Heating, load, index, sizingMethod, dryBulbTemp, resultantTemp,
infiltartionGain: infVentGain,
airMovementGain: airMovementGain,
buildingHeatTransfer: buildingHeatTransfer,
glazingExternalConduction: externalConductionGlazing,
opaqueExternalConduction: externalConductionOpaque,
humidityRatio: spaceHumidityRatio);
}
else if (loadType == LoadType.Cooling)
{
float solarGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.solarGain);
float lightingGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.lightingGain);
float occupancySensibleGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.occupantSensibleGain);
float equipmentSensibleGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.equipmentSensibleGain);
float equipmentLatentGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.equipmentLatentGain);
float occupancyLatentGain = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.occupancyLatentGain);
float relativeHumidity = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.relativeHumidity);
float zoneApertureFlowIn = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.zoneApertureFlowIn);
float zoneApertureFlowOut = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.zoneApertureFlowOut);
float pollutant = zoneData.GetHourlyZoneResult(index, (short)tsdZoneArray.pollutant);
result = Analytical.Create.SpaceSimulationResult(name, Query.Source(), reference, volume, area, loadType, load, index, sizingMethod,
dryBulbTemp, resultantTemp, solarGain, lightingGain, infVentGain, airMovementGain,
buildingHeatTransfer, externalConductionGlazing, externalConductionOpaque, occupancySensibleGain,
occupancyLatentGain, equipmentSensibleGain, equipmentLatentGain, spaceHumidityRatio, relativeHumidity,
zoneApertureFlowIn, zoneApertureFlowOut, pollutant);
}
if (result == null)
{
return(null);
}
List <double> dryBulbTemperatures = zoneData.AnnualZoneResult <double>(tsdZoneArray.dryBulbTemp);
if (dryBulbTemperatures != null)
{
result.SetValue(SpaceSimulationResultParameter.DryBulbTemperatureProfile, new Profile("Dry Bulb Temperature", "Annual Space Values", dryBulbTemperatures));
}
result.SetValue(SpaceSimulationResultParameter.ZoneGuid, zoneData.zoneGUID);
ParameterSet parameterSet = ParameterSet_SpaceSimulationResult(ActiveSetting.Setting, zoneData);
if (parameterSet != null)
{
result.Add(parameterSet);
}
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);
}
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))
public static AnalyticalModel RunWorkflow(this AnalyticalModel analyticalModel, string path_TBD, string path_gbXML = null, Weather.WeatherData weatherData = null, List <DesignDay> heatingDesignDays = null, List <DesignDay> coolingDesignDays = null, List <SurfaceOutputSpec> surfaceOutputSpecs = null, bool unmetHours = true)
{
if (analyticalModel == null || string.IsNullOrWhiteSpace(path_TBD))
{
return(null);
}
string directory = System.IO.Path.GetDirectoryName(path_TBD);
string fileName = System.IO.Path.GetFileNameWithoutExtension(path_TBD);
string path_TSD = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "tsd"));
if (!string.IsNullOrWhiteSpace(path_gbXML))
{
string path_T3D = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "t3d"));
string guid = null;
using (SAMT3DDocument sAMT3DDocument = new SAMT3DDocument(path_T3D))
{
TAS3D.T3DDocument t3DDocument = sAMT3DDocument.T3DDocument;
guid = t3DDocument.Building.GUID;
sAMT3DDocument.Save();
}
float latitude = float.NaN;
float longitude = float.NaN;
float timeZone = float.NaN;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (weatherData != null)
{
Weather.Tas.Modify.UpdateWeatherData(tBDDocument, weatherData);
}
if (!string.IsNullOrWhiteSpace(guid))
{
tBDDocument.Building.GUID = guid;
}
TBD.Calendar calendar = tBDDocument.Building.GetCalendar();
List <TBD.dayType> dayTypes = Query.DayTypes(calendar);
if (dayTypes.Find(x => x.name == "HDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "HDD";
}
if (dayTypes.Find(x => x.name == "CDD") == null)
{
TBD.dayType dayType = calendar.AddDayType();
dayType.name = "CDD";
}
latitude = tBDDocument.Building.latitude;
longitude = tBDDocument.Building.longitude;
timeZone = tBDDocument.Building.timeZone;
sAMTBDDocument.Save();
}
using (SAMT3DDocument sAMT3DDocument = new SAMT3DDocument(path_T3D))
{
TAS3D.T3DDocument t3DDocument = sAMT3DDocument.T3DDocument;
t3DDocument.TogbXML(path_gbXML, true, true, true);
t3DDocument.SetUseBEWidths(false);
analyticalModel = Query.UpdateT3D(analyticalModel, t3DDocument);
t3DDocument.Building.latitude = float.IsNaN(latitude) ? t3DDocument.Building.latitude : latitude;
t3DDocument.Building.longitude = float.IsNaN(longitude) ? t3DDocument.Building.longitude : longitude;
t3DDocument.Building.timeZone = float.IsNaN(timeZone) ? t3DDocument.Building.timeZone : timeZone;
sAMT3DDocument.Save();
Convert.ToTBD(t3DDocument, path_TBD, 1, 365, 15, true);
}
}
AdjacencyCluster adjacencyCluster = null;
bool hasWeatherData = false;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
hasWeatherData = tBDDocument?.Building.GetWeatherYear() != null;
analyticalModel = Query.UpdateFacingExternal(analyticalModel, tBDDocument);
AssignAdiabaticConstruction(tBDDocument, "Adiabatic", new string[] { "-unzoned", "-internal", "-exposed" }, false, true);
UpdateBuildingElements(tBDDocument, analyticalModel);
adjacencyCluster = analyticalModel.AdjacencyCluster;
UpdateThermalParameters(adjacencyCluster, tBDDocument.Building);
analyticalModel = new AnalyticalModel(analyticalModel, adjacencyCluster);
UpdateZones(tBDDocument.Building, analyticalModel, true);
if (coolingDesignDays != null || heatingDesignDays != null)
{
AddDesignDays(tBDDocument, coolingDesignDays, heatingDesignDays, 30);
}
sAMTBDDocument.Save();
}
if (!hasWeatherData)
{
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
Query.Sizing(path_TBD, analyticalModel, false, true);
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
TBD.TBDDocument tBDDocument = sAMTBDDocument.TBDDocument;
if (surfaceOutputSpecs != null && surfaceOutputSpecs.Count > 0)
{
Core.Tas.Modify.UpdateSurfaceOutputSpecs(tBDDocument, surfaceOutputSpecs);
Core.Tas.Modify.AssignSurfaceOutputSpecs(tBDDocument, surfaceOutputSpecs[0].Name);
sAMTBDDocument.Save();
}
Simulate(tBDDocument, path_TSD, 1, 1);
}
adjacencyCluster = analyticalModel.AdjacencyCluster;
List <Core.Result> results = AddResults(path_TSD, adjacencyCluster);
if (unmetHours)
{
List <Core.Result> results_UnmetHours = Query.UnmetHours(path_TSD, path_TBD, 0.5);
if (results_UnmetHours != null && results_UnmetHours.Count > 0)
{
foreach (Core.Result result in results_UnmetHours)
{
if (result is AdjacencyClusterSimulationResult)
{
adjacencyCluster.AddObject(result);
}
else if (result is SpaceSimulationResult)
{
SpaceSimulationResult spaceSimulationResult = (SpaceSimulationResult)result;
List <SpaceSimulationResult> spaceSimulationResults = Query.Results(results, spaceSimulationResult);
if (spaceSimulationResults == null)
{
results.Add(spaceSimulationResult);
}
else
{
spaceSimulationResults.ForEach(x => Core.Modify.Copy(spaceSimulationResult, x, Analytical.SpaceSimulationResultParameter.UnmetHourFirstIndex, Analytical.SpaceSimulationResultParameter.UnmetHours, Analytical.SpaceSimulationResultParameter.OccupiedUnmetHours));
}
}
}
}
}
AnalyticalModel analyticalModel_Temp = new AnalyticalModel(analyticalModel, adjacencyCluster);
//if (System.IO.File.Exists(path_TSD))
//{
// string path_TPD = System.IO.Path.Combine(directory, string.Format("{0}.{1}", fileName, "tpd"));
// CreateTPD(path_TPD, path_TSD, analyticalModel_Temp);
//}
adjacencyCluster = UpdateDesignLoads(path_TBD, analyticalModel_Temp.AdjacencyCluster);
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
