public static List <Panel> ToSAM_Panels(this FamilyInstance familyInstance, ConvertSettings convertSettings)
{
if (familyInstance == null)
{
return(null);
}
List <Panel> result = convertSettings?.GetObjects <Panel>(familyInstance.Id);
if (result != null)
{
return(result);
}
RevitInstance3D revitInstance3D = Geometry.Revit.Convert.ToSAM(familyInstance, convertSettings) as RevitInstance3D;
if (revitInstance3D == null)
{
return(null);
}
result = ToSAM_Panels(revitInstance3D);
if (result != null)
{
convertSettings?.Add(familyInstance.Id, result);
}
return(result);
}
public static List <Element> ToRevit(this AnalyticalModel analyticalModel, Document document, ConvertSettings convertSettings)
{
if (analyticalModel == null || document == null)
{
return(null);
}
List <Element> result = convertSettings?.GetObjects <Element>(analyticalModel.Guid);
if (result != null)
{
return(result);
}
result = ToRevit(analyticalModel.AdjacencyCluster, document, convertSettings);
if (convertSettings.ConvertParameters)
{
ProjectInfo projectInfo = document.ProjectInformation;
if (projectInfo != null)
{
if (result.Find(x => x.Id == projectInfo.Id) == null)
{
result.Add(projectInfo);
}
Core.Revit.Modify.SetValues(projectInfo, analyticalModel);
Core.Revit.Modify.SetValues(projectInfo, analyticalModel, ActiveSetting.Setting, convertSettings.GetParameters());
}
}
convertSettings?.Add(analyticalModel.Guid, result);
return(result);
}
public static ProjectInfo ToRevit(this AdjacencyClusterSimulationResult adjacencyClusterSimulationResult, Document document, ConvertSettings convertSettings)
{
if (adjacencyClusterSimulationResult == null || document == null)
{
return(null);
}
ProjectInfo result = convertSettings?.GetObject <ProjectInfo>(adjacencyClusterSimulationResult.Guid);
if (result != null)
{
return(result);
}
result = document.ProjectInformation;
if (convertSettings.ConvertParameters)
{
if (result != null)
{
Core.Revit.Modify.SetValues(result, adjacencyClusterSimulationResult);
Core.Revit.Modify.SetValues(result, adjacencyClusterSimulationResult, ActiveSetting.Setting);
Modify.SetValues(result, adjacencyClusterSimulationResult, ActiveSetting.Setting, adjacencyClusterSimulationResult.LoadType());
}
}
convertSettings?.Add(adjacencyClusterSimulationResult.Guid, result);
return(result);
}
public static IOpening ToSAM_Opening(this EnergyAnalysisOpening energyAnalysisOpening, ConvertSettings convertSettings)
{
if (energyAnalysisOpening == null)
{
return(null);
}
IOpening result = convertSettings?.GetObject <IOpening>(energyAnalysisOpening.Id);
if (result != null)
{
return(result);
}
Polygon3D polygon3D = energyAnalysisOpening.GetPolyloop().ToSAM();
if (polygon3D == null)
{
return(null);
}
FamilyInstance familyInstance = Core.Revit.Query.Element(energyAnalysisOpening) as FamilyInstance;
if (familyInstance == null)
{
return(null);
}
if (Core.Revit.Query.Simplified(familyInstance))
{
result = Core.Revit.Query.IJSAMObjects <IOpening>(familyInstance)?.FirstOrDefault();
if (result != null)
{
return(result);
}
}
OpeningType openingType = ToSAM_OpeningType(familyInstance.Symbol, convertSettings);
Point3D point3D_Location = Geometry.Revit.Query.LocationPoint3D(familyInstance);
if (point3D_Location == null)
{
return(null);
}
Face3D face3D = new Face3D(Geometry.Spatial.Create.IClosedPlanar3D(polygon3D, point3D_Location));
if (face3D == null)
{
return(null);
}
result = Analytical.Create.Opening(openingType, face3D);
result.UpdateParameterSets(familyInstance);
convertSettings?.Add(energyAnalysisOpening.Id, result);
return(result);
}
public static RevitType ToSAM(this ElementType elementType, ConvertSettings convertSettings)
{
if (elementType == null)
{
return(null);
}
RevitType result = convertSettings?.GetObject <RevitType>(elementType.Id);
if (result != null)
{
return(result);
}
switch (elementType.Category.CategoryType)
{
case CategoryType.AnalyticalModel:
case CategoryType.Model:
result = new RevitType3D(elementType.Name);
break;
case CategoryType.Annotation:
result = new RevitType2D(elementType.Name);
break;
}
if (result != null)
{
result.UpdateParameterSets(elementType, ActiveSetting.Setting.GetValue <TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(elementType.Id, result);
}
return(result);
}
public static DesignOption ToSAM(this Autodesk.Revit.DB.DesignOption designOption, ConvertSettings convertSettings)
{
if (designOption == null)
{
return(null);
}
DesignOption result = convertSettings?.GetObject <DesignOption>(designOption.Id);
if (result != null)
{
return(result);
}
result = new DesignOption(designOption.Name, designOption.IsPrimary);
result.UpdateParameterSets(designOption, ActiveSetting.Setting.GetValue <TypeMap>(ActiveSetting.Name.ParameterMap));
if (result != null)
{
convertSettings?.Add(designOption.Id, result);
}
return(result);
}
public static Level ToSAM(this Autodesk.Revit.DB.Level level, ConvertSettings convertSettings)
{
if (level == null)
{
return(null);
}
Document document = level.Document;
Level result = convertSettings?.GetObject <Level>(level.Id);
if (result != null)
{
return(result);
}
double elevation = Query.Elevation(level);
result = new Level(level.Name, elevation);
result.UpdateParameterSets(level, ActiveSetting.Setting.GetValue <Core.TypeMap>(ActiveSetting.Name.ParameterMap));
//result.Add(Core.Revit.Query.ParameterSet(level));
convertSettings?.Add(level.Id, result);
return(result);
}
public static Aperture ToSAM(this EnergyAnalysisOpening energyAnalysisOpening, ConvertSettings convertSettings)
{
if (energyAnalysisOpening == null)
{
return(null);
}
Aperture result = convertSettings?.GetObject <Aperture>(energyAnalysisOpening.Id);
if (result != null)
{
return(result);
}
Polygon3D polygon3D = energyAnalysisOpening.GetPolyloop().ToSAM();
if (polygon3D == null)
{
return(null);
}
FamilyInstance familyInstance = Core.Revit.Query.Element(energyAnalysisOpening) as FamilyInstance;
if (familyInstance == null)
{
return(new Aperture(null, polygon3D));
}
if (Core.Revit.Query.Simplified(familyInstance))
{
result = Core.Revit.Query.IJSAMObjects <Aperture>(familyInstance)?.FirstOrDefault();
if (result != null)
{
return(result);
}
}
ApertureConstruction apertureConstruction = ToSAM_ApertureConstruction(familyInstance, convertSettings);
Point3D point3D_Location = Geometry.Revit.Query.LocationPoint3D(familyInstance);
if (point3D_Location == null)
{
return(null);
}
result = new Aperture(apertureConstruction, polygon3D, point3D_Location);
result.UpdateParameterSets(energyAnalysisOpening, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
//result.UpdateParameterSets(familyInstance, ActiveSetting.Setting.GetValue<Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
//result.Add(Core.Revit.Query.ParameterSet(familyInstance));
convertSettings?.Add(energyAnalysisOpening.Id, result);
return(result);
}
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);
}
public static Autodesk.Revit.DB.Mechanical.Space ToRevit(this Space space, Document document, ConvertSettings convertSettings)
{
if (space == null)
{
return(null);
}
Autodesk.Revit.DB.Mechanical.Space result = convertSettings?.GetObject <Autodesk.Revit.DB.Mechanical.Space>(space.Guid);
if (result != null)
{
return(result);
}
if (!convertSettings.RemoveExisting)
{
result = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, space);
}
if (result == null)
{
double lowElevation = Query.LowElevation(space);
if (double.IsNaN(lowElevation))
{
return(null);
}
Level level = Geometry.Revit.Query.LowLevel(document, lowElevation);
if (level == null)
{
return(null);
}
result = document.Create.NewSpace(level, new UV(UnitUtils.ConvertToInternalUnits(space.Location.X, DisplayUnitType.DUT_METERS), UnitUtils.ConvertToInternalUnits(space.Location.Y, DisplayUnitType.DUT_METERS)));
}
if (result == null)
{
return(null);
}
result.get_Parameter(BuiltInParameter.ROOM_NAME).Set(space.Name);
if (convertSettings.ConvertParameters)
{
Core.Revit.Modify.SetValues(result, space);
Core.Revit.Modify.SetValues(result, space, ActiveSetting.Setting);
Core.Revit.Modify.SetJson(result, space.ToJObject()?.ToString());
}
convertSettings?.Add(space.Guid, result);
return(result);
}
public static IRevitInstance ToSAM(this FamilyInstance familyInstance, ConvertSettings convertSettings)
{
if (familyInstance == null || !familyInstance.IsValidObject)
{
return(null);
}
IRevitInstance result = convertSettings?.GetObject <IRevitInstance>(familyInstance.Id);
if (result != null)
{
return(result);
}
Document document = familyInstance.Document;
if (document == null)
{
return(result);
}
ElementType elementType = document.GetElement(familyInstance.GetTypeId()) as ElementType;
if (elementType == null)
{
return(null);
}
RevitType revitType = elementType.ToSAM(convertSettings);
if (revitType == null)
{
return(null);
}
if (revitType is RevitType3D)
{
result = new RevitInstance3D((RevitType3D)revitType, familyInstance.ToSAM_Geometries <Spatial.ISAMGeometry3D>());
}
else if (revitType is RevitType2D)
{
result = new RevitInstance2D((RevitType2D)revitType, familyInstance.ToSAM_Geometries <Planar.ISAMGeometry2D>());
}
if (result != null)
{
result.UpdateParameterSets(familyInstance, ActiveSetting.Setting.GetValue <TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(familyInstance.Id, result);
}
return(result);
}
public static HostPartitionType ToSAM_HostPartitionType(this HostObjAttributes hostObjAttributes, ConvertSettings convertSettings)
{
if (hostObjAttributes == null)
{
return(null);
}
HostPartitionType result = convertSettings?.GetObject <HostPartitionType>(hostObjAttributes.Id);
if (result != null)
{
return(result);
}
string name = hostObjAttributes.Name;
List <MaterialLayer> materialLayers = Architectural.Revit.Create.MaterialLayers(hostObjAttributes.Document, hostObjAttributes.GetCompoundStructure());
if (materialLayers == null)
{
return(null);
}
if (hostObjAttributes is Autodesk.Revit.DB.WallType)
{
result = new WallType(name);
}
else if (hostObjAttributes is Autodesk.Revit.DB.RoofType)
{
result = new RoofType(name);
}
else if (hostObjAttributes is Autodesk.Revit.DB.FloorType)
{
result = new FloorType(name);
}
CompoundStructure compoundStructure = hostObjAttributes.GetCompoundStructure();
if (compoundStructure != null)
{
compoundStructure.GetLayers();
}
if (result != null)
{
result.UpdateParameterSets(hostObjAttributes);
convertSettings?.Add(hostObjAttributes.Id, result);
}
return(result);
}
public static InternalCondition ToSAM_InternalCondition(this SpatialElement spatialElement, ConvertSettings convertSettings)
{
if (spatialElement == null)
{
return(null);
}
InternalCondition result = convertSettings?.GetObject <InternalCondition>(spatialElement.Id);
if (result != null)
{
return(result);
}
string name = null;
Core.TypeMap typeMap = ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap);
if (typeMap != null)
{
string parameterName = typeMap.GetName(typeof(InternalCondition), typeof(Autodesk.Revit.DB.Mechanical.Space), "Name", 2);
if (!string.IsNullOrWhiteSpace(parameterName))
{
Parameter parameter = spatialElement.GetParameters(parameterName)?.ToList().Find(x => x.StorageType == StorageType.String);
if (parameter != null)
{
name = parameter.AsString();
}
}
if (string.IsNullOrWhiteSpace(name))
{
name = Core.Revit.Query.Name(spatialElement);
}
if (string.IsNullOrWhiteSpace(name))
{
name = spatialElement.Name;
}
}
result = new InternalCondition(name);
result.UpdateParameterSets(spatialElement, typeMap, null, null, false);
convertSettings?.Add(spatialElement.Id, result);
return(result);
}
public static RevitInstance3D ToSAM(this WallSweep wallSweep, ConvertSettings convertSettings)
{
if (wallSweep == null || !wallSweep.IsValidObject)
{
return(null);
}
RevitInstance3D result = convertSettings?.GetObject <RevitInstance3D>(wallSweep.Id);
if (result != null)
{
return(result);
}
Document document = wallSweep.Document;
if (document == null)
{
return(result);
}
ElementType elementType = document.GetElement(wallSweep.GetTypeId()) as ElementType;
if (elementType == null)
{
return(null);
}
RevitType3D revitType3D = elementType.ToSAM(convertSettings) as RevitType3D;
if (revitType3D == null)
{
return(null);
}
result = new RevitInstance3D(revitType3D, wallSweep.ToSAM_Geometries <Spatial.ISAMGeometry3D>());
if (result != null)
{
result.UpdateParameterSets(elementType, ActiveSetting.Setting.GetValue <TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(elementType.Id, result);
}
return(result);
}
public static Construction ToSAM_Construction(this ElementType elementType, ConvertSettings convertSettings)
{
if (elementType == null || elementType.Category == null)
{
return(null);
}
if ((BuiltInCategory)elementType.Category.Id.IntegerValue != BuiltInCategory.OST_Cornices)
{
return(null);
}
Construction result = convertSettings?.GetObject <Construction>(elementType.Id);
if (result != null)
{
return(result);
}
PanelType panelType = PanelType.Wall;
string name = elementType.Name;
Construction construction = Analytical.Query.DefaultConstruction(panelType);
if (construction != null && (name.Equals(construction.Name) || name.Equals(construction.UniqueName())))
{
result = new Construction(construction);
}
else
{
result = new Construction(elementType.Name);
}
result.UpdateParameterSets(elementType, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
result.SetValue(ConstructionParameter.DefaultPanelType, panelType.Text());
convertSettings?.Add(elementType.Id, result);
return(result);
}
public static TagType ToSAM_TagType(this FamilySymbol familySymbol, ConvertSettings convertSettings)
{
if (familySymbol == null)
{
return(null);
}
TagType result = convertSettings?.GetObject <TagType>(familySymbol.Id);
if (result != null)
{
return(result);
}
result = new TagType(familySymbol.Name);
if (result != null)
{
Modify.SetValues(familySymbol, result);
result.SetValue(ElementParameter.RevitId, Query.IntegerId(familySymbol));
convertSettings?.Add(familySymbol.Id, result);
}
return(result);
}
public static ApertureConstruction ToSAM_ApertureConstruction(this FamilySymbol familySymbol, ConvertSettings convertSettings)
{
if (familySymbol == null)
{
return(null);
}
ApertureConstruction result = convertSettings?.GetObject <ApertureConstruction>(familySymbol.Id);
if (result != null)
{
return(result);
}
string name = familySymbol.FullName();
ApertureType apertureType = familySymbol.ApertureType();
List <ApertureConstruction> apertureConstructions = Analytical.ActiveSetting.Setting.GetValue <ApertureConstructionLibrary>(AnalyticalSettingParameter.DefaultApertureConstructionLibrary).GetApertureConstructions(apertureType);
if (apertureConstructions != null)
{
result = apertureConstructions.Find(x => name.Equals(x.UniqueName()) || name.Equals(x.Name));
}
if (result == null)
{
result = new ApertureConstruction(name, apertureType);
}
result.UpdateParameterSets(familySymbol, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(familySymbol.Id, result);
return(result);
}
public static FilledRegionType ToSAM(this Autodesk.Revit.DB.FilledRegionType filledRegionType, ConvertSettings convertSettings)
{
if (filledRegionType == null)
{
return(null);
}
FilledRegionType result = convertSettings?.GetObject <FilledRegionType>(filledRegionType.Id);
if (result != null)
{
return(result);
}
result = new FilledRegionType(filledRegionType.Name);
if (result != null)
{
result.UpdateParameterSets(filledRegionType, ActiveSetting.Setting.GetValue <TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(filledRegionType.Id, result);
}
return(result);
}
public static TagType ToSAM(this SpaceTagType spaceTagType, ConvertSettings convertSettings)
{
if (spaceTagType == null)
{
return(null);
}
TagType result = convertSettings?.GetObject <TagType>(spaceTagType.Id);
if (result != null)
{
return(result);
}
result = new TagType(spaceTagType.Name);
if (result != null)
{
Modify.SetValues(spaceTagType, result);
result.SetValue(ElementParameter.RevitId, Query.IntegerId(spaceTagType));
convertSettings?.Add(spaceTagType.Id, result);
}
return(result);
}
public static Space ToSAM(this SpatialElement spatialElement, ConvertSettings convertSettings)
{
if (spatialElement == null)
{
return(null);
}
Point3D point3D = null;
Space result = convertSettings?.GetObject <Space>(spatialElement.Id);
if (result != null)
{
return(result);
}
if (spatialElement.Location != null)
{
point3D = ((LocationPoint)spatialElement.Location).Point.ToSAM();
}
string name = Core.Revit.Query.Name(spatialElement);
if (string.IsNullOrWhiteSpace(name))
{
name = spatialElement.Name;
}
result = new Space(name, point3D);
result.UpdateParameterSets(spatialElement, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
result.InternalCondition = ToSAM_InternalCondition(spatialElement, convertSettings);
ElementId elementId_Level = spatialElement.LevelId;
if (elementId_Level != null && elementId_Level != ElementId.InvalidElementId)
{
Level level = spatialElement.Document?.GetElement(elementId_Level) as Level;
if (level != null)
{
result.SetValue(SpaceParameter.LevelName, level.Name);
}
}
double area;
if (!result.TryGetValue(SpaceParameter.Area, out area) || double.IsNaN(area) || area == 0)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
result.SetValue(SpaceParameter.Area, UnitUtils.ConvertFromInternalUnits(spatialElement.Area, DisplayUnitType.DUT_SQUARE_METERS));
#else
result.SetValue(SpaceParameter.Area, UnitUtils.ConvertFromInternalUnits(spatialElement.Area, UnitTypeId.SquareMeters));
#endif
}
double volume;
if (!result.TryGetValue(SpaceParameter.Volume, out volume) || double.IsNaN(volume) || volume == 0)
{
Parameter parameter = spatialElement.get_Parameter(BuiltInParameter.ROOM_VOLUME);
if (parameter != null && parameter.HasValue)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
result.SetValue(SpaceParameter.Volume, UnitUtils.ConvertFromInternalUnits(parameter.AsDouble(), DisplayUnitType.DUT_CUBIC_METERS));
#else
result.SetValue(SpaceParameter.Volume, UnitUtils.ConvertFromInternalUnits(parameter.AsDouble(), UnitTypeId.CubicMeters));
#endif
}
}
convertSettings?.Add(spatialElement.Id, result);
return(result);
}
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 List <Panel> ToSAM(this HostObject hostObject, ConvertSettings convertSettings)
{
if (hostObject == null || !hostObject.IsValidObject)
{
return(null);
}
List <Panel> result = convertSettings?.GetObjects <Panel>(hostObject.Id);
if (result != null)
{
return(result);
}
ElementId elementId_Type = hostObject.GetTypeId();
if (elementId_Type == null || elementId_Type == ElementId.InvalidElementId)
{
return(null);
}
result = new List <Panel>();
PanelType panelType = Query.PanelType(hostObject);
Construction construction = ((HostObjAttributes)hostObject.Document.GetElement(elementId_Type)).ToSAM(convertSettings);
if (construction == null)
{
construction = Analytical.Query.DefaultConstruction(panelType); //Default Construction
}
PanelType panelType_Temp = Query.PanelType(construction);
if (panelType_Temp != PanelType.Undefined)
{
panelType = panelType_Temp;
}
List <Geometry.Spatial.Face3D> face3Ds = hostObject.Profiles();
if (face3Ds == null || face3Ds.Count == 0)
{
return(null);
}
LogicalOrFilter logicalOrFilter = new LogicalOrFilter(new List <ElementFilter>()
{
new ElementCategoryFilter(BuiltInCategory.OST_Windows), new ElementCategoryFilter(BuiltInCategory.OST_Doors)
});
IEnumerable <ElementId> elementIds = hostObject.GetDependentElements(logicalOrFilter);
if (hostObject is Wall)
{
List <Autodesk.Revit.DB.Panel> panels = Create.Panels((Wall)hostObject, convertSettings);
if (panels != null && panels.Count > 0)
{
List <ElementId> elementIds_Temp = panels.ConvertAll(x => x.Id);
if (elementIds != null && elementIds.Count() > 0)
{
elementIds_Temp.AddRange(elementIds);
}
elementIds = elementIds_Temp;
}
}
foreach (Geometry.Spatial.Face3D face3D in face3Ds)
{
if (face3D == null)
{
continue;
}
Panel panel = new Panel(construction, panelType, face3D);
panel.UpdateParameterSets(hostObject, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
if (elementIds != null && elementIds.Count() > 0)
{
foreach (ElementId elementId in elementIds)
{
Element element = hostObject.Document.GetElement(elementId);
if (element == null)
{
continue;
}
if (!(element is FamilyInstance))
{
continue;
}
Aperture aperture = ToSAM_Aperture((FamilyInstance)element, convertSettings);
panel.AddAperture(aperture);
}
}
result.Add(panel);
}
convertSettings?.Add(hostObject.Id, result);
return(result);
}
public static List <IPartition> ToSAM_Partitions(this HostObject hostObject, ConvertSettings convertSettings)
{
if (hostObject == null)
{
return(null);
}
List <IPartition> result = convertSettings?.GetObjects <IPartition>(hostObject.Id);
if (result != null)
{
return(result);
}
ElementId elementId_Type = hostObject.GetTypeId();
if (elementId_Type == null || elementId_Type == ElementId.InvalidElementId)
{
return(null);
}
HostPartitionType hostPartitionType = ((HostObjAttributes)hostObject.Document.GetElement(elementId_Type)).ToSAM_HostPartitionType(convertSettings);
if (hostPartitionType == null)
{
return(null);
}
List <Face3D> face3Ds = hostObject.Profiles();
if (face3Ds == null || face3Ds.Count == 0)
{
return(null);
}
LogicalOrFilter logicalOrFilter = new LogicalOrFilter(new List <ElementFilter>()
{
new ElementCategoryFilter(BuiltInCategory.OST_Windows), new ElementCategoryFilter(BuiltInCategory.OST_Doors)
});
#if Revit2017
IEnumerable <ElementId> elementIds = null;
#else
IEnumerable <ElementId> elementIds = hostObject.GetDependentElements(logicalOrFilter);
#endif
if (hostObject is Autodesk.Revit.DB.Wall || hostObject is CurtainSystem)
{
List <Autodesk.Revit.DB.Panel> panels = Core.Revit.Query.Panels(hostObject as dynamic);
if (panels != null && panels.Count > 0)
{
List <ElementId> elementIds_Temp = panels.ConvertAll(x => x.Id);
if (elementIds != null && elementIds.Count() > 0)
{
elementIds_Temp.AddRange(elementIds);
}
elementIds = elementIds_Temp;
}
}
result = new List <IPartition>();
foreach (Face3D face3D in face3Ds)
{
if (face3D == null)
{
continue;
}
IHostPartition hostPartition = Analytical.Create.HostPartition(face3D, hostPartitionType);
hostPartition.UpdateParameterSets(hostObject);
if (elementIds != null && elementIds.Count() > 0)
{
foreach (ElementId elementId in elementIds)
{
Element element = hostObject.Document.GetElement(elementId);
if (element == null)
{
continue;
}
if (!(element is FamilyInstance))
{
continue;
}
IOpening opening = ToSAM_Opening((FamilyInstance)element, convertSettings);
if (opening != null)
{
opening = Analytical.Query.Project(hostPartition, opening);
hostPartition.AddOpening(opening);
}
}
}
result.Add(hostPartition);
}
convertSettings?.Add(hostObject.Id, result);
return(result);
}
public static List <Panel> ToSAM(this HostObject hostObject, ConvertSettings convertSettings)
{
if (hostObject == null || !hostObject.IsValidObject)
{
return(null);
}
if (hostObject is WallSweep)
{
return(((WallSweep)hostObject).ToSAM_Panels(convertSettings));
}
List <Panel> result = convertSettings?.GetObjects <Panel>(hostObject.Id);
if (result != null)
{
return(result);
}
ElementId elementId_Type = hostObject.GetTypeId();
if (elementId_Type == null || elementId_Type == ElementId.InvalidElementId)
{
return(null);
}
Document document = hostObject.Document;
if (document == null)
{
return(null);
}
result = new List <Panel>();
PanelType panelType = Query.PanelType(hostObject);
Construction construction = ((HostObjAttributes)document.GetElement(elementId_Type)).ToSAM(convertSettings);
if (construction == null)
{
construction = Analytical.Query.DefaultConstruction(panelType); //Default Construction
}
PanelType panelType_Temp = Query.PanelType(construction);
if (panelType_Temp != PanelType.Undefined)
{
panelType = panelType_Temp;
}
List <Face3D> face3Ds = hostObject.Profiles();
if (face3Ds == null || face3Ds.Count == 0)
{
return(null);
}
LogicalOrFilter logicalOrFilter = new LogicalOrFilter(new List <ElementFilter>()
{
new ElementCategoryFilter(BuiltInCategory.OST_Windows), new ElementCategoryFilter(BuiltInCategory.OST_Doors)
});
#if Revit2017
IEnumerable <ElementId> elementIds = null;
#else
IEnumerable <ElementId> elementIds = hostObject.GetDependentElements(logicalOrFilter);
#endif
if (hostObject is Autodesk.Revit.DB.Wall || hostObject is CurtainSystem)
{
List <Autodesk.Revit.DB.Panel> panels = Core.Revit.Query.Panels(hostObject as dynamic);
if (panels != null && panels.Count > 0)
{
List <ElementId> elementIds_Temp = panels.ConvertAll(x => x.Id);
if (elementIds != null && elementIds.Count() > 0)
{
elementIds_Temp.AddRange(elementIds);
}
elementIds = elementIds_Temp;
}
}
List <Aperture> apertures = new List <Aperture>();
if (elementIds != null && elementIds.Count() > 0)
{
foreach (ElementId elementId in elementIds)
{
FamilyInstance familyInstance = document.GetElement(elementId) as FamilyInstance;
if (familyInstance == null)
{
continue;
}
List <Aperture> apertures_Temp = ToSAM_Apertures(familyInstance, convertSettings);
if (apertures_Temp == null)
{
continue;
}
apertures.AddRange(apertures_Temp);
}
}
foreach (Face3D face3D in face3Ds)
{
if (face3D == null)
{
continue;
}
//Panel panel = Analytical.Create.Panel(construction, panelType, face3D.Reduce(0.2)); Double check why Reduce have been used turn off on 27.10.2021 when mesh roof in sam teplate gave gap
Panel panel = Analytical.Create.Panel(construction, panelType, face3D);
panel.UpdateParameterSets(hostObject, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
foreach (Aperture aperture in apertures)
{
panel.AddAperture(aperture);
}
result.Add(panel);
}
convertSettings?.Add(hostObject.Id, result);
//Handling WallSweeps
//if(hostObject is Wall)
//{
// elementIds = hostObject.GetDependentElements(new ElementCategoryFilter(BuiltInCategory.OST_Cornices));
// if (elementIds != null && elementIds.Count() != 0)
// {
// //Fix it
// foreach (ElementId elementId in elementIds)
// {
// WallSweep wallSweep = document.GetElement(elementId) as WallSweep;
// if (wallSweep == null)
// {
// continue;
// }
// List<Panel> panels_WallSweep = wallSweep.ToSAM_Panels(convertSettings);
// if (panels_WallSweep == null || panels_WallSweep.Count == 0)
// {
// continue;
// }
// result.AddRange(panels_WallSweep);
// }
// }
//}
return(result);
}
public static Autodesk.Revit.DB.Level ToRevit(this Level level, Document document, ConvertSettings convertSettings)
{
if (level == null || document == null)
{
return(null);
}
Autodesk.Revit.DB.Level result = convertSettings?.GetObject <Autodesk.Revit.DB.Level>(level.Guid);
if (result != null)
{
return(result);
}
if (!convertSettings.RemoveExisting)
{
result = Core.Revit.Query.Element <Autodesk.Revit.DB.Level>(document, level);
}
double elevation = level.Elevation;
if (double.IsNaN(elevation))
{
return(null);
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
elevation = UnitUtils.ConvertToInternalUnits(elevation, DisplayUnitType.DUT_METERS);
#else
elevation = UnitUtils.ConvertToInternalUnits(elevation, UnitTypeId.Meters);
#endif
if (result == null)
{
List <Autodesk.Revit.DB.Level> levels = new FilteredElementCollector(document).OfClass(typeof(Autodesk.Revit.DB.Level)).Cast <Autodesk.Revit.DB.Level>().ToList();
if (levels != null && levels.Count != 0)
{
result = levels.Find(x => x.Elevation.Equals(elevation));
}
}
if (convertSettings.RemoveExisting)
{
ElementId elementId = level.ElementId();
if (elementId != null && elementId != ElementId.InvalidElementId)
{
Element element = document.GetElement(elementId) as Autodesk.Revit.DB.Level;
if (element != null)
{
document.Delete(elementId);
}
}
}
if (result == null)
{
result = Autodesk.Revit.DB.Level.Create(document, elevation);
}
if (result == null)
{
return(null);
}
//TODO: Implement method to properly rename element
try
{
result.Name = level.Name;
}
catch (Exception exception)
{
}
if (convertSettings.ConvertParameters)
{
Core.Revit.Modify.SetValues(result, level);
Core.Revit.Modify.SetValues(result, level, ActiveSetting.Setting);
Core.Revit.Modify.SetJson(result, level.ToJObject()?.ToString());
}
convertSettings?.Add(level.Guid, result);
return(result);
}
public static List <Panel> ToSAM_Panels(this ModelCurve modelCurve, ConvertSettings convertSettings)
{
if (modelCurve == null)
{
return(null);
}
List <Panel> result = convertSettings?.GetObjects <Panel>(modelCurve.Id);
if (result != null)
{
return(result);
}
List <Segment3D> segment3Ds = Geometry.Revit.Convert.ToSAM_Segment3Ds(modelCurve.GeometryCurve);
if (segment3Ds == null || segment3Ds.Count == 0)
{
return(null);
}
PanelType panelType = PanelType.WallInternal;
if (modelCurve.Category.Id.IntegerValue == (int)BuiltInCategory.OST_MEPSpaceSeparationLines || modelCurve.Category.Id.IntegerValue == (int)BuiltInCategory.OST_RoomSeparationLines)
{
panelType = PanelType.Air;
}
Construction construction = null;
if (ActiveSetting.Setting.TryGetValue(AnalyticalSettingParameter.DefaultConstructionLibrary, out ConstructionLibrary constructionLibrary))
{
construction = constructionLibrary.GetConstructions(panelType).FirstOrDefault();
}
Document document = modelCurve.Document;
result = new List <Panel>();
foreach (Segment3D segment3D in segment3Ds)
{
//double elevation_Min = System.Math.Max(segment3D[0].Z, segment3D[1].Z);
double elevation_Min = (document.GetElement(modelCurve.LevelId) as Level).Elevation;
//Level level_Max = Core.Revit.Query.HighLevel(document, UnitUtils.ConvertToInternalUnits(elevation_Min, DisplayUnitType.DUT_METERS));
Level level_Max = Core.Revit.Query.HighLevel(document, elevation_Min);
if (level_Max == null)
{
continue;
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
double height = UnitUtils.ConvertFromInternalUnits(level_Max.Elevation - elevation_Min, DisplayUnitType.DUT_METERS);
#else
double height = UnitUtils.ConvertFromInternalUnits(level_Max.Elevation - elevation_Min, UnitTypeId.Meters);
#endif
if (height == 0)
{
continue;
}
Vector3D vector3D = new Vector3D(0, 0, height);
Face3D face3D = new Face3D(new Polygon3D(new Point3D[] { segment3D[0], segment3D[1], segment3D[1].GetMoved(vector3D) as Point3D, segment3D[0].GetMoved(vector3D) as Point3D }));
Panel panel = Analytical.Create.Panel(construction, panelType, face3D);
panel.UpdateParameterSets(modelCurve, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap), null, new string[] { "Length" }, true);
panel.SetValue(RevitPanelParameter.Length, segment3D.GetLength());
result.Add(panel);
}
convertSettings?.Add(modelCurve.Id, result);
return(result);
}
/// <summary>
/// Conversion of WallSweep to panels. WARNING! Method does not handle more complex WallSweep
/// </summary>
/// <param name="wallSweep">Revit WallSweep</param>
/// <param name="convertSettings">SAM Revit ConvertSettings</param>
/// <returns>SAM Analytical Panels (Panels projected on host (Wall) plane)</returns>
public static List <Panel> ToSAM_Panels(this WallSweep wallSweep, ConvertSettings convertSettings)
{
if (wallSweep == null)
{
return(null);
}
List <Panel> result = convertSettings?.GetObjects <Panel>(wallSweep.Id);
if (result != null)
{
return(result);
}
RevitInstance3D revitInstance3D = Geometry.Revit.Convert.ToSAM(wallSweep, convertSettings);
if (revitInstance3D == null)
{
return(null);
}
result = ToSAM_Panels(revitInstance3D);
if (result != null)
{
convertSettings?.Add(wallSweep.Id, result);
}
return(result);
//if (wallSweep == null || !wallSweep.IsValidObject)
// return null;
//List<Panel> result = convertSettings?.GetObjects<Panel>(wallSweep.Id);
//if (result != null)
// return result;
//IEnumerable<ElementId> elementIds = wallSweep.GetHostIds();
//if (elementIds == null || elementIds.Count() == 0)
//{
// return null;
//}
//Document document = wallSweep.Document;
//if(document == null)
//{
// return null;
//}
//HostObject hostObject = null;
//foreach(ElementId elementId in elementIds)
//{
// hostObject = document.GetElement(elementId) as HostObject;
// if(hostObject != null)
// {
// break;
// }
//}
//List<Face3D> face3Ds = hostObject?.Profiles();
//if(face3Ds == null || face3Ds.Count == 0)
//{
// return null;
//}
//Geometry.Spatial.Plane plane = face3Ds[0]?.GetPlane();
//if(plane == null)
//{
// return null;
//}
//List<Face3D> face3Ds_WallSweep = Geometry.Revit.Convert.ToSAM_Geometries<Face3D>(wallSweep);
//if(face3Ds_WallSweep == null || face3Ds_WallSweep.Count == 0)
//{
// return null;
//}
//List<Face2D> face2Ds = new List<Face2D>();
//foreach(Face3D face3D_WallSweep in face3Ds_WallSweep)
//{
// Geometry.Spatial.Plane plane_WallSweep = face3D_WallSweep?.GetPlane();
// if (plane_WallSweep == null || plane.Perpendicular(plane_WallSweep))
// {
// continue;
// }
// Face3D face3D = plane.Project(face3D_WallSweep);
// if(face3D == null || !face3D.IsValid())
// {
// continue;
// }
// Face2D face2D = plane.Convert(face3D);
// if(face2D == null || !face2D.IsValid())
// {
// continue;
// }
// face2Ds.Add(face2D);
//}
//face2Ds = face2Ds.Union();
//if(face2Ds == null || face2Ds.Count == 0)
//{
// return null;
//}
//Construction construction = ToSAM_Construction((ElementType)document.GetElement(wallSweep.GetTypeId()), convertSettings);
//result = new List<Panel>();
//foreach(Face2D face2D in face2Ds)
//{
// Face3D face3D = plane.Convert(face2D);
// if(face3D == null || !face3D.IsValid())
// {
// continue;
// }
// Panel panel = Analytical.Create.Panel(construction, PanelType.Wall, face3D);
// if(panel == null)
// {
// continue;
// }
// result.Add(panel);
//}
//convertSettings?.Add(wallSweep.Id, result);
//return result;
}
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)
{
string zoneParameterName = Query.ZoneParameterName(zone);
ZoneType zoneType = zone.ZoneType();
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_SAM in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, zone);
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 (!string.IsNullOrWhiteSpace(zoneParameterName))
{
IEnumerable <Parameter> parameters = space_Revit.GetParameters(zoneParameterName);
if (parameters != null)
{
foreach (Parameter parameter in parameters)
{
if (parameter == null || parameter.IsReadOnly || parameter.StorageType != StorageType.String)
{
continue;
}
parameter.Set(zone.Name);
}
}
}
Core.Revit.Modify.SetValues(space_Revit, zone_Temp);
Core.Revit.Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting);
if (zoneType != ZoneType.Undefined)
{
Modify.SetValues(space_Revit, zone_Temp, ActiveSetting.Setting, zoneType, convertSettings?.GetParameters());
}
}
}
}
convertSettings?.Add(zone.Guid, result);
return(result);
}
public static Construction ToSAM(this HostObjAttributes hostObjAttributes, ConvertSettings convertSettings)
{
if (hostObjAttributes == null)
{
return(null);
}
Construction result = convertSettings?.GetObject <Construction>(hostObjAttributes.Id);
if (result != null)
{
return(result);
}
string name = hostObjAttributes.Name;
PanelType panelType = hostObjAttributes.PanelType();
if (panelType == PanelType.Undefined)
{
panelType = Query.PanelType((BuiltInCategory)hostObjAttributes.Category.Id.IntegerValue);
}
Construction construction = Analytical.Query.DefaultConstruction(panelType);
if (construction != null && (name.Equals(construction.Name) || name.Equals(construction.UniqueName())))
{
result = new Construction(construction);
}
else
{
result = new Construction(hostObjAttributes.Name);
}
result.UpdateParameterSets(hostObjAttributes, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
//result.Add(Core.Revit.Query.ParameterSet(hostObjAttributes));
convertSettings?.Add(hostObjAttributes.Id, result);
if (panelType != PanelType.Undefined)
{
result.SetValue(ConstructionParameter.DefaultPanelType, panelType.Text());
}
else
{
result.SetValue(ConstructionParameter.DefaultPanelType, null);
}
List <ConstructionLayer> constructionLayers = result.ConstructionLayers;
if (constructionLayers != null && constructionLayers.Count != 0)
{
result.SetValue(ConstructionParameter.DefaultThickness, constructionLayers.ConvertAll(x => x.Thickness).Sum());
}
else
{
CompoundStructure compoundStructure = hostObjAttributes.GetCompoundStructure();
if (compoundStructure != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
double thickness = UnitUtils.ConvertFromInternalUnits(compoundStructure.GetWidth(), DisplayUnitType.DUT_METERS);
#else
double thickness = UnitUtils.ConvertFromInternalUnits(compoundStructure.GetWidth(), UnitTypeId.Meters);
#endif
result.SetValue(ConstructionParameter.DefaultThickness, thickness);
}
}
return(result);
}
public static List <Autodesk.Revit.DB.Mechanical.Space> ToRevit(this AdjacencyCluster adjacencyCluster, ZoneSimulationResult zoneSimulationResult, Document document, ConvertSettings convertSettings)
{
if (adjacencyCluster == null || zoneSimulationResult == null)
{
return(null);
}
List <Autodesk.Revit.DB.Mechanical.Space> result = convertSettings?.GetObjects <Autodesk.Revit.DB.Mechanical.Space>(zoneSimulationResult.Guid);
if (result != null)
{
return(result);
}
ZoneSimulationResult zoneSimulationResult_Temp = adjacencyCluster.GetObject <ZoneSimulationResult>(zoneSimulationResult.Guid);
if (zoneSimulationResult_Temp == null)
{
zoneSimulationResult_Temp = zoneSimulationResult;
}
List <Zone> zones = adjacencyCluster.GetRelatedObjects <Zone>(zoneSimulationResult_Temp);
if (zones != null && zones.Count != 0)
{
if (convertSettings.ConvertParameters)
{
foreach (Zone zone in zones)
{
List <Space> spaces = adjacencyCluster.GetSpaces(zone);
if (spaces != null)
{
ZoneType zoneType = zone.ZoneType();
if (zoneType == ZoneType.Undefined)
{
continue;
}
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_SAM in spaces)
{
Autodesk.Revit.DB.Mechanical.Space space_Revit = Core.Revit.Query.Element <Autodesk.Revit.DB.Mechanical.Space>(document, zoneSimulationResult_Temp);
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;
}
Core.Revit.Modify.SetValues(space_Revit, zoneSimulationResult);
Core.Revit.Modify.SetValues(space_Revit, zoneSimulationResult, ActiveSetting.Setting);
Modify.SetValues(space_Revit, zoneSimulationResult, ActiveSetting.Setting, zoneType, convertSettings?.GetParameters());
}
}
}
}
}
convertSettings?.Add(zoneSimulationResult.Guid, result);
return(result);
}
