static void Main(string[] args)
        {
            DatabaseIfc db = new DatabaseIfc(ModelView.Ifc4X3NotAssigned);

            db.Factory.Options.GenerateOwnerHistory = false;

            IfcProject        project        = new IfcProject(db, "DemoProject");
            IfcProjectLibrary projectLibrary = new IfcProjectLibrary(db, "ClassificationLibrary");

            project.AddDeclared(projectLibrary);

            IfcClassification classification = new IfcClassification(db, "MyClassification");

            new IfcRelAssociatesClassification(classification, projectLibrary);

            IfcClassificationReference buildingElements = new IfcClassificationReference(classification)
            {
                Identification = "100", Name = "BuildingElements"
            };
            IfcClassificationReference walls = new IfcClassificationReference(buildingElements)
            {
                Identification = "100.100", Name = "Walls"
            };
            IfcClassificationReference partionWalls = new IfcClassificationReference(walls)
            {
                Identification = "100.100.002", Name = "PartiionWalls"
            };

            IfcSimplePropertyTemplate simplePropertyTemplate = new IfcSimplePropertyTemplate(db, "IsExternal")
            {
                GlobalId = "3Yss80qXKHuO00025QrE$V", PrimaryMeasureType = "IfcBoolean"
            };
            IfcPropertySetTemplate psetTemplate = new IfcPropertySetTemplate("Pset_WallCommon", simplePropertyTemplate)
            {
                GlobalId = "2VWFE0qXKHuO00025QrE$V"
            };

            IfcPropertySingleValue psv  = new IfcPropertySingleValue(db, "IsExternal", new IfcBoolean(false));
            IfcPropertySet         pset = new IfcPropertySet("Pset_WallCommon", psv);

            new IfcRelDefinesByTemplate(pset, psetTemplate);

            new IfcRelAssociatesClassification(partionWalls, pset);

            DirectoryInfo di = Directory.GetParent(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));

            di = Directory.GetParent(di.FullName);
            db.WriteFile(Path.Combine(di.FullName, "TestClassification.ifc"));
        }
        public RequirementSetView(IfcPropertySetTemplate psetTemplate)
        {
            this.PsetTemplate = psetTemplate;
            Requirements      = psetTemplate.HasPropertyTemplates
                                .OfType <IfcSimplePropertyTemplate>()
                                .Select(p => new RequirementView(p, this))
                                .ToList();


            lang = Language.Lang;
            Language.PropertyChanged += (_, p) => {
                if (p.PropertyName != nameof(Language.Lang))
                {
                    return;
                }
                lang = Language.Lang;
            };
        }
Beispiel #3
0
        public override void Run()

        {
            using (var txn = model.BeginTransaction("Example creation"))
            {
                IfcProject        project           = model.Instances.New <IfcProject>(p => p.Name = "TriluxLightingProducts");
                IfcUnitAssignment ifcUnitAssignment = model.Instances.New <IfcUnitAssignment>(ua =>
                {
                    ua.Units.Add(model.Instances.New <IfcSIUnit>(u =>
                    {
                        u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                        u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                        u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                    }));
                    ua.Units.Add(model.Instances.New <IfcSIUnit>(u =>
                    {
                        u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.MASSUNIT;
                        u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.GRAM;
                        u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.KILO;
                    }));
                });


                //Insert Classification system
                var ifcClassificationSystemOmniClass = model.Instances.New <IfcClassification>(cs =>
                {
                    cs.Name        = "Omniclass";
                    cs.Edition     = "1.0";
                    cs.EditionDate = "2018-12-27T00:00:00.0000000";
                    cs.Description = "The OmniClass Construction Classification System (known as OmniClass™ or OCCS) is a classification system for the construction industry. OmniClass is useful for many applications, from organizing library materials, product literature, and project information, to providing a classification structure for electronic databases. It incorporates other extant systems currently in use as the basis of many of its Tables – MasterFormat™ for work results, UniFormat for elements, and EPIC (Electronic Product Information Cooperation) for structuring products.";
                    cs.Location    = "http://www.omniclass.org/";
                });

                //Insertion of some sample classification references
                //I would be better to insert the whole classification system and reference the appropriate code
                var ifcClassificationReferenceOmniClass = model.Instances.New <IfcClassificationReference>(cr =>
                {
                    cr.Identification   = "23-35-47";
                    cr.Name             = "Electrical Lighting";
                    cr.Description      = "";
                    cr.ReferencedSource = ifcClassificationSystemOmniClass;
                });

                var ifcRelAssociatesClassificationOmniClass = model.Instances.New <IfcRelAssociatesClassification>(relc =>
                {
                    relc.RelatingClassification = ifcClassificationReferenceOmniClass;
                });

                //Insert Classification system
                var ifcClassificationSystemUniClass = model.Instances.New <IfcClassification>(cs =>
                {
                    cs.Name        = "Uniclass";
                    cs.Edition     = "2015";
                    cs.EditionDate = "01.01.2015";
                    cs.Description = "Uniclass is a voluntary classification system for the construction industry that can be used for structuring project information, such as building information models (BIM).";
                    cs.Location    = "https://www.thenbs.com/our-tools/introducing-uniclass-2015";
                });

                //Insertion of some sample classification references
                //I would be better to insert the whole classification system and reference the appropriate code
                var ifcClassificationReferenceUniClass = model.Instances.New <IfcClassificationReference>(cr =>
                {
                    cr.Identification   = "CA-70-10-30";
                    cr.Name             = "Site lighting equipment";
                    cr.Description      = "";
                    cr.ReferencedSource = ifcClassificationSystemUniClass;
                });

                var ifcRelAssociatesClassificationUniClass = model.Instances.New <IfcRelAssociatesClassification>(relc =>
                {
                    relc.RelatingClassification = ifcClassificationReferenceUniClass;
                });

                //Insert a project library to store the product data templates and type products

                var ifcProductDataLibrary = model.Instances.New <IfcProjectLibrary>(l => {
                    l.Name         = "TriluxLightingProductsLibrary";
                    l.GlobalId     = "1DbshdzGD71ejurQqQcxbw";
                    l.Description  = "Library for Trilux light fixtures product data templates based on the ZVEI European core properties";
                    l.Phase        = "Design,Build,Operate";
                    l.OwnerHistory = model.Instances.New <IfcOwnerHistory>(oh =>
                    {
                        oh.CreationDate = DateTime.Now;
                        //oh.ChangeAction = Xbim.Ifc4.Interfaces.IfcChangeActionEnum.ADDED;
                        oh.OwningUser = model.Instances.New <IfcPersonAndOrganization>(po =>
                        {
                            po.TheOrganization = model.Instances.New <IfcOrganization>(o =>
                            {
                                o.Name = "TRILUX GmbH & Co. KG";
                            });

                            po.ThePerson = model.Instances.New <IfcPerson>(p =>
                            {
                                p.GivenName  = "Robert";
                                p.FamilyName = "Heinze";
                            });
                        });
                        oh.OwningApplication = model.Instances.New <IfcApplication>(app =>
                        {
                            app.ApplicationIdentifier = "ID_OF_PIM-SYSTEM";
                            app.ApplicationFullName   = "My Product Information System (PIM)";
                            app.ApplicationDeveloper  = model.Instances.New <IfcOrganization>(o =>
                            {
                                o.Name = "The software company, that developed the PIM system";
                            });
                            app.Version = "1.0";
                        });
                    });
                });

                Comment(ifcProductDataLibrary, @"Root element of this file. Because this doesn't define a specific instance in the building it is a library. It can be used to declare elements, properties, property templates and other library objects which can be later used in the actual design.");
                Comment(ifcProductDataLibrary.OwnerHistory, @"Owner history is used to define ownership of the information.");

                var ifcProductDataLibraryDeclarations = New <IfcRelDeclares>(rel =>
                {
                    rel.RelatingContext = ifcProductDataLibrary;
                }).RelatedDefinitions;
                Comment(ifcProductDataLibraryDeclarations.OwningEntity, @"This relation points to all definitions declared within the scope of the library. These can be elements, element types, properties or property templates");


                //Creating an IfcPropertySetTemplate manually
                //This is not optimal
                //Instead of creating the IfcPropertySetTemplates manually,
                //they should be loaded from the publishing dictionary


                //Read templates from excel sheet
                var          workbookTemplates  = new XLWorkbook(Path.Combine(sourceFolder, sourceFile));
                IXLWorksheet worksheetTemplates = workbookTemplates.Worksheet("Templates");
                //IXLRange rangeTemplates = worksheetTemplates.Range("A1:Z690");
                //IXLTable rawDataTemplates = rangeTemplates.AsTable();
                DataTable dtTemplates = ReadDataTable(worksheetTemplates);

                var productDataTemplates = from DataRow dr in dtTemplates.Rows orderby dr["DataTemplate"] group dr by dr["DataTemplate"];
                foreach (var productDataTemplate in productDataTemplates)
                {
                    IfcPropertySetTemplate ifcPropertySetTemplate = model.Instances.New <IfcPropertySetTemplate>(pset =>
                    {
                        pset.GlobalId         = Xbim.Ifc4.UtilityResource.IfcGloballyUniqueId.ConvertToBase64(Guid.NewGuid());
                        pset.Name             = productDataTemplate.Key.ToString();
                        pset.Description      = "Data Template by " + productDataTemplate.ElementAt(0)["Publisher"].ToString();
                        pset.ApplicableEntity = "IfcBuildingElementProxy/USERDEFINED";
                        pset.TemplateType     = Xbim.Ifc4.Interfaces.IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY;
                    });
                    Comment(ifcPropertySetTemplate, @"Declaration of 'IfcPropertySetTemplate' within the library for lighting product data templates.");
                    Comment(ifcPropertySetTemplate, @"Insert property templates; they should be loaded from the publishing dictionary");

                    foreach (DataRow propertyTemplate in productDataTemplate)
                    {
                        IfcSimplePropertyTemplate ifcSimplePropertyTemplate = model.Instances.New <IfcSimplePropertyTemplate>(spt =>
                        {
                            spt.Name               = propertyTemplate["SystemName"].ToString();
                            spt.Description        = propertyTemplate["Definition"].ToString();
                            spt.Expression         = "";
                            spt.GlobalId           = GetGuid(propertyTemplate["GlobalId"].ToString());
                            spt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            spt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            spt.PrimaryMeasureType = propertyTemplate["PrimaryMeasureType"].ToString();

                            //check if enum values exists in this template, and if, create themn in IFC
                            string allowedValues = propertyTemplate["AllowedValues"].ToString();
                            if (allowedValues.Length > 0)
                            {
                                spt.TemplateType = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE;
                                IfcPropertyEnumeration ifcPropertyEnumeration = model.Instances.New <IfcPropertyEnumeration>(pe =>
                                {
                                    pe.Name = $"Allowed values of {spt.Name}";
                                });

                                char delimiter = '|';
                                foreach (string allowedValue in allowedValues.Split(delimiter))
                                {
                                    ifcPropertyEnumeration.EnumerationValues.Add(new IfcLabel(allowedValue));
                                }

                                spt.Enumerators = ifcPropertyEnumeration;
                            }

                            //Check the measures and units
                            string primaryMeasureType = propertyTemplate["PrimaryMeasureType"].ToString();
                            if ((primaryMeasureType == "IfcDocumentInformation") ||
                                (primaryMeasureType == "IfcClassificationReference") ||
                                (primaryMeasureType == "IfcGloballyUniqueId"))
                            {
                                spt.PrimaryMeasureType = "IfcLabel";
                            }
                            else if (primaryMeasureType == typeof(IfcLengthMeasure).Name)
                            {
                                spt.PrimaryUnit = model.Instances.New <IfcSIUnit>(u =>
                                {
                                    u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                                    u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                                    u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                                });
                            }
                            else if (primaryMeasureType == typeof(IfcMassMeasure).Name)
                            {
                                spt.PrimaryUnit = model.Instances.New <IfcSIUnit>(u =>
                                {
                                    u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.MASSUNIT;
                                    u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.GRAM;
                                });
                            }
                            else if (primaryMeasureType == typeof(IfcPlaneAngleMeasure).Name)
                            {
                                spt.PrimaryUnit = model.Instances.New <IfcConversionBasedUnit>(punit =>
                                {
                                    //Convert the angel measure from the unit grad to the SI Unit radian
                                    //rad=grad*(PI/180)
                                    punit.Name             = "Grad";
                                    punit.UnitType         = Xbim.Ifc4.Interfaces.IfcUnitEnum.PLANEANGLEUNIT;
                                    punit.ConversionFactor = model.Instances.New <IfcMeasureWithUnit>(mwu =>
                                    {
                                        mwu.UnitComponent = model.Instances.New <IfcSIUnit>(siUnit =>
                                        {
                                            siUnit.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.PLANEANGLEUNIT;
                                            siUnit.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.RADIAN;
                                        });
                                        mwu.ValueComponent = new IfcReal(Math.PI / 180);
                                    });
                                    punit.Dimensions = model.Instances.New <IfcDimensionalExponents>(dim =>
                                    {
                                        dim.LengthExponent                   = 0;
                                        dim.MassExponent                     = 0;
                                        dim.TimeExponent                     = 0;
                                        dim.ElectricCurrentExponent          = 0;
                                        dim.ThermodynamicTemperatureExponent = 0;
                                        dim.AmountOfSubstanceExponent        = 0;
                                        dim.LuminousIntensityExponent        = 0;
                                    });
                                });
                            }
                        });


                        string complexGroupName = propertyTemplate["ComplexGroupName"].ToString();
                        if (complexGroupName.Length == 0)
                        {
                            ifcPropertySetTemplate.HasPropertyTemplates.Add(ifcSimplePropertyTemplate);
                        }
                        else
                        {
                            //Find the appropriate IfcComplexPropertyTemplate, and if it does not yet exist, create it
                            IfcComplexPropertyTemplate ifcComplexPropertyTemplate
                                = model.Instances.OfType <IfcComplexPropertyTemplate>()
                                  .Where(cpt => cpt.Name == complexGroupName)
                                  .FirstOrDefault();

                            if (ifcComplexPropertyTemplate == null)
                            {
                                ifcComplexPropertyTemplate = model.Instances.New <IfcComplexPropertyTemplate>(cpt =>
                                {
                                    cpt.Name        = complexGroupName;
                                    cpt.Description = propertyTemplate["ComplexGroupDescription"].ToString();
                                    cpt.GlobalId    = GetGuid(propertyTemplate["ComplexGroupGuid"].ToString());
                                });

                                ifcPropertySetTemplate.HasPropertyTemplates.Add(ifcComplexPropertyTemplate);
                            }

                            ifcComplexPropertyTemplate.HasPropertyTemplates.Add(ifcSimplePropertyTemplate);
                        }
                    }

                    ifcProductDataLibraryDeclarations.Add(ifcPropertySetTemplate);
                }

                //Read source data from excel sheet
                var          workbookData  = new XLWorkbook(Path.Combine(sourceFolder, sourceFile));
                IXLWorksheet worksheetData = workbookData.Worksheet("Sheets");
                //IXLRange rangeData = worksheetData.Range("A1:Z690");
                //IXLTable rawData = rangeData.AsTable();
                DataTable dtData = ReadDataTable(worksheetData);

                //Loop through the products in the data sheet
                foreach (DataRow product in dtData.Rows)
                {
                    var ifcTypeProduct = model.Instances.New <IfcTypeProduct>();
                    ifcTypeProduct.Name                 = product["Name"].ToString();
                    ifcTypeProduct.Description          = "Description of " + ifcTypeProduct.Name;
                    ifcTypeProduct.ApplicableOccurrence = "IfcLightFixture";

                    //Create the property sets, and relate them to their templates
                    foreach (IfcPropertySetTemplate ifcPropertySetTemplate in model.Instances.OfType <IfcPropertySetTemplate>().ToList())
                    {
                        IfcPropertySet ifcPropertySet = model.Instances.New <IfcPropertySet>(pset =>
                        {
                            pset.Name        = ifcPropertySetTemplate.Name;
                            pset.Description = ifcPropertySetTemplate.Description;
                        });

                        ifcTypeProduct.HasPropertySets.Add(ifcPropertySet);

                        //Relate the property set to the definition of the property set template
                        //Find the appropriate relation, and if it does not yet exist, create it
                        IfcRelDefinesByTemplate ifcRelDefinesByTemplate
                            = model.Instances.OfType <IfcRelDefinesByTemplate>()
                              .Where(rdbt => rdbt.RelatingTemplate == ifcPropertySetTemplate)
                              .FirstOrDefault();

                        if (ifcRelDefinesByTemplate == null)
                        {
                            ifcRelDefinesByTemplate = New <IfcRelDefinesByTemplate>(dbt =>
                            {
                                dbt.RelatingTemplate = ifcPropertySetTemplate;
                            });
                        }

                        ifcRelDefinesByTemplate.RelatedPropertySets.Add(ifcPropertySet);
                    }

                    //loop through the properties of the product, based on the data template
                    foreach (DataRow propertyTemplate in dtTemplates.Rows)
                    {
                        //Load the correct IfcPropertySet for this property, that was created above
                        IfcPropertySet ifcPropertySet = (IfcPropertySet)ifcTypeProduct.HasPropertySets
                                                        .Where(x => x.Name == propertyTemplate["DataTemplate"].ToString())
                                                        .FirstOrDefault();

                        //Check, which measure type the property is based on
                        switch (propertyTemplate["PrimaryMeasureType"].ToString())
                        {
                        case "IfcGloballyUniqueId":
                            //Insert the unique number for the product type
                            ifcTypeProduct.GlobalId = GetGuid(product[propertyTemplate["SystemName"].ToString()].ToString());
                            break;

                        case "IfcDocumentInformation":
                            //Insert the product information that are in documents
                            string folderName = propertyTemplate["SystemName"].ToString();
                            string docName    = product[propertyTemplate["SystemName"].ToString()].ToString();
                            if (docName.Length > 0)
                            {
                                string fileLocation = $"{folderName}/{docName}";

                                IfcDocumentInformation ifcDocumentInformation;
                                var existingInsertedDocumentInformation = model.Instances.OfType <IfcDocumentInformation>().Where(x => x.Location == fileLocation);
                                if (existingInsertedDocumentInformation.Count() == 0)
                                {
                                    ifcDocumentInformation = model.Instances.New <IfcDocumentInformation>(doc =>
                                    {
                                        doc.Identification   = docName;
                                        doc.Name             = docName;
                                        doc.Location         = $@"{folderName}/{docName}";
                                        doc.CreationTime     = DateTime.Now.ToString("dd.MM.yyyy");
                                        doc.Confidentiality  = Xbim.Ifc4.Interfaces.IfcDocumentConfidentialityEnum.PUBLIC;
                                        doc.ElectronicFormat = MimeTypes.GetMimeType(docName);
                                        doc.IntendedUse      = "Product information";
                                        doc.Purpose          = "Product information";
                                        doc.ValidFrom        = "01.01.2018";
                                        doc.ValidUntil       = "31.12.2021";
                                        doc.Scope            = "Europa";
                                        doc.Revision         = "1.0";
                                    });

                                    string test = Path.GetExtension(docName);
                                    switch (Path.GetExtension(docName))
                                    {
                                    case ".pdf":
                                        ifcDocumentInformation.Description = "Produktdatenblatt";
                                        break;

                                    case ".3ds":
                                        ifcDocumentInformation.Description = "3D-Visualisierung";
                                        break;

                                    case ".jpg":
                                        ifcDocumentInformation.Description = "Produktphoto";
                                        break;

                                    case ".ies":
                                        ifcDocumentInformation.Description = "Lichtverteilung von IES Standard";
                                        break;
                                    }


                                    IfcRelAssociatesDocument ifcRelAssociatesDocument = model.Instances.New <IfcRelAssociatesDocument>(docref =>
                                    {
                                        docref.RelatedObjects.Add(ifcTypeProduct);
                                        docref.RelatingDocument = ifcDocumentInformation;
                                    });
                                }
                                else
                                {
                                    ifcDocumentInformation = existingInsertedDocumentInformation.FirstOrDefault();
                                    var existingDocumentInformationRelation = model.Instances.OfType <IfcRelAssociatesDocument>()
                                                                              .Where(x => x.RelatingDocument == ifcDocumentInformation).FirstOrDefault();

                                    existingDocumentInformationRelation.RelatedObjects.Add(ifcTypeProduct);
                                }
                            }
                            break;

                        case "IfcClassificationReference":

                            switch (propertyTemplate["SystemName"].ToString())
                            {
                            case "Omniclass":
                                var classificationReference = model.Instances.OfType <IfcClassificationReference>()
                                                              .Where(x => x.Identification == product[propertyTemplate["SystemName"].ToString()].ToString()).FirstOrDefault();

                                ifcRelAssociatesClassificationOmniClass.RelatedObjects.Add(ifcTypeProduct);
                                break;

                            case "Uniclass":

                                ifcRelAssociatesClassificationUniClass.RelatedObjects.Add(ifcTypeProduct);
                                break;
                            }

                            break;

                        default:

                            IfcPropertySingleValue ifcPropertySingleValue
                                = model.Instances.New <IfcPropertySingleValue>(p =>
                            {
                                string propertyName = propertyTemplate["SystemName"].ToString();
                                var dataValue       = product[propertyName];

                                p.Name        = propertyName;
                                p.Description = "";

                                string primaryMeasureType = propertyTemplate["PrimaryMeasureType"].ToString();
                                if (primaryMeasureType == typeof(IfcLengthMeasure).Name)
                                {
                                    p.NominalValue = new IfcMassMeasure(Double.Parse(dataValue.ToString()));
                                }
                                else if (primaryMeasureType == typeof(IfcMassMeasure).Name)
                                {
                                    p.NominalValue = new IfcMassMeasure(Double.Parse(dataValue.ToString()));
                                }
                                else if (primaryMeasureType == typeof(IfcPlaneAngleMeasure).Name)
                                {
                                    p.NominalValue = new IfcPlaneAngleMeasure(Double.Parse(dataValue.ToString()));
                                }
                                else
                                {
                                    p.NominalValue = new IfcLabel(dataValue.ToString());
                                }
                            });


                            // Check, if the template of this property is part of a complex property
                            if (propertyTemplate["ComplexGroupName"].ToString().Length > 0)
                            {
                                string complexPropertyName        = propertyTemplate["ComplexGroupName"].ToString();
                                string complexPropertyDescription = propertyTemplate["ComplexGroupDescription"].ToString();
                                string complexPropertyGlobalId    = GetGuid(propertyTemplate["ComplexGroupGuid"].ToString());

                                IfcComplexProperty ifcComplexProperty = model.Instances
                                                                        .OfType <IfcComplexProperty>()
                                                                        .Where(n => n.Name == complexPropertyName)
                                                                        .Where(u => u.UsageName == ifcTypeProduct.Name.ToString())
                                                                        .FirstOrDefault();

                                if (ifcComplexProperty == null)
                                {
                                    ifcComplexProperty = model.Instances.New <IfcComplexProperty>(p =>
                                    {
                                        p.Name        = complexPropertyName;
                                        p.Description = complexPropertyDescription;
                                        p.UsageName   = ifcTypeProduct.Name.ToString();
                                    });
                                    ifcPropertySet.HasProperties.Add(ifcComplexProperty);
                                }

                                //Insert the product information into the complex property and then into the property set
                                ifcComplexProperty.HasProperties.Add(ifcPropertySingleValue);
                            }
                            else
                            {
                                //Insert the product information directly into the property set
                                ifcPropertySet.HasProperties.Add(ifcPropertySingleValue);
                            }

                            break;
                        }
                    }
                    ;

                    ifcProductDataLibraryDeclarations.Add(ifcTypeProduct);
                    Comment(ifcTypeProduct, @"Declaration of 'IfcTypeProduct' within the library for a ligthing product.");
                }

                txn.Commit();
            }

            string targetFileName = Path.Combine(targetFolder, targetFile);

            SaveAs(targetFileName, false, typeof(IfcProjectLibrary));

            //DirtyFix with Schema location
            //https://github.com/xBimTeam/XbimEssentials/issues/288
            string contentOfFile        = File.ReadAllText($"{targetFileName}.ifcXML");
            string oldNameSpaceLocation = @"xsi:schemaLocation=""http://www.buildingsmart-tech.org/ifcXML/IFC4/Add2 http://www.buildingsmart-tech.org/ifc/IFC4/Add2/IFC4_ADD2.xsd""";
            string newNameSpaceLocation = @"xsi:schemaLocation=""http://www.buildingsmart-tech.org/ifcXML/IFC4/Add2 ../../IFC4_ADD2.xsd""";

            contentOfFile = contentOfFile.Replace(oldNameSpaceLocation, newNameSpaceLocation);
            File.WriteAllText($"{targetFileName}.ifcXML", contentOfFile);


            //Create ifcZip file
            File.Delete(targetzipFile);
            ZipFile.CreateFromDirectory(sourceFolder, targetzipFile);
            using (ZipArchive zipArchive = ZipFile.Open(targetzipFile, ZipArchiveMode.Update))
            {
                zipArchive.GetEntry(sourceFile).Delete();
                zipArchive.CreateEntryFromFile($"{targetFolder}/{targetFile}.ifcXML", $"{targetFile}.ifcXML");
                zipArchive.CreateEntryFromFile($"{targetFolder}/{targetFile}.ifc", $"{targetFile}.ifc");
            }
        }
        public override void Run()
        {
            using (var txn = model.BeginTransaction("Example creation"))
            {
                //How to fill the header with xBIM Eseentials?
                //model.Header.Name = "Product data file";
                //model.Header.Organization = "HC Italy";
                //model.Header.Author = "Ugo";
                //model.Header.Authorization = "CEN-TC442-WG2-TG3";
                //model.Header.TimeStamp = DateTime.Now;
                //model.Header.OriginatingSystem = "CEN-TC442-WG2-TG3-Writer";

                //there should always be one project in the model
                var project = model.Instances.New <IfcProject>(p => p.Name = "Basic Creation");
                //our shortcut to define basic default units
                project.Initialize(Xbim.Common.ProjectUnits.SIUnitsUK);

                //Insert a project library to store the product data templates
                var ifcProductDataLibrary = New <IfcProjectLibrary>(l => {
                    l.Name        = "Library for brick product data templates";
                    l.GlobalId    = "1DbshdzGD71ejurQqQcxbw";
                    l.Description = "";
                    l.Phase       = "";
                });
                Comment(ifcProductDataLibrary, @"Root element of this file. Because this doesn't define a specific instance in the building it is a library. It can be used to declare elements, properties, property templates and other library objects which can be later used in the actual design.");
                Comment(ifcProductDataLibrary.OwnerHistory, @"Owner history is used to define ownership of the information.");

                var ifcProductDataLibraryDeclarations = New <IfcRelDeclares>(rel =>
                {
                    rel.RelatingContext = ifcProductDataLibrary;
                }).RelatedDefinitions;
                Comment(ifcProductDataLibraryDeclarations.OwningEntity, @"This relation points to all definitions declared within the scope of the library. These can be elements, element types, properties or property templates");

                IfcPropertySetTemplate ifcPropertySetTemplate = model.Instances.New <IfcPropertySetTemplate>(pset =>
                {
                    pset.GlobalId         = "1DbshTzGD71ejurQqQcxbw";
                    pset.Name             = "My IfcPropertySetTemplate";
                    pset.Description      = "Group of properties for " + ifcProductDataLibrary.Name;
                    pset.ApplicableEntity = "IfcWall/USERDEFINED";
                    pset.TemplateType     = Xbim.Ifc4.Interfaces.IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY;
                    pset.HasPropertyTemplates.AddRange(new[]
                    {
                        model.Instances.New <IfcSimplePropertyTemplate>(pt =>
                        {
                            pt.Name               = "zone";
                            pt.Description        = "";
                            pt.GlobalId           = "1DbshTzGD71ejuZQqQcxba";
                            pt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            pt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            pt.PrimaryMeasureType = "IfcLabel";
                        }),
                        model.Instances.New <IfcSimplePropertyTemplate>(pt =>
                        {
                            pt.Name               = "height";
                            pt.Description        = "";
                            pt.GlobalId           = "1DbshTzGD71ejuZQqQkxad";
                            pt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            pt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            pt.PrimaryMeasureType = "IfcReal";
                            pt.PrimaryUnit        = model.Instances.New <IfcSIUnit>(u =>
                            {
                                u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                                u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                                u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                            });
                        }),
                        model.Instances.New <IfcSimplePropertyTemplate>(pt =>
                        {
                            pt.Name               = "width";
                            pt.Description        = "";
                            pt.GlobalId           = "1DbshTzGD71ejuZQqQcxac";
                            pt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            pt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            pt.PrimaryMeasureType = "IfcReal";
                            pt.PrimaryUnit        = model.Instances.New <IfcSIUnit>(u =>
                            {
                                u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                                u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                                u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                            });
                        }),
                        model.Instances.New <IfcSimplePropertyTemplate>(pt =>
                        {
                            pt.Name               = "length";
                            pt.Description        = "";
                            pt.GlobalId           = "1DbshTzGD71ejuZQqQcxab";
                            pt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            pt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            pt.PrimaryMeasureType = "IfcReal";
                            pt.PrimaryUnit        = project.UnitsInContext.LengthUnit;
                        })
                    });
                });

                ifcProductDataLibraryDeclarations.Add(ifcPropertySetTemplate);
                Comment(ifcPropertySetTemplate, @"Declaration of 'IfcPropertySetTemplate' within the library for brick product data templates.");

                //Read source data from excel sheet
                var          workbook = new XLWorkbook(Path.Combine(baseFolder, sourceFile));
                IXLWorksheet worksheet;
                IXLRange     dataRange;
                worksheet = workbook.Worksheet(sheetName);
                dataRange = worksheet.Range("A1:E4231");
                IXLTable  rawData = dataRange.AsTable();
                DataTable dt      = ReadDataTable(worksheet);


                var ifcRelDefinesByTemplate = New <IfcRelDefinesByTemplate>(dbt =>
                {
                    dbt.RelatingTemplate = ifcPropertySetTemplate;
                });

                int n = 0;
                do
                {
                    foreach (DataRow row in dt.Rows)
                    {
                        var ifcTypeProduct = model.Instances.New <IfcTypeProduct>();
                        ifcTypeProduct.GlobalId             = "1DbshTzGD71ejurQqQcxbw"; //How to generate a fresh IFC GlobalId with XBim?
                        ifcTypeProduct.Tag                  = string.Format("{0}", row["Id"].ToString());
                        ifcTypeProduct.Name                 = string.Format("Brick Product variant #{0}", row["Id"].ToString());
                        ifcTypeProduct.Description          = "Description of " + ifcTypeProduct.Name;
                        ifcTypeProduct.ApplicableOccurrence = "IfcWall";

                        IfcPropertySet ifcPropertySet = model.Instances.New <IfcPropertySet>(pset =>
                        {
                            pset.Name = "Properties of " + ifcTypeProduct.Name;
                            pset.HasProperties.AddRange(new[]
                            {
                                model.Instances.New <IfcPropertySingleValue>(p =>
                                {
                                    p.Name         = "zone";
                                    p.Description  = "";
                                    p.NominalValue = new IfcText(row["Zone"].ToString().TrimEnd());
                                }),

                                model.Instances.New <IfcPropertySingleValue>(p =>
                                {
                                    p.Name         = "height";
                                    p.NominalValue = new IfcLengthMeasure(Double.Parse(row["Height"].ToString()));
                                    p.Unit         = project.UnitsInContext.LengthUnit;
                                }),
                                model.Instances.New <IfcPropertySingleValue>(p =>
                                {
                                    p.Name         = "width";
                                    p.NominalValue = new IfcLengthMeasure(Double.Parse(row["Width"].ToString()));
                                    p.Unit         = project.UnitsInContext.LengthUnit;
                                }),
                                model.Instances.New <IfcPropertySingleValue>(p =>
                                {
                                    p.Name         = "lenght";
                                    p.NominalValue = new IfcLengthMeasure(Double.Parse(row["Length"].ToString()));
                                    p.Unit         = project.UnitsInContext.LengthUnit;
                                })
                            });
                        });

                        ifcTypeProduct.HasPropertySets.Add(ifcPropertySet);
                        ifcProductDataLibraryDeclarations.Add(ifcTypeProduct);
                        Comment(ifcTypeProduct, @"Declaration of 'IfcTypeProduct' within the library for brick product data templates.");

                        ifcRelDefinesByTemplate.RelatedPropertySets.Add(ifcPropertySet);
                    }
                    n++;
                }while (n < 1);

                // commit to confirm changes in the model

                txn.Commit();
            }

            string targetFileName = Path.Combine(baseFolder, targetFile + sheetName);

            SaveAs(targetFileName, true, typeof(IfcProjectLibrary));
        }
Beispiel #5
0
        static void Main(string[] args)
        {
            //
            ifcSIUnitMap = new Dictionary <string, IfcSIUnitName>
            {
                { "AMPERE", IfcSIUnitName.AMPERE },
                { "BECQUEREL", IfcSIUnitName.BECQUEREL },
                { "CANDELA", IfcSIUnitName.CANDELA },
                { "COULOMB", IfcSIUnitName.COULOMB },
                { "CUBIC_METRE", IfcSIUnitName.CUBIC_METRE },
                { "DEGREE_CELSIUS", IfcSIUnitName.DEGREE_CELSIUS },
                { "FARAD", IfcSIUnitName.FARAD },
                { "GRAM", IfcSIUnitName.GRAM },
                { "GRAY", IfcSIUnitName.GRAY },
                { "HENRY", IfcSIUnitName.HENRY },
                { "HERTZ", IfcSIUnitName.HERTZ },
                { "JOULE", IfcSIUnitName.JOULE },
                { "KELVIN", IfcSIUnitName.KELVIN },
                { "LUMEN", IfcSIUnitName.LUMEN },
                { "LUX", IfcSIUnitName.LUX },
                { "METRE", IfcSIUnitName.METRE },
                { "MOLE", IfcSIUnitName.MOLE },
                { "NEWTON", IfcSIUnitName.NEWTON },
                { "OHM", IfcSIUnitName.OHM },
                { "PASCAL", IfcSIUnitName.PASCAL },
                { "RADIAN", IfcSIUnitName.RADIAN },
                { "SECOND", IfcSIUnitName.SECOND },
                { "SIEMENS", IfcSIUnitName.SIEMENS },
                { "SIEVERT", IfcSIUnitName.SIEVERT },
                { "SQUARE_METRE", IfcSIUnitName.SQUARE_METRE },
                { "STERADIAN", IfcSIUnitName.STERADIAN },
                { "TESLA", IfcSIUnitName.TESLA },
                { "VOLT", IfcSIUnitName.VOLT },
                { "WATT", IfcSIUnitName.WATT },
                { "WEBER", IfcSIUnitName.WEBER }
            };
            //
            breakedownRootMap = new Dictionary <string, BreakdownItem>();          // prazdna mapa klasifikaci, bude plnena postupne
            //
            breakedownMap     = new Dictionary <int, BreakdownItem>();             // prazdna mapa trid, bude plnena postupne
            ifcPropertyMap    = new Dictionary <int, IfcSimplePropertyTemplate>(); // prazdna mapa vlastnosti, bude plnena postupne
            ifcPropertySetMap = new Dictionary <int, IfcPropertySetTemplate>();    // prazdna mapa skupin vlastnosti, bude plnena postupne
            reasonsMap        = new Dictionary <int, Reason>();                    // prazdna mapa IfcRelAssignsToControl, bude plnena postupne
            actorMap          = new Dictionary <string, Actor>();                  // prazdna mapa IfcRelAssignsToActor, bude plnena postupne
            milestonesCache   = new Dictionary <int, Milestone>();                 // prazdna mapa IfcRelAssignsToProcess, bude plnena postupne

            //using (var reader = new StreamReader("sfdi_export.csv"))
            using (var reader = new StreamReader(Console.OpenStandardInput()))
                using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
                {
                    var records = new List <RecordLine>();
                    csv.Read(); // CSV header Line 0 - XbimEditorCredentials
                    csv.ReadHeader();

                    csv.Read(); // CSV line 0 - XbimEditorCredentials
                    var record = new RecordLine
                    {
                        Id       = csv.GetField <int>("Id"),
                        Pid      = csv.GetField <int>("Pid"),
                        Lvl      = csv.GetField <int>("Lvl") + 2, // -2..+inf -> 0..+inf
                        Method   = csv.GetField("Method"),
                        GlobalId = csv.GetField("GlobalId"),
                        Par01    = csv.GetField("Par01"),
                        Par02    = csv.GetField("Par02"),
                        Par03    = csv.GetField("Par03"),
                        Par04    = csv.GetField("Par04"),
                        Par05    = csv.GetField("Par05"),
                        Par06    = csv.GetField("Par06"),
                        Par07    = csv.GetField("Par07"),
                        Par08    = csv.GetField("Par08"),
                        Par09    = csv.GetField("Par09")
                    };
                    records.Add(record);

                    //START
                    var ifcFile    = args[0]; // tempfile // "/var/www/html/tmp/DDSS.ifc";
                    var doValidate = "validate";
                    if (args.Length > 1)
                    {
                        doValidate = args[1]; // "novalidate"
                    }
                    var editor = new XbimEditorCredentials
                    {
                        ApplicationFullName       = record.Par01, // "Databáze datového standardu stavebnictví"
                        ApplicationDevelopersName = record.Par02, // "Michal Kopecký"
                        ApplicationIdentifier     = record.Par03, // "DDSS"
                        ApplicationVersion        = record.Par04, // "1.0"
                        EditorsFamilyName         = record.Par05, // "Žák"
                        EditorsGivenName          = record.Par06, // "Josef"
                        EditorsOrganisationName   = record.Par07, // "Česká agentura pro standardizaci"
                    };

                    //IfcStore.ModelProviderFactory.UseMemoryModelProvider(); // OLD VERSION
                    // set up logger to file and console
                    var logFile = Path.ChangeExtension(ifcFile, ".log");
                    Log.Logger = new LoggerConfiguration()
                                 .Enrich.FromLogContext()
                                 .WriteTo.Console()
                                 .WriteTo.File(logFile)
                                 .CreateLogger();
                    XbimLogging.LoggerFactory.AddSerilog();

                    IfcStore.ModelProviderFactory.UseMemoryModelProvider();
                    using (var model = Model.Create(editor))
                    {
                        //var i = model.Internal.Instances;

                        //using (var txn = model.BeginTransaction()) // OLD VERSION
                        using (var txn = model.Internal.BeginTransaction("Model creation"))
                        {
                            // these will keep cache of units and enums
                            // units have to be defined in the source of 'UnitMap' (compile time) while
                            // enumerations are to be defined in runtime based on the values in the DB
                            var units = new UnitMap(model);
                            var enums = new EnumsMap(model);

                            while (csv.Read())
                            {
                                record = new RecordLine
                                {
                                    Id       = csv.GetField <int>("Id"),
                                    Pid      = csv.GetField <int>("Pid"),
                                    Method   = csv.GetField("Method"),
                                    GlobalId = csv.GetField("GlobalId"),
                                    Par01    = csv.GetField("Par01"),
                                    Par02    = csv.GetField("Par02"),
                                    Par03    = csv.GetField("Par03"),
                                    Par04    = csv.GetField("Par04"),
                                    Par05    = csv.GetField("Par05"),
                                    Par06    = csv.GetField("Par06"),
                                    Par07    = csv.GetField("Par07"),
                                    Par08    = csv.GetField("Par08"),
                                    Par09    = csv.GetField("Par09")
                                };
                                records.Add(record);
                                //Console.WriteLine(record.Method);

                                if (record.Method == "IfcClassification")
                                {
                                    var root = model.CreateBreakedownRoot(record.Par01, null); // "Klasifikace DSS, CCI:ET, CCI:CS, CCI:FS"

                                    // set name in default language
                                    root.SetName("en", record.Par01);

                                    // set name in other languages
                                    root.SetName("cs", "");

                                    breakedownRootMap.Add(record.Par01, root);
                                }
                                else if (record.Method == "IfcProjectLibrary")
                                {
                                    currentRequirementsSet = model.CreateRequirementSet(record.Par01, null); // "Level of Information Need"
                                    if (record.GlobalId != "")
                                    {
                                        currentRequirementsSet.Entity.GlobalId = record.GlobalId;
                                    }

                                    // set name in default language
                                    currentRequirementsSet.SetName("en", record.Par01);

                                    // set name in other languages
                                    currentRequirementsSet.SetName("cs", "");
                                }
                                else if (record.Method == "IfcRelAssignsToControl")
                                {
                                    // Purpose of the data requirement/exchange
                                    if (!reasonsMap.TryGetValue(record.Id, out Reason reason))
                                    {
                                        reason = model.CreateReason(record.Par01, record.Par02);
                                        if (record.GlobalId != "")
                                        {
                                            reason.Entity.GlobalId = record.GlobalId;
                                        }
                                        reasonsMap.Add(record.Id, reason);

                                        // set name in default language
                                        reason.SetName("en", record.Par01);

                                        // set name in other languages
                                        reason.SetName("cs", record.Par02);
                                    }
                                    reason.AddToContext(currentRequirementsSet);
                                }
                                else if (record.Method == "IfcRelAssignsToActor")
                                {
                                    // Actor / Role = Who is interested in the data
                                    if (!actorMap.TryGetValue(record.GlobalId, out Actor actor))
                                    {
                                        actor = model.CreateActor(record.Par01, null);
                                        if (record.GlobalId != "")
                                        {
                                            actor.Entity.GlobalId = record.GlobalId;
                                        }
                                        actorMap.Add(record.GlobalId, actor);

                                        // set name in default language
                                        actor.SetName("en", record.Par01);

                                        // set name in other languages
                                        actor.SetName("cs", "");
                                    }
                                    actor.AddToContext(currentRequirementsSet);
                                }
                                else if (record.Method == "IfcRelAssignsToProcess")
                                {
                                    // Milestone = point in time
                                    if (!milestonesCache.TryGetValue(record.Id, out Milestone milestone))
                                    {
                                        milestone = model.CreateMilestone(record.Par02, null);
                                        milestone.Entity.IsMilestone = record.Par03 == "true";

                                        if (record.GlobalId != "")
                                        {
                                            milestone.Entity.GlobalId = record.GlobalId;
                                        }
                                        milestonesCache.Add(record.Id, milestone);

                                        // set name in default language
                                        milestone.SetName("en", record.Par01);

                                        // set name in other languages
                                        milestone.SetName("cs", record.Par02);
                                    }
                                    milestone.AddToContext(currentRequirementsSet);
                                }
                                else if (record.Method == "IfcClassificationReference")
                                {
                                    // Class within classification
                                    // Set parent
                                    BreakdownItem parent = null;
                                    if (record.Par04 == "")
                                    {
                                        //Program.ifcCRS = Program.ifcCL; // classification for root class
                                        parent = breakedownRootMap[record.Par09]; // classification for root class
                                    }
                                    else
                                    {
                                        parent = breakedownMap[record.Pid]; // parent class othewise
                                    }
                                    // Optionally add new class
                                    if (!breakedownMap.ContainsKey(record.Id))
                                    {
                                        var item = model.CreateBreakedownItem(record.Par02, record.Par03, null, parent);
                                        breakedownMap.Add(record.Id, item);

                                        // set name in default language
                                        item.SetName("en", record.Par01);

                                        // set name in other languages
                                        item.SetName("cs", record.Par02);
                                    }
                                    ;
                                }
                                else if (record.Method == "IfcRelAssociatesClassification")
                                {
                                    breakedownMap[record.Id].AddToContext(currentRequirementsSet);
                                }
                                else if (record.Method == "IfcRelDeclares")
                                {
                                    // nothing to do, handled by LOIN library
                                }
                                else if (record.Method == "IfcPropertySetTemplate")
                                {
                                    if (ifcPropertySetMap.ContainsKey(record.Id))
                                    {
                                        PropertySetReused  = true;
                                        currentPropertySet = ifcPropertySetMap[record.Id];
                                    }
                                    else
                                    {
                                        PropertySetReused  = false;
                                        currentPropertySet = model.CreatePropertySetTemplate(record.Par01, null); // "Základní informace o místnostech"

                                        // set name in default language
                                        currentPropertySet.SetName("en", record.Par01);

                                        // set name in other languages
                                        currentPropertySet.SetName("cs", record.Par02);

                                        //ApplicableEntity
                                        //Description
                                        if (record.Par03 != "")
                                        {
                                            currentPropertySet.Description = record.Par03;

                                            // set name in default language
                                            currentPropertySet.SetDescription("en", record.Par03);

                                            // set name in other languages
                                            currentPropertySet.SetDescription("cs", record.Par04);
                                        }
                                        else if (record.Par04 != "")
                                        {
                                            currentPropertySet.Description = record.Par04;

                                            // set name in default language
                                            currentPropertySet.SetDescription("en", "");

                                            // set name in other languages
                                            currentPropertySet.SetDescription("cs", record.Par04);
                                        }
                                        if (record.GlobalId != "")
                                        {
                                            currentPropertySet.GlobalId = record.GlobalId;
                                        }
                                        ifcPropertySetMap.Add(record.Id, currentPropertySet);
                                    };
                                    currentRequirementsSet.Add(currentPropertySet);
                                }
                                else if (record.Method == "IfcSimplePropertyTemplate")
                                {
                                    if (!PropertySetReused)
                                    {
                                        if (!ifcPropertyMap.TryGetValue(record.Id, out IfcSimplePropertyTemplate propertyTemplate))
                                        {
                                            propertyTemplate = model.New <IfcSimplePropertyTemplate>(p =>
                                            {
                                                p.Name = record.Par08; // "Název EN"

                                                // Set description in primary language
                                                p.SetName("en", record.Par08);

                                                // Set description in other languages
                                                p.SetName("cs", record.Par01);
                                            });
                                            if (record.GlobalId != "")
                                            {
                                                propertyTemplate.GlobalId = record.GlobalId;
                                            }
                                            //Description
                                            if (record.Par09 != "")
                                            {
                                                propertyTemplate.Description = record.Par09;

                                                // Set description in primary language
                                                propertyTemplate.SetDescription("en", record.Par09);

                                                // Set description in other languages
                                                propertyTemplate.SetDescription("cs", record.Par02);
                                            }
                                            else if (record.Par02 != "")
                                            {
                                                propertyTemplate.Description = record.Par02;

                                                // Set description in primary language
                                                propertyTemplate.SetDescription("en", "");

                                                // Set description in other languages
                                                propertyTemplate.SetDescription("cs", record.Par02);
                                            }

                                            if (record.Par03 != "") // dataunit
                                            {
                                                propertyTemplate.PrimaryUnit = units[record.Par03];
                                            }
                                            if (record.Par04 != "") // nameof(X) -> "X"
                                            {
                                                propertyTemplate.PrimaryMeasureType = record.Par04;
                                            }
                                            //TemplateType
                                            switch (record.Par05)
                                            {
                                            case "P_SINGLEVALUE":
                                                propertyTemplate.TemplateType = IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                                                break;

                                            case "P_ENUMERATEDVALUE":
                                                propertyTemplate.TemplateType = IfcSimplePropertyTemplateTypeEnum.P_ENUMERATEDVALUE;
                                                propertyTemplate.Enumerators  = enums.GetOrAdd(record.Par06, record.Par07.Split(",", StringSplitOptions.RemoveEmptyEntries)); // { "Pondělí", "Úterý", "Středa", "Čtvrtek", "Pátek", "Sobota", "Neděle"}
                                                break;

                                            case "P_REFERENCEVALUE":
                                                propertyTemplate.TemplateType = IfcSimplePropertyTemplateTypeEnum.P_REFERENCEVALUE;
                                                break;

                                            case "P_BOUNDEDVALUE":
                                                propertyTemplate.TemplateType = IfcSimplePropertyTemplateTypeEnum.P_BOUNDEDVALUE;
                                                break;

                                            default:
                                                Console.WriteLine("IfcSimplePropertyTemplate: UNKNOWN TEMPLATE TYPE ", record.Par05);
                                                //Program.ifcSPT.TemplateType = ...
                                                break;
                                            }
                                            ;
                                            ifcPropertyMap.Add(record.Id, propertyTemplate);
                                        }
                                        ;

                                        currentPropertySet.HasPropertyTemplates.Add(propertyTemplate);
                                        currentPropertyTemplate = propertyTemplate;
                                    }
                                    ;
                                }
                                else if (record.Method == "IfcSIUnit")
                                {
                                    var unit = model.New <IfcSIUnit>();
                                    //Name
                                    //Program.ifcISU.Name = IfcSIUnitName.SQUARE_METRE;
                                    try
                                    {
                                        unit.Name = ifcSIUnitMap[record.Par01];
                                    }
                                    catch (KeyNotFoundException)
                                    {
                                        Console.WriteLine("IfcSIUnit: UNKNOWN NAME ", record.Par01);
                                        //ifcISU.Name = IfcSIUnitName. ...
                                    }
                                    //UnitType
                                    switch (record.Par02)
                                    {
                                    case "AREAUNIT":
                                        unit.UnitType = IfcUnitEnum.AREAUNIT;
                                        break;

                                    default:
                                        Console.WriteLine("IfcSIUnit: UNKNOWN UNIT TYPE ", record.Par02);
                                        //ifcISU.UnitType = ...
                                        break;
                                    }
                                    ;
                                    currentPropertyTemplate.PrimaryUnit = unit;
                                }
                                else if (record.Method == "IfcDocumentReference")
                                {
                                    // Declared data requirements / templates
                                    model.New <IfcRelAssociatesDocument>(rd => {
                                        rd.RelatedObjects.Add(currentPropertyTemplate);
                                        rd.RelatingDocument = model.New <IfcDocumentReference>(doc => {
                                            doc.Identification = record.Par01; // "Vyhláška č. 441/2013 Sb."
                                            doc.Location       = record.Par02; // "https://www.mfcr.cz/cs/legislativa/legislativni-dokumenty/2013/vyhlaska-c-441-2013-sb-16290"
                                            doc.Name           = record.Par03; // "Vyhláška k provedení zákona o oceňování majetku (oceňovací vyhláška)"
                                        });
                                    });
                                }
                                ;
                            }
                            ; // konec while read
                            txn.Commit();
                        }

                        // validate schema and proper units
                        var validator = new IfcValidator();
                        var valid     = validator.Check(model.Internal);
                        if (doValidate != "novalidate" && !valid)
                        {
                            throw new Exception("Invalid model shouldn't be stored and used for any purposes.");
                        }

                        // this is stdout if you want to use it
                        //var stdout = Console.OpenStandardOutput();

                        // writing to stream (any stream)
                        using (var stream = File.Create(ifcFile))
                        {
                            if (Path.GetExtension(ifcFile) == ".ifcxml")
                            {
                                model.Internal.SaveAsIfcXml(stream);
                            }
                            else
                            {
                                model.Internal.SaveAsIfc(stream);
                            };
                        }

                        //model.SaveAs("DDSS.ifc");
                        //model.SaveAs("DDSS.ifcxml");
                        //model.SaveAs(ifcFile); // args[0]
                    }
                    //STOP
                }// csv
        }
Beispiel #6
0
        /// <summary>
        /// Load user-defined Property set
        /// Format:
        ///    PropertSet: <Pset_name> I[nstance]/T[ype] <IFC entity list separated by ','>
        ///              Property_name   Data_type   Revit_Parameter
        ///              ...
        /// Datatype supported: Text, Integer, Real, Boolean
        /// Line divider between Property Mapping and User defined property sets:
        ///     #! UserDefinedPset
        /// </summary>
        /// <returns>List of property set definitions</returns>
        public static IEnumerable <IfcPropertySetTemplate> LoadUserDefinedPset()
        {
            List <IfcPropertySetTemplate> userDefinedPsets = new List <IfcPropertySetTemplate>();

            try
            {
                string filename = ExporterCacheManager.ExportOptionsCache.PropertySetOptions.ExportUserDefinedPsetsFileName;
                if (!File.Exists(filename))
                {
                    // This allows for the original behavior of looking in the directory of the export DLL to look for the default file name.
                    filename = GetUserDefPsetFilename();
                }
                if (!File.Exists(filename))
                {
                    return(userDefinedPsets);
                }

                string extension = Path.GetExtension(filename);
                if (string.Compare(extension, ".ifcxml", true) == 0 || string.Compare(extension, ".ifcjson", true) == 0 || string.Compare(extension, ".ifc", true) == 0)
                {
                    DatabaseIfc db      = new DatabaseIfc(filename);
                    IfcContext  context = db.Context;
                    if (context == null)
                    {
                        return(userDefinedPsets);
                    }
                    foreach (IfcRelDeclares relDeclares in context.Declares)
                    {
                        userDefinedPsets.AddRange(relDeclares.RelatedDefinitions.OfType <IfcPropertySetTemplate>());
                    }
                }
                else
                {
                    using (StreamReader sr = new StreamReader(filename))
                    {
                        string line;

                        DatabaseIfc            db = new DatabaseIfc(false, ReleaseVersion.IFC4);
                        IfcPropertySetTemplate userDefinedPset = null;
                        while ((line = sr.ReadLine()) != null)
                        {
                            line.TrimStart(' ', '\t');

                            if (String.IsNullOrEmpty(line))
                            {
                                continue;
                            }
                            if (line[0] != '#')
                            {
                                // Format: PropertSet: <Pset_name> I[nstance]/T[ype] <IFC entity list separated by ','>
                                //              Property_name   Data_type   Revit_Parameter
                                // ** For now it only works for simple property with single value (datatype supported: Text, Integer, Real and Boolean)

                                string[] split = line.Split(new char[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                                if (string.Compare(split[0], "PropertySet:", true) == 0)
                                {
                                    userDefinedPset = new IfcPropertySetTemplate(db, split.Length > 2 ? split[1] : "Unknown");
                                    if (split.Count() >= 4) // Any entry with less than 3 par is malformed
                                    {
                                        switch (split[2][0])
                                        {
                                        case 'T':
                                            userDefinedPset.TemplateType = IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY;
                                            break;

                                        case 'I':
                                            userDefinedPset.TemplateType = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN;
                                            break;

                                        default:
                                            userDefinedPset.TemplateType = IfcPropertySetTemplateTypeEnum.PSET_OCCURRENCEDRIVEN;
                                            break;
                                        }
                                        userDefinedPset.ApplicableEntity = string.Join(",", split[3].Split(new char[] { ',', ';', ' ' }, StringSplitOptions.RemoveEmptyEntries));
                                        userDefinedPsets.Add(userDefinedPset);
                                    }
                                }
                                else
                                {
                                    if (split.Count() >= 2)
                                    {
                                        string propertyTemplateName = split[0];
                                        IfcSimplePropertyTemplate propertyDefUnit = userDefinedPset[propertyTemplateName] as IfcSimplePropertyTemplate;
                                        if (propertyDefUnit == null)
                                        {
                                            userDefinedPset.AddPropertyTemplate(propertyDefUnit = new IfcSimplePropertyTemplate(db, split[0]));
                                        }
                                        if (split.Count() >= 3 && !string.IsNullOrEmpty(split[2]))
                                        {
                                            new IfcRelAssociatesClassification(new IfcClassificationReference(db)
                                            {
                                                Identification = split[2]
                                            }, propertyDefUnit);
                                        }
                                        if (!string.IsNullOrEmpty(split[1]))
                                        {
                                            propertyDefUnit.PrimaryMeasureType = "Ifc" + split[1];
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }

            return(userDefinedPsets);
        }
        public override void Run()
        {
            using (var txn = model.BeginTransaction("Example creation"))
            {
                IfcProject        project           = model.Instances.New <IfcProject>(p => p.Name = "TriluxLightingProducts");
                IfcUnitAssignment ifcUnitAssignment = model.Instances.New <IfcUnitAssignment>(ua =>
                {
                    ua.Units.Add(model.Instances.New <IfcSIUnit>(u =>
                    {
                        u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                        u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                        u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                    }));
                    ua.Units.Add(model.Instances.New <IfcSIUnit>(u =>
                    {
                        u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.MASSUNIT;
                        u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.GRAM;
                        u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.KILO;
                    }));
                });

                var ifcClassificationSystemOmniClass = model.Instances.New <IfcClassification>();
                ifcClassificationSystemOmniClass.Name        = "Omniclass";
                ifcClassificationSystemOmniClass.Edition     = "1.0";
                ifcClassificationSystemOmniClass.EditionDate = "2018-12-27T00:00:00.0000000";
                ifcClassificationSystemOmniClass.Description = "The OmniClass Construction Classification System (known as OmniClass™ or OCCS) is a classification system for the construction industry. OmniClass is useful for many applications, from organizing library materials, product literature, and project information, to providing a classification structure for electronic databases. It incorporates other extant systems currently in use as the basis of many of its Tables – MasterFormat™ for work results, UniFormat for elements, and EPIC (Electronic Product Information Cooperation) for structuring products.";
                ifcClassificationSystemOmniClass.Location    = "http://www.omniclass.org/";

                var ifcClassificationReferenceOmniClass = model.Instances.New <IfcClassificationReference>();
                ifcClassificationReferenceOmniClass.Identification   = "23-35-47";
                ifcClassificationReferenceOmniClass.Name             = "Electrical Lighting";
                ifcClassificationReferenceOmniClass.Description      = "NOT PROVIDED";
                ifcClassificationReferenceOmniClass.ReferencedSource = ifcClassificationSystemOmniClass;

                var ifcRelAssociatesClassificationOmniClass = model.Instances.New <IfcRelAssociatesClassification>();
                ifcRelAssociatesClassificationOmniClass.RelatingClassification = ifcClassificationReferenceOmniClass;

                var ifcClassificationSystemUniClass = model.Instances.New <IfcClassification>();
                ifcClassificationSystemUniClass.Name        = "Uniclass";
                ifcClassificationSystemUniClass.Edition     = "2015";
                ifcClassificationSystemUniClass.EditionDate = "";
                ifcClassificationSystemUniClass.Description = "";
                ifcClassificationSystemUniClass.Location    = "https://www.thenbs.com/our-tools/introducing-uniclass-2015";

                var ifcClassificationReferenceUniClass = model.Instances.New <IfcClassificationReference>();
                ifcClassificationReferenceUniClass.Identification   = "CA-70-10-30";
                ifcClassificationReferenceUniClass.Name             = "Site lighting equipment";
                ifcClassificationReferenceUniClass.Description      = "NOT PROVIDED";
                ifcClassificationReferenceUniClass.ReferencedSource = ifcClassificationSystemUniClass;

                var ifcRelAssociatesClassificationUniClass = model.Instances.New <IfcRelAssociatesClassification>();
                ifcRelAssociatesClassificationUniClass.RelatingClassification = ifcClassificationReferenceUniClass;

                //Insert a project library to store the product data templates and type products
                IfcProjectLibrary ifcProductDataLibrary = New <IfcProjectLibrary>(l => {
                    l.Name        = "TriluxLightingProductsLibrary";
                    l.GlobalId    = "1DbshdzGD71ejurQqQcxbw";
                    l.Description = "Library for Trilux light fixtures product data templates based on the ZVEI European core properties";
                    l.Phase       = "Design,Build,Operate";
                });
                Comment(ifcProductDataLibrary, @"Root element of this file. Because this doesn't define a specific instance in the building it is a library. It can be used to declare elements, properties, property templates and other library objects which can be later used in the actual design.");
                Comment(ifcProductDataLibrary.OwnerHistory, @"Owner history is used to define ownership of the information.");

                var ifcProductDataLibraryDeclarations = New <IfcRelDeclares>(rel =>
                {
                    rel.RelatingContext = ifcProductDataLibrary;
                }).RelatedDefinitions;
                Comment(ifcProductDataLibraryDeclarations.OwningEntity, @"This relation points to all definitions declared within the scope of the library. These can be elements, element types, properties or property templates");


                //Creating an IfcPropertySetTemplate manually
                //This is not optimal
                //Instead of creating the IfcPropertySetTemplates manually,
                //they should be loaded from the publishing dictionary

                //Read templates from excel sheet
                var          workbook = new XLWorkbook(Path.Combine(sourceFolder, sourceFile));
                IXLWorksheet worksheetTemplates;
                IXLRange     rangeTemplates;
                worksheetTemplates = workbook.Worksheet("Templates");
                rangeTemplates     = worksheetTemplates.Range("A1:H27");
                IXLTable  rawDataTemplates = rangeTemplates.AsTable();
                DataTable dtTemplates      = ReadDataTable(worksheetTemplates);


                IfcPropertySetTemplate ifcPropertySetTemplate = model.Instances.New <IfcPropertySetTemplate>(pset =>
                {
                    pset.GlobalId         = "1DbshTzGD71ejurQqQcxbw";
                    pset.Name             = "IfcPropertySetTemplate";
                    pset.Description      = "Group of properties for " + ifcProductDataLibrary.Name;
                    pset.ApplicableEntity = "IfcLightFixture/USERDEFINED";
                    pset.TemplateType     = Xbim.Ifc4.Interfaces.IfcPropertySetTemplateTypeEnum.PSET_TYPEDRIVENONLY;
                });
                Comment(ifcPropertySetTemplate, @"Declaration of 'IfcPropertySetTemplate' within the library for lighting product data templates.");
                Comment(ifcPropertySetTemplate, @"Insert property templates; they should be loaded from the publishing dictionary");

                foreach (DataRow row in dtTemplates.Rows)
                {
                    //Publisher SystemName  GlobalId PrimaryMeasureType  DataColumn

                    ifcPropertySetTemplate.HasPropertyTemplates.AddRange(new[]
                    {
                        model.Instances.New <IfcSimplePropertyTemplate>(pt =>
                        {
                            pt.Name               = row["SystemName"].ToString();
                            pt.Description        = "";
                            pt.GlobalId           = row["GlobalId"].ToString();
                            pt.TemplateType       = Xbim.Ifc4.Interfaces.IfcSimplePropertyTemplateTypeEnum.P_SINGLEVALUE;
                            pt.AccessState        = Xbim.Ifc4.Interfaces.IfcStateEnum.LOCKED;
                            pt.PrimaryMeasureType = row["PrimaryMeasureType"].ToString();

                            string primaryMeasureType = row["PrimaryMeasureType"].ToString();

                            if (primaryMeasureType == typeof(IfcLengthMeasure).Name)
                            {
                                pt.PrimaryUnit = model.Instances.New <IfcSIUnit>(u =>
                                {
                                    u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.LENGTHUNIT;
                                    u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.METRE;
                                    u.Prefix   = Xbim.Ifc4.Interfaces.IfcSIPrefix.MILLI;
                                });
                            }
                            else if (primaryMeasureType == typeof(IfcMassMeasure).Name)
                            {
                                pt.PrimaryUnit = model.Instances.New <IfcSIUnit>(u =>
                                {
                                    u.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.MASSUNIT;
                                    u.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.GRAM;
                                });
                            }
                            else if (primaryMeasureType == typeof(IfcPlaneAngleMeasure).Name)
                            {
                                pt.PrimaryUnit = model.Instances.New <IfcConversionBasedUnit>(punit =>
                                {
                                    //Convert the angel measure from the unit grad to the SI Unit radian
                                    //rad=grad*(PI/180)
                                    punit.Name             = "Grad";
                                    punit.UnitType         = Xbim.Ifc4.Interfaces.IfcUnitEnum.PLANEANGLEUNIT;
                                    punit.ConversionFactor = model.Instances.New <IfcMeasureWithUnit>(mwu =>
                                    {
                                        mwu.UnitComponent = model.Instances.New <IfcSIUnit>(siUnit =>
                                        {
                                            siUnit.UnitType = Xbim.Ifc4.Interfaces.IfcUnitEnum.PLANEANGLEUNIT;
                                            siUnit.Name     = Xbim.Ifc4.Interfaces.IfcSIUnitName.RADIAN;
                                        });
                                        mwu.ValueComponent = new IfcReal(Math.PI / 180);
                                    });
                                    punit.Dimensions = model.Instances.New <IfcDimensionalExponents>(dim =>
                                    {
                                        dim.LengthExponent                   = 0;
                                        dim.MassExponent                     = 0;
                                        dim.TimeExponent                     = 0;
                                        dim.ElectricCurrentExponent          = 0;
                                        dim.ThermodynamicTemperatureExponent = 0;
                                        dim.AmountOfSubstanceExponent        = 0;
                                        dim.LuminousIntensityExponent        = 0;
                                    });
                                });
                            }
                        })
                    });
                }
                ;


                ifcProductDataLibraryDeclarations.Add(ifcPropertySetTemplate);

                //Read source data from excel sheet
                var          workbookData = new XLWorkbook(Path.Combine(sourceFolder, sourceFile));
                IXLWorksheet worksheetData;
                IXLRange     rangeData;
                worksheetData = workbookData.Worksheet("Sheets");
                rangeData     = worksheetData.Range("A1:Z690");
                IXLTable  rawData = rangeData.AsTable();
                DataTable dtData  = ReadDataTable(worksheetData);

                var ifcRelDefinesByTemplate = New <IfcRelDefinesByTemplate>(dbt =>
                {
                    dbt.RelatingTemplate = ifcPropertySetTemplate;
                });

                int n = 0;
                do
                {
                    foreach (DataRow row in dtData.Rows)
                    {
                        var ifcTypeProduct = model.Instances.New <IfcTypeProduct>();
                        ifcTypeProduct.GlobalId             = "1DbshTzGD71ejurQqQcxbw"; //How to generate a fresh IFC GlobalId with XBim?
                        ifcTypeProduct.Name                 = row["Name"].ToString();
                        ifcTypeProduct.Description          = "Description of " + ifcTypeProduct.Name;
                        ifcTypeProduct.ApplicableOccurrence = "IfcLightFixture";

                        ifcRelAssociatesClassificationOmniClass.RelatedObjects.Add(ifcTypeProduct);
                        ifcRelAssociatesClassificationUniClass.RelatedObjects.Add(ifcTypeProduct);

                        IfcPropertySet ifcPropertySet = model.Instances.New <IfcPropertySet>(pset =>
                        {
                            pset.Name = "Properties of " + ifcTypeProduct.Name;
                        });

                        foreach (DataRow template in dtTemplates.Rows)
                        {
                            if (template["PropertyWithDocumentLink"].ToString() == "Yes")
                            {
                                //Insert the product information into documents
                                string folderName = template["SystemName"].ToString();
                                string docName    = row[template["SystemName"].ToString()].ToString();

                                IfcDocumentInformation ifcDocumentInformation = model.Instances.New <IfcDocumentInformation>(doc =>
                                {
                                    doc.Identification   = docName;
                                    doc.Name             = docName;
                                    doc.Location         = $@"{folderName}/{docName}";
                                    doc.Confidentiality  = Xbim.Ifc4.Interfaces.IfcDocumentConfidentialityEnum.PUBLIC;
                                    doc.ElectronicFormat = MimeTypes.GetMimeType(docName);
                                    doc.IntendedUse      = "Product information";
                                    doc.Purpose          = "Product information";
                                });

                                IfcRelAssociatesDocument ifcRelAssociatesDocument = model.Instances.New <IfcRelAssociatesDocument>(docref =>
                                {
                                    docref.RelatedObjects.Add(ifcTypeProduct);
                                    docref.RelatingDocument = ifcDocumentInformation;
                                });

                                //<IfcRelAssociatesDocument GlobalId="3vBcwkKGf1cxmQZUtNnL0g">
                                //   < RelatedObjects >
                                //      < IfcTransportElement xsi: nil = "true" ref= "i143" />
                                //   </ RelatedObjects >
                                //   < RelatingDocument >
                                //      < IfcDocumentInformation xsi: nil = "true" ref= "i150" />
                                //   </ RelatingDocument >
                                //</ IfcRelAssociatesDocument >
                            }
                            else
                            {
                                //Insert the product information into Properties
                                ifcPropertySet.HasProperties.AddRange(new[]
                                {
                                    model.Instances.New <IfcPropertySingleValue>(p =>
                                    {
                                        string propertyName = template["SystemName"].ToString();
                                        var dataValue       = row[propertyName];

                                        p.Name        = propertyName;
                                        p.Description = "";

                                        string primaryMeasureType = template["PrimaryMeasureType"].ToString();
                                        if (primaryMeasureType == typeof(IfcLengthMeasure).Name)
                                        {
                                            p.NominalValue = new IfcMassMeasure(Double.Parse(dataValue.ToString()));
                                        }
                                        else if (primaryMeasureType == typeof(IfcMassMeasure).Name)
                                        {
                                            p.NominalValue = new IfcMassMeasure(Double.Parse(dataValue.ToString()));
                                        }
                                        else if (primaryMeasureType == typeof(IfcPlaneAngleMeasure).Name)
                                        {
                                            p.NominalValue = new IfcPlaneAngleMeasure(Double.Parse(dataValue.ToString()));
                                        }
                                        else
                                        {
                                            p.NominalValue = new IfcLabel(dataValue.ToString());
                                        }
                                    })
                                });
                            }
                        }
                        ;

                        ifcTypeProduct.HasPropertySets.Add(ifcPropertySet);

                        ifcProductDataLibraryDeclarations.Add(ifcTypeProduct);
                        Comment(ifcTypeProduct, @"Declaration of 'IfcTypeProduct' within the library for a ligthing product.");

                        ifcRelDefinesByTemplate.RelatedPropertySets.Add(ifcPropertySet);
                    }
                    n++;
                }while (n < 1);

                txn.Commit();
            }

            string targetFileName = Path.Combine(targetFolder, targetFile);

            SaveAs(targetFileName, true, typeof(IfcProjectLibrary));

            //Create ifcZip file
            File.Delete(zipFile);
            ZipFile.CreateFromDirectory(sourceFolder, zipFile);
            using (ZipArchive zipArchive = ZipFile.Open(zipFile, ZipArchiveMode.Update))
            {
                zipArchive.GetEntry(sourceFile).Delete();
                zipArchive.CreateEntryFromFile($"{targetFolder}/{targetFile}.ifcXML", $"{targetFile}.ifcXML");
                zipArchive.CreateEntryFromFile($"{targetFolder}/{targetFile}.ifc", $"{targetFile}.ifc");
            }
        }