From e8d943392a2741b99f7a47ffab48a7cfe342d43f Mon Sep 17 00:00:00 2001
From: babio <oleksandr.babii@autodesk.com>
Date: Thu, 20 Jul 2023 06:38:13 -0700
Subject: [PATCH 1/2] 24_1_1 Code update

---
 .../bundle/PackageContents.xml                |   4 +-
 Install/RevitIFCSetupWix/Product.wxs          |   2 +-
 Install/RevitIFCSetupWix/buildInstaller.bat   |   8 +-
 .../IFCAddressInformationUI.xaml              |   2 +-
 .../IFCExporterUIWindow.xaml                  |   6 +-
 .../Properties/AssemblyInfo.cs                |   4 +-
 .../Properties/Resources.Designer.cs          |  36 ++
 .../Properties/Resources.resx                 |  15 +
 .../Enums/IFC4x3EntityType.cs                 |   5 -
 .../Revit.IFC.Common/Enums/IFCEntityType.cs   |   8 +-
 .../Properties/AssemblyInfo.cs                |   4 +-
 .../Exporter/HostedSweepExporter.cs           |   2 +-
 .../Exporter/WallSweepExporter.cs             |   2 +-
 .../Properties/AssemblyInfo.cs                |   4 +-
 .../Revit.IFC.Export/Utility/OpeningUtil.cs   |  55 ++-
 .../Properties/AssemblyInfo.cs                |   4 +-
 .../Data/IFCBuildingElementProxy.cs           |   2 +-
 .../Data/IFCBuildingStorey.cs                 |  34 +-
 .../Data/IFCDistributionPort.cs               |  16 +-
 .../Data/IFCDistributionSystem.cs             |   7 +-
 Source/Revit.IFC.Import/Data/IFCDoorStyle.cs  |  19 +-
 Source/Revit.IFC.Import/Data/IFCDoorType.cs   |  12 +-
 .../Data/IFCDoorWindowPropertyBase.cs         |  13 +-
 Source/Revit.IFC.Import/Data/IFCElement.cs    |  10 +-
 .../Data/IFCElementAssembly.cs                |   4 +-
 .../Data/IFCElementQuantity.cs                |   5 +-
 .../Revit.IFC.Import/Data/IFCElementType.cs   |   2 +-
 Source/Revit.IFC.Import/Data/IFCGroup.cs      |   2 +-
 Source/Revit.IFC.Import/Data/IFCImportFile.cs |  55 ++-
 Source/Revit.IFC.Import/Data/IFCMappedItem.cs |  28 +-
 Source/Revit.IFC.Import/Data/IFCMaterial.cs   |   7 +-
 Source/Revit.IFC.Import/Data/IFCObject.cs     |   2 +-
 .../Data/IFCObjectDefinition.cs               | 260 ++++++++---
 .../Data/IFCPhysicalComplexQuantity.cs        |   7 +-
 .../Data/IFCPhysicalQuantity.cs               |   4 +-
 .../Data/IFCPhysicalSimpleQuantity.cs         |  10 +-
 Source/Revit.IFC.Import/Data/IFCPort.cs       |  12 +-
 Source/Revit.IFC.Import/Data/IFCProduct.cs    |  90 ++--
 Source/Revit.IFC.Import/Data/IFCProject.cs    |  51 ++-
 Source/Revit.IFC.Import/Data/IFCProperty.cs   |  63 ++-
 .../Revit.IFC.Import/Data/IFCPropertySet.cs   | 289 +-----------
 .../Data/IFCPropertySetDefinition.cs          |   3 +-
 Source/Revit.IFC.Import/Data/IFCProxy.cs      |   4 +-
 .../Data/IFCRepresentation.cs                 |  39 +-
 .../Data/IFCRepresentationItem.cs             |   5 +-
 .../Data/IFCRepresentationMap.cs              |  12 +-
 Source/Revit.IFC.Import/Data/IFCSite.cs       |   3 +-
 Source/Revit.IFC.Import/Data/IFCSpace.cs      |   8 +-
 .../Data/IFCSpatialStructureElement.cs        |  43 +-
 Source/Revit.IFC.Import/Data/IFCStyledItem.cs |   5 +
 Source/Revit.IFC.Import/Data/IFCTypeObject.cs |  14 +-
 .../Revit.IFC.Import/Data/IFCTypeProduct.cs   |  41 +-
 Source/Revit.IFC.Import/Importer.cs           | 209 +++++----
 .../Processors/IFCDefaultProcessor.cs         |  15 +-
 .../Properties/AssemblyInfo.cs                |   4 +-
 .../Revit.IFC.Import/Revit.IFC.Import.csproj  |   1 +
 .../Utility/IFCCategoryUtil.cs                |  24 +-
 .../Utility/IFCElementUtil.cs                 |   2 +-
 .../Utility/IFCImportCache.cs                 |  23 +-
 .../Utility/IFCImportHybridInfo.cs            | 376 ++++++++-------
 .../Utility/IFCImportOptions.cs               |  54 ++-
 .../Utility/IFCImportShapeEditScope.cs        |  10 +-
 .../Utility/ParametersToSet.cs                | 427 ++++++++++++++++++
 63 files changed, 1547 insertions(+), 940 deletions(-)
 create mode 100644 Source/Revit.IFC.Import/Utility/ParametersToSet.cs

diff --git a/Install/Program Files to Install/bundle/PackageContents.xml b/Install/Program Files to Install/bundle/PackageContents.xml
index c50f769c..6b607fd1 100644
--- a/Install/Program Files to Install/bundle/PackageContents.xml	
+++ b/Install/Program Files to Install/bundle/PackageContents.xml	
@@ -4,7 +4,7 @@
   <RuntimeRequirements OS="Win64" Platform="Revit" SeriesMin="R2024" SeriesMax="R2024" />
   <Components Description="2024">
     <RuntimeRequirements OS="Win64" Platform="Revit" SeriesMin="R2024" SeriesMax="R2024" />
-    <ComponentEntry AppName="IFC For Revit 2024" Version="24.1.0" ModuleName="./Contents/2024/IFCExporterUIOverride.addin" AppDescription="IFC For Revit 2024" />
-    <ComponentEntry AppName="IFC For Revit 2024" Version="24.1.0" ModuleName="./Contents/2024/Revit.IFC.addin" AppDescription="IFC For Revit 2024" />
+    <ComponentEntry AppName="IFC For Revit 2024" Version="24.1.1" ModuleName="./Contents/2024/IFCExporterUIOverride.addin" AppDescription="IFC For Revit 2024" />
+    <ComponentEntry AppName="IFC For Revit 2024" Version="24.1.1" ModuleName="./Contents/2024/Revit.IFC.addin" AppDescription="IFC For Revit 2024" />
   </Components>
 </ApplicationPackage>
\ No newline at end of file
diff --git a/Install/RevitIFCSetupWix/Product.wxs b/Install/RevitIFCSetupWix/Product.wxs
index 4ce070cc..b9c1d43a 100644
--- a/Install/RevitIFCSetupWix/Product.wxs
+++ b/Install/RevitIFCSetupWix/Product.wxs
@@ -2,7 +2,7 @@
 <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi"
      xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
 
-   <Product Id="1A9C2C21-24B8-42D2-0000-992E73C12400" Name="Revit IFC 2024" Language="1033" Version="24.1.0.22" Manufacturer="Autodesk" UpgradeCode="1A9C2C21-24B8-42D2-0000-992E73C11B3F">
+   <Product Id="1A9C2C21-24B8-42D2-0000-992E73C12400" Name="Revit IFC 2024" Language="1033" Version="24.1.1.0" Manufacturer="Autodesk" UpgradeCode="1A9C2C21-24B8-42D2-0000-992E73C11B3F">
       <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine" />
 
       <MajorUpgrade DowngradeErrorMessage="A newer version of [ProductName] is already installed." />
diff --git a/Install/RevitIFCSetupWix/buildInstaller.bat b/Install/RevitIFCSetupWix/buildInstaller.bat
index c1dd5db0..e394f267 100644
--- a/Install/RevitIFCSetupWix/buildInstaller.bat
+++ b/Install/RevitIFCSetupWix/buildInstaller.bat
@@ -11,9 +11,9 @@ rem It is necessary to add the Wix bin directory to the system path temporarily
 SET PATH=%PATH%;%WixRoot%
 
 candle.exe -dProjectDir=%2 -ext WixUtilExtension %2Product.wxs 
-light.exe -ext WixUtilExtension -out RevitIFC2024.1.0.msi product.wixobj -ext WixUIExtension
+light.exe -ext WixUtilExtension -out RevitIFC2024.1.1.msi product.wixobj -ext WixUIExtension
 
-copy RevitIFC2024.1.0.msi %1..\Releasex64
-del RevitIFC2024.1.0.msi
+copy RevitIFC2024.1.1.msi %1..\Releasex64
+del RevitIFC2024.1.1.msi
 
-echo %1..\Releasex64\RevitIFC2024.1.0.msi
+echo %1..\Releasex64\RevitIFC2024.1.1.msi
diff --git a/Source/IFCExporterUIOverride/IFCAddressInformationUI.xaml b/Source/IFCExporterUIOverride/IFCAddressInformationUI.xaml
index c3db7e0a..ea3bcc8a 100644
--- a/Source/IFCExporterUIOverride/IFCAddressInformationUI.xaml
+++ b/Source/IFCExporterUIOverride/IFCAddressInformationUI.xaml
@@ -28,7 +28,7 @@
         </Grid.ColumnDefinitions>
         <Label Content="{x:Static p:Resources.Purpose}" Height="28" HorizontalAlignment="Left" Margin="21,10,0,0" x:Name="labelPurpose" VerticalAlignment="Top" Width="147"/>
         <Label Content="{x:Static p:Resources.UserDefinedPurpose}" Height="28" HorizontalAlignment="Left" Margin="21,43,0,0" x:Name="labelUserDefinedPurpose" VerticalAlignment="Top" Width="195" />
-        <TextBox Text="{Binding UserDefinedPurpose, UpdateSourceTrigger=PropertyChanged}" LostFocus="UserDefinedPurposeTextBox_LostFocus" Height="23" Margin="14,45,10,0" x:Name="UserDefinedPurposeTextBox" VerticalAlignment="Top" VerticalContentAlignment="Center" ToolTip="Entering value here will reset Purpose to &quot;USERDEFINED&quot;" Grid.Column="1"/>
+        <TextBox Text="{Binding UserDefinedPurpose, UpdateSourceTrigger=PropertyChanged}" LostFocus="UserDefinedPurposeTextBox_LostFocus" Height="23" Margin="14,45,10,0" x:Name="UserDefinedPurposeTextBox" VerticalAlignment="Top" VerticalContentAlignment="Center" ToolTip="{x:Static p:Resources.AddressInformationTooltip}" Grid.Column="1"/>
         <Label Content="{x:Static p:Resources.Description}" Height="28" HorizontalAlignment="Left" Margin="21,75,0,0" x:Name="labelDescription" VerticalAlignment="Top" Width="152"/>
         <TextBox Text="{Binding Description, UpdateSourceTrigger=PropertyChanged}" Height="23" HorizontalAlignment="Stretch" Margin="15,80,10,0" x:Name="DescriptionTextBox" VerticalAlignment="Top" VerticalContentAlignment="Center" Grid.Column="1"/>
         <Label Content="{x:Static p:Resources.AddressLine1}" Height="28" HorizontalAlignment="Left" Margin="21,110,0,0" x:Name="labelAddressLine1" VerticalAlignment="Top" Width="152"/>
diff --git a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
index 86e6b841..be07def3 100644
--- a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
+++ b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
@@ -81,9 +81,9 @@
                     <CheckBox Content="{x:Static p:Resources.IncludeIfcSiteElevation}" Height="16" HorizontalAlignment="Left" Margin="10,112,0,0" x:Name="checkboxIncludeIfcSiteElevation" VerticalAlignment="Top" Checked="checkboxIfcSiteElevation_Checked" Unchecked="checkboxIfcSiteElevation_Checked" Width="569" Grid.ColumnSpan="2" />
                     <CheckBox Content="{x:Static p:Resources.StoreIFCGUID}" Height="16" HorizontalAlignment="Left" Margin="10,133,0,0" x:Name="checkboxStoreIFCGUID" VerticalAlignment="Top" Checked="checkboxStoreIFCGUID_Checked" Unchecked="checkboxStoreIFCGUID_Checked" Width="569" Grid.ColumnSpan="2"  />
                     <CheckBox Content="{x:Static p:Resources.ExportBoundingBox}" Height="16" HorizontalAlignment="Left" Margin="10,154,0,0" Name="checkboxExportBoundingBox" VerticalAlignment="Top" Checked="checkboxExportBoundingBox_Checked" Unchecked="checkboxExportBoundingBox_Checked" Width="569" Grid.ColumnSpan="2" />
-                    <CheckBox Content="{x:Static p:Resources.UseOnlyTriangulation}" Margin="10,175,0,0" x:Name="checkBox_TriangulationOnly" Checked="checkBox_TriangulationOnly_Checked" Unchecked="checkBox_TriangulationOnly_Unchecked" ToolTip="Use this option if any tessellated geometry should remain as triangulated faces, or if the export performance is affected" HorizontalAlignment="Left" Width="588" Height="15" VerticalAlignment="Top"/>
-                    <CheckBox Content="{x:Static p:Resources.UseTypeNameOnlyForIfcType}" Margin="10,196,0,0" x:Name="checkbox_UseTypeNameOnly" Checked="Checkbox_UseTypeNameOnly_Checked" Unchecked="Checkbox_UseTypeNameOnly_Unchecked" ToolTip="Use this option to export IfcType name to use only Revit type name without the family name" HorizontalAlignment="Left" Width="588" Height="15" VerticalAlignment="Top"/>
-                    <CheckBox Content="{x:Static p:Resources.UseVisibleRevitNameAsEntityName}" Margin="10,217,0,0" x:Name="checkbox_UseVisibleRevitNameAsEntityName" Checked="Checkbox_UseVisibleRevitName_Checked" Unchecked="Checkbox_UseVisibleRevitName_Unchecked" ToolTip="Use this option to export Ifc Entity name to use visible Revit name " Height="19" VerticalAlignment="Top" HorizontalAlignment="Left" Width="588"/>
+                    <CheckBox Content="{x:Static p:Resources.UseOnlyTriangulation}" Margin="10,175,0,0" x:Name="checkBox_TriangulationOnly" Checked="checkBox_TriangulationOnly_Checked" Unchecked="checkBox_TriangulationOnly_Unchecked" ToolTip="{x:Static p:Resources.TriangulationOnlyTooltip}" HorizontalAlignment="Left" Width="588" Height="15" VerticalAlignment="Top"/>
+                    <CheckBox Content="{x:Static p:Resources.UseTypeNameOnlyForIfcType}" Margin="10,196,0,0" x:Name="checkbox_UseTypeNameOnly" Checked="Checkbox_UseTypeNameOnly_Checked" Unchecked="Checkbox_UseTypeNameOnly_Unchecked" ToolTip="{x:Static p:Resources.UseTypeNameOnlyTooltip}" HorizontalAlignment="Left" Width="588" Height="15" VerticalAlignment="Top"/>
+                    <CheckBox Content="{x:Static p:Resources.UseVisibleRevitNameAsEntityName}" Margin="10,217,0,0" x:Name="checkbox_UseVisibleRevitNameAsEntityName" Checked="Checkbox_UseVisibleRevitName_Checked" Unchecked="Checkbox_UseVisibleRevitName_Unchecked" ToolTip="{x:Static p:Resources.UseVisibleRevitNameTooltip}" Height="19" VerticalAlignment="Top" HorizontalAlignment="Left" Width="588"/>
                     <Button x:Name="button_ExcludeElement" Content="{x:Static p:Resources.ExcludeEntitySelection}" Margin="16,0,0,12" Height="23" VerticalAlignment="Bottom" HorizontalAlignment="Left" Padding="5,0,5,0" Click="button_ExcludeElement_Click"/>
                 </Grid>
             </TabItem>
diff --git a/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs b/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
index 98ee2ed8..4b4c3688 100644
--- a/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
+++ b/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
@@ -66,6 +66,6 @@
 // The following information is used in the Open Source version as the release version number.
 // The number will show up in the Title bar of the export dialog as well as at the IFC header file
 // This number must be manually updated prior to releasing the new version
-[assembly: AssemblyVersion("24.1.0.22")]
-[assembly: AssemblyFileVersion("24.1.0.22")]
+[assembly: AssemblyVersion("24.1.1.0")]
+[assembly: AssemblyFileVersion("24.1.1.0")]
 #endif
\ No newline at end of file
diff --git a/Source/IFCExporterUIOverride/Properties/Resources.Designer.cs b/Source/IFCExporterUIOverride/Properties/Resources.Designer.cs
index 3a83cbd1..aca80384 100644
--- a/Source/IFCExporterUIOverride/Properties/Resources.Designer.cs
+++ b/Source/IFCExporterUIOverride/Properties/Resources.Designer.cs
@@ -96,6 +96,15 @@ public static string AddressInformation {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Entering a value here will reset the Purpose field to &quot;USERDEFINED&quot;..
+        /// </summary>
+        public static string AddressInformationTooltip {
+            get {
+                return ResourceManager.GetString("AddressInformationTooltip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Address line 1.
         /// </summary>
@@ -2373,6 +2382,15 @@ public static string TessellationDetails {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use this option if any tessellated geometry should remain as triangulated faces, or if the export performance is affected..
+        /// </summary>
+        public static string TriangulationOnlyTooltip {
+            get {
+                return ResourceManager.GetString("TriangulationOnlyTooltip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Unknown alternate UI version.
         /// </summary>
@@ -2526,6 +2544,15 @@ public static string UseTypeNameOnlyForIfcType {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use this option to export the IFC type name as the Revit type name without the family name..
+        /// </summary>
+        public static string UseTypeNameOnlyTooltip {
+            get {
+                return ResourceManager.GetString("UseTypeNameOnlyTooltip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Use visible Revit name as the IFCEntity name.
         /// </summary>
@@ -2535,6 +2562,15 @@ public static string UseVisibleRevitNameAsEntityName {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Use this option to export IFC entity name as the visible Revit name..
+        /// </summary>
+        public static string UseVisibleRevitNameTooltip {
+            get {
+                return ResourceManager.GetString("UseVisibleRevitNameTooltip", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Path does not exist.
         /// </summary>
diff --git a/Source/IFCExporterUIOverride/Properties/Resources.resx b/Source/IFCExporterUIOverride/Properties/Resources.resx
index 1dd1cd91..2ecaee70 100644
--- a/Source/IFCExporterUIOverride/Properties/Resources.resx
+++ b/Source/IFCExporterUIOverride/Properties/Resources.resx
@@ -959,4 +959,19 @@
   <data name="IFCSG" xml:space="preserve">
     <value>IFC-SG Regulatory Requirements View</value>
   </data>
+  <data name="AddressInformationTooltip" xml:space="preserve">
+    <value>Entering a value here will reset the Purpose field to "USERDEFINED".</value>
+  </data>
+  <data name="ExportHostAsSingleEntityTooltip" xml:space="preserve">
+    <value>If this option is checked, don't create a container for floors and roofs unless exporting parts.</value>
+  </data>
+  <data name="TriangulationOnlyTooltip" xml:space="preserve">
+    <value>Use this option if any tessellated geometry should remain as triangulated faces, or if the export performance is affected.</value>
+  </data>
+  <data name="UseTypeNameOnlyTooltip" xml:space="preserve">
+    <value>Use this option to export the IFC type name as the Revit type name without the family name.</value>
+  </data>
+  <data name="UseVisibleRevitNameTooltip" xml:space="preserve">
+    <value>Use this option to export IFC entity name as the visible Revit name.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs b/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
index dd9e988e..61ddb163 100644
--- a/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
+++ b/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
@@ -1,8 +1,3 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
 namespace Revit.IFC.Common.Enums.IFC4x3
 {
    /// <summary>
diff --git a/Source/Revit.IFC.Common/Enums/IFCEntityType.cs b/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
index 49b313b1..4fecbc2b 100644
--- a/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
+++ b/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Revit.IFC.Common.Enums
+namespace Revit.IFC.Common.Enums
 {
    /// <summary>
    /// IFC entity types. Combining IFC2x2_ADD1, IFC2x3_TC1, IFC4 (Add2) and IFC4x entities, which are non-abstract 
@@ -478,7 +473,6 @@ public enum IFCEntityType
       IfcInventory,
       IfcIrregularTimeSeries,
       IfcIrregularTimeSeriesValue,
-      IfcIshapeProfileDef,
       IfcIShapeProfileDef,
       IfcJunctionBox,
       IfcJunctionBoxType,
diff --git a/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
index d3a36c0d..2e71c63b 100644
--- a/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
@@ -13,8 +13,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.0.22")]
-[assembly: AssemblyFileVersion("24.1.0.22")]
+[assembly: AssemblyVersion("24.1.1.0")]
+[assembly: AssemblyFileVersion("24.1.1.0")]
 #endif
 
 
diff --git a/Source/Revit.IFC.Export/Exporter/HostedSweepExporter.cs b/Source/Revit.IFC.Export/Exporter/HostedSweepExporter.cs
index 32fdc46e..5aed8a29 100644
--- a/Source/Revit.IFC.Export/Exporter/HostedSweepExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/HostedSweepExporter.cs
@@ -46,7 +46,7 @@ public static void Export(ExporterIFC exporterIFC, HostedSweep hostedSweep, Geom
          if (catId == new ElementId(BuiltInCategory.OST_Gutter))
             ExportGutter(exporterIFC, hostedSweep, geometryElement, productWrapper);
          else
-            ProxyElementExporter.Export(exporterIFC, hostedSweep, geometryElement, productWrapper);
+            GenericElementExporter.ExportElement(exporterIFC, hostedSweep, geometryElement, productWrapper);
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Export/Exporter/WallSweepExporter.cs b/Source/Revit.IFC.Export/Exporter/WallSweepExporter.cs
index e443ec73..4f5ef559 100644
--- a/Source/Revit.IFC.Export/Exporter/WallSweepExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/WallSweepExporter.cs
@@ -46,7 +46,7 @@ public static void Export(ExporterIFC exporterIFC, WallSweep wallSweep, Geometry
          if (wallSweepInfo.WallSweepType == WallSweepType.Reveal)
             return;
 
-         if (!ProxyElementExporter.Export(exporterIFC, wallSweep, geometryElement, productWrapper))
+         if (!GenericElementExporter.ExportElement(exporterIFC, wallSweep, geometryElement, productWrapper))
             return;
 
          HostObjectExporter.ExportHostObjectMaterials(exporterIFC, wallSweep, productWrapper.GetAnElement(),
diff --git a/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
index 71b64f90..1569e07f 100644
--- a/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
@@ -14,8 +14,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.0.22")]
-[assembly: AssemblyFileVersion("24.1.0.22")]
+[assembly: AssemblyVersion("24.1.1.0")]
+[assembly: AssemblyFileVersion("24.1.1.0")]
 
 #endif
 
diff --git a/Source/Revit.IFC.Export/Utility/OpeningUtil.cs b/Source/Revit.IFC.Export/Utility/OpeningUtil.cs
index 82fd0174..9de9d659 100644
--- a/Source/Revit.IFC.Export/Utility/OpeningUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/OpeningUtil.cs
@@ -485,24 +485,19 @@ static public IFCAnyHandle CreateOpening(ExporterIFC exporterIFC, IFCAnyHandle h
             lcs = GeometryUtil.CreateTransformFromPlane(curveLoops[0].GetPlane());
          }
 
-         ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
-
          if (extrusionData.ScaledExtrusionLength < MathUtil.Eps())
          {
-            double thickness = 0.0;
-            if (hostElement is Floor)
-               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.FLOOR_ATTR_THICKNESS_PARAM, out thickness);
-            else if (hostElement is RoofBase)
-               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.ROOF_ATTR_THICKNESS_PARAM, out thickness);
-            else if (hostElement is Ceiling)
-               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.CEILING_THICKNESS, out thickness);
+            double extrusionLength = 0.0;
+            if (hostElement is Floor || hostElement is RoofBase || hostElement is Ceiling)
+               extrusionLength = CalculateOpeningExtrusionInFloorRoofOrCeiling(hostElement, extrusionData);
 
-            if (thickness < MathUtil.Eps())
+            if (extrusionLength < MathUtil.Eps())
                return null;
 
-            extrusionData.ScaledExtrusionLength = UnitUtil.ScaleLength(thickness);
+            extrusionData.ScaledExtrusionLength = UnitUtil.ScaleLength(extrusionLength);
          }
 
+         ElementId catId = CategoryUtil.GetSafeCategoryId(insertElement);
          IFCAnyHandle openingHnd = null;
          IFCAnyHandle openingProdRepHnd = RepresentationUtil.CreateExtrudedProductDefShape(exporterIFC, insertElement, catId,
              curveLoops, lcs, extrusionData.ExtrusionDirection, extrusionData.ScaledExtrusionLength);
@@ -596,5 +591,43 @@ static bool GetOpeningDirections(Element hostElem, out XYZ perpToWall, out XYZ w
 
          return isLinearWall;
       }
+
+      /// <summary>
+      /// Calculates extrusion length for openings in floor roof or ceiling based on the element thickness for not sloped elements, 
+      /// and based on bounding box for sloped. Also defines the extrusion direction for sloped elements.
+      /// </summary>
+      /// <param name="hostElement">The host element.</param>
+      /// <param name="extrusionData">The opening extrusion data</param>
+      /// <returns>The extrusion length</returns>
+      private static double CalculateOpeningExtrusionInFloorRoofOrCeiling(Element hostElement, IFCExtrusionData extrusionData)
+      {
+         double extrusionLength = 0.0;
+         //Use the element thickness for not sloped elements, if the host element is sloped, the extrusions of the resulting opening will not intersect the host element.  
+         //To handle such cases using bounding box height instead of thickness.
+         //
+         double slopeValue = 0.0;
+         ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.ROOF_SLOPE, out slopeValue);
+         if (MathUtil.IsAlmostZero(slopeValue))
+         {
+            if (hostElement is Floor)
+               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.FLOOR_ATTR_THICKNESS_PARAM, out extrusionLength);
+            else if (hostElement is RoofBase)
+               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.ROOF_ATTR_THICKNESS_PARAM, out extrusionLength);
+            else if (hostElement is Ceiling)
+               ParameterUtil.GetDoubleValueFromElement(hostElement, BuiltInParameter.CEILING_THICKNESS, out extrusionLength);
+         }
+         else
+         {
+            BoundingBoxXYZ hostElementBoundingBox = hostElement.get_BoundingBox(hostElement.Document.GetElement(hostElement.OwnerViewId) as View);
+            extrusionLength = hostElementBoundingBox.Max.Z - hostElementBoundingBox.Min.Z;
+
+            //Need to recheck the ExtrusionDirection.
+            //If slope is positive value the host it will be above.
+            //
+            extrusionData.ExtrusionDirection = (slopeValue > 0) ? XYZ.BasisZ : -XYZ.BasisZ;
+         }
+
+         return extrusionLength;
+      }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
index af54ca93..a1e402d4 100644
--- a/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
@@ -13,8 +13,8 @@
 [assembly: AssemblyDescription("Revit.IFC.Import.Core")]
 [assembly: AssemblyCompany("Autodesk")]
 [assembly: AssemblyCopyright("@2012-2023 Autodesk, Inc. All rights reserved.")]
-[assembly: AssemblyVersion("24.1.0.22")]
-[assembly: AssemblyFileVersion("24.1.0.22")]
+[assembly: AssemblyVersion("24.1.1.0")]
+[assembly: AssemblyFileVersion("24.1.1.0")]
 
 // Version information can now be found in Source\Foundation\RevitENU\Version.cs
 //
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingElementProxy.cs b/Source/Revit.IFC.Import/Data/IFCBuildingElementProxy.cs
index d3c4dbbb..3a8354f7 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingElementProxy.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingElementProxy.cs
@@ -140,7 +140,7 @@ protected override void Create(Document doc)
                   geomObjs.Add(solid.GeometryObject);
             }
 
-            DirectShape buildingElementProxyShape = IFCElementUtil.CreateElement(doc, CategoryId, GlobalId, geomObjs, Id, EntityType);
+            DirectShape buildingElementProxyShape = IFCElementUtil.CreateElement(doc, GetCategoryId(doc), GlobalId, geomObjs, Id, EntityType);
             if (buildingElementProxyShape != null)
             {
                CreatedElementId = buildingElementProxyShape.Id;
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
index 2a8c977a..1bdaad36 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
@@ -17,6 +17,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
+using System;
 using System.Collections.Generic;
 using Autodesk.Revit.ApplicationServices;
 using Autodesk.Revit.DB;
@@ -32,13 +33,6 @@ namespace Revit.IFC.Import.Data
    /// </summary>
    public class IFCBuildingStorey : IFCSpatialStructureElement
    {
-      static ElementId ViewPlanTypeId { get; set; } = ElementId.InvalidElementId;
-
-      /// <summary>
-      /// Returns true if we have tried to set ViewPlanTypeId.  ViewPlanTypeId may or may not have a valid value.
-      /// </summary>
-      static bool ViewPlanTypeIdInitialized { get; set; } = false;
-
       /// <summary>
       /// Returns the associated Plan View for the level.
       /// </summary>
@@ -53,14 +47,24 @@ public class IFCBuildingStorey : IFCSpatialStructureElement
       /// Get the default family type for creating ViewPlans.
       /// </summary>
       /// <param name="doc"></param>
-      /// <returns></returns>
+      /// <returns>The default family type.</returns>
       public static ElementId GetViewPlanTypeId(Document doc)
       {
-         if (ViewPlanTypeIdInitialized == false)
+         // There are theoretical cases where this could fail, but no such cases have been
+         // seen in practice.
+         if (Importer.TheCache.ViewPlanTypeIdInitialized == false)
          {
-            ViewFamily viewFamilyToUse = (doc.Application.Product == ProductType.Structure) ? ViewFamily.StructuralPlan : ViewFamily.FloorPlan;
-
-            ViewPlanTypeIdInitialized = true;
+            // Basically, we only want to use the StructuralPlan if Structure is our only valid
+            // option.
+            ViewFamily viewFamilyToUse;
+            if (doc.Application.IsArchitectureEnabled || doc.Application.IsSystemsEnabled)
+               viewFamilyToUse = ViewFamily.FloorPlan;
+            else if (doc.Application.IsStructureEnabled)
+               viewFamilyToUse = ViewFamily.StructuralPlan;
+            else
+               viewFamilyToUse = ViewFamily.FloorPlan;
+
+            Importer.TheCache.ViewPlanTypeIdInitialized = true;
             FilteredElementCollector collector = new FilteredElementCollector(doc);
             ICollection<Element> viewFamilyTypes = collector.OfClass(typeof(ViewFamilyType)).ToElements();
             foreach (Element element in viewFamilyTypes)
@@ -68,12 +72,12 @@ public static ElementId GetViewPlanTypeId(Document doc)
                ViewFamilyType viewFamilyType = element as ViewFamilyType;
                if (viewFamilyType.ViewFamily == viewFamilyToUse)
                {
-                  ViewPlanTypeId = viewFamilyType.Id;
+                  Importer.TheCache.ViewPlanTypeId = viewFamilyType.Id;
                   break;
                }
             }
          }
-         return ViewPlanTypeId;
+         return Importer.TheCache.ViewPlanTypeId;
       }
 
       /// <summary>
@@ -98,7 +102,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
          {
             // Set "IfcElevation" parameter.
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-            IFCPropertySet.AddParameterDouble(doc, element, category, this, "IfcElevation", SpecTypeId.Length, UnitTypeId.Feet, Elevation, Id);
+            ParametersToSet.AddParameterDouble(doc, element, category, this, "IfcElevation", SpecTypeId.Length, UnitTypeId.Feet, Elevation, Id);
          }
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs b/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
index cde28cb2..e55bcc8a 100644
--- a/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
@@ -80,8 +80,9 @@ protected override void CreateParametersInternal(Document doc, Element element)
          if (element != null)
          {
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-            IFCPropertySet.AddParameterString(doc, element, category, this, "Flow Direction", FlowDirection.ToString(), Id);
-            IFCPropertySet.AddParameterString(doc, element, category, this, "System Type", SystemType.ToString(), Id);
+
+            ParametersToSet.AddStringParameter(doc, element, category, this, "Flow Direction", FlowDirection.ToString(), Id);
+            ParametersToSet.AddStringParameter(doc, element, category, this, "System Type", SystemType.ToString(), Id);
          }
       }
 
@@ -110,14 +111,16 @@ protected override void Create(Document doc)
 
          // 2016+ only.
          XYZ origin = lcs.Origin;
-         Point point = XYZ.IsWithinLengthLimits(origin) ? Point.Create(origin, GraphicsStyleId) : null;
+
+         ElementId graphicsStyleId = GetGraphicsStyleId(doc);
+         Point point = XYZ.IsWithinLengthLimits(origin) ? Point.Create(origin, graphicsStyleId) : null;
 
          // 2015+: create cone(s) for the direction of flow.
          CurveLoop rightTrangle = new CurveLoop();
          const double radius = 0.04;
          const double height = 0.12;
 
-         SolidOptions solidOptions = new SolidOptions(ElementId.InvalidElementId, GraphicsStyleId);
+         SolidOptions solidOptions = new SolidOptions(ElementId.InvalidElementId, graphicsStyleId);
 
          Frame coordinateFrame = new Frame(lcs.Origin, lcs.BasisX, lcs.BasisY, lcs.BasisZ);
 
@@ -145,8 +148,7 @@ protected override void Create(Document doc)
             oppositeRightTrangle.Append(Line.CreateBound(pt1, oppPt2));
             oppositeRightTrangle.Append(Line.CreateBound(oppPt2, oppPt3));
             oppositeRightTrangle.Append(Line.CreateBound(oppPt3, pt1));
-            IList<CurveLoop> oppositeCurveLoops = new List<CurveLoop>();
-            oppositeCurveLoops.Add(oppositeRightTrangle);
+            IList<CurveLoop> oppositeCurveLoops = new List<CurveLoop>() { oppositeRightTrangle };
 
             oppositePortArrow = GeometryCreationUtilities.CreateRevolvedGeometry(oppositeCoordinateFrame, oppositeCurveLoops, 0.0, Math.PI * 2.0, solidOptions);
          }
@@ -161,7 +163,7 @@ protected override void Create(Document doc)
             if (oppositePortArrow != null)
                geomObjs.Add(oppositePortArrow);
 
-            DirectShape directShape = IFCElementUtil.CreateElement(doc, CategoryId, GlobalId, geomObjs, Id, EntityType);
+            DirectShape directShape = IFCElementUtil.CreateElement(doc, GetCategoryId(doc), GlobalId, geomObjs, Id, EntityType);
             if (directShape != null)
             {
                CreatedGeometry = geomObjs;
diff --git a/Source/Revit.IFC.Import/Data/IFCDistributionSystem.cs b/Source/Revit.IFC.Import/Data/IFCDistributionSystem.cs
index 21e3bca2..f212b21b 100644
--- a/Source/Revit.IFC.Import/Data/IFCDistributionSystem.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDistributionSystem.cs
@@ -17,6 +17,7 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
+using System;
 using System.Collections.Generic;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
@@ -139,7 +140,7 @@ public static IFCDistributionSystem ProcessIFCDistributionSystem(IFCAnyHandle if
 
       /// <summary>
       /// Indicates whether we should create a separate DirectShape for this IFC entity.
-      /// For IfcDistributionSystem, a DIrectShape should be created.
+      /// For IfcDistributionSystem, a DirectShape should be created.
       /// </summary>
       /// <returns>True if a DirectShape container is created, False otherwise.</returns>
       public override bool CreateContainer() { return true; }
@@ -162,8 +163,8 @@ protected override void CreateParametersInternal(Document doc, Element element)
 
                // Add IfcSystemClassification parameter.
                Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "SystemClassification", systemClassificationString, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "SystemName", LongName, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "SystemClassification", systemClassificationString, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "SystemName", LongName, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCDoorStyle.cs b/Source/Revit.IFC.Import/Data/IFCDoorStyle.cs
index f957f212..1fd1fa18 100644
--- a/Source/Revit.IFC.Import/Data/IFCDoorStyle.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDoorStyle.cs
@@ -116,11 +116,20 @@ protected override void CreateParametersInternal(Document doc, Element element)
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
             if (category != null)
             {
-               Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false);
-               Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_CONSTRUCTION_TYPE, ConstructionType.ToString(), false);
-
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcOperationType", OperationType.ToString(), Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcConstructionType", ConstructionType.ToString(), Id);
+               IFCDefaultProcessor processor = Importer.TheProcessor as IFCDefaultProcessor;
+               if (processor != null)
+               {
+                  processor.SetElementStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false, ParametersToSet);
+                  processor.SetElementStringParameter(element, Id, BuiltInParameter.DOOR_CONSTRUCTION_TYPE, ConstructionType.ToString(), false, ParametersToSet);
+               }
+               else
+               {
+                  Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false);
+                  Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_CONSTRUCTION_TYPE, ConstructionType.ToString(), false);
+               }
+
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcOperationType", OperationType.ToString(), Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcConstructionType", ConstructionType.ToString(), Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCDoorType.cs b/Source/Revit.IFC.Import/Data/IFCDoorType.cs
index 6f18f179..8cbc3e79 100644
--- a/Source/Revit.IFC.Import/Data/IFCDoorType.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDoorType.cs
@@ -98,8 +98,18 @@ protected override void CreateParametersInternal(Document doc, Element element)
       {
          base.CreateParametersInternal(doc, element);
 
-         if (element != null)
+         if (element == null)
+            return;
+
+         IFCDefaultProcessor processor = Importer.TheProcessor as IFCDefaultProcessor;
+         if (processor != null)
+         {
+            processor.SetElementStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false, ParametersToSet);
+         }
+         else
+         {
             Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false);
+         }
       }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Data/IFCDoorWindowPropertyBase.cs b/Source/Revit.IFC.Import/Data/IFCDoorWindowPropertyBase.cs
index 35a548b8..7e78c806 100644
--- a/Source/Revit.IFC.Import/Data/IFCDoorWindowPropertyBase.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDoorWindowPropertyBase.cs
@@ -98,7 +98,8 @@ protected override void Process(IFCAnyHandle ifcDoorWindowPropertyBase)
       /// <param name="element">The element being created.</param>
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <returns>The name of the property set created, if it was created, and a Boolean value if it should be added to the property set list.</returns>
-      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap)
+      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, ParametersToSet parametersToSet)
       {
          IDictionary<string, IFCData> parametersToAdd = new Dictionary<string, IFCData>();
          Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
@@ -114,17 +115,17 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
                // and so will always be in feet.
                ForgeTypeId unitType = (!Importer.TheProcessor.ScaleValues && valueType == SpecTypeId.Length) ? 
                   UnitTypeId.Feet : null;
-               IFCPropertySet.AddParameterDouble(doc, element, category, objDef, name, valueType, unitType, property.Value, Id);
+               parametersToSet.AddParameterDouble(doc, element, category, objDef, name, valueType, unitType, property.Value, Id);
                continue;
             }
 
             switch (existingParameter.StorageType)
             {
                case StorageType.String:
-                  existingParameter.Set(property.Value.ToString());
+                  parametersToSet.AddStringParameter(existingParameter, property.Value.ToString());
                   break;
                case StorageType.Double:
-                  existingParameter.Set(property.Value);
+                  parametersToSet.AddDoubleParameter(existingParameter, property.Value);
                   break;
                default:
                   Importer.TheLog.LogError(Id, "couldn't create parameter: " + name + " of storage type: " + existingParameter.StorageType.ToString(), false);
@@ -138,14 +139,14 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
             Parameter existingParameter = null;
             if (!parameterGroupMap.TryFindParameter(name, out existingParameter))
             {
-               IFCPropertySet.AddParameterString(doc, element, category, objDef, property.Key, property.Value, Id);
+               parametersToSet.AddStringParameter(doc, element, category, objDef, property.Key, property.Value, Id);
                continue;
             }
 
             switch (existingParameter.StorageType)
             {
                case StorageType.String:
-                  existingParameter.Set(property.Value);
+                  parametersToSet.AddStringParameter(existingParameter, property.Value);
                   break;
                default:
                   Importer.TheLog.LogError(Id, "couldn't create parameter: " + name + " of storage type: " + existingParameter.StorageType.ToString(), false);
diff --git a/Source/Revit.IFC.Import/Data/IFCElement.cs b/Source/Revit.IFC.Import/Data/IFCElement.cs
index a6256fa9..1a67c0b0 100644
--- a/Source/Revit.IFC.Import/Data/IFCElement.cs
+++ b/Source/Revit.IFC.Import/Data/IFCElement.cs
@@ -217,7 +217,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
             // Set "Tag" parameter.
             string ifcTag = Tag;
             if (!string.IsNullOrWhiteSpace(ifcTag))
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcTag", ifcTag, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcTag", ifcTag, Id);
 
             IFCFeatureElementSubtraction ifcFeatureElementSubtraction = FillsOpening;
             if (ifcFeatureElementSubtraction != null)
@@ -225,8 +225,8 @@ protected override void CreateParametersInternal(Document doc, Element element)
                IFCElement ifcElement = ifcFeatureElementSubtraction.VoidsElement;
                if (ifcElement != null)
                {
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcContainedInHost", ifcElement.Name, Id);
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcContainedInHostGUID", ifcElement.GlobalId, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcContainedInHost", ifcElement.Name, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcContainedInHostGUID", ifcElement.GlobalId, Id);
                }
             }
 
@@ -241,13 +241,13 @@ protected override void CreateParametersInternal(Document doc, Element element)
                if (!string.IsNullOrWhiteSpace(name))
                {
                   string parameterName = "IfcElement HasPorts Name " + ((numPorts == 0) ? "" : (numPorts + 1).ToString());
-                  IFCPropertySet.AddParameterString(doc, element, category, this, parameterName, name, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, parameterName, name, Id);
                }
 
                if (!string.IsNullOrWhiteSpace(guid))
                {
                   string parameterName = "IfcElement HasPorts IfcGUID " + ((numPorts == 0) ? "" : (numPorts + 1).ToString());
-                  IFCPropertySet.AddParameterString(doc, element, category, this, parameterName, guid, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, parameterName, guid, Id);
                }
 
                numPorts++;
diff --git a/Source/Revit.IFC.Import/Data/IFCElementAssembly.cs b/Source/Revit.IFC.Import/Data/IFCElementAssembly.cs
index af2900eb..abffc09c 100644
--- a/Source/Revit.IFC.Import/Data/IFCElementAssembly.cs
+++ b/Source/Revit.IFC.Import/Data/IFCElementAssembly.cs
@@ -99,8 +99,8 @@ protected override void CreateParametersInternal(Document doc, Element element)
          if (element != null)
          {
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-            IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPredefinedType", PredefinedType, Id);
-            IFCPropertySet.AddParameterString(doc, element, category, this, "IfcAssemblyPlace", AssemblyPlace.ToString(), Id);
+            ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPredefinedType", PredefinedType, Id);
+            ParametersToSet.AddStringParameter(doc, element, category, this, "IfcAssemblyPlace", AssemblyPlace.ToString(), Id);
          }
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs b/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
index bd6106f1..16047231 100644
--- a/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
+++ b/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
@@ -128,7 +128,8 @@ public static IFCElementQuantity ProcessIFCElementQuantity(IFCAnyHandle ifcEleme
       /// <param name="element">The element being created.</param>
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <returns>The name of the property set created, if it was created, and a Boolean value if it should be added to the property set list.</returns>
-      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap)
+      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, ParametersToSet parametersToSet)
       {
          Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
 
@@ -138,7 +139,7 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
          foreach (IFCPhysicalQuantity quantity in IFCQuantities.Values)
          {
             string fullName = CreatePropertyName(quantity.Name);
-            quantity.Create(doc, element, category, objDef, parameterGroupMap, fullName, parametersCreated);
+            quantity.Create(doc, element, category, objDef, parameterGroupMap, fullName, parametersCreated, parametersToSet);
          }
 
          return Tuple.Create(quotedName, true);
diff --git a/Source/Revit.IFC.Import/Data/IFCElementType.cs b/Source/Revit.IFC.Import/Data/IFCElementType.cs
index af06b50c..5ad5514f 100644
--- a/Source/Revit.IFC.Import/Data/IFCElementType.cs
+++ b/Source/Revit.IFC.Import/Data/IFCElementType.cs
@@ -104,7 +104,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
             if (!string.IsNullOrWhiteSpace(ElementType))
             {
                Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcElementType", ElementType, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcElementType", ElementType, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCGroup.cs b/Source/Revit.IFC.Import/Data/IFCGroup.cs
index b93c55b0..b0de2edd 100644
--- a/Source/Revit.IFC.Import/Data/IFCGroup.cs
+++ b/Source/Revit.IFC.Import/Data/IFCGroup.cs
@@ -219,7 +219,7 @@ protected override void Create(Document doc)
                   }
                }
 
-               DirectShape directShape = IFCElementUtil.CreateElement(doc, CategoryId, GlobalId, geometryObjects, Id, EntityType);
+               DirectShape directShape = IFCElementUtil.CreateElement(doc, GetCategoryId(doc), GlobalId, geometryObjects, Id, EntityType);
                if (directShape != null)
                {
                   CreatedElementId = directShape.Id;
diff --git a/Source/Revit.IFC.Import/Data/IFCImportFile.cs b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
index 10348837..dcccf5ba 100644
--- a/Source/Revit.IFC.Import/Data/IFCImportFile.cs
+++ b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
@@ -585,29 +585,44 @@ private static void UpdateDocumentFileMetrics(Document doc, string ifcFileName)
             return;
 
          Parameter originalImporterVersion = projInfo.LookupParameter("Revit Importer Version");
-         if (originalTimeStampParam != null && originalTimeStampParam.StorageType != StorageType.String)
+         if (originalImporterVersion != null && originalImporterVersion.StorageType != StorageType.String)
             return;
 
+         Parameter originalImportMethod = projInfo.LookupParameter(IFCImportOptions.ImportMethodParameter);
+         if (originalImportMethod != null && originalImportMethod.StorageType != StorageType.String)
+            return;
+         
          Category category = IFCPropertySet.GetCategoryForParameterIfValid(projInfo, -1);
-         if (originalFileName != null)
-            originalFileName.Set(ifcFileName);
-         else
-            IFCPropertySet.AddParameterString(doc, projInfo, category, TheFile.IFCProject, "Original IFC File Name", ifcFileName, -1);
 
-         if (originalFileSizeParam != null)
-            originalFileSizeParam.Set(ifcFileLength.ToString());
-         else
-            IFCPropertySet.AddParameterString(doc, projInfo, category, TheFile.IFCProject, "Original IFC File Size", ifcFileLength.ToString(), -1);
+         using (ParameterSetter setter = new ParameterSetter())
+         {
+            ParametersToSet parametersToSet = setter.ParametersToSet;
 
-         if (originalTimeStampParam != null)
-            originalTimeStampParam.Set(ticks.ToString());
-         else
-            IFCPropertySet.AddParameterString(doc, projInfo, category, TheFile.IFCProject, "Revit File Last Updated", ticks.ToString(), -1);
+            if (originalFileName != null)
+               parametersToSet.AddStringParameter(originalFileName, ifcFileName);
+            else
+               parametersToSet.AddStringParameter(doc, projInfo, category, TheFile.IFCProject, "Original IFC File Name", ifcFileName, -1);
 
-         if (originalImporterVersion != null)
-            originalImporterVersion.Set(IFCImportOptions.ImporterVersion);
-         else
-            IFCPropertySet.AddParameterString(doc, projInfo, category, TheFile.IFCProject, "Revit Importer Version", IFCImportOptions.ImporterVersion, -1);
+            if (originalFileSizeParam != null)
+               parametersToSet.AddStringParameter(originalFileSizeParam, ifcFileLength.ToString());
+            else
+               parametersToSet.AddStringParameter(doc, projInfo, category, TheFile.IFCProject, "Original IFC File Size", ifcFileLength.ToString(), -1);
+
+            if (originalTimeStampParam != null)
+               parametersToSet.AddStringParameter(originalTimeStampParam, ticks.ToString());
+            else
+               parametersToSet.AddStringParameter(doc, projInfo, category, TheFile.IFCProject, "Revit File Last Updated", ticks.ToString(), -1);
+
+            if (originalImporterVersion != null)
+               parametersToSet.AddStringParameter(originalImporterVersion, IFCImportOptions.ImporterVersion);
+            else
+               parametersToSet.AddStringParameter(doc, projInfo, category, TheFile.IFCProject, "Revit Importer Version", IFCImportOptions.ImporterVersion, -1);
+
+            if (originalImportMethod != null)
+               parametersToSet.AddStringParameter(originalImportMethod, Importer.TheOptions.CurrentImportMethod.ToString());
+            else
+               parametersToSet.AddStringParameter(doc, projInfo, category, TheFile.IFCProject, IFCImportOptions.ImportMethodParameter, Importer.TheOptions.CurrentImportMethod.ToString(), -1);
+         }
       }
 
       private bool DontDeleteSpecialElement(ElementId elementId)
@@ -638,6 +653,9 @@ public void EndImport(Document doc, string fileName)
 
             foreach (ElementId elementId in Importer.TheCache.GUIDToElementMap.Values)
             {
+               if (Importer.TheHybridInfo?.HybridElements.Contains(elementId) ?? false)
+                  continue;
+
                if (DontDeleteSpecialElement(elementId))
                   continue;
 
@@ -653,6 +671,9 @@ public void EndImport(Document doc, string fileName)
 
             foreach (ElementId elementId in Importer.TheCache.GridNameToElementMap.Values)
             {
+               if (Importer.TheHybridInfo?.HybridElements.Contains(elementId) ?? false)
+                  continue;
+
                Element element = doc.GetElement(elementId);
                if (element == null)
                   continue;
diff --git a/Source/Revit.IFC.Import/Data/IFCMappedItem.cs b/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
index 722042ce..eec928ea 100644
--- a/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
+++ b/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
@@ -63,18 +63,20 @@ override protected void Process(IFCAnyHandle item)
       {
          base.Process(item);
 
+         IFCAnyHandle mappingSource = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "MappingSource", false);
+         if (mappingSource == null)
+            return;
+
+         MappingSource = IFCRepresentationMap.ProcessIFCRepresentationMap(mappingSource);
+         if (MappingSource.IsHybridOnly())
+            return;
+
          // We will not fail if the transform is not given, but instead assume it to be the identity.
          IFCAnyHandle mappingTarget = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "MappingTarget", false);
          if (mappingTarget != null)
             MappingTarget = IFCCartesianTransformOperator.ProcessIFCCartesianTransformOperator(mappingTarget);
          else
             MappingTarget = IFCCartesianTransformOperator.ProcessIFCCartesianTransformOperator();
-
-         IFCAnyHandle mappingSource = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "MappingSource", false);
-         if (mappingSource == null)
-            return;
-
-         MappingSource = IFCRepresentationMap.ProcessIFCRepresentationMap(mappingSource);
       }
 
       private int FindAlternateGeometrySource(int originalId)
@@ -101,6 +103,12 @@ protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditSco
       {
          base.CreateShapeInternal(shapeEditScope, scaledLcs, guid);
 
+         // Optimization for hybrid import.  MappingTarget will be null in this case.
+         if (MappingTarget == null)
+         {
+            return;
+         }
+
          // Check scale; if it is uniform, create an instance.  If not, create a shape directly.
          // TODO: Instead allow creation of instances based on similar scaling.
          double scaleX = MappingTarget.Scale;
@@ -129,15 +137,19 @@ protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditSco
          if (canCreateType)
          {
             int mappingSourceId = MappingSource.Id;
+
             int geometrySourceId = FindAlternateGeometrySource(mappingSourceId);
             MappingSource.CreateShape(shapeEditScope, null, guid);
 
-            if (shapeEditScope.Creator != null)
+            // IFCDefaultProcessor doesn't implement PostProcessMappedItem.  Skip this call to avoid
+            // GetCategoryId(), which can create an unnecessary subcategory (which also forces an
+            // unnecessary regeneration).
+            if ((shapeEditScope.Creator != null) && !(Importer.TheProcessor is IFCDefaultProcessor))
             {
                Importer.TheProcessor.PostProcessMappedItem(shapeEditScope.Creator.Id,
                   shapeEditScope.Creator.GlobalId,
                   shapeEditScope.Creator.EntityType.ToString(),
-                  shapeEditScope.Creator.CategoryId,
+                  shapeEditScope.Creator.GetCategoryId(shapeEditScope.Document),
                   geometrySourceId,
                   newScaledLcs);
             }
diff --git a/Source/Revit.IFC.Import/Data/IFCMaterial.cs b/Source/Revit.IFC.Import/Data/IFCMaterial.cs
index a281e602..c8762f61 100644
--- a/Source/Revit.IFC.Import/Data/IFCMaterial.cs
+++ b/Source/Revit.IFC.Import/Data/IFCMaterial.cs
@@ -87,7 +87,7 @@ protected override void Process(IFCAnyHandle ifcMaterial)
          if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC2x3))
             hasRepresentation = IFCAnyHandleUtil.GetAggregateInstanceAttribute<List<IFCAnyHandle>>(ifcMaterial, "HasRepresentation");
 
-         if (hasRepresentation != null && hasRepresentation.Count == 1)
+         if ((hasRepresentation?.Count ?? 0) == 1)
          {
             if (!IFCAnyHandleUtil.IsSubTypeOf(hasRepresentation[0], IFCEntityType.IfcMaterialDefinitionRepresentation))
                Importer.TheLog.LogUnexpectedTypeError(hasRepresentation[0], IFCEntityType.IfcMaterialDefinitionRepresentation, false);
@@ -108,7 +108,7 @@ private static string GetMaterialName(int id, string originalName)
          if (revitMaterialName != null)
             return revitMaterialName;
 
-         return String.Format(Resources.IFCDefaultMaterialName, id);
+         return string.Format(Resources.IFCDefaultMaterialName, id);
       }
 
       /// <summary>
@@ -116,8 +116,7 @@ private static string GetMaterialName(int id, string originalName)
       /// </summary>
       public IList<IFCMaterial> GetMaterials()
       {
-         IList<IFCMaterial> materials = new List<IFCMaterial>();
-         materials.Add(this);
+         IList<IFCMaterial> materials = new List<IFCMaterial>() { this };
          return materials;
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCObject.cs b/Source/Revit.IFC.Import/Data/IFCObject.cs
index df7dd41c..d6b0ce2c 100644
--- a/Source/Revit.IFC.Import/Data/IFCObject.cs
+++ b/Source/Revit.IFC.Import/Data/IFCObject.cs
@@ -319,7 +319,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
             if (!string.IsNullOrWhiteSpace(objectTypeOverride))
             {
                Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "ObjectTypeOverride", objectTypeOverride, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "ObjectTypeOverride", objectTypeOverride, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs b/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
index 089c62b3..ecb3ee2b 100644
--- a/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
+++ b/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
@@ -1,4 +1,4 @@
-//
+//
 // Revit IFC Import library: this library works with Autodesk(R) Revit(R) to import IFC files.
 // Copyright (C) 2013  Autodesk, Inc.
 // 
@@ -19,7 +19,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Configuration;
 using System.Linq;
+using System.Runtime.Remoting;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Common.Enums;
@@ -37,7 +39,7 @@ public abstract class IFCObjectDefinition : IFCRoot
       ICollection<IFCGroup> m_AssignmentGroups = null; //HasAssignments
 
       private IFCMaterial m_TheMaterial = null;
-      
+
       private bool m_TheMaterialIsSet = false;
 
       private IDictionary<string, object> m_AdditionalIntParameters = null;
@@ -46,6 +48,8 @@ public abstract class IFCObjectDefinition : IFCRoot
 
       private IFCObjectDefinition m_Nests = null;
 
+      protected ParametersToSet ParametersToSet { get; set; } = new ParametersToSet();
+
       /// <summary>
       /// The IFCObjectDefinition that is nested by this.
       /// </summary>
@@ -62,15 +66,41 @@ public IFCObjectDefinition NestsWhole
          }
       }
 
+      protected ElementId CategoryIdCache { get; set; } = ElementId.InvalidElementId;
+
+      protected ElementId GraphicsStyleIdCache { get; set; } = ElementId.InvalidElementId;
+
+      private void CalculateCategoryAndGStyleIds(Document doc)
+      {
+         CategoryIdCache = IFCCategoryUtil.GetCategoryIdForEntity(doc, this, out ElementId gstyleId);
+         GraphicsStyleIdCache = gstyleId;
+      }
+
       /// <summary>
       /// The category id corresponding to the element created for this IFCObjectDefinition.
       /// </summary>
-      public ElementId CategoryId { get; protected set; } = ElementId.InvalidElementId;
+      public ElementId GetCategoryId(Document doc)
+      {
+         if (CategoryIdCache == ElementId.InvalidElementId)
+         {
+            CalculateCategoryAndGStyleIds(doc);
+         }
+
+         return CategoryIdCache;
+      }
 
       /// <summary>
       /// The graphics style id corresponding to the element created for this IFCObjectDefinition.
       /// </summary>
-      public ElementId GraphicsStyleId { get; protected set; } = ElementId.InvalidElementId;
+      public ElementId GetGraphicsStyleId(Document doc)
+      {
+         if (GraphicsStyleIdCache == ElementId.InvalidElementId)
+         {
+            CalculateCategoryAndGStyleIds(doc);
+         }
+
+         return GraphicsStyleIdCache;
+      }
 
       /// <summary>
       /// Returns true if sub-elements should be grouped; false otherwise.
@@ -109,7 +139,10 @@ public virtual bool GroupSubElements()
       /// <returns></returns>
       public bool IsHybridImportContainer()
       {
-         return (Importer.TheOptions.IsHybridImport && IsAllowedToAggregateGeometry() && (Importer.TheHybridInfo?.ContainerMap?.ContainsKey(Id) ?? false));
+         return Importer.TheOptions.IsHybridImport &&
+            IsAllowedToAggregateGeometry() &&
+            ((ComposedObjectDefinitions?.Count ?? 0) > 0) &&
+            (Importer.TheHybridInfo?.ContainerMap?.ContainsKey(Id) ?? false);
       }
 
       /// <summary>
@@ -359,8 +392,8 @@ protected IFCObjectDefinition()
       /// <param name="doc">The document.</param>
       protected override void Create(Document doc)
       {
-         if (MaterialSelect != null)
-            MaterialSelect.Create(doc);
+         // We will not process the MaterialSelect here, as if we actually need the material information, we will create
+         // it then.  This is an optimization for Hybrid mode but should work for Legacy also.
 
          base.Create(doc);
 
@@ -400,6 +433,18 @@ protected virtual bool CutSolidByVoids(IFCSolidInfo solidInfo)
          return true;
       }
 
+      private void AddPlanViewCurves(Document doc, DirectShape containerDirectShape, IList<Curve> planViewCurves)
+      {
+         if (doc == null || containerDirectShape == null || ((planViewCurves?.Count ?? 0) == 0) || !(this is IFCProduct))
+            return;
+
+         using (IFCImportShapeEditScope planViewScope = IFCImportShapeEditScope.Create(doc, this as IFCProduct))
+         {
+            planViewScope.AddPlanViewCurves(planViewCurves, Id);
+            planViewScope.SetPlanViewRep(containerDirectShape);
+         }
+      }
+
       /// <summary>
       /// Creates or populates Revit elements based on the information contained in this class.
       /// </summary>
@@ -447,46 +492,54 @@ protected virtual void TraverseSubElements(Document doc)
             }
          }
 
-         if (GroupSubElements())
+         if (GroupSubElements() && subElementIds.Count > 0)
          {
-            if (subElementIds.Count > 0)
+            if (CreatedElementId != ElementId.InvalidElementId)
             {
-               if (CreatedElementId != ElementId.InvalidElementId && groupedSubElementGeometries.Count == 0)
-               {
-                  // If CreateDuplicateContainerGeometry is false,  then
-                  // groupedSubElementGeometries is empty and we then create a new
-                  // DirectShape with no content in it.
-                  //
-                  // For files such as NW-55644 that has geometry on the slab element and
-                  // children with geometry, this means that the slab geometry is thrown away
-                  return;
-               }
-
-               if (CreatedElementId != ElementId.InvalidElementId)
-                  subElementIds.Add(CreatedElementId);
-
-               // We aren't yet actually grouping the elements.  DirectShape doesn't support grouping, and
-               // the Group element doesn't support adding parameters.  For now, we will create a DirectShape that "forgets"
-               // the association, which is good enough for link.
-               DirectShape directShape = IFCElementUtil.CreateElement(doc, CategoryId, GlobalId, groupedSubElementGeometries, Id, EntityType);
-               //Group group = doc.Create.NewGroup(subElementIds);
-
-               if (directShape != null)
+               if (Importer.TheOptions.IsHybridImport)
                {
-                  CreatedElementId = directShape.Id;
-                  CreatedGeometry = groupedSubElementGeometries;
-
-                  if (groupedSubElementFootprintCurves.Count != 0 && this is IFCProduct)
+                  DirectShape containerDirectShape = doc.GetElement(CreatedElementId) as DirectShape;
+                  if (containerDirectShape != null)
                   {
-                     using (IFCImportShapeEditScope planViewScope = IFCImportShapeEditScope.Create(doc, this as IFCProduct))
+                     if (groupedSubElementGeometries != null)
                      {
-                        planViewScope.AddPlanViewCurves(groupedSubElementFootprintCurves, Id);
-                        planViewScope.SetPlanViewRep(directShape);
+                        containerDirectShape.AppendShape(groupedSubElementGeometries);
                      }
+                     AddPlanViewCurves(doc, containerDirectShape, groupedSubElementFootprintCurves);
+                     return;
                   }
                }
-               else
-                  Importer.TheLog.LogCreationError(this, null, false);
+
+               // If CreateDuplicateContainerGeometry is false,  then
+               // groupedSubElementGeometries is empty and we then create a new
+               // DirectShape with no content in it.
+               //
+               // For files such as NW-55644 that has geometry on the slab element and
+               // children with geometry, this means that the slab geometry is thrown away
+               if (groupedSubElementGeometries.Count == 0 && !Importer.TheOptions.IsHybridImport)
+               {
+                  return;
+               }
+            }
+
+            if (CreatedElementId != ElementId.InvalidElementId)
+               subElementIds.Add(CreatedElementId);
+
+            // We aren't yet actually grouping the elements.  DirectShape doesn't support grouping, and
+            // the Group element doesn't support adding parameters.  For now, we will create a DirectShape that "forgets"
+            // the association, which is good enough for link.
+            DirectShape directShape = IFCElementUtil.CreateElement(doc, GetCategoryId(doc), GlobalId, groupedSubElementGeometries, Id, EntityType);
+            //Group group = doc.Create.NewGroup(subElementIds);
+
+            if (directShape != null)
+            {
+               CreatedElementId = directShape.Id;
+               CreatedGeometry = groupedSubElementGeometries;
+               AddPlanViewCurves(doc, directShape, groupedSubElementFootprintCurves);
+            }
+            else
+            {
+               Importer.TheLog.LogCreationError(this, null, false);
             }
          }
       }
@@ -501,9 +554,19 @@ protected override void Process(IFCAnyHandle ifcObjectDefinition)
 
          PredefinedType = GetPredefinedType(ifcObjectDefinition);
 
+         ElementId createdElementId = ElementId.InvalidElementId;
+         if (Importer.TheOptions.IsHybridImport)
+         {
+            Importer.TheHybridInfo?.HybridMap?.TryGetValue(GlobalId, out createdElementId);
+         }
+
          // If we aren't importing this category, skip processing.
          if (!IFCCategoryUtil.CanImport(EntityType, PredefinedType))
+         {
+            if (createdElementId != ElementId.InvalidElementId)
+               Importer.TheHybridInfo.ElementsToDelete?.Add(createdElementId);
             throw new InvalidOperationException("Don't Import");
+         }
 
          HashSet<IFCAnyHandle> nests = IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcObjectDefinition, "Nests");
          if (nests != null && nests.Count != 0)
@@ -533,11 +596,17 @@ protected override void Process(IFCAnyHandle ifcObjectDefinition)
             foreach (IFCAnyHandle hasAssociation in hasAssociations)
             {
                if (IFCAnyHandleUtil.IsSubTypeOf(hasAssociation, IFCEntityType.IfcRelAssociatesMaterial))
+               {
                   ProcessIFCRelAssociatesMaterial(hasAssociation);
+               }
                else if (IFCAnyHandleUtil.IsSubTypeOf(hasAssociation, IFCEntityType.IfcRelAssociatesClassification))
+               {
                   ProcessRelAssociatesClassification(hasAssociation);
+               }
                else
+               {
                   Importer.TheLog.LogUnhandledSubTypeError(hasAssociation, IFCEntityType.IfcRelAssociates, false);
+               }
             }
          }
 
@@ -792,10 +861,9 @@ private void SetName(Document doc, Element element, Category category)
             }
          }
 
-         string name = string.IsNullOrWhiteSpace(Name) ? "" : Name;
          // 2015: Revit links don't show the name of a selected item inside the link.
          // 2015: DirectShapes don't have a built-in "Name" parameter.
-         IFCPropertySet.AddParameterString(doc, element, category, this, IFCSharedParameters.IfcName, Name, Id);
+         ParametersToSet.AddStringParameter(doc, element, category, this, IFCSharedParameters.IfcName, Name, Id);
       }
 
       /// <summary>
@@ -810,9 +878,18 @@ private void SetDescription(Document doc, Element element, Category category)
          // If the element has the built-in ALL_MODEL_DESCRIPTION parameter, populate that also.
          // We will create/populate the parameter even if the description is empty or null.
          string description = string.IsNullOrWhiteSpace(Description) ? string.Empty : Description;
-         Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.ALL_MODEL_DESCRIPTION, description, true);
-         
-         IFCPropertySet.AddParameterString(doc, element, category, this, IFCSharedParameters.IfcDescription, description, Id);
+
+         IFCDefaultProcessor processor = Importer.TheProcessor as IFCDefaultProcessor;
+         if (processor != null)
+         {
+            processor.SetElementStringParameter(element, Id, BuiltInParameter.ALL_MODEL_DESCRIPTION, description, true, ParametersToSet);
+         }
+         else
+         {
+            Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.ALL_MODEL_DESCRIPTION, description, true);
+         }
+
+         ParametersToSet.AddStringParameter(doc, element, category, this, IFCSharedParameters.IfcDescription, description, Id);
       }
 
       /// <summary>
@@ -839,7 +916,7 @@ private void SetMaterialParameter(Document doc, Element element, Category catego
                materialNames += ";" + val;
          }
          if (materialNames != null)
-            IFCPropertySet.AddParameterString(doc, element, category, this, IFCSharedParameters.IfcMaterial, materialNames, Id);
+            ParametersToSet.AddStringParameter(doc, element, category, this, IFCSharedParameters.IfcMaterial, materialNames, Id);
       }
 
       /// <summary>
@@ -882,7 +959,7 @@ private void SetGroupsParameter(IList<IFCGroup> groups, string parameterName, Do
          if (category == null)
             return;
 
-         string groupNames = String.Empty;
+         string groupNames = string.Empty;
 
          foreach (IFCGroup group in groups)
          {
@@ -890,14 +967,14 @@ private void SetGroupsParameter(IList<IFCGroup> groups, string parameterName, Do
             if (string.IsNullOrWhiteSpace(name))
                continue;
 
-            if (!String.IsNullOrEmpty(groupNames))
+            if (!string.IsNullOrEmpty(groupNames))
                groupNames += ";";
             
             groupNames += name;
          }
 
-         if (!String.IsNullOrEmpty(groupNames))
-            IFCPropertySet.AddParameterString(doc, element, category, this, parameterName, groupNames, Id);
+         if (!string.IsNullOrEmpty(groupNames))
+            ParametersToSet.AddStringParameter(doc, element, category, this, parameterName, groupNames, Id);
       }
 
       /// <summary>
@@ -943,8 +1020,11 @@ protected virtual void CreateParametersInternal(Document doc, Element element)
          {
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
 
-            Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), CategoryId.Value, null);
-            
+            if (!Importer.IsDefaultProcessor())
+            {
+               Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), GetCategoryId(doc).Value, null);
+            }
+
             // Set the element name.
             SetName(doc, element, category);
 
@@ -957,11 +1037,20 @@ protected virtual void CreateParametersInternal(Document doc, Element element)
             // Set the "IfcSystem" and "IfcGroup" parameters.
             SetSystemAndGroupParameter(doc, element, category);
 
+            IFCDefaultProcessor processor = Importer.TheProcessor as IFCDefaultProcessor;
+
             bool elementIsType = (element is ElementType);
             if (!string.IsNullOrWhiteSpace(GlobalId))
             {
                BuiltInParameter ifcGUIDId = GetGUIDParameter(element, elementIsType);
-               Importer.TheProcessor.SetStringParameter(element, Id, ifcGUIDId, GlobalId, true);
+               if (processor != null)
+               {
+                  processor.SetElementStringParameter(element, Id, ifcGUIDId, GlobalId, true, ParametersToSet);
+               }
+               else
+               {
+                  Importer.TheProcessor.SetStringParameter(element, Id, ifcGUIDId, GlobalId, true);
+               }
             }
 
             // Set the built-in parameters.
@@ -969,21 +1058,35 @@ protected virtual void CreateParametersInternal(Document doc, Element element)
             if (!string.IsNullOrWhiteSpace(entityName))
             {
                BuiltInParameter ifcExportElementAsParam = elementIsType ? BuiltInParameter.IFC_EXPORT_ELEMENT_TYPE_AS : BuiltInParameter.IFC_EXPORT_ELEMENT_AS;
-               Importer.TheProcessor.SetStringParameter(element, Id, ifcExportElementAsParam, entityName, true);
+               if (processor != null)
+               {
+                  processor.SetElementStringParameter(element, Id, ifcExportElementAsParam, entityName, true, ParametersToSet);
+               }
+               else
+               {
+                  Importer.TheProcessor.SetStringParameter(element, Id, ifcExportElementAsParam, entityName, true);
+               }
             }
 
             if (!string.IsNullOrWhiteSpace(predefinedType))
             {
                BuiltInParameter ifcPredefinedTypeParam = elementIsType ? BuiltInParameter.IFC_EXPORT_PREDEFINEDTYPE_TYPE : BuiltInParameter.IFC_EXPORT_PREDEFINEDTYPE;
-               Importer.TheProcessor.SetStringParameter(element, Id, ifcPredefinedTypeParam, predefinedType, true);
+               if (processor != null)
+               {
+                  processor.SetElementStringParameter(element, Id, ifcPredefinedTypeParam, predefinedType, true, ParametersToSet);
+               }
+               else
+               {
+                  Importer.TheProcessor.SetStringParameter(element, Id, ifcPredefinedTypeParam, predefinedType, true);
+               }
             }
             // Set the IFCElementAssembly Parameter
             if (Decomposes != null)
             {
                string containerParamName = (Decomposes is IFCElementAssembly) ? "IfcElementAssembly" : "IfcDecomposes";
                string containerParamGUIDName = (Decomposes is IFCElementAssembly) ? "IfcElementAssemblyGUID" : "IfcDecomposesGUID";
-               IFCPropertySet.AddParameterString(doc, element, category, this, containerParamName, Decomposes.Name, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, containerParamGUIDName, Decomposes.GlobalId, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, containerParamName, Decomposes.Name, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, containerParamGUIDName, Decomposes.GlobalId, Id);
             }
 
             // Set additional parameters (if any), e.g. for Classification assignments
@@ -992,13 +1095,22 @@ protected virtual void CreateParametersInternal(Document doc, Element element)
                foreach (KeyValuePair<string, object> parItem in AdditionalIntParameters)
                {
                   if (parItem.Value is string)
-                     IFCPropertySet.AddParameterString(doc, element, category, this, parItem.Key, (string)parItem.Value, Id);
+                  {
+                     ParametersToSet.AddStringParameter(doc, element, category, this, parItem.Key, 
+                        (string)parItem.Value, Id);
+                  }
                   else if (parItem.Value is double)
-                     IFCPropertySet.AddParameterDouble(doc, element, category, this, parItem.Key, SpecTypeId.Custom, UnitTypeId.General, (double)parItem.Value, Id);
+                  {
+                     ParametersToSet.AddParameterDouble(doc, element, category, this, parItem.Key, SpecTypeId.Custom, UnitTypeId.General, (double)parItem.Value, Id);
+                  }
                   else if (parItem.Value is int)
-                     IFCPropertySet.AddParameterInt(doc, element, category, this, parItem.Key, (int)parItem.Value, Id);
+                  {
+                     ParametersToSet.AddParameterInt(doc, element, category, this, parItem.Key, (int)parItem.Value, Id);
+                  }
                   else if (parItem.Value is bool)
-                     IFCPropertySet.AddParameterBoolean(doc, element, category, this, parItem.Key, (bool)parItem.Value, Id);
+                  {
+                     ParametersToSet.AddParameterBoolean(doc, element, category, this, parItem.Key, (bool)parItem.Value, Id);
+                  }
                }
             }
          }
@@ -1015,12 +1127,16 @@ protected void CreateParameters(Document doc)
             return;
 
          // Create Revit parameters corresponding to IFC entity values, not in a property set.
-         CreateParametersInternal(doc, element);
+         using (ParameterSetter setter = new ParameterSetter())
+         {
+            ParametersToSet = setter.ParametersToSet;
+            CreateParametersInternal(doc, element);
 
-         // Now create parameters related to property sets.  Note we want to add the parameters above first,
-         // so we can use them for creating schedules in CreatePropertySets.
-         string propertySetsCreated = "";
-         CreatePropertySets(doc, element, propertySetsCreated);
+            // Now create parameters related to property sets.  Note we want to add the parameters above first,
+            // so we can use them for creating schedules in CreatePropertySets.
+            string propertySetsCreated = "";
+            CreatePropertySets(doc, element, propertySetsCreated);
+         }
       }
 
       /// <summary>
@@ -1048,15 +1164,14 @@ public static ElementId CreateElement(Document doc, IFCObjectDefinition objDef)
          {
             if ((createdElementId == ElementId.InvalidElementId) && objDef.IsValidForCreation)
             {
-               ElementId gstyleId;
-               objDef.CategoryId = IFCCategoryUtil.GetCategoryIdForEntity(doc, objDef, out gstyleId);
-               objDef.GraphicsStyleId = gstyleId;
-
                if (objDef is IFCObject)
                {
                   IFCObject asObject = objDef as IFCObject;
                   foreach (IFCTypeObject typeObject in asObject.TypeObjects)
-                     IFCObjectDefinition.CreateElement(doc, typeObject);
+                  {
+                     typeObject.CalculateCategoryAndGStyleIdsFromObject(doc, asObject);
+                     CreateElement(doc, typeObject);
+                  }
                }
 
                objDef.Create(doc);
@@ -1095,7 +1210,8 @@ protected void CreatePropertySetsBase(Document doc, Element element, string prop
             IFCParameterSetByGroup parameterGroupMap = IFCParameterSetByGroup.Create(element);
             foreach (IFCPropertySetDefinition propertySet in propertySets.Values)
             {
-               Tuple<string, bool> newPropertySetCreated = propertySet.CreatePropertySet(doc, element, this, parameterGroupMap);
+               Tuple<string, bool> newPropertySetCreated = propertySet.CreatePropertySet(doc, element, this, 
+                  parameterGroupMap, ParametersToSet);
                if (newPropertySetCreated == null || !newPropertySetCreated.Item2 || string.IsNullOrWhiteSpace(newPropertySetCreated.Item1))
                   continue;
 
@@ -1108,7 +1224,7 @@ protected void CreatePropertySetsBase(Document doc, Element element, string prop
          // Add property set-based parameters.
          // We are going to create this "fake" parameter so that we can filter elements in schedules based on their property sets.
          Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-         IFCPropertySet.AddParameterString(doc, element, category, this, propertySetListName, propertySetsCreated, Id);
+         ParametersToSet.AddStringParameter(doc, element, category, this, propertySetListName, propertySetsCreated, Id);
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCPhysicalComplexQuantity.cs b/Source/Revit.IFC.Import/Data/IFCPhysicalComplexQuantity.cs
index dd532703..36c89d14 100644
--- a/Source/Revit.IFC.Import/Data/IFCPhysicalComplexQuantity.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPhysicalComplexQuantity.cs
@@ -139,12 +139,15 @@ public static IFCPhysicalComplexQuantity ProcessIFCPhysicalComplexQuantity(IFCAn
       /// <param name="parameterGroupMap">The parameters.</param>
       /// <param name="quantityFullName">The name of the containing quantity set with quantity name.</param>
       /// <param name="createdParameters">The names of the created parameters.</param>
-      public override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters)
+      public override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters,
+         ParametersToSet parametersToSet)
       {
          foreach (IFCPhysicalQuantity quantity in HasQuantities)
          {
             string complexFullName = AppendComplexQuantityName(quantityFullName, quantity.Name);
-            quantity.Create(doc, element, category, objDef, parameterGroupMap, complexFullName, createdParameters);
+            quantity.Create(doc, element, category, objDef, parameterGroupMap, complexFullName, createdParameters,
+               parametersToSet);
          }
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCPhysicalQuantity.cs b/Source/Revit.IFC.Import/Data/IFCPhysicalQuantity.cs
index b7a7d683..9ca2779f 100644
--- a/Source/Revit.IFC.Import/Data/IFCPhysicalQuantity.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPhysicalQuantity.cs
@@ -112,6 +112,8 @@ public static IFCPhysicalQuantity ProcessIFCPhysicalQuantity(IFCAnyHandle ifcPhy
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <param name="quantityFullName">The name of the containing quantity set with quantity name.</param>
       /// <param name="createdParameters">The names of the created parameters.</param>
-      public abstract void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters);
+      public abstract void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters,
+         ParametersToSet parametersToSet);
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Data/IFCPhysicalSimpleQuantity.cs b/Source/Revit.IFC.Import/Data/IFCPhysicalSimpleQuantity.cs
index 12f4143c..21f78326 100644
--- a/Source/Revit.IFC.Import/Data/IFCPhysicalSimpleQuantity.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPhysicalSimpleQuantity.cs
@@ -141,7 +141,9 @@ public static IFCPhysicalSimpleQuantity ProcessIFCPhysicalSimpleQuantity(IFCAnyH
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <param name="quantityFullName">The name of the containing quantity set with quantity name.</param>
       /// <param name="createdParameters">The names of the created parameters.</param>
-      public override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters)
+      public override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, string quantityFullName, ISet<string> createdParameters,
+         ParametersToSet parametersToSet)
       {
          double baseValue = 0.0;
          IFCDataPrimitiveType type = Value.PrimitiveType;
@@ -194,7 +196,7 @@ public override void Create(Document doc, Element element, Category category, IF
                   specTypeId = IFCDataUtil.GetUnitTypeFromData(Value, SpecTypeId.Number);
                }
 
-               bool created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse, Id);
+               bool created = parametersToSet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse, Id);
                if (created)
                   createdParameters.Add(parameterName);
 
@@ -206,10 +208,10 @@ public override void Create(Document doc, Element element, Category category, IF
          switch (existingParameter.StorageType)
          {
             case StorageType.String:
-               existingParameter.Set(doubleValueToUse.ToString());
+               parametersToSet.AddStringParameter(existingParameter, doubleValueToUse.ToString());
                break;
             case StorageType.Double:
-               existingParameter.Set(doubleValueToUse);
+               parametersToSet.AddDoubleParameter(existingParameter, doubleValueToUse);
                break;
             default:
                setValue = false;
diff --git a/Source/Revit.IFC.Import/Data/IFCPort.cs b/Source/Revit.IFC.Import/Data/IFCPort.cs
index 4eb4c667..904211c6 100644
--- a/Source/Revit.IFC.Import/Data/IFCPort.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPort.cs
@@ -177,33 +177,33 @@ protected override void CreateParametersInternal(Document doc, Element element)
             {
                string guid = portOwner.GlobalId;
                if (!string.IsNullOrWhiteSpace(guid))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcElement ContainedIn IfcGUID", guid, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcElement ContainedIn IfcGUID", guid, Id);
 
                string name = portOwner.Name;
                if (!string.IsNullOrWhiteSpace(name))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcElement ContainedIn Name", name, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcElement ContainedIn Name", name, Id);
             }
 
             if (ConnectedFrom != null)
             {
                string guid = ConnectedFrom.GlobalId;
                if (!string.IsNullOrWhiteSpace(guid))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPort ConnectedFrom IfcGUID", guid, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPort ConnectedFrom IfcGUID", guid, Id);
 
                string name = ConnectedFrom.Name;
                if (!string.IsNullOrWhiteSpace(name))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPort ConnectedFrom Name", name, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPort ConnectedFrom Name", name, Id);
             }
 
             if (ConnectedTo != null)
             {
                string guid = ConnectedTo.GlobalId;
                if (!string.IsNullOrWhiteSpace(guid))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPort ConnectedTo IfcGUID", guid, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPort ConnectedTo IfcGUID", guid, Id);
 
                string name = ConnectedTo.Name;
                if (!string.IsNullOrWhiteSpace(name))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPort ConnectedTo Name", name, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPort ConnectedTo Name", name, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCProduct.cs b/Source/Revit.IFC.Import/Data/IFCProduct.cs
index c1d726fb..326d2785 100644
--- a/Source/Revit.IFC.Import/Data/IFCProduct.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProduct.cs
@@ -1,4 +1,4 @@
-//
+//
 // Revit IFC Import library: this library works with Autodesk(R) Revit(R) to import IFC files.
 // Copyright (C) 2013  Autodesk, Inc.
 // 
@@ -112,19 +112,9 @@ protected override void Process(IFCAnyHandle ifcProduct)
          IFCAnyHandle ifcProductRepresentation = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcProduct, "Representation");
          if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ifcProductRepresentation))
          {
-            // IFCRepresentationItem should know that it is processing something for Hybrid IFC Imports.
-            // Then it will create IFCHybridRepresentationItems, which are placeholders for body geometry created via AnyCAD.
-            // This is so data for Representation Item will still exist, even if legacy geometry does not.
-            if ((Importer.TheOptions.IsHybridImport) && (Importer.TheHybridInfo?.HybridMap?.ContainsKey(GlobalId) ?? false))
-            {
-               Importer.TheHybridInfo.RepresentationsAlreadyCreated = true;
-            }
-
-            ProductRepresentation = IFCProductRepresentation.ProcessIFCProductRepresentation(ifcProductRepresentation);
-
-            if ((Importer.TheOptions.IsHybridImport) && (Importer.TheHybridInfo?.RepresentationsAlreadyCreated ?? false))
-            {
-               Importer.TheHybridInfo.RepresentationsAlreadyCreated = false;
+            using (RepresentationsAlreadyCreatedSetter setter = new RepresentationsAlreadyCreatedSetter(GlobalId))
+            { 
+               ProductRepresentation = IFCProductRepresentation.ProcessIFCProductRepresentation(ifcProductRepresentation);
             }
          }
       }
@@ -188,14 +178,14 @@ protected override void CreateParametersInternal(Document doc, Element element)
             }
 
             if (ifcPresentationLayer != null)
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPresentationLayer", ifcPresentationLayer, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcPresentationLayer", ifcPresentationLayer, Id);
 
             // Set the container name of the element.
             string containerName = ContainingStructure?.Name;
             if (containerName != null)
             {
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcSpatialContainer", containerName, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcSpatialContainer GUID", ContainingStructure.GlobalId, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcSpatialContainer", containerName, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcSpatialContainer GUID", ContainingStructure.GlobalId, Id);
             }
          }
       }
@@ -308,6 +298,18 @@ protected override bool CutSolidByVoids(IFCSolidInfo solidInfo)
          return true;
       }
 
+      private Transform CalculateLocalCoordinateSystem()
+      {
+         Transform lcs = IFCImportFile.TheFile.IFCProject.WorldCoordinateSystem;
+         if (lcs == null)
+            return ObjectLocation?.TotalTransform ?? Transform.Identity;
+
+         if (ObjectLocation != null)
+            return lcs.Multiply(ObjectLocation.TotalTransform);
+
+         return lcs;
+      }
+
       /// <summary>
       /// Creates or populates Revit elements based on the information contained in this class.
       /// </summary>
@@ -362,28 +364,10 @@ protected override void Create(Document doc)
             // IFCImportShapeEditScope will not create Body geometry for Hybrid IFC Import, but it may need to create other geometry.
             using (IFCImportShapeEditScope shapeEditScope = IFCImportShapeEditScope.Create(doc, this))
             {
-               shapeEditScope.GraphicsStyleId = GraphicsStyleId;
-               shapeEditScope.CategoryId = CategoryId;
+               Transform lcs = CalculateLocalCoordinateSystem();
+
                shapeEditScope.PreventInstances = preventInstances;
                
-               // The name can be added as well. but it is usually less useful than 'oid'
-               string myId = GlobalId; // + "(" + Name + ")";
-
-               Transform lcs = IFCImportFile.TheFile.IFCProject.WorldCoordinateSystem;
-               if (lcs == null)
-                  lcs = (ObjectLocation != null) ? ObjectLocation.TotalTransform : Transform.Identity;
-               else if (ObjectLocation != null)
-                  lcs = lcs.Multiply(ObjectLocation.TotalTransform);
-
-               // If we are not applying transforms to the geometry, then pass in the identity matrix.
-               // Lower down this method we then pass lcs to the consumer element, so that it can apply
-               // the transform as required.
-               Transform transformToUse = Importer.TheProcessor.ApplyTransforms ? lcs : Transform.Identity;
-               if (Importer.TheOptions.IsHybridImport && (Importer.TheHybridInfo != null))
-               {
-                  transformToUse = transformToUse.Multiply(Importer.TheHybridInfo.LargeCoordinateTransform);
-               }
-
                // Hybrid Import only:   An IfcProduct whose DirectShape will be a container might not have a DirectShape created yet.
                // If this is the case, create an empty DirectShape for the container.
                // If so, create an empty DirectShape to hold container Geometry.
@@ -395,11 +379,22 @@ protected override void Create(Document doc)
                      Importer.TheLog.LogComment(Id, $"Creating Empty Container for {GlobalId}:{CreatedElementId}", false);
                   }
                }
-               
-               // For Hybrid Import Containers, there may be the possibility that there is no valid top-level Geometry.  In that
-               // case, don't create the ProductRepresentation.
+
                if (HasValidTopLevelGeometry())
                {
+                  // If we are not applying transforms to the geometry, then pass in the identity matrix.
+                  // Lower down this method we then pass lcs to the consumer element, so that it can apply
+                  // the transform as required.
+                  Transform transformToUse = Importer.TheProcessor.ApplyTransforms ? lcs : Transform.Identity;
+                  if (Importer.TheOptions.IsHybridImport && (
+                     Importer.TheHybridInfo != null))
+                  {
+                     transformToUse.Origin += Importer.TheHybridInfo.LargeCoordinateOriginOffset;
+                  }
+
+                  // The name can be added as well. but it is usually less useful than 'oid'
+                  string myId = GlobalId; // + "(" + Name + ")";
+
                   ProductRepresentation.CreateProductRepresentation(shapeEditScope, transformToUse, myId);
                }
 
@@ -407,14 +402,13 @@ protected override void Create(Document doc)
                // geometry, but it will contain parameters that are needed for the DirectShape imported for Hybrid IFC Import.
                if (Importer.TheOptions.IsHybridImport && GlobalId != null)
                {
-                  // "Create" a DirectShape Element.
-                  // This is for those Elements imported via the ATF Pipeline, or for those Elements created above simply to hold an empty container.
-                  ElementId hybridElementId = ElementId.InvalidElementId;
-                  if (Importer.TheHybridInfo?.HybridMap?.TryGetValue(GlobalId, out hybridElementId) ?? false)
+                  if ((Importer.TheHybridInfo?.HybridMap?.TryGetValue(GlobalId, out ElementId hybridElementId) ?? false) &&
+                     hybridElementId != ElementId.InvalidElementId)
                   {
-                     // If GlobalId is in the HybridMap, handle Hybrid Product Creation from Hybrid Import.
+                     // "Create" a DirectShape Element.
+                     // This is for those Elements imported via the ATF Pipeline, or for those Elements created above simply to hold an empty container.
+                     CreatedGeometry = Importer.TheHybridInfo.HandleHybridProductCreation(shapeEditScope, this, ref hybridElementId);
                      CreatedElementId = hybridElementId;
-                     CreatedElementId = Importer.TheHybridInfo.HandleHybridProductCreation(shapeEditScope, this);
                   }
                }
 
@@ -443,7 +437,9 @@ protected override void Create(Document doc)
                         DirectShape shape = Importer.TheCache.UseElementByGUID<DirectShape>(doc, GlobalId);
 
                         if (shape == null)
-                           shape = IFCElementUtil.CreateElement(doc, CategoryId, GlobalId, null, Id, EntityType);
+                        {
+                           shape = IFCElementUtil.CreateElement(doc, GetCategoryId(doc), GlobalId, null, Id, EntityType);
+                        }
 
                         List<GeometryObject> directShapeGeometries = new List<GeometryObject>();
                         foreach (IFCSolidInfo geometryObject in Solids)
diff --git a/Source/Revit.IFC.Import/Data/IFCProject.cs b/Source/Revit.IFC.Import/Data/IFCProject.cs
index 9ea19f8f..e3c94caa 100644
--- a/Source/Revit.IFC.Import/Data/IFCProject.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProject.cs
@@ -215,30 +215,39 @@ protected override void Process(IFCAnyHandle ifcProjectHandle)
                               // we should probably augment Processor.AddParameter to ensure that CreateOrUpdateElement
                               // is called before anything is attempted to be added.  This is a special case, though,
                               // as in Revit we don't actually create an element for the IfcProject.
-                              Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), CategoryId.Value, null);
+                              if (!Importer.IsDefaultProcessor())
+                              {
+                                 Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), GetCategoryId(doc).Value, null);
+                              }
 
                               Category category = IFCPropertySet.GetCategoryForParameterIfValid(projectInfo, Id);
-                              IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.Name", geoRefName, Id);
-                              if (!string.IsNullOrEmpty(desc))
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.Description", desc, Id);
-                              if (!string.IsNullOrEmpty(geodeticDatum))
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.GeodeticDatum", geodeticDatum, Id);
-                              if (!string.IsNullOrEmpty(verticalDatum))
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.VerticalDatum", verticalDatum, Id);
-                              if (!string.IsNullOrEmpty(mapProj))
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapProjection", mapProj, Id);
-                              if (!string.IsNullOrEmpty(mapZone))
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapZone", mapZone, Id);
-                              if (!IFCAnyHandleUtil.IsNullOrHasNoValue(mapUnit))
+
+                              using (ParameterSetter setter = new ParameterSetter())
                               {
-                                 IFCUnit mapUnitIfc = IFCUnit.ProcessIFCUnit(mapUnit);
-                                 string unitStr = UnitUtils.GetTypeCatalogStringForUnit(mapUnitIfc.Unit);
-                                 IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapUnit", unitStr, Id);
-                                 double convFactor = UnitUtils.Convert(1.0, mapUnitIfc.Unit, IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length).Unit);
-                                 eastings = convFactor * eastings;
-                                 northings = convFactor * northings;
-                                 orthogonalHeight = convFactor * orthogonalHeight;
-                                 geoRef = new XYZ(eastings, northings, orthogonalHeight);
+                                 ParametersToSet parametersToSet = setter.ParametersToSet;
+                                 parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.Name", geoRefName, Id);
+                                 if (!string.IsNullOrEmpty(desc))
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.Description", desc, Id);
+                                 if (!string.IsNullOrEmpty(geodeticDatum))
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.GeodeticDatum", geodeticDatum, Id);
+                                 if (!string.IsNullOrEmpty(verticalDatum))
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.VerticalDatum", verticalDatum, Id);
+                                 if (!string.IsNullOrEmpty(mapProj))
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.MapProjection", mapProj, Id);
+                                 if (!string.IsNullOrEmpty(mapZone))
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.MapZone", mapZone, Id);
+
+                                 if (!IFCAnyHandleUtil.IsNullOrHasNoValue(mapUnit))
+                                 {
+                                    IFCUnit mapUnitIfc = IFCUnit.ProcessIFCUnit(mapUnit);
+                                    string unitStr = UnitUtils.GetTypeCatalogStringForUnit(mapUnitIfc.Unit);
+                                    parametersToSet.AddStringParameter(doc, projectInfo, category, this, "IfcProjectedCRS.MapUnit", unitStr, Id);
+                                    double convFactor = UnitUtils.Convert(1.0, mapUnitIfc.Unit, IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length).Unit);
+                                    eastings = convFactor * eastings;
+                                    northings = convFactor * northings;
+                                    orthogonalHeight = convFactor * orthogonalHeight;
+                                    geoRef = new XYZ(eastings, northings, orthogonalHeight);
+                                 }
                               }
                            }
                         }
diff --git a/Source/Revit.IFC.Import/Data/IFCProperty.cs b/Source/Revit.IFC.Import/Data/IFCProperty.cs
index a74c3b91..beb043c3 100644
--- a/Source/Revit.IFC.Import/Data/IFCProperty.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProperty.cs
@@ -24,6 +24,8 @@
 using Revit.IFC.Common.Utility;
 using Revit.IFC.Common.Enums;
 using Revit.IFC.Import.Utility;
+using Revit.IFC.Import.Core;
+using System.Runtime.Remoting;
 
 namespace Revit.IFC.Import.Data
 {
@@ -114,6 +116,18 @@ private bool IsValidParameterType(Parameter parameter, IFCDataPrimitiveType data
          return false;
       }
 
+      private bool AddStringTypeParameter(bool multilineTableProperty, Document doc, Element element, Category category,
+         IFCObjectDefinition objDef, string parameterName, string stringValueToUse, ParametersToSet parametersToSet)
+      {
+         if (multilineTableProperty)
+         {
+            return parametersToSet.AddParameterMultilineString(doc, element, category, objDef, parameterName,
+               stringValueToUse, Id);
+         }
+
+         return parametersToSet.AddStringParameter(doc, element, category, objDef, parameterName, stringValueToUse, Id);
+      }
+
       /// <summary>
       /// Create a property for a given element.
       /// </summary>
@@ -123,7 +137,9 @@ private bool IsValidParameterType(Parameter parameter, IFCDataPrimitiveType data
       /// <param name="parameterMap">The parameters of the element.  Cached for performance.</param>
       /// <param name="propertyFullName">The name of the containing property set.</param>
       /// <param name="createdParameters">The names of the created parameters.</param>
-      public void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string propertyFullName, ISet<string> createdParameters)
+      public void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, string propertyFullName, ISet<string> createdParameters,
+         ParametersToSet parametersToSet)
       {
          // Try to get the single value from the property.  If we can't get a single value, get it as a string.
          IFCPropertyValue propertyValueToUse = null;
@@ -258,25 +274,26 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
                case IFCDataPrimitiveType.String:
                case IFCDataPrimitiveType.Enumeration:
                case IFCDataPrimitiveType.Binary:
-                     created = multilineTableProperty ? IFCPropertySet.AddParameterMultilineString(doc, element, category, objDef, parameterName, stringValueToUse, Id):
-                                                        IFCPropertySet.AddParameterString(doc, element, category, objDef, parameterName, stringValueToUse, Id);
+                  created = AddStringTypeParameter(multilineTableProperty, doc, element, category,
+                     objDef, parameterName, stringValueToUse, parametersToSet);
                   break;
                case IFCDataPrimitiveType.Integer:
-                  created = IFCPropertySet.AddParameterInt(doc, element, category, objDef, parameterName, intValueToUse.Value, Id);
+                  created = parametersToSet.AddParameterInt(doc, element, category, objDef, parameterName, 
+                     intValueToUse.Value, Id);
                   break;
                case IFCDataPrimitiveType.Boolean:
-                  created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, boolValueToUse.Value, Id);
+                  created = parametersToSet.AddParameterBoolean(doc, element, category, objDef, parameterName, boolValueToUse.Value, Id);
                   break;
                case IFCDataPrimitiveType.Logical:
                   if (logicalValueToUse != IFCLogical.Unknown)
-                     created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, (logicalValueToUse == IFCLogical.True), Id);
+                     created = parametersToSet.AddParameterBoolean(doc, element, category, objDef, parameterName, (logicalValueToUse == IFCLogical.True), Id);
                   break;
                case IFCDataPrimitiveType.Number:
                case IFCDataPrimitiveType.Double:
-                  created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse.Value, Id);
+                  created = parametersToSet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse.Value, Id);
                   break;
                case IFCDataPrimitiveType.Instance:
-                  created = IFCPropertySet.AddParameterElementId(doc, element, category, objDef, parameterName, elementIdValueToUse, Id);
+                  created = parametersToSet.AddParameterElementId(doc, element, category, objDef, parameterName, elementIdValueToUse, Id);
                   break;
             }
 
@@ -286,7 +303,6 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
             return;
          }
 
-         bool couldSetValue = false;
          switch (existingParameter.StorageType)
          {
             case StorageType.String:
@@ -296,20 +312,20 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
                      case IFCDataPrimitiveType.String:
                      case IFCDataPrimitiveType.Enumeration:
                      case IFCDataPrimitiveType.Binary:
-                        couldSetValue = existingParameter.Set(stringValueToUse);
+                        parametersToSet.AddStringParameter(existingParameter, stringValueToUse);
                         break;
                      case IFCDataPrimitiveType.Integer:
-                        couldSetValue = existingParameter.Set(intValueToUse.Value.ToString());
+                        parametersToSet.AddStringParameter(existingParameter, intValueToUse.Value.ToString());
                         break;
                      case IFCDataPrimitiveType.Boolean:
-                        couldSetValue = existingParameter.Set(boolValueToUse.Value ? "True" : "False");
+                        parametersToSet.AddStringParameter(existingParameter, boolValueToUse.Value ? "True" : "False");
                         break;
                      case IFCDataPrimitiveType.Logical:
-                        couldSetValue = existingParameter.Set(logicalValueToUse.ToString());
+                        parametersToSet.AddStringParameter(existingParameter, logicalValueToUse.ToString());
                         break;
                      case IFCDataPrimitiveType.Number:
                      case IFCDataPrimitiveType.Double:
-                        couldSetValue = existingParameter.Set(doubleValueToUse.ToString());
+                        parametersToSet.AddStringParameter(existingParameter, doubleValueToUse.ToString());
                         break;
                      default:
                         break;
@@ -318,26 +334,23 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
                break;
             case StorageType.Integer:
                if (dataType == IFCDataPrimitiveType.Integer)
-                  couldSetValue = existingParameter.Set(intValueToUse.Value);
+                  parametersToSet.AddIntegerParameter(existingParameter, intValueToUse.Value);
                else if (dataType == IFCDataPrimitiveType.Boolean)
-                  couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0);
-               else if (dataType == IFCDataPrimitiveType.Logical)
-                  couldSetValue = (logicalValueToUse == IFCLogical.Unknown) ? true : existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0);
+                  parametersToSet.AddIntegerParameter(existingParameter, boolValueToUse.Value ? 1 : 0);
+               else if (dataType == IFCDataPrimitiveType.Logical && logicalValueToUse != IFCLogical.Unknown)
+                  parametersToSet.AddIntegerParameter(existingParameter, (logicalValueToUse == IFCLogical.True) ? 1 : 0);
                break;
             case StorageType.Double:
                if (dataType == IFCDataPrimitiveType.Double)
-                  couldSetValue = existingParameter.Set(doubleValueToUse.Value);
+                  parametersToSet.AddDoubleParameter(existingParameter, doubleValueToUse.Value);
                else if (dataType == IFCDataPrimitiveType.Integer)
-                  couldSetValue = existingParameter.Set(intValueToUse.Value);
+                  parametersToSet.AddDoubleParameter(existingParameter, intValueToUse.Value);
                else if (dataType == IFCDataPrimitiveType.Boolean)
-                  couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0);
+                  parametersToSet.AddDoubleParameter(existingParameter, boolValueToUse.Value ? 1 : 0);
                else if ((dataType == IFCDataPrimitiveType.Logical) && (logicalValueToUse != IFCLogical.Unknown))
-                  couldSetValue = existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0);
+                  parametersToSet.AddDoubleParameter(existingParameter, (logicalValueToUse == IFCLogical.True) ? 1 : 0);
                break;
          }
-
-         if (!couldSetValue)
-            Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false);
       }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Data/IFCPropertySet.cs b/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
index 34d08846..e5860da1 100644
--- a/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
@@ -105,289 +105,6 @@ private static bool IsDisallowedCategory(Category category)
          return false;
       }
 
-      public static Parameter AddParameterBase(Document doc, Element element, Category category, string parameterName, int parameterSetId, ForgeTypeId specId)
-      {
-         bool isElementType = (element is ElementType);
-         Definitions definitions = isElementType ? Importer.TheCache.TypeGroupDefinitions : Importer.TheCache.InstanceGroupDefinitions;
-
-         bool newlyCreated = false;
-         Definition definition = definitions.get_Item(parameterName);
-         if (definition == null)
-         {
-            ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions(parameterName, specId);
-            definition = definitions.Create(option);
-            if (definition == null)
-            {
-               Importer.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false);
-               return null;
-            }
-            newlyCreated = true;
-         }
-
-         Guid guid = (definition as ExternalDefinition).GUID;
-
-         Parameter parameter = null;
-         ElementBinding binding = null;
-         bool reinsert = false;
-
-         if (!newlyCreated)
-         {
-            BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
-            binding = bindingMap.get_Item(definition) as ElementBinding;
-            reinsert = (binding != null);
-         }
-
-         if (binding == null)
-         {
-            if (isElementType)
-               binding = new TypeBinding();
-            else
-               binding = new InstanceBinding();
-         }
-
-         // The binding can fail if we haven't identified a "bad" category above.  Use try/catch as a safety net.
-         try
-         {
-            if (!reinsert || !binding.Categories.Contains(category))
-            {
-               binding.Categories.Insert(category);
-
-               BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
-               if (reinsert)
-                  bindingMap.ReInsert(definition, binding, GroupTypeId.Ifc);
-               else
-                  bindingMap.Insert(definition, binding, GroupTypeId.Ifc);
-            }
-
-            parameter = element.get_Parameter(guid);
-         }
-         catch
-         {
-         }
-
-         if (parameter == null)
-            Importer.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false);
-
-         return parameter;
-      }
-
-      /// <summary>
-      /// Adds a parameter with the name of an element represented by an ElementId to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterElementId(Document doc, Element element, Category category, IFCObjectDefinition objDef, string parameterName, ElementId parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         Element parameterElement = doc.GetElement(parameterValue);
-         if (parameterElement == null)
-            return false;
-
-         string name = parameterElement.Name;
-         if (string.IsNullOrEmpty(name))
-            return false;
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(name);
-         return true;
-      }
-
-      /// <summary>
-      /// Add a Boolean parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterBoolean(Document doc, Element element, Category category, IFCObjectDefinition objDef, string parameterName, bool parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.Boolean.YesNo);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue ? 1 : 0);
-         return true;
-      }
-
-      /// <summary>
-      /// Add an int parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterInt(Document doc, Element element, Category category, IFCObjectDefinition objDef, string parameterName, int parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.Int.Integer);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue);
-         return true;
-      }
-
-      private static ForgeTypeId CalculateUnitsTypeId(ForgeTypeId unitsTypeId,
-         ForgeTypeId specTypeId)
-      {
-         if (unitsTypeId != null || Importer.TheProcessor.ScaleValues)
-            return unitsTypeId;
-
-         // We can look up the units when the values are not scaled.
-         var units = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(specTypeId);
-         return (units != null) ? units.Unit : UnitTypeId.General;
-      }
-   
-      /// <summary>
-      /// Add a double parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="specTypeId">Identifier of the parameter spec (e.g. length)</param>
-      /// <param name="unitsTypeId">Identifier of the unscaled parameter units (e.g. mm)</param>
-      /// <param name="parameterValue">The parameter value, scaled into document units.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterDouble(Document doc, Element element, Category category,
-         IFCObjectDefinition objDef, string parameterName, ForgeTypeId specTypeId, 
-         ForgeTypeId unitsTypeId, double parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         unitsTypeId = CalculateUnitsTypeId(unitsTypeId, specTypeId);
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, 
-            specTypeId, unitsTypeId, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, specTypeId);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue);
-         return true; 
-      }
-
-      /// <summary>
-      /// Add a string parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterString(Document doc, Element element, Category category, IFCObjectDefinition objDef, string parameterName, string parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue);
-         return true;
-      }
-
-      /// <summary>
-      /// Add a multistring parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterName">The parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterMultilineString(Document doc, Element element, Category category, IFCObjectDefinition objDef, string parameterName, string parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null)
-            return false;
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.MultilineText);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue);
-         return true;
-      }
-
-      /// <summary>
-      /// Add a string parameter to an element.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="objDef">The IFCObjectDefinition that created the element.</param>
-      /// <param name="name">The enum corresponding to the parameter name.</param>
-      /// <param name="parameterValue">The parameter value.</param>
-      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
-      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
-      public static bool AddParameterString(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCSharedParameters name, string parameterValue, int parameterSetId)
-      {
-         if (doc == null || element == null || category == null || objDef == null)
-            return false;
-
-         string parameterName = objDef.GetSharedParameterName(name, element is ElementType);
-
-         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
-         if (processedParameter.HasValue)
-            return processedParameter.Value;
-
-         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
-         if (parameter == null)
-            return false;
-
-         parameter.Set(parameterValue);
-         return true;
-      }
-
       public static Category GetCategoryForParameterIfValid(Element element, int id)
       {
          Category category = element.Category;
@@ -415,7 +132,8 @@ public static Category GetCategoryForParameterIfValid(Element element, int id)
       /// <param name="element">The element being created.</param>
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <returns>The name of the property set created, if it was created, and a Boolean value if it should be added to the property set list.</returns>
-      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap)
+      public override Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef,
+         IFCParameterSetByGroup parameterGroupMap, ParametersToSet parametersToSet)
       {
          Category category = GetCategoryForParameterIfValid(element, Id);
          if (category == null)
@@ -429,7 +147,8 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
             bool elementIsType = (element is ElementType);
             string typeString = elementIsType ? " " + Resources.IFCTypeSchedule : string.Empty;
             string fullName = CreatePropertyName(property.Name, typeString);
-            property.Create(doc, element, category, objDef, parameterGroupMap, fullName, parametersCreated);
+            property.Create(doc, element, category, objDef, parameterGroupMap, fullName, parametersCreated,
+               parametersToSet);
          }
 
          return Tuple.Create(quotedName, true);
diff --git a/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs b/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
index 015057c2..f291105a 100644
--- a/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
@@ -127,7 +127,8 @@ public static IFCPropertySetDefinition ProcessIFCPropertySetDefinition(IFCAnyHan
       /// <param name="element">The element being created.</param>
       /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
       /// <returns>The name of the property set created, if it was created, and a Boolean value if it should be added to the property set list.</returns>
-      public virtual Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap)
+      public virtual Tuple<string, bool> CreatePropertySet(Document doc, Element element, IFCObjectDefinition objDef, 
+         IFCParameterSetByGroup parameterGroupMap, ParametersToSet parametersToSet)
       {
          return new Tuple<string, bool>(null, false);
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCProxy.cs b/Source/Revit.IFC.Import/Data/IFCProxy.cs
index 0402ae54..d209cec9 100644
--- a/Source/Revit.IFC.Import/Data/IFCProxy.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProxy.cs
@@ -106,14 +106,14 @@ protected override void CreateParametersInternal(Document doc, Element element)
             string ifcTag = Tag;
             if (!string.IsNullOrWhiteSpace(ifcTag))
             {
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcTag", ifcTag, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcTag", ifcTag, Id);
             }
 
             // Set "ProxyType" parameter.
             string ifcProxyType = ProxyType;
             if (!string.IsNullOrWhiteSpace(ifcProxyType))
             {
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcProxyType", ifcProxyType, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcProxyType", ifcProxyType, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCRepresentation.cs b/Source/Revit.IFC.Import/Data/IFCRepresentation.cs
index 4c5986d5..78541c92 100644
--- a/Source/Revit.IFC.Import/Data/IFCRepresentation.cs
+++ b/Source/Revit.IFC.Import/Data/IFCRepresentation.cs
@@ -74,6 +74,24 @@ protected IFCRepresentation()
 
       }
 
+      /// <summary>
+      /// Determine if the IFCRepresentationMap only has at least 1 IFCHybridInformation.
+      /// </summary>
+      /// <returns>True if the IFCRepresentationMap only has at least 1 IFCHybridInformation.</returns>
+      public bool IsHybridOnly()
+      {
+         if ((RepresentationItems?.Count ?? 0) == 0)
+            return false;
+
+         foreach (IFCRepresentationItem item in RepresentationItems)
+         {
+            if (!(item is IFCHybridRepresentationItem))
+               return false;
+         }
+
+         return true;
+      }
+
       private IFCRepresentationIdentifier GetRepresentationIdentifier(string identifier, IFCAnyHandle ifcRepresentation)
       {
          if (Enum.TryParse(identifier, true, out IFCRepresentationIdentifier ifcRepresentationIdentifier))
@@ -139,19 +157,13 @@ override protected void Process(IFCAnyHandle ifcRepresentation)
       {
          base.Process(ifcRepresentation);
 
-         IFCAnyHandle representationContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentation, "ContextOfItems", false);
-         if (representationContext != null)
-            Context = IFCRepresentationContext.ProcessIFCRepresentationContext(representationContext);
-
          string identifier = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationIdentifier", null);
          Identifier = GetRepresentationIdentifier(identifier, ifcRepresentation);
 
-         RepresentationType = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationType", null);
+         LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(ifcRepresentation);
 
          HashSet<IFCAnyHandle> items =
-             IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcRepresentation, "Items");
-
-         LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(ifcRepresentation);
+            IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcRepresentation, "Items");
 
          if (items == null)
          {
@@ -195,10 +207,21 @@ override protected void Process(IFCAnyHandle ifcRepresentation)
                {
                   Importer.TheLog.LogError(item.StepId, ex.Message, false);
                }
+
                if (repItem != null)
                   RepresentationItems.Add(repItem);
             }
          }
+
+         // If we have a body representation and we have already gone through Hybrid, skip the rest of the work here.
+         if (Identifier == IFCRepresentationIdentifier.Body && (Importer.TheHybridInfo?.RepresentationsAlreadyCreated ?? false))
+            return;
+
+         IFCAnyHandle representationContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentation, "ContextOfItems", false);
+         if (representationContext != null)
+            Context = IFCRepresentationContext.ProcessIFCRepresentationContext(representationContext);
+
+         RepresentationType = IFCImportHandleUtil.GetOptionalStringAttribute(ifcRepresentation, "RepresentationType", null);
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCRepresentationItem.cs b/Source/Revit.IFC.Import/Data/IFCRepresentationItem.cs
index 45cf6e34..14ed537a 100644
--- a/Source/Revit.IFC.Import/Data/IFCRepresentationItem.cs
+++ b/Source/Revit.IFC.Import/Data/IFCRepresentationItem.cs
@@ -72,6 +72,10 @@ override protected void Process(IFCAnyHandle item)
 
          LayerAssignment = IFCPresentationLayerAssignment.GetTheLayerAssignment(item);
 
+         // Don't bother processing styled items we will never use.
+         if (this is IFCHybridRepresentationItem)
+            return;
+
          // IFC2x has a different representation for styled items which we don't support.
          ICollection<IFCAnyHandle> styledByItems = null;
          if (Importer.TheCache.StyledByItems.TryGetValue(item, out styledByItems))
@@ -213,7 +217,6 @@ public static IFCRepresentationItem ProcessIFCRepresentationItem(IFCAnyHandle if
 
          if (skipBodyGeometry)
          {
-            Importer.TheLog.LogComment(ifcRepresentationItem.Id, "Hybrid Import Adding Dummy IfcRepresentationItem, since geometry is already imported", true);
             return IFCHybridRepresentationItem.ProcessIFCHybridRepresentationItem(ifcRepresentationItem);
          }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs b/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
index 52ca8adc..dfcc3838 100644
--- a/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
+++ b/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
@@ -93,6 +93,15 @@ protected IFCRepresentationMap(IFCAnyHandle representationMap)
          Process(representationMap);
       }
 
+      /// <summary>
+      /// Determine if the IFCRepresentationMap only has at least 1 IFCHybridInformation.
+      /// </summary>
+      /// <returns>True if the IFCRepresentationMap only has at least 1 IFCHybridInformation.</returns>
+      public bool IsHybridOnly()
+      {
+         return MappedRepresentation?.IsHybridOnly() ?? false;
+      }
+
       /// <summary>
       /// Create geometry for a particular representation map.
       /// </summary>
@@ -168,7 +177,8 @@ public void CreateShape(IFCImportShapeEditScope shapeEditScope, Transform scaled
                   if (directShapeType == null)
                   {
                      string directShapeTypeName = Id.ToString();
-                     directShapeType = IFCElementUtil.CreateElementType(doc, directShapeTypeName, shapeEditScope.CategoryId, Id, null, EntityType);
+                     directShapeType = IFCElementUtil.CreateElementType(doc, directShapeTypeName, 
+                        shapeEditScope.CategoryId, Id, null, EntityType);
                      typeId = Id;
                   }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCSite.cs b/Source/Revit.IFC.Import/Data/IFCSite.cs
index 32a9cb4f..65c3bbf6 100644
--- a/Source/Revit.IFC.Import/Data/IFCSite.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSite.cs
@@ -434,6 +434,7 @@ public static void ProcessSiteLocations(Document doc, IList<IFCSite> sites)
       protected override void CreateParametersInternal(Document doc, Element element)
       {
          base.CreateParametersInternal(doc, element);
+
          string parameterName = "LandTitleNumber";
 
          // TODO: move this to new shared parameter names override function.
@@ -448,7 +449,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
             if (!string.IsNullOrWhiteSpace(landTitleNumber))
             {
                Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, parameterName, landTitleNumber, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, parameterName, landTitleNumber, Id);
             }
          }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCSpace.cs b/Source/Revit.IFC.Import/Data/IFCSpace.cs
index cd651eb0..4c9b96b0 100644
--- a/Source/Revit.IFC.Import/Data/IFCSpace.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSpace.cs
@@ -76,15 +76,15 @@ protected override void CreateParametersInternal(Document doc, Element element)
             Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
 
             // Set "ElevationWithFlooring" parameter.
-            IFCPropertySet.AddParameterDouble(doc, element, category, this, "ElevationWithFlooring", SpecTypeId.Length, UnitTypeId.Feet, ElevationWithFlooring, Id);
+            ParametersToSet.AddParameterDouble(doc, element, category, this, "ElevationWithFlooring", SpecTypeId.Length, UnitTypeId.Feet, ElevationWithFlooring, Id);
 
             // Set "PredefinedType" parameter.
             if (PredefinedType != null)
             {
                if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC4Obsolete))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "PredefinedType", PredefinedType, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "PredefinedType", PredefinedType, Id);
                else
-                  IFCPropertySet.AddParameterString(doc, element, category, this, "InteriorOrExteriorSpace", PredefinedType, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, "InteriorOrExteriorSpace", PredefinedType, Id);
             }
 
             // Set "IfcZone" parameter.
@@ -105,7 +105,7 @@ protected override void CreateParametersInternal(Document doc, Element element)
             }
 
             if (zoneNames != null)
-               IFCPropertySet.AddParameterString(doc, element, category, this, "IfcZone", zoneNames, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, "IfcZone", zoneNames, Id);
          }
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
index 6d1c120b..5076e455 100644
--- a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
@@ -120,20 +120,19 @@ protected override void CreateParametersInternal(Document doc, Element element)
       {
          base.CreateParametersInternal(doc, element);
 
+         if (element == null)
+            return;
 
-         if (element != null)
+         // Set "ObjectTypeOverride" parameter.
+         string longName = LongName;
+         if (!string.IsNullOrWhiteSpace(longName))
          {
-            // Set "ObjectTypeOverride" parameter.
-            string longName = LongName;
-            if (!string.IsNullOrWhiteSpace(longName))
-            {
-               string parameterName = "LongNameOverride";
-               if (element is ProjectInfo)
-                  parameterName = EntityType.ToString() + " " + parameterName;
+            string parameterName = "LongNameOverride";
+            if (element is ProjectInfo)
+               parameterName = EntityType.ToString() + " " + parameterName;
 
-               Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
-               IFCPropertySet.AddParameterString(doc, element, category, this, parameterName, longName, Id);
-            }
+            Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
+            ParametersToSet.AddStringParameter(doc, element, category, this, parameterName, longName, Id);
          }
       }
 
@@ -257,37 +256,37 @@ protected void CreatePostalParameters(Document doc, Element element, IFCPostalAd
             string typeName = EntityType.ToString() + " ";
 
             if (!string.IsNullOrWhiteSpace(postalAddress.Purpose))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "Purpose", postalAddress.Purpose, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "Purpose", postalAddress.Purpose, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.Description))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "Description", postalAddress.Description, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "Description", postalAddress.Description, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.UserDefinedPurpose))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "UserDefinedPurpose", postalAddress.UserDefinedPurpose, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "UserDefinedPurpose", postalAddress.UserDefinedPurpose, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.InternalLocation))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "InternalLocation", postalAddress.InternalLocation, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "InternalLocation", postalAddress.InternalLocation, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.PostalBox))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "PostalBox", postalAddress.PostalBox, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "PostalBox", postalAddress.PostalBox, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.Town))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "Town", postalAddress.Town, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "Town", postalAddress.Town, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.Region))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "Region", postalAddress.Region, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "Region", postalAddress.Region, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.PostalCode))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "PostalCode", postalAddress.PostalCode, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "PostalCode", postalAddress.PostalCode, Id);
 
             if (!string.IsNullOrWhiteSpace(postalAddress.Country))
-               IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "Country", postalAddress.Country, Id);
+               ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "Country", postalAddress.Country, Id);
 
             if (postalAddress.AddressLines != null)
             {
-               string jointAddress = String.Join(", ", postalAddress.AddressLines);
+               string jointAddress = string.Join(", ", postalAddress.AddressLines);
                if (!string.IsNullOrWhiteSpace(jointAddress))
-                  IFCPropertySet.AddParameterString(doc, element, category, this, typeName + "AddressLines", jointAddress, Id);
+                  ParametersToSet.AddStringParameter(doc, element, category, this, typeName + "AddressLines", jointAddress, Id);
             }
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCStyledItem.cs b/Source/Revit.IFC.Import/Data/IFCStyledItem.cs
index daadd2ba..3098fcbf 100644
--- a/Source/Revit.IFC.Import/Data/IFCStyledItem.cs
+++ b/Source/Revit.IFC.Import/Data/IFCStyledItem.cs
@@ -190,6 +190,11 @@ public IFCSurfaceStyle GetSurfaceStyle()
       /// <param name="doc">The document.</param>
       public void Create(IFCImportShapeEditScope shapeEditScope)
       {
+         // If we have an IFCHybridRepresentationItem, there's no reason to create the styled item, because
+         // we won't use it.
+         if (Item is IFCHybridRepresentationItem)
+            return;
+
          // TODO: support cut pattern id and cut pattern color.
          if (m_CreatedElementId != ElementId.InvalidElementId || !IsValidForCreation)
             return;
diff --git a/Source/Revit.IFC.Import/Data/IFCTypeObject.cs b/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
index 0c92586f..5eca2c71 100644
--- a/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
+++ b/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
@@ -120,6 +120,18 @@ protected override string GetPredefinedType(IFCAnyHandle ifcObjectDefinition)
          return null;
       }
 
+      /// <summary>
+      /// Get the category id for an object from another object.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="objDef">The other IFCObjectDefinition.</param>
+      /// <remarks>This is intended for IFCTypeObjects to have the same category id as their entities.</remarks>
+      public void CalculateCategoryAndGStyleIdsFromObject(Document doc, IFCObject obj)
+      {
+         CategoryIdCache = obj.GetCategoryId(doc);
+         GraphicsStyleIdCache = obj.GetGraphicsStyleId(doc);
+      }
+
       /// <summary>
       /// Processes IfcTypeObject attributes.
       /// </summary>
@@ -193,7 +205,7 @@ protected override void Create(Document doc)
 
             if (shapeType == null)
             {
-               shapeType = IFCElementUtil.CreateElementType(doc, GetVisibleName(), CategoryId, Id, GlobalId, EntityType);
+               shapeType = IFCElementUtil.CreateElementType(doc, GetVisibleName(), GetCategoryId(doc), Id, GlobalId, EntityType);
             }
             else
             {
diff --git a/Source/Revit.IFC.Import/Data/IFCTypeProduct.cs b/Source/Revit.IFC.Import/Data/IFCTypeProduct.cs
index 4918407b..47c37001 100644
--- a/Source/Revit.IFC.Import/Data/IFCTypeProduct.cs
+++ b/Source/Revit.IFC.Import/Data/IFCTypeProduct.cs
@@ -25,6 +25,7 @@
 using Revit.IFC.Common.Enums;
 using Revit.IFC.Common.Utility;
 using Revit.IFC.Import.Enums;
+using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import.Data
 {
@@ -115,37 +116,27 @@ protected override void Process(IFCAnyHandle ifcTypeProduct)
 
          Tag = IFCAnyHandleUtil.GetStringAttribute(ifcTypeProduct, "Tag");
 
-         // IFCRepresentationItem should know that it is processing something for Hybrid IFC Imports.
-         // Then it will create IFCHybridRepresentationItems, which are placeholders for body geometry created by AnyCAD.
-         // This is so data for Representation Item will still exist, even if legacy geometry does not.
-         if ((Importer.TheOptions.IsHybridImport) && (Importer.TheHybridInfo?.HybridMap?.ContainsKey(GlobalId) ?? false))
+         using (RepresentationsAlreadyCreatedSetter setter = new RepresentationsAlreadyCreatedSetter(GlobalId))
          {
-            Importer.TheHybridInfo.RepresentationsAlreadyCreated = true;
-         }
-
-         IList<IFCAnyHandle> representationMapsHandle = IFCAnyHandleUtil.GetAggregateInstanceAttribute<List<IFCAnyHandle>>(ifcTypeProduct, "RepresentationMaps");
-         if (representationMapsHandle != null && representationMapsHandle.Count > 0)
-         {
-            foreach (IFCAnyHandle representationMapHandle in representationMapsHandle)
+            IList<IFCAnyHandle> representationMapsHandle = IFCAnyHandleUtil.GetAggregateInstanceAttribute<List<IFCAnyHandle>>(ifcTypeProduct, "RepresentationMaps");
+            if (representationMapsHandle?.Count > 0)
             {
-               IFCRepresentationMap representationMap = IFCRepresentationMap.ProcessIFCRepresentationMap(representationMapHandle);
-               if (representationMap != null)
+               foreach (IFCAnyHandle representationMapHandle in representationMapsHandle)
                {
-                  RepresentationMaps.Add(representationMap);
-
-                  // Traditionally we would create a "dummy" DirectShapeType for each IfcRepresentationMap.  In the case where the IfcRepresentationMap is not used by another other IfcTypeProduct, 
-                  // we would like to stop creating the "dummy" DirectShapeType and store the geometry in the DirectShapeType associated with the IfcTypeProduct.  However, IfcRepresentationMap 
-                  // does not have an INVERSE relationship to its IfcTypeProduct(s), at least in IFC2x3.
-                  // As such, we keep track of the IfcRepresentationMaps that have the relationship described above for future correspondence.
-                  RegisterRepresentationMapWithTypeProject(representationMap, this);
+                  IFCRepresentationMap representationMap = IFCRepresentationMap.ProcessIFCRepresentationMap(representationMapHandle);
+                  if (representationMap != null)
+                  {
+                     RepresentationMaps.Add(representationMap);
+
+                     // Traditionally we would create a "dummy" DirectShapeType for each IfcRepresentationMap.  In the case where the IfcRepresentationMap is not used by another other IfcTypeProduct, 
+                     // we would like to stop creating the "dummy" DirectShapeType and store the geometry in the DirectShapeType associated with the IfcTypeProduct.  However, IfcRepresentationMap 
+                     // does not have an INVERSE relationship to its IfcTypeProduct(s), at least in IFC2x3.
+                     // As such, we keep track of the IfcRepresentationMaps that have the relationship described above for future correspondence.
+                     RegisterRepresentationMapWithTypeProject(representationMap, this);
+                  }
                }
             }
          }
-
-         if ((Importer.TheOptions.IsHybridImport) && (Importer.TheHybridInfo?.RepresentationsAlreadyCreated ?? false))
-         {
-            Importer.TheHybridInfo.RepresentationsAlreadyCreated = false;
-         }
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Import/Importer.cs b/Source/Revit.IFC.Import/Importer.cs
index be6f0a25..ca366fef 100644
--- a/Source/Revit.IFC.Import/Importer.cs
+++ b/Source/Revit.IFC.Import/Importer.cs
@@ -29,6 +29,7 @@
 using Revit.IFC.Import.Utility;
 using IFCImportOptions = Revit.IFC.Import.Utility.IFCImportOptions;
 using Revit.IFC.Import.Core;
+using static Revit.IFC.Import.Utility.IFCImportOptions;
 
 namespace Revit.IFC.Import
 {
@@ -99,8 +100,6 @@ public class Importer : IIFCImporterServer
 
       IFCImportLog m_ImportLog = null;
 
-      IFCImportHybridInfo m_ImportHybridInfo = null;
-
       private static HashSet<FailureDefinitionId> m_ImportPostedErrors = null;
 
       /// <summary>
@@ -155,6 +154,14 @@ static public IFCImportCache TheCache
          protected set { TheImporter.m_ImportCache = value; }
       }
 
+      /// <summary>
+      /// Determines if we are using the default (i.e., Revit) processor.
+      /// </summary>
+      /// <returns>True if we are using the default processor.</returns>
+      /// <remarks>This function can be used to short-circuit function calls that do unnecessary
+      /// work (e.g., creating custom sub-categories.)</remarks>
+      static public bool IsDefaultProcessor() { return TheProcessor is IFCDefaultProcessor; }
+
       static public IIFCFileProcessor TheProcessor { get => TheOptions?.Processor; }
 
       static public IFCImportHybridInfo TheHybridInfo { get; protected set; } = null;
@@ -188,7 +195,7 @@ public static Importer CreateImporter(Document originalDocument, string ifcFileN
          Importer importer = new Importer();
          TheImporter = importer;
          TheCache = IFCImportCache.Create(originalDocument, ifcFileName);
-         TheOptions = importer.m_ImportOptions = IFCImportOptions.Create(importOptions, ifcFileName);
+         TheOptions = importer.m_ImportOptions = IFCImportOptions.Create(importOptions, ifcFileName, originalDocument);
          TheLog = IFCImportLog.CreateLog(ifcFileName, "log.html", !TheOptions.DisableLogging);
          return importer;
       }
@@ -200,9 +207,33 @@ private Document LoadLinkDocument(Document originalDocument, string linkedFileNa
 
          Application application = originalDocument.Application;
 
+         Document doc = application.OpenDocumentFile(linkedFileName);
+         if (doc == null)
+         {
+            return null;
+         }
+
+         ProjectInfo projInfo = doc.ProjectInformation;
+         if (projInfo == null)
+         {
+            doc.Close();
+            return null;
+         }
+
+         // Check to see if the projInfo ImportMethod parameter equals the current method of import.
+         // If it does not, then update current method to match original method.
+         bool isHybridImport = false;
+         Parameter originalImportMethod = projInfo.LookupParameter(ImportMethodParameter);
+         if ((originalImportMethod?.StorageType ?? StorageType.None) == StorageType.String)
+         {
+            isHybridImport = Enum.TryParse(originalImportMethod.AsString(), true, out ImportMethod existingMethod) && 
+               existingMethod == ImportMethod.Hybrid;
+         }
+         TheOptions.IsHybridImport = isHybridImport;
+
          // We won't catch any exceptions here, yet.
          // There could be a number of reasons why this fails, to be investigated.
-         return application.OpenDocumentFile(linkedFileName);
+         return doc;
       }
 
       private Document CreateLinkDocument(Document originalDocument)
@@ -277,9 +308,10 @@ private Document CreateLinkDocument(Document originalDocument)
          return ifcDocument;
       }
 
-      private Document LoadOrCreateLinkDocument(Document originalDocument, string linkedFileName)
+      private (Document ifcDocument, bool doUpdate) LoadOrCreateLinkDocument(Document originalDocument, string linkedFileName)
       {
          Document ifcDocument = null;
+         bool doUpdate = true;
 
          try
          {
@@ -290,6 +322,7 @@ private Document LoadOrCreateLinkDocument(Document originalDocument, string link
             if (ifcDocument == null)
             {
                ifcDocument = CreateLinkDocument(originalDocument);
+               doUpdate = false;
             }
 
             if (ifcDocument == null)
@@ -300,10 +333,10 @@ private Document LoadOrCreateLinkDocument(Document originalDocument, string link
          finally
          {
             if(ifcDocument == null)
-               Importer.TheLog.LogError(-1, "Could not create document for cached IFC Revit file while importing: " + linkedFileName + ", aborting.", false);
+               TheLog.LogError(-1, "Could not create document for cached IFC Revit file while importing: " + linkedFileName + ", aborting.", false);
          }
 
-         return ifcDocument;
+         return (ifcDocument, doUpdate);
       }
 
       /// <summary>
@@ -355,7 +388,7 @@ private bool NeedsReload(Document doc, string originalIFCFileName)
          if (checkFileTimestamp)
          {
             // Ignore ticks - only needs to be accurate to the second, or 10,000,000 ticks.
-            Int64 diffTicks = infoIFC.LastWriteTimeUtc.Ticks - TheOptions.OriginalTimeStamp.Ticks;
+            long diffTicks = infoIFC.LastWriteTimeUtc.Ticks - TheOptions.OriginalTimeStamp.Ticks;
             if (diffTicks < 0 || diffTicks >= 10000000)
                return true;
          }
@@ -375,7 +408,7 @@ public static TransactionStatus StartReferenceIFCTransaction(Transaction transac
          TransactionStatus transactionStatus = transaction.GetStatus();
          if (transactionStatus == TransactionStatus.Started)
          {
-            TheLog.LogWarning(-1, "Attempting to start ReferenceIFC Transaction when already started", true);
+            TheLog.LogComment(-1, "Attempting to start ReferenceIFC Transaction when already started", true);
             return transactionStatus;
          }
 
@@ -462,13 +495,81 @@ private bool DocumentUpToDate(Document doc, string ifcFileName)
          return true;
       }
 
+      private void LogEndImportDetailed(Document ifcDocument)
+      {
+         if (!TheOptions.VerboseLogging || TheHybridInfo == null)
+            return;
+
+         TheLog.LogWarning(-1, "--- Hybrid IFC Import:  Start of Detailed Logging after Hybrid IFC Import. ---", false);
+         TheLog.LogWarning(-1, "Hybrid IFC Import:  If an IfcGuid does not appear in the following list, then it was processed entirely via legacy code.", false);
+         TheLog.LogWarning(-1, "Hybrid IFC Import:  If an IfcGuid is no longer in the Hybrid Map, but its ElementId is in the Elements to be deleted list, this is normal.", false);
+         TheHybridInfo.LogHybridMapDetailed();
+         TheHybridInfo.LogElementsToDeleteDetailed();
+         TheLog.LogWarning(-1, "--- Hybrid IFC Import:  End of Logging detailed Information after Hybrid IFC Import.---", false);
+
+         FilteredElementCollector collector = new FilteredElementCollector(ifcDocument);
+
+         List<Type> supportedElementTypes = new List<Type>() { typeof(DirectShape) };
+         ElementMulticlassFilter multiclassFilter = new ElementMulticlassFilter(supportedElementTypes);
+         collector.WherePasses(multiclassFilter);
+
+         int numDirectShapes = collector.GetElementCount();
+         if (numDirectShapes == 0)
+         {
+            ifcDocument.Application.WriteJournalComment("Hybrid IFC Import: No IFCProducts Imported.", false);
+         }
+         else if (numDirectShapes != (Importer.TheHybridInfo.HybridElements?.Count ?? 0))
+         {
+            ifcDocument.Application.WriteJournalComment("---- Hybrid IFC Import: Some DirectShapes processed within Revit. ---", false);
+
+            IList<Element> directShapeElements = collector.ToElements();
+            // This is inefficient, but we need to reliably get the IFCGuids
+
+            // HybridMap is for IFC GlobalId --> ElementId.  This is used for almost all of the Hybrid IFC Import processing.
+            // reverseLookup is for ElementId --> IFC GlobalId.  This is used to find the ElementId associated with a given IFC GlobalId (for logging purposes).
+            IDictionary<ElementId, string> reverseLookup = new Dictionary<ElementId, string>();
+            foreach (KeyValuePair<string, ElementId> pair in TheHybridInfo.HybridMap)
+            {
+               try
+               {
+                  ElementId elementId = pair.Value;
+                  string ifcGuid = pair.Key;
+                  reverseLookup.Add(pair.Value, pair.Key);
+               }
+               catch (ArgumentException ex)
+               {
+                  TheLog.LogWarning(-1, $"Duplicate ElementId found when reversing Hybrid Map for logging {ex.Message}", false);
+               }
+            }
+
+            // Log (into journal) IFC GlobalIds & ElementIds that were imported by AnyCAD or via Revit alone.
+            ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Count of DirectShapes imported via AnyCAD:  {Importer.TheHybridInfo.HybridElements.Count}", false);
+            foreach (Element element in directShapeElements)
+            {
+               string ifcGuid;
+               if (reverseLookup.TryGetValue(element.Id, out ifcGuid))
+               {
+                  ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: AnyCAD DirectShape (IFC GUID, ElementId): ({ifcGuid}, {element.Id})", false);
+               }
+            }
+
+            ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Count of DirectShapes falling back to Revit:  {numDirectShapes - Importer.TheHybridInfo.HybridElements.Count}", false);
+            foreach (Element element in directShapeElements)
+            {
+               if (reverseLookup.ContainsKey(element.Id))
+                  continue;
+               string ifcGuid = IFCGUIDUtil.GetGUID(element);
+               ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Fallback DirectShape (IFC GUID, ElementId): ({ifcGuid}, {element.Id})", false);
+            }
+         }
+      }
+
       /// <summary>
       /// Import an IFC file into a given document for Reference only.
       /// </summary>
       /// <param name="document">The host document for the import.</param>
       /// <param name="origFullFileName">The full file name of the document.</param>
-      /// <param name="options">The list of configurable options for this import.</param>
-      public void ReferenceIFC(Document document, string origFullFileName, IDictionary<String, String> options)
+      public void ReferenceIFC(Document document, string origFullFileName)
       {
          // We need to generate a local file name for all of the intermediate files (the log file, the cache file, and the shared parameters file).
          string localFileName = ImporterIFCUtils.GetLocalFileName(document, origFullFileName);
@@ -482,12 +583,17 @@ public void ReferenceIFC(Document document, string origFullFileName, IDictionary
             m_ImportLog = IFCImportLog.CreateLog(localFileName, "log.html", !m_ImportOptions.DisableLogging);
 
          Document originalDocument = document;
-         Document ifcDocument = null;
+         Document ifcDocument;
+         bool doUpdate = false;
+
          if (TheOptions.Action == IFCImportAction.Link)
          {
             string linkedFileName = IFCImportFile.GetRevitFileName(localFileName);
 
-            ifcDocument = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
+            // NOTE: This will update IsHybridImport if we are reloading an existing document - we will use
+            // whatever method we originally used.  If a user wants to switch, they will have to delete the
+            // cache file.  Do not use IsHybridImport before this call.
+            (ifcDocument, doUpdate) = LoadOrCreateLinkDocument(originalDocument, linkedFileName);
          }
          else
          {
@@ -532,7 +638,7 @@ public void ReferenceIFC(Document document, string origFullFileName, IDictionary
                }
                else
                {
-                  TheHybridInfo = m_ImportHybridInfo = new IFCImportHybridInfo(ifcDocument, localFileName);
+                  TheHybridInfo = new IFCImportHybridInfo(ifcDocument, localFileName, doUpdate);
                   if (TheHybridInfo != null)
                   {
                      BasePoint newSurveyPoint = BasePoint.GetSurveyPoint(ifcDocument);
@@ -540,7 +646,7 @@ public void ReferenceIFC(Document document, string origFullFileName, IDictionary
 
                      if (!newPosition.IsAlmostEqualTo(originalPosition))
                      {
-                        TheHybridInfo.LargeCoordinateTransform = Transform.CreateTranslation(newPosition - originalPosition);
+                        TheHybridInfo.LargeCoordinateOriginOffset = originalPosition - newPosition;
                      }
                   }
                }
@@ -565,73 +671,7 @@ public void ReferenceIFC(Document document, string origFullFileName, IDictionary
                theFile.EndImport(ifcDocument, localFileName);
 
                // Make sure to log detailed information after EndImport.
-               if (Importer.TheOptions.VerboseLogging && Importer.TheHybridInfo != null)
-               {
-                  Importer.TheLog.LogWarning(-1, "--- Hybrid IFC Import:  Start of Detailed Logging after Hybrid IFC Import. ---", false);
-                  Importer.TheLog.LogWarning(-1, "Hybrid IFC Import:  If an IfcGuid does not appear in the following list, then it was processed entirely via legacy code.", false);
-                  Importer.TheLog.LogWarning(-1, "Hybrid IFC Import:  If an IfcGuid is no longer in the Hybrid Map, but its ElementId is in the Elements to be deleted list, this is normal.", false);
-                  Importer.TheHybridInfo.LogHybridMapDetailed();
-                  Importer.TheHybridInfo.LogElementsToDeleteDetailed();
-                  Importer.TheLog.LogWarning(-1, "--- Hybrid IFC Import:  End of Logging detailed Information after Hybrid IFC Import.---", false);
-
-                  FilteredElementCollector collector = new FilteredElementCollector(ifcDocument);
-
-                  List<Type> supportedElementTypes = new List<Type>();
-                  supportedElementTypes.Add(typeof(DirectShape));
-                  ElementMulticlassFilter multiclassFilter = new ElementMulticlassFilter(supportedElementTypes);
-                  collector.WherePasses(multiclassFilter);
-
-                  int numDirectShapes = collector.GetElementCount();
-                  if (numDirectShapes == 0)
-                  {
-                     ifcDocument.Application.WriteJournalComment("Hybrid IFC Import: No IFCProducts Imported.", false);
-                  }
-                  else if (numDirectShapes != (Importer.TheHybridInfo.HybridElements?.Count ?? 0))
-                  {
-                     ifcDocument.Application.WriteJournalComment("---- Hybrid IFC Import: Some DirectShapes processed within Revit. ---", false);
-
-                     IList<Element> directShapeElements = collector.ToElements();
-                     // This is inefficient, but we need to reliably get the IFCGuids
-
-                     // HybridMap is for IFC GlobalId --> ElementId.  This is used for almost all of the Hybrid IFC Import processing.
-                     // reverseLookup is for ElementId --> IFC GlobalId.  This is used to find the ElementId associated with a given IFC GlobalId (for logging purposes).
-                     IDictionary<ElementId, String> reverseLookup = new Dictionary<ElementId, String>();
-                     foreach (KeyValuePair<String, ElementId> pair in Importer.TheHybridInfo.HybridMap)
-                     {
-                        try
-                        {
-                           ElementId elementId = pair.Value;
-                           string ifcGuid = pair.Key;
-                           reverseLookup.Add(pair.Value, pair.Key);
-                        }
-                        catch (ArgumentException ex)
-                        {
-                           Importer.TheLog.LogWarning(-1, $"Duplicate ElementId found when reversing Hybrid Map for logging {ex.Message}", false);
-                        }
-                     }
-
-                     // Log (into journal) IFC GlobalIds & ElementIds that were imported by AnyCAD or via Revit alone.
-                     ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Count of DirectShapes imported via AnyCAD:  {Importer.TheHybridInfo.HybridElements.Count}", false);
-                     foreach (Element element in directShapeElements)
-                     {
-                        String ifcGuid;
-                        if (reverseLookup.TryGetValue(element.Id, out ifcGuid))
-                        {
-                           ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: AnyCAD DirectShape (IFC GUID, ElementId): ({ifcGuid}, {element.Id})", false);
-                        }
-                     }
-
-                     ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Count of DirectShapes falling back to Revit:  {numDirectShapes - Importer.TheHybridInfo.HybridElements.Count}", false);
-                     foreach (Element element in directShapeElements)
-                     {
-                        if (reverseLookup.ContainsKey(element.Id))
-                           continue;
-                        string ifcGuid = IFCGUIDUtil.GetGUID(element);
-                        ifcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Fallback DirectShape (IFC GUID, ElementId): ({ifcGuid}, {element.Id})", false);
-                     }
-                  }
-               }
-
+               LogEndImportDetailed(ifcDocument);      
             }
 
             if (TheOptions.Action == IFCImportAction.Link)
@@ -656,7 +696,7 @@ public void ImportIFC(ImporterIFC importer)
 
          string fullIFCFileName = importer.FullFileName;
          IDictionary<string, string> options = importer.GetOptions();
-         TheOptions = m_ImportOptions = IFCImportOptions.Create(options, fullIFCFileName);
+         TheOptions = m_ImportOptions = IFCImportOptions.Create(options, fullIFCFileName, importer.Document);
 
          // An early check, based on the options set - if we are allowed to use an up-to-date existing file on disk, use it.
          try
@@ -673,7 +713,7 @@ public void ImportIFC(ImporterIFC importer)
             }
             else
             {
-               ReferenceIFC(importer.Document, fullIFCFileName, options);
+               ReferenceIFC(importer.Document, fullIFCFileName);
             }
          }
          catch (Exception ex)
@@ -690,6 +730,7 @@ public void ImportIFC(ImporterIFC importer)
             TheLog?.Close();
             TheLog = null;
             IFCImportFile.TheFile?.Close();
+            TheHybridInfo = null;
          }
       }
 
diff --git a/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs b/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
index 07f8954e..7ada9475 100644
--- a/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
+++ b/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
@@ -1,7 +1,9 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 using Autodesk.Revit.DB;
 using Revit.IFC.Import.Core;
+using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import
 {
@@ -60,7 +62,8 @@ public bool PostProcessProduct(int ifcId,
          return null;
       }
 
-      public void SetStringParameter(Element element, int objDefId, BuiltInParameter parameterId, string value, bool allowUnfound)
+      public void SetElementStringParameter(Element element, int objDefId, BuiltInParameter parameterId, string value, 
+         bool allowUnfound, ParametersToSet parametersToSet)
       {
          Parameter parameter = element?.get_Parameter(parameterId);
          if (parameter == null)
@@ -82,7 +85,13 @@ public void SetStringParameter(Element element, int objDefId, BuiltInParameter p
             return;
          }
 
-         parameter.Set(value);
+         parametersToSet.AddStringParameter(parameter, value);
+      }
+
+      public void SetStringParameter(Element element, int objDefId, BuiltInParameter parameterId, string value, bool allowUnfound)
+      {
+         // No longer used.
+         return;
       }
 
       public bool PostProcessRepresentationMap(int typeId, 
diff --git a/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
index ed08b54f..7946176e 100644
--- a/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
@@ -12,8 +12,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.0.22")]
-[assembly: AssemblyFileVersion("24.1.0.22")]
+[assembly: AssemblyVersion("24.1.1.0")]
+[assembly: AssemblyFileVersion("24.1.1.0")]
 #endif
 
 #region Using directives
diff --git a/Source/Revit.IFC.Import/Revit.IFC.Import.csproj b/Source/Revit.IFC.Import/Revit.IFC.Import.csproj
index 0771fdb4..ef25bbdd 100644
--- a/Source/Revit.IFC.Import/Revit.IFC.Import.csproj
+++ b/Source/Revit.IFC.Import/Revit.IFC.Import.csproj
@@ -269,6 +269,7 @@
     <Compile Include="Utility\IFCParameterSetByGroup.cs" />
     <Compile Include="Utility\IFCSolidInfo.cs" />
     <Compile Include="Utility\IFCUnitUtil.cs" />
+    <Compile Include="Utility\ParametersToSet.cs" />
     <Compile Include="Utility\ProcessIFCRelation.cs" />
     <Compile Include="Utility\TessellatedShapeBuilderScope.cs" />
   </ItemGroup>
diff --git a/Source/Revit.IFC.Import/Utility/IFCCategoryUtil.cs b/Source/Revit.IFC.Import/Utility/IFCCategoryUtil.cs
index 419a102f..1d86652a 100644
--- a/Source/Revit.IFC.Import/Utility/IFCCategoryUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCCategoryUtil.cs
@@ -396,10 +396,14 @@ private static void InitEntityTypeToCategoryMaps()
          m_EntityTypeToCategory[IFCEntityType.IfcAirToAirHeatRecovery] = BuiltInCategory.OST_MechanicalEquipment;
          m_EntityTypeToCategory[IFCEntityType.IfcAirToAirHeatRecoveryType] = BuiltInCategory.OST_MechanicalEquipment;
          m_EntityTypeToCategory[IFCEntityType.IfcAlarmType] = BuiltInCategory.OST_GenericModel;
-         m_EntityTypeToCategory[IFCEntityType.IfcAlignment] = BuiltInCategory.OST_Alignments;
-         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentHorizontal] = BuiltInCategory.OST_Alignments;
-         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentSegment] = BuiltInCategory.OST_Alignments;
-         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentVertical] = BuiltInCategory.OST_Alignments;
+
+         // NOTE: We do have BuiltInCategory.OST_Alignments, and you can create a DirectShape of that type, but the
+         // Alignment update code isn't very happy about it.  So we will map to generic model for now.
+         m_EntityTypeToCategory[IFCEntityType.IfcAlignment] = BuiltInCategory.OST_GenericModel;
+         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentHorizontal] = BuiltInCategory.OST_GenericModel;
+         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentSegment] = BuiltInCategory.OST_GenericModel;
+         m_EntityTypeToCategory[IFCEntityType.IfcAlignmentVertical] = BuiltInCategory.OST_GenericModel;
+         
          m_EntityTypeToCategory[IFCEntityType.IfcAnnotation] = BuiltInCategory.OST_GenericModel;
          m_EntityTypeToCategory[IFCEntityType.IfcAudioVisualAppliance] = BuiltInCategory.OST_AudioVisualDevices;
          m_EntityTypeToCategory[IFCEntityType.IfcAudioVisualApplianceType] = BuiltInCategory.OST_AudioVisualDevices;
@@ -432,8 +436,8 @@ private static void InitEntityTypeToCategoryMaps()
          m_EntityTypeToCategory[IFCEntityType.IfcControllerType] = BuiltInCategory.OST_SpecialityEquipment;
          m_EntityTypeToCategory[IFCEntityType.IfcCovering] = BuiltInCategory.OST_GenericModel;
          m_EntityTypeToCategory[IFCEntityType.IfcCoveringType] = BuiltInCategory.OST_GenericModel;
-         m_EntityTypeToCategory[IFCEntityType.IfcCurtainWall] = BuiltInCategory.OST_CurtaSystem;
-         m_EntityTypeToCategory[IFCEntityType.IfcCurtainWallType] = BuiltInCategory.OST_CurtaSystem;
+         m_EntityTypeToCategory[IFCEntityType.IfcCurtainWall] = BuiltInCategory.OST_Walls;
+         m_EntityTypeToCategory[IFCEntityType.IfcCurtainWallType] = BuiltInCategory.OST_Walls;
          m_EntityTypeToCategory[IFCEntityType.IfcDamper] = BuiltInCategory.OST_DuctAccessory;
          m_EntityTypeToCategory[IFCEntityType.IfcDamperType] = BuiltInCategory.OST_DuctAccessory;
          m_EntityTypeToCategory[IFCEntityType.IfcDiscreteAccessory] = BuiltInCategory.OST_SpecialityEquipment;
@@ -526,7 +530,11 @@ private static void InitEntityTypeToCategoryMaps()
          m_EntityTypeToCategory[IFCEntityType.IfcRampType] = BuiltInCategory.OST_Ramps;
          m_EntityTypeToCategory[IFCEntityType.IfcRampFlight] = BuiltInCategory.OST_Ramps;
          m_EntityTypeToCategory[IFCEntityType.IfcRampFlightType] = BuiltInCategory.OST_Ramps;
-         m_EntityTypeToCategory[IFCEntityType.IfcReferent] = BuiltInCategory.OST_Alignments;
+
+         // NOTE: We do have BuiltInCategory.OST_Alignments, and you can create a DirectShape of that type, but the
+         // Alignment update code isn't very happy about it.  So we will map to generic model for now.
+         m_EntityTypeToCategory[IFCEntityType.IfcReferent] = BuiltInCategory.OST_GenericModel;
+
          m_EntityTypeToCategory[IFCEntityType.IfcReinforcingBar] = BuiltInCategory.OST_Rebar;
          m_EntityTypeToCategory[IFCEntityType.IfcReinforcingBarType] = BuiltInCategory.OST_Rebar;
          m_EntityTypeToCategory[IFCEntityType.IfcReinforcingMesh] = BuiltInCategory.OST_FabricAreas;
@@ -702,7 +710,7 @@ private static bool InitFromFile()
             if (string.IsNullOrWhiteSpace(ifcClassName))
                continue;
             IFCEntityType ifcClassType;
-            if (!Enum.TryParse<IFCEntityType>(ifcClassName, true, out ifcClassType))
+            if (!Enum.TryParse(ifcClassName, true, out ifcClassType))
             {
                Importer.TheLog.LogWarning(-1, "Unknown class name in IFC entity to category mapping file: " + ifcClassName, true);
                continue;
diff --git a/Source/Revit.IFC.Import/Utility/IFCElementUtil.cs b/Source/Revit.IFC.Import/Utility/IFCElementUtil.cs
index 6bd79821..2ad2d024 100644
--- a/Source/Revit.IFC.Import/Utility/IFCElementUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCElementUtil.cs
@@ -153,7 +153,7 @@ static public DirectShapeType CreateElementType(Document doc, string name, Eleme
       {
          DirectShapeTypeOptions options = new DirectShapeTypeOptions();
          options.AllowDuplicateNames = true;
-         ElementId validCategoryId = IFCElementUtil.GetDSValidCategoryId(doc, categoryId, id);
+         ElementId validCategoryId = GetDSValidCategoryId(doc, categoryId, id);
          DirectShapeType directShapeType = DirectShapeType.Create(doc, name, validCategoryId, options);
          Importer.TheCache.CreatedDirectShapeTypes[id] = directShapeType.Id;
 
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportCache.cs b/Source/Revit.IFC.Import/Utility/IFCImportCache.cs
index a96921e7..62e8d676 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportCache.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportCache.cs
@@ -173,6 +173,17 @@ public BindingMap GetParameterBinding(Document doc)
       /// </summary>
       public IDictionary<string, ElementId> GridNameToElementMap { get; } = new Dictionary<string, ElementId>();
 
+      /// <summary>
+      /// The view plane type if, if ViewPlanTypeIdInitialized is true and we found one.
+      /// </summary>
+      public ElementId ViewPlanTypeId { get; set; } = ElementId.InvalidElementId;
+
+      /// <summary>
+      /// Returns true if we have tried to set ViewPlanTypeId.  ViewPlanTypeId may or may not have a valid value.
+      /// </summary>
+      public bool ViewPlanTypeIdInitialized { get; set; } = false;
+
+
       private bool HavePreProcessedGrids { get; set; } = false;
 
       /// <summary>
@@ -220,11 +231,13 @@ public void CreateExistingElementMaps(Document document)
 
          // These are the only element types currently created in .NET code.  This list needs to be updated when a new
          // type is created.
-         List<Type> supportedElementTypes = new List<Type>();
-         supportedElementTypes.Add(typeof(DirectShape));
-         supportedElementTypes.Add(typeof(DirectShapeType));
-         supportedElementTypes.Add(typeof(Level));
-         supportedElementTypes.Add(typeof(Grid));
+         List<Type> supportedElementTypes = new List<Type>()
+         {
+            typeof(DirectShape),
+            typeof(DirectShapeType),
+            typeof(Level),
+            typeof(Grid)
+         };
 
          ElementMulticlassFilter multiclassFilter = new ElementMulticlassFilter(supportedElementTypes);
          collector.WherePasses(multiclassFilter);
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportHybridInfo.cs b/Source/Revit.IFC.Import/Utility/IFCImportHybridInfo.cs
index 6807b936..e6c46d7e 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportHybridInfo.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportHybridInfo.cs
@@ -32,9 +32,41 @@
 namespace Revit.IFC.Import.Utility
 {
    /// <summary>
-   /// Provide methods to perform Hybrid IFC Import.
+   /// A helper class to set and unset RepresentationsAlreadyCreated, with the "using" keyword.
    /// </summary>
-   public class IFCImportHybridInfo
+   public class RepresentationsAlreadyCreatedSetter : IDisposable
+   {
+      /// <summary>
+      /// The constructor.
+      /// </summary>
+      /// <param name="guid">The GUID to check.</param>
+      public RepresentationsAlreadyCreatedSetter(string guid)
+      {
+         // IFCRepresentationItem should know that it is processing something for Hybrid IFC Imports.
+         // Then it will create IFCHybridRepresentationItems, which are placeholders for body geometry created via AnyCAD.
+         // This is so data for Representation Item will still exist, even if legacy geometry does not.
+         if (Importer.TheHybridInfo?.HybridMap?.ContainsKey(guid) ?? false)
+         {
+            Importer.TheHybridInfo.RepresentationsAlreadyCreated = true;
+         }
+      }
+
+      /// <summary>
+      /// The Dispose method.
+      /// </summary>
+      public void Dispose()
+      {
+         if (Importer.TheHybridInfo != null)
+         {
+            Importer.TheHybridInfo.RepresentationsAlreadyCreated = false;
+         }
+      }
+   }
+
+/// <summary>
+/// Provide methods to perform Hybrid IFC Import.
+/// </summary>
+public class IFCImportHybridInfo
    {
       /// <summary>
       /// Keeps track of Elements imported (DirectShape/DirectShapeTypes) by AnyCAD
@@ -75,9 +107,9 @@ public class IFCImportHybridInfo
       public string IfcInputFile { get; set; } = null;
 
       /// <summary>
-      /// Transform applied to all Elements created via open-source processing within Revit.
+      /// Origin offset applied to all Elements created via legacy processing within Revit.
       /// </summary>
-      public Transform LargeCoordinateTransform { get; set; } = Transform.Identity;
+      public XYZ LargeCoordinateOriginOffset { get; set; } = XYZ.Zero;
 
       /// <summary>
       /// Keeps track of one-to-many mapping of entities that will result in container to sub-Element relationships.
@@ -91,7 +123,13 @@ public class IFCImportHybridInfo
       /// </summary>
       private IFCHybridImport HybridImporter { get; set; } = null;
 
-      public IFCImportHybridInfo(Document ifcDocument, string ifcInputFile)
+      /// <summary>
+      /// Create a new IFCImportHybridInfo.
+      /// </summary>
+      /// <param name="ifcDocument">The document that will contain elements created by AnyCAD.</param>
+      /// <param name="ifcInputFile">The IFC file to import.</param>
+      /// <param name="doUpdate">If true, update an existing document (don't recreate elements).</param>
+      public IFCImportHybridInfo(Document ifcDocument, string ifcInputFile, bool doUpdate)
       {
          HybridImporter = new IFCHybridImport();
 
@@ -110,17 +148,16 @@ public IFCImportHybridInfo(Document ifcDocument, string ifcInputFile)
 
          // Import Elements
          //
-         int? elementsImported = ImportElements();
+         int? elementsImported = ImportElements(doUpdate);
          if (elementsImported == null)
          {
-            IfcDocument.Application.WriteJournalComment("Hybrid IFC Import: elementsImportedList = null -- reverting to fallback for entire import.", false);
             Importer.TheLog.LogError(-1, "Hybrid IFC Import:  Unknown Error during Element Import -- aborting", true);
             return;
          }
 
          if (elementsImported == 0)
          {
-            IfcDocument.Application.WriteJournalComment("Hybrid IFC Import: elementsImportedList empty -- reverting to fallback for entire import.", false);
+            Importer.TheLog.LogError(-1, "Hybrid IFC Import:  elementsImportedList empty -- reverting to fallback for entire import.", false);
             return;
          }
 
@@ -129,7 +166,6 @@ public IFCImportHybridInfo(Document ifcDocument, string ifcInputFile)
          int? associationsPerformed = AssociateElementsWithIFCGuids();
          if (associationsPerformed == null)
          {
-            IfcDocument.Application.WriteJournalComment("Hybrid IFC Import: Hybrid IFC Map null -- falling back to Revit for entire import.", false);
             Importer.TheLog.LogError(-1, "Hybrid IFC Import:  Unknown Error during Element / IFC Guid association.", true);
             return;
          }
@@ -137,15 +173,17 @@ public IFCImportHybridInfo(Document ifcDocument, string ifcInputFile)
          // Not an error, but this may hinder the Import Later.
          if (associationsPerformed != elementsImported)
          {
-            IfcDocument.Application.WriteJournalComment("Hybrid IFC Import: Count of Elements in map differs from elements Imported -- falling back to Revit for part of import.", false);
             Importer.TheLog.LogWarning(-1, "Hybrid IFC Import:  Number of Element / IFC Guid associations do not match number of imported Elements.", false);
          }
 
-         Importer.TheLog.LogComment(-1, "--- Hybrid IFC Import:  Start of Logging detailed Information about AnyCAD Import ---", false);
-         Importer.TheLog.LogComment(-1, "Hybrid IFC Import:  If an IfcGuid does not appear in the following list, then it will fallback to Revit processing ---", false);
-         LogImportedElementsDetailed();
-         LogHybridMapDetailed();
-         Importer.TheLog.LogComment(-1, "--- Hybrid IFC Import: End of Logging detailed Information about AnyCAD Import ---", false);
+         if (Importer.TheOptions.VerboseLogging)
+         {
+            Importer.TheLog.LogComment(-1, "--- Hybrid IFC Import:  Start of Logging detailed Information about AnyCAD Import ---", false);
+            Importer.TheLog.LogComment(-1, "Hybrid IFC Import:  If an IfcGuid does not appear in the following list, then it will fallback to Revit processing ---", false);
+            LogImportedElementsDetailed();
+            LogHybridMapDetailed();
+            Importer.TheLog.LogComment(-1, "--- Hybrid IFC Import: End of Logging detailed Information about AnyCAD Import ---", false);
+         }
       }
 
       /// <summary>
@@ -228,7 +266,7 @@ public void LogHybridMapDetailed ()
       /// <summary>
       /// Log ElementIds that will be deleted at the end of Import.  These is populated when Revit must create a new DirectShape for a category change.
       /// </summary>
-      public void LogElementsToDeleteDetailed ()
+      public void LogElementsToDeleteDetailed()
       {
          Importer.TheLog.LogComment(-1, "--- Hybrid IFC Import: Start Elements to be deleted Details. ---", false);
          foreach (ElementId elementId in ElementsToDelete)
@@ -254,16 +292,14 @@ public void LogElementsToDeleteDetailed ()
       }
 
       /// <summary>
-      /// Import Elements from IFC File using AnyCAD.
-      /// Imported Elements will be in the HybridElements data member.
+      /// Import Elements from IFC File using AnyCAD.  Imported Elements will be in the HybridElements data member.
       /// </summary>
-      /// <returns>Number of Elements returned.</returns>
-      /// <exception cref="InvalidOperationException"></exception>
-      public int? ImportElements()
+      /// <returns>The number of elements created.</returns>
+      public int? ImportElements(bool update)
       {
          if (HybridImporter == null)
          {
-            throw new InvalidOperationException("Attempting to import elements with null IFCHybridImporter");
+            throw new ArgumentNullException("Attempting to import elements with null IFCHybridImporter");
          }
 
          if (IfcDocument == null)
@@ -278,11 +314,33 @@ public void LogElementsToDeleteDetailed ()
             return null;
          }
 
-         HybridElements = HybridImporter.ImportElements(IfcDocument, IfcInputFile);
+         if (update)
+         {
+            //IFC Extension back - compatibility:
+            //HybridImporter.UpdateElements method available since Revit 2024.1, handle it for addin usage with the previous Revit versions.
+            //
+            try
+            {
+               TryToUpdateElements();
+            }
+            catch(MissingMethodException)
+            {
+               HybridElements = HybridImporter.ImportElements(IfcDocument, IfcInputFile);
+            }
+         }
+         else
+         {
+            HybridElements = HybridImporter.ImportElements(IfcDocument, IfcInputFile);
+         }
 
          return HybridElements?.Count;
       }
 
+      private void TryToUpdateElements()
+      {
+         HybridElements = HybridImporter.UpdateElements(IfcDocument, IfcInputFile);
+      }
+
       /// <summary>
       /// Associate ElementIds with IFCGuids.  In other words, populate the IFCGuid --> ElementId map.
       /// </summary>
@@ -326,15 +384,13 @@ public void LogElementsToDeleteDetailed ()
             {
                HybridMap.Add(ifcGuid, elementId);
             }
-            catch (ArgumentException ex)
+            catch (ArgumentException)
             {
                Importer.TheLog.LogWarning(-1, "Duplicate IFC Global Ids. This will cause some IFC entities to fallback to Revit processing.", false);
-               IfcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Duplicate IFC GUIDs detected in Hybrid IFC Map.  Exception message = {ex.Message}", false);
             }
-            catch (Exception ex)
+            catch (Exception)
             {
                Importer.TheLog.LogWarning(-1, "Error in adding items to IFC GUID-to-ElementId map. This will cause some IFC entities to fallback to Revit processing.", false);
-               IfcDocument.Application.WriteJournalComment($"Hybrid IFC Import: Exception adding items to IFC GUID-to-ElementId map.  Exception message = {ex.Message}", false);
             }
          }
          return HybridMap?.Count;
@@ -384,14 +440,15 @@ public ElementId CreateEmptyContainer(IFCProduct ifcProduct)
             return ElementId.InvalidElementId;
          }
 
-         // If Container is already in HybridMAp, DirectShape has already been created.
+         // If Container is already in HybridMap, DirectShape has already been created.
          ElementId containerElementId;
          if (HybridMap.TryGetValue(ifcProduct.GlobalId, out containerElementId))
          {
             return containerElementId;
          }
 
-         DirectShape emptyContainerDS = IFCElementUtil.CreateElement(IfcDocument, ifcProduct.CategoryId, ifcProduct.GlobalId, null, ifcProduct.Id, ifcProduct.EntityType);
+         DirectShape emptyContainerDS = IFCElementUtil.CreateElement(IfcDocument, ifcProduct.GetCategoryId(IfcDocument),
+            ifcProduct.GlobalId, null, ifcProduct.Id, ifcProduct.EntityType);
          if (emptyContainerDS == null)
          {
             return ElementId.InvalidElementId;
@@ -424,7 +481,8 @@ public ElementId CreateContainer(IFCGroup ifcGroup)
             return ElementId.InvalidElementId;
          }
 
-         DirectShape directShape = DirectShape.CreateElement(IfcDocument, IFCElementUtil.GetDSValidCategoryId(IfcDocument, ifcGroup.CategoryId, ifcGroup.Id));
+         ElementId categoryId = IFCElementUtil.GetDSValidCategoryId(IfcDocument, ifcGroup.GetCategoryId(IfcDocument), ifcGroup.Id);
+         DirectShape directShape = DirectShape.CreateElement(IfcDocument, categoryId);
          if (directShape == null)
          {
             return ElementId.InvalidElementId;
@@ -467,142 +525,109 @@ public ElementId CreateContainer(IFCGroup ifcGroup)
       ///    empty
       /// </summary>
       /// <param name="objectDefinition">Entity that may exhibit special-case behavior.</param>
+      /// <param name="hybridElementId">The element id of the existing DirectShape.</param>
       /// <returns>ElementId of new DirectShape if new Element created, ElementId.InvalidElement otherwise.</returns>
-      public ElementId CreateElementForSpecialCases(IFCObjectDefinition objectDefinition)
+      private void UpdateElementForSpecialCases(IFCObjectDefinition objectDefinition, ref ElementId hybridElementId)
       {
          if (objectDefinition == null)
          {
             Importer.TheLog.LogNullError(objectDefinition.EntityType);
-            return ElementId.InvalidElementId;
+            return;
          }
 
-         ElementId newElementId = ElementId.InvalidElementId;
-         // Special Cases:
-         // 1. Columns that should be Structure Columns.
-         // 2. Containers that have sub-elements.
+         // Special Case: columns that should be structural columns.
          if (IFCCategoryUtil.IsSpecialColumnCase(objectDefinition))
          {
-            newElementId = (objectDefinition is IFCProduct architecturalColumn) ? CreateStructuralColumnDirectShape(architecturalColumn) : ElementId.InvalidElementId;
-         }
-         else if (objectDefinition.IsHybridImportContainer())
-         {
-            newElementId = (objectDefinition is IFCProduct container) ? CreateContainer(container) : ElementId.InvalidElementId;
-         }
+            if (objectDefinition is IFCProduct architecturalColumn)
+            {
+               try
+               {
+                  UpdateStructuralColumnDirectShape(architecturalColumn, hybridElementId);
+               }
+               catch (MissingMethodException)
+               {
+                  ElementId specialCaseElementId = CreateStructuralColumnDirectShape(architecturalColumn, hybridElementId);
 
-         // If special case processing resulted in an error, or did not change the ElementId, there is no need to replace
-         // the old ElementId with a new one.
-         if ((newElementId != ElementId.InvalidElementId) && (newElementId != objectDefinition.CreatedElementId))
-         {
-            ReplaceElementId(objectDefinition.GlobalId, objectDefinition.CreatedElementId, newElementId);
+                  if ((specialCaseElementId != ElementId.InvalidElementId) && (specialCaseElementId != hybridElementId))
+                  {
+                     ElementId hybridElementIdToDelete = new ElementId(hybridElementId.Value);
+                     // specialCaseElementId has replaced hybridElementId in the HybridMap.
+                     // The hybridElementId will be deleted later.
+                     Importer.TheHybridInfo.ElementsToDelete.Add(hybridElementIdToDelete);
+                     hybridElementId = specialCaseElementId;
+                  }
+               }
+            }
          }
-
-         return newElementId;
       }
 
       /// <summary>
-      /// Populate Container DirectShape Element with sub-Element Geometry.
-      /// This will not actually create the DirectShape.  The DirectShape should already exist and be within the HybridMap.
+      /// Update a DirectShape and its type to be a Structural Column.
       /// </summary>
-      /// <param name="containerProduct">IFCProduct representing the Container.</param>
-      /// <returns>ElementId of the DirectShape if successful, ElementId.InvalidElementId otherwise.</returns>
-      protected ElementId CreateContainer(IFCProduct containerProduct)
+      /// <param name="ifcColumn">Column that needs a Category change from OST_Column to OST_StructuralColumn.</param>
+      private void UpdateStructuralColumnDirectShape(IFCProduct ifcColumn, ElementId hybridElementId)
       {
-         // If nothing is in the HybridMap, just return.  Nothing needs to be done.
-         if ((containerProduct == null) || ((HybridMap?.Count ?? 0) == 0))
+         if (ifcColumn == null)
          {
-            Importer.TheLog.LogNullError(containerProduct.EntityType);
+            Importer.TheLog.LogError(-1, "IfcColumn invalid during DirectShape recategorization.", false);
+            return;
          }
 
-         int stepId = containerProduct.Id;
-         string containerGuid = containerProduct.GlobalId;
-         ElementId containerCategoryId = containerProduct.CategoryId;
-         if ((stepId < 1) || string.IsNullOrEmpty(containerGuid) || (containerCategoryId == ElementId.InvalidElementId))
+         int stepId = ifcColumn.Id;
+         ElementId ifcColumnCategory = ifcColumn.GetCategoryId(IfcDocument);
+         if (ifcColumnCategory != new ElementId(BuiltInCategory.OST_StructuralColumns))
          {
-            Importer.TheLog.LogError(stepId, "Cannot create Container Geometry for IfcProduct -- invalid entity", false);
-            return ElementId.InvalidElementId;
+            Importer.TheLog.LogWarning(stepId, "IfcColumn is not a Structural Column", false);
+            return;
          }
 
-         if (HybridMap == null)
+         DirectShape directShape = IfcDocument.GetElement(hybridElementId) as DirectShape;
+         ElementId directShapeCategory = (directShape?.Category?.Id ?? ElementId.InvalidElementId);
+         if (directShapeCategory == ElementId.InvalidElementId)
          {
-            Importer.TheLog.LogWarning(stepId, $"No Sub-elements imported for {containerProduct.GlobalId} via Hybrid.  Nothing to reference", false);
-            return ElementId.InvalidElementId;
+            Importer.TheLog.LogWarning(stepId, "Unable to determine Category of DirectShape.", false);
+            return;
          }
 
-         IList<GeometryObject> newGeometryObjects = new List<GeometryObject>();
-
-         // If there is any Geometry already within the DirectShape (there may be an Axis Curve for an IfcWall, for instance,
-         // add it to the Shape used at the end.  This will overwrite the current Geometry.
-         ElementId containerDirectShapeElementId = ElementId.InvalidElementId;
-         if (!HybridMap.TryGetValue(containerGuid, out containerDirectShapeElementId))
+         if (directShapeCategory == ifcColumnCategory)
          {
-            return ElementId.InvalidElementId;
+            Importer.TheLog.LogComment(stepId, "Category of Column and DirectShape agree. No recategorization needed.", false);
+            return;
          }
 
-         DirectShape containerDirectShape = IfcDocument.GetElement(containerDirectShapeElementId) as DirectShape;
-         if (containerDirectShape == null)
-         {
-            return ElementId.InvalidElementId;
-         }
+         //IFC Extension back-compatibility:
+         //ImporterIFCUtils.UpdateDirectShapeCategory method available since Revit 2024.1, handle it for addin usage with the previous Revit versions.
+         //Handle this with using CreateStructuralColumnDirectShape instead by catching MissingMethodExseption in UpdateElementForSpecialCases.
+         //
 
-         Options options = new Options();
-         GeometryElement oldContainerGeometryElement = containerDirectShape?.get_Geometry(options);
-         if (oldContainerGeometryElement != null)
+         ImporterIFCUtils.UpdateDirectShapeCategory(directShape, new ElementId(BuiltInCategory.OST_StructuralColumns));
+
+         (IList<GeometryObject> newGeomObjects, ElementId directShapeTypeId) =
+            DuplicateGeometryForDirectShape(directShape, ifcColumn);
+         if ((newGeomObjects?.Count ?? 0) == 0)
          {
-            foreach (GeometryObject geomObj in oldContainerGeometryElement)
-            {
-               if (geomObj != null)
-               {
-                  newGeometryObjects.Add(geomObj);
-               }
-            }
+            Importer.TheLog.LogError(stepId, "Unable to duplicate Geometry for DirectShape recategorization.", false);
+            return;
          }
 
-         // Iterate through all the sub-elements.
-         HashSet<IFCObjectDefinition> relatedObjects = null;
-         if (!(ContainerMap?.TryGetValue(stepId, out relatedObjects) ?? false))
+         GeometryInstance newDirectShapeGeometryInstance = newGeomObjects.First() as GeometryInstance;
+         if (newDirectShapeGeometryInstance == null)
          {
-            Importer.TheLog.LogComment(stepId, $"No Related Objects for Container {containerProduct.GlobalId}.", false);
-            return ElementId.InvalidElementId;
+            Importer.TheLog.LogWarning(stepId, "Duplicate Geometry is not a GeometryInstance.  Using old Geometry.", false);
+            return;
          }
 
-         foreach (IFCObjectDefinition relatedObject in relatedObjects)
+         ElementId directShapeGeomTypeId = newDirectShapeGeometryInstance.GetSymbolGeometryId().SymbolId;
+         if (directShapeGeomTypeId == ElementId.InvalidElementId)
          {
-            // Get the DirectShape for each sub-element.  It should be there.
-            ElementId subElementId;
-            if (!HybridMap.TryGetValue(relatedObject.GlobalId, out subElementId))
-            {
-               Importer.TheLog.LogWarning(stepId, $"{relatedObject.GlobalId} is not an Aggregate of {containerProduct.GlobalId}", false);
-               continue;
-            }
-
-            DirectShape subElementDirectShape = IfcDocument.GetElement(subElementId) as DirectShape;
-            if (subElementDirectShape == null)
-            {
-               continue;
-            }
-
-            // Duplicate sub-Element Geometry using the Category of the Container Geometry.
-            IList<GeometryObject> newSubElementGeometries = DuplicateGeometryForDirectShape(subElementDirectShape, containerProduct);
-            if ((newSubElementGeometries?.Count ?? 0) == 0)
-            {
-               Importer.TheLog.LogError(stepId, "Unable to duplicate Geometry for DirectShape recategorization.", false);
-               return ElementId.InvalidElementId;
-            }
-
-            // Reference new sub-Element Geometry.
-            GeometryInstance newSubElementGeometryInstance = newSubElementGeometries.First() as GeometryInstance; ;
-            if (newSubElementGeometryInstance == null)
-            {
-               Importer.TheLog.LogWarning(stepId, "Duplicate Geometry is not a GeometryInstance.  Using old Geometry.", false);
-               return ElementId.InvalidElementId;
-            }
-
-            newGeometryObjects.Add(newSubElementGeometryInstance);
+            Importer.TheLog.LogWarning(stepId, "Even though new DirectShape Geometry created, unable to find DirectShapeType.", false);
+            return;
          }
 
-         // Set the Geometry of the containerDirectShape to newGeometryObjects.
-         containerDirectShape.SetShape(newGeometryObjects);
-         return containerDirectShape.Id;
+         directShape.SetShape(newGeomObjects);
+
+         if (directShapeTypeId == directShapeGeomTypeId)
+            directShape.SetTypeId(directShapeGeomTypeId);
       }
 
       /// <summary>
@@ -611,7 +636,7 @@ protected ElementId CreateContainer(IFCProduct containerProduct)
       /// <preconditions></preconditions>
       /// <param name="ifcColumn">Column that needs a Category change from OST_Column to OST_StructuralColumn.</param>
       /// <returns>ElementId of new Structural Column for successful creation, ElementId.InvalidElementId otherwise.</returns>
-      protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
+      private ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn, ElementId hybridElementId)
       {
          if (ifcColumn == null)
          {
@@ -620,15 +645,14 @@ protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
          }
 
          int stepId = ifcColumn.Id;
-         ElementId ifcColumnCategory = ifcColumn.CategoryId;
+         ElementId ifcColumnCategory = ifcColumn.GetCategoryId(IfcDocument);
          if (ifcColumnCategory != new ElementId(BuiltInCategory.OST_StructuralColumns))
          {
             Importer.TheLog.LogWarning(stepId, "IfcColumn is not a Structural Column", false);
             return ElementId.InvalidElementId;
          }
 
-         ElementId oldDirectShapeElementId = ifcColumn.CreatedElementId;
-         DirectShape oldDirectShape = IfcDocument.GetElement(oldDirectShapeElementId) as DirectShape;
+         DirectShape oldDirectShape = IfcDocument.GetElement(hybridElementId) as DirectShape;
          ElementId oldDirectShapeCategory = (oldDirectShape?.Category?.Id ?? ElementId.InvalidElementId);
          if (oldDirectShapeCategory == ElementId.InvalidElementId)
          {
@@ -643,7 +667,8 @@ protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
          }
 
          // Perform Deep copy of Geometry and DirectShapeTypes.
-         IList<GeometryObject> newGeomObjects = DuplicateGeometryForDirectShape(oldDirectShape, ifcColumn);
+         (IList<GeometryObject> newGeomObjects, ElementId directShapeTypeId)
+            = DuplicateGeometryForDirectShape(oldDirectShape, ifcColumn);
          if ((newGeomObjects?.Count ?? 0) == 0)
          {
             Importer.TheLog.LogError(stepId, "Unable to duplicate Geometry for DirectShape recategorization.", false);
@@ -657,15 +682,14 @@ protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
             return ElementId.InvalidElementId;
          }
 
-         ElementId directShapeTypeId = newDirectShapeGeometryInstance.GetSymbolGeometryId().SymbolId;
+         directShapeTypeId = newDirectShapeGeometryInstance.GetSymbolGeometryId().SymbolId;
          if (directShapeTypeId == ElementId.InvalidElementId)
          {
             Importer.TheLog.LogWarning(stepId, "Even though new DirectShape Geometry created, unable to find DirectShapeType.", false);
             return ElementId.InvalidElementId;
          }
 
-         IList<GeometryObject> structuralColumnGeometry = new List<GeometryObject>();
-         structuralColumnGeometry.Add(newDirectShapeGeometryInstance);
+         IList<GeometryObject> structuralColumnGeometry = new List<GeometryObject>() { newDirectShapeGeometryInstance };
 
          DirectShape newDirectShape = IFCElementUtil.CreateElement(IfcDocument, ifcColumnCategory, ifcColumn.GlobalId, structuralColumnGeometry, stepId, ifcColumn.EntityType);
          if (newDirectShape == null)
@@ -678,6 +702,8 @@ protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
          return newDirectShape.Id;
       }
 
+
+
       /// <summary>
       /// Duplicates Geometry within DirectShape for a new DirectShape creation.
       /// This is to drive the process where the DirectShape -> GInstance -> DirectShapeType -> etc. will be preserved.
@@ -685,33 +711,46 @@ protected ElementId CreateStructuralColumnDirectShape(IFCProduct ifcColumn)
       /// <param name="oldDirectShapeElementId">ElementId for the exiting DirectShape.</param>
       /// <param name="ifcProduct">IfcProduct corresponding to the DirectShape.</param>
       /// <returns>List of Geometry Objects for the new DirectShape.</returns>
-      protected IList<GeometryObject> DuplicateGeometryForDirectShape(DirectShape oldDirectShape, IFCProduct ifcProduct)
+      private GeometryInstance GetDirectShapeGeometryInstance(DirectShape directShape)
       {
-         int stepId = ifcProduct?.Id ?? -1;
-         if ((oldDirectShape == null) || (stepId <= 0))
-         {
-            return null;
-         }
-
          // DirectShape should have one and only one GeometryInstance, and no other GeometryObjects.
          Options options = new Options();
-         GeometryElement geometryElement = oldDirectShape?.get_Geometry(options);
+         GeometryElement geometryElement = directShape?.get_Geometry(options);
          if ((geometryElement?.Count() ?? 0) == 0)
          {
             return null;
          }
 
-         GeometryInstance oldDirectShapeGeometryInstance = geometryElement?.First() as GeometryInstance;
+         return geometryElement?.First() as GeometryInstance;
+      }
+
+      /// <summary>
+      /// Duplicates Geometry within DirectShape for a new DirectShape creation.
+      /// This is to drive the process where the DirectShape -> GInstance -> DirectShapeType -> etc. will be preserved.
+      /// </summary>
+      /// <param name="oldDirectShapeElementId">ElementId for the exiting DirectShape.</param>
+      /// <param name="ifcProduct">IfcProduct corresponding to the DirectShape.</param>
+      /// <returns>List of Geometry Objects for the new DirectShape and the old DirectShapeType element id.</returns>
+      protected (IList<GeometryObject>, ElementId) DuplicateGeometryForDirectShape(DirectShape oldDirectShape, IFCProduct ifcProduct)
+      {
+         int stepId = ifcProduct?.Id ?? -1;
+         if (stepId <= 0)
+         {
+            return (null, ElementId.InvalidElementId);
+         }
+
+         // DirectShape should have one and only one GeometryInstance, and no other GeometryObjects.
+         GeometryInstance oldDirectShapeGeometryInstance = GetDirectShapeGeometryInstance(oldDirectShape);
          GeometryElement oldDirectShapeTypeGeometryElement = oldDirectShapeGeometryInstance?.SymbolGeometry;
          if (oldDirectShapeTypeGeometryElement == null)
          {
-            return null;
+            return (null, ElementId.InvalidElementId);
          }
 
          ElementId oldDirectShapeTypeElementId = oldDirectShapeGeometryInstance?.GetSymbolGeometryId().SymbolId ?? ElementId.InvalidElementId;
          if (oldDirectShapeTypeElementId == ElementId.InvalidElementId)
          {
-            return null;
+            return (null, ElementId.InvalidElementId);
          }
 
          // Reminder:  the passed-in IfcProduct may be a Container for the DirectShape.  
@@ -724,18 +763,19 @@ protected IList<GeometryObject> DuplicateGeometryForDirectShape(DirectShape oldD
          }
 
          // Most of the work happens here to Copy DirectShapeTypes.
-         ElementId newDirectShapeTypeId = DeepCopyDirectShapeType(oldDirectShapeTypeElementId, oldDirectShapeTypeGeometryElement, ifcProduct.CategoryId, ifcTypeObject);
+         ElementId newDirectShapeTypeId = DeepCopyDirectShapeType(oldDirectShapeTypeElementId, 
+            oldDirectShapeTypeGeometryElement, ifcProduct.GetCategoryId(IfcDocument), ifcTypeObject);
 
          string definitionId = GetDirectShapeTypeDefinitionId(newDirectShapeTypeId);
          if (string.IsNullOrEmpty(definitionId))
          {
-            return null;
+            return (null, ElementId.InvalidElementId);
          }
 
          // Create new GeoemtryInstance to add new DirectShapeType using the same Trf.
          // String = ifcTypeObject.GlobalId + oldDirectShapeTypeElementId (as a string).
          IList<GeometryObject> newGeomObjects = DirectShape.CreateGeometryInstance(IfcDocument, definitionId, oldDirectShapeGeometryInstance.Transform);
-         return newGeomObjects;
+         return (newGeomObjects, oldDirectShapeTypeElementId);
       }
 
       /// <summary>
@@ -944,20 +984,23 @@ public IList<GeometryObject> DuplicateDirectShapeGeometry(IList<ElementId> direc
       /// </summary>
       /// <param name="shapeEditScope">Some data is contained in the ShapeEditScope (but not actual geometry).</param>
       /// <param name="ifcProduct">IFCProduct to edit.</param>
-      public ElementId HandleHybridProductCreation(IFCImportShapeEditScope shapeEditScope, IFCProduct ifcProduct)
+      /// <param name="hybridElementId">The associated element id.</param> 
+      /// <returns>The list of created geometries.</returns>
+      public IList<GeometryObject> HandleHybridProductCreation(IFCImportShapeEditScope shapeEditScope, 
+         IFCProduct ifcProduct, ref ElementId hybridElementId)
       {
-         if (!Importer.TheOptions.IsHybridImport || (shapeEditScope == null) || (ifcProduct == null) || (ifcProduct.CreatedElementId == ElementId.InvalidElementId))
+         IList<GeometryObject> createdGeometries = new List<GeometryObject>();
+
+         if (!Importer.TheOptions.IsHybridImport || (shapeEditScope == null) || (ifcProduct == null) || (hybridElementId == ElementId.InvalidElementId))
          {
-            return ElementId.InvalidElementId;
+            return createdGeometries;
          }
 
-         ElementId hybridElementId = ifcProduct.CreatedElementId;
-
          // Get DirectShape to "Create".  It's already created, so Revit is not really creating it here.
          DirectShape directShape = IfcDocument.GetElement(hybridElementId) as DirectShape;
          if (directShape == null)
          {
-            return ElementId.InvalidElementId;
+            return createdGeometries;
          }
 
          // Get solids for IFCProduct.  Only Points and Curves should be contained within "Solids".
@@ -975,6 +1018,11 @@ public ElementId HandleHybridProductCreation(IFCImportShapeEditScope shapeEditSc
                {
                   wireframeBuilder.AddCurve(currObject as Curve);
                }
+               else
+               {
+                  continue;
+               }
+               createdGeometries.Add(currObject);
             }
 
             directShape.AppendShape(wireframeBuilder);
@@ -992,20 +1040,8 @@ public ElementId HandleHybridProductCreation(IFCImportShapeEditScope shapeEditSc
          // Handle Special Cases:
          // 1.  Possible Category Change for Structural Columns.  This requires a whole new DirectShape/DirectShapeType tree creation.
          // 2.  Containers for IfcRelAggregates (e.g., IfcWall & IfcBuildingElementParts).
-         // In either of these, the specialCaseElementId may end up being the same as the original CreatedElementId.
-         // If new ElementId is in
-         // This means that there was no new Element created, so don't delete the ElementId in that case.
-         ElementId newCreatedId = hybridElementId;
-         ElementId specialCaseElementId = Importer.TheHybridInfo.CreateElementForSpecialCases(ifcProduct);
-         if ((specialCaseElementId != ElementId.InvalidElementId) && (specialCaseElementId != hybridElementId))
-         {
-            // specialCaseElementId has replaced hybridElementId in the HybridMap.
-            // The hybridElementId will be deleted later.
-            Importer.TheHybridInfo.ElementsToDelete.Add(hybridElementId);
-            newCreatedId = specialCaseElementId;
-         }
-
-         return newCreatedId;
+         Importer.TheHybridInfo.UpdateElementForSpecialCases(ifcProduct, ref hybridElementId);
+         return createdGeometries;
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs b/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
index 64714038..999e7e1d 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
@@ -78,6 +78,25 @@ public void Dispose()
          }
       }
 
+      /// <summary>
+      /// Choice of Import Method stored to ProjectInfo.
+      /// </summary>
+      public enum ImportMethod
+      {
+         Hybrid,
+         Legacy
+      }
+
+      /// <summary>
+      /// Simply returns whether the CurrentImportMethod is Hybrid or Legacy.  Useful when checking for previous import.
+      /// </summary>
+      public ImportMethod CurrentImportMethod => IsHybridImport ? ImportMethod.Hybrid : ImportMethod.Legacy;
+
+      /// <summary>
+      /// Defines parameter storing Import Method in ProjectInfo.
+      /// </summary>
+      public static string ImportMethodParameter => "Import Method";
+
       /// <summary>
       /// If true, does an import optimized for performance that minimizes unnecessary functionality.
       /// </summary>
@@ -85,7 +104,7 @@ public void Dispose()
 
       /// <summary>
       /// If we are linking, specify the file name of the intermediate Revit file.  This can be null, and
-      /// the .NET code will detemine the file name.
+      /// the .NET code will determine the file name.
       /// </summary>
       public string RevitLinkFileName { get; protected set; } = null;
 
@@ -184,13 +203,13 @@ public static string ImporterVersion
       /// True:  Hybrid (legacy + AnyCAD)
       /// False:  legacy only
       /// </summary>
-      public bool IsHybridImport { get; protected set; } = false;
+      public bool IsHybridImport { get; set; } = false;
 
       protected IFCImportOptions()
       {
       }
 
-      protected IFCImportOptions(IDictionary<string, string> options, string ifcFileName)
+      protected IFCImportOptions(IDictionary<string, string> options, string ifcFileName, Document doc)
       {
          // "Intent": covers what the import operation is intended to create.
          // The two options are:
@@ -300,23 +319,32 @@ protected IFCImportOptions(IDictionary<string, string> options, string ifcFileNa
          ImportIFCOptions importIFCOptions = ImportIFCOptions.GetImportIFCOptions();
          string linkProcessor = importIFCOptions.LinkProcessor;
 
-         // For now, only use hybrid import if revit.ini has "AnyCAD" set and we are importing
-         // STEP (.ifc) files.
-         // In the future, this will change to:
-         // IsHybridImport = (string.Compare(linkProcessor, "Legacy", true) != 0);
-         IsHybridImport = (string.Compare(linkProcessor, "AnyCAD", true) == 0) &&
-            (ifcFileName.EndsWith(".ifc"));
+         string revitVersion = doc.Application.VersionBuild;
+         if (revitVersion.StartsWith("24.0"))
+         {
+            // For Revit 24.0.x, only use hybrid import if revit.ini has "AnyCAD" set.
+            IsHybridImport = (string.Compare(linkProcessor, "AnyCAD", true) == 0) &&
+               (ifcFileName.EndsWith(".ifc")) && (Processor is IFCDefaultProcessor);
+         }
+         else
+         {
+            // For Revit 24.1.x
+            // Use hybrid import if revit.ini does not have "Legacy" in it and we are using
+            // the default (Revit) processor.  For other processors (e.g., Navis), revert
+            // to Legacy.
+            IsHybridImport = (string.Compare(linkProcessor, "Legacy", true) != 0) &&
+               (Processor is IFCDefaultProcessor);
+         }
       }
 
       /// <summary>
-      /// Populate a new IFCImportOptions class with values based on the opions passed in by the user.
+      /// Populate a new IFCImportOptions class with values based on the options passed in by the user.
       /// </summary>
       /// <param name="options">The user-set options for this import.</param>
-      /// <param name="ifcFileName">The name of the IFC file.</param>
       /// <returns>The new IFCImportOptions class.</returns>
-      static public IFCImportOptions Create(IDictionary<string, string> options, string ifcFileName)
+      static public IFCImportOptions Create(IDictionary<string, string> options, string ifcFileName, Document doc)
       {
-         return new IFCImportOptions(options, ifcFileName);
+         return new IFCImportOptions(options, ifcFileName, doc);
       }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs b/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
index 298eabc6..e2eaab0f 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
@@ -70,12 +70,18 @@ private IList<ElementId> MaterialIdList
       /// <summary>
       /// The id of the associated graphics style, if any.
       /// </summary>
-      public ElementId GraphicsStyleId { get; set; } = ElementId.InvalidElementId;
+      public ElementId GraphicsStyleId
+      {
+         get { return Creator?.GetGraphicsStyleId(Document) ?? ElementId.InvalidElementId; }
+      }
 
       /// <summary>
       /// The id of the associated category.
       /// </summary>
-      public ElementId CategoryId { get; set; } = ElementId.InvalidElementId;
+      public ElementId CategoryId
+      {
+         get { return Creator?.GetCategoryId(Document) ?? ElementId.InvalidElementId; }
+      }
 
 
       private void PushMaterialId(ElementId materialId)
diff --git a/Source/Revit.IFC.Import/Utility/ParametersToSet.cs b/Source/Revit.IFC.Import/Utility/ParametersToSet.cs
new file mode 100644
index 00000000..b5d00939
--- /dev/null
+++ b/Source/Revit.IFC.Import/Utility/ParametersToSet.cs
@@ -0,0 +1,427 @@
+using Autodesk.Revit.DB;
+using Revit.IFC.Import.Data;
+using Revit.IFC.Import.Enums;
+using System;
+using System.Collections.Generic;
+
+namespace Revit.IFC.Import.Utility
+{
+   public class ParameterSetter : IDisposable
+   {
+      public ParameterSetter()
+      {
+         ParametersToSet = new ParametersToSet();
+      }
+
+      public void Dispose()
+      {
+         if (ParametersToSet != null)
+         {
+            //IFC Extension back - compatibility:
+            //Parameter.SetMultiple method available since Revit 2024.1, handle it for addin usage with the previous Revit versions.
+            //
+            try
+            {
+               TryToSetMultipleParameters();
+            }
+            catch (MissingMethodException)
+            {
+               foreach (Tuple<Parameter, ParameterValue> parameterAndParameterValue in ParametersToSet.ParameterList)
+               {
+                  Parameter param = parameterAndParameterValue.Item1;
+                  ParameterValue paramValue = parameterAndParameterValue.Item2;
+
+                  if(param != null)
+                  {
+                     StorageType storageType = param.StorageType;
+                     switch (storageType)
+                     {
+                        case StorageType.Integer:
+                           {
+                              param.Set((int)(paramValue as IntegerParameterValue)?.Value);
+                              break;
+                           }
+                        case StorageType.Double:
+                           {
+                              param.Set((double)(paramValue as DoubleParameterValue)?.Value);
+                              break;
+                           }
+                        case StorageType.String:
+                           {
+                              param.Set((string)(paramValue as StringParameterValue)?.Value);
+                              break;
+                           }
+                        case StorageType.ElementId:
+                           {
+                              param.Set((ElementId)(paramValue as ElementIdParameterValue)?.Value);
+                              break;
+                           }
+                     }
+                  }
+               }
+            }
+         }
+      }
+
+      private void TryToSetMultipleParameters()
+      {
+         Parameter.SetMultiple(ParametersToSet.ParameterList);
+      }
+
+      public ParametersToSet ParametersToSet { get; private set; } = null;
+   }
+
+   /// <summary>
+   /// A list of parameters and values, intended to be set at once for performance reasons.
+   /// </summary>
+   public class ParametersToSet
+   {
+      /// <summary>
+      /// The default constructor.
+      /// </summary>
+      public ParametersToSet() { }
+
+      /// <summary>
+      /// Clears the list.
+      /// </summary>
+      public void Clear()
+      {
+         ParameterList.Clear();
+      }
+
+      /// <summary>
+      /// Adds an integer parameter.
+      /// </summary>
+      /// <param name="parameter">The parameter.</param>
+      /// <param name="value">The integer value.</param>
+      public void AddIntegerParameter(Parameter parameter, int value)
+      {
+         if (parameter == null)
+            return;
+
+         ParameterValue intValue = new IntegerParameterValue(value);
+         ParameterList.Add(Tuple.Create(parameter, intValue));
+      }
+
+      /// <summary>
+      /// Adds a double parameter.
+      /// </summary>
+      /// <param name="parameter">The parameter.</param>
+      /// <param name="value">The double value.</param>
+      public void AddDoubleParameter(Parameter parameter, double value)
+      {
+         if (parameter == null)
+            return;
+
+         ParameterValue stringValue = new DoubleParameterValue(value);
+         ParameterList.Add(Tuple.Create(parameter, stringValue));
+      }
+
+      private Parameter AddParameterBase(Document doc, Element element, Category category, string parameterName, int parameterSetId, ForgeTypeId specId)
+      {
+         bool isElementType = (element is ElementType);
+         Definitions definitions = isElementType ? Importer.TheCache.TypeGroupDefinitions : Importer.TheCache.InstanceGroupDefinitions;
+
+         bool newlyCreated = false;
+         Definition definition = definitions.get_Item(parameterName);
+         if (definition == null)
+         {
+            ExternalDefinitionCreationOptions option = new ExternalDefinitionCreationOptions(parameterName, specId);
+            definition = definitions.Create(option);
+            if (definition == null)
+            {
+               Importer.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false);
+               return null;
+            }
+            newlyCreated = true;
+         }
+
+         Guid guid = (definition as ExternalDefinition).GUID;
+
+         Parameter parameter = null;
+         ElementBinding binding = null;
+         bool reinsert = false;
+
+         if (!newlyCreated)
+         {
+            BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
+            binding = bindingMap.get_Item(definition) as ElementBinding;
+            reinsert = (binding != null);
+         }
+
+         if (binding == null)
+         {
+            if (isElementType)
+               binding = new TypeBinding();
+            else
+               binding = new InstanceBinding();
+         }
+
+         // The binding can fail if we haven't identified a "bad" category above.  Use try/catch as a safety net.
+         try
+         {
+            if (!reinsert || !binding.Categories.Contains(category))
+            {
+               binding.Categories.Insert(category);
+
+               BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
+               if (reinsert)
+                  bindingMap.ReInsert(definition, binding, GroupTypeId.Ifc);
+               else
+                  bindingMap.Insert(definition, binding, GroupTypeId.Ifc);
+            }
+
+            parameter = element.get_Parameter(guid);
+         }
+         catch
+         {
+         }
+
+         if (parameter == null)
+            Importer.TheLog.LogError(parameterSetId, "Couldn't create parameter: " + parameterName, false);
+
+         return parameter;
+      }
+
+      /// <summary>
+      /// Add a string parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="objDef">The IFCObjectDefinition that created the element.</param>
+      /// <param name="name">The enum corresponding to the parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddStringParameter(Document doc, Element element, Category category, IFCObjectDefinition objDef,
+         IFCSharedParameters name, string parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null || objDef == null || parameterValue == null)
+            return false;
+
+         string parameterName = objDef.GetSharedParameterName(name, element is ElementType);
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
+         if (parameter == null)
+            return false;
+
+         AddStringParameter(parameter, parameterValue);
+         return true;
+      }
+
+      /// <summary>
+      /// Add a string parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddStringParameter(Document doc, Element element, Category category, IFCObjectDefinition objDef,
+         string parameterName, string parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
+         if (parameter == null)
+            return false;
+
+         AddStringParameter(parameter, parameterValue);
+         return true;
+      }
+
+      /// <summary>
+      /// Adds a string parameter.
+      /// </summary>
+      /// <param name="parameter">The parameter.</param>
+      /// <param name="value">The string value.</param>
+      public void AddStringParameter(Parameter parameter, string value)
+      {
+         if (parameter == null)
+            return;
+
+         ParameterValue stringValue = new StringParameterValue(value == null ? string.Empty : value);
+         ParameterList.Add(Tuple.Create(parameter, stringValue));
+      }
+
+      /// <summary>
+      /// Adds a parameter with the name of an element represented by an ElementId to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddParameterElementId(Document doc, Element element, Category category, IFCObjectDefinition objDef,
+         string parameterName, ElementId parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         Element parameterElement = doc.GetElement(parameterValue);
+         if (parameterElement == null)
+            return false;
+
+         string name = parameterElement.Name;
+         if (string.IsNullOrEmpty(name))
+            return false;
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.Text);
+         if (parameter == null)
+            return false;
+
+         AddStringParameter(parameter, name);
+         return true;
+      }
+
+      /// <summary>
+      /// Add a Boolean parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddParameterBoolean(Document doc, Element element, Category category,
+         IFCObjectDefinition objDef, string parameterName, bool parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.Boolean.YesNo);
+         if (parameter == null)
+            return false;
+
+         AddIntegerParameter(parameter, parameterValue ? 1 : 0);
+         return true;
+      }
+
+      /// <summary>
+      /// Add an int parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddParameterInt(Document doc, Element element, Category category, IFCObjectDefinition objDef,
+         string parameterName, int parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.Int.Integer);
+         if (parameter == null)
+            return false;
+
+         AddIntegerParameter(parameter, parameterValue);
+         return true;
+      }
+
+      private static ForgeTypeId CalculateUnitsTypeId(ForgeTypeId unitsTypeId,
+         ForgeTypeId specTypeId)
+      {
+         if (unitsTypeId != null || Importer.TheProcessor.ScaleValues)
+            return unitsTypeId;
+
+         // We can look up the units when the values are not scaled.
+         var units = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(specTypeId);
+         return (units != null) ? units.Unit : UnitTypeId.General;
+      }
+
+
+      /// <summary>
+      /// Add a double parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="specTypeId">Identifier of the parameter spec (e.g. length)</param>
+      /// <param name="unitsTypeId">Identifier of the unscaled parameter units (e.g. mm)</param>
+      /// <param name="parameterValue">The parameter value, scaled into document units.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddParameterDouble(Document doc, Element element, Category category,
+         IFCObjectDefinition objDef, string parameterName, ForgeTypeId specTypeId,
+         ForgeTypeId unitsTypeId, double parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         unitsTypeId = CalculateUnitsTypeId(unitsTypeId, specTypeId);
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id,
+            specTypeId, unitsTypeId, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, specTypeId);
+         if (parameter == null)
+            return false;
+
+         AddDoubleParameter(parameter, parameterValue);
+         return true;
+      }
+
+      /// <summary>
+      /// Add a multistring parameter to an element.
+      /// </summary>
+      /// <param name="doc">The document.</param>
+      /// <param name="element">The element.</param>
+      /// <param name="category">The category of the element.</param>
+      /// <param name="parameterName">The parameter name.</param>
+      /// <param name="parameterValue">The parameter value.</param>
+      /// <param name="parameterSetId">The id of the containing parameter set, for reporting errors.</param>
+      /// <returns>True if the parameter was successfully added, false otherwise.</returns>
+      public bool AddParameterMultilineString(Document doc, Element element, Category category,
+         IFCObjectDefinition objDef, string parameterName, string parameterValue, int parameterSetId)
+      {
+         if (doc == null || element == null || category == null)
+            return false;
+
+         bool? processedParameter = Importer.TheProcessor.ProcessParameter(objDef.Id, parameterSetId, parameterName, parameterValue);
+         if (processedParameter.HasValue)
+            return processedParameter.Value;
+
+         Parameter parameter = AddParameterBase(doc, element, category, parameterName, parameterSetId, SpecTypeId.String.MultilineText);
+         if (parameter == null)
+            return false;
+
+         AddStringParameter(parameter, parameterValue);
+         return true;
+      }
+
+      public IList<Tuple<Parameter, ParameterValue>> ParameterList { get; private set; } =
+         new List<Tuple<Parameter, ParameterValue>>();
+   };
+}
\ No newline at end of file

From ccc7069287a11339546d97af978209b71bcf398f Mon Sep 17 00:00:00 2001
From: babio <oleksandr.babii@autodesk.com>
Date: Fri, 28 Jul 2023 07:20:16 -0700
Subject: [PATCH 2/2] update version

---
 .../Autodesk.SteelConnections.ASIFC.dll       | Bin 197408 -> 197408 bytes
 .../DefaultUserDefinedParameterSets.txt       |   4 +++
 .../Resources/ADSKIFCExporterHelp.htm         |  28 ++++++++++++++++++
 Install/RevitIFCSetupWix/Product.wxs          |   2 +-
 .../RevitIFCSetupWix/RevitIFCSetupWix.wixproj |   2 +-
 .../Properties/AssemblyInfo.cs                |   4 +--
 .../Properties/AssemblyInfo.cs                |   4 +--
 .../Properties/AssemblyInfo.cs                |   4 +--
 .../Properties/AssemblyInfo.cs                |   4 +--
 .../Properties/AssemblyInfo.cs                |   4 +--
 10 files changed, 44 insertions(+), 12 deletions(-)

diff --git a/Install/Program Files to Install/Autodesk.SteelConnections.ASIFC.dll b/Install/Program Files to Install/Autodesk.SteelConnections.ASIFC.dll
index f19e8b758c1c032eaf74eea1867d162fe30ec70c..2208cd4e040d655554e8f9385922f0fa4785d56e 100644
GIT binary patch
delta 4119
zcmY*b3tWv^*FS5YQ#pFNDAT=EBwf_0sAz<glX5RqN})7KQZqv?6-6|uWT`z-N%5+N
zE*?2@Np6Wuh)@hN($Iy$WOD1<hmYU;KIeD#de++OviDm5y`Ei|!WE`)JGKc;TI#aW
z452)$)RtuXWwnijKm;&X7|}xn253U8(I3p=C~ks8*nvPa6|TmD0O*Zt#EG9x7AV7a
ze2L0@!pMNyIVD)ipVRgRIL)i-W~zWW7K}U%T701S0U-$^SW&2tMpgsZYR~Z&)_EYl
zD-;MuJrW28W1_7Vl~}_d>>h0bb-b$0d4PL-v#l*5qvVE$Xl!2t-F%z96F?hYaWKY=
z=jOcsm?r?HysP6xfGL>ZGypc3;2a76^3R<cm7tYBHc6X+0XDe>gEDV3<tBibCmzhX
z2VXyR7{FNmsk8#XozIzu1b#%z>5cF&_Dv54g7arIf;yVcOoJjUpLrhkW9+O%D8W~=
z8gX10hnHu^;py4R{Pa170Ken%x%W`)%i$cK<75C(+4m`Y!dJcrv9z1x56t6$<?+b;
zdvJ`;Snv?QiC^ijBn04B2QC1(iA_PBVk!BWkBLjQ@X;6%-d&Urp13+#3VX3OI2`hE
zWJov^V+I=wurDMW(?d9nSRBaKSid+Nrt&sRya|Nk%TS}w4z72Y;OS6%h+>jyaD^Wq
zW(N?;7*otxW)6{`6>lv&EROvad((0)zA$_;fqnQm;ssP<^YRM39BG2CXr7%59JWM$
z4<C7r6~!Q4|IMmu<L4FgccZ=o_#S&#E`)2mSF}E0?mmu>S>+4xj<1hdPhc4D_7fBL
z)N*{p&)XHnN5A=~*q}v?y}$x^blt$yQZp9p<AxCE<QK&+P!w<YrYK3#!jK(i*q^Ke
z8&G5OeAtQ+n?2zdJhHhFbohiV3q@oz!NfE}tV<B_A5u2~OvHpVDP&=N+DWFEv^^P8
zP%%9XcH++TOOTEM8Cx+Zb1-&g#6lV_%KQ^ldAA*j1XR!nO;J7C1Qk#R!*DoGLNjJ2
zmrnZ21WVBxoEay@7W9Na*qhPksM~g>15p$HKYY#L9}LJjNV0@DF?SemO7#gO@~*iD
zf!vqt=<eKO0TX!3J;?y}Sf1C&AhIr>VKj%|U7$%ofaQf#u(XJ!q%e>4g4_h_oCo2l
zeI^i$5B4<z;me9DM65Oe2O|M2`T7!Xf`+@4d4u1AL{N?EDtJ6y$>F%l%^1IhA@~dB
z{i`a4Fc$|`OHuc_G9Oso4{!<R%cRhN1+qr6;L8#Gb-Wn_@a4y~0S_PN_!~9u03E1x
zl7bbMpZpCEpXB(kQ>OqHp=oU+bn(5l#Q>H3&N>Hzxdj~76b`}qoZ+Z&J_N<pDrk9L
z>q`R9Tf<?zeO`*`7dW)I5DIyG#)aVo*H&=+>H1J0-tr9Tqie$~c*SQl>;))8n=5~U
z7HTwRLM~s_I6xqfFKSu?Fq_xA?jvITYUQnm@DyjZWMa@_W&W?0s=;KK5Tn~o=p$n=
z!}doyunkwXo6;SMjGf$WjWzAc7}q`-{WCcJV!Hu>$MSiU>=xmmC;9A<|L2JmZei~e
ziak#_%<9-kZWHwG)W@u+TDVFgLeHnEa0i>8uF)L$iq^qa>Iou&KxBL!13Pn}8T&dZ
zyvB^bq|o?z{Del&I>mRt>f`kuEqvKM7X6<GGBh1~9u5!Cs4E-|yI9DsKxoI_u9MJ;
zW!=&8=7MHDfjHwihv_|s;0=!NT?l=c(<^0->_Klh2>7Wlx&WSh*@?agxA&Q$|34h2
z{=EYfQ18_XR>Z-trC9ow!=Tr9QT$q&pY%o-pc4cBIgjywvy${}L&H7}PxtMIE?n|f
z3f)-tHX3?S@81D<iF*C-QMaE%lXoxik6sQ9-|v8TSpI&1wbAkqdq5ezK8CWf;^Tg_
z7*NIa?V7l8m<Z!ORk6%l4itk0HVrgVT`N$f>lHyayAH;Y#e_z)%1~o~kMILEB9IKR
z^f>``?AQU^EPq|dBvXYTg&$=ZLQn%pq6H$xCd;0RKnR*CUq3P5s<2J&$Ou<T6sfTy
z%zzlWQW1Wn5wk&=#wmgxRa62OSV@0T`VxmuR)XR3(@%d_0v$-FPnDSe3~Dn7-otWg
zDP~;MXF{K`UO^qj%zV3CU@S8o3`+?aB%)^+;ADq57(&38)~W&z(`c+3Yz0I5P7T6g
z30<Pjhz7l)4w<l&1`J`?h<D<sodyKbRt>hc23430hiIDy(>qArG#Sy9yBaCGt_dbW
zas5~P&@4UBqUzeLk6xhTwc!Oc$Sidr7*Iu*lV$6|_drv1nMc%vq4cF5Y$3{Qg{mym
zAsm>AR2W#Po<11SOhx8hYycq&Y+uVw;2w0yrkcWezzMk=Z8ZdaDj5N}oaAfh!NwBW
zGJ>6u+(*jvs2TJ?ysT&>tP#O#s%Hh>WQdUJTY(p?vVstJNj0ol@?OaTtl^*`wGgu?
zs$ML6o-!{l5EA%_&YTXvL86>|ZoqWH3|4}8I)4VUOP~caSQ6r>;!IYFb(G8k8LX!#
zW`UH}%wqfFW<wC|pAO2hpJqc8p%y+&$os<393PgO12Rh=a3SK-uLz;h3s^s4p9{Ke
z9+<%_S@}FTNibrrym6_qR?8;*Sdt?AfTJ~ja37jwIsRZOgc4azAk2w`MKa|E_(NSN
zzan+rh2h%lMez0UU}+TybeIIFSu2eDpGnRCn*6yH%;YX)`K@s6qPl^@`m=&dDbn)w
zr`%H&av#bz>?N~pITa8LvL9n($9|5qwTaAjVVAj3c?ebvfdPv<iCy9*T_b|IKJGrT
z2ak@Lx#G9!2R=S-zB4Czu6$V@;{$zuh*%|eLc^|+ewEF=a?>wQ0gbv&^kIiA^*Y%C
zSrQRdZ6*oIit^>NO)x5>%|r}Bdx4l1-z4Trb^;rLqd*|Lag*Ewp(7Jlv=FPWV%pw9
z?8I^%`ClR%a+f>>@gpMOSiDMCIsbx%QOao}%0q`JiY-$-Q{Jk85-CiwAd;j}pXjhQ
zGS_&&O`%k^Zb9k1wVP~DH-;SXd>0sh;mJ__u5tYeQKA74SymevuFCx&Nzw}?0Frn~
z1g#n%=5*CP;zli=k;FvTa9(@<31Mxdx8E;*JG|aiVL?M??e9aA|6Ji6qh3!WD&L|5
zC<sJJL@<By?%gGhPYt?^=sT17OFle$6B6mr;?{1waq5`WliD`?)#-fJW2A$)fIL!5
z(6u`{Z{)f6+V{Nk-D_=~e(Zl~lVDr=DcYp^@j&Y8_{2FG&)3)mEd73;skX<V-U$kQ
zdY4a{etIP~-aYwc9i-e>vR=M@$kp{SpP$xU9C0Y5Gi%7R9>W_uZw-17H2g#LkuB<`
z)fV0dsv2eqS57)NB0}otCsn;zKK@kG^3CmkKfib(-?d?XK$ezesKM#uQ?u^<Ufp_J
z==pHlbdLe|XR$l;5_R7M-Evu2s^Mi4aQS20ttyL4Ypr6f3ob6!x|KoS<-7X@_68T0
z*@j`>-sWLSVU4+!&-rSfZEnYs>`#?$+vjsqmf|+(Lu^N!3i+h}!<5k56=v=l+V@)a
z&26(1&wZr6=e|wbGJbo2%Wm}u>GY$+T_*2}Y6xnm8NH~d`A)#v#KRgdKm6NtwD{)c
z{+JS%_uZ%Za$@^y>hn_1jMW;adO9Wc;TE->AKF8{zt^F!vq`HmdXc)!G00%eqyulu
zQ#ITZ)6)Y>j&;Wzu&jGA>dc3#Mdpe_hn5F#x@?j@#yo3maE;BD00)=42gMWrzHs!}
z%x9x^2midQ{lup+^~m`e++UYyJHm1Cxm~~RnzD18Owq|<dc@EL2S;z$j8ky#xIMe9
zwBz;UE1Q?K#1HJ*;*v8@;-zaVp75WUm1_Hvv|S}h+T#@mTPcDFlAMG>uuIamWU`Up
z03(O1wl)*7`<l>BO%A1y6i)~fiU@;}Bu-J;QvD0C#p)m`j1YxO!l*+xF`4qL`<&gZ
zh8aC&L!Yg78WEd6TJz)OI6H>}5ofj@DZ6k-mkbf?2@*<ro3)>KSw(3GOb&bNsM$;G
z9VAZnjuPjwcJ}tNoNm&rDgMT1#|S4HKUiM-t5v?joA=uK(=6w>Bo>DYVjn-)ec_hT
z>SI?%79GyME}WhiRPie~PVBprdTE}a`;Wt>4w!^B#cwaGzq7pN#mb{AaBEtN#~JtF
zfBnr4m8RAxtF8S`CGVndqBy^~^{mP|%R^hEd|Cq%{NF?+Z|Dpu`xHEJ^<1NP-I5Z+
zmI6sl#7WOFCj0ik(0Xud#_**dZabI8?ObYF;;{IBTk7uWWz$->CSGispnc=<Ki9KU
z|Ju4WNB?k&TkOJUTA4ZGbx_;YbtSgZ3+DY61BLc!bF|9FU0mdy?OKs+y+5|ziE~}{
zc9VCOo1?!QS)6^X(QJQkw2R-}w3j11{S=q{yf*eoV&9cji$4}mSy*RlbHnPxa+}hP
zk&!Ek9v(7VW?QCb)}vxH(Kj)F%)|G8UOhGIV5I9+_XByw&(v=0G2)s83PA?yL4S5j
zPyVsV&~d(WW>kcRQmyHC-u)?pu@~Qkrrp*)(KNA)Ta|hF@9{C)^R9Y~sXA+{F*#FX
z{FK4jwaynD4@T^nk#y$rs&PASS*^XRz%8UHW8LlsdQ>D_B59f9lg28TUnvSsl&;K}
zqm$?QyhACdWAx$|A6KMrOz!ZXrgtXnz~%nrMX8!G$!*6fKlKEjP4TsyQPjWhb=Xbk
z6I@W3ot-o7tz3P3yVsFrzpr~Ywm#oh#m-2_cv@l6rM!}qY@@0M;!&~JH9o16OH=>l
lJFPv{qkXg7Ck&4tu~2z!jE;rU<>KS7ltMS<u3>HX{{VIhPq6?1

delta 4123
zcmZWr3s{ZW*FS5Y)2Y*WC1pBYRHx{w%PF_QU|cFmmx+*WC?U!;jB!bn8cowhi*^?!
zjiLA}d2uF*>KM01l3Ot@p&}JAMUwvS;p6$f=X;;$-Rs?J?X}n1YyZ~oc?%Mmf<z{L
zCx2Pu>|M!*aC}#>J#kChb=Mq15WqskvXk&epb4?TMPLDc;&zCI-3UZmr9K*XK&!8j
z39L6+AO;<_Xow%-#Nf~xRS0EkBy)f!=>fy)>FpQ-mY8o|2@*EI;txJqPO!AV0F6cu
zV)lN9wX)d@q9#6%XZeW7Q^#0)9V)W{HSDl8fofL6P66-_+hA``h?UaO5T%agXlTQ*
zEsiz-_wdRXDW<ktu#3h%1sKUr89x<ZCT^WD2==(uDFXV~cBfiZxXYfJCLv&mb<=~n
zwCrZw08nSiECrzLQii?mG8|w$+v-{hFpJHcjRe-AwMQ-VVXsFp@X>E>Eeu0b&t&)=
zOFR|S$`=@n@mdGP_}Z%${>HQ3@woDPG3()D2z2E_&bt2ldH{6sRS+IQ@w`?P&0}z2
z-d>#B&ai*XX8=y(ald;YXHyqE1aM*_7pd~GxR7DD2Y3M7#Ja#XksJ9^nW@Wk@X=TS
zHU{OvZ2T$M6$<cda5&_nc}O@0E@3b`BmgUe8H6PPc>k6dS1bv{ln@55F9`rw)^6z>
z0xR%UsL`iw>RU{(GSm?wIn8XW^k&#uVdel~+|(3Pms`N<PfKquKZ;f!VvJukoGl3d
zj^I&G20K?ig)(edRSKK%N`w@rpapJ^Fu|Y}3;4)tt^OTETfXL9w(V2iY~z}50IhPx
z_%6~1>RI<F1AtfT^0mPL{p^JwHWQGt)7NpzPBv&g72?KHF_vu^PNnW(1t)OI78XqL
z^_B>D#s<YK5Q<{HMvx`yU`V<d_QmT$3~KH0gPpi?hZ`j0@g22Td5mF`61)W@fnaR1
zAy#b_upg4P15CrM$*z!r7m_P5Fijnkf7=AVpfDvF5HnIPVtF%zVX0dn1s|twhTkwK
z?FkHJr>Dmf&_E+JMa?J^R6$*?CydY)4RIt+duD>gXamkl4NUwrKHx^9Pf>U7P649H
z{~r{aK`;7e9wHfhoSJRSno<KoMWZ-u&d%No<i2v5UPi7JOku5a;{nEC$=+HHB%AV#
z0Vtc3uT3~~l@!bX0lqFcL|%f@0jr$U@XUS_u7e-!uLVAPxUf{f-HHF92!PS-g(40E
zlUS`I;Q}~?n@U+QK)YjUXnTyo%g1&oCA+BX7$1C5{iG|3PKw!plYIb}&`<6PmoZ;n
zOBQ}^!>oyBu$V3RQvwjcUMTkhoXbH@T9JZ_&M;VBQ2@5A|Cx(`_xCesd$tM#*E4M2
z*(`uEHlu0`Az8{38sLS@k*J~wp_Lk3%UCHSpKGYFffBr}aOKc#bUq3V&ogZHd0oQw
z%JB<PKs-MCPPya-Z`jmJ`v8uh-IXUGL9N;}$YBd>2MGkSg>@SMd|3T@UjgjG$eRzL
z4LxtA!9n)HtqOHoYzAWdxmlM!l7bmFKhlLHjBGZg=|XP$U9%0ObJIDH#-47rAn-(K
zLs^ah)t=@-9Ugq@3b(N9DTUjZ*ph5;=L;UyM{8~s@OT1g!xs&vwd&$pnE>5dlb{hB
zS~qC(zA)a`)z>kgEgNoNZyQDDt|6H7Y!XK+sn1+t5RIO<VR45T8#;%hY^)XhgP!f-
zX!wG`>h=J5h(<5M;SnZs<74c4QGwa>89dn$s$?28>kNSV7}qI>9-P><7~W!Lmn+9>
z54yquSeKVC07Y*Y+}JEZnSlU*>or5eUIvr8(?N*(uU|qds=skXy>|=-zG=ioJq-KZ
zzq)`i-CTS0{0Z%7)Qj)}kN1{h@mn#je)}zS;^DVZ@Dlak4MI2S_w~bT)Op{JNBbEx
z>`#Y&Ea@NQSheIsE_dth1EJhlI&c6ixEf1wo3Q|Y{#XX)Xg&BlSYzE_Enbdb=tdzJ
z?5P50vXsy$?vAJwU;tK9BLea8BW))fK}<t4S}uYiw3mPvr*z?iE3A{J@?j`IJk1w?
zD}7EtOkWA0Py3hucMD0%-Hb3&CZtj!%!OzgDTE&(PANuFp(;$GNvgngI-0>+`l~7|
zhE&?B$^}WIc52WM5!715%_2XG#Lpr{DWq~!by!A-NI=hVfRq1+fnfyZ)3X}Df;){K
z3cr96eLob!>7rr4&^4M60NV75CZs_q^&bYcFpHXNK{%8sedf><E$$powIC3R=yYvP
zKU}Fdm)C29314*a3;O6TebAwr5{^dyq7x<X5-!WFb%EpEbMjyHxLie5U&`=#=_`Fm
zAPkqK23O+{2FwH+9G<DZ0heBykP9Fh0U;`&L06f;J!qA?n1TYxc0#Wiat^Xlkj*%J
z39c@6ptnZBO)#N{&EPF;l^2@B2Em?e&fQ`(Od(o)YA~8Re%WXUfo`g0!zJ`a?r#H!
z3}H1T?%Z^?+}$1c1lChe4>&?sdUMBK=mEM)0;b>21zp%m{pNBP+vmYqiso_!*+_++
z&`&v95>v(tj=~mt+KbyNh7xbCP}}9JykP?o9r}9kvU#AB>C2VqpxoLQCK1u$ucoL4
zprhn(x^q6q3wrfp`JeNljF4-eD4Jtj&ax29pq`d2<Ot?!AS2(u2qb*?kGwnpd?FxN
zF1`f!HMtFW^hG0#lyDzkpIKaKc|2X^K+T%K`TrQT|Ce!n6PPKtkmohQwZAmY_YUt7
zByOFVkZV21E<4pyzGWZrwjZJaJdxvAI|n<NoueadtRvo&IUnv1FH{+UyA|FD;PGa1
ze|9sk5#IN{Gkw>N8y@S>pf&e6G1i*ku|tnD^JYy9@LjQTt>aj_>>BAC&g1RuQo4SA
z3YFi|T_!rPTb@u)5`bznkgZ}J&I;T?I4P$ML<Ib?Jazi}4Pv1x<Js{Xd5-eyH^@EU
zJ8|mLTV(VXHEq5{97M`BpI-T}M$!tRM})_4JD!-LoWF!!GS$qxL_AzmD6&p;OME*7
zR7pXc70BW&2dME~^1ZaK*mh1%R#*+)Jl0fKb*;|NyQ1cNh(4gEF>t*uKcv%1zUwX-
zsi6`si_>35%b$^#v6mvo%Yz*r#wA6L3VKrhcfX?h%*ReMV^;Oxa<$%bBLuP`UxNXt
z@C0#$w|(gQmcPpGjmUEC;*VcEWvzPH<lL~6;g4FTdlgK7*!|w=_3EB!r)K1}PgJq@
z&r-xb%JEW@*u1T8S!3KC8CM!zRrJB)N{wOplo^jV$JTjUWVl!TC2Ul2>7Pxu*^J*r
zb*Y~B=0Z#VCw6U#&MkM7uPGd2zZup#q~Lw;D}OTXgO7E`>sM;|Sto;fK3dF3%BX6O
zKT>P3+d(zuc2MQOPWOwaHn@_&-)k~2Jg>>s_qu(jI$_DBBie^^CRe9vWY_5i8}FT3
zKKUon)LFBfW24hUx8$rXj$He<@j%Ur@kt-%saNY?coAV1Xw>$$&3fPY57VrgY_m@1
zdYv)ym^x;MLgT9MQ|rW!QoE9xrly=W`%BL&y#4L>y}NoR=k{Ya^B*=Z4^1z$c%Bd+
zeS3Wtvy0L9snPmd>wWRu<f7)D`~|(zkg%fqoU^&7uLmvdfY=8vF6AdmcL;+=*(dn_
zVEtQ6Ro8^4*{kz6om;(rj`Q(<Z`KJiTdJD6ygI|~wHcX?sjj`|<JlhZ?8xmz>1{jK
za!t~_xTQ-jY+i6CWJYA=<;Hv8hUe)dYzkD--c~-L^r6K8HUCL3ur$?neP&L#)5yGH
zo^(QW&2pYxO}w!E!^+rYCo<doPLwzPoj2o3hVW$eS*II=6Eo%%4;()gQ<d16zNX$@
z?l#kJ-^Yetzy6E%>W!7gPIY?*_Qy%SmBmS%h3cb)Ab_|Dd_FkDNvt@X*;l|Q(J9g4
zR9Xc14nvht3Q2T>Fus6rP?BvBimf$2<5;8#f`S!-<+4yZrh}MFZ`~Ai@7TG`?*D{b
z0)6+SpWnS}%JRH=C?>*3zkYn-?z==Y(9+uG;{5bwlM-7+9VUe`-Jy;$$1$?8j^iC=
z<DAEhmD3K=pe_13-xJNBD!tLS=lz<xDdSZHjkc4${)nC_biVO4C3bRwTWU{-*2m~Q
z*ZCf?7vG(V_PPJfqf5(8ryJjwKVP96$S#>|+wJu@^T3H4`&^tdJ8E=_cfURQI&9p&
ztf9`OyT?>3LX2A)1`jrWxT^R1l#Xsl&rI37y7u@jB_SVca&IkDr0!_!UNzy(uNA$M
zj|C<~I|{dlk8q56Yri6KM{K_C>4KtZE$?4$Iw_X8SI2f4`{gJ4W`{mDj`Zoh$Fn}3
zc~B<V@IG_Ms#RW6W3R*EEf%M<cHX<6Z~trjK&mk1jjvZ%>cRA&XxpY2vbZPTh<lcn
zmMPx<)1+Z=r&FQ+xMD`i=FWy-pJ?`sNf&MWYo(>`tveB!S$&@SkJ-n>$F2U5ZM;X#
zAgpBKF;7E3uUMw8oq7KH=D~RVGQIYmZEg!7ujlUNGD&16t)BW@hP-*DUrKSk$wnbr
ztYAtrdK3w1MtzF5#_fM-Zg87t@uP8h%By`pm^fPvSBQRc`RV7ttwm~=w4!|CzAef#
zxsbjtws6>Ck;5X}Bau>}z;Tt<2=hZdCIQn{X-n3OJK*IKd&kGRTJLVhl67GfSKiF)
z>6Tm(+gd*~dN!hE+|DT1jsE4!txs(jdGop@Pf}R6bF+ZAH|^j}cDs}NIg<lMrXSCQ
z?^zl}D|1I>%NGY#SRSaly#CM)oj;bIaPZd+ztQJ?{#dGK$Hlb%h{_+oe`s{S^54Dl
Za+@kFOHNOBHCl}A5o*Q7x85j8{=b({U-ke1

diff --git a/Install/Program Files to Install/DefaultUserDefinedParameterSets.txt b/Install/Program Files to Install/DefaultUserDefinedParameterSets.txt
index bb46a284..c5a487c2 100644
--- a/Install/Program Files to Install/DefaultUserDefinedParameterSets.txt	
+++ b/Install/Program Files to Install/DefaultUserDefinedParameterSets.txt	
@@ -14,6 +14,10 @@
 #	Pressure, Ratio, Real, Text, ThermalTransmittance, ThermodynamicTemperature, Volume, 
 #	VolumetricFlowRate
 # 
+# Since 24.1.0, type properties are not exported in case they are not specified in the user-defined property sets file.
+#	To export type properties for the IFCElement, for example, 
+#	a user should include "IFCElementType" in the proper .txt file.
+#
 # Example property set definition for COBie:
 #
 #PropertySet:	COBie_Specification	T	IfcElementType
diff --git a/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm b/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm
index 073841ad..4068aac2 100644
--- a/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm	
+++ b/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm	
@@ -236,6 +236,34 @@ <h3>Support Information</h3>
 <p>or if you have an inquiry specific to this add-in, send us an e-mail to: <a href="mailto:Revit.apps@autodesk.com">Revit.apps@autodesk.com</a></p>
 <h2 id="VersionHistory" name="VersionHistory">Version History</h2>
 
+<div class="version">24.1.1.6</div><div class="versioninfo-bullet">
+      <br><p>
+         General:
+			<ul>
+				<li>This is the minor update of IFC Exporter for Revit 2024. 
+				<li>It contains a various improvements and bug fixes for the basic Revit 2024. 
+			</ul>	
+       </p>
+	   <br>
+	   <p>
+	    Bug Fixes:
+			<ul>
+				<li>The default import processor has been changed to Hybrid
+			</ul>
+		</p>
+		<br>
+		<p>
+         Bug Fixes:
+			<ul>
+				<li>Fixed a bunch of potential bugs related to the compatibility with older Revit versions.
+				<li>Fix sketch-based openings in sloped slabs.
+				<li>Fixed placement of some specific wall sweep elements.
+			</ul>
+		</p>
+		<br>
+	</div>
+	<br>
+
 <div class="version">24.1.0.22</div><div class="versioninfo-bullet">
       <br><p>
          General:
diff --git a/Install/RevitIFCSetupWix/Product.wxs b/Install/RevitIFCSetupWix/Product.wxs
index b9c1d43a..2271a0b6 100644
--- a/Install/RevitIFCSetupWix/Product.wxs
+++ b/Install/RevitIFCSetupWix/Product.wxs
@@ -2,7 +2,7 @@
 <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi"
      xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
 
-   <Product Id="1A9C2C21-24B8-42D2-0000-992E73C12400" Name="Revit IFC 2024" Language="1033" Version="24.1.1.0" Manufacturer="Autodesk" UpgradeCode="1A9C2C21-24B8-42D2-0000-992E73C11B3F">
+   <Product Id="1A9C2C21-2411-42D2-0000-992E73C12400" Name="Revit IFC 2024" Language="1033" Version="24.1.1.0" Manufacturer="Autodesk" UpgradeCode="1A9C2C21-24B8-42D2-0000-992E73C11B3F">
       <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine" />
 
       <MajorUpgrade DowngradeErrorMessage="A newer version of [ProductName] is already installed." />
diff --git a/Install/RevitIFCSetupWix/RevitIFCSetupWix.wixproj b/Install/RevitIFCSetupWix/RevitIFCSetupWix.wixproj
index 500ea3b6..888bc8fe 100644
--- a/Install/RevitIFCSetupWix/RevitIFCSetupWix.wixproj
+++ b/Install/RevitIFCSetupWix/RevitIFCSetupWix.wixproj
@@ -6,7 +6,7 @@
     <ProductVersion>3.8</ProductVersion>
     <ProjectGuid>7dfbd495-c588-4c7b-b8f6-5b793adb06f2</ProjectGuid>
     <SchemaVersion>2.0</SchemaVersion>
-    <OutputName>IFC for Revit 2024.1.0.22</OutputName>
+    <OutputName>IFC for Revit 2024.1.1.6</OutputName>
     <OutputType>Package</OutputType>
     <WixTargetsPath Condition=" '$(WixTargetsPath)' == '' AND '$(MSBuildExtensionsPath32)' != '' ">$(MSBuildExtensionsPath32)\Microsoft\WiX\v3.x\Wix.targets</WixTargetsPath>
     <WixTargetsPath Condition=" '$(WixTargetsPath)' == '' ">$(MSBuildExtensionsPath)\Microsoft\WiX\v3.x\Wix.targets</WixTargetsPath>
diff --git a/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs b/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
index 4b4c3688..fd15a6db 100644
--- a/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
+++ b/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
@@ -66,6 +66,6 @@
 // The following information is used in the Open Source version as the release version number.
 // The number will show up in the Title bar of the export dialog as well as at the IFC header file
 // This number must be manually updated prior to releasing the new version
-[assembly: AssemblyVersion("24.1.1.0")]
-[assembly: AssemblyFileVersion("24.1.1.0")]
+[assembly: AssemblyVersion("24.1.1.6")]
+[assembly: AssemblyFileVersion("24.1.1.6")]
 #endif
\ No newline at end of file
diff --git a/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
index 2e71c63b..457f87b5 100644
--- a/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Common/Properties/AssemblyInfo.cs
@@ -13,8 +13,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.1.0")]
-[assembly: AssemblyFileVersion("24.1.1.0")]
+[assembly: AssemblyVersion("24.1.1.6")]
+[assembly: AssemblyFileVersion("24.1.1.6")]
 #endif
 
 
diff --git a/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
index 1569e07f..5fe57fc0 100644
--- a/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
@@ -14,8 +14,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.1.0")]
-[assembly: AssemblyFileVersion("24.1.1.0")]
+[assembly: AssemblyVersion("24.1.1.6")]
+[assembly: AssemblyFileVersion("24.1.1.6")]
 
 #endif
 
diff --git a/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
index a1e402d4..53e712b7 100644
--- a/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Import.Core/Properties/AssemblyInfo.cs
@@ -13,8 +13,8 @@
 [assembly: AssemblyDescription("Revit.IFC.Import.Core")]
 [assembly: AssemblyCompany("Autodesk")]
 [assembly: AssemblyCopyright("@2012-2023 Autodesk, Inc. All rights reserved.")]
-[assembly: AssemblyVersion("24.1.1.0")]
-[assembly: AssemblyFileVersion("24.1.1.0")]
+[assembly: AssemblyVersion("24.1.1.6")]
+[assembly: AssemblyFileVersion("24.1.1.6")]
 
 // Version information can now be found in Source\Foundation\RevitENU\Version.cs
 //
diff --git a/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
index 7946176e..813b0c7d 100644
--- a/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
+++ b/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
@@ -12,8 +12,8 @@
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
-[assembly: AssemblyVersion("24.1.1.0")]
-[assembly: AssemblyFileVersion("24.1.1.0")]
+[assembly: AssemblyVersion("24.1.1.6")]
+[assembly: AssemblyFileVersion("24.1.1.6")]
 #endif
 
 #region Using directives