From 11a8fee71457db542333271fbe7148fe71dc9108 Mon Sep 17 00:00:00 2001
From: Oleksandr Babii <oleksandr.babii@autodesk.com>
Date: Wed, 29 Sep 2021 04:39:16 -0700
Subject: [PATCH 1/5] Code updated code to be compatible with Revit 2022.1 and
 ODA Toolkit.

---
 .../IFCExporterUIWindow.xaml                  |    2 +-
 .../IFCExporterUIWindow.xaml.cs               |   11 +-
 .../Revit.IFC.Common/Enums/IFC2xEntityType.cs |   86 +-
 .../Enums/IFC4x1EntityType.cs                 |  837 ++++
 .../Enums/IFC4x2EntityType.cs                 |  852 ++++
 .../Enums/IFC4x3EntityType.cs                 |  910 ++++
 .../Revit.IFC.Common/Enums/IFCEntityType.cs   |  179 +-
 .../Extension/IFCFileHeader.cs                |    2 -
 .../Revit.IFC.Common/Revit.IFC.Common.csproj  |    3 +
 .../Revit.IFC.Common/Utility/DirectoryUtil.cs |    2 +-
 .../Revit.IFC.Export/Exporter/BeamExporter.cs |   29 +-
 .../Revit.IFC.Export/Exporter/BodyExporter.cs |  249 +-
 .../Exporter/CeilingExporter.cs               |    2 +-
 .../Exporter/ConnectorExporter.cs             |   38 +-
 .../Exporter/CurtainSystemExporter.cs         |    7 +-
 .../Exporter/DuctLiningExporter.cs            |    2 +-
 Source/Revit.IFC.Export/Exporter/Exporter.cs  |   90 +-
 .../Exporter/ExporterInitializer.cs           |  189 +-
 .../Exporter/ExporterInitializer_PsetDef.cs   | 1628 +++++--
 .../Exporter/ExporterInitializer_QsetDef.cs   | 4319 +++++++++++++++++
 .../Exporter/ExtrusionExporter.cs             |   14 +-
 .../Exporter/FamilyInstanceExporter.cs        |   60 +-
 .../Exporter/FloorExporter.cs                 |    4 +-
 .../Exporter/FootingExporter.cs               |    2 +-
 .../Exporter/GenericMEPExporter.cs            |   12 +-
 .../Exporter/InsulationExporter.cs            |    2 +-
 .../Revit.IFC.Export/Exporter/PileExporter.cs |    2 +-
 .../Exporter/PropertySet/AttributeEntry.cs    |    2 +-
 .../NetCrossSectionAreaCalculator.cs          |  102 +
 .../PropertySet/Calculators/SpanCalculator.cs |    2 +
 .../Exporter/PropertySet/Description.cs       |    2 +-
 .../Exporter/PropertySet/Entry.cs             |   98 +-
 .../Exporter/PropertySet/EntryMap.cs          |  110 +-
 .../ExporterInitializer_PsetDefIFC2X2Enum.cs  |   40 +
 ... ExporterInitializer_PsetDefIFC2X3Enum.cs} |   42 +-
 .../ExporterInitializer_PsetDefIFC4Enum.cs    |   48 +
 .../Exporter/PropertySet/PropertySetEntry.cs  |  158 +-
 .../PropertySet/PropertySetEntryMap.cs        |  104 +-
 .../Exporter/PropertySet/PropertyUtil.cs      |  191 +-
 .../Exporter/PropertySet/QuantityEntry.cs     |   13 +-
 .../Exporter/PropertySet/QuantityEntryMap.cs  |   55 +-
 .../Revit.IFC.Export/Exporter/RampExporter.cs |   23 +-
 .../Revit.IFC.Export/Exporter/SiteExporter.cs |    8 +-
 .../Exporter/SpatialElementExporter.cs        |  126 +-
 .../Exporter/SurfaceExporter.cs               |    6 +-
 .../Revit.IFC.Export/Exporter/WallExporter.cs |    8 +-
 .../Revit.IFC.Export/Revit.IFC.Export.csproj  |    5 +-
 .../Revit.IFC.Export/Toolkit/IFCDataUtil.cs   |   10 +
 .../Toolkit/IFCInstanceExporter.cs            |   96 +-
 .../Utility/ElementFilteringUtil.cs           |    2 +
 .../Utility/ExporterCacheManager.cs           |    6 +
 .../Revit.IFC.Export/Utility/ExporterUtil.cs  |  193 +-
 .../Revit.IFC.Export/Utility/GeometryUtil.cs  |  693 ++-
 Source/Revit.IFC.Export/Utility/MEPCache.cs   |    5 +
 .../Revit.IFC.Export/Utility/ParameterUtil.cs |  140 +-
 .../Utility/RepresentationUtil.cs             |    4 +-
 .../Utility/TriangleMergeUtil.cs              |   21 +-
 Source/Revit.IFC.Export/Utility/UnitUtil.cs   |   10 +
 Source/Revit.IFC.Import/Data/IFCBuilding.cs   |    9 +
 .../Data/IFCBuildingElementComponent.cs       |    7 -
 .../Data/IFCBuildingElementPart.cs            |    7 -
 .../Data/IFCBuildingStorey.cs                 |   10 +-
 .../Data/IFCComplexProperty.cs                |   25 +-
 .../Data/IFCCompositeCurve.cs                 |    7 +-
 Source/Revit.IFC.Import/Data/IFCCurve.cs      |   21 +-
 .../Data/IFCDistributionPort.cs               |   29 +-
 .../Data/IFCElementQuantity.cs                |    1 -
 Source/Revit.IFC.Import/Data/IFCFaceBound.cs  |    2 +-
 Source/Revit.IFC.Import/Data/IFCGridAxis.cs   |    8 +-
 Source/Revit.IFC.Import/Data/IFCGroup.cs      |   16 +-
 Source/Revit.IFC.Import/Data/IFCImportFile.cs |   80 +-
 Source/Revit.IFC.Import/Data/IFCLocation.cs   |   91 +-
 Source/Revit.IFC.Import/Data/IFCMappedItem.cs |   62 +-
 .../Data/IFCObjectDefinition.cs               |  125 +-
 Source/Revit.IFC.Import/Data/IFCProduct.cs    |  176 +-
 Source/Revit.IFC.Import/Data/IFCProject.cs    |   18 +-
 .../Revit.IFC.Import/Data/IFCPropertySet.cs   |   27 +-
 .../Data/IFCPropertySetDefinition.cs          |   99 -
 .../Data/IFCRepresentationContext.cs          |    2 +-
 .../Data/IFCRepresentationMap.cs              |    9 +-
 Source/Revit.IFC.Import/Data/IFCSite.cs       |  187 +-
 Source/Revit.IFC.Import/Data/IFCSpace.cs      |    2 +-
 .../Data/IFCSpatialStructureElement.cs        |   28 +
 .../Data/IFCSweptDiskSolid.cs                 |   12 +-
 .../Revit.IFC.Import/Data/IFCTrimmedCurve.cs  |    4 +-
 Source/Revit.IFC.Import/Data/IFCTypeObject.cs |    1 +
 Source/Revit.IFC.Import/Data/IFCUnit.cs       |   50 +
 .../Enums/IFCSchemaVersion.cs                 |    6 +-
 .../Geometry/IFCGeometryUtil.cs               |   47 +-
 .../Processors/IFCDefaultProcessor.cs         |   60 +-
 .../Processors/IFCNavisProcessor.cs           |  171 +-
 .../Processors/IIFCFileProcessor.cs           |   52 +-
 .../Revit.IFC.Import/Utility/IFCDataUtil.cs   |    3 +
 .../Utility/IFCImportHandleUtil.cs            |   26 -
 .../Utility/IFCImportOptions.cs               |    6 -
 .../Utility/IFCImportShapeEditScope.cs        |    4 +-
 .../Revit.IFC.Import/Utility/IFCUnitUtil.cs   |   22 +-
 .../Utility/TessellatedShapeBuilderScope.cs   |    2 +-
 98 files changed, 11092 insertions(+), 2278 deletions(-)
 create mode 100644 Source/Revit.IFC.Common/Enums/IFC4x1EntityType.cs
 create mode 100644 Source/Revit.IFC.Common/Enums/IFC4x2EntityType.cs
 create mode 100644 Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
 create mode 100644 Source/Revit.IFC.Export/Exporter/ExporterInitializer_QsetDef.cs
 create mode 100644 Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/NetCrossSectionAreaCalculator.cs
 rename Source/Revit.IFC.Export/Exporter/PropertySet/{ExporterInitializer_PsetDefIFC2X3TC1Enum.cs => ExporterInitializer_PsetDefIFC2X3Enum.cs} (97%)

diff --git a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
index 4809a515..40a6084e 100644
--- a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
+++ b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml
@@ -32,7 +32,7 @@
                <Button Content="{x:Static p:Resources.Address}" Margin="0,0,10,9" Name="addressInformation" Click="buttonAddressInformation_Click" HorizontalAlignment="Right" Width="200" Height="23" VerticalAlignment="Bottom"/>
                <ComboBox x:Name="comboBoxExchangeRequirement" Margin="0,36,10,0" SelectionChanged="comboBoxExchangeRequirement_SelectionChanged" HorizontalAlignment="Right" Width="298" Height="22" VerticalAlignment="Top"/>
                <Label Content="{x:Static p:Resources.ExchangeRequirement}" Margin="10,34,0,0" Name="labelExchangeRequirement" HorizontalAlignment="Left" Width="176" Height="28" VerticalAlignment="Top" />
-               <Label Content="Projected Coordinate System Reference" Margin="10,204,0,0" x:Name="label_ProjectedCRS" RenderTransformOrigin="0.738,0.586" HorizontalAlignment="Left" Width="275" Height="26" VerticalAlignment="Top"/>
+               <Label Content="{x:Static p:Resources.ProjectedCRS}" Margin="10,204,0,0" x:Name="label_ProjectedCRS" RenderTransformOrigin="0.738,0.586" HorizontalAlignment="Left" Width="275" Height="26" VerticalAlignment="Top"/>
 
                <Border BorderBrush="#FFCBCBCB" BorderThickness="1" Margin="12,228,10,70" RenderTransformOrigin="0.5,0.5">
                   <Border.RenderTransform>
diff --git a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml.cs b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml.cs
index e14a623c..0acf5a55 100644
--- a/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml.cs
+++ b/Source/IFCExporterUIOverride/IFCExporterUIWindow.xaml.cs
@@ -826,12 +826,11 @@ private IFCExportConfiguration CreateNewEditableConfiguration(IFCExportConfigura
       private IFCExportConfiguration GetSelectedConfiguration()
       {
          IFCExportConfiguration configuration = (IFCExportConfiguration)listBoxConfigurations.SelectedItem;
-         //if (configuration == null)
-         //{
-         //   configuration = IFCExportConfiguration.CreateDefaultConfiguration();
-         //   IFCExportConfiguration.SetInSession(configuration);
-         //   listBoxConfigurations.SelectedItem = configuration;
-         //}
+         if (configuration == null)
+         {
+            configuration = IFCExportConfiguration.GetInSession();
+            listBoxConfigurations.SelectedItem = configuration;
+         }
          return configuration;
       }
 
diff --git a/Source/Revit.IFC.Common/Enums/IFC2xEntityType.cs b/Source/Revit.IFC.Common/Enums/IFC2xEntityType.cs
index 592e643c..4245cce9 100644
--- a/Source/Revit.IFC.Common/Enums/IFC2xEntityType.cs
+++ b/Source/Revit.IFC.Common/Enums/IFC2xEntityType.cs
@@ -30,10 +30,15 @@ public enum IFCEntityType
    {
       Ifc2DCompositeCurve,
       IfcActionRequest,
+      IfcActionTimeControl,
       IfcActor,
       IfcActorRole,
+      IfcActuator,
       IfcActuatorType,
       IfcAddress,
+      IfcAirFilter,
+      IfcAirTerminal,
+      IfcAirTerminalBox,
       IfcAirTerminalBoxType,
       IfcAirTerminalType,
       IfcAirToAirHeatRecoveryType,
@@ -55,9 +60,11 @@ public enum IFCEntityType
       IfcApprovalActorRelationship,
       IfcApprovalPropertyRelationship,
       IfcApprovalRelationship,
+      IfcApprovalUsage,
       IfcArbitraryClosedProfileDef,
       IfcArbitraryOpenProfileDef,
       IfcArbitraryProfileDefWithVoids,
+      IfcAssessory,
       IfcAsset,
       IfcAsymmetricIShapeProfileDef,
       IfcAxis1Placement,
@@ -69,6 +76,7 @@ public enum IFCEntityType
       IfcBezierCurve,
       IfcBlobTexture,
       IfcBlock,
+      IfcBoiler,
       IfcBoilerType,
       IfcBooleanClippingResult,
       IfcBooleanResult,
@@ -81,6 +89,7 @@ public enum IFCEntityType
       IfcBoundedSurface,
       IfcBoundingBox,
       IfcBoxedHalfSpace,
+      IfcBudget,
       IfcBuilding,
       IfcBuildingElement,
       IfcBuildingElementComponent,
@@ -89,6 +98,7 @@ public enum IFCEntityType
       IfcBuildingElementProxyType,
       IfcBuildingElementType,
       IfcBuildingStorey,
+      IfcBuiltIn,
       IfcCShapeProfileDef,
       IfcCableCarrierFittingType,
       IfcCableCarrierSegmentType,
@@ -102,6 +112,8 @@ public enum IFCEntityType
       IfcCartesianTransformationOperator3DnonUniform,
       IfcCenterLineProfileDef,
       IfcChamferEdgeFeature,
+      IfcChangeOrder,
+      IfcChiller,
       IfcChillerType,
       IfcCircle,
       IfcCircleHollowProfileDef,
@@ -113,21 +125,26 @@ public enum IFCEntityType
       IfcClassificationNotationFacet,
       IfcClassificationReference,
       IfcClosedShell,
+      IfcCMDocPackage,
+      IfcCoil,
       IfcCoilType,
       IfcColourRgb,
       IfcColourSpecification,
       IfcColumn,
       IfcColumnType,
+      IfcCompartment,
       IfcComplexProperty,
       IfcCompositeCurve,
       IfcCompositeCurveSegment,
       IfcCompositeProfileDef,
+      IfcCompressor,
       IfcCompressorType,
       IfcCondenserType,
       IfcCondition,
       IfcConditionCriterion,
       IfcConic,
       IfcConnectedFaceSet,
+      IfcConnectionConstraint,
       IfcConnectionCurveGeometry,
       IfcConnectionGeometry,
       IfcConnectionPointEccentricity,
@@ -138,20 +155,29 @@ public enum IFCEntityType
       IfcConstraintAggregationRelationship,
       IfcConstraintClassificationRelationship,
       IfcConstraintRelationship,
+      IfcConstraintUsage,
       IfcConstructionEquipmentResource,
       IfcConstructionMaterialResource,
       IfcConstructionProductResource,
       IfcConstructionResource,
       IfcContextDependentUnit,
       IfcControl,
+      IfcControlElement,
+      IfcController,
       IfcControllerType,
       IfcConversionBasedUnit,
       IfcCooledBeamType,
+      IfcCoolingTower,
       IfcCoolingTowerType,
       IfcCoordinatedUniversalTimeOffset,
+      IfcCost,
       IfcCostItem,
+      IfcCostModifier,
+      IfcCostModifierValue,
+      IfcCostQuantity,
       IfcCostSchedule,
       IfcCostValue,
+      IfcCostValueRelationship,
       IfcCovering,
       IfcCoveringType,
       IfcCraneRailAShapeProfileDef,
@@ -168,6 +194,7 @@ public enum IFCEntityType
       IfcCurveStyleFont,
       IfcCurveStyleFontAndScaling,
       IfcCurveStyleFontPattern,
+      IfcDamper,
       IfcDamperType,
       IfcDateAndTime,
       IfcDefinedSymbol,
@@ -182,8 +209,10 @@ public enum IFCEntityType
       IfcDimensionPair,
       IfcDimensionalExponents,
       IfcDirection,
+      IfcDirectionalLightSource,
       IfcDiscreteAccessory,
       IfcDiscreteAccessoryType,
+      IfcDiscreteElement,
       IfcDistributionChamberElement,
       IfcDistributionChamberElementType,
       IfcDistributionControlElement,
@@ -213,16 +242,19 @@ public enum IFCEntityType
       IfcEdgeCurve,
       IfcEdgeFeature,
       IfcEdgeLoop,
+      IfcElectricalAppliance,
+      IfcElectricalBaseProperties,
+      IfcElectricalCircuit,
+      IfcElectricalElement,
+      IfcElectricalExtendedProperties,
       IfcElectricApplianceType,
       IfcElectricDistributionPoint,
       IfcElectricFlowStorageDeviceType,
       IfcElectricGeneratorType,
       IfcElectricHeaterType,
+      IfcElectricMotor,
       IfcElectricMotorType,
       IfcElectricTimeControlType,
-      IfcElectricalBaseProperties,
-      IfcElectricalCircuit,
-      IfcElectricalElement,
       IfcElement,
       IfcElementAssembly,
       IfcElementComponent,
@@ -255,6 +287,7 @@ public enum IFCEntityType
       IfcFacetedBrep,
       IfcFacetedBrepWithVoids,
       IfcFailureConnectionCondition,
+      IfcFan,
       IfcFanType,
       IfcFastener,
       IfcFastenerType,
@@ -284,10 +317,12 @@ public enum IFCEntityType
       IfcFlowTreatmentDevice,
       IfcFlowTreatmentDeviceType,
       IfcFluidFlowProperties,
+      IfcFluidMovingDevice,
       IfcFooting,
       IfcFuelProperties,
       IfcFurnishingElement,
       IfcFurnishingElementType,
+      IfcFurniture,
       IfcFurnitureStandard,
       IfcFurnitureType,
       IfcGasTerminalType,
@@ -303,14 +338,18 @@ public enum IFCEntityType
       IfcGridPlacement,
       IfcGroup,
       IfcHalfSpaceSolid,
+      IfcHeatExchanger,
       IfcHeatExchangerType,
+      IfcHeatTransferDevice,
       IfcHumidifierType,
+      IfcHydronicHeater,
       IfcHygroscopicMaterialProperties,
-      IfcIShapeProfileDef,
       IfcImageTexture,
       IfcInventory,
       IfcIrregularTimeSeries,
       IfcIrregularTimeSeriesValue,
+      IfcIShapeProfileDef,
+      IfcIshapeProfileDef,
       IfcJunctionBoxType,
       IfcLShapeProfileDef,
       IfcLaborResource,
@@ -318,6 +357,7 @@ public enum IFCEntityType
       IfcLibraryInformation,
       IfcLibraryReference,
       IfcLightDistributionData,
+      IfcLightFixture,
       IfcLightFixtureType,
       IfcLightIntensityDistribution,
       IfcLightSource,
@@ -331,7 +371,10 @@ public enum IFCEntityType
       IfcLocalPlacement,
       IfcLocalTime,
       IfcLoop,
+      IfcMaintenanceRecord,
+      IfcMaintenanceWorkOrder,
       IfcManifoldSolidBrep,
+      IfcManufacturerInformation,
       IfcMappedItem,
       IfcMaterial,
       IfcMaterialClassificationRelationship,
@@ -350,6 +393,8 @@ public enum IFCEntityType
       IfcMember,
       IfcMemberType,
       IfcMetric,
+      IfcMetricBenchmark,
+      IfcMetricValue,
       IfcMonetaryUnit,
       IfcMotorConnectionType,
       IfcMove,
@@ -369,6 +414,7 @@ public enum IFCEntityType
       IfcOrganization,
       IfcOrganizationRelationship,
       IfcOrientedEdge,
+      IfcOutlet,
       IfcOutletType,
       IfcOwnerHistory,
       IfcParameterizedProfileDef,
@@ -392,6 +438,7 @@ public enum IFCEntityType
       IfcPlate,
       IfcPlateType,
       IfcPoint,
+      IfcPointLightSource,
       IfcPointOnCurve,
       IfcPointOnSurface,
       IfcPolyLoop,
@@ -409,6 +456,7 @@ public enum IFCEntityType
       IfcPreDefinedTextFont,
       IfcPresentationLayerAssignment,
       IfcPresentationLayerWithStyle,
+      IfcPresentationLightSource,
       IfcPresentationStyle,
       IfcPresentationStyleAssignment,
       IfcProcedure,
@@ -439,7 +487,9 @@ public enum IFCEntityType
       IfcPropertyTableValue,
       IfcProtectiveDeviceType,
       IfcProxy,
+      IfcPump,
       IfcPumpType,
+      IfcPurchaseOrder,
       IfcQuantityArea,
       IfcQuantityCount,
       IfcQuantityLength,
@@ -457,7 +507,12 @@ public enum IFCEntityType
       IfcRectangleProfileDef,
       IfcRectangularPyramid,
       IfcRectangularTrimmedSurface,
+      IfcReferenceEdge,
+      IfcReferenceFace,
+      IfcReferenceGeometry,
+      IfcReferencesCostDocument,
       IfcReferencesValueDocument,
+      IfcReferenceVertex,
       IfcRegularTimeSeries,
       IfcReinforcementBarProperties,
       IfcReinforcementDefinitionProperties,
@@ -465,7 +520,9 @@ public enum IFCEntityType
       IfcReinforcingElement,
       IfcReinforcingMesh,
       IfcRelAggregates,
+      IfcRelAggregatesResources,
       IfcRelAssigns,
+      IfcRelAssignsFMStandard,
       IfcRelAssignsTasks,
       IfcRelAssignsToActor,
       IfcRelAssignsToControl,
@@ -494,6 +551,7 @@ public enum IFCEntityType
       IfcRelConnectsWithEccentricity,
       IfcRelConnectsWithRealizingElements,
       IfcRelContainedInSpatialStructure,
+      IfcRelCostsObjects,
       IfcRelCoversBldgElements,
       IfcRelCoversSpaces,
       IfcRelDecomposes,
@@ -503,6 +561,7 @@ public enum IFCEntityType
       IfcRelFillsElement,
       IfcRelFlowControlElements,
       IfcRelInteractionRequirements,
+      IfcRelMaintenanceEvent,
       IfcRelNests,
       IfcRelOccupiesSpaces,
       IfcRelOverridesProperties,
@@ -512,6 +571,7 @@ public enum IFCEntityType
       IfcRelSequence,
       IfcRelServicesBuildings,
       IfcRelSpaceBoundary,
+      IfcRelUsesResource,
       IfcRelVoidsElement,
       IfcRelationship,
       IfcRelaxation,
@@ -529,11 +589,13 @@ public enum IFCEntityType
       IfcRoundedEdgeFeature,
       IfcRoundedRectangleProfileDef,
       IfcSIUnit,
+      IfcSanitaryTerminal,
       IfcSanitaryTerminalType,
       IfcScheduleTimeControl,
       IfcSectionProperties,
       IfcSectionReinforcementProperties,
       IfcSectionedSpine,
+      IfcSensor,
       IfcSensorType,
       IfcServiceLife,
       IfcServiceLifeFactor,
@@ -552,15 +614,19 @@ public enum IFCEntityType
       IfcSpace,
       IfcSpaceHeaterType,
       IfcSpaceProgram,
+      IfcSpaceProgramGroup,
+      IfcSpaceThermalLoad,
       IfcSpaceThermalLoadProperties,
       IfcSpaceType,
       IfcSpatialStructureElement,
       IfcSpatialStructureElementType,
       IfcSphere,
+      IfcSpotLightSource,
       IfcStackTerminalType,
       IfcStair,
       IfcStairFlight,
       IfcStairFlightType,
+      IfcStorageDevice,
       IfcStructuralAction,
       IfcStructuralActivity,
       IfcStructuralAnalysisModel,
@@ -603,13 +669,18 @@ public enum IFCEntityType
       IfcSubedge,
       IfcSurface,
       IfcSurfaceCurveSweptAreaSolid,
+      IfcSurfaceExtendedProperties,
       IfcSurfaceOfLinearExtrusion,
       IfcSurfaceOfRevolution,
+      IfcSurfaceRenderingProperties,
+      IfcSurfaceShadingProperties,
       IfcSurfaceStyle,
       IfcSurfaceStyleLighting,
+      IfcSurfaceStyleProperties,
       IfcSurfaceStyleRefraction,
       IfcSurfaceStyleRendering,
       IfcSurfaceStyleShading,
+      IfcSurfaceStyleUsage,
       IfcSurfaceStyleWithTextures,
       IfcSurfaceTexture,
       IfcSweptAreaSolid,
@@ -618,10 +689,12 @@ public enum IFCEntityType
       IfcSwitchingDeviceType,
       IfcSymbolStyle,
       IfcSystem,
+      IfcSystemFurnitureElement,
       IfcSystemFurnitureElementType,
       IfcTShapeProfileDef,
       IfcTable,
       IfcTableRow,
+      IfcTank,
       IfcTankType,
       IfcTask,
       IfcTelecomAddress,
@@ -650,14 +723,18 @@ public enum IFCEntityType
       IfcTransportElement,
       IfcTransportElementType,
       IfcTrapeziumProfileDef,
+      IfcTreatmentDevice,
       IfcTrimmedCurve,
+      IfcTubeBundle,
       IfcTubeBundleType,
       IfcTwoDirectionRepeatFactor,
       IfcTypeObject,
       IfcTypeProduct,
       IfcUShapeProfileDef,
       IfcUnitAssignment,
+      IfcUnitHeater,
       IfcUnitaryEquipmentType,
+      IfcValve,
       IfcValveType,
       IfcVector,
       IfcVertex,
@@ -677,6 +754,7 @@ public enum IFCEntityType
       IfcWindowPanelProperties,
       IfcWindowStyle,
       IfcWorkControl,
+      IfcWorkOrder,
       IfcWorkPlan,
       IfcWorkSchedule,
       IfcZShapeProfileDef,
diff --git a/Source/Revit.IFC.Common/Enums/IFC4x1EntityType.cs b/Source/Revit.IFC.Common/Enums/IFC4x1EntityType.cs
new file mode 100644
index 00000000..2ddd9ce9
--- /dev/null
+++ b/Source/Revit.IFC.Common/Enums/IFC4x1EntityType.cs
@@ -0,0 +1,837 @@
+//
+// BIM IFC export alternate UI library: this library works with Autodesk(R) Revit(R) to provide an alternate user interface for the export of IFC files from Revit.
+// Copyright (C) 2013  Autodesk, Inc.
+// 
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Revit.IFC.Common.Enums.IFC4x1
+{
+   /// <summary>
+   /// IFC4x1 entity types.
+   /// <remarks>
+   /// Schema IFC4x1 currently withdrawn <see cref="https://technical.buildingsmart.org/standards/ifc/ifc-schema-specifications/"/>
+   /// </remarks>
+   /// </summary>
+   public enum IFCEntityType
+   {
+      IfcActionRequest,
+      IfcActor,
+      IfcActorRole,
+      IfcActuator,
+      IfcActuatorType,
+      IfcAddress,
+      IfcAdvancedBrep,
+      IfcAdvancedBrepWithVoids,
+      IfcAdvancedFace,
+      IfcAirTerminal,
+      IfcAirTerminalBox,
+      IfcAirTerminalBoxType,
+      IfcAirTerminalType,
+      IfcAirToAirHeatRecovery,
+      IfcAirToAirHeatRecoveryType,
+      IfcAlarm,
+      IfcAlarmType,
+      IfcAlignment,
+      IfcAlignment2DHorizontal,
+      IfcAlignment2DHorizontalSegment,
+      IfcAlignment2DSegment,
+      IfcAlignment2DVerSegCircularArc,
+      IfcAlignment2DVerSegLine,
+      IfcAlignment2DVerSegParabolicArc,
+      IfcAlignment2DVertical,
+      IfcAlignment2DVerticalSegment,
+      IfcAlignmentCurve,
+      IfcAnnotation,
+      IfcAnnotationFillArea,
+      IfcApplication,
+      IfcAppliedValue,
+      IfcApproval,
+      IfcApprovalRelationship,
+      IfcArbitraryClosedProfileDef,
+      IfcArbitraryOpenProfileDef,
+      IfcArbitraryProfileDefWithVoids,
+      IfcAsset,
+      IfcAsymmetricIShapeProfileDef,
+      IfcAudioVisualAppliance,
+      IfcAudioVisualApplianceType,
+      IfcAxis1Placement,
+      IfcAxis2Placement2D,
+      IfcAxis2Placement3D,
+      IfcBeam,
+      IfcBeamStandardCase,
+      IfcBeamType,
+      IfcBlobTexture,
+      IfcBlock,
+      IfcBoiler,
+      IfcBoilerType,
+      IfcBooleanClippingResult,
+      IfcBooleanResult,
+      IfcBoundaryCondition,
+      IfcBoundaryCurve,
+      IfcBoundaryEdgeCondition,
+      IfcBoundaryFaceCondition,
+      IfcBoundaryNodeCondition,
+      IfcBoundaryNodeConditionWarping,
+      IfcBoundedCurve,
+      IfcBoundedSurface,
+      IfcBoundingBox,
+      IfcBoxedHalfSpace,
+      IfcBSplineCurve,
+      IfcBSplineCurveWithKnots,
+      IfcBSplineSurface,
+      IfcBSplineSurfaceWithKnots,
+      IfcBuilding,
+      IfcBuildingElement,
+      IfcBuildingElementPart,
+      IfcBuildingElementPartType,
+      IfcBuildingElementProxy,
+      IfcBuildingElementProxyType,
+      IfcBuildingElementType,
+      IfcBuildingStorey,
+      IfcBuildingSystem,
+      IfcBurner,
+      IfcBurnerType,
+      IfcCableCarrierFitting,
+      IfcCableCarrierFittingType,
+      IfcCableCarrierSegment,
+      IfcCableCarrierSegmentType,
+      IfcCableFitting,
+      IfcCableFittingType,
+      IfcCableSegment,
+      IfcCableSegmentType,
+      IfcCartesianPoint,
+      IfcCartesianPointList,
+      IfcCartesianPointList2D,
+      IfcCartesianPointList3D,
+      IfcCartesianTransformationOperator,
+      IfcCartesianTransformationOperator2D,
+      IfcCartesianTransformationOperator2DnonUniform,
+      IfcCartesianTransformationOperator3D,
+      IfcCartesianTransformationOperator3DnonUniform,
+      IfcCenterLineProfileDef,
+      IfcChiller,
+      IfcChillerType,
+      IfcChimney,
+      IfcChimneyType,
+      IfcCircle,
+      IfcCircleHollowProfileDef,
+      IfcCircleProfileDef,
+      IfcCircularArcSegment2D,
+      IfcCivilElement,
+      IfcCivilElementType,
+      IfcClassification,
+      IfcClassificationReference,
+      IfcClosedShell,
+      IfcCoil,
+      IfcCoilType,
+      IfcColourRgb,
+      IfcColourRgbList,
+      IfcColourSpecification,
+      IfcColumn,
+      IfcColumnStandardCase,
+      IfcColumnType,
+      IfcCommunicationsAppliance,
+      IfcCommunicationsApplianceType,
+      IfcComplexProperty,
+      IfcComplexPropertyTemplate,
+      IfcCompositeCurve,
+      IfcCompositeCurveOnSurface,
+      IfcCompositeCurveSegment,
+      IfcCompositeProfileDef,
+      IfcCompressor,
+      IfcCompressorType,
+      IfcCondenser,
+      IfcCondenserType,
+      IfcConic,
+      IfcConnectedFaceSet,
+      IfcConnectionCurveGeometry,
+      IfcConnectionGeometry,
+      IfcConnectionPointEccentricity,
+      IfcConnectionPointGeometry,
+      IfcConnectionSurfaceGeometry,
+      IfcConnectionVolumeGeometry,
+      IfcConstraint,
+      IfcConstructionEquipmentResource,
+      IfcConstructionEquipmentResourceType,
+      IfcConstructionMaterialResource,
+      IfcConstructionMaterialResourceType,
+      IfcConstructionProductResource,
+      IfcConstructionProductResourceType,
+      IfcConstructionResource,
+      IfcConstructionResourceType,
+      IfcContext,
+      IfcContextDependentUnit,
+      IfcControl,
+      IfcController,
+      IfcControllerType,
+      IfcConversionBasedUnit,
+      IfcConversionBasedUnitWithOffset,
+      IfcCooledBeam,
+      IfcCooledBeamType,
+      IfcCoolingTower,
+      IfcCoolingTowerType,
+      IfcCoordinateOperation,
+      IfcCoordinateReferenceSystem,
+      IfcCostItem,
+      IfcCostSchedule,
+      IfcCostValue,
+      IfcCovering,
+      IfcCoveringType,
+      IfcCrewResource,
+      IfcCrewResourceType,
+      IfcCsgPrimitive3D,
+      IfcCsgSolid,
+      IfcCShapeProfileDef,
+      IfcCurrencyRelationship,
+      IfcCurtainWall,
+      IfcCurtainWallType,
+      IfcCurve,
+      IfcCurveBoundedPlane,
+      IfcCurveBoundedSurface,
+      IfcCurveSegment2D,
+      IfcCurveStyle,
+      IfcCurveStyleFont,
+      IfcCurveStyleFontAndScaling,
+      IfcCurveStyleFontPattern,
+      IfcCylindricalSurface,
+      IfcDamper,
+      IfcDamperType,
+      IfcDerivedProfileDef,
+      IfcDerivedUnit,
+      IfcDerivedUnitElement,
+      IfcDimensionalExponents,
+      IfcDirection,
+      IfcDiscreteAccessory,
+      IfcDiscreteAccessoryType,
+      IfcDistanceExpression,
+      IfcDistributionChamberElement,
+      IfcDistributionChamberElementType,
+      IfcDistributionCircuit,
+      IfcDistributionControlElement,
+      IfcDistributionControlElementType,
+      IfcDistributionElement,
+      IfcDistributionElementType,
+      IfcDistributionFlowElement,
+      IfcDistributionFlowElementType,
+      IfcDistributionPort,
+      IfcDistributionSystem,
+      IfcDocumentInformation,
+      IfcDocumentInformationRelationship,
+      IfcDocumentReference,
+      IfcDoor,
+      IfcDoorLiningProperties,
+      IfcDoorPanelProperties,
+      IfcDoorStandardCase,
+      IfcDoorStyle,
+      IfcDoorType,
+      IfcDraughtingPreDefinedColour,
+      IfcDraughtingPreDefinedCurveFont,
+      IfcDuctFitting,
+      IfcDuctFittingType,
+      IfcDuctSegment,
+      IfcDuctSegmentType,
+      IfcDuctSilencer,
+      IfcDuctSilencerType,
+      IfcEdge,
+      IfcEdgeCurve,
+      IfcEdgeLoop,
+      IfcElectricAppliance,
+      IfcElectricApplianceType,
+      IfcElectricDistributionBoard,
+      IfcElectricDistributionBoardType,
+      IfcElectricFlowStorageDevice,
+      IfcElectricFlowStorageDeviceType,
+      IfcElectricGenerator,
+      IfcElectricGeneratorType,
+      IfcElectricMotor,
+      IfcElectricMotorType,
+      IfcElectricTimeControl,
+      IfcElectricTimeControlType,
+      IfcElement,
+      IfcElementarySurface,
+      IfcElementAssembly,
+      IfcElementAssemblyType,
+      IfcElementComponent,
+      IfcElementComponentType,
+      IfcElementQuantity,
+      IfcElementType,
+      IfcEllipse,
+      IfcEllipseProfileDef,
+      IfcEnergyConversionDevice,
+      IfcEnergyConversionDeviceType,
+      IfcEngine,
+      IfcEngineType,
+      IfcEvaporativeCooler,
+      IfcEvaporativeCoolerType,
+      IfcEvaporator,
+      IfcEvaporatorType,
+      IfcEvent,
+      IfcEventTime,
+      IfcEventType,
+      IfcExtendedProperties,
+      IfcExternalInformation,
+      IfcExternallyDefinedHatchStyle,
+      IfcExternallyDefinedSurfaceStyle,
+      IfcExternallyDefinedTextFont,
+      IfcExternalReference,
+      IfcExternalReferenceRelationship,
+      IfcExternalSpatialElement,
+      IfcExternalSpatialStructureElement,
+      IfcExtrudedAreaSolid,
+      IfcExtrudedAreaSolidTapered,
+      IfcFace,
+      IfcFaceBasedSurfaceModel,
+      IfcFaceBound,
+      IfcFaceOuterBound,
+      IfcFaceSurface,
+      IfcFacetedBrep,
+      IfcFacetedBrepWithVoids,
+      IfcFailureConnectionCondition,
+      IfcFan,
+      IfcFanType,
+      IfcFastener,
+      IfcFastenerType,
+      IfcFeatureElement,
+      IfcFeatureElementAddition,
+      IfcFeatureElementSubtraction,
+      IfcFillAreaStyle,
+      IfcFillAreaStyleHatching,
+      IfcFillAreaStyleTiles,
+      IfcFilter,
+      IfcFilterType,
+      IfcFireSuppressionTerminal,
+      IfcFireSuppressionTerminalType,
+      IfcFixedReferenceSweptAreaSolid,
+      IfcFlowController,
+      IfcFlowControllerType,
+      IfcFlowFitting,
+      IfcFlowFittingType,
+      IfcFlowInstrument,
+      IfcFlowInstrumentType,
+      IfcFlowMeter,
+      IfcFlowMeterType,
+      IfcFlowMovingDevice,
+      IfcFlowMovingDeviceType,
+      IfcFlowSegment,
+      IfcFlowSegmentType,
+      IfcFlowStorageDevice,
+      IfcFlowStorageDeviceType,
+      IfcFlowTerminal,
+      IfcFlowTerminalType,
+      IfcFlowTreatmentDevice,
+      IfcFlowTreatmentDeviceType,
+      IfcFooting,
+      IfcFootingType,
+      IfcFurnishingElement,
+      IfcFurnishingElementType,
+      IfcFurniture,
+      IfcFurnitureType,
+      IfcGeographicElement,
+      IfcGeographicElementType,
+      IfcGeometricCurveSet,
+      IfcGeometricRepresentationContext,
+      IfcGeometricRepresentationItem,
+      IfcGeometricRepresentationSubContext,
+      IfcGeometricSet,
+      IfcGrid,
+      IfcGridAxis,
+      IfcGridPlacement,
+      IfcGroup,
+      IfcHalfSpaceSolid,
+      IfcHeatExchanger,
+      IfcHeatExchangerType,
+      IfcHumidifier,
+      IfcHumidifierType,
+      IfcImageTexture,
+      IfcIndexedColourMap,
+      IfcIndexedPolyCurve,
+      IfcIndexedPolygonalFace,
+      IfcIndexedPolygonalFaceWithVoids,
+      IfcIndexedTextureMap,
+      IfcIndexedTriangleTextureMap,
+      IfcInterceptor,
+      IfcInterceptorType,
+      IfcIntersectionCurve,
+      IfcInventory,
+      IfcIrregularTimeSeries,
+      IfcIrregularTimeSeriesValue,
+      IfcIShapeProfileDef,
+      IfcJunctionBox,
+      IfcJunctionBoxType,
+      IfcLaborResource,
+      IfcLaborResourceType,
+      IfcLagTime,
+      IfcLamp,
+      IfcLampType,
+      IfcLibraryInformation,
+      IfcLibraryReference,
+      IfcLightDistributionData,
+      IfcLightFixture,
+      IfcLightFixtureType,
+      IfcLightIntensityDistribution,
+      IfcLightSource,
+      IfcLightSourceAmbient,
+      IfcLightSourceDirectional,
+      IfcLightSourceGoniometric,
+      IfcLightSourcePositional,
+      IfcLightSourceSpot,
+      IfcLine,
+      IfcLinearPlacement,
+      IfcLinearPositioningElement,
+      IfcLineSegment2D,
+      IfcLocalPlacement,
+      IfcLoop,
+      IfcLShapeProfileDef,
+      IfcManifoldSolidBrep,
+      IfcMapConversion,
+      IfcMappedItem,
+      IfcMaterial,
+      IfcMaterialClassificationRelationship,
+      IfcMaterialConstituent,
+      IfcMaterialConstituentSet,
+      IfcMaterialDefinition,
+      IfcMaterialDefinitionRepresentation,
+      IfcMaterialLayer,
+      IfcMaterialLayerSet,
+      IfcMaterialLayerSetUsage,
+      IfcMaterialLayerWithOffsets,
+      IfcMaterialList,
+      IfcMaterialProfile,
+      IfcMaterialProfileSet,
+      IfcMaterialProfileSetUsage,
+      IfcMaterialProfileSetUsageTapering,
+      IfcMaterialProfileWithOffsets,
+      IfcMaterialProperties,
+      IfcMaterialRelationship,
+      IfcMaterialUsageDefinition,
+      IfcMeasureWithUnit,
+      IfcMechanicalFastener,
+      IfcMechanicalFastenerType,
+      IfcMedicalDevice,
+      IfcMedicalDeviceType,
+      IfcMember,
+      IfcMemberStandardCase,
+      IfcMemberType,
+      IfcMetric,
+      IfcMirroredProfileDef,
+      IfcMonetaryUnit,
+      IfcMotorConnection,
+      IfcMotorConnectionType,
+      IfcNamedUnit,
+      IfcObject,
+      IfcObjectDefinition,
+      IfcObjective,
+      IfcObjectPlacement,
+      IfcOccupant,
+      IfcOffsetCurve,
+      IfcOffsetCurve2D,
+      IfcOffsetCurve3D,
+      IfcOffsetCurveByDistances,
+      IfcOpeningElement,
+      IfcOpeningStandardCase,
+      IfcOpenShell,
+      IfcOrganization,
+      IfcOrganizationRelationship,
+      IfcOrientationExpression,
+      IfcOrientedEdge,
+      IfcOuterBoundaryCurve,
+      IfcOutlet,
+      IfcOutletType,
+      IfcOwnerHistory,
+      IfcParameterizedProfileDef,
+      IfcPath,
+      IfcPcurve,
+      IfcPerformanceHistory,
+      IfcPermeableCoveringProperties,
+      IfcPermit,
+      IfcPerson,
+      IfcPersonAndOrganization,
+      IfcPhysicalComplexQuantity,
+      IfcPhysicalQuantity,
+      IfcPhysicalSimpleQuantity,
+      IfcPile,
+      IfcPileType,
+      IfcPipeFitting,
+      IfcPipeFittingType,
+      IfcPipeSegment,
+      IfcPipeSegmentType,
+      IfcPixelTexture,
+      IfcPlacement,
+      IfcPlanarBox,
+      IfcPlanarExtent,
+      IfcPlane,
+      IfcPlate,
+      IfcPlateStandardCase,
+      IfcPlateType,
+      IfcPoint,
+      IfcPointOnCurve,
+      IfcPointOnSurface,
+      IfcPolygonalBoundedHalfSpace,
+      IfcPolygonalFaceSet,
+      IfcPolyline,
+      IfcPolyLoop,
+      IfcPort,
+      IfcPositioningElement,
+      IfcPostalAddress,
+      IfcPreDefinedColour,
+      IfcPreDefinedCurveFont,
+      IfcPreDefinedItem,
+      IfcPreDefinedProperties,
+      IfcPreDefinedPropertySet,
+      IfcPreDefinedTextFont,
+      IfcPresentationItem,
+      IfcPresentationLayerAssignment,
+      IfcPresentationLayerWithStyle,
+      IfcPresentationStyle,
+      IfcPresentationStyleAssignment,
+      IfcProcedure,
+      IfcProcedureType,
+      IfcProcess,
+      IfcProduct,
+      IfcProductDefinitionShape,
+      IfcProductRepresentation,
+      IfcProfileDef,
+      IfcProfileProperties,
+      IfcProject,
+      IfcProjectedCRS,
+      IfcProjectionElement,
+      IfcProjectLibrary,
+      IfcProjectOrder,
+      IfcProperty,
+      IfcPropertyAbstraction,
+      IfcPropertyBoundedValue,
+      IfcPropertyDefinition,
+      IfcPropertyDependencyRelationship,
+      IfcPropertyEnumeratedValue,
+      IfcPropertyEnumeration,
+      IfcPropertyListValue,
+      IfcPropertyReferenceValue,
+      IfcPropertySet,
+      IfcPropertySetDefinition,
+      IfcPropertySetTemplate,
+      IfcPropertySingleValue,
+      IfcPropertyTableValue,
+      IfcPropertyTemplate,
+      IfcPropertyTemplateDefinition,
+      IfcProtectiveDevice,
+      IfcProtectiveDeviceTrippingUnit,
+      IfcProtectiveDeviceTrippingUnitType,
+      IfcProtectiveDeviceType,
+      IfcProxy,
+      IfcPump,
+      IfcPumpType,
+      IfcQuantityArea,
+      IfcQuantityCount,
+      IfcQuantityLength,
+      IfcQuantitySet,
+      IfcQuantityTime,
+      IfcQuantityVolume,
+      IfcQuantityWeight,
+      IfcRailing,
+      IfcRailingType,
+      IfcRamp,
+      IfcRampFlight,
+      IfcRampFlightType,
+      IfcRampType,
+      IfcRationalBSplineCurveWithKnots,
+      IfcRationalBSplineSurfaceWithKnots,
+      IfcRectangleHollowProfileDef,
+      IfcRectangleProfileDef,
+      IfcRectangularPyramid,
+      IfcRectangularTrimmedSurface,
+      IfcRecurrencePattern,
+      IfcReference,
+      IfcReferent,
+      IfcRegularTimeSeries,
+      IfcReinforcementBarProperties,
+      IfcReinforcementDefinitionProperties,
+      IfcReinforcingBar,
+      IfcReinforcingBarType,
+      IfcReinforcingElement,
+      IfcReinforcingElementType,
+      IfcReinforcingMesh,
+      IfcReinforcingMeshType,
+      IfcRelAggregates,
+      IfcRelAssigns,
+      IfcRelAssignsToActor,
+      IfcRelAssignsToControl,
+      IfcRelAssignsToGroup,
+      IfcRelAssignsToGroupByFactor,
+      IfcRelAssignsToProcess,
+      IfcRelAssignsToProduct,
+      IfcRelAssignsToResource,
+      IfcRelAssociates,
+      IfcRelAssociatesApproval,
+      IfcRelAssociatesClassification,
+      IfcRelAssociatesConstraint,
+      IfcRelAssociatesDocument,
+      IfcRelAssociatesLibrary,
+      IfcRelAssociatesMaterial,
+      IfcRelationship,
+      IfcRelConnects,
+      IfcRelConnectsElements,
+      IfcRelConnectsPathElements,
+      IfcRelConnectsPorts,
+      IfcRelConnectsPortToElement,
+      IfcRelConnectsStructuralActivity,
+      IfcRelConnectsStructuralMember,
+      IfcRelConnectsWithEccentricity,
+      IfcRelConnectsWithRealizingElements,
+      IfcRelContainedInSpatialStructure,
+      IfcRelCoversBldgElements,
+      IfcRelCoversSpaces,
+      IfcRelDeclares,
+      IfcRelDecomposes,
+      IfcRelDefines,
+      IfcRelDefinesByObject,
+      IfcRelDefinesByProperties,
+      IfcRelDefinesByTemplate,
+      IfcRelDefinesByType,
+      IfcRelFillsElement,
+      IfcRelFlowControlElements,
+      IfcRelInterferesElements,
+      IfcRelNests,
+      IfcRelProjectsElement,
+      IfcRelReferencedInSpatialStructure,
+      IfcRelSequence,
+      IfcRelServicesBuildings,
+      IfcRelSpaceBoundary,
+      IfcRelSpaceBoundary1stLevel,
+      IfcRelSpaceBoundary2ndLevel,
+      IfcRelVoidsElement,
+      IfcReparametrisedCompositeCurveSegment,
+      IfcRepresentation,
+      IfcRepresentationContext,
+      IfcRepresentationItem,
+      IfcRepresentationMap,
+      IfcResource,
+      IfcResourceApprovalRelationship,
+      IfcResourceConstraintRelationship,
+      IfcResourceLevelRelationship,
+      IfcResourceTime,
+      IfcRevolvedAreaSolid,
+      IfcRevolvedAreaSolidTapered,
+      IfcRightCircularCone,
+      IfcRightCircularCylinder,
+      IfcRoof,
+      IfcRoofType,
+      IfcRoot,
+      IfcRoundedRectangleProfileDef,
+      IfcSanitaryTerminal,
+      IfcSanitaryTerminalType,
+      IfcSchedulingTime,
+      IfcSeamCurve,
+      IfcSectionedSolid,
+      IfcSectionedSolidHorizontal,
+      IfcSectionedSpine,
+      IfcSectionProperties,
+      IfcSectionReinforcementProperties,
+      IfcSensor,
+      IfcSensorType,
+      IfcShadingDevice,
+      IfcShadingDeviceType,
+      IfcShapeAspect,
+      IfcShapeModel,
+      IfcShapeRepresentation,
+      IfcShellBasedSurfaceModel,
+      IfcSimpleProperty,
+      IfcSimplePropertyTemplate,
+      IfcSite,
+      IfcSIUnit,
+      IfcSlab,
+      IfcSlabElementedCase,
+      IfcSlabStandardCase,
+      IfcSlabType,
+      IfcSlippageConnectionCondition,
+      IfcSolarDevice,
+      IfcSolarDeviceType,
+      IfcSolidModel,
+      IfcSpace,
+      IfcSpaceHeater,
+      IfcSpaceHeaterType,
+      IfcSpaceType,
+      IfcSpatialElement,
+      IfcSpatialElementType,
+      IfcSpatialStructureElement,
+      IfcSpatialStructureElementType,
+      IfcSpatialZone,
+      IfcSpatialZoneType,
+      IfcSphere,
+      IfcSphericalSurface,
+      IfcStackTerminal,
+      IfcStackTerminalType,
+      IfcStair,
+      IfcStairFlight,
+      IfcStairFlightType,
+      IfcStairType,
+      IfcStructuralAction,
+      IfcStructuralActivity,
+      IfcStructuralAnalysisModel,
+      IfcStructuralConnection,
+      IfcStructuralConnectionCondition,
+      IfcStructuralCurveAction,
+      IfcStructuralCurveConnection,
+      IfcStructuralCurveMember,
+      IfcStructuralCurveMemberVarying,
+      IfcStructuralCurveReaction,
+      IfcStructuralItem,
+      IfcStructuralLinearAction,
+      IfcStructuralLoad,
+      IfcStructuralLoadCase,
+      IfcStructuralLoadConfiguration,
+      IfcStructuralLoadGroup,
+      IfcStructuralLoadLinearForce,
+      IfcStructuralLoadOrResult,
+      IfcStructuralLoadPlanarForce,
+      IfcStructuralLoadSingleDisplacement,
+      IfcStructuralLoadSingleDisplacementDistortion,
+      IfcStructuralLoadSingleForce,
+      IfcStructuralLoadSingleForceWarping,
+      IfcStructuralLoadStatic,
+      IfcStructuralLoadTemperature,
+      IfcStructuralMember,
+      IfcStructuralPlanarAction,
+      IfcStructuralPointAction,
+      IfcStructuralPointConnection,
+      IfcStructuralPointReaction,
+      IfcStructuralReaction,
+      IfcStructuralResultGroup,
+      IfcStructuralSurfaceAction,
+      IfcStructuralSurfaceConnection,
+      IfcStructuralSurfaceMember,
+      IfcStructuralSurfaceMemberVarying,
+      IfcStructuralSurfaceReaction,
+      IfcStyledItem,
+      IfcStyledRepresentation,
+      IfcStyleModel,
+      IfcSubContractResource,
+      IfcSubContractResourceType,
+      IfcSubedge,
+      IfcSurface,
+      IfcSurfaceCurve,
+      IfcSurfaceCurveSweptAreaSolid,
+      IfcSurfaceFeature,
+      IfcSurfaceOfLinearExtrusion,
+      IfcSurfaceOfRevolution,
+      IfcSurfaceReinforcementArea,
+      IfcSurfaceStyle,
+      IfcSurfaceStyleLighting,
+      IfcSurfaceStyleRefraction,
+      IfcSurfaceStyleRendering,
+      IfcSurfaceStyleShading,
+      IfcSurfaceStyleWithTextures,
+      IfcSurfaceTexture,
+      IfcSweptAreaSolid,
+      IfcSweptDiskSolid,
+      IfcSweptDiskSolidPolygonal,
+      IfcSweptSurface,
+      IfcSwitchingDevice,
+      IfcSwitchingDeviceType,
+      IfcSystem,
+      IfcSystemFurnitureElement,
+      IfcSystemFurnitureElementType,
+      IfcTable,
+      IfcTableColumn,
+      IfcTableRow,
+      IfcTank,
+      IfcTankType,
+      IfcTask,
+      IfcTaskTime,
+      IfcTaskTimeRecurring,
+      IfcTaskType,
+      IfcTelecomAddress,
+      IfcTendon,
+      IfcTendonAnchor,
+      IfcTendonAnchorType,
+      IfcTendonType,
+      IfcTessellatedFaceSet,
+      IfcTessellatedItem,
+      IfcTextLiteral,
+      IfcTextLiteralWithExtent,
+      IfcTextStyle,
+      IfcTextStyleFontModel,
+      IfcTextStyleForDefinedFont,
+      IfcTextStyleTextModel,
+      IfcTextureCoordinate,
+      IfcTextureCoordinateGenerator,
+      IfcTextureMap,
+      IfcTextureVertex,
+      IfcTextureVertexList,
+      IfcTimePeriod,
+      IfcTimeSeries,
+      IfcTimeSeriesValue,
+      IfcTopologicalRepresentationItem,
+      IfcTopologyRepresentation,
+      IfcToroidalSurface,
+      IfcTransformer,
+      IfcTransformerType,
+      IfcTransitionCurveSegment2D,
+      IfcTransportElement,
+      IfcTransportElementType,
+      IfcTrapeziumProfileDef,
+      IfcTriangulatedFaceSet,
+      IfcTriangulatedIrregularNetwork,
+      IfcTrimmedCurve,
+      IfcTShapeProfileDef,
+      IfcTubeBundle,
+      IfcTubeBundleType,
+      IfcTypeObject,
+      IfcTypeProcess,
+      IfcTypeProduct,
+      IfcTypeResource,
+      IfcUnitaryControlElement,
+      IfcUnitaryControlElementType,
+      IfcUnitaryEquipment,
+      IfcUnitaryEquipmentType,
+      IfcUnitAssignment,
+      IfcUShapeProfileDef,
+      IfcValve,
+      IfcValveType,
+      IfcVector,
+      IfcVertex,
+      IfcVertexLoop,
+      IfcVertexPoint,
+      IfcVibrationIsolator,
+      IfcVibrationIsolatorType,
+      IfcVirtualElement,
+      IfcVirtualGridIntersection,
+      IfcVoidingFeature,
+      IfcWall,
+      IfcWallElementedCase,
+      IfcWallStandardCase,
+      IfcWallType,
+      IfcWasteTerminal,
+      IfcWasteTerminalType,
+      IfcWindow,
+      IfcWindowLiningProperties,
+      IfcWindowPanelProperties,
+      IfcWindowStandardCase,
+      IfcWindowStyle,
+      IfcWindowType,
+      IfcWorkCalendar,
+      IfcWorkControl,
+      IfcWorkPlan,
+      IfcWorkSchedule,
+      IfcWorkTime,
+      IfcZone,
+      IfcZShapeProfileDef,
+      UnKnown
+   }
+}
diff --git a/Source/Revit.IFC.Common/Enums/IFC4x2EntityType.cs b/Source/Revit.IFC.Common/Enums/IFC4x2EntityType.cs
new file mode 100644
index 00000000..dfd6ebb5
--- /dev/null
+++ b/Source/Revit.IFC.Common/Enums/IFC4x2EntityType.cs
@@ -0,0 +1,852 @@
+//
+// BIM IFC export alternate UI library: this library works with Autodesk(R) Revit(R) to provide an alternate user interface for the export of IFC files from Revit.
+// Copyright (C) 2013  Autodesk, Inc.
+// 
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Revit.IFC.Common.Enums.IFC4x2
+{
+   /// <summary>
+   /// IFC4x2 entity types.
+   /// <remarks>
+   /// Schema IFC4x2 currently withdrawn <see cref="https://technical.buildingsmart.org/standards/ifc/ifc-schema-specifications/"/>
+   /// </remarks>
+   /// </summary>
+   public enum IFCEntityType
+   {
+      IfcActionRequest,
+      IfcActor,
+      IfcActorRole,
+      IfcActuator,
+      IfcActuatorType,
+      IfcAddress,
+      IfcAdvancedBrep,
+      IfcAdvancedBrepWithVoids,
+      IfcAdvancedFace,
+      IfcAirTerminal,
+      IfcAirTerminalBox,
+      IfcAirTerminalBoxType,
+      IfcAirTerminalType,
+      IfcAirToAirHeatRecovery,
+      IfcAirToAirHeatRecoveryType,
+      IfcAlarm,
+      IfcAlarmType,
+      IfcAlignment,
+      IfcAlignment2DHorizontal,
+      IfcAlignment2DHorizontalSegment,
+      IfcAlignment2DSegment,
+      IfcAlignment2DVerSegCircularArc,
+      IfcAlignment2DVerSegLine,
+      IfcAlignment2DVerSegParabolicArc,
+      IfcAlignment2DVertical,
+      IfcAlignment2DVerticalSegment,
+      IfcAlignmentCurve,
+      IfcAnnotation,
+      IfcAnnotationFillArea,
+      IfcApplication,
+      IfcAppliedValue,
+      IfcApproval,
+      IfcApprovalRelationship,
+      IfcArbitraryClosedProfileDef,
+      IfcArbitraryOpenProfileDef,
+      IfcArbitraryProfileDefWithVoids,
+      IfcAsset,
+      IfcAsymmetricIShapeProfileDef,
+      IfcAudioVisualAppliance,
+      IfcAudioVisualApplianceType,
+      IfcAxis1Placement,
+      IfcAxis2Placement2D,
+      IfcAxis2Placement3D,
+      IfcBeam,
+      IfcBeamStandardCase,
+      IfcBeamType,
+      IfcBearing,
+      IfcBearingType,
+      IfcBlobTexture,
+      IfcBlock,
+      IfcBoiler,
+      IfcBoilerType,
+      IfcBooleanClippingResult,
+      IfcBooleanResult,
+      IfcBoundaryCondition,
+      IfcBoundaryCurve,
+      IfcBoundaryEdgeCondition,
+      IfcBoundaryFaceCondition,
+      IfcBoundaryNodeCondition,
+      IfcBoundaryNodeConditionWarping,
+      IfcBoundedCurve,
+      IfcBoundedSurface,
+      IfcBoundingBox,
+      IfcBoxedHalfSpace,
+      IfcBridge,
+      IfcBridgePart,
+      IfcBSplineCurve,
+      IfcBSplineCurveWithKnots,
+      IfcBSplineSurface,
+      IfcBSplineSurfaceWithKnots,
+      IfcBuilding,
+      IfcBuildingElement,
+      IfcBuildingElementPart,
+      IfcBuildingElementPartType,
+      IfcBuildingElementProxy,
+      IfcBuildingElementProxyType,
+      IfcBuildingElementType,
+      IfcBuildingStorey,
+      IfcBuildingSystem,
+      IfcBurner,
+      IfcBurnerType,
+      IfcCableCarrierFitting,
+      IfcCableCarrierFittingType,
+      IfcCableCarrierSegment,
+      IfcCableCarrierSegmentType,
+      IfcCableFitting,
+      IfcCableFittingType,
+      IfcCableSegment,
+      IfcCableSegmentType,
+      IfcCaissonFoundation,
+      IfcCaissonFoundationType,
+      IfcCartesianPoint,
+      IfcCartesianPointList,
+      IfcCartesianPointList2D,
+      IfcCartesianPointList3D,
+      IfcCartesianTransformationOperator,
+      IfcCartesianTransformationOperator2D,
+      IfcCartesianTransformationOperator2DnonUniform,
+      IfcCartesianTransformationOperator3D,
+      IfcCartesianTransformationOperator3DnonUniform,
+      IfcCenterLineProfileDef,
+      IfcChiller,
+      IfcChillerType,
+      IfcChimney,
+      IfcChimneyType,
+      IfcCircle,
+      IfcCircleHollowProfileDef,
+      IfcCircleProfileDef,
+      IfcCircularArcSegment2D,
+      IfcCivilElement,
+      IfcCivilElementType,
+      IfcClassification,
+      IfcClassificationReference,
+      IfcClosedShell,
+      IfcCoil,
+      IfcCoilType,
+      IfcColourRgb,
+      IfcColourRgbList,
+      IfcColourSpecification,
+      IfcColumn,
+      IfcColumnStandardCase,
+      IfcColumnType,
+      IfcCommunicationsAppliance,
+      IfcCommunicationsApplianceType,
+      IfcComplexProperty,
+      IfcComplexPropertyTemplate,
+      IfcCompositeCurve,
+      IfcCompositeCurveOnSurface,
+      IfcCompositeCurveSegment,
+      IfcCompositeProfileDef,
+      IfcCompressor,
+      IfcCompressorType,
+      IfcCondenser,
+      IfcCondenserType,
+      IfcConic,
+      IfcConnectedFaceSet,
+      IfcConnectionCurveGeometry,
+      IfcConnectionGeometry,
+      IfcConnectionPointEccentricity,
+      IfcConnectionPointGeometry,
+      IfcConnectionSurfaceGeometry,
+      IfcConnectionVolumeGeometry,
+      IfcConstraint,
+      IfcConstructionEquipmentResource,
+      IfcConstructionEquipmentResourceType,
+      IfcConstructionMaterialResource,
+      IfcConstructionMaterialResourceType,
+      IfcConstructionProductResource,
+      IfcConstructionProductResourceType,
+      IfcConstructionResource,
+      IfcConstructionResourceType,
+      IfcContext,
+      IfcContextDependentUnit,
+      IfcControl,
+      IfcController,
+      IfcControllerType,
+      IfcConversionBasedUnit,
+      IfcConversionBasedUnitWithOffset,
+      IfcCooledBeam,
+      IfcCooledBeamType,
+      IfcCoolingTower,
+      IfcCoolingTowerType,
+      IfcCoordinateOperation,
+      IfcCoordinateReferenceSystem,
+      IfcCostItem,
+      IfcCostSchedule,
+      IfcCostValue,
+      IfcCovering,
+      IfcCoveringType,
+      IfcCrewResource,
+      IfcCrewResourceType,
+      IfcCsgPrimitive3D,
+      IfcCsgSolid,
+      IfcCShapeProfileDef,
+      IfcCurrencyRelationship,
+      IfcCurtainWall,
+      IfcCurtainWallType,
+      IfcCurve,
+      IfcCurveBoundedPlane,
+      IfcCurveBoundedSurface,
+      IfcCurveSegment2D,
+      IfcCurveStyle,
+      IfcCurveStyleFont,
+      IfcCurveStyleFontAndScaling,
+      IfcCurveStyleFontPattern,
+      IfcCylindricalSurface,
+      IfcDamper,
+      IfcDamperType,
+      IfcDeepFoundation,
+      IfcDeepFoundationType,
+      IfcDerivedProfileDef,
+      IfcDerivedUnit,
+      IfcDerivedUnitElement,
+      IfcDimensionalExponents,
+      IfcDirection,
+      IfcDiscreteAccessory,
+      IfcDiscreteAccessoryType,
+      IfcDistanceExpression,
+      IfcDistributionChamberElement,
+      IfcDistributionChamberElementType,
+      IfcDistributionCircuit,
+      IfcDistributionControlElement,
+      IfcDistributionControlElementType,
+      IfcDistributionElement,
+      IfcDistributionElementType,
+      IfcDistributionFlowElement,
+      IfcDistributionFlowElementType,
+      IfcDistributionPort,
+      IfcDistributionSystem,
+      IfcDocumentInformation,
+      IfcDocumentInformationRelationship,
+      IfcDocumentReference,
+      IfcDoor,
+      IfcDoorLiningProperties,
+      IfcDoorPanelProperties,
+      IfcDoorStandardCase,
+      IfcDoorStyle,
+      IfcDoorType,
+      IfcDraughtingPreDefinedColour,
+      IfcDraughtingPreDefinedCurveFont,
+      IfcDuctFitting,
+      IfcDuctFittingType,
+      IfcDuctSegment,
+      IfcDuctSegmentType,
+      IfcDuctSilencer,
+      IfcDuctSilencerType,
+      IfcEdge,
+      IfcEdgeCurve,
+      IfcEdgeLoop,
+      IfcElectricAppliance,
+      IfcElectricApplianceType,
+      IfcElectricDistributionBoard,
+      IfcElectricDistributionBoardType,
+      IfcElectricFlowStorageDevice,
+      IfcElectricFlowStorageDeviceType,
+      IfcElectricGenerator,
+      IfcElectricGeneratorType,
+      IfcElectricMotor,
+      IfcElectricMotorType,
+      IfcElectricTimeControl,
+      IfcElectricTimeControlType,
+      IfcElement,
+      IfcElementarySurface,
+      IfcElementAssembly,
+      IfcElementAssemblyType,
+      IfcElementComponent,
+      IfcElementComponentType,
+      IfcElementQuantity,
+      IfcElementType,
+      IfcEllipse,
+      IfcEllipseProfileDef,
+      IfcEnergyConversionDevice,
+      IfcEnergyConversionDeviceType,
+      IfcEngine,
+      IfcEngineType,
+      IfcEvaporativeCooler,
+      IfcEvaporativeCoolerType,
+      IfcEvaporator,
+      IfcEvaporatorType,
+      IfcEvent,
+      IfcEventTime,
+      IfcEventType,
+      IfcExtendedProperties,
+      IfcExternalInformation,
+      IfcExternallyDefinedHatchStyle,
+      IfcExternallyDefinedSurfaceStyle,
+      IfcExternallyDefinedTextFont,
+      IfcExternalReference,
+      IfcExternalReferenceRelationship,
+      IfcExternalSpatialElement,
+      IfcExternalSpatialStructureElement,
+      IfcExtrudedAreaSolid,
+      IfcExtrudedAreaSolidTapered,
+      IfcFace,
+      IfcFaceBasedSurfaceModel,
+      IfcFaceBound,
+      IfcFaceOuterBound,
+      IfcFaceSurface,
+      IfcFacetedBrep,
+      IfcFacetedBrepWithVoids,
+      IfcFacility,
+      IfcFacilityPart,
+      IfcFailureConnectionCondition,
+      IfcFan,
+      IfcFanType,
+      IfcFastener,
+      IfcFastenerType,
+      IfcFeatureElement,
+      IfcFeatureElementAddition,
+      IfcFeatureElementSubtraction,
+      IfcFillAreaStyle,
+      IfcFillAreaStyleHatching,
+      IfcFillAreaStyleTiles,
+      IfcFilter,
+      IfcFilterType,
+      IfcFireSuppressionTerminal,
+      IfcFireSuppressionTerminalType,
+      IfcFixedReferenceSweptAreaSolid,
+      IfcFlowController,
+      IfcFlowControllerType,
+      IfcFlowFitting,
+      IfcFlowFittingType,
+      IfcFlowInstrument,
+      IfcFlowInstrumentType,
+      IfcFlowMeter,
+      IfcFlowMeterType,
+      IfcFlowMovingDevice,
+      IfcFlowMovingDeviceType,
+      IfcFlowSegment,
+      IfcFlowSegmentType,
+      IfcFlowStorageDevice,
+      IfcFlowStorageDeviceType,
+      IfcFlowTerminal,
+      IfcFlowTerminalType,
+      IfcFlowTreatmentDevice,
+      IfcFlowTreatmentDeviceType,
+      IfcFooting,
+      IfcFootingType,
+      IfcFurnishingElement,
+      IfcFurnishingElementType,
+      IfcFurniture,
+      IfcFurnitureType,
+      IfcGeographicElement,
+      IfcGeographicElementType,
+      IfcGeometricCurveSet,
+      IfcGeometricRepresentationContext,
+      IfcGeometricRepresentationItem,
+      IfcGeometricRepresentationSubContext,
+      IfcGeometricSet,
+      IfcGrid,
+      IfcGridAxis,
+      IfcGridPlacement,
+      IfcGroup,
+      IfcHalfSpaceSolid,
+      IfcHeatExchanger,
+      IfcHeatExchangerType,
+      IfcHumidifier,
+      IfcHumidifierType,
+      IfcImageTexture,
+      IfcIndexedColourMap,
+      IfcIndexedPolyCurve,
+      IfcIndexedPolygonalFace,
+      IfcIndexedPolygonalFaceWithVoids,
+      IfcIndexedTextureMap,
+      IfcIndexedTriangleTextureMap,
+      IfcInterceptor,
+      IfcInterceptorType,
+      IfcIntersectionCurve,
+      IfcInventory,
+      IfcIrregularTimeSeries,
+      IfcIrregularTimeSeriesValue,
+      IfcIShapeProfileDef,
+      IfcJunctionBox,
+      IfcJunctionBoxType,
+      IfcLaborResource,
+      IfcLaborResourceType,
+      IfcLagTime,
+      IfcLamp,
+      IfcLampType,
+      IfcLibraryInformation,
+      IfcLibraryReference,
+      IfcLightDistributionData,
+      IfcLightFixture,
+      IfcLightFixtureType,
+      IfcLightIntensityDistribution,
+      IfcLightSource,
+      IfcLightSourceAmbient,
+      IfcLightSourceDirectional,
+      IfcLightSourceGoniometric,
+      IfcLightSourcePositional,
+      IfcLightSourceSpot,
+      IfcLine,
+      IfcLinearPlacement,
+      IfcLinearPositioningElement,
+      IfcLineSegment2D,
+      IfcLocalPlacement,
+      IfcLoop,
+      IfcLShapeProfileDef,
+      IfcManifoldSolidBrep,
+      IfcMapConversion,
+      IfcMappedItem,
+      IfcMaterial,
+      IfcMaterialClassificationRelationship,
+      IfcMaterialConstituent,
+      IfcMaterialConstituentSet,
+      IfcMaterialDefinition,
+      IfcMaterialDefinitionRepresentation,
+      IfcMaterialLayer,
+      IfcMaterialLayerSet,
+      IfcMaterialLayerSetUsage,
+      IfcMaterialLayerWithOffsets,
+      IfcMaterialList,
+      IfcMaterialProfile,
+      IfcMaterialProfileSet,
+      IfcMaterialProfileSetUsage,
+      IfcMaterialProfileSetUsageTapering,
+      IfcMaterialProfileWithOffsets,
+      IfcMaterialProperties,
+      IfcMaterialRelationship,
+      IfcMaterialUsageDefinition,
+      IfcMeasureWithUnit,
+      IfcMechanicalFastener,
+      IfcMechanicalFastenerType,
+      IfcMedicalDevice,
+      IfcMedicalDeviceType,
+      IfcMember,
+      IfcMemberStandardCase,
+      IfcMemberType,
+      IfcMetric,
+      IfcMirroredProfileDef,
+      IfcMonetaryUnit,
+      IfcMotorConnection,
+      IfcMotorConnectionType,
+      IfcNamedUnit,
+      IfcObject,
+      IfcObjectDefinition,
+      IfcObjective,
+      IfcObjectPlacement,
+      IfcOccupant,
+      IfcOffsetCurve,
+      IfcOffsetCurve2D,
+      IfcOffsetCurve3D,
+      IfcOffsetCurveByDistances,
+      IfcOpeningElement,
+      IfcOpeningStandardCase,
+      IfcOpenShell,
+      IfcOrganization,
+      IfcOrganizationRelationship,
+      IfcOrientationExpression,
+      IfcOrientedEdge,
+      IfcOuterBoundaryCurve,
+      IfcOutlet,
+      IfcOutletType,
+      IfcOwnerHistory,
+      IfcParameterizedProfileDef,
+      IfcPath,
+      IfcPcurve,
+      IfcPerformanceHistory,
+      IfcPermeableCoveringProperties,
+      IfcPermit,
+      IfcPerson,
+      IfcPersonAndOrganization,
+      IfcPhysicalComplexQuantity,
+      IfcPhysicalQuantity,
+      IfcPhysicalSimpleQuantity,
+      IfcPile,
+      IfcPileType,
+      IfcPipeFitting,
+      IfcPipeFittingType,
+      IfcPipeSegment,
+      IfcPipeSegmentType,
+      IfcPixelTexture,
+      IfcPlacement,
+      IfcPlanarBox,
+      IfcPlanarExtent,
+      IfcPlane,
+      IfcPlate,
+      IfcPlateStandardCase,
+      IfcPlateType,
+      IfcPoint,
+      IfcPointOnCurve,
+      IfcPointOnSurface,
+      IfcPolygonalBoundedHalfSpace,
+      IfcPolygonalFaceSet,
+      IfcPolyline,
+      IfcPolyLoop,
+      IfcPort,
+      IfcPositioningElement,
+      IfcPostalAddress,
+      IfcPreDefinedColour,
+      IfcPreDefinedCurveFont,
+      IfcPreDefinedItem,
+      IfcPreDefinedProperties,
+      IfcPreDefinedPropertySet,
+      IfcPreDefinedTextFont,
+      IfcPresentationItem,
+      IfcPresentationLayerAssignment,
+      IfcPresentationLayerWithStyle,
+      IfcPresentationStyle,
+      IfcPresentationStyleAssignment,
+      IfcProcedure,
+      IfcProcedureType,
+      IfcProcess,
+      IfcProduct,
+      IfcProductDefinitionShape,
+      IfcProductRepresentation,
+      IfcProfileDef,
+      IfcProfileProperties,
+      IfcProject,
+      IfcProjectedCRS,
+      IfcProjectionElement,
+      IfcProjectLibrary,
+      IfcProjectOrder,
+      IfcProperty,
+      IfcPropertyAbstraction,
+      IfcPropertyBoundedValue,
+      IfcPropertyDefinition,
+      IfcPropertyDependencyRelationship,
+      IfcPropertyEnumeratedValue,
+      IfcPropertyEnumeration,
+      IfcPropertyListValue,
+      IfcPropertyReferenceValue,
+      IfcPropertySet,
+      IfcPropertySetDefinition,
+      IfcPropertySetTemplate,
+      IfcPropertySingleValue,
+      IfcPropertyTableValue,
+      IfcPropertyTemplate,
+      IfcPropertyTemplateDefinition,
+      IfcProtectiveDevice,
+      IfcProtectiveDeviceTrippingUnit,
+      IfcProtectiveDeviceTrippingUnitType,
+      IfcProtectiveDeviceType,
+      IfcProxy,
+      IfcPump,
+      IfcPumpType,
+      IfcQuantityArea,
+      IfcQuantityCount,
+      IfcQuantityLength,
+      IfcQuantitySet,
+      IfcQuantityTime,
+      IfcQuantityVolume,
+      IfcQuantityWeight,
+      IfcRailing,
+      IfcRailingType,
+      IfcRamp,
+      IfcRampFlight,
+      IfcRampFlightType,
+      IfcRampType,
+      IfcRationalBSplineCurveWithKnots,
+      IfcRationalBSplineSurfaceWithKnots,
+      IfcRectangleHollowProfileDef,
+      IfcRectangleProfileDef,
+      IfcRectangularPyramid,
+      IfcRectangularTrimmedSurface,
+      IfcRecurrencePattern,
+      IfcReference,
+      IfcReferent,
+      IfcRegularTimeSeries,
+      IfcReinforcementBarProperties,
+      IfcReinforcementDefinitionProperties,
+      IfcReinforcingBar,
+      IfcReinforcingBarType,
+      IfcReinforcingElement,
+      IfcReinforcingElementType,
+      IfcReinforcingMesh,
+      IfcReinforcingMeshType,
+      IfcRelAggregates,
+      IfcRelAssigns,
+      IfcRelAssignsToActor,
+      IfcRelAssignsToControl,
+      IfcRelAssignsToGroup,
+      IfcRelAssignsToGroupByFactor,
+      IfcRelAssignsToProcess,
+      IfcRelAssignsToProduct,
+      IfcRelAssignsToResource,
+      IfcRelAssociates,
+      IfcRelAssociatesApproval,
+      IfcRelAssociatesClassification,
+      IfcRelAssociatesConstraint,
+      IfcRelAssociatesDocument,
+      IfcRelAssociatesLibrary,
+      IfcRelAssociatesMaterial,
+      IfcRelationship,
+      IfcRelConnects,
+      IfcRelConnectsElements,
+      IfcRelConnectsPathElements,
+      IfcRelConnectsPorts,
+      IfcRelConnectsPortToElement,
+      IfcRelConnectsStructuralActivity,
+      IfcRelConnectsStructuralMember,
+      IfcRelConnectsWithEccentricity,
+      IfcRelConnectsWithRealizingElements,
+      IfcRelContainedInSpatialStructure,
+      IfcRelCoversBldgElements,
+      IfcRelCoversSpaces,
+      IfcRelDeclares,
+      IfcRelDecomposes,
+      IfcRelDefines,
+      IfcRelDefinesByObject,
+      IfcRelDefinesByProperties,
+      IfcRelDefinesByTemplate,
+      IfcRelDefinesByType,
+      IfcRelFillsElement,
+      IfcRelFlowControlElements,
+      IfcRelInterferesElements,
+      IfcRelNests,
+      IfcRelPositions,
+      IfcRelProjectsElement,
+      IfcRelReferencedInSpatialStructure,
+      IfcRelSequence,
+      IfcRelServicesBuildings,
+      IfcRelSpaceBoundary,
+      IfcRelSpaceBoundary1stLevel,
+      IfcRelSpaceBoundary2ndLevel,
+      IfcRelVoidsElement,
+      IfcReparametrisedCompositeCurveSegment,
+      IfcRepresentation,
+      IfcRepresentationContext,
+      IfcRepresentationItem,
+      IfcRepresentationMap,
+      IfcResource,
+      IfcResourceApprovalRelationship,
+      IfcResourceConstraintRelationship,
+      IfcResourceLevelRelationship,
+      IfcResourceTime,
+      IfcRevolvedAreaSolid,
+      IfcRevolvedAreaSolidTapered,
+      IfcRightCircularCone,
+      IfcRightCircularCylinder,
+      IfcRoof,
+      IfcRoofType,
+      IfcRoot,
+      IfcRoundedRectangleProfileDef,
+      IfcSanitaryTerminal,
+      IfcSanitaryTerminalType,
+      IfcSchedulingTime,
+      IfcSeamCurve,
+      IfcSectionedSolid,
+      IfcSectionedSolidHorizontal,
+      IfcSectionedSpine,
+      IfcSectionProperties,
+      IfcSectionReinforcementProperties,
+      IfcSensor,
+      IfcSensorType,
+      IfcShadingDevice,
+      IfcShadingDeviceType,
+      IfcShapeAspect,
+      IfcShapeModel,
+      IfcShapeRepresentation,
+      IfcShellBasedSurfaceModel,
+      IfcSimpleProperty,
+      IfcSimplePropertyTemplate,
+      IfcSite,
+      IfcSIUnit,
+      IfcSlab,
+      IfcSlabElementedCase,
+      IfcSlabStandardCase,
+      IfcSlabType,
+      IfcSlippageConnectionCondition,
+      IfcSolarDevice,
+      IfcSolarDeviceType,
+      IfcSolidModel,
+      IfcSpace,
+      IfcSpaceHeater,
+      IfcSpaceHeaterType,
+      IfcSpaceType,
+      IfcSpatialElement,
+      IfcSpatialElementType,
+      IfcSpatialStructureElement,
+      IfcSpatialStructureElementType,
+      IfcSpatialZone,
+      IfcSpatialZoneType,
+      IfcSphere,
+      IfcSphericalSurface,
+      IfcStackTerminal,
+      IfcStackTerminalType,
+      IfcStair,
+      IfcStairFlight,
+      IfcStairFlightType,
+      IfcStairType,
+      IfcStructuralAction,
+      IfcStructuralActivity,
+      IfcStructuralAnalysisModel,
+      IfcStructuralConnection,
+      IfcStructuralConnectionCondition,
+      IfcStructuralCurveAction,
+      IfcStructuralCurveConnection,
+      IfcStructuralCurveMember,
+      IfcStructuralCurveMemberVarying,
+      IfcStructuralCurveReaction,
+      IfcStructuralItem,
+      IfcStructuralLinearAction,
+      IfcStructuralLoad,
+      IfcStructuralLoadCase,
+      IfcStructuralLoadConfiguration,
+      IfcStructuralLoadGroup,
+      IfcStructuralLoadLinearForce,
+      IfcStructuralLoadOrResult,
+      IfcStructuralLoadPlanarForce,
+      IfcStructuralLoadSingleDisplacement,
+      IfcStructuralLoadSingleDisplacementDistortion,
+      IfcStructuralLoadSingleForce,
+      IfcStructuralLoadSingleForceWarping,
+      IfcStructuralLoadStatic,
+      IfcStructuralLoadTemperature,
+      IfcStructuralMember,
+      IfcStructuralPlanarAction,
+      IfcStructuralPointAction,
+      IfcStructuralPointConnection,
+      IfcStructuralPointReaction,
+      IfcStructuralReaction,
+      IfcStructuralResultGroup,
+      IfcStructuralSurfaceAction,
+      IfcStructuralSurfaceConnection,
+      IfcStructuralSurfaceMember,
+      IfcStructuralSurfaceMemberVarying,
+      IfcStructuralSurfaceReaction,
+      IfcStyledItem,
+      IfcStyledRepresentation,
+      IfcStyleModel,
+      IfcSubContractResource,
+      IfcSubContractResourceType,
+      IfcSubedge,
+      IfcSurface,
+      IfcSurfaceCurve,
+      IfcSurfaceCurveSweptAreaSolid,
+      IfcSurfaceFeature,
+      IfcSurfaceOfLinearExtrusion,
+      IfcSurfaceOfRevolution,
+      IfcSurfaceReinforcementArea,
+      IfcSurfaceStyle,
+      IfcSurfaceStyleLighting,
+      IfcSurfaceStyleRefraction,
+      IfcSurfaceStyleRendering,
+      IfcSurfaceStyleShading,
+      IfcSurfaceStyleWithTextures,
+      IfcSurfaceTexture,
+      IfcSweptAreaSolid,
+      IfcSweptDiskSolid,
+      IfcSweptDiskSolidPolygonal,
+      IfcSweptSurface,
+      IfcSwitchingDevice,
+      IfcSwitchingDeviceType,
+      IfcSystem,
+      IfcSystemFurnitureElement,
+      IfcSystemFurnitureElementType,
+      IfcTable,
+      IfcTableColumn,
+      IfcTableRow,
+      IfcTank,
+      IfcTankType,
+      IfcTask,
+      IfcTaskTime,
+      IfcTaskTimeRecurring,
+      IfcTaskType,
+      IfcTelecomAddress,
+      IfcTendon,
+      IfcTendonAnchor,
+      IfcTendonAnchorType,
+      IfcTendonConduit,
+      IfcTendonConduitType,
+      IfcTendonType,
+      IfcTessellatedFaceSet,
+      IfcTessellatedItem,
+      IfcTextLiteral,
+      IfcTextLiteralWithExtent,
+      IfcTextStyle,
+      IfcTextStyleFontModel,
+      IfcTextStyleForDefinedFont,
+      IfcTextStyleTextModel,
+      IfcTextureCoordinate,
+      IfcTextureCoordinateGenerator,
+      IfcTextureMap,
+      IfcTextureVertex,
+      IfcTextureVertexList,
+      IfcTimePeriod,
+      IfcTimeSeries,
+      IfcTimeSeriesValue,
+      IfcTopologicalRepresentationItem,
+      IfcTopologyRepresentation,
+      IfcToroidalSurface,
+      IfcTransformer,
+      IfcTransformerType,
+      IfcTransitionCurveSegment2D,
+      IfcTransportElement,
+      IfcTransportElementType,
+      IfcTrapeziumProfileDef,
+      IfcTriangulatedFaceSet,
+      IfcTriangulatedIrregularNetwork,
+      IfcTrimmedCurve,
+      IfcTShapeProfileDef,
+      IfcTubeBundle,
+      IfcTubeBundleType,
+      IfcTypeObject,
+      IfcTypeProcess,
+      IfcTypeProduct,
+      IfcTypeResource,
+      IfcUnitaryControlElement,
+      IfcUnitaryControlElementType,
+      IfcUnitaryEquipment,
+      IfcUnitaryEquipmentType,
+      IfcUnitAssignment,
+      IfcUShapeProfileDef,
+      IfcValve,
+      IfcValveType,
+      IfcVector,
+      IfcVertex,
+      IfcVertexLoop,
+      IfcVertexPoint,
+      IfcVibrationDamper,
+      IfcVibrationDamperType,
+      IfcVibrationIsolator,
+      IfcVibrationIsolatorType,
+      IfcVirtualElement,
+      IfcVirtualGridIntersection,
+      IfcVoidingFeature,
+      IfcWall,
+      IfcWallElementedCase,
+      IfcWallStandardCase,
+      IfcWallType,
+      IfcWasteTerminal,
+      IfcWasteTerminalType,
+      IfcWindow,
+      IfcWindowLiningProperties,
+      IfcWindowPanelProperties,
+      IfcWindowStandardCase,
+      IfcWindowStyle,
+      IfcWindowType,
+      IfcWorkCalendar,
+      IfcWorkControl,
+      IfcWorkPlan,
+      IfcWorkSchedule,
+      IfcWorkTime,
+      IfcZone,
+      IfcZShapeProfileDef,
+      UnKnown
+   }
+}
diff --git a/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs b/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
new file mode 100644
index 00000000..db903af7
--- /dev/null
+++ b/Source/Revit.IFC.Common/Enums/IFC4x3EntityType.cs
@@ -0,0 +1,910 @@
+//
+// BIM IFC export alternate UI library: this library works with Autodesk(R) Revit(R) to provide an alternate user interface for the export of IFC files from Revit.
+// Copyright (C) 2013  Autodesk, Inc.
+// 
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Revit.IFC.Common.Enums.IFC4x3
+{
+   /// <summary>
+   /// IFC4x3 entity types (updated to IFC4_RC3).
+   /// </summary>
+   public enum IFCEntityType
+   {
+      IfcActionRequest,
+      IfcActor,
+      IfcActorRole,
+      IfcActuator,
+      IfcActuatorType,
+      IfcAddress,
+      IfcAdvancedBrep,
+      IfcAdvancedBrepWithVoids,
+      IfcAdvancedFace,
+      IfcAirTerminal,
+      IfcAirTerminalBox,
+      IfcAirTerminalBoxType,
+      IfcAirTerminalType,
+      IfcAirToAirHeatRecovery,
+      IfcAirToAirHeatRecoveryType,
+      IfcAlarm,
+      IfcAlarmType,
+      IfcAlignment,
+      IfcAlignmentCant,
+      IfcAlignmentCantSegment,
+      IfcAlignmentHorizontal,
+      IfcAlignmentHorizontalSegment,
+      IfcAlignmentParameterSegment,
+      IfcAlignmentSegment,
+      IfcAlignmentVertical,
+      IfcAlignmentVerticalSegment,
+      IfcAnnotation,
+      IfcAnnotationFillArea,
+      IfcApplication,
+      IfcAppliedValue,
+      IfcApproval,
+      IfcApprovalRelationship,
+      IfcArbitraryClosedProfileDef,
+      IfcArbitraryOpenProfileDef,
+      IfcArbitraryProfileDefWithVoids,
+      IfcAsset,
+      IfcAsymmetricIShapeProfileDef,
+      IfcAudioVisualAppliance,
+      IfcAudioVisualApplianceType,
+      IfcAxis1Placement,
+      IfcAxis2Placement2D,
+      IfcAxis2Placement3D,
+      IfcAxis2PlacementLinear,
+      IfcBeam,
+      IfcBeamStandardCase,
+      IfcBeamType,
+      IfcBearing,
+      IfcBearingType,
+      IfcBlobTexture,
+      IfcBlock,
+      IfcBlossCurve,
+      IfcBoiler,
+      IfcBoilerType,
+      IfcBooleanClippingResult,
+      IfcBooleanResult,
+      IfcBorehole,
+      IfcBoundaryCondition,
+      IfcBoundaryCurve,
+      IfcBoundaryEdgeCondition,
+      IfcBoundaryFaceCondition,
+      IfcBoundaryNodeCondition,
+      IfcBoundaryNodeConditionWarping,
+      IfcBoundedCurve,
+      IfcBoundedSurface,
+      IfcBoundingBox,
+      IfcBoxedHalfSpace,
+      IfcBridge,
+      IfcBSplineCurve,
+      IfcBSplineCurveWithKnots,
+      IfcBSplineSurface,
+      IfcBSplineSurfaceWithKnots,
+      IfcBuilding,
+      IfcBuildingElementPart,
+      IfcBuildingElementPartType,
+      IfcBuildingElementProxy,
+      IfcBuildingElementProxyType,
+      IfcBuildingStorey,
+      IfcBuildingSystem,
+      IfcBuiltElement,
+      IfcBuiltElementType,
+      IfcBuiltSystem,
+      IfcBurner,
+      IfcBurnerType,
+      IfcCableCarrierFitting,
+      IfcCableCarrierFittingType,
+      IfcCableCarrierSegment,
+      IfcCableCarrierSegmentType,
+      IfcCableFitting,
+      IfcCableFittingType,
+      IfcCableSegment,
+      IfcCableSegmentType,
+      IfcCaissonFoundation,
+      IfcCaissonFoundationType,
+      IfcCartesianPoint,
+      IfcCartesianPointList,
+      IfcCartesianPointList2D,
+      IfcCartesianPointList3D,
+      IfcCartesianTransformationOperator,
+      IfcCartesianTransformationOperator2D,
+      IfcCartesianTransformationOperator2DnonUniform,
+      IfcCartesianTransformationOperator3D,
+      IfcCartesianTransformationOperator3DnonUniform,
+      IfcCenterLineProfileDef,
+      IfcChiller,
+      IfcChillerType,
+      IfcChimney,
+      IfcChimneyType,
+      IfcCircle,
+      IfcCircleHollowProfileDef,
+      IfcCircleProfileDef,
+      IfcCivilElement,
+      IfcCivilElementType,
+      IfcClassification,
+      IfcClassificationReference,
+      IfcClosedShell,
+      IfcClothoid,
+      IfcCoil,
+      IfcCoilType,
+      IfcColourRgb,
+      IfcColourRgbList,
+      IfcColourSpecification,
+      IfcColumn,
+      IfcColumnStandardCase,
+      IfcColumnType,
+      IfcCommunicationsAppliance,
+      IfcCommunicationsApplianceType,
+      IfcComplexProperty,
+      IfcComplexPropertyTemplate,
+      IfcCompositeCurve,
+      IfcCompositeCurveOnSurface,
+      IfcCompositeCurveSegment,
+      IfcCompositeProfileDef,
+      IfcCompressor,
+      IfcCompressorType,
+      IfcCondenser,
+      IfcCondenserType,
+      IfcConic,
+      IfcConnectedFaceSet,
+      IfcConnectionCurveGeometry,
+      IfcConnectionGeometry,
+      IfcConnectionPointEccentricity,
+      IfcConnectionPointGeometry,
+      IfcConnectionSurfaceGeometry,
+      IfcConnectionVolumeGeometry,
+      IfcConstraint,
+      IfcConstructionEquipmentResource,
+      IfcConstructionEquipmentResourceType,
+      IfcConstructionMaterialResource,
+      IfcConstructionMaterialResourceType,
+      IfcConstructionProductResource,
+      IfcConstructionProductResourceType,
+      IfcConstructionResource,
+      IfcConstructionResourceType,
+      IfcContext,
+      IfcContextDependentUnit,
+      IfcControl,
+      IfcController,
+      IfcControllerType,
+      IfcConversionBasedUnit,
+      IfcConversionBasedUnitWithOffset,
+      IfcConveyorSegment,
+      IfcConveyorSegmentType,
+      IfcCooledBeam,
+      IfcCooledBeamType,
+      IfcCoolingTower,
+      IfcCoolingTowerType,
+      IfcCoordinateOperation,
+      IfcCoordinateReferenceSystem,
+      IfcCosine,
+      IfcCostItem,
+      IfcCostSchedule,
+      IfcCostValue,
+      IfcCourse,
+      IfcCourseType,
+      IfcCovering,
+      IfcCoveringType,
+      IfcCrewResource,
+      IfcCrewResourceType,
+      IfcCsgPrimitive3D,
+      IfcCsgSolid,
+      IfcCShapeProfileDef,
+      IfcCurrencyRelationship,
+      IfcCurtainWall,
+      IfcCurtainWallType,
+      IfcCurve,
+      IfcCurveBoundedPlane,
+      IfcCurveBoundedSurface,
+      IfcCurveSegment,
+      IfcCurveStyle,
+      IfcCurveStyleFont,
+      IfcCurveStyleFontAndScaling,
+      IfcCurveStyleFontPattern,
+      IfcCylindricalSurface,
+      IfcDamper,
+      IfcDamperType,
+      IfcDeepFoundation,
+      IfcDeepFoundationType,
+      IfcDerivedProfileDef,
+      IfcDerivedUnit,
+      IfcDerivedUnitElement,
+      IfcDimensionalExponents,
+      IfcDirection,
+      IfcDirectrixCurveSweptAreaSolid,
+      IfcDirectrixDistanceSweptAreaSolid,
+      IfcDiscreteAccessory,
+      IfcDiscreteAccessoryType,
+      IfcDistributionBoard,
+      IfcDistributionBoardType,
+      IfcDistributionChamberElement,
+      IfcDistributionChamberElementType,
+      IfcDistributionCircuit,
+      IfcDistributionControlElement,
+      IfcDistributionControlElementType,
+      IfcDistributionElement,
+      IfcDistributionElementType,
+      IfcDistributionFlowElement,
+      IfcDistributionFlowElementType,
+      IfcDistributionPort,
+      IfcDistributionSystem,
+      IfcDocumentInformation,
+      IfcDocumentInformationRelationship,
+      IfcDocumentReference,
+      IfcDoor,
+      IfcDoorLiningProperties,
+      IfcDoorPanelProperties,
+      IfcDoorStandardCase,
+      IfcDoorStyle,
+      IfcDoorType,
+      IfcDraughtingPreDefinedColour,
+      IfcDraughtingPreDefinedCurveFont,
+      IfcDuctFitting,
+      IfcDuctFittingType,
+      IfcDuctSegment,
+      IfcDuctSegmentType,
+      IfcDuctSilencer,
+      IfcDuctSilencerType,
+      IfcEarthworksCut,
+      IfcEarthworksElement,
+      IfcEarthworksFill,
+      IfcEdge,
+      IfcEdgeCurve,
+      IfcEdgeLoop,
+      IfcElectricAppliance,
+      IfcElectricApplianceType,
+      IfcElectricDistributionBoard,
+      IfcElectricDistributionBoardType,
+      IfcElectricFlowStorageDevice,
+      IfcElectricFlowStorageDeviceType,
+      IfcElectricFlowTreatmentDevice,
+      IfcElectricFlowTreatmentDeviceType,
+      IfcElectricGenerator,
+      IfcElectricGeneratorType,
+      IfcElectricMotor,
+      IfcElectricMotorType,
+      IfcElectricTimeControl,
+      IfcElectricTimeControlType,
+      IfcElement,
+      IfcElementarySurface,
+      IfcElementAssembly,
+      IfcElementAssemblyType,
+      IfcElementComponent,
+      IfcElementComponentType,
+      IfcElementQuantity,
+      IfcElementType,
+      IfcEllipse,
+      IfcEllipseProfileDef,
+      IfcEnergyConversionDevice,
+      IfcEnergyConversionDeviceType,
+      IfcEngine,
+      IfcEngineType,
+      IfcEvaporativeCooler,
+      IfcEvaporativeCoolerType,
+      IfcEvaporator,
+      IfcEvaporatorType,
+      IfcEvent,
+      IfcEventTime,
+      IfcEventType,
+      IfcExtendedProperties,
+      IfcExternalInformation,
+      IfcExternallyDefinedHatchStyle,
+      IfcExternallyDefinedSurfaceStyle,
+      IfcExternallyDefinedTextFont,
+      IfcExternalReference,
+      IfcExternalReferenceRelationship,
+      IfcExternalSpatialElement,
+      IfcExternalSpatialStructureElement,
+      IfcExtrudedAreaSolid,
+      IfcExtrudedAreaSolidTapered,
+      IfcFace,
+      IfcFaceBasedSurfaceModel,
+      IfcFaceBound,
+      IfcFaceOuterBound,
+      IfcFaceSurface,
+      IfcFacetedBrep,
+      IfcFacetedBrepWithVoids,
+      IfcFacility,
+      IfcFacilityPart,
+      IfcFailureConnectionCondition,
+      IfcFan,
+      IfcFanType,
+      IfcFastener,
+      IfcFastenerType,
+      IfcFeatureElement,
+      IfcFeatureElementAddition,
+      IfcFeatureElementSubtraction,
+      IfcFillAreaStyle,
+      IfcFillAreaStyleHatching,
+      IfcFillAreaStyleTiles,
+      IfcFilter,
+      IfcFilterType,
+      IfcFireSuppressionTerminal,
+      IfcFireSuppressionTerminalType,
+      IfcFixedReferenceSweptAreaSolid,
+      IfcFlowController,
+      IfcFlowControllerType,
+      IfcFlowFitting,
+      IfcFlowFittingType,
+      IfcFlowInstrument,
+      IfcFlowInstrumentType,
+      IfcFlowMeter,
+      IfcFlowMeterType,
+      IfcFlowMovingDevice,
+      IfcFlowMovingDeviceType,
+      IfcFlowSegment,
+      IfcFlowSegmentType,
+      IfcFlowStorageDevice,
+      IfcFlowStorageDeviceType,
+      IfcFlowTerminal,
+      IfcFlowTerminalType,
+      IfcFlowTreatmentDevice,
+      IfcFlowTreatmentDeviceType,
+      IfcFooting,
+      IfcFootingType,
+      IfcFurnishingElement,
+      IfcFurnishingElementType,
+      IfcFurniture,
+      IfcFurnitureType,
+      IfcGeographicElement,
+      IfcGeographicElementType,
+      IfcGeometricCurveSet,
+      IfcGeometricRepresentationContext,
+      IfcGeometricRepresentationItem,
+      IfcGeometricRepresentationSubContext,
+      IfcGeometricSet,
+      IfcGeomodel,
+      IfcGeoslice,
+      IfcGeotechnicalAssembly,
+      IfcGeotechnicalElement,
+      IfcGeotechnicalStratum,
+      IfcGradientCurve,
+      IfcGrid,
+      IfcGridAxis,
+      IfcGridPlacement,
+      IfcGroup,
+      IfcHalfSpaceSolid,
+      IfcHeatExchanger,
+      IfcHeatExchangerType,
+      IfcHelmertCurve,
+      IfcHumidifier,
+      IfcHumidifierType,
+      IfcImageTexture,
+      IfcImpactProtectionDevice,
+      IfcImpactProtectionDeviceType,
+      IfcInclinedReferenceSweptAreaSolid,
+      IfcIndexedColourMap,
+      IfcIndexedPolyCurve,
+      IfcIndexedPolygonalFace,
+      IfcIndexedPolygonalFaceWithVoids,
+      IfcIndexedTextureMap,
+      IfcIndexedTriangleTextureMap,
+      IfcInterceptor,
+      IfcInterceptorType,
+      IfcIntersectionCurve,
+      IfcInventory,
+      IfcIrregularTimeSeries,
+      IfcIrregularTimeSeriesValue,
+      IfcIShapeProfileDef,
+      IfcJunctionBox,
+      IfcJunctionBoxType,
+      IfcKerb,
+      IfcKerbType,
+      IfcLaborResource,
+      IfcLaborResourceType,
+      IfcLagTime,
+      IfcLamp,
+      IfcLampType,
+      IfcLibraryInformation,
+      IfcLibraryReference,
+      IfcLightDistributionData,
+      IfcLightFixture,
+      IfcLightFixtureType,
+      IfcLightIntensityDistribution,
+      IfcLightSource,
+      IfcLightSourceAmbient,
+      IfcLightSourceDirectional,
+      IfcLightSourceGoniometric,
+      IfcLightSourcePositional,
+      IfcLightSourceSpot,
+      IfcLine,
+      IfcLinearElement,
+      IfcLinearPlacement,
+      IfcLinearPositioningElement,
+      IfcLiquidTerminal,
+      IfcLiquidTerminalType,
+      IfcLocalPlacement,
+      IfcLoop,
+      IfcLShapeProfileDef,
+      IfcManifoldSolidBrep,
+      IfcMapConversion,
+      IfcMappedItem,
+      IfcMarineFacility,
+      IfcMaterial,
+      IfcMaterialClassificationRelationship,
+      IfcMaterialConstituent,
+      IfcMaterialConstituentSet,
+      IfcMaterialDefinition,
+      IfcMaterialDefinitionRepresentation,
+      IfcMaterialLayer,
+      IfcMaterialLayerSet,
+      IfcMaterialLayerSetUsage,
+      IfcMaterialLayerWithOffsets,
+      IfcMaterialList,
+      IfcMaterialProfile,
+      IfcMaterialProfileSet,
+      IfcMaterialProfileSetUsage,
+      IfcMaterialProfileSetUsageTapering,
+      IfcMaterialProfileWithOffsets,
+      IfcMaterialProperties,
+      IfcMaterialRelationship,
+      IfcMaterialUsageDefinition,
+      IfcMeasureWithUnit,
+      IfcMechanicalFastener,
+      IfcMechanicalFastenerType,
+      IfcMedicalDevice,
+      IfcMedicalDeviceType,
+      IfcMember,
+      IfcMemberStandardCase,
+      IfcMemberType,
+      IfcMetric,
+      IfcMirroredProfileDef,
+      IfcMobileTelecommunicationsAppliance,
+      IfcMobileTelecommunicationsApplianceType,
+      IfcMonetaryUnit,
+      IfcMooringDevice,
+      IfcMooringDeviceType,
+      IfcMotorConnection,
+      IfcMotorConnectionType,
+      IfcNamedUnit,
+      IfcNavigationElement,
+      IfcNavigationElementType,
+      IfcObject,
+      IfcObjectDefinition,
+      IfcObjective,
+      IfcObjectPlacement,
+      IfcOccupant,
+      IfcOffsetCurve,
+      IfcOffsetCurve2D,
+      IfcOffsetCurve3D,
+      IfcOffsetCurveByDistances,
+      IfcOpenCrossProfileDef,
+      IfcOpeningElement,
+      IfcOpeningStandardCase,
+      IfcOpenShell,
+      IfcOrganization,
+      IfcOrganizationRelationship,
+      IfcOrientedEdge,
+      IfcOuterBoundaryCurve,
+      IfcOutlet,
+      IfcOutletType,
+      IfcOwnerHistory,
+      IfcParameterizedProfileDef,
+      IfcPath,
+      IfcPavement,
+      IfcPavementType,
+      IfcPcurve,
+      IfcPerformanceHistory,
+      IfcPermeableCoveringProperties,
+      IfcPermit,
+      IfcPerson,
+      IfcPersonAndOrganization,
+      IfcPhysicalComplexQuantity,
+      IfcPhysicalQuantity,
+      IfcPhysicalSimpleQuantity,
+      IfcPile,
+      IfcPileType,
+      IfcPipeFitting,
+      IfcPipeFittingType,
+      IfcPipeSegment,
+      IfcPipeSegmentType,
+      IfcPixelTexture,
+      IfcPlacement,
+      IfcPlanarBox,
+      IfcPlanarExtent,
+      IfcPlane,
+      IfcPlant,
+      IfcPlate,
+      IfcPlateStandardCase,
+      IfcPlateType,
+      IfcPoint,
+      IfcPointByDistanceExpression,
+      IfcPointOnCurve,
+      IfcPointOnSurface,
+      IfcPolygonalBoundedHalfSpace,
+      IfcPolygonalFaceSet,
+      IfcPolyline,
+      IfcPolyLoop,
+      IfcPolynomialCurve,
+      IfcPort,
+      IfcPositioningElement,
+      IfcPostalAddress,
+      IfcPreDefinedColour,
+      IfcPreDefinedCurveFont,
+      IfcPreDefinedItem,
+      IfcPreDefinedProperties,
+      IfcPreDefinedPropertySet,
+      IfcPreDefinedTextFont,
+      IfcPresentationItem,
+      IfcPresentationLayerAssignment,
+      IfcPresentationLayerWithStyle,
+      IfcPresentationStyle,
+      IfcPresentationStyleAssignment,
+      IfcProcedure,
+      IfcProcedureType,
+      IfcProcess,
+      IfcProduct,
+      IfcProductDefinitionShape,
+      IfcProductRepresentation,
+      IfcProfileDef,
+      IfcProfileProperties,
+      IfcProject,
+      IfcProjectedCRS,
+      IfcProjectionElement,
+      IfcProjectLibrary,
+      IfcProjectOrder,
+      IfcProperty,
+      IfcPropertyAbstraction,
+      IfcPropertyBoundedValue,
+      IfcPropertyDefinition,
+      IfcPropertyDependencyRelationship,
+      IfcPropertyEnumeratedValue,
+      IfcPropertyEnumeration,
+      IfcPropertyListValue,
+      IfcPropertyReferenceValue,
+      IfcPropertySet,
+      IfcPropertySetDefinition,
+      IfcPropertySetTemplate,
+      IfcPropertySingleValue,
+      IfcPropertyTableValue,
+      IfcPropertyTemplate,
+      IfcPropertyTemplateDefinition,
+      IfcProtectiveDevice,
+      IfcProtectiveDeviceTrippingUnit,
+      IfcProtectiveDeviceTrippingUnitType,
+      IfcProtectiveDeviceType,
+      IfcProxy,
+      IfcPump,
+      IfcPumpType,
+      IfcQuantityArea,
+      IfcQuantityCount,
+      IfcQuantityLength,
+      IfcQuantitySet,
+      IfcQuantityTime,
+      IfcQuantityVolume,
+      IfcQuantityWeight,
+      IfcRail,
+      IfcRailing,
+      IfcRailingType,
+      IfcRailType,
+      IfcRailway,
+      IfcRamp,
+      IfcRampFlight,
+      IfcRampFlightType,
+      IfcRampType,
+      IfcRationalBSplineCurveWithKnots,
+      IfcRationalBSplineSurfaceWithKnots,
+      IfcRectangleHollowProfileDef,
+      IfcRectangleProfileDef,
+      IfcRectangularPyramid,
+      IfcRectangularTrimmedSurface,
+      IfcRecurrencePattern,
+      IfcReference,
+      IfcReferent,
+      IfcRegularTimeSeries,
+      IfcReinforcedSoil,
+      IfcReinforcementBarProperties,
+      IfcReinforcementDefinitionProperties,
+      IfcReinforcingBar,
+      IfcReinforcingBarType,
+      IfcReinforcingElement,
+      IfcReinforcingElementType,
+      IfcReinforcingMesh,
+      IfcReinforcingMeshType,
+      IfcRelAggregates,
+      IfcRelAssigns,
+      IfcRelAssignsToActor,
+      IfcRelAssignsToControl,
+      IfcRelAssignsToGroup,
+      IfcRelAssignsToGroupByFactor,
+      IfcRelAssignsToProcess,
+      IfcRelAssignsToProduct,
+      IfcRelAssignsToResource,
+      IfcRelAssociates,
+      IfcRelAssociatesApproval,
+      IfcRelAssociatesClassification,
+      IfcRelAssociatesConstraint,
+      IfcRelAssociatesDocument,
+      IfcRelAssociatesLibrary,
+      IfcRelAssociatesMaterial,
+      IfcRelAssociatesProfileDef,
+      IfcRelationship,
+      IfcRelConnects,
+      IfcRelConnectsElements,
+      IfcRelConnectsPathElements,
+      IfcRelConnectsPorts,
+      IfcRelConnectsPortToElement,
+      IfcRelConnectsStructuralActivity,
+      IfcRelConnectsStructuralMember,
+      IfcRelConnectsWithEccentricity,
+      IfcRelConnectsWithRealizingElements,
+      IfcRelContainedInSpatialStructure,
+      IfcRelCoversBldgElements,
+      IfcRelCoversSpaces,
+      IfcRelDeclares,
+      IfcRelDecomposes,
+      IfcRelDefines,
+      IfcRelDefinesByObject,
+      IfcRelDefinesByProperties,
+      IfcRelDefinesByTemplate,
+      IfcRelDefinesByType,
+      IfcRelFillsElement,
+      IfcRelFlowControlElements,
+      IfcRelInterferesElements,
+      IfcRelNests,
+      IfcRelPositions,
+      IfcRelProjectsElement,
+      IfcRelReferencedInSpatialStructure,
+      IfcRelSequence,
+      IfcRelServicesBuildings,
+      IfcRelSpaceBoundary,
+      IfcRelSpaceBoundary1stLevel,
+      IfcRelSpaceBoundary2ndLevel,
+      IfcRelVoidsElement,
+      IfcReparametrisedCompositeCurveSegment,
+      IfcRepresentation,
+      IfcRepresentationContext,
+      IfcRepresentationItem,
+      IfcRepresentationMap,
+      IfcResource,
+      IfcResourceApprovalRelationship,
+      IfcResourceConstraintRelationship,
+      IfcResourceLevelRelationship,
+      IfcResourceTime,
+      IfcRevolvedAreaSolid,
+      IfcRevolvedAreaSolidTapered,
+      IfcRightCircularCone,
+      IfcRightCircularCylinder,
+      IfcRoad,
+      IfcRoof,
+      IfcRoofType,
+      IfcRoot,
+      IfcRoundedRectangleProfileDef,
+      IfcSanitaryTerminal,
+      IfcSanitaryTerminalType,
+      IfcSchedulingTime,
+      IfcSeamCurve,
+      IfcSectionedSolid,
+      IfcSectionedSolidHorizontal,
+      IfcSectionedSpine,
+      IfcSectionedSurface,
+      IfcSectionProperties,
+      IfcSectionReinforcementProperties,
+      IfcSegment,
+      IfcSegmentedReferenceCurve,
+      IfcSensor,
+      IfcSensorType,
+      IfcShadingDevice,
+      IfcShadingDeviceType,
+      IfcShapeAspect,
+      IfcShapeModel,
+      IfcShapeRepresentation,
+      IfcShellBasedSurfaceModel,
+      IfcSign,
+      IfcSignal,
+      IfcSignalType,
+      IfcSignType,
+      IfcSimpleProperty,
+      IfcSimplePropertyTemplate,
+      IfcSine,
+      IfcSite,
+      IfcSIUnit,
+      IfcSlab,
+      IfcSlabElementedCase,
+      IfcSlabStandardCase,
+      IfcSlabType,
+      IfcSlippageConnectionCondition,
+      IfcSolarDevice,
+      IfcSolarDeviceType,
+      IfcSolidModel,
+      IfcSolidStratum,
+      IfcSpace,
+      IfcSpaceHeater,
+      IfcSpaceHeaterType,
+      IfcSpaceType,
+      IfcSpatialElement,
+      IfcSpatialElementType,
+      IfcSpatialStructureElement,
+      IfcSpatialStructureElementType,
+      IfcSpatialZone,
+      IfcSpatialZoneType,
+      IfcSphere,
+      IfcSphericalSurface,
+      IfcSpiral,
+      IfcStackTerminal,
+      IfcStackTerminalType,
+      IfcStair,
+      IfcStairFlight,
+      IfcStairFlightType,
+      IfcStairType,
+      IfcStructuralAction,
+      IfcStructuralActivity,
+      IfcStructuralAnalysisModel,
+      IfcStructuralConnection,
+      IfcStructuralConnectionCondition,
+      IfcStructuralCurveAction,
+      IfcStructuralCurveConnection,
+      IfcStructuralCurveMember,
+      IfcStructuralCurveMemberVarying,
+      IfcStructuralCurveReaction,
+      IfcStructuralItem,
+      IfcStructuralLinearAction,
+      IfcStructuralLoad,
+      IfcStructuralLoadCase,
+      IfcStructuralLoadConfiguration,
+      IfcStructuralLoadGroup,
+      IfcStructuralLoadLinearForce,
+      IfcStructuralLoadOrResult,
+      IfcStructuralLoadPlanarForce,
+      IfcStructuralLoadSingleDisplacement,
+      IfcStructuralLoadSingleDisplacementDistortion,
+      IfcStructuralLoadSingleForce,
+      IfcStructuralLoadSingleForceWarping,
+      IfcStructuralLoadStatic,
+      IfcStructuralLoadTemperature,
+      IfcStructuralMember,
+      IfcStructuralPlanarAction,
+      IfcStructuralPointAction,
+      IfcStructuralPointConnection,
+      IfcStructuralPointReaction,
+      IfcStructuralReaction,
+      IfcStructuralResultGroup,
+      IfcStructuralSurfaceAction,
+      IfcStructuralSurfaceConnection,
+      IfcStructuralSurfaceMember,
+      IfcStructuralSurfaceMemberVarying,
+      IfcStructuralSurfaceReaction,
+      IfcStyledItem,
+      IfcStyledRepresentation,
+      IfcStyleModel,
+      IfcSubContractResource,
+      IfcSubContractResourceType,
+      IfcSubedge,
+      IfcSurface,
+      IfcSurfaceCurve,
+      IfcSurfaceCurveSweptAreaSolid,
+      IfcSurfaceFeature,
+      IfcSurfaceOfLinearExtrusion,
+      IfcSurfaceOfRevolution,
+      IfcSurfaceReinforcementArea,
+      IfcSurfaceStyle,
+      IfcSurfaceStyleLighting,
+      IfcSurfaceStyleRefraction,
+      IfcSurfaceStyleRendering,
+      IfcSurfaceStyleShading,
+      IfcSurfaceStyleWithTextures,
+      IfcSurfaceTexture,
+      IfcSweptAreaSolid,
+      IfcSweptDiskSolid,
+      IfcSweptDiskSolidPolygonal,
+      IfcSweptSurface,
+      IfcSwitchingDevice,
+      IfcSwitchingDeviceType,
+      IfcSystem,
+      IfcSystemFurnitureElement,
+      IfcSystemFurnitureElementType,
+      IfcTable,
+      IfcTableColumn,
+      IfcTableRow,
+      IfcTank,
+      IfcTankType,
+      IfcTask,
+      IfcTaskTime,
+      IfcTaskTimeRecurring,
+      IfcTaskType,
+      IfcTelecomAddress,
+      IfcTendon,
+      IfcTendonAnchor,
+      IfcTendonAnchorType,
+      IfcTendonConduit,
+      IfcTendonConduitType,
+      IfcTendonType,
+      IfcTessellatedFaceSet,
+      IfcTessellatedItem,
+      IfcTextLiteral,
+      IfcTextLiteralWithExtent,
+      IfcTextStyle,
+      IfcTextStyleFontModel,
+      IfcTextStyleForDefinedFont,
+      IfcTextStyleTextModel,
+      IfcTextureCoordinate,
+      IfcTextureCoordinateGenerator,
+      IfcTextureMap,
+      IfcTextureVertex,
+      IfcTextureVertexList,
+      IfcTimePeriod,
+      IfcTimeSeries,
+      IfcTimeSeriesValue,
+      IfcTopologicalRepresentationItem,
+      IfcTopologyRepresentation,
+      IfcToroidalSurface,
+      IfcTrackElement,
+      IfcTrackElementType,
+      IfcTransformer,
+      IfcTransformerType,
+      IfcTransportElement,
+      IfcTransportElementType,
+      IfcTrapeziumProfileDef,
+      IfcTriangulatedFaceSet,
+      IfcTriangulatedIrregularNetwork,
+      IfcTrimmedCurve,
+      IfcTShapeProfileDef,
+      IfcTubeBundle,
+      IfcTubeBundleType,
+      IfcTypeObject,
+      IfcTypeProcess,
+      IfcTypeProduct,
+      IfcTypeResource,
+      IfcUnitaryControlElement,
+      IfcUnitaryControlElementType,
+      IfcUnitaryEquipment,
+      IfcUnitaryEquipmentType,
+      IfcUnitAssignment,
+      IfcUShapeProfileDef,
+      IfcValve,
+      IfcValveType,
+      IfcVector,
+      IfcVertex,
+      IfcVertexLoop,
+      IfcVertexPoint,
+      IfcVibrationDamper,
+      IfcVibrationDamperType,
+      IfcVibrationIsolator,
+      IfcVibrationIsolatorType,
+      IfcVienneseBend,
+      IfcVirtualElement,
+      IfcVirtualGridIntersection,
+      IfcVoidingFeature,
+      IfcVoidStratum,
+      IfcWall,
+      IfcWallElementedCase,
+      IfcWallStandardCase,
+      IfcWallType,
+      IfcWasteTerminal,
+      IfcWasteTerminalType,
+      IfcWaterStratum,
+      IfcWindow,
+      IfcWindowLiningProperties,
+      IfcWindowPanelProperties,
+      IfcWindowStandardCase,
+      IfcWindowStyle,
+      IfcWindowType,
+      IfcWorkCalendar,
+      IfcWorkControl,
+      IfcWorkPlan,
+      IfcWorkSchedule,
+      IfcWorkTime,
+      IfcZone,
+      IfcZShapeProfileDef,
+      UnKnown
+   }
+}
diff --git a/Source/Revit.IFC.Common/Enums/IFCEntityType.cs b/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
index 57f009bf..09cd47a5 100644
--- a/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
+++ b/Source/Revit.IFC.Common/Enums/IFCEntityType.cs
@@ -6,14 +6,18 @@
 namespace Revit.IFC.Common.Enums
 {
    /// <summary>
-   /// IFC entity types. Combining IFC2x3 and IFC4 (Add2) entities. 
+   /// IFC entity types. Combining IFC2x, IFC4 (Add2) and IFC4x entities. 
    /// List of Entities for IFC2x is found in IFC2xEntityType.cs
    /// List of Entities for IFC4 is found in IFC4EntityType.cs
+   /// List of Entities for IFC4x1 is found in IFC4x1EntityType.cs
+   /// List of Entities for IFC4x2 is found in IFC4x2EntityType.cs
+   /// List of Entities for IFC4x3 (RC_3) is found in IFC4x3EntityType.cs
    /// </summary>
    public enum IFCEntityType
    {
       Ifc2DCompositeCurve,
       IfcActionRequest,
+      IfcActionTimeControl,
       IfcActor,
       IfcActorRole,
       IfcActuator,
@@ -22,6 +26,7 @@ public enum IFCEntityType
       IfcAdvancedBrep,
       IfcAdvancedBrepWithVoids,
       IfcAdvancedFace,
+      IfcAirFilter,
       IfcAirTerminal,
       IfcAirTerminalBox,
       IfcAirTerminalBoxType,
@@ -30,6 +35,24 @@ public enum IFCEntityType
       IfcAirToAirHeatRecoveryType,
       IfcAlarm,
       IfcAlarmType,
+      IfcAlignment,
+      IfcAlignment2DHorizontal,
+      IfcAlignment2DHorizontalSegment,
+      IfcAlignment2DSegment,
+      IfcAlignment2DVerSegCircularArc,
+      IfcAlignment2DVerSegLine,
+      IfcAlignment2DVerSegParabolicArc,
+      IfcAlignment2DVertical,
+      IfcAlignment2DVerticalSegment,
+      IfcAlignmentCant,
+      IfcAlignmentCantSegment,
+      IfcAlignmentCurve,
+      IfcAlignmentHorizontal,
+      IfcAlignmentHorizontalSegment,
+      IfcAlignmentParameterSegment,
+      IfcAlignmentSegment,
+      IfcAlignmentVertical,
+      IfcAlignmentVerticalSegment,
       IfcAngularDimension,
       IfcAnnotation,
       IfcAnnotationCurveOccurrence,
@@ -47,9 +70,11 @@ public enum IFCEntityType
       IfcApprovalActorRelationship,
       IfcApprovalPropertyRelationship,
       IfcApprovalRelationship,
+      IfcApprovalUsage,
       IfcArbitraryClosedProfileDef,
       IfcArbitraryOpenProfileDef,
       IfcArbitraryProfileDefWithVoids,
+      IfcAssessory,
       IfcAsset,
       IfcAsymmetricIShapeProfileDef,
       IfcAudioVisualAppliance,
@@ -57,16 +82,21 @@ public enum IFCEntityType
       IfcAxis1Placement,
       IfcAxis2Placement2D,
       IfcAxis2Placement3D,
+      IfcAxis2PlacementLinear,
       IfcBeam,
       IfcBeamStandardCase,
       IfcBeamType,
       IfcBezierCurve,
+      IfcBearing,
+      IfcBearingType,
       IfcBlobTexture,
       IfcBlock,
+      IfcBlossCurve,
       IfcBoiler,
       IfcBoilerType,
       IfcBooleanClippingResult,
       IfcBooleanResult,
+      IfcBorehole,
       IfcBoundaryCondition,
       IfcBoundaryCurve,
       IfcBoundaryEdgeCondition,
@@ -77,10 +107,13 @@ public enum IFCEntityType
       IfcBoundedSurface,
       IfcBoundingBox,
       IfcBoxedHalfSpace,
+      IfcBridge,
+      IfcBridgePart,
       IfcBSplineCurve,
       IfcBSplineCurveWithKnots,
       IfcBSplineSurface,
       IfcBSplineSurfaceWithKnots,
+      IfcBudget,
       IfcBuilding,
       IfcBuildingElement,
       IfcBuildingElementComponent,
@@ -91,6 +124,10 @@ public enum IFCEntityType
       IfcBuildingElementType,
       IfcBuildingStorey,
       IfcBuildingSystem,
+      IfcBuiltElement,
+      IfcBuiltElementType,
+      IfcBuiltIn,
+      IfcBuiltSystem,
       IfcBurner,
       IfcBurnerType,
       IfcCableCarrierFitting,
@@ -101,6 +138,8 @@ public enum IFCEntityType
       IfcCableFittingType,
       IfcCableSegment,
       IfcCableSegmentType,
+      IfcCaissonFoundation,
+      IfcCaissonFoundationType,
       IfcCalendarDate,
       IfcCartesianPoint,
       IfcCartesianPointList,
@@ -113,6 +152,7 @@ public enum IFCEntityType
       IfcCartesianTransformationOperator3DnonUniform,
       IfcCenterLineProfileDef,
       IfcChamferEdgeFeature,
+      IfcChangeOrder,
       IfcChiller,
       IfcChillerType,
       IfcChimney,
@@ -120,6 +160,7 @@ public enum IFCEntityType
       IfcCircle,
       IfcCircleHollowProfileDef,
       IfcCircleProfileDef,
+      IfcCircularArcSegment2D,
       IfcCivilElement,
       IfcCivilElementType,
       IfcClassification,
@@ -129,6 +170,8 @@ public enum IFCEntityType
       IfcClassificationNotationFacet,
       IfcClassificationReference,
       IfcClosedShell,
+      IfcClothoid,
+      IfcCMDocPackage,
       IfcCoil,
       IfcCoilType,
       IfcColourRgb,
@@ -139,6 +182,7 @@ public enum IFCEntityType
       IfcColumnType,
       IfcCommunicationsAppliance,
       IfcCommunicationsApplianceType,
+      IfcCompartment,
       IfcComplexProperty,
       IfcComplexPropertyTemplate,
       IfcCompositeCurve,
@@ -153,6 +197,7 @@ public enum IFCEntityType
       IfcConditionCriterion,
       IfcConic,
       IfcConnectedFaceSet,
+      IfcConnectionConstraint,
       IfcConnectionCurveGeometry,
       IfcConnectionGeometry,
       IfcConnectionPointEccentricity,
@@ -164,6 +209,7 @@ public enum IFCEntityType
       IfcConstraintAggregationRelationship,
       IfcConstraintClassificationRelationship,
       IfcConstraintRelationship,
+      IfcConstraintUsage,
       IfcConstructionEquipmentResource,
       IfcConstructionEquipmentResourceType,
       IfcConstructionMaterialResource,
@@ -175,10 +221,13 @@ public enum IFCEntityType
       IfcContext,
       IfcContextDependentUnit,
       IfcControl,
+      IfcControlElement,
       IfcController,
       IfcControllerType,
       IfcConversionBasedUnit,
       IfcConversionBasedUnitWithOffset,
+      IfcConveyorSegment,
+      IfcConveyorSegmentType,
       IfcCooledBeam,
       IfcCooledBeamType,
       IfcCoolingTower,
@@ -186,9 +235,17 @@ public enum IFCEntityType
       IfcCoordinatedUniversalTimeOffset,
       IfcCoordinateOperation,
       IfcCoordinateReferenceSystem,
+      IfcCosine,
+      IfcCost,
       IfcCostItem,
+      IfcCostModifier,
+      IfcCostModifierValue,
+      IfcCostQuantity,
       IfcCostSchedule,
       IfcCostValue,
+      IfcCostValueRelationship,
+      IfcCourse,
+      IfcCourseType,
       IfcCovering,
       IfcCoveringType,
       IfcCraneRailAShapeProfileDef,
@@ -204,6 +261,8 @@ public enum IFCEntityType
       IfcCurve,
       IfcCurveBoundedPlane,
       IfcCurveBoundedSurface,
+      IfcCurveSegment,
+      IfcCurveSegment2D,
       IfcCurveStyle,
       IfcCurveStyleFont,
       IfcCurveStyleFontAndScaling,
@@ -213,6 +272,8 @@ public enum IFCEntityType
       IfcDamperType,
       IfcDateAndTime,
       IfcDefinedSymbol,
+      IfcDeepFoundation,
+      IfcDeepFoundationType,
       IfcDerivedProfileDef,
       IfcDerivedUnit,
       IfcDerivedUnitElement,
@@ -224,8 +285,15 @@ public enum IFCEntityType
       IfcDimensionCurveTerminator,
       IfcDimensionPair,
       IfcDirection,
+      IfcDirectionalLightSource,
+      IfcDirectrixCurveSweptAreaSolid,
+      IfcDirectrixDistanceSweptAreaSolid,
       IfcDiscreteAccessory,
       IfcDiscreteAccessoryType,
+      IfcDistanceExpression,
+      IfcDiscreteElement,
+      IfcDistributionBoard,
+      IfcDistributionBoardType,
       IfcDistributionChamberElement,
       IfcDistributionChamberElementType,
       IfcDistributionCircuit,
@@ -258,13 +326,18 @@ public enum IFCEntityType
       IfcDuctSegmentType,
       IfcDuctSilencer,
       IfcDuctSilencerType,
+      IfcEarthworksCut,
+      IfcEarthworksElement,
+      IfcEarthworksFill,
       IfcEdge,
       IfcEdgeCurve,
       IfcEdgeFeature,
       IfcEdgeLoop,
+      IfcElectricalAppliance,
       IfcElectricalBaseProperties,
       IfcElectricalCircuit,
       IfcElectricalElement,
+      IfcElectricalExtendedProperties,
       IfcElectricAppliance,
       IfcElectricApplianceType,
       IfcElectricDistributionBoard,
@@ -272,6 +345,8 @@ public enum IFCEntityType
       IfcElectricDistributionPoint,
       IfcElectricFlowStorageDevice,
       IfcElectricFlowStorageDeviceType,
+      IfcElectricFlowTreatmentDevice,
+      IfcElectricFlowTreatmentDeviceType,
       IfcElectricGenerator,
       IfcElectricGeneratorType,
       IfcElectricHeaterType,
@@ -324,6 +399,8 @@ public enum IFCEntityType
       IfcFaceSurface,
       IfcFacetedBrep,
       IfcFacetedBrepWithVoids,
+      IfcFacility,
+      IfcFacilityPart,
       IfcFailureConnectionCondition,
       IfcFan,
       IfcFanType,
@@ -360,6 +437,7 @@ public enum IFCEntityType
       IfcFlowTreatmentDevice,
       IfcFlowTreatmentDeviceType,
       IfcFluidFlowProperties,
+      IfcFluidMovingDevice,
       IfcFooting,
       IfcFootingType,
       IfcFuelProperties,
@@ -378,6 +456,12 @@ public enum IFCEntityType
       IfcGeometricRepresentationItem,
       IfcGeometricRepresentationSubContext,
       IfcGeometricSet,
+      IfcGeomodel,
+      IfcGeoslice,
+      IfcGeotechnicalAssembly,
+      IfcGeotechnicalElement,
+      IfcGeotechnicalStratum,
+      IfcGradientCurve,
       IfcGrid,
       IfcGridAxis,
       IfcGridPlacement,
@@ -385,10 +469,16 @@ public enum IFCEntityType
       IfcHalfSpaceSolid,
       IfcHeatExchanger,
       IfcHeatExchangerType,
+      IfcHeatTransferDevice,
+      IfcHelmertCurve,
       IfcHumidifier,
       IfcHumidifierType,
+      IfcHydronicHeater,
       IfcHygroscopicMaterialProperties,
       IfcImageTexture,
+      IfcImpactProtectionDevice,
+      IfcImpactProtectionDeviceType,
+      IfcInclinedReferenceSweptAreaSolid,
       IfcIndexedColourMap,
       IfcIndexedPolyCurve,
       IfcIndexedPolygonalFace,
@@ -402,8 +492,11 @@ public enum IFCEntityType
       IfcIrregularTimeSeries,
       IfcIrregularTimeSeriesValue,
       IfcIShapeProfileDef,
+      IfcIshapeProfileDef,
       IfcJunctionBox,
       IfcJunctionBoxType,
+      IfcKerb,
+      IfcKerbType,
       IfcLaborResource,
       IfcLaborResourceType,
       IfcLagTime,
@@ -422,14 +515,24 @@ public enum IFCEntityType
       IfcLightSourcePositional,
       IfcLightSourceSpot,
       IfcLine,
+      IfcLinearElement,
       IfcLinearDimension,
+      IfcLinearPlacement,
+      IfcLinearPositioningElement,
+      IfcLineSegment2D,
+      IfcLiquidTerminal,
+      IfcLiquidTerminalType,
       IfcLocalPlacement,
       IfcLocalTime,
       IfcLoop,
       IfcLShapeProfileDef,
+      IfcMaintenanceRecord,
+      IfcMaintenanceWorkOrder,
       IfcManifoldSolidBrep,
+      IfcManufacturerInformation,
       IfcMapConversion,
       IfcMappedItem,
+      IfcMarineFacility,
       IfcMaterial,
       IfcMaterialClassificationRelationship,
       IfcMaterialConstituent,
@@ -461,20 +564,31 @@ public enum IFCEntityType
       IfcMemberStandardCase,
       IfcMemberType,
       IfcMetric,
+      IfcMetricBenchmark,
+      IfcMetricValue,
       IfcMirroredProfileDef,
+      IfcMobileTelecommunicationsAppliance,
+      IfcMobileTelecommunicationsApplianceType,
       IfcMonetaryUnit,
+      IfcMooringDevice,
+      IfcMooringDeviceType,
       IfcMotorConnection,
       IfcMotorConnectionType,
       IfcMove,
       IfcNamedUnit,
+      IfcNavigationElement,
+      IfcNavigationElementType,
       IfcObject,
       IfcObjectDefinition,
       IfcObjective,
       IfcObjectPlacement,
       IfcOccupant,
+      IfcOffsetCurve,
       IfcOffsetCurve2D,
       IfcOffsetCurve3D,
+      IfcOffsetCurveByDistances,
       IfcOneDirectionRepeatFactor,
+      IfcOpenCrossProfileDef,
       IfcOpeningElement,
       IfcOpeningStandardCase,
       IfcOpenShell,
@@ -482,6 +596,7 @@ public enum IFCEntityType
       IfcOrderAction,
       IfcOrganization,
       IfcOrganizationRelationship,
+      IfcOrientationExpression,
       IfcOrientedEdge,
       IfcOuterBoundaryCurve,
       IfcOutlet,
@@ -489,6 +604,8 @@ public enum IFCEntityType
       IfcOwnerHistory,
       IfcParameterizedProfileDef,
       IfcPath,
+      IfcPavement,
+      IfcPavementType,
       IfcPcurve,
       IfcPerformanceHistory,
       IfcPermeableCoveringProperties,
@@ -509,17 +626,22 @@ public enum IFCEntityType
       IfcPlanarBox,
       IfcPlanarExtent,
       IfcPlane,
+      IfcPlant,
       IfcPlate,
       IfcPlateStandardCase,
       IfcPlateType,
       IfcPoint,
+      IfcPointByDistanceExpression,
+      IfcPointLightSource,
       IfcPointOnCurve,
       IfcPointOnSurface,
       IfcPolygonalBoundedHalfSpace,
       IfcPolygonalFaceSet,
       IfcPolyline,
       IfcPolyLoop,
+      IfcPolynomialCurve,
       IfcPort,
+      IfcPositioningElement,
       IfcPostalAddress,
       IfcPreDefinedColour,
       IfcPreDefinedCurveFont,
@@ -534,6 +656,7 @@ public enum IFCEntityType
       IfcPresentationItem,
       IfcPresentationLayerAssignment,
       IfcPresentationLayerWithStyle,
+      IfcPresentationLightSource,
       IfcPresentationStyle,
       IfcPresentationStyleAssignment,
       IfcProcedure,
@@ -576,6 +699,7 @@ public enum IFCEntityType
       IfcProxy,
       IfcPump,
       IfcPumpType,
+      IfcPurchaseOrder,
       IfcQuantityArea,
       IfcQuantityCount,
       IfcQuantityLength,
@@ -584,8 +708,11 @@ public enum IFCEntityType
       IfcQuantityVolume,
       IfcQuantityWeight,
       IfcRadiusDimension,
+      IfcRail,
       IfcRailing,
       IfcRailingType,
+      IfcRailType,
+      IfcRailway,
       IfcRamp,
       IfcRampFlight,
       IfcRampFlightType,
@@ -599,8 +726,15 @@ public enum IFCEntityType
       IfcRectangularTrimmedSurface,
       IfcRecurrencePattern,
       IfcReference,
+      IfcReferenceEdge,
+      IfcReferenceFace,
+      IfcReferenceGeometry,
+      IfcReferencesCostDocument,
       IfcReferencesValueDocument,
+      IfcReferenceVertex,
+      IfcReferent,
       IfcRegularTimeSeries,
+      IfcReinforcedSoil,
       IfcReinforcementBarProperties,
       IfcReinforcementDefinitionProperties,
       IfcReinforcingBar,
@@ -610,7 +744,9 @@ public enum IFCEntityType
       IfcReinforcingMesh,
       IfcReinforcingMeshType,
       IfcRelAggregates,
+      IfcRelAggregatesResources,
       IfcRelAssigns,
+      IfcRelAssignsFMStandard,
       IfcRelAssignsTasks,
       IfcRelAssignsToActor,
       IfcRelAssignsToControl,
@@ -628,6 +764,7 @@ public enum IFCEntityType
       IfcRelAssociatesDocument,
       IfcRelAssociatesLibrary,
       IfcRelAssociatesMaterial,
+      IfcRelAssociatesProfileDef,
       IfcRelAssociatesProfileProperties,
       IfcRelationship,
       IfcRelaxation,
@@ -642,6 +779,7 @@ public enum IFCEntityType
       IfcRelConnectsWithEccentricity,
       IfcRelConnectsWithRealizingElements,
       IfcRelContainedInSpatialStructure,
+      IfcRelCostsObjects,
       IfcRelCoversBldgElements,
       IfcRelCoversSpaces,
       IfcRelDeclares,
@@ -655,9 +793,11 @@ public enum IFCEntityType
       IfcRelFlowControlElements,
       IfcRelInteractionRequirements,
       IfcRelInterferesElements,
+      IfcRelMaintenanceEvent,
       IfcRelNests,
       IfcRelOccupiesSpaces,
       IfcRelOverridesProperties,
+      IfcRelPositions,
       IfcRelProjectsElement,
       IfcRelReferencedInSpatialStructure,
       IfcRelSchedulesCostItems,
@@ -666,6 +806,7 @@ public enum IFCEntityType
       IfcRelSpaceBoundary,
       IfcRelSpaceBoundary1stLevel,
       IfcRelSpaceBoundary2ndLevel,
+      IfcRelUsesResource,
       IfcRelVoidsElement,
       IfcReparametrisedCompositeCurveSegment,
       IfcRepresentation,
@@ -682,6 +823,7 @@ public enum IFCEntityType
       IfcRibPlateProfileProperties,
       IfcRightCircularCone,
       IfcRightCircularCylinder,
+      IfcRoad,
       IfcRoof,
       IfcRoofType,
       IfcRoot,
@@ -692,9 +834,14 @@ public enum IFCEntityType
       IfcScheduleTimeControl,
       IfcSchedulingTime,
       IfcSeamCurve,
+      IfcSectionedSolid,
+      IfcSectionedSolidHorizontal,
       IfcSectionedSpine,
+      IfcSectionedSurface,
       IfcSectionProperties,
       IfcSectionReinforcementProperties,
+      IfcSegment,
+      IfcSegmentedReferenceCurve,
       IfcSensor,
       IfcSensorType,
       IfcServiceLife,
@@ -705,8 +852,13 @@ public enum IFCEntityType
       IfcShapeModel,
       IfcShapeRepresentation,
       IfcShellBasedSurfaceModel,
+      IfcSign,
+      IfcSignal,
+      IfcSignalType,
+      IfcSignType,
       IfcSimpleProperty,
       IfcSimplePropertyTemplate,
+      IfcSine,
       IfcSite,
       IfcSIUnit,
       IfcSlab,
@@ -719,10 +871,13 @@ public enum IFCEntityType
       IfcSolidModel,
       IfcSoundProperties,
       IfcSoundValue,
+      IfcSolidStratum,
       IfcSpace,
       IfcSpaceHeater,
       IfcSpaceHeaterType,
       IfcSpaceProgram,
+      IfcSpaceProgramGroup,
+      IfcSpaceThermalLoad,
       IfcSpaceThermalLoadProperties,
       IfcSpaceType,
       IfcSpatialElement,
@@ -733,12 +888,15 @@ public enum IFCEntityType
       IfcSpatialZoneType,
       IfcSphere,
       IfcSphericalSurface,
+      IfcSpiral,
+      IfcSpotLightSource,
       IfcStackTerminal,
       IfcStackTerminalType,
       IfcStair,
       IfcStairFlight,
       IfcStairFlightType,
       IfcStairType,
+      IfcStorageDevice,
       IfcStructuralAction,
       IfcStructuralActivity,
       IfcStructuralAnalysisModel,
@@ -790,15 +948,20 @@ public enum IFCEntityType
       IfcSurface,
       IfcSurfaceCurve,
       IfcSurfaceCurveSweptAreaSolid,
+      IfcSurfaceExtendedProperties,
       IfcSurfaceFeature,
       IfcSurfaceOfLinearExtrusion,
       IfcSurfaceOfRevolution,
       IfcSurfaceReinforcementArea,
+      IfcSurfaceRenderingProperties,
+      IfcSurfaceShadingProperties,
       IfcSurfaceStyle,
       IfcSurfaceStyleLighting,
+      IfcSurfaceStyleProperties,
       IfcSurfaceStyleRefraction,
       IfcSurfaceStyleRendering,
       IfcSurfaceStyleShading,
+      IfcSurfaceStyleUsage,
       IfcSurfaceStyleWithTextures,
       IfcSurfaceTexture,
       IfcSweptAreaSolid,
@@ -824,6 +987,8 @@ public enum IFCEntityType
       IfcTendon,
       IfcTendonAnchor,
       IfcTendonAnchorType,
+      IfcTendonConduit,
+      IfcTendonConduitType,
       IfcTendonType,
       IfcTerminatorSymbol,
       IfcTessellatedFaceSet,
@@ -849,12 +1014,17 @@ public enum IFCEntityType
       IfcTopologicalRepresentationItem,
       IfcTopologyRepresentation,
       IfcToroidalSurface,
+      IfcTrackElement,
+      IfcTrackElementType,
       IfcTransformer,
       IfcTransformerType,
+      IfcTransitionCurveSegment2D,
       IfcTransportElement,
       IfcTransportElementType,
       IfcTrapeziumProfileDef,
+      IfcTreatmentDevice,
       IfcTriangulatedFaceSet,
+      IfcTriangulatedIrregularNetwork,
       IfcTrimmedCurve,
       IfcTShapeProfileDef,
       IfcTubeBundle,
@@ -869,6 +1039,7 @@ public enum IFCEntityType
       IfcUnitaryEquipment,
       IfcUnitaryEquipmentType,
       IfcUnitAssignment,
+      IfcUnitHeater,
       IfcUShapeProfileDef,
       IfcValve,
       IfcValveType,
@@ -877,11 +1048,15 @@ public enum IFCEntityType
       IfcVertexBasedTextureMap,
       IfcVertexLoop,
       IfcVertexPoint,
+      IfcVibrationDamper,
+      IfcVibrationDamperType,
       IfcVibrationIsolator,
       IfcVibrationIsolatorType,
+      IfcVienneseBend,
       IfcVirtualElement,
       IfcVirtualGridIntersection,
       IfcVoidingFeature,
+      IfcVoidStratum,
       IfcWall,
       IfcWallElementedCase,
       IfcWallStandardCase,
@@ -889,6 +1064,7 @@ public enum IFCEntityType
       IfcWasteTerminal,
       IfcWasteTerminalType,
       IfcWaterProperties,
+      IfcWaterStratum,
       IfcWindow,
       IfcWindowLiningProperties,
       IfcWindowPanelProperties,
@@ -897,6 +1073,7 @@ public enum IFCEntityType
       IfcWindowType,
       IfcWorkCalendar,
       IfcWorkControl,
+      IfcWorkOrder,
       IfcWorkPlan,
       IfcWorkSchedule,
       IfcWorkTime,
diff --git a/Source/Revit.IFC.Common/Extension/IFCFileHeader.cs b/Source/Revit.IFC.Common/Extension/IFCFileHeader.cs
index 6cc9a8b2..3f786347 100644
--- a/Source/Revit.IFC.Common/Extension/IFCFileHeader.cs
+++ b/Source/Revit.IFC.Common/Extension/IFCFileHeader.cs
@@ -19,9 +19,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Autodesk.Revit.DB;
-using Autodesk.Revit.DB.IFC;
 using Autodesk.Revit.DB.ExtensibleStorage;
 
 
diff --git a/Source/Revit.IFC.Common/Revit.IFC.Common.csproj b/Source/Revit.IFC.Common/Revit.IFC.Common.csproj
index e0cdb3fe..47a8ebad 100644
--- a/Source/Revit.IFC.Common/Revit.IFC.Common.csproj
+++ b/Source/Revit.IFC.Common/Revit.IFC.Common.csproj
@@ -68,6 +68,9 @@
     <Compile Include="Enums\CommonEnum.cs" />
     <Compile Include="Enums\IFC2xEntityType.cs" />
     <Compile Include="Enums\IFC4EntityType.cs" />
+    <Compile Include="Enums\IFC4x1EntityType.cs" />
+    <Compile Include="Enums\IFC4x2EntityType.cs" />
+    <Compile Include="Enums\IFC4x3EntityType.cs" />
     <Compile Include="Enums\IFCEntityType.cs" />
     <Compile Include="Enums\IFCKnownMVDAndER.cs" />
     <Compile Include="Extension\IFCAddress.cs" />
diff --git a/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs b/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
index 110198b3..ed89e046 100644
--- a/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
+++ b/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
@@ -41,7 +41,7 @@ public static string IFCSchemaLocation
       {
          get
          {
-            return Path.Combine(RevitProgramPath, "EDM");
+            return Path.Combine(RevitProgramPath, "IFC");
          }
       }
    }
diff --git a/Source/Revit.IFC.Export/Exporter/BeamExporter.cs b/Source/Revit.IFC.Export/Exporter/BeamExporter.cs
index ad0cbef4..f562dbf6 100644
--- a/Source/Revit.IFC.Export/Exporter/BeamExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/BeamExporter.cs
@@ -100,7 +100,7 @@ public BeamBodyAsExtrusionInfo()
          /// <summary>
          /// The material profile set for the extruded Beam
          /// </summary>
-         public MaterialAndProfile materialAndProfile { get; set; }
+         public MaterialAndProfile MaterialAndProfile { get; set; }
 
          /// <summary>
          /// The calculated slope of the beam along its axis, relative to the XY plane.
@@ -302,13 +302,13 @@ private static BeamBodyAsExtrusionInfo CreateBeamGeometryAsExtrusion(ExporterIFC
             IFCExtrusionBasis bestAxis = (Math.Abs(beamDirection[0]) > Math.Abs(beamDirection[1])) ?
                 IFCExtrusionBasis.BasisX : IFCExtrusionBasis.BasisY;
             info.Slope = GeometryUtil.GetSimpleExtrusionSlope(beamDirection, bestAxis);
-            ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, exporterIFC, element);
+            ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, element);
             if (materialId != ElementId.InvalidElementId)
                info.Materials.Add(materialId);
          }
 
          if (materialAndProfile != null)
-            info.materialAndProfile = materialAndProfile;
+            info.MaterialAndProfile = materialAndProfile;
 
          return info;
       }
@@ -455,7 +455,7 @@ public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
                   bool tryToCreateBeamGeometryAsExtrusion = true;
 
                   //bool useFamilySymbolGeometry = (element is FamilyInstance) ? !ExporterIFCUtils.UsesInstanceGeometry(element as FamilyInstance) : false;
-                  bool useFamilySymbolGeometry = (element is FamilyInstance) ? !GeometryUtil.UsesInstanceGeometry(element as FamilyInstance) : false;
+                  bool useFamilySymbolGeometry = (element is FamilyInstance) && !GeometryUtil.UsesInstanceGeometry(element as FamilyInstance);
                   ElementId beamTypeId = element.GetTypeId();
                   if (useFamilySymbolGeometry)
                   {
@@ -478,7 +478,7 @@ public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
                      return null;
                   }
 
-                  IFCAnyHandle repHnd = (extrusionInfo != null) ? extrusionInfo.RepresentationHandle : null;
+                  IFCAnyHandle repHnd = extrusionInfo?.RepresentationHandle;
 
                   if (!IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
                   {
@@ -523,7 +523,7 @@ public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
                         representations.Add(axisRep);
                   representations.Add(repHnd);
 
-                  Transform boundingBoxTrf = (offsetTransform == null) ? Transform.Identity : offsetTransform.Inverse;
+                  Transform boundingBoxTrf = offsetTransform?.Inverse ?? Transform.Identity;
                   IFCAnyHandle boundingBoxRep = BoundingBoxExporter.ExportBoundingBox(exporterIFC, geometryElement, boundingBoxTrf);
                   if (boundingBoxRep != null)
                      representations.Add(boundingBoxRep);
@@ -561,22 +561,5 @@ public static IFCAnyHandle ExportBeamAsStandardElement(ExporterIFC exporterIFC,
             return beam;
          }
       }
-
-      static IFCBeamType GetBeamType(Element element, string beamType)
-      {
-         string value = null;
-         if (ParameterUtil.GetStringValueFromElementOrSymbol(element, "IfcType", out value) == null)
-            value = beamType;
-
-         if (String.IsNullOrEmpty(value))
-            return IFCBeamType.Beam;
-
-         string newValue = NamingUtil.RemoveSpacesAndUnderscores(value);
-
-         if (String.Compare(newValue, "USERDEFINED", true) == 0)
-            return IFCBeamType.UserDefined;
-
-         return IFCBeamType.Beam;
-      }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Export/Exporter/BodyExporter.cs b/Source/Revit.IFC.Export/Exporter/BodyExporter.cs
index 83c744e2..2897f405 100644
--- a/Source/Revit.IFC.Export/Exporter/BodyExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/BodyExporter.cs
@@ -49,7 +49,7 @@ class BodyExporter
       public static ElementId SetBestMaterialIdInExporter(GeometryObject geometryObject, Element element, ElementId overrideMaterialId, ExporterIFC exporterIFC)
       {
          ElementId materialId = overrideMaterialId != ElementId.InvalidElementId ? overrideMaterialId :
-             GetBestMaterialIdFromGeometryOrParameter(geometryObject, exporterIFC, element);
+             GetBestMaterialIdFromGeometryOrParameter(geometryObject, element);
 
          if (materialId != ElementId.InvalidElementId)
             exporterIFC.SetMaterialIdForCurrentExportState(materialId);
@@ -92,7 +92,7 @@ public static ElementId GetBestMaterialIdForGeometry(IList<Solid> solids, IList<
             {
                if (solids[currentSolid].Faces.Size > 0)
                {
-                  bestMaterialId = GetBestMaterialIdForGeometry(solids[currentSolid], null);
+                  bestMaterialId = GetBestMaterialIdForGeometry(solids[currentSolid]);
                   break;
                }
             }
@@ -118,7 +118,7 @@ public static ElementId GetBestMaterialIdForGeometry(IList<Solid> solids, IList<
                if (solids[currentSolid].Faces.Size > 0)
                   continue;
 
-               ElementId currentMaterialId = GetBestMaterialIdForGeometry(solids[currentSolid], null);
+               ElementId currentMaterialId = GetBestMaterialIdForGeometry(solids[currentSolid]);
                if (currentMaterialId != ElementId.InvalidElementId && currentMaterialId != bestMaterialId)
                {
                   bestMaterialId = ElementId.InvalidElementId;
@@ -141,18 +141,12 @@ public static ElementId GetBestMaterialIdForGeometry(IList<Solid> solids, IList<
       /// <param name="range">The range to get the clipped geometry.</param>
       /// <returns>The material id.</returns>
       public static ElementId GetBestMaterialIdForGeometry(GeometryElement geometryElement,
-         ExporterIFC exporterIFC, IFCRange range)
+         IFCRange range)
       {
-         SolidMeshGeometryInfo solidMeshCapsule = null;
+         SolidMeshGeometryInfo solidMeshCapsule = (range == null) ?
+            GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity) :
+            GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, range);
 
-         if (range == null)
-         {
-            solidMeshCapsule = GeometryUtil.GetSolidMeshGeometry(geometryElement, Transform.Identity);
-         }
-         else
-         {
-            solidMeshCapsule = GeometryUtil.GetClippedSolidMeshGeometry(geometryElement, range);
-         }
 
          IList<Solid> solids = solidMeshCapsule.GetSolids();
          IList<Mesh> polyMeshes = solidMeshCapsule.GetMeshes();
@@ -166,12 +160,11 @@ public static ElementId GetBestMaterialIdForGeometry(GeometryElement geometryEle
       /// Gets the best material id for the geometry.
       /// </summary>
       /// <param name="geometryObject">The geometry object to get the best material id.</param>
-      /// <param name="exporterIFC">The ExporterIFC object.</param>
       /// <returns>The material id.</returns>
-      public static ElementId GetBestMaterialIdForGeometry(GeometryObject geometryObject, ExporterIFC exporterIFC)
+      public static ElementId GetBestMaterialIdForGeometry(GeometryObject geometryObject)
       {
          if (geometryObject is GeometryElement)
-            return GetBestMaterialIdForGeometry(geometryObject as GeometryElement, exporterIFC, null);
+            return GetBestMaterialIdForGeometry(geometryObject as GeometryElement, null);
 
          if (!(geometryObject is Solid))
          {
@@ -250,7 +243,7 @@ public static ElementId GetBestMaterialIdForGeometry(GeometryObject geometryObje
          return mostPopularId;
       }
 
-      private static bool isDuctCategory(BuiltInCategory categoryId)
+      private static bool IsDuctCategory(BuiltInCategory categoryId)
       {
          return categoryId == BuiltInCategory.OST_DuctAccessory ||
             categoryId == BuiltInCategory.OST_DuctCurves ||
@@ -262,7 +255,7 @@ private static bool isDuctCategory(BuiltInCategory categoryId)
             categoryId == BuiltInCategory.OST_PlaceHolderDucts;      
       }
 
-      private static bool isPipeCategory(BuiltInCategory categoryId)
+      private static bool IsPipeCategory(BuiltInCategory categoryId)
       {
          return categoryId == BuiltInCategory.OST_AnalyticalPipeConnections ||
             categoryId == BuiltInCategory.OST_FlexPipeCurves ||
@@ -275,7 +268,7 @@ private static bool isPipeCategory(BuiltInCategory categoryId)
             categoryId == BuiltInCategory.OST_Sprinklers;
       }
 
-      private static bool categoryHasMaterialIdParam(BuiltInCategory categoryId)
+      private static bool CategoryHasMaterialIdParam(BuiltInCategory categoryId)
       {
          // OST_Cornices also has a MaterialId parameter, but Revit doesn't want us
          // to ask for it.
@@ -290,7 +283,7 @@ private static bool categoryHasMaterialIdParam(BuiltInCategory categoryId)
             categoryId == BuiltInCategory.OST_DuctLinings;
       }
 
-      private static bool categoryHasStructuralMaterialParam(BuiltInCategory categoryId)
+      private static bool CategoryHasStructuralMaterialParam(BuiltInCategory categoryId)
       {
          return categoryId == BuiltInCategory.OST_AnalyticalMember ||
             categoryId == BuiltInCategory.OST_BuildingPad ||
@@ -316,11 +309,11 @@ private static ElementId GetBestMaterialIdFromParameter(Element element)
 
          // Try to get it from the category of the element first.
          BuiltInCategory categoryId = (BuiltInCategory)element.Category.Id.IntegerValue;
-         if (categoryHasMaterialIdParam(categoryId) || element is MEPSystemType)
+         if (CategoryHasMaterialIdParam(categoryId) || element is MEPSystemType)
          {
             ParameterUtil.GetElementIdValueFromElementOrSymbol(element, BuiltInParameter.MATERIAL_ID_PARAM, out matId);
          }
-         else if (categoryHasStructuralMaterialParam(categoryId))
+         else if (CategoryHasStructuralMaterialParam(categoryId))
          {
             ParameterUtil.GetElementIdValueFromElementOrSymbol(element, BuiltInParameter.STRUCTURAL_MATERIAL_PARAM, out matId);
          }
@@ -330,9 +323,9 @@ private static ElementId GetBestMaterialIdFromParameter(Element element)
 
          // If not, try to get it from the system.
          ElementId systemTypeId = ElementId.InvalidElementId;
-         if (isDuctCategory(categoryId))
+         if (IsDuctCategory(categoryId))
             ParameterUtil.GetElementIdValueFromElement(element, BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM, out systemTypeId);
-         else if (isPipeCategory(categoryId))
+         else if (IsPipeCategory(categoryId))
             ParameterUtil.GetElementIdValueFromElement(element, BuiltInParameter.RBS_PIPING_SYSTEM_TYPE_PARAM, out systemTypeId);
 
          if (systemTypeId != ElementId.InvalidElementId)
@@ -369,9 +362,9 @@ public static ElementId GetBestMaterialIdFromGeometryOrParameter(IList<Solid> so
       /// <param name="element">The element.</param>
       /// <returns>The material id.</returns>
       public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryElement geometryElement,
-         ExporterIFC exporterIFC, IFCRange range, Element element)
+         IFCRange range, Element element)
       {
-         ElementId matId = GetBestMaterialIdForGeometry(geometryElement, exporterIFC, range);
+         ElementId matId = GetBestMaterialIdForGeometry(geometryElement, range);
          if (matId == ElementId.InvalidElementId && element != null)
             matId = GetBestMaterialIdFromParameter(element);
          return matId;
@@ -384,9 +377,10 @@ public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryElement
       /// <param name="exporterIFC">The exporter.</param>
       /// <param name="element">The element.</param>
       /// <returns>The material id.</returns>
-      public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryObject geometryObject, ExporterIFC exporterIFC, Element element)
+      public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryObject geometryObject, 
+         Element element)
       {
-         ElementId matId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC);
+         ElementId matId = GetBestMaterialIdForGeometry(geometryObject);
          if (matId == ElementId.InvalidElementId && element != null)
             matId = GetBestMaterialIdFromParameter(element);
          return matId;
@@ -422,16 +416,14 @@ public static void CreateSurfaceStyleForRepItem(ExporterIFC exporterIFC, Documen
          if (materialId == ElementId.InvalidElementId)
             return;
 
-         IFCAnyHandle presStyleHnd = null;
-         presStyleHnd = ExporterCacheManager.PresentationStyleAssignmentCache.Find(materialId);
+         IFCAnyHandle presStyleHnd = ExporterCacheManager.PresentationStyleAssignmentCache.Find(materialId);
          if (IFCAnyHandleUtil.IsNullOrHasNoValue(presStyleHnd))
          {
             IFCAnyHandle surfStyleHnd = CategoryUtil.GetOrCreateMaterialStyle(document, file, materialId);
             if (IFCAnyHandleUtil.IsNullOrHasNoValue(surfStyleHnd))
                return;
 
-            ISet<IFCAnyHandle> styles = new HashSet<IFCAnyHandle>();
-            styles.Add(surfStyleHnd);
+            ISet<IFCAnyHandle> styles = new HashSet<IFCAnyHandle>() { surfStyleHnd };
 
             if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
             {
@@ -452,8 +444,7 @@ public static void CreateSurfaceStyleForRepItem(ExporterIFC exporterIFC, Documen
             HashSet<IFCAnyHandle> styledByItemHandles = IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(repItemHnd, "StyledByItem");
             if (styledByItemHandles == null || styledByItemHandles.Count == 0)
             {
-               HashSet<IFCAnyHandle> presStyleSet = new HashSet<IFCAnyHandle>();
-               presStyleSet.Add(presStyleHnd);
+               HashSet<IFCAnyHandle> presStyleSet = new HashSet<IFCAnyHandle>() { presStyleHnd };
                IFCAnyHandle styledItem = IFCInstanceExporter.CreateStyledItem(file, repItemHnd, presStyleSet, null);
             }
             else
@@ -483,18 +474,15 @@ public static IFCAnyHandle CreateCurveStyleForRepItem(ExporterIFC exporterIFC, I
          if (repItemHnd == null || ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
             return null;
 
-         IFCAnyHandle presStyleHnd = null;
          IFCFile file = exporterIFC.GetFile();
 
          IFCAnyHandle curveStyleHnd = IFCInstanceExporter.CreateCurveStyle(file, null, null, curveWidth, colorHnd);
-         ISet<IFCAnyHandle> styles = new HashSet<IFCAnyHandle>();
-         styles.Add(curveStyleHnd);
+         ISet<IFCAnyHandle> styles = new HashSet<IFCAnyHandle>() { curveStyleHnd };
 
          if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
          {
-            presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, styles);
-            HashSet<IFCAnyHandle> presStyleSet = new HashSet<IFCAnyHandle>();
-            presStyleSet.Add(presStyleHnd);
+            IFCAnyHandle presStyleHnd = IFCInstanceExporter.CreatePresentationStyleAssignment(file, styles);
+            HashSet<IFCAnyHandle> presStyleSet = new HashSet<IFCAnyHandle>() { presStyleHnd };
 
             return IFCInstanceExporter.CreateStyledItem(file, repItemHnd, presStyleSet, null);
          }
@@ -532,8 +520,8 @@ public static bool CanCreateClosedShell(Mesh mesh)
                uint pt1 = meshTriangle.get_Index(jj);
                uint pt2 = meshTriangle.get_Index((jj + 1) % 3);
 
-               IList<uint> unmatchedEdgesPt2 = null;
-               if (unmatchedEdges.TryGetValue(pt2, out unmatchedEdgesPt2) && unmatchedEdgesPt2.Contains(pt1))
+               if (unmatchedEdges.TryGetValue(pt2, out IList<uint> unmatchedEdgesPt2) && 
+                  unmatchedEdgesPt2.Contains(pt1))
                {
                   unmatchedEdgesPt2.Remove(pt1);
                   unmatchedEdgeSz--;
@@ -607,16 +595,16 @@ public static bool CanCreateClosedShell(ICollection<IFCAnyHandle> faceSet)
                   int pt1 = reverse ? points[(ii + 1) % sizeOfBoundary].Id : points[ii].Id;
                   int pt2 = reverse ? points[ii].Id : points[(ii + 1) % sizeOfBoundary].Id;
 
-                  IList<int> unmatchedEdgesPt2 = null;
-                  if (unmatchedEdges.TryGetValue(pt2, out unmatchedEdgesPt2) && unmatchedEdgesPt2.Contains(pt1))
+                  if (unmatchedEdges.TryGetValue(pt2, out IList<int> unmatchedEdgesPt2) && 
+                     unmatchedEdgesPt2.Contains(pt1))
                   {
                      unmatchedEdgesPt2.Remove(pt1);
                      unmatchedEdgeSz--;
                   }
                   else
                   {
-                     IList<int> unmatchedEdgesPt1 = null;
-                     if (unmatchedEdges.TryGetValue(pt1, out unmatchedEdgesPt1) && unmatchedEdgesPt1.Contains(pt2))
+                     if (unmatchedEdges.TryGetValue(pt1, out IList<int> unmatchedEdgesPt1) &&
+                        unmatchedEdgesPt1.Contains(pt2))
                      {
                         // An edge with the same orientation exists twice; can't create solid.
                         return false;
@@ -638,36 +626,6 @@ public static bool CanCreateClosedShell(ICollection<IFCAnyHandle> faceSet)
          return (unmatchedEdgeSz == 0);
       }
 
-      private static IFCAnyHandle CreateBRepRepresentationMap(ExporterIFC exporterIFC, IFCFile file, Element element, ElementId categoryId,
-          IFCAnyHandle contextOfItems, IFCAnyHandle brepHnd)
-      {
-         ISet<IFCAnyHandle> currBodyItems = new HashSet<IFCAnyHandle>();
-         currBodyItems.Add(brepHnd);
-         IFCAnyHandle currRepHnd = RepresentationUtil.CreateBRepRep(exporterIFC, element, categoryId,
-             contextOfItems, currBodyItems);
-
-         IFCAnyHandle currOrigin = ExporterUtil.CreateAxis2Placement3D(file);
-         IFCAnyHandle currMappedRepHnd = IFCInstanceExporter.CreateRepresentationMap(file, currOrigin, currRepHnd);
-         return currMappedRepHnd;
-      }
-
-      private static IFCAnyHandle CreateSurfaceRepresentationMap(ExporterIFC exporterIFC, IFCFile file, Element element, ElementId categoryId,
-          IFCAnyHandle contextOfItems, IFCAnyHandle faceSetHnd)
-      {
-         HashSet<IFCAnyHandle> currFaceSet = new HashSet<IFCAnyHandle>();
-         currFaceSet.Add(faceSetHnd);
-
-         ISet<IFCAnyHandle> currFaceSetItems = new HashSet<IFCAnyHandle>();
-         IFCAnyHandle currSurfaceModelHnd = IFCInstanceExporter.CreateFaceBasedSurfaceModel(file, currFaceSet);
-         currFaceSetItems.Add(currSurfaceModelHnd);
-         IFCAnyHandle currRepHnd = RepresentationUtil.CreateSurfaceRep(exporterIFC, element, categoryId, contextOfItems,
-             currFaceSetItems, false, null);
-
-         IFCAnyHandle currOrigin = ExporterUtil.CreateAxis2Placement3D(file);
-         IFCAnyHandle currMappedRepHnd = IFCInstanceExporter.CreateRepresentationMap(file, currOrigin, currRepHnd);
-         return currMappedRepHnd;
-      }
-
       // This is a simplified routine for solids that are composed of planar faces with polygonal edges.  This
       // allows us to use the edges as the boundaries of the faces.
       private static bool ExportPlanarBodyIfPossible(ExporterIFC exporterIFC, Solid solid,
@@ -711,9 +669,7 @@ private static bool ExportPlanarBodyIfPossible(ExporterIFC exporterIFC, Solid so
                   // Don't add last point to vertices, as this will be added in the next edge.
                   for (int idx = 0; idx < numPoints - 1; idx++)
                   {
-                     IFCAnyHandle pointHandle = null;
-
-                     if (!vertexCache.TryGetValue(curvePoints[idx], out pointHandle))
+                     if (!vertexCache.TryGetValue(curvePoints[idx], out IFCAnyHandle pointHandle))
                      {
                         XYZ pointScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, curvePoints[idx]);
                         pointHandle = ExporterUtil.CreateCartesianPoint(file, pointScaled);
@@ -825,8 +781,8 @@ public override int GetHashCode()
       // This class allows us to merge Planes that have normals and origins that are equal within a small tolerance.
       private class PlanarKey
       {
-         FuzzyPoint m_Norm;
-         FuzzyPoint m_Origin;
+         readonly FuzzyPoint m_Norm;
+         readonly FuzzyPoint m_Origin;
 
          public PlanarKey(XYZ norm, XYZ origin)
          {
@@ -898,13 +854,11 @@ private class PlanarInfo
 
          public void AddTriangleIndexToVertexGrouping(int triangleIndex, int vertex)
          {
-            HashSet<int> trianglesAtVertex;
-            if (TrianglesAtVertexList.TryGetValue(vertex, out trianglesAtVertex))
+            if (TrianglesAtVertexList.TryGetValue(vertex, out HashSet<int> trianglesAtVertex))
                trianglesAtVertex.Add(triangleIndex);
             else
             {
-               trianglesAtVertex = new HashSet<int>();
-               trianglesAtVertex.Add(triangleIndex);
+               trianglesAtVertex = new HashSet<int>() { triangleIndex };
                TrianglesAtVertexList[vertex] = trianglesAtVertex;
             }
          }
@@ -956,10 +910,8 @@ private static IList<LinkedList<int>> ConvertTrianglesToPlanarFacets(Triangulate
             XYZ origin = new XYZ(norm.X * distToOrig, norm.Y * distToOrig, norm.Z * distToOrig);
 
             // Go through map of existing planes and add triangle.
-            PlanarInfo planarGrouping = null;
-
             PlanarKey currKey = new PlanarKey(norm, origin);
-            if (planarGroupings.TryGetValue(currKey, out planarGrouping))
+            if (planarGroupings.TryGetValue(currKey, out PlanarInfo planarGrouping))
             {
                planarGrouping.TriangleList.Add(ii);
             }
@@ -1009,10 +961,12 @@ private static IList<LinkedList<int>> ConvertTrianglesToPlanarFacets(Triangulate
                   continue;
                }
 
-               HashSet<int> currFacetVertices = new HashSet<int>();
-               currFacetVertices.Add(currTriangle.VertexIndex0);
-               currFacetVertices.Add(currTriangle.VertexIndex1);
-               currFacetVertices.Add(currTriangle.VertexIndex2);
+               HashSet<int> currFacetVertices = new HashSet<int>() 
+               {
+                  currTriangle.VertexIndex0,
+                  currTriangle.VertexIndex1,
+                  currTriangle.VertexIndex2 
+               };
 
                visitedTriangles.Add(idx);
 
@@ -1124,8 +1078,7 @@ public static IFCAnyHandle CreateFaceFromVertexList(IFCFile file, IList<IFCAnyHa
       {
          IFCAnyHandle faceOuterLoop = IFCInstanceExporter.CreatePolyLoop(file, vertices);
          IFCAnyHandle faceOuterBound = IFCInstanceExporter.CreateFaceOuterBound(file, faceOuterLoop, true);
-         HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>();
-         faceBounds.Add(faceOuterBound);
+         HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>() { faceOuterBound };
          return IFCInstanceExporter.CreateFace(file, faceBounds);
       }
 
@@ -1401,7 +1354,7 @@ private static bool IsRightHanded(XYZ testPoint, XYZ axis, XYZ origin, XYZ uDeri
       /// <param name="options">exporter option</param>
       /// <param name="geomObject">the geometry object</param>
       /// <returns>the handle</returns>
-      public static IFCAnyHandle ExportBodyAsAdvancedBrep(ExporterIFC exporterIFC, Element element, BodyExporterOptions options,
+      public static IFCAnyHandle ExportBodyAsAdvancedBrep(ExporterIFC exporterIFC, Element element, 
           GeometryObject geomObject)
       {
          IFCFile file = exporterIFC.GetFile();
@@ -1557,8 +1510,7 @@ public static IFCAnyHandle ExportBodyAsAdvancedBrep(ExporterIFC exporterIFC, Ele
                   // calculate sameSense by getting a point on the Revit Surface and compute the normal of the Revit Face and the surface at that point
                   // if these two vectors agree, then sameSense is true.
                   // The point we use to test will be the middle point of the first appropriate edge in the in all loops of Revit Face
-                  UV revitTestUV = null;
-                  GetNonSingularUVPointForRevitFace(face, out revitTestUV);
+                  GetNonSingularUVPointForRevitFace(face, out UV revitTestUV);
                   if (revitTestUV == null)
                   {
                      return null;
@@ -1789,7 +1741,7 @@ public static IFCAnyHandle ExportBodyAsAdvancedBrep(ExporterIFC exporterIFC, Ele
                         double paramStart = 1.0;
                         while (xDir.IsAlmostEqualTo(v2))
                         {
-                           paramStart = paramStart / 2;
+                           paramStart /= 2;
                            v2 = (firstProfileCurve.Evaluate(paramStart, true) - firstProfileCurve.GetEndPoint(0)).Normalize();
                         }
                         XYZ zdir = xDir.CrossProduct(v2).Normalize();
@@ -2053,16 +2005,15 @@ public static IList<IFCAnyHandle> ExportBodyAsPolygonalFaceSet(ExporterIFC expor
       {
          IFCFile file = exporterIFC.GetFile();
 
-         double opacity;
-         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, exporterIFC, element, geomObject, out opacity);
+         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, element, geomObject, 
+            out double opacity, out ElementId matId);
 
          Document document = element.Document;
          IList<IFCAnyHandle> polygonalFaceSetList = new List<IFCAnyHandle>();
 
          // If the geomObject is GeometryELement or GeometryInstance, we need to collect their primitive Solid and Mesh first
-         bool allNotToBeExported;
          IList<GeometryObject> geomObjectPrimitives = GetGeometriesFromGeometryElement(
-            exporterIFC, document, geomObject, false, out allNotToBeExported);
+            exporterIFC, document, geomObject, false, out bool allNotToBeExported);
 
          // At this point all collected geometry will only contains Solid and/or Mesh
          foreach (GeometryObject geom in geomObjectPrimitives)
@@ -2111,8 +2062,16 @@ public static IList<IFCAnyHandle> ExportBodyAsPolygonalFaceSet(ExporterIFC expor
                      coordList.Add(new List<double>() { vertexScaled.X, vertexScaled.Y, vertexScaled.Z });
                   }
 
-                  TriangleMergeUtil triMerge = new TriangleMergeUtil(mesh);
-                  IList<IFCAnyHandle> ifcFaces = MergeAndCreateIfcFaces(file, triMerge);
+                  IList<IFCAnyHandle> ifcFaces = null;
+                  try
+                  {
+                     ifcFaces = MergeAndCreateIfcFaces(file, new TriangleMergeUtil(mesh));
+                  }
+                  catch 
+                  {
+                     ifcFaces = MergeAndCreateIfcFaces(file, new TriangleMergeUtil(mesh), true);
+                  }
+                  
                   IFCAnyHandle polygonalFaceSet = ExportIfcFacesAsPolygonalFaceSet(file, ifcFaces, coordList, mesh.IsClosed, ifcColourRgbList, opacity);
                   if (!IFCAnyHandleUtil.IsNullOrHasNoValue(polygonalFaceSet))
                      polygonalFaceSetList.Add(polygonalFaceSet);
@@ -2135,6 +2094,9 @@ public static IList<IFCAnyHandle> ExportBodyAsPolygonalFaceSet(ExporterIFC expor
                polygonalFaceSetList.Add(triangulatedMesh);
          }
 
+         foreach (IFCAnyHandle polygonalFaceSet in polygonalFaceSetList)
+            CreateSurfaceStyleForRepItem(exporterIFC, document, options.CreatingVoid, polygonalFaceSet, matId);
+
          return polygonalFaceSetList;
       }
 
@@ -2162,10 +2124,11 @@ private static List<GeometryObject> GetGeometryObjectListFromGeometryElement(Doc
       /// <param name="file">the File</param>
       /// <param name="triMerge">TriangleMergeUtil instance with initialized geometry</param>
       /// <returns>List of IFC face handles</returns>
-      private static IList<IFCAnyHandle> MergeAndCreateIfcFaces(IFCFile file, TriangleMergeUtil triMerge)
+      private static IList<IFCAnyHandle> MergeAndCreateIfcFaces(IFCFile file, TriangleMergeUtil triMerge, bool ignoreMerge = false)
       {
          IList<IFCAnyHandle> faces = new List<IFCAnyHandle>();
-         triMerge.SimplifyAndMergeFaces();
+         triMerge.SimplifyAndMergeFaces(ignoreMerge);
+
          for (int jj = 0; jj < triMerge.NoOfFaces; ++jj)
          {
             IFCAnyHandle faceHandle = null;
@@ -2234,8 +2197,8 @@ public static IList<IFCAnyHandle> ExportBodyAsTriangulatedFaceSet(ExporterIFC ex
          IFCFile file = exporterIFC.GetFile();
          Document document = element.Document;
 
-         double opacity;
-         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, exporterIFC, element, geomObject, out opacity);
+         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, element, 
+            geomObject, out double opacity, out ElementId matId);
 
          IList<IFCAnyHandle> triangulatedBodyList = new List<IFCAnyHandle>();
 
@@ -2243,9 +2206,8 @@ public static IList<IFCAnyHandle> ExportBodyAsTriangulatedFaceSet(ExporterIFC ex
          
          // We need to collect all SOlids and Meshes from the GeometryObject if it is of types GeometryElement or GeometryInstance
          // If the geomObject is GeometryELement or GeometryInstance, we need to collect their primitive Solid and Mesh first
-         bool allNotToBeExported;
          IList<GeometryObject> geomObjectPrimitives = GetGeometriesFromGeometryElement(
-            exporterIFC, document, geomObject, true, out allNotToBeExported);
+            exporterIFC, document, geomObject, true, out bool allNotToBeExported);
 
          // At this point the collection will only contains Solids and/or Meshes. Loop through each of them
          foreach (GeometryObject geom in geomObjectPrimitives)
@@ -2378,6 +2340,9 @@ public static IList<IFCAnyHandle> ExportBodyAsTriangulatedFaceSet(ExporterIFC ex
                triangulatedBodyList.Add(triangulatedMesh);
          }
 
+         foreach (IFCAnyHandle triangulatedBody in triangulatedBodyList)
+            CreateSurfaceStyleForRepItem(exporterIFC, document, options.CreatingVoid, triangulatedBody, matId);
+
          return triangulatedBodyList;
       }
 
@@ -2406,9 +2371,9 @@ public static IList<IFCAnyHandle> ExportBodyAsTessellatedFaceSet(ExporterIFC exp
          return tessellatedBodyList;
       }
 
-      private static IFCAnyHandle GetBestColourAndOpacity(IFCFile file, ExporterIFC exporterIFC, Element element, GeometryObject geometryObject, out double opacity)
+      private static IFCAnyHandle GetBestColourAndOpacity(IFCFile file, Element element, GeometryObject geometryObject, out double opacity, out ElementId bestMaterialId)
       {
-         ElementId bestMaterialId = GetBestMaterialIdFromGeometryOrParameter(geometryObject, exporterIFC, element);
+         bestMaterialId = GetBestMaterialIdFromGeometryOrParameter(geometryObject, element);
          
          Material matElem = (bestMaterialId != null && bestMaterialId != ElementId.InvalidElementId) ? 
             element.Document.GetElement(bestMaterialId) as Material : null;
@@ -2445,8 +2410,8 @@ private static IFCAnyHandle ExportSurfaceAsTriangulatedFaceSet(ExporterIFC expor
       {
          IFCFile file = exporterIFC.GetFile();
 
-         double opacity;
-         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, exporterIFC, element, geomObject, out opacity);
+         IFCAnyHandle ifcColourRgbList = GetBestColourAndOpacity(file, element, geomObject,
+            out double opacity, out _);
 
          IList<int> colourIndex = new List<int>();
 
@@ -2458,7 +2423,7 @@ private static IFCAnyHandle ExportSurfaceAsTriangulatedFaceSet(ExporterIFC expor
          }
          else if (geomObject is Mesh)
          {
-            triangleList = GetTriangleListFromMesh(geomObject, options, trfToUse);
+            triangleList = GetTriangleListFromMesh(geomObject, trfToUse);
          }
          // There is also a possibility that the geomObject is an GeometryElement thaat is a collection of GeometryObjects. Go through the collection and get the Mesh, Solid, or Face in it
          else if (geomObject is GeometryElement)
@@ -2469,14 +2434,15 @@ private static IFCAnyHandle ExportSurfaceAsTriangulatedFaceSet(ExporterIFC expor
                if (geom is Solid)
                   triangleList.AddRange(GetTriangleListFromSolid(geom, options, trfToUse));
                if (geom is Mesh)
-                  triangleList.AddRange(GetTriangleListFromMesh(geom, options, trfToUse));
+                  triangleList.AddRange(GetTriangleListFromMesh(geom, trfToUse));
                if (geom is Face)
                {
                   Mesh faceMesh = (geom as Face).Triangulate();
-                  triangleList.AddRange(GetTriangleListFromMesh(faceMesh, options, trfToUse));
+                  triangleList.AddRange(GetTriangleListFromMesh(faceMesh, trfToUse));
                }
             }
          }
+
          IFCAnyHandle indexedTriangles = GeometryUtil.GetIndexedTriangles(file, triangleList);
          for (int faceCnt = 0; faceCnt < triangleList.Count; ++faceCnt)
          {
@@ -2706,7 +2672,7 @@ private static BodyData ExportBodyAsBRep(ExporterIFC exporterIFC, IList<Geometry
             if (exportAsBReps && (currAnalyzer != null))
             {
                SweptSolidExporter sweptSolidExporter = SweptSolidExporter.Create(exporterIFC, element, currAnalyzer, geomObject);
-               HashSet<IFCAnyHandle> facetHnds = (sweptSolidExporter != null) ? sweptSolidExporter.Facets : null;
+               HashSet<IFCAnyHandle> facetHnds = sweptSolidExporter?.Facets;
                if (facetHnds != null && facetHnds.Count != 0)
                {
                   currentFaceHashSetList.Add(facetHnds);
@@ -2718,7 +2684,7 @@ private static BodyData ExportBodyAsBRep(ExporterIFC exporterIFC, IList<Geometry
             // Next, try to represent as an AdvancedBRep.
             if (!alreadyExported && canExportAsAdvancedGeometry)
             {
-               IFCAnyHandle advancedBrepBodyItem = ExportBodyAsAdvancedBrep(exporterIFC, element, options, geomObject);
+               IFCAnyHandle advancedBrepBodyItem = ExportBodyAsAdvancedBrep(exporterIFC, element, geomObject);
                if (!IFCAnyHandleUtil.IsNullOrHasNoValue(advancedBrepBodyItem))
                {
                   bodyItems.Add(advancedBrepBodyItem);
@@ -2741,7 +2707,6 @@ private static BodyData ExportBodyAsBRep(ExporterIFC exporterIFC, IList<Geometry
                   foreach (IFCAnyHandle triangulatedBodyItem in triangulatedBodyItems)
                   {
                      bodyItems.Add(triangulatedBodyItem);
-                     CreateSurfaceStyleForRepItem(exporterIFC, document, options.CreatingVoid, triangulatedBodyItem, materialId);
                      bodyData.AddRepresentationItemInfo(document, geomObject, materialId, triangulatedBodyItem);
                   }
                   alreadyExported = true;
@@ -2885,15 +2850,13 @@ private static BodyData ExportBodyAsBRep(ExporterIFC exporterIFC, IList<Geometry
                      matToUse++;
 
                   IFCAnyHandle faceSetHnd = IFCInstanceExporter.CreateConnectedFaceSet(file, currentFaceHashSet);
-                  HashSet<IFCAnyHandle> surfaceSet = null;
-                  if (faceSets.TryGetValue(materialIds[matToUse], out surfaceSet))
+                  if (faceSets.TryGetValue(materialIds[matToUse], out HashSet<IFCAnyHandle> surfaceSet))
                   {
                      surfaceSet.Add(faceSetHnd);
                   }
                   else
                   {
-                     surfaceSet = new HashSet<IFCAnyHandle>();
-                     surfaceSet.Add(faceSetHnd);
+                     surfaceSet = new HashSet<IFCAnyHandle>() { faceSetHnd };
                      faceSets[materialIds[matToUse]] = surfaceSet;
                   }
                }
@@ -3393,7 +3356,7 @@ public static BodyData ExportBody(ExporterIFC exporterIFC,
                                  addInfo |= GenerateAdditionalInfo.GenerateFootprint;
 
                               SweptSolidExporter sweptSolidExporter = SweptSolidExporter.Create(exporterIFC, element, simpleSweptSolidAnalyzer, solid, addInfo: addInfo);
-                              IFCAnyHandle sweptHandle = (sweptSolidExporter != null) ? sweptSolidExporter.RepresentationItem : null;
+                              IFCAnyHandle sweptHandle = sweptSolidExporter?.RepresentationItem;
 
                               if (!IFCAnyHandleUtil.IsNullOrHasNoValue(sweptHandle))
                               {
@@ -3457,14 +3420,14 @@ public static BodyData ExportBody(ExporterIFC exporterIFC,
                            bodyData.RepresentationHnd =
                                  RepresentationUtil.CreateSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItemSet, bodyData.RepresentationHnd);
                            bodyData.ShapeRepresentationType = ShapeRepresentationType.SweptSolid;
-                           bodyData = SaveMaterialAndFootprintInfo(exporterIFC, bodyData, materialAndProfile, footprintInfoSet, options.CollectFootprintHandle);
+                           bodyData = SaveMaterialAndFootprintInfo(bodyData, materialAndProfile, footprintInfoSet, options.CollectFootprintHandle);
                         }
                         else if (hasSweptSolids && !hasExtrusions)
                         {
                            bodyData.RepresentationHnd =
                                  RepresentationUtil.CreateAdvancedSweptSolidRep(exporterIFC, element, categoryId, contextOfItems, bodyItemSet, bodyData.RepresentationHnd);
                            bodyData.ShapeRepresentationType = ShapeRepresentationType.AdvancedSweptSolid;
-                           bodyData = SaveMaterialAndFootprintInfo(exporterIFC, bodyData, materialAndProfile, footprintInfoSet, options.CollectFootprintHandle);
+                           bodyData = SaveMaterialAndFootprintInfo(bodyData, materialAndProfile, footprintInfoSet, options.CollectFootprintHandle);
                         }
                         else if (hasRepresentationType == ShapeRepresentationType.Tessellation)
                         {
@@ -3645,13 +3608,8 @@ public static BodyData ExportBody(ExporterIFC exporterIFC,
          return ExportBody(exporterIFC, element, categoryId, overrideMaterialId, geomList,
              options, exportBodyParams);
       }
-
-      static void DeleteOrphanedFootprintHnd(IFCAnyHandle footprintHandle)
-      {
-         RepresentationUtil.DeleteShapeRepresentation(footprintHandle);
-      }
-
-      static BodyData SaveMaterialAndFootprintInfo(ExporterIFC exporterIFC, BodyData bodyData, MaterialAndProfile materialAndProfile, HashSet<FootPrintInfo> footprintInfoSet, bool collectFootprintOption)
+      
+      static BodyData SaveMaterialAndFootprintInfo(BodyData bodyData, MaterialAndProfile materialAndProfile, HashSet<FootPrintInfo> footprintInfoSet, bool collectFootprintOption)
       {
          if (materialAndProfile != null)
             bodyData.MaterialAndProfile = materialAndProfile;
@@ -3672,27 +3630,6 @@ static BodyData SaveMaterialAndFootprintInfo(ExporterIFC exporterIFC, BodyData b
          return bodyData;
       }
 
-      static bool IsAllPlanar(GeometryObject geom)
-      {
-         bool ret = true;
-
-         if (geom is Solid)
-         {
-            Solid solid = geom as Solid;
-            foreach (Face f in solid.Faces)
-            {
-               if (!(f is PlanarFace))
-               {
-                  ret = false;
-                  break;
-               }
-            }
-            return ret;
-         }
-         else
-            return false;
-      }
-
       static List<List<XYZ>> GetTriangleListFromSolid(GeometryObject geomObject, BodyExporterOptions options, Transform trfToUse)
       {
          List<List<XYZ>> triangleList = new List<List<XYZ>>();
@@ -3733,7 +3670,7 @@ static List<List<XYZ>> GetTriangleListFromSolid(GeometryObject geomObject, BodyE
          return triangleList;
       }
 
-      static List<List<XYZ>> GetTriangleListFromMesh(GeometryObject geomObject, BodyExporterOptions options, Transform trfToUse)
+      static List<List<XYZ>> GetTriangleListFromMesh(GeometryObject geomObject, Transform trfToUse)
       {
          List<List<XYZ>> triangleList = new List<List<XYZ>>();
          Mesh geomMesh = geomObject as Mesh;
diff --git a/Source/Revit.IFC.Export/Exporter/CeilingExporter.cs b/Source/Revit.IFC.Export/Exporter/CeilingExporter.cs
index 28905c4c..dd8346dd 100644
--- a/Source/Revit.IFC.Export/Exporter/CeilingExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/CeilingExporter.cs
@@ -193,7 +193,7 @@ public static void ExportCovering(ExporterIFC exporterIFC, Element element, ref
                      }
                      else
                      {
-                        ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geomElem, exporterIFC, element);
+                        ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geomElem, element);
                         CategoryUtil.CreateMaterialAssociation(exporterIFC, covering, matId);
                      }
                   }
diff --git a/Source/Revit.IFC.Export/Exporter/ConnectorExporter.cs b/Source/Revit.IFC.Export/Exporter/ConnectorExporter.cs
index 8211fac3..3ea2d489 100644
--- a/Source/Revit.IFC.Export/Exporter/ConnectorExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/ConnectorExporter.cs
@@ -498,27 +498,31 @@ public static string GetConnectorParameterFromDescription(Connector connector, s
             return parameterValue;
 
          string parsedValue = String.Empty;
-
          // For the connectors of pipes or fittings we extract the parameters from the connector's owner
          // for others - from the connector itself
-         Element owner = connector.Owner;
-         bool isPipeConnector = owner is Pipe;
-         bool isFittingConnector = owner is FamilyInstance && (owner as FamilyInstance).MEPModel is MechanicalFitting;
-         if (isPipeConnector || isFittingConnector)
+         if (!ExporterCacheManager.MEPCache.ConnectorDescriptionCache.TryGetValue(connector, out parsedValue))
          {
-            // Read description from the parameter with the name based on connector ID
-            int connectorId = connector.Id;
-            // ID's if pipe connectors are zero-based
-            if (isPipeConnector)
-               connectorId++;
-
-            string descriptionParameter = "PortDescription " + connectorId.ToString();
-            ParameterUtil.GetStringValueFromElementOrSymbol(owner, descriptionParameter, out parsedValue);
-         }
-         else
-         {
-            parsedValue = connector.Description;
+            Element owner = connector.Owner;
+            if (owner is Pipe ||
+               owner is Duct ||
+               owner is FamilyInstance && (owner as FamilyInstance).MEPModel is MechanicalFitting)
+            {
+               // Read description from the parameter with the name based on connector ID
+               int connectorId = connector.Id;
+               // ID's if pipe connectors are zero-based
+               if (owner is Pipe || owner is Duct)
+                  connectorId++;
+
+               string descriptionParameter = "PortDescription " + connectorId.ToString();
+               ParameterUtil.GetStringValueFromElementOrSymbol(owner, descriptionParameter, out parsedValue);
+            }
+            else
+            {
+               parsedValue = connector.Description;
+            }
+            ExporterCacheManager.MEPCache.ConnectorDescriptionCache.Add(connector, parsedValue);
          }
+
         
          if (String.IsNullOrEmpty(parsedValue))
             return parameterValue;
diff --git a/Source/Revit.IFC.Export/Exporter/CurtainSystemExporter.cs b/Source/Revit.IFC.Export/Exporter/CurtainSystemExporter.cs
index 69070a3f..8d157c53 100644
--- a/Source/Revit.IFC.Export/Exporter/CurtainSystemExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/CurtainSystemExporter.cs
@@ -186,7 +186,7 @@ public static void ExportCurtainObjectCommonAsContainer(ICollection<ElementId> a
       /// The handle.
       /// </returns>
       public static IFCAnyHandle ExportCurtainObjectCommonAsOneBRep(ICollection<ElementId> allSubElements, Element wallElement,
-         ExporterIFC exporterIFC, PlacementSetter setter, IFCAnyHandle localPlacement)
+         ExporterIFC exporterIFC)
       {
          IFCAnyHandle prodDefRep = null;
          Document document = wallElement.Document;
@@ -231,8 +231,7 @@ public static IFCAnyHandle ExportCurtainObjectCommonAsOneBRep(ICollection<Elemen
             // Export AdvancedFace before use fallback BREP
             else if (ExporterCacheManager.ExportOptionsCache.ExportAs4DesignTransferView)
             {
-               BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(false, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
-               IFCAnyHandle advancedBRep = BodyExporter.ExportBodyAsAdvancedBrep(exporterIFC, subElem, bodyExporterOptions, geomElem);
+               IFCAnyHandle advancedBRep = BodyExporter.ExportBodyAsAdvancedBrep(exporterIFC, subElem, geomElem);
                if (!IFCAnyHandleUtil.IsNullOrHasNoValue(advancedBRep))
                {
                   bodyItems.Add(advancedBRep);
@@ -386,7 +385,7 @@ private static void ExportBase(ExporterIFC exporterIFC, ICollection<ElementId> a
                IFCAnyHandle rep = null;
                if (!canExportCurtainWallAsContainer)
                {
-                  rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC, setter, localPlacement);
+                  rep = ExportCurtainObjectCommonAsOneBRep(allSubElements, element, exporterIFC);
                   if (IFCAnyHandleUtil.IsNullOrHasNoValue(rep))
                      return;
                }
diff --git a/Source/Revit.IFC.Export/Exporter/DuctLiningExporter.cs b/Source/Revit.IFC.Export/Exporter/DuctLiningExporter.cs
index 5df09247..846db6f5 100644
--- a/Source/Revit.IFC.Export/Exporter/DuctLiningExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/DuctLiningExporter.cs
@@ -89,7 +89,7 @@ public static bool ExportDuctLining(ExporterIFC exporterIFC, Element element,
 
                   productWrapper.AddElement(element, ductLining, placementSetter.LevelInfo, ecData, true, exportInfo);
 
-                  ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
+                  ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, element);
                   CategoryUtil.CreateMaterialAssociation(exporterIFC, ductLining, matId);
                }
             }
diff --git a/Source/Revit.IFC.Export/Exporter/Exporter.cs b/Source/Revit.IFC.Export/Exporter/Exporter.cs
index 9ab4fe7e..17b9a74b 100644
--- a/Source/Revit.IFC.Export/Exporter/Exporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/Exporter.cs
@@ -165,8 +165,7 @@ public void ExportIFC(Autodesk.Revit.DB.Document document, ExporterIFC exporterI
 
             ParamExprListener.ResetParamExprInternalDicts();
             InitializeElementExporters();
-            if (m_ElementExporter != null)
-               m_ElementExporter(exporterIFC, document);
+            m_ElementExporter?.Invoke(exporterIFC, document);
 
             EndExport(exporterIFC, document);
             WriteIFCFile(exporterIFC, document);
@@ -243,12 +242,7 @@ protected void ExportAdvanceSteelElements(ExporterIFC exporterIFC, Autodesk.Revi
          {
             try
             {
-#if IFC_OPENSOURCE
-               string dllPath = Assembly.GetExecutingAssembly().Location;
-               Assembly assembly = Assembly.LoadFrom(Path.GetDirectoryName(dllPath) + @"\Autodesk.SteelConnections.ASIFC.dll");
-#else
                Assembly assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + @"\Addins\SteelConnections\Autodesk.SteelConnections.ASIFC.dll");
-#endif
                if (assembly != null)
                {
                   Type type = assembly.GetType("Autodesk.SteelConnections.ASIFC.ASExporter");
@@ -373,7 +367,7 @@ protected void ExportSpatialElements(ExporterIFC exporterIFC, Autodesk.Revit.DB.
          // couldn't be exported above.
          // Note that FilteredElementCollector is one use only, so we need to create a new one here.
          FilteredElementCollector spatialElementCollector = GetExportElementCollector(document, useFilterViewInCollector);
-         SpatialElementExporter.InitializeSpatialElementGeometryCalculator(document, exporterIFC);
+         SpatialElementExporter.InitializeSpatialElementGeometryCalculator(document);
          ElementFilter spatialElementFilter = ElementFilteringUtil.GetSpatialElementFilter(document, exporterIFC);
          spatialElementCollector.WherePasses(spatialElementFilter);
 
@@ -648,7 +642,7 @@ public virtual bool ExportElement(ExporterIFC exporterIFC, Autodesk.Revit.DB.Ele
          }
          catch (System.Exception ex)
          {
-            HandleUnexpectedException(ex, exporterIFC, element);
+            HandleUnexpectedException(ex, element);
             return false;
          }
 
@@ -660,7 +654,7 @@ public virtual bool ExportElement(ExporterIFC exporterIFC, Autodesk.Revit.DB.Ele
       /// </summary>
       /// <param name="ex">The unexpected exception.</param>
       /// <param name="element ">The element got the exception.</param>
-      internal void HandleUnexpectedException(Exception exception, ExporterIFC exporterIFC, Element element)
+      internal void HandleUnexpectedException(Exception exception, Element element)
       {
          Document document = element.Document;
          string errMsg = String.Format("IFC error: Exporting element \"{0}\",{1} - {2}", element.Name, element.Id, exception.ToString());
@@ -685,7 +679,7 @@ internal void HandleUnexpectedException(Exception exception, ExporterIFC exporte
       /// <param name="exporterIFC">The IFC exporter object.</param>
       /// <param name="element">The element to check.</param>
       /// <returns>True for MEP type of elements.</returns>
-      private bool IsMEPType(ExporterIFC exporterIFC, Element element, IFCExportInfoPair exportType)
+      private bool IsMEPType(Element element, IFCExportInfoPair exportType)
       {
          return (ElementFilteringUtil.IsMEPType(exportType) || ElementFilteringUtil.ProxyForMEPType(element, exportType));
       }
@@ -975,7 +969,7 @@ public virtual void ExportElementImpl(ExporterIFC exporterIFC, Element element,
                   // We would then in addition have specialized functions that would convert specific Revit elements to specific IFC instances where extra information
                   // could be gathered from the element.
                   bool exported = false;
-                  if (IsMEPType(exporterIFC, element, exportType))
+                  if (IsMEPType(element, exportType))
                   {
                      exported = GenericMEPExporter.Export(exporterIFC, element, geomElem, exportType, ifcEnumType, productWrapper);
                   }
@@ -1024,37 +1018,20 @@ protected virtual IFCFileModelOptions CreateIFCFileModelOptions(ExporterIFC expo
          IFCFileModelOptions modelOptions = new IFCFileModelOptions();
          if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC2X2_ADD1.exp");
             modelOptions.SchemaName = "IFC2x2_FINAL";
          }
          else if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC4.exp");
             modelOptions.SchemaName = "IFC4";
          }
          else
          {
             // We leave IFC2x3 as default until IFC4 is finalized and generally supported across platforms.
-            modelOptions.SchemaFile = LocateSchemaFile("IFC2X3_TC1.exp");
             modelOptions.SchemaName = "IFC2x3";
          }
          return modelOptions;
       }
 
-      private string LocateSchemaFile(string schemaFileName)
-      {
-         string filePath = null;
-#if IFC_OPENSOURCE
-         // Find the alternate schema file from the open source install folder
-         filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location), schemaFileName);
-         if (!File.Exists(filePath))
-#endif
-         {
-            filePath = Path.Combine(DirectoryUtil.RevitProgramPath, "EDM", schemaFileName);
-         }
-         return filePath;
-      }
-
       /// <summary>
       /// Sets the lists of property sets to be exported.  This can be overriden.
       /// </summary>
@@ -2027,9 +2004,9 @@ private void WriteIFCFile(ExporterIFC exporterIFC, Document document)
                descriptions.Add("Options [Excluded Entities: " + ExporterCacheManager.ExportOptionsCache.ExcludeFilter + "]");
             }
 
-            string projectNumber = (projectInfo != null) ? projectInfo.Number : null;
-            string projectName = (projectInfo != null) ? projectInfo.Name : null;
-            string projectStatus = (projectInfo != null) ? projectInfo.Status : null;
+            string projectNumber = projectInfo?.Number;
+            string projectName = projectInfo?.Name;
+            string projectStatus = projectInfo?.Status;
 
             if (projectNumber == null)
                projectNumber = string.Empty;
@@ -2485,7 +2462,7 @@ private void CreateProject(ExporterIFC exporterIFC, Document doc, IFCAnyHandle a
          }
          else
          {
-            IFCAnyHandle telecomAddress = GetTelecomAddressFromExtStorage(file, doc);
+            IFCAnyHandle telecomAddress = GetTelecomAddressFromExtStorage(file);
             IList<IFCAnyHandle> telecomAddresses = null;
             if (telecomAddress != null)
             {
@@ -2542,8 +2519,8 @@ private void CreateProject(ExporterIFC exporterIFC, Document doc, IFCAnyHandle a
          else
          {
             // As per IFC implementer's agreement, we get IfcProject.Name from ProjectInfo.Number and IfcProject.Longname from ProjectInfo.Name 
-            projectName = (projectInfo != null) ? projectInfo.Number : null;
-            projectLongName = (projectInfo != null) ? projectInfo.Name : null;
+            projectName = projectInfo?.Number;
+            projectLongName = projectInfo?.Name;
 
             // Get project description if it is set in the Project info
             projectDescription = (projectInfo != null) ? NamingUtil.GetDescriptionOverride(projectInfo, null) : null;
@@ -2600,7 +2577,7 @@ private void CreateContact(IFCFile file, string category, string company, string
          IFCAnyHandle contactEntry = IFCInstanceExporter.CreatePersonAndOrganization(file, contactPerson, contactOrganization, actorRoles);
       }
 
-      private IFCAnyHandle GetTelecomAddressFromExtStorage(IFCFile file, Document document)
+      private IFCAnyHandle GetTelecomAddressFromExtStorage(IFCFile file)
       {
          IFCFileHeaderItem fHItem = ExporterCacheManager.ExportOptionsCache.FileHeaderItem;
          if (!String.IsNullOrEmpty(fHItem.AuthorEmail))
@@ -3228,10 +3205,11 @@ private IFCAnyHandle CreateDefaultUnits(ExporterIFC exporterIFC, Document doc)
          }
 
          // Power - support metric watt only.
+         IFCAnyHandle powerSIUnit = null;
          {
-            IFCAnyHandle voltageSIUnit = CreateSIUnit(file, SpecTypeId.HvacPower, IFCUnit.PowerUnit, IFCSIUnitName.Watt,
+            powerSIUnit = CreateSIUnit(file, SpecTypeId.HvacPower, IFCUnit.PowerUnit, IFCSIUnitName.Watt,
                 null, UnitTypeId.Watts);
-            unitSet.Add(voltageSIUnit);      // created above, so unique.
+            unitSet.Add(powerSIUnit);      // created above, so unique.
          }
 
          // Force - support newtons (N) and kN only.
@@ -3301,6 +3279,19 @@ private IFCAnyHandle CreateDefaultUnits(ExporterIFC exporterIFC, Document doc)
             unitSet.Add(luminousEfficacyUnit);
          }
 
+         // Sound Power - support watt only.
+         {
+            ISet<IFCAnyHandle> elements = new HashSet<IFCAnyHandle>();
+            elements.Add(IFCInstanceExporter.CreateDerivedUnitElement(file, powerSIUnit, 1));
+
+            IFCAnyHandle soundPowerUnit = IFCInstanceExporter.CreateDerivedUnit(file, elements,
+                IFCDerivedUnitEnum.SoundPowerUnit, null);
+            unitSet.Add(soundPowerUnit);
+
+            double soundPowerFactor = UnitUtils.ConvertFromInternalUnits(1.0, UnitTypeId.Watts);
+            ExporterCacheManager.UnitsCache.AddUnit(SpecTypeId.Wattage, soundPowerUnit, soundPowerFactor, 0.0);
+         }
+
          // Linear Velocity - support m/s only.
          {
             ISet<IFCAnyHandle> elements = new HashSet<IFCAnyHandle>();
@@ -4025,24 +4016,19 @@ private bool ExportCachedSystem(ExporterIFC exporterIFC, Document doc, IFCFile f
 
                string systemGUID = GUIDUtil.CreateGUID(systemElem);
                IFCAnyHandle systemHandle = null;
-               string ifcEnumType;
-               IFCExportInfoPair exportAs = ExporterUtil.GetObjectExportType(exporterIFC, systemElem, out ifcEnumType);
-               if (exportAs.ExportInstance == IFCEntityType.IfcDistributionSystem)
+               if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
                {
-                  if (exportAs.ValidatedPredefinedType == null)
-                  {
-                     Toolkit.IFC4.IFCDistributionSystem systemType = ConnectorExporter.GetMappedIFCDistributionSystemFromElement(systemElem);
-                     exportAs.ValidatedPredefinedType = IFCValidateEntry.ValidateStrEnum<Toolkit.IFC4.IFCDistributionSystem>(systemType.ToString());
-                  }
-
-                  string longName = NamingUtil.GetLongNameOverride(systemElem, null);
-                  systemHandle = IFCInstanceExporter.CreateDistributionSystem(file, exportAs, systemGUID,
-                     ownerHistory, name, desc, objectType, longName);
+                  systemHandle = IFCInstanceExporter.CreateSystem(file, systemGUID,
+                     ownerHistory, name, desc, objectType);
                }
                else
                {
-                  systemHandle = IFCInstanceExporter.CreateSystem(file, systemGUID,
-                   ownerHistory, name, desc, objectType);
+                  string longName = NamingUtil.GetLongNameOverride(systemElem, null);
+                  Toolkit.IFC4.IFCDistributionSystem systemType = ConnectorExporter.GetMappedIFCDistributionSystemFromElement(systemElem);
+                  string predefinedType = IFCValidateEntry.ValidateStrEnum<Toolkit.IFC4.IFCDistributionSystem>(systemType.ToString());
+
+                  systemHandle = IFCInstanceExporter.CreateDistributionSystem(file, systemGUID,
+                     ownerHistory, name, desc, objectType, longName, predefinedType);
                }
 
                if (systemHandle == null)
diff --git a/Source/Revit.IFC.Export/Exporter/ExporterInitializer.cs b/Source/Revit.IFC.Export/Exporter/ExporterInitializer.cs
index 604daa59..b7c3a87b 100644
--- a/Source/Revit.IFC.Export/Exporter/ExporterInitializer.cs
+++ b/Source/Revit.IFC.Export/Exporter/ExporterInitializer.cs
@@ -107,6 +107,7 @@ public static void InitPropertySets(Exporter.PropertySetsToExport propertySetsTo
                propertySetsToExport += InitCommonPropertySets;
 
             propertySetsToExport += InitExtraCommonPropertySets;
+            propertySetsToExport += InitPredefinedPropertySets;
          }
 
          if (ExporterCacheManager.ExportOptionsCache.PropertySetOptions.ExportSchedulesAsPsets)
@@ -133,8 +134,7 @@ public static void InitPropertySets(Exporter.PropertySetsToExport propertySetsTo
                propertySetsToExport += InitCOBIEPropertySets;
          }
 
-         if (propertySetsToExport != null)
-            propertySetsToExport(cache.PropertySets);
+         propertySetsToExport?.Invoke(cache.PropertySets);
       }
 
       /// <summary>
@@ -148,10 +148,20 @@ public static void InitQuantities(Exporter.QuantitiesToExport quantitiesToExport
 
          if (exportBaseQuantities)
          {
-            if (quantitiesToExport == null)
-               quantitiesToExport = InitBaseQuantities;
+            if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
+            {
+               if (quantitiesToExport == null)
+                  quantitiesToExport = InitBaseQuantities;
+               else
+                  quantitiesToExport += InitBaseQuantities;
+            }
             else
-               quantitiesToExport += InitBaseQuantities;
+            {
+               if (quantitiesToExport == null)
+                  quantitiesToExport = InitQtoSets;
+               else
+                  quantitiesToExport += InitQtoSets;
+            }
          }
 
          if (ExporterCacheManager.ExportOptionsCache.ExportAsCOBIE)
@@ -162,8 +172,7 @@ public static void InitQuantities(Exporter.QuantitiesToExport quantitiesToExport
                quantitiesToExport += InitCOBIEQuantities;
          }
 
-         if (quantitiesToExport != null)
-            quantitiesToExport(cache.Quantities);
+         quantitiesToExport?.Invoke(cache.Quantities);
       }
 
       private static ISet<IFCEntityType> GetListOfRelatedEntities(IFCEntityType entityType)
@@ -416,6 +425,13 @@ private static void InitUserDefinedPropertySets(IList<IList<PropertySetDescripti
 
       }
 
+      private static bool IsSupportedFieldType(ScheduleFieldType fieldType)
+      {
+         return (fieldType == ScheduleFieldType.Instance ||
+            fieldType == ScheduleFieldType.ElementType ||
+            fieldType == ScheduleFieldType.CombinedParameter);
+      }
+
       /// <summary>
       /// Initializes custom property sets from schedules.
       /// </summary>
@@ -497,54 +513,76 @@ from viewSchedule in viewScheduleElementCollector
                ScheduleField field = definition.GetField(ii);
 
                ScheduleFieldType fieldType = field.FieldType;
-               if (fieldType != ScheduleFieldType.Instance && fieldType != ScheduleFieldType.ElementType)
-                  continue;
-
-               ElementId parameterId = field.ParameterId;
-               if (parameterId == ElementId.InvalidElementId)
+               if (!IsSupportedFieldType(fieldType))
                   continue;
 
-               // We use asBuiltInParameterId to get the parameter by id below.  We don't want to use it later, however, so
-               // we store builtInParameterId only if it is a proper member of the enumeration.
-               BuiltInParameter asBuiltInParameterId = (BuiltInParameter)parameterId.IntegerValue;
-               BuiltInParameter builtInParameterId =
-                   Enum.IsDefined(typeof(BuiltInParameter), asBuiltInParameterId) ? asBuiltInParameterId : BuiltInParameter.INVALID;
-
-               Parameter containedElementParameter = null;
+               // Check if it is a combined parameter.  If so, calculate the formula later 
+               // as necessary.
+               PropertySetEntry ifcPSE = null;
 
-               // We could cache the actual elements when we store the element ids.  However, this would almost certainly take more
-               // time than getting one of the first few elements in the collector.
-               foreach (Element containedElement in elementsInViewScheduleCollector)
+               switch (fieldType)
                {
-                  if (fieldType == ScheduleFieldType.Instance)
-                     containedElementParameter = containedElement.get_Parameter(asBuiltInParameterId);
-
-                  // shared parameters can return ScheduleFieldType.Instance, even if they are type parameters, so take a look.
-                  if (containedElementParameter == null)
-                  {
-                     ElementId containedElementTypeId = containedElement.GetTypeId();
-                     Element containedElementType = null;
-                     if (containedElementTypeId != ElementId.InvalidElementId)
+                  case ScheduleFieldType.CombinedParameter:
+                     {
+                        ifcPSE = PropertySetEntry.CreateParameterEntry(field.ColumnHeading, field.GetCombinedParameters());
+                        break;
+                     }
+                  default:
                      {
-                        if (!cachedElementTypes.TryGetValue(containedElementTypeId, out containedElementType))
+                        ElementId parameterId = field.ParameterId;
+                        if (parameterId == ElementId.InvalidElementId)
+                           continue;
+
+                        // We use asBuiltInParameterId to get the parameter by id below.  We don't want to use it later, however, so
+                        // we store builtInParameterId only if it is a proper member of the enumeration.
+                        BuiltInParameter asBuiltInParameterId = (BuiltInParameter)parameterId.IntegerValue;
+                        BuiltInParameter builtInParameterId =
+                            Enum.IsDefined(typeof(BuiltInParameter), asBuiltInParameterId) ? asBuiltInParameterId : BuiltInParameter.INVALID;
+
+                        // We could cache the actual elements when we store the element ids.  However,
+                        // this would almost certainly take more time than getting one of the first
+                        // few elements in the collector.
+                        foreach (Element containedElement in elementsInViewScheduleCollector)
                         {
-                           containedElementType = document.GetElement(containedElementTypeId);
-                           cachedElementTypes[containedElementTypeId] = containedElementType;
+                           Parameter containedElementParameter = null;
+
+                           if (fieldType == ScheduleFieldType.Instance)
+                              containedElementParameter = containedElement.get_Parameter(asBuiltInParameterId);
+
+                           // shared parameters can return ScheduleFieldType.Instance, even if they are type parameters, so take a look.
+                           if (containedElementParameter == null)
+                           {
+                              ElementId containedElementTypeId = containedElement.GetTypeId();
+                              Element containedElementType = null;
+                              if (containedElementTypeId != ElementId.InvalidElementId)
+                              {
+                                 if (!cachedElementTypes.TryGetValue(containedElementTypeId, out containedElementType))
+                                 {
+                                    containedElementType = document.GetElement(containedElementTypeId);
+                                    cachedElementTypes[containedElementTypeId] = containedElementType;
+                                 }
+                              }
+
+                              if (containedElementType != null)
+                                 containedElementParameter = containedElementType.get_Parameter(asBuiltInParameterId);
+                           }
+
+                           if (containedElementParameter != null)
+                           {
+                              ifcPSE = PropertySetEntry.CreateParameterEntry(containedElementParameter, builtInParameterId);
+                              break;
+                           }
                         }
-                     }
-                     if (containedElementType != null)
-                        containedElementParameter = containedElementType.get_Parameter(asBuiltInParameterId);
-                  }
 
-                  if (containedElementParameter != null)
-                     break;
+                        break;
+                     }
                }
-               if (containedElementParameter == null)
-                  continue;
 
-               PropertySetEntry ifcPSE = PropertySetEntry.CreateParameterEntry(containedElementParameter, builtInParameterId);
-               ifcPSE.PropertyName = field.ColumnHeading;
-               customPSet.AddEntry(ifcPSE);
+               if (ifcPSE != null)
+               {
+                  ifcPSE.PropertyName = field.ColumnHeading;
+                  customPSet.AddEntry(ifcPSE);
+               }
             }
 
             customPropertySets.Add(customPSet);
@@ -969,6 +1007,60 @@ private static void InitPlateBaseQuantities(IList<QuantityDescription> baseQuant
          baseQuantities.Add(ifcPlateQuantity);
       }
 
+      /// <summary>
+      /// Init Duct Fitting Quantities
+      /// </summary>
+      /// <param name="baseQuantities">The list of all of the quantity sets.</param>
+      private static void InitDuctFittingBaseQuantities(IList<QuantityDescription> baseQuantities)
+      {
+         QuantityDescription ifcDuctFittingQuantities = new QuantityDescription("DuctFitting", IFCEntityType.IfcDuctFitting);
+         ifcDuctFittingQuantities.AddEntry("Length", QuantityType.PositiveLength, LengthCalculator.Instance);
+         ifcDuctFittingQuantities.AddEntry("GrossCrossSectionArea", QuantityType.Area, GrossCrossSectionAreaCalculator.Instance);
+         ifcDuctFittingQuantities.AddEntry("NetCrossSectionArea", QuantityType.Area, NetCrossSectionAreaCalculator.Instance);
+         ifcDuctFittingQuantities.AddEntry("OuterSurfaceArea", QuantityType.Area, OuterSurfaceAreaCalculator.Instance);
+         ifcDuctFittingQuantities.AddEntry("GrossWeight", QuantityType.Weight, GrossWeightCalculator.Instance);
+
+         baseQuantities.Add(ifcDuctFittingQuantities);
+      }
+
+      private static void InitElectricApplianceBaseQuantities(IList<QuantityDescription> baseQuantities)
+      {
+         QuantityDescription ifcElectricApplianceQuantities = new QuantityDescription("ElectricAppliance", IFCEntityType.IfcElectricAppliance);
+         ifcElectricApplianceQuantities.AddEntry("GrossWeight", QuantityType.Weight, GrossWeightCalculator.Instance);
+
+         baseQuantities.Add(ifcElectricApplianceQuantities);
+      }
+
+      private static void InitCableCarrierFittingBaseQuantities(IList<QuantityDescription> baseQuantities)
+      {
+         QuantityDescription ifcCableCarrierFittingQuantities = new QuantityDescription("CableCarrierFitting", IFCEntityType.IfcCableCarrierFitting);
+         ifcCableCarrierFittingQuantities.AddEntry("GrossWeight", QuantityType.Weight, GrossWeightCalculator.Instance);
+
+         baseQuantities.Add(ifcCableCarrierFittingQuantities);
+      }
+
+      private static void InitCableCarrierSegmentQuantities(IList<QuantityDescription> baseQuantities)
+      {
+         QuantityDescription ifcCableCarrierSegmentQuantities = new QuantityDescription("CableCarrierSegment", IFCEntityType.IfcCableCarrierSegment);
+         ifcCableCarrierSegmentQuantities.AddEntry("Length", QuantityType.PositiveLength, LengthCalculator.Instance);
+         ifcCableCarrierSegmentQuantities.AddEntry("CrossSectionArea", QuantityType.Area, CrossSectionAreaCalculator.Instance);
+         ifcCableCarrierSegmentQuantities.AddEntry("OuterSurfaceArea", QuantityType.Area, OuterSurfaceAreaCalculator.Instance);
+         ifcCableCarrierSegmentQuantities.AddEntry("GrossWeight", QuantityType.Weight, GrossWeightCalculator.Instance);
+
+         baseQuantities.Add(ifcCableCarrierSegmentQuantities);
+      }
+
+      private static void InitCableSegmentQuantities(IList<QuantityDescription> baseQuantities)
+      {
+         QuantityDescription ifcCableSegmentQuantities = new QuantityDescription("CableSegment", IFCEntityType.IfcCableSegment);
+         ifcCableSegmentQuantities.AddEntry("Length", QuantityType.PositiveLength, LengthCalculator.Instance);
+         ifcCableSegmentQuantities.AddEntry("CrossSectionArea", QuantityType.Area, CrossSectionAreaCalculator.Instance);
+         ifcCableSegmentQuantities.AddEntry("OuterSurfaceArea", QuantityType.Area, OuterSurfaceAreaCalculator.Instance);
+         ifcCableSegmentQuantities.AddEntry("GrossWeight", QuantityType.Weight, GrossWeightCalculator.Instance);
+
+         baseQuantities.Add(ifcCableSegmentQuantities);
+      }
+
       /// <summary>
       /// Initializes base quantities.
       /// </summary>
@@ -993,6 +1085,13 @@ private static void InitBaseQuantities(IList<IList<QuantityDescription>> quantit
          InitSpaceBaseQuantities(baseQuantities);
          InitStairFlightBaseQuantities(baseQuantities);
          InitWindowBaseQuantities(baseQuantities);
+
+         // MEP Quantities
+         InitDuctFittingBaseQuantities(baseQuantities);
+         InitElectricApplianceBaseQuantities(baseQuantities);
+         InitCableCarrierFittingBaseQuantities(baseQuantities);
+         InitCableCarrierSegmentQuantities(baseQuantities);
+         InitCableSegmentQuantities(baseQuantities);
          
          quantities.Add(baseQuantities);
       }
diff --git a/Source/Revit.IFC.Export/Exporter/ExporterInitializer_PsetDef.cs b/Source/Revit.IFC.Export/Exporter/ExporterInitializer_PsetDef.cs
index 80fda378..c63ca876 100644
--- a/Source/Revit.IFC.Export/Exporter/ExporterInitializer_PsetDef.cs
+++ b/Source/Revit.IFC.Export/Exporter/ExporterInitializer_PsetDef.cs
@@ -531,6 +531,924 @@ public static void InitCommonPropertySets(IList<IList<PropertySetDescription>> p
          propertySets.Add(commonPropertySets);
       }
 
+      public static void InitPredefinedPropertySets(IList<IList<PropertySetDescription>> propertySets)
+      {
+         IList<PropertySetDescription> predefinedPropertySets = new List<PropertySetDescription>();
+         InitIfcDoorLiningProperties(predefinedPropertySets);
+         InitIfcDoorPanelProperties(predefinedPropertySets);
+         InitIfcPermeableCoveringProperties(predefinedPropertySets);
+         InitIfcReinforcementDefinitionProperties(predefinedPropertySets);
+         InitIfcWindowLiningProperties(predefinedPropertySets);
+         InitIfcWindowPanelProperties(predefinedPropertySets);
+
+         propertySets.Add(predefinedPropertySets);
+      }
+
+      private static void InitIfcDoorLiningProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcDoorLiningProperties = new PropertySetDescription();
+         IfcDoorLiningProperties.Name = "IfcDoorLiningProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorLiningProperties"))
+         {
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoorStyle);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdDepth");
+            ifcPSE.PropertyName = "ThresholdDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomOffset");
+            ifcPSE.PropertyName = "TransomOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningOffset");
+            ifcPSE.PropertyName = "LiningOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdOffset");
+            ifcPSE.PropertyName = "ThresholdOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingThickness");
+            ifcPSE.PropertyName = "CasingThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingDepth");
+            ifcPSE.PropertyName = "CasingDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdThickness");
+            ifcPSE.PropertyName = "ThresholdThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorLiningProperties"))
+         {
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoorStyle);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdDepth");
+            ifcPSE.PropertyName = "ThresholdDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomOffset");
+            ifcPSE.PropertyName = "TransomOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningOffset");
+            ifcPSE.PropertyName = "LiningOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdOffset");
+            ifcPSE.PropertyName = "ThresholdOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingThickness");
+            ifcPSE.PropertyName = "CasingThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingDepth");
+            ifcPSE.PropertyName = "CasingDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdThickness");
+            ifcPSE.PropertyName = "ThresholdThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorLiningProperties"))
+         {
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorLiningProperties.EntityTypes.Add(IFCEntityType.IfcDoorType);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdDepth");
+            ifcPSE.PropertyName = "ThresholdDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomOffset");
+            ifcPSE.PropertyName = "TransomOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningOffset");
+            ifcPSE.PropertyName = "LiningOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdOffset");
+            ifcPSE.PropertyName = "ThresholdOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingThickness");
+            ifcPSE.PropertyName = "CasingThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("CasingDepth");
+            ifcPSE.PropertyName = "CasingDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CasingDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("ThresholdThickness");
+            ifcPSE.PropertyName = "ThresholdThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThresholdThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningToPanelOffsetX");
+            ifcPSE.PropertyName = "LiningToPanelOffsetX";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningToPanelOffsetXCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningToPanelOffsetY");
+            ifcPSE.PropertyName = "LiningToPanelOffsetY";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningToPanelOffsetYCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcDoorLiningProperties);
+         }
+      }
+
+
+      private static void InitIfcDoorPanelProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcDoorPanelProperties = new PropertySetDescription();
+         IfcDoorPanelProperties.Name = "IfcDoorPanelProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorPanelProperties"))
+         {
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoorStyle);
+            ifcPSE = new PropertySetEntry("PanelDepth");
+            ifcPSE.PropertyName = "PanelDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelWidth");
+            ifcPSE.PropertyName = "PanelWidth";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelWidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelOperation");
+            ifcPSE.PropertyName = "PanelOperation";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X2.IFCDoorPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelOperationCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X2.IFCDoorPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorPanelProperties"))
+         {
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoorStyle);
+            ifcPSE = new PropertySetEntry("PanelDepth");
+            ifcPSE.PropertyName = "PanelDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelWidth");
+            ifcPSE.PropertyName = "PanelWidth";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelWidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelOperation");
+            ifcPSE.PropertyName = "PanelOperation";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.IFCDoorPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelOperationCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.IFCDoorPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcDoorPanelProperties"))
+         {
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcDoorPanelProperties.EntityTypes.Add(IFCEntityType.IfcDoorType);
+            ifcPSE = new PropertySetEntry("PanelDepth");
+            ifcPSE.PropertyName = "PanelDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelWidth");
+            ifcPSE.PropertyName = "PanelWidth";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelWidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelOperation");
+            ifcPSE.PropertyName = "PanelOperation";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCDoorPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelOperationCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCDoorPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcDoorPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcDoorPanelProperties);
+         }
+      }
+
+
+      private static void InitIfcPermeableCoveringProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcPermeableCoveringProperties = new PropertySetDescription();
+         IfcPermeableCoveringProperties.Name = "IfcPermeableCoveringProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcPermeableCoveringProperties"))
+         {
+            IfcPermeableCoveringProperties.EntityTypes.Add(IFCEntityType.IfcDoor);
+            IfcPermeableCoveringProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcPermeableCoveringProperties.EntityTypes.Add(IFCEntityType.IfcDoorType);
+            IfcPermeableCoveringProperties.EntityTypes.Add(IFCEntityType.IfcWindowType);
+            ifcPSE = new PropertySetEntry("OperationType");
+            ifcPSE.PropertyName = "OperationType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCPermeableCoveringOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperationTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcPermeableCoveringProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCWindowPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcPermeableCoveringProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FrameDepth");
+            ifcPSE.PropertyName = "FrameDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcPermeableCoveringProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FrameThickness");
+            ifcPSE.PropertyName = "FrameThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcPermeableCoveringProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcPermeableCoveringProperties);
+         }
+      }
+
+
+      private static void InitIfcReinforcementDefinitionProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcReinforcementDefinitionProperties = new PropertySetDescription();
+         IfcReinforcementDefinitionProperties.Name = "IfcReinforcementDefinitionProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcReinforcementDefinitionProperties"))
+         {
+            IfcReinforcementDefinitionProperties.EntityTypes.Add(IFCEntityType.IfcReinforcingElement);
+            ifcPSE = new PropertySetEntry("DefinitionType");
+            ifcPSE.PropertyName = "DefinitionType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DefinitionTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcReinforcementDefinitionProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcReinforcementDefinitionProperties"))
+         {
+            IfcReinforcementDefinitionProperties.EntityTypes.Add(IFCEntityType.IfcReinforcingElement);
+            ifcPSE = new PropertySetEntry("DefinitionType");
+            ifcPSE.PropertyName = "DefinitionType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DefinitionTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcReinforcementDefinitionProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcReinforcementDefinitionProperties"))
+         {
+            IfcReinforcementDefinitionProperties.EntityTypes.Add(IFCEntityType.IfcReinforcingElement);
+            ifcPSE = new PropertySetEntry("DefinitionType");
+            ifcPSE.PropertyName = "DefinitionType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DefinitionTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcReinforcementDefinitionProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcReinforcementDefinitionProperties);
+         }
+      }
+
+
+      private static void InitIfcWindowLiningProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcWindowLiningProperties = new PropertySetDescription();
+         IfcWindowLiningProperties.Name = "IfcWindowLiningProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowLiningProperties"))
+         {
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindowStyle);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstTransomOffset");
+            ifcPSE.PropertyName = "FirstTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondTransomOffset");
+            ifcPSE.PropertyName = "SecondTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstMullionOffset");
+            ifcPSE.PropertyName = "FirstMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondMullionOffset");
+            ifcPSE.PropertyName = "SecondMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("MullionThickness");
+            ifcPSE.PropertyName = "MullionThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MullionThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowLiningProperties"))
+         {
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindowStyle);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstTransomOffset");
+            ifcPSE.PropertyName = "FirstTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondTransomOffset");
+            ifcPSE.PropertyName = "SecondTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstMullionOffset");
+            ifcPSE.PropertyName = "FirstMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondMullionOffset");
+            ifcPSE.PropertyName = "SecondMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("MullionThickness");
+            ifcPSE.PropertyName = "MullionThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MullionThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowLiningProperties"))
+         {
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowLiningProperties.EntityTypes.Add(IFCEntityType.IfcWindowType);
+            ifcPSE = new PropertySetEntry("LiningDepth");
+            ifcPSE.PropertyName = "LiningDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstTransomOffset");
+            ifcPSE.PropertyName = "FirstTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondTransomOffset");
+            ifcPSE.PropertyName = "SecondTransomOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondTransomOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FirstMullionOffset");
+            ifcPSE.PropertyName = "FirstMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FirstMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("SecondMullionOffset");
+            ifcPSE.PropertyName = "SecondMullionOffset";
+            ifcPSE.PropertyType = PropertyType.NormalisedRatio;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondMullionOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningThickness");
+            ifcPSE.PropertyName = "LiningThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("TransomThickness");
+            ifcPSE.PropertyName = "TransomThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TransomThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("MullionThickness");
+            ifcPSE.PropertyName = "MullionThickness";
+            ifcPSE.PropertyType = PropertyType.NonNegativeLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MullionThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningOffset");
+            ifcPSE.PropertyName = "LiningOffset";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningOffsetCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningToPanelOffsetX");
+            ifcPSE.PropertyName = "LiningToPanelOffsetX";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningToPanelOffsetXCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("LiningToPanelOffsetY");
+            ifcPSE.PropertyName = "LiningToPanelOffsetY";
+            ifcPSE.PropertyType = PropertyType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LiningToPanelOffsetYCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowLiningProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcWindowLiningProperties);
+         }
+      }
+
+
+      private static void InitIfcWindowPanelProperties(IList<PropertySetDescription> commonPropertySets)
+      {
+         PropertySetDescription IfcWindowPanelProperties = new PropertySetDescription();
+         IfcWindowPanelProperties.Name = "IfcWindowPanelProperties";
+         PropertySetEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowPanelProperties"))
+         {
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindowStyle);
+            ifcPSE = new PropertySetEntry("FrameDepth");
+            ifcPSE.PropertyName = "FrameDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FrameThickness");
+            ifcPSE.PropertyName = "FrameThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("OperationType");
+            ifcPSE.PropertyName = "OperationType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X2.IFCWindowPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperationTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X2.IFCWindowPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs2x3 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowPanelProperties"))
+         {
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindowStyle);
+            ifcPSE = new PropertySetEntry("FrameDepth");
+            ifcPSE.PropertyName = "FrameDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FrameThickness");
+            ifcPSE.PropertyName = "FrameThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("OperationType");
+            ifcPSE.PropertyName = "OperationType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.IFCWindowPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperationTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.IFCWindowPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "IfcWindowPanelProperties"))
+         {
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindow);
+            IfcWindowPanelProperties.EntityTypes.Add(IFCEntityType.IfcWindowType);
+            ifcPSE = new PropertySetEntry("FrameDepth");
+            ifcPSE.PropertyName = "FrameDepth";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameDepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("FrameThickness");
+            ifcPSE.PropertyName = "FrameThickness";
+            ifcPSE.PropertyType = PropertyType.PositiveLength;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FrameThicknessCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("OperationType");
+            ifcPSE.PropertyName = "OperationType";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCWindowPanelOperation);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperationTypeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PanelPosition");
+            ifcPSE.PropertyName = "PanelPosition";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.IFCWindowPanelPosition);
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanelPositionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            IfcWindowPanelProperties.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            commonPropertySets.Add(IfcWindowPanelProperties);
+         }
+      }
+
+
       private static void InitPset_ActionRequest(IList<PropertySetDescription> commonPropertySets)
       {
          PropertySetDescription propertySetActionRequest = new PropertySetDescription();
@@ -601,7 +1519,7 @@ private static void InitPset_ActionRequest(IList<PropertySetDescription> commonP
             ifcPSE.PropertyName = "RequestSourceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RequestSourceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RequestSourceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RequestSourceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -644,7 +1562,7 @@ private static void InitPset_ActionRequest(IList<PropertySetDescription> commonP
             ifcPSE.PropertyName = "Status";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RequestStatus);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RequestStatus);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.StatusCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -890,7 +1808,7 @@ private static void InitPset_ActuatorTypeCommon(IList<PropertySetDescription> co
             ifcPSE.PropertyName = "FailPosition";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FailPosition);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FailPosition);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FailPositionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -1021,7 +1939,7 @@ private static void InitPset_ActuatorTypeElectricActuator(IList<PropertySetDescr
             ifcPSE.PropertyName = "ElectricActuatorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ElectricActuatorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ElectricActuatorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ElectricActuatorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -1575,7 +2493,7 @@ private static void InitPset_AirSideSystemInformation(IList<PropertySetDescripti
             ifcPSE.PropertyName = "AirSideSystemType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirSideSystemType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirSideSystemType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirSideSystemTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -1585,7 +2503,7 @@ private static void InitPset_AirSideSystemInformation(IList<PropertySetDescripti
             ifcPSE.PropertyName = "AirSideSystemDistributionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirSideSystemDistributionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirSideSystemDistributionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirSideSystemDistributionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -2220,7 +3138,7 @@ private static void InitPset_AirTerminalBoxTypeCommon(IList<PropertySetDescripti
             ifcPSE.PropertyName = "ArrangementType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalBoxArrangementType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalBoxArrangementType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ArrangementTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -2230,7 +3148,7 @@ private static void InitPset_AirTerminalBoxTypeCommon(IList<PropertySetDescripti
             ifcPSE.PropertyName = "ReheatType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalBoxReheatType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalBoxReheatType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ReheatTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -2994,7 +3912,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "Shape";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalShape);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalShape);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ShapeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3004,7 +3922,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "FlowPattern";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFlowPattern);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFlowPattern);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlowPatternCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3032,7 +3950,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "DischargeDirection";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalDischargeDirection);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalDischargeDirection);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DischargeDirectionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3067,7 +3985,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "FinishType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFinishType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFinishType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FinishTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3085,7 +4003,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "MountingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalMountingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalMountingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MountingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3095,7 +4013,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "CoreType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalCoreType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalCoreType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CoreTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3129,7 +4047,7 @@ private static void InitPset_AirTerminalTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "FlowControlType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFlowControlType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFlowControlType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlowControlTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3537,7 +4455,7 @@ private static void InitPset_AirTerminalTypeRectangular(IList<PropertySetDescrip
             ifcPSE.PropertyName = "FaceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFaceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFaceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3582,7 +4500,7 @@ private static void InitPset_AirTerminalTypeRound(IList<PropertySetDescription>
             ifcPSE.PropertyName = "FaceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFaceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFaceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -3700,7 +4618,7 @@ private static void InitPset_AirTerminalTypeSquare(IList<PropertySetDescription>
             ifcPSE.PropertyName = "FaceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalFaceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalFaceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4118,7 +5036,7 @@ private static void InitPset_AirToAirHeatRecoveryTypeCommon(IList<PropertySetDes
             ifcPSE.PropertyName = "HeatTransferTypeEnum";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirToAirHeatTransferHeatTransferType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirToAirHeatTransferHeatTransferType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeatTransferTypeEnumCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4511,7 +5429,7 @@ private static void InitPset_AnalogInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4521,7 +5439,7 @@ private static void InitPset_AnalogInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "NotifyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetNotifyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetNotifyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NotifyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4652,7 +5570,7 @@ private static void InitPset_AnalogOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4662,7 +5580,7 @@ private static void InitPset_AnalogOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "NotifyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetNotifyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetNotifyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NotifyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4879,7 +5797,7 @@ private static void InitPset_Asset(IList<PropertySetDescription> commonPropertyS
             ifcPSE.PropertyName = "AssetAccountingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AssetAccountingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AssetAccountingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AssetAccountingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4889,7 +5807,7 @@ private static void InitPset_Asset(IList<PropertySetDescription> commonPropertyS
             ifcPSE.PropertyName = "AssetTaxType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AssetTaxType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AssetTaxType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AssetTaxTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -4899,7 +5817,7 @@ private static void InitPset_Asset(IList<PropertySetDescription> commonPropertyS
             ifcPSE.PropertyName = "AssetInsuranceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AssetInsuranceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AssetInsuranceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AssetInsuranceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -5286,6 +6204,16 @@ private static void InitPset_AudioVisualApplianceTypeCommon(IList<PropertySetDes
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
             propertySetAudioVisualApplianceTypeCommon.AddEntry(ifcPSE);
 
+            ifcPSE = new PropertySetEntry("AudioVolume2");
+            ifcPSE.PropertyName = "AudioVolume2";
+            ifcPSE.PropertyType = PropertyType.SoundPower;
+            ifcPSE.PropertyValueType = PropertyValueType.SingleValue;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Audio Volume 2");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AudioVolume2Calculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
+            propertySetAudioVisualApplianceTypeCommon.AddEntry(ifcPSE);
+
          }
          if (ifcPSE != null)
          {
@@ -6169,7 +7097,7 @@ private static void InitPset_BinaryInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "Polarity";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PolarityEnum);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PolarityEnum);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PolarityCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6213,7 +7141,7 @@ private static void InitPset_BinaryInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "FeedbackValue";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetFeedbackValueType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetFeedbackValueType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FeedbackValueCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6223,7 +7151,7 @@ private static void InitPset_BinaryInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6233,7 +7161,7 @@ private static void InitPset_BinaryInput(IList<PropertySetDescription> commonPro
             ifcPSE.PropertyName = "AckedTransitions";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetAckedTransitionsType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetAckedTransitionsType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AckedTransitionsCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6320,7 +7248,7 @@ private static void InitPset_BinaryOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "Polarity";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PolarityEnum);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PolarityEnum);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PolarityCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6346,7 +7274,7 @@ private static void InitPset_BinaryOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "AlarmValue";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetAlarmValueType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetAlarmValueType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AlarmValueCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6356,7 +7284,7 @@ private static void InitPset_BinaryOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6366,7 +7294,7 @@ private static void InitPset_BinaryOutput(IList<PropertySetDescription> commonPr
             ifcPSE.PropertyName = "AckedTransitions";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetAckedTransitionsType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetAckedTransitionsType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AckedTransitionsCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6786,7 +7714,7 @@ private static void InitPset_BoilerTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "OperatingMode";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BoilerOperatingMode);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BoilerOperatingMode);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperatingModeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -6900,116 +7828,111 @@ private static void InitPset_BoilerTypeCommon(IList<PropertySetDescription> comm
          {
             propertySetBoilerTypeCommon.EntityTypes.Add(IFCEntityType.IfcBoiler);
             propertySetBoilerTypeCommon.ObjectType = "IfcBoiler";
-#pragma warning disable 0162
-            if (false)
-            {
-
-               ifcPSE = new PropertySetEntry("Reference");
-               ifcPSE.PropertyName = "Reference";
-               ifcPSE.PropertyType = PropertyType.Identifier;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Reference");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "Référence");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "参照記号");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ReferenceCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("Status");
-               ifcPSE.PropertyName = "Status";
-               ifcPSE.PropertyType = PropertyType.Label;
-               ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-               ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_ElementStatus);
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Status");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "Etat");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "状態");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.StatusCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("PressureRating");
-               ifcPSE.PropertyName = "PressureRating";
-               ifcPSE.PropertyType = PropertyType.Pressure;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Pressure Rating");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "PressionAdmissibleNominale");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "常用圧力");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PressureRatingCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("OperatingMode");
-               ifcPSE.PropertyName = "OperatingMode";
-               ifcPSE.PropertyType = PropertyType.Label;
-               ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-               ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_BoilerOperatingMode);
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Operating Mode");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "ModeFonctionnement");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "動作モード");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperatingModeCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("HeatTransferSurfaceArea");
-               ifcPSE.PropertyName = "HeatTransferSurfaceArea";
-               ifcPSE.PropertyType = PropertyType.Area;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Heat Transfer Surface Area");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "SurfaceEchangeChaleur");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "伝熱面積");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeatTransferSurfaceAreaCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("NominalPartLoadRatio");
-               ifcPSE.PropertyName = "NominalPartLoadRatio";
-               ifcPSE.PropertyValueType = PropertyValueType.BoundedValue;
-               ifcPSE.PropertyType = PropertyType.Real;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Nominal Part Load Ratio");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "PlageNominaleChargePartielle");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "設計部分負荷比率");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NominalPartLoadRatioCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("WaterInletTemperatureRange");
-               ifcPSE.PropertyName = "WaterInletTemperatureRange";
-               ifcPSE.PropertyValueType = PropertyValueType.BoundedValue;
-               ifcPSE.PropertyType = PropertyType.ThermodynamicTemperature;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Water Inlet Temperature Range");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "PlageTempératureAlimentationEau");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "入口水温範囲");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WaterInletTemperatureRangeCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("WaterStorageCapacity");
-               ifcPSE.PropertyName = "WaterStorageCapacity";
-               ifcPSE.PropertyType = PropertyType.Volume;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Water Storage Capacity");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "CapacitéRéservoirEau");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "缶内水量");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WaterStorageCapacityCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("IsWaterStorageHeater");
-               ifcPSE.PropertyName = "IsWaterStorageHeater";
-               ifcPSE.PropertyType = PropertyType.Boolean;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Is Water Storage Heater");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "AvoirChauffeEau");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "給湯タンク有無");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.IsWaterStorageHeaterCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-            }
+            ifcPSE = new PropertySetEntry("Reference");
+            ifcPSE.PropertyName = "Reference";
+            ifcPSE.PropertyType = PropertyType.Identifier;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Reference");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "Référence");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "参照記号");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ReferenceCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("Status");
+            ifcPSE.PropertyName = "Status";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_ElementStatus);
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Status");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "Etat");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "状態");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.StatusCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("PressureRating");
+            ifcPSE.PropertyName = "PressureRating";
+            ifcPSE.PropertyType = PropertyType.Pressure;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Pressure Rating");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "PressionAdmissibleNominale");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "常用圧力");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PressureRatingCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("OperatingMode");
+            ifcPSE.PropertyName = "OperatingMode";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_BoilerOperatingMode);
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Operating Mode");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "ModeFonctionnement");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "動作モード");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperatingModeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("HeatTransferSurfaceArea");
+            ifcPSE.PropertyName = "HeatTransferSurfaceArea";
+            ifcPSE.PropertyType = PropertyType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Heat Transfer Surface Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "SurfaceEchangeChaleur");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "伝熱面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeatTransferSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("NominalPartLoadRatio");
+            ifcPSE.PropertyName = "NominalPartLoadRatio";
+            ifcPSE.PropertyValueType = PropertyValueType.BoundedValue;
+            ifcPSE.PropertyType = PropertyType.Real;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Nominal Part Load Ratio");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "PlageNominaleChargePartielle");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "設計部分負荷比率");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NominalPartLoadRatioCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("WaterInletTemperatureRange");
+            ifcPSE.PropertyName = "WaterInletTemperatureRange";
+            ifcPSE.PropertyValueType = PropertyValueType.BoundedValue;
+            ifcPSE.PropertyType = PropertyType.ThermodynamicTemperature;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Water Inlet Temperature Range");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "PlageTempératureAlimentationEau");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "入口水温範囲");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WaterInletTemperatureRangeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("WaterStorageCapacity");
+            ifcPSE.PropertyName = "WaterStorageCapacity";
+            ifcPSE.PropertyType = PropertyType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Water Storage Capacity");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "CapacitéRéservoirEau");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "缶内水量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WaterStorageCapacityCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("IsWaterStorageHeater");
+            ifcPSE.PropertyName = "IsWaterStorageHeater";
+            ifcPSE.PropertyType = PropertyType.Boolean;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Is Water Storage Heater");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "AvoirChauffeEau");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "給湯タンク有無");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.IsWaterStorageHeaterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
             ifcPSE = new PropertySetEntry("PartialLoadEfficiencyCurves");
             ifcPSE.PropertyName = "PartialLoadEfficiencyCurves";
             ifcPSE.PropertyArgumentType = PropertyType.PositiveRatio;
@@ -7035,32 +7958,30 @@ private static void InitPset_BoilerTypeCommon(IList<PropertySetDescription> comm
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
             propertySetBoilerTypeCommon.AddEntry(ifcPSE);
 
-            if (false)
-            {
-               ifcPSE = new PropertySetEntry("NominalEnergyConsumption");
-               ifcPSE.PropertyName = "NominalEnergyConsumption";
-               ifcPSE.PropertyType = PropertyType.Power;
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Nominal Energy Consumption");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "Consommation nominale d'energie");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "設計エネルギー消費量");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NominalEnergyConsumptionCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-
-               ifcPSE = new PropertySetEntry("EnergySource");
-               ifcPSE.PropertyName = "EnergySource";
-               ifcPSE.PropertyType = PropertyType.Label;
-               ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-               ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_EnergySource);
-               ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Energy Source");
-               ifcPSE.AddLocalizedParameterName(LanguageType.French, "SourceEnergie");
-               ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "エネルギ種別");
-               calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EnergySourceCalculator");
-               if (calcType != null)
-                  ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
-               propertySetBoilerTypeCommon.AddEntry(ifcPSE);
-            }
+            ifcPSE = new PropertySetEntry("NominalEnergyConsumption");
+            ifcPSE.PropertyName = "NominalEnergyConsumption";
+            ifcPSE.PropertyType = PropertyType.Power;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Nominal Energy Consumption");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "Consommation nominale d'energie");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "設計エネルギー消費量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NominalEnergyConsumptionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("EnergySource");
+            ifcPSE.PropertyName = "EnergySource";
+            ifcPSE.PropertyType = PropertyType.Label;
+            ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC4.PEnum_EnergySource);
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Energy Source");
+            ifcPSE.AddLocalizedParameterName(LanguageType.French, "SourceEnergie");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "エネルギ種別");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EnergySourceCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            propertySetBoilerTypeCommon.AddEntry(ifcPSE);
+
          }
          if (ifcPSE != null)
          {
@@ -9178,7 +10099,7 @@ private static void InitPset_CableCarrierSegmentTypeConduitSegment(IList<Propert
             ifcPSE.PropertyName = "ConduitShapeType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ConduitShapeType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ConduitShapeType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ConduitShapeTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -9952,7 +10873,7 @@ private static void InitPset_CableSegmentTypeConductorSegment(IList<PropertySetD
             ifcPSE.PropertyName = "ElectricalConductorFunction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ConductorFunction);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ConductorFunction);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ElectricalConductorFunctionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -11272,7 +12193,7 @@ private static void InitPset_CoilTypeHydronic(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "CoilCoolant";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoilCoolant);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoilCoolant);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CoilCoolantCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -11282,7 +12203,7 @@ private static void InitPset_CoilTypeHydronic(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "CoilConnectionDirection";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoilConnectionDirection);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoilConnectionDirection);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CoilConnectionDirectionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -11292,7 +12213,7 @@ private static void InitPset_CoilTypeHydronic(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "CoilFluidArrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoilFluidArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoilFluidArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CoilFluidArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -12299,7 +13220,7 @@ private static void InitPset_CompressorTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "PowerSource";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CompressorTypePowerSource);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CompressorTypePowerSource);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PowerSourceCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -12309,7 +13230,7 @@ private static void InitPset_CompressorTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "RefrigerantClass";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RefrigerantClass);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RefrigerantClass);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RefrigerantClassCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -13973,7 +14894,7 @@ private static void InitPset_CondenserTypeCommon(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "RefrigerantClass";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RefrigerantClass);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RefrigerantClass);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RefrigerantClassCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -14352,7 +15273,7 @@ private static void InitPset_ControllerTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "ControlType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ControlType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ControlType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ControlTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -14647,7 +15568,7 @@ private static void InitPset_ControllerTypeProportional(IList<PropertySetDescrip
             ifcPSE.PropertyName = "ControlType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ProportionalControlType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ProportionalControlType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ControlTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -14807,7 +15728,7 @@ private static void InitPset_ControllerTypeTwoPosition(IList<PropertySetDescript
             ifcPSE.PropertyName = "ControlType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TwoPositionControlType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TwoPositionControlType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ControlTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -15375,7 +16296,7 @@ private static void InitPset_CooledBeamTypeActive(IList<PropertySetDescription>
             ifcPSE.PropertyName = "AirFlowConfiguration";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CooledBeamActiveAirFlowConfigurationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CooledBeamActiveAirFlowConfigurationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirFlowConfigurationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -15394,7 +16315,7 @@ private static void InitPset_CooledBeamTypeActive(IList<PropertySetDescription>
             ifcPSE.PropertyName = "SupplyAirConnectionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CooledBeamSupplyAirConnectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CooledBeamSupplyAirConnectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SupplyAirConnectionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -15672,7 +16593,7 @@ private static void InitPset_CooledBeamTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "WaterFlowControlSystemType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CooledBeamWaterFlowControlSystemType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CooledBeamWaterFlowControlSystemType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WaterFlowControlSystemTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -15788,7 +16709,7 @@ private static void InitPset_CooledBeamTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "IntegratedLightingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CooledBeamIntegratedLightingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CooledBeamIntegratedLightingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.IntegratedLightingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -15798,7 +16719,7 @@ private static void InitPset_CooledBeamTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "PipeConnectionEnum";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CooledBeamPipeConnection);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CooledBeamPipeConnection);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PipeConnectionEnumCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -16368,7 +17289,7 @@ private static void InitPset_CoolingTowerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "CircuitType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoolingTowerCircuitType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoolingTowerCircuitType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CircuitTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -16378,7 +17299,7 @@ private static void InitPset_CoolingTowerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "FlowArrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoolingTowerFlowArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoolingTowerFlowArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlowArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -16388,7 +17309,7 @@ private static void InitPset_CoolingTowerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "SprayType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoolingTowerSprayType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoolingTowerSprayType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SprayTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -16398,7 +17319,7 @@ private static void InitPset_CoolingTowerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "CapacityControl";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoolingTowerCapacityControl);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoolingTowerCapacityControl);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CapacityControlCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -16408,7 +17329,7 @@ private static void InitPset_CoolingTowerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "ControlStrategy";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CoolingTowerControlStrategy);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CoolingTowerControlStrategy);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ControlStrategyCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -17881,7 +18802,7 @@ private static void InitPset_DamperTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "Operation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperOperation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperOperation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -17891,7 +18812,7 @@ private static void InitPset_DamperTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "Orientation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperOrientation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperOrientation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OrientationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -17927,7 +18848,7 @@ private static void InitPset_DamperTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "BladeAction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperBladeAction);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperBladeAction);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BladeActionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -17937,7 +18858,7 @@ private static void InitPset_DamperTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "BladeShape";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperBladeShape);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperBladeShape);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BladeShapeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -17947,7 +18868,7 @@ private static void InitPset_DamperTypeCommon(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "BladeEdge";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperBladeEdge);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperBladeEdge);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BladeEdgeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -18405,7 +19326,7 @@ private static void InitPset_DamperTypeControlDamper(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "ControlDamperOperation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ControlDamperOperation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ControlDamperOperation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ControlDamperOperationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -18503,7 +19424,7 @@ private static void InitPset_DamperTypeFireDamper(IList<PropertySetDescription>
             ifcPSE.PropertyName = "ActuationType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FireDamperActuationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FireDamperActuationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ActuationTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -18513,7 +19434,7 @@ private static void InitPset_DamperTypeFireDamper(IList<PropertySetDescription>
             ifcPSE.PropertyName = "ClosureRatingEnum";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FireDamperClosureRating);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FireDamperClosureRating);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ClosureRatingEnumCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -22175,7 +23096,7 @@ private static void InitPset_DistributionPortDuct(IList<PropertySetDescription>
             ifcPSE.PropertyName = "ConnectionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DuctConnectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DuctConnectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ConnectionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -22502,7 +23423,7 @@ private static void InitPset_DistributionPortPipe(IList<PropertySetDescription>
             ifcPSE.PropertyName = "ConnectionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PipeEndStyleTreatment);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PipeEndStyleTreatment);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ConnectionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -24645,7 +25566,7 @@ private static void InitPset_DuctDesignCriteria(IList<PropertySetDescription> co
             ifcPSE.PropertyName = "DuctSizingMethod";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DuctSizingMethod);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DuctSizingMethod);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DuctSizingMethodCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -25444,7 +26365,7 @@ private static void InitPset_DuctSegmentTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "Shape";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DuctSegmentShape);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DuctSegmentShape);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ShapeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -25855,7 +26776,7 @@ private static void InitPset_DuctSilencerTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "Shape";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DuctSilencerShape);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DuctSilencerShape);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ShapeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -26296,7 +27217,7 @@ private static void InitPset_ElectricalDeviceCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "InsulationStandardClass";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_InsulationStandardClass);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_InsulationStandardClass);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.InsulationStandardClassCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -27346,7 +28267,7 @@ private static void InitPset_ElectricMotorTypeCommon(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "MotorEnclosureType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_MotorEnclosureType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_MotorEnclosureType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MotorEnclosureTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -27786,7 +28707,7 @@ private static void InitPset_ElementShading(IList<PropertySetDescription> common
             ifcPSE.PropertyName = "ShadingDeviceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ElementShading);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ElementShading);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ShadingDeviceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -29016,7 +29937,7 @@ private static void InitPset_EvaporativeCoolerTypeCommon(IList<PropertySetDescri
             ifcPSE.PropertyName = "FlowArrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_EvaporativeCoolerFlowArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_EvaporativeCoolerFlowArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlowArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -29579,7 +30500,7 @@ private static void InitPset_EvaporatorTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "EvaporatorMediumType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_EvaporatorMediumType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_EvaporatorMediumType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EvaporatorMediumTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -29589,7 +30510,7 @@ private static void InitPset_EvaporatorTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "EvaporatorCoolant";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_EvaporatorCoolant);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_EvaporatorCoolant);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EvaporatorCoolantCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -29599,7 +30520,7 @@ private static void InitPset_EvaporatorTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "RefrigerantClass";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RefrigerantClass);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RefrigerantClass);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RefrigerantClassCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -30357,7 +31278,7 @@ private static void InitPset_FanTypeCommon(IList<PropertySetDescription> commonP
             ifcPSE.PropertyName = "MotorDriveType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanMotorConnectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanMotorConnectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MotorDriveTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -30367,7 +31288,7 @@ private static void InitPset_FanTypeCommon(IList<PropertySetDescription> commonP
             ifcPSE.PropertyName = "CapacityControlType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanCapacityControlType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanCapacityControlType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CapacityControlTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -31066,7 +31987,7 @@ private static void InitPset_FilterTypeAirParticleFilter(IList<PropertySetDescri
             ifcPSE.PropertyName = "AirParticleFilterType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FilterAirParticleFilterType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FilterAirParticleFilterType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirParticleFilterTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -31094,7 +32015,7 @@ private static void InitPset_FilterTypeAirParticleFilter(IList<PropertySetDescri
             ifcPSE.PropertyName = "SeparationType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FilterAirParticleFilterSeparationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FilterAirParticleFilterSeparationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SeparationTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -31883,7 +32804,7 @@ private static void InitPset_FireSuppressionTerminalTypeBreechingInlet(IList<Pro
             ifcPSE.PropertyName = "BreechingInletType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BreechingInletType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BreechingInletType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BreechingInletTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -31909,7 +32830,7 @@ private static void InitPset_FireSuppressionTerminalTypeBreechingInlet(IList<Pro
             ifcPSE.PropertyName = "CouplingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BreechingInletCouplingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BreechingInletCouplingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CouplingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32142,7 +33063,7 @@ private static void InitPset_FireSuppressionTerminalTypeFireHydrant(IList<Proper
             ifcPSE.PropertyName = "FireHydrantType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FireHydrantType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FireHydrantType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FireHydrantTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32426,7 +33347,7 @@ private static void InitPset_FireSuppressionTerminalTypeHoseReel(IList<PropertyS
             ifcPSE.PropertyName = "HoseReelType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HoseReelType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HoseReelType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HoseReelTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32436,7 +33357,7 @@ private static void InitPset_FireSuppressionTerminalTypeHoseReel(IList<PropertyS
             ifcPSE.PropertyName = "HoseReelMountingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HoseReelMountingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HoseReelMountingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HoseReelMountingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32470,7 +33391,7 @@ private static void InitPset_FireSuppressionTerminalTypeHoseReel(IList<PropertyS
             ifcPSE.PropertyName = "HoseNozzleType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HoseNozzleType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HoseNozzleType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HoseNozzleTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32734,7 +33655,7 @@ private static void InitPset_FireSuppressionTerminalTypeSprinkler(IList<Property
             ifcPSE.PropertyName = "SprinklerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SprinklerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SprinklerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SprinklerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32744,7 +33665,7 @@ private static void InitPset_FireSuppressionTerminalTypeSprinkler(IList<Property
             ifcPSE.PropertyName = "Activation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SprinklerActivation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SprinklerActivation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ActivationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32754,7 +33675,7 @@ private static void InitPset_FireSuppressionTerminalTypeSprinkler(IList<Property
             ifcPSE.PropertyName = "Response";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SprinklerResponse);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SprinklerResponse);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ResponseCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -32788,7 +33709,7 @@ private static void InitPset_FireSuppressionTerminalTypeSprinkler(IList<Property
             ifcPSE.PropertyName = "BulbLiquidColor";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SprinklerBulbLiquidColor);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SprinklerBulbLiquidColor);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BulbLiquidColorCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33021,7 +33942,7 @@ private static void InitPset_FlowControllerDamper(IList<PropertySetDescription>
             ifcPSE.PropertyName = "SizingMethod";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_DamperSizingMethod);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_DamperSizingMethod);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SizingMethodCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33062,7 +33983,7 @@ private static void InitPset_FlowControllerFlowMeter(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "Purpose";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FlowMeterPurpose);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FlowMeterPurpose);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PurposeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33325,7 +34246,7 @@ private static void InitPset_FlowInstrumentTypePressureGauge(IList<PropertySetDe
             ifcPSE.PropertyName = "PressureGaugeType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PressureGaugeType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PressureGaugeType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PressureGaugeTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33415,7 +34336,7 @@ private static void InitPset_FlowInstrumentTypeThermometer(IList<PropertySetDesc
             ifcPSE.PropertyName = "ThermometerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ThermometerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ThermometerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ThermometerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33539,7 +34460,7 @@ private static void InitPset_FlowMeterTypeCommon(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "ReadOutType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_MeterReadOutType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_MeterReadOutType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ReadOutTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33743,7 +34664,7 @@ private static void InitPset_FlowMeterTypeGasMeter(IList<PropertySetDescription>
             ifcPSE.PropertyName = "GasType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_GasType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_GasType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GasTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -33969,7 +34890,7 @@ private static void InitPset_FlowMeterTypeWaterMeter(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "Type";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_WaterMeterType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_WaterMeterType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34003,7 +34924,7 @@ private static void InitPset_FlowMeterTypeWaterMeter(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "BackflowPreventerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BackflowPreventerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BackflowPreventerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BackflowPreventerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34192,7 +35113,7 @@ private static void InitPset_FlowMovingDeviceFan(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "DischargeType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanDischargeType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanDischargeType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DischargeTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34202,7 +35123,7 @@ private static void InitPset_FlowMovingDeviceFan(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "ApplicationOfFan";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanApplicationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanApplicationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ApplicationOfFanCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34212,7 +35133,7 @@ private static void InitPset_FlowMovingDeviceFan(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "CoilPosition";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanCoilPosition);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanCoilPosition);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CoilPositionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34222,7 +35143,7 @@ private static void InitPset_FlowMovingDeviceFan(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "MotorPosition";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanMotorPosition);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanMotorPosition);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MotorPositionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34232,7 +35153,7 @@ private static void InitPset_FlowMovingDeviceFan(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "FanMountingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FanMountingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FanMountingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FanMountingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34311,7 +35232,7 @@ private static void InitPset_FlowMovingDeviceFanCentrifugal(IList<PropertySetDes
             ifcPSE.PropertyName = "DischargePosition";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CentrifugalFanDischargePosition);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CentrifugalFanDischargePosition);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DischargePositionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34321,7 +35242,7 @@ private static void InitPset_FlowMovingDeviceFanCentrifugal(IList<PropertySetDes
             ifcPSE.PropertyName = "DirectionOfRotation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CentrifugalFanRotation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CentrifugalFanRotation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DirectionOfRotationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34331,7 +35252,7 @@ private static void InitPset_FlowMovingDeviceFanCentrifugal(IList<PropertySetDes
             ifcPSE.PropertyName = "Arrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CentrifugalFanArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CentrifugalFanArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34398,7 +35319,7 @@ private static void InitPset_FlowMovingDevicePump(IList<PropertySetDescription>
             ifcPSE.PropertyName = "BaseType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PumpBaseType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PumpBaseType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BaseTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34408,7 +35329,7 @@ private static void InitPset_FlowMovingDevicePump(IList<PropertySetDescription>
             ifcPSE.PropertyName = "DriveConnectionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PumpDriveConnectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PumpDriveConnectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DriveConnectionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34667,7 +35588,7 @@ private static void InitPset_FlowStorageDeviceTank(IList<PropertySetDescription>
             ifcPSE.PropertyName = "TankComposition";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TankComposition);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TankComposition);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TankCompositionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34734,7 +35655,7 @@ private static void InitPset_FlowTerminalAirTerminal(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "AirflowType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalAirflowType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalAirflowType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirflowTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -34744,7 +35665,7 @@ private static void InitPset_FlowTerminalAirTerminal(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "Location";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirTerminalLocation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirTerminalLocation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LocationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35402,7 +36323,7 @@ private static void InitPset_GasTerminalTypeGasAppliance(IList<PropertySetDescri
             ifcPSE.PropertyName = "GasApplianceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_GasApplianceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_GasApplianceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GasApplianceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35412,7 +36333,7 @@ private static void InitPset_GasTerminalTypeGasAppliance(IList<PropertySetDescri
             ifcPSE.PropertyName = "FlueType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FlueType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FlueType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlueTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35457,7 +36378,7 @@ private static void InitPset_GasTerminalTypeGasBurner(IList<PropertySetDescripti
             ifcPSE.PropertyName = "GasBurnerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_GasBurnerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_GasBurnerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GasBurnerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35507,7 +36428,7 @@ private static void InitPset_HeatExchangerTypeCommon(IList<PropertySetDescriptio
             ifcPSE.PropertyName = "Arrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HeatExchangerArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HeatExchangerArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35811,7 +36732,7 @@ private static void InitPset_HumidifierTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "Application";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HumidifierApplication);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HumidifierApplication);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ApplicationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -35845,7 +36766,7 @@ private static void InitPset_HumidifierTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "InternalControl";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HumidifierInternalControl);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HumidifierInternalControl);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.InternalControlCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36348,7 +37269,7 @@ private static void InitPset_LampTypeCommon(IList<PropertySetDescription> common
             ifcPSE.PropertyName = "LampBallastType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_LampBallastType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_LampBallastType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LampBallastTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36358,7 +37279,7 @@ private static void InitPset_LampTypeCommon(IList<PropertySetDescription> common
             ifcPSE.PropertyName = "LampCompensationType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_LampCompensationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_LampCompensationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LampCompensationTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36687,7 +37608,7 @@ private static void InitPset_LightFixtureTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "LightFixtureMountingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_LightFixtureMountingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_LightFixtureMountingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LightFixtureMountingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36697,7 +37618,7 @@ private static void InitPset_LightFixtureTypeCommon(IList<PropertySetDescription
             ifcPSE.PropertyName = "LightFixturePlacingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_LightFixturePlacingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_LightFixturePlacingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LightFixturePlacingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36870,7 +37791,7 @@ private static void InitPset_LightFixtureTypeExitSign(IList<PropertySetDescripti
             ifcPSE.PropertyName = "SelfTestFunction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SelfTestType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SelfTestType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SelfTestFunctionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36880,7 +37801,7 @@ private static void InitPset_LightFixtureTypeExitSign(IList<PropertySetDescripti
             ifcPSE.PropertyName = "BackupSupplySystem";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BackupSupplySystemType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BackupSupplySystemType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BackupSupplySystemCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36890,7 +37811,7 @@ private static void InitPset_LightFixtureTypeExitSign(IList<PropertySetDescripti
             ifcPSE.PropertyName = "PictogramEscapeDirection";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PictogramEscapeDirectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PictogramEscapeDirectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PictogramEscapeDirectionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -36900,7 +37821,7 @@ private static void InitPset_LightFixtureTypeExitSign(IList<PropertySetDescripti
             ifcPSE.PropertyName = "Addressablility";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AddressabilityType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AddressabilityType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AddressablilityCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -39828,7 +40749,7 @@ private static void InitPset_MultiStateInput(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -39838,7 +40759,7 @@ private static void InitPset_MultiStateInput(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "NotifyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetNotifyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetNotifyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NotifyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -39941,7 +40862,7 @@ private static void InitPset_MultiStateOutput(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "EventEnable";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetEventEnableType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetEventEnableType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EventEnableCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -39951,7 +40872,7 @@ private static void InitPset_MultiStateOutput(IList<PropertySetDescription> comm
             ifcPSE.PropertyName = "NotifyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BACnetNotifyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BACnetNotifyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NotifyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -40393,7 +41314,7 @@ private static void InitPset_OutsideDesignCriteria(IList<PropertySetDescription>
             ifcPSE.PropertyName = "BuildingThermalExposure";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BuildingThermalExposure);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BuildingThermalExposure);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BuildingThermalExposureCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -40604,7 +41525,7 @@ private static void InitPset_PackingInstructions(IList<PropertySetDescription> c
             ifcPSE.PropertyName = "PackingCareType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PackingCareType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PackingCareType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PackingCareTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -40773,7 +41694,7 @@ private static void InitPset_Permit(IList<PropertySetDescription> commonProperty
             ifcPSE.PropertyName = "PermitType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PermitType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PermitType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PermitTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -44427,7 +45348,7 @@ private static void InitPset_ProjectOrderMaintenanceWorkOrder(IList<PropertySetD
             ifcPSE.PropertyName = "MaintenaceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_MaintenanceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_MaintenanceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MaintenaceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -44437,7 +45358,7 @@ private static void InitPset_ProjectOrderMaintenanceWorkOrder(IList<PropertySetD
             ifcPSE.PropertyName = "FaultPriorityType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PriorityType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PriorityType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaultPriorityTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -44447,7 +45368,7 @@ private static void InitPset_ProjectOrderMaintenanceWorkOrder(IList<PropertySetD
             ifcPSE.PropertyName = "LocationPriorityType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PriorityType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PriorityType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LocationPriorityTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -44985,7 +45906,7 @@ private static void InitPset_PropertyAgreement(IList<PropertySetDescription> com
             ifcPSE.PropertyName = "AgreementType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_PropertyAgreementType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_PropertyAgreementType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AgreementTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -47096,7 +48017,7 @@ private static void InitPset_ProtectiveDeviceTypeCircuitBreaker(IList<PropertySe
             ifcPSE.PropertyName = "CircuitBreakerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CircuitBreakerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CircuitBreakerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CircuitBreakerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -47404,7 +48325,7 @@ private static void InitPset_ProtectiveDeviceTypeEarthFailureDevice(IList<Proper
             ifcPSE.PropertyName = "EarthFailureDeviceType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_EarthFailureDeviceType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_EarthFailureDeviceType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EarthFailureDeviceTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -47499,7 +48420,7 @@ private static void InitPset_ProtectiveDeviceTypeFuseDisconnector(IList<Property
             ifcPSE.PropertyName = "FuseDisconnectorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FuseDisconnectorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FuseDisconnectorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FuseDisconnectorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -47711,7 +48632,7 @@ private static void InitPset_ProtectiveDeviceTypeVaristor(IList<PropertySetDescr
             ifcPSE.PropertyName = "VaristorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_VaristorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_VaristorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.VaristorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -49348,7 +50269,7 @@ private static void InitPset_ReinforcementBarPitchOfColumn(IList<PropertySetDesc
             ifcPSE.PropertyName = "ReinforcementBarType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ReinforcementBarType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ReinforcementBarType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ReinforcementBarTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -50092,7 +51013,7 @@ private static void InitPset_ReinforcementBarPitchOfWall(IList<PropertySetDescri
             ifcPSE.PropertyName = "BarAllocationType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ReinforcementBarAllocationType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ReinforcementBarAllocationType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BarAllocationTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -50127,6 +51048,37 @@ private static void InitPset_ReinforcementBarPitchOfWall(IList<PropertySetDescri
          {
             propertySetReinforcementBarPitchOfWall.EntityTypes.Add(IFCEntityType.IfcWall);
             propertySetReinforcementBarPitchOfWall.ObjectType = "IfcWall";
+
+            ifcPSE = new PropertySetEntry("AudioVolume");
+            ifcPSE.PropertyName = "AudioVolume";
+            ifcPSE.PropertyArgumentType = PropertyType.Integer;
+            ifcPSE.PropertyType = PropertyType.SoundPower;
+            ifcPSE.PropertyValueType = PropertyValueType.TableValue;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Audio Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AudioVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
+            propertySetReinforcementBarPitchOfWall.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("AudioVolume2");
+            ifcPSE.PropertyName = "AudioVolume2";
+            ifcPSE.PropertyType = PropertyType.SoundPower;
+            ifcPSE.PropertyValueType = PropertyValueType.SingleValue;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Audio Volume 2");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AudioVolume2Calculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
+            propertySetReinforcementBarPitchOfWall.AddEntry(ifcPSE);
+
+            ifcPSE = new PropertySetEntry("NominalEnergyConsumption");
+            ifcPSE.PropertyName = "NominalEnergyConsumption";
+            ifcPSE.PropertyType = PropertyType.Power;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NominalEnergyConsumptionCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator)calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { });
+            propertySetReinforcementBarPitchOfWall.AddEntry(ifcPSE);
+
+
             ifcPSE = new PropertySetEntry("Description");
             ifcPSE.PropertyName = "Description";
             ifcPSE.PropertyType = PropertyType.Text;
@@ -51300,7 +52252,7 @@ private static void InitPset_Risk(IList<PropertySetDescription> commonPropertySe
             ifcPSE.PropertyName = "RiskType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RiskType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RiskType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RiskTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51342,7 +52294,7 @@ private static void InitPset_Risk(IList<PropertySetDescription> commonPropertySe
             ifcPSE.PropertyName = "AssessmentOfRisk";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RiskAssessment);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RiskAssessment);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AssessmentOfRiskCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51352,7 +52304,7 @@ private static void InitPset_Risk(IList<PropertySetDescription> commonPropertySe
             ifcPSE.PropertyName = "RiskConsequence";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RiskConsequence);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RiskConsequence);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RiskConsequenceCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51362,7 +52314,7 @@ private static void InitPset_Risk(IList<PropertySetDescription> commonPropertySe
             ifcPSE.PropertyName = "RiskRating";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RiskRating);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RiskRating);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RiskRatingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51372,7 +52324,7 @@ private static void InitPset_Risk(IList<PropertySetDescription> commonPropertySe
             ifcPSE.PropertyName = "RiskOwner";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_RiskOwner);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_RiskOwner);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.RiskOwnerCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51789,7 +52741,7 @@ private static void InitPset_SanitaryTerminalTypeBath(IList<PropertySetDescripti
             ifcPSE.PropertyName = "BathType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BathType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BathType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BathTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -51993,7 +52945,7 @@ private static void InitPset_SanitaryTerminalTypeBidet(IList<PropertySetDescript
             ifcPSE.PropertyName = "BidetMounting";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SanitaryMounting);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SanitaryMounting);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BidetMountingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52192,7 +53144,7 @@ private static void InitPset_SanitaryTerminalTypeCistern(IList<PropertySetDescri
             ifcPSE.PropertyName = "CisternHeight";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_CisternHeight);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_CisternHeight);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CisternHeightCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52218,7 +53170,7 @@ private static void InitPset_SanitaryTerminalTypeCistern(IList<PropertySetDescri
             ifcPSE.PropertyName = "FlushType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FlushType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FlushType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FlushTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52496,7 +53448,7 @@ private static void InitPset_SanitaryTerminalTypeSanitaryFountain(IList<Property
             ifcPSE.PropertyName = "FountainType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FountainType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FountainType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FountainTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52506,7 +53458,7 @@ private static void InitPset_SanitaryTerminalTypeSanitaryFountain(IList<Property
             ifcPSE.PropertyName = "Mounting";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SanitaryMounting);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SanitaryMounting);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MountingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52712,7 +53664,7 @@ private static void InitPset_SanitaryTerminalTypeShower(IList<PropertySetDescrip
             ifcPSE.PropertyName = "ShowerType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ShowerType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ShowerType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ShowerTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52935,7 +53887,7 @@ private static void InitPset_SanitaryTerminalTypeSink(IList<PropertySetDescripti
             ifcPSE.PropertyName = "SinkType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SinkType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SinkType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SinkTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -52945,7 +53897,7 @@ private static void InitPset_SanitaryTerminalTypeSink(IList<PropertySetDescripti
             ifcPSE.PropertyName = "SinkMounting";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SanitaryMounting);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SanitaryMounting);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SinkMountingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53167,7 +54119,7 @@ private static void InitPset_SanitaryTerminalTypeToiletPan(IList<PropertySetDesc
             ifcPSE.PropertyName = "ToiletType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ToiletType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ToiletType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ToiletTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53177,7 +54129,7 @@ private static void InitPset_SanitaryTerminalTypeToiletPan(IList<PropertySetDesc
             ifcPSE.PropertyName = "ToiletPanType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ToiletPanType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ToiletPanType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ToiletPanTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53187,7 +54139,7 @@ private static void InitPset_SanitaryTerminalTypeToiletPan(IList<PropertySetDesc
             ifcPSE.PropertyName = "PanMounting";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SanitaryMounting);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SanitaryMounting);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PanMountingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53381,7 +54333,7 @@ private static void InitPset_SanitaryTerminalTypeUrinal(IList<PropertySetDescrip
             ifcPSE.PropertyName = "UrinalType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_UrinalType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_UrinalType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.UrinalTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53573,7 +54525,7 @@ private static void InitPset_SanitaryTerminalTypeWashHandBasin(IList<PropertySet
             ifcPSE.PropertyName = "WashHandBasinType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_WashHandBasinType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_WashHandBasinType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WashHandBasinTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53583,7 +54535,7 @@ private static void InitPset_SanitaryTerminalTypeWashHandBasin(IList<PropertySet
             ifcPSE.PropertyName = "WashHandBasinMounting";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SanitaryMounting);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SanitaryMounting);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WashHandBasinMountingCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -53751,7 +54703,7 @@ private static void InitPset_SanitaryTerminalTypeWCSeat(IList<PropertySetDescrip
             ifcPSE.PropertyName = "SeatType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ToiletSeatType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ToiletSeatType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SeatTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -54920,7 +55872,7 @@ private static void InitPset_SensorTypeMovementSensor(IList<PropertySetDescripti
             ifcPSE.PropertyName = "MovementSensingType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_MovementSensingType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_MovementSensingType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MovementSensingTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -55530,7 +56482,7 @@ private static void InitPset_SensorTypeTemperatureSensor(IList<PropertySetDescri
             ifcPSE.PropertyName = "TemperatureSensorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TemperatureSensorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TemperatureSensorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TemperatureSensorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -57718,7 +58670,7 @@ private static void InitPset_SpaceHeaterTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "TemperatureClassification";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SpaceHeaterTemperatureClassification);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SpaceHeaterTemperatureClassification);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TemperatureClassificationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -57728,7 +58680,7 @@ private static void InitPset_SpaceHeaterTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "HeatingSource";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_HeatingSource);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_HeatingSource);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeatingSourceCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61079,7 +62031,7 @@ private static void InitPset_SwitchingDeviceTypeCommon(IList<PropertySetDescript
             ifcPSE.PropertyName = "SwitchFunction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SwitchFunctionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SwitchFunctionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SwitchFunctionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61229,7 +62181,7 @@ private static void InitPset_SwitchingDeviceTypeContactor(IList<PropertySetDescr
             ifcPSE.PropertyName = "ContactorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ContactorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ContactorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ContactorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61324,7 +62276,7 @@ private static void InitPset_SwitchingDeviceTypeEmergencyStop(IList<PropertySetD
             ifcPSE.PropertyName = "SwitchOperation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SwitchFunctionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SwitchFunctionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SwitchOperationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61537,7 +62489,7 @@ private static void InitPset_SwitchingDeviceTypeStarter(IList<PropertySetDescrip
             ifcPSE.PropertyName = "StarterType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_StarterType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_StarterType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.StarterTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61618,7 +62570,7 @@ private static void InitPset_SwitchingDeviceTypeSwitchDisconnector(IList<Propert
             ifcPSE.PropertyName = "SwitchDisconnectorType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SwitchDisconnectorType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SwitchDisconnectorType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SwitchDisconnectorTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61628,7 +62580,7 @@ private static void InitPset_SwitchingDeviceTypeSwitchDisconnector(IList<Propert
             ifcPSE.PropertyName = "LoadDisconnectionType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_LoadDisconnectionType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_LoadDisconnectionType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LoadDisconnectionTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61747,7 +62699,7 @@ private static void InitPset_SwitchingDeviceTypeToggleSwitch(IList<PropertySetDe
             ifcPSE.PropertyName = "ToggleSwitchType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ToggleSwitchType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ToggleSwitchType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ToggleSwitchTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61757,7 +62709,7 @@ private static void InitPset_SwitchingDeviceTypeToggleSwitch(IList<PropertySetDe
             ifcPSE.PropertyName = "SwitchUsage";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SwitchUsage);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SwitchUsage);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SwitchUsageCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -61767,7 +62719,7 @@ private static void InitPset_SwitchingDeviceTypeToggleSwitch(IList<PropertySetDe
             ifcPSE.PropertyName = "SwitchActivation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SwitchActivation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SwitchActivation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SwitchActivationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62044,7 +62996,7 @@ private static void InitPset_SystemFurnitureElementTypePanel(IList<PropertySetDe
             ifcPSE.PropertyName = "FurniturePanelType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FurniturePanelType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FurniturePanelType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FurniturePanelTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62168,7 +63120,7 @@ private static void InitPset_SystemFurnitureElementTypeWorkSurface(IList<Propert
             ifcPSE.PropertyName = "SupportType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FurniturePanelType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FurniturePanelType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SupportTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62454,7 +63406,7 @@ private static void InitPset_TankTypeCommon(IList<PropertySetDescription> common
             ifcPSE.PropertyName = "Type";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TankType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TankType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62464,7 +63416,7 @@ private static void InitPset_TankTypeCommon(IList<PropertySetDescription> common
             ifcPSE.PropertyName = "AccessType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TankAccessType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TankAccessType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AccessTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62874,7 +63826,7 @@ private static void InitPset_TankTypePreformed(IList<PropertySetDescription> com
             ifcPSE.PropertyName = "PatternType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TankPatternType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TankPatternType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PatternTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -62884,7 +63836,7 @@ private static void InitPset_TankTypePreformed(IList<PropertySetDescription> com
             ifcPSE.PropertyName = "EndShapeType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_EndShapeType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_EndShapeType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EndShapeTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -63901,7 +64853,7 @@ private static void InitPset_TransformerTypeCommon(IList<PropertySetDescription>
             ifcPSE.PropertyName = "SecondaryCurrentType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_SecondaryCurrentType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_SecondaryCurrentType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.SecondaryCurrentTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -65554,7 +66506,7 @@ private static void InitPset_UnitaryEquipmentTypeAirHandler(IList<PropertySetDes
             ifcPSE.PropertyName = "AirHandlerConstruction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirHandlerConstruction);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirHandlerConstruction);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirHandlerConstructionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -65564,7 +66516,7 @@ private static void InitPset_UnitaryEquipmentTypeAirHandler(IList<PropertySetDes
             ifcPSE.PropertyName = "AirHandlerFanCoilArrangement";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_AirHandlerFanCoilArrangement);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_AirHandlerFanCoilArrangement);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AirHandlerFanCoilArrangementCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66093,7 +67045,7 @@ private static void InitPset_ValveTypeCommon(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "ValvePattern";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ValvePattern);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ValvePattern);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ValvePatternCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66103,7 +67055,7 @@ private static void InitPset_ValveTypeCommon(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "ValveOperation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ValveOperation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ValveOperation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ValveOperationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66113,7 +67065,7 @@ private static void InitPset_ValveTypeCommon(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "ValveMechanism";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_ValveMechanism);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_ValveMechanism);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ValveMechanismCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66420,7 +67372,7 @@ private static void InitPset_ValveTypeFaucet(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "FaucetType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FaucetType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FaucetType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaucetTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66430,7 +67382,7 @@ private static void InitPset_ValveTypeFaucet(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "FaucetOperation";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FaucetOperation);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FaucetOperation);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaucetOperationCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66440,7 +67392,7 @@ private static void InitPset_ValveTypeFaucet(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "FaucetFunction";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_FaucetFunction);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_FaucetFunction);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FaucetFunctionCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66745,7 +67697,7 @@ private static void InitPset_ValveTypeIsolating(IList<PropertySetDescription> co
             ifcPSE.PropertyName = "IsolatingPurpose";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_IsolatingPurpose);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_IsolatingPurpose);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.IsolatingPurposeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -66826,7 +67778,7 @@ private static void InitPset_ValveTypeMixing(IList<PropertySetDescription> commo
             ifcPSE.PropertyName = "MixerControl";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_MixingValveControl);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_MixingValveControl);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.MixerControlCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -67998,7 +68950,7 @@ private static void InitPset_WasteTerminalTypeFloorTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "TrapType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TrapType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TrapType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TrapTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -68024,7 +68976,7 @@ private static void InitPset_WasteTerminalTypeFloorTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "InletPatternType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_InletPatternType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_InletPatternType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.InletPatternTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -68813,7 +69765,7 @@ private static void InitPset_WasteTerminalTypeGullySump(IList<PropertySetDescrip
             ifcPSE.PropertyName = "GullyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_GullyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_GullyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GullyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -68823,7 +69775,7 @@ private static void InitPset_WasteTerminalTypeGullySump(IList<PropertySetDescrip
             ifcPSE.PropertyName = "TrapType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TrapType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TrapType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TrapTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -68841,7 +69793,7 @@ private static void InitPset_WasteTerminalTypeGullySump(IList<PropertySetDescrip
             ifcPSE.PropertyName = "BackInletPatternType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BackInletPatternType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BackInletPatternType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BackInletPatternTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -69165,7 +70117,7 @@ private static void InitPset_WasteTerminalTypeGullyTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "GullyType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_GullyType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_GullyType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GullyTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -69183,7 +70135,7 @@ private static void InitPset_WasteTerminalTypeGullyTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "TrapType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TrapType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TrapType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TrapTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -69201,7 +70153,7 @@ private static void InitPset_WasteTerminalTypeGullyTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "BackInletPatternType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_BackInletPatternType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_BackInletPatternType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.BackInletPatternTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
@@ -70105,7 +71057,7 @@ private static void InitPset_WasteTerminalTypeWasteTrap(IList<PropertySetDescrip
             ifcPSE.PropertyName = "WasteTrapType";
             ifcPSE.PropertyType = PropertyType.Label;
             ifcPSE.PropertyValueType = PropertyValueType.EnumeratedValue;
-            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1.PEnum_TrapType);
+            ifcPSE.PropertyEnumerationType = typeof(Revit.IFC.Export.Exporter.PropertySet.IFC2X3.PEnum_TrapType);
             calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WasteTrapTypeCalculator");
             if (calcType != null)
                ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
diff --git a/Source/Revit.IFC.Export/Exporter/ExporterInitializer_QsetDef.cs b/Source/Revit.IFC.Export/Exporter/ExporterInitializer_QsetDef.cs
new file mode 100644
index 00000000..27692368
--- /dev/null
+++ b/Source/Revit.IFC.Export/Exporter/ExporterInitializer_QsetDef.cs
@@ -0,0 +1,4319 @@
+/********************************************************************************************************************************
+** NOTE: This code is generated from IFC psd files automatically by RevitIFCTools.                                            **
+**       DO NOT change it manually as it will be overwritten the next time this file is re-generated!!                        **
+********************************************************************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Autodesk.Revit;
+using Autodesk.Revit.DB;
+using Autodesk.Revit.DB.IFC;
+using Autodesk.Revit.ApplicationServices;
+using Revit.IFC.Export.Exporter.PropertySet;
+using Revit.IFC.Export.Exporter.PropertySet.Calculators;
+using Revit.IFC.Export.Utility;
+using Revit.IFC.Export.Toolkit;
+using Revit.IFC.Common.Enums;
+
+namespace Revit.IFC.Export.Exporter
+{
+   partial class ExporterInitializer
+   {
+      public static void InitQtoSets(IList<IList<QuantityDescription>> allQuantitySets)
+      {
+         IList<QuantityDescription> quantitySets = new List<QuantityDescription>();
+         InitQto_ActuatorBaseQuantities(quantitySets);
+         InitQto_AirTerminalBaseQuantities(quantitySets);
+         InitQto_AirTerminalBoxTypeBaseQuantities(quantitySets);
+         InitQto_AirToAirHeatRecoveryBaseQuantities(quantitySets);
+         InitQto_AlarmBaseQuantities(quantitySets);
+         InitQto_AudioVisualApplianceBaseQuantities(quantitySets);
+         InitQto_BeamBaseQuantities(quantitySets);
+         InitQto_BoilerBaseQuantities(quantitySets);
+         InitQto_BuildingBaseQuantities(quantitySets);
+         InitQto_BuildingElementProxyQuantities(quantitySets);
+         InitQto_BuildingStoreyBaseQuantities(quantitySets);
+         InitQto_BurnerBaseQuantities(quantitySets);
+         InitQto_CableCarrierFittingBaseQuantities(quantitySets);
+         InitQto_CableCarrierSegmentBaseQuantities(quantitySets);
+         InitQto_CableFittingBaseQuantities(quantitySets);
+         InitQto_CableSegmentBaseQuantities(quantitySets);
+         InitQto_ChillerBaseQuantities(quantitySets);
+         InitQto_ChimneyBaseQuantities(quantitySets);
+         InitQto_CoilBaseQuantities(quantitySets);
+         InitQto_ColumnBaseQuantities(quantitySets);
+         InitQto_CommunicationsApplianceBaseQuantities(quantitySets);
+         InitQto_CompressorBaseQuantities(quantitySets);
+         InitQto_CondenserBaseQuantities(quantitySets);
+         InitQto_ConstructionEquipmentResourceBaseQuantities(quantitySets);
+         InitQto_ConstructionMaterialResourceBaseQuantities(quantitySets);
+         InitQto_ControllerBaseQuantities(quantitySets);
+         InitQto_CooledBeamBaseQuantities(quantitySets);
+         InitQto_CoolingTowerBaseQuantities(quantitySets);
+         InitQto_CoveringBaseQuantities(quantitySets);
+         InitQto_CurtainWallQuantities(quantitySets);
+         InitQto_DamperBaseQuantities(quantitySets);
+         InitQto_DistributionChamberElementBaseQuantities(quantitySets);
+         InitQto_DoorBaseQuantities(quantitySets);
+         InitQto_DuctFittingBaseQuantities(quantitySets);
+         InitQto_DuctSegmentBaseQuantities(quantitySets);
+         InitQto_DuctSilencerBaseQuantities(quantitySets);
+         InitQto_ElectricApplianceBaseQuantities(quantitySets);
+         InitQto_ElectricDistributionBoardBaseQuantities(quantitySets);
+         InitQto_ElectricFlowStorageDeviceBaseQuantities(quantitySets);
+         InitQto_ElectricGeneratorBaseQuantities(quantitySets);
+         InitQto_ElectricMotorBaseQuantities(quantitySets);
+         InitQto_ElectricTimeControlBaseQuantities(quantitySets);
+         InitQto_EvaporativeCoolerBaseQuantities(quantitySets);
+         InitQto_EvaporatorBaseQuantities(quantitySets);
+         InitQto_FanBaseQuantities(quantitySets);
+         InitQto_FilterBaseQuantities(quantitySets);
+         InitQto_FireSuppressionTerminalBaseQuantities(quantitySets);
+         InitQto_FlowInstrumentBaseQuantities(quantitySets);
+         InitQto_FlowMeterBaseQuantities(quantitySets);
+         InitQto_FootingBaseQuantities(quantitySets);
+         InitQto_HeatExchangerBaseQuantities(quantitySets);
+         InitQto_HumidifierBaseQuantities(quantitySets);
+         InitQto_InterceptorBaseQuantities(quantitySets);
+         InitQto_JunctionBoxBaseQuantities(quantitySets);
+         InitQto_LaborResourceBaseQuantities(quantitySets);
+         InitQto_LampBaseQuantities(quantitySets);
+         InitQto_LightFixtureBaseQuantities(quantitySets);
+         InitQto_MemberBaseQuantities(quantitySets);
+         InitQto_MotorConnectionBaseQuantities(quantitySets);
+         InitQto_OpeningElementBaseQuantities(quantitySets);
+         InitQto_OutletBaseQuantities(quantitySets);
+         InitQto_PileBaseQuantities(quantitySets);
+         InitQto_PipeFittingBaseQuantities(quantitySets);
+         InitQto_PipeSegmentBaseQuantities(quantitySets);
+         InitQto_PlateBaseQuantities(quantitySets);
+         InitQto_ProjectionElementBaseQuantities(quantitySets);
+         InitQto_ProtectiveDeviceBaseQuantities(quantitySets);
+         InitQto_ProtectiveDeviceTrippingUnitBaseQuantities(quantitySets);
+         InitQto_PumpBaseQuantities(quantitySets);
+         InitQto_RailingBaseQuantities(quantitySets);
+         InitQto_RampFlightBaseQuantities(quantitySets);
+         InitQto_ReinforcingElementBaseQuantities(quantitySets);
+         InitQto_RoofBaseQuantities(quantitySets);
+         InitQto_SanitaryTerminalBaseQuantities(quantitySets);
+         InitQto_SensorBaseQuantities(quantitySets);
+         InitQto_SiteBaseQuantities(quantitySets);
+         InitQto_SlabBaseQuantities(quantitySets);
+         InitQto_SolarDeviceBaseQuantities(quantitySets);
+         InitQto_SpaceBaseQuantities(quantitySets);
+         InitQto_SpaceHeaterBaseQuantities(quantitySets);
+         InitQto_StackTerminalBaseQuantities(quantitySets);
+         InitQto_StairFlightBaseQuantities(quantitySets);
+         InitQto_SwitchingDeviceBaseQuantities(quantitySets);
+         InitQto_TankBaseQuantities(quantitySets);
+         InitQto_TransformerBaseQuantities(quantitySets);
+         InitQto_TubeBundleBaseQuantities(quantitySets);
+         InitQto_UnitaryControlElementBaseQuantities(quantitySets);
+         InitQto_UnitaryEquipmentBaseQuantities(quantitySets);
+         InitQto_ValveBaseQuantities(quantitySets);
+         InitQto_VibrationIsolatorBaseQuantities(quantitySets);
+         InitQto_WallBaseQuantities(quantitySets);
+         InitQto_WasteTerminalBaseQuantities(quantitySets);
+         InitQto_WindowBaseQuantities(quantitySets);
+
+         allQuantitySets.Add(quantitySets);
+      }
+
+      private static void InitQto_ActuatorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetActuatorBaseQuantities = new QuantityDescription();
+         qtoSetActuatorBaseQuantities.Name = "Qto_ActuatorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ActuatorBaseQuantities"))
+         {
+            qtoSetActuatorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcActuator);
+            qtoSetActuatorBaseQuantities.ObjectType = "IfcActuator";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetActuatorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetActuatorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_AirTerminalBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetAirTerminalBaseQuantities = new QuantityDescription();
+         qtoSetAirTerminalBaseQuantities.Name = "Qto_AirTerminalBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_AirTerminalBaseQuantities"))
+         {
+            qtoSetAirTerminalBaseQuantities.EntityTypes.Add(IFCEntityType.IfcAirTerminal);
+            qtoSetAirTerminalBaseQuantities.ObjectType = "IfcAirTerminal";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAirTerminalBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Perimeter");
+            ifcPSE.PropertyName = "Perimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Perimeter");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAirTerminalBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("TotalSurfaceArea");
+            ifcPSE.PropertyName = "TotalSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Total Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TotalSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAirTerminalBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetAirTerminalBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_AirTerminalBoxTypeBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetAirTerminalBoxTypeBaseQuantities = new QuantityDescription();
+         qtoSetAirTerminalBoxTypeBaseQuantities.Name = "Qto_AirTerminalBoxTypeBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_AirTerminalBoxTypeBaseQuantities"))
+         {
+            qtoSetAirTerminalBoxTypeBaseQuantities.EntityTypes.Add(IFCEntityType.IfcAirTerminalBox);
+            qtoSetAirTerminalBoxTypeBaseQuantities.ObjectType = "IfcAirTerminalBox";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAirTerminalBoxTypeBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetAirTerminalBoxTypeBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_AirToAirHeatRecoveryBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetAirToAirHeatRecoveryBaseQuantities = new QuantityDescription();
+         qtoSetAirToAirHeatRecoveryBaseQuantities.Name = "Qto_AirToAirHeatRecoveryBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_AirToAirHeatRecoveryBaseQuantities"))
+         {
+            qtoSetAirToAirHeatRecoveryBaseQuantities.EntityTypes.Add(IFCEntityType.IfcAirToAirHeatRecovery);
+            qtoSetAirToAirHeatRecoveryBaseQuantities.ObjectType = "IfcAirToAirHeatRecovery";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAirToAirHeatRecoveryBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetAirToAirHeatRecoveryBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_AlarmBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetAlarmBaseQuantities = new QuantityDescription();
+         qtoSetAlarmBaseQuantities.Name = "Qto_AlarmBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_AlarmBaseQuantities"))
+         {
+            qtoSetAlarmBaseQuantities.EntityTypes.Add(IFCEntityType.IfcAlarm);
+            qtoSetAlarmBaseQuantities.ObjectType = "IfcAlarm";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAlarmBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetAlarmBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_AudioVisualApplianceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetAudioVisualApplianceBaseQuantities = new QuantityDescription();
+         qtoSetAudioVisualApplianceBaseQuantities.Name = "Qto_AudioVisualApplianceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_AudioVisualApplianceBaseQuantities"))
+         {
+            qtoSetAudioVisualApplianceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcAudioVisualAppliance);
+            qtoSetAudioVisualApplianceBaseQuantities.ObjectType = "IfcAudioVisualAppliance";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetAudioVisualApplianceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetAudioVisualApplianceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_BeamBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBeamBaseQuantities = new QuantityDescription();
+         qtoSetBeamBaseQuantities.Name = "Qto_BeamBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BeamBaseQuantities"))
+         {
+            qtoSetBeamBaseQuantities.EntityTypes.Add(IFCEntityType.IfcBeam);
+            qtoSetBeamBaseQuantities.ObjectType = "IfcBeam";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Querschnittsfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "断面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Mantelfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "外表面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Gesamtoberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "表面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSurfaceArea");
+            ifcPSE.PropertyName = "NetSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettooberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBeamBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBeamBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_BoilerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBoilerBaseQuantities = new QuantityDescription();
+         qtoSetBoilerBaseQuantities.Name = "Qto_BoilerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BoilerBaseQuantities"))
+         {
+            qtoSetBoilerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcBoiler);
+            qtoSetBoilerBaseQuantities.ObjectType = "IfcBoiler";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBoilerBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBoilerBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("TotalSurfaceArea");
+            ifcPSE.PropertyName = "TotalSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Total Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TotalSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBoilerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBoilerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_BuildingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBuildingBaseQuantities = new QuantityDescription();
+         qtoSetBuildingBaseQuantities.Name = "Qto_BuildingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BuildingBaseQuantities"))
+         {
+            qtoSetBuildingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcBuilding);
+            qtoSetBuildingBaseQuantities.ObjectType = "IfcBuilding";
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Firsthöhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("EavesHeight");
+            ifcPSE.PropertyName = "EavesHeight";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Traufhöhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Eaves Height");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.EavesHeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("FootprintArea");
+            ifcPSE.PropertyName = "FootprintArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bebaute Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Footprint Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "建築面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FootprintAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossFloorArea");
+            ifcPSE.PropertyName = "GrossFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "延べ床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetFloorArea");
+            ifcPSE.PropertyName = "NetFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttorauminhalt");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "建物体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettorauminhalt");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味建物体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBuildingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_BuildingElementProxyQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBuildingElementProxyQuantities = new QuantityDescription();
+         qtoSetBuildingElementProxyQuantities.Name = "Qto_BuildingElementProxyQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BuildingElementProxyQuantities"))
+         {
+            qtoSetBuildingElementProxyQuantities.EntityTypes.Add(IFCEntityType.IfcBuildingElementProxy);
+            qtoSetBuildingElementProxyQuantities.ObjectType = "IfcBuildingElementProxy";
+            ifcPSE = new QuantityEntry("NetSurfaceArea");
+            ifcPSE.PropertyName = "NetSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingElementProxyQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingElementProxyQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBuildingElementProxyQuantities);
+         }
+      }
+
+
+      private static void InitQto_BuildingStoreyBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBuildingStoreyBaseQuantities = new QuantityDescription();
+         qtoSetBuildingStoreyBaseQuantities.Name = "Qto_BuildingStoreyBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BuildingStoreyBaseQuantities"))
+         {
+            qtoSetBuildingStoreyBaseQuantities.EntityTypes.Add(IFCEntityType.IfcBuildingStorey);
+            qtoSetBuildingStoreyBaseQuantities.ObjectType = "IfcBuildingStorey";
+            ifcPSE = new QuantityEntry("GrossHeight");
+            ifcPSE.PropertyName = "GrossHeight";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Systemhöhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "階高");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossHeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetHeigtht");
+            ifcPSE.PropertyName = "NetHeigtht";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Lichte Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Heigtht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味階高");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetHeigthtCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossPerimeter");
+            ifcPSE.PropertyName = "GrossPerimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周辺長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossPerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossFloorArea");
+            ifcPSE.PropertyName = "GrossFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetFloorArea");
+            ifcPSE.PropertyName = "NetFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttorauminhalt");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "建物階体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettorauminhalt");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味建物階体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBuildingStoreyBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBuildingStoreyBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_BurnerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetBurnerBaseQuantities = new QuantityDescription();
+         qtoSetBurnerBaseQuantities.Name = "Qto_BurnerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_BurnerBaseQuantities"))
+         {
+            qtoSetBurnerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcBurner);
+            qtoSetBurnerBaseQuantities.ObjectType = "IfcBurner";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetBurnerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetBurnerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CableCarrierFittingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCableCarrierFittingBaseQuantities = new QuantityDescription();
+         qtoSetCableCarrierFittingBaseQuantities.Name = "Qto_CableCarrierFittingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CableCarrierFittingBaseQuantities"))
+         {
+            qtoSetCableCarrierFittingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCableCarrierFitting);
+            qtoSetCableCarrierFittingBaseQuantities.ObjectType = "IfcCableCarrierFitting";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableCarrierFittingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCableCarrierFittingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CableCarrierSegmentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCableCarrierSegmentBaseQuantities = new QuantityDescription();
+         qtoSetCableCarrierSegmentBaseQuantities.Name = "Qto_CableCarrierSegmentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CableCarrierSegmentBaseQuantities"))
+         {
+            qtoSetCableCarrierSegmentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCableCarrierSegment);
+            qtoSetCableCarrierSegmentBaseQuantities.ObjectType = "IfcCableCarrierSegment";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableCarrierSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableCarrierSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableCarrierSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableCarrierSegmentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCableCarrierSegmentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CableFittingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCableFittingBaseQuantities = new QuantityDescription();
+         qtoSetCableFittingBaseQuantities.Name = "Qto_CableFittingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CableFittingBaseQuantities"))
+         {
+            qtoSetCableFittingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCableFitting);
+            qtoSetCableFittingBaseQuantities.ObjectType = "IfcCableFitting";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableFittingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCableFittingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CableSegmentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCableSegmentBaseQuantities = new QuantityDescription();
+         qtoSetCableSegmentBaseQuantities.Name = "Qto_CableSegmentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CableSegmentBaseQuantities"))
+         {
+            qtoSetCableSegmentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCableSegment);
+            qtoSetCableSegmentBaseQuantities.ObjectType = "IfcCableSegment";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCableSegmentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCableSegmentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ChillerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetChillerBaseQuantities = new QuantityDescription();
+         qtoSetChillerBaseQuantities.Name = "Qto_ChillerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ChillerBaseQuantities"))
+         {
+            qtoSetChillerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcChiller);
+            qtoSetChillerBaseQuantities.ObjectType = "IfcChiller";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetChillerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetChillerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ChimneyBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetChimneyBaseQuantities = new QuantityDescription();
+         qtoSetChimneyBaseQuantities.Name = "Qto_ChimneyBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ChimneyBaseQuantities"))
+         {
+            qtoSetChimneyBaseQuantities.EntityTypes.Add(IFCEntityType.IfcChimney);
+            qtoSetChimneyBaseQuantities.ObjectType = "IfcChimney";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetChimneyBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetChimneyBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CoilBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCoilBaseQuantities = new QuantityDescription();
+         qtoSetCoilBaseQuantities.Name = "Qto_CoilBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CoilBaseQuantities"))
+         {
+            qtoSetCoilBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCoil);
+            qtoSetCoilBaseQuantities.ObjectType = "IfcCoil";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCoilBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCoilBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ColumnBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetColumnBaseQuantities = new QuantityDescription();
+         qtoSetColumnBaseQuantities.Name = "Qto_ColumnBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ColumnBaseQuantities"))
+         {
+            qtoSetColumnBaseQuantities.EntityTypes.Add(IFCEntityType.IfcColumn);
+            qtoSetColumnBaseQuantities.ObjectType = "IfcColumn";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Querschnittsfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "断面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Mantelfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "外表面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Gesamtoberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "表面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSurfaceArea");
+            ifcPSE.PropertyName = "NetSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettooberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetColumnBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetColumnBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CommunicationsApplianceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCommunicationsApplianceBaseQuantities = new QuantityDescription();
+         qtoSetCommunicationsApplianceBaseQuantities.Name = "Qto_CommunicationsApplianceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CommunicationsApplianceBaseQuantities"))
+         {
+            qtoSetCommunicationsApplianceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCommunicationsAppliance);
+            qtoSetCommunicationsApplianceBaseQuantities.ObjectType = "IfcCommunicationsAppliance";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCommunicationsApplianceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCommunicationsApplianceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CompressorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCompressorBaseQuantities = new QuantityDescription();
+         qtoSetCompressorBaseQuantities.Name = "Qto_CompressorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CompressorBaseQuantities"))
+         {
+            qtoSetCompressorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCompressor);
+            qtoSetCompressorBaseQuantities.ObjectType = "IfcCompressor";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCompressorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCompressorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CondenserBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCondenserBaseQuantities = new QuantityDescription();
+         qtoSetCondenserBaseQuantities.Name = "Qto_CondenserBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CondenserBaseQuantities"))
+         {
+            qtoSetCondenserBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCondenser);
+            qtoSetCondenserBaseQuantities.ObjectType = "IfcCondenser";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCondenserBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCondenserBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ConstructionEquipmentResourceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetConstructionEquipmentResourceBaseQuantities = new QuantityDescription();
+         qtoSetConstructionEquipmentResourceBaseQuantities.Name = "Qto_ConstructionEquipmentResourceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ConstructionEquipmentResourceBaseQuantities"))
+         {
+            qtoSetConstructionEquipmentResourceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcConstructionEquipmentResource);
+            qtoSetConstructionEquipmentResourceBaseQuantities.ObjectType = "IfcConstructionEquipmentResource";
+            ifcPSE = new QuantityEntry("UsageTime");
+            ifcPSE.PropertyName = "UsageTime";
+            ifcPSE.QuantityType = QuantityType.Time;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Usage Time");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.UsageTimeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionEquipmentResourceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OperatingTime");
+            ifcPSE.PropertyName = "OperatingTime";
+            ifcPSE.QuantityType = QuantityType.Time;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Operating Time");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OperatingTimeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionEquipmentResourceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetConstructionEquipmentResourceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ConstructionMaterialResourceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetConstructionMaterialResourceBaseQuantities = new QuantityDescription();
+         qtoSetConstructionMaterialResourceBaseQuantities.Name = "Qto_ConstructionMaterialResourceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ConstructionMaterialResourceBaseQuantities"))
+         {
+            qtoSetConstructionMaterialResourceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcConstructionMaterialResource);
+            qtoSetConstructionMaterialResourceBaseQuantities.ObjectType = "IfcConstructionMaterialResource";
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionMaterialResourceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionMaterialResourceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionMaterialResourceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetConstructionMaterialResourceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetConstructionMaterialResourceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ControllerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetControllerBaseQuantities = new QuantityDescription();
+         qtoSetControllerBaseQuantities.Name = "Qto_ControllerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ControllerBaseQuantities"))
+         {
+            qtoSetControllerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcController);
+            qtoSetControllerBaseQuantities.ObjectType = "IfcController";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetControllerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetControllerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CooledBeamBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCooledBeamBaseQuantities = new QuantityDescription();
+         qtoSetCooledBeamBaseQuantities.Name = "Qto_CooledBeamBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CooledBeamBaseQuantities"))
+         {
+            qtoSetCooledBeamBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCooledBeam);
+            qtoSetCooledBeamBaseQuantities.ObjectType = "IfcCooledBeam";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCooledBeamBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCooledBeamBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CoolingTowerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCoolingTowerBaseQuantities = new QuantityDescription();
+         qtoSetCoolingTowerBaseQuantities.Name = "Qto_CoolingTowerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CoolingTowerBaseQuantities"))
+         {
+            qtoSetCoolingTowerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCoolingTower);
+            qtoSetCoolingTowerBaseQuantities.ObjectType = "IfcCoolingTower";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCoolingTowerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCoolingTowerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CoveringBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCoveringBaseQuantities = new QuantityDescription();
+         qtoSetCoveringBaseQuantities.Name = "Qto_CoveringBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CoveringBaseQuantities"))
+         {
+            qtoSetCoveringBaseQuantities.EntityTypes.Add(IFCEntityType.IfcCovering);
+            qtoSetCoveringBaseQuantities.ObjectType = "IfcCovering";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCoveringBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCoveringBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetArea");
+            ifcPSE.PropertyName = "NetArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCoveringBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCoveringBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_CurtainWallQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetCurtainWallQuantities = new QuantityDescription();
+         qtoSetCurtainWallQuantities.Name = "Qto_CurtainWallQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_CurtainWallQuantities"))
+         {
+            qtoSetCurtainWallQuantities.EntityTypes.Add(IFCEntityType.IfcCurtainWall);
+            qtoSetCurtainWallQuantities.ObjectType = "IfcCurtainWall";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCurtainWallQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCurtainWallQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCurtainWallQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSideArea");
+            ifcPSE.PropertyName = "GrossSideArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Side Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "側面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSideAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCurtainWallQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSideArea");
+            ifcPSE.PropertyName = "NetSideArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Side Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味側面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSideAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetCurtainWallQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetCurtainWallQuantities);
+         }
+      }
+
+
+      private static void InitQto_DamperBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDamperBaseQuantities = new QuantityDescription();
+         qtoSetDamperBaseQuantities.Name = "Qto_DamperBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DamperBaseQuantities"))
+         {
+            qtoSetDamperBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDamper);
+            qtoSetDamperBaseQuantities.ObjectType = "IfcDamper";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDamperBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDamperBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_DistributionChamberElementBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDistributionChamberElementBaseQuantities = new QuantityDescription();
+         qtoSetDistributionChamberElementBaseQuantities.Name = "Qto_DistributionChamberElementBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DistributionChamberElementBaseQuantities"))
+         {
+            qtoSetDistributionChamberElementBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDistributionChamberElement);
+            qtoSetDistributionChamberElementBaseQuantities.ObjectType = "IfcDistributionChamberElement";
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDistributionChamberElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSurfaceArea");
+            ifcPSE.PropertyName = "NetSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDistributionChamberElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDistributionChamberElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDistributionChamberElementBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDistributionChamberElementBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_DoorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDoorBaseQuantities = new QuantityDescription();
+         qtoSetDoorBaseQuantities.Name = "Qto_DoorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DoorBaseQuantities"))
+         {
+            qtoSetDoorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDoor);
+            qtoSetDoorBaseQuantities.ObjectType = "IfcDoor";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Breite");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDoorBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDoorBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Perimeter");
+            ifcPSE.PropertyName = "Perimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周囲長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDoorBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Area");
+            ifcPSE.PropertyName = "Area";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDoorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDoorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_DuctFittingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDuctFittingBaseQuantities = new QuantityDescription();
+         qtoSetDuctFittingBaseQuantities.Name = "Qto_DuctFittingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DuctFittingBaseQuantities"))
+         {
+            qtoSetDuctFittingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDuctFitting);
+            qtoSetDuctFittingBaseQuantities.ObjectType = "IfcDuctFitting";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossCrossSectionArea");
+            ifcPSE.PropertyName = "GrossCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetCrossSectionArea");
+            ifcPSE.PropertyName = "NetCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctFittingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDuctFittingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_DuctSegmentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDuctSegmentBaseQuantities = new QuantityDescription();
+         qtoSetDuctSegmentBaseQuantities.Name = "Qto_DuctSegmentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DuctSegmentBaseQuantities"))
+         {
+            qtoSetDuctSegmentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDuctSegment);
+            qtoSetDuctSegmentBaseQuantities.ObjectType = "IfcDuctSegment";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossCrossSectionArea");
+            ifcPSE.PropertyName = "GrossCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetCrossSectionArea");
+            ifcPSE.PropertyName = "NetCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSegmentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDuctSegmentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_DuctSilencerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetDuctSilencerBaseQuantities = new QuantityDescription();
+         qtoSetDuctSilencerBaseQuantities.Name = "Qto_DuctSilencerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_DuctSilencerBaseQuantities"))
+         {
+            qtoSetDuctSilencerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcDuctSilencer);
+            qtoSetDuctSilencerBaseQuantities.ObjectType = "IfcDuctSilencer";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetDuctSilencerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetDuctSilencerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricApplianceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricApplianceBaseQuantities = new QuantityDescription();
+         qtoSetElectricApplianceBaseQuantities.Name = "Qto_ElectricApplianceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricApplianceBaseQuantities"))
+         {
+            qtoSetElectricApplianceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricAppliance);
+            qtoSetElectricApplianceBaseQuantities.ObjectType = "IfcElectricAppliance";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricApplianceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricApplianceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricDistributionBoardBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricDistributionBoardBaseQuantities = new QuantityDescription();
+         qtoSetElectricDistributionBoardBaseQuantities.Name = "Qto_ElectricDistributionBoardBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricDistributionBoardBaseQuantities"))
+         {
+            qtoSetElectricDistributionBoardBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricDistributionBoard);
+            qtoSetElectricDistributionBoardBaseQuantities.ObjectType = "IfcElectricDistributionBoard";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricDistributionBoardBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NumberOfCircuits");
+            ifcPSE.PropertyName = "NumberOfCircuits";
+            ifcPSE.QuantityType = QuantityType.Count;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Number Of Circuits");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NumberOfCircuitsCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricDistributionBoardBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricDistributionBoardBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricFlowStorageDeviceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricFlowStorageDeviceBaseQuantities = new QuantityDescription();
+         qtoSetElectricFlowStorageDeviceBaseQuantities.Name = "Qto_ElectricFlowStorageDeviceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricFlowStorageDeviceBaseQuantities"))
+         {
+            qtoSetElectricFlowStorageDeviceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricFlowStorageDevice);
+            qtoSetElectricFlowStorageDeviceBaseQuantities.ObjectType = "IfcElectricFlowStorageDevice";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricFlowStorageDeviceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricFlowStorageDeviceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricGeneratorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricGeneratorBaseQuantities = new QuantityDescription();
+         qtoSetElectricGeneratorBaseQuantities.Name = "Qto_ElectricGeneratorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricGeneratorBaseQuantities"))
+         {
+            qtoSetElectricGeneratorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricGenerator);
+            qtoSetElectricGeneratorBaseQuantities.ObjectType = "IfcElectricGenerator";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricGeneratorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricGeneratorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricMotorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricMotorBaseQuantities = new QuantityDescription();
+         qtoSetElectricMotorBaseQuantities.Name = "Qto_ElectricMotorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricMotorBaseQuantities"))
+         {
+            qtoSetElectricMotorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricMotor);
+            qtoSetElectricMotorBaseQuantities.ObjectType = "IfcElectricMotor";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricMotorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricMotorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ElectricTimeControlBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetElectricTimeControlBaseQuantities = new QuantityDescription();
+         qtoSetElectricTimeControlBaseQuantities.Name = "Qto_ElectricTimeControlBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ElectricTimeControlBaseQuantities"))
+         {
+            qtoSetElectricTimeControlBaseQuantities.EntityTypes.Add(IFCEntityType.IfcElectricTimeControl);
+            qtoSetElectricTimeControlBaseQuantities.ObjectType = "IfcElectricTimeControl";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetElectricTimeControlBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetElectricTimeControlBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_EvaporativeCoolerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetEvaporativeCoolerBaseQuantities = new QuantityDescription();
+         qtoSetEvaporativeCoolerBaseQuantities.Name = "Qto_EvaporativeCoolerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_EvaporativeCoolerBaseQuantities"))
+         {
+            qtoSetEvaporativeCoolerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcEvaporativeCooler);
+            qtoSetEvaporativeCoolerBaseQuantities.ObjectType = "IfcEvaporativeCooler";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetEvaporativeCoolerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetEvaporativeCoolerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_EvaporatorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetEvaporatorBaseQuantities = new QuantityDescription();
+         qtoSetEvaporatorBaseQuantities.Name = "Qto_EvaporatorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_EvaporatorBaseQuantities"))
+         {
+            qtoSetEvaporatorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcEvaporator);
+            qtoSetEvaporatorBaseQuantities.ObjectType = "IfcEvaporator";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetEvaporatorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetEvaporatorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FanBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFanBaseQuantities = new QuantityDescription();
+         qtoSetFanBaseQuantities.Name = "Qto_FanBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FanBaseQuantities"))
+         {
+            qtoSetFanBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFan);
+            qtoSetFanBaseQuantities.ObjectType = "IfcFan";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFanBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFanBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FilterBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFilterBaseQuantities = new QuantityDescription();
+         qtoSetFilterBaseQuantities.Name = "Qto_FilterBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FilterBaseQuantities"))
+         {
+            qtoSetFilterBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFilter);
+            qtoSetFilterBaseQuantities.ObjectType = "IfcFilter";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFilterBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFilterBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FireSuppressionTerminalBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFireSuppressionTerminalBaseQuantities = new QuantityDescription();
+         qtoSetFireSuppressionTerminalBaseQuantities.Name = "Qto_FireSuppressionTerminalBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FireSuppressionTerminalBaseQuantities"))
+         {
+            qtoSetFireSuppressionTerminalBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFireSuppressionTerminal);
+            qtoSetFireSuppressionTerminalBaseQuantities.ObjectType = "IfcFireSuppressionTerminal";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFireSuppressionTerminalBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFireSuppressionTerminalBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FlowInstrumentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFlowInstrumentBaseQuantities = new QuantityDescription();
+         qtoSetFlowInstrumentBaseQuantities.Name = "Qto_FlowInstrumentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FlowInstrumentBaseQuantities"))
+         {
+            qtoSetFlowInstrumentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFlowInstrument);
+            qtoSetFlowInstrumentBaseQuantities.ObjectType = "IfcFlowInstrument";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFlowInstrumentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFlowInstrumentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FlowMeterBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFlowMeterBaseQuantities = new QuantityDescription();
+         qtoSetFlowMeterBaseQuantities.Name = "Qto_FlowMeterBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FlowMeterBaseQuantities"))
+         {
+            qtoSetFlowMeterBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFlowMeter);
+            qtoSetFlowMeterBaseQuantities.ObjectType = "IfcFlowMeter";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFlowMeterBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFlowMeterBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_FootingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetFootingBaseQuantities = new QuantityDescription();
+         qtoSetFootingBaseQuantities.Name = "Qto_FootingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_FootingBaseQuantities"))
+         {
+            qtoSetFootingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcFooting);
+            qtoSetFootingBaseQuantities.ObjectType = "IfcFooting";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetFootingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetFootingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_HeatExchangerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetHeatExchangerBaseQuantities = new QuantityDescription();
+         qtoSetHeatExchangerBaseQuantities.Name = "Qto_HeatExchangerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_HeatExchangerBaseQuantities"))
+         {
+            qtoSetHeatExchangerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcHeatExchanger);
+            qtoSetHeatExchangerBaseQuantities.ObjectType = "IfcHeatExchanger";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetHeatExchangerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetHeatExchangerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_HumidifierBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetHumidifierBaseQuantities = new QuantityDescription();
+         qtoSetHumidifierBaseQuantities.Name = "Qto_HumidifierBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_HumidifierBaseQuantities"))
+         {
+            qtoSetHumidifierBaseQuantities.EntityTypes.Add(IFCEntityType.IfcHumidifier);
+            qtoSetHumidifierBaseQuantities.ObjectType = "IfcHumidifier";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetHumidifierBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetHumidifierBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_InterceptorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetInterceptorBaseQuantities = new QuantityDescription();
+         qtoSetInterceptorBaseQuantities.Name = "Qto_InterceptorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_InterceptorBaseQuantities"))
+         {
+            qtoSetInterceptorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcInterceptor);
+            qtoSetInterceptorBaseQuantities.ObjectType = "IfcInterceptor";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetInterceptorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetInterceptorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_JunctionBoxBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetJunctionBoxBaseQuantities = new QuantityDescription();
+         qtoSetJunctionBoxBaseQuantities.Name = "Qto_JunctionBoxBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_JunctionBoxBaseQuantities"))
+         {
+            qtoSetJunctionBoxBaseQuantities.EntityTypes.Add(IFCEntityType.IfcJunctionBox);
+            qtoSetJunctionBoxBaseQuantities.ObjectType = "IfcJunctionBox";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetJunctionBoxBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NumberOfGangs");
+            ifcPSE.PropertyName = "NumberOfGangs";
+            ifcPSE.QuantityType = QuantityType.Count;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Number Of Gangs");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NumberOfGangsCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetJunctionBoxBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetJunctionBoxBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_LaborResourceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetLaborResourceBaseQuantities = new QuantityDescription();
+         qtoSetLaborResourceBaseQuantities.Name = "Qto_LaborResourceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_LaborResourceBaseQuantities"))
+         {
+            qtoSetLaborResourceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcLaborResource);
+            qtoSetLaborResourceBaseQuantities.ObjectType = "IfcLaborResource";
+            ifcPSE = new QuantityEntry("StandardWork");
+            ifcPSE.PropertyName = "StandardWork";
+            ifcPSE.QuantityType = QuantityType.Time;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Standard Work");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.StandardWorkCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetLaborResourceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OvertimeWork");
+            ifcPSE.PropertyName = "OvertimeWork";
+            ifcPSE.QuantityType = QuantityType.Time;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Overtime Work");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OvertimeWorkCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetLaborResourceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetLaborResourceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_LampBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetLampBaseQuantities = new QuantityDescription();
+         qtoSetLampBaseQuantities.Name = "Qto_LampBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_LampBaseQuantities"))
+         {
+            qtoSetLampBaseQuantities.EntityTypes.Add(IFCEntityType.IfcLamp);
+            qtoSetLampBaseQuantities.ObjectType = "IfcLamp";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetLampBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetLampBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_LightFixtureBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetLightFixtureBaseQuantities = new QuantityDescription();
+         qtoSetLightFixtureBaseQuantities.Name = "Qto_LightFixtureBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_LightFixtureBaseQuantities"))
+         {
+            qtoSetLightFixtureBaseQuantities.EntityTypes.Add(IFCEntityType.IfcLightFixture);
+            qtoSetLightFixtureBaseQuantities.ObjectType = "IfcLightFixture";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetLightFixtureBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetLightFixtureBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_MemberBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetMemberBaseQuantities = new QuantityDescription();
+         qtoSetMemberBaseQuantities.Name = "Qto_MemberBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_MemberBaseQuantities"))
+         {
+            qtoSetMemberBaseQuantities.EntityTypes.Add(IFCEntityType.IfcMember);
+            qtoSetMemberBaseQuantities.ObjectType = "IfcMember";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Querschnittsfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Mantelfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Gesamtoberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSurfaceArea");
+            ifcPSE.PropertyName = "NetSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettooberfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMemberBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetMemberBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_MotorConnectionBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetMotorConnectionBaseQuantities = new QuantityDescription();
+         qtoSetMotorConnectionBaseQuantities.Name = "Qto_MotorConnectionBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_MotorConnectionBaseQuantities"))
+         {
+            qtoSetMotorConnectionBaseQuantities.EntityTypes.Add(IFCEntityType.IfcMotorConnection);
+            qtoSetMotorConnectionBaseQuantities.ObjectType = "IfcMotorConnection";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetMotorConnectionBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetMotorConnectionBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_OpeningElementBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetOpeningElementBaseQuantities = new QuantityDescription();
+         qtoSetOpeningElementBaseQuantities.Name = "Qto_OpeningElementBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_OpeningElementBaseQuantities"))
+         {
+            qtoSetOpeningElementBaseQuantities.EntityTypes.Add(IFCEntityType.IfcOpeningElement);
+            qtoSetOpeningElementBaseQuantities.ObjectType = "IfcOpeningElement";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Breite");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "開口幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOpeningElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "開口高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOpeningElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Depth");
+            ifcPSE.PropertyName = "Depth";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Tiefe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Depth");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "開口奥行き");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOpeningElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Area");
+            ifcPSE.PropertyName = "Area";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOpeningElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Volume");
+            ifcPSE.PropertyName = "Volume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Volumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.VolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOpeningElementBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetOpeningElementBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_OutletBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetOutletBaseQuantities = new QuantityDescription();
+         qtoSetOutletBaseQuantities.Name = "Qto_OutletBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_OutletBaseQuantities"))
+         {
+            qtoSetOutletBaseQuantities.EntityTypes.Add(IFCEntityType.IfcOutlet);
+            qtoSetOutletBaseQuantities.ObjectType = "IfcOutlet";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetOutletBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetOutletBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_PileBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetPileBaseQuantities = new QuantityDescription();
+         qtoSetPileBaseQuantities.Name = "Qto_PileBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_PileBaseQuantities"))
+         {
+            qtoSetPileBaseQuantities.EntityTypes.Add(IFCEntityType.IfcPile);
+            qtoSetPileBaseQuantities.ObjectType = "IfcPile";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("CrossSectionArea");
+            ifcPSE.PropertyName = "CrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSurfaceArea");
+            ifcPSE.PropertyName = "GrossSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPileBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetPileBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_PipeFittingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetPipeFittingBaseQuantities = new QuantityDescription();
+         qtoSetPipeFittingBaseQuantities.Name = "Qto_PipeFittingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_PipeFittingBaseQuantities"))
+         {
+            qtoSetPipeFittingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcPipeFitting);
+            qtoSetPipeFittingBaseQuantities.ObjectType = "IfcPipeFitting";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossCrossSectionArea");
+            ifcPSE.PropertyName = "GrossCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetCrossSectionArea");
+            ifcPSE.PropertyName = "NetCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeFittingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetPipeFittingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_PipeSegmentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetPipeSegmentBaseQuantities = new QuantityDescription();
+         qtoSetPipeSegmentBaseQuantities.Name = "Qto_PipeSegmentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_PipeSegmentBaseQuantities"))
+         {
+            qtoSetPipeSegmentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcPipeSegment);
+            qtoSetPipeSegmentBaseQuantities.ObjectType = "IfcPipeSegment";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossCrossSectionArea");
+            ifcPSE.PropertyName = "GrossCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetCrossSectionArea");
+            ifcPSE.PropertyName = "NetCrossSectionArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Cross Section Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetCrossSectionAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("OuterSurfaceArea");
+            ifcPSE.PropertyName = "OuterSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Outer Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.OuterSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPipeSegmentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetPipeSegmentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_PlateBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetPlateBaseQuantities = new QuantityDescription();
+         qtoSetPlateBaseQuantities.Name = "Qto_PlateBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_PlateBaseQuantities"))
+         {
+            qtoSetPlateBaseQuantities.EntityTypes.Add(IFCEntityType.IfcPlate);
+            qtoSetPlateBaseQuantities.ObjectType = "IfcPlate";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Perimeter");
+            ifcPSE.PropertyName = "Perimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Perimeter");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetArea");
+            ifcPSE.PropertyName = "NetArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPlateBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetPlateBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ProjectionElementBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetProjectionElementBaseQuantities = new QuantityDescription();
+         qtoSetProjectionElementBaseQuantities.Name = "Qto_ProjectionElementBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ProjectionElementBaseQuantities"))
+         {
+            qtoSetProjectionElementBaseQuantities.EntityTypes.Add(IFCEntityType.IfcProjectionElement);
+            qtoSetProjectionElementBaseQuantities.ObjectType = "IfcProjectionElement";
+            ifcPSE = new QuantityEntry("Area");
+            ifcPSE.PropertyName = "Area";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetProjectionElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Volume");
+            ifcPSE.PropertyName = "Volume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Volumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.VolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetProjectionElementBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetProjectionElementBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ProtectiveDeviceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetProtectiveDeviceBaseQuantities = new QuantityDescription();
+         qtoSetProtectiveDeviceBaseQuantities.Name = "Qto_ProtectiveDeviceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ProtectiveDeviceBaseQuantities"))
+         {
+            qtoSetProtectiveDeviceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcProtectiveDevice);
+            qtoSetProtectiveDeviceBaseQuantities.ObjectType = "IfcProtectiveDevice";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetProtectiveDeviceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetProtectiveDeviceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ProtectiveDeviceTrippingUnitBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetProtectiveDeviceTrippingUnitBaseQuantities = new QuantityDescription();
+         qtoSetProtectiveDeviceTrippingUnitBaseQuantities.Name = "Qto_ProtectiveDeviceTrippingUnitBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ProtectiveDeviceTrippingUnitBaseQuantities"))
+         {
+            qtoSetProtectiveDeviceTrippingUnitBaseQuantities.EntityTypes.Add(IFCEntityType.IfcProtectiveDeviceTrippingUnit);
+            qtoSetProtectiveDeviceTrippingUnitBaseQuantities.ObjectType = "IfcProtectiveDeviceTrippingUnit";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetProtectiveDeviceTrippingUnitBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetProtectiveDeviceTrippingUnitBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_PumpBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetPumpBaseQuantities = new QuantityDescription();
+         qtoSetPumpBaseQuantities.Name = "Qto_PumpBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_PumpBaseQuantities"))
+         {
+            qtoSetPumpBaseQuantities.EntityTypes.Add(IFCEntityType.IfcPump);
+            qtoSetPumpBaseQuantities.ObjectType = "IfcPump";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetPumpBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetPumpBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_RailingBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetRailingBaseQuantities = new QuantityDescription();
+         qtoSetRailingBaseQuantities.Name = "Qto_RailingBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_RailingBaseQuantities"))
+         {
+            qtoSetRailingBaseQuantities.EntityTypes.Add(IFCEntityType.IfcRailing);
+            qtoSetRailingBaseQuantities.ObjectType = "IfcRailing";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRailingBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetRailingBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_RampFlightBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetRampFlightBaseQuantities = new QuantityDescription();
+         qtoSetRampFlightBaseQuantities.Name = "Qto_RampFlightBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_RampFlightBaseQuantities"))
+         {
+            qtoSetRampFlightBaseQuantities.EntityTypes.Add(IFCEntityType.IfcRampFlight);
+            qtoSetRampFlightBaseQuantities.ObjectType = "IfcRampFlight";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetArea");
+            ifcPSE.PropertyName = "NetArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRampFlightBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetRampFlightBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ReinforcingElementBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetReinforcingElementBaseQuantities = new QuantityDescription();
+         qtoSetReinforcingElementBaseQuantities.Name = "Qto_ReinforcingElementBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ReinforcingElementBaseQuantities"))
+         {
+            qtoSetReinforcingElementBaseQuantities.EntityTypes.Add(IFCEntityType.IfcReinforcingElement);
+            qtoSetReinforcingElementBaseQuantities.ObjectType = "IfcReinforcingElement";
+            ifcPSE = new QuantityEntry("Count");
+            ifcPSE.PropertyName = "Count";
+            ifcPSE.QuantityType = QuantityType.Count;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.CountCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetReinforcingElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetReinforcingElementBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Weight");
+            ifcPSE.PropertyName = "Weight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetReinforcingElementBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetReinforcingElementBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_RoofBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetRoofBaseQuantities = new QuantityDescription();
+         qtoSetRoofBaseQuantities.Name = "Qto_RoofBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_RoofBaseQuantities"))
+         {
+            qtoSetRoofBaseQuantities.EntityTypes.Add(IFCEntityType.IfcRoof);
+            qtoSetRoofBaseQuantities.ObjectType = "IfcRoof";
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRoofBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetArea");
+            ifcPSE.PropertyName = "NetArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRoofBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("ProjectedArea");
+            ifcPSE.PropertyName = "ProjectedArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "projizierte Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Projected Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.ProjectedAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetRoofBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetRoofBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SanitaryTerminalBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSanitaryTerminalBaseQuantities = new QuantityDescription();
+         qtoSetSanitaryTerminalBaseQuantities.Name = "Qto_SanitaryTerminalBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SanitaryTerminalBaseQuantities"))
+         {
+            qtoSetSanitaryTerminalBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSanitaryTerminal);
+            qtoSetSanitaryTerminalBaseQuantities.ObjectType = "IfcSanitaryTerminal";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSanitaryTerminalBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSanitaryTerminalBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SensorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSensorBaseQuantities = new QuantityDescription();
+         qtoSetSensorBaseQuantities.Name = "Qto_SensorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SensorBaseQuantities"))
+         {
+            qtoSetSensorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSensor);
+            qtoSetSensorBaseQuantities.ObjectType = "IfcSensor";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSensorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSensorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SiteBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSiteBaseQuantities = new QuantityDescription();
+         qtoSetSiteBaseQuantities.Name = "Qto_SiteBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SiteBaseQuantities"))
+         {
+            qtoSetSiteBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSite);
+            qtoSetSiteBaseQuantities.ObjectType = "IfcSite";
+            ifcPSE = new QuantityEntry("GrossPerimeter");
+            ifcPSE.PropertyName = "GrossPerimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周辺長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossPerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSiteBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Grundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "敷地面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSiteBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSiteBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SlabBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSlabBaseQuantities = new QuantityDescription();
+         qtoSetSlabBaseQuantities.Name = "Qto_SlabBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SlabBaseQuantities"))
+         {
+            qtoSetSlabBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSlab);
+            qtoSetSlabBaseQuantities.ObjectType = "IfcSlab";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Depth");
+            ifcPSE.PropertyName = "Depth";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Breite");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Depth");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.DepthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Perimeter");
+            ifcPSE.PropertyName = "Perimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周囲長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetArea");
+            ifcPSE.PropertyName = "NetArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSlabBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSlabBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SolarDeviceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSolarDeviceBaseQuantities = new QuantityDescription();
+         qtoSetSolarDeviceBaseQuantities.Name = "Qto_SolarDeviceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SolarDeviceBaseQuantities"))
+         {
+            qtoSetSolarDeviceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSolarDevice);
+            qtoSetSolarDeviceBaseQuantities.ObjectType = "IfcSolarDevice";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSolarDeviceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossArea");
+            ifcPSE.PropertyName = "GrossArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSolarDeviceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSolarDeviceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SpaceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSpaceBaseQuantities = new QuantityDescription();
+         qtoSetSpaceBaseQuantities.Name = "Qto_SpaceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SpaceBaseQuantities"))
+         {
+            qtoSetSpaceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSpace);
+            qtoSetSpaceBaseQuantities.ObjectType = "IfcSpace";
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("FinishCeilingHeight");
+            ifcPSE.PropertyName = "FinishCeilingHeight";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Lichte Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Finish Ceiling Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "天井仕上げ高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FinishCeilingHeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("FinishFloorHeight");
+            ifcPSE.PropertyName = "FinishFloorHeight";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Fussboden Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Finish Floor Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "床仕上げ高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.FinishFloorHeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossPerimeter");
+            ifcPSE.PropertyName = "GrossPerimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang Brutto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周辺長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossPerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetPerimeter");
+            ifcPSE.PropertyName = "NetPerimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang Netto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味周辺長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetPerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossFloorArea");
+            ifcPSE.PropertyName = "GrossFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bodenfläche Brutto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetFloorArea");
+            ifcPSE.PropertyName = "NetFloorArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bodenfläche Netto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Floor Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味床面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetFloorAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWallArea");
+            ifcPSE.PropertyName = "GrossWallArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Senkrechte Fläche Brutto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Wall Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "壁面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWallAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWallArea");
+            ifcPSE.PropertyName = "NetWallArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Senkrechte Fläche Netto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Wall Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味壁面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWallAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossCeilingArea");
+            ifcPSE.PropertyName = "GrossCeilingArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Deckenfläche Brutto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Ceiling Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "天井面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossCeilingAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetCeilingArea");
+            ifcPSE.PropertyName = "NetCeilingArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Deckenfläche Netto");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Ceiling Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味天井面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetCeilingAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSpaceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SpaceHeaterBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSpaceHeaterBaseQuantities = new QuantityDescription();
+         qtoSetSpaceHeaterBaseQuantities.Name = "Qto_SpaceHeaterBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SpaceHeaterBaseQuantities"))
+         {
+            qtoSetSpaceHeaterBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSpaceHeater);
+            qtoSetSpaceHeaterBaseQuantities.ObjectType = "IfcSpaceHeater";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceHeaterBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceHeaterBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSpaceHeaterBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSpaceHeaterBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_StackTerminalBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetStackTerminalBaseQuantities = new QuantityDescription();
+         qtoSetStackTerminalBaseQuantities.Name = "Qto_StackTerminalBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_StackTerminalBaseQuantities"))
+         {
+            qtoSetStackTerminalBaseQuantities.EntityTypes.Add(IFCEntityType.IfcStackTerminal);
+            qtoSetStackTerminalBaseQuantities.ObjectType = "IfcStackTerminal";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetStackTerminalBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetStackTerminalBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_StairFlightBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetStairFlightBaseQuantities = new QuantityDescription();
+         qtoSetStairFlightBaseQuantities.Name = "Qto_StairFlightBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_StairFlightBaseQuantities"))
+         {
+            qtoSetStairFlightBaseQuantities.EntityTypes.Add(IFCEntityType.IfcStairFlight);
+            qtoSetStairFlightBaseQuantities.ObjectType = "IfcStairFlight";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetStairFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetStairFlightBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetStairFlightBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetStairFlightBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_SwitchingDeviceBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetSwitchingDeviceBaseQuantities = new QuantityDescription();
+         qtoSetSwitchingDeviceBaseQuantities.Name = "Qto_SwitchingDeviceBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_SwitchingDeviceBaseQuantities"))
+         {
+            qtoSetSwitchingDeviceBaseQuantities.EntityTypes.Add(IFCEntityType.IfcSwitchingDevice);
+            qtoSetSwitchingDeviceBaseQuantities.ObjectType = "IfcSwitchingDevice";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetSwitchingDeviceBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetSwitchingDeviceBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_TankBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetTankBaseQuantities = new QuantityDescription();
+         qtoSetTankBaseQuantities.Name = "Qto_TankBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_TankBaseQuantities"))
+         {
+            qtoSetTankBaseQuantities.EntityTypes.Add(IFCEntityType.IfcTank);
+            qtoSetTankBaseQuantities.ObjectType = "IfcTank";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTankBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTankBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("TotalSurfaceArea");
+            ifcPSE.PropertyName = "TotalSurfaceArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Total Surface Area");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.TotalSurfaceAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTankBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetTankBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_TransformerBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetTransformerBaseQuantities = new QuantityDescription();
+         qtoSetTransformerBaseQuantities.Name = "Qto_TransformerBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_TransformerBaseQuantities"))
+         {
+            qtoSetTransformerBaseQuantities.EntityTypes.Add(IFCEntityType.IfcTransformer);
+            qtoSetTransformerBaseQuantities.ObjectType = "IfcTransformer";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTransformerBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetTransformerBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_TubeBundleBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetTubeBundleBaseQuantities = new QuantityDescription();
+         qtoSetTubeBundleBaseQuantities.Name = "Qto_TubeBundleBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_TubeBundleBaseQuantities"))
+         {
+            qtoSetTubeBundleBaseQuantities.EntityTypes.Add(IFCEntityType.IfcTubeBundle);
+            qtoSetTubeBundleBaseQuantities.ObjectType = "IfcTubeBundle";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTubeBundleBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetTubeBundleBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetTubeBundleBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_UnitaryControlElementBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetUnitaryControlElementBaseQuantities = new QuantityDescription();
+         qtoSetUnitaryControlElementBaseQuantities.Name = "Qto_UnitaryControlElementBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_UnitaryControlElementBaseQuantities"))
+         {
+            qtoSetUnitaryControlElementBaseQuantities.EntityTypes.Add(IFCEntityType.IfcUnitaryControlElement);
+            qtoSetUnitaryControlElementBaseQuantities.ObjectType = "IfcUnitaryControlElement";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetUnitaryControlElementBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetUnitaryControlElementBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_UnitaryEquipmentBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetUnitaryEquipmentBaseQuantities = new QuantityDescription();
+         qtoSetUnitaryEquipmentBaseQuantities.Name = "Qto_UnitaryEquipmentBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_UnitaryEquipmentBaseQuantities"))
+         {
+            qtoSetUnitaryEquipmentBaseQuantities.EntityTypes.Add(IFCEntityType.IfcUnitaryEquipment);
+            qtoSetUnitaryEquipmentBaseQuantities.ObjectType = "IfcUnitaryEquipment";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetUnitaryEquipmentBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetUnitaryEquipmentBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_ValveBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetValveBaseQuantities = new QuantityDescription();
+         qtoSetValveBaseQuantities.Name = "Qto_ValveBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_ValveBaseQuantities"))
+         {
+            qtoSetValveBaseQuantities.EntityTypes.Add(IFCEntityType.IfcValve);
+            qtoSetValveBaseQuantities.ObjectType = "IfcValve";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetValveBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetValveBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_VibrationIsolatorBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetVibrationIsolatorBaseQuantities = new QuantityDescription();
+         qtoSetVibrationIsolatorBaseQuantities.Name = "Qto_VibrationIsolatorBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_VibrationIsolatorBaseQuantities"))
+         {
+            qtoSetVibrationIsolatorBaseQuantities.EntityTypes.Add(IFCEntityType.IfcVibrationIsolator);
+            qtoSetVibrationIsolatorBaseQuantities.ObjectType = "IfcVibrationIsolator";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetVibrationIsolatorBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetVibrationIsolatorBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_WallBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetWallBaseQuantities = new QuantityDescription();
+         qtoSetWallBaseQuantities.Name = "Qto_WallBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_WallBaseQuantities"))
+         {
+            qtoSetWallBaseQuantities.EntityTypes.Add(IFCEntityType.IfcWall);
+            qtoSetWallBaseQuantities.ObjectType = "IfcWall";
+            ifcPSE = new QuantityEntry("Length");
+            ifcPSE.PropertyName = "Length";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Länge");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Length");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "長さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.LengthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Dicke");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossFootprintArea");
+            ifcPSE.PropertyName = "GrossFootprintArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Footprint Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "フットプリント面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossFootprintAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetFootprintArea");
+            ifcPSE.PropertyName = "NetFootprintArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogrundfläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Footprint Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味フットプリント面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetFootprintAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossSideArea");
+            ifcPSE.PropertyName = "GrossSideArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Side Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "側面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossSideAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetSideArea");
+            ifcPSE.PropertyName = "NetSideArea";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettofläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Side Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味側面面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetSideAreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossVolume");
+            ifcPSE.PropertyName = "GrossVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetVolume");
+            ifcPSE.PropertyName = "NetVolume";
+            ifcPSE.QuantityType = QuantityType.Volume;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettovolumen");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Volume");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味体積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetVolumeCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Bruttogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("NetWeight");
+            ifcPSE.PropertyName = "NetWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Nettogewicht");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Net Weight");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "正味重量");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.NetWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWallBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetWallBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_WasteTerminalBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetWasteTerminalBaseQuantities = new QuantityDescription();
+         qtoSetWasteTerminalBaseQuantities.Name = "Qto_WasteTerminalBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_WasteTerminalBaseQuantities"))
+         {
+            qtoSetWasteTerminalBaseQuantities.EntityTypes.Add(IFCEntityType.IfcWasteTerminal);
+            qtoSetWasteTerminalBaseQuantities.ObjectType = "IfcWasteTerminal";
+            ifcPSE = new QuantityEntry("GrossWeight");
+            ifcPSE.PropertyName = "GrossWeight";
+            ifcPSE.QuantityType = QuantityType.Weight;
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Gross Weight");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.GrossWeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWasteTerminalBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetWasteTerminalBaseQuantities);
+         }
+      }
+
+
+      private static void InitQto_WindowBaseQuantities(IList<QuantityDescription> quantitySets)
+      {
+         QuantityDescription qtoSetWindowBaseQuantities = new QuantityDescription();
+         qtoSetWindowBaseQuantities.Name = "Qto_WindowBaseQuantities";
+         QuantityEntry ifcPSE = null;
+         Type calcType = null;
+         if (ExporterCacheManager.ExportOptionsCache.ExportAs4 && certifiedEntityAndPsetList.AllowPsetToBeCreated(ExporterCacheManager.ExportOptionsCache.FileVersion.ToString().ToUpper(), "Qto_WindowBaseQuantities"))
+         {
+            qtoSetWindowBaseQuantities.EntityTypes.Add(IFCEntityType.IfcWindow);
+            qtoSetWindowBaseQuantities.ObjectType = "IfcWindow";
+            ifcPSE = new QuantityEntry("Width");
+            ifcPSE.PropertyName = "Width";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Breite");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Width");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "幅");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.WidthCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWindowBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Height");
+            ifcPSE.PropertyName = "Height";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Höhe");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Height");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "高さ");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.HeightCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWindowBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Perimeter");
+            ifcPSE.PropertyName = "Perimeter";
+            ifcPSE.QuantityType = QuantityType.Length;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Umfang");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Perimeter");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "周囲長");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.PerimeterCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWindowBaseQuantities.AddEntry(ifcPSE);
+
+            ifcPSE = new QuantityEntry("Area");
+            ifcPSE.PropertyName = "Area";
+            ifcPSE.QuantityType = QuantityType.Area;
+            ifcPSE.AddLocalizedParameterName(LanguageType.German, "Fläche");
+            ifcPSE.AddLocalizedParameterName(LanguageType.English_USA, "Area");
+            ifcPSE.AddLocalizedParameterName(LanguageType.Japanese, "面積");
+            calcType = System.Reflection.Assembly.GetExecutingAssembly().GetType("Revit.IFC.Export.Exporter.PropertySet.Calculators.AreaCalculator");
+            if (calcType != null)
+               ifcPSE.PropertyCalculator = (PropertyCalculator) calcType.GetConstructor(Type.EmptyTypes).Invoke(new object[]{});
+            qtoSetWindowBaseQuantities.AddEntry(ifcPSE);
+
+         }
+         if (ifcPSE != null)
+         {
+            quantitySets.Add(qtoSetWindowBaseQuantities);
+         }
+      }
+
+
+   }
+}
diff --git a/Source/Revit.IFC.Export/Exporter/ExtrusionExporter.cs b/Source/Revit.IFC.Export/Exporter/ExtrusionExporter.cs
index 95f30178..30b59d7c 100644
--- a/Source/Revit.IFC.Export/Exporter/ExtrusionExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/ExtrusionExporter.cs
@@ -1209,7 +1209,7 @@ public static void AddOpeningData(IFCExtrusionCreationData creationData, IFCExtr
       /// <param name="projDir">The projection direction of the extrusion.</param>
       /// <param name="analyzer">The extrusion analyzer.</param>
       /// <returns>The IFCExtrusionCreationData information.</returns>
-      public static IFCExtrusionCreationData GetExtrusionCreationDataFromAnalyzer(ExporterIFC exporterIFC, XYZ projDir, ExtrusionAnalyzer analyzer)
+      public static IFCExtrusionCreationData GetExtrusionCreationDataFromAnalyzer(XYZ projDir, ExtrusionAnalyzer analyzer)
       {
          IFCExtrusionCreationData exportBodyParams = new IFCExtrusionCreationData();
 
@@ -1334,9 +1334,8 @@ private static HandleAndAnalyzer CreateExtrusionWithClippingBase(
                ExtraClippingData currentExtraClippingData = null;
                HandleAndAnalyzer currRetVal = CreateExtrusionWithClippingAndOpening(
                   exporterIFC, element, isVoid,
-                  catId, solid, basePlane, planeOrigin, projDir, range,
+                  solid, basePlane, planeOrigin, projDir, range,
                   out currentExtraClippingData,
-                  ref materialAndProfile,
                   addInfo: addInfo,
                   profileName: profileName);
 
@@ -1446,9 +1445,8 @@ private static bool AllowMultipleClipPlanesForCategory(ElementId cuttingElementC
 
       private static HandleAndAnalyzer CreateExtrusionWithClippingAndOpening(
          ExporterIFC exporterIFC, Element element, bool isVoid,
-         ElementId catId, Solid solid, Plane basePlane, XYZ planeOrigin, XYZ projDir, IFCRange range,
+         Solid solid, Plane basePlane, XYZ planeOrigin, XYZ projDir, IFCRange range,
          out ExtraClippingData extraClippingData,
-         ref MaterialAndProfile materialAndProfile,
          GenerateAdditionalInfo addInfo = GenerateAdditionalInfo.GenerateBody,
          string profileName = null)
       {
@@ -1702,7 +1700,7 @@ private static HandleAndAnalyzer CreateExtrusionWithClippingAndOpening(
                      }
                   }
 
-                  ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, exporterIFC, element);
+                  ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, element);
                   extraClippingData.MaterialIds.Add(materialId);
                   if ((addInfo & GenerateAdditionalInfo.GenerateBody) != 0)
                   {
@@ -1809,7 +1807,7 @@ public static IFCAnyHandle CreateExtrusionWithClipping(ExporterIFC exporterIFC,
             materialAndProfile = handleAndAnalyzer.MaterialAndProfile;
          }
          if (handleAndAnalyzer.Analyzer != null)
-            extrusionData = GetExtrusionCreationDataFromAnalyzer(exporterIFC, projDir, handleAndAnalyzer.Analyzer);
+            extrusionData = GetExtrusionCreationDataFromAnalyzer(projDir, handleAndAnalyzer.Analyzer);
 
          return handleAndAnalyzer.Handle;
       }
@@ -1846,7 +1844,7 @@ public static HandleAndData CreateExtrusionWithClippingAndProperties(ExporterIFC
          ret.ShapeRepresentationType = handleAndAnalyzer.ShapeRepresentationType;
          ret.MaterialIds = extraClippingData.MaterialIds;
          if (handleAndAnalyzer.Analyzer != null)
-            ret.Data = GetExtrusionCreationDataFromAnalyzer(exporterIFC, projDir, handleAndAnalyzer.Analyzer);
+            ret.Data = GetExtrusionCreationDataFromAnalyzer(projDir, handleAndAnalyzer.Analyzer);
          if ((addInfo & GenerateAdditionalInfo.GenerateProfileDef) != 0)
             ret.MaterialAndProfile = handleAndAnalyzer.MaterialAndProfile;
          return ret;
diff --git a/Source/Revit.IFC.Export/Exporter/FamilyInstanceExporter.cs b/Source/Revit.IFC.Export/Exporter/FamilyInstanceExporter.cs
index 4f21736f..5b7a93af 100644
--- a/Source/Revit.IFC.Export/Exporter/FamilyInstanceExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/FamilyInstanceExporter.cs
@@ -437,7 +437,7 @@ public static void ExportFamilyInstanceAsMappedItem(ExporterIFC exporterIFC, Fam
          FamilyTypeInfo typeInfo = new FamilyTypeInfo();
          IFCExtrusionCreationData extraParams = typeInfo.extraParams;
 
-         bool flipped = doorWindowInfo != null ? doorWindowInfo.FlippedSymbol : false;
+         bool flipped = doorWindowInfo != null && doorWindowInfo.FlippedSymbol;
          FamilyTypeInfo currentTypeInfo = ExporterCacheManager.FamilySymbolToTypeInfoCache.Find(originalFamilySymbol.Id, flipped, exportType);
          bool found = currentTypeInfo.IsValid();
 
@@ -871,9 +871,9 @@ public static void ExportFamilyInstanceAsMappedItem(ExporterIFC exporterIFC, Fam
                   else
                   {
                      Element elementType = familyInstance.Document.GetElement(familyInstance.GetTypeId());
-                     ElementId bestMatId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(exportGeometry, exporterIFC, elementType);
+                     ElementId bestMatId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(exportGeometry, elementType);
                      if (bestMatId == ElementId.InvalidElementId)
-                        bestMatId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(exportGeometry, exporterIFC, familyInstance);
+                        bestMatId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(exportGeometry, familyInstance);
 
                      // Also get the materials from Parameters
                      IList<ElementId> matIds = ParameterUtil.FindMaterialParameters(elementType);
@@ -1361,7 +1361,7 @@ public static void ExportFamilyInstanceAsMappedItem(ExporterIFC exporterIFC, Fam
                                  ownerHistory, localPlacementToUse, repHnd, exportType.ValidatedPredefinedType);
                            }
 
-                           bool associateToLevel = containedInSpace ? false : !isChildInContainer;
+                           bool associateToLevel = !containedInSpace && !isChildInContainer;
                            wrapper.AddElement(familyInstance, instanceHandle, setter, extraParams, associateToLevel, exportType);
                            if (containedInSpace)
                               ExporterCacheManager.SpaceInfoCache.RelateToSpace(roomId, instanceHandle);
@@ -1551,30 +1551,6 @@ static double GetMinSymbolWidth(FamilySymbol symbol)
          return ExporterIFCUtils.GetMinSymbolWidth(symbol);
       }
 
-      /// <summary>
-      /// Gets IFCBeamType from beam type name.
-      /// </summary>
-      /// <param name="element">The beam element.</param>
-      /// <param name="defaultBeamType">The default beam type name.</param>
-      /// <returns>The IFCBeamType.</returns>
-      static IFCBeamType GetBeamType(Element element, string beamType)
-      {
-         string value = null;
-         if (ParameterUtil.GetStringValueFromElementOrSymbol(element, "IfcType", out value) == null)
-            value = beamType;
-
-         if (String.IsNullOrEmpty(value))
-            return IFCBeamType.Beam;
-
-         string newValue = NamingUtil.RemoveSpacesAndUnderscores(value);
-
-         if (String.Compare(newValue, "USERDEFINED", true) == 0)
-            return IFCBeamType.UserDefined;
-
-         return IFCBeamType.Beam;
-      }
-
-
       /// <summary>
       /// Gets IFCColumnType from column type name.
       /// </summary>
@@ -1678,33 +1654,7 @@ public static IFCMemberType GetMemberType(Element element, string memberType)
             cardinalPoint = null;       // not supported combination
          return cardinalPoint;
       }
-
-      /// <summary>
-      /// This function is to check whether a GeometryObject is empty (no Face/Edge for Solid, or no Triangle/Vert for Mesh). This may occur for certain geometry parts
-      /// </summary>
-      /// <param name="geom"></param>
-      /// <returns></returns>
-      private static bool GeometryIsEmpty(IList<Solid> solids, IList<Mesh> meshes)
-      {
-         if (solids.Count == 0 && meshes.Count == 0)
-            return true;
-
-         // We will return false (not empty) if any of the geometry is not empty
-         foreach (Solid solidGeom in solids)
-         {
-            if (!solidGeom.Faces.IsEmpty || !solidGeom.Edges.IsEmpty)
-               return false;
-         }
-
-         foreach (Mesh meshGeom in meshes)
-         {
-            if (meshGeom.NumTriangles > 0 || meshGeom.Vertices.Count > 0)
-               return false;
-         }
-
-         return true;
-      }
-
+      
       private static GeometryObject GetPotentialCurveOrPolyline(Element element, Options options)
       {
          IList<GeometryObject> potentialCurves = new List<GeometryObject>();
diff --git a/Source/Revit.IFC.Export/Exporter/FloorExporter.cs b/Source/Revit.IFC.Export/Exporter/FloorExporter.cs
index 5a197974..cdc9be05 100644
--- a/Source/Revit.IFC.Export/Exporter/FloorExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/FloorExporter.cs
@@ -122,7 +122,7 @@ public static void ExportGenericSlab(ExporterIFC exporterIFC, Element slabElemen
                         }
                         else if (slabElement is FamilyInstance)
                         {
-                           ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, slabElement);
+                           ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, slabElement);
                            //Document doc = slabElement.Document;
                            if (typeHnd != null)
                               CategoryUtil.CreateMaterialAssociation(exporterIFC, typeHnd, matId);
@@ -433,6 +433,7 @@ public static void ExportCeilingAndFloorElement(ExporterIFC exporterIFC, Ceiling
                            break;
                         case IFCEntityType.IfcSlab:
                            bool isBaseSlab = false;
+#pragma warning disable CS0612, CS0618//AnalyticalModel is obsolette
                            AnalyticalModel analyticalModel = floorElement.GetAnalyticalModel();
                            if (analyticalModel != null)
                            {
@@ -441,6 +442,7 @@ public static void ExportCeilingAndFloorElement(ExporterIFC exporterIFC, Ceiling
                            }
                            exportType.ValidatedPredefinedType = IFCValidateEntry.GetValidIFCType<IFCSlabType>(floorElement, ifcEnumType, isBaseSlab ? "BASESLAB" : "FLOOR");
                            break;
+#pragma warning restore CS0612, CS0618
                      }
 
                      for (int ii = 0; ii < numReps; ii++)
diff --git a/Source/Revit.IFC.Export/Exporter/FootingExporter.cs b/Source/Revit.IFC.Export/Exporter/FootingExporter.cs
index 59dbcc6e..00053188 100644
--- a/Source/Revit.IFC.Export/Exporter/FootingExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/FootingExporter.cs
@@ -105,7 +105,7 @@ public static void ExportFooting(ExporterIFC exporterIFC, Element element, Geome
                      ElementId catId = CategoryUtil.GetSafeCategoryId(element);
 
 
-                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
+                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, element);
                      BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
                      prodRep = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC,
                         element, catId, geometryElement, bodyExporterOptions, null, ecData, true);
diff --git a/Source/Revit.IFC.Export/Exporter/GenericMEPExporter.cs b/Source/Revit.IFC.Export/Exporter/GenericMEPExporter.cs
index 6f724d0e..274d4add 100644
--- a/Source/Revit.IFC.Export/Exporter/GenericMEPExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/GenericMEPExporter.cs
@@ -92,7 +92,7 @@ public static bool Export(ExporterIFC exporterIFC, Element element, GeometryElem
                            return false;
                         }
 
-                        ExportAsMappedItem(exporterIFC, element, file, exportType, ifcEnumType, extraParams,
+                        ExportAsMappedItem(exporterIFC, element, exportType, ifcEnumType, extraParams,
                                            setter, localPlacementToUse, productRepresentation,
                                            productWrapper);
                      }
@@ -166,7 +166,7 @@ public static bool Export(ExporterIFC exporterIFC, Element element, GeometryElem
                               return false;
                            }
 
-                           ExportAsMappedItem(exporterIFC, element, file, exportType, ifcEnumType,
+                           ExportAsMappedItem(exporterIFC, element, exportType, ifcEnumType,
                                               extraParams, setter, localPlacementToUse,
                                               productRepresentation, productWrapper);
                         }
@@ -180,7 +180,7 @@ public static bool Export(ExporterIFC exporterIFC, Element element, GeometryElem
          return true;
       }
 
-      private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element, IFCFile file, IFCExportInfoPair exportType, string ifcEnumType, IFCExtrusionCreationData extraParams,
+      private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element, IFCExportInfoPair exportType, string ifcEnumType, IFCExtrusionCreationData extraParams,
           PlacementSetter setter, IFCAnyHandle localPlacementToUse, IFCAnyHandle productRepresentation, ProductWrapper productWrapper)
       {
          IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
@@ -210,9 +210,9 @@ private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element,
                   ExporterCacheManager.FamilySymbolToTypeInfoCache.Register(typeId, false, exportType, currentTypeInfo);
 
                   Element elementType = element.Document.GetElement(element.GetTypeId());
-                  matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, elementType);
+                  matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), elementType);
                   if (matId == ElementId.InvalidElementId)
-                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, element);
+                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), element);
 
                   if (matId != ElementId.InvalidElementId)
                   {
@@ -260,7 +260,7 @@ private static void ExportAsMappedItem(ExporterIFC exporterIFC, Element element,
             return;
          if (matId == ElementId.InvalidElementId && !hasMaterialAssociatedToType)
          {
-            matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), exporterIFC, element);
+            matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(element.get_Geometry(geomOptions), element);
             if (matId != ElementId.InvalidElementId)
                CategoryUtil.CreateMaterialAssociation(exporterIFC, instanceHandle, matId);
          }
diff --git a/Source/Revit.IFC.Export/Exporter/InsulationExporter.cs b/Source/Revit.IFC.Export/Exporter/InsulationExporter.cs
index de7938b6..3edabd19 100644
--- a/Source/Revit.IFC.Export/Exporter/InsulationExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/InsulationExporter.cs
@@ -89,7 +89,7 @@ protected static bool ExportInsulation(ExporterIFC exporterIFC, Element element,
 
                   productWrapper.AddElement(element, insulation, placementSetter.LevelInfo, ecData, true, exportInfo);
 
-                  ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
+                  ElementId matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, element);
                   CategoryUtil.CreateMaterialAssociation(exporterIFC, insulation, matId);
                }
             }
diff --git a/Source/Revit.IFC.Export/Exporter/PileExporter.cs b/Source/Revit.IFC.Export/Exporter/PileExporter.cs
index db3d47a7..fc3fa929 100644
--- a/Source/Revit.IFC.Export/Exporter/PileExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/PileExporter.cs
@@ -69,7 +69,7 @@ public static void ExportPile(ExporterIFC exporterIFC, Element element, Geometry
                      ElementId catId = CategoryUtil.GetSafeCategoryId(element);
 
 
-                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element);
+                     matId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, element);
                      BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.ExtraLow);
 
                      StructuralMemberAxisInfo axisInfo = StructuralMemberExporter.GetStructuralMemberAxisTransform(element);
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/AttributeEntry.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/AttributeEntry.cs
index b1ac977e..7da8e9b2 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/AttributeEntry.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/AttributeEntry.cs
@@ -67,7 +67,7 @@ internal string AsString(Element element)
       {
          if (element == null)
             return null;
-         foreach (AttributeEntryMap entry in m_Entries)
+         foreach (AttributeEntryMap entry in Entries)
          {
             string result = entry.AsString(element);
             if (result != null)
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/NetCrossSectionAreaCalculator.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/NetCrossSectionAreaCalculator.cs
new file mode 100644
index 00000000..4fdabbc3
--- /dev/null
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/NetCrossSectionAreaCalculator.cs
@@ -0,0 +1,102 @@
+//
+// BIM IFC library: this library works with Autodesk(R) Revit(R) to export IFC files containing model geometry.
+// Copyright (C) 2012  Autodesk, Inc.
+// 
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autodesk.Revit.DB;
+using Autodesk.Revit.DB.IFC;
+using Revit.IFC.Export.Utility;
+using Revit.IFC.Common.Utility;
+
+namespace Revit.IFC.Export.Exporter.PropertySet.Calculators
+{
+   /// <summary>
+   /// A calculation class to calculate net cross section area.
+   /// </summary>
+   class NetCrossSectionAreaCalculator : PropertyCalculator
+   {
+      /// <summary>
+      /// A double variable to keep the calculated value.
+      /// </summary>
+      private double m_Area = 0;
+
+      /// <summary>
+      /// A static instance of this class.
+      /// </summary>
+      static NetCrossSectionAreaCalculator s_Instance = new NetCrossSectionAreaCalculator();
+
+      /// <summary>
+      /// The NetCrossSectionAreaCalculator instance.
+      /// </summary>
+      public static NetCrossSectionAreaCalculator Instance
+      {
+         get { return s_Instance; }
+      }
+
+      /// <summary>
+      /// Calculates cross area.
+      /// </summary>
+      /// <param name="exporterIFC">
+      /// The ExporterIFC object.
+      /// </param>
+      /// <param name="extrusionCreationData">
+      /// The IFCExtrusionCreationData.
+      /// </param>
+      /// <param name="element">
+      /// The element to calculate the value.
+      /// </param>
+      /// <param name="elementType">
+      /// The element type.
+      /// </param>
+      /// <returns>
+      /// True if the operation succeed, false otherwise.
+      /// </returns>
+      public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
+      {
+         double crossSectionArea = 0;
+
+         // 1. Check override parameter
+         if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyNetCrossSectionArea", out crossSectionArea) == null)
+               ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "NetCrossSectionArea", out crossSectionArea);
+         m_Area = UnitUtil.ScaleArea(crossSectionArea);
+         if (m_Area > MathUtil.Eps() * MathUtil.Eps())
+            return true;
+
+         // 2. try using extrusion data
+         if (extrusionCreationData == null)
+            return false;
+
+         m_Area = extrusionCreationData.ScaledArea;
+         return m_Area > MathUtil.Eps() * MathUtil.Eps();
+      }
+
+      /// <summary>
+      /// Gets the calculated double value.
+      /// </summary>
+      /// <returns>
+      /// The double value.
+      /// </returns>
+      public override double GetDoubleValue()
+      {
+         return m_Area;
+      }
+   }
+}
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/SpanCalculator.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/SpanCalculator.cs
index d770fc3b..943d6d6e 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/SpanCalculator.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/SpanCalculator.cs
@@ -89,7 +89,9 @@ public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData
             return false;
          }
          m_Span = extrusionCreationData.ScaledLength;
+#pragma warning disable CS0612, CS0618 //AnalyticalModel is obsolette
          AnalyticalModel elemAnalyticalModel = element.GetAnalyticalModel();
+#pragma warning restore CS0612, CS0618
          if (elemAnalyticalModel != null)
          {
             IList<AnalyticalModelSupport> supports = elemAnalyticalModel.GetAnalyticalModelSupports();
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/Description.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/Description.cs
index 5e2679e2..0052f067 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/Description.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/Description.cs
@@ -125,7 +125,7 @@ public bool IsAppropriateType(IFCAnyHandle handle)
          if (ObjectType == "")
             return true;
 
-         string objectType = IFCAnyHandleUtil.GetObjectType(handle);
+         string objectType = IFCAnyHandleUtil.GetEntityType(handle).ToString();
          return (NamingUtil.IsEqualIgnoringCaseAndSpaces(ObjectType, objectType));
       }
 
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/Entry.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/Entry.cs
index 1d4b2fcb..fe1334f2 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/Entry.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/Entry.cs
@@ -17,14 +17,9 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
-using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Text;
-using Autodesk.Revit;
 using Autodesk.Revit.ApplicationServices;
 using Autodesk.Revit.DB;
-using Autodesk.Revit.DB.IFC;
 
 namespace Revit.IFC.Export.Exporter.PropertySet
 {
@@ -48,16 +43,22 @@ namespace Revit.IFC.Export.Exporter.PropertySet
    abstract public class Entry<T> where T : EntryMap, new()
    {
       /// <summary>
-      /// The default name for IFC property.  This is generally assumed to be in English (ENU).
+      /// The name of the property or quantity as stored in the IFC export.
       /// </summary>
-      string m_PropertyName = String.Empty;
+      /// <remarks>
+      /// Default is empty; if empty the name of the Revit parameter will be used.
+      /// </remarks>
+      public string PropertyName { get; set; } = string.Empty;
 
       /// <summary>
-      /// Indicates if the property is for element type.
+      /// True if the property comes from the element's type (vs. the element itself).
       /// </summary>
-      bool m_IsElementTypeProperty = true;
+      /// <remarks>
+      /// The default value is true.
+      /// </remarks>
+      public bool IsElementTypeProperty { get; set; } = true;
 
-      protected List<T> m_Entries = new List<T>();
+      protected List<T> Entries { get; set; } = new List<T>();
 
       /// <summary>
       /// Constructor to create an Entry object.
@@ -67,93 +68,60 @@ namespace Revit.IFC.Export.Exporter.PropertySet
       /// </param>
       public Entry(string revitParameterName)
       {
-         m_Entries.Add(new T() { RevitParameterName = revitParameterName });
-         this.m_PropertyName = revitParameterName;
+         Entries.Add(new T() { RevitParameterName = revitParameterName });
+         PropertyName = revitParameterName;
       }
+
       public Entry(string propertyName, T entry)
       {
-         m_Entries.Add(entry);
-         this.m_PropertyName = propertyName;
-      }
-      public Entry(string propertyName, IEnumerable<T> entries)
-      {
-         m_Entries.AddRange(entries);
-         this.m_PropertyName = propertyName;
+         Entries.Add(entry);
+         PropertyName = propertyName;
       }
 
-      /// <summary>
-      /// True if the property comes from the element's type (vs. the element itself).
-      /// </summary>
-      /// <remarks>
-      /// The default value is true.
-      /// </remarks>
-      public bool IsElementTypeProperty
-      {
-         get
-         {
-            return m_IsElementTypeProperty;
-         }
-         set
-         {
-            m_IsElementTypeProperty = value;
-         }
-      }
-
-      /// <summary>
-      /// The name of the property or quantity as stored in the IFC export.
-      /// </summary>
-      /// <remarks>
-      /// Default is empty; if empty the name of the Revit parameter will be used.
-      /// </remarks>
-      public string PropertyName
+      public Entry(string propertyName, IEnumerable<T> entries)
       {
-         get
-         {
-            return m_PropertyName;
-         }
-         set
-         {
-            m_PropertyName = value;
-         }
+         Entries.AddRange(entries);
+         PropertyName = propertyName;
       }
 
       public PropertyCalculator PropertyCalculator
       {
          set
          {
-            if (m_Entries.Count > 0)
-               m_Entries[0].PropertyCalculator = value;
+            if (Entries.Count > 0)
+               Entries[0].PropertyCalculator = value;
          }
       }
       public void AddLocalizedParameterName(LanguageType locale, string localizedName)
       {
-         if (m_Entries.Count > 0)
-            m_Entries[0].AddLocalizedParameterName(locale, localizedName);
+         if (Entries.Count > 0)
+            Entries[0].AddLocalizedParameterName(locale, localizedName);
       }
+
       public void AddEntry(T entry)
       {
-         m_Entries.Add(entry);
+         Entries.Add(entry);
       }
+
       public void UpdateEntry()
       {
-         foreach (T entry in m_Entries)
+         foreach (T entry in Entries)
             entry.UpdateEntry();
       }
       public void SetRevitParameterName(string revitParameterName)
       {
-         if (m_Entries.Count == 0)
-            m_Entries.Add(new T() { RevitParameterName = revitParameterName });
+         if (Entries.Count == 0)
+            Entries.Add(new T() { RevitParameterName = revitParameterName });
          else
-            m_Entries[0].RevitParameterName = revitParameterName;
+            Entries[0].RevitParameterName = revitParameterName;
       }
 
       public void SetRevitBuiltInParameter(BuiltInParameter builtInParameter)
       {
-         if (m_Entries.Count == 0)
-            m_Entries.Add(new T() { RevitBuiltInParameter = builtInParameter });
+         if (Entries.Count == 0)
+            Entries.Add(new T() { RevitBuiltInParameter = builtInParameter });
          else
-            m_Entries[0].RevitBuiltInParameter = builtInParameter;
+            Entries[0].RevitBuiltInParameter = builtInParameter;
       }
-
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/EntryMap.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/EntryMap.cs
index 4d2ae019..3d856093 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/EntryMap.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/EntryMap.cs
@@ -50,34 +50,35 @@ abstract public class EntryMap
       /// <summary>
       /// The parameter name to be used to get the parameter value.  This is generally in English (ENU).
       /// </summary>
-      string m_RevitParameterName = String.Empty;
+      public string RevitParameterName { get; set; } = string.Empty;
 
       /// <summary>
       /// The parameter name to be used to get the parameter value in other locales.
       /// </summary>
-      Dictionary<LanguageType, string> m_LocalizedRevitParameterNames = null;
+      public Dictionary<LanguageType, string> LocalizedRevitParameterNames { get; set; } = null;
 
       /// <summary>
       /// The built in parameter.
       /// </summary>
-      BuiltInParameter m_RevitBuiltInParameter = BuiltInParameter.INVALID;
+      public BuiltInParameter RevitBuiltInParameter { get; set; } = BuiltInParameter.INVALID;
 
       /// <summary>
       /// The property calculator to calculate the property value.
       /// </summary>
-      PropertyCalculator m_PropertyCalculator;
+      public PropertyCalculator PropertyCalculator { get; set; }
 
       /// <summary>
       /// Indicates if the property value is retrieved only from the calculator.
       /// </summary>
-      bool m_UseCalculatorOnly = false;
+      public bool UseCalculatorOnly { get; set; }  = false;
 
       /// <summary>
       /// Calculated value indicates whether or not there is a valid parameter name associated with this entry.
       /// </summary>
-      bool m_ParameterNameIsValid = false;
+      public bool ParameterNameIsValid { get; private set; } = false;
 
       public EntryMap() { }
+
       /// <summary>
       /// Constructor to create an Entry object.
       /// </summary>
@@ -86,50 +87,31 @@ public EntryMap() { }
       /// </param>
       public EntryMap(string revitParameterName)
       {
-         this.m_RevitParameterName = revitParameterName;
+         RevitParameterName = revitParameterName;
       }
+
       public EntryMap(BuiltInParameter builtInParameter)
       {
-         this.m_RevitBuiltInParameter = builtInParameter;
+         RevitBuiltInParameter = builtInParameter;
       }
+
       public EntryMap(PropertyCalculator calculator)
       {
-         this.m_PropertyCalculator = calculator;
+         PropertyCalculator = calculator;
       }
+
       public EntryMap(string revitParameterName, BuiltInParameter builtInParameter)
       {
-         this.m_RevitParameterName = revitParameterName;
-         this.m_RevitBuiltInParameter = builtInParameter;
+         RevitParameterName = revitParameterName;
+         RevitBuiltInParameter = builtInParameter;
       }
+
       /// <summary>
       /// Updates caches to make use of this Entry faster after it is completed.
       /// </summary>
       public void UpdateEntry()
       {
-         m_ParameterNameIsValid = (!UseCalculatorOnly && (!String.IsNullOrEmpty(RevitParameterName) || (RevitBuiltInParameter != BuiltInParameter.INVALID)));
-      }
-
-      /// <summary>
-      /// Returns whether the parameter has a usable (valid) name.
-      /// </summary>
-      public bool ParameterNameIsValid
-      {
-         get { return m_ParameterNameIsValid; }
-      }
-
-      /// <summary>
-      /// The standard name of the parameter in Revit (if it exists).
-      /// </summary>
-      public string RevitParameterName
-      {
-         get
-         {
-            return m_RevitParameterName;
-         }
-         set
-         {
-            m_RevitParameterName = value;
-         }
+         ParameterNameIsValid = (!UseCalculatorOnly && (!string.IsNullOrEmpty(RevitParameterName) || (RevitBuiltInParameter != BuiltInParameter.INVALID)));
       }
 
       /// <summary>
@@ -139,10 +121,9 @@ public string RevitParameterName
       /// <returns>The localized name, or null if it does not exist.</returns>
       public string LocalizedRevitParameterName(LanguageType locale)
       {
-         string localizedName = null;
-         if (m_LocalizedRevitParameterNames != null)
+         if (LocalizedRevitParameterNames != null)
          {
-            if (m_LocalizedRevitParameterNames.TryGetValue(locale, out localizedName))
+            if (LocalizedRevitParameterNames.TryGetValue(locale, out string localizedName))
                return localizedName;
          }
          return null;
@@ -155,57 +136,12 @@ public string LocalizedRevitParameterName(LanguageType locale)
       /// <param name="localizedName">The name for that language.</param>
       public void AddLocalizedParameterName(LanguageType locale, string localizedName)
       {
-         if (m_LocalizedRevitParameterNames == null)
-            m_LocalizedRevitParameterNames = new Dictionary<LanguageType, string>();
+         if (LocalizedRevitParameterNames == null)
+            LocalizedRevitParameterNames = new Dictionary<LanguageType, string>();
 
-         if (m_LocalizedRevitParameterNames.ContainsKey(locale))
+         if (LocalizedRevitParameterNames.ContainsKey(locale))
             throw new ArgumentException("Locale value already defined.");
-         m_LocalizedRevitParameterNames[locale] = localizedName;
-      }
-
-      /// <summary>
-      /// The built-in parameter.
-      /// </summary>
-      public BuiltInParameter RevitBuiltInParameter
-      {
-         get
-         {
-            return m_RevitBuiltInParameter;
-         }
-         set
-         {
-            m_RevitBuiltInParameter = value;
-         }
-      }
-
-      /// <summary>
-      /// The instance of a class that can calculate the value of the property or quantity.
-      /// </summary>
-      public PropertyCalculator PropertyCalculator
-      {
-         get
-         {
-            return m_PropertyCalculator;
-         }
-         set
-         {
-            m_PropertyCalculator = value;
-         }
-      }
-
-      /// <summary>
-      /// Indicates if the property value is retrieved only from the calculator.
-      /// </summary>
-      public bool UseCalculatorOnly
-      {
-         get
-         {
-            return m_UseCalculatorOnly;
-         }
-         set
-         {
-            m_UseCalculatorOnly = value;
-         }
+         LocalizedRevitParameterNames[locale] = localizedName;
       }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X2Enum.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X2Enum.cs
index 6fcf200f..c9e9714e 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X2Enum.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X2Enum.cs
@@ -16,6 +16,46 @@ namespace Revit.IFC.Export.Exporter.PropertySet.IFC2X2
 {
 
 
+   public enum IFCDoorPanelOperation {
+      Swinging,
+      Double_Acting,
+      Sliding,
+      Folding,
+      Revolving,
+      RollingUp,
+      UserDefined,
+      NotDefined}
+
+   public enum IFCDoorPanelPosition {
+      Left,
+      Middle,
+      Right,
+      NotDefined}
+
+   public enum IFCWindowPanelOperation {
+      SideHungRightHand,
+      SideHungLeftHand,
+      TiltAndTurnRightHand,
+      TiltAndTurnLeftHand,
+      TopHung,
+      BottomHung,
+      PivotHorizontal,
+      PivotVertical,
+      SlidingHorizontal,
+      SlidingVertical,
+      RemovableCasement,
+      FixedCasement,
+      OtherOperation,
+      NotDefined}
+
+   public enum IFCWindowPanelPosition {
+      Left,
+      Middle,
+      Right,
+      Bottom,
+      Top,
+      NotDefined}
+
    public enum PEnum_RequestSourceType {
       Email,
       Fax,
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3TC1Enum.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3Enum.cs
similarity index 97%
rename from Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3TC1Enum.cs
rename to Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3Enum.cs
index 1492c677..75436781 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3TC1Enum.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC2X3Enum.cs
@@ -12,10 +12,50 @@
 using Revit.IFC.Export.Toolkit;
 using Revit.IFC.Common.Enums;
 
-namespace Revit.IFC.Export.Exporter.PropertySet.IFC2X3TC1
+namespace Revit.IFC.Export.Exporter.PropertySet.IFC2X3
 {
 
 
+   public enum IFCDoorPanelOperation {
+      Swinging,
+      Double_Acting,
+      Sliding,
+      Folding,
+      Revolving,
+      RollingUp,
+      UserDefined,
+      NotDefined}
+
+   public enum IFCDoorPanelPosition {
+      Left,
+      Middle,
+      Right,
+      NotDefined}
+
+   public enum IFCWindowPanelOperation {
+      SideHungRightHand,
+      SideHungLeftHand,
+      TiltAndTurnRightHand,
+      TiltAndTurnLeftHand,
+      TopHung,
+      BottomHung,
+      PivotHorizontal,
+      PivotVertical,
+      SlidingHorizontal,
+      SlidingVertical,
+      RemovableCasement,
+      FixedCasement,
+      OtherOperation,
+      NotDefined}
+
+   public enum IFCWindowPanelPosition {
+      Left,
+      Middle,
+      Right,
+      Bottom,
+      Top,
+      NotDefined}
+
    public enum PEnum_RequestSourceType {
       Email,
       Fax,
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC4Enum.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC4Enum.cs
index fa6f2457..d84d948e 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC4Enum.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/ExporterInitializer_PsetDefIFC4Enum.cs
@@ -16,6 +16,54 @@ namespace Revit.IFC.Export.Exporter.PropertySet.IFC4
 {
 
 
+   public enum IFCDoorPanelOperation {
+      SWINGING,
+      DOUBLE_ACTING,
+      SLIDING,
+      FOLDING,
+      REVOLVING,
+      ROLLINGUP,
+      FIXEDPANEL,
+      USERDEFINED,
+      NOTDEFINED}
+
+   public enum IFCDoorPanelPosition {
+      LEFT,
+      MIDDLE,
+      RIGHT,
+      NOTDEFINED}
+
+   public enum IFCPermeableCoveringOperation {
+      GRILL,
+      LOUVER,
+      SCREEN,
+      USERDEFINED,
+      NOTDEFINED}
+
+   public enum IFCWindowPanelPosition {
+      LEFT,
+      MIDDLE,
+      RIGHT,
+      BOTTOM,
+      TOP,
+      NOTDEFINED}
+
+   public enum IFCWindowPanelOperation {
+      SIDEHUNGRIGHTHAND,
+      SIDEHUNGLEFTHAND,
+      TILTANDTURNRIGHTHAND,
+      TILTANDTURNLEFTHAND,
+      TOPHUNG,
+      BOTTOMHUNG,
+      PIVOTHORIZONTAL,
+      PIVOTVERTICAL,
+      SLIDINGHORIZONTAL,
+      SLIDINGVERTICAL,
+      REMOVABLECASEMENT,
+      FIXEDCASEMENT,
+      OTHEROPERATION,
+      NOTDEFINED}
+
    public enum PEnum_ElementStatus {
       NEW,
       EXISTING,
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntry.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntry.cs
index 60094c20..fa23486b 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntry.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntry.cs
@@ -264,7 +264,7 @@ public class PropertySetEntry : Entry<PropertySetEntryMap>
       /// <summary>
       /// The type of the IFC property set entry. Default is label.
       /// </summary>
-      PropertyType m_PropertyType = PropertyType.Label;
+      public PropertyType PropertyType { get; set; } = PropertyType.Label;
 
       /// <summary>
       /// The type of the IFC argument of table property set entry. Use if PropertyValueType is TableValue
@@ -274,16 +274,18 @@ public class PropertySetEntry : Entry<PropertySetEntryMap>
       /// <summary>
       /// The value type of the IFC property set entry.
       /// </summary>
-      PropertyValueType m_PropertyValueType = PropertyValueType.SingleValue;
+      public PropertyValueType PropertyValueType { get; set; } = PropertyValueType.SingleValue;
 
       /// <summary>
       /// The type of the Enum that will validate the value for an enumeration.
       /// </summary>
-      Type m_PropertyEnumerationType = null;
+      public Type PropertyEnumerationType { get; set; } = null;
 
-      IFCAnyHandle m_DefaultProperty = null;
+      IFCAnyHandle DefaultProperty { get; set; } = null;
 
-      IfcValue m_DefaultValue = null;
+      public IfcValue DefaultValue { get; set; } = null;
+
+      public IList<TableCellCombinedParameterData> CombinedParameterData { get; set; } = null;
 
       /// <summary>
       /// Constructs a PropertySetEntry object.
@@ -295,108 +297,94 @@ public PropertySetEntry(string revitParameterName)
           : base(revitParameterName)
       {
       }
+
       public PropertySetEntry(PropertyType propertyType, string revitParameterName)
           : base(revitParameterName)
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
       public PropertySetEntry(PropertyType propertyType, string propertyName, BuiltInParameter builtInParameter)
              : base(propertyName, new PropertySetEntryMap(propertyName) { RevitBuiltInParameter = builtInParameter })
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
       public PropertySetEntry(PropertyType propertyType, string propertyName, PropertyCalculator propertyCalculator)
              : base(propertyName, new PropertySetEntryMap(propertyName) { PropertyCalculator = propertyCalculator })
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
       public PropertySetEntry(PropertyType propertyType, string propertyName, BuiltInParameter builtInParameter, PropertyCalculator propertyCalculator)
              : base(propertyName, new PropertySetEntryMap(propertyName) { RevitBuiltInParameter = builtInParameter, PropertyCalculator = propertyCalculator })
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
       public PropertySetEntry(PropertyType propertyType, string propertyName, PropertySetEntryMap entry)
            : base(propertyName, entry)
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
       public PropertySetEntry(PropertyType propertyType, string propertyName, IEnumerable<PropertySetEntryMap> entries)
            : base(propertyName, entries)
       {
-         m_PropertyType = propertyType;
+         PropertyType = propertyType;
       }
-      /// <summary>
-      /// The type of the IFC property set entry.
-      /// </summary>
-      public PropertyType PropertyType
+      
+      private IFCAnyHandle SetDefaultProperty(IFCFile file)
       {
-         get
-         {
-            return m_PropertyType;
-         }
-         set
+         if (DefaultProperty == null)
          {
-            m_PropertyType = value;
+            if (DefaultValue != null)
+            {
+               switch (PropertyType)
+               {
+                  case PropertyType.Label:
+                     return DefaultProperty = PropertyUtil.CreateLabelProperty(file, PropertyName, DefaultValue.ValueString, PropertyValueType, PropertyEnumerationType);
+                  case PropertyType.Text:
+                     return DefaultProperty = PropertyUtil.CreateTextProperty(file, PropertyName, DefaultValue.ValueString, PropertyValueType);
+                  case PropertyType.Identifier:
+                     return DefaultProperty = PropertyUtil.CreateIdentifierProperty(file, PropertyName, DefaultValue.ValueString, PropertyValueType);
+                  //todo make this work for all values
+               }
+            }
          }
-      }
 
-      /// <summary>
-      /// The value type of the IFC property set entry.
-      /// </summary>
-      public PropertyValueType PropertyValueType
-      {
-         get
-         {
-            return m_PropertyValueType;
-         }
-         set
-         {
-            m_PropertyValueType = value;
-         }
+         return DefaultProperty;
       }
 
-      /// <summary>
-      /// The type of the Enum that will validate the value for an enumeration.
-      /// </summary>
-      public Type PropertyEnumerationType
+      private string GetParameterValueById(Element element, ElementId paramId)
       {
-         get
+         if (element == null)
+            return string.Empty;
+
+         Parameter parameter = null;
+
+         int paramIdAsInteger = paramId.IntegerValue;
+         if (paramIdAsInteger < 0)
          {
-            return m_PropertyEnumerationType;
+            parameter = element.get_Parameter((BuiltInParameter)paramIdAsInteger);
          }
-         set
+         else
          {
-            m_PropertyEnumerationType = value;
+            ParameterElement parameterElem = element.Document.GetElement(paramId) as ParameterElement;            parameter = element?.get_Parameter((BuiltInParameter)paramIdAsInteger);
+            if (parameterElem == null)
+               return string.Empty;
+            parameter = element.get_Parameter(parameterElem.GetDefinition());
          }
-      }
 
-      public IfcValue DefaultValue
-      {
-         set
-         {
-            m_DefaultValue = value;
-         }
+         return parameter?.AsValueString() ?? string.Empty;
       }
 
-      private IFCAnyHandle DefaultProperty(IFCFile file)
+      private IFCAnyHandle CreateTextPropertyFromCombinedParameterData(IFCFile file, Element element)
       {
-         if (m_DefaultProperty == null)
+         string parameterString = string.Empty;
+         foreach (var parameterData in CombinedParameterData)
          {
-            if (m_DefaultValue != null)
-            {
-               switch (PropertyType)
-               {
-                  case PropertyType.Label:
-                     return m_DefaultProperty = PropertyUtil.CreateLabelProperty(file, PropertyName, m_DefaultValue.ValueString, PropertyValueType, PropertyEnumerationType);
-                  case PropertyType.Text:
-                     return m_DefaultProperty = PropertyUtil.CreateTextProperty(file, PropertyName, m_DefaultValue.ValueString, PropertyValueType);
-                  case PropertyType.Identifier:
-                     return m_DefaultProperty = PropertyUtil.CreateIdentifierProperty(file, PropertyName, m_DefaultValue.ValueString, PropertyValueType);
-                  //todo make this work for all values
-               }
-            }
+            parameterString += parameterData.Prefix;
+            parameterString += GetParameterValueById(element, parameterData.ParamId);
+            parameterString += (parameterData.Suffix + parameterData.Separator);
          }
-         return m_DefaultProperty;
+
+         return PropertyUtil.CreateTextPropertyFromCache(file, PropertyName, parameterString, PropertyValueType);
       }
 
       /// <summary>
@@ -410,16 +398,28 @@ private IFCAnyHandle DefaultProperty(IFCFile file)
       /// <param name="elementType">The element type of which this property is created for.</param>
       /// <param name="handle">The handle for which this property is created for.</param>
       /// <returns>The created property handle.</returns>
-      public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, string owningPsetName, IFCExtrusionCreationData extrusionCreationData, ElementOrConnector elementOrConnector,
+      public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, string owningPsetName, 
+         IFCExtrusionCreationData extrusionCreationData, ElementOrConnector elementOrConnector,
          ElementType elementType, IFCAnyHandle handle)
       {
-         foreach (PropertySetEntryMap map in m_Entries)
+         // if CombinedParameterData, then we have to recreate the parameter value, since there is no
+         // API for this.
+         if (CombinedParameterData != null)
          {
-            IFCAnyHandle propHnd = map.ProcessEntry(file, exporterIFC, owningPsetName, extrusionCreationData, elementOrConnector, elementType, handle, PropertyType, PropertyArgumentType, PropertyValueType, PropertyEnumerationType, PropertyName);
+            return CreateTextPropertyFromCombinedParameterData(file, elementOrConnector.Element);
+         }
+
+         // Otherwise, do standard processing.
+         foreach (PropertySetEntryMap map in Entries)
+         {
+            IFCAnyHandle propHnd = map.ProcessEntry(file, exporterIFC, owningPsetName,
+               extrusionCreationData, elementOrConnector, elementType, handle, PropertyType,
+               PropertyArgumentType, PropertyValueType, PropertyEnumerationType, PropertyName);
             if (propHnd != null)
                return propHnd;
          }
-         return DefaultProperty(file);
+
+         return SetDefaultProperty(file);
       }
 
       /// <summary>
@@ -623,6 +623,15 @@ public static PropertySetEntry CreateText(string revitParameterName)
          return pse;
       }
 
+      public static PropertySetEntry CreateParameterEntry(string propertyName, 
+         IList<TableCellCombinedParameterData> combinedParameterData)
+      {
+         PropertySetEntry pse = new PropertySetEntry(propertyName);
+         pse.PropertyType = PropertyType.Text;
+         pse.CombinedParameterData = combinedParameterData;
+         return pse;
+      }
+
       /// <summary>
       /// Creates an entry of type identifier.
       /// </summary>
@@ -959,6 +968,14 @@ public static PropertySetEntry CreateParameterEntry(Parameter parameter, BuiltIn
                   {
                      propertyType = PropertyType.Volume;
                   }
+                  else if (type == SpecTypeId.PipingMassPerTime)
+                  {
+                     propertyType = PropertyType.MassFlowRate;
+                  }
+                  else if (type == SpecTypeId.AngularSpeed)
+                  {
+                     propertyType = PropertyType.RotationalFrequency;
+                  }
                   else
                   {
                      assigned = false;
@@ -979,6 +996,7 @@ public static PropertySetEntry CreateParameterEntry(Parameter parameter, BuiltIn
                   break;
                }
          }
+
          return new PropertySetEntry(propertyType, parameterDefinition.Name, builtInParameter);
       }
    }
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntryMap.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntryMap.cs
index 3222a66b..88c6dbb4 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntryMap.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertySetEntryMap.cs
@@ -20,11 +20,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Export.Toolkit;
-using Revit.IFC.Common.Enums;
 using Revit.IFC.Common.Utility;
 using Revit.IFC.Export.Utility;
 
@@ -64,7 +62,7 @@ public PropertySetEntryMap(string revitParameterName, BuiltInParameter builtInPa
       /// </summary>
       /// <param name="file">The IFC file.</param>
       /// <param name="exporterIFC">The ExporterIFC object.</param>
-      /// <param name="owningPsetName">Name of Property Set this entry belongs to .</param>
+      /// <param name="owningPsetName">Name of Property Set this entry belongs to.</param>
       /// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
       /// <param name="elementOrConnector">The element or connector of which this property is created for.</param>
       /// <param name="elementType">The element type of which this property is created for.</param>
@@ -75,9 +73,11 @@ public PropertySetEntryMap(string revitParameterName, BuiltInParameter builtInPa
       /// <param name="propertyEnumerationType">The type of property.</param>
       /// <param name="propertyName">The name of property to create.</param>
       /// <returns>The created property handle.</returns>
-      public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, string owningPsetName, IFCExtrusionCreationData extrusionCreationData,
-         ElementOrConnector elementOrConnector, ElementType elementType, IFCAnyHandle handle, 
-         PropertyType propertyType, PropertyType propertyArgumentType, PropertyValueType valueType, Type propertyEnumerationType, string propertyName)
+      public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, string owningPsetName, 
+         IFCExtrusionCreationData extrusionCreationData, ElementOrConnector elementOrConnector, 
+         ElementType elementType, IFCAnyHandle handle, PropertyType propertyType, 
+         PropertyType propertyArgumentType, PropertyValueType valueType, Type propertyEnumerationType,
+         string propertyName)
       {
          IFCAnyHandle propHnd = null;
 
@@ -85,11 +85,15 @@ public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, string o
             return propHnd;
 
          // First try to create property from Element 
-         if (elementOrConnector.Element != null && ParameterNameIsValid)
+         if (elementOrConnector.Element != null)
          {
-            Element element = elementOrConnector.Element;
-            propHnd = CreatePropertyFromElementOrSymbol(file, exporterIFC, owningPsetName, element, elementType,
-                  propertyType, propertyArgumentType, valueType, propertyEnumerationType, propertyName);
+            if (ParameterNameIsValid)
+            {
+               Element element = elementOrConnector.Element;
+               propHnd = CreatePropertyFromElementOrSymbol(file, exporterIFC, owningPsetName, element,
+                  elementType, propertyType, propertyArgumentType, valueType, propertyEnumerationType,
+                  propertyName);
+            }
          }
 
          // If unsuccessful - from calculator (element) or description (connector)
@@ -110,19 +114,19 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
          {
             case PropertyType.Area:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsAreaMeasure(value);
                   break;
                }
             case PropertyType.AreaDensity:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsMeasure(value, "IfcAreaDensityMeasure");
                   break;
                }
             case PropertyType.Boolean:
                {
-                  if (Int32.TryParse(valueString, out int value))
+                  if (int.TryParse(valueString, out int value))
                      data = IFCDataUtil.CreateAsBoolean((value != 0));
                   break;
                }
@@ -132,19 +136,19 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
                }
             case PropertyType.ColorTemperature:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsMeasure(value, "IfcReal");
                   break;
                }
             case PropertyType.Count:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsCountMeasure(value);
                   break;
                }
             case PropertyType.Currency:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                   {
                      data = ExporterCacheManager.UnitsCache.ContainsKey("CURRENCY") ?
                         IFCDataUtil.CreateAsMeasure(value, "IfcMonetaryMeasure") : IFCDataUtil.CreateAsMeasure(value, "IfcReal");
@@ -153,13 +157,13 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
                }
             case PropertyType.ElectricalEfficacy:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsMeasure(value, "IfcReal");
                   break;
                }
             case PropertyType.ElectricCurrent:
                {
-                  if (Double.TryParse(valueString, out double value))
+                  if (double.TryParse(valueString, out double value))
                      data = IFCDataUtil.CreateAsElectricCurrentMeasure(value);
                   break;
                }
@@ -326,6 +330,12 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
                      data = IFCDataUtil.CreateAsMeasure(value, "IfcRotationalFrequencyMeasure");
                   break;
                }
+            case PropertyType.SoundPower:
+               {
+                  if (Double.TryParse(valueString, out double value))
+                     data = IFCDataUtil.CreateAsSoundPowerMeasure(value);
+                  break;
+               }
             case PropertyType.Text:
                {
                   data = IFCDataUtil.CreateAsText(valueString);
@@ -356,6 +366,12 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
                      data = IFCDataUtil.CreateAsMeasure(value, "IfcVolumetricFlowRateMeasure");
                   break;
                }
+            case PropertyType.Time:
+               {
+                  if (Double.TryParse(valueString, out double value))
+                     data = IFCDataUtil.CreateAsMeasure(value, "IfcTimeMeasure");
+                  break;
+               }
             // Known unhandled cases:
             case PropertyType.IfcCalendarDate:
             case PropertyType.IfcClassificationReference:
@@ -363,7 +379,6 @@ private static IFCData GetPropertyDataFromString(string valueString, PropertyTyp
             case PropertyType.IfcMaterial:
             case PropertyType.IfcOrganization:
             case PropertyType.Monetary:
-            case PropertyType.Time:
                return null;
             default:
                // Unexpected unhandled cases.
@@ -384,10 +399,10 @@ private static IFCAnyHandle CreatePropertyFromElementBase(IFCFile file, Exporter
             IList<IFCData> definingValues;
             IList<IFCData> definedValues;
 
-            CollectTableDataFromElement(file, exporterIFC, element, revitParamNameToUse, ifcPropertyName, builtInParameter, 
-               propertyType, propertyArgumentType, propertyEnumerationType, out definingValues, out definedValues);
+            CollectTableDataFromElement(element, revitParamNameToUse, builtInParameter, 
+               propertyType, propertyArgumentType, out definingValues, out definedValues);
 
-            if (definingValues.Count() != definedValues.Count() || definedValues.Count() < 1)
+            if (definingValues == null || definedValues == null || definingValues.Count() != definedValues.Count() || definedValues.Count() < 1)
                return propHnd;
 
             propHnd = PropertyUtil.CreateTableProperty(file, ifcPropertyName, definingValues, definedValues, null, null);
@@ -611,6 +626,12 @@ private static IFCAnyHandle CreatePropertyFromElementBase(IFCFile file, Exporter
                          ifcPropertyName, valueType);
                      break;
                   }
+               case PropertyType.SoundPower:
+                  {
+                     propHnd = PropertyUtil.CreateSoundPowerPropertyFromElement(file, exporterIFC, element, revitParamNameToUse,
+                         builtInParameter, ifcPropertyName, valueType);
+                     break;
+                  }
                case PropertyType.Text:
                   {
                      propHnd = PropertyUtil.CreateTextPropertyFromElement(file, element, revitParamNameToUse, builtInParameter, ifcPropertyName, valueType, propertyEnumerationType);
@@ -640,6 +661,12 @@ private static IFCAnyHandle CreatePropertyFromElementBase(IFCFile file, Exporter
                          builtInParameter, ifcPropertyName, valueType);
                      break;
                   }
+               case PropertyType.Time:
+                  {
+                     propHnd = PropertyUtil.CreateTimePropertyFromElement(file, exporterIFC, element, revitParamNameToUse,
+                         builtInParameter, ifcPropertyName, valueType);
+                     break;
+                  }
                // Known unhandled cases:
                case PropertyType.IfcCalendarDate:
                case PropertyType.IfcClassificationReference:
@@ -647,7 +674,6 @@ private static IFCAnyHandle CreatePropertyFromElementBase(IFCFile file, Exporter
                case PropertyType.IfcMaterial:
                case PropertyType.IfcOrganization:
                case PropertyType.Monetary:
-               case PropertyType.Time:
                   return null;
                default:
                   // Unexpected unhandled cases.
@@ -658,9 +684,9 @@ private static IFCAnyHandle CreatePropertyFromElementBase(IFCFile file, Exporter
          return propHnd;
       }
 
-      private static bool CollectTableDataFromElement(IFCFile file, ExporterIFC exporterIFC, Element element, string revitParamNameToUse, 
-         string ifcPropertyName, BuiltInParameter builtInParameter, PropertyType propertyType, PropertyType propertyArgumentType,
-         Type propertyEnumerationType, out IList<IFCData> definingValues, out IList<IFCData> definedValues)
+      private static bool CollectTableDataFromElement(Element element, string revitParamNameToUse, 
+         BuiltInParameter builtInParameter, PropertyType propertyType, PropertyType propertyArgumentType,
+         out IList<IFCData> definingValues, out IList<IFCData> definedValues)
       {
          definingValues = null;
          definedValues = null;
@@ -683,7 +709,7 @@ private static bool CollectTableDataFromElement(IFCFile file, ExporterIFC export
          string[] tableRaws = tableString.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);         
          foreach (string raw in tableRaws)
          {
-            string[] splitRaw = raw.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+            string[] splitRaw = raw.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
             if (splitRaw.Count() == 2)
                parsedTable.Add(new Tuple<string, string>(splitRaw[0], splitRaw[1]));
          }
@@ -726,13 +752,13 @@ IFCAnyHandle CreatePropertyFromElementOrSymbol(IFCFile file, ExporterIFC exporte
          IFCAnyHandle propHnd = null;
          if (localizedRevitParameterName != null)
          {
-            propHnd = PropertySetEntryMap.CreatePropertyFromElementBase(file, exporterIFC, element,
+            propHnd = CreatePropertyFromElementBase(file, exporterIFC, element,
                  localizedRevitParameterName, propertyName, BuiltInParameter.INVALID,
                  propertyType, propertyArgumentType, valueType, propertyEnumerationType);
             if (IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd) && (element is ElementType || element is FamilySymbol))
             {
-               localizedRevitParameterName = localizedRevitParameterName + "[Type]";
-               propHnd = PropertySetEntryMap.CreatePropertyFromElementBase(file, exporterIFC, element,
+               localizedRevitParameterName += "[Type]";
+               propHnd = CreatePropertyFromElementBase(file, exporterIFC, element,
                  localizedRevitParameterName, propertyName, BuiltInParameter.INVALID,
                  propertyType, propertyArgumentType, valueType, propertyEnumerationType);
             }
@@ -740,22 +766,24 @@ IFCAnyHandle CreatePropertyFromElementOrSymbol(IFCFile file, ExporterIFC exporte
 
          if (IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd))
          {
-            propHnd = PropertySetEntryMap.CreatePropertyFromElementBase(file, exporterIFC, element,
+            propHnd = CreatePropertyFromElementBase(file, exporterIFC, element,
                  revitParameterName, propertyName, RevitBuiltInParameter,
                  propertyType, propertyArgumentType, valueType, propertyEnumerationType);
             if (IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd) && (element is ElementType || element is FamilySymbol))
             {
-               revitParameterName = revitParameterName + "[Type]";
-               propHnd = PropertySetEntryMap.CreatePropertyFromElementBase(file, exporterIFC, element,
+               revitParameterName += "[Type]";
+               propHnd = CreatePropertyFromElementBase(file, exporterIFC, element,
                  revitParameterName, propertyName, RevitBuiltInParameter,
                  propertyType, propertyArgumentType, valueType, propertyEnumerationType);
             }
-            //When querying values from ProjectInfo we need to try alternative parameter names too.
+            //When querying values from ProjectInfo (or when the name exists in different psets)
+            //we need to try alternative parameter names too.
             //These names are constructed as shown below.
-            if (IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd) && (element is ProjectInfo))
+            bool isOverlappingName = (propertyName == "NominalCapacity") ? true : false;
+            if (IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd) && (element is ProjectInfo || isOverlappingName))
             {
-               revitParameterName = owningPsetName + "." + revitParameterName;
-               propHnd = PropertySetEntryMap.CreatePropertyFromElementBase(file, exporterIFC, element,
+               revitParameterName = owningPsetName + "." + RevitParameterName;
+               propHnd = CreatePropertyFromElementBase(file, exporterIFC, element,
                  revitParameterName, propertyName, RevitBuiltInParameter,
                  propertyType, propertyArgumentType, valueType, propertyEnumerationType);
             }
@@ -846,7 +874,7 @@ IFCAnyHandle CreatePropertyFromCalculator(IFCFile file, PropertyType propertyTyp
                   }
                   else
                   {
-                     bool cacheLabel = (useCalculator) ? PropertyCalculator.CacheStringValues : false;
+                     bool cacheLabel = useCalculator && PropertyCalculator.CacheStringValues;
                      string val = (useCalculator) ? PropertyCalculator.GetStringValue() : propertyValue;
                      propHnd = PropertyUtil.CreateLabelPropertyFromCache(file, null, propertyName, val, valueType, cacheLabel, propertyEnumerationType);
                   }
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertyUtil.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertyUtil.cs
index 33a7a0ab..33c09c6e 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/PropertyUtil.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/PropertyUtil.cs
@@ -198,7 +198,7 @@ public static IFCAnyHandle CreateTextProperty(IFCFile file, string propertyName,
       /// <returns>The created property handle.</returns>
       public static IFCAnyHandle CreateTextPropertyFromCache(IFCFile file, string propertyName, string value, PropertyValueType valueType)
       {
-         bool canCache = (value == String.Empty);
+         bool canCache = (value == string.Empty);
          StringPropertyInfoCache stringInfoCache = null;
          IFCAnyHandle textHandle = null;
 
@@ -770,6 +770,20 @@ public static IFCAnyHandle CreateVolumeMeasureProperty(IFCFile file, string prop
          return CreateCommonProperty(file, propertyName, volumeData, valueType, null);
       }
 
+      /// <summary>
+      /// Creates a sound power measure property.
+      /// </summary>
+      /// <param name="file">The IFC file.</param>
+      /// <param name="propertyName">The name of the property.</param>
+      /// <param name="value">The value of the property.</param>
+      /// <param name="valueType">The value type of the property.</param>
+      /// <returns>The created property handle.</returns>
+      public static IFCAnyHandle CreateSoundPowerMeasureProperty(IFCFile file, string propertyName, double value, PropertyValueType valueType)
+      {
+         IFCData soundPowerData = IFCDataUtil.CreateAsSoundPowerMeasure(value);
+         return CreateCommonProperty(file, propertyName, soundPowerData, valueType, null);
+      }
+
       /// <summary>
       /// Create a positive length measure property.
       /// </summary>
@@ -1176,6 +1190,45 @@ public static IFCAnyHandle CreateVolumetricFlowRatePropertyFromElement(IFCFile f
              "IfcVolumetricFlowRateMeasure", SpecTypeId.AirFlow, valueType);
       }
 
+      /// <summary>
+      /// Create a Time measure property from the element's parameter.
+      /// </summary>
+      /// <param name="file">The IFC file.</param>
+      /// <param name="exporterIFC">The ExporterIFC.</param>
+      /// <param name="elem">The Element.</param>
+      /// <param name="revitParameterName">The name of the parameter.</param>
+      /// <param name="ifcPropertyName">The name of the property.</param>
+      /// <param name="valueType">The value type of the property.</param>
+      /// <returns>The created property handle.</returns>
+      public static IFCAnyHandle CreateTimePropertyFromElement(IFCFile file, ExporterIFC exporterIFC, Element elem,
+          string revitParameterName, string ifcPropertyName, PropertyValueType valueType)
+      {
+          return CreateDoublePropertyFromElement(file, exporterIFC, elem, revitParameterName, ifcPropertyName,
+          "IfcTimeMeasure", SpecTypeId.Time, valueType);
+      }
+
+      /// <summary>
+      /// Create a Sound power measure property from the element's parameter.
+      /// </summary>
+      /// <param name="file">The IFC file.</param>
+      /// <param name="exporterIFC">The ExporterIFC.</param>
+      /// <param name="elem">The Element.</param>
+      /// <param name="revitParameterName">The name of the parameter.</param>
+      /// <param name="ifcPropertyName">The name of the property.</param>
+      /// <param name="valueType">The value type of the property.</param>
+      /// <returns>The created property handle.</returns>
+      public static IFCAnyHandle CreateSoundPowerPropertyFromElement(IFCFile file, ExporterIFC exporterIFC, Element elem,
+          string revitParameterName, string ifcPropertyName, PropertyValueType valueType)
+      {
+         double propertyValue;
+         if (ParameterUtil.GetDoubleValueFromElement(elem, null, revitParameterName, out propertyValue) != null)
+         {
+            propertyValue = UnitUtil.ScaleSoundPower(propertyValue);
+            return CreateSoundPowerMeasureProperty(file, ifcPropertyName, propertyValue, valueType);
+         }
+         return null;
+      }
+
       /// <summary>
       /// Create a Color Temperature measure property from the element's parameter.  This will be an IfcReal with a custom unit.
       /// </summary>
@@ -1424,6 +1477,64 @@ public static IFCAnyHandle CreateVolumetricFlowRatePropertyFromElement(IFCFile f
          return null;
       }
 
+      /// <summary>
+      /// Create a Time property from the element's parameter.
+      /// </summary>
+      /// <param name="file">The IFC file.</param>
+      /// <param name="exporterIFC">The ExporterIFC.</param>
+      /// <param name="elem">The Element.</param>
+      /// <param name="revitParameterName">The name of the parameter.</param>
+      /// <param name="revitBuiltInParam">The built in parameter to use, if revitParameterName isn't found.</param>
+      /// <param name="ifcPropertyName">The name of the property.</param>
+      /// <param name="valueType">The value type of the property.</param>
+      /// <returns>The created property handle.</returns>
+      public static IFCAnyHandle CreateTimePropertyFromElement(IFCFile file, ExporterIFC exporterIFC, Element elem,
+          string revitParameterName, BuiltInParameter revitBuiltInParam, string ifcPropertyName, PropertyValueType valueType)
+      {
+         IFCAnyHandle propHnd = CreateTimePropertyFromElement(file, exporterIFC, elem, revitParameterName, ifcPropertyName, valueType);
+         if (!IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd))
+            return propHnd;
+
+         if (revitBuiltInParam != BuiltInParameter.INVALID)
+         {
+            string builtInParamName = LabelUtils.GetLabelFor(revitBuiltInParam);
+            propHnd = CreateTimePropertyFromElement(file, exporterIFC, elem, builtInParamName, ifcPropertyName, valueType);
+            if (!IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd))
+               return propHnd;
+         }
+
+         return null;
+      }
+
+      /// <summary>
+      /// Create a Sound power property from the element's parameter.
+      /// </summary>
+      /// <param name="file">The IFC file.</param>
+      /// <param name="exporterIFC">The ExporterIFC.</param>
+      /// <param name="elem">The Element.</param>
+      /// <param name="revitParameterName">The name of the parameter.</param>
+      /// <param name="revitBuiltInParam">The built in parameter to use, if revitParameterName isn't found.</param>
+      /// <param name="ifcPropertyName">The name of the property.</param>
+      /// <param name="valueType">The value type of the property.</param>
+      /// <returns>The created property handle.</returns>
+      public static IFCAnyHandle CreateSoundPowerPropertyFromElement(IFCFile file, ExporterIFC exporterIFC, Element elem,
+          string revitParameterName, BuiltInParameter revitBuiltInParam, string ifcPropertyName, PropertyValueType valueType)
+      {
+         IFCAnyHandle propHnd = CreateSoundPowerPropertyFromElement(file, exporterIFC, elem, revitParameterName, ifcPropertyName, valueType);
+         if (!IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd))
+            return propHnd; 
+
+         if (revitBuiltInParam != BuiltInParameter.INVALID)
+         {
+            string builtInParamName = LabelUtils.GetLabelFor(revitBuiltInParam);
+            propHnd = CreateSoundPowerPropertyFromElement(file, exporterIFC, elem, builtInParamName, ifcPropertyName, valueType);
+            if (!IFCAnyHandleUtil.IsNullOrHasNoValue(propHnd))
+               return propHnd;
+         }
+
+         return null;
+      }
+
       /// <summary>
       /// Create an IfcClassificationReference property from the element's parameter.
       /// </summary>
@@ -2859,10 +2970,8 @@ public static void CreatePreCOBIEGSAQuantities(ExporterIFC exporterIFC, IFCAnyHa
          IFCAnyHandle areaQuantityHnd = IFCInstanceExporter.CreateQuantityArea(file, quantityName, null, null, area);
          HashSet<IFCAnyHandle> areaQuantityHnds = new HashSet<IFCAnyHandle>();
          areaQuantityHnds.Add(areaQuantityHnd);
-         IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, quantityName, null, areaName, areaQuantityHnds);
-         HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
-         relatedObjects.Add(elemHnd);
-         ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
+
+         PropertyUtil.CreateAndRelateBaseQuantities(file, exporterIFC, elemHnd, areaQuantityHnds, quantityName, null, areaName);
       }
 
       /// <summary>
@@ -3045,17 +3154,23 @@ public static void CreateWallBaseQuantities(ExporterIFC exporterIFC, Wall wallEl
       /// <param name="exporterIFC">The exporter.</param>
       /// <param name="elemHnd">The element handle.</param>
       /// <param name="quantityHnds">The quantity handles.</param>
-      static public void CreateAndRelateBaseQuantities(IFCFile file, ExporterIFC exporterIFC, IFCAnyHandle elemHnd, HashSet<IFCAnyHandle> quantityHnds, string quantitySetName = null)
+      static public void CreateAndRelateBaseQuantities(IFCFile file, ExporterIFC exporterIFC, IFCAnyHandle elemHnd, HashSet<IFCAnyHandle> quantityHnds, 
+         string quantitySetName = null, string description = null, string methodOfMeasurement = null)
       {
          if (quantityHnds.Count > 0)
          {
             if (string.IsNullOrEmpty(quantitySetName))
                quantitySetName = "BaseQuantities";
             IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
-            IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, quantitySetName, null, null, quantityHnds);
-            HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
-            relatedObjects.Add(elemHnd);
-            ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
+
+            // Skip if the elementHandle has the associated QuantitySet has been created before 
+            if (!ExporterCacheManager.QtoSetCreated.Contains((elemHnd, quantitySetName)))
+            {
+               IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, elemHnd, GUIDUtil.CreateGUID(), ownerHistory, quantitySetName, description, methodOfMeasurement, quantityHnds);
+               HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
+               relatedObjects.Add(elemHnd);
+               ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
+            }
          }
       }
 
@@ -3073,36 +3188,6 @@ public static void CreateBeamColumnMemberBaseQuantities(ExporterIFC exporterIFC,
          CreateBeamColumnBaseQuantities(exporterIFC, elemHandle, element, ifcTypeInfo, null);
       }
 
-      /// <summary>
-      /// Returns a string value corresponding to an ElementId Parameter.
-      /// </summary>
-      /// <param name="parameter">The parameter.</param>
-      /// <returns>The string.</returns>
-      public static string ElementIdParameterAsString(Parameter parameter)
-      {
-         ElementId value = parameter.AsElementId();
-         if (value == ElementId.InvalidElementId)
-            return null;
-
-         string valueString = null;
-         // All real elements in Revit have non-negative ids.
-         if (value.IntegerValue >= 0)
-         {
-            // Get the family and element name.
-            Element paramElement = ExporterCacheManager.Document.GetElement(value);
-            valueString = (paramElement != null) ? paramElement.Name : null;
-         }
-         else
-         {
-            valueString = parameter.AsValueString();
-         }
-
-         if (string.IsNullOrEmpty(valueString))
-            valueString = value.ToString();
-
-         return valueString;
-      }
-
       /// <summary>
       /// Creates property sets for Revit groups and parameters, if export options is set.
       /// </summary>
@@ -3422,6 +3507,20 @@ public static void CreateInternalRevitPropertySets(ExporterIFC exporterIFC, Elem
                               propertyHandle = CreateVolumeMeasureProperty(file, parameterCaption,
                                     scaledValue, PropertyValueType.SingleValue);
                            }
+                           else if (type == SpecTypeId.PipingMassPerTime)
+                           {
+                              double scaledValue = UnitUtil.ScaleDouble(SpecTypeId.PipingMassPerTime, value);
+                              IFCData massFlowRateData = IFCDataUtil.CreateAsMeasure(scaledValue, "IfcMassFlowRateMeasure");
+                              propertyHandle = CreateCommonProperty(file, parameterCaption, massFlowRateData,
+                                    PropertyValueType.SingleValue, null);
+                           }
+                           else if (type == SpecTypeId.AngularSpeed)
+                           {
+                              double scaledValue = UnitUtil.ScaleDouble(SpecTypeId.AngularSpeed, value);
+                              IFCData rotationalFrequencyData = IFCDataUtil.CreateAsMeasure(scaledValue, "IfcRotationalFrequencyMeasure");
+                              propertyHandle = CreateCommonProperty(file, parameterCaption, rotationalFrequencyData,
+                                    PropertyValueType.SingleValue, null);
+                           }
                            else
                            {
                               double scaledValue = value;
@@ -3444,18 +3543,16 @@ public static void CreateInternalRevitPropertySets(ExporterIFC exporterIFC, Elem
                      case StorageType.String:
                         {
                            string value = parameter.AsString();
-
                            currPropertiesForGroup.Add(CreateTextPropertyFromCache(file, parameterCaption, value, PropertyValueType.SingleValue));
                            break;
                         }
                      case StorageType.ElementId:
                         {
-                           ElementId value = parameter.AsElementId();
-                           if (value == ElementId.InvalidElementId)
-                              continue;
-
-                           string valueString = ElementIdParameterAsString(parameter);
-                           currPropertiesForGroup.Add(CreateLabelPropertyFromCache(file, parameter.Id, parameterCaption, valueString, PropertyValueType.SingleValue, true, null));
+                           if (parameter.AsElementId() != ElementId.InvalidElementId)
+                           {
+                              string valueString = parameter.AsValueString();
+                              currPropertiesForGroup.Add(CreateLabelPropertyFromCache(file, parameter.Id, parameterCaption, valueString, PropertyValueType.SingleValue, true, null));
+                           }
                            break;
                         }
                   }
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntry.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntry.cs
index 3a79ca1d..b5812ec0 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntry.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntry.cs
@@ -36,6 +36,7 @@ public enum QuantityType
       /// <summary>
       /// A length quantity.
       /// </summary>
+      Length,
       PositiveLength,
       /// <summary>
       /// An area quantity.
@@ -48,7 +49,15 @@ public enum QuantityType
       /// <summary>
       /// A Weight quantity
       /// </summary>
-      Weight
+      Weight,
+      /// <summary>
+      /// A Count quantity
+      /// </summary>
+      Count,
+      /// <summary>
+      /// A time duration quantity
+      /// </summary>
+      Time
    }
 
    /// <summary>
@@ -121,7 +130,7 @@ public QuantityEntry(string propertyName, IEnumerable<QuantityEntryMap> entries)
       public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC,
          IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
       {
-         foreach (QuantityEntryMap entry in m_Entries)
+         foreach (QuantityEntryMap entry in Entries)
          {
             IFCAnyHandle result = entry.ProcessEntry(file, exporterIFC, extrusionCreationData, element, 
                elementType, this);
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntryMap.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntryMap.cs
index d0520ea8..0f828c08 100644
--- a/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntryMap.cs
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/QuantityEntryMap.cs
@@ -80,25 +80,47 @@ public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, IFCExtru
          bool useProperty = (!String.IsNullOrEmpty(RevitParameterName)) || (RevitBuiltInParameter != BuiltInParameter.INVALID);
          
          bool success = false;
-         double val = 0;
+         object val = 0;
          if (useProperty)
          {
-            success = (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, RevitParameterName, parentEntry.IgnoreInternalValue, out val) != null);
-            if (!success && RevitBuiltInParameter != BuiltInParameter.INVALID)
-               success = (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, RevitBuiltInParameter, out val) != null);
+            double dblVal = 0.0;
+
+            if (parentEntry.QuantityType is QuantityType.Count)
+            {
+               int? intValPar = null;
+               intValPar = (ParameterUtil.GetIntValueFromElementOrSymbol(element, RevitParameterName));
+               if (intValPar.HasValue)
+               {
+                  success = true;
+                  val = intValPar.Value;
+               }
+            }
+            else
+            {
+               success = (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, RevitParameterName, parentEntry.IgnoreInternalValue, out dblVal) != null);
+               if (!success && RevitBuiltInParameter != BuiltInParameter.INVALID)
+                  success = (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, RevitBuiltInParameter, out dblVal) != null);
+               if (success)
+                  val = dblVal;
+            }
 
             if (success) // factor in the scale factor for all the parameters depending of the data type to get the correct value
             {
                switch (parentEntry.QuantityType)
                {
                   case QuantityType.PositiveLength:
-                     val = UnitUtil.ScaleLength(val);
+                  case QuantityType.Length:
+                     val = UnitUtil.ScaleLength((double)val);
                      break;
                   case QuantityType.Area:
-                     val = UnitUtil.ScaleArea(val);
+                     val = UnitUtil.ScaleArea((double)val);
                      break;
                   case QuantityType.Volume:
-                     val = UnitUtil.ScaleVolume(val);
+                     val = UnitUtil.ScaleVolume((double)val);
+                     break;
+                  case QuantityType.Count:
+                     break;
+                  case QuantityType.Time:
                      break;
                   default:
                      break;
@@ -109,7 +131,9 @@ public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, IFCExtru
          if (PropertyCalculator != null && !success)
          {
             success = PropertyCalculator.Calculate(exporterIFC, extrusionCreationData, element, elementType);
-            if (success)
+            if (success && parentEntry.QuantityType == QuantityType.Count)
+               val = PropertyCalculator.GetIntValue();
+            else
                val = PropertyCalculator.GetDoubleValue();
          }
 
@@ -119,16 +143,23 @@ public IFCAnyHandle ProcessEntry(IFCFile file, ExporterIFC exporterIFC, IFCExtru
             switch (parentEntry.QuantityType)
             {
                case QuantityType.PositiveLength:
-                  quantityHnd = IFCInstanceExporter.CreateQuantityLength(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, val);
+               case QuantityType.Length:
+                  quantityHnd = IFCInstanceExporter.CreateQuantityLength(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (double)val);
                   break;
                case QuantityType.Area:
-                  quantityHnd = IFCInstanceExporter.CreateQuantityArea(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, val);
+                  quantityHnd = IFCInstanceExporter.CreateQuantityArea(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (double)val);
                   break;
                case QuantityType.Volume:
-                  quantityHnd = IFCInstanceExporter.CreateQuantityVolume(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, val);
+                  quantityHnd = IFCInstanceExporter.CreateQuantityVolume(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (double)val);
                   break;
                case QuantityType.Weight:
-                  quantityHnd = IFCInstanceExporter.CreateQuantityWeight(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, val);
+                  quantityHnd = IFCInstanceExporter.CreateQuantityWeight(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (double)val);
+                  break;
+               case QuantityType.Count:
+                  quantityHnd = IFCInstanceExporter.CreateQuantityCount(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (int)val);
+                  break;
+               case QuantityType.Time:
+                  quantityHnd = IFCInstanceExporter.CreateQuantityTime(file, parentEntry.PropertyName, parentEntry.MethodOfMeasurement, null, (double)val);
                   break;
                default:
                   throw new InvalidOperationException("Missing case!");
diff --git a/Source/Revit.IFC.Export/Exporter/RampExporter.cs b/Source/Revit.IFC.Export/Exporter/RampExporter.cs
index 21dda20a..d9116248 100644
--- a/Source/Revit.IFC.Export/Exporter/RampExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/RampExporter.cs
@@ -25,6 +25,7 @@
 using Revit.IFC.Common.Utility;
 using Revit.IFC.Export.Utility;
 using Revit.IFC.Export.Toolkit;
+using Revit.IFC.Export.Exporter.PropertySet;
 
 namespace Revit.IFC.Export.Exporter
 {
@@ -986,16 +987,7 @@ private static void CreateQuantitySetRampFlight(ExporterIFC exporterIFC, IFCFile
             quantitySetName = "Qto_RampFlightBaseQuantities";
          }
 
-         if (quantityHnds.Count > 0)
-         {
-            if (string.IsNullOrEmpty(quantitySetName))
-               quantitySetName = "BaseQuantities";
-            IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
-            IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, quantitySetName, null, null, quantityHnds);
-            HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
-            relatedObjects.Add(rampFlightHnd);
-            ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
-         }
+         PropertyUtil.CreateAndRelateBaseQuantities(file, exporterIFC, rampFlightHnd, quantityHnds, quantitySetName);
       }
 
       private static void CreateQuantitySetLanding(ExporterIFC exporterIFC, IFCFile file, IFCAnyHandle rampLandingHnd, Element element, (Solid body, Face topFace) geometry, int flightIndex)
@@ -1094,16 +1086,7 @@ private static void CreateQuantitySetLanding(ExporterIFC exporterIFC, IFCFile fi
             quantitySetName = "Qto_SlabBaseQuantities";
          }
 
-         if (quantityHnds.Count > 0)
-         {
-            if (string.IsNullOrEmpty(quantitySetName))
-               quantitySetName = "BaseQuantities";
-            IFCAnyHandle ownerHistory = ExporterCacheManager.OwnerHistoryHandle;
-            IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, quantitySetName, null, null, quantityHnds);
-            HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
-            relatedObjects.Add(rampLandingHnd);
-            ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
-         }
+         PropertyUtil.CreateAndRelateBaseQuantities(file, exporterIFC, rampLandingHnd, quantityHnds, quantitySetName);
       }
 
    }
diff --git a/Source/Revit.IFC.Export/Exporter/SiteExporter.cs b/Source/Revit.IFC.Export/Exporter/SiteExporter.cs
index 15eb6540..8ae1ce9d 100644
--- a/Source/Revit.IFC.Export/Exporter/SiteExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/SiteExporter.cs
@@ -201,8 +201,6 @@ private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, E
             }
 
             // Get elevation for site.
-            double elevation = UnitUtil.ScaleLength(unscaledElevation);
-
             IFCAnyHandle relativePlacement = null;
             IFCAnyHandle localPlacement = null;
             if (ExporterCacheManager.ExportOptionsCache.ExportingLink)
@@ -212,7 +210,9 @@ private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, E
             }
             else
             {
-               Transform wcs = GeometryUtil.GetWCS(doc);
+               if (ExporterCacheManager.ExportOptionsCache.IncludeSiteElevation)
+                  unscaledElevation = 0.0;
+               Transform wcs = GeometryUtil.GetWCS(doc, unscaledElevation);
                if (wcs != null && !wcs.IsIdentity)
                {
                   relativePlacement = ExporterUtil.CreateAxis2Placement3D(file, wcs.Origin, wcs.BasisZ, wcs.BasisX);
@@ -296,6 +296,8 @@ private static void ExportSiteBase(ExporterIFC exporterIFC, Document document, E
                if (Exporter.NeedToCreateAddressForSite(doc))
                   address = Exporter.CreateIFCAddress(file, doc, projectInfo);
 
+               double elevation = UnitUtil.ScaleLength(unscaledElevation);
+
                siteHandle = IFCInstanceExporter.CreateSite(exporterIFC, element, siteGUID, ownerHistory, siteName, siteDescription, siteObjectType, localPlacement,
                   siteRepresentation, siteLongName, IFCElementComposition.Element, latitude, longitude, elevation, siteLandTitleNumber, address);
                productWrapper.AddSite(mainSiteElement, siteHandle);
diff --git a/Source/Revit.IFC.Export/Exporter/SpatialElementExporter.cs b/Source/Revit.IFC.Export/Exporter/SpatialElementExporter.cs
index e88c4dcb..37442b60 100644
--- a/Source/Revit.IFC.Export/Exporter/SpatialElementExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/SpatialElementExporter.cs
@@ -50,7 +50,7 @@ class SpatialElementExporter
       /// <param name="exporterIFC">
       /// The ExporterIFC object.
       /// </param>
-      public static void InitializeSpatialElementGeometryCalculator(Document document, ExporterIFC exporterIFC)
+      public static void InitializeSpatialElementGeometryCalculator(Document document)
       {
          SpatialElementBoundaryOptions options = GetSpatialElementBoundaryOptions(null);
          s_SpatialElementGeometryCalculator = new SpatialElementGeometryCalculator(document, options);
@@ -336,7 +336,7 @@ public static void ExportSpatialElement(ExporterIFC exporterIFC, SpatialElement
                }
 
                CreateZoneInfos(exporterIFC, file, spatialElement, productWrapper);
-               CreateSpaceOccupantInfo(exporterIFC, file, spatialElement, productWrapper);
+               CreateSpaceOccupantInfo(file, spatialElement, productWrapper);
             }
             transaction.Commit();
          }
@@ -440,7 +440,7 @@ public static ISet<ElementId> ExportSpatialElement2ndLevel(Revit.IFC.Export.Expo
                                  }
                               }
                               CreateZoneInfos(exporterIFC, file, spatialElement, productWrapper);
-                              CreateSpaceOccupantInfo(exporterIFC, file, spatialElement, productWrapper);
+                              CreateSpaceOccupantInfo(file, spatialElement, productWrapper);
 
                               ExporterUtil.ExportRelatedProperties(exporterIFC, spatialElement, productWrapper);
                            }
@@ -448,7 +448,7 @@ public static ISet<ElementId> ExportSpatialElement2ndLevel(Revit.IFC.Export.Expo
                      }
                      catch (Exception ex)
                      {
-                        ifcExporter.HandleUnexpectedException(ex, exporterIFC, spatialElement);
+                        ifcExporter.HandleUnexpectedException(ex, spatialElement);
                      }
                      finally
                      {
@@ -776,7 +776,7 @@ public static bool ProcessIFCSpaceBoundary(ExporterIFC exporterIFC, SpaceBoundar
       /// <param name="spaceHnd">The space handle.</param>
       /// <param name="projectInfo">The project info.</param>
       /// <param name="spatialElement">The spatial element.</param>
-      private static void CreateCOBIESpaceClassifications(ExporterIFC exporterIFC, IFCFile file, IFCAnyHandle spaceHnd,
+      private static void CreateCOBIESpaceClassifications(IFCFile file, IFCAnyHandle spaceHnd,
           ProjectInfo projectInfo, SpatialElement spatialElement)
       {
          HashSet<IFCAnyHandle> spaceHnds = new HashSet<IFCAnyHandle>();
@@ -866,34 +866,32 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
          if (spatialElement.Location == null)
             return false;
 
-         SpatialElementBoundaryOptions options = GetSpatialElementBoundaryOptions(spatialElement);
          IList<CurveLoop> curveLoops = null;
+         GeometryElement geomElem = null;
 
-         try
-         {
-            curveLoops = ExporterIFCUtils.GetRoomBoundaryAsCurveLoopArray(spatialElement, options, true);
-            if (curveLoops == null || curveLoops.Count == 0)
-               return false;
-         }
-         catch
+         Area spatialElementAsArea = spatialElement as Area;
+
+         if (!ExporterCacheManager.ExportOptionsCache.Use2DRoomBoundaryForRoomVolumeCreation)
          {
-            return false;
+            geomElem = (spatialElement as Autodesk.Revit.DB.Architecture.Room)?.ClosedShell;
+            if (geomElem == null)
+            {
+               geomElem = (spatialElement as Autodesk.Revit.DB.Mechanical.Space)?.ClosedShell;
+               if (geomElem == null && spatialElementAsArea != null)
+               {
+                  Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
+                  geomElem = spatialElementAsArea.get_Geometry(geomOptions);
+               }
+            }
          }
 
-         double dArea = 0.0;
-         if (ParameterUtil.GetDoubleValueFromElement(spatialElement, BuiltInParameter.ROOM_AREA, out dArea) != null)
-            dArea = UnitUtil.ScaleArea(dArea);
-
-         ElementId levelId = spatialElement.LevelId;
-         IFCLevelInfo levelInfo = exporterIFC.GetLevelInfo(levelId);
-
-         IFCFile file = exporterIFC.GetFile();
-         IFCAnyHandle localPlacement = setter.LocalPlacement;
-
          // If the override container paramater is detected, the LevelInfo and LocalPlacement will be overriden
          IFCAnyHandle overrideContainer;
          ElementId overrideContainerId = ParameterUtil.OverrideContainmentParameter(exporterIFC, spatialElement, out overrideContainer);
 
+         ElementId levelId = spatialElement.LevelId;
+         IFCLevelInfo levelInfo = exporterIFC.GetLevelInfo(levelId);
+
          if (!IFCAnyHandleUtil.IsNullOrHasNoValue(overrideContainer))
          {
             if (overrideContainerId != ElementId.InvalidElementId)
@@ -907,40 +905,18 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
             }
          }
 
-         Autodesk.Revit.DB.Document document = spatialElement.Document;
-         ElementType elemType = document.GetElement(spatialElement.GetTypeId()) as ElementType;
-         IFCInternalOrExternal internalOrExternal = CategoryUtil.IsElementExternal(spatialElement) ? IFCInternalOrExternal.External : IFCInternalOrExternal.Internal;
-
          double scaledRoomHeight = GetScaledHeight(spatialElement, levelId, levelInfo);
          if (scaledRoomHeight <= 0.0)
             return false;
 
-         double bottomOffset;
-         ParameterUtil.GetDoubleValueFromElement(spatialElement, BuiltInParameter.ROOM_LOWER_OFFSET, out bottomOffset);
-
-         GeometryElement geomElem = null;
-         bool isArea = (spatialElement is Area);
-         Area spatialElementAsArea = isArea ? (spatialElement as Area) : null;
-
-         if (spatialElement is Autodesk.Revit.DB.Architecture.Room)
-         {
-            Autodesk.Revit.DB.Architecture.Room room = spatialElement as Autodesk.Revit.DB.Architecture.Room;
-            geomElem = room.ClosedShell;
-         }
-         else if (spatialElement is Autodesk.Revit.DB.Mechanical.Space)
-         {
-            Autodesk.Revit.DB.Mechanical.Space space = spatialElement as Autodesk.Revit.DB.Mechanical.Space;
-            geomElem = space.ClosedShell;
-         }
-         else if (isArea)
-         {
-            Options geomOptions = GeometryUtil.GetIFCExportGeometryOptions();
-            geomElem = spatialElementAsArea.get_Geometry(geomOptions);
-         }
+         double dArea = 0.0;  // Will be calculated later.
+         IFCFile file = exporterIFC.GetFile();
 
          IFCAnyHandle spaceHnd = null;
          using (IFCExtrusionCreationData extraParams = new IFCExtrusionCreationData())
          {
+            IFCAnyHandle localPlacement = setter.LocalPlacement;
+
             extraParams.SetLocalPlacement(localPlacement);
             extraParams.PossibleExtrusionAxes = IFCExtrusionAxes.TryZ;
 
@@ -949,16 +925,36 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
                ElementId catId = spatialElement.Category != null ? spatialElement.Category.Id : ElementId.InvalidElementId;
 
                IFCAnyHandle repHnd = null;
-               if (!ExporterCacheManager.ExportOptionsCache.Use2DRoomBoundaryForRoomVolumeCreation && geomElem != null)
+               if (geomElem != null)
                {
                   BodyExporterOptions bodyExporterOptions = new BodyExporterOptions(true, ExportOptionsCache.ExportTessellationLevel.Medium);
                   repHnd = RepresentationUtil.CreateAppropriateProductDefinitionShape(exporterIFC, spatialElement,
                       catId, geomElem, bodyExporterOptions, null, extraParams, false);
                   if (IFCAnyHandleUtil.IsNullOrHasNoValue(repHnd))
+                  {
+                     repHnd = null;
                      extraParams.ClearOpenings();
+                  }
                }
-               else
+
+               if (repHnd == null)
                {
+                  SpatialElementBoundaryOptions options = GetSpatialElementBoundaryOptions(spatialElement);
+
+                  try
+                  {
+                     curveLoops = ExporterIFCUtils.GetRoomBoundaryAsCurveLoopArray(spatialElement, options, true);
+                     if (curveLoops == null || curveLoops.Count == 0)
+                        return false;
+                  }
+                  catch
+                  {
+                     return false;
+                  }
+
+                  double bottomOffset;
+                  ParameterUtil.GetDoubleValueFromElement(spatialElement, BuiltInParameter.ROOM_LOWER_OFFSET, out bottomOffset);
+
                   double elevation = (levelInfo != null) ? levelInfo.Elevation : 0.0;
                   XYZ orig = new XYZ(0, 0, elevation + bottomOffset);
                   Transform lcs = Transform.CreateTranslation(orig); // room calculated as level offset.
@@ -966,7 +962,7 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
                   IFCAnyHandle shapeRep = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, null, curveLoops, lcs, XYZ.BasisZ, scaledRoomHeight, true);
                   if (IFCAnyHandleUtil.IsNullOrHasNoValue(shapeRep))
                      return false;
-                  
+
                   // Spaces shouldn't have styled items.
                   HashSet<IFCAnyHandle> bodyItems = new HashSet<IFCAnyHandle>();
                   bodyItems.Add(shapeRep);
@@ -981,11 +977,15 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
                   repHnd = IFCInstanceExporter.CreateProductDefinitionShape(file, null, null, shapeReps);
                }
 
+               if (ParameterUtil.GetDoubleValueFromElement(spatialElement, BuiltInParameter.ROOM_AREA, out dArea) != null)
+                  dArea = UnitUtil.ScaleArea(dArea);
+
                extraParams.ScaledHeight = scaledRoomHeight;
                extraParams.ScaledArea = dArea;
 
                if (exportInfo.ExportInstance == IFCEntityType.IfcSpace)
                {
+                  IFCInternalOrExternal internalOrExternal = CategoryUtil.IsElementExternal(spatialElement) ? IFCInternalOrExternal.External : IFCInternalOrExternal.Internal;
                   spaceHnd = IFCInstanceExporter.CreateSpace(exporterIFC, spatialElement, GUIDUtil.CreateGUID(spatialElement),
                                                 ExporterCacheManager.OwnerHistoryHandle,
                                                 extraParams.GetLocalPlacement(), repHnd, IFCElementComposition.Element,
@@ -1008,7 +1008,7 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
             if (spaceHnd != null)
             {
                productWrapper.AddSpace(spatialElement, spaceHnd, levelInfo, extraParams, true, exportInfo);
-               if (isArea)
+               if (spatialElementAsArea != null)
                {
                   Element areaScheme = spatialElementAsArea.AreaScheme;
                   if (areaScheme != null)
@@ -1053,9 +1053,9 @@ static bool CreateIFCSpace(ExporterIFC exporterIFC, SpatialElement spatialElemen
          // Export Classifications for SpatialElement for GSA/COBIE.
          if (ExporterCacheManager.ExportOptionsCache.ExportAsCOBIE)
          {
-            ProjectInfo projectInfo = document.ProjectInformation;
+            ProjectInfo projectInfo = spatialElement.Document.ProjectInformation;
             if (projectInfo != null)
-               CreateCOBIESpaceClassifications(exporterIFC, file, spaceHnd, projectInfo, spatialElement);
+               CreateCOBIESpaceClassifications(file, spaceHnd, projectInfo, spatialElement);
          }
 
          return true;
@@ -1134,7 +1134,7 @@ static private bool GetCeilingSpaceBoundary(SpatialElement spatialElement, out S
       /// <param name="file">The file.</param>
       /// <param name="element">The element.</param>
       /// <returns>The handle.</returns>
-      static private IFCAnyHandle CreateSpatialZoneEnergyAnalysisPSet(ExporterIFC exporterIFC, IFCFile file, Element element)
+      static private IFCAnyHandle CreateSpatialZoneEnergyAnalysisPSet(IFCFile file, Element element)
       {
          // Property Sets.  We don't use the generic Property Set mechanism because Zones aren't "real" elements.
          HashSet<IFCAnyHandle> properties = new HashSet<IFCAnyHandle>();
@@ -1344,7 +1344,7 @@ static private IFCAnyHandle CreateZoneCommonPSet(ExporterIFC exporterIFC, IFCFil
       /// <param name="file">The file.</param>
       /// <param name="element">The element.</param>
       /// <returns>The handle.</returns>
-      private static IFCAnyHandle CreatePSetSpaceOccupant(ExporterIFC exporterIFC, IFCFile file, Element element)
+      private static IFCAnyHandle CreatePSetSpaceOccupant(IFCFile file, Element element)
       {
          HashSet<IFCAnyHandle> properties = new HashSet<IFCAnyHandle>();
 
@@ -1387,7 +1387,7 @@ private static IFCAnyHandle CreatePSetSpaceOccupant(ExporterIFC exporterIFC, IFC
       /// <param name="productWrapper">
       /// The ProductWrapper.
       /// </param>
-      static void CreateSpaceOccupantInfo(ExporterIFC exporterIFC, IFCFile file, Element element, ProductWrapper productWrapper)
+      static void CreateSpaceOccupantInfo(IFCFile file, Element element, ProductWrapper productWrapper)
       {
          IFCAnyHandle roomHandle = productWrapper.GetElementOfType(IFCEntityType.IfcSpace);
 
@@ -1451,7 +1451,7 @@ static void CreateSpaceOccupantInfo(ExporterIFC exporterIFC, IFCFile file, Eleme
             }
 
             // Look for Parameter Set definition.  We don't use the general approach as Space Occupants are not "real" elements.
-            IFCAnyHandle spaceOccupantPSetHnd = CreatePSetSpaceOccupant(exporterIFC, file, element);
+            IFCAnyHandle spaceOccupantPSetHnd = CreatePSetSpaceOccupant(file, element);
 
             SpaceOccupantInfo spaceOccupantInfo = ExporterCacheManager.SpaceOccupantInfoCache.Find(name);
             if (spaceOccupantInfo == null)
@@ -1482,7 +1482,7 @@ static void CreateSpaceOccupantInfo(ExporterIFC exporterIFC, IFCFile file, Eleme
       }
 
       static private bool CreateGSAInformation(ExporterIFC exporterIFC, Element element, string zoneObjectType,
-          Dictionary<string, IFCAnyHandle> classificationHandles, IFCAnyHandle energyAnalysisPSetHnd)
+          Dictionary<string, IFCAnyHandle> classificationHandles)
       {
          IFCFile file = exporterIFC.GetFile();
 
@@ -1533,7 +1533,7 @@ static private bool CreateGSAInformation(ExporterIFC exporterIFC, Element elemen
          if (isSpatialZone || NamingUtil.IsEqualIgnoringCaseAndSpaces(zoneObjectType, "EnergyAnalysisZone"))
          {
             // Property Sets.  We don't use the generic Property Set mechanism because Zones aren't "real" elements.
-            energyAnalysisPSetHnd = CreateSpatialZoneEnergyAnalysisPSet(exporterIFC, file, element);
+            IFCAnyHandle energyAnalysisPSetHnd = CreateSpatialZoneEnergyAnalysisPSet(file, element);
 
             if (classificationHandles.Count > 0 || energyAnalysisPSetHnd != null)
                return true;
@@ -1594,7 +1594,7 @@ static void CreateZoneInfos(ExporterIFC exporterIFC, IFCFile file, Element eleme
             {
                string zoneObjectType = zoneInfoFinder.GetPropZoneValue(ZoneInfoLabel.ObjectType);
                exportedExtraZoneInformation = CreateGSAInformation(exporterIFC, element, zoneObjectType,
-                   classificationHandles, energyAnalysisPSetHnd);
+                   classificationHandles);
             }
 
             ZoneInfo zoneInfo = ExporterCacheManager.ZoneInfoCache.Find(zoneName);
diff --git a/Source/Revit.IFC.Export/Exporter/SurfaceExporter.cs b/Source/Revit.IFC.Export/Exporter/SurfaceExporter.cs
index a4d135f0..d738fe67 100644
--- a/Source/Revit.IFC.Export/Exporter/SurfaceExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/SurfaceExporter.cs
@@ -67,9 +67,6 @@ public static bool ExportSurface(ExporterIFC exporterIFC, Element element, Geome
             if (items == null || items.Count == 0)
                return false;
 
-            // Surface is never a void.
-            BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, doc, false, items[0], BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element));
-
             foreach (IFCAnyHandle item in items)
                surfaceItems.Add(item);
          }
@@ -102,7 +99,8 @@ public static bool ExportSurface(ExporterIFC exporterIFC, Element element, Geome
                return false;
 
             // This is currently never a void.
-            BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, doc, false, surface, BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, exporterIFC, element));
+            BodyExporter.CreateSurfaceStyleForRepItem(exporterIFC, doc, false, surface, 
+               BodyExporter.GetBestMaterialIdFromGeometryOrParameter(geometryElement, element));
 
             surfaceItems.Add(surface);
          }
diff --git a/Source/Revit.IFC.Export/Exporter/WallExporter.cs b/Source/Revit.IFC.Export/Exporter/WallExporter.cs
index 0cdc28d9..7bd61a80 100644
--- a/Source/Revit.IFC.Export/Exporter/WallExporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/WallExporter.cs
@@ -68,7 +68,7 @@ private static bool GetDifferenceFromWallJoins(Document doc, ElementId wallId, S
                   continue;
 
                Element otherElem = doc.GetElement(otherWallId);
-               GeometryElement otherGeomElem = (otherElem != null) ? otherElem.get_Geometry(options) : null;
+               GeometryElement otherGeomElem = otherElem?.get_Geometry(options);
                if (otherGeomElem == null)
                   continue;
 
@@ -555,7 +555,7 @@ private static void GetSolidsAndMeshes(Document doc, ExporterIFC exporterIFC, Ge
       }
 
       // Get List of Solids that are from Wall Sweep
-      private static IList<Solid> GetSolidOfWallSweep(Document doc, ExporterIFC exporterIFC, GeometryElement geometryElement, IFCRange range)
+      private static IList<Solid> GetSolidOfWallSweep(GeometryElement geometryElement, IFCRange range)
       {
          IList<Solid> solids = new List<Solid>();
 
@@ -714,7 +714,7 @@ public static IFCAnyHandle ExportWallBase(ExporterIFC exporterIFC, string ifcEnu
          Document doc = element.Document;
          // Collect solids of Wall Sweep first before attempting to split into Parts because once it is split, we cannot get the information
          // the owner being Wall Sweep
-         IList<Solid> solidsOfWallSweep = GetSolidOfWallSweep(doc, exporterIFC, geometryElement, range);
+         IList<Solid> solidsOfWallSweep = GetSolidOfWallSweep(geometryElement, range);
          using (SubTransaction tempPartTransaction = new SubTransaction(doc))
          {
             bool exportByComponents = false;
@@ -1196,7 +1196,7 @@ public static IFCAnyHandle ExportWallBase(ExporterIFC exporterIFC, string ifcEnu
                            }
 
                            // export Base Quantities
-                           if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities)
+                           if (ExporterCacheManager.ExportOptionsCache.ExportBaseQuantities && exportType.ExportType == IFCEntityType.IfcWallType)
                            {
                               scaledFootprintArea = MathUtil.AreaIsAlmostZero(scaledFootprintArea) ? extraParams.ScaledArea : scaledFootprintArea;
                               scaledLength = MathUtil.IsAlmostZero(scaledLength) ? extraParams.ScaledLength : scaledLength;
diff --git a/Source/Revit.IFC.Export/Revit.IFC.Export.csproj b/Source/Revit.IFC.Export/Revit.IFC.Export.csproj
index 7789ff0a..e1ad55f2 100644
--- a/Source/Revit.IFC.Export/Revit.IFC.Export.csproj
+++ b/Source/Revit.IFC.Export/Revit.IFC.Export.csproj
@@ -79,6 +79,7 @@
     <Compile Include="Exporter\DuctInsulationExporter.cs" />
     <Compile Include="Exporter\DuctLiningExporter.cs" />
     <Compile Include="Exporter\ExporterInitializer_PsetDef.cs" />
+    <Compile Include="Exporter\ExporterInitializer_QsetDef.cs" />
     <Compile Include="Exporter\GenericElementExporter.cs" />
     <Compile Include="Exporter\ExtrusionExporter.cs" />
     <Compile Include="Exporter\FabricSheetExporter.cs" />
@@ -100,7 +101,9 @@
     <Compile Include="Exporter\PropertySet\AttributeEntryMap.cs" />
     <Compile Include="Exporter\PropertySet\AttributeSetDescription.cs" />
     <Compile Include="Exporter\PropertySet\Calculators\FireRatingCalculator.cs" />
+    <Compile Include="Exporter\PropertySet\Calculators\GrossCrossSectionAreaCalculator.cs" />
     <Compile Include="Exporter\PropertySet\Calculators\IsExternalCalculator.cs" />
+    <Compile Include="Exporter\PropertySet\Calculators\NetCrossSectionAreaCalculator.cs" />
     <Compile Include="Exporter\PropertySet\Calculators\NosingLengthCalculator.cs" />
     <Compile Include="Exporter\PropertySet\Calculators\NumberOfRiserCalculator.cs" />
     <Compile Include="Exporter\PropertySet\Calculators\NumberOfTreadsCalculator.cs" />
@@ -149,7 +152,7 @@
     <Compile Include="Exporter\PropertySet\ElectricalVoltagePropertyUtil.cs" />
     <Compile Include="Exporter\PropertySet\EntryMap.cs" />
     <Compile Include="Exporter\PropertySet\ExporterInitializer_PsetDefIFC2X2Enum.cs" />
-    <Compile Include="Exporter\PropertySet\ExporterInitializer_PsetDefIFC2X3TC1Enum.cs" />
+    <Compile Include="Exporter\PropertySet\ExporterInitializer_PsetDefIFC2X3Enum.cs" />
     <Compile Include="Exporter\PropertySet\ExporterInitializer_PsetDefIFC4Enum.cs" />
     <Compile Include="Exporter\PropertySet\FrequencyPropertyUtil.cs" />
     <Compile Include="Exporter\PropertySet\PositivePlaneAnglePropertyUtil.cs" />
diff --git a/Source/Revit.IFC.Export/Toolkit/IFCDataUtil.cs b/Source/Revit.IFC.Export/Toolkit/IFCDataUtil.cs
index 62d17539..092574b0 100644
--- a/Source/Revit.IFC.Export/Toolkit/IFCDataUtil.cs
+++ b/Source/Revit.IFC.Export/Toolkit/IFCDataUtil.cs
@@ -282,6 +282,16 @@ public static IFCData CreateAsPowerMeasure(double value)
          return CreateAsMeasure(value, "IfcPowerMeasure");
       }
 
+      /// <summary>
+      /// Creates an IFCData object as IfcSoundPowerMeasure.
+      /// </summary>
+      /// <param name="value">The double value.</param>
+      /// <returns>The IFCData object.</returns>
+      public static IFCData CreateAsSoundPowerMeasure(double value)
+      {
+         return CreateAsMeasure(value, "IfcSoundPowerMeasure");
+      }
+
       /// <summary>
       /// Creates an IFCData object as IfcFrequencyMeasure.
       /// </summary>
diff --git a/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs b/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
index 3115fe7c..35285425 100644
--- a/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
+++ b/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
@@ -3147,7 +3147,7 @@ public static IFCAnyHandle CreatePhysicalComplexQuantity(IFCFile file, string na
       /// <param name="methodOfMeasurement">Name of the method of measurement used to calculate the element quantity.</param>
       /// <param name="quantities">The individual quantities for the element.</param>
       /// <returns>The handle.</returns>
-      public static IFCAnyHandle CreateElementQuantity(IFCFile file, string guid, IFCAnyHandle ownerHistory,
+      public static IFCAnyHandle CreateElementQuantity(IFCFile file, IFCAnyHandle elemHnd, string guid, IFCAnyHandle ownerHistory,
           string name, string description, string methodOfMeasurement, HashSet<IFCAnyHandle> quantities)
       {
          IFCAnyHandleUtil.ValidateSubTypeOf(quantities, false, IFCEntityType.IfcPhysicalQuantity);
@@ -3158,6 +3158,7 @@ public static IFCAnyHandle CreateElementQuantity(IFCFile file, string guid, IFCA
          IFCAnyHandleUtil.SetAttribute(elementQuantity, "MethodOfMeasurement", methodOfMeasurement);
          IFCAnyHandleUtil.SetAttribute(elementQuantity, "Quantities", quantities);
          SetPropertySetDefinition(elementQuantity, guid, ownerHistory, name, description);
+         ExporterCacheManager.QtoSetCreated.Add((elemHnd, name));
          return elementQuantity;
       }
 
@@ -3924,7 +3925,7 @@ public static IFCData CreateArcIndexType(IFCFile file, IList<int> arcIndexList)
          return arcIndexData;
       }
 
-      public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coordinates, IList<IList<int>> segmentIndexList, bool? selfIntersect)
+      public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coordinates, IList<GeometryUtil.SegmentIndices> segmentIndexList, bool? selfIntersect)
       {
          if (coordinates == null)
             throw new ArgumentNullException("Points");
@@ -3935,7 +3936,41 @@ public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coo
          IFCAnyHandle indexedPolyCurveHnd = CreateInstance(file, IFCEntityType.IfcIndexedPolyCurve, null);
          IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "Points", coordinates);
          if (segmentIndexList != null)
-            IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "Segments", segmentIndexList, 1, null, 2, null);
+         {
+            IFCAggregate segments = indexedPolyCurveHnd.CreateAggregateAttribute("Segments");
+            foreach (GeometryUtil.SegmentIndices segmentIndices in segmentIndexList)
+            {
+               if(segmentIndices.IsCalculated == false)
+                  throw new ArgumentNullException("Segments");
+
+               IFCData segment = null;
+
+               var polyLineIndices = segmentIndices as GeometryUtil.PolyLineIndices;
+               if (polyLineIndices != null)
+               {
+                  segment = segments.CreateValueOfType("IfcLineIndex");
+
+                  IFCAggregate lineIndexAggr = segment.AsAggregate();
+                  foreach (int index in polyLineIndices.Indices)
+                     lineIndexAggr.Add(IFCData.CreateInteger(index));
+               }
+               else
+               {
+                  var arcIndices = segmentIndices as GeometryUtil.ArcIndices;
+                  if (arcIndices != null)
+                  {
+                     segment = segments.CreateValueOfType("IfcArcIndex");
+
+                     IFCAggregate arcIndexAggr = segment.AsAggregate();
+                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.Start));
+                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.Mid));
+                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.End));
+                  }
+               }
+               segments.Add(segment);
+            }
+         }
+
          IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "SelfIntersect", selfIntersect);
 
          return indexedPolyCurveHnd;
@@ -5552,8 +5587,8 @@ public static IFCAnyHandle CreateElectricalCircuit(IFCFile file, string guid, IF
       /// <param name="objectType">The object type.</param>
       /// <param name="longName">The long name.</param>
       /// <returns></returns>
-      public static IFCAnyHandle CreateDistributionSystem(IFCFile file, IFCExportInfoPair entityToCreate, string guid, IFCAnyHandle ownerHistory, string name,
-         string description, string objectType, string longName)
+      public static IFCAnyHandle CreateDistributionSystem(IFCFile file, string guid, IFCAnyHandle ownerHistory, string name,
+         string description, string objectType, string longName, string predefinedType)
       {
          if (ExporterCacheManager.ExportOptionsCache.ExportAsOlderThanIFC4)
             return null;
@@ -5561,8 +5596,8 @@ public static IFCAnyHandle CreateDistributionSystem(IFCFile file, IFCExportInfoP
          IFCAnyHandle buildingSystem = CreateInstance(file, IFCEntityType.IfcDistributionSystem, null);
          SetSystem(buildingSystem, guid, ownerHistory, name, description, objectType);
 
-         if (!string.IsNullOrEmpty(entityToCreate.ValidatedPredefinedType))
-            IFCAnyHandleUtil.SetAttribute(buildingSystem, "PredefinedType", entityToCreate.ValidatedPredefinedType, true);
+         if (!string.IsNullOrEmpty(predefinedType))
+            IFCAnyHandleUtil.SetAttribute(buildingSystem, "PredefinedType", predefinedType, true);
          if (!string.IsNullOrEmpty(longName))
             IFCAnyHandleUtil.SetAttribute(buildingSystem, "LongName", longName, false);
 
@@ -6958,6 +6993,15 @@ public static IFCAnyHandle CreateQuantityVolume(IFCFile file, string name, strin
          return quantityVolume;
       }
 
+      /// <summary>
+      /// Creates an IfcQuantityWeight and assigns it to the file.
+      /// </summary>
+      /// <param name="file">The file</param>
+      /// <param name="name">The name</param>
+      /// <param name="description">The description</param>
+      /// <param name="unit">The unit</param>
+      /// <param name="weightValue">The value of the quantity, in the appropriate units.</param>
+      /// <returns>The handle</returns>
       public static IFCAnyHandle CreateQuantityWeight(IFCFile file, string name, string description, IFCAnyHandle unit, double weightValue)
       {
          ValidatePhysicalSimpleQuantity(name, description, unit);
@@ -6968,6 +7012,44 @@ public static IFCAnyHandle CreateQuantityWeight(IFCFile file, string name, strin
          return quantityWeight;
       }
 
+      /// <summary>
+      /// Creates an IfcQuantityCount and assigns it to the file.
+      /// </summary>
+      /// <param name="file">The file</param>
+      /// <param name="name">The name</param>
+      /// <param name="description">The description</param>
+      /// <param name="unit">The unit</param>
+      /// <param name="weightValue">The value of the quantity, in the appropriate units.</param>
+      /// <returns>The handle</returns>
+      public static IFCAnyHandle CreateQuantityCount(IFCFile file, string name, string description, IFCAnyHandle unit, int countValue)
+      {
+         ValidatePhysicalSimpleQuantity(name, description, unit);
+
+         IFCAnyHandle quantityCount = CreateInstance(file, IFCEntityType.IfcQuantityCount, null);
+         IFCAnyHandleUtil.SetAttribute(quantityCount, "CountValue", countValue);
+         SetPhysicalSimpleQuantity(quantityCount, name, description, unit);
+         return quantityCount;
+      }
+
+      /// <summary>
+      /// Creates an IfcQuantityTime and assigns it to the file.
+      /// </summary>
+      /// <param name="file">The file</param>
+      /// <param name="name">The name</param>
+      /// <param name="description">The description</param>
+      /// <param name="unit">The unit</param>
+      /// <param name="weightValue">The value of the quantity, in the appropriate units.</param>
+      /// <returns>The handle</returns>
+      public static IFCAnyHandle CreateQuantityTime(IFCFile file, string name, string description, IFCAnyHandle unit, double timeValue)
+      {
+         ValidatePhysicalSimpleQuantity(name, description, unit);
+
+         IFCAnyHandle quantityTime = CreateInstance(file, IFCEntityType.IfcQuantityTime, null);
+         IFCAnyHandleUtil.SetAttribute(quantityTime, "TimeValue", timeValue);
+         SetPhysicalSimpleQuantity(quantityTime, name, description, unit);
+         return quantityTime;
+      }
+
       /// <summary>
       /// Creates an IfcRelConnectsPorts and assigns it to the file.
       /// </summary>
diff --git a/Source/Revit.IFC.Export/Utility/ElementFilteringUtil.cs b/Source/Revit.IFC.Export/Utility/ElementFilteringUtil.cs
index 7a8eee14..0d3e1faa 100644
--- a/Source/Revit.IFC.Export/Utility/ElementFilteringUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/ElementFilteringUtil.cs
@@ -503,7 +503,9 @@ private static ElementFilter GetClassFilter(bool forSpatialElements)
             excludedTypes.Add(typeof(Level));
 
             // exclude analytical models
+#pragma warning disable CS0612, CS0618 //AnalyticalModel is obsolette
             excludedTypes.Add(typeof(Autodesk.Revit.DB.Structure.AnalyticalModel));
+#pragma warning restore CS0612, CS0618
 
             ElementFilter excludedClassFilter = new ElementMulticlassFilter(excludedTypes, true);
 
diff --git a/Source/Revit.IFC.Export/Utility/ExporterCacheManager.cs b/Source/Revit.IFC.Export/Utility/ExporterCacheManager.cs
index fd09b187..7dc98714 100644
--- a/Source/Revit.IFC.Export/Utility/ExporterCacheManager.cs
+++ b/Source/Revit.IFC.Export/Utility/ExporterCacheManager.cs
@@ -403,6 +403,11 @@ public class ExporterCacheManager
       /// </summary>
       static public IDictionary<IFCAnyHandle, HashSet<IFCAnyHandle>> ComplexPropertyCache { get; set; } = new Dictionary<IFCAnyHandle, HashSet<IFCAnyHandle>>();
 
+      /// <summary>
+      /// Cache for information whether a QuantitySet specified in the Dict. value has been created for the elementHandle
+      /// </summary>
+      static public HashSet<(IFCAnyHandle, string)> QtoSetCreated { get; set; } = new HashSet<(IFCAnyHandle, string)>();
+
       /// <summary>
       /// The ParameterCache object.
       /// </summary>
@@ -1497,6 +1502,7 @@ public static void Clear()
          m_UnitsCache = null;
          m_ZoneCache = null;
          m_ZoneInfoCache = null;
+         QtoSetCreated.Clear();
       }
    }
 }
diff --git a/Source/Revit.IFC.Export/Utility/ExporterUtil.cs b/Source/Revit.IFC.Export/Utility/ExporterUtil.cs
index cce6ea8d..205782c5 100644
--- a/Source/Revit.IFC.Export/Utility/ExporterUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/ExporterUtil.cs
@@ -48,15 +48,15 @@ private static ProjectPosition GetSafeProjectPosition(Document doc)
             return null;
          }
       }
-      private static void Union<T>(ref List<T> lList, List<T> rList)
+      private static void Union<T>(ref IList<T> lList, IList<T> rList)
       {
-         if (rList.Count() > 0)
-         {
-            if (lList.Count() == 0)
-               lList = rList;
-            else
-               lList = lList.Union(rList).ToList();
-         }
+         if (rList == null || rList.Count() == 0)
+            return;
+
+         if (lList.Count() == 0)
+            lList = rList;
+         else
+            lList = lList.Union(rList).ToList();
       }
 
       /// <summary>
@@ -946,6 +946,16 @@ public static string GetIFCTypeFromExportTable(ExporterIFC exporterIFC, Element
          return GetIFCTypeFromExportTable(exporterIFC, element, categoryId, -1);
       }
 
+      private class ApplicablePsets
+      {
+         public class PsetsByTypeAndPredefinedType
+         {
+            public IList<PropertySetDescription> ByType { get; set; }
+            public IList<PropertySetDescription> ByPredefinedType { get; set; }
+         }
+         public PsetsByTypeAndPredefinedType ByIfcEntity { get; set; } = new PsetsByTypeAndPredefinedType();
+         public PsetsByTypeAndPredefinedType ByIfcEntityType { get; set; } = new PsetsByTypeAndPredefinedType();
+      }
       /// <summary>
       /// Gets the list of common property sets appropriate to this handle.
       /// </summary>
@@ -1014,45 +1024,59 @@ public static IList<PropertySetDescription> GetCurrPSetsToCreate(IFCAnyHandle pr
          // Find existing Psets list for the given type in the cache
          var cachedPsets = GetCachedPropertySets(exportInfo);
          //Set bool variables to true below to search for property sets If they were not found in cache 
-         bool searchPsetsByType = cachedPsets.ByType == null;
-         bool searchPsetsByPredefinedType = cachedPsets.ByPredefinedType == null;
+         bool searchPsetsByEntity                     = cachedPsets.ByIfcEntity.ByType == null;
+         bool searchPsetsByEntityPredefinedType       = cachedPsets.ByIfcEntity.ByPredefinedType == null;
+         bool searchPsetsByEntityType                 = cachedPsets.ByIfcEntityType.ByType == null;
+         bool searchPsetsByEntityTypePredefinedType   = cachedPsets.ByIfcEntityType.ByPredefinedType == null;
 
-         List<PropertySetDescription> currPsetsForType = new List<PropertySetDescription>();
-         List<PropertySetDescription> currPsetsForPredefinedType = new List<PropertySetDescription>();
-         if (searchPsetsByType || searchPsetsByPredefinedType)
+         IList<PropertySetDescription> currPsetsForEntity                     = new List<PropertySetDescription>();
+         IList<PropertySetDescription> currPsetsForEntityPredefinedType       = new List<PropertySetDescription>();
+         IList<PropertySetDescription> currPsetsForEntityType                 = new List<PropertySetDescription>();
+         IList<PropertySetDescription> currPsetsForEntityTypePredefinedType   = new List<PropertySetDescription>();
+         if (searchPsetsByEntity || searchPsetsByEntityPredefinedType || searchPsetsByEntityType || searchPsetsByEntityTypePredefinedType)
          {
             foreach (IList<PropertySetDescription> currStandard in psetsToCreate)
             {
                var applicablePsets = GetApplicablePropertySets(exportInfo, currStandard);
-               if (searchPsetsByType)
-                  Union(ref currPsetsForType, applicablePsets.ByType);
-               if (searchPsetsByPredefinedType)
-                  Union(ref currPsetsForPredefinedType, applicablePsets.ByPredefinedType);
+               if (searchPsetsByEntity)
+                  Union(ref currPsetsForEntity, applicablePsets.ByIfcEntity.ByType);
+               if (searchPsetsByEntityPredefinedType)
+                  Union(ref currPsetsForEntityPredefinedType, applicablePsets.ByIfcEntity.ByPredefinedType);
+               if (searchPsetsByEntityType)
+                  Union(ref currPsetsForEntityType, applicablePsets.ByIfcEntityType.ByType);
+               if (searchPsetsByEntityTypePredefinedType)
+                  Union(ref currPsetsForEntityTypePredefinedType, applicablePsets.ByIfcEntityType.ByPredefinedType);
             }
 
-            if (searchPsetsByType)
-            {
-               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(prodHndType, null)] = currPsetsForType;
-            }
+            if (searchPsetsByEntity)
+               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, null)] = currPsetsForEntity;
 
-            if (searchPsetsByPredefinedType)
-            {
-               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(prodHndType, exportInfo.ValidatedPredefinedType)] = currPsetsForPredefinedType;
-            }
-         }
+            if (searchPsetsByEntityPredefinedType)
+               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, exportInfo.ValidatedPredefinedType)] = currPsetsForEntityPredefinedType;
 
-         if (!searchPsetsByType)
-         {
-            currPsetsForType = cachedPsets.ByType.ToList();
-         }
+            if (searchPsetsByEntityType)
+               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, null)] = currPsetsForEntityType;
 
-         if (!searchPsetsByPredefinedType)
-         {
-            currPsetsForPredefinedType = cachedPsets.ByPredefinedType.ToList();
+            if (searchPsetsByEntityTypePredefinedType)
+               ExporterCacheManager.PropertySetsForTypeCache[new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, exportInfo.ValidatedPredefinedType)] = currPsetsForEntityTypePredefinedType;
          }
 
-         var currPsets = currPsetsForType;
-         currPsets.AddRange(currPsetsForPredefinedType);
+         if (!searchPsetsByEntity)
+            currPsetsForEntity = cachedPsets.ByIfcEntity.ByType;
+
+         if (!searchPsetsByEntityPredefinedType)
+            currPsetsForEntityPredefinedType = cachedPsets.ByIfcEntity.ByPredefinedType;
+
+         if (!searchPsetsByEntityType)
+            currPsetsForEntityType = cachedPsets.ByIfcEntityType.ByType;
+
+         if (!searchPsetsByEntityTypePredefinedType)
+            currPsetsForEntityTypePredefinedType = cachedPsets.ByIfcEntityType.ByPredefinedType;
+
+         var currPsets = currPsetsForEntity.ToList();//make independent copy. Without this we will have a bug.
+         currPsets.AddRange(currPsetsForEntityPredefinedType);
+         currPsets.AddRange(currPsetsForEntityType);
+         currPsets.AddRange(currPsetsForEntityTypePredefinedType);
          return currPsets;
       }
 
@@ -1066,22 +1090,30 @@ public static IList<PropertySetDescription> GetCurrPSetsToCreate(IFCAnyHandle pr
       /// <param name="exportInfo">the export infor pair</param>
       /// <param name="psetList">the pset list to iterate</param>
       /// <returns>filtered results of the applicable Psets. Output psets are grouped by type they relate to.</returns>
-      static (List<PropertySetDescription> ByType, List<PropertySetDescription> ByPredefinedType) GetApplicablePropertySets(IFCExportInfoPair exportInfo, IEnumerable<PropertySetDescription> psetList)
-      {
-         List<PropertySetDescription> applicablePsetsByType = new List<PropertySetDescription>();
-         List<PropertySetDescription> applicablePsetsByPredefinedType = new List<PropertySetDescription>();
-
+      static ApplicablePsets GetApplicablePropertySets(IFCExportInfoPair exportInfo, IEnumerable<PropertySetDescription> psetList)
+      {
+         IList<PropertySetDescription> applicablePsetsByType = null;
+         IList<PropertySetDescription> applicablePsetsByPredefinedType = null;
+         ApplicablePsets applicablePsets = new ApplicablePsets();
+         applicablePsets.ByIfcEntity.ByType = new List<PropertySetDescription>();
+         applicablePsets.ByIfcEntity.ByPredefinedType = new List<PropertySetDescription>();
+         applicablePsets.ByIfcEntityType.ByType = new List<PropertySetDescription>();
+         applicablePsets.ByIfcEntityType.ByPredefinedType = new List<PropertySetDescription>();
          foreach (PropertySetDescription currDesc in psetList)
          {
             bool toAdd = false;
-            if (currDesc.IsAppropriateEntityType(exportInfo.ExportInstance) || currDesc.IsAppropriateEntityType(exportInfo.ExportType))
+            if (currDesc.IsAppropriateEntityType(exportInfo.ExportInstance) || currDesc.IsAppropriateObjectType(exportInfo.ExportInstance))
             {
                toAdd = true;
+               applicablePsetsByType = applicablePsets.ByIfcEntity.ByType;
+               applicablePsetsByPredefinedType = applicablePsets.ByIfcEntity.ByPredefinedType;
             }
             // ObjectType if the Applicable type is missing
-            else if (currDesc.IsAppropriateObjectType(exportInfo.ExportInstance) || currDesc.IsAppropriateObjectType(exportInfo.ExportType))
+            else if (currDesc.IsAppropriateEntityType(exportInfo.ExportType) || currDesc.IsAppropriateObjectType(exportInfo.ExportType))
             {
                toAdd = true;
+               applicablePsetsByType = applicablePsets.ByIfcEntityType.ByType;
+               applicablePsetsByPredefinedType = applicablePsets.ByIfcEntityType.ByPredefinedType;
             }
 
             if (toAdd)
@@ -1101,60 +1133,56 @@ public static IList<PropertySetDescription> GetCurrPSetsToCreate(IFCAnyHandle pr
                }
             }
          }
-         return (applicablePsetsByType, applicablePsetsByPredefinedType);
+         return applicablePsets;
       }
 
       /// <summary>
       /// Get PropertySets from cache.
-      ///    Current logic distinguishes property sets related to ifc entity's type and predefined type.
-      ///    This function returns both kinds of psets.
+      /// Current logic searches psets by 4 different PropertySet keys:
+      ///   1)IfcEntity,
+      ///   2)IfcEntity + PredefinedType,
+      ///   3)IfcEntityType,
+      ///   4)IfcEntityType + PredefinedType.
+      /// Found psets are stored separately in ApplicablePsets object.
       /// </summary>
       /// <param name="exportInfo">the export infor pair</param>
-      /// <returns>Tuple with two containers. ByType: psets related to ifc entity type. ByPredefinedType: psets related to ifc entity's predefined type.
+      /// <returns>ApplicablePsets object with 4 containers which store 4 different groups of psets.
       /// If size of container is 0 then this means that search hasn't found any Psets associated with this type 
       /// which is why empty container was cached. This function finds it and returns.
       /// If container is null then this means that info for this type is not cached because search has never been performed for it.
       /// </returns>
-      private static (HashSet<PropertySetDescription> ByType, HashSet<PropertySetDescription> ByPredefinedType) GetCachedPropertySets(IFCExportInfoPair exportInfo)
+      private static ApplicablePsets GetCachedPropertySets(IFCExportInfoPair exportInfo)
       {
-         HashSet<PropertySetDescription> cachedPsetsByType = null;
-         HashSet<PropertySetDescription> cachedPsetsByPredefinedType = null;
-         IList<PropertySetDescription> tmpCachedPsetsByType = null;
-         IList<PropertySetDescription> tmpCachedPsetsByPredefinedType = null;
-         if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, null), out tmpCachedPsetsByType))
+         ApplicablePsets applicablePsets = new ApplicablePsets();
+         IList<PropertySetDescription> tmpCachedPsets = null;
+
+         if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, null), out tmpCachedPsets))
          {
-            cachedPsetsByType = new HashSet<PropertySetDescription>();
-            cachedPsetsByType.UnionWith(tmpCachedPsetsByType);
+            applicablePsets.ByIfcEntity.ByType = tmpCachedPsets;
          }
-         if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, null), out tmpCachedPsetsByType))
+         if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, null), out tmpCachedPsets))
          {
-            if(cachedPsetsByType == null)
-               cachedPsetsByType = new HashSet<PropertySetDescription>();
-
-            cachedPsetsByType.UnionWith(tmpCachedPsetsByType);
+            applicablePsets.ByIfcEntityType.ByType = tmpCachedPsets;
          }
 
          if (string.IsNullOrEmpty(exportInfo.ValidatedPredefinedType))
          {
-            cachedPsetsByPredefinedType = new HashSet<PropertySetDescription>();// Search will never find any psets in this case so return empty container
+            applicablePsets.ByIfcEntity.ByPredefinedType = new List<PropertySetDescription>();
+            applicablePsets.ByIfcEntityType.ByPredefinedType = new List<PropertySetDescription>();
          }
          else
          {
-            if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, exportInfo.ValidatedPredefinedType), out tmpCachedPsetsByPredefinedType))
+            if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportInstance, exportInfo.ValidatedPredefinedType), out tmpCachedPsets))
             {
-               cachedPsetsByPredefinedType = new HashSet<PropertySetDescription>();
-               cachedPsetsByPredefinedType.UnionWith(tmpCachedPsetsByPredefinedType);
+               applicablePsets.ByIfcEntity.ByPredefinedType = tmpCachedPsets;
             }
-            if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, exportInfo.ValidatedPredefinedType), out tmpCachedPsetsByPredefinedType))
+            if (ExporterCacheManager.PropertySetsForTypeCache.TryGetValue(new ExporterCacheManager.PropertySetKey(exportInfo.ExportType, exportInfo.ValidatedPredefinedType), out tmpCachedPsets))
             {
-               if (cachedPsetsByPredefinedType == null)
-                  cachedPsetsByPredefinedType = new HashSet<PropertySetDescription>();
-
-               cachedPsetsByPredefinedType.UnionWith(tmpCachedPsetsByPredefinedType);
+               applicablePsets.ByIfcEntityType.ByPredefinedType = tmpCachedPsets;
             }
          }
 
-         return (cachedPsetsByType, cachedPsetsByPredefinedType);
+         return applicablePsets;
       }
 
       /// <summary>
@@ -1396,7 +1424,7 @@ private static void ExportElementQuantities(ExporterIFC exporterIFC, Element ele
                      if (elemTypeToUse == null)
                         elemTypeToUse = elemType;
 
-                     if (currDesc.IsAppropriateType(prodHnd))
+                     if (currDesc.IsAppropriateType(prodHnd) && !ExporterCacheManager.QtoSetCreated.Contains((prodHnd, currDesc.Name)))
                      {
                         HashSet<string> uniqueQuantityNames = new HashSet<string>();
                         HashSet<IFCAnyHandle> quantities = new HashSet<IFCAnyHandle>();
@@ -1435,18 +1463,23 @@ private static void ExportElementQuantities(ExporterIFC exporterIFC, Element ele
                            string methodName = currDesc.MethodOfMeasurement;
                            string description = currDesc.DescriptionOfSet;
 
-                           IFCAnyHandle propertySet = IFCInstanceExporter.CreateElementQuantity(file, GUIDUtil.CreateGUID(), ownerHistory, paramSetName, description, methodName, quantities);
-                           IFCAnyHandle prodHndToUse = prodHnd;
-                           DescriptionCalculator ifcRDC = currDesc.DescriptionCalculator;
-                           if (ifcRDC != null)
+
+                           // Skip if the elementHandle has the associated QuantitySet has been created before
+                           if (!ExporterCacheManager.QtoSetCreated.Contains((prodHnd, paramSetName)))
                            {
-                              IFCAnyHandle overrideHnd = ifcRDC.RedirectDescription(exporterIFC, element);
-                              if (!IFCAnyHandleUtil.IsNullOrHasNoValue(overrideHnd))
-                                 prodHndToUse = overrideHnd;
+                              IFCAnyHandle quantity = IFCInstanceExporter.CreateElementQuantity(file, prodHnd, GUIDUtil.CreateGUID(), ownerHistory, paramSetName, description, methodName, quantities);
+                              IFCAnyHandle prodHndToUse = prodHnd;
+                              DescriptionCalculator ifcRDC = currDesc.DescriptionCalculator;
+                              if (ifcRDC != null)
+                              {
+                                 IFCAnyHandle overrideHnd = ifcRDC.RedirectDescription(exporterIFC, element);
+                                 if (!IFCAnyHandleUtil.IsNullOrHasNoValue(overrideHnd))
+                                    prodHndToUse = overrideHnd;
+                              }
+                              HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
+                              relatedObjects.Add(prodHndToUse);
+                              ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, quantity);
                            }
-                           HashSet<IFCAnyHandle> relatedObjects = new HashSet<IFCAnyHandle>();
-                           relatedObjects.Add(prodHndToUse);
-                           ExporterUtil.CreateRelDefinesByProperties(file, GUIDUtil.CreateGUID(), ownerHistory, null, null, relatedObjects, propertySet);
                         }
                      }
                   }
diff --git a/Source/Revit.IFC.Export/Utility/GeometryUtil.cs b/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
index 7634623f..68cd9cb1 100644
--- a/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
@@ -91,6 +91,263 @@ public override int GetHashCode(EdgeEndPoint edgePnt)
          }
       }
 
+      /// <summary>
+      /// Stores vertices list of geometry primitives.
+      /// Derived classes concretize the actual primitive type the vertices list belong to.
+      /// </summary>
+      private abstract class PrimVertices
+      {
+         public IFCAnyHandleUtil.IfcPointList PointList { get; protected set; } = new IFCAnyHandleUtil.IfcPointList();
+         public PointBase this[int key]
+         {
+            get => PointList[key];
+            set => PointList[key] = value;
+         }
+         public PointBase Last() { return PointList.Last(); }
+      }
+      private class PolyLineVertices : PrimVertices
+      {
+         public PolyLineVertices(UV beg, UV end)
+         {
+            PointList.AddPoints(beg, end);
+         }
+         public PolyLineVertices(XYZ beg, XYZ end)
+         {
+            PointList.AddPoints(beg, end);
+         }
+         public PolyLineVertices(List<XYZ> points)
+         {
+            if (points.Count < 2)
+               throw new ArgumentException("Number of points must be 2 or greater");
+
+            PointList.AddPoints(points);
+         }
+         public PolyLineVertices(List<UV> points)
+         {
+            if (points.Count < 2)
+               throw new ArgumentException("Number of points must be 2 or greater");
+
+            PointList.AddPoints(points);
+         }
+      }
+      private class ArcVertices : PrimVertices
+      {
+         public ArcVertices(UV start, UV mid, UV end)
+         {
+            PointList.AddPoints(start, mid, end);
+         }
+         public ArcVertices(XYZ start, XYZ mid, XYZ end)
+         {
+            PointList.AddPoints(start, mid, end);
+         }
+      }
+      /// <summary>
+      /// Stores indices list used to build geometry primitives.
+      /// Derived classes concretize the primitive type defined by indices.
+      /// </summary>
+      public abstract class SegmentIndices
+      {
+         public abstract int GetStart();
+         public abstract int GetEnd();
+         public abstract void SetEnd(int endIndex);
+         public abstract void CalcIndices(int startIdx);
+         public bool IsCalculated { get; protected set; } = false;
+         public virtual bool TryMerge(SegmentIndices segmentIndices)
+         {
+            return false;
+         }
+      }
+      public class PolyLineIndices : SegmentIndices
+      {
+         public PolyLineIndices(int lineCount)
+         { LineCount = lineCount; }
+         public List<int> Indices { get; protected set; }
+         public int m_lineCount = 0;
+         public int LineCount
+         {
+            get { return m_lineCount; }
+            //Indices are not valid because line count has been changed. So delete indince list.
+            set { m_lineCount = value; IsCalculated = false; }
+         }
+         public override int GetStart()
+         { return Indices[0]; }
+         public override int GetEnd()
+         { return Indices.Last(); }
+         public override void SetEnd(int endIndex)
+         { Indices[Indices.Count - 1] = endIndex; }
+         public override void CalcIndices(int startIdx)
+         {
+            Indices = new List<int> { startIdx };
+            Indices.AddRange(Enumerable.Range(startIdx, LineCount).Select(x => x + 1));
+            IsCalculated = true;
+         }
+         //Function assumes that input and this segmants are consecutive. End index of this segmant must be equal to start index of input segment.
+         public override bool TryMerge(SegmentIndices segmentIndices)
+         {
+            PolyLineIndices inputPolyLineIndices = segmentIndices as PolyLineIndices;
+            if (segmentIndices == this || inputPolyLineIndices == null)
+               return false;
+            
+            //Indices array after merge must not contain duplicated indices.
+            //So remove either End index of this segment or Start index of input segment.
+            Indices.RemoveAt(Indices.Count - 1);
+            Indices.AddRange(inputPolyLineIndices.Indices);
+            return true;
+         }
+      }
+      public class ArcIndices : SegmentIndices
+      {
+         public int Start { get; protected set; }
+         public int Mid { get; protected set; }
+         public int End { get; protected set; }
+         public override int GetStart()
+         { return Start; }
+         public override int GetEnd()
+         { return End; }
+         public override void SetEnd(int endIndex)
+         { End = endIndex; }
+         public override void CalcIndices(int startIdx)
+         {
+            Start = startIdx;
+            Mid = startIdx + 1;
+            End = startIdx + 2;
+            IsCalculated = true;
+         }
+      }
+      /// <summary>
+      /// Accumulates vertices and calculates indices.
+      /// This class assumes that primitive vertices should be connected in the order they appear in the array.
+      /// Based on this assumption this class constructs indices array.
+      /// </summary>
+      private class PolyCurve
+      {
+         private List<PrimVertices> PrimVerticesList { get; set; } = new List<PrimVertices>();
+         public bool PolyLinesOnly { get; protected set; } = true;
+         //PointList and SegmentsIndices are built by BuildVerticesAndIndices()
+         public IFCAnyHandleUtil.IfcPointList PointList { get; protected set; } = new IFCAnyHandleUtil.IfcPointList();
+         public List<SegmentIndices> SegmentsIndices { get; protected set; } = null;
+
+         public PolyCurve(PrimVertices primVertices)
+         {
+            if (!AddPrimVertices(primVertices))
+               throw new ArgumentException("Error when constructing PolyCurve");
+         }
+
+         public void BuildVerticesAndIndices()
+         {
+            foreach (PrimVertices primVertices in PrimVerticesList)
+            {
+               const int MinIndexValue = 1;
+
+               //1. Build point list.
+               //Current poly curve's end point and start point of primitive curve are always equal.
+               //So remove one of them from point list.
+               if (PointList.Count != 0)
+                  PointList.Points.RemoveAt(PointList.Count - 1);
+               PointList.AddPointList(primVertices.PointList);
+
+               //2. Build indices. Do not do it if poly curve contains poly line segments only.
+               PointBase endPoint = PointList.Last();
+               bool startEndPointsAreEqual = CoordsAreWithinVertexTol(PointList[0], endPoint);
+               SegmentIndices segmentIndices = null;
+               if (PolyLinesOnly)
+               {
+                  // Kind of workaround to ensure that the first and last points, if they are supposed to be 
+                  // the same, are exactly the same.
+                  if (startEndPointsAreEqual)
+                     PointList[0] = endPoint;
+               }
+               else
+               {
+                  if (SegmentsIndices == null)
+                     SegmentsIndices = new List<SegmentIndices>();
+
+                  if (primVertices as PolyLineVertices != null)
+                  {
+                     segmentIndices = new PolyLineIndices(primVertices.PointList.Count - 1);
+                  }
+                  else if (primVertices as ArcVertices != null)
+                  {
+                     segmentIndices = new ArcIndices();
+                  }
+                  else
+                     throw new ArgumentException("Unknown PrimVertices object");
+
+                  segmentIndices.CalcIndices(SegmentsIndices.Count == 0 ? MinIndexValue : SegmentsIndices.Last().GetEnd());
+
+                  // if start and end points of poly curve are equal we should remove duplicated point from vertices array.
+                  // Indices array should be updated accordingly ( to access end point programmer should use start index).
+                  if (startEndPointsAreEqual)
+                  {
+                     PointList.Points.RemoveAt(PointList.Count - 1);
+                     segmentIndices.SetEnd(MinIndexValue);
+                  }
+
+                  //TryMerge is implemented for polylines because we can easily merge two consecutive polyline segments.
+                  if (SegmentsIndices.Count == 0 || !SegmentsIndices.Last().TryMerge(segmentIndices))
+                     SegmentsIndices.Add(segmentIndices);
+               }
+            }
+         }
+
+         public bool AddPrimVertices(PrimVertices primVertices)
+         {
+            if (primVertices == null)
+               return false;
+
+            //PrimVertices class guarantees that number of points is always >= 2.
+            var curvePoints = primVertices.PointList.Points;
+            var pointsCount = curvePoints.Count;
+
+            PointBase currentStartPoint = PrimVerticesList.Count != 0 ? PrimVerticesList[0][0] : null;
+            PointBase currentEndPoint = PrimVerticesList.Count != 0 ? PrimVerticesList.Last().Last() : null;
+            bool addAtEnd = true;
+            bool reverseCurve = false;
+
+            if (currentStartPoint != null && currentEndPoint != null)
+            {
+               // Need to check all possible connections between the current curve and the
+               // existing curve by checking start and endpoints.
+
+               // For options to attach the next curve to the existing curve below.
+               if (!CoordsAreWithinVertexTol(curvePoints[0], currentEndPoint))
+               {
+                  if (CoordsAreWithinVertexTol(curvePoints[pointsCount - 1], currentEndPoint))
+                  {
+                     reverseCurve = true;
+                  }
+                  else
+                  {
+                     addAtEnd = false;
+                     if (CoordsAreWithinVertexTol(curvePoints[0], currentStartPoint))
+                     {
+                        reverseCurve = true;
+                     }
+                     else
+                     {
+                        //Neither start nor end point of Input curve coincide with any of this polycurve's edge points.
+                        //In this case we do not know how to connect them, so return false.
+                        return false;
+                     }
+                  }
+               }
+            }
+
+            if (reverseCurve)
+               curvePoints.Reverse();
+
+            if (primVertices as PolyLineVertices == null)
+               PolyLinesOnly = false;
+
+            if (addAtEnd)
+               PrimVerticesList.Add(primVertices);
+            else
+               PrimVerticesList.Insert(0, primVertices);
+
+            return true;
+         }
+      }
+
       /// <summary>
       /// Creates a default plane whose origin is at (0, 0, 0) and normal is (0, 0, 1).
       /// </summary>
@@ -550,42 +807,42 @@ private static void CollectSolidMeshGeometry(GeometryElement geomElem,
             // Add try catch here because in a rare cases we find solid that throws exception/invalid solid.Faces
             try
             {
-            Solid solid = geomObj as Solid;
-            if (solid != null && solid.Faces.Size > 0)
-            {
-               solidMeshCapsule.AddSolid(solid, containingElement);
-            }
-            else
-            {
-               Mesh mesh = geomObj as Mesh;
-               if (mesh != null)
+               Solid solid = geomObj as Solid;
+               if (solid != null && solid.Faces.Size > 0)
                {
-                  solidMeshCapsule.AddMesh(mesh);
+                  solidMeshCapsule.AddSolid(solid, containingElement);
                }
                else
                {
-                  // if the current geomObj is castable as a GeometryInstance, then we perform the same collection on its symbol geometry
-                  GeometryInstance inst = geomObj as GeometryInstance;
-
-                  if (inst != null)
+                  Mesh mesh = geomObj as Mesh;
+                  if (mesh != null)
+                  {
+                     solidMeshCapsule.AddMesh(mesh);
+                  }
+                  else
                   {
-                     try
+                     // if the current geomObj is castable as a GeometryInstance, then we perform the same collection on its symbol geometry
+                     GeometryInstance inst = geomObj as GeometryInstance;
+
+                     if (inst != null)
                      {
-                        GeometryElement instanceSymbol = inst.GetSymbolGeometry();
-                        if (instanceSymbol != null && instanceSymbol.Count() != 0)
+                        try
+                        {
+                           GeometryElement instanceSymbol = inst.GetSymbolGeometry();
+                           if (instanceSymbol != null && instanceSymbol.Count() != 0)
+                           {
+                              Transform instanceTransform = localTrf.Multiply(inst.Transform);
+                              CollectSolidMeshGeometry(instanceSymbol, inst.Symbol,
+                                 instanceTransform, solidMeshCapsule);
+                           }
+                        }
+                        catch
                         {
-                           Transform instanceTransform = localTrf.Multiply(inst.Transform);
-                           CollectSolidMeshGeometry(instanceSymbol, inst.Symbol,
-                              instanceTransform, solidMeshCapsule);
                         }
-                     }
-                     catch
-                     {
                      }
                   }
                }
             }
-         }
             catch
             {
             }
@@ -600,7 +857,7 @@ private static void CollectSolidMeshGeometry(GeometryElement geomElem,
       public static bool BoundaryHasSameSense(IFCAnyHandle boundary)
       {
          bool? hasSameSense = IFCAnyHandleUtil.GetBooleanAttribute(boundary, "Orientation");
-         return hasSameSense != null ? (bool)hasSameSense : false;
+         return hasSameSense.HasValue && hasSameSense.Value;
       }
 
       /// <summary>
@@ -701,7 +958,7 @@ public static void UpdateLocalPlacement(IFCAnyHandle localPlacement, IFCAnyHandl
          SetPlacementRelTo(localPlacement, newPlacementRelTo);
          SetRelativePlacement(localPlacement, newRelativePlacement);
       }
-      
+
       /// <summary>
       /// Get geometry of one level of a potentially multi-story stair, ramp, or railing.
       /// </summary>
@@ -1020,7 +1277,7 @@ private static IFCRange GetExtrusionRangeOfCurveLoop(CurveLoop loop, XYZ extrusi
          return range;
       }
 
-      private static bool IsInRange(IFCRange range, CurveLoop loop, Transform lcs, XYZ extrusionDirection, out bool clipCompletely)
+      private static bool IsInRange(IFCRange range, Transform lcs, XYZ extrusionDirection, out bool clipCompletely)
       {
          clipCompletely = false;
          if (range != null)
@@ -1078,7 +1335,7 @@ private static IFCAnyHandle ProcessClippingFace(ExporterIFC exporterIFC, CurveLo
          }
 
          bool clipCompletely;
-         if (!IsInRange(range, outerBoundary, boundaryLCS, extrusionDirection, out clipCompletely))
+         if (!IsInRange(range, boundaryLCS, extrusionDirection, out clipCompletely))
             return clipCompletely ? null : bodyItemHnd;
 
          if (MathUtil.IsAlmostZero(clippingSlant))
@@ -2585,29 +2842,48 @@ public static bool ProcessCurve(ExporterIFC exporterIFC, Curve curve, Transform
          return true;
       }
 
-      static IList<double> ScaledUVListFromXYZ(XYZ thePoint, Transform lcs, XYZ projectDir)
+      static UV ScaledUVListFromXYZ(XYZ thePoint, Transform lcs, XYZ projectDir)
       {
          UV projectPoint = GeometryUtil.ProjectPointToXYPlaneOfLCS(lcs, projectDir, thePoint);
-         projectPoint = UnitUtil.ScaleLength(projectPoint);
-         return new List<double>(2) { projectPoint.U, projectPoint.V };
+         return UnitUtil.ScaleLength(projectPoint);
       }
 
-      private static double DistanceSquaredBetweenVertices(IList<double> coord1, IList<double> coord2)
+      private static double DistanceSquaredBetweenVertices(XYZ coord1, XYZ coord2)
       {
-         int size = coord1.Count;
-         if (size != coord2.Count)
-            return double.MaxValue;     // Cannot compare lists of different number of members
+         var dX = coord1.X - coord2.X;
+         var dY = coord1.Y - coord2.Y;
+         var dZ = coord1.Z - coord2.Z;
 
-         double distSq = 0.0;
-         for (int ii = 0; ii < size; ++ii)
-         {
-            distSq += (coord1[ii] - coord2[ii]) * (coord1[ii] - coord2[ii]);
-         }
+         return dX * dX + dY * dY + dZ * dZ;
+      }
+      private static double DistanceSquaredBetweenVertices(UV coord1, UV coord2)
+      {
+         var dU = coord1.U - coord2.U;
+         var dV = coord1.V - coord2.V;
 
-         return distSq;
+         return dU * dU + dV * dV;
       }
 
-      private static bool CoordsAreWithinVertexTol(IList<double> coord1, IList<double> coord2)
+      private static bool CoordsAreWithinVertexTol(PointBase coord1, PointBase coord2)
+      {
+         double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
+         Point3D coord13D = coord1 as Point3D;
+         Point3D coord23D = coord2 as Point3D;
+         if (coord13D != null && coord23D != null)
+            return (DistanceSquaredBetweenVertices(coord13D.coords, coord23D.coords) < vertexTol * vertexTol);
+         Point2D coord12D = coord1 as Point2D;
+         Point2D coord22D = coord2 as Point2D;
+         if (coord12D != null && coord22D != null)
+            return (DistanceSquaredBetweenVertices(coord12D.coords, coord22D.coords) < vertexTol * vertexTol);
+
+         throw new ArgumentException("Invalid Point type");
+      }
+      private static bool CoordsAreWithinVertexTol(XYZ coord1, XYZ coord2)
+      {
+         double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
+         return (DistanceSquaredBetweenVertices(coord1, coord2) < vertexTol * vertexTol);
+      }
+      private static bool CoordsAreWithinVertexTol(UV coord1, UV coord2)
       {
          double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
          return (DistanceSquaredBetweenVertices(coord1, coord2) < vertexTol * vertexTol);
@@ -2623,47 +2899,20 @@ private static bool CoordsAreWithinVertexTol(IList<double> coord1, IList<double>
       /// <returns>IFCAnyHandle for the created IfcIndexedPolyCurve</returns>
       public static IFCAnyHandle CreatePolyCurveFromCurve(ExporterIFC exporterIFC, Curve curve, Transform lcs = null, XYZ projectDir = null)
       {
-         IList<IList<double>> pointList = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
-         if (pointList == null)
-            return null;
-
          IFCFile file = exporterIFC.GetFile();
-         IFCAnyHandle pointListHnd;
-         if (Is2DPointList(ref pointList))
-            pointListHnd = IFCInstanceExporter.CreateCartesianPointList2D(file, pointList);
-         else
-            pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
 
+         PrimVertices vertices = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
+         // Points from the curve may have been merged after projection, so skip curves that
+         // won't add any new points.
+         if (vertices == null)
+            return null;
 
-         IList<IList<int>> segmentIndexList = null;
-         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
-   }
-
-      static bool Is2DPointList(ref IList<IList<double>> pointList)
-      {
-         bool contains2DPoint = false;
-         bool contains3DPoint = false;
+         PolyCurve polyCurve = new PolyCurve(vertices);
+         polyCurve.BuildVerticesAndIndices();
+         IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
 
-         foreach (IList<double> pointCoord in pointList)
-         {
-            if (pointCoord.Count == 2)
-               contains2DPoint |= true;
-            else if (pointCoord.Count == 3)
-               contains3DPoint |= true;
-            else
-               throw (new ArgumentOutOfRangeException("pointList", "Only 2D or 3D point coordinates are valid!"));
-         }
-         if (contains2DPoint && contains3DPoint)
-         {
-            // Something is not right because of a mix of 2D and 3D coordinates. It will normalize below and discard the 3rd ordinate of 3D coordinates to 2D
-            for (int ii = 0; ii < pointList.Count; ++ii)
-            {
-               if (pointList[ii].Count == 3)
-                  pointList[ii].RemoveAt(2);
-            }
-         }
-
-         return contains2DPoint;
+         IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
+         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
       }
 
       /// <summary>
@@ -2680,88 +2929,31 @@ public static IFCAnyHandle CreatePolyCurveFromCurveLoop(ExporterIFC exporterIFC,
          if (curves.Count() == 0)
             return null;
 
-         bool use3DPoint = (lcs == null || projectDir == null);
-
          IFCFile file = exporterIFC.GetFile();
-         List<IList<double>> pointList = new List<IList<double>>();
-         
-         IList<double> currentStartPoint = null;
-         IList<double> currentEndPoint = null;
-         
+
+         PolyCurve polyCurve = null;
          foreach (Curve curve in curves)
          {
-            IList<IList<double>> curveCoords = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
-
+            PrimVertices vertices = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
             // Points from the curve may have been merged after projection, so skip curves that
             // won't add any new points.
-            if (curveCoords == null)
-               continue;
-
-            int curveCount = curveCoords.Count;
-            if (curveCoords.Count < 2)
+            if (vertices == null)
                continue;
 
-            bool removeDuplicatePoint = false;
-            bool addAtEnd = true;
-            bool reverseCurve = false;
-
-            if (currentStartPoint != null && currentEndPoint != null)
-            {
-               // Need to check all possible connections between the current curve and the
-               // existing curve by checking start and endpoints.
-               removeDuplicatePoint = true;
-
-               // For options to attach the next curve to the existing curve below.
-               if (!CoordsAreWithinVertexTol(curveCoords[0], currentEndPoint))
-               {
-                  if (CoordsAreWithinVertexTol(curveCoords[curveCount - 1], currentEndPoint))
-                  {
-                     reverseCurve = true;
-                  }
-                  else
-                  {
-                     addAtEnd = false;
-                     if (CoordsAreWithinVertexTol(curveCoords[0], currentStartPoint))
-                     {
-                        reverseCurve = true;
-                     }
-                  }
-               }
-            }
-
-            if (reverseCurve)
-               curveCoords.Reverse();
-
-            if (removeDuplicatePoint)
-               curveCoords.RemoveAt(addAtEnd ? 0 : curveCount-1);
-            
-            if (addAtEnd)
-               pointList.AddRange(curveCoords);
-            else
-               pointList.InsertRange(0, curveCoords);
-
-            currentStartPoint = pointList[0];
-            currentEndPoint = pointList[pointList.Count - 1];
+            if (polyCurve == null)
+               polyCurve = new PolyCurve(vertices);
+            else if (!polyCurve.AddPrimVertices(vertices))
+               return null;
          }
 
-         // Kind of workaround to ensure that the first and last points, if they are supposed to be 
-         // the same, are exactly the same.
-         if (CoordsAreWithinVertexTol(currentStartPoint, currentEndPoint))
-            pointList[pointList.Count - 1] = pointList[0];
-
-         // SegmentIndexList is not yet supported.
-         IList<IList<int>> segmentIndexList = null;
-
-         IFCAnyHandle pointListHnd;
-         if (use3DPoint)
-            pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
-         else
-            pointListHnd = IFCInstanceExporter.CreateCartesianPointList2D(file, pointList);
+         polyCurve.BuildVerticesAndIndices();
+         IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
 
-         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
+         IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
+         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
       }
 
-      private static IList<IList<double>> PointListFromCurve(ExporterIFC exporterIFC, Curve curve,
+      private static PrimVertices PointListFromCurve(ExporterIFC exporterIFC, Curve curve,
          Transform lcs, XYZ projectDir)
       {
          if (curve == null)
@@ -2769,100 +2961,146 @@ private static IList<IList<double>> PointListFromCurve(ExporterIFC exporterIFC,
 
          if (curve is Line)
             return PointListFromLine(exporterIFC, curve as Line, lcs, projectDir);
-         
+
          if (curve is Arc)
             return PointListFromArc(exporterIFC, curve as Arc, lcs, projectDir);
-         
-         return PointListFromGenericCurve(exporterIFC, curve, lcs, projectDir);
-      }
 
-      private static IList<double> Scaled3dListFromXYZ(ExporterIFC exporterIFC, XYZ thePoint)
-      {
-         XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, thePoint);
-         return new List<double>(3) { vertexScaled.X, vertexScaled.Y, vertexScaled.Z };
+         return PointListFromGenericCurve(exporterIFC, curve, lcs, projectDir);
       }
 
-      private static IList<IList<double>> PointListFromLine(ExporterIFC exporterIFC, Line line, 
+      private static PolyLineVertices PointListFromLine(ExporterIFC exporterIFC, Line line,
          Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         IList<double> startPoint = use3DPoint ?
-            Scaled3dListFromXYZ(exporterIFC, line.GetEndPoint(0)) :
-            ScaledUVListFromXYZ(line.GetEndPoint(0), lcs, projectDir);
-
-         IList<double> endPoint = use3DPoint ?
-            Scaled3dListFromXYZ(exporterIFC, line.GetEndPoint(1)) :
-            ScaledUVListFromXYZ(line.GetEndPoint(1), lcs, projectDir);
+         if (use3DPoint)
+         {
+            XYZ startPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, line.GetEndPoint(0));
+            XYZ endPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, line.GetEndPoint(1));
+            // Avoid consecutive duplicates
+            if (CoordsAreWithinVertexTol(startPoint, endPoint))
+               return null;
 
-         // Avoid consecutive duplicates
-         if (CoordsAreWithinVertexTol(startPoint, endPoint))
-            return null;
+            return new PolyLineVertices(startPoint, endPoint);
+         }
+         else
+         {
+            var startPoint = ScaledUVListFromXYZ(line.GetEndPoint(0), lcs, projectDir);
+            var endPoint = ScaledUVListFromXYZ(line.GetEndPoint(1), lcs, projectDir);
+            // Avoid consecutive duplicates
+            if (CoordsAreWithinVertexTol(startPoint, endPoint))
+               return null;
 
-         List<IList<double>> pointList = new List<IList<double>>();
-         pointList.Add(startPoint);
-         pointList.Add(endPoint);
-         return pointList;
+            return new PolyLineVertices(startPoint, endPoint);
+         }
       }
 
-      private static IList<IList<double>> PointListFromArc(ExporterIFC exporterIFC, Arc arc, 
+      private static PrimVertices PointListFromArc(ExporterIFC exporterIFC, Arc arc,
          Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         IList<IList<double>> pointList = new List<IList<double>>();
-         
-         // An integer value is used here to get an accurate interval the value ranges from
-         // 0 to 90 or 100 percent, depending on whether the arc is bound or not.
-         int normalizedEnd = arc.IsBound ? 10 : 9;
-         IList<double> lastPoint = null;
-         for (int ii = 0; ii <= normalizedEnd; ++ii)
+         if (use3DPoint && arc.IsBound)
          {
-            XYZ tessellationPt = arc.Evaluate(ii / 10.0, arc.IsBound);
-            IList<double> point = use3DPoint ?
-               Scaled3dListFromXYZ(exporterIFC, tessellationPt) :
-               ScaledUVListFromXYZ(tessellationPt, lcs, projectDir);
+            XYZ startPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(0, true));
+            XYZ midPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(0.5, true));
+            XYZ endPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(1, true));
 
-            // Avoid consecutive duplicates
-            if (lastPoint == null || !CoordsAreWithinVertexTol(point, lastPoint))
+            return new ArcVertices(startPoint, midPoint, endPoint);
+         }
+         else
+         {
+            //If arc's normal is parallel to projection direction and Z axis of lcs then projected arc will be of correct shape.
+            //That is why it can be defined by 3 points: start, mid, end.
+            if (MathUtil.VectorsAreParallel(arc.Normal, projectDir) && MathUtil.VectorsAreParallel(lcs.BasisZ, projectDir) && arc.IsBound)
+            {
+               var startPoint = ScaledUVListFromXYZ(arc.Evaluate(0, true), lcs, projectDir);
+               var midPoint = ScaledUVListFromXYZ(arc.Evaluate(0.5, true), lcs, projectDir);
+               var endPoint = ScaledUVListFromXYZ(arc.Evaluate(1, true), lcs, projectDir);
+
+               return new ArcVertices(startPoint, midPoint, endPoint);
+            }
+
+            //Handle cases when Arc is a circle (arc.IsBound == false) or projected arc is of incorrect shape
+            //and cannot be defined by 3 points. Tesselate it in this case.
+            List<XYZ> pointList3D = new List<XYZ>();
+            List<UV> pointList2D = new List<UV>();
+
+            // An integer value is used here to get an accurate interval the value ranges from
+            // 0 to 90 or 100 percent, depending on whether the arc is bound or not.
+            int normalizedEnd = arc.IsBound ? 10 : 9;
+            XYZ lastPoint3D = null;
+            UV lastPoint2D = null;
+            for (int ii = 0; ii <= normalizedEnd; ++ii)
             {
-               pointList.Add(point);
-               lastPoint = point;
+               XYZ tessellationPt = arc.Evaluate(ii / 10.0, arc.IsBound);
+               if (use3DPoint)
+               {
+                  XYZ point = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, tessellationPt);
+
+                  // Avoid consecutive duplicates
+                  if (lastPoint3D == null || !CoordsAreWithinVertexTol(point, lastPoint3D))
+                  {
+                     pointList3D.Add(point);
+                     lastPoint3D = point;
+                  }
+               }
+               else
+               {
+                  var point2D = ScaledUVListFromXYZ(tessellationPt, lcs, projectDir);
+
+                  // Avoid consecutive duplicates
+                  if (lastPoint2D == null || !CoordsAreWithinVertexTol(point2D, lastPoint2D))
+                  {
+                     pointList2D.Add(point2D);
+                     lastPoint2D = point2D;
+                  }
+               }
             }
-         }
 
-         if (pointList.Count < 2)
-            return null;
+            if (pointList3D != null && pointList3D.Count >= 2)
+               return new PolyLineVertices(pointList3D);
+            else if (pointList2D != null && pointList2D.Count >= 2)
+               return new PolyLineVertices(pointList2D);
+         }
 
-         return pointList;
+         return null;
       }
 
-      private static IList<IList<double>> PointListFromGenericCurve(ExporterIFC exporterIFC,
+      private static PolyLineVertices PointListFromGenericCurve(ExporterIFC exporterIFC,
          Curve curve, Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         IList<IList<double>> pointList = new List<IList<double>>();
+         List<XYZ> listXYZ = new List<XYZ>();
+         List<UV> listUV = new List<UV>();
+
          IList<XYZ> tessellatedCurve = curve.Tessellate();
-         IList<double> lastPoint = null;
-         for (int ii = 0; ii < tessellatedCurve.Count; ++ii)
+         var pointsCount = tessellatedCurve.Count;
+         for (int ii = 0; ii < pointsCount; ++ii)
          {
-            IList<double> point = use3DPoint ?
-               Scaled3dListFromXYZ(exporterIFC, tessellatedCurve[ii]) :
-               ScaledUVListFromXYZ(tessellatedCurve[ii], lcs, projectDir);
-
-            // Avoid consecutive duplicates
-            if (lastPoint == null || !CoordsAreWithinVertexTol(point, lastPoint))
+            if (use3DPoint)
+            {
+               var point = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, tessellatedCurve[ii]);
+               // Avoid consecutive duplicates
+               if (listXYZ.Count == 0 || !CoordsAreWithinVertexTol(point, listXYZ.Last()))
+                  listXYZ.Add(point);
+            }
+            else
             {
-               pointList.Add(point);
-               lastPoint = point;
+               var point = ScaledUVListFromXYZ(tessellatedCurve[ii], lcs, projectDir);
+               // Avoid consecutive duplicates
+               if (listUV.Count == 0 || !CoordsAreWithinVertexTol(point, listUV.Last()))
+                  listUV.Add(point);
             }
          }
 
-         if (pointList.Count < 2)
-            return null;
+         if (listXYZ != null && listXYZ.Count >= 2)
+            return new PolyLineVertices(listXYZ);
+         else if (listUV != null && listUV.Count >= 2)
+            return new PolyLineVertices(listUV);
 
-         return pointList;
+         return null;
       }
 
       static private bool AllowedCurveForAllowComplexBoundary(Curve curve)
@@ -3053,7 +3291,7 @@ public static IFCAnyHandle GetIndexedTriangles(IFCFile file, List<List<XYZ>> tri
          {
             coordList.Add(new List<double>(3));
          }
-         
+
          foreach (KeyValuePair<IFCFuzzyXYZ, int> vertexAndIndex in vertexMap)
          {
             IFCFuzzyXYZ vertex = vertexAndIndex.Key;
@@ -3413,15 +3651,18 @@ public static IFCAnyHandle CreateIFCCurveFromRevitCurve(IFCFile file, ExporterIF
 
          if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
          {
-            IList<IList<double>> pointList = PointListFromCurve(exporterIFC, curve, additionalTrf, null);
-            if (pointList == null)
+            PrimVertices vertices = PointListFromCurve(exporterIFC, curve, additionalTrf, null);
+            // Points from the curve may have been merged after projection, so skip curves that
+            // won't add any new points.
+            if (vertices == null)
                return null;
 
-            // Segment index list not yet supported.
-            IList<IList<int>> segmentIndexList = null;
+            PolyCurve polyCurve = new PolyCurve(vertices);
+            polyCurve.BuildVerticesAndIndices();
+            IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
 
-            IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
-            return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
+            IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
+            return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
          }
 
          // if the Curve is a line, do the following
@@ -3608,7 +3849,7 @@ public static IFCAnyHandle CreateIFCCurveFromRevitCurve(IFCFile file, ExporterIF
       /// <param name="thePoint">The point</param>
       /// <param name="cartesianPoints">A map of already created IfcCartesianPoints.  This argument may be null.</param>
       /// <returns>The handle representing IfcCartesianPoint</returns>
-      public static IFCAnyHandle XYZtoIfcCartesianPoint(ExporterIFC exporterIFC, XYZ thePoint, 
+      public static IFCAnyHandle XYZtoIfcCartesianPoint(ExporterIFC exporterIFC, XYZ thePoint,
          IDictionary<IFCFuzzyXYZ, IFCAnyHandle> cartesianPoints, Transform additionalTrf = null)
       {
          IFCFile file = exporterIFC.GetFile();
@@ -3786,7 +4027,7 @@ public static IFCAnyHandle GetExtrusionBaseProfile(ExporterIFC exporterIFC, Soli
             return null;
          }
       }
-      
+
       /// <summary>
       /// Attempt to get profile and simple material information from a FamilyInstance element.
       /// </summary>
@@ -3795,7 +4036,7 @@ public static IFCAnyHandle GetExtrusionBaseProfile(ExporterIFC exporterIFC, Soli
       /// <param name="basePlaneNormal">The normal used to try to find the profile.</param>
       /// <param name="basePlaneOrigin">The original for the profile.</param>
       /// <returns></returns>
-      public static MaterialAndProfile GetProfileAndMaterial(ExporterIFC exporterIFC, 
+      public static MaterialAndProfile GetProfileAndMaterial(ExporterIFC exporterIFC,
          Element element, XYZ basePlaneNormal, XYZ basePlaneOrigin)
       {
          MaterialAndProfile materialAndProfile = new MaterialAndProfile();
@@ -3820,7 +4061,7 @@ public static MaterialAndProfile GetProfileAndMaterial(ExporterIFC exporterIFC,
             XYZ projDir = XYZ.BasisZ;
             try
             {
-               CurveLoop curveloop = CurveLoop.Create(profileCurves);              
+               CurveLoop curveloop = CurveLoop.Create(profileCurves);
                if (curveloop.HasPlane())
                   projDir = curveloop.GetPlane().Normal;
             }
@@ -3861,7 +4102,7 @@ public static MaterialAndProfile GetProfileAndMaterial(ExporterIFC exporterIFC,
                   if (solid == null || solid.Faces.IsEmpty || solid.Edges.IsEmpty)
                      continue;
 
-                  ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, exporterIFC, familyInstance);
+                  ElementId materialId = BodyExporter.GetBestMaterialIdFromGeometryOrParameter(solid, familyInstance);
                   IFCAnyHandle profileDef = GetExtrusionBaseProfile(exporterIFC, solid, profileName, basePlane, basePlaneOrigin, out extrusionEndFaces);
                   if (!IFCAnyHandleUtil.IsNullOrHasNoValue(profileDef))
                      materialAndProfile.Add(materialId, profileDef);
@@ -3935,7 +4176,7 @@ public static bool PlaneIntersect(Plane plane, Curve curve, out IList<XYZ> inter
             return false;              // Supports only a planar based curve
 
          // Get the plane where the curve lies
-         Plane planeOfCurve = planarPlaneOf(curve);
+         Plane planeOfCurve = PlanarPlaneOf(curve);
          if (plane.Normal.IsAlmostEqualTo(planeOfCurve.Normal))
             return false;                 // THe planes are parallel to each other, no intersection
 
@@ -3963,7 +4204,7 @@ public static bool PlaneIntersect(Plane plane, Curve curve, out IList<XYZ> inter
          return true;
       }
 
-      public static Plane planarPlaneOf(Curve curve)
+      public static Plane PlanarPlaneOf(Curve curve)
       {
          // We will only try up to six different parameters to find the 3rd point on the curve.
          IList<double> parToTry = new List<double>() { 0.15, 0.3, 0.45, 0.6, 0.75, 0.9 };
@@ -4234,7 +4475,7 @@ public static double GetAngleOfFace(Face face, XYZ projection)
       public static List<Curve> GetCurvesFromGeometryElement(GeometryElement geomElem)
       {
          List<Curve> curveList = new List<Curve>();
-         foreach(GeometryObject geomObject in geomElem)
+         foreach (GeometryObject geomObject in geomElem)
          {
             if (geomObject is GeometryElement)
             {
@@ -4277,15 +4518,13 @@ public static bool SolidsQuickEqualityCompare(Solid solid1, Solid solid2)
          else
             return false;
       }
-      public static Transform GetWCS(Document doc)
+      public static Transform GetWCS(Document doc, double unscaledElevation)
       {
          Transform trf = null;
          ProjectLocation projLocation = doc.ActiveProjectLocation;
          if (projLocation == null)
             return trf;
 
-         double unscaledElevation = 0.0;
-         ExporterUtil.GetSafeProjectPositionElevation(doc, out unscaledElevation);
          SiteTransformBasis transformBasis = ExporterCacheManager.ExportOptionsCache.SiteTransformation;
 
          trf = Transform.Identity;
@@ -4309,9 +4548,7 @@ public static Transform GetWCS(Document doc)
 
          if (!trf.IsIdentity)
          {
-            double unscaledSiteElevation = ExporterCacheManager.ExportOptionsCache.IncludeSiteElevation ? 0.0 : unscaledElevation;
-            XYZ orig = UnitUtil.ScaleLength(trf.Origin - new XYZ(0, 0, unscaledSiteElevation));
-
+            XYZ orig = UnitUtil.ScaleLength(trf.Origin - new XYZ(0, 0, unscaledElevation));
             trf = CreateTransformFromVectorsAndOrigin(trf.BasisX, trf.BasisY, trf.BasisZ, orig);
          }
 
diff --git a/Source/Revit.IFC.Export/Utility/MEPCache.cs b/Source/Revit.IFC.Export/Utility/MEPCache.cs
index 0ba3f0ce..f865c4ed 100644
--- a/Source/Revit.IFC.Export/Utility/MEPCache.cs
+++ b/Source/Revit.IFC.Export/Utility/MEPCache.cs
@@ -58,6 +58,11 @@ public class MEPCache
       /// </summary>
       public Dictionary<Connector, IFCAnyHandle> ConnectorCache = new Dictionary<Connector, IFCAnyHandle>();
 
+      /// <summary>
+      /// The dictionary mapping from an exported connector to its description string. 
+      /// </summary>
+      public Dictionary<Connector, string> ConnectorDescriptionCache = new Dictionary<Connector, string>();
+
       /// <summary>
       /// Finds the Ifc handle from the dictionary.
       /// </summary>
diff --git a/Source/Revit.IFC.Export/Utility/ParameterUtil.cs b/Source/Revit.IFC.Export/Utility/ParameterUtil.cs
index 84c7cdf3..a24e8020 100644
--- a/Source/Revit.IFC.Export/Utility/ParameterUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/ParameterUtil.cs
@@ -70,63 +70,42 @@ public static void ClearParameterCache()
       private static Parameter GetStringValueFromElementBase(Element element, string propertyName, bool allowUnset, out string propertyValue)
       {
          propertyValue = string.Empty;
-         if (element == null)
-            return null;
-
-         if (String.IsNullOrEmpty(propertyName))
+         if (element == null || string.IsNullOrEmpty(propertyName))
             return null;
 
          ElementId elementId = element.Id;
-
          Parameter parameter = GetParameterFromName(elementId, null, propertyName);
 
-         if (parameter != null)
+         if (parameter == null)
+            return null;
+
+         if (parameter.HasValue)
          {
             StorageType storageType = parameter.StorageType;
-            if (storageType == StorageType.Double || (storageType == StorageType.Integer && parameter.GetTypeId() != SpecTypeId.Boolean.YesNo))
+            if (!(storageType == StorageType.ElementId &&
+                  parameter.AsElementId() == ElementId.InvalidElementId))
             {
-               if (parameter.HasValue)
+               propertyValue = parameter.AsValueString();
+               if (!string.IsNullOrEmpty(propertyValue))
                {
-                  propertyValue = parameter.AsValueString();
-                  return parameter;
-               }
-            }
-            else if (storageType != StorageType.String && storageType != StorageType.ElementId)
-               return null;
-
-            if (parameter.HasValue)
-            {
-               if (storageType == StorageType.String)
-               {
-                  string propValue = parameter.AsString();
-                  if (!string.IsNullOrEmpty(propValue))
+                  if (storageType == StorageType.String)
                   {
-                     object strValue = null;
-                     ParamExprResolver.CheckForParameterExpr(propValue, element, propertyName, ParamExprResolver.ExpectedValueEnum.STRINGVALUE,
-                              out strValue);
-                     if (strValue != null && strValue is string)
+                     ParamExprResolver.CheckForParameterExpr(propertyValue, element,
+                        propertyName, ParamExprResolver.ExpectedValueEnum.STRINGVALUE,
+                        out object strValue);
+                     if (strValue is string)
                         propertyValue = strValue as string;
-                     else
-                        propertyValue = propValue;    // return the original propValue (un-trimmed)
-
-                     return parameter;
                   }
-               }
-               else if ( storageType == StorageType.ElementId && parameter.AsElementId() != null)
-               {
-                  propertyValue = PropertyUtil.ElementIdParameterAsString(parameter);
                   return parameter;
                }
             }
-
-            if (allowUnset)
-            {
-               propertyValue = null;
-               return parameter;
-            }
          }
 
-         return null;
+         if (!allowUnset)
+            return null;
+
+         propertyValue = null;
+         return parameter;
       }
 
       /// <summary>
@@ -285,32 +264,14 @@ public static Parameter GetStringValueFromElement(Element element, BuiltInParame
          if (builtInParameter == BuiltInParameter.INVALID)
             throw new ArgumentException("BuiltInParameter is INVALID", "builtInParameter");
 
-         propertyValue = String.Empty;
+         propertyValue = string.Empty;
 
-         if (element == null)
+         Parameter parameter = element?.get_Parameter(builtInParameter);
+         if (!(parameter?.HasValue ?? false))
             return null;
 
-         Parameter parameter = element.get_Parameter(builtInParameter);
-         if (parameter != null && parameter.HasValue)
-         {
-            switch (parameter.StorageType)
-            {
-               case StorageType.Double:
-                  propertyValue = parameter.AsDouble().ToString();
-                  return parameter;
-               case StorageType.Integer:
-                  propertyValue = parameter.AsInteger().ToString();
-                  return parameter;
-               case StorageType.String:
-                  propertyValue = parameter.AsString();
-                  return parameter;
-               case StorageType.ElementId:
-                  propertyValue = PropertyUtil.ElementIdParameterAsString(parameter);
-                  return parameter;
-            }
-         }
-
-         return null;
+         propertyValue = parameter.AsValueString();
+         return parameter;
       }
 
       /// <summary>Gets string value from built-in parameter of an element or its type.</summary>
@@ -340,7 +301,7 @@ public static Parameter GetStringValueFromElementOrSymbol(Element element, Eleme
          Parameter parameter = GetStringValueFromElement(element, builtInParameter, out propertyValue);
          if (parameter != null)
          {
-            if (!String.IsNullOrEmpty(propertyValue))
+            if (!string.IsNullOrEmpty(propertyValue))
                return parameter;
          }
 
@@ -351,7 +312,7 @@ public static Parameter GetStringValueFromElementOrSymbol(Element element, Eleme
          if (elementType != null)
          {
             parameter = GetStringValueFromElement(elementType, builtInParameter, out propertyValue);
-            if ((parameter != null) && !nullAllowed && String.IsNullOrEmpty(propertyValue))
+            if ((parameter != null) && !nullAllowed && string.IsNullOrEmpty(propertyValue))
                parameter = null;
          }
 
@@ -404,18 +365,12 @@ public static Parameter GetDoubleValueFromElement(Element element, BuiltInParame
 
          propertyValue = 0.0;
 
-         if (element == null)
+         Parameter parameter = element?.get_Parameter(builtInParameter);
+         if (!(parameter?.HasValue ?? false) || parameter.StorageType != StorageType.Double)
             return null;
 
-         Parameter parameter = element.get_Parameter(builtInParameter);
-
-         if (parameter != null && parameter.HasValue && parameter.StorageType == StorageType.Double)
-         {
-            propertyValue = parameter.AsDouble();
-            return parameter;
-         }
-
-         return null;
+         propertyValue = parameter.AsDouble();
+         return parameter;
       }
 
       /// <summary>
@@ -434,18 +389,12 @@ public static Parameter GetIntValueFromElement(Element element, BuiltInParameter
 
          propertyValue = 0;
 
-         if (element == null)
+         Parameter parameter = element?.get_Parameter(builtInParameter);
+         if (!(parameter?.HasValue ?? false) || parameter.StorageType != StorageType.Integer)
             return null;
 
-         Parameter parameter = element.get_Parameter(builtInParameter);
-
-         if (parameter != null && parameter.HasValue && parameter.StorageType == StorageType.Integer)
-         {
-            propertyValue = parameter.AsInteger();
-            return parameter;
-         }
-
-         return null;
+         propertyValue = parameter.AsInteger();
+         return parameter;
       }
 
       /// <summary>
@@ -557,17 +506,12 @@ public static Parameter GetElementIdValueFromElement(Element element, BuiltInPar
 
          propertyValue = ElementId.InvalidElementId;
 
-         if (element == null)
+         Parameter parameter = element?.get_Parameter(builtInParameter);
+         if (!(parameter?.HasValue ?? false) || parameter.StorageType != StorageType.ElementId)
             return null;
 
-         Parameter parameter = element.get_Parameter(builtInParameter);
-         if (parameter != null && parameter.HasValue && parameter.StorageType == StorageType.ElementId)
-         {
-            propertyValue = parameter.AsElementId();
-            return parameter;
-         }
-
-         return null;
+         propertyValue = parameter.AsElementId();
+         return parameter;
       }
 
       /// <summary>
@@ -629,10 +573,9 @@ public static IList<ElementId> FindMaterialParameters(Element element)
       /// <returns>The parameter.</returns>
       static private Parameter getParameterByNameFromCache(ElementId elementId, string propertyName)
       {
-         Parameter parameter = null;
          string cleanPropertyName = NamingUtil.RemoveSpaces(propertyName);
 
-         if (m_IFCParameters[elementId].ParameterCache.TryGetValue(cleanPropertyName, out parameter))
+         if (m_IFCParameters[elementId].ParameterCache.TryGetValue(cleanPropertyName, out Parameter parameter))
             return parameter;
 
          foreach (ParameterElementCache otherCache in m_NonIFCParameters[elementId].Values)
@@ -654,17 +597,16 @@ static private Parameter getParameterByNameFromCache(ElementId elementId, string
       static private Parameter getParameterByNameFromCache(ElementId elementId, BuiltInParameterGroup group,
           string propertyName)
       {
-         Parameter parameter = null;
          string cleanPropertyName = NamingUtil.RemoveSpaces(propertyName);
 
+         Parameter parameter = null;
          if (group == BuiltInParameterGroup.PG_IFC)
          {
             m_IFCParameters[elementId].ParameterCache.TryGetValue(cleanPropertyName, out parameter);
             return parameter;
          }
 
-         ParameterElementCache otherCache = null;
-         m_NonIFCParameters[elementId].TryGetValue(group, out otherCache);
+         m_NonIFCParameters[elementId].TryGetValue(group, out ParameterElementCache otherCache);
          if (otherCache != null)
             otherCache.ParameterCache.TryGetValue(cleanPropertyName, out parameter);
          return parameter;
diff --git a/Source/Revit.IFC.Export/Utility/RepresentationUtil.cs b/Source/Revit.IFC.Export/Utility/RepresentationUtil.cs
index 38c06204..ed6c5352 100644
--- a/Source/Revit.IFC.Export/Utility/RepresentationUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/RepresentationUtil.cs
@@ -950,7 +950,7 @@ public static void CreateRepForShapeAspect(ExporterIFC exporterIFC, Element host
          if (IFCAnyHandleUtil.IsSubTypeOf(hostProdDefShape, IFCEntityType.IfcProductRepresentation))
          {
             IFCAnyHandle representationOfItem = RepresentationUtil.CreateShapeRepresentation(exporterIFC, hostElement, catId, contextOfItems, shapeIdent, repType, itemRepSet);
-            IFCAnyHandle shapeAspect = IFCInstanceExporter.CreateShapeAspect(exporterIFC.GetFile(), new List<IFCAnyHandle>() { representationOfItem }, aspectName, null, null, hostProdDefShape);
+            IFCInstanceExporter.CreateShapeAspect(exporterIFC.GetFile(), new List<IFCAnyHandle>() { representationOfItem }, aspectName, null, null, hostProdDefShape);
          }
          else if (IFCAnyHandleUtil.IsSubTypeOf(hostProdDefShape, IFCEntityType.IfcRepresentationMap))
          {
@@ -958,7 +958,7 @@ public static void CreateRepForShapeAspect(ExporterIFC exporterIFC, Element host
             string representationType = IFCAnyHandleUtil.GetRepresentationType(representation);
             IFCAnyHandle representationOfItem = RepresentationUtil.CreateShapeRepresentation(exporterIFC, hostElement, catId, contextOfItems, shapeIdent,
                representationType, itemRepSet);
-            IFCAnyHandle shapeAspect = IFCInstanceExporter.CreateShapeAspect(exporterIFC.GetFile(), new List<IFCAnyHandle>() { representationOfItem }, aspectName, null, null, hostProdDefShape);
+            IFCInstanceExporter.CreateShapeAspect(exporterIFC.GetFile(), new List<IFCAnyHandle>() { representationOfItem }, aspectName, null, null, hostProdDefShape);
          }
       }
 
diff --git a/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs b/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
index d47b94f1..442b71e5 100644
--- a/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
@@ -362,6 +362,13 @@ public TriangleMergeUtil(TriangulatedShellComponent triangulatedBody)
       {
          m_Geom = triangulatedBody;
          m_MeshGeom = null;
+         m_MeshVertices.Clear();
+         int idx = 0;
+         foreach(XYZ vert in triangulatedBody.GetVertices())
+         {
+            m_MeshVertices.Add(idx, vert);
+            idx++;
+         }
       }
 
       /// <summary>
@@ -470,9 +477,9 @@ public static XYZ NormalByNewellMethod(IList<XYZ> vertices)
       /// <summary>
       /// Combine coplanar triangles from the faceted body if they share the edge. From this process, polygonal faces (with or without holes) will be created
       /// </summary>
-      public void SimplifyAndMergeFaces()
+      public void SimplifyAndMergeFaces(bool ignoreMerge = false)
       {
-         int eulerBefore = CalculateEulerCharacteristic();
+         int eulerBefore = ignoreMerge ? 0 : CalculateEulerCharacteristic();
 
          int noTriangle = (IsMesh) ? m_MeshGeom.NumTriangles : m_Geom.TriangleCount;
          IEqualityComparer<XYZ> normalComparer = new VectorCompare();
@@ -513,7 +520,13 @@ public void SimplifyAndMergeFaces()
             List<int> mergedFaceList = null;
             if (fListDict.Value.Count > 1)
             {
-               TryMergeFaces(fListDict.Value, out mergedFaceList);
+               if (!ignoreMerge)
+                  TryMergeFaces(fListDict.Value, out mergedFaceList);
+               else
+               {
+                  // keep original face list
+                  mergedFaceList = fListDict.Value;
+               }
                if (mergedFaceList != null && mergedFaceList.Count > 0)
                {
                   // insert only new face indexes as the mergedlist from different vertices can be duplicated
@@ -528,7 +541,7 @@ public void SimplifyAndMergeFaces()
                m_MergedFaceSet.Add(fListDict.Value[0]);    // No pair face, add it into the mergedList
          }
 
-         int eulerAfter = CalculateEulerCharacteristic();
+         int eulerAfter = ignoreMerge ? 0 : CalculateEulerCharacteristic();
          if (eulerBefore != eulerAfter)
             throw new InvalidOperationException(); // Coplanar merge broke the mesh in some way, so we need to fall back to exporting a triangular mesh
       }
diff --git a/Source/Revit.IFC.Export/Utility/UnitUtil.cs b/Source/Revit.IFC.Export/Utility/UnitUtil.cs
index c36bd5b7..f0ae6588 100644
--- a/Source/Revit.IFC.Export/Utility/UnitUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/UnitUtil.cs
@@ -115,6 +115,16 @@ static public double ScalePower(double unscaledPower)
          return ScaleDouble(SpecTypeId.HvacPower, unscaledPower);
       }
 
+      /// <summary>
+      /// Converts a sound power value in Revit internal units to IFC units.
+      /// </summary>
+      /// <param name="unscaledPower">The power value in Revit internal units.</param>
+      /// <returns>The power in IFC units.</returns>
+      static public double ScaleSoundPower(double unscaledPower)
+      {
+         return ScaleDouble(SpecTypeId.Wattage, unscaledPower);
+      }
+
       /// <summary>
       /// Converts an area in Revit internal units to IFC units.
       /// </summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCBuilding.cs b/Source/Revit.IFC.Import/Data/IFCBuilding.cs
index 849684b6..40913934 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuilding.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuilding.cs
@@ -58,6 +58,13 @@ protected override void Process(IFCAnyHandle ifcBuilding)
          base.Process(ifcBuilding);
       }
 
+      public override void PostProcess()
+      {
+         TryToFixFarawayOrigin();
+         base.PostProcess();
+      }
+
+
       /// <summary>
       /// Allow for override of IfcObjectDefinition shared parameter names.
       /// </summary>
@@ -102,6 +109,8 @@ protected override void Create(Document doc)
       {
          base.Create(doc);
 
+         IFCLocation.WarnIfFaraway(this);
+
          // IfcBuilding usually won't create an element, as it contains no geometry.
          // If it doesn't, use the ProjectInfo element in the document to store its parameters.
          if (CreatedElementId == ElementId.InvalidElementId)
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingElementComponent.cs b/Source/Revit.IFC.Import/Data/IFCBuildingElementComponent.cs
index 03a99f61..8061a913 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingElementComponent.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingElementComponent.cs
@@ -17,16 +17,9 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Revit.IFC.Common.Enums;
-using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Common.Utility;
-using Revit.IFC.Import.Enums;
-using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import.Data
 {
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingElementPart.cs b/Source/Revit.IFC.Import/Data/IFCBuildingElementPart.cs
index 48c6e2a5..96d3d2ae 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingElementPart.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingElementPart.cs
@@ -17,16 +17,9 @@
 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 //
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Revit.IFC.Common.Enums;
-using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Common.Utility;
-using Revit.IFC.Import.Enums;
-using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import.Data
 {
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
index 0f2ece67..b5df9eac 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
@@ -98,7 +98,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, null, Elevation, Id);
+            IFCPropertySet.AddParameterDouble(doc, element, category, this, "IfcElevation", SpecTypeId.Length, UnitTypeId.Feet, Elevation, Id);
          }
       }
 
@@ -108,6 +108,8 @@ protected override void CreateParametersInternal(Document doc, Element element)
       /// <param name="doc">The document.</param>
       protected override void Create(Document doc)
       {
+         IFCLocation.WarnIfFaraway(this);
+
          // We may re-use the ActiveView Level and View, since we can't delete them.
          // We will consider that we "created" this level and view for creation metrics.
          Level level = Importer.TheCache.UseElementByGUID<Level>(doc, GlobalId);
@@ -191,6 +193,12 @@ protected override void Process(IFCAnyHandle ifcIFCBuildingStorey)
          Elevation = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcIFCBuildingStorey, "Elevation", 0.0);
       }
 
+      public override void PostProcess()
+      {
+         TryToFixFarawayOrigin();
+         base.PostProcess();
+      }
+
       /// <summary>
       /// The elevation.
       /// </summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCComplexProperty.cs b/Source/Revit.IFC.Import/Data/IFCComplexProperty.cs
index 2db6da22..0518ee42 100644
--- a/Source/Revit.IFC.Import/Data/IFCComplexProperty.cs
+++ b/Source/Revit.IFC.Import/Data/IFCComplexProperty.cs
@@ -32,40 +32,23 @@ namespace Revit.IFC.Import.Data
    /// </summary>-
    public class IFCComplexProperty : IFCProperty
    {
-      /// <summary>
-      /// The properties in the complex property.
-      /// </summary>
-      IDictionary<string, IFCProperty> m_IFCProperties = new Dictionary<string, IFCProperty>();
-
-      /// <summary>
-      /// The usage name.
-      /// </summary>
-      string m_UsageName;
-
       /// <summary>
       /// The usage name.
       /// </summary>
-      public string UsageName
-      {
-         get { return m_UsageName; }
-         protected set { m_UsageName = value; }
-      }
+      public string UsageName { get; protected set; } = null;
 
       /// <summary>
       /// The IFC properties.
       /// </summary>
-      public IDictionary<string, IFCProperty> IFCProperties
-      {
-         get { return m_IFCProperties; }
-      }
-
+      public IDictionary<string, IFCProperty> IFCProperties { get; } = new Dictionary<string, IFCProperty>();
+      
       /// <summary>
       /// Returns the property value as a string, for Set().
       /// </summary>
       /// <returns>The property value as a string.</returns>
       public override string PropertyValueAsString()
       {
-         int numValues = (IFCProperties != null) ? IFCProperties.Count : 0;
+         int numValues = IFCProperties.Count;
          if (numValues == 0)
             return "";
 
diff --git a/Source/Revit.IFC.Import/Data/IFCCompositeCurve.cs b/Source/Revit.IFC.Import/Data/IFCCompositeCurve.cs
index 14b139c6..32b5ebd8 100644
--- a/Source/Revit.IFC.Import/Data/IFCCompositeCurve.cs
+++ b/Source/Revit.IFC.Import/Data/IFCCompositeCurve.cs
@@ -167,7 +167,7 @@ protected override void Process(IFCAnyHandle ifcCurve)
          if (segments == null)
             Importer.TheLog.LogError(Id, "Invalid IfcCompositeCurve with no segments.", true);
 
-         double shortCurveTol = Importer.TheProcessor.ShortCurveTolerance;
+         double shortCurveTol = IFCImportFile.TheFile.ShortCurveTolerance;
 
          // need List<> so that we can AddRange later.
          List<Curve> curveSegments = new List<Curve>();
@@ -216,11 +216,12 @@ protected override void Process(IFCAnyHandle ifcCurve)
             XYZ curveLoopStartPoint = curveSegments[0].GetEndPoint(0);
             XYZ curveLoopEndPoint = curveSegments[0].GetEndPoint(1);
 
-            double vertexEps = Importer.TheProcessor.VertexTolerance;
+            double vertexEps = IFCImportFile.TheFile.VertexTolerance;
 
             // This is intended to be "relatively large".  The idea here is that the user would rather have the information presented
             // than thrown away because of a gap that is architecturally insignificant.
-            double gapVertexEps = Math.Max(vertexEps, IFCImportFile.TheFile.OneHundrethOfAFoot); // 1/100th of a foot, or 3.048 mm.
+            const double oneHundrethOfAFoot = 0.01;
+            double gapVertexEps = Math.Max(vertexEps, oneHundrethOfAFoot); // 1/100th of a foot, or 3.048 mm.
 
             // canRepairFirst may change over time, as we may potentially add curves to the start of the CurveLoop.
             bool canRepairFirst = (curveSegments[0] is Line);
diff --git a/Source/Revit.IFC.Import/Data/IFCCurve.cs b/Source/Revit.IFC.Import/Data/IFCCurve.cs
index 78212986..ef70a069 100644
--- a/Source/Revit.IFC.Import/Data/IFCCurve.cs
+++ b/Source/Revit.IFC.Import/Data/IFCCurve.cs
@@ -228,7 +228,7 @@ public Curve ConvertCurveLoopIntoSingleCurve()
          Curve firstCurve = curveIterator.Current;
          Curve returnCurve = null;
 
-         double vertexEps = Importer.TheProcessor.VertexTolerance;
+         double vertexEps = IFCImportFile.TheFile.VertexTolerance;
 
          // We only connect the curves if they are Line, Arc or Ellipse
          if (!((firstCurve is Line) || (firstCurve is Arc) || (firstCurve is Ellipse)))
@@ -483,7 +483,7 @@ public static IFCCurve ProcessIFCCurve(IFCAnyHandle ifcCurve)
 
       private Curve CreateTransformedCurve(Curve baseCurve, IFCRepresentation parentRep, Transform lcs)
       {
-         Curve transformedCurve = (baseCurve != null) ? baseCurve.CreateTransformed(lcs) : null;
+         Curve transformedCurve = baseCurve?.CreateTransformed(lcs);
          if (transformedCurve == null)
          {
             Importer.TheLog.LogWarning(Id, "couldn't create curve for " +
@@ -529,10 +529,13 @@ protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditSco
 
          // TODO: set graphics style for footprint curves.
          IFCRepresentationIdentifier repId = (parentRep == null) ? IFCRepresentationIdentifier.Unhandled : parentRep.Identifier;
-         bool createModelGeometry = (repId == IFCRepresentationIdentifier.Body) || (repId == IFCRepresentationIdentifier.Axis) || (repId == IFCRepresentationIdentifier.Unhandled);
+         bool createModelGeometry = (repId == IFCRepresentationIdentifier.Body) || 
+            (repId == IFCRepresentationIdentifier.Axis) || 
+            (repId == IFCRepresentationIdentifier.Unhandled);
+         bool createFootprintGeometry = (repId == IFCRepresentationIdentifier.FootPrint);
 
          ElementId gstyleId = ElementId.InvalidElementId;
-         if (createModelGeometry)
+         if (createModelGeometry || createFootprintGeometry)
          {
             Category curveCategory = IFCCategoryUtil.GetSubCategoryForRepresentation(shapeEditScope.Document, Id, parentRep.Identifier);
             if (curveCategory != null)
@@ -545,16 +548,14 @@ protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditSco
 
          foreach (Curve curve in transformedCurves)
          {
-            if (createModelGeometry)
-            {
+            if (gstyleId != ElementId.InvalidElementId)
                curve.SetGraphicsStyleId(gstyleId);
+  
+            // If it is not model geometry, assume it is a plan view curve.
+            if (createModelGeometry)
                shapeEditScope.AddGeometry(IFCSolidInfo.Create(Id, curve));
-            }
             else
-            {
-               // Default: assume a plan view curve.
                shapeEditScope.AddFootprintCurve(curve);
-            }
          }
       }
    }
diff --git a/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs b/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
index 8af9a2aa..92d67004 100644
--- a/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
+++ b/Source/Revit.IFC.Import/Data/IFCDistributionPort.cs
@@ -19,14 +19,11 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Common.Enums;
 using Revit.IFC.Common.Utility;
 using Revit.IFC.Import.Enums;
-using Revit.IFC.Import.Geometry;
 using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import.Data
@@ -36,16 +33,10 @@ namespace Revit.IFC.Import.Data
    /// </summary>
    public class IFCDistributionPort : IFCPort
    {
-      private IFCFlowDirection m_FlowDirection = IFCFlowDirection.NotDefined;
-
       /// <summary>
       /// The flow direction of this port.
       /// </summary>
-      public IFCFlowDirection FlowDirection
-      {
-         get { return m_FlowDirection; }
-         protected set { m_FlowDirection = value; }
-      }
+      public IFCFlowDirection FlowDirection { get; protected set; } = IFCFlowDirection.NotDefined;
 
       /// <summary>
       /// Default constructor.
@@ -93,15 +84,25 @@ protected override void CreateParametersInternal(Document doc, Element element)
       /// <param name="doc">The document.</param>
       protected override void Create(Document doc)
       {
-         Transform lcs = (ObjectLocation != null) ? ObjectLocation.TotalTransform : Transform.Identity;
+         // Try to get the location:
+         // 1. From the ObjectLocation, if it exists.  This should be exact.
+         // 2. From the ObjectLocation of the element that the port is associated to, if it exists.
+         // This should be approximate.
+         // 3. Default to the origin.
+         Transform lcs = ObjectLocation?.TotalTransform;
+         if (lcs == null)
+            lcs = ContainedIn?.ObjectLocation?.TotalTransform;
+         if (lcs == null)
+            lcs = Transform.Identity;
 
          // 2016+ only.
-         Point point = Point.Create(lcs.Origin, GraphicsStyleId);
+         XYZ origin = lcs.Origin;
+         Point point = XYZ.IsWithinLengthLimits(origin) ? Point.Create(origin, GraphicsStyleId) : null;
 
          // 2015+: create cone(s) for the direction of flow.
          CurveLoop rightTrangle = new CurveLoop();
-         double radius = IFCImportFile.TheFile.OneHundrethOfAFoot * 4.0;
-         double height = IFCImportFile.TheFile.OneHundrethOfAFoot * 12.0;
+         const double radius = 0.04;
+         const double height = 0.12;
 
          SolidOptions solidOptions = new SolidOptions(ElementId.InvalidElementId, GraphicsStyleId);
 
diff --git a/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs b/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
index c9a881e3..c3d1ff9d 100644
--- a/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
+++ b/Source/Revit.IFC.Import/Data/IFCElementQuantity.cs
@@ -140,7 +140,6 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
             quantity.Create(doc, element, category, objDef, parameterGroupMap, Name, parametersCreated);
          }
 
-         CreateScheduleForPropertySet(doc, element, category, parameterGroupMap, parametersCreated);
          return Tuple.Create(quotedName, true);
       }
    }
diff --git a/Source/Revit.IFC.Import/Data/IFCFaceBound.cs b/Source/Revit.IFC.Import/Data/IFCFaceBound.cs
index 46de5dda..be71a58a 100644
--- a/Source/Revit.IFC.Import/Data/IFCFaceBound.cs
+++ b/Source/Revit.IFC.Import/Data/IFCFaceBound.cs
@@ -176,7 +176,7 @@ private void CreateTessellatedShapeInternal(IFCImportShapeEditScope shapeEditSco
                }
                else
                {
-                  double vertexEps = Importer.TheProcessor.VertexTolerance;
+                  double vertexEps = IFCImportFile.TheFile.VertexTolerance;
 
                   for (int index = 0; index < count; index++)
                   {
diff --git a/Source/Revit.IFC.Import/Data/IFCGridAxis.cs b/Source/Revit.IFC.Import/Data/IFCGridAxis.cs
index 167438ec..fa2ec6ca 100644
--- a/Source/Revit.IFC.Import/Data/IFCGridAxis.cs
+++ b/Source/Revit.IFC.Import/Data/IFCGridAxis.cs
@@ -19,14 +19,10 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
 using Revit.IFC.Common.Enums;
 using Revit.IFC.Common.Utility;
-using Revit.IFC.Import.Enums;
-using Revit.IFC.Import.Geometry;
 using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import.Data
@@ -393,8 +389,8 @@ public void Create(Document doc, Transform lcs)
          // would not be placed too close to one another; if they are, and they use different
          // grid structures, then the plan views may have overlapping grid lines.  This seems
          // more likely in theory than practice.
-         const double bottomOffset = -1.0 / 12.0;    // 1" =   2.54 cm
-         const double topOffset = 4.0;               // 4' = 121.92 cm
+         const double bottomOffset = 1.0 / 12.0;    // 1" =   2.54 cm
+         const double topOffset = 4.0;              // 4' = 121.92 cm
 
          double originalZ = (lcs != null) ? lcs.Origin.Z : 0.0;
 
diff --git a/Source/Revit.IFC.Import/Data/IFCGroup.cs b/Source/Revit.IFC.Import/Data/IFCGroup.cs
index 63e9f781..1500e171 100644
--- a/Source/Revit.IFC.Import/Data/IFCGroup.cs
+++ b/Source/Revit.IFC.Import/Data/IFCGroup.cs
@@ -69,10 +69,18 @@ protected override void Process(IFCAnyHandle ifcGroup)
       {
          base.Process(ifcGroup);
 
-         ICollection<IFCAnyHandle> isGroupedByList =
-             IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcGroup, "IsGroupedBy");
-         foreach (IFCAnyHandle isGroupedBy in isGroupedByList)
-            ProcessIFCRelAssignsToGroup(isGroupedBy);
+         if (IFCImportFile.TheFile.SchemaVersionAtLeast(IFCSchemaVersion.IFC4))
+         {
+            ICollection<IFCAnyHandle> isGroupedByList =
+               IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcGroup, "IsGroupedBy");
+            foreach (IFCAnyHandle isGroupedBy in isGroupedByList)
+               ProcessIFCRelAssignsToGroup(isGroupedBy);
+         }
+         else
+         {
+            IFCAnyHandle isGroupedByHnd = IFCAnyHandleUtil.GetInstanceAttribute(ifcGroup, "IsGroupedBy");
+            ProcessIFCRelAssignsToGroup(isGroupedByHnd);
+         }
       }
 
       protected IFCGroup()
diff --git a/Source/Revit.IFC.Import/Data/IFCImportFile.cs b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
index 47a84bcd..5f4c5cbb 100644
--- a/Source/Revit.IFC.Import/Data/IFCImportFile.cs
+++ b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
@@ -66,9 +66,6 @@ public class IFCImportFile
 
       private IFCFile IFCFile { get; set; } = null;
 
-      public double OneHundrethOfAFoot { get; set; } = 0.01;
-      public double OneMillimeter { get; set; } = 1.0 / 304.8;
-
       private static void StoreIFCCreatorInfo(IFCFile ifcFile, ProjectInfo projectInfo)
       {
          if (ifcFile == null || projectInfo == null)
@@ -185,6 +182,16 @@ public static void Import(ImporterIFC importer)
       /// </summary>
       public IFCProject IFCProject { get; set; }
 
+      /// <summary>
+      /// The vertex tolerance for this import.  Convenience function.
+      /// </summary>
+      public double VertexTolerance { get; set; } = 0.0;
+
+      /// <summary>
+      /// The short curve tolerance for this import.  Convenience function.
+      /// </summary>
+      public double ShortCurveTolerance { get; set; } = 0.0;
+
       /// <summary>
       /// A list of entities not contained in IFCProject to create.  This could include, e.g., zones.
       /// </summary>
@@ -387,33 +394,6 @@ private void PreProcessInverseCaches()
          PreProcessPresentationLayers();
       }
 
-      private void PostProcessAssignments()
-      {
-         // The IFC toolkit relies on the IFC schema definition to read in the file. The schema definition has entities that have data fields,
-         // and INVERSE relationships. Unfortunately, the standard IFC 2x3 schema has a "bug" where one of the inverse relationships is missing. 
-         // Normally we don't care all that much, but now we do. So if we don't allow using this inverse (because if we did, it would just constantly 
-         // throw exceptions), we need another way to get the zones. This is the way.
-         // We are also using this to find IfcSystems that don't have the optional IfcRelServicesBuildings set.
-         if (!IFCImportFile.TheFile.Options.AllowUseHasAssignments)
-         {
-            IList<IFCAnyHandle> zones = IFCImportFile.TheFile.GetInstances(IFCEntityType.IfcZone, false);
-            foreach (IFCAnyHandle zone in zones)
-            {
-               IFCZone ifcZone = IFCZone.ProcessIFCZone(zone);
-               if (ifcZone != null)
-                  OtherEntitiesToCreate.Add(ifcZone);
-            }
-
-            IList<IFCAnyHandle> systems = IFCImportFile.TheFile.GetInstances(IFCEntityType.IfcSystem, false);
-            foreach (IFCAnyHandle system in systems)
-            {
-               IFCSystem ifcSystem = IFCSystem.ProcessIFCSystem(system);
-               if (ifcSystem != null)
-                  OtherEntitiesToCreate.Add(ifcSystem);
-            }
-         }
-      }
-
       /// <summary>
       /// Top-level function that processes an IFC file for reference.
       /// </summary>
@@ -435,7 +415,6 @@ private bool ProcessReference()
          // This is where the main work happens.
          IFCProject.ProcessIFCProject(projects[0]);
 
-         PostProcessAssignments();
          return PostProcessReference();
       }
 
@@ -1079,20 +1058,6 @@ static IFCFile CreateIFCFileFromIFCZIP(string path, out IFCSchemaVersion schemaV
          }
       }
 
-      private static string LocateSchemaFile(string schemaFileName)
-      {
-         string filePath = null;
-#if IFC_OPENSOURCE
-         // Find the alternate schema file from the open source install folder
-         filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location), schemaFileName);
-         if (!File.Exists(filePath))
-#endif
-         {
-            filePath = Path.Combine(DirectoryUtil.RevitProgramPath, "EDM", schemaFileName);
-         }
-         return filePath;
-      }
-
       /// <summary>
       /// Gets IFCFileModelOptions from schema name.
       /// </summary>
@@ -1111,27 +1076,44 @@ static IFCFileModelOptions GetIFCFileModelOptions(string schemaName, out IFCSche
          }
          else if (schemaName.Equals("IFC2X3", StringComparison.OrdinalIgnoreCase))
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC2X3_TC1.exp");
             schemaVersion = IFCSchemaVersion.IFC2x3;
          }
          else if (schemaName.Equals("IFC2X_FINAL", StringComparison.OrdinalIgnoreCase))
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC2X_PROXY.exp");
             schemaVersion = IFCSchemaVersion.IFC2x;
          }
          else if (schemaName.Equals("IFC2X2_FINAL", StringComparison.OrdinalIgnoreCase))
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC2X2_ADD1.exp");
             schemaVersion = IFCSchemaVersion.IFC2x2;
          }
          else if (schemaName.Equals("IFC4", StringComparison.OrdinalIgnoreCase))
          {
-            modelOptions.SchemaFile = LocateSchemaFile("IFC4.exp");
             schemaVersion = IFCSchemaVersion.IFC4;
          }
+         else if (schemaName.Equals("IFC4X1", StringComparison.OrdinalIgnoreCase))
+         {
+            schemaVersion = IFCSchemaVersion.IFC4x1;
+         }
+         else if (schemaName.Equals("IFC4X2", StringComparison.OrdinalIgnoreCase))
+         {
+            schemaVersion = IFCSchemaVersion.IFC4x2;
+         }
+         else if (schemaName.Equals("IFC4X3_RC1", StringComparison.OrdinalIgnoreCase))
+         {
+            schemaVersion = IFCSchemaVersion.IFC4x3_RC1;
+         }
+         else if (schemaName.Equals("IFC4X3_RC3", StringComparison.OrdinalIgnoreCase))
+         {
+            schemaVersion = IFCSchemaVersion.IFC4x3_RC3;
+         }
          else
             throw new ArgumentException("Invalid or unsupported schema: " + schemaName);
 
+         if (schemaVersion >= IFCSchemaVersion.IFC4x1)
+         {
+            Importer.TheLog.LogWarning(-1, "Schema " + schemaName + " is not fully supported. Some elements may be missed or imported incorrectly.", false);
+         }
+
          return modelOptions;
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCLocation.cs b/Source/Revit.IFC.Import/Data/IFCLocation.cs
index 9c43a66d..f4f11cb0 100644
--- a/Source/Revit.IFC.Import/Data/IFCLocation.cs
+++ b/Source/Revit.IFC.Import/Data/IFCLocation.cs
@@ -32,49 +32,6 @@ namespace Revit.IFC.Import.Data
    /// </summary>
    public class IFCLocation : IFCEntity
    {
-      /// <summary>
-      /// Determines whether we should fix the origin of the IFCLocation
-      /// if it is too far from the origin for Revit's standards.
-      /// </summary>
-      /// <remarks>
-      /// This is intended for IfcBuilding and IfcBuildingStorey.
-      /// IfcSite has a more robust implementation for getting around far origins,
-      /// and in a well-structured IFC file, this should not be necessary.
-      /// </remarks>
-      private static bool FixFarawayLocationOrigin { get; set; } = false;
-
-      /// <summary>
-      /// A class that controls whether or not we should correct the IFCLocation
-      /// relative transform if it is too far from the origin for Revit's standards.
-      /// </summary>
-      /// <remarks>This class should be used with the 'using' keyword to scope
-      /// its effects.  In general, we shouldn't ever have to use this; IFC files
-      /// shouldn't be far from the origin, as CAD systems can have issues with
-      /// large coordinates.  Also, specifically for IfcSite, we set shared coordinates
-      /// based on the offset to avoid the issue.  For other containers, it is
-      /// more difficult to determine what to do.  So we will limit this to buildings
-      /// and building stories.</remarks>
-      public class IFCLocationChecker : IDisposable
-      {
-         /// <summary>
-         /// The constructor.
-         /// </summary>
-         public IFCLocationChecker(IFCProduct product)
-         {
-            // We don't need to do this fixup if something else is consuming the content
-            LastFixFarawayLocationOrigin = FixFarawayLocationOrigin;
-            FixFarawayLocationOrigin = Importer.TheProcessor.ShouldFixFarAwayLocation &&
-               (product != null) && ((product is IFCBuilding) || (product is IFCBuildingStorey));
-         }
-
-         public void Dispose()
-         {
-            FixFarawayLocationOrigin = LastFixFarawayLocationOrigin;
-         }
-
-         private bool LastFixFarawayLocationOrigin { get; set; } = false;
-      }
-
       /// <summary>
       /// The IFCLocation that this IFCLocation is relative to. 
       /// </summary>
@@ -112,6 +69,22 @@ protected IFCLocation()
 
       }
 
+      /// <summary>
+      /// Create a dummy IFCLocation that contains only a relative transform.
+      /// </summary>
+      /// <param name="relativeTransform">The transform associated with the location.</param>
+      /// <returns>The new IFCLocation.</returns>
+      /// <remarks>
+      /// This is intended for use for IFCSites, whose location has either been modified
+      /// by the RefElevation parameter, or by being moved far from the origin.
+      /// </remarks>
+      static public IFCLocation CreateDummyLocation(Transform relativeTransform)
+      {
+         IFCLocation dummyLocation = new IFCLocation();
+         dummyLocation.RelativeTransform = relativeTransform;
+         return dummyLocation;
+      }
+
       /// <summary>
       /// Constructs an IFCLocation from the IfcObjectPlacement handle.
       /// </summary>
@@ -130,11 +103,6 @@ static Transform ProcessPlacementBase(IFCAnyHandle placement)
             Importer.TheLog.LogError(placement.StepId, "Missing or invalid location attribute.", false);
             origin = XYZ.Zero;
          }
-         else if (FixFarawayLocationOrigin && !XYZ.IsWithinLengthLimits(origin))
-         {
-            Importer.TheLog.LogError(placement.StepId, "The local placement has an origin that is outside of Revit's creation limits.  Moving to the internal origin.", false);
-            origin = XYZ.Zero;
-         }
          return Transform.CreateTranslation(origin);
       }
 
@@ -257,20 +225,16 @@ protected void ProcessLocalPlacement(IFCAnyHandle objectPlacement)
          IFCAnyHandle placementRelTo = IFCAnyHandleUtil.GetInstanceAttribute(objectPlacement, "PlacementRelTo");
          IFCAnyHandle relativePlacement = IFCAnyHandleUtil.GetInstanceAttribute(objectPlacement, "RelativePlacement");
 
-         // We don't want to fix any previous object placement that we either already fixed,
-         // or decided not to fix.
-         using (IFCLocationChecker dontFix = new IFCLocationChecker(null))
+         if (!IFCAnyHandleUtil.IsNullOrHasNoValue(placementRelTo))
          {
-            RelativeTo =
-                IFCAnyHandleUtil.IsNullOrHasNoValue(placementRelTo) ? null : ProcessIFCObjectPlacement(placementRelTo);
+            RelativeTo = ProcessIFCObjectPlacement(placementRelTo);
+            // If the location that this is relative to is relative to the site location, then
+            // so is this.  This relies on RelativeToSite for the IfcSite local placement to be
+            // set to true before any other entities are processed.
+            RelativeToSite = RelativeTo.RelativeToSite;
          }
 
          RelativeTransform = ProcessIFCAxis2Placement(relativePlacement);
-
-         // If the location that this is relative to is relative to the site location, then so is this.
-         // This relies on RelativeToSite for the IfcSite local placement to be set to true before any other entities are processed.
-         if (RelativeTo != null)
-            RelativeToSite = RelativeTo.RelativeToSite;
       }
 
       protected void ProcessGridPlacement(IFCAnyHandle gridPlacement)
@@ -328,5 +292,14 @@ public static IFCLocation ProcessIFCObjectPlacement(IFCAnyHandle ifcObjectPlacem
 
          return new IFCLocation(ifcObjectPlacement);
       }
-   }
+
+      public static void WarnIfFaraway(IFCProduct product)
+      {
+         XYZ origin = product?.ObjectLocation?.TotalTransform?.Origin;
+         if (origin != null && !XYZ.IsWithinLengthLimits(origin))
+         {
+            Importer.TheLog.LogWarning(product.Id, "This entity has an origin that is outside of Revit's creation limits.  This could result in bad graphical display of geometry.", false);
+         }
+      }
+}
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Data/IFCMappedItem.cs b/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
index 793d7b93..e0a203f7 100644
--- a/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
+++ b/Source/Revit.IFC.Import/Data/IFCMappedItem.cs
@@ -77,6 +77,19 @@ override protected void Process(IFCAnyHandle item)
          MappingSource = IFCRepresentationMap.ProcessIFCRepresentationMap(mappingSource);
       }
 
+      private int FindAlternateGeometrySource(int originalId)
+      {
+         // NAVIS_TODO: Explain this.
+         if (!Importer.TheProcessor.FindAlternateGeometrySource)
+            return originalId;
+
+         // Copy some code from elsewhere to work out what the object was that got the
+         // geometry.
+         IFCTypeProduct typeProduct;
+         Importer.TheCache.RepMapToTypeProduct.TryGetValue(MappingSource.Id, out typeProduct);
+         return typeProduct?.Id ?? originalId;
+      }
+
       /// <summary>
       /// Create geometry for a particular representation item.
       /// </summary>
@@ -99,35 +112,40 @@ protected override void CreateShapeInternal(IFCImportShapeEditScope shapeEditSco
 
          Transform mappingTransform = MappingTarget.Transform;
 
-         Transform newLcs = null;
-         if (lcs == null)
-            newLcs = mappingTransform;
-         else if (mappingTransform == null)
-            newLcs = lcs;
-         else
-            newLcs = lcs.Multiply(mappingTransform);
-
-         Transform newScaledLcs = null;
-         if (scaledLcs == null)
-            newScaledLcs = mappingTransform;
-         else if (mappingTransform == null)
-            newScaledLcs = scaledLcs;
-         else
-            newScaledLcs = scaledLcs.Multiply(mappingTransform);
+         Transform newLcs = 
+            (mappingTransform == null) ? lcs : (lcs?.Multiply(mappingTransform) ?? mappingTransform);
+         
+         Transform newScaledLcs =
+            (mappingTransform == null) ? scaledLcs : (scaledLcs?.Multiply(mappingTransform) ?? mappingTransform);
 
-         // Pass in newLCS = null, use newLCS for instance.
          bool isFootprint = (shapeEditScope.ContainingRepresentation.Identifier == IFCRepresentationIdentifier.FootPrint);
 
-         bool canCreateType = !shapeEditScope.PreventInstances && 
-            (newLcs != null && newLcs.IsConformal) &&
-         (newScaledLcs != null && newScaledLcs.IsConformal) &&
-         isUnitScale &&
-         (shapeEditScope.ContainingRepresentation != null && !isFootprint);
+         bool canCreateType = !shapeEditScope.PreventInstances && !isFootprint && isUnitScale &&
+            (newLcs?.IsConformal ?? true) &&
+            (newScaledLcs?.IsConformal ?? true) &&
+            (shapeEditScope.ContainingRepresentation != null);
 
          if (canCreateType)
          {
+            int mappingSourceId = MappingSource.Id;
+            int geometrySourceId = FindAlternateGeometrySource(mappingSourceId);
             MappingSource.CreateShape(shapeEditScope, null, null, guid);
-            Importer.TheProcessor.PostProcessMappedItem(shapeEditScope, this, newLcs);
+
+            if (shapeEditScope.Creator != null)
+            {
+               Importer.TheProcessor.PostProcessMappedItem(shapeEditScope.Creator.Id,
+                  shapeEditScope.Creator.GlobalId,
+                  shapeEditScope.Creator.EntityType.ToString(),
+                  shapeEditScope.Creator.CategoryId,
+                  geometrySourceId,
+                  newLcs);
+            }
+
+            // NAVIS_TODO: Figure out how not to do this.
+            IList<GeometryObject> instances = DirectShape.CreateGeometryInstance(
+               shapeEditScope.Document, mappingSourceId.ToString(), newLcs);
+            foreach (GeometryObject instance in instances)
+               shapeEditScope.AddGeometry(IFCSolidInfo.Create(Id, instance));
          }
          else
          {
diff --git a/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs b/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
index 3b6e17a3..7c4adb28 100644
--- a/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
+++ b/Source/Revit.IFC.Import/Data/IFCObjectDefinition.cs
@@ -33,16 +33,12 @@ namespace Revit.IFC.Import.Data
    /// </summary>
    public abstract class IFCObjectDefinition : IFCRoot
    {
-      HashSet<IFCObjectDefinition> m_ComposedObjectDefinitions = null; //IsDecomposedBy
-
       ICollection<IFCGroup> m_AssignmentGroups = null; //HasAssignments
 
       private IFCMaterial m_TheMaterial = null;
       
       private bool m_TheMaterialIsSet = false;
 
-      private IList<GeometryObject> m_CreatedGeometry = null;
-
       private IDictionary<string, object> m_AdditionalIntParameters = null;
 
       /// <summary>
@@ -69,7 +65,7 @@ public virtual bool GroupSubElements()
       public IIFCMaterialSelect MaterialSelect { get; protected set; } = null;
 
       /// <summary>
-      /// The object that composes this object
+      /// The object that this object via the "IsDecomposedBy" inverse attribute.
       /// </summary>
       public IFCObjectDefinition Decomposes { get; set; } = null;
 
@@ -265,29 +261,12 @@ public string GetTheMaterialName()
       /// <summary>
       /// Returns the list of geometries created in the Create() function, for DirectShape representations only.
       /// </summary>
-      public IList<GeometryObject> CreatedGeometry
-      {
-         get
-         {
-            if (m_CreatedGeometry == null)
-               m_CreatedGeometry = new List<GeometryObject>();
-            return m_CreatedGeometry;
-         }
-         set { m_CreatedGeometry = value; }
-      }
+      public IList<GeometryObject> CreatedGeometry { get; set; } = new List<GeometryObject>();
 
       /// <summary>
-      /// The composed objects.
+      /// The composed objects, from the "IsDecomposedBy" inverse attribute.
       /// </summary>
-      public HashSet<IFCObjectDefinition> ComposedObjectDefinitions
-      {
-         get
-         {
-            if (m_ComposedObjectDefinitions == null)
-               m_ComposedObjectDefinitions = new HashSet<IFCObjectDefinition>();
-            return m_ComposedObjectDefinitions;
-         }
-      }
+      public HashSet<IFCObjectDefinition> ComposedObjectDefinitions { get; } = new HashSet<IFCObjectDefinition>();
 
       /// <summary>
       /// The assignment objects (from HasAssignments inverse).
@@ -386,44 +365,42 @@ protected virtual void TraverseSubElements(Document doc)
       {
          IList<ElementId> subElementIds = new List<ElementId>();
 
-         // These two should only be populated if GroupSubElements() is true and we are duplicating geometry for containers.
+         // These two should only be populated if GroupSubElements() is true and we are duplicating
+         // geometry for containers.
          List<GeometryObject> groupedSubElementGeometries = new List<GeometryObject>();
          List<Curve> groupedSubElementFootprintCurves = new List<Curve>();
 
-         if (ComposedObjectDefinitions != null)
+         foreach (IFCObjectDefinition objectDefinition in ComposedObjectDefinitions)
          {
-            foreach (IFCObjectDefinition objectDefinition in ComposedObjectDefinitions)
-            {
-               IFCObjectDefinition.CreateElement(doc, objectDefinition);
-               if (objectDefinition.CreatedElementId != ElementId.InvalidElementId)
-               {
-                  subElementIds.Add(objectDefinition.CreatedElementId);
+            CreateElement(doc, objectDefinition);
+            if (objectDefinition.CreatedElementId == ElementId.InvalidElementId)
+               continue;
 
-                  // CreateDuplicateContainerGeometry is currently an API-only option (no UI), set to true by default.
-                  //
-                  // NAVIS_TODO - This is wrong if Importer.TheProcessor.ApplyTransforms is false
-                  if (GroupSubElements() && Importer.TheOptions.CreateDuplicateContainerGeometry)
-                  {
-                     IList<GeometryObject> subGeometries = GetOrCloneGeometry(doc, objectDefinition);
-                     if (subGeometries != null)
-                        groupedSubElementGeometries.AddRange(subGeometries);
+            subElementIds.Add(objectDefinition.CreatedElementId);
 
-                     if (objectDefinition is IFCProduct)
-                        groupedSubElementFootprintCurves.AddRange((objectDefinition as IFCProduct).FootprintCurves);
-                  }
-               }
-            }
+            // CreateDuplicateContainerGeometry is currently an API-only option (no UI), set to true by default.
+            //
+            // NAVIS_TODO - This is wrong if Importer.TheProcessor.ApplyTransforms is false
+            if (!GroupSubElements() || !Importer.TheOptions.CreateDuplicateContainerGeometry)
+               continue;
+
+            IList<GeometryObject> subGeometries = GetOrCloneGeometry(doc, objectDefinition);
+            if (subGeometries != null)
+               groupedSubElementGeometries.AddRange(subGeometries);
 
-            if (groupedSubElementGeometries.Count > 0)
+            if (objectDefinition is IFCProduct)
+               groupedSubElementFootprintCurves.AddRange((objectDefinition as IFCProduct).FootprintCurves);
+         }
+
+         if (groupedSubElementGeometries.Count > 0)
+         {
+            // Add main element geometry to include it in direct shape 
+            // and be able to assign parameters to the whole geometry and not just to subelements
+            IList<GeometryObject> elementGeometry = GetOrCloneGeometry(doc, this);
+            if ((elementGeometry?.Count ?? 0) > 0)
             {
-               // Add main element geometry to include it in direct shape 
-               // and be able to assign parameters to the whole geometry and not just to subelements
-               IList<GeometryObject> elementGeometry = GetOrCloneGeometry(doc, this);
-               if (elementGeometry != null && elementGeometry.Count > 0)
-               {
-                  groupedSubElementGeometries.AddRange(elementGeometry);
-                  Importer.TheLog.LogWarning(Id, "Entity contains both geometry and sub-entities with geometry. This may result in duplicate geometry.", false);
-               }
+               groupedSubElementGeometries.AddRange(elementGeometry);
+               Importer.TheLog.LogWarning(Id, "Entity contains both geometry and sub-entities with geometry. This may result in duplicate geometry.", false);
             }
          }
 
@@ -433,11 +410,12 @@ protected virtual void TraverseSubElements(Document doc)
             {
                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.
+                  // 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
+                  // 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;
                }
 
@@ -516,8 +494,7 @@ protected override void Process(IFCAnyHandle ifcObjectDefinition)
             }
          }
 
-         // The default IFC2x3_TC1.exp file does not have this INVERSE attribute correctly set.  Encapsulate this function.
-         ISet<IFCAnyHandle> hasAssignments = IFCImportHandleUtil.GetHasAssignments(ifcObjectDefinition);
+         ISet<IFCAnyHandle> hasAssignments = IFCAnyHandleUtil.GetAggregateInstanceAttribute<HashSet<IFCAnyHandle>>(ifcObjectDefinition, "HasAssignments");
 
          if (hasAssignments != null)
          {
@@ -732,6 +709,19 @@ public virtual string GetSharedParameterName(IFCSharedParameters name, bool isTy
          return name.ToString() + (isType ? " [Type]" : "");
       }
 
+      private bool SuccessfullySetName(Element element, string name)
+      {
+         try
+         {
+            element.Name = name;
+            return true;
+         }
+         catch
+         {
+            return false;
+         }
+      }
+
       /// <summary>
       /// Set the Element.Name property if possible, and add an "IfcName" parameter to an element containing the original name of the generating entity. 
       /// </summary>
@@ -746,14 +736,13 @@ private void SetName(Document doc, Element element, Category category)
          string revitName = GetName(null);
          if (!string.IsNullOrWhiteSpace(revitName))
          {
-            try
-            {
-               if (CanSetRevitName(element))
-                  element.Name = revitName;
-               
-            }
-            catch
+            if (CanSetRevitName(element))
             {
+               if (!SuccessfullySetName(element, revitName))
+               {
+                  if (!SuccessfullySetName(element, revitName + " " + Id))
+                     Importer.TheLog.LogWarning(Id, "Couldn't set element name.", false);
+               }
             }
          }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCProduct.cs b/Source/Revit.IFC.Import/Data/IFCProduct.cs
index 927036c2..06b7ccf3 100644
--- a/Source/Revit.IFC.Import/Data/IFCProduct.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProduct.cs
@@ -48,20 +48,6 @@ public IFCVoidInfo(IFCSolidInfo solid)
    /// </summary>
    public abstract class IFCProduct : IFCObject
    {
-      protected IFCProductRepresentation m_ProductRepresentation = null;
-
-      protected IFCSpatialStructureElement m_ContainingStructure = null;
-
-      // List of objects created in Create().  May be split off at some point.
-
-      private IList<IFCSolidInfo> m_Solids = null;
-
-      private IList<IFCVoidInfo> m_Voids = null;
-
-      private IList<Curve> m_FootprintCurves = null;
-
-      private ISet<string> m_PresentationLayerNames = null;
-
       /// <summary>
       /// The id of the corresponding IfcTypeProduct, if any.
       /// </summary>
@@ -70,73 +56,32 @@ public abstract class IFCProduct : IFCObject
       /// <summary>
       /// The list of solids created for the associated element.
       /// </summary>
-      public IList<IFCSolidInfo> Solids
-      {
-         get
-         {
-            if (m_Solids == null)
-               m_Solids = new List<IFCSolidInfo>();
-            return m_Solids;
-         }
-      }
+      public IList<IFCSolidInfo> Solids { get; } = new List<IFCSolidInfo>();
 
       /// <summary>
       /// The list of voids created for the associated element.
       /// </summary>
-      public IList<IFCVoidInfo> Voids
-      {
-         get
-         {
-            if (m_Voids == null)
-               m_Voids = new List<IFCVoidInfo>();
-            return m_Voids;
-         }
-      }
+      public IList<IFCVoidInfo> Voids { get; } = new List<IFCVoidInfo>();
 
       /// <summary>
       /// The list of curves created for the associated element, for use in plan views.
       /// </summary>
-      public IList<Curve> FootprintCurves
-      {
-         get
-         {
-            if (m_FootprintCurves == null)
-               m_FootprintCurves = new List<Curve>();
-            return m_FootprintCurves;
-         }
-      }
+      public IList<Curve> FootprintCurves { get; } = new List<Curve>();
 
       /// <summary>
       /// The names of the presentation layers associated with the representations and representation items.
       /// </summary>
-      public ISet<string> PresentationLayerNames
-      {
-         get
-         {
-            if (m_PresentationLayerNames == null)
-               m_PresentationLayerNames = new SortedSet<string>();
-            return m_PresentationLayerNames;
-         }
-         protected set { m_PresentationLayerNames = value; }
-      }
+      public ISet<string> PresentationLayerNames { get; } = new SortedSet<string>();
 
       /// <summary>
       /// The one product representation of the product.
       /// </summary>
-      public IFCProductRepresentation ProductRepresentation
-      {
-         get { return m_ProductRepresentation; }
-         protected set { m_ProductRepresentation = value; }
-      }
+      public IFCProductRepresentation ProductRepresentation { get; protected set; } = null;
 
       /// <summary>
       /// The IfcSpatialStructureElement that contains the IfcElement.
       /// </summary>
-      public IFCSpatialStructureElement ContainingStructure
-      {
-         get { return m_ContainingStructure; }
-         set { m_ContainingStructure = value; }
-      }
+      public IFCSpatialStructureElement ContainingStructure { get; set; } = null;
 
       /// <summary>
       /// The local coordinate system of the IfcProduct.
@@ -169,6 +114,38 @@ protected override void Process(IFCAnyHandle ifcProduct)
             ProductRepresentation = IFCProductRepresentation.ProcessIFCProductRepresentation(ifcProductRepresentation);
       }
 
+      static public BoundingBoxXYZ ProjectScope { get; set; } = null;
+
+      private void AddLocationToPlacementBoundingBox()
+      {
+         if (!Importer.TheProcessor.TryToFixFarawayOrigin)
+            return;
+
+         if (!(this is IFCSpatialStructureElement))
+         {
+            XYZ lcsOrigin = ObjectLocation?.TotalTransform?.Origin ?? XYZ.Zero;
+            if (ProjectScope == null)
+            {
+               ProjectScope = new BoundingBoxXYZ();
+               ProjectScope.Min = lcsOrigin;
+               ProjectScope.Max = lcsOrigin;
+            }
+            else
+            {
+               ProjectScope.Min = new XYZ(
+                  Math.Min(ProjectScope.Min.X, lcsOrigin.X),
+                  Math.Min(ProjectScope.Min.Y, lcsOrigin.Y),
+                  Math.Min(ProjectScope.Min.Z, lcsOrigin.Z)
+                  );
+               ProjectScope.Max = new XYZ(
+                  Math.Max(ProjectScope.Min.X, lcsOrigin.X),
+                  Math.Max(ProjectScope.Min.Y, lcsOrigin.Y),
+                  Math.Max(ProjectScope.Min.Z, lcsOrigin.Z)
+                  );
+            }
+         }
+      }
+
       /// <summary>
       /// Creates or populates Revit element params based on the information contained in this class.
       /// </summary>
@@ -221,10 +198,6 @@ private bool HasValidTopLevelGeometry()
       /// <returns>True if the IFCProduct directly or indirectly contains geometry.</returns>
       private bool HasValidSubElementGeometry(IList<IFCEntity> visitedEntities)
       {
-         // If the ProductRepresentation doesn't contain valid geometry, then the ComposedObjectDefinitions determine if it has geometry or not.
-         if (ComposedObjectDefinitions == null)
-            return false;
-
          foreach (IFCObjectDefinition objDef in ComposedObjectDefinitions)
          {
             if (visitedEntities.Contains(objDef))
@@ -252,12 +225,28 @@ private bool HasValidSubElementGeometry(IList<IFCEntity> visitedEntities)
       /// <returns>False if the return solid is empty; true otherwise.</returns>
       protected override bool CutSolidByVoids(IFCSolidInfo solidInfo)
       {
-         int numVoids = Voids.Count;
-         if (numVoids == 0)
+         // We only cut "Body" representation items.
+         if (solidInfo.RepresentationType != IFCRepresentationIdentifier.Body)
             return true;
 
-         // We only cut body representation items.
-         if (solidInfo.RepresentationType != IFCRepresentationIdentifier.Body)
+         IList<IFCVoidInfo> voidsToUse = null;
+         List<IFCVoidInfo> partVoids = null;
+
+         IList <IFCVoidInfo> parentVoids = (Decomposes as IFCProduct)?.Voids;
+         if (parentVoids != null)
+         {
+            partVoids = new List<IFCVoidInfo>();
+            partVoids.AddRange(Voids);
+            partVoids.AddRange(parentVoids);
+            voidsToUse = partVoids;
+         }
+         else
+         {
+            voidsToUse = Voids;
+         }
+
+         int numVoids = voidsToUse.Count;
+         if (numVoids == 0)
             return true;
 
          if (!(solidInfo.GeometryObject is Solid))
@@ -267,16 +256,16 @@ protected override bool CutSolidByVoids(IFCSolidInfo solidInfo)
             return true;
          }
 
-         for (int voidIdx = 0; voidIdx < numVoids; voidIdx++)
+         foreach (IFCVoidInfo voidInfo in voidsToUse)
          {
-            Solid voidObject = Voids[voidIdx].GeometryObject as Solid;
+            Solid voidObject = voidInfo.GeometryObject as Solid;
             if (voidObject == null)
             {
-               Importer.TheLog.LogError(Id, "Can't cut Solid geometry with a Mesh (# " + Voids[voidIdx].Id + "), ignoring.", false);
+               Importer.TheLog.LogError(Id, "Can't cut Solid geometry with a Mesh (# " + voidInfo.Id + "), ignoring.", false);
                return true;
             }
 
-            var voidTransform = Voids[voidIdx].TotalTransform;
+            var voidTransform = voidInfo.TotalTransform;
 
             if (voidTransform != null && voidTransform.IsIdentity == false)
             {
@@ -285,7 +274,7 @@ protected override bool CutSolidByVoids(IFCSolidInfo solidInfo)
                voidObject = SolidUtils.CreateTransformed(voidObject, t);
             }
 
-            solidInfo.GeometryObject = IFCGeometryUtil.ExecuteSafeBooleanOperation(solidInfo.Id, Voids[voidIdx].Id,
+            solidInfo.GeometryObject = IFCGeometryUtil.ExecuteSafeBooleanOperation(solidInfo.Id, voidInfo.Id,
                (solidInfo.GeometryObject as Solid), voidObject, BooleanOperationsType.Difference, null);
 
             if (solidInfo.GeometryObject == null || (solidInfo.GeometryObject as Solid).Faces.IsEmpty)
@@ -366,21 +355,14 @@ protected override void Create(Document doc)
                ProductRepresentation.CreateProductRepresentation(shapeEditScope, transformToUse, transformToUse, myId);
 
                int numSolids = Solids.Count;
-               int numVoids = Voids.Count;
-               if ((numSolids > 0) && (numVoids > 0))
+               // Attempt to cut each solid with each void.
+               for (int solidIdx = 0; solidIdx < numSolids; solidIdx++)
                {
-                  // This may be different than before, with the addition of solids from FamilyInstances.
-                  numSolids = Solids.Count;
-
-                  // Attempt to cut each solid with each void.
-                  for (int solidIdx = 0; solidIdx < numSolids; solidIdx++)
+                  if (!CutSolidByVoids(Solids[solidIdx]))
                   {
-                     if (!CutSolidByVoids(Solids[solidIdx]))
-                     {
-                        Solids.RemoveAt(solidIdx);
-                        solidIdx--;
-                        numSolids--;
-                     }
+                     Solids.RemoveAt(solidIdx);
+                     solidIdx--;
+                     numSolids--;
                   }
                }
 
@@ -428,7 +410,18 @@ protected override void Create(Document doc)
                         }
                      }
 
-                     Importer.TheProcessor.PostProcessProduct(Id, typeObjectToUse, shapeEditScope, shape, lcs, directShapeGeometries);
+                     if (!Importer.TheProcessor.PostProcessProduct(Id, typeObjectToUse?.Id, lcs, 
+                        directShapeGeometries))
+                     {
+                        if (shape != null)
+                        {
+                           shape.SetShape(directShapeGeometries);
+                           shapeEditScope.SetPlanViewRep(shape);
+
+                           if (typeObjectToUse != null && typeObjectToUse.CreatedElementId != ElementId.InvalidElementId)
+                              shape.SetTypeId(typeObjectToUse.CreatedElementId);
+                        }
+                     }
 
                      PresentationLayerNames.UnionWith(shapeEditScope.PresentationLayerNames);
 
@@ -465,11 +458,8 @@ protected void ProcessObjectPlacement(IFCAnyHandle ifcProduct)
 
          if (!IFCAnyHandleUtil.IsNullOrHasNoValue(objectPlacement))
          {
-            using (IFCLocation.IFCLocationChecker checker = new IFCLocation.IFCLocationChecker(this))
-            {
-               ObjectLocation = IFCLocation.ProcessIFCObjectPlacement(objectPlacement);
-            }
-
+            ObjectLocation = IFCLocation.ProcessIFCObjectPlacement(objectPlacement);
+            AddLocationToPlacementBoundingBox();
             IFCSite.CheckObjectPlacementIsRelativeToSite(this, ifcProduct.StepId, objectPlacement);
          }
       }
diff --git a/Source/Revit.IFC.Import/Data/IFCProject.cs b/Source/Revit.IFC.Import/Data/IFCProject.cs
index b8de0f22..e38100b6 100644
--- a/Source/Revit.IFC.Import/Data/IFCProject.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProject.cs
@@ -130,7 +130,12 @@ protected override void Process(IFCAnyHandle ifcProjectHandle)
             }
          }
 
-         Importer.TheProcessor.PostProcessProject();
+         var application = IFCImportFile.TheFile.Document.Application;
+         var projectUnits = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length);
+
+         IFCImportFile.TheFile.VertexTolerance = application.VertexTolerance;
+         IFCImportFile.TheFile.ShortCurveTolerance = application.ShortCurveTolerance;
+         Importer.TheProcessor.PostProcessProject(projectUnits?.ScaleFactor, projectUnits?.Unit);
 
          // We need to process the units before we process the rest of the file, since we will scale values as we go along.
          base.Process(ifcProjectHandle);
@@ -282,6 +287,17 @@ protected override void Create(Document doc)
             grid.Name = Guid.NewGuid().ToString();
          }
 
+         // Pre-process sites to orient them properly.
+         IList<IFCSite> sites = new List<IFCSite>();
+         foreach (IFCObjectDefinition objectDefinition in ComposedObjectDefinitions)
+         {
+            if (objectDefinition is IFCSite)
+            {
+               sites.Add(objectDefinition as IFCSite);
+            }
+         }
+         IFCSite.ProcessSiteLocations(doc, sites);
+               
          base.Create(doc);
 
          // IfcProject usually won't create an element, as it contains no geometry.
diff --git a/Source/Revit.IFC.Import/Data/IFCPropertySet.cs b/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
index 682914d7..13c40a7e 100644
--- a/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPropertySet.cs
@@ -38,8 +38,8 @@ public class IFCPropertySet : IFCPropertySetDefinition
       /// <summary>
       /// The properties.
       /// </summary>
-      public IDictionary<string, IFCProperty> IFCProperties { get; protected set; }
-      
+      public IDictionary<string, IFCProperty> IFCProperties { get; protected set; } = new Dictionary<string, IFCProperty>();
+
       /// <summary>
       /// Processes IfcPropertySet attributes.
       /// </summary>
@@ -61,8 +61,6 @@ protected override void Process(IFCAnyHandle ifcPropertySet)
 
          if (properties != null)
          {
-            IFCProperties = new Dictionary<string, IFCProperty>();
-
             foreach (IFCAnyHandle property in properties)
             {
                IFCProperty ifcProperty = IFCProperty.ProcessIFCProperty(property);
@@ -131,7 +129,7 @@ public static Parameter AddParameterBase(Document doc, Element element, Category
          Parameter parameter = null;
          ElementBinding binding = null;
          bool reinsert = false;
-         
+
          if (!newlyCreated)
          {
             BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
@@ -153,7 +151,7 @@ public static Parameter AddParameterBase(Document doc, Element element, Category
             if (!reinsert || !binding.Categories.Contains(category))
             {
                binding.Categories.Insert(category);
-      
+
                BindingMap bindingMap = Importer.TheCache.GetParameterBinding(doc);
                if (reinsert)
                   bindingMap.ReInsert(definition, binding, BuiltInParameterGroup.PG_IFC);
@@ -262,6 +260,17 @@ public static bool AddParameterInt(Document doc, Element element, Category categ
          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>
@@ -274,11 +283,14 @@ public static bool AddParameterInt(Document doc, Element element, Category categ
       /// <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)
+      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)
@@ -390,7 +402,6 @@ public override Tuple<string, bool> CreatePropertySet(Document doc, Element elem
             property.Create(doc, element, category, objDef, parameterGroupMap, Name, parametersCreated);
          }
 
-         CreateScheduleForPropertySet(doc, element, category, parameterGroupMap, parametersCreated);
          return Tuple.Create(quotedName, true);
       }
    }
diff --git a/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs b/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
index 3df50244..2376e0dc 100644
--- a/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPropertySetDefinition.cs
@@ -119,105 +119,6 @@ public static IFCPropertySetDefinition ProcessIFCPropertySetDefinition(IFCAnyHan
          return null;
       }
 
-      /// <summary>
-      /// Create a schedule for a given property set.
-      /// </summary>
-      /// <param name="doc">The document.</param>
-      /// <param name="element">The element being created.</param>
-      /// <param name="category">The category of the element.</param>
-      /// <param name="parameterGroupMap">The parameters of the element.  Cached for performance.</param>
-      /// <param name="parametersCreated">The created parameters.</param>
-      protected void CreateScheduleForPropertySet(Document doc, Element element, Category category,
-         IFCParameterSetByGroup parameterGroupMap, ISet<string> parametersCreated)
-      {
-         // Don't bother creating schedules if we are maximizing performance.
-         if (IFCImportFile.TheFile.Options.UseStreamlinedOptions)
-            return;
-
-         if (parametersCreated.Count == 0)
-            return;
-
-         if (category == null)
-            return;
-
-         ElementId categoryId = category.Id;
-         bool elementIsType = (element is ElementType);
-
-         string cleanName = IFCNamingUtil.CleanIFCName(Name);
-         Tuple<ElementId, bool, string> scheduleKey = Tuple.Create(categoryId, elementIsType, cleanName);
-
-         ISet<string> viewScheduleNames = Importer.TheCache.ViewScheduleNames;
-         IDictionary<Tuple<ElementId, bool, string>, ElementId> viewSchedules = Importer.TheCache.ViewSchedules;
-
-         ElementId viewScheduleId;
-         if (!viewSchedules.TryGetValue(scheduleKey, out viewScheduleId))
-         {
-            string scheduleName = scheduleKey.Item3;
-            string scheduleTypeName = elementIsType ? " " + Resources.IFCTypeSchedule : string.Empty;
-
-            int index = 1;
-            while (viewScheduleNames.Contains(scheduleName))
-            {
-               string indexString = (index > 1) ? " " + index.ToString() : string.Empty;
-               scheduleName += " (" + category.Name + scheduleTypeName + indexString + ")";
-               index++;
-               if (index > 1000)
-               {
-                  Importer.TheLog.LogWarning(Id, "Too many property sets with the name " + scheduleKey.Item3 +
-                     ", no longer creating schedules with that name.", true);
-                  return;
-               }
-            }
-
-            // Not all categories allow creating schedules.  Skip these.
-            ViewSchedule viewSchedule = null;
-            try
-            {
-               viewSchedule = ViewSchedule.CreateSchedule(doc, scheduleKey.Item1);
-            }
-            catch
-            {
-               // Only try to create the schedule once per key.
-               viewSchedules[scheduleKey] = ElementId.InvalidElementId;
-               return;
-            }
-
-            if (viewSchedule != null)
-            {    
-               viewSchedule.Name = scheduleName;
-               viewSchedules[scheduleKey] = viewSchedule.Id;
-               viewScheduleNames.Add(scheduleName);
-
-               ElementId ifcGUIDId = new ElementId(elementIsType ? BuiltInParameter.IFC_TYPE_GUID : BuiltInParameter.IFC_GUID);
-               string propertySetListName = elementIsType ? Resources.IFCTypeSchedule + " IfcPropertySetList" : "IfcPropertySetList";
-
-               ScheduleDefinition viewScheduleDefinition = viewSchedule.Definition;
-               IList<SchedulableField> schedulableFields = viewScheduleDefinition.GetSchedulableFields();
-
-               bool filtered = false;
-               foreach (SchedulableField sf in schedulableFields)
-               {
-                  string fieldName = sf.GetName(doc);
-                  if (parametersCreated.Contains(fieldName) || sf.ParameterId == ifcGUIDId)
-                  {
-                     viewScheduleDefinition.AddField(sf);
-                  }
-                  else if (!filtered && fieldName == propertySetListName)
-                  {
-                     // We want to filter the schedule for specifically those elements that have this property set assigned.
-                     ScheduleField scheduleField = viewScheduleDefinition.AddField(sf);
-                     scheduleField.IsHidden = true;
-                     ScheduleFilter filter = new ScheduleFilter(scheduleField.FieldId, ScheduleFilterType.Contains, "\"" + Name + "\"");
-                     viewScheduleDefinition.AddFilter(filter);
-                     filtered = true;
-                  }
-               }
-            }
-         }
-
-         return;
-      }
-
       /// <summary>
       /// Create a property set for a given element.
       /// </summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCRepresentationContext.cs b/Source/Revit.IFC.Import/Data/IFCRepresentationContext.cs
index c938abff..aaca1a08 100644
--- a/Source/Revit.IFC.Import/Data/IFCRepresentationContext.cs
+++ b/Source/Revit.IFC.Import/Data/IFCRepresentationContext.cs
@@ -163,7 +163,7 @@ override protected void Process(IFCAnyHandle ifcRepresentationContext)
                if (!found)
                   CoordinateSpaceDimension = 3;   // Don't throw, just set to default 3D.
 
-               Precision = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcRepresentationContext, "Precision", Importer.TheProcessor.VertexTolerance);
+               Precision = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcRepresentationContext, "Precision", IFCImportFile.TheFile.VertexTolerance);
 
                IFCAnyHandle worldCoordinateSystem = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcRepresentationContext, "WorldCoordinateSystem", false);
                if (!IFCAnyHandleUtil.IsNullOrHasNoValue(worldCoordinateSystem))
diff --git a/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs b/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
index 845d771e..6a05b98c 100644
--- a/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
+++ b/Source/Revit.IFC.Import/Data/IFCRepresentationMap.cs
@@ -184,7 +184,14 @@ public void CreateShape(IFCImportShapeEditScope shapeEditScope, Transform lcs, T
                      typeId = Id;
                   }
 
-                  Importer.TheProcessor.PostProcessRepresentationMap(typeId, shapeEditScope, mappedCurves, mappedSolids, directShapeType);
+                  if (!Importer.TheProcessor.PostProcessRepresentationMap(typeId, mappedCurves, mappedSolids))
+                  {
+                     // Do the "default" here instead of the processor, since we don't want the processor
+                     // to know about Revit.IFC.Import stuff.
+                     directShapeType.AppendShape(mappedSolids);
+                     if (mappedCurves.Count != 0)
+                        shapeEditScope.SetPlanViewRep(directShapeType);
+                  }
 
                   IFCImportFile.TheFile.ShapeLibrary.AddDefinitionType(Id.ToString(), directShapeType.Id);
                }
diff --git a/Source/Revit.IFC.Import/Data/IFCSite.cs b/Source/Revit.IFC.Import/Data/IFCSite.cs
index ac6b78ff..48ffa483 100644
--- a/Source/Revit.IFC.Import/Data/IFCSite.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSite.cs
@@ -239,6 +239,183 @@ protected override void Create(Document doc)
       /// used to offset objects placed not relative to a site.</remarks>
       public static XYZ BaseSiteOffset { get; set; } = null;
 
+      public static void ProcessSiteLocations(Document doc, IList<IFCSite> sites)
+      {
+         BaseSiteOffset = null;
+
+         // Ideally, in most cases, this routine will do nothing.  In particular, that is 
+         // true if the project has an arbitrary number of sites that are "close" to the
+         // origin.
+
+         if (sites == null || sites.Count == 0)
+            return;
+
+         ProjectLocation projectLocation = doc.ActiveProjectLocation;
+         if (projectLocation == null)
+            return;
+
+         // If there is one site, and it is far from the origin, then we will move the site
+         // close to the origin, give a warning, and set the shared coordinates in the file.
+
+         // If there is more than one site, and at least one site is far from the origin:
+         // 1. If all of the sites have an origin close to one another, then we will move the 
+         // site close to the origin based on the first site encountered, give a warning, 
+         // and set the shared coordinates in the file and the rest of the sites relative to
+         // the first site.
+         // 2. If the sites do not have origins close to one another, then we will do nothing
+         // and give an error that the site is far from the origin and may have poor
+         // performance and appearance.
+         int numSites = sites.Count;
+         bool hasSiteLocation = false;
+
+         // First pass: deal with latitude and longitude.
+         for (int ii = 0; ii < numSites; ii++)
+         {
+            IFCSite currSite = sites[ii];
+
+            // Set the project latitude and longitude if the information is available, and
+            // it hasn't already been set.
+            SiteLocation siteLocation = projectLocation.GetSiteLocation();
+            if (siteLocation != null)
+            {
+               // Some Tekla files may have invalid information here that would otherwise cause the
+               // link to fail.  Recover with a warning.
+               try
+               {
+                  bool foundSiteLocation = (currSite.RefLatitude.HasValue && currSite.RefLongitude.HasValue);
+                  if (foundSiteLocation)
+                  {
+                     if (hasSiteLocation)
+                     {
+                        Importer.TheLog.LogWarning(currSite.Id, "Duplicate latitude or longitude value supplied for IFCSITE, ignoring.", false);
+                     }
+                     else
+                     {
+                        hasSiteLocation = true;
+                        siteLocation.Latitude = currSite.RefLatitude.Value * Math.PI / 180.0;
+                        siteLocation.Longitude = currSite.RefLongitude.Value * Math.PI / 180.0;
+                     }
+                  }
+               }
+               catch (Exception ex)
+               {
+                  Importer.TheLog.LogWarning(currSite.Id, "Invalid latitude or longitude value supplied for IFCSITE: " + ex.Message, false);
+               }
+            }
+         }
+
+         int? distantOriginFirstSiteId = null;
+
+         for (int ii = 0; ii < numSites; ii++)
+         {
+            IFCSite currSite = sites[ii];
+
+            // This is effectively no offset.  This is good, as long as we don't have
+            // a distance origin.  In that case, we will warn and not do any special offsets.
+            if (currSite.ObjectLocation?.RelativeTransform == null)
+            {
+               if (distantOriginFirstSiteId.HasValue)
+               {
+                  BaseSiteOffset = null;
+                  break;
+               }
+               continue;
+            }
+
+            double elevationToUse = currSite.RefElevation;
+            XYZ projectLoc = currSite.ObjectLocation.RelativeTransform.Origin;
+            if (!MathUtil.IsAlmostZero(projectLoc.Z))
+            {
+               if (MathUtil.IsAlmostZero(elevationToUse))
+               {
+                  currSite.RefElevation = projectLoc.Z;
+                  Importer.TheLog.LogError(currSite.Id, "The Z-value of the IfcSite object placement relative transform should be zero.  This will override the RefElevation value of zero.", false);
+               }
+               else
+               {
+                  Importer.TheLog.LogError(currSite.Id, "The Z-value of the IfcSite object placement relative transform should be zero.  This will be ignored in favor of the non-zero RefElevation value.", false);
+               }
+            }
+
+            XYZ offset = new XYZ(projectLoc.X, projectLoc.Y, elevationToUse);
+            if (XYZ.IsWithinLengthLimits(offset))
+            {
+               if (distantOriginFirstSiteId.HasValue)
+               {
+                  BaseSiteOffset = null;
+                  break;
+               }
+               continue;
+            }
+
+            if (BaseSiteOffset == null)
+            {
+               distantOriginFirstSiteId = currSite.Id;
+               
+               // If the index is greater than 0, then we have found some sites close to the
+               // origin.  That means we have incompatible origins which is an issue.
+               if (ii == 0)
+                  BaseSiteOffset = offset;
+               else
+                  break;
+            }
+         }
+
+         if (BaseSiteOffset != null)
+         {
+            ProjectPosition projectPosition = projectLocation.GetProjectPosition(XYZ.Zero);
+
+            projectPosition.EastWest += BaseSiteOffset.X;
+            projectPosition.NorthSouth += BaseSiteOffset.Y;
+            projectPosition.Elevation += BaseSiteOffset.Z;
+
+            projectLocation.SetProjectPosition(XYZ.Zero, projectPosition);
+
+            // Modify the RelativeTransforms for each of these sites.
+            // Note that the RelativeTransform must be defined to have gotten here.
+            for (int ii = 0; ii < numSites; ii++)
+            {
+               XYZ currentOffset = 
+                  new XYZ(-BaseSiteOffset.X, -BaseSiteOffset.Y, -BaseSiteOffset.Z + sites[ii].RefElevation);
+               Transform newSiteTransform = sites[ii].ObjectLocation.TotalTransform;
+               newSiteTransform.Origin += currentOffset;
+               sites[ii].ObjectLocation = IFCLocation.CreateDummyLocation(newSiteTransform);
+            }
+         }
+         else
+         {
+            // In this case, we just have to make sure that the RefElevation is included in
+            // the site transform.
+            for (int ii = 0; ii < numSites; ii++)
+            {
+               if (MathUtil.IsAlmostZero(sites[ii].RefElevation))
+                  continue;
+
+               if (sites[ii].ObjectLocation == null || sites[ii].ObjectLocation.RelativeTransform == null)
+               {
+                  XYZ currentOffset = new XYZ(0, 0, sites[ii].RefElevation);
+                  sites[ii].ObjectLocation = IFCLocation.CreateDummyLocation(Transform.CreateTranslation(currentOffset));
+               }
+               else
+               {
+                  double currRefElevation = sites[ii].RefElevation;
+                  double currZOffset = sites[ii].ObjectLocation.RelativeTransform.Origin.Z;
+                  if (!MathUtil.IsAlmostEqual(currZOffset, currRefElevation))
+                  {
+                     XYZ currentOffset = new XYZ(0, 0, currRefElevation - currZOffset);
+                     Transform newSiteTransform = sites[ii].ObjectLocation.TotalTransform;
+                     newSiteTransform.Origin += currentOffset;
+                     sites[ii].ObjectLocation = IFCLocation.CreateDummyLocation(newSiteTransform);
+                  }
+               }
+            }
+         }
+
+         if (BaseSiteOffset == null && distantOriginFirstSiteId.HasValue)
+         {
+            Importer.TheLog.LogError(distantOriginFirstSiteId.Value, "There are multiple sites in the file that are located far away from each other.  This may result in poor visualization of the data.", false);
+         }
+      }
 
       /// <summary>
       /// Creates or populates Revit element params based on the information contained in this class.
@@ -266,7 +443,15 @@ protected override void CreateParametersInternal(Document doc, Element element)
             }
          }
 
-         Importer.TheProcessor.PostProcessSite(this);
+         ForgeTypeId lengthUnits = null;
+         if (!Importer.TheProcessor.ScaleValues)
+         {
+            lengthUnits = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length)?.Unit;
+         }
+         
+         Importer.TheProcessor.PostProcessSite(Id, RefLatitude,
+            RefLongitude, RefElevation, LandTitleNumber, lengthUnits,
+            ObjectLocation?.TotalTransform);
       }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Data/IFCSpace.cs b/Source/Revit.IFC.Import/Data/IFCSpace.cs
index a4de72f7..cd651eb0 100644
--- a/Source/Revit.IFC.Import/Data/IFCSpace.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSpace.cs
@@ -76,7 +76,7 @@ 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, null, ElevationWithFlooring, Id);
+            IFCPropertySet.AddParameterDouble(doc, element, category, this, "ElevationWithFlooring", SpecTypeId.Length, UnitTypeId.Feet, ElevationWithFlooring, Id);
 
             // Set "PredefinedType" parameter.
             if (PredefinedType != null)
diff --git a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
index 36aec495..66542e31 100644
--- a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
@@ -221,6 +221,34 @@ void ProcessIFCRelServicesBuildings(IFCAnyHandle ifcRelHandle)
             Systems.Add(system);
       }
 
+      protected void TryToFixFarawayOrigin()
+      {
+         if (!(ProjectScope?.IsSet ?? false))
+            return;
+
+         // It is amazing that this works at all, but basically if we set the ProjectScope,
+         // and it has a reasonable bounding box size that is far from the origin, and
+         // the relative (non-shared) portion of this spatial element (building or
+         // building storey only) is also far from the origin and close to the bounding box,
+         // then we move it closer to the origin by subtracting the min corner of the
+         // bounding box.
+         // This fixes some cases where we have buildings or building stories that are really
+         // far from the origin but aren't all over the place.
+         // Real solution: don't create this data.
+         // There may be some better solution, but this is a compromise between not doing
+         // anything at all and not having a regression in old code that just moved stuff
+         // back to the origin.
+         XYZ relativeOrigin = ObjectLocation?.RelativeTransform?.Origin;
+         if (relativeOrigin != null && !XYZ.IsWithinLengthLimits(relativeOrigin))
+         {
+            if (XYZ.IsWithinLengthLimits(ProjectScope.Max - ProjectScope.Min) &&
+               XYZ.IsWithinLengthLimits(relativeOrigin - ProjectScope.Min))
+            {
+               ObjectLocation.RelativeTransform.Origin -= ProjectScope.Min;
+            }
+         }
+      }
+
       /// <summary>
       /// Processes IfcSpatialStructureElement handle.
       /// </summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCSweptDiskSolid.cs b/Source/Revit.IFC.Import/Data/IFCSweptDiskSolid.cs
index 3d0ad53f..b531bc06 100644
--- a/Source/Revit.IFC.Import/Data/IFCSweptDiskSolid.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSweptDiskSolid.cs
@@ -118,20 +118,22 @@ private IList<CurveLoop> CreateProfileCurveLoopsForDirectrix(Curve directrix, ou
             return null;
 
          // The X-dir of the transform of the start of the directrix will form the normal of the disk.
-         Plane diskPlane = Plane.CreateByNormalAndOrigin(originTrf.BasisX, originTrf.Origin);
+         // We are not using the origin in Plane.CreateByNormalAndOrigin because that has
+         // limits of [-30K,30K].
+         Plane diskPlaneAxes = Plane.CreateByNormalAndOrigin(originTrf.BasisX, XYZ.Zero);
 
          IList<CurveLoop> profileCurveLoops = new List<CurveLoop>();
 
          CurveLoop diskOuterCurveLoop = new CurveLoop();
-         diskOuterCurveLoop.Append(Arc.Create(diskPlane, Radius, 0, Math.PI));
-         diskOuterCurveLoop.Append(Arc.Create(diskPlane, Radius, Math.PI, 2.0 * Math.PI));
+         diskOuterCurveLoop.Append(Arc.Create(originTrf.Origin, Radius, 0, Math.PI, diskPlaneAxes.XVec, diskPlaneAxes.YVec));
+         diskOuterCurveLoop.Append(Arc.Create(originTrf.Origin, Radius, Math.PI, 2.0 * Math.PI, diskPlaneAxes.XVec, diskPlaneAxes.YVec));
          profileCurveLoops.Add(diskOuterCurveLoop);
 
          if (InnerRadius.HasValue)
          {
             CurveLoop diskInnerCurveLoop = new CurveLoop();
-            diskInnerCurveLoop.Append(Arc.Create(diskPlane, InnerRadius.Value, 0, Math.PI));
-            diskInnerCurveLoop.Append(Arc.Create(diskPlane, InnerRadius.Value, Math.PI, 2.0 * Math.PI));
+            diskInnerCurveLoop.Append(Arc.Create(originTrf.Origin, InnerRadius.Value, 0, Math.PI, diskPlaneAxes.XVec, diskPlaneAxes.YVec));
+            diskInnerCurveLoop.Append(Arc.Create(originTrf.Origin, InnerRadius.Value, Math.PI, 2.0 * Math.PI, diskPlaneAxes.XVec, diskPlaneAxes.YVec));
             profileCurveLoops.Add(diskInnerCurveLoop);
          }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs b/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
index 16e5143a..37eb8a43 100644
--- a/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
+++ b/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
@@ -204,7 +204,7 @@ protected override void Process(IFCAnyHandle ifcCurve)
             Curve copyCurve = baseCurve.Clone();
 
             double length = param2 - param1;
-            if (length <= Importer.TheProcessor.ShortCurveTolerance)
+            if (length <= IFCImportFile.TheFile.ShortCurveTolerance)
             {
                string lengthAsString = IFCUnitUtil.FormatLengthAsString(length);
                Importer.TheLog.LogError(Id, "curve length of " + lengthAsString + " is invalid, ignoring.", false);
@@ -283,7 +283,7 @@ private void GetTrimParameters(int id, IFCData trim1, IFCData trim2,
          bool preferParam = !(trimPreference == IFCTrimmingPreference.Cartesian);
          if (secondAttempt)
             preferParam = !preferParam;
-         double vertexEps = Importer.TheProcessor.VertexTolerance;
+         double vertexEps = IFCImportFile.TheFile.VertexTolerance;
 
          IFCAggregate trimAggregate = trim.AsAggregate();
          foreach (IFCData trimParam in trimAggregate)
diff --git a/Source/Revit.IFC.Import/Data/IFCTypeObject.cs b/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
index f41eea05..0ab215f2 100644
--- a/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
+++ b/Source/Revit.IFC.Import/Data/IFCTypeObject.cs
@@ -191,6 +191,7 @@ protected override void Create(Document doc)
             // If we used the element from the cache, we want to make sure that the IFCRepresentationMap can access it
             // instead of creating a new element.
             Importer.TheCache.CreatedDirectShapeTypes[Id] = shapeType.Id;
+            shapeType.SetShape(new List<GeometryObject>());
          }
 
          if (shapeType == null)
diff --git a/Source/Revit.IFC.Import/Data/IFCUnit.cs b/Source/Revit.IFC.Import/Data/IFCUnit.cs
index 7a3af4d7..9b2872a3 100644
--- a/Source/Revit.IFC.Import/Data/IFCUnit.cs
+++ b/Source/Revit.IFC.Import/Data/IFCUnit.cs
@@ -297,6 +297,15 @@ private IDictionary<string, Tuple<ForgeTypeId, ForgeTypeId>> GetSupportedDisplay
                supportedTypes[""] = Tuple.Create(UnitTypeId.KilogramsPerCubicMeter, SymbolTypeId.KgPerMSup3);    // Even if unit is grams, display kg.
                supportedTypes["KILO"] = Tuple.Create(UnitTypeId.KilogramsPerCubicMeter, SymbolTypeId.KgPerMSup3);
             }
+            else if (specTypeId.Equals(SpecTypeId.PipingMassPerTime))
+            {
+               supportedTypes[""] = Tuple.Create(UnitTypeId.KilogramsPerSecond, SymbolTypeId.KgPerS);    // Even if unit is grams, display kg.
+               supportedTypes["KILO"] = Tuple.Create(UnitTypeId.KilogramsPerSecond, SymbolTypeId.KgPerS);
+            }
+            else if (specTypeId.Equals(SpecTypeId.AngularSpeed))
+            {
+               supportedTypes[""] = Tuple.Create(UnitTypeId.RevolutionsPerSecond, SymbolTypeId.Rps);
+            }
             else if (specTypeId.Equals(SpecTypeId.Volume))
             {
                supportedTypes[""] = Tuple.Create(UnitTypeId.CubicMeters, SymbolTypeId.MSup3);
@@ -304,6 +313,10 @@ private IDictionary<string, Tuple<ForgeTypeId, ForgeTypeId>> GetSupportedDisplay
                supportedTypes["CENTI"] = Tuple.Create(UnitTypeId.CubicCentimeters, SymbolTypeId.CmSup3);
                supportedTypes["MILLI"] = Tuple.Create(UnitTypeId.CubicMillimeters, SymbolTypeId.MmSup3);
             }
+            else if (specTypeId.Equals(SpecTypeId.Wattage))
+            {
+               supportedTypes[""] = Tuple.Create(UnitTypeId.Watts, SymbolTypeId.Watt);
+            }
             m_sSupportedMetricUnitTypes[specTypeId] = supportedTypes;
          }
 
@@ -606,6 +619,43 @@ void ProcessIFCDerivedUnit(IFCAnyHandle unitHnd)
             expectedTypes2.AddExpectedType(-2, SpecTypeId.Length);
             expectedTypesList.Add(expectedTypes2);
          }
+         else if (string.Compare(unitType, "MASSFLOWRATEUNIT", true) == 0)
+         {
+            Spec = SpecTypeId.PipingMassPerTime;
+            UnitSystem = UnitSystem.Metric;
+
+            // Support kg / s in the IFC file.
+
+            // kg / s
+            DerivedUnitExpectedTypes expectedTypesKgPerS = new DerivedUnitExpectedTypes(UnitTypeId.KilogramsPerSecond, SymbolTypeId.KgPerS);
+            expectedTypesKgPerS.AddExpectedType(1, SpecTypeId.Mass);
+            expectedTypesKgPerS.AddCustomExpectedType(-1, "TIMEUNIT");
+            expectedTypesList.Add(expectedTypesKgPerS);
+         }
+         else if (string.Compare(unitType, "ROTATIONALFREQUENCYUNIT", true) == 0)
+         {
+            Spec = SpecTypeId.AngularSpeed;
+            UnitSystem = UnitSystem.Metric;
+
+            // Support revolutions / s in the IFC file.
+
+            // revolutions / s
+            DerivedUnitExpectedTypes expectedTypesCps = new DerivedUnitExpectedTypes(UnitTypeId.RevolutionsPerSecond, SymbolTypeId.Rps);
+            expectedTypesCps.AddCustomExpectedType(-1, "TIMEUNIT");
+            expectedTypesList.Add(expectedTypesCps);
+         }
+         else if (string.Compare(unitType, "SOUNDPOWERUNIT", true) == 0)
+         {
+            Spec = SpecTypeId.Wattage;
+            UnitSystem = UnitSystem.Metric;
+
+            // Support watt in the IFC file.
+
+            // watt
+            DerivedUnitExpectedTypes expectedTypesW = new DerivedUnitExpectedTypes(UnitTypeId.Watts, SymbolTypeId.Watt);
+            expectedTypesW.AddExpectedType(1, SpecTypeId.HvacPower);
+            expectedTypesList.Add(expectedTypesW);
+         }
          else if (string.Compare(unitType, "USERDEFINED", true) == 0)
          {
             // Look at the sub-types to see what we support.
diff --git a/Source/Revit.IFC.Import/Enums/IFCSchemaVersion.cs b/Source/Revit.IFC.Import/Enums/IFCSchemaVersion.cs
index d440bf97..7a1f0bf0 100644
--- a/Source/Revit.IFC.Import/Enums/IFCSchemaVersion.cs
+++ b/Source/Revit.IFC.Import/Enums/IFCSchemaVersion.cs
@@ -39,6 +39,10 @@ public enum IFCSchemaVersion
       // are older formats, in which case we can "downgrade" the version.
       IFC4Obsolete,
       IFC4Add1Obsolete,
-      IFC4
+      IFC4,
+      IFC4x1,
+      IFC4x2,
+      IFC4x3_RC1,
+      IFC4x3_RC3
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Geometry/IFCGeometryUtil.cs b/Source/Revit.IFC.Import/Geometry/IFCGeometryUtil.cs
index 88fa6ecd..6319064a 100644
--- a/Source/Revit.IFC.Import/Geometry/IFCGeometryUtil.cs
+++ b/Source/Revit.IFC.Import/Geometry/IFCGeometryUtil.cs
@@ -206,7 +206,7 @@ private static double ScaleCurveLengthForSweptSolid(Curve curve, double param)
       public static bool LineSegmentIsTooShort(XYZ pt1, XYZ pt2)
       {
          double dist = pt1.DistanceTo(pt2);
-         return (dist < Importer.TheProcessor.ShortCurveTolerance + MathUtil.Eps());
+         return (dist < IFCImportFile.TheFile.ShortCurveTolerance + MathUtil.Eps());
       }
 
       /// <summary>
@@ -703,6 +703,35 @@ public static IList<CurveLoop> TrimCurveLoops(int id, IFCCurve ifcCurve, double
          return trimmedDirectrices;
       }
 
+      private class ShiftDistance
+      {
+         public static double GetScaledShiftDistance(int pass, out double unscaledDistance)
+         {
+            unscaledDistance = GetShiftDistanceInMM(pass);
+            return unscaledDistance * GetShiftDirection(pass) * OneMilliter;
+         }
+
+         private static double GetShiftDistanceInMM(int pass)
+         {
+            if (pass < 1 || pass > NumberOfPasses)
+               return 0.0;
+            return Distances[((pass - 1) >> 3)];
+         }
+
+         private static int GetShiftDirection(int pass)
+         {
+            return (pass % 2 == 1) ? 1 : -1;
+         }
+
+         private static readonly double[] Distances = new double[5] { 0.1, 0.25, 0.5, 0.75, 1.0 };
+
+         private static readonly int NumberOfNudgeDistances = 5;
+
+         public static int NumberOfPasses { get => NumberOfNudgeDistances * 8 + 1; }
+
+         private static readonly double OneMilliter = 1.0 / 304.8;
+      };
+      
       /// <summary>
       /// Execute a Boolean operation, and catch the exception.
       /// </summary>
@@ -750,13 +779,13 @@ public static Solid ExecuteSafeBooleanOperation(int id, int secondId, Solid firs
          // In the first pass, we will try to do the Boolean operation as-is.
          // For subsequent passes, we will shift the second operand by a small distance in 
          // a given direction, using the following formula:
-         // We start with a 1mm shift, and try each of (up to 4) shift directions given by
+         // We start with a 0.1mm shift, and try each of (up to 5) shift directions given by
          // the shiftDirections list below, in alternating positive and negative directions.
          // In none of these succeed, we will increment the distance by 1mm and try again
          // until we reach numPasses.
          // Boolean operations are expensive, and as such we want to limit the number of
          // attempts we make here to balance fidelity and performance.  Initial experimentation
-         // suggests that a maximum 3mm shift is a good first start for this balance.
+         // suggests that a maximum 1mm shift is a good first start for this balance.
          IList<XYZ> shiftDirections = new List<XYZ>()
          {
             suggestedShiftDirection,
@@ -765,10 +794,10 @@ public static Solid ExecuteSafeBooleanOperation(int id, int secondId, Solid firs
             XYZ.BasisY
          };
 
-         const int numberOfNudges = 4;
-         const int numPasses = numberOfNudges * 8 + 1; // 1 base, 8 possible nudges up to 0.75mm.
+         // 1 base, 8 possible nudges up to 1mm.
+         int numPasses = ShiftDistance.NumberOfPasses;
          double currentShiftFactor = 0.0;
-
+         
          for (int ii = 0; ii < numPasses; ii++)
          {
             try
@@ -783,10 +812,8 @@ public static Solid ExecuteSafeBooleanOperation(int id, int secondId, Solid firs
                   if (shiftDirectionToUse == null)
                      continue;
 
-                  // ((ii + 3) >> 3) * 0.25mm shift.  Basically, a 0.25mm shift for every 8 attempts.
-                  currentShiftFactor = ((ii + 1) >> 3) * 0.25;
-                  int posOrNegDirection = (ii % 2 == 1) ? 1 : -1;
-                  double scale = currentShiftFactor * posOrNegDirection * IFCImportFile.TheFile.OneMillimeter;
+                  // Increase the shift distance after every 8 attempts.
+                  double scale = ShiftDistance.GetScaledShiftDistance(ii, out currentShiftFactor);
                   Transform secondSolidShift = Transform.CreateTranslation(scale * shiftDirectionToUse);
                   secondOperand = SolidUtils.CreateTransformed(secondOperand, secondSolidShift);
                }
diff --git a/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs b/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
index 8daf7004..6192782c 100644
--- a/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
+++ b/Source/Revit.IFC.Import/Processors/IFCDefaultProcessor.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 using Autodesk.Revit.DB;
-using Revit.IFC.Import.Data;
-using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import
 {
@@ -19,27 +16,21 @@ public void CreateElementType(int ifcId, string ifcGuid, string ifcEntityType, i
       {
       }
 
-      public void PostProcessMappedItem(IFCImportShapeEditScope shapeEditScope, IFCMappedItem mappedItem, Transform newLcs)
-      {
-         // We should now have a type object that contains geometry.
-         IFCRepresentationMap mappingSource = mappedItem.MappingSource;
-
-         IList<GeometryObject> instances = DirectShape.CreateGeometryInstance(shapeEditScope.Document, mappingSource.Id.ToString(), newLcs);
-         foreach (GeometryObject instance in instances)
-            shapeEditScope.AddGeometry(IFCSolidInfo.Create(mappedItem.Id, instance));
+      public void PostProcessMappedItem(int creatorId,
+         string globalId,
+         string entityTypeAsString,
+         ElementId categoryId,
+         int geometrySourceId,
+         Transform newLcs)
+      { 
       }
 
-      public void PostProcessProduct(int ifcId, IFCTypeObject typeObject, IFCImportShapeEditScope shapeEditScope,
-         DirectShape shape, Transform lcs, IList<GeometryObject> directShapeGeometries)
+      public bool PostProcessProduct(int ifcId,
+         int? typeObjectId,
+         Transform lcs,
+         IList<GeometryObject> directShapeGeometries)
       {
-         if (shape == null)
-            return;
-
-         shape.SetShape(directShapeGeometries);
-         shapeEditScope.SetPlanViewRep(shape);
-
-         if (typeObject != null && typeObject.CreatedElementId != ElementId.InvalidElementId)
-            shape.SetTypeId(typeObject.CreatedElementId);
+         return false;
       }
 
       public bool? ProcessParameter(int objDefId, ForgeTypeId specTypeId, ForgeTypeId unitsTypeId,
@@ -78,33 +69,30 @@ public bool SetParameter(Element element, BuiltInParameter parameterId, string v
          return true;
       }
 
-      public void PostProcessRepresentationMap(int typeId, IFCImportShapeEditScope shapeEditScope,
-         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids, DirectShapeType directShapeType)
+      public bool PostProcessRepresentationMap(int typeId, 
+         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids)
       {
-         directShapeType.AppendShape(mappedSolids);
-         if (mappedCurves.Count != 0)
-            shapeEditScope.SetPlanViewRep(directShapeType);
+         return false;
       }
 
-      public void PostProcessSite(IFCSite site)
+      public void PostProcessSite(int siteId, double? refLatitude, double? refLongitude,
+         double refElevation, string landTitleNumber, ForgeTypeId baseLengthUnits,
+         Transform lcs)
       {
       }
 
-      public void PostProcessProject()
+      public void PostProcessProject(double? lengthScaleFactor, ForgeTypeId lengthUnit)
       {
-         var application = IFCImportFile.TheFile.Document.Application;
-         VertexTolerance = application.VertexTolerance;
-         ShortCurveTolerance = application.ShortCurveTolerance;
       }
 
-      public bool ShouldFixFarAwayLocation { get => true; }
+      public bool FindAlternateGeometrySource { get => false; }
 
       public bool ScaleValues { get => true; }
 
       public bool ApplyTransforms { get => true; }
 
-      public double VertexTolerance { get; set; } = 0.0;
-
-      public double ShortCurveTolerance { get; set; } = 0.0;
+      public bool TryToFixFarawayOrigin { get => true; }
+      
+      public double ScaleLength(double length) { return length; }
    }
 }
diff --git a/Source/Revit.IFC.Import/Processors/IFCNavisProcessor.cs b/Source/Revit.IFC.Import/Processors/IFCNavisProcessor.cs
index fec5911d..88e42321 100644
--- a/Source/Revit.IFC.Import/Processors/IFCNavisProcessor.cs
+++ b/Source/Revit.IFC.Import/Processors/IFCNavisProcessor.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 using Autodesk.Revit.DB;
-using Revit.IFC.Import.Data;
-using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import
 {
@@ -114,43 +111,32 @@ public void CreateElementType(int ifcId, string ifcGuid, string ifcEntityType, i
          }
       }
 
-      public void PostProcessMappedItem(IFCImportShapeEditScope shapeEditScope, IFCMappedItem mappedItem, Transform newLcs)
+      public void PostProcessMappedItem(int creatorId,
+         string globalId,
+         string entityTypeAsString,
+         ElementId categoryId,
+         int geometrySourceId,
+         Transform newLcs)
       {
-         if (shapeEditScope.Creator != null)
+         // Copy some code from elsewhere to work out what the object was that got the geometry.
+         // Now get that type object
+         var typeEle = GetElementFromStepId(geometrySourceId);
+
+         // The type element might not have been created, if its geometry processing failed.
+         if (typeEle != null)
          {
-            // Copy some code from elsewhere to work out what the object was that got the geometry.
-            int originalMappingSourceId = mappedItem.MappingSource.Id;
-            int typeObjectId = originalMappingSourceId;
-            IFCTypeProduct typeProduct = null;
-            if (Importer.TheCache.RepMapToTypeProduct.TryGetValue(originalMappingSourceId, out typeProduct) && typeProduct != null)
-            {
-               typeObjectId = typeProduct.Id;
-            }
-
-            // Now get that type object
-            var typeEle = GetElementFromStepId(typeObjectId);
-
-            // The type element might not have been created, if its geometry processing failed.
-            if (typeEle != null)
-            {
-               // We now need to set the type object geometry onto the entity.
-               // The main reason for needing to do it here is because we have newLcs calculated, but we haven't yet got 
-               // and IElement for the entity, so first create one.
-               var instEle = CreateElement(shapeEditScope.Creator.Id, shapeEditScope.Creator.GlobalId, shapeEditScope.Creator.EntityType.ToString(), shapeEditScope.Creator.CategoryId.IntegerValue);
-               instEle.SetGeometry(typeEle, newLcs);
-
-               // Hack
-               // Add some bogus geometry so that later on we think that this object matters.
-               // Without this we don't create a DirectShape later on and so CreatedElementId is not set.
-               IList<GeometryObject> instances = DirectShape.CreateGeometryInstance(shapeEditScope.Document, originalMappingSourceId.ToString(), newLcs);
-               foreach (GeometryObject instance in instances)
-                  shapeEditScope.AddGeometry(IFCSolidInfo.Create(mappedItem.Id, instance));
-            }
+            // We now need to set the type object geometry onto the entity.
+            // The main reason for needing to do it here is because we have newLcs calculated, but we haven't yet got 
+            // and IElement for the entity, so first create one.
+            var instEle = CreateElement(creatorId, globalId, entityTypeAsString, categoryId.IntegerValue);
+            instEle.SetGeometry(typeEle, newLcs);
          }
       }
 
-      public void PostProcessProduct(int ifcId, IFCTypeObject typeObject, IFCImportShapeEditScope shapeEditScope,
-         DirectShape shape, Transform lcs, IList<GeometryObject> directShapeGeometries)
+      public bool PostProcessProduct(int ifcId, 
+         int? typeObjectId,
+         Transform lcs,
+         IList<GeometryObject> directShapeGeometries)
       {
          var ele = GetElementFromStepId(ifcId);
 
@@ -168,66 +154,34 @@ public void PostProcessProduct(int ifcId, IFCTypeObject typeObject, IFCImportSha
          // with this.
          ele.SetGeometry(directShapeGeometries);
 
-         if (typeObject != null)
+         if (typeObjectId.HasValue)
          {
-            var typeEle = GetElementFromStepId(typeObject.Id);
+            var typeEle = GetElementFromStepId(typeObjectId.Value);
 
             ele.SetType(typeEle);
          }
+
+         return true;
       }
 
-      public void PostProcessProject()
+      public void PostProcessProject(double? lengthScaleFactor, ForgeTypeId lengthUnit)
       {
-         var application = IFCImportFile.TheFile.Document.Application;
-         double vertexTolerance = application.VertexTolerance;
-         double shortCurveTolerance = application.ShortCurveTolerance;
-
-         if (ScaleValues)
+         if (lengthUnit != null && lengthScaleFactor.HasValue && !ScaleValues)
          {
-            ReportLengthUnits(UnitTypeId.Feet);
-            VertexTolerance = vertexTolerance;
-            ShortCurveTolerance = shortCurveTolerance;
+            LengthScale = 1.0 / lengthScaleFactor.Value;
+            ReportLengthUnits(lengthUnit);
          }
          else
          {
-            var units = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length);
-
-            if (units != null)
-            {
-               ReportLengthUnits(units.Unit);
-               VertexTolerance = vertexTolerance / units.ScaleFactor;
-               ShortCurveTolerance = shortCurveTolerance / units.ScaleFactor;
-               IFCImportFile.TheFile.OneHundrethOfAFoot = 0.01 / units.ScaleFactor;
-               IFCImportFile.TheFile.OneMillimeter = UnitUtils.Convert(1.0, UnitTypeId.Millimeters, units.Unit);
-            }
+            LengthScale = 1.0;
+            ReportLengthUnits(UnitTypeId.Feet);
          }
       }
 
-      public bool? ProcessParameter(int objDefId, ForgeTypeId specTypeId, ForgeTypeId unitsTypeId,
+      public bool? ProcessParameter(int objDefId, ForgeTypeId specTypeId, 
+         ForgeTypeId unitsTypeId,
          int parameterSetId, string parameterName, double parameterValue)
       {
-         if (unitsTypeId == null)
-         {
-            if (!ScaleValues)
-            {
-               // We can look up the units when the values are not scaled.
-               var units = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(specTypeId);
-               if (units != null)
-               {
-                  unitsTypeId = units.Unit;
-               }
-               else
-               {
-                  // No units - is this the current unit for that ?
-                  unitsTypeId = UnitTypeId.General;
-               }
-            }
-            else
-            {
-               // Get the internal units for the specTypeId
-            }
-         }
-
          GetElementFromStepId(objDefId).AddParameter(parameterSetId, parameterName, parameterValue, specTypeId, unitsTypeId);
          return true;
       }
@@ -261,57 +215,58 @@ public bool SetParameter(Element element, BuiltInParameter parameterId, string v
          return false;
       }
 
-      public void PostProcessRepresentationMap(int typeId, IFCImportShapeEditScope shapeEditScope,
-         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids, DirectShapeType directShapeType)
+      public bool PostProcessRepresentationMap(int typeId,
+         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids)
       {
          GetElementFromStepId(typeId).SetGeometry(mappedSolids);
+         return true;
       }
 
-      public void PostProcessSite(IFCSite site)
+      public void PostProcessSite(int siteId, double? refLatitude, double? refLongitude, 
+         double refElevation, string landTitleNumber, ForgeTypeId baseLengthUnits, 
+         Transform lcs)
       {
-         var ele = GetElementFromStepId(site.Id);
-         if (site.RefLatitude.HasValue)
-         {
-            ele.AddParameter(-1, "Latitude", site.RefLatitude.Value, SpecTypeId.Angle, UnitTypeId.Degrees);
-         }
-         if (site.RefLongitude.HasValue)
+         var ele = GetElementFromStepId(siteId);
+         if (refLatitude.HasValue)
          {
-            ele.AddParameter(-1, "Longitude", site.RefLongitude.Value, SpecTypeId.Angle, UnitTypeId.Degrees);
+            ele.AddParameter(-1, "Latitude", refLatitude.Value, SpecTypeId.Angle, UnitTypeId.Degrees);
          }
-
-         var lengthUnits = UnitTypeId.Feet;
-
-         if (!ScaleValues)
+         if (refLongitude.HasValue)
          {
-            var lU = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length);
-            if (lU != null)
-            {
-               lengthUnits = lU.Unit;
-            }
+            ele.AddParameter(-1, "Longitude", refLongitude.Value, SpecTypeId.Angle, UnitTypeId.Degrees);
          }
 
-         ele.AddParameter(-1, "Elevation", site.RefElevation, SpecTypeId.Length, lengthUnits);
-         ele.AddParameter(-1, "LandTitleNumber", site.LandTitleNumber);
+         // refElevation comes from an attribute so will be in feet
+         ele.AddParameter(-1, "Elevation", refElevation, SpecTypeId.Length, UnitTypeId.Feet);
+         ele.AddParameter(-1, "LandTitleNumber", landTitleNumber);
 
-         if (site.ObjectLocation != null)
+         if (lcs != null)
          {
             // If we are reporting Latitude and Longitude, then we need a transform, to know 
             // where this survey point is, in our world space.
-            ele.SetTransform(site.ObjectLocation.TotalTransform);
+            ele.SetTransform(lcs);
          }
       }
 
-      public bool ShouldFixFarAwayLocation { get => false; }
+      public bool FindAlternateGeometrySource { get => true; }
 
       // For this initial implementation of a Navis processor, 
-      // we have no scaling and no applied transforms.
-      
+      // we have no applied transforms and property values are unscaled.
+      // However, geometry always need to be in feet and for simplicity
+      // this means that no values going through IFCUnitUtil are scaled.
+      // This means that transforms and attribute length values are also
+      // in feet
       public bool ScaleValues { get => false; }
 
       public bool ApplyTransforms { get => false; }
 
-      public double VertexTolerance { get; set; } = 0.0;
+      public bool TryToFixFarawayOrigin { get => false; }
+
+      private double LengthScale { get; set; } = 1.0;
 
-      public double ShortCurveTolerance { get; set; } = 0.0;
+      public double ScaleLength(double length)
+      {
+         return length * LengthScale;
+      }
    }
 }
diff --git a/Source/Revit.IFC.Import/Processors/IIFCFileProcessor.cs b/Source/Revit.IFC.Import/Processors/IIFCFileProcessor.cs
index 8b71d1b7..4446e1e1 100644
--- a/Source/Revit.IFC.Import/Processors/IIFCFileProcessor.cs
+++ b/Source/Revit.IFC.Import/Processors/IIFCFileProcessor.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 using Autodesk.Revit.DB;
-using Revit.IFC.Import.Data;
-using Revit.IFC.Import.Utility;
 
 namespace Revit.IFC.Import
 {
@@ -63,29 +60,38 @@ bool CreateOrUpdateElement(int ifcId, string ifcGuid, string ifcEntityType, int
       /// <param name="shapeEditScope">The shape edit scope of the object.</param>
       /// <param name="mappedItem">The mapped item container.</param>
       /// <param name="newLcs">The local transform for the mapped item.</param>
-      void PostProcessMappedItem(IFCImportShapeEditScope shapeEditScope, IFCMappedItem mappedItem, Transform newLcs);
+      void PostProcessMappedItem(int creatorId,
+         string globalId,
+         string entityTypeAsString,
+         ElementId categoryId,
+         int geometrySourceId,
+         Transform newLcs);
 
       /// <summary>
       /// NAVIS_TODO
       /// </summary>
       /// <param name="ifcId">The STEP Id of the IFC entity</param>
-      /// <param name="typeObject">The IfcTypeObject related to the entity</param>
+      /// <param name="typeObjectId">The id of the IfcTypeObject related to the entity, if any</param>
       /// <param name="shapeEditScope">The shape edit scope</param>
       /// <param name="shape">The DirectShape containing the IFC entity data</param>
       /// <param name="lcs">The transform of the associated geometry</param>
       /// <param name="directShapeGeometries">The associated geometry</param>
-      void PostProcessProduct(int ifcId, IFCTypeObject typeObject, IFCImportShapeEditScope shapeEditScope,
-         DirectShape shape, Transform lcs, IList<GeometryObject> directShapeGeometries);
+      bool PostProcessProduct(int ifcId,
+         int? typeObjectId,
+         Transform lcs,
+         IList<GeometryObject> directShapeGeometries);
 
       /// <summary>
       /// NAVIS_TODO
       /// </summary>
-      void PostProcessProject();
+      void PostProcessProject(double? lengthScaleFactor, ForgeTypeId lengthUnit);
 
-      void PostProcessRepresentationMap(int typeId, IFCImportShapeEditScope shapeEditScope,
-         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids, DirectShapeType directShapeType);
+      bool PostProcessRepresentationMap(int typeId, 
+         IList<Curve> mappedCurves, IList<GeometryObject> mappedSolids);
 
-      void PostProcessSite(IFCSite site);
+      void PostProcessSite(int siteId, double? refLatitude, double? refLongitude,
+         double refElevation, string landTitleNumber, ForgeTypeId baseLengthUnits,
+         Transform lcs);
 
       /// <summary>
       /// Set a built-in parameter string value in an element.
@@ -96,8 +102,17 @@ void PostProcessRepresentationMap(int typeId, IFCImportShapeEditScope shapeEditS
       /// <returns>True if the parameter was set, false otherwise.</returns>
       bool SetParameter(Element element, BuiltInParameter parameterId, string value);
 
+      /// <summary>
+      /// Determine if we should apply transforms to geometries.
+      /// </summary>
       bool ApplyTransforms { get; }
 
+      /// <summary>
+      /// Determine if we should try to fix building and building story locations 
+      /// far from the origin.
+      /// </summary>
+      bool TryToFixFarawayOrigin { get; }
+      
       /// <summary>
       /// If true, then scale all values into internal units, otherwise leave them as is.
       /// </summary>
@@ -108,14 +123,13 @@ void PostProcessRepresentationMap(int typeId, IFCImportShapeEditScope shapeEditS
       /// </remarks>
       bool ScaleValues { get; }
 
+      bool FindAlternateGeometrySource { get; }
+      
       /// <summary>
-      /// Determines if the importer should try to fix files which have large origin offsets
-      /// for some entities.
+      /// Performs a processor-specific extra length scaling if necessary.
       /// </summary>
-      bool ShouldFixFarAwayLocation { get; }
-
-      double ShortCurveTolerance { get; set; }
-
-      double VertexTolerance { get; set; }
+      /// <param name="length">The original length.</param>
+      /// <returns>The scaled length.</returns>
+      double ScaleLength(double length);
    }
 }
diff --git a/Source/Revit.IFC.Import/Utility/IFCDataUtil.cs b/Source/Revit.IFC.Import/Utility/IFCDataUtil.cs
index 4510c45e..28ea9f24 100644
--- a/Source/Revit.IFC.Import/Utility/IFCDataUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCDataUtil.cs
@@ -52,6 +52,7 @@ static private void InitializeMeasureCache()
          m_MeasureCache["IfcLinearVelocityMeasure"] = SpecTypeId.HvacVelocity;
          m_MeasureCache["IfcLuminousFluxMeasure"] = SpecTypeId.LuminousFlux;
          m_MeasureCache["IfcLuminousIntensityMeasure"] = SpecTypeId.LuminousIntensity;
+         m_MeasureCache["IfcMassFlowRateMeasure"] = SpecTypeId.PipingMassPerTime;
          m_MeasureCache["IfcMassMeasure"] = SpecTypeId.Mass;
          m_MeasureCache["IfcMassDensityMeasure"] = SpecTypeId.MassDensity;
          m_MeasureCache["IfcMonetaryMeasure"] = SpecTypeId.Currency;
@@ -65,6 +66,8 @@ static private void InitializeMeasureCache()
          m_MeasureCache["IfcPressureMeasure"] = SpecTypeId.HvacPressure;
          m_MeasureCache["IfcRatioMeasure"] = SpecTypeId.Number;
          m_MeasureCache["IfcReal"] = SpecTypeId.Number;
+         m_MeasureCache["IfcRotationalFrequencyMeasure"] = SpecTypeId.AngularSpeed;
+         m_MeasureCache["IfcSoundPowerMeasure"] = SpecTypeId.Wattage;
          m_MeasureCache["IfcTimeMeasure"] = SpecTypeId.Time;
          m_MeasureCache["IfcTimeStamp"] = SpecTypeId.Number;  // No unit type for time in Revit.
          m_MeasureCache["IfcThermalTransmittanceMeasure"] = SpecTypeId.HeatTransferCoefficient;
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs b/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
index 759ff6a7..70201040 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
@@ -436,31 +436,5 @@ public static IList<IList<IFCAnyHandle>> GetListOfListOfInstanceAttribute(IFCAny
          }
          return outerList;
       }
-
-      /// <summary>
-      /// Read the HasAssignments INVERSE attribute from an IfcObjectDefinition, if it is defined.
-      /// </summary>
-      /// <param name="ifcObjectDefinition">The handle assumed to be an IfcObjectDefinition.</param>
-      /// <returns>The set.</returns>
-      /// <remarks>This deals with the issue that the default IFC2x3 EXP file doesn't have this inverse attribute set.</remarks>
-      static public ISet<IFCAnyHandle> GetHasAssignments(IFCAnyHandle ifcObjectDefinition)
-      {
-         HashSet<IFCAnyHandle> hasAssignments = null;
-         if (IFCImportFile.TheFile.Options.AllowUseHasAssignments)
-         {
-            try
-            {
-               hasAssignments = IFCAnyHandleUtil.GetAggregateInstanceAttribute
-                   <HashSet<IFCAnyHandle>>(ifcObjectDefinition, "HasAssignments");
-            }
-            catch
-            {
-               IFCImportFile.TheFile.Options.AllowUseHasAssignments = false;
-               hasAssignments = null;
-            }
-         }
-
-         return hasAssignments;
-      }
    }
 }
\ No newline at end of file
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs b/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
index 8d9252d8..cf910fce 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportOptions.cs
@@ -134,12 +134,6 @@ public static string ImporterVersion
       /// </summary>
       public bool CreateDuplicateContainerGeometry { get; protected set; } = true;
 
-      /// <summary>
-      /// If true, process the HasAssignments INVERSE attribute.  If false, ignore.
-      /// This is necessary because the default IFC2x3_TC1 EXPRESS schema file is (incorrectly) missing this inverse attribute.
-      /// </summary>
-      public bool AllowUseHasAssignments { get; set; } = false;
-
       /// <summary>
       /// If this value is false, then, if we find an already created Revit file corresponding to the IFC file,
       /// and it is up-to-date (that is, the saved timestamp and file size on the RVT file are the same as on the IFC file),
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs b/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
index 946f95fb..7ea9d192 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportShapeEditScope.cs
@@ -304,11 +304,11 @@ public bool MustCreateSolid()
       public double GetShortSegmentTolerance()
       {
          if (BuilderType != IFCShapeBuilderType.TessellatedShapeBuilder)
-            return Importer.TheProcessor.ShortCurveTolerance;
+            return IFCImportFile.TheFile.ShortCurveTolerance;
 
          TessellatedShapeBuilderScope bs = BuilderScope as TessellatedShapeBuilderScope;
          return (bs.TargetGeometry == TessellatedShapeBuilderTarget.Mesh) ?
-            MathUtil.Eps() : Importer.TheProcessor.ShortCurveTolerance;
+            MathUtil.Eps() : IFCImportFile.TheFile.ShortCurveTolerance;
       }
 
       /// <summary>
diff --git a/Source/Revit.IFC.Import/Utility/IFCUnitUtil.cs b/Source/Revit.IFC.Import/Utility/IFCUnitUtil.cs
index 368121d3..5dcf35f9 100644
--- a/Source/Revit.IFC.Import/Utility/IFCUnitUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCUnitUtil.cs
@@ -36,7 +36,7 @@ public class IFCUnitUtil
       /// <returns>The result value in Revit internal units.</returns>
       static public double ScaleAngle(double inValue)
       {
-         return ProjectScale(SpecTypeId.Angle, inValue, true);
+         return ProjectScale(SpecTypeId.Angle, inValue);
       }
 
       /// <summary>
@@ -57,9 +57,6 @@ static public double ScaleLength(double inValue)
       /// <remarks>Note that the OffsetFactor is ignored.</remarks>
       static public XYZ ScaleLength(XYZ inValue)
       {
-         if (!Importer.TheProcessor.ScaleValues)
-            return inValue;
-
          IFCUnit projectUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length);
          if (projectUnit != null)
             return inValue * projectUnit.ScaleFactor;
@@ -72,16 +69,12 @@ static public XYZ ScaleLength(XYZ inValue)
       /// </summary>
       /// <param name="specTypeId">Identifier of the spec for this value.</param>
       /// <param name="inValue">The value to convert.</param>
-      /// <param name="forceScale">Force scaling of values whatever. 
       /// Some units we really always want in the standard document units.
       /// For example, angles in Radians.
       /// </param>
       /// <returns>The result value in Revit internal units.</returns>
-      static private double ProjectScale(ForgeTypeId specTypeId, double inValue, bool forceScale = false)
+      static private double ProjectScale(ForgeTypeId specTypeId, double inValue)
       {
-         if (!Importer.TheProcessor.ScaleValues && !forceScale)
-            return inValue;
-
          IFCUnit projectUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(specTypeId);
          if (projectUnit != null)
             return inValue * projectUnit.ScaleFactor - projectUnit.OffsetFactor;
@@ -98,9 +91,6 @@ static private double ProjectScale(ForgeTypeId specTypeId, double inValue, bool
       /// <remarks>Note that the OffsetFactor is ignored.</remarks>
       static public void ProjectScale(ForgeTypeId specTypeId, IList<XYZ> inValues)
       {
-         if (!Importer.TheProcessor.ScaleValues)
-            return;
-
          if (inValues == null)
             return;
 
@@ -131,14 +121,6 @@ static public string FormatLengthAsString(double value)
          if (lengthFormatOptions.CanSuppressTrailingZeros())
             lengthFormatOptions.SuppressTrailingZeros = true;
          formatValueOptions.SetFormatOptions(lengthFormatOptions);
-
-         if (!Importer.TheProcessor.ScaleValues)
-         {
-            // value is in source file units, but 'UnitFormatUtils.Format' expects it in internal units
-            // and it then converts it to display units, which should be the same as the source file units
-            value = UnitUtils.ConvertToInternalUnits(value, lengthFormatOptions.GetUnitTypeId());
-         }
-
          return UnitFormatUtils.Format(IFCImportFile.TheFile.Document.GetUnits(), SpecTypeId.Length, value, false, formatValueOptions);
       }
    }
diff --git a/Source/Revit.IFC.Import/Utility/TessellatedShapeBuilderScope.cs b/Source/Revit.IFC.Import/Utility/TessellatedShapeBuilderScope.cs
index 9b07b34a..26fafe0a 100644
--- a/Source/Revit.IFC.Import/Utility/TessellatedShapeBuilderScope.cs
+++ b/Source/Revit.IFC.Import/Utility/TessellatedShapeBuilderScope.cs
@@ -208,7 +208,7 @@ private double GetVertexTolerance()
          // sphere of equivalence.  In the case of AnyGeometry, we resort to the Solid tolerance as we are
          // generally trying to create Solids over Meshes.
          return (TargetGeometry == TessellatedShapeBuilderTarget.Mesh) ?
-            MathUtil.Eps() : Importer.TheProcessor.ShortCurveTolerance;
+            MathUtil.Eps() : IFCImportFile.TheFile.ShortCurveTolerance;
       }
 
       /// <summary>

From 717e7ca0e5da76e6c97b1f1191a8b0fc92d16bda Mon Sep 17 00:00:00 2001
From: Oleksandr Babii <oleksandr.babii@autodesk.com>
Date: Thu, 7 Oct 2021 07:50:25 -0700
Subject: [PATCH 2/5] Fixes for compatibility with Revit 2022.0.1

---
 .../Revit.IFC.Common/Utility/DirectoryUtil.cs |   2 +-
 .../Utility/IFCAnyHandleUtil.cs               |  63 +++++++----
 Source/Revit.IFC.Export/Exporter/Exporter.cs  |  22 ++++
 .../GrossCrossSectionAreaCalculator.cs        | 102 ++++++++++++++++++
 Source/Revit.IFC.Import/Data/IFCBuilding.cs   |   1 -
 .../Data/IFCBuildingStorey.cs                 |   1 -
 Source/Revit.IFC.Import/Data/IFCImportFile.cs |  18 ++++
 .../Data/IFCIndexedPolyCurve.cs               |   2 +-
 .../Data/IFCPresentationStyleAssignment.cs    |   2 +-
 Source/Revit.IFC.Import/Data/IFCProperty.cs   |  24 +++--
 .../Revit.IFC.Import/Data/IFCPropertyValue.cs |   5 +-
 .../Data/IFCSpatialStructureElement.cs        |  28 -----
 .../Data/IFCSurfaceStyleShading.cs            |  10 +-
 .../Revit.IFC.Import/Data/IFCTrimmedCurve.cs  |   6 +-
 .../Utility/IFCImportHandleUtil.cs            |   6 +-
 15 files changed, 215 insertions(+), 77 deletions(-)
 create mode 100644 Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/GrossCrossSectionAreaCalculator.cs

diff --git a/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs b/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
index ed89e046..110198b3 100644
--- a/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
+++ b/Source/Revit.IFC.Common/Utility/DirectoryUtil.cs
@@ -41,7 +41,7 @@ public static string IFCSchemaLocation
       {
          get
          {
-            return Path.Combine(RevitProgramPath, "IFC");
+            return Path.Combine(RevitProgramPath, "EDM");
          }
       }
    }
diff --git a/Source/Revit.IFC.Common/Utility/IFCAnyHandleUtil.cs b/Source/Revit.IFC.Common/Utility/IFCAnyHandleUtil.cs
index 7d40d9d8..c1b299af 100644
--- a/Source/Revit.IFC.Common/Utility/IFCAnyHandleUtil.cs
+++ b/Source/Revit.IFC.Common/Utility/IFCAnyHandleUtil.cs
@@ -1113,7 +1113,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
 
          T aggregateAttribute = default(T);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null)
@@ -1144,7 +1144,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
 
          T aggregateAttribute = default(T);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null)
@@ -1178,7 +1178,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
 
          T aggregateAttribute = default(T);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null)
@@ -1212,7 +1212,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
 
          T aggregateAttribute = default(T);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null)
@@ -1243,7 +1243,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
 
          T aggregateAttribute = default(T);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null)
@@ -1251,7 +1251,7 @@ public static void SetAttribute(IFCAnyHandle handle, string name, IFCData value)
                aggregateAttribute = new T();
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      aggregateAttribute.Add(val.AsInstance());
                   }
@@ -1325,7 +1325,7 @@ public static IList<double> GetCoordinates(IFCAnyHandle cartesianPoint)
             throw new ArgumentException("Not an IfcCartesianPoint handle.");
 
          IFCData ifcData = cartesianPoint.GetAttribute("Coordinates");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
@@ -1355,7 +1355,7 @@ public static IFCAnyHandle GetValidInstanceAttribute(IFCAnyHandle hnd, string na
          try
          {
             IFCData ifcData = hnd.GetAttribute(name);
-            if (ifcData.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (ifcData.PrimitiveType.ToString() == "Instance")
                return ifcData.AsInstance();
          }
          catch { }
@@ -1554,7 +1554,7 @@ public static bool HasRelDecomposes(IFCAnyHandle objectHandle)
 
          if (!ifcData.HasValue)
             return false;
-         else if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         else if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
@@ -1579,14 +1579,14 @@ public static HashSet<IFCAnyHandle> GetRelDecomposes(IFCAnyHandle objectHandle)
 
          HashSet<IFCAnyHandle> decomposes = new HashSet<IFCAnyHandle>();
          IFCData ifcData = objectHandle.GetAttribute("IsDecomposedBy");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
             {
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      decomposes.Add(val.AsInstance());
                   }
@@ -1608,14 +1608,14 @@ public static HashSet<IFCAnyHandle> GetHasRepresentation(IFCAnyHandle objectHand
 
          HashSet<IFCAnyHandle> hasRepresentation = new HashSet<IFCAnyHandle>();
          IFCData ifcData = objectHandle.GetAttribute("HasRepresentation");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
             {
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      hasRepresentation.Add(val.AsInstance());
                   }
@@ -1636,7 +1636,7 @@ public static IFCAnyHandle GetRepresentation(IFCAnyHandle productHandle)
             throw new ArgumentException("The operation is not valid for this handle.");
 
          IFCData ifcData = productHandle.GetAttribute("Representation");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Instance)
+         if (ifcData.PrimitiveType.ToString() == "Instance")
          {
             return ifcData.AsInstance();
          }
@@ -1655,7 +1655,7 @@ public static IFCAnyHandle GetContextOfItems(IFCAnyHandle representation)
             throw new ArgumentException("The operation is not valid for this handle.");
 
          IFCData ifcData = representation.GetAttribute("ContextOfItems");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Instance)
+         if (ifcData.PrimitiveType.ToString() == "Instance")
          {
             return ifcData.AsInstance();
          }
@@ -1713,14 +1713,14 @@ public static HashSet<IFCAnyHandle> GetItems(IFCAnyHandle representation)
 
          HashSet<IFCAnyHandle> items = new HashSet<IFCAnyHandle>();
          IFCData ifcData = representation.GetAttribute("Items");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
             {
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      items.Add(val.AsInstance());
                   }
@@ -1742,14 +1742,14 @@ public static List<IFCAnyHandle> GetRepresentations(IFCAnyHandle representation)
 
          List<IFCAnyHandle> representations = new List<IFCAnyHandle>();
          IFCData ifcData = representation.GetAttribute("Representations");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
             {
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      representations.Add(val.AsInstance());
                   }
@@ -1771,14 +1771,14 @@ public static List<IFCAnyHandle> GetOpenings(IFCAnyHandle ifcElement)
 
          List<IFCAnyHandle> openings = new List<IFCAnyHandle>();
          IFCData ifcData = ifcElement.GetAttribute("HasOpenings");
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate aggregate = ifcData.AsAggregate();
             if (aggregate != null && aggregate.Count > 0)
             {
                foreach (IFCData val in aggregate)
                {
-                  if (val.PrimitiveType == IFCDataPrimitiveType.Instance)
+                  if (val.PrimitiveType.ToString() == "Instance")
                   {
                      IFCAnyHandle relVoidElement = val.AsInstance();
                      IFCData openingElementData = relVoidElement.GetAttribute("RelatedOpeningElement");
@@ -1994,6 +1994,27 @@ public static bool IsValidSubTypeOf(IFCAnyHandle handle, IFCEntityType handleTyp
          return handle.IsSubTypeOf(GetIFCEntityTypeName(type));
       }
 
+      /// <summary>
+      /// Gets the <see cref="IFCDataPrimitiveType"/> value from type name.
+      /// This method is used for negotiation differences between IfCDataPrimitiveType enums in 2022.0.1 and 2022.1 APIs using string comparison.
+      /// </summary>
+      /// <param name="typeName">Primitive type name.</param>
+      /// <returns><see cref="IFCDataPrimitiveType"/> value.</returns>
+      public static IFCDataPrimitiveType GetPrimitiveTypeForOlderAPI(string typeName)
+      {
+         IFCDataPrimitiveType resultType = IFCDataPrimitiveType.Integer;
+
+         for(int iterator = 0; iterator <= 21; iterator++)
+         {
+            if (resultType.ToString() == typeName)
+               return resultType;
+            else
+               resultType++;
+         }
+
+         return resultType;
+      }
+
       /// <summary>
       /// Updates the project information.
       /// </summary>
diff --git a/Source/Revit.IFC.Export/Exporter/Exporter.cs b/Source/Revit.IFC.Export/Exporter/Exporter.cs
index 17b9a74b..41d7dfa1 100644
--- a/Source/Revit.IFC.Export/Exporter/Exporter.cs
+++ b/Source/Revit.IFC.Export/Exporter/Exporter.cs
@@ -242,7 +242,12 @@ protected void ExportAdvanceSteelElements(ExporterIFC exporterIFC, Autodesk.Revi
          {
             try
             {
+#if IFC_OPENSOURCE
+               string dllPath = Assembly.GetExecutingAssembly().Location;
+               Assembly assembly = Assembly.LoadFrom(Path.GetDirectoryName(dllPath) + @"\Autodesk.SteelConnections.ASIFC.dll");
+#else
                Assembly assembly = Assembly.LoadFrom(AppDomain.CurrentDomain.BaseDirectory + @"\Addins\SteelConnections\Autodesk.SteelConnections.ASIFC.dll");
+#endif
                if (assembly != null)
                {
                   Type type = assembly.GetType("Autodesk.SteelConnections.ASIFC.ASExporter");
@@ -1018,20 +1023,37 @@ protected virtual IFCFileModelOptions CreateIFCFileModelOptions(ExporterIFC expo
          IFCFileModelOptions modelOptions = new IFCFileModelOptions();
          if (ExporterCacheManager.ExportOptionsCache.ExportAs2x2)
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC2X2_ADD1.exp");
             modelOptions.SchemaName = "IFC2x2_FINAL";
          }
          else if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC4.exp");
             modelOptions.SchemaName = "IFC4";
          }
          else
          {
             // We leave IFC2x3 as default until IFC4 is finalized and generally supported across platforms.
+            modelOptions.SchemaFile = LocateSchemaFile("IFC2X3_TC1.exp");
             modelOptions.SchemaName = "IFC2x3";
          }
          return modelOptions;
       }
 
+      private string LocateSchemaFile(string schemaFileName)
+      {
+         string filePath = null;
+#if IFC_OPENSOURCE
+         // Find the alternate schema file from the open source install folder
+         filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location), schemaFileName);
+         if (!File.Exists(filePath))
+#endif
+         {
+            filePath = Path.Combine(DirectoryUtil.RevitProgramPath, "EDM", schemaFileName);
+         }
+         return filePath;
+      }
+
       /// <summary>
       /// Sets the lists of property sets to be exported.  This can be overriden.
       /// </summary>
diff --git a/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/GrossCrossSectionAreaCalculator.cs b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/GrossCrossSectionAreaCalculator.cs
new file mode 100644
index 00000000..e4b1fdcd
--- /dev/null
+++ b/Source/Revit.IFC.Export/Exporter/PropertySet/Calculators/GrossCrossSectionAreaCalculator.cs
@@ -0,0 +1,102 @@
+//
+// BIM IFC library: this library works with Autodesk(R) Revit(R) to export IFC files containing model geometry.
+// Copyright (C) 2012  Autodesk, Inc.
+// 
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+//
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Autodesk.Revit.DB;
+using Autodesk.Revit.DB.IFC;
+using Revit.IFC.Export.Utility;
+using Revit.IFC.Common.Utility;
+
+namespace Revit.IFC.Export.Exporter.PropertySet.Calculators
+{
+   /// <summary>
+   /// A calculation class to calculate gross cross section area.
+   /// </summary>
+   class GrossCrossSectionAreaCalculator : PropertyCalculator
+   {
+      /// <summary>
+      /// A double variable to keep the calculated value.
+      /// </summary>
+      private double m_Area = 0;
+
+      /// <summary>
+      /// A static instance of this class.
+      /// </summary>
+      static GrossCrossSectionAreaCalculator s_Instance = new GrossCrossSectionAreaCalculator();
+
+      /// <summary>
+      /// The GrossCrossSectionAreaCalculator instance.
+      /// </summary>
+      public static GrossCrossSectionAreaCalculator Instance
+      {
+         get { return s_Instance; }
+      }
+
+      /// <summary>
+      /// Calculates gross cross area.
+      /// </summary>
+      /// <param name="exporterIFC">
+      /// The ExporterIFC object.
+      /// </param>
+      /// <param name="extrusionCreationData">
+      /// The IFCExtrusionCreationData.
+      /// </param>
+      /// <param name="element">
+      /// The element to calculate the value.
+      /// </param>
+      /// <param name="elementType">
+      /// The element type.
+      /// </param>
+      /// <returns>
+      /// True if the operation succeed, false otherwise.
+      /// </returns>
+      public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType)
+      {
+         double crossSectionArea = 0;
+
+         // 1. Check override parameter
+         if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyGrossCrossSectionArea", out crossSectionArea) == null)
+               ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "GrossCrossSectionArea", out crossSectionArea);
+         m_Area = UnitUtil.ScaleArea(crossSectionArea);
+         if (m_Area > MathUtil.Eps() * MathUtil.Eps())
+            return true;
+
+         // 2. try using extrusion data
+         if (extrusionCreationData == null)
+            return false;
+
+         m_Area = extrusionCreationData.ScaledArea;
+         return m_Area > MathUtil.Eps() * MathUtil.Eps();
+      }
+
+      /// <summary>
+      /// Gets the calculated double value.
+      /// </summary>
+      /// <returns>
+      /// The double value.
+      /// </returns>
+      public override double GetDoubleValue()
+      {
+         return m_Area;
+      }
+   }
+}
diff --git a/Source/Revit.IFC.Import/Data/IFCBuilding.cs b/Source/Revit.IFC.Import/Data/IFCBuilding.cs
index 40913934..5bdf6ce2 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuilding.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuilding.cs
@@ -60,7 +60,6 @@ protected override void Process(IFCAnyHandle ifcBuilding)
 
       public override void PostProcess()
       {
-         TryToFixFarawayOrigin();
          base.PostProcess();
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
index b5df9eac..f8d5f5dc 100644
--- a/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
+++ b/Source/Revit.IFC.Import/Data/IFCBuildingStorey.cs
@@ -195,7 +195,6 @@ protected override void Process(IFCAnyHandle ifcIFCBuildingStorey)
 
       public override void PostProcess()
       {
-         TryToFixFarawayOrigin();
          base.PostProcess();
       }
 
diff --git a/Source/Revit.IFC.Import/Data/IFCImportFile.cs b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
index 5f4c5cbb..8987a54e 100644
--- a/Source/Revit.IFC.Import/Data/IFCImportFile.cs
+++ b/Source/Revit.IFC.Import/Data/IFCImportFile.cs
@@ -1058,6 +1058,20 @@ static IFCFile CreateIFCFileFromIFCZIP(string path, out IFCSchemaVersion schemaV
          }
       }
 
+      private static string LocateSchemaFile(string schemaFileName)
+      {
+         string filePath = null;
+#if IFC_OPENSOURCE
+         // Find the alternate schema file from the open source install folder
+         filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location), schemaFileName);
+         if (!File.Exists(filePath))
+#endif
+         {
+            filePath = Path.Combine(DirectoryUtil.RevitProgramPath, "EDM", schemaFileName);
+         }
+         return filePath;
+      }
+
       /// <summary>
       /// Gets IFCFileModelOptions from schema name.
       /// </summary>
@@ -1076,18 +1090,22 @@ static IFCFileModelOptions GetIFCFileModelOptions(string schemaName, out IFCSche
          }
          else if (schemaName.Equals("IFC2X3", StringComparison.OrdinalIgnoreCase))
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC2X3_TC1.exp");
             schemaVersion = IFCSchemaVersion.IFC2x3;
          }
          else if (schemaName.Equals("IFC2X_FINAL", StringComparison.OrdinalIgnoreCase))
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC2X_PROXY.exp");
             schemaVersion = IFCSchemaVersion.IFC2x;
          }
          else if (schemaName.Equals("IFC2X2_FINAL", StringComparison.OrdinalIgnoreCase))
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC2X2_ADD1.exp");
             schemaVersion = IFCSchemaVersion.IFC2x2;
          }
          else if (schemaName.Equals("IFC4", StringComparison.OrdinalIgnoreCase))
          {
+            modelOptions.SchemaFile = LocateSchemaFile("IFC4.exp");
             schemaVersion = IFCSchemaVersion.IFC4;
          }
          else if (schemaName.Equals("IFC4X1", StringComparison.OrdinalIgnoreCase))
diff --git a/Source/Revit.IFC.Import/Data/IFCIndexedPolyCurve.cs b/Source/Revit.IFC.Import/Data/IFCIndexedPolyCurve.cs
index 49571e6c..8b733262 100644
--- a/Source/Revit.IFC.Import/Data/IFCIndexedPolyCurve.cs
+++ b/Source/Revit.IFC.Import/Data/IFCIndexedPolyCurve.cs
@@ -50,7 +50,7 @@ protected IFCIndexedPolyCurve(IFCAnyHandle indexedPolyCurve)
       /// <remarks>The calling function is responsible for logging errors.</remarks>
       private string ValidateSegment(IFCData segment)
       {
-         if (segment.PrimitiveType != IFCDataPrimitiveType.Aggregate)
+         if (segment.PrimitiveType.ToString() != "Aggregate")
          {
             return null;
          }
diff --git a/Source/Revit.IFC.Import/Data/IFCPresentationStyleAssignment.cs b/Source/Revit.IFC.Import/Data/IFCPresentationStyleAssignment.cs
index 57c23310..c2762deb 100644
--- a/Source/Revit.IFC.Import/Data/IFCPresentationStyleAssignment.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPresentationStyleAssignment.cs
@@ -52,7 +52,7 @@ override protected void Process(IFCAnyHandle item)
          {
             foreach (IFCData styleData in styles)
             {
-               if (styleData.PrimitiveType == IFCDataPrimitiveType.Instance)
+               if (styleData.PrimitiveType.ToString() == "Instance")
                {
                   IFCAnyHandle style = styleData.AsInstance();
                   try
diff --git a/Source/Revit.IFC.Import/Data/IFCProperty.cs b/Source/Revit.IFC.Import/Data/IFCProperty.cs
index d41e7a2b..34cdeba5 100644
--- a/Source/Revit.IFC.Import/Data/IFCProperty.cs
+++ b/Source/Revit.IFC.Import/Data/IFCProperty.cs
@@ -152,6 +152,10 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
          }
 
          IFCDataPrimitiveType dataType = IFCDataPrimitiveType.Unknown;
+
+         if(dataType.ToString() != "Unknown")
+            dataType = IFCAnyHandleUtil.GetPrimitiveTypeForOlderAPI("Unknown");
+
          ForgeTypeId specTypeId = new ForgeTypeId();
          ForgeTypeId unitsTypeId = null;
 
@@ -177,7 +181,7 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
          else
          {
             dataType = propertyValueToUse.Value.PrimitiveType;
-            if (dataType == IFCDataPrimitiveType.Instance)
+            if (dataType.ToString() == "Instance")
             {
                IFCAnyHandle propertyValueHandle = propertyValueToUse.Value.AsInstance();
                ElementId propertyValueAsId = IFCObjectReferenceSelect.ToElementId(propertyValueHandle);
@@ -258,27 +262,27 @@ public void Create(Document doc, Element element, Category category, IFCObjectDe
                Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false);
 
             bool created = false;
-            switch (dataType)
+            switch (dataType.ToString())
             {
-               case IFCDataPrimitiveType.String:
-               case IFCDataPrimitiveType.Enumeration:
-               case IFCDataPrimitiveType.Binary:
+               case "String":
+               case "Enumeration":
+               case "Binary":
                   created = IFCPropertySet.AddParameterString(doc, element, category, objDef, parameterName, stringValueToUse, Id);
                   break;
-               case IFCDataPrimitiveType.Integer:
+               case "Integer":
                   created = IFCPropertySet.AddParameterInt(doc, element, category, objDef, parameterName, intValueToUse.Value, Id);
                   break;
-               case IFCDataPrimitiveType.Boolean:
+               case "Boolean":
                   created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, boolValueToUse.Value, Id);
                   break;
-               case IFCDataPrimitiveType.Logical:
+               case "Logical":
                   if (logicalValueToUse != IFCLogical.Unknown)
                      created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, (logicalValueToUse == IFCLogical.True), Id);
                   break;
-               case IFCDataPrimitiveType.Double:
+               case "Double":
                   created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse.Value, Id);
                   break;
-               case IFCDataPrimitiveType.Instance:
+               case "Instance":
                   created = IFCPropertySet.AddParameterElementId(doc, element, category, objDef, parameterName, elementIdValueToUse, Id);
                   break;
             }
diff --git a/Source/Revit.IFC.Import/Data/IFCPropertyValue.cs b/Source/Revit.IFC.Import/Data/IFCPropertyValue.cs
index c0877c02..d8b5f863 100644
--- a/Source/Revit.IFC.Import/Data/IFCPropertyValue.cs
+++ b/Source/Revit.IFC.Import/Data/IFCPropertyValue.cs
@@ -23,6 +23,7 @@
 using System.Text;
 using Autodesk.Revit.DB;
 using Autodesk.Revit.DB.IFC;
+using Revit.IFC.Common.Utility;
 
 namespace Revit.IFC.Import.Data
 {
@@ -57,7 +58,7 @@ public IFCPropertyValue(IFCSimpleProperty ifcSimpleProperty, IFCData value)
       /// </summary>
       public IFCDataPrimitiveType Type
       {
-         get { return m_Value != null ? m_Value.PrimitiveType : IFCDataPrimitiveType.Unknown; }
+         get { return m_Value != null ? m_Value.PrimitiveType : IFCAnyHandleUtil.GetPrimitiveTypeForOlderAPI("Unknown"); }
       }
 
       /// <summary>
@@ -232,7 +233,7 @@ public bool AsBoolean()
       /// <returns>The bool value.</returns>
       public IFCAnyHandle AsInstance()
       {
-         if (Type == IFCDataPrimitiveType.Instance)
+         if (Type.ToString() == "Instance")
          {
             return Value.AsInstance();
          }
diff --git a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
index 66542e31..36aec495 100644
--- a/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSpatialStructureElement.cs
@@ -221,34 +221,6 @@ void ProcessIFCRelServicesBuildings(IFCAnyHandle ifcRelHandle)
             Systems.Add(system);
       }
 
-      protected void TryToFixFarawayOrigin()
-      {
-         if (!(ProjectScope?.IsSet ?? false))
-            return;
-
-         // It is amazing that this works at all, but basically if we set the ProjectScope,
-         // and it has a reasonable bounding box size that is far from the origin, and
-         // the relative (non-shared) portion of this spatial element (building or
-         // building storey only) is also far from the origin and close to the bounding box,
-         // then we move it closer to the origin by subtracting the min corner of the
-         // bounding box.
-         // This fixes some cases where we have buildings or building stories that are really
-         // far from the origin but aren't all over the place.
-         // Real solution: don't create this data.
-         // There may be some better solution, but this is a compromise between not doing
-         // anything at all and not having a regression in old code that just moved stuff
-         // back to the origin.
-         XYZ relativeOrigin = ObjectLocation?.RelativeTransform?.Origin;
-         if (relativeOrigin != null && !XYZ.IsWithinLengthLimits(relativeOrigin))
-         {
-            if (XYZ.IsWithinLengthLimits(ProjectScope.Max - ProjectScope.Min) &&
-               XYZ.IsWithinLengthLimits(relativeOrigin - ProjectScope.Min))
-            {
-               ObjectLocation.RelativeTransform.Origin -= ProjectScope.Min;
-            }
-         }
-      }
-
       /// <summary>
       /// Processes IfcSpatialStructureElement handle.
       /// </summary>
diff --git a/Source/Revit.IFC.Import/Data/IFCSurfaceStyleShading.cs b/Source/Revit.IFC.Import/Data/IFCSurfaceStyleShading.cs
index 57c4280e..c60b4c7f 100644
--- a/Source/Revit.IFC.Import/Data/IFCSurfaceStyleShading.cs
+++ b/Source/Revit.IFC.Import/Data/IFCSurfaceStyleShading.cs
@@ -232,31 +232,31 @@ override protected void Process(IFCAnyHandle item)
             Transparency = IFCImportHandleUtil.GetOptionalNormalisedRatioAttribute(item, "Transparency", 0.0);
 
             IFCData diffuseColour = item.GetAttribute("DiffuseColour");
-            if (diffuseColour.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (diffuseColour.PrimitiveType.ToString() == "Instance")
                m_DiffuseColour = IFCColourRgb.ProcessIFCColourRgb(diffuseColour.AsInstance());
             else if (diffuseColour.PrimitiveType == IFCDataPrimitiveType.Double)
                m_DiffuseColourFactor = diffuseColour.AsDouble();
 
             IFCData transmissionColour = item.GetAttribute("TransmissionColour");
-            if (transmissionColour.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (transmissionColour.PrimitiveType.ToString() == "Instance")
                m_TransmissionColour = IFCColourRgb.ProcessIFCColourRgb(transmissionColour.AsInstance());
             else if (transmissionColour.PrimitiveType == IFCDataPrimitiveType.Double)
                m_TransmissionColourFactor = transmissionColour.AsDouble();
 
             IFCData diffuseTransmissionColour = item.GetAttribute("DiffuseTransmissionColour");
-            if (diffuseTransmissionColour.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (diffuseTransmissionColour.PrimitiveType.ToString() == "Instance")
                m_DiffuseTransmissionColour = IFCColourRgb.ProcessIFCColourRgb(diffuseTransmissionColour.AsInstance());
             else if (diffuseTransmissionColour.PrimitiveType == IFCDataPrimitiveType.Double)
                m_DiffuseTransmissionColourFactor = diffuseTransmissionColour.AsDouble();
 
             IFCData reflectionColour = item.GetAttribute("ReflectionColour");
-            if (reflectionColour.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (reflectionColour.PrimitiveType.ToString() == "Instance")
                m_ReflectionColour = IFCColourRgb.ProcessIFCColourRgb(reflectionColour.AsInstance());
             else if (reflectionColour.PrimitiveType == IFCDataPrimitiveType.Double)
                m_ReflectionColourFactor = reflectionColour.AsDouble();
 
             IFCData specularColour = item.GetAttribute("SpecularColour");
-            if (specularColour.PrimitiveType == IFCDataPrimitiveType.Instance)
+            if (specularColour.PrimitiveType.ToString() == "Instance")
                m_SpecularColour = IFCColourRgb.ProcessIFCColourRgb(specularColour.AsInstance());
             else if (specularColour.PrimitiveType == IFCDataPrimitiveType.Double)
                m_SpecularColourFactor = specularColour.AsDouble();
diff --git a/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs b/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
index 37eb8a43..3cf4e4ad 100644
--- a/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
+++ b/Source/Revit.IFC.Import/Data/IFCTrimmedCurve.cs
@@ -121,14 +121,14 @@ protected override void Process(IFCAnyHandle ifcCurve)
          }
 
          IFCData trim1 = ifcCurve.GetAttribute("Trim1");
-         if (trim1.PrimitiveType != IFCDataPrimitiveType.Aggregate)
+         if (trim1.PrimitiveType.ToString() != "Aggregate")
          {
             // LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
             return;
          }
 
          IFCData trim2 = ifcCurve.GetAttribute("Trim2");
-         if (trim2.PrimitiveType != IFCDataPrimitiveType.Aggregate)
+         if (trim2.PrimitiveType.ToString() != "Aggregate")
          {
             // LOG: ERROR: Invalid data type for Trim1 attribute for IfcTrimmedCurve #.
             return;
@@ -288,7 +288,7 @@ private void GetTrimParameters(int id, IFCData trim1, IFCData trim2,
          IFCAggregate trimAggregate = trim.AsAggregate();
          foreach (IFCData trimParam in trimAggregate)
          {
-            if (!preferParam && (trimParam.PrimitiveType == IFCDataPrimitiveType.Instance))
+            if (!preferParam && (trimParam.PrimitiveType.ToString() == "Instance"))
             {
                IFCAnyHandle trimParamInstance = trimParam.AsInstance();
                XYZ trimParamPt = IFCPoint.ProcessScaledLengthIFCCartesianPoint(trimParamInstance);
diff --git a/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs b/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
index 70201040..ac5d7acc 100644
--- a/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
+++ b/Source/Revit.IFC.Import/Utility/IFCImportHandleUtil.cs
@@ -323,7 +323,7 @@ public static IList<IList<double>> GetListOfListOfDoubleAttribute(IFCAnyHandle h
 
          IFCData ifcData = handle.GetAttribute(name);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate outer = ifcData.AsAggregate();
             if (outer != null)
@@ -367,7 +367,7 @@ public static IList<IList<int>> GetListOfListOfIntegerAttribute(IFCAnyHandle han
 
          IFCData ifcData = handle.GetAttribute(name);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate outer = ifcData.AsAggregate();
             if (outer != null)
@@ -411,7 +411,7 @@ public static IList<IList<IFCAnyHandle>> GetListOfListOfInstanceAttribute(IFCAny
 
          IFCData ifcData = handle.GetAttribute(name);
 
-         if (ifcData.PrimitiveType == IFCDataPrimitiveType.Aggregate)
+         if (ifcData.PrimitiveType.ToString() == "Aggregate")
          {
             IFCAggregate outer = ifcData.AsAggregate();
             if (outer != null)

From 8e72ac4341f8da61eb3eb0bdc07da2ca2ec99a8b Mon Sep 17 00:00:00 2001
From: Oleksandr Babii <oleksandr.babii@autodesk.com>
Date: Thu, 7 Oct 2021 09:13:01 -0700
Subject: [PATCH 3/5] Update version number

---
 .../Program Files to Install/bundle/PackageContents.xml   | 4 ++--
 Install/RevitIFCSetupWix/Product.wxs                      | 2 +-
 Install/RevitIFCSetupWix/RevitIFCSetupWix.wixproj         | 2 +-
 Install/RevitIFCSetupWix/buildInstaller.bat               | 8 ++++----
 Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs   | 4 ++--
 Source/Revit.IFC.Common/Properties/AssemblyInfo.cs        | 4 ++--
 Source/Revit.IFC.Export/Properties/AssemblyInfo.cs        | 4 ++--
 Source/Revit.IFC.Import/Properties/AssemblyInfo.cs        | 4 ++--
 Source/RevitIFCTools/Properties/AssemblyInfo.cs           | 4 ++--
 9 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/Install/Program Files to Install/bundle/PackageContents.xml b/Install/Program Files to Install/bundle/PackageContents.xml
index 004fd823..847efae7 100644
--- a/Install/Program Files to Install/bundle/PackageContents.xml	
+++ b/Install/Program Files to Install/bundle/PackageContents.xml	
@@ -8,7 +8,7 @@
   <RuntimeRequirements OS="Win64" Platform="Revit" SeriesMin="R2022" SeriesMax="R2022" />
   <Components Description="2022">
     <RuntimeRequirements OS="Win64" Platform="Revit" SeriesMin="R2022" SeriesMax="R2022" />
-    <ComponentEntry AppName="IFC For Revit 2022" Version="22.2.1" ModuleName="./Contents/2022/IFCExporterUIOverride.addin" AppDescription="IFC For Revit 2022" />
-    <ComponentEntry AppName="IFC For Revit 2022" Version="22.2.1" ModuleName="./Contents/2022/Revit.IFC.addin" AppDescription="IFC For Revit 2022" />
+    <ComponentEntry AppName="IFC For Revit 2022" Version="22.3.0" ModuleName="./Contents/2022/IFCExporterUIOverride.addin" AppDescription="IFC For Revit 2022" />
+    <ComponentEntry AppName="IFC For Revit 2022" Version="22.3.0" ModuleName="./Contents/2022/Revit.IFC.addin" AppDescription="IFC For Revit 2022" />
   </Components>
 </ApplicationPackage>
\ No newline at end of file
diff --git a/Install/RevitIFCSetupWix/Product.wxs b/Install/RevitIFCSetupWix/Product.wxs
index 655ad2a8..585b1ed5 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="C72C0DBE-435A-4020-AD66-CEF6AA69C1A2" Name="Revit IFC 2022" Language="1033" Version="22.2.1.0" Manufacturer="Autodesk" UpgradeCode="254F4C8A-9ECA-4690-A718-21ACD3849485">
+   <Product Id="73E9D55B-2254-449D-B9A2-98F52DEF3B0B" Name="Revit IFC 2022" Language="1033" Version="22.3.0.0" Manufacturer="Autodesk" UpgradeCode="254F4C8A-9ECA-4690-A718-21ACD3849485">
       <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 7e2f6350..fecb9c0c 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 2022.2.1.0</OutputName>
+    <OutputName>IFC for Revit 2022.3.0.0</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/Install/RevitIFCSetupWix/buildInstaller.bat b/Install/RevitIFCSetupWix/buildInstaller.bat
index 3c0a8099..c37522a5 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 RevitIFC2022.2.1.msi product.wixobj -ext WixUIExtension
+light.exe -ext WixUtilExtension -out RevitIFC2022.3.0.msi product.wixobj -ext WixUIExtension
 
-copy RevitIFC2022.2.1.msi %1..\Releasex64
-del RevitIFC2022.2.1.msi
+copy RevitIFC2022.3.0.msi %1..\Releasex64
+del RevitIFC2022.3.0.msi
 
-echo %1..\Releasex64\RevitIFC2022.2.1.msi
+echo %1..\Releasex64\RevitIFC2022.3.0.msi
diff --git a/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs b/Source/IFCExporterUIOverride/Properties/AssemblyInfo.cs
index 6e2c73ec..61052108 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("22.2.1.0")]
-[assembly: AssemblyFileVersion("22.2.1.0")]
+[assembly: AssemblyVersion("22.3.0.0")]
+[assembly: AssemblyFileVersion("22.3.0.0")]
 #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 a3b7afbb..ee78a246 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("22.2.1.0")]
-[assembly: AssemblyFileVersion("22.2.1.0")]
+[assembly: AssemblyVersion("22.3.0.0")]
+[assembly: AssemblyFileVersion("22.3.0.0")]
 #endif
 
 
diff --git a/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Export/Properties/AssemblyInfo.cs
index 0491c450..352ee3ab 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("22.2.1.0")]
-[assembly: AssemblyFileVersion("22.2.1.0")]
+[assembly: AssemblyVersion("22.3.0.0")]
+[assembly: AssemblyFileVersion("22.3.0.0")]
 
 #endif
 
diff --git a/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs b/Source/Revit.IFC.Import/Properties/AssemblyInfo.cs
index 759daa7c..3c9852db 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("22.2.1.0")]
-[assembly: AssemblyFileVersion("22.2.1.0")]
+[assembly: AssemblyVersion("22.3.0.0")]
+[assembly: AssemblyFileVersion("22.3.0.0")]
 #endif
 
 #region Using directives
diff --git a/Source/RevitIFCTools/Properties/AssemblyInfo.cs b/Source/RevitIFCTools/Properties/AssemblyInfo.cs
index 6209b4e6..97589323 100644
--- a/Source/RevitIFCTools/Properties/AssemblyInfo.cs
+++ b/Source/RevitIFCTools/Properties/AssemblyInfo.cs
@@ -51,5 +51,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("22.1.1.0")]
-[assembly: AssemblyFileVersion("22.1.1.0")]
+[assembly: AssemblyVersion("22.3.0.0")]
+[assembly: AssemblyFileVersion("22.3.0.0")]

From 3c7898693017570a5f9a77c3f6cf4d7d72384774 Mon Sep 17 00:00:00 2001
From: Oleksandr Babii <oleksandr.babii@autodesk.com>
Date: Fri, 8 Oct 2021 04:33:52 -0700
Subject: [PATCH 4/5] Update release notes

---
 .../Resources/ADSKIFCExporterHelp.htm         | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

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 ab5fc941..3ced4aaf 100644
--- a/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm	
+++ b/Install/Program Files to Install/bundle/Contents/Resources/ADSKIFCExporterHelp.htm	
@@ -238,6 +238,60 @@ <h2 id="VersionHistory" name="VersionHistory">Version History</h2>
 
 <div class="versionset">
 
+	<div class="version">22.3.0.0</div><div class="versioninfo-bullet">
+
+      <br><p>
+         General:
+			<ul>
+            <li>This version contains various improvements and bugfixes since the latest release of 22.2.1.0.
+			</ul>	
+			<br>
+		</p>
+     <p>
+	  		Improvements:
+			<ul>
+				<li>Added additional generic support for IFC4.x files for 2022.1. (Added entities represented in schemas:IFC2x, IFC4x, IFC4x2, IFC4x3).
+				<li>Added export NominalCapacityCooling as Pset_CoolingTowerTypeCommon.NominalCapacity.
+				<li>Added port description parsing for ducts.
+				<li>Improved performance by connectors description caching.
+				<li>Improved export of "invalid" files with Z value in the IfcSite offset.
+				<li>Implemented export IfcDistributionSystem by default for IFC4.
+				<li>Refactored IfcIndexedPolyCurve creation.
+				<li>Modified File interface based on new scaling requirements.
+				<li>Removed dependency on Revit.IFC.Import for processors.
+				<li>Improved Boolean shift heuristic.
+				<li>PEnum_ConductorFunctionEnum entity fixed according to IFC4x3 standards.
+				<li>Updated QtoSets.
+				<li>Table property separator is changed to semicolon.
+			</ul>
+	  </p>
+	  <br> <p>
+         Bug Fixes:
+	  </p>
+			<p>
+			Export bug fixes:
+			<ul>
+				<li>Removed duplicated indices when merging two consecutive IfcLineIndex segments into one.
+				<li>Fixed renaming of IFC export setup.
+				<li>Fixed export of combined parameters to IFC psets.
+				<li>Fixed color loss for Wall element that is exported as Tessellated geometry in IFC4 RV [Architecture] mode.
+				<li>Restored proper behavior for invalidElementId parameter export.
+				<li>Removed extra assignment of styledbyitems for IfcPolygonalFaceSet.
+				<li>Fixed bug with exporting of "Type" parameter in a schedule to IFC as Family+Type.
+			</ul>
+			</p>
+			<br><p>
+			Import bug fixes:
+			<ul>
+				<li>Fixed bugs in IFC2x3 connected with schema differences.
+				<li>Fixed applying voids to sub-elements on link. 
+				<li>Fixed creation swept disk solids far from the origin.
+				<li>Fixed IFC links updating.
+			</ul></p>
+			<br>
+	</div>
+	<br>
+
 		<div class="version">22.2.1.0</div><div class="versioninfo-bullet">
 
       <br><p>

From fbaae070a88ee62d4171b27a294c57028e7f2199 Mon Sep 17 00:00:00 2001
From: Oleksandr Babii <oleksandr.babii@autodesk.com>
Date: Mon, 11 Oct 2021 11:38:05 -0700
Subject: [PATCH 5/5] Implementing compatibility for the format IFC4

---
 .../Toolkit/IFCInstanceExporter.cs            |  38 +-
 .../Revit.IFC.Export/Utility/GeometryUtil.cs  | 603 ++++++------------
 .../Utility/TriangleMergeUtil.cs              |   7 -
 3 files changed, 183 insertions(+), 465 deletions(-)

diff --git a/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs b/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
index 35285425..119a16e7 100644
--- a/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
+++ b/Source/Revit.IFC.Export/Toolkit/IFCInstanceExporter.cs
@@ -3925,7 +3925,7 @@ public static IFCData CreateArcIndexType(IFCFile file, IList<int> arcIndexList)
          return arcIndexData;
       }
 
-      public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coordinates, IList<GeometryUtil.SegmentIndices> segmentIndexList, bool? selfIntersect)
+      public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coordinates, IList<IList<int>> segmentIndexList, bool? selfIntersect)
       {
          if (coordinates == null)
             throw new ArgumentNullException("Points");
@@ -3936,41 +3936,7 @@ public static IFCAnyHandle CreateIndexedPolyCurve(IFCFile file, IFCAnyHandle coo
          IFCAnyHandle indexedPolyCurveHnd = CreateInstance(file, IFCEntityType.IfcIndexedPolyCurve, null);
          IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "Points", coordinates);
          if (segmentIndexList != null)
-         {
-            IFCAggregate segments = indexedPolyCurveHnd.CreateAggregateAttribute("Segments");
-            foreach (GeometryUtil.SegmentIndices segmentIndices in segmentIndexList)
-            {
-               if(segmentIndices.IsCalculated == false)
-                  throw new ArgumentNullException("Segments");
-
-               IFCData segment = null;
-
-               var polyLineIndices = segmentIndices as GeometryUtil.PolyLineIndices;
-               if (polyLineIndices != null)
-               {
-                  segment = segments.CreateValueOfType("IfcLineIndex");
-
-                  IFCAggregate lineIndexAggr = segment.AsAggregate();
-                  foreach (int index in polyLineIndices.Indices)
-                     lineIndexAggr.Add(IFCData.CreateInteger(index));
-               }
-               else
-               {
-                  var arcIndices = segmentIndices as GeometryUtil.ArcIndices;
-                  if (arcIndices != null)
-                  {
-                     segment = segments.CreateValueOfType("IfcArcIndex");
-
-                     IFCAggregate arcIndexAggr = segment.AsAggregate();
-                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.Start));
-                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.Mid));
-                     arcIndexAggr.Add(IFCData.CreateInteger(arcIndices.End));
-                  }
-               }
-               segments.Add(segment);
-            }
-         }
-
+            IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "Segments", segmentIndexList, 1, null, 2, null);
          IFCAnyHandleUtil.SetAttribute(indexedPolyCurveHnd, "SelfIntersect", selfIntersect);
 
          return indexedPolyCurveHnd;
diff --git a/Source/Revit.IFC.Export/Utility/GeometryUtil.cs b/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
index 68cd9cb1..5c9217fa 100644
--- a/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/GeometryUtil.cs
@@ -91,263 +91,6 @@ public override int GetHashCode(EdgeEndPoint edgePnt)
          }
       }
 
-      /// <summary>
-      /// Stores vertices list of geometry primitives.
-      /// Derived classes concretize the actual primitive type the vertices list belong to.
-      /// </summary>
-      private abstract class PrimVertices
-      {
-         public IFCAnyHandleUtil.IfcPointList PointList { get; protected set; } = new IFCAnyHandleUtil.IfcPointList();
-         public PointBase this[int key]
-         {
-            get => PointList[key];
-            set => PointList[key] = value;
-         }
-         public PointBase Last() { return PointList.Last(); }
-      }
-      private class PolyLineVertices : PrimVertices
-      {
-         public PolyLineVertices(UV beg, UV end)
-         {
-            PointList.AddPoints(beg, end);
-         }
-         public PolyLineVertices(XYZ beg, XYZ end)
-         {
-            PointList.AddPoints(beg, end);
-         }
-         public PolyLineVertices(List<XYZ> points)
-         {
-            if (points.Count < 2)
-               throw new ArgumentException("Number of points must be 2 or greater");
-
-            PointList.AddPoints(points);
-         }
-         public PolyLineVertices(List<UV> points)
-         {
-            if (points.Count < 2)
-               throw new ArgumentException("Number of points must be 2 or greater");
-
-            PointList.AddPoints(points);
-         }
-      }
-      private class ArcVertices : PrimVertices
-      {
-         public ArcVertices(UV start, UV mid, UV end)
-         {
-            PointList.AddPoints(start, mid, end);
-         }
-         public ArcVertices(XYZ start, XYZ mid, XYZ end)
-         {
-            PointList.AddPoints(start, mid, end);
-         }
-      }
-      /// <summary>
-      /// Stores indices list used to build geometry primitives.
-      /// Derived classes concretize the primitive type defined by indices.
-      /// </summary>
-      public abstract class SegmentIndices
-      {
-         public abstract int GetStart();
-         public abstract int GetEnd();
-         public abstract void SetEnd(int endIndex);
-         public abstract void CalcIndices(int startIdx);
-         public bool IsCalculated { get; protected set; } = false;
-         public virtual bool TryMerge(SegmentIndices segmentIndices)
-         {
-            return false;
-         }
-      }
-      public class PolyLineIndices : SegmentIndices
-      {
-         public PolyLineIndices(int lineCount)
-         { LineCount = lineCount; }
-         public List<int> Indices { get; protected set; }
-         public int m_lineCount = 0;
-         public int LineCount
-         {
-            get { return m_lineCount; }
-            //Indices are not valid because line count has been changed. So delete indince list.
-            set { m_lineCount = value; IsCalculated = false; }
-         }
-         public override int GetStart()
-         { return Indices[0]; }
-         public override int GetEnd()
-         { return Indices.Last(); }
-         public override void SetEnd(int endIndex)
-         { Indices[Indices.Count - 1] = endIndex; }
-         public override void CalcIndices(int startIdx)
-         {
-            Indices = new List<int> { startIdx };
-            Indices.AddRange(Enumerable.Range(startIdx, LineCount).Select(x => x + 1));
-            IsCalculated = true;
-         }
-         //Function assumes that input and this segmants are consecutive. End index of this segmant must be equal to start index of input segment.
-         public override bool TryMerge(SegmentIndices segmentIndices)
-         {
-            PolyLineIndices inputPolyLineIndices = segmentIndices as PolyLineIndices;
-            if (segmentIndices == this || inputPolyLineIndices == null)
-               return false;
-            
-            //Indices array after merge must not contain duplicated indices.
-            //So remove either End index of this segment or Start index of input segment.
-            Indices.RemoveAt(Indices.Count - 1);
-            Indices.AddRange(inputPolyLineIndices.Indices);
-            return true;
-         }
-      }
-      public class ArcIndices : SegmentIndices
-      {
-         public int Start { get; protected set; }
-         public int Mid { get; protected set; }
-         public int End { get; protected set; }
-         public override int GetStart()
-         { return Start; }
-         public override int GetEnd()
-         { return End; }
-         public override void SetEnd(int endIndex)
-         { End = endIndex; }
-         public override void CalcIndices(int startIdx)
-         {
-            Start = startIdx;
-            Mid = startIdx + 1;
-            End = startIdx + 2;
-            IsCalculated = true;
-         }
-      }
-      /// <summary>
-      /// Accumulates vertices and calculates indices.
-      /// This class assumes that primitive vertices should be connected in the order they appear in the array.
-      /// Based on this assumption this class constructs indices array.
-      /// </summary>
-      private class PolyCurve
-      {
-         private List<PrimVertices> PrimVerticesList { get; set; } = new List<PrimVertices>();
-         public bool PolyLinesOnly { get; protected set; } = true;
-         //PointList and SegmentsIndices are built by BuildVerticesAndIndices()
-         public IFCAnyHandleUtil.IfcPointList PointList { get; protected set; } = new IFCAnyHandleUtil.IfcPointList();
-         public List<SegmentIndices> SegmentsIndices { get; protected set; } = null;
-
-         public PolyCurve(PrimVertices primVertices)
-         {
-            if (!AddPrimVertices(primVertices))
-               throw new ArgumentException("Error when constructing PolyCurve");
-         }
-
-         public void BuildVerticesAndIndices()
-         {
-            foreach (PrimVertices primVertices in PrimVerticesList)
-            {
-               const int MinIndexValue = 1;
-
-               //1. Build point list.
-               //Current poly curve's end point and start point of primitive curve are always equal.
-               //So remove one of them from point list.
-               if (PointList.Count != 0)
-                  PointList.Points.RemoveAt(PointList.Count - 1);
-               PointList.AddPointList(primVertices.PointList);
-
-               //2. Build indices. Do not do it if poly curve contains poly line segments only.
-               PointBase endPoint = PointList.Last();
-               bool startEndPointsAreEqual = CoordsAreWithinVertexTol(PointList[0], endPoint);
-               SegmentIndices segmentIndices = null;
-               if (PolyLinesOnly)
-               {
-                  // Kind of workaround to ensure that the first and last points, if they are supposed to be 
-                  // the same, are exactly the same.
-                  if (startEndPointsAreEqual)
-                     PointList[0] = endPoint;
-               }
-               else
-               {
-                  if (SegmentsIndices == null)
-                     SegmentsIndices = new List<SegmentIndices>();
-
-                  if (primVertices as PolyLineVertices != null)
-                  {
-                     segmentIndices = new PolyLineIndices(primVertices.PointList.Count - 1);
-                  }
-                  else if (primVertices as ArcVertices != null)
-                  {
-                     segmentIndices = new ArcIndices();
-                  }
-                  else
-                     throw new ArgumentException("Unknown PrimVertices object");
-
-                  segmentIndices.CalcIndices(SegmentsIndices.Count == 0 ? MinIndexValue : SegmentsIndices.Last().GetEnd());
-
-                  // if start and end points of poly curve are equal we should remove duplicated point from vertices array.
-                  // Indices array should be updated accordingly ( to access end point programmer should use start index).
-                  if (startEndPointsAreEqual)
-                  {
-                     PointList.Points.RemoveAt(PointList.Count - 1);
-                     segmentIndices.SetEnd(MinIndexValue);
-                  }
-
-                  //TryMerge is implemented for polylines because we can easily merge two consecutive polyline segments.
-                  if (SegmentsIndices.Count == 0 || !SegmentsIndices.Last().TryMerge(segmentIndices))
-                     SegmentsIndices.Add(segmentIndices);
-               }
-            }
-         }
-
-         public bool AddPrimVertices(PrimVertices primVertices)
-         {
-            if (primVertices == null)
-               return false;
-
-            //PrimVertices class guarantees that number of points is always >= 2.
-            var curvePoints = primVertices.PointList.Points;
-            var pointsCount = curvePoints.Count;
-
-            PointBase currentStartPoint = PrimVerticesList.Count != 0 ? PrimVerticesList[0][0] : null;
-            PointBase currentEndPoint = PrimVerticesList.Count != 0 ? PrimVerticesList.Last().Last() : null;
-            bool addAtEnd = true;
-            bool reverseCurve = false;
-
-            if (currentStartPoint != null && currentEndPoint != null)
-            {
-               // Need to check all possible connections between the current curve and the
-               // existing curve by checking start and endpoints.
-
-               // For options to attach the next curve to the existing curve below.
-               if (!CoordsAreWithinVertexTol(curvePoints[0], currentEndPoint))
-               {
-                  if (CoordsAreWithinVertexTol(curvePoints[pointsCount - 1], currentEndPoint))
-                  {
-                     reverseCurve = true;
-                  }
-                  else
-                  {
-                     addAtEnd = false;
-                     if (CoordsAreWithinVertexTol(curvePoints[0], currentStartPoint))
-                     {
-                        reverseCurve = true;
-                     }
-                     else
-                     {
-                        //Neither start nor end point of Input curve coincide with any of this polycurve's edge points.
-                        //In this case we do not know how to connect them, so return false.
-                        return false;
-                     }
-                  }
-               }
-            }
-
-            if (reverseCurve)
-               curvePoints.Reverse();
-
-            if (primVertices as PolyLineVertices == null)
-               PolyLinesOnly = false;
-
-            if (addAtEnd)
-               PrimVerticesList.Add(primVertices);
-            else
-               PrimVerticesList.Insert(0, primVertices);
-
-            return true;
-         }
-      }
-
       /// <summary>
       /// Creates a default plane whose origin is at (0, 0, 0) and normal is (0, 0, 1).
       /// </summary>
@@ -2842,48 +2585,29 @@ public static bool ProcessCurve(ExporterIFC exporterIFC, Curve curve, Transform
          return true;
       }
 
-      static UV ScaledUVListFromXYZ(XYZ thePoint, Transform lcs, XYZ projectDir)
+      static IList<double> ScaledUVListFromXYZ(XYZ thePoint, Transform lcs, XYZ projectDir)
       {
          UV projectPoint = GeometryUtil.ProjectPointToXYPlaneOfLCS(lcs, projectDir, thePoint);
-         return UnitUtil.ScaleLength(projectPoint);
+         projectPoint = UnitUtil.ScaleLength(projectPoint);
+         return new List<double>(2) { projectPoint.U, projectPoint.V };
       }
 
-      private static double DistanceSquaredBetweenVertices(XYZ coord1, XYZ coord2)
+      private static double DistanceSquaredBetweenVertices(IList<double> coord1, IList<double> coord2)
       {
-         var dX = coord1.X - coord2.X;
-         var dY = coord1.Y - coord2.Y;
-         var dZ = coord1.Z - coord2.Z;
+         int size = coord1.Count;
+         if (size != coord2.Count)
+            return double.MaxValue;     // Cannot compare lists of different number of members
 
-         return dX * dX + dY * dY + dZ * dZ;
-      }
-      private static double DistanceSquaredBetweenVertices(UV coord1, UV coord2)
-      {
-         var dU = coord1.U - coord2.U;
-         var dV = coord1.V - coord2.V;
+         double distSq = 0.0;
+         for (int ii = 0; ii < size; ++ii)
+         {
+            distSq += (coord1[ii] - coord2[ii]) * (coord1[ii] - coord2[ii]);
+         }
 
-         return dU * dU + dV * dV;
+         return distSq;
       }
 
-      private static bool CoordsAreWithinVertexTol(PointBase coord1, PointBase coord2)
-      {
-         double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
-         Point3D coord13D = coord1 as Point3D;
-         Point3D coord23D = coord2 as Point3D;
-         if (coord13D != null && coord23D != null)
-            return (DistanceSquaredBetweenVertices(coord13D.coords, coord23D.coords) < vertexTol * vertexTol);
-         Point2D coord12D = coord1 as Point2D;
-         Point2D coord22D = coord2 as Point2D;
-         if (coord12D != null && coord22D != null)
-            return (DistanceSquaredBetweenVertices(coord12D.coords, coord22D.coords) < vertexTol * vertexTol);
-
-         throw new ArgumentException("Invalid Point type");
-      }
-      private static bool CoordsAreWithinVertexTol(XYZ coord1, XYZ coord2)
-      {
-         double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
-         return (DistanceSquaredBetweenVertices(coord1, coord2) < vertexTol * vertexTol);
-      }
-      private static bool CoordsAreWithinVertexTol(UV coord1, UV coord2)
+      private static bool CoordsAreWithinVertexTol(IList<double> coord1, IList<double> coord2)
       {
          double vertexTol = UnitUtil.ScaleLength(ExporterCacheManager.Document.Application.VertexTolerance);
          return (DistanceSquaredBetweenVertices(coord1, coord2) < vertexTol * vertexTol);
@@ -2899,20 +2623,47 @@ private static bool CoordsAreWithinVertexTol(UV coord1, UV coord2)
       /// <returns>IFCAnyHandle for the created IfcIndexedPolyCurve</returns>
       public static IFCAnyHandle CreatePolyCurveFromCurve(ExporterIFC exporterIFC, Curve curve, Transform lcs = null, XYZ projectDir = null)
       {
+         IList<IList<double>> pointList = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
+         if (pointList == null)
+            return null;
+
          IFCFile file = exporterIFC.GetFile();
+         IFCAnyHandle pointListHnd;
+         if (Is2DPointList(ref pointList))
+            pointListHnd = IFCInstanceExporter.CreateCartesianPointList2D(file, pointList);
+         else
+            pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
 
-         PrimVertices vertices = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
-         // Points from the curve may have been merged after projection, so skip curves that
-         // won't add any new points.
-         if (vertices == null)
-            return null;
 
-         PolyCurve polyCurve = new PolyCurve(vertices);
-         polyCurve.BuildVerticesAndIndices();
-         IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
+         IList<IList<int>> segmentIndexList = null;
+         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
+      }
 
-         IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
-         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
+      static bool Is2DPointList(ref IList<IList<double>> pointList)
+      {
+         bool contains2DPoint = false;
+         bool contains3DPoint = false;
+
+         foreach (IList<double> pointCoord in pointList)
+         {
+            if (pointCoord.Count == 2)
+               contains2DPoint |= true;
+            else if (pointCoord.Count == 3)
+               contains3DPoint |= true;
+            else
+               throw (new ArgumentOutOfRangeException("pointList", "Only 2D or 3D point coordinates are valid!"));
+         }
+         if (contains2DPoint && contains3DPoint)
+         {
+            // Something is not right because of a mix of 2D and 3D coordinates. It will normalize below and discard the 3rd ordinate of 3D coordinates to 2D
+            for (int ii = 0; ii < pointList.Count; ++ii)
+            {
+               if (pointList[ii].Count == 3)
+                  pointList[ii].RemoveAt(2);
+            }
+         }
+
+         return contains2DPoint;
       }
 
       /// <summary>
@@ -2929,31 +2680,88 @@ public static IFCAnyHandle CreatePolyCurveFromCurveLoop(ExporterIFC exporterIFC,
          if (curves.Count() == 0)
             return null;
 
+         bool use3DPoint = (lcs == null || projectDir == null);
+
          IFCFile file = exporterIFC.GetFile();
+         List<IList<double>> pointList = new List<IList<double>>();
+
+         IList<double> currentStartPoint = null;
+         IList<double> currentEndPoint = null;
 
-         PolyCurve polyCurve = null;
          foreach (Curve curve in curves)
          {
-            PrimVertices vertices = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
+            IList<IList<double>> curveCoords = PointListFromCurve(exporterIFC, curve, lcs, projectDir);
+
             // Points from the curve may have been merged after projection, so skip curves that
             // won't add any new points.
-            if (vertices == null)
+            if (curveCoords == null)
                continue;
 
-            if (polyCurve == null)
-               polyCurve = new PolyCurve(vertices);
-            else if (!polyCurve.AddPrimVertices(vertices))
-               return null;
+            int curveCount = curveCoords.Count;
+            if (curveCoords.Count < 2)
+               continue;
+
+            bool removeDuplicatePoint = false;
+            bool addAtEnd = true;
+            bool reverseCurve = false;
+
+            if (currentStartPoint != null && currentEndPoint != null)
+            {
+               // Need to check all possible connections between the current curve and the
+               // existing curve by checking start and endpoints.
+               removeDuplicatePoint = true;
+
+               // For options to attach the next curve to the existing curve below.
+               if (!CoordsAreWithinVertexTol(curveCoords[0], currentEndPoint))
+               {
+                  if (CoordsAreWithinVertexTol(curveCoords[curveCount - 1], currentEndPoint))
+                  {
+                     reverseCurve = true;
+                  }
+                  else
+                  {
+                     addAtEnd = false;
+                     if (CoordsAreWithinVertexTol(curveCoords[0], currentStartPoint))
+                     {
+                        reverseCurve = true;
+                     }
+                  }
+               }
+            }
+
+            if (reverseCurve)
+               curveCoords.Reverse();
+
+            if (removeDuplicatePoint)
+               curveCoords.RemoveAt(addAtEnd ? 0 : curveCount - 1);
+
+            if (addAtEnd)
+               pointList.AddRange(curveCoords);
+            else
+               pointList.InsertRange(0, curveCoords);
+
+            currentStartPoint = pointList[0];
+            currentEndPoint = pointList[pointList.Count - 1];
          }
 
-         polyCurve.BuildVerticesAndIndices();
-         IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
+         // Kind of workaround to ensure that the first and last points, if they are supposed to be 
+         // the same, are exactly the same.
+         if (CoordsAreWithinVertexTol(currentStartPoint, currentEndPoint))
+            pointList[pointList.Count - 1] = pointList[0];
+
+         // SegmentIndexList is not yet supported.
+         IList<IList<int>> segmentIndexList = null;
+
+         IFCAnyHandle pointListHnd;
+         if (use3DPoint)
+            pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
+         else
+            pointListHnd = IFCInstanceExporter.CreateCartesianPointList2D(file, pointList);
 
-         IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
-         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
+         return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
       }
 
-      private static PrimVertices PointListFromCurve(ExporterIFC exporterIFC, Curve curve,
+      private static IList<IList<double>> PointListFromCurve(ExporterIFC exporterIFC, Curve curve,
          Transform lcs, XYZ projectDir)
       {
          if (curve == null)
@@ -2968,139 +2776,93 @@ private static PrimVertices PointListFromCurve(ExporterIFC exporterIFC, Curve cu
          return PointListFromGenericCurve(exporterIFC, curve, lcs, projectDir);
       }
 
-      private static PolyLineVertices PointListFromLine(ExporterIFC exporterIFC, Line line,
+      private static IList<double> Scaled3dListFromXYZ(ExporterIFC exporterIFC, XYZ thePoint)
+      {
+         XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, thePoint);
+         return new List<double>(3) { vertexScaled.X, vertexScaled.Y, vertexScaled.Z };
+      }
+
+      private static IList<IList<double>> PointListFromLine(ExporterIFC exporterIFC, Line line,
          Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         if (use3DPoint)
-         {
-            XYZ startPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, line.GetEndPoint(0));
-            XYZ endPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, line.GetEndPoint(1));
-            // Avoid consecutive duplicates
-            if (CoordsAreWithinVertexTol(startPoint, endPoint))
-               return null;
+         IList<double> startPoint = use3DPoint ?
+            Scaled3dListFromXYZ(exporterIFC, line.GetEndPoint(0)) :
+            ScaledUVListFromXYZ(line.GetEndPoint(0), lcs, projectDir);
 
-            return new PolyLineVertices(startPoint, endPoint);
-         }
-         else
-         {
-            var startPoint = ScaledUVListFromXYZ(line.GetEndPoint(0), lcs, projectDir);
-            var endPoint = ScaledUVListFromXYZ(line.GetEndPoint(1), lcs, projectDir);
-            // Avoid consecutive duplicates
-            if (CoordsAreWithinVertexTol(startPoint, endPoint))
-               return null;
+         IList<double> endPoint = use3DPoint ?
+            Scaled3dListFromXYZ(exporterIFC, line.GetEndPoint(1)) :
+            ScaledUVListFromXYZ(line.GetEndPoint(1), lcs, projectDir);
 
-            return new PolyLineVertices(startPoint, endPoint);
-         }
+         // Avoid consecutive duplicates
+         if (CoordsAreWithinVertexTol(startPoint, endPoint))
+            return null;
+
+         List<IList<double>> pointList = new List<IList<double>>();
+         pointList.Add(startPoint);
+         pointList.Add(endPoint);
+         return pointList;
       }
 
-      private static PrimVertices PointListFromArc(ExporterIFC exporterIFC, Arc arc,
+      private static IList<IList<double>> PointListFromArc(ExporterIFC exporterIFC, Arc arc,
          Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         if (use3DPoint && arc.IsBound)
-         {
-            XYZ startPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(0, true));
-            XYZ midPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(0.5, true));
-            XYZ endPoint = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, arc.Evaluate(1, true));
+         IList<IList<double>> pointList = new List<IList<double>>();
 
-            return new ArcVertices(startPoint, midPoint, endPoint);
-         }
-         else
+         // An integer value is used here to get an accurate interval the value ranges from
+         // 0 to 90 or 100 percent, depending on whether the arc is bound or not.
+         int normalizedEnd = arc.IsBound ? 10 : 9;
+         IList<double> lastPoint = null;
+         for (int ii = 0; ii <= normalizedEnd; ++ii)
          {
-            //If arc's normal is parallel to projection direction and Z axis of lcs then projected arc will be of correct shape.
-            //That is why it can be defined by 3 points: start, mid, end.
-            if (MathUtil.VectorsAreParallel(arc.Normal, projectDir) && MathUtil.VectorsAreParallel(lcs.BasisZ, projectDir) && arc.IsBound)
-            {
-               var startPoint = ScaledUVListFromXYZ(arc.Evaluate(0, true), lcs, projectDir);
-               var midPoint = ScaledUVListFromXYZ(arc.Evaluate(0.5, true), lcs, projectDir);
-               var endPoint = ScaledUVListFromXYZ(arc.Evaluate(1, true), lcs, projectDir);
+            XYZ tessellationPt = arc.Evaluate(ii / 10.0, arc.IsBound);
+            IList<double> point = use3DPoint ?
+               Scaled3dListFromXYZ(exporterIFC, tessellationPt) :
+               ScaledUVListFromXYZ(tessellationPt, lcs, projectDir);
 
-               return new ArcVertices(startPoint, midPoint, endPoint);
-            }
-
-            //Handle cases when Arc is a circle (arc.IsBound == false) or projected arc is of incorrect shape
-            //and cannot be defined by 3 points. Tesselate it in this case.
-            List<XYZ> pointList3D = new List<XYZ>();
-            List<UV> pointList2D = new List<UV>();
-
-            // An integer value is used here to get an accurate interval the value ranges from
-            // 0 to 90 or 100 percent, depending on whether the arc is bound or not.
-            int normalizedEnd = arc.IsBound ? 10 : 9;
-            XYZ lastPoint3D = null;
-            UV lastPoint2D = null;
-            for (int ii = 0; ii <= normalizedEnd; ++ii)
+            // Avoid consecutive duplicates
+            if (lastPoint == null || !CoordsAreWithinVertexTol(point, lastPoint))
             {
-               XYZ tessellationPt = arc.Evaluate(ii / 10.0, arc.IsBound);
-               if (use3DPoint)
-               {
-                  XYZ point = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, tessellationPt);
-
-                  // Avoid consecutive duplicates
-                  if (lastPoint3D == null || !CoordsAreWithinVertexTol(point, lastPoint3D))
-                  {
-                     pointList3D.Add(point);
-                     lastPoint3D = point;
-                  }
-               }
-               else
-               {
-                  var point2D = ScaledUVListFromXYZ(tessellationPt, lcs, projectDir);
-
-                  // Avoid consecutive duplicates
-                  if (lastPoint2D == null || !CoordsAreWithinVertexTol(point2D, lastPoint2D))
-                  {
-                     pointList2D.Add(point2D);
-                     lastPoint2D = point2D;
-                  }
-               }
+               pointList.Add(point);
+               lastPoint = point;
             }
-
-            if (pointList3D != null && pointList3D.Count >= 2)
-               return new PolyLineVertices(pointList3D);
-            else if (pointList2D != null && pointList2D.Count >= 2)
-               return new PolyLineVertices(pointList2D);
          }
 
-         return null;
+         if (pointList.Count < 2)
+            return null;
+
+         return pointList;
       }
 
-      private static PolyLineVertices PointListFromGenericCurve(ExporterIFC exporterIFC,
+      private static IList<IList<double>> PointListFromGenericCurve(ExporterIFC exporterIFC,
          Curve curve, Transform lcs, XYZ projectDir)
       {
          bool use3DPoint = (lcs == null || projectDir == null);
 
-         List<XYZ> listXYZ = new List<XYZ>();
-         List<UV> listUV = new List<UV>();
-
+         IList<IList<double>> pointList = new List<IList<double>>();
          IList<XYZ> tessellatedCurve = curve.Tessellate();
-         var pointsCount = tessellatedCurve.Count;
-         for (int ii = 0; ii < pointsCount; ++ii)
+         IList<double> lastPoint = null;
+         for (int ii = 0; ii < tessellatedCurve.Count; ++ii)
          {
-            if (use3DPoint)
-            {
-               var point = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, tessellatedCurve[ii]);
-               // Avoid consecutive duplicates
-               if (listXYZ.Count == 0 || !CoordsAreWithinVertexTol(point, listXYZ.Last()))
-                  listXYZ.Add(point);
-            }
-            else
+            IList<double> point = use3DPoint ?
+               Scaled3dListFromXYZ(exporterIFC, tessellatedCurve[ii]) :
+               ScaledUVListFromXYZ(tessellatedCurve[ii], lcs, projectDir);
+
+            // Avoid consecutive duplicates
+            if (lastPoint == null || !CoordsAreWithinVertexTol(point, lastPoint))
             {
-               var point = ScaledUVListFromXYZ(tessellatedCurve[ii], lcs, projectDir);
-               // Avoid consecutive duplicates
-               if (listUV.Count == 0 || !CoordsAreWithinVertexTol(point, listUV.Last()))
-                  listUV.Add(point);
+               pointList.Add(point);
+               lastPoint = point;
             }
          }
 
-         if (listXYZ != null && listXYZ.Count >= 2)
-            return new PolyLineVertices(listXYZ);
-         else if (listUV != null && listUV.Count >= 2)
-            return new PolyLineVertices(listUV);
+         if (pointList.Count < 2)
+            return null;
 
-         return null;
+         return pointList;
       }
 
       static private bool AllowedCurveForAllowComplexBoundary(Curve curve)
@@ -3651,18 +3413,15 @@ public static IFCAnyHandle CreateIFCCurveFromRevitCurve(IFCFile file, ExporterIF
 
          if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
          {
-            PrimVertices vertices = PointListFromCurve(exporterIFC, curve, additionalTrf, null);
-            // Points from the curve may have been merged after projection, so skip curves that
-            // won't add any new points.
-            if (vertices == null)
+            IList<IList<double>> pointList = PointListFromCurve(exporterIFC, curve, additionalTrf, null);
+            if (pointList == null)
                return null;
 
-            PolyCurve polyCurve = new PolyCurve(vertices);
-            polyCurve.BuildVerticesAndIndices();
-            IList<SegmentIndices> segmentsIndices = polyCurve.SegmentsIndices;
+            // Segment index list not yet supported.
+            IList<IList<int>> segmentIndexList = null;
 
-            IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList(file, polyCurve.PointList);
-            return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentsIndices, false);
+            IFCAnyHandle pointListHnd = IFCInstanceExporter.CreateCartesianPointList3D(file, pointList);
+            return IFCInstanceExporter.CreateIndexedPolyCurve(file, pointListHnd, segmentIndexList, false);
          }
 
          // if the Curve is a line, do the following
diff --git a/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs b/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
index 442b71e5..d8081953 100644
--- a/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
+++ b/Source/Revit.IFC.Export/Utility/TriangleMergeUtil.cs
@@ -362,13 +362,6 @@ public TriangleMergeUtil(TriangulatedShellComponent triangulatedBody)
       {
          m_Geom = triangulatedBody;
          m_MeshGeom = null;
-         m_MeshVertices.Clear();
-         int idx = 0;
-         foreach(XYZ vert in triangulatedBody.GetVertices())
-         {
-            m_MeshVertices.Add(idx, vert);
-            idx++;
-         }
       }
 
       /// <summary>