public static AnalyticalModel UpdateDesignLoads(this TBDDocument tBDDocument, AnalyticalModel analyticalModel)
{
if (tBDDocument == null || analyticalModel == null)
{
return(null);
}
Building building = tBDDocument.Building;
if (building == null)
{
return(null);
}
AdjacencyCluster adjacencyCluster = analyticalModel.AdjacencyCluster;
if (adjacencyCluster == null)
{
return(null);
}
adjacencyCluster = UpdateDesignLoads(tBDDocument, adjacencyCluster);
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
bool run = false;
if (!dataAccess.GetData(2, ref run) || !run)
{
return;
}
ConvertSettings convertSettings = null;
dataAccess.GetData(1, ref convertSettings);
convertSettings = this.UpdateSolutionEndEventHandler(convertSettings);
AdjacencyCluster adjacencyCluster = null;
if (!dataAccess.GetData(0, ref adjacencyCluster))
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
List <Element> elements = Analytical.Revit.Convert.ToRevit(adjacencyCluster, document, convertSettings);
dataAccess.SetDataList(0, elements);
}
public static AdjacencyCluster ToSAM(this BuildingData buildingData, IEnumerable <SpaceDataType> spaceDataTypes = null, IEnumerable <PanelDataType> panelDataTypes = null)
{
if (buildingData == null)
{
return(null);
}
List <ZoneData> zoneDatas = buildingData.ZoneDatas();
if (zoneDatas == null)
{
return(null);
}
AdjacencyCluster result = new AdjacencyCluster();
foreach (ZoneData zoneData in zoneDatas)
{
if (zoneData == null)
{
continue;
}
Space space = zoneData.ToSAM(spaceDataTypes);
if (space != null)
{
result.AddObject(space);
}
List <SurfaceData> surfaceDatas = zoneData.SurfaceDatas();
if (surfaceDatas == null)
{
continue;
}
foreach (SurfaceData surfaceData in surfaceDatas)
{
if (surfaceData == null)
{
continue;
}
Panel panel = surfaceData.ToSAM(panelDataTypes);
if (panel == null)
{
continue;
}
result.AddObject(panel);
if (space != null)
{
result.AddRelation(space, panel);
}
}
}
return(result);
}
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
int index;
index = Params.IndexOfInputParam("_analytical");
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;
}
AdjacencyCluster adjacencyCluster = null;
if (sAMObject is AnalyticalModel)
{
adjacencyCluster = ((AnalyticalModel)sAMObject).AdjacencyCluster;
}
else if (sAMObject is AdjacencyCluster)
{
adjacencyCluster = new AdjacencyCluster((AdjacencyCluster)sAMObject);
}
List <Zone> zones = null;
if (adjacencyCluster != null)
{
zones = adjacencyCluster.MapZones();
if (zones != null && zones.Count != 0)
{
if (sAMObject is AdjacencyCluster)
{
sAMObject = adjacencyCluster;
}
else if (sAMObject is AnalyticalModel)
{
sAMObject = new AnalyticalModel((AnalyticalModel)sAMObject, adjacencyCluster);
}
}
}
index = Params.IndexOfOutputParam("Analytical");
if (index != -1)
{
dataAccess.SetData(index, sAMObject);
}
index = Params.IndexOfOutputParam("Zones");
if (index != -1)
{
dataAccess.SetDataList(index, zones);
}
}
public static List <Core.Result> AddResults(this TSDDocument tSDDocument, AdjacencyCluster adjacencyCLuster)
{
if (tSDDocument == null || adjacencyCLuster == null)
{
return(null);
}
return(AddResults(tSDDocument.SimulationData, adjacencyCLuster));
}
public static AnalyticalModel UpdateFacingExternal(this AnalyticalModel analyticalModel, TBD.TBDDocument tBDDocument)
{
if (analyticalModel == null || tBDDocument == null)
{
return(null);
}
Dictionary <string, TBD.zone> zones = tBDDocument.Building?.ZoneDictionary();
if (zones == null)
{
return(null);
}
AdjacencyCluster adjacencyCluster = analyticalModel.AdjacencyCluster;
if (adjacencyCluster == null)
{
return(null);
}
Dictionary <string, Space> spaces = adjacencyCluster.SpaceDictionary();
if (spaces == null)
{
return(null);
}
if (zones.Count == 0 || spaces.Count == 0)
{
return(new AnalyticalModel(analyticalModel));
}
foreach (KeyValuePair <string, Space> keyValuePair in spaces)
{
TBD.zone zone = null;
if (!zones.TryGetValue(keyValuePair.Key, out zone))
{
continue;
}
if (zone == null)
{
continue;
}
Space space_New = UpdateFacingExternal(keyValuePair.Value, zone);
if (space_New == null)
{
continue;
}
adjacencyCluster.AddObject(space_New);
}
return(new AnalyticalModel(analyticalModel, adjacencyCluster));
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, Zone zone, Document document, ConvertSettings convertSettings)
{
if (adjacencyCluster == null || zone == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(zone.Guid);
if (result != null)
{
return(result);
}
Zone zone_Temp = adjacencyCluster.GetObject <Zone>(zone.Guid);
if (zone_Temp == null)
{
zone_Temp = zone;
}
if (convertSettings.ConvertParameters)
{
List <Space> spaces = adjacencyCluster.GetSpaces(zone_Temp);
if (spaces != null)
{
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Revit = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
foreach (Space space in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space);
if (space_Revit == null)
{
string name = space.Name;
if (name != null)
{
space_Revit = spaces_Revit?.Find(x => x.get_Parameter(BuiltInParameter.ROOM_NAME)?.AsString() == name);
}
}
if (space_Revit == null)
{
continue;
}
Core.Revit.Modify.SetValues(space_Revit, zone_Temp);
Core.Revit.Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting);
}
}
}
convertSettings?.Add(zone.Guid, result);
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)
{
dataAccess.SetData(1, false);
bool run = false;
if (!dataAccess.GetData(2, ref run))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
if (!run)
{
return;
}
string path_TBD = null;
if (!dataAccess.GetData(0, ref path_TBD) || string.IsNullOrWhiteSpace(path_TBD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
AnalyticalModel analyticalModel = null;
if (!dataAccess.GetData(1, ref analyticalModel) || analyticalModel == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
bool result = false;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
{
result = Analytical.Tas.Modify.UpdateBuildingElements(sAMTBDDocument, analyticalModel);
AdjacencyCluster adjacencyCluster = analyticalModel.AdjacencyCluster;
Analytical.Tas.Modify.UpdateThermalParameters(adjacencyCluster, sAMTBDDocument.TBDDocument?.Building);
analyticalModel = new AnalyticalModel(analyticalModel, adjacencyCluster);
if (result)
{
sAMTBDDocument.Save();
}
}
dataAccess.SetData(0, new GooAnalyticalModel(analyticalModel));
dataAccess.SetData(1, result);
}
public static List <Core.Result> AddResults(this string path_TSD, AdjacencyCluster adjacencyCLuster)
{
if (adjacencyCLuster == null || string.IsNullOrWhiteSpace(path_TSD))
{
return(null);
}
List <Core.Result> result = null;
using (SAMTSDDocument sAMTSDDocument = new SAMTSDDocument(path_TSD, true))
{
result = AddResults(sAMTSDDocument, adjacencyCLuster);
}
return(result);
}
public static AdjacencyCluster ToSAM_AdjacencyCluster(this string path_TSD, IEnumerable <SpaceDataType> spaceDataTypes = null, IEnumerable <PanelDataType> panelDataTypes = null)
{
if (string.IsNullOrWhiteSpace(path_TSD))
{
return(null);
}
AdjacencyCluster result = null;
using (SAMTSDDocument sAMTSDDocument = new SAMTSDDocument(path_TSD))
{
result = sAMTSDDocument.ToSAM(spaceDataTypes, panelDataTypes);
}
return(result);
}
public static List <Zone> MapZones(this AdjacencyCluster adjacencyCluster)
{
if (adjacencyCluster == null)
{
return(null);
}
TextMap textMap;
if (!ActiveSetting.Setting.TryGetValue(ActiveSetting.Name.ZoneMap, out textMap) || textMap == null)
{
return(null);
}
return(Analytical.Modify.MapZones(adjacencyCluster, textMap));
}
public static string ZoneId(this AdjacencyCluster adjacencyCluster, ZoneSimulationResult zoneSimulationResult)
{
if (adjacencyCluster == null || zoneSimulationResult == null)
{
return(null);
}
Zone zone = adjacencyCluster.GetRelatedObjects <Zone>(zoneSimulationResult).FirstOrDefault();
if (zone == null)
{
return(null);
}
return(ZoneId(zone));
}
/// <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)
{
SAMObject sAMObject = null;
if (!dataAccess.GetData(0, ref sAMObject))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
if (sAMObject is Panel)
{
dataAccess.SetDataList(0, new List <global::Topologic.Face> {
Analytical.Topologic.Convert.ToTopologic((Panel)sAMObject)
});
return;
}
else if (sAMObject is AdjacencyCluster)
{
dataAccess.SetDataList(0, null);
AdjacencyCluster adjacencyCluster = sAMObject as AdjacencyCluster;
List <Geometry.Spatial.Shell> shells = adjacencyCluster.GetShells();
if (shells != null)
{
dataAccess.SetDataList(0, shells.ConvertAll(x => Geometry.Topologic.Convert.ToTopologic_Cell(x)));
}
return;
}
else if (sAMObject is AnalyticalModel)
{
dataAccess.SetDataList(0, null);
AdjacencyCluster adjacencyCluster = (sAMObject as AnalyticalModel).AdjacencyCluster;
List <Geometry.Spatial.Shell> shells = adjacencyCluster.GetShells();
if (shells != null)
{
dataAccess.SetDataList(0, shells.ConvertAll(x => Geometry.Topologic.Convert.ToTopologic_Cell(x)));
}
return;
}
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
}
/// <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)
{
dataAccess.SetData(1, false);
bool run = false;
if (!dataAccess.GetData(3, ref run))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
if (!run)
{
return;
}
AdjacencyCluster adjacencyCluster = null;
if (!dataAccess.GetData(0, ref adjacencyCluster) || adjacencyCluster == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
string path = null;
dataAccess.GetData <string>(1, ref path);
double tolerance = Tolerance.Distance;
if (!dataAccess.GetData(2, ref tolerance))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
string gEM = Convert.ToGEM(adjacencyCluster, Tolerance.MacroDistance, tolerance);
if (!string.IsNullOrWhiteSpace(path))
{
System.IO.File.WriteAllText(path, gEM);
}
dataAccess.SetData(0, gEM);
dataAccess.SetData(1, true);
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
ConvertSettings convertSettings = null;
index = Params.IndexOfInputParam("_convertSettings_");
if (index != -1)
{
dataAccess.GetData(index, ref convertSettings);
}
convertSettings = this.UpdateSolutionEndEventHandler(convertSettings);
AdjacencyCluster adjacencyCluster = null;
index = Params.IndexOfInputParam("_adjacencyCluster");
if (index == -1 || !dataAccess.GetData(index, ref adjacencyCluster))
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
StartTransaction(document);
convertSettings.AddParameter("AdjacencyCluster", adjacencyCluster);
List <Element> elements = Analytical.Revit.Convert.ToRevit(adjacencyCluster, document, convertSettings);
index = Params.IndexOfOutputParam("elements");
if (index != -1)
{
dataAccess.SetDataList(index, elements);
}
}
/// <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)
{
AdjacencyCluster adjacencyCluster = null;
if (!dataAccess.GetData(0, ref adjacencyCluster))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
SAMObject sAMObject = null;
if (!dataAccess.GetData(1, ref sAMObject))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
IEnumerable <SAMObject> result = null;
if (sAMObject is Space)
{
result = adjacencyCluster.GetPanels((Space)sAMObject);
}
else if (sAMObject is Panel)
{
result = adjacencyCluster.GetSpaces((Panel)sAMObject);
}
if (result == null)
{
dataAccess.SetDataList(0, null);
return;
}
if (result.Count() == 0)
{
dataAccess.SetDataList(0, result);
return;
}
dataAccess.SetDataList(0, result.ToList().ConvertAll(x => new GooJSAMObject <SAMObject>(x)));
}
public static AdjacencyCluster UpdateDesignLoads(this string path_TBD, AdjacencyCluster adjacencyCluster)
{
if (string.IsNullOrWhiteSpace(path_TBD))
{
return(null);
}
AdjacencyCluster result = null;
using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD, true))
{
result = UpdateDesignLoads(sAMTBDDocument.TBDDocument, adjacencyCluster);
if (result != null)
{
sAMTBDDocument.Save();
}
}
return(result);
}
public static Log Log(this AdjacencyCluster adjacencyCluster, Document document)
{
if (adjacencyCluster == null || document == null)
{
return(null);
}
Log result = new Log();
foreach (Construction construction in adjacencyCluster.GetConstructions())
{
result.AddRange(Log(construction, document));
}
foreach (ApertureConstruction apertureConstruction in adjacencyCluster.ApertureConstructions())
{
result.AddRange(Log(apertureConstruction, document));
}
List <Panel> panels = adjacencyCluster.GetPanels();
panels?.ForEach(x => Core.Modify.AddRange(result, Core.Revit.Create.Log(x, document)));
List <Architectural.Level> levels = Architectural.Create.Levels(panels);
if (levels == null || levels.Count == 0)
{
result.Add("Could not find proper levels in AdjacencyCluster", LogRecordType.Error);
}
else
{
result.AddRange(Architectural.Revit.Create.Log(levels, document));
}
foreach (Space space in adjacencyCluster.GetSpaces())
{
Core.Modify.AddRange(result, Log(space, document));
}
return(result);
}
public static List <Guid> SetBlinds(this AnalyticalModel analyticalModel, string path_TBD, string path_TSD, string path_TBD_Output = null)
{
if (analyticalModel == null || string.IsNullOrWhiteSpace(path_TBD) || string.IsNullOrWhiteSpace(path_TSD))
{
return(null);
}
AdjacencyCluster adjacencyCluster = analyticalModel.AdjacencyCluster;
if (adjacencyCluster == null)
{
return(null);
}
List <SAMType> sAMTypes = new List <SAMType>();
List <Construction> constructions = adjacencyCluster.GetConstructions();
if (constructions != null)
{
sAMTypes.AddRange(constructions);
}
List <ApertureConstruction> apertureConstructions = adjacencyCluster.GetApertureConstructions();
if (apertureConstructions != null)
{
sAMTypes.AddRange(apertureConstructions);
}
string path = path_TBD;
if (!string.IsNullOrWhiteSpace(path_TBD_Output))
{
System.IO.File.Copy(path_TBD, path_TBD_Output, true);
path = path_TBD_Output;
}
return(SetBlinds(sAMTypes, path, path_TSD));
}
public static List <Guid> SetBlinds(this IEnumerable <SAMType> sAMTypes, string path_TBD, string path_TSD)
{
List <Tuple <SAMType, double, double> > tuples = new List <Tuple <SAMType, double, double> >();
foreach (SAMType sAMType in sAMTypes)
{
double blindSolarGainPerAreaToClose;
if (!sAMType.TryGetValue("SAM_BuildingElementBlindSolarGainPerAreaToClose", out blindSolarGainPerAreaToClose, true) || double.IsNaN(blindSolarGainPerAreaToClose) || blindSolarGainPerAreaToClose == 0)
{
continue;
}
double blindFactor;
if (!sAMType.TryGetValue("SAM_BuildingElementBlindFactor", out blindFactor, true) || double.IsNaN(blindFactor) || blindFactor == 0)
{
continue;
}
tuples.Add(new Tuple <SAMType, double, double> (sAMType, blindSolarGainPerAreaToClose, blindFactor));
}
if (tuples == null || tuples.Count == 0)
{
return(new List <Guid>());
}
AdjacencyCluster adjacencyCluster_TSD = path_TSD.ToSAM_AdjacencyCluster(null, new PanelDataType[] { PanelDataType.ExternalSolarGain });
throw new NotImplementedException();
//using (SAMTBDDocument sAMTBDDocument = new SAMTBDDocument(path_TBD))
//{
// result = SetBlinds(sAMTBDDocument, apertureConstructions);
// if (result != null)
// sAMTBDDocument.Save();
//}
//return result;
}
public static Dictionary <string, Space> SpaceDictionary(this AdjacencyCluster adjacencyCluster)
{
List <Space> spaces = adjacencyCluster?.GetSpaces();
if (spaces == null)
{
return(null);
}
Dictionary <string, Space> result = new Dictionary <string, Space>();
foreach (Space space in spaces)
{
string name = space?.Name;
if (name == null)
{
continue;
}
result[name] = space;
}
return(result);
}
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 <Core.Result> AddResults(this SAMTSDDocument sAMTSDDocument, AdjacencyCluster adjacencyCLuster)
{
if (sAMTSDDocument == null || adjacencyCLuster == null)
{
return(null);
}
return(AddResults(sAMTSDDocument.TSDDocument, adjacencyCLuster));
}
public static AdjacencyCluster AdjacencyCluster(IEnumerable <Space> spaces, IEnumerable <Panel> panels, out List <Topology> topologies, out List <Panel> redundantPanels, double minArea = Tolerance.MacroDistance, bool updatePanels = true, bool tryCellComplexByCells = true, Log log = null, double silverSpacing = Tolerance.MacroDistance, double tolerance = Tolerance.Distance)
{
Core.Modify.Add(log, "Method Name: {0}, Tolerance: {1}, Update Panels: {2}", "SAM.Analytical.Topologic.Create.AdjacencyCluster", tolerance, updatePanels);
topologies = null;
redundantPanels = null;
AdjacencyCluster result = new AdjacencyCluster();
result.AddObjects(spaces);
result.AddObjects(panels);
List <Face> faces = new List <Face>();
int index = 1;
foreach (Panel panel in result.GetObjects <Panel>())
{
if (panel == null)
{
continue;
}
Face face = Convert.ToTopologic(panel);
if (face == null)
{
continue;
}
faces.Add(face);
Core.Modify.Add(log, "Face {0:D4} added. Panel [{1}]", index, panel.Guid);
index++;
}
if (faces == null || faces.Count == 0)
{
return(null);
}
topologies = new List <Topology>();
List <Cell> cells = null;
if (tryCellComplexByCells)
{
try
{
Core.Modify.Add(log, "Trying to make CellComplex By Cells");
Cluster cluster = Cluster.ByTopologies(faces as IList <Topology>);
Core.Modify.Add(log, "Cluster.ByTopologies Done");
Topology topology = cluster.SelfMerge();
Core.Modify.Add(log, "Cluster SelfMerge Done");
if (topology.Cells != null && topology.Cells.Count != 0)
{
cells = topology.Cells?.ToList();
CellComplex cellComplex = null;
try
{
cellComplex = CellComplex.ByCells(cells);
}
catch (Exception exception)
{
Core.Modify.Add(log, "Cells could not be taken from CellComplex");
Core.Modify.Add(log, "Exception Message: {0}", exception.Message);
}
if (cellComplex != null && cellComplex.Cells != null && cellComplex.Cells.Count != 0)
{
topologies.Add(cellComplex);
cells = cellComplex.Cells?.ToList();
}
else
{
topologies.Add(topology);
Core.Modify.Add(log, "Cells taken from Cluster");
}
}
}
catch (Exception exception)
{
Core.Modify.Add(log, "Cannot create CellComplex By Cells or Cells form Cluster SelfMerge");
Core.Modify.Add(log, "Exception Message: {0}", exception.Message);
cells = null;
}
}
if (cells == null)
{
try
{
Core.Modify.Add(log, "Trying to make CellComplex By Faces");
CellComplex cellComplex = CellComplex.ByFaces(faces, tolerance);
topologies.Add(cellComplex);
cells = cellComplex.Cells?.ToList();
Core.Modify.Add(log, "CellComplex By Faces Created");
}
catch (Exception exception)
{
Core.Modify.Add(log, "Cannot create CellComplex By Faces");
Core.Modify.Add(log, "Exception Message: {0}", exception.Message);
cells = null;
}
}
if (cells == null || cells.Count == 0)
{
Core.Modify.Add(log, "No cells found");
return(null);
}
List <Geometry.Spatial.Shell> shells = cells.ToSAM();
Core.Modify.Add(log, "Single CellComplex converted to shells");
if (shells == null)
{
return(null);
}
//Matching spaces with shells
Dictionary <Geometry.Spatial.Shell, List <Space> > dictionary_Spaces = new Dictionary <Geometry.Spatial.Shell, List <Space> >();
if (spaces != null)
{
foreach (Space space in spaces)
{
if (space == null || space.Location == null || !space.IsPlaced())
{
continue;
}
List <Geometry.Spatial.Shell> shells_Temp = Analytical.Query.SpaceShells(shells, space.Location, silverSpacing, tolerance);
if (shells_Temp == null || shells_Temp.Count == 0)
{
continue;
}
foreach (Geometry.Spatial.Shell shell in shells_Temp)
{
if (!dictionary_Spaces.TryGetValue(shell, out List <Space> spaces_Shell))
{
spaces_Shell = new List <Space>();
dictionary_Spaces[shell] = spaces_Shell;
}
spaces_Shell.Add(space);
}
}
}
HashSet <Guid> guids_Updated = new HashSet <Guid>();
Dictionary <Panel, Face3D> dictionary_Panel_Face3D = new Dictionary <Panel, Face3D>();
result.GetObjects <Panel>().ForEach(x => dictionary_Panel_Face3D[x] = x.GetFace3D());
index = 1;
List <Tuple <Panel, Point3D> > tuples_InternalPoint3D = new List <Tuple <Panel, Point3D> >();
for (int i = 0; i < shells.Count; i++)
{
Geometry.Spatial.Shell shell = shells[i];
if (shell == null)
{
return(null);
}
Core.Modify.Add(log, "Simplifying shell");
//shell.Simplify(tolerance); // Low tolerance cause of rounding issues
shell.Simplify();
Core.Modify.Add(log, "Extracting faces from shell");
List <Face3D> face3Ds = shell?.Face3Ds;
if (face3Ds == null)
{
Core.Modify.Add(log, "No face2Ds found in Shell");
continue;
}
dictionary_Spaces.TryGetValue(shell, out List <Space> spaces_Shell);
if (spaces_Shell == null || spaces_Shell.Count == 0)
{
Core.Modify.Add(log, "Creating new Space");
Point3D location = shell.CalculatedInternalPoint3D(silverSpacing, tolerance);
if (location == null)
{
continue;
}
Space space = new Space("Cell " + index, location);
index++;
if (!result.AddObject(space))
{
continue;
}
spaces_Shell = new List <Space>()
{
space
};
dictionary_Spaces[shell] = spaces_Shell;
}
if (spaces_Shell == null || spaces_Shell.Count == 0)
{
continue;
}
double volume = double.NaN;
if (cells[i] != null)
{
Core.Modify.Add(log, "Calculating Volume");
volume = CellUtility.Volume(cells[i]);
foreach (Space space_Shell in spaces_Shell)
{
space_Shell.SetValue(SpaceParameter.Volume, volume);
}
}
Core.Modify.Add(log, "Upadting Panels");
foreach (Face3D face3D in face3Ds)
{
if (minArea != 0 && face3D.GetArea() <= minArea)
{
Core.Modify.Add(log, "Face3D is too small");
continue;
}
Core.Modify.Add(log, "Looking for existing Panel");
Tuple <Panel, Point3D> tuple_InternalPoint3D = tuples_InternalPoint3D.Find(x => face3D.Inside(x.Item2, tolerance));
if (tuple_InternalPoint3D != null)
{
Core.Modify.Add(log, "Existing Panel found: {0}", tuple_InternalPoint3D.Item1.Guid);
foreach (Space space in spaces_Shell)
{
if (result.AddRelation(space, tuple_InternalPoint3D.Item1))
{
Core.Modify.Add(log, "Space [{0}] and Panel [{1}] relation added", space.Guid, tuple_InternalPoint3D.Item1.Guid);
}
}
continue;
}
Core.Modify.Add(log, "Looking for old Panel");
//Panel panel_Old = Query.SimilarPanel(face3D, dictionary_Panel_Face3D);
//if (panel_Old == null)
// continue;
List <Panel> panels_Old = Query.SimilarPanels(face3D, dictionary_Panel_Face3D);
if (panels_Old == null || panels_Old.Count == 0)
{
continue;
}
Panel panel_Old = panels_Old.First();
if (panels_Old.Count > 1)
{
if (redundantPanels == null)
{
redundantPanels = new List <Panel>();
}
panels_Old.RemoveAt(0);
redundantPanels.AddRange(panels_Old);
}
Core.Modify.Add(log, "Old Panel found: {0}", panel_Old.Guid);
Panel panel_New = null;
if (updatePanels)
{
if (guids_Updated.Contains(panel_Old.Guid))
{
panel_New = Analytical.Create.Panel(Guid.NewGuid(), panel_Old, face3D);
Core.Modify.Add(log, "Creating new Panel for Old Panel [{0}]. New Panel [{1}]", panel_Old.Guid, panel_New.Guid);
}
else
{
panel_New = Analytical.Create.Panel(panel_Old.Guid, panel_Old, face3D);
guids_Updated.Add(panel_Old.Guid);
Core.Modify.Add(log, "Updating Panel [{0}] with new geometry", panel_New.Guid);
}
result.AddObject(panel_New);
}
else
{
panel_New = Analytical.Create.Panel(panel_Old.Guid, panel_Old, face3D);
Core.Modify.Add(log, "Creating temporary Panel for Panel [{0}]", panel_New.Guid);
}
if (panel_New == null)
{
continue;
}
tuples_InternalPoint3D.Add(new Tuple <Panel, Point3D>(panel_New, face3D.InternalPoint3D(tolerance)));
foreach (Space space in spaces_Shell)
{
if (result.AddRelation(space, panel_New))
{
Core.Modify.Add(log, "Space [{0}] and Panel [{1}] relation added", space.Guid, panel_New.Guid);
}
}
Core.Modify.Add(log, "Adding face finished");
}
}
if (redundantPanels != null && redundantPanels.Count != 0)
{
Core.Modify.Add(log, "Solving Redundant Panels");
foreach (Panel panel in redundantPanels)
{
result.RemoveObject <Panel>(panel.Guid);
}
}
List <Panel> panels_Shading = Analytical.Query.CutShading(result.GetPanels(), panels, tolerance);
if (panels_Shading != null || panels_Shading.Count != 0)
{
foreach (Panel panel_Shading in panels_Shading)
{
result.AddObject(panel_Shading);
}
}
Core.Modify.Add(log, "AdjacencyCluster verification");
Log log_AdjacencyCluster = Analytical.Create.Log(result);
if (log != null)
{
log.AddRange(log_AdjacencyCluster);
}
Core.Modify.Add(log, "Process completed");
return(result);
}
public static Model ToLadybugTools(this AnalyticalModel analyticalModel, double silverSpacing = Tolerance.MacroDistance, double tolerance = Tolerance.Distance)
{
if (analyticalModel == null)
{
return(null);
}
AnalyticalModel analyticalModel_Temp = new AnalyticalModel(analyticalModel);
analyticalModel_Temp.OffsetAperturesOnEdge(0.1, tolerance);
analyticalModel_Temp.ReplaceTransparentPanels(0.1);
string uniqueName = Core.LadybugTools.Query.UniqueName(analyticalModel_Temp);
AdjacencyCluster adjacencyCluster = analyticalModel_Temp.AdjacencyCluster;
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 = adjacencyCluster?.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 <Panel> > dictionary_elevations = Analytical.Query.MinElevationDictionary(adjacencyCluster.GetPanels(), true);
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(analyticalModel_Temp, silverSpacing, tolerance);
if (room == null)
{
continue;
}
if (levels != null && levels.Count > 0)
{
double elevation_Min = space.MinElevation(adjacencyCluster);
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 <Panel> panels_Shading = adjacencyCluster.GetShadingPanels();
if (panels_Shading != null)
{
foreach (Panel panel_Shading in panels_Shading)
{
if (panels_Shading == null)
{
continue;
}
if (panel_Shading.PanelType == PanelType.Shade)
{
Shade shade = panel_Shading.ToLadybugTools_Shade();
if (shade == null)
{
continue;
}
if (shades == null)
{
shades = new List <Shade>();
}
shades.Add(shade);
}
else
{
Face face_Orphaned = panel_Shading.ToLadybugTools_Face();
if (face_Orphaned == null)
{
continue;
}
if (faces_Orphaned == null)
{
faces_Orphaned = new List <Face>();
}
faces_Orphaned.Add(face_Orphaned);
}
}
}
MaterialLibrary materialLibrary = analyticalModel_Temp?.MaterialLibrary;
List <Construction> constructions_AdjacencyCluster = adjacencyCluster.GetConstructions();
List <ApertureConstruction> apertureConstructions_AdjacencyCluster = adjacencyCluster.GetApertureConstructions();
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 (constructions_AdjacencyCluster != null)
{
foreach (Construction construction in constructions_AdjacencyCluster)
{
List <ConstructionLayer> constructionLayers = construction.ConstructionLayers;
if (constructionLayers == null)
{
continue;
}
constructions.Add(construction.ToLadybugTools());
constructions.Add(construction.ToLadybugTools(false));
foreach (ConstructionLayer constructionLayer in constructionLayers)
{
IMaterial material = constructionLayer.Material(materialLibrary);
if (material == null)
{
continue;
}
if (dictionary_Materials.ContainsKey(material.Name))
{
continue;
}
if (material is GasMaterial)
{
List <Panel> panels = Analytical.Query.Panels(adjacencyCluster, construction);
List <double> tilts = panels.ConvertAll(x => Analytical.Query.Tilt(x).Round(Tolerance.MacroDistance));
double tilt = tilts.Distinct().ToList().Average();
tilt = Units.Convert.ToRadians(tilt);
dictionary_Materials[material.Name] = ((GasMaterial)material).ToLadybugTools(tilt, constructionLayer.Thickness);
}
else if (material is OpaqueMaterial)
{
EnergyMaterial energyMaterial = ((OpaqueMaterial)material).ToLadybugTools();
dictionary_Materials[material.Name] = energyMaterial;
if (!double.IsNaN(constructionLayer.Thickness))
{
energyMaterial.Thickness = constructionLayer.Thickness;
}
}
}
}
}
if (apertureConstructions_AdjacencyCluster != null)
{
foreach (ApertureConstruction apertureConstruction in apertureConstructions_AdjacencyCluster)
{
List <ConstructionLayer> constructionLayers = null;
constructionLayers = apertureConstruction.PaneConstructionLayers;
if (constructionLayers != null)
{
MaterialType materialType = Analytical.Query.MaterialType(constructionLayers, materialLibrary);
if (materialType != MaterialType.Undefined && materialType != MaterialType.Gas)
{
if (materialType == MaterialType.Opaque)
{
constructions.Add(apertureConstruction.ToLadybugTools());
constructions.Add(apertureConstruction.ToLadybugTools(false));
}
else
{
constructions.Add(apertureConstruction.ToLadybugTools_WindowConstructionAbridged());
constructions.Add(apertureConstruction.ToLadybugTools_WindowConstructionAbridged(false));
}
foreach (ConstructionLayer constructionLayer in constructionLayers)
{
IMaterial material = constructionLayer.Material(materialLibrary);
if (material == null)
{
continue;
}
string name = material.Name;
if (dictionary_Materials.ContainsKey(name))
{
continue;
}
if (material is TransparentMaterial)
{
dictionary_Materials[name] = ((TransparentMaterial)material).ToLadybugTools();
}
else if (material is GasMaterial)
{
dictionary_Materials[name] = ((GasMaterial)material).ToLadybugTools_EnergyWindowMaterialGas();
}
else
{
dictionary_Materials[name] = ((OpaqueMaterial)material).ToLadybugTools();
}
}
}
}
}
}
ProfileLibrary profileLibrary = analyticalModel.ProfileLibrary;
Dictionary <System.Guid, ProgramType> dictionary_InternalConditions = new Dictionary <System.Guid, ProgramType>();
if (spaces != null)
{
foreach (Space space in spaces)
{
InternalCondition internalCondition = space?.InternalCondition;
if (internalCondition == null)
{
continue;
}
if (dictionary_InternalConditions.ContainsKey(internalCondition.Guid))
{
continue;
}
ProgramType programType = space.ToLadybugTools(adjacencyCluster, profileLibrary);
if (programType != null)
{
dictionary_InternalConditions[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_InternalConditions.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, adjacencyCluster.Name, null, rooms, faces_Orphaned, shades);
model.AngleTolerance = Units.Convert.ToDegrees(Tolerance.Angle);// 2;
model.Tolerance = Tolerance.MacroDistance;
return(model);
}
protected override void TrySolveInstance(IGH_DataAccess dataAccess)
{
int index = -1;
int index_Elements = -1;
int index_Successful = -1;
index_Successful = Params.IndexOfOutputParam("successful");
if (index_Successful != -1)
{
dataAccess.SetData(index_Successful, false);
}
index_Elements = Params.IndexOfOutputParam("elements");
if (index_Elements != -1)
{
dataAccess.SetData(index_Elements, null);
}
bool run = false;
index = Params.IndexOfInputParam("_run");
if (index == -1 || !dataAccess.GetData(index, ref run) || !run)
{
return;
}
ConvertSettings convertSettings = null;
index = Params.IndexOfInputParam("_convertSettings_");
if (index != -1)
{
dataAccess.GetData(index, ref convertSettings);
}
convertSettings = this.UpdateSolutionEndEventHandler(convertSettings);
SAMObject sAMObject = null;
index = Params.IndexOfInputParam("_analytical");
if (index == -1 || !dataAccess.GetData(index, ref sAMObject))
{
return;
}
Document document = RhinoInside.Revit.Revit.ActiveDBDocument;
StartTransaction(document);
if (!(sAMObject is Panel) && !(sAMObject is Aperture) && !(sAMObject is Space) && !(sAMObject is AdjacencyCluster) && !(sAMObject is AnalyticalModel))
{
return;
}
AdjacencyCluster adjacencyCluster = null;
if (sAMObject is AdjacencyCluster)
{
adjacencyCluster = (AdjacencyCluster)sAMObject;
convertSettings.AddParameter("AdjacencyCluster", adjacencyCluster);
}
else if (sAMObject is AnalyticalModel)
{
adjacencyCluster = ((AnalyticalModel)sAMObject).AdjacencyCluster;
convertSettings.AddParameter("AnalyticalModel", (AnalyticalModel)sAMObject);
}
if (adjacencyCluster != null)
{
adjacencyCluster.GetPanels()?.ForEach(x => Core.Revit.Modify.RemoveExisting(convertSettings, document, x));
adjacencyCluster.GetSpaces()?.ForEach(x => Core.Revit.Modify.RemoveExisting(convertSettings, document, x));
}
else
{
Core.Revit.Modify.RemoveExisting(convertSettings, document, sAMObject);
}
object @object = Analytical.Revit.Convert.ToRevit(sAMObject as dynamic, document, convertSettings);
IEnumerable <Element> elements = null;
if (@object is IEnumerable)
{
elements = ((IEnumerable)@object).Cast <Element>();
}
else
{
elements = new List <Element>()
{
@object as Element
}
};
//if(elements != null)
//{
// foreach(Element element in elements)
// {
// ElementId elementId = element.Id;
// if (elementId == null)
// continue;
// elementIds.Add(elementId);
// }
//}
if (index_Elements != -1)
{
dataAccess.SetDataList(index_Elements, elements);
}
if (index_Successful != -1)
{
dataAccess.SetData(index_Successful, elements != null && elements.Count() > 0);
}
}
//protected override void OnAfterStart(Document document, string strTransactionName)
//{
// base.OnAfterStart(document, strTransactionName);
// elementIds = new HashSet<ElementId>();
//}
//protected override void OnBeforeCommit(Document document, string strTransactionName)
//{
// base.OnBeforeCommit(document, strTransactionName);
// if(elementIds != null && elementIds.Count != 0)
// {
// List<Wall> walls = new FilteredElementCollector(document, elementIds).OfClass(typeof(Wall)).Cast<Wall>().ToList();
// if(walls != null && walls.Count != 0)
// {
// Dictionary<Wall, int> dictionary = new Dictionary<Wall, int>();
// walls.ForEach(x => dictionary[x] = x.get_Parameter(BuiltInParameter.WALL_ATTR_ROOM_BOUNDING).AsInteger());
// using (SubTransaction subTransaction = new SubTransaction(document))
// {
// subTransaction.Start();
// foreach (Wall wall in dictionary.Keys)
// wall.get_Parameter(BuiltInParameter.WALL_ATTR_ROOM_BOUNDING).Set(0);
// document.Regenerate();
// subTransaction.Commit();
// subTransaction.Start();
// foreach (KeyValuePair<Wall, int> keyValuePair in dictionary)
// keyValuePair.Key.get_Parameter(BuiltInParameter.WALL_ATTR_ROOM_BOUNDING).Set(keyValuePair.Value);
// subTransaction.Commit();
// }
// }
// }
//}
}
/// <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)
{
dataAccess.SetData(4, false);
bool run = false;
if (!dataAccess.GetData(2, ref run))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
if (!run)
{
return;
}
string path_TBD = null;
if (!dataAccess.GetData(0, ref path_TBD) || string.IsNullOrWhiteSpace(path_TBD))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
IAnalyticalObject analyticalObject = null;
if (!dataAccess.GetData(1, ref analyticalObject) || analyticalObject == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
List <SpaceSimulationResult> spaceSimulationResults_Cooling = null;
List <SpaceSimulationResult> spaceSimulationResults_Heating = null;
List <Space> spaces = null;
bool result = false;
if (analyticalObject is AnalyticalModel)
{
analyticalObject = Analytical.Tas.Modify.UpdateDesignLoads(path_TBD, (AnalyticalModel)analyticalObject);
AdjacencyCluster adjacencyCluster = ((AnalyticalModel)analyticalObject).AdjacencyCluster;
if (adjacencyCluster != null)
{
spaces = adjacencyCluster.GetSpaces();
if (spaces != null)
{
spaceSimulationResults_Cooling = new List <SpaceSimulationResult>();
spaceSimulationResults_Heating = new List <SpaceSimulationResult>();
foreach (Space space in spaces)
{
List <SpaceSimulationResult> spaceSimulationResults = adjacencyCluster.GetResults <SpaceSimulationResult>(space, Analytical.Tas.Query.Source());
if (spaceSimulationResults == null)
{
continue;
}
spaceSimulationResults_Cooling.AddRange(spaceSimulationResults.FindAll(x => x.LoadType() == LoadType.Cooling));
spaceSimulationResults_Cooling.AddRange(spaceSimulationResults.FindAll(x => x.LoadType() == LoadType.Heating));
}
result = true;
}
}
}
else if (analyticalObject is BuildingModel)
{
BuildingModel buildingModel = new BuildingModel((BuildingModel)analyticalObject);
spaces = Analytical.Tas.Modify.UpdateDesignLoads(buildingModel, path_TBD);
if (spaces != null)
{
spaceSimulationResults_Cooling = new List <SpaceSimulationResult>();
spaceSimulationResults_Heating = new List <SpaceSimulationResult>();
foreach (Space space in spaces)
{
List <SpaceSimulationResult> spaceSimulationResults = buildingModel.GetResults <SpaceSimulationResult>(space, Analytical.Tas.Query.Source());
if (spaceSimulationResults == null)
{
continue;
}
spaceSimulationResults_Cooling.AddRange(spaceSimulationResults.FindAll(x => x.LoadType() == LoadType.Cooling));
spaceSimulationResults_Cooling.AddRange(spaceSimulationResults.FindAll(x => x.LoadType() == LoadType.Heating));
}
result = true;
}
analyticalObject = buildingModel;
}
dataAccess.SetData(0, new GooAnalyticalObject(analyticalObject));
dataAccess.SetDataList(1, spaces?.ConvertAll(x => new GooSpace(x)));
dataAccess.SetDataList(2, spaceSimulationResults_Cooling?.ConvertAll(x => new GooResult(x)));
dataAccess.SetDataList(3, spaceSimulationResults_Heating?.ConvertAll(x => new GooResult(x)));
dataAccess.SetData(4, result);
}
public static List <SAMType> UpdateConstructions(this TBDDocument tBDDocument, AnalyticalModel analyticalModel)
{
if (tBDDocument == null || analyticalModel == null)
{
return(null);
}
Building building = tBDDocument.Building;
if (building == null)
{
return(null);
}
AdjacencyCluster adjacencyCluster = analyticalModel.AdjacencyCluster;
if (adjacencyCluster == null)
{
return(null);
}
adjacencyCluster.SetConstructionsDefaultPanelType();
List <SAMType> result = new List <SAMType>();
Dictionary <System.Guid, Construction> dictionary_Construction = new Dictionary <System.Guid, Construction>();
foreach (Panel panel in adjacencyCluster.GetPanels())
{
if (panel == null || panel.PanelType == PanelType.Air)
{
continue;
}
Construction construction = panel.Construction;
if (construction == null)
{
continue;
}
dictionary_Construction[construction.Guid] = construction;
}
if (dictionary_Construction != null && dictionary_Construction.Count != 0)
{
List <Construction> constructions = UpdateConstructions(building, dictionary_Construction.Values, analyticalModel.MaterialLibrary);
if (constructions != null && constructions.Count != 0)
{
constructions.ForEach(x => result.Add(x));
}
}
List <ApertureConstruction> apertureConstructions = analyticalModel.AdjacencyCluster?.GetApertureConstructions();
if (apertureConstructions != null && apertureConstructions.Count != 0)
{
apertureConstructions = UpdateConstructions(building, apertureConstructions, analyticalModel.MaterialLibrary);
if (apertureConstructions != null && apertureConstructions.Count != 0)
{
apertureConstructions.ForEach(x => result.Add(x));
}
}
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));
}
}
/// <summary>
/// Updates TBD.zones in given TBD.Buiding based on provided spaces and profileLibrary
/// </summary>
/// <param name="building">TBD.Buidling</param>
/// <param name="spaces">SAM Analytical Spaces</param>
/// <param name="profileLibrary">ProfileLibrary which contains information about profiles used in spaces</param>
/// <param name="includeHDD">Include Heating Design Day in the process</param>
/// <returns>TBD.zones have been used in update process</returns>
public static bool UpdateZones(this TBD.Building building, AdjacencyCluster adjacencyCluster, ProfileLibrary profileLibrary, bool includeHDD = false)
{
if (building == null || adjacencyCluster == null || profileLibrary == null)
{
return(false);
}
List <Space> spaces = adjacencyCluster?.GetSpaces();
if (spaces == null || spaces.Count == 0)
{
return(false);
}
//Zone Dictionary <- Dictionary constains zone.name as a key and TBD.zone as Value. Dictionary helps to match TBD.zone with SAM.Analytical.Space
Dictionary <string, TBD.zone> dictionary_Zones = building.ZoneDictionary();
if (dictionary_Zones == null)
{
return(false);
}
//Space Dictionary <- Dictionary constains Space.Name as a key and SAM.Analytical.Space as Value. Assumption: InternalCondition Name equals to Space Name. It also holds names for HDD Spaces/InternalConditions
Dictionary <string, Space> dictionary_Spaces = new Dictionary <string, Space>();
foreach (Space space in spaces)
{
string name = space.Name;
if (name == null)
{
continue;
}
dictionary_Spaces[name] = space;
if (includeHDD)
{
dictionary_Spaces[space.Name + " - HDD"] = space;
}
}
//Removes Internal Conditions with given names. Names are taken from Space Name (assumption Space Name equals InternalCondtion Name)
RemoveInternalConditions(building, dictionary_Spaces.Keys);
List <TBD.zone> result = new List <TBD.zone>();
foreach (Space space in spaces)
{
string name = space?.Name;
if (name == null)
{
continue;
}
//Matching Space with TBD.zone via name
TBD.zone zone = null;
if (!dictionary_Zones.TryGetValue(name, out zone) || zone == null)
{
continue;
}
zone = building.UpdateZone(zone, space, profileLibrary);
VentilationSystem ventilationSystem = adjacencyCluster.GetRelatedObjects <VentilationSystem>(space)?.FirstOrDefault();
if (ventilationSystem != null)
{
string ventilationSystemTypeName = (ventilationSystem.Type as VentilationSystemType)?.Name;
if (!string.IsNullOrWhiteSpace(ventilationSystemTypeName))
{
TBD.ZoneGroup zoneGroup = Query.ZoneGroups(building)?.Find(x => ventilationSystemTypeName.Equals(x.name));
if (zoneGroup == null)
{
zoneGroup = building.AddZoneGroup();
zoneGroup.name = ventilationSystemTypeName;
zoneGroup.type = (int)TBD.ZoneGroupType.tbdHVACZG;
}
if (zoneGroup != null)
{
zoneGroup.InsertZone(zone);
}
}
}
//Update TBD.zone using data stored in space and ProfileLibrary
result.Add(zone);
//Include HDD if includeHDD input set to true
if (includeHDD)
{
building.UpdateZone_HDD(zone, space, profileLibrary);
}
}
//Updating Builidng Information
building.description = string.Format("Delivered by SAM https://github.com/HoareLea/SAM [{0}]", System.DateTime.Now.ToString("yyyy/MM/dd"));
TBD.GeneralDetails generaldetails = building.GetGeneralDetails();
if (generaldetails != null)
{
if (generaldetails.engineer1 == "")
{
generaldetails.engineer1 = System.Environment.UserName;
}
else if (generaldetails.engineer1 != System.Environment.UserName)
{
generaldetails.engineer2 = System.Environment.UserName;
}
if (generaldetails.externalPollutant == 315) //600
{
generaldetails.externalPollutant = 415;
}
generaldetails.TerrainType = TBD.TerrainType.tbdCity;
}
//Returning TBD.zones have been used in update process
return(result != null && result.Count > 0);
}
