public static Dictionary <string, object> GetEnergySettings()
{
// Get current document
Document RvtDoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument.Document;
// Load the default energy setting from the active Revit instance
EnergyDataSettings es = Autodesk.Revit.DB.Analysis.EnergyDataSettings.GetFromDocument(RvtDoc);
return(new Dictionary <string, object>
{
{ "BldgType", Enum.GetName(typeof(gbXMLBuildingType), es.BuildingType) },
{ "GlzPer", es.PercentageGlazing },
{ "SkylightPer", es.PercentageSkylights },
{ "ShadeDepth", es.ShadeDepth },
// { "ShadeDepth", es.ShadeDepth * UnitConverter.HostToDynamoFactor},
{ "HVACSystem", Enum.GetName(typeof(gbXMLBuildingHVACSystem), es.BuildingHVACSystem) },
{ "OSchedule", Enum.GetName(typeof(gbXMLBuildingOperatingSchedule), es.BuildingOperatingSchedule) },
{ "CoreOffset", es.MassZoneCoreOffset },
{ "DividePerimeter", es.MassZoneDividePerimeter }
});
// User Visible Versions NOTE: this available in only Revit 2015 API
//EnergyDataSettings es = EnergyDataSettings.GetFromDocument(RvtDoc);
//es.get_Parameter(BuiltInParameter.ENERGY_ANALYSIS_HVAC_SYSTEM).AsValueString();
}
public static void ActivateEnergyModel(Document RvtDoc)
{
//try to get at least one MassEnergyAnalyticalModel object in the doc. if there is one there, we don't need to turn on the energy model
FilteredElementCollector col = new FilteredElementCollector(RvtDoc);
var meas = col.OfClass(typeof(MassEnergyAnalyticalModel)).ToElementIds();
if (meas.Count != 0)
{
return;
}
//if we make it here, turn on the Analytical model, and regenerate the doc
TransactionManager.Instance.EnsureInTransaction(RvtDoc);
EnergyDataSettings energyData = EnergyDataSettings.GetFromDocument(RvtDoc);
if (energyData != null)
{
energyData.SetCreateAnalyticalModel(true);
}
TransactionManager.Instance.TransactionTaskDone();
DocumentManager.Regenerate();
}
public static Dictionary <string, int> CreateProject(string ProjectTitle)
{
//1. Output variable
int newProjectId = 0;
//2. Initiate the Revit Auth
Helper.InitRevitAuthProvider();
//NOTE: GBS allows to duplicate Project Titles !!! from user point of view we would like keep Project Titles Unique.
//Create Project node return the Id of a project if it already exists. If more than one project with the same name already exist, throw an exception telling the user that multiple projects with that name exist.
//Check if the project exists
List <Project> ExtngProjects = Helper.GetExistingProjectsTitles();
var queryProjects = from pr in ExtngProjects
where pr.Title == ProjectTitle
select pr;
if (queryProjects.Any()) // Existing Project
{
// check if multiple projects
if (queryProjects.Count() > 1)
{
// if there are multiple thow and exception
throw new Exception("Multiple Projects with this title " + ProjectTitle + " exist. Try with a another name or use GetProjectList Node to get the existing GBS projects' attributes");
}
else
{
newProjectId = queryProjects.First().Id;
}
}
else //Create New Project
{
#region Setup : Get values from current Revit document
//local variable to get SiteLocation and Lat & Lon information
Document RvtDoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument.Document;
//Load the default energy setting from the active Revit instance
EnergyDataSettings myEnergySettings = Autodesk.Revit.DB.Analysis.EnergyDataSettings.GetFromDocument(RvtDoc);
// get BuildingType and ScheduleId from document
// Remap Revit enum/values to GBS enum/ values
string RvtBldgtype = Enum.GetName(typeof(gbXMLBuildingType), myEnergySettings.BuildingType);
int BuildingTypeId = Helper.RemapBldgType(RvtBldgtype);
// this for comparison
int RvtBuildingTypeId = (int)myEnergySettings.BuildingType;
// Lets set the schedule ID to 1 for now
//int ScheduleId = (int)myEnergySettings.BuildingOperatingSchedule;
int ScheduleId = Helper.RemapScheduleType((int)myEnergySettings.BuildingOperatingSchedule);
// Angles are in Rdaians when coming from revit API
// Convert to lat & lon values
const double angleRatio = Math.PI / 180; // angle conversion factor
double lat = RvtDoc.SiteLocation.Latitude / angleRatio;
double lon = RvtDoc.SiteLocation.Longitude / angleRatio;
#endregion
#region Setup : Get default Utility Values
//1. Initiate the Revit Auth
Helper.InitRevitAuthProvider();
// Try to get Default Utility Costs from API
string requestGetDefaultUtilityCost = GBSUri.GBSAPIUri + APIV1Uri.GetDefaultUtilityCost;
string requestUriforUtilityCost = string.Format(requestGetDefaultUtilityCost, BuildingTypeId, lat, lon, "xml");
HttpWebResponse responseUtility = (HttpWebResponse)Helper._CallGetApi(requestUriforUtilityCost);
string theresponse = "";
using (Stream responseStream = responseUtility.GetResponseStream())
{
using (StreamReader streamReader = new StreamReader(responseStream))
{
theresponse = streamReader.ReadToEnd();
}
}
DefaultUtilityItem utilityCost = Helper.DataContractDeserialize <DefaultUtilityItem>(theresponse);
#endregion
// 2. Create A New Project
string requestUri = GBSUri.GBSAPIUri + string.Format(APIV1Uri.CreateProjectUri, "xml");
var response =
(HttpWebResponse)
Helper._CallPostApi(requestUri, typeof(NewProjectItem), Helper._CreateProjectItem(ProjectTitle, false, BuildingTypeId, ScheduleId, lat, lon, utilityCost.ElecCost, utilityCost.FuelCost));
newProjectId = Helper.DeserializeHttpWebResponse(response);
}
// 3. Populate the Outputs
return(new Dictionary <string, int>
{
{ "ProjectId", newProjectId }
});
}
public static bool TogbXML(this Document document, string path)
{
if (document == null || document.IsFamilyDocument || string.IsNullOrWhiteSpace(path))
{
return(false);
}
bool result = true;
try
{
using (Transaction transaction = new Transaction(document, "Export gbXML"))
{
transaction.Start();
EnergyAnalysisDetailModel energyAnalysisDetailModel = null;
using (SubTransaction subTransaction = new SubTransaction(document))
{
subTransaction.Start();
energyAnalysisDetailModel = EnergyAnalysisDetailModel.GetMainEnergyAnalysisDetailModel(document);
if (energyAnalysisDetailModel != null && energyAnalysisDetailModel.IsValidObject)
{
document.Delete(energyAnalysisDetailModel.Id);
}
subTransaction.Commit();
}
//Reseting Project Base Point
IEnumerable <Element> elements = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_ProjectBasePoint);
foreach (Element aElement in elements)
{
if (aElement.Pinned)
{
aElement.Pinned = false;
}
Parameter parameter = null;
parameter = aElement.get_Parameter(BuiltInParameter.BASEPOINT_EASTWEST_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = aElement.get_Parameter(BuiltInParameter.BASEPOINT_NORTHSOUTH_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = aElement.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = aElement.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = aElement.get_Parameter(BuiltInParameter.BASEPOINT_ANGLETON_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
}
EnergyAnalysisDetailModelOptions energyAnalysisDetailModelOptions = new EnergyAnalysisDetailModelOptions();
energyAnalysisDetailModelOptions.Tier = EnergyAnalysisDetailModelTier.SecondLevelBoundaries;
energyAnalysisDetailModelOptions.EnergyModelType = EnergyModelType.SpatialElement;
energyAnalysisDetailModelOptions.ExportMullions = true;
energyAnalysisDetailModelOptions.IncludeShadingSurfaces = true;
energyAnalysisDetailModelOptions.SimplifyCurtainSystems = false;
EnergyDataSettings energyDataSettings = EnergyDataSettings.GetFromDocument(document);
energyDataSettings.ExportComplexity = gbXMLExportComplexity.ComplexWithMullionsAndShadingSurfaces;
energyDataSettings.ExportDefaults = false;
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
energyDataSettings.SliverSpaceTolerance = UnitUtils.ConvertToInternalUnits(5, DisplayUnitType.DUT_MILLIMETERS);
#else
energyDataSettings.SliverSpaceTolerance = UnitUtils.ConvertToInternalUnits(5, UnitTypeId.Millimeters);
#endif
energyDataSettings.AnalysisType = AnalysisMode.BuildingElements;
energyDataSettings.EnergyModel = false;
energyAnalysisDetailModel = EnergyAnalysisDetailModel.Create(document, energyAnalysisDetailModelOptions);
GBXMLExportOptions gBXMLExportOptions = new GBXMLExportOptions();
gBXMLExportOptions.ExportEnergyModelType = ExportEnergyModelType.SpatialElement;
if (!document.Export(System.IO.Path.GetDirectoryName(path), System.IO.Path.GetFileName(path), gBXMLExportOptions))
{
result = false;
}
transaction.RollBack();
}
}
catch (System.Exception Exception)
{
result = false;
}
return(result);
}
public static Dictionary <string, object> SetEnergySettings(string BldgTyp = "", double GlzPer = 0, double ShadeDepth = 0, double SkylightPer = 0, string HVACSystem = "", string OSchedule = "")
{
//Get active document
Document RvtDoc = DocumentManager.Instance.CurrentUIApplication.ActiveUIDocument.Document;
//enable the analytical model in the document if it isn't already
try
{
PrepareEnergyModel.ActivateEnergyModel(RvtDoc);
}
catch (Exception)
{
throw new Exception("Something went wrong when trying to enable the energy model.");
}
//Load the default energy setting from the active Revit instance
EnergyDataSettings myEnergySettings = Autodesk.Revit.DB.Analysis.EnergyDataSettings.GetFromDocument(RvtDoc);
//make sure we are in a transaction
TransactionManager.Instance.EnsureInTransaction(RvtDoc);
if (!string.IsNullOrEmpty(BldgTyp))
{
Autodesk.Revit.DB.Analysis.gbXMLBuildingType type;
try
{
type = (Autodesk.Revit.DB.Analysis.gbXMLBuildingType)Enum.Parse(typeof(Autodesk.Revit.DB.Analysis.gbXMLBuildingType), BldgTyp);
}
catch (Exception)
{
throw new Exception("Building type is not found");
}
myEnergySettings.BuildingType = type;
}
if (!string.IsNullOrEmpty(HVACSystem))
{
Autodesk.Revit.DB.Analysis.gbXMLBuildingHVACSystem type;
try
{
type = (Autodesk.Revit.DB.Analysis.gbXMLBuildingHVACSystem)Enum.Parse(typeof(Autodesk.Revit.DB.Analysis.gbXMLBuildingHVACSystem), HVACSystem);
}
catch (Exception)
{
throw new Exception("HVAC system is not found");
}
myEnergySettings.BuildingHVACSystem = type;
}
if (!string.IsNullOrEmpty(OSchedule))
{
Autodesk.Revit.DB.Analysis.gbXMLBuildingOperatingSchedule type;
try
{
type = (Autodesk.Revit.DB.Analysis.gbXMLBuildingOperatingSchedule)Enum.Parse(typeof(Autodesk.Revit.DB.Analysis.gbXMLBuildingOperatingSchedule), OSchedule);
}
catch (Exception)
{
throw new Exception("Operating Schedule is not found");
}
myEnergySettings.BuildingOperatingSchedule = type;
}
if (GlzPer > 0.0 && GlzPer <= 1.0)
{
try
{
myEnergySettings.PercentageGlazing = GlzPer;
}
catch (Exception)
{
throw new Exception("The Glazing Percentage input range should be 0 - 1");
}
}
if (ShadeDepth > 0.0)
{
myEnergySettings.IsGlazingShaded = true;
myEnergySettings.ShadeDepth = ShadeDepth * UnitConverter.DynamoToHostFactor;
}
else
{
myEnergySettings.IsGlazingShaded = false;
myEnergySettings.ShadeDepth = 0;
}
// add skylight percentage
myEnergySettings.PercentageSkylights = SkylightPer;
//done with the transaction
TransactionManager.Instance.TransactionTaskDone();
// Report
string report = "Building type is " + Enum.GetName(typeof(gbXMLBuildingType), myEnergySettings.BuildingType) + ".\n" +
"Glazing percentage is set to " + myEnergySettings.PercentageGlazing.ToString() + ".\n" +
"Shading depth is " + ShadeDepth.ToString() + ".\n" +
"Current HVAC system is " + Enum.GetName(typeof(gbXMLBuildingHVACSystem), myEnergySettings.BuildingHVACSystem) + ".\n" +
"Current Operating Schedule is " + Enum.GetName(typeof(gbXMLBuildingOperatingSchedule), myEnergySettings.BuildingOperatingSchedule) + ".";
return(new Dictionary <string, object>
{
{ "EnergySettings", myEnergySettings },
{ "report", report }
});
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <IBHoMObject> EnergyAnalysisModelFromRevit(this EnergyAnalysisDetailModel energyAnalysisModel, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null)
{
if (energyAnalysisModel.Document.IsLinked)
{
BH.Engine.Reflection.Compute.RecordError($"It is not allowed to pull the energy analysis model from linked models - please open the document {energyAnalysisModel.Document.PathName} and pull directly from it instead.");
return(null);
}
settings = settings.DefaultIfNull();
ElementId modelId = energyAnalysisModel.Id;
List <IBHoMObject> result = refObjects.GetValues <IBHoMObject>(energyAnalysisModel.Id);
if (result != null)
{
return(result);
}
Document document = energyAnalysisModel.Document;
ProjectInfo projectInfo = new FilteredElementCollector(document).OfClass(typeof(ProjectInfo)).FirstOrDefault() as ProjectInfo;
if (projectInfo == null)
{
BH.Engine.Reflection.Compute.RecordError("Project info of a document has not been found.");
}
else
{
projectInfo.BuildingFromRevit(settings, refObjects);
}
using (Transaction transaction = new Transaction(document, "GetAnalyticalModel"))
{
transaction.Start();
FailureHandlingOptions failureHandlingOptions = transaction.GetFailureHandlingOptions();
failureHandlingOptions.SetFailuresPreprocessor(new WarningSwallower());
transaction.SetFailureHandlingOptions(failureHandlingOptions);
EnergyAnalysisDetailModelOptions energyAnalysisDetailModelOptions = new EnergyAnalysisDetailModelOptions();
energyAnalysisDetailModelOptions.Tier = EnergyAnalysisDetailModelTier.SecondLevelBoundaries;
energyAnalysisDetailModelOptions.EnergyModelType = EnergyModelType.SpatialElement;
energyAnalysisDetailModelOptions.ExportMullions = true;
energyAnalysisDetailModelOptions.IncludeShadingSurfaces = true;
energyAnalysisDetailModelOptions.SimplifyCurtainSystems = false;
EnergyDataSettings energyDataSettings = EnergyDataSettings.GetFromDocument(document);
energyDataSettings.ExportComplexity = gbXMLExportComplexity.ComplexWithMullionsAndShadingSurfaces;
energyDataSettings.ExportDefaults = false;
energyDataSettings.SliverSpaceTolerance = Convert.FromSI(0.005, UnitType.UT_Length);
energyDataSettings.AnalysisType = AnalysisMode.BuildingElements;
energyDataSettings.EnergyModel = false;
//Reseting Project Base Point
IEnumerable <Element> elements = new FilteredElementCollector(document).OfCategory(Autodesk.Revit.DB.BuiltInCategory.OST_ProjectBasePoint);
foreach (Element element in elements)
{
if (element.Pinned)
{
element.Pinned = false;
}
Parameter parameter = null;
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_EASTWEST_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_NORTHSOUTH_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ANGLETON_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
}
//AnalyticalSpaces
energyAnalysisModel = EnergyAnalysisDetailModel.Create(document, energyAnalysisDetailModelOptions);
IList <EnergyAnalysisSpace> energyAnalysisSpaces = energyAnalysisModel.GetAnalyticalSpaces();
Dictionary <string, EnergyAnalysisSurface> energyAnalsyisSurfaces = new Dictionary <string, EnergyAnalysisSurface>();
foreach (EnergyAnalysisSpace energyAnalysisSpace in energyAnalysisSpaces)
{
try
{
Space space = energyAnalysisSpace.SpaceFromRevit(settings, refObjects);
foreach (EnergyAnalysisSurface energyAnalysisSurface in energyAnalysisSpace.GetAnalyticalSurfaces())
{
if (!energyAnalsyisSurfaces.ContainsKey(energyAnalysisSurface.SurfaceName))
{
energyAnalsyisSurfaces.Add(energyAnalysisSurface.SurfaceName, energyAnalysisSurface);
}
}
}
catch
{
energyAnalysisSpace.ElementCouldNotBeQueriedWarning();
}
}
//EnergyAnalysisSurfaces
foreach (KeyValuePair <string, EnergyAnalysisSurface> kvp in energyAnalsyisSurfaces)
{
try
{
oM.Environment.Elements.Panel panel = kvp.Value.EnvironmentPanelFromRevit(settings, refObjects);
List <IBHoMObject> hostedBHoMObjects = new List <IBHoMObject>();
foreach (EnergyAnalysisOpening energyAnalysisOpening in kvp.Value.GetAnalyticalOpenings())
{
oM.Environment.Elements.Opening opening = energyAnalysisOpening.OpeningFromRevit(settings, refObjects);
panel.Openings.Add(opening);
}
}
catch
{
kvp.Value.ElementCouldNotBeQueriedWarning();
}
}
//AnalyticalShadingSurfaces
IList <EnergyAnalysisSurface> analyticalShadingSurfaces = energyAnalysisModel.GetAnalyticalShadingSurfaces();
foreach (EnergyAnalysisSurface energyAnalysisSurface in analyticalShadingSurfaces)
{
try
{
oM.Environment.Elements.Panel panel = energyAnalysisSurface.EnvironmentPanelFromRevit(settings, refObjects);
List <IBHoMObject> hostedBHoMObjects = new List <IBHoMObject>();
foreach (EnergyAnalysisOpening energyOpening in energyAnalysisSurface.GetAnalyticalOpenings())
{
oM.Environment.Elements.Opening opening = energyOpening.OpeningFromRevit(settings, refObjects);
panel.Openings.Add(opening);
}
}
catch
{
energyAnalysisSurface.ElementCouldNotBeQueriedWarning();
}
}
transaction.RollBack();
}
//Levels
IEnumerable <Level> levels = new FilteredElementCollector(document).OfClass(typeof(Level)).Cast <Level>();
foreach (Level level in levels)
{
level.LevelFromRevit(settings, refObjects);
}
result = new List <IBHoMObject>();
foreach (List <IBHoMObject> bhomObjects in refObjects.Values)
{
if (bhomObjects != null)
{
result.AddRange(bhomObjects);
}
}
refObjects.AddOrReplace(modelId, result);
return(result);
}
/// <summary>
/// Initializes private variables.
/// </summary>
/// <param name="gbXMLParamElem">gbXMLParamElem</param>
public EnergyDataSettingsWrapper(Document document)
{
m_document = document;
m_energyDataSettings = EnergyDataSettings.GetFromDocument(document);
}
public static AnalyticalModel ToSAM_AnalyticalModel(this Document document, ConvertSettings convertSettings)
{
if (document == null)
{
return(null);
}
ProjectInfo projectInfo = document.ProjectInformation;
AnalyticalModel result = convertSettings?.GetObject <AnalyticalModel>(projectInfo?.Id);
if (result != null)
{
return(result);
}
Core.Location location = Core.Revit.Query.Location(document);
Address address = null;
if (projectInfo != null)
{
address = new Address(Guid.NewGuid(), projectInfo.BuildingName, projectInfo.Address, null, null, CountryCode.Undefined);
}
AdjacencyCluster adjacencyCluster = new AdjacencyCluster();
EnergyAnalysisDetailModelOptions energyAnalysisDetailModelOptions = new EnergyAnalysisDetailModelOptions();
energyAnalysisDetailModelOptions.Tier = EnergyAnalysisDetailModelTier.SecondLevelBoundaries;
energyAnalysisDetailModelOptions.EnergyModelType = EnergyModelType.SpatialElement;
energyAnalysisDetailModelOptions.ExportMullions = true;
energyAnalysisDetailModelOptions.IncludeShadingSurfaces = true;
energyAnalysisDetailModelOptions.SimplifyCurtainSystems = false;
EnergyDataSettings energyDataSettings = EnergyDataSettings.GetFromDocument(document);
energyDataSettings.ExportComplexity = gbXMLExportComplexity.ComplexWithMullionsAndShadingSurfaces;
energyDataSettings.ExportDefaults = false;
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
energyDataSettings.SliverSpaceTolerance = UnitUtils.ConvertToInternalUnits(0.005, DisplayUnitType.DUT_METERS);
#else
energyDataSettings.SliverSpaceTolerance = UnitUtils.ConvertToInternalUnits(0.005, UnitTypeId.Meters);
#endif
energyDataSettings.AnalysisType = AnalysisMode.BuildingElements;
energyDataSettings.EnergyModel = false;
//Reseting Project Base Point
IEnumerable <Element> elements = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_ProjectBasePoint);
foreach (Element element in elements)
{
if (element.Pinned)
{
element.Pinned = false;
}
Parameter parameter = null;
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_EASTWEST_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_NORTHSOUTH_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ELEVATION_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
parameter = element.get_Parameter(BuiltInParameter.BASEPOINT_ANGLETON_PARAM);
if (parameter != null && !parameter.IsReadOnly)
{
parameter.Set(0.0);
}
}
//AnalyticalSpaces
EnergyAnalysisDetailModel energyAnalysisDetailModel = EnergyAnalysisDetailModel.Create(document, energyAnalysisDetailModelOptions);
IList <EnergyAnalysisSpace> energyAnalysisSpaces = energyAnalysisDetailModel.GetAnalyticalSpaces();
Dictionary <string, Tuple <Panel, List <Space> > > dictionary = new Dictionary <string, Tuple <Panel, List <Space> > >();
foreach (EnergyAnalysisSpace energyAnalysisSpace in energyAnalysisSpaces)
{
try
{
if (energyAnalysisSpace.Area <= Core.Tolerance.MacroDistance)
{
continue;
}
Space space = energyAnalysisSpace.ToSAM(convertSettings);
if (space == null)
{
continue;
}
Shell shell = Geometry.Revit.Convert.ToSAM(energyAnalysisSpace.GetClosedShell());
if (shell == null)
{
continue;
}
adjacencyCluster.AddObject(space);
foreach (EnergyAnalysisSurface energyAnalysisSurface in energyAnalysisSpace.GetAnalyticalSurfaces())
{
Tuple <Panel, List <Space> > tuple;
if (!dictionary.TryGetValue(energyAnalysisSurface.SurfaceName, out tuple))
{
Panel panel = energyAnalysisSurface.ToSAM(convertSettings, shell);
if (panel == null)
{
continue;
}
tuple = new Tuple <Panel, List <Space> >(panel, new List <Space>());
dictionary[energyAnalysisSurface.SurfaceName] = tuple;
}
tuple.Item2.Add(space);
}
}
catch
{
}
}
#region Additional Checks (WIP)
//Additional Check for wrongly recoginzed internal panels (WIP)
List <Tuple <string, Panel, Space, Face3D> > tuples_External = new List <Tuple <string, Panel, Space, Face3D> >();
foreach (KeyValuePair <string, Tuple <Panel, List <Space> > > keyValuePair in dictionary)
{
Tuple <Panel, List <Space> > tuple = keyValuePair.Value;
if (tuple.Item1 != null && tuple.Item2 != null && tuple.Item2.Count == 1)
{
Face3D face3D = tuple.Item1.GetFace3D();
if (face3D != null)
{
tuples_External.Add(new Tuple <string, Panel, Space, Face3D>(keyValuePair.Key, tuple.Item1, tuple.Item2[0], face3D));
}
}
}
while (tuples_External.Count > 0)
{
Tuple <string, Panel, Space, Face3D> tuple = tuples_External[0];
tuples_External.RemoveAt(0);
Point3D point3D = tuple.Item4.InternalPoint3D();
if (point3D == null)
{
continue;
}
List <Tuple <string, Panel, Space, Face3D> > tuples_Overlap = tuples_External.FindAll(x => x.Item4.Inside(point3D));
if (tuples_Overlap.Count != 1)
{
continue;
}
tuples_Overlap.Add(tuple);
tuples_Overlap.Sort((x, y) => y.Item4.GetArea().CompareTo(x.Item4.GetArea()));
tuple = tuples_Overlap[0];
Tuple <string, Panel, Space, Face3D> tuple_Overlap = tuples_Overlap[1];
dictionary[tuple.Item1].Item2.Add(tuple_Overlap.Item3);
dictionary[tuple_Overlap.Item1] = new Tuple <Panel, List <Space> >(Analytical.Create.Panel(dictionary[tuple_Overlap.Item1].Item1, PanelType.Shade), null);
int index = tuples_External.IndexOf(tuple_Overlap);
if (index != -1)
{
tuples_External.RemoveAt(index);
}
}
#endregion
foreach (Tuple <Panel, List <Space> > tuple in dictionary.Values)
{
Panel panel = tuple.Item1;
adjacencyCluster.AddObject(panel);
tuple.Item2?.ForEach(x => adjacencyCluster.AddRelation(x, panel));
}
//AnalyticalShadingSurfaces
IList <EnergyAnalysisSurface> analyticalShadingSurfaces = energyAnalysisDetailModel.GetAnalyticalShadingSurfaces();
foreach (EnergyAnalysisSurface energyAnalysisSurface in analyticalShadingSurfaces)
{
try
{
Panel panel = energyAnalysisSurface.ToSAM(convertSettings);
if (panel == null)
{
continue;
}
panel = Analytical.Create.Panel(panel, PanelType.Shade);
adjacencyCluster.AddObject(panel);
}
catch
{
}
}
adjacencyCluster.MapZones();
IEnumerable <IMaterial> materials = Analytical.Query.Materials(adjacencyCluster, Analytical.ActiveSetting.Setting.GetValue <MaterialLibrary>(AnalyticalSettingParameter.DefaultMaterialLibrary));
MaterialLibrary materialLibrary = Core.Create.MaterialLibrary("Default Material Library", materials);
IEnumerable <Profile> profiles = Analytical.Query.Profiles(adjacencyCluster, Analytical.ActiveSetting.Setting.GetValue <ProfileLibrary>(AnalyticalSettingParameter.DefaultProfileLibrary));
ProfileLibrary profileLibrary = new ProfileLibrary("Default Profile Library", profiles);
result = new AnalyticalModel(document.Title, null, location, address, adjacencyCluster, materialLibrary, profileLibrary);
result.UpdateParameterSets(document.ProjectInformation, ActiveSetting.Setting.GetValue <TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(projectInfo.Id, result);
return(result);
}
/// <summary>
/// Initializes private variables.
/// </summary>
/// <param name="gbXMLParamElem">gbXMLParamElem</param>
public EnergyDataSettingsWrapper(Document document)
{
m_document = document;
m_energyDataSettings = EnergyDataSettings.GetFromDocument(document);
}
