diff --git a/.readthedocs.yaml b/.github/workflows/.readthedocs.yaml similarity index 100% rename from .readthedocs.yaml rename to .github/workflows/.readthedocs.yaml diff --git a/.github/workflows/create-dist.bat b/.github/workflows/create-dist.bat index 911d3c0..1610747 100644 --- a/.github/workflows/create-dist.bat +++ b/.github/workflows/create-dist.bat @@ -1,4 +1,4 @@ -cd pulmtln +cd tulip md "dist\" xcopy "build\bin\Release\" "dist\" /e cd .. \ No newline at end of file diff --git a/.github/workflows/ubuntu-builds-and-tests.yml b/.github/workflows/ubuntu-builds-and-tests.yml index bfc5ac4..c077e32 100644 --- a/.github/workflows/ubuntu-builds-and-tests.yml +++ b/.github/workflows/ubuntu-builds-and-tests.yml @@ -1,4 +1,4 @@ -name: "Ubuntu | Build and tests" +name: "Ubuntu | Tulip build and tests" permissions: actions: write @@ -6,7 +6,7 @@ permissions: on: push: branches: - - master + - main - dev pull_request: branches: @@ -15,7 +15,7 @@ on: workflow_dispatch: env: - PULMTLN_TOP_DIR: pulmtln + TULIP_TOP_DIR: tulip MFEM_TOP_DIR: mfem jobs: @@ -30,33 +30,37 @@ jobs: runs-on: ${{ matrix.os }} steps: - - name: checkout PULMTLN + - name: checkout TULIP uses: actions/checkout@v3 with: - path: ${{ env.PULMTLN_TOP_DIR }} + path: ${{ env.TULIP_TOP_DIR }} ssh-key: ${{secrets.PULMTLN_SSH_KEY}} submodules: 'recursive' - name: getcmake uses: lukka/get-cmake@latest - - name: Setup vcpkg (it does not install any package yet) + - name: Install system packages + run: bash ${{ env.TULIP_TOP_DIR }}/scripts/install-packages.sh + + - name: Setup vcpkg uses: lukka/run-vcpkg@v11 with: - vcpkgGitCommitId: 42bb0d9e8d4cf33485afb9ee2229150f79f61a1f - vcpkgJsonGlob: 'pulmtln/vcpkg.json' - - - name: Configuring PULMTLN - env: - MFEM_PACKAGE: ${{ github.workspace }}/${{env.MFEM_TOP_DIR}}/build + vcpkgGitCommitId: eed289f6e06a5e7a5c9e6a729671b0a56af7dd69 + vcpkgJsonGlob: 'tulip/vcpkg.json' + + - name: Configure TULIP + env: + MFEM_PACKAGE: ${{ github.workspace }}/${{ env.MFEM_TOP_DIR }}/build run: | - cmake --preset "gnu" -S pulmtln -B pulmtln/build - - - name: Building PULMTLN + cmake --preset "gnu" -S ${{ env.TULIP_TOP_DIR }} -B ${{ env.TULIP_TOP_DIR }}/build + + - name: Build TULIP run: | - cmake --build pulmtln/build/ + cmake --build ${{ env.TULIP_TOP_DIR }}/build --parallel 2 - - name: test PULMTLN - run: cd pulmtln && build/bin/pulmtln_tests + - name: Test TULIP + run: | + ctest --test-dir ${{ env.TULIP_TOP_DIR }}/build --output-on-failure \ No newline at end of file diff --git a/.github/workflows/windows-automated-releases.yml b/.github/workflows/windows-automated-releases.yml index b7ed592..0eae7cc 100644 --- a/.github/workflows/windows-automated-releases.yml +++ b/.github/workflows/windows-automated-releases.yml @@ -7,11 +7,11 @@ permissions: on: push: branches: - - master + - main - feature/automate-release env: - PULMTLN_TOP_DIR: pulmtln + TULIP_TOP_DIR: tulip MFEM_TOP_DIR: mfem @@ -32,10 +32,10 @@ jobs: with: access_token: ${{ github.token }} - - name: checkout PULMTLN + - name: checkout TULIP uses: actions/checkout@v4 with: - path: ${{ env.PULMTLN_TOP_DIR }} + path: ${{ env.TULIP_TOP_DIR }} - name: getcmake uses: lukka/get-cmake@latest @@ -44,7 +44,7 @@ jobs: uses: lukka/run-vcpkg@v11 with: vcpkgGitCommitId: 120deac3062162151622ca4860575a33844ba10b - vcpkgJsonGlob: 'pulmtln/vcpkg.json' + vcpkgJsonGlob: 'tulip/vcpkg.json' - name: cache MFEM uses: actions/cache@v3 @@ -79,29 +79,29 @@ jobs: # - name: Setup tmate session # uses: mxschmitt/action-tmate@v3 - - name: Configuring PULMTLN + - name: Configuring TULIP env: MFEM_PACKAGE: ${{ github.workspace }}/${{env.MFEM_TOP_DIR}}/build run: | - cmake --preset "msbuild-vcpkg" -S pulmtln -B pulmtln/build + cmake --preset "msbuild-vcpkg" -S tulip -B tulip/build - - name: Building PULMTLN + - name: Building TULIP run: | - cmake --build pulmtln/build/ --config Release + cmake --build tulip/build/ --config Release - # - name: Configuring and building PULMTLN + # - name: Configuring and building TULIP # uses: lukka/run-cmake@v10 # id: runcmake # with: - # cmakeListsTxtPath: '${{ github.workspace }}/pulmtln/CMakeLists.txt' + # cmakeListsTxtPath: '${{ github.workspace }}/tulip/CMakeLists.txt' # configurePreset: 'msbuild-vcpkg' # configurePresetAdditionalArgs: '[`-DCMAKE_PREFIX_PATH=../mfem`]' # buildPreset: 'msbuild-vcpkg' # buildPresetAdditionalArgs: '[`--config Release`]' - - name: test PULMTLN - run: cd pulmtln && build/bin/Release/pulmtln_tests.exe + - name: test TULIP + run: cd tulip && build/bin/Release/tulip_tests.exe - name: Get current date id: date @@ -110,11 +110,11 @@ jobs: - name: Create dist folder shell: bash run: | - ${{ env.PULMTLN_TOP_DIR }}/.github/workflows/create-dist.bat + ${{ env.TULIP_TOP_DIR }}/.github/workflows/create-dist.bat - name: Create .tar file run: | - cd pulmtln && tar -czvf tulip-windows.tar.gz dist/* + cd tulip && tar -czvf tulip-windows.tar.gz dist/* - name: Generating release @@ -125,4 +125,4 @@ jobs: prerelease: false title: "${{ steps.date.outputs.date }} Windows TULIP" files: | - pulmtln/tulip-windows.tar.gz + tulip/tulip-windows.tar.gz diff --git a/.github/workflows/windows-builds-and-tests.yml b/.github/workflows/windows-builds-and-tests.yml index 588882e..80774fe 100644 --- a/.github/workflows/windows-builds-and-tests.yml +++ b/.github/workflows/windows-builds-and-tests.yml @@ -1,4 +1,4 @@ -name: "Windows | Build and tests" +name: "Windows | Tulip build and tests" permissions: actions: write @@ -6,7 +6,7 @@ permissions: on: push: branches: - - master + - main - dev pull_request: branches: @@ -15,7 +15,7 @@ on: workflow_dispatch: env: - PULMTLN_TOP_DIR: pulmtln + TULIP_TOP_DIR: tulip MFEM_TOP_DIR: mfem jobs: @@ -35,10 +35,10 @@ jobs: with: access_token: ${{ github.token }} - - name: checkout PULMTLN + - name: checkout TULIP uses: actions/checkout@v3 with: - path: ${{ env.PULMTLN_TOP_DIR }} + path: ${{ env.TULIP_TOP_DIR }} ssh-key: ${{secrets.PULMTLN_SSH_KEY}} - name: getcmake @@ -47,8 +47,8 @@ jobs: - name: Setup vcpkg (it does not install any package yet) uses: lukka/run-vcpkg@v11 with: - vcpkgGitCommitId: 120deac3062162151622ca4860575a33844ba10b - vcpkgJsonGlob: 'pulmtln/vcpkg.json' + vcpkgGitCommitId: eed289f6e06a5e7a5c9e6a729671b0a56af7dd69 + vcpkgJsonGlob: 'tulip/vcpkg.json' - name: cache MFEM uses: actions/cache@v3 @@ -64,7 +64,7 @@ jobs: repository: opensemba/mfem path: ${{ env.MFEM_TOP_DIR }} - - name: build MFEM + - name: Build MFEM if: steps.mfem-cache.outputs.cache-hit != 'true' uses: mfem/github-actions/build-mfem@v2.4 env: @@ -80,28 +80,17 @@ jobs: metis-dir: ${{ env.METIS_TOP_DIR }} mfem-dir: ${{ env.MFEM_TOP_DIR }} - - name: Configuring PULMTLN + - name: Configure TULIP env: MFEM_PACKAGE: ${{ github.workspace }}/${{env.MFEM_TOP_DIR}}/build run: | - cmake --preset "msbuild-vcpkg" -S pulmtln -B pulmtln/build + cmake --preset "msbuild-vcpkg" -S tulip -B tulip/build - - name: Building PULMTLN + - name: Build TULIP run: | - cmake --build pulmtln/build/ --config Release - - # - name: Configuring and building PULMTLN - # uses: lukka/run-cmake@v10 - # id: runcmake - - # with: - # cmakeListsTxtPath: '${{ github.workspace }}/pulmtln/CMakeLists.txt' - # configurePreset: 'msbuild-vcpkg' - # configurePresetAdditionalArgs: '[`-DCMAKE_PREFIX_PATH=../mfem`]' - # buildPreset: 'msbuild-vcpkg' - # buildPresetAdditionalArgs: '[`--config Release`]' - - - name: test PULMTLN - run: cd pulmtln && build/bin/Release/pulmtln_tests.exe - + cmake --build tulip/build/ --config Release + + - name: Test TULIP + run: | + ctest --test-dir ${{ env.TULIP_TOP_DIR }}/build -C Release --output-on-failure \ No newline at end of file diff --git a/.gitignore b/.gitignore index efee6b1..ca16725 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ .vs/ out/ -build/ +build*/ builds/ ParaView/ tmp_cases/ @@ -11,8 +11,6 @@ CMakeSettings.json .vscode/c_cpp_properties.json -/*.msh - *.csv *.gf mesh.mesh @@ -61,7 +59,7 @@ __pycache__/ /CMakeUserPresets.json -/to_from_JSONFile_test.pulmtln.out.json +/to_from_JSONFile_test.tulip.out.json /Results /mfem-build /testData/lansink2024_single_wire/lansink2024_single_wire.areas.json @@ -69,3 +67,19 @@ __pycache__/ /testData/lansink2024/inCellPotentials.out.json /XMLGoogleTestResults.xml *.inCellPotentials.out.json +*.FCStd1 +*.pyc +.vscode/ +.pytest_cache/ +.idea/ +tmpFolder/ +venv/ +gmshDoc/ +vcpkg_installed/ + +*.msh +*.vtk +*.areas.json +build +Testing/Temporary/CTestCostData.txt +Testing/Temporary/LastTest.log diff --git a/.gitmodules b/.gitmodules index 7de3c4b..75cd985 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,7 +1,4 @@ [submodule "external/mfem-geg"] path = external/mfem-geg url = https://github.com/OpenSEMBA/mfem.git - ignore = dirty -[submodule "external/step2gmsh"] - path = external/step2gmsh - url = https://github.com/OpenSEMBA/step2gmsh.git + ignore = dirty \ No newline at end of file diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..62b7839 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,96 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "adapter_tests (gdb)", + "type": "cppdbg", + "request": "launch", + "program": "${workspaceFolder}/build-dbg/bin/adapter_tests", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "externalConsole": false, + "MIMode": "gdb", + "visualizerFile": [ + "${workspaceFolder}/resources/Eigen.natvis", + "${workspaceFolder}/resources/mfem.natvis", + "${workspaceFolder}/resources/nlohmann_json.natvis" + ], + "additionalSOLibSearchPath": "", + "showDisplayString": true, + "setupCommands": [ + { + "description": "Enable pretty-printing for gdb", + "text": "-enable-pretty-printing", + "ignoreFailures": true + }, + { + "description": "Set Disassembly Flavor to Intel", + "text": "-gdb-set disassembly-flavor intel", + "ignoreFailures": true + } + ] + }, + { + "name": "pulmtln_tests (gdb)", + "type": "cppdbg", + "request": "launch", + "program": "${workspaceFolder}/build-dbg/bin/pulmtln_tests", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "externalConsole": false, + "MIMode": "gdb", + "visualizerFile": [ + "${workspaceFolder}/resources/Eigen.natvis", + "${workspaceFolder}/resources/mfem.natvis", + "${workspaceFolder}/resources/nlohmann_json.natvis" + ], + "showDisplayString": true, + "setupCommands": [ + { + "description": "Enable pretty-printing for gdb", + "text": "-enable-pretty-printing", + "ignoreFailures": true + }, + { + "description": "Set Disassembly Flavor to Intel", + "text": "-gdb-set disassembly-flavor intel", + "ignoreFailures": true + } + ] + }, + { + "name": "pulmtln (gdb)", + "type": "cppdbg", + "request": "launch", + "program": "${workspaceFolder}/build-dbg/bin/pulmtln", + "args": [], + "stopAtEntry": false, + "cwd": "${workspaceFolder}", + "environment": [], + "externalConsole": false, + "MIMode": "gdb", + "visualizerFile": [ + "${workspaceFolder}/resources/Eigen.natvis", + "${workspaceFolder}/resources/mfem.natvis", + "${workspaceFolder}/resources/nlohmann_json.natvis" + ], + "showDisplayString": true, + "setupCommands": [ + { + "description": "Enable pretty-printing for gdb", + "text": "-enable-pretty-printing", + "ignoreFailures": true + }, + { + "description": "Set Disassembly Flavor to Intel", + "text": "-gdb-set disassembly-flavor intel", + "ignoreFailures": true + } + ] + } + ] +} \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index 1232f1b..ba3b968 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) -set(PROJECT_NAME "pulmtln") +set(PROJECT_NAME "tulip") project(${PROJECT_NAME}) @@ -26,11 +26,9 @@ else () include_directories(${MFEM_INCLUDE_DIRS}) endif() -include_directories(src/) - -add_subdirectory(src) +add_subdirectory(src/adapter) +add_subdirectory(src/driver) enable_testing() -add_subdirectory(test/) - -add_test(${PROJECT_NAME} ${CMAKE_BINARY_DIR}/bin/${PROJECT_NAME}_tests) +add_subdirectory(test/adapter) +add_subdirectory(test/driver) diff --git a/CMakePresets.json b/CMakePresets.json index 5b079a5..e30fe15 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -15,6 +15,10 @@ "type": "FILEPATH", "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" }, + "VCPKG_OVERLAY_TRIPLETS": { + "type": "PATH", + "value": "${sourceDir}/triplets" + }, "CMAKE_PREFIX_PATH": { "type": "FILEPATH", "value": "$env{MFEM_PACKAGE}" @@ -40,7 +44,7 @@ "cacheVariables": { "TULIP_USE_MFEM_AS_SUBDIRECTORY": true, "MFEM_ENABLE_TESTING": false, - "MFEM_USE_OPENMP": true + "MFEM_USE_OPENMP": false } } ], diff --git a/LICENSE b/LICENSE index be971dd..d159169 100644 --- a/LICENSE +++ b/LICENSE @@ -1,29 +1,339 @@ -BSD 3-Clause License - -Copyright (c) 2021, OpenSEMBA -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -1. Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -2. Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -3. Neither the name of the copyright holder nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/README.md b/README.md index 05642e4..b130a5f 100644 --- a/README.md +++ b/README.md @@ -3,42 +3,24 @@ [![Ubuntu | Build and tests](https://github.com/OpenSEMBA/tulip/actions/workflows/ubuntu-builds-and-tests.yml/badge.svg)](https://github.com/OpenSEMBA/tulip/actions/workflows/ubuntu-builds-and-tests.yml) -**Tulip** (**T**ransmission line **u**nit **l**ength conductors and **i**n-cell **p**arameters) is a solver to obtain the _per unit length_ (PUL) $C$ and $L$ matrices which characterize electromagnetic propagation within a multiconductor tranmission line (MTL). Tulip is based on finite element methods to solver an electroestatic problem for each conductor. Some of its features are: +**Tulip** (**T**ransmission line per **u**nit **l**ength and **i**n-cell **p**arameters) is a solver to obtain the _per unit length_ (PUL) $C$ and $L$ matrices which characterize electromagnetic propagation within a multiconductor tranmission line (MTL). Tulip is based on finite element methods to solver an electroestatic problem for each conductor. Some of its features are: - Calculation of p.u.l $C$ and $L$ matrices. - Third order isoparametric elements. - Support for dielectric materials. - Open boundary conditions. -- Works on closed, open, or semiopen MTL. +- Works on closed and open MTLs. - Multilevel domain decomposition. - Uses a modified [MFEM](https://mfem.org/) solver engine available [here](https://github.com/OpenSEMBA/mfem). - Result visualization with [Paraview](https://www.paraview.org/). - Start from `.step` CAD files using the [step2gmsh](https://github.com/OpenSEMBA/step2gmsh) workflow. -## Compiling +## Compile and testing Compilation needs vcpkg with the packages stated in the ```vcpkg.json``` manifest. Additionally needs: - mfem (with the version pointed by the external/mfem-geg submodule) -### Compiling in windows (cmake) - -#### Manually (Windows/Linux) -Compile mfem in external/mfem-geg - -```shell - cmake -S external/mfem-geg -B mfem-build/rls -DCMAKE_INSTALL_PREFIX= - cmake --build mfem-build/rls --target install --config Release -``` - -Launch cmake in root. - -```shell - cmake -S . -B pulmtln-build/rls -DMFEM_DIR= -DCMAKE_TOOLCHAIN_FILE= - cmake --build pulmtln-build/rls --config Release -``` - -#### Compilation using presets -Configure and build presets are available. To configure +Configure and build presets are available. For instance, to configure in windows you can use ```shell cmake @@ -48,74 +30,28 @@ Configure and build presets are available. To configure -B ``` -which requires the following environment variables to be set (using ```export```) - -```shell - VCPKG_ROOT= - MFEM_PACKAGE= -``` - -Using ```CMAKE_FIND_USE_PACKAGE_REGISTRY=FALSE``` warranties that no previously used package is used for compilation if any of the needed paths is not found (a questionable Windows _feature_). - -### Testing - Once compiled, test cases can be launched from the project root folder, with ```shell - /bin/Release/pulmtln_tests.exe + ctest --test-dir ./ --output-on-failure ``` Most cases will store results in the `Results` folder. Please check the codes in `test` folder for information on the validation cases and their expected tolerances. ## Usage example -Call `pulmtln` from command line as, +Call `tulip` from command line as, ```shell - pulmtln.exe -i + tulip.exe -i ``` -The input file must be describe a JSON object which describes the problem. An example for the `five_wires` case (available [here](testData/five_wires)) follows, - -```json - { - "analysis": { - "order": 3, - "exportParaViewSolution": true, - "exportFolder": "Results/five_wires/" - }, - "model": { - "materials": { - "Conductor_0": {"type": "PEC", "tag": 1 }, - "Conductor_1": {"type": "PEC", "tag": 2 }, - "Conductor_2": {"type": "PEC", "tag": 3 }, - "Conductor_3": {"type": "PEC", "tag": 4 }, - "Conductor_4": {"type": "PEC", "tag": 5 }, - "Conductor_5": {"type": "PEC", "tag": 6 }, - "Dielectric_1": {"type": "Dielectric", "eps_r": 2.0, "tag": 8}, - "Dielectric_2": {"type": "Dielectric", "eps_r": 2.0, "tag": 9}, - "Dielectric_3": {"type": "Dielectric", "eps_r": 2.0, "tag": 10}, - "Dielectric_4": {"type": "Dielectric", "eps_r": 2.0, "tag": 11}, - "Dielectric_5": {"type": "Dielectric", "eps_r": 2.0, "tag": 12} - }, - "gmshFile": "five_wires.msh" - } - } -``` - -This object must contain the following entries: +The input file format is [described here](docs/tulip_data_format.md). - + An `analysis` JSON object specifies options for the solver such as the `order` of the FEM basis and other exporting options. - + A `model` JSON object which specifies - + the mesh through `gmshFile`. In this case the `five_wires.msh` file has been generated from a `.step` file using the [step2gmsh](https://github.com/OpenSEMBA/step2gmsh) program. - + the `materials` object which identifies materials and boundaries assigned to each layer. The location in the mesh is done through its `tag` number which corresponds to a `physical model` in the mesh. - -By default, `pulmtln` will generate a file called `matrices.pulmtln.out.json` which contains the $C$ and $L$ p.u.l parameters of the MTL. Each row and column corresponds to the `N` integer in `Conductor_N`. `Conductor_0` is used as reference. +By default, `tulip` will generate a file called `matrices.tulip.out.json` which contains the $C$ and $L$ p.u.l parameters of the MTL. Each row and column corresponds to the `N` integer in `Conductor_N`. `Conductor_0` is used as reference. These results have been cross-compared [here][test/DriverTest.cpp] to match with [Ansys Maxwell](https://www.ansys.com/products/electronics/ansys-maxwell). Comparison with [SACAMOS](https://www.sacamos.org/) does not produce satisfactory because of the different underlying analytical assumptions that are made. - -If `ExportParaviewSolution` is defined as `true` in `analysis`, `pulmtln` will also export visualization results for each simulation performed. This means two results for each conductor different from zero: with and without accounting for dielectrics, used to compute the p.u.l $C$ and $L$ matrices, respectively. Below there is an example of the electric fields for the `five_wires` case visualized in Paraview with (above) and without (below) considering dielectrics. @@ -123,7 +59,7 @@ Below there is an example of the electric fields for the `five_wires` case visua ![Electric field for the five wires case without dielectrics](docs/fig/five_wires_conductor_2_without_dielectrics_E_field.png) ## License and copyright -``` pulmtln ``` is licensed under [BSD 3-Clause](LICENSE). Its copyright belongs to the University of Granada. +``` tulip ``` is licensed under [GPL v2](LICENSE). Its copyright belongs to the University of Granada. ## Acknowledgements This project is funded by the following grants: diff --git a/docs/Doc.md b/docs/Doc.md deleted file mode 100644 index 4e8057d..0000000 --- a/docs/Doc.md +++ /dev/null @@ -1,49 +0,0 @@ -# pulmtln -[![Tests](https://github.com/lmdiazangulo/pulmtln/actions/workflows/builds-and-tests.yml/badge.svg)](https://github.com/lmdiazangulo/pulmtln/actions/workflows/builds-and-tests.yml) - -Per Unit Length Multiconductor Transmission Line Network solver. Features: -- $C$ and $L$ matrix extraction. -- Third order isoparametric elements. -- Support for dielectric materials. -- Open boundary problems. -- Domain decomposition. - - -## License -- ``` pulmtln ``` has the same license as MFEM. - -## Compiling -Compilation needs vcpkg with the packages stated in the ```vcpkg.json``` manifest. - -Additionally needs: -- mfem (with the version pointed by the external/mfem-geg submodule) - -### Compiling in windows (cmake) - -#### Manually (Windows/Linux) -Compile mfem in external/mfem-geg -``` - cmake -S external/mfem-geg -B mfem-build/rls - cmake --build mfem-build/rls --config Release -``` -Launch cmake in root. -``` - cmake -S . -B pulmtln-build/rls -Dmfem_DIR=mfem-build/rls - cmake --build pulmtln-build/rls --config Release -``` - -#### Using presets -Configure and build presets are available. To configure -``` - cmake - -DCMAKE_FIND_USE_PACKAGE_REGISTRY=FALSE - --preset "msbuild-vcpkg" - -S - -B -``` -which requires the following environment variables to be set (using ```export```) -``` - VCPKG_ROOT= - MFEM_PACKAGE= -``` -Using ```CMAKE_FIND_USE_PACKAGE_REGISTRY=FALSE``` warranties that no previously used package is used for compilation if any of the needed paths is not found (a questionable Windows _feature_). diff --git a/docs/fig/five_wires_freecad.png b/docs/fig/five_wires_freecad.png new file mode 100644 index 0000000..608aca8 Binary files /dev/null and b/docs/fig/five_wires_freecad.png differ diff --git a/docs/fig/five_wires_gmsh.png b/docs/fig/five_wires_gmsh.png new file mode 100644 index 0000000..fd6ff34 Binary files /dev/null and b/docs/fig/five_wires_gmsh.png differ diff --git a/docs/tulip_data_format.md b/docs/tulip_data_format.md new file mode 100644 index 0000000..4340e73 --- /dev/null +++ b/docs/tulip_data_format.md @@ -0,0 +1,77 @@ +# Tulip input data format + +- [Tulip input data format](#tulip-input-data-format) + - [`[analysis]`.](#analysis) + - [adapter options](#adapter-options) + - [driver options](#driver-options) + - [``](#materials) + - [`conductor`](#conductor) + - [`shield`](#shield) + - [`dielectric`](#dielectric) + - [`open`](#open) + - [``](#model) + +Tulip receives a JSON object as an input with the entries described below. Square brackets indicate that the entry is optional and a default value will be assumed, angle brackets indicate that the entry is mandatory. + +Unless specified otherwise all units are assumed to be in SI-MKS. + +## `[analysis]`. +This object contains options to control the adapter and driver behaviors. +Adapter is in + +### adapter options + +### driver options +- `[exportParaviewSolution]` can be `true` or `false`. Exports visualization results for each simulation performed. +- `[order]`{3}; + bool printIterations{ false }; + + +## `` +These materials are associated with `model` `layers` to define regions with different material properties. +They are defined by an array of JSON objects with: +- `` an integer identifier with a unique number. +- `` a string with a human readable name. +- `` a string with `conductor`, `shield`, `dielectric`, or `open`. Depending on their type they may need additional entries, as described below. + +### `conductor` +A conductor material can contain either `[resistancePerMeter]` or `[conductivity]`, but not both. If `conductivity` is defined, it will be used to compute a resistance per meter for the conductor. +If none is specified, the conductor is considered to be a perfect electric conductor. + +Conductors associated with layers cannot intersect any other layer which is also associated with a conductor. They can however intersect layers associated with `shield`, `dielectric`, or `open`, taking precedence over them. + +### `shield` +A shield is a special kind of conductor which defines a transfer impedance model, specified with: +- `[resistancePerMeter]` defined by a real representing transfer impedance resistance. Defaults to `0.0` +- `[inductancePerMeter]` defined by a real representing transfer impedance inductance. Defaults to `0.0`. +- `[direction]` which can be `both`, `inwards`, or `outwards`. Indicating the type of coupling considered. Defaults to `both` meaning that fields can couple from the exterior to interior and the other way round. + +Shield layers can never intersect any other `shield` layer. They can be used in two ways: ++ To represent a _closed problem_, or the interior of a shielded domain. In that case: + - Shields can intersect conductor or dielectric layers. + - The problem cannot contain any open layer. + - The shield is assumed to be the ground conductor. + - There can only be one shield. ++ In _open problems_ they act as the boundary between an internal and external domain. In that case: + - They follow the same rules as conductors about intersections + - Must have a non-null area. + - The shield is assumed to be the ground of the domain which it encloses and is one conductor more for the domain to which it belongs. + +### `dielectric` +A dielectric is defined with a `[relativePermittivity]` which defaults to `1.0`. If two dielectrics are intersecting, the one with the highest permittivity takes precedence. + +### `open` +An `open` material serves to specify the computational boundary of the problem. It must intersect every other material layer. If no open boundary is specified for an open problem, one is computed automatically, together with _inner_ and _outer_ regions used to extract the unshielded multiwire coefficients. + + +## `` +This object can contain the following entries: ++ `[stepFilename]` defaults to the ```CASE_NAME.step``` where CASE_NAME is the basename of the input file (wt). ++ `` which is an array which associates the layers present in the `.step` file with the different `materials`. Each layer is specified by: + - `` which must match exactly the name of the corresponding layer within the `.step` file. It must be unique. + - `` which is an integer unique identifier which will be used to order the results for the calculated PUL matrices. + - `` which must match an `id` from a material in the list of `materials` + + + + \ No newline at end of file diff --git a/external/step2gmsh b/external/step2gmsh deleted file mode 160000 index 38be140..0000000 --- a/external/step2gmsh +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 38be140d489bacb1e911a7a66dcd30e22134ecd8 diff --git a/matrices.pulmtln.out.json b/matrices.pulmtln.out.json deleted file mode 100644 index d9899cf..0000000 --- a/matrices.pulmtln.out.json +++ /dev/null @@ -1 +0,0 @@ -{"C":[[1.8746501451383102e-11,-1.4191259748331942e-12],[-1.4191259748331942e-12,1.8760352287360533e-11]],"L":[[5.969424307186195e-07,4.5155682363363776e-08],[4.5155682363363776e-08,5.965017059620048e-07]]} \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml index d21b443..f073c45 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,4 +1,4 @@ -site_name: OpenSemba/pulmtln +site_name: opensemba/tulip theme: readthedocs nav: diff --git a/scripts/install-packages.sh b/scripts/install-packages.sh new file mode 100644 index 0000000..a5e3a90 --- /dev/null +++ b/scripts/install-packages.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +# Install system packages required to bootstrap vcpkg and build all dependencies. +set -euo pipefail + +# -- vcpkg bootstrap requirements -- +VCPKG_PACKAGES=( + curl + zip + unzip + tar +) + +# -- Build-time requirements for vcpkg ports (gmsh, opencascade, etc.) -- +PORT_PACKAGES=( + autoconf + autoconf-archive + automake + libtool +) + +# -- X11/display libraries required by OpenCASCADE (gmsh[occ]) -- +OCC_PACKAGES=( + libx11-dev + libxext-dev + libxi-dev + libxmu-dev + libxt-dev + libfreetype-dev + libfontconfig1-dev + mesa-common-dev +) + +ALL_PACKAGES=("${VCPKG_PACKAGES[@]}" "${PORT_PACKAGES[@]}" "${OCC_PACKAGES[@]}") + +echo "Updating package lists..." +sudo apt-get update -qq + +echo "Installing packages: ${ALL_PACKAGES[*]}" +sudo apt-get install -y "${ALL_PACKAGES[@]}" + +echo "All packages installed successfully." diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 963fef8..37551a4 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,31 +1,10 @@ cmake_minimum_required(VERSION 3.21) -set(LIBRARY_NAME "pulmtln-core") -message(STATUS "Creating build system for ${LIBRARY_NAME}") - -find_package(nlohmann_json CONFIG REQUIRED) - -find_package(Boost REQUIRED graph program_options) -include_directories(${Boost_INCLUDE_DIRS}) - -add_library(${LIBRARY_NAME} STATIC - "FES.cpp" - "ElectrostaticSolver.cpp" - "Driver.cpp" - "Parser.cpp" - "Model.cpp" - "Materials.cpp" - "Results.cpp" - "DirectedGraph.cpp" - "Domain.cpp") - -target_link_libraries(${LIBRARY_NAME} mfem nlohmann_json Boost::graph) - -set(EXECUTABLE_NAME "pulmtln") +set(EXECUTABLE_NAME "tulip") message(STATUS "Creating build system for ${EXECUTABLE_NAME}") -add_executable(${EXECUTABLE_NAME} - "pulmtln.cpp" -) +add_executable(${EXECUTABLE_NAME} + "tulip.cpp" +) -target_link_libraries(${EXECUTABLE_NAME} ${LIBRARY_NAME} Boost::program_options) \ No newline at end of file +target_link_libraries(${EXECUTABLE_NAME} PRIVATE ${LIBRARY_NAME} Boost::program_options) \ No newline at end of file diff --git a/src/adapter/AreaExporterService.cpp b/src/adapter/AreaExporterService.cpp new file mode 100644 index 0000000..9a6d2cf --- /dev/null +++ b/src/adapter/AreaExporterService.cpp @@ -0,0 +1,78 @@ +#include "AreaExporterService.h" + +#include +#include +#include + +#include + +namespace step2gmsh { + +AreaExporterService::AreaExporterService() { + computedAreas["geometries"] = nlohmann::json::array(); +} + +void AreaExporterService::addComputedArea(const std::string& geometry, + const std::string& label, + double area) +{ + double rounded = std::round(area * 1e6) / 1e6; + computedAreas["geometries"].push_back({ + {"geometry", geometry}, + {"label", label}, + {"area", rounded} + }); +} + +void AreaExporterService::addPhysicalModelForConductors( + const std::map& mappedElements) +{ + gmsh::vectorpair physicalGroups; + gmsh::model::getPhysicalGroups(physicalGroups, 1); + + gmsh::vectorpair allSurfaces; + gmsh::model::getEntities(allSurfaces, 2); + + for (const auto& [pgDim, pgTag] : physicalGroups) { + std::string geometryName; + gmsh::model::getPhysicalName(pgDim, pgTag, geometryName); + + if (geometryName.rfind("Conductor_", 0) != 0) continue; + + std::vector entityTags; + gmsh::model::getEntitiesForPhysicalGroup(pgDim, pgTag, entityTags); + std::set entityTagSet(entityTags.begin(), entityTags.end()); + + // Find the label associated with this geometry name + std::string label; + for (const auto& [key, geom] : mappedElements) { + if (geom == geometryName) { + label = key; + break; + } + } + + // Find the surface whose boundary matches the curve tags + for (const auto& surface : allSurfaces) { + gmsh::vectorpair boundary; + gmsh::model::getBoundary({surface}, boundary, true, false, false); + std::set boundaryTags; + for (const auto& [dim, tag] : boundary) { + boundaryTags.insert(tag); + } + if (entityTagSet == boundaryTags) { + double area = 0.0; + gmsh::model::occ::getMass(2, surface.second, area); + addComputedArea(geometryName, label, area); + break; + } + } + } +} + +void AreaExporterService::exportToJson(const std::string& exportFileName) const { + std::ofstream f(exportFileName + ".areas.json"); + f << computedAreas.dump(3); +} + +} // namespace step2gmsh diff --git a/src/adapter/AreaExporterService.h b/src/adapter/AreaExporterService.h new file mode 100644 index 0000000..e29d025 --- /dev/null +++ b/src/adapter/AreaExporterService.h @@ -0,0 +1,27 @@ +#pragma once + +#include +#include +#include + +#include + +namespace step2gmsh { + +class AreaExporterService { +public: + nlohmann::json computedAreas; + + AreaExporterService(); + + void addComputedArea(const std::string& geometry, + const std::string& label, + double area); + + void addPhysicalModelForConductors( + const std::map& mappedElements); + + void exportToJson(const std::string& exportFileName) const; +}; + +} // namespace step2gmsh diff --git a/src/adapter/BoundingBox.cpp b/src/adapter/BoundingBox.cpp new file mode 100644 index 0000000..2eab5c9 --- /dev/null +++ b/src/adapter/BoundingBox.cpp @@ -0,0 +1,76 @@ +#include "BoundingBox.h" + +#include +#include +#include + +#include + +namespace step2gmsh { + +BoundingBox::BoundingBox(double xMin_, double yMin_, double zMin_, + double xMax_, double yMax_, double zMax_) + : xMin(xMin_), yMin(yMin_), zMin(zMin_), + xMax(xMax_), yMax(yMax_), zMax(zMax_) {} + +BoundingBox::BoundingBox(const std::array& coords) + : xMin(coords[0]), yMin(coords[1]), zMin(coords[2]), + xMax(coords[3]), yMax(coords[4]), zMax(coords[5]) {} + +std::array BoundingBox::getOrigin() const { + return {xMin, yMin, zMin}; +} + +std::array BoundingBox::getCenter() const { + return { + (xMax + xMin) / 2.0, + (yMax + yMin) / 2.0, + (zMax + zMin) / 2.0 + }; +} + +double BoundingBox::getDiagonal() const { + double dx = xMax - xMin; + double dy = yMax - yMin; + double dz = zMax - zMin; + return std::sqrt(dx * dx + dy * dy + dz * dz); +} + +std::array BoundingBox::getLengths() const { + return {xMax - xMin, yMax - yMin, zMax - zMin}; +} + +BoundingBox BoundingBox::getBoundingBox(int dim, int tag) { + double xmin, ymin, zmin, xmax, ymax, zmax; + gmsh::model::occ::getBoundingBox(dim, tag, xmin, ymin, zmin, xmax, ymax, zmax); + return BoundingBox(xmin, ymin, zmin, xmax, ymax, zmax); +} + +BoundingBox BoundingBox::getBoundingBoxFromGroup( + const std::vector>& elements) +{ + if (elements.empty()) { + return BoundingBox(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + } + + double xMinAll, yMinAll, zMinAll, xMaxAll, yMaxAll, zMaxAll; + { + auto bb = getBoundingBox(elements[0].first, elements[0].second); + xMinAll = bb.xMin; yMinAll = bb.yMin; zMinAll = bb.zMin; + xMaxAll = bb.xMax; yMaxAll = bb.yMax; zMaxAll = bb.zMax; + } + + for (std::size_t i = 1; i < elements.size(); ++i) { + auto bb = getBoundingBox(elements[i].first, elements[i].second); + xMinAll = std::min(xMinAll, bb.xMin); + yMinAll = std::min(yMinAll, bb.yMin); + zMinAll = std::min(zMinAll, bb.zMin); + xMaxAll = std::max(xMaxAll, bb.xMax); + yMaxAll = std::max(yMaxAll, bb.yMax); + zMaxAll = std::max(zMaxAll, bb.zMax); + } + + return BoundingBox(xMinAll, yMinAll, zMinAll, xMaxAll, yMaxAll, zMaxAll); +} + +} // namespace step2gmsh diff --git a/src/adapter/BoundingBox.h b/src/adapter/BoundingBox.h new file mode 100644 index 0000000..0bf2fef --- /dev/null +++ b/src/adapter/BoundingBox.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include + +namespace step2gmsh { + +class BoundingBox { +public: + double xMin, yMin, zMin; + double xMax, yMax, zMax; + + BoundingBox(double xMin, double yMin, double zMin, + double xMax, double yMax, double zMax); + + explicit BoundingBox(const std::array& coords); + + std::array getOrigin() const; + std::array getCenter() const; + double getDiagonal() const; + std::array getLengths() const; + + static BoundingBox getBoundingBox(int dim, int tag); + static BoundingBox getBoundingBoxFromGroup( + const std::vector>& elements); +}; + +} // namespace step2gmsh diff --git a/src/adapter/CMakeLists.txt b/src/adapter/CMakeLists.txt new file mode 100644 index 0000000..420edae --- /dev/null +++ b/src/adapter/CMakeLists.txt @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.21) + +set(ADAPTER_LIB "tulip-adapter") +message(STATUS "Creating build system for ${ADAPTER_LIB}") + +find_package(gmsh CONFIG REQUIRED) +find_package(nlohmann_json CONFIG REQUIRED) + +add_library(${ADAPTER_LIB} STATIC + Graph.cpp + BoundingBox.cpp + ShapesClassification.cpp + AreaExporterService.cpp + Mesher.cpp +) + +target_include_directories(${ADAPTER_LIB} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries(${ADAPTER_LIB} PUBLIC + $,gmsh::shared,gmsh::lib> + nlohmann_json::nlohmann_json +) diff --git a/src/adapter/Graph.cpp b/src/adapter/Graph.cpp new file mode 100644 index 0000000..043a443 --- /dev/null +++ b/src/adapter/Graph.cpp @@ -0,0 +1,182 @@ +#include "Graph.h" + +#include +#include +#include +#include +#include +#include + +namespace step2gmsh { + +std::vector Graph::roots() const { + std::vector r; + for (const auto& node : nodes_) { + bool isChild = false; + for (const auto& edge : edges_) { + if (edge.second == node) { + isChild = true; + break; + } + } + if (!isChild) { + r.push_back(node); + } + } + return r; +} + +const std::vector& Graph::nodes() const { return nodes_; } +const std::vector& Graph::edges() const { return edges_; } + +void Graph::setNodes(std::vector nodes) { nodes_ = std::move(nodes); } +void Graph::setEdges(std::vector edges) { edges_ = std::move(edges); } + +void Graph::addNode(const Node& node) { + if (std::find(nodes_.begin(), nodes_.end(), node) == nodes_.end()) { + nodes_.push_back(node); + } +} + +void Graph::addEdge(const Node& source, const Node& dest) { + addNode(source); + addNode(dest); + Edge e{source, dest}; + if (std::find(edges_.begin(), edges_.end(), e) == edges_.end()) { + edges_.push_back(e); + } +} + +std::map> Graph::getConnections() const { + std::map> connections; + for (const auto& node : nodes_) { + connections[node] = {}; + } + for (const auto& edge : edges_) { + connections[edge.first].push_back(edge.second); + } + return connections; +} + +std::vector Graph::getParentNodes() const { + std::vector parents; + for (const auto& edge : edges_) { + parents.push_back(edge.first); + } + return parents; +} + +std::vector Graph::getChildNodes() const { + std::vector children; + for (const auto& edge : edges_) { + children.push_back(edge.second); + } + return children; +} + +void Graph::pruneToLongestPaths() { + auto connections = getConnections(); + auto childNodes = getChildNodes(); + + std::vector rootNodes; + for (const auto& node : nodes_) { + if (std::find(childNodes.begin(), childNodes.end(), node) == childNodes.end()) { + rootNodes.push_back(node); + } + } + + std::vector> allPaths; + std::function)> dfs = + [&](const Node& node, std::vector path) { + path.push_back(node); + auto it = connections.find(node); + if (it == connections.end() || it->second.empty()) { + allPaths.push_back(path); + return; + } + for (const auto& child : it->second) { + dfs(child, path); + } + }; + + for (const auto& root : rootNodes) { + dfs(root, {}); + } + + std::map> leafToPath; + for (const auto& path : allPaths) { + const Node& leaf = path.back(); + auto it = leafToPath.find(leaf); + if (it == leafToPath.end() || path.size() > it->second.size()) { + leafToPath[leaf] = path; + } + } + + std::set newNodes; + std::set newEdges; + for (const auto& [leaf, path] : leafToPath) { + for (const auto& n : path) { + newNodes.insert(n); + } + for (std::size_t i = 0; i + 1 < path.size(); ++i) { + newEdges.insert({path[i], path[i + 1]}); + } + } + + nodes_ = std::vector(newNodes.begin(), newNodes.end()); + edges_ = std::vector(newEdges.begin(), newEdges.end()); +} + +std::map> Graph::getAdjacencyTree() const { + std::map> tree; + for (const auto& root : roots()) { + tree[""].push_back(root); + } + for (const auto& edge : edges_) { + tree[edge.first].push_back(edge.second); + } + return tree; +} + +std::vector Graph::getNodesByLevels() const { + auto tree = getAdjacencyTree(); + std::queue> q; + q.push({"", 0}); + std::vector nodeList; + while (!q.empty()) { + auto [node, level] = q.front(); + q.pop(); + nodeList.push_back(node); + auto it = tree.find(node); + if (it != tree.end()) { + for (const auto& child : it->second) { + q.push({child, level + 1}); + } + } + } + // Remove the first element (empty-string sentinel root) + return std::vector(nodeList.begin() + 1, nodeList.end()); +} + +void Graph::reorderData() { + std::sort(edges_.begin(), edges_.end()); + std::sort(nodes_.begin(), nodes_.end()); +} + +std::string Graph::toString() const { + std::ostringstream oss; + oss << "Graph(Nodes: ["; + for (std::size_t i = 0; i < nodes_.size(); ++i) { + if (i > 0) oss << ", "; + oss << nodes_[i]; + } + oss << "],\n Edges: ["; + for (std::size_t i = 0; i < edges_.size(); ++i) { + if (i > 0) oss << ", "; + oss << "(" << edges_[i].first << ", " << edges_[i].second << ")"; + } + oss << "])"; + return oss.str(); +} + +} // namespace step2gmsh diff --git a/src/adapter/Graph.h b/src/adapter/Graph.h new file mode 100644 index 0000000..f0f53ae --- /dev/null +++ b/src/adapter/Graph.h @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +namespace step2gmsh { + +class Graph { +public: + using Node = std::string; + using Edge = std::pair; + + Graph() = default; + + std::vector roots() const; + + const std::vector& nodes() const; + const std::vector& edges() const; + + void setNodes(std::vector nodes); + void setEdges(std::vector edges); + + void addNode(const Node& node); + void addEdge(const Node& source, const Node& dest); + + std::map> getConnections() const; + std::vector getParentNodes() const; + std::vector getChildNodes() const; + + void pruneToLongestPaths(); + + std::map> getAdjacencyTree() const; + std::vector getNodesByLevels() const; + + void reorderData(); + + std::string toString() const; + +private: + std::vector nodes_; + std::vector edges_; +}; + +} // namespace step2gmsh diff --git a/src/adapter/Mesher.cpp b/src/adapter/Mesher.cpp new file mode 100644 index 0000000..0baaeb0 --- /dev/null +++ b/src/adapter/Mesher.cpp @@ -0,0 +1,201 @@ +#include "Mesher.h" + +#include +#include +#include +#include + +#include + +#include "AreaExporterService.h" + +namespace step2gmsh { + +const std::map Mesher::DEFAULT_MESHING_OPTIONS = { + {"Mesh.MshFileVersion", 2.2}, + {"Mesh.MeshSizeFromCurvature", 50.0}, + {"Mesh.ElementOrder", 3.0}, + {"Mesh.ScalingFactor", 1e-3}, + {"Mesh.SurfaceFaces", 1.0}, + {"Mesh.MeshSizeMax", 40.0} +}; + +std::pair, + std::vector>> +Mesher::findDuplicateNodes() +{ + std::vector nodeTags; + std::vector nodeCoords, nodeParams; + gmsh::model::mesh::getNodes(nodeTags, nodeCoords, nodeParams); + + std::map, std::vector> groups; + for (std::size_t idx = 0; idx < nodeTags.size(); ++idx) { + auto key = std::make_tuple( + nodeCoords[3 * idx], + nodeCoords[3 * idx + 1], + nodeCoords[3 * idx + 2]); + groups[key].push_back(nodeTags[idx]); + } + + // Keep only groups with duplicates + for (auto it = groups.begin(); it != groups.end();) { + if (it->second.size() <= 1) it = groups.erase(it); + else ++it; + } + + return {!groups.empty(), groups}; +} + +void Mesher::runFromInput(const std::string& inputFile, bool runGui) { + auto stem = std::filesystem::path(inputFile).stem().string(); + + gmsh::initialize(); + auto mappedElements = meshFromStep(inputFile, stem, &DEFAULT_MESHING_OPTIONS); + exportGeometryAreas(stem, mappedElements); + gmsh::write(stem + ".msh"); + gmsh::write(stem + ".vtk"); + if (runGui) { + gmsh::fltk::run(); + } + gmsh::finalize(); +} + +std::map Mesher::meshFromStep( + const std::string& inputFile, + const std::string& caseName, + const std::map* meshingOptions) +{ + if (!meshingOptions) { + meshingOptions = &DEFAULT_MESHING_OPTIONS; + } + + gmsh::model::add(caseName); + + EntityList shapes; + gmsh::model::occ::importShapes(inputFile, shapes, false); + + auto jsonFile = std::filesystem::path(inputFile).replace_extension(".json").string(); + ShapesClassification allShapes(shapes, jsonFile); + + // Geometry manipulation + allShapes.ensureDielectricsDoNotOverlap(); + allShapes.removeConductorsFromDielectrics(); + allShapes.vacuum = allShapes.buildVacuumDomain(); + allShapes.pecs = extractBoundaries(allShapes.pecs); + + // Mapping + auto mappedComponents = allShapes.getMappedComponents(); + buildPhysicalModel(allShapes, mappedComponents); + + // Meshing options + for (const auto& [opt, val] : *meshingOptions) { + gmsh::option::setNumber(opt, val); + } + + gmsh::model::mesh::generate(2); + gmsh::model::mesh::removeDuplicateNodes(); + + auto [hasDups, _] = findDuplicateNodes(); + assert(!hasDups); + + return mappedComponents; +} + +void Mesher::exportGeometryAreas( + const std::string& caseName, + const std::map& mappedElements) +{ + AreaExporterService exporter; + exporter.addPhysicalModelForConductors(mappedElements); + exporter.exportToJson(caseName); +} + +void Mesher::buildPhysicalModel( + ShapesClassification& shapes, + const std::map& labelMapping) +{ + EntityMap components; + for (const auto& [k, v] : shapes.pecs) components[k] = v; + for (const auto& [k, v] : shapes.dielectrics) components[k] = v; + for (const auto& [k, v] : shapes.open) components[k] = v; + for (const auto& [k, v] : shapes.vacuum) components[k] = v; + + createPhysicalGroups(components, labelMapping); + + gmsh::vectorpair allEnts; + gmsh::model::getEntities(allEnts); + + gmsh::vectorpair allPGs; + gmsh::model::getPhysicalGroups(allPGs); + + gmsh::vectorpair entsInPG; + for (const auto& [pgDim, pgTag] : allPGs) { + std::vector tags; + gmsh::model::getEntitiesForPhysicalGroup(pgDim, pgTag, tags); + for (int t : tags) { + entsInPG.push_back({pgDim, t}); + } + } + + gmsh::vectorpair entsNotInPG; + for (const auto& ent : allEnts) { + if (std::find(entsInPG.begin(), entsInPG.end(), ent) == entsInPG.end()) { + entsNotInPG.push_back(ent); + } + } + + gmsh::model::removeEntities(entsNotInPG, false); + gmsh::model::occ::synchronize(); +} + +void Mesher::createPhysicalGroups( + const EntityMap& objsDict, + const std::map& labelMapping) +{ + for (const auto& [name, elements] : objsDict) { + auto it = labelMapping.find(name); + if (it == labelMapping.end()) continue; + const std::string& mappedName = it->second; + int dim = elements[0].first; + std::vector tags; + for (const auto& [d, t] : elements) tags.push_back(t); + gmsh::model::addPhysicalGroup(dim, tags, -1, mappedName); + } +} + +std::pair Mesher::getPhysicalGroupWithName(const std::string& name) { + gmsh::vectorpair pGs; + gmsh::model::getPhysicalGroups(pGs); + for (const auto& [dim, tag] : pGs) { + std::string pgName; + gmsh::model::getPhysicalName(dim, tag, pgName); + if (pgName == name) return {dim, tag}; + } + return {-1, -1}; +} + +EntityMap Mesher::extractBoundaries(const EntityMap& shapes) { + EntityMap boundaries; + for (const auto& [name, surfs] : shapes) { + gmsh::vectorpair bdrs; + gmsh::model::getBoundary(surfs, bdrs, true, true, false); + boundaries[name] = bdrs; + } + return boundaries; +} + +void Mesher::runCase( + const std::string& folder, + const std::string& caseName, + const std::map* meshingOptions) +{ + gmsh::initialize(); + std::string inputFile = folder + caseName + "/" + caseName + ".step"; + Mesher mesher; + mesher.meshFromStep(inputFile, caseName, meshingOptions); + gmsh::write(caseName + ".msh"); + gmsh::finalize(); +} + +} // namespace step2gmsh diff --git a/src/adapter/Mesher.h b/src/adapter/Mesher.h new file mode 100644 index 0000000..8aeda89 --- /dev/null +++ b/src/adapter/Mesher.h @@ -0,0 +1,50 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include "ShapesClassification.h" + +namespace step2gmsh { + +class Mesher { +public: + static const std::map DEFAULT_MESHING_OPTIONS; + + static std::pair, + std::vector>> + findDuplicateNodes(); + + void runFromInput(const std::string& inputFile, bool runGui = false); + + std::map meshFromStep( + const std::string& inputFile, + const std::string& caseName, + const std::map* meshingOptions = nullptr); + + void exportGeometryAreas( + const std::string& caseName, + const std::map& mappedElements); + + void buildPhysicalModel(ShapesClassification& shapes, + const std::map& labelMapping); + + static std::pair getPhysicalGroupWithName(const std::string& name); + + EntityMap extractBoundaries(const EntityMap& shapes); + + static void runCase( + const std::string& folder, + const std::string& caseName, + const std::map* meshingOptions = nullptr); + +private: + void createPhysicalGroups(const EntityMap& objsDict, + const std::map& labelMapping); +}; + +} // namespace step2gmsh diff --git a/src/adapter/ShapesClassification.cpp b/src/adapter/ShapesClassification.cpp new file mode 100644 index 0000000..1848f6c --- /dev/null +++ b/src/adapter/ShapesClassification.cpp @@ -0,0 +1,402 @@ +#include "ShapesClassification.h" + +#include +#include +#include +#include +#include + +#include + +namespace step2gmsh { + +ShapesClassification::ShapesClassification(const EntityList& shapes, + const std::string& jsonFile) +{ + gmsh::model::occ::synchronize(); + + allShapes = shapes; + + std::ifstream f(jsonFile); + if (!f.is_open()) { + throw std::runtime_error("Cannot open JSON file: " + jsonFile); + } + nlohmann::json jsonData; + f >> jsonData; + crossSectionData_ = jsonData["CrossSection"]; + + pecs = getPECs(shapes); + dielectrics = getDielectrics(shapes); + open = getOpenBoundaries(shapes); + nestedGraph = buildNestedGraph(); + isOpenCase = isOpenProblem(); +} + +int ShapesClassification::getNumberFromName(const std::string& entityName, + const std::string& label) +{ + auto pos = entityName.rfind(label); + if (pos == std::string::npos) { + throw std::runtime_error("Label '" + label + "' not found in '" + entityName + "'"); + } + return std::stoi(entityName.substr(pos + label.size())); +} + +std::vector ShapesClassification::getGeometryNamesByMaterialType( + const std::string& materialType) const +{ + std::vector names; + for (const auto& geometry : crossSectionData_) { + if (geometry["material"]["type"] == materialType) { + names.push_back(geometry["name"].get()); + } + } + return names; +} + +EntityMap ShapesClassification::getEntitiesByMaterialType( + const EntityList& entityTags, + const std::string& materialType, + int entityDim) const +{ + auto materialNames = getGeometryNamesByMaterialType(materialType); + // Collect all matching entities with their full GMSH name + struct EntityInfo { + std::string fullName; + EntityTag tag; + }; + std::map> candidates; + for (const auto& [dim, tag] : entityTags) { + if (dim != entityDim) continue; + std::string fullName; + gmsh::model::getEntityName(dim, tag, fullName); + auto pos = fullName.rfind('/'); + std::string name = (pos != std::string::npos) ? fullName.substr(pos + 1) : fullName; + if (std::find(materialNames.begin(), materialNames.end(), name) == materialNames.end()) { + continue; + } + candidates[name].push_back({fullName, {dim, tag}}); + } + + EntityMap entities; + for (const auto& [name, infos] : candidates) { + // Check if any entity has a deep path (assembly instance). + // Bare part definitions have paths like "Shapes/" (1 slash). + std::string barePath = "Shapes/" + name; + bool hasDeepEntities = false; + for (const auto& info : infos) { + if (info.fullName != barePath) { + hasDeepEntities = true; + break; + } + } + for (const auto& info : infos) { + if (hasDeepEntities && info.fullName == barePath) { + continue; // Skip bare part definition + } + entities[name].push_back(info.tag); + } + } + return entities; +} + +EntityMap ShapesClassification::getPECs(const EntityList& entityTags) { + return getEntitiesByMaterialType(entityTags, "PEC"); +} + +EntityMap ShapesClassification::getDielectrics(const EntityList& entityTags) { + return getEntitiesByMaterialType(entityTags, "Dielectric"); +} + +EntityMap ShapesClassification::getOpenBoundaries(const EntityList& entityTags) { + return getEntitiesByMaterialType(entityTags, "OpenBoundary"); +} + +bool ShapesClassification::isOpenBoundaryDefined() const { + return !open.empty(); +} + +bool ShapesClassification::isOpenProblem() const { + auto roots = nestedGraph.roots(); + if (open.size() == 1) return true; + if (roots.size() > 1) return true; + if (!roots.empty()) { + const auto& root = roots[0]; + if (dielectrics.count(root)) return true; + if (pecs.count(root)) { + auto parentNodes = nestedGraph.getParentNodes(); + if (std::find(parentNodes.begin(), parentNodes.end(), root) == parentNodes.end()) { + return true; + } + } + } + return false; +} + +void ShapesClassification::removeConductorsFromDielectrics() { + auto connections = nestedGraph.getConnections(); + + for (auto& [dielName, dielSurfs] : dielectrics) { + EntityList pecSurfs; + auto it = connections.find(dielName); + if (it != connections.end()) { + for (const auto& childName : it->second) { + if (pecs.count(childName)) { + const auto& surf = pecs.at(childName); + pecSurfs.insert(pecSurfs.end(), surf.begin(), surf.end()); + } + } + } + if (pecSurfs.empty()) continue; + + gmsh::vectorpair outDimTags; + std::vector outMap; + gmsh::model::occ::cut(dielSurfs, pecSurfs, outDimTags, outMap, -1, true, false); + dielSurfs = outDimTags; + } + + gmsh::model::occ::synchronize(); +} + +void ShapesClassification::ensureDielectricsDoNotOverlap() { + for (auto& [currentKey, currentSurfs] : dielectrics) { + EntityList others; + for (const auto& [key, surf] : dielectrics) { + if (key != currentKey) { + others.insert(others.end(), surf.begin(), surf.end()); + } + } + if (others.empty()) continue; + + gmsh::vectorpair outDimTags; + std::vector outMap; + gmsh::model::occ::cut(currentSurfs, others, outDimTags, outMap, -1, true, false); + currentSurfs = outDimTags; + } + + gmsh::model::occ::synchronize(); +} + +EntityMap ShapesClassification::buildVacuumDomain() { + if (isOpenCase) { + vacuum = buildOpenVacuumDomain(); + } else { + vacuum = buildClosedVacuumDomain(); + } + return vacuum; +} + +EntityMap ShapesClassification::buildClosedVacuumDomain() { + const auto roots = nestedGraph.roots(); + const auto& root = roots[0]; + EntityList dom = pecs.at(root); + EntityList toRemove; + + for (const auto& [name, surf] : pecs) { + if (name == root) continue; + toRemove.insert(toRemove.end(), surf.begin(), surf.end()); + } + for (const auto& [name, surf] : dielectrics) { + toRemove.insert(toRemove.end(), surf.begin(), surf.end()); + } + + gmsh::vectorpair outDimTags; + std::vector outMap; + gmsh::model::occ::cut(dom, toRemove, outDimTags, outMap, -1, false, false); + gmsh::model::occ::synchronize(); + + return {{"Vacuum_0", outDimTags}}; +} + +EntityMap ShapesClassification::buildOpenVacuumDomain() { + constexpr double NEAR_REGION_SCALING = 1.15; + constexpr double FAR_REGION_SCALING = 4.0; + + EntityList nonVacuumSurfaces; + for (const auto& [name, surf] : pecs) { + nonVacuumSurfaces.insert(nonVacuumSurfaces.end(), surf.begin(), surf.end()); + } + for (const auto& [name, surf] : dielectrics) { + nonVacuumSurfaces.insert(nonVacuumSurfaces.end(), surf.begin(), surf.end()); + } + + if (isOpenBoundaryDefined()) { + auto [openName, openVacuum] = *open.begin(); + + gmsh::vectorpair outDimTags; + std::vector outMap; + gmsh::model::occ::cut(openVacuum, nonVacuumSurfaces, outDimTags, outMap, -1, true, false); + gmsh::model::occ::synchronize(); + + gmsh::vectorpair vacuumBoundaries; + gmsh::model::getBoundary(outDimTags, vacuumBoundaries, true, true, false); + EntityList externalBoundaries; + for (const auto& [dim, tag] : vacuumBoundaries) { + if (tag > 0) externalBoundaries.push_back({dim, tag}); + } + open = {{openName, externalBoundaries}}; + + return {{"Vacuum_0", outDimTags}}; + } else { + auto boundingBox = BoundingBox::getBoundingBoxFromGroup(nonVacuumSurfaces); + auto lengths = boundingBox.getLengths(); + double bbMaxLen = *std::max_element(lengths.begin(), lengths.end()); + + double nearBoxSize = bbMaxLen * NEAR_REGION_SCALING; + auto center = boundingBox.getCenter(); + double nVX = center[0] - nearBoxSize / 2.0; + double nVY = center[1] - nearBoxSize / 2.0; + double nVZ = center[2]; + + int nearRectTag = gmsh::model::occ::addRectangle( + nVX, nVY, nVZ, nearBoxSize, nearBoxSize); + EntityList nearVacuum = {{2, nearRectTag}}; + + double farDiameter = FAR_REGION_SCALING * boundingBox.getDiagonal(); + int farDiskTag = gmsh::model::occ::addDisk( + center[0], center[1], center[2], farDiameter, farDiameter); + EntityList farVacuum = {{2, farDiskTag}}; + + gmsh::model::occ::synchronize(); + + gmsh::vectorpair farBoundary; + gmsh::model::getBoundary(farVacuum, farBoundary, true, true, false); + open = {{"OpenBoundary_0", farBoundary}}; + + { + gmsh::vectorpair out; + std::vector map; + gmsh::model::occ::cut(farVacuum, nearVacuum, out, map, -1, true, false); + farVacuum = out; + } + { + gmsh::vectorpair out; + std::vector map; + gmsh::model::occ::cut(nearVacuum, nonVacuumSurfaces, out, map, -1, true, false); + nearVacuum = out; + } + + gmsh::model::occ::synchronize(); + + // Set mesh size for near-vacuum inner boundary + BoundingBox bb = BoundingBox::getBoundingBox(2, nearVacuum[0].second); + auto nlen = bb.getLengths(); + double minSide = std::min(nlen[0], nlen[1]); + + gmsh::vectorpair innerRegion; + gmsh::model::getBoundary(nearVacuum, innerRegion, true, true, true); + gmsh::model::mesh::setSize(innerRegion, minSide / 20.0); + + gmsh::model::occ::synchronize(); + + return {{"Vacuum_0", nearVacuum}, {"Vacuum_1", farVacuum}}; + } +} + +Graph ShapesClassification::buildNestedGraph() { + gmsh::model::occ::synchronize(); + Graph graph; + + // Merge pecs, dielectrics, open into a single map + EntityMap elements; + for (const auto& [k, v] : pecs) elements[k] = v; + for (const auto& [k, v] : dielectrics) elements[k] = v; + for (const auto& [k, v] : open) elements[k] = v; + + for (const auto& [key, _] : elements) { + graph.addNode(key); + } + + std::vector keys; + for (const auto& [key, _] : elements) keys.push_back(key); + + for (std::size_t i = 0; i < keys.size(); ++i) { + for (std::size_t j = i + 1; j < keys.size(); ++j) { + const auto& keyA = keys[i]; + const auto& keyB = keys[j]; + const auto& elemsA = elements.at(keyA); + const auto& elemsB = elements.at(keyB); + + BoundingBox bbA = BoundingBox::getBoundingBoxFromGroup(elemsA); + BoundingBox bbB = BoundingBox::getBoundingBoxFromGroup(elemsB); + + bool aInB = (bbA.xMin >= bbB.xMin && bbA.xMax <= bbB.xMax && + bbA.yMin >= bbB.yMin && bbA.yMax <= bbB.yMax); + bool bInA = (bbB.xMin >= bbA.xMin && bbB.xMax <= bbA.xMax && + bbB.yMin >= bbA.yMin && bbB.yMax <= bbA.yMax); + + if (aInB && !bInA) { + graph.addEdge(keyB, keyA); // B contains A + } else if (bInA && !aInB) { + graph.addEdge(keyA, keyB); // A contains B + } + } + } + + graph.pruneToLongestPaths(); + graph.reorderData(); + return graph; +} + +Graph ShapesClassification::getConductorOnlyGraph() const { + Graph conductorGraph; + + for (const auto& [name, _] : pecs) { + auto& nodes = nestedGraph.nodes(); + if (std::find(nodes.begin(), nodes.end(), name) != nodes.end()) { + conductorGraph.addNode(name); + } + } + + for (const auto& edge : nestedGraph.edges()) { + const auto& src = edge.first; + const auto& dest = edge.second; + + bool srcIsPec = pecs.count(src) > 0; + bool destIsPec = pecs.count(dest) > 0; + bool destIsDiel = dielectrics.count(dest) > 0; + + if (srcIsPec && destIsPec) { + conductorGraph.addEdge(src, dest); + } else if (srcIsPec && destIsDiel) { + for (const auto& childEdge : nestedGraph.edges()) { + if (childEdge.first == dest && pecs.count(childEdge.second)) { + conductorGraph.addEdge(src, childEdge.second); + } + } + } + } + + conductorGraph.pruneToLongestPaths(); + conductorGraph.reorderData(); + return conductorGraph; +} + +std::map ShapesClassification::getMappedComponents() const { + std::map mappedComponents; + + std::vector sortedNodes = nestedGraph.getNodesByLevels(); + + int conductorIdx = 0; + for (const auto& node : sortedNodes) { + if (pecs.count(node)) { + mappedComponents[node] = "Conductor_" + std::to_string(conductorIdx++); + } + } + + int dielectricIdx = 0; + for (const auto& [name, _] : dielectrics) { + mappedComponents[name] = "Dielectric_" + std::to_string(dielectricIdx++); + } + + for (const auto& [domain, _] : vacuum) { + mappedComponents[domain] = domain; + } + for (const auto& [openBoundary, _] : open) { + mappedComponents[openBoundary] = "OpenBoundary_0"; + } + + return mappedComponents; +} + +} // namespace step2gmsh diff --git a/src/adapter/ShapesClassification.h b/src/adapter/ShapesClassification.h new file mode 100644 index 0000000..07cf907 --- /dev/null +++ b/src/adapter/ShapesClassification.h @@ -0,0 +1,63 @@ +#pragma once + +#include +#include +#include +#include + +#include + +#include "BoundingBox.h" +#include "Graph.h" + +namespace step2gmsh { + +using EntityTag = std::pair; +using EntityList = std::vector; +using EntityMap = std::map; + +class ShapesClassification { +public: + bool isOpenCase; + EntityMap pecs; + EntityMap dielectrics; + EntityMap open; + EntityMap vacuum; + EntityList allShapes; + Graph nestedGraph; + + ShapesClassification(const EntityList& shapes, const std::string& jsonFile); + + static int getNumberFromName(const std::string& entityName, + const std::string& label); + + EntityMap getEntitiesByMaterialType(const EntityList& entityTags, + const std::string& materialType, + int entityDim = 2) const; + + EntityMap getPECs(const EntityList& entityTags); + EntityMap getDielectrics(const EntityList& entityTags); + EntityMap getOpenBoundaries(const EntityList& entityTags); + + bool isOpenBoundaryDefined() const; + bool isOpenProblem() const; + + void removeConductorsFromDielectrics(); + void ensureDielectricsDoNotOverlap(); + EntityMap buildVacuumDomain(); + + Graph getConductorOnlyGraph() const; + std::map getMappedComponents() const; + +private: + nlohmann::json crossSectionData_; + + std::vector getGeometryNamesByMaterialType( + const std::string& materialType) const; + + Graph buildNestedGraph(); + EntityMap buildClosedVacuumDomain(); + EntityMap buildOpenVacuumDomain(); +}; + +} // namespace step2gmsh diff --git a/src/AttrToValueMap.h b/src/driver/AttrToValueMap.h similarity index 97% rename from src/AttrToValueMap.h rename to src/driver/AttrToValueMap.h index 5aa357c..b225f3d 100644 --- a/src/AttrToValueMap.h +++ b/src/driver/AttrToValueMap.h @@ -3,7 +3,7 @@ #include #include "FES.h" -namespace pulmtln { +namespace tulip { using NameToAttrMap = std::map; diff --git a/src/driver/CMakeLists.txt b/src/driver/CMakeLists.txt new file mode 100644 index 0000000..182bab6 --- /dev/null +++ b/src/driver/CMakeLists.txt @@ -0,0 +1,30 @@ +cmake_minimum_required(VERSION 3.21) + +set(LIBRARY_NAME "tulip-driver") +message(STATUS "Creating build system for ${LIBRARY_NAME}") + +find_package(nlohmann_json CONFIG REQUIRED) +find_package(Boost REQUIRED graph program_options) + +add_library(${LIBRARY_NAME} STATIC + "FES.cpp" + "Solver.cpp" + "Driver.cpp" + "Results.cpp" + "DirectedGraph.cpp" + "Domain.cpp" + "Materials.cpp" + "Model.cpp" + "Parser.cpp" +) + +target_include_directories(${LIBRARY_NAME} PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${Boost_INCLUDE_DIRS} +) + +target_link_libraries(${LIBRARY_NAME} PUBLIC + mfem + nlohmann_json::nlohmann_json + Boost::graph +) diff --git a/src/DirectedGraph.cpp b/src/driver/DirectedGraph.cpp similarity index 99% rename from src/DirectedGraph.cpp rename to src/driver/DirectedGraph.cpp index f37e7fb..d586ffc 100644 --- a/src/DirectedGraph.cpp +++ b/src/driver/DirectedGraph.cpp @@ -10,7 +10,7 @@ namespace boost { template inline void renumber_vertex_indices(G& g) { throw; } } -namespace pulmtln { +namespace tulip { IdSet DirectedGraph::getVertices() const { diff --git a/src/DirectedGraph.h b/src/driver/DirectedGraph.h similarity index 99% rename from src/DirectedGraph.h rename to src/driver/DirectedGraph.h index 0726c1f..f824f01 100644 --- a/src/DirectedGraph.h +++ b/src/driver/DirectedGraph.h @@ -10,7 +10,7 @@ #include #include -namespace pulmtln { +namespace tulip { using namespace boost; diff --git a/src/Domain.cpp b/src/driver/Domain.cpp similarity index 99% rename from src/Domain.cpp rename to src/driver/Domain.cpp index 66599ee..6d280f2 100644 --- a/src/Domain.cpp +++ b/src/driver/Domain.cpp @@ -2,7 +2,7 @@ using namespace mfem; -namespace pulmtln { +namespace tulip { DirectedGraph buildMeshGraph(const mfem::Mesh& mesh) { diff --git a/src/Domain.h b/src/driver/Domain.h similarity index 97% rename from src/Domain.h rename to src/driver/Domain.h index 42d5222..db4710e 100644 --- a/src/Domain.h +++ b/src/driver/Domain.h @@ -3,7 +3,7 @@ #include "DirectedGraph.h" #include "Model.h" -namespace pulmtln { +namespace tulip { struct Domain { using Id = int; diff --git a/src/Driver.cpp b/src/driver/Driver.cpp similarity index 97% rename from src/Driver.cpp rename to src/driver/Driver.cpp index d16a5d8..58a24c1 100644 --- a/src/Driver.cpp +++ b/src/driver/Driver.cpp @@ -1,12 +1,12 @@ #include "Driver.h" -#include "ElectrostaticSolver.h" +#include "Solver.h" #include "Parser.h" #include "multipolarExpansion.h" using namespace mfem; -namespace pulmtln { +namespace tulip { const std::string INNER_REGION_DEFAULT_NAME = "Vacuum_0"; @@ -31,7 +31,7 @@ std::vector getAttributesInMap(const NameToAttrMap& m) void exportFieldSolutions( const DriverOptions& opts, - ElectrostaticSolver& s, + Solver& s, const std::string name, bool ignoreDielectrics) { @@ -45,7 +45,7 @@ void exportFieldSolutions( } -Driver Driver::loadFromFile(const std::string& fn) +Driver Driver::loadFromAdaptedFile(const std::string& fn) { Parser p{ fn }; return Driver{ @@ -144,9 +144,9 @@ SolvedProblem Driver::solveForAllConductors(bool ignoreDielectrics) SolvedProblem res; const auto baseParameters{ buildSolverInputsFromModel(model_, ignoreDielectrics) }; - res.solver = std::make_unique( + res.solver = std::make_unique( *model_.getMesh(), baseParameters, opts_.solverOptions); - ElectrostaticSolver& s = *res.solver.get(); + Solver& s = *res.solver.get(); auto conductors{ model_.getMaterials().buildIdToAttrMapFor() }; res.solutions.resize(conductors.size()); @@ -291,7 +291,7 @@ void Driver::run() auto pul = buildPULParametersForModel(); saveToJSONFile( pul.toJSON(), - opts_.exportFolder + "pulmtln.out.json"); + opts_.exportFolder + "tulip.out.json"); } else if (openness == Model::Openness::open) { auto inCell = getInCellPotentials(); @@ -433,7 +433,7 @@ std::list listMaterialsInInnerRegion( double Driver::getInnerRegionAveragePotential( - const ElectrostaticSolver& s, + const Solver& s, bool includeConductors) { @@ -472,7 +472,7 @@ std::map Driver::getFieldParameters( sP = &electric_; } - ElectrostaticSolver& s = *sP->solver; + Solver& s = *sP->solver; const auto conductors{ model_.getMaterials().buildIdToAttrMapFor() }; for (const auto& [condI, bdrAttI] : conductors) { diff --git a/src/Driver.h b/src/driver/Driver.h similarity index 84% rename from src/Driver.h rename to src/driver/Driver.h index 6bb64dd..078fcd1 100644 --- a/src/Driver.h +++ b/src/driver/Driver.h @@ -1,16 +1,16 @@ #pragma once -#include "SolverOptions.h" +#include "DriverOptions.h" #include "Model.h" #include "Results.h" -#include "ElectrostaticSolver.h" +#include "Solver.h" #include -namespace pulmtln { +namespace tulip { struct SolvedProblem { - std::unique_ptr solver; + std::unique_ptr solver; std::vector solutions; }; @@ -39,7 +39,8 @@ class Driver { DenseMatrix getLMatrix(); DenseMatrix getFloatingPotentialsMatrix(const bool ignoreDielectrics); - static Driver loadFromFile(const std::string& filename); + static Driver loadFromAdaptedFile(const std::string& filename); + static Driver adaptFromFile(const std::string& filename); private: Model model_; @@ -51,7 +52,7 @@ class Driver { PULParameters buildPULParametersForModel(); PULParameters buildGeneralizedLCMatrices(); double getInnerRegionAveragePotential( - const ElectrostaticSolver& s, + const Solver& s, bool includeConductors); std::map getFieldParameters( bool ignoreDielectrics); diff --git a/src/SolverOptions.h b/src/driver/DriverOptions.h similarity index 62% rename from src/SolverOptions.h rename to src/driver/DriverOptions.h index e037687..4b891ed 100644 --- a/src/SolverOptions.h +++ b/src/driver/DriverOptions.h @@ -1,20 +1,17 @@ #pragma once -#include +#include "SolverOptions.h" -namespace pulmtln { +#include -struct SolverOptions { - int order{3}; // Basis function order - bool printIterations{ false }; -}; +namespace tulip { struct DriverOptions { SolverOptions solverOptions; // Number of coefficients in the multipolar expansion // for in-cell parameters calculations. - int multipolarExpansionOrder{ 5 }; + int multipolarExpansionOrder{ 3 }; bool exportParaViewSolution{ true }; diff --git a/src/FES.cpp b/src/driver/FES.cpp similarity index 98% rename from src/FES.cpp rename to src/driver/FES.cpp index 0b80d90..3ac0c6a 100644 --- a/src/FES.cpp +++ b/src/driver/FES.cpp @@ -1,6 +1,6 @@ #include "FES.h" -namespace pulmtln { +namespace tulip { H1_FESpace::H1_FESpace(Mesh *m, const int p, const int space_dim, const int type, diff --git a/src/FES.h b/src/driver/FES.h similarity index 98% rename from src/FES.h rename to src/driver/FES.h index d537b05..af3ee9a 100644 --- a/src/FES.h +++ b/src/driver/FES.h @@ -5,7 +5,7 @@ #include -namespace pulmtln { +namespace tulip { using namespace mfem; diff --git a/src/Materials.cpp b/src/driver/Materials.cpp similarity index 98% rename from src/Materials.cpp rename to src/driver/Materials.cpp index 1a26b32..46a1d89 100644 --- a/src/Materials.cpp +++ b/src/driver/Materials.cpp @@ -1,7 +1,7 @@ #include "Materials.h" #include "constants.h" -namespace pulmtln { +namespace tulip { NameToAttrMap Materials::buildNameToAttrMap() const diff --git a/src/Materials.h b/src/driver/Materials.h similarity index 99% rename from src/Materials.h rename to src/driver/Materials.h index 424b1b4..16b113f 100644 --- a/src/Materials.h +++ b/src/driver/Materials.h @@ -2,7 +2,7 @@ #include "AttrToValueMap.h" -namespace pulmtln { +namespace tulip { using MaterialId = int; using Attribute = int; diff --git a/src/Model.cpp b/src/driver/Model.cpp similarity index 92% rename from src/Model.cpp rename to src/driver/Model.cpp index 84afc90..3671bbb 100644 --- a/src/Model.cpp +++ b/src/driver/Model.cpp @@ -5,7 +5,7 @@ #include "DirectedGraph.h" -namespace pulmtln { +namespace tulip { using namespace mfem; @@ -93,18 +93,11 @@ std::size_t Model::numberOfConductors() const Model::Openness Model::determineOpenness() const { - assert(materials_.openBoundaries.size() <= 1); - if (materials_.openBoundaries.size() == 0) { return Openness::closed; + } else { + return Openness::open; } - - for (const auto& m : materials_.openBoundaries) { - if (!elementsFormOpenLoops(getElementsWithAttribute(*mesh_, m.attribute))) { - return Openness::open; - } - } - return Openness::semiopen; } double Model::getAreaOfMaterial(const std::string& materialName) const diff --git a/src/Model.h b/src/driver/Model.h similarity index 94% rename from src/Model.h rename to src/driver/Model.h index 8fe8407..9452aa7 100644 --- a/src/Model.h +++ b/src/driver/Model.h @@ -3,7 +3,7 @@ #include "AttrToValueMap.h" #include "Materials.h" -namespace pulmtln { +namespace tulip { struct Box { std::array min, max; @@ -36,7 +36,6 @@ class Model { public: enum class Openness { open, // The most external boundary is open. - semiopen, // The most external boundaries are open and a conductor. closed // The most external boundary is a conductor. }; diff --git a/src/Parser.cpp b/src/driver/Parser.cpp similarity index 99% rename from src/Parser.cpp rename to src/driver/Parser.cpp index 9cdd596..05668d6 100644 --- a/src/Parser.cpp +++ b/src/driver/Parser.cpp @@ -6,7 +6,7 @@ using json = nlohmann::json; -namespace pulmtln { +namespace tulip { enum class MaterialType { PEC, diff --git a/src/Parser.h b/src/driver/Parser.h similarity index 84% rename from src/Parser.h rename to src/driver/Parser.h index 931ec0b..b0b1205 100644 --- a/src/Parser.h +++ b/src/driver/Parser.h @@ -1,11 +1,11 @@ #pragma once -#include "SolverOptions.h" +#include "DriverOptions.h" #include "Model.h" #include -namespace pulmtln { +namespace tulip { class Parser { public: diff --git a/src/Results.cpp b/src/driver/Results.cpp similarity index 99% rename from src/Results.cpp rename to src/driver/Results.cpp index d318a77..9e5f042 100644 --- a/src/Results.cpp +++ b/src/driver/Results.cpp @@ -2,7 +2,7 @@ #include "constants.h" -namespace pulmtln { +namespace tulip { using namespace mfem; using json = nlohmann::json; diff --git a/src/Results.h b/src/driver/Results.h similarity index 98% rename from src/Results.h rename to src/driver/Results.h index 91ddb99..7d78172 100644 --- a/src/Results.h +++ b/src/driver/Results.h @@ -6,7 +6,7 @@ #include "Domain.h" #include "multipolarExpansion.h" -namespace pulmtln { +namespace tulip { void saveToJSONFile(const nlohmann::json&, const std::string& filename); diff --git a/src/ElectrostaticSolver.cpp b/src/driver/Solver.cpp similarity index 92% rename from src/ElectrostaticSolver.cpp rename to src/driver/Solver.cpp index 1b84d55..9f50f8b 100644 --- a/src/ElectrostaticSolver.cpp +++ b/src/driver/Solver.cpp @@ -1,9 +1,9 @@ -#include "ElectrostaticSolver.h" +#include "Solver.h" #include "constants.h" #include "AttrToValueMap.h" -namespace pulmtln { +namespace tulip { Array AttrToMarker(const Mesh& mesh, const Array& attrs) { @@ -56,7 +56,7 @@ double firstOrderABC(const Vector& rVec) } -ElectrostaticSolver::ElectrostaticSolver( +Solver::Solver( Mesh& mesh, const SolverInputs& parameters, const SolverOptions opts) : @@ -151,7 +151,7 @@ ElectrostaticSolver::ElectrostaticSolver( applyBoundaryConstantValuesToGridFunction(parameters_.neumannBoundaries, *sigma_src_); } -ElectrostaticSolver::~ElectrostaticSolver() +Solver::~Solver() { delete phi_; delete rhod_; @@ -174,7 +174,7 @@ ElectrostaticSolver::~ElectrostaticSolver() delete epsCoef_; } -void ElectrostaticSolver::Assemble() +void Solver::Assemble() { divEpsGrad_->Assemble(); divEpsGrad_->Finalize(); @@ -194,7 +194,7 @@ void ElectrostaticSolver::Assemble() grad_->Finalize(); } -void ElectrostaticSolver::applyBoundaryConstantValuesToGridFunction( +void Solver::applyBoundaryConstantValuesToGridFunction( const AttrToValueMap& bdrValues, GridFunction& gf) const { @@ -218,7 +218,7 @@ void ElectrostaticSolver::applyBoundaryConstantValuesToGridFunction( } } -void ElectrostaticSolver::Solve() +void Solver::Solve() { // Initialize the surface charge density (From Neumann boundaries). h1SurfMass_->Mult(*sigma_src_, *rhod_); @@ -276,12 +276,12 @@ void ElectrostaticSolver::Solve() } -void ElectrostaticSolver::setDirichletConditions(const AttrToValueMap& dbcs) +void Solver::setDirichletConditions(const AttrToValueMap& dbcs) { parameters_.dirichletBoundaries = dbcs; } -void ElectrostaticSolver::setNeumannCondition( +void Solver::setNeumannCondition( const int bdrAttribute, Coefficient& chargeDensity) { @@ -292,7 +292,7 @@ void ElectrostaticSolver::setNeumannCondition( sigma_src_->ProjectBdrCoefficient(chargeDensity, bdr_attr); } -double ElectrostaticSolver::getTotalCharge() const +double Solver::getTotalCharge() const { LinearForm rt_surf_int{HDivFESpace_}; rt_surf_int.AddBoundaryIntegrator(new VectorFEBoundaryFluxLFIntegrator); @@ -300,7 +300,7 @@ double ElectrostaticSolver::getTotalCharge() const return rt_surf_int(*d_); } -double ElectrostaticSolver::getChargeMomentComponent( +double Solver::getChargeMomentComponent( int n, int d, const Vector& center) const { // Computes the 2^n-polar term component for direction d around an expansion center. @@ -346,7 +346,7 @@ double ElectrostaticSolver::getChargeMomentComponent( return surf_int(*d_); } -Vector ElectrostaticSolver::getCenterOfCharge() const +Vector Solver::getCenterOfCharge() const { // "Center of Charge" is the place where the dipole moment is zero. // It can only be defined for open and non-neutral systems. @@ -368,7 +368,7 @@ Vector ElectrostaticSolver::getCenterOfCharge() const return res; } -multipolarCoefficients ElectrostaticSolver::getMultipolarCoefficients( +multipolarCoefficients Solver::getMultipolarCoefficients( std::size_t order) const { auto centerOfCharge{ getCenterOfCharge() }; @@ -444,7 +444,7 @@ void copyGridFunctionValues(GridFunction* tgt, const GridFunction* src) } } -SolverSolution ElectrostaticSolver::getSolution() const +SolverSolution Solver::getSolution() const { SolverSolution res; res.phi = cloneGridFunction(phi_); @@ -453,21 +453,21 @@ SolverSolution ElectrostaticSolver::getSolution() const return res; } -void ElectrostaticSolver::setSolution(const SolverSolution& s) +void Solver::setSolution(const SolverSolution& s) { copyGridFunctionValues(phi_, s.phi.get()); copyGridFunctionValues(e_, s.e.get()); copyGridFunctionValues(d_, s.d.get()); } -double ElectrostaticSolver::getChargeInBoundary(int bdrAttribute) const +double Solver::getChargeInBoundary(int bdrAttribute) const { ConstantCoefficient minusOne{ -1.0 }; auto surf_int{ buildHDivBoundaryIntegrator(HDivFESpace_, bdrAttribute, minusOne) }; return (*surf_int)(*d_); } -double ElectrostaticSolver::getAveragePotentialInDomain(int domainAttribute) const +double Solver::getAveragePotentialInDomain(int domainAttribute) const { mfem::Array attr(1); attr[0] = domainAttribute; @@ -492,7 +492,7 @@ double ElectrostaticSolver::getAveragePotentialInDomain(int domainAttribute) con return totalPotential / area; } -double ElectrostaticSolver::getAveragePotentialInBoundary(int bdrAttribute) const +double Solver::getAveragePotentialInBoundary(int bdrAttribute) const { ConstantCoefficient one{ 1.0 }; auto surf_int{ buildH1BoundaryIntegrator(H1FESpace_, bdrAttribute, one) }; @@ -506,7 +506,7 @@ double ElectrostaticSolver::getAveragePotentialInBoundary(int bdrAttribute) cons return totalPotential / totalLength; } -double ElectrostaticSolver::getTotalEnergy() const +double Solver::getTotalEnergy() const { Array domainAttributes = mesh_->attributes; int maxAttr = domainAttributes.Max(); @@ -531,7 +531,7 @@ double ElectrostaticSolver::getTotalEnergy() const return energy; } -void ElectrostaticSolver::writeParaViewFields(ParaViewDataCollection& pv) const +void Solver::writeParaViewFields(ParaViewDataCollection& pv) const { pv.SetHighOrderOutput(true); pv.SetLevelsOfDetail(3); diff --git a/src/ElectrostaticSolver.h b/src/driver/Solver.h similarity index 96% rename from src/ElectrostaticSolver.h rename to src/driver/Solver.h index 1ac755e..96b11a4 100644 --- a/src/ElectrostaticSolver.h +++ b/src/driver/Solver.h @@ -6,7 +6,7 @@ #include "FES.h" #include "AttrToValueMap.h" -namespace pulmtln { +namespace tulip { using namespace mfem; @@ -21,13 +21,13 @@ struct SolverSolution { std::unique_ptr phi, e, d; }; -class ElectrostaticSolver { +class Solver { public: - ElectrostaticSolver( + Solver( Mesh& mesh, const SolverInputs&, const SolverOptions = SolverOptions{}); - ~ElectrostaticSolver(); + ~Solver(); void Solve(); void setDirichletConditions(const AttrToValueMap& dbcs); diff --git a/src/driver/SolverOptions.h b/src/driver/SolverOptions.h new file mode 100644 index 0000000..135c0a2 --- /dev/null +++ b/src/driver/SolverOptions.h @@ -0,0 +1,13 @@ +#pragma once + +#include + +namespace tulip { + +struct SolverOptions { + // Basis function order + int order{3}; + bool printIterations{ false }; +}; + +} \ No newline at end of file diff --git a/src/constants.h b/src/driver/constants.h similarity index 95% rename from src/constants.h rename to src/driver/constants.h index 18f9d6e..415146b 100644 --- a/src/constants.h +++ b/src/driver/constants.h @@ -3,7 +3,7 @@ #define _USE_MATH_DEFINES #include -namespace pulmtln { +namespace tulip { static const double VACUUM_RELATIVE_PERMITTIVITY{ 1.0 }; diff --git a/src/multipolarExpansion.h b/src/driver/multipolarExpansion.h similarity index 98% rename from src/multipolarExpansion.h rename to src/driver/multipolarExpansion.h index 5354ff6..298fdb5 100644 --- a/src/multipolarExpansion.h +++ b/src/driver/multipolarExpansion.h @@ -3,7 +3,7 @@ #include "FES.h" #include "constants.h" -namespace pulmtln { +namespace tulip { using multipolarCoefficient = std::pair; using multipolarCoefficients = std::vector; diff --git a/src/pulmtln.cpp b/src/tulip.cpp similarity index 75% rename from src/pulmtln.cpp rename to src/tulip.cpp index 3da0739..1930ebf 100644 --- a/src/pulmtln.cpp +++ b/src/tulip.cpp @@ -13,20 +13,19 @@ int main(int argc, char* argv[]) po::options_description desc( "-- tulip --\n" - "Per unit length capacitance and inductance for MTL cross - sections.\n" + "Transmission line unit length conductors and in-cell parameters calculator.\n" "Visit https://github.com/OpenSEMBA/tulip for more information.\n" "Available options" ); desc.add_options() ("help,h", "this help message") - ("input,i", po::value(&inputFilename), "input filename .pulmtln.json") + ("input,i", po::value(&inputFilename), "input filename in JSON format") ; po::variables_map vm; po::store(po::parse_command_line(argc, argv, desc), vm); po::notify(vm); - if (vm.count("help") || vm.empty()) { std::cout << desc << std::endl; return 0; @@ -41,10 +40,10 @@ int main(int argc, char* argv[]) "./" + std::filesystem::path{inputFilename}.parent_path().string() + "/" }; - auto driver{ pulmtln::Driver::loadFromFile(inputFilename) }; + auto driver{ tulip::Driver::adaptFromFile(inputFilename) }; driver.setExportFolder(folder); driver.run(); - std::cout << "-- tulip finished succesfully --" << std::endl; + std::cout << "-- tulip finished successfully --" << std::endl; } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt deleted file mode 100644 index 3a967bb..0000000 --- a/test/CMakeLists.txt +++ /dev/null @@ -1,26 +0,0 @@ -cmake_minimum_required(VERSION 3.21) - -message(STATUS "Creating build system for ${PROJECT_NAME}_tests") - -find_package(GTest CONFIG REQUIRED) -include_directories(${GTEST_INCLUDE_DIRS}) - -add_executable(${PROJECT_NAME}_tests - "ElectrostaticSolverTest.cpp" - "mfemTest.cpp" - "DriverTest.cpp" - "ParserTest.cpp" - "ResultsTest.cpp" - "ModelTest.cpp" - "DirectedGraphTest.cpp" - "DomainTest.cpp" - "multipolarExpansionTest.cpp") - -include_directories(./) - -target_link_libraries(${PROJECT_NAME}_tests - pulmtln-core - GTest::gtest - GTest::gtest_main -) - diff --git a/test/adapter/BoundingBoxTest.cpp b/test/adapter/BoundingBoxTest.cpp new file mode 100644 index 0000000..1e29a57 --- /dev/null +++ b/test/adapter/BoundingBoxTest.cpp @@ -0,0 +1,102 @@ +#include + +#include + +#include "BoundingBox.h" + +using namespace step2gmsh; + +class BoundingBoxTest : public ::testing::Test { +protected: + void TearDown() override { + if (gmsh::isInitialized()) gmsh::finalize(); + } +}; + +TEST_F(BoundingBoxTest, canDefineBoundingBox) { + BoundingBox bb(-1.0, 2.0, 3.0, 5.0, 6.0, 7.0); + EXPECT_DOUBLE_EQ(bb.xMin, -1.0); + EXPECT_DOUBLE_EQ(bb.yMin, 2.0); + EXPECT_DOUBLE_EQ(bb.zMin, 3.0); + EXPECT_DOUBLE_EQ(bb.xMax, 5.0); + EXPECT_DOUBLE_EQ(bb.yMax, 6.0); + EXPECT_DOUBLE_EQ(bb.zMax, 7.0); +} + +TEST_F(BoundingBoxTest, constructFromArray) { + BoundingBox bb(std::array{0.0, 1.0, 2.0, 3.0, 4.0, 5.0}); + EXPECT_DOUBLE_EQ(bb.xMin, 0.0); + EXPECT_DOUBLE_EQ(bb.zMax, 5.0); +} + +TEST_F(BoundingBoxTest, getOrigin) { + BoundingBox bb(-1.0, 2.0, 3.0, 5.0, 6.0, 7.0); + auto origin = bb.getOrigin(); + EXPECT_DOUBLE_EQ(origin[0], -1.0); + EXPECT_DOUBLE_EQ(origin[1], 2.0); + EXPECT_DOUBLE_EQ(origin[2], 3.0); +} + +TEST_F(BoundingBoxTest, getCenter) { + BoundingBox bb(0.0, 0.0, 0.0, 4.0, 6.0, 8.0); + auto center = bb.getCenter(); + EXPECT_DOUBLE_EQ(center[0], 2.0); + EXPECT_DOUBLE_EQ(center[1], 3.0); + EXPECT_DOUBLE_EQ(center[2], 4.0); +} + +TEST_F(BoundingBoxTest, getDiagonal) { + BoundingBox bb(0.0, 0.0, 0.0, 3.0, 4.0, 0.0); + EXPECT_DOUBLE_EQ(bb.getDiagonal(), 5.0); +} + +TEST_F(BoundingBoxTest, getLengths) { + BoundingBox bb(1.0, 2.0, 3.0, 4.0, 6.0, 9.0); + auto len = bb.getLengths(); + EXPECT_DOUBLE_EQ(len[0], 3.0); + EXPECT_DOUBLE_EQ(len[1], 4.0); + EXPECT_DOUBLE_EQ(len[2], 6.0); +} + +TEST_F(BoundingBoxTest, canGetBoundingBoxFromSurface) { + gmsh::initialize(); + gmsh::model::add("Test_Model"); + + int circleTag = gmsh::model::occ::addCircle(0, 0, 0, 10, 1); + gmsh::model::occ::synchronize(); + + auto bb = BoundingBox::getBoundingBox(1, circleTag); + + EXPECT_NEAR(bb.xMin, -10.0, 1e-6); + EXPECT_NEAR(bb.yMin, -10.0, 1e-6); + EXPECT_NEAR(bb.zMin, 0.0, 1e-6); + EXPECT_NEAR(bb.xMax, 10.0, 1e-6); + EXPECT_NEAR(bb.yMax, 10.0, 1e-6); + EXPECT_NEAR(bb.zMax, 0.0, 1e-6); +} + +TEST_F(BoundingBoxTest, canGetBoundingBoxFromGroupOfSurfaces) { + gmsh::initialize(); + gmsh::model::add("Test_Model"); + + int c1 = gmsh::model::occ::addCircle(0, 0, 0, 10, 1); + int c2 = gmsh::model::occ::addCircle(0, 0, 0, 5, 2); + int c3 = gmsh::model::occ::addCircle(25, 30, 0, 10, 3); + gmsh::model::occ::synchronize(); + + std::vector> group = {{1, c1}, {1, c2}, {1, c3}}; + auto bb = BoundingBox::getBoundingBoxFromGroup(group); + + EXPECT_NEAR(bb.xMin, -10.0, 1e-6); + EXPECT_NEAR(bb.yMin, -10.0, 1e-6); + EXPECT_NEAR(bb.zMin, 0.0, 1e-6); + EXPECT_NEAR(bb.xMax, 35.0, 1e-6); + EXPECT_NEAR(bb.yMax, 40.0, 1e-6); + EXPECT_NEAR(bb.zMax, 0.0, 1e-6); +} + +TEST_F(BoundingBoxTest, emptyGroupReturnsZeroBoundingBox) { + auto bb = BoundingBox::getBoundingBoxFromGroup({}); + EXPECT_DOUBLE_EQ(bb.xMin, 0.0); + EXPECT_DOUBLE_EQ(bb.xMax, 0.0); +} diff --git a/test/adapter/CMakeLists.txt b/test/adapter/CMakeLists.txt new file mode 100644 index 0000000..d878a0c --- /dev/null +++ b/test/adapter/CMakeLists.txt @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 3.21) + +message(STATUS "Creating build system for adapter_tests") + +find_package(GTest CONFIG REQUIRED) + +add_executable(adapter_tests + GraphTest.cpp + BoundingBoxTest.cpp + ShapesClassificationTest.cpp + MesherTest.cpp +) + +target_include_directories(adapter_tests PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries(adapter_tests + tulip-adapter + GTest::gtest + GTest::gtest_main +) + +add_test( + NAME adapter_tests + COMMAND adapter_tests + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} +) diff --git a/test/adapter/GraphTest.cpp b/test/adapter/GraphTest.cpp new file mode 100644 index 0000000..916d56b --- /dev/null +++ b/test/adapter/GraphTest.cpp @@ -0,0 +1,113 @@ +#include + +#include + +#include "Graph.h" + +using namespace step2gmsh; + +class GraphTest : public ::testing::Test { +protected: + Graph graph; +}; + +TEST_F(GraphTest, addNode) { + graph.addNode("A"); + auto nodes = graph.nodes(); + EXPECT_NE(std::find(nodes.begin(), nodes.end(), "A"), nodes.end()); + + graph.addNode("A"); + int count = (int)std::count(nodes.begin(), nodes.end(), "A"); + EXPECT_EQ(count, 1); +} + +TEST_F(GraphTest, addEdge) { + graph.addEdge("A", "B"); + auto edges = graph.edges(); + EXPECT_NE(std::find(edges.begin(), edges.end(), Graph::Edge("A", "B")), edges.end()); + + auto nodes = graph.nodes(); + EXPECT_NE(std::find(nodes.begin(), nodes.end(), "A"), nodes.end()); + EXPECT_NE(std::find(nodes.begin(), nodes.end(), "B"), nodes.end()); + + graph.addEdge("A", "B"); + int count = (int)std::count(edges.begin(), edges.end(), Graph::Edge("A", "B")); + EXPECT_EQ(count, 1); +} + +TEST_F(GraphTest, settersAndGetters) { + std::vector nodes = {"X", "Y"}; + std::vector edges = {{"X", "Y"}}; + graph.setNodes(nodes); + graph.setEdges(edges); + EXPECT_EQ(graph.nodes(), nodes); + EXPECT_EQ(graph.edges(), edges); +} + +TEST_F(GraphTest, getConnections) { + graph.addEdge("A", "B"); + graph.addEdge("A", "C"); + graph.addNode("D"); + + auto connections = graph.getConnections(); + EXPECT_EQ(connections.at("A"), (std::vector{"B", "C"})); + EXPECT_TRUE(connections.at("B").empty()); + EXPECT_TRUE(connections.at("C").empty()); + EXPECT_TRUE(connections.at("D").empty()); +} + +TEST_F(GraphTest, toString) { + graph.addEdge("A", "B"); + std::string s = graph.toString(); + EXPECT_NE(s.find("A"), std::string::npos); + EXPECT_NE(s.find("B"), std::string::npos); + EXPECT_NE(s.find("Edges"), std::string::npos); +} + +TEST_F(GraphTest, pruneToLongestPaths) { + graph.setNodes({"A", "B", "C", "D", "E", "F", "G"}); + graph.setEdges({ + {"A", "B"}, {"A", "C"}, {"A", "D"}, {"A", "E"}, + {"B", "C"}, {"B", "E"}, + {"C", "E"}, + {"F", "G"} + }); + + std::vector expectedEdges = { + {"A", "B"}, {"A", "D"}, + {"B", "C"}, + {"C", "E"}, + {"F", "G"} + }; + + graph.pruneToLongestPaths(); + + auto resultEdges = graph.edges(); + std::sort(resultEdges.begin(), resultEdges.end()); + std::sort(expectedEdges.begin(), expectedEdges.end()); + EXPECT_EQ(resultEdges, expectedEdges); +} + +TEST_F(GraphTest, getNodesByLevel) { + graph.setNodes({"A", "B", "C", "D", "E", "F", "G"}); + graph.setEdges({ + {"A", "B"}, {"A", "D"}, + {"B", "C"}, + {"C", "E"}, + {"F", "G"} + }); + + std::vector expected = {"A", "F", "B", "D", "G", "C", "E"}; + EXPECT_EQ(graph.getNodesByLevels(), expected); +} + +TEST_F(GraphTest, getRoots) { + graph.setNodes({"A", "B", "C", "D", "E", "F", "G"}); + graph.setEdges({ + {"A", "B"}, {"A", "D"}, + {"B", "C"}, + {"C", "E"}, + {"F", "G"} + }); + EXPECT_EQ(graph.roots(), (std::vector{"A", "F"})); +} diff --git a/test/adapter/MesherTest.cpp b/test/adapter/MesherTest.cpp new file mode 100644 index 0000000..987be55 --- /dev/null +++ b/test/adapter/MesherTest.cpp @@ -0,0 +1,311 @@ +#include + +#include +#include +#include + +#include + +#include "AreaExporterService.h" +#include "Mesher.h" +#include "TestUtils.h" + +using namespace step2gmsh; + +class MesherTest : public ::testing::Test +{ +protected: + void SetUp() override + { + gmsh::initialize(); + gmsh::option::setNumber("General.Verbosity", 0); + } + void TearDown() override { gmsh::finalize(); } + + int countEntitiesInPhysicalGroupWithName(const std::string &name) + { + auto [dim, tag] = Mesher::getPhysicalGroupWithName(name); + if (dim < 0) { + return 0; + } + std::vector tags; + gmsh::model::getEntitiesForPhysicalGroup(dim, tag, tags); + return (int)tags.size(); + } + + // expectedCounts[i] corresponds to expectedNames[i]. If empty, entity counts are not checked. + void assertPhysicalGroups(const std::vector &expectedNames, + const std::vector &expectedCounts = {}) + { + gmsh::vectorpair pGs; + gmsh::model::getPhysicalGroups(pGs); + + std::vector pgNames; + for (const auto &[dim, tag] : pGs) + { + std::string n; + gmsh::model::getPhysicalName(dim, tag, n); + pgNames.push_back(n); + } + + auto sortedActual = pgNames; + auto sortedExpected = expectedNames; + std::sort(sortedActual.begin(), sortedActual.end()); + std::sort(sortedExpected.begin(), sortedExpected.end()); + EXPECT_EQ(sortedActual, sortedExpected); + + for (std::size_t i = 0; i < expectedCounts.size(); ++i) + { + EXPECT_EQ(countEntitiesInPhysicalGroupWithName(expectedNames[i]), + expectedCounts[i]) + << expectedNames[i]; + } + } +}; + +TEST_F(MesherTest, empty_coax) +{ + const std::string caseName = "empty_coax"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = {"Conductor_0", "Conductor_1", "Vacuum_0"}; + assertPhysicalGroups(expectedNames, {1, 1, 1}); +} + +TEST_F(MesherTest, partially_filled_coax) +{ + const std::string caseName = "partially_filled_coax"; + Mesher mesher; + mesher.meshFromStep(stepFileFromCaseName(caseName), caseName); + + gmsh::vectorpair pGs; + gmsh::model::getPhysicalGroups(pGs); + EXPECT_EQ(pGs.size(), 4u); + + std::vector pgNames; + for (const auto &[dim, tag] : pGs) + { + std::string name; + gmsh::model::getPhysicalName(dim, tag, name); + pgNames.push_back(name); + } + std::sort(pgNames.begin(), pgNames.end()); + + std::vector expected = { + "Conductor_0", "Conductor_1", "Dielectric_0", "Vacuum_0"}; + std::sort(expected.begin(), expected.end()); + EXPECT_EQ(pgNames, expected); + + for (const auto &name : expected) + { + EXPECT_EQ(countEntitiesInPhysicalGroupWithName(name), 1) << name; + } +} + +TEST_F(MesherTest, two_wires_coax) +{ + const std::string caseName = "two_wires_coax"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", "Vacuum_0"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1}); +} + +TEST_F(MesherTest, two_wires_open) +{ + const std::string caseName = "two_wires_open"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + // gmsh::write(caseName + ".msh"); + // gmsh::write(caseName + ".vtk"); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, dielectric_unshielded_pair) +{ + const std::string caseName = "DielectricUnshieldedPair"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", + "Dielectric_0", "Dielectric_1", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, dielectric_unshielded_pair_defined_boundary) +{ + const std::string caseName = "DielectricUnshieldedPairDefinedBoundary"; + auto opts = Mesher::DEFAULT_MESHING_OPTIONS; + opts["Mesh.ElementOrder"] = 1; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName, &opts); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", + "Dielectric_0", "Dielectric_1", + "OpenBoundary_0", "Vacuum_0"}; + + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1, 1}); + + // gmsh::write(caseName + ".msh"); + // gmsh::write(caseName + ".vtk"); +} + +TEST_F(MesherTest, five_wires) +{ + const std::string caseName = "five_wires"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", "Conductor_3", + "Conductor_4", "Conductor_5", + "Dielectric_0", "Dielectric_1", "Dielectric_2", "Dielectric_3", + "Dielectric_4", "Vacuum_0"}; + assertPhysicalGroups(expectedNames, + {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, three_wires_ribbon) +{ + const std::string caseName = "three_wires_ribbon"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", + "OpenBoundary_0", + "Dielectric_0", "Dielectric_1", "Dielectric_2", + "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, + {1, 1, 1, 1, 1, 1, 1, 1, 1}); + + // gmsh::write(caseName + ".msh"); + // gmsh::write(caseName + ".vtk"); +} + +TEST_F(MesherTest, nested_coax) +{ + const std::string caseName = "nested_coax"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", "Vacuum_0"}; + assertPhysicalGroups(expectedNames, {1, 2, 1, 2}); +} + +TEST_F(MesherTest, agrawal1981) +{ + const std::string caseName = "agrawal1981"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", "Conductor_3", + "Dielectric_0", "Dielectric_1", "Dielectric_2", + "Vacuum_0"}; + const std::vector expectedCounts = {2, 1, 1, 1, 1, 1, 1, 2}; + assertPhysicalGroups(expectedNames, expectedCounts); +} + +TEST_F(MesherTest, unshielded_multiwire) +{ + const std::string caseName = "unshielded_multiwire"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Dielectric_0", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, conductor_and_outer_dielectric) +{ + const std::string caseName = "conductor_and_outer_dielectric"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Dielectric_0", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 2, 1}); +} + +TEST_F(MesherTest, realistic_case_with_dielectrics_fdtd_cell) +{ + const std::string caseName = "realistic_case_with_dielectrics_fdtd_cell"; + auto opts = Mesher::DEFAULT_MESHING_OPTIONS; + opts["Mesh.ElementOrder"] = 1; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName, &opts); + + std::vector expectedNames; + for (int i = 0; i <= 30; ++i) + expectedNames.push_back("Conductor_" + std::to_string(i)); + for (int i = 0; i <= 31; ++i) + expectedNames.push_back("Dielectric_" + std::to_string(i)); + expectedNames.push_back("OpenBoundary_0"); + expectedNames.push_back("Vacuum_0"); + + assertPhysicalGroups(expectedNames); +} + +TEST_F(MesherTest, lansink2024_single_wire_multipolar) +{ + const std::string caseName = "lansink2024_single_wire_multipolar"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Dielectric_0", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, single_wire) +{ + const std::string caseName = "single_wire"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1}); +} + +TEST_F(MesherTest, unshielded_nesting) +{ + const std::string caseName = "UnshieldedNested"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", "Conductor_2", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {2, 1, 1, 1, 2, 1}); +} + +TEST_F(MesherTest, two_wires_with_touching_dielectric) +{ + const std::string caseName = "two_wires_with_touching_dielectric"; + Mesher().meshFromStep(stepFileFromCaseName(caseName), caseName); + + const std::vector expectedNames = { + "Conductor_0", "Conductor_1", + "Dielectric_0", "Dielectric_1", + "OpenBoundary_0", "Vacuum_0", "Vacuum_1"}; + assertPhysicalGroups(expectedNames, {1, 1, 1, 1, 1, 1, 1}); +} + +TEST_F(MesherTest, area_exporter_returns_true_values_for_dielectric_unshielded_pair) +{ + const std::string caseName = "DielectricUnshieldedPair"; + auto mappedElements = Mesher().meshFromStep( + stepFileFromCaseName(caseName), caseName); + + AreaExporterService exporter; + exporter.addPhysicalModelForConductors(mappedElements); + const auto &geometries = exporter.computedAreas["geometries"]; + + ASSERT_EQ(geometries.size(), 2u); + for (const auto &g : geometries) + { + EXPECT_NEAR(g["area"].get(), 201.06193, 1e-4); + } +} diff --git a/test/adapter/ShapesClassificationTest.cpp b/test/adapter/ShapesClassificationTest.cpp new file mode 100644 index 0000000..8317ade --- /dev/null +++ b/test/adapter/ShapesClassificationTest.cpp @@ -0,0 +1,171 @@ +#include + +#include +#include +#include + +#include + +#include "ShapesClassification.h" +#include "TestUtils.h" + +using namespace step2gmsh; + +class ShapesClassificationTest : public ::testing::Test { +protected: + void SetUp() override { gmsh::initialize(); } + void TearDown() override { gmsh::finalize(); } + + ShapesClassification* initShapeClassification(const std::string& inputFile) { + EntityList shapes; + gmsh::model::occ::importShapes(inputFile, shapes, false); + auto jsonFile = std::filesystem::path(inputFile).replace_extension(".json").string(); + return new ShapesClassification(shapes, jsonFile); + } +}; + +TEST_F(ShapesClassificationTest, getNumberFromName) { + EXPECT_EQ(ShapesClassification::getNumberFromName("Shapes/Conductor_1", "Conductor_"), 1); + EXPECT_EQ(ShapesClassification::getNumberFromName( + "Shapes/solid_wire_002/Conductor_002/Conductor_002", "Conductor_"), 2); +} + +TEST_F(ShapesClassificationTest, dielectricShieldedPairClassification) { + auto* sc = initShapeClassification(stepFileFromCaseName("DielectricShieldedPair")); + + EntityList expectedAllShapes = { + {2, 1},{2, 2},{2, 3},{2, 4},{2, 5}, + {1, 1},{1, 2},{1, 3},{1, 4},{1, 5}, + {0, 1},{0, 1},{0, 2},{0, 2},{0, 3},{0, 3},{0, 4},{0, 4},{0, 5},{0, 5}, + }; + EntityMap expectedPecs = { + {"RightConductor", {{2, 1}}}, + {"ExternalShield", {{2, 2}}}, + {"LeftConductor", {{2, 3}}}, + }; + EntityMap expectedDielectrics = { + {"RightDielectric", {{2, 4}}}, + {"LeftDielectric", {{2, 5}}}, + }; + + EXPECT_EQ(sc->allShapes, expectedAllShapes); + EXPECT_EQ(sc->pecs, expectedPecs); + EXPECT_EQ(sc->dielectrics, expectedDielectrics); + EXPECT_FALSE(sc->isOpenCase); + + delete sc; +} + +TEST_F(ShapesClassificationTest, dielectricUnshieldedPairClassification) { + auto* sc = initShapeClassification(stepFileFromCaseName("DielectricUnshieldedPair")); + + EntityList expectedAllShapes = { + {2, 1},{2, 2},{2, 3},{2, 4}, + {1, 1},{1, 2},{1, 3},{1, 4}, + {0, 1},{0, 1},{0, 2},{0, 2},{0, 3},{0, 3},{0, 4},{0, 4}, + }; + EntityMap expectedPecs = { + {"LeftConductor", {{2, 2}}}, + {"RightConductor", {{2, 1}}}, + }; + EntityMap expectedDielectrics = { + {"RightDielectric", {{2, 3}}}, + {"LeftDielectric", {{2, 4}}}, + }; + + EXPECT_EQ(sc->allShapes, expectedAllShapes); + EXPECT_EQ(sc->pecs, expectedPecs); + EXPECT_EQ(sc->dielectrics, expectedDielectrics); + EXPECT_TRUE(sc->isOpenCase); + + delete sc; +} + +TEST_F(ShapesClassificationTest, partiallyFilledCoaxHasTwoPecs) { + auto* sc = initShapeClassification(stepFileFromCaseName("partially_filled_coax")); + EXPECT_EQ(sc->pecs.size(), 2u); + EXPECT_EQ(sc->dielectrics.size(), 1u); + delete sc; +} + +TEST_F(ShapesClassificationTest, fusedConductors) { + auto* sc = initShapeClassification(stepFileFromCaseName("FusedConductor")); + delete sc; +} + +TEST_F(ShapesClassificationTest, complexNesting) { + auto* sc = initShapeClassification(stepFileFromCaseName("ComplexNesting")); + delete sc; +} + +TEST_F(ShapesClassificationTest, fiveWiresStepShapes) { + auto* sc = initShapeClassification(stepFileFromCaseName("five_wires")); + EXPECT_EQ(sc->pecs.size(), 6u); + EXPECT_EQ(sc->dielectrics.size(), 5u); + delete sc; +} + +TEST_F(ShapesClassificationTest, threeWiresRibbonStepShapes) { + auto* sc = initShapeClassification(stepFileFromCaseName("three_wires_ribbon")); + EXPECT_EQ(sc->open.size(), 0u); + EXPECT_EQ(sc->pecs.size(), 3u); + EXPECT_EQ(sc->dielectrics.size(), 3u); + delete sc; +} + +TEST_F(ShapesClassificationTest, conductorOnlyGraphDielectricUnshielded) { + auto* sc = initShapeClassification(stepFileFromCaseName("DielectricUnshieldedPair")); + + const Graph& originalGraph = sc->nestedGraph; + const Graph conductorGraph = sc->getConductorOnlyGraph(); + + std::set conductorNames; + for (auto& [name, _] : sc->pecs) + conductorNames.insert(name); + + std::set graphNodes( + conductorGraph.nodes().begin(), conductorGraph.nodes().end()); + + // All nodes in conductor graph should be conductors + for (auto& n : graphNodes) + EXPECT_TRUE(conductorNames.count(n) > 0); + + // The graph should contain all conductors that were in the original graph + std::set originalConductorNodes; + for (auto& n : originalGraph.nodes()) + if (conductorNames.count(n)) + originalConductorNodes.insert(n); + EXPECT_EQ(graphNodes, originalConductorNodes); + + // Verify no dielectric nodes remain + std::set dielectricNames; + for (auto& [name, _] : sc->dielectrics) + dielectricNames.insert(name); + for (auto& n : graphNodes) + EXPECT_TRUE(dielectricNames.count(n) == 0); + + delete sc; +} + +TEST_F(ShapesClassificationTest, conductorOnlyGraphFiveWires) { + auto* sc = initShapeClassification(stepFileFromCaseName("five_wires")); + + const Graph conductorGraph = sc->getConductorOnlyGraph(); + std::set graphNodes( + conductorGraph.nodes().begin(), conductorGraph.nodes().end()); + + std::set conductorNames; + for (auto& [name, _] : sc->pecs) + conductorNames.insert(name); + + std::set dielectricNames; + for (auto& [name, _] : sc->dielectrics) + dielectricNames.insert(name); + + for (auto& n : graphNodes) + EXPECT_TRUE(conductorNames.count(n) > 0); + for (auto& n : graphNodes) + EXPECT_TRUE(dielectricNames.count(n) == 0); + + delete sc; +} diff --git a/test/adapter/TestUtils.h b/test/adapter/TestUtils.h new file mode 100644 index 0000000..3830702 --- /dev/null +++ b/test/adapter/TestUtils.h @@ -0,0 +1,9 @@ +#pragma once + +#include + +static std::string testDataPath() { return "./testData/"; } + +static std::string stepFileFromCaseName(const std::string& caseName) { + return testDataPath() + caseName + "/" + caseName + ".step"; +} diff --git a/test/adapter/utils.py b/test/adapter/utils.py new file mode 100644 index 0000000..9be9f7b --- /dev/null +++ b/test/adapter/utils.py @@ -0,0 +1,30 @@ +import numpy as np +from typing import List, Union + +def assertListOfFloatsAlmostEqual(realValues, expectedValues, tolerance = 0.0000001): + if len(realValues) != len(expectedValues): + raise AssertionError("List have diferent lengths: {} != {}".format(len(realValues), len(expectedValues))) + + if not np.allclose(realValues, expectedValues, atol=tolerance): + raise AssertionError("List are not the same: {} != {}".format(realValues, expectedValues)) + +def getMinFromList(values: List[Union[float, int]]) -> Union[float, int]: + if not values: + raise ValueError("List cannot be empty") + + for value in values: + if not isinstance(value, (int, float)): + raise TypeError(f"List must contain only numbers. Found invalid value: {value} of type {type(value)}") + + return min(values) + +def getMaxFromList(values: List[Union[float, int]]) -> Union[float, int]: + if not values: + raise ValueError("List cannot be empty") + + for value in values: + if not isinstance(value, (int, float)): + raise TypeError(f"List must contain only numbers. Found invalid value: {value} of type {type(value)}") + + return max(values) + diff --git a/test/driver/CMakeLists.txt b/test/driver/CMakeLists.txt new file mode 100644 index 0000000..15bd89e --- /dev/null +++ b/test/driver/CMakeLists.txt @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.21) + +message(STATUS "Creating build system for driver_tests") + +find_package(GTest CONFIG REQUIRED) + +add_executable(driver_tests + "DriverTest.cpp" + "mfemTest.cpp" + "ResultsTest.cpp" + "DirectedGraphTest.cpp" + "DomainTest.cpp" + "multipolarExpansionTest.cpp" + "ModelTest.cpp" + "ParserTest.cpp" + "SolverTest.cpp" +) + +target_include_directories(driver_tests PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries(driver_tests + tulip-driver + GTest::gtest + GTest::gtest_main +) + +add_test( + NAME driver_tests + COMMAND driver_tests + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} +) + diff --git a/test/DirectedGraphTest.cpp b/test/driver/DirectedGraphTest.cpp similarity index 98% rename from test/DirectedGraphTest.cpp rename to test/driver/DirectedGraphTest.cpp index 2343b20..3c779a9 100644 --- a/test/DirectedGraphTest.cpp +++ b/test/driver/DirectedGraphTest.cpp @@ -4,7 +4,7 @@ class DirectedGraphTest : public ::testing::Test {}; -using namespace pulmtln; +using namespace tulip; TEST_F(DirectedGraphTest, getVertices) { diff --git a/test/DomainTest.cpp b/test/driver/DomainTest.cpp similarity index 98% rename from test/DomainTest.cpp rename to test/driver/DomainTest.cpp index 38331b7..fd8ff0c 100644 --- a/test/DomainTest.cpp +++ b/test/driver/DomainTest.cpp @@ -5,7 +5,7 @@ #include "Domain.h" #include "Parser.h" -using namespace pulmtln; +using namespace tulip; class DomainTest : public ::testing::Test {}; diff --git a/test/DriverTest.cpp b/test/driver/DriverTest.cpp similarity index 88% rename from test/DriverTest.cpp rename to test/driver/DriverTest.cpp index cd07a29..1f2657f 100644 --- a/test/DriverTest.cpp +++ b/test/driver/DriverTest.cpp @@ -4,9 +4,9 @@ #include "constants.h" #include "Driver.h" -#include "ElectrostaticSolver.h" +#include "Solver.h" -using namespace pulmtln; +using namespace tulip; using json = nlohmann::json; @@ -15,7 +15,7 @@ class DriverTest : public ::testing::Test {}; TEST_F(DriverTest, empty_coax) { // Empty Coaxial case. - auto out{ Driver::loadFromFile(inputCase("empty_coax")).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(inputCase("empty_coax")).getPULMTL() }; auto CExpected{ EPSILON0_SI * 2 * M_PI / log(0.05 / 0.025) }; @@ -36,7 +36,7 @@ TEST_F(DriverTest, partially_filled_coax) // Dielectric internal radius -> rI_dielectric = 25 mm // Dielectric external radius -> rO_dielectric = 35 mm // Dielectric permittivity -> eps_r = 4.0 - auto out{ Driver::loadFromFile(inputCase("partially_filled_coax")).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(inputCase("partially_filled_coax")).getPULMTL() }; // Equivalent capacity is the series of the inner and outer capacitors. auto COut{ EPSILON0_SI * 2 * M_PI / log(0.050 / 0.035) }; @@ -57,7 +57,7 @@ TEST_F(DriverTest, partially_filled_coax) TEST_F(DriverTest, partially_filled_coax_by_domains) { - auto dr{ Driver::loadFromFile(inputCase("partially_filled_coax")) }; + auto dr{ Driver::loadFromAdaptedFile(inputCase("partially_filled_coax")) }; auto globalOut{ dr.getPULMTL() }; auto out{ dr.getPULMTLByDomains() }; @@ -79,7 +79,7 @@ TEST_F(DriverTest, partially_filled_coax_by_domains) TEST_F(DriverTest, two_wires_coax) { const std::string CASE{ "two_wires_coax" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; mfem::DenseMatrix CMatExpected(2, 2); CMatExpected(0, 0) = 2.15605359; @@ -90,7 +90,7 @@ TEST_F(DriverTest, two_wires_coax) const double rTol{ 2.5e-2 }; - auto out{ Driver::loadFromFile(fn).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(fn).getPULMTL() }; const int N{ 2 }; ASSERT_EQ(N, out.C.NumCols()); @@ -115,11 +115,11 @@ TEST_F(DriverTest, two_wires_coax) TEST_F(DriverTest, two_wires_shielded_floating_potentials) { const std::string CASE{ "two_wires_shielded" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; const double rTol{ 2.5e-2 }; - auto fp{ Driver::loadFromFile(fn).getFloatingPotentials().electric }; + auto fp{ Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric }; const int N{ 2 }; ASSERT_EQ(N, fp.NumCols()); @@ -139,11 +139,11 @@ TEST_F(DriverTest, two_wires_shielded_floating_potentials) }; SolverOptions solverOpts; - ElectrostaticSolver s{ m, p, solverOpts }; + tulip::Solver s{ m, p, solverOpts }; s.Solve(); // For debugging. - ParaViewDataCollection pd{ outFolder() + CASE + "_floating", s.getMesh() }; + ParaViewDataCollection pd(outFolder() + CASE + "_floating", s.getMesh()); s.writeParaViewFields(pd); auto Q0 = s.getChargeInBoundary(1); @@ -157,9 +157,9 @@ TEST_F(DriverTest, two_wires_shielded_floating_potentials) TEST_F(DriverTest, two_wires_open_floating_potentials) { const std::string CASE{ "two_wires_open" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; - auto fp{ Driver::loadFromFile(fn).getFloatingPotentials().electric }; + auto fp{ Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric }; const int N{ 2 }; ASSERT_EQ(N, fp.NumCols()); @@ -179,11 +179,11 @@ TEST_F(DriverTest, two_wires_open_floating_potentials) }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); // For debugging. - ParaViewDataCollection pd{ outFolder() + CASE + "_floating", s.getMesh() }; + ParaViewDataCollection pd(outFolder() + CASE + "_floating", s.getMesh()); s.writeParaViewFields(pd); auto Q0 = s.getChargeInBoundary(1); @@ -201,7 +201,7 @@ TEST_F(DriverTest, five_wires) // Comparison with SACAMOS data (No Laplace). const std::string CASE{ "five_wires" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; mfem::DenseMatrix couplingExpected(5, 5); double couplingExpectedData[25] = { @@ -214,7 +214,7 @@ TEST_F(DriverTest, five_wires) couplingExpected.UseExternalData(couplingExpectedData, 5, 5); auto out{ - Driver::loadFromFile(fn).getPULMTL().getCapacitiveCouplingCoefficients() + Driver::loadFromAdaptedFile(fn).getPULMTL().getCapacitiveCouplingCoefficients() }; ASSERT_EQ(couplingExpected.NumRows(), out.NumRows()); @@ -237,7 +237,7 @@ TEST_F(DriverTest, three_wires_ribbon) // Sec. 5.2.3, p. 187. const std::string CASE{ "three_wires_ribbon" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; double CExpectedData[4] = { 37.432, -18.716, @@ -255,7 +255,7 @@ TEST_F(DriverTest, three_wires_ribbon) LExpected.UseExternalData(LExpectedData, 2, 2); LExpected *= 1e-6; - auto out{ Driver::loadFromFile(fn).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(fn).getPULMTL() }; const double rTol{ 0.0025 }; ASSERT_EQ(CExpected.NumRows(), out.C.NumRows()); @@ -285,9 +285,9 @@ TEST_F(DriverTest, three_wires_ribbon_generalized_capacitance) // Sec. 5.2.3, p. 187. const std::string CASE{ "three_wires_ribbon" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; - auto dr = Driver::loadFromFile(fn); + auto dr = Driver::loadFromAdaptedFile(fn); double gCExpectedData[9] = { 26.2148, -18.0249, -5.03325, @@ -320,9 +320,9 @@ TEST_F(DriverTest, three_wires_ribbon_floating_potentials) // Sec. 5.2.3, p. 187. const std::string CASE{ "three_wires_ribbon" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; - auto fp = Driver::loadFromFile(fn).getFloatingPotentials().electric; + auto fp = Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric; // Solves problem and checks that charge is zero in the floating conductor. { @@ -347,12 +347,12 @@ TEST_F(DriverTest, three_wires_ribbon_floating_potentials) }; SolverOptions solverOpts; - ElectrostaticSolver s{ m, p, solverOpts }; + tulip::Solver s{ m, p, solverOpts }; s.Solve(); // For debugging. - ParaViewDataCollection pd{ outFolder() + CASE + "_floating", s.getMesh() }; - s.writeParaViewFields(pd); + // ParaViewDataCollection pd(outFolder() + CASE + "_floating", s.getMesh()); + // s.writeParaViewFields(pd); auto Q0 = s.getChargeInBoundary(1); auto Q1 = s.getChargeInBoundary(2); @@ -368,7 +368,7 @@ TEST_F(DriverTest, three_wires_ribbon_floating_potentials) TEST_F(DriverTest, nested_coax) { - auto out{ Driver::loadFromFile(inputCase("nested_coax")).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(inputCase("nested_coax")).getPULMTL() }; auto C01{ EPSILON0_SI * 2.0 * M_PI / log(8.0 / 5.6) }; @@ -395,7 +395,7 @@ TEST_F(DriverTest, nested_coax) TEST_F(DriverTest, DISABLED_nested_coax_by_domains) // Fails when enforcing conductors to start in zero and be consecutive. { - auto out{ Driver::loadFromFile(inputCase("nested_coax")).getPULMTLByDomains() }; + auto out{ Driver::loadFromAdaptedFile(inputCase("nested_coax")).getPULMTLByDomains() }; auto C01{ EPSILON0_SI * 2.0 * M_PI / log(8.0 / 5.6) }; auto C12{ EPSILON0_SI * 2.0 * M_PI / log(4.8 / 2.0) }; @@ -422,7 +422,7 @@ TEST_F(DriverTest, agrawal1981) // Transmission Lines in the Time Domain. IEEE-TEMC. 1981. const std::string CASE{ "agrawal1981" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; // P.U.L. Capacitances obtained from eigenvectors. const int nConductors = 3; @@ -435,7 +435,7 @@ TEST_F(DriverTest, agrawal1981) CExpected.UseExternalData(CExpectedData, nConductors, nConductors); CExpected *= 1e-12; - auto out{ Driver::loadFromFile(fn).getPULMTL() }; + auto out{ Driver::loadFromAdaptedFile(fn).getPULMTL() }; const double rTol{ 0.10 }; @@ -459,7 +459,7 @@ TEST_F(DriverTest, lansink2024_floating_potentials) const std::string CASE{ "lansink2024" }; - auto dr{ Driver::loadFromFile(casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json") }; + auto dr{ Driver::loadFromAdaptedFile(casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json") }; auto fp{ dr.getFloatingPotentials().electric }; auto inCell{ dr.getInCellPotentials() }; @@ -475,7 +475,7 @@ TEST_F(DriverTest, lansink2024_floating_potentials) }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); auto Q0 = s.getChargeInBoundary(1); @@ -483,7 +483,7 @@ TEST_F(DriverTest, lansink2024_floating_potentials) auto Qb = s.getChargeInBoundary(3); // For debugging. - ParaViewDataCollection pd{ outFolder() + CASE + "_floating", s.getMesh() }; + ParaViewDataCollection pd(outFolder() + CASE + "_floating", s.getMesh()); s.writeParaViewFields(pd); // Expectations. @@ -506,8 +506,8 @@ TEST_F(DriverTest, lansink2024_fdtd_in_cell_parameters_around_conductor_1) const std::string CASE{ "lansink2024_fdtd_cell" }; auto inCell{ - Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" ).getInCellPotentials() }; @@ -552,8 +552,8 @@ TEST_F(DriverTest, lansink2024_two_wires_using_multipolar_expansion) const std::string CASE{ "lansink2024" }; auto inCell{ - Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" ).getInCellPotentials() }; @@ -608,8 +608,8 @@ TEST_F(DriverTest, lansink2024_fdtd_cell_shifted_and_centered) const std::string CASE{ "lansink2024" }; auto inCell{ - Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" ).getInCellPotentials() }; @@ -657,8 +657,8 @@ TEST_F(DriverTest, lansink2024_single_wire_in_cell_parameters) const std::string CASE{ "lansink2024_single_wire" }; auto inCell{ - Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" ).getInCellPotentials() }; @@ -695,8 +695,8 @@ TEST_F(DriverTest, lansink2024_single_wire_multipolar_in_cell_parameters) const std::string CASE{ "lansink2024_single_wire_multipolar" }; auto inCell{ - Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" ).getInCellPotentials() }; @@ -733,9 +733,9 @@ TEST_F(DriverTest, lansink2024_single_wire_multipolar_in_cell_parameters) TEST_F(DriverTest, getCFromGeneralizedC_two_wires_open) { const std::string CASE{ "two_wires_open" }; - auto fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + auto fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; - auto gC{ Driver::loadFromFile(fn).getGeneralizedCMatrix() }; + auto gC{ Driver::loadFromAdaptedFile(fn).getGeneralizedCMatrix() }; double d = 50; double rw1 = 2; @@ -800,8 +800,8 @@ TEST_F(DriverTest, lansink2024_small_one_centered_fdtd_cell_vs_multipolar) InCellPotentials fdtdCellPotentials; { const std::string CASE{ "lansink2024_small_one_centered_fdtd_cell" }; - fdtdCellPotentials = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + fdtdCellPotentials = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); } auto fdtdCellComputedC00 = fdtdCellPotentials.getCapacitanceUsingInnerRegion(0, 0); auto fdtdCellComputedC01 = fdtdCellPotentials.getCapacitanceUsingInnerRegion(0, 1); @@ -810,8 +810,8 @@ TEST_F(DriverTest, lansink2024_small_one_centered_fdtd_cell_vs_multipolar) InCellPotentials multipolarPotentials; { const std::string CASE{ "lansink2024_small_one_centered" }; - multipolarPotentials = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + multipolarPotentials = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); } Box fdtdCell{ {-0.1, -0.1}, {0.1, 0.1} }; auto multipolarComputedC00 = multipolarPotentials.getCapacitanceOnBox(0, 0, fdtdCell); @@ -834,8 +834,8 @@ TEST_F(DriverTest, lansink2024_large_one_centered_fdtd_cell) InCellPotentials fdtdCellPotentials; { const std::string CASE{ "lansink2024_large_one_centered_fdtd_cell" }; - fdtdCellPotentials = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + fdtdCellPotentials = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); } auto fdtdCellComputedC10 = fdtdCellPotentials.getCapacitanceUsingInnerRegion(1, 0); @@ -849,8 +849,8 @@ TEST_F(DriverTest, lansink2024_small_one_centered_different_integration_centers) InCellPotentials multipolarPotentials; const std::string CASE{ "lansink2024_small_one_centered" }; - multipolarPotentials = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + multipolarPotentials = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); mfem::DenseMatrix geometricC(2, 2); Box fdtdCellCenteredOnConductor0{ {-0.1, -0.1}, {0.1, 0.1} }; @@ -887,8 +887,8 @@ TEST_F(DriverTest, DISABLED_realistic_case_with_dielectrics_fdtd_cell) InCellPotentials fdtdCellPotentials; { const std::string CASE{ "realistic_case_with_dielectrics_fdtd_cell" }; - fdtdCellPotentials = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + fdtdCellPotentials = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); } auto fdtdCellComputedC_0 = fdtdCellPotentials.getCapacitanceUsingInnerRegion(0, 0); auto fdtdCellComputedC_16 = fdtdCellPotentials.getCapacitanceUsingInnerRegion(0, 16); @@ -906,8 +906,8 @@ TEST_F(DriverTest, realistic_case_with_dielectrics) InCellPotentials mP; { const std::string CASE{ "realistic_case_with_dielectrics" }; - mP = Driver::loadFromFile( - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json").getInCellPotentials(); + mP = Driver::loadFromAdaptedFile( + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json").getInCellPotentials(); } Box fdtdCellCenteredOnConductor0{ {-0.016209, -0.009066}, {0.013791, 0.020934} }; diff --git a/test/ModelTest.cpp b/test/driver/ModelTest.cpp similarity index 87% rename from test/ModelTest.cpp rename to test/driver/ModelTest.cpp index 90fcc33..f21acb1 100644 --- a/test/ModelTest.cpp +++ b/test/driver/ModelTest.cpp @@ -4,7 +4,7 @@ #include "Parser.h" #include "TestUtils.h" -using namespace pulmtln; +using namespace tulip; class ModelTest : public ::testing::Test {}; @@ -16,14 +16,6 @@ TEST_F(ModelTest, empty_coax_is_closed) ); } -TEST_F(ModelTest, agrawal1981_is_semiopen) -{ - EXPECT_EQ( - Parser{ inputCase("agrawal1981") }.readModel().determineOpenness(), - Model::Openness::semiopen - ); -} - TEST_F(ModelTest, three_wires_ribbon_is_open) { EXPECT_EQ( diff --git a/test/ParserTest.cpp b/test/driver/ParserTest.cpp similarity index 88% rename from test/ParserTest.cpp rename to test/driver/ParserTest.cpp index 642370f..f42c9f7 100644 --- a/test/ParserTest.cpp +++ b/test/driver/ParserTest.cpp @@ -4,7 +4,7 @@ #include "TestUtils.h" #include "constants.h" -using namespace pulmtln; +using namespace tulip; class ParserTest : public ::testing::Test {}; @@ -12,7 +12,7 @@ TEST_F(ParserTest, empty_coax) { const std::string CASE{ "empty_coax" }; Parser parser{ - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto opts{ parser.readDriverOptions() }; @@ -41,7 +41,7 @@ TEST_F(ParserTest, partially_filled_coax) { const std::string CASE{ "partially_filled_coax" }; Parser parser{ - casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" + casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto opts{ parser.readDriverOptions() }; @@ -72,7 +72,7 @@ TEST_F(ParserTest, partially_filled_coax) TEST_F(ParserTest, hasDielectrics_returns_false_for_vacuum_only_case) { const std::string CASE{ "empty_coax" }; - Parser parser{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + Parser parser{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ parser.readModel() }; EXPECT_FALSE(model.getMaterials().hasDielectrics()); } @@ -80,7 +80,7 @@ TEST_F(ParserTest, hasDielectrics_returns_false_for_vacuum_only_case) TEST_F(ParserTest, hasDielectrics_returns_true_when_dielectric_present) { const std::string CASE{ "partially_filled_coax" }; - Parser parser{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + Parser parser{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ parser.readModel() }; EXPECT_TRUE(model.getMaterials().hasDielectrics()); } diff --git a/test/ResultsTest.cpp b/test/driver/ResultsTest.cpp similarity index 99% rename from test/ResultsTest.cpp rename to test/driver/ResultsTest.cpp index ddeb7ec..3bc16f2 100644 --- a/test/ResultsTest.cpp +++ b/test/driver/ResultsTest.cpp @@ -4,7 +4,7 @@ #include "Results.h" -using namespace pulmtln; +using namespace tulip; using json = nlohmann::json; diff --git a/test/ElectrostaticSolverTest.cpp b/test/driver/SolverTest.cpp similarity index 86% rename from test/ElectrostaticSolverTest.cpp rename to test/driver/SolverTest.cpp index 29112e8..a15e470 100644 --- a/test/ElectrostaticSolverTest.cpp +++ b/test/driver/SolverTest.cpp @@ -3,12 +3,12 @@ #include #include "TestUtils.h" -#include "ElectrostaticSolver.h" +#include "Solver.h" #include "Parser.h" #include "Driver.h" using namespace mfem; -using namespace pulmtln; +using namespace tulip; Vector getBaricenterOfElement(Mesh& mesh, int e) { @@ -32,17 +32,17 @@ void wireField(const Vector& pos, Vector& res) res /= (norm * 2.0 * M_PI); } -void exportSolution(ElectrostaticSolver& s, const std::string& caseName) +void exportSolution(tulip::Solver& s, const std::string& caseName) { - ParaViewDataCollection paraview_dc{ outFolder() + caseName, s.getMesh() }; + ParaViewDataCollection paraview_dc(outFolder() + caseName, s.getMesh()); s.writeParaViewFields(paraview_dc); } -class ElectrostaticSolverTest : public ::testing::Test { +class SolverTest : public ::testing::Test { }; -TEST_F(ElectrostaticSolverTest, parallel_plates) +TEST_F(SolverTest, parallel_plates) { // 0 V // +-----+ @@ -61,7 +61,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates) } }; - ElectrostaticSolver s{m, params}; + tulip::Solver s{m, params}; s.Solve(); exportSolution(s, "parallel_plates"); @@ -85,7 +85,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates) } -TEST_F(ElectrostaticSolverTest, parallel_plates_energy) +TEST_F(SolverTest, parallel_plates_energy) { // 0 V // +-----+ @@ -104,7 +104,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_energy) } }; - ElectrostaticSolver s{ m, params }; + tulip::Solver s{ m, params }; s.Solve(); // Expected energy formula (1/2) * epsilon_0 * E^2 * A. @@ -116,7 +116,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_energy) } -TEST_F(ElectrostaticSolverTest, parallel_plates_neumann) +TEST_F(SolverTest, parallel_plates_neumann) { // Q = -1 // +-----+ @@ -135,7 +135,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_neumann) } }; - ElectrostaticSolver s{ m, params }; + tulip::Solver s{ m, params }; s.Solve(); exportSolution(s, "parallel_plates_neumann"); @@ -152,7 +152,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_neumann) } -TEST_F(ElectrostaticSolverTest, parallel_plates_epsr2) +TEST_F(SolverTest, parallel_plates_epsr2) { // 0 V // +-----+ @@ -170,7 +170,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_epsr2) } }; p.domainPermittivities = {{ {1, 2.0} }}; - ElectrostaticSolver s{m, p, SolverOptions{}}; + tulip::Solver s{m, p, SolverOptions{}}; s.Solve(); exportSolution(s, "Parallel_plates_epsr2"); @@ -179,7 +179,7 @@ TEST_F(ElectrostaticSolverTest, parallel_plates_epsr2) EXPECT_LE(relError(2.0, s.getChargeInBoundary(1)), tol); } -TEST_F(ElectrostaticSolverTest, two_materials) +TEST_F(SolverTest, two_materials) { // 0 V, Bdr 3 // +-------------+ @@ -205,7 +205,7 @@ TEST_F(ElectrostaticSolverTest, two_materials) } }; p.domainPermittivities = { {{2, 4.0}} }; - ElectrostaticSolver s{m, p}; + tulip::Solver s{m, p}; s.Solve(); exportSolution(s, "two_materials"); @@ -220,7 +220,7 @@ TEST_F(ElectrostaticSolverTest, two_materials) } -TEST_F(ElectrostaticSolverTest, empty_coax_charge_in_boundaries) +TEST_F(SolverTest, empty_coax_charge_in_boundaries) { // Coaxial case. const std::string CASE{ "empty_coax" }; @@ -233,7 +233,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_charge_in_boundaries) {2, V}, // inner boundary }}; - ElectrostaticSolver s{m, p}; + tulip::Solver s{m, p}; s.Solve(); exportSolution(s, getCaseName()); @@ -248,7 +248,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_charge_in_boundaries) EXPECT_LE(relError(-QExpected, s.getChargeInBoundary(1)), rTol); // Boundary 1 is the external. } -TEST_F(ElectrostaticSolverTest, empty_coax_average_potential) +TEST_F(SolverTest, empty_coax_average_potential) { // Coaxial case. const std::string CASE{ "empty_coax" }; @@ -260,7 +260,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_average_potential) } }; p.openBoundaries = { 1 }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); exportSolution(s, getCaseName()); @@ -281,7 +281,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_average_potential) } -TEST_F(ElectrostaticSolverTest, empty_coax_neumann) +TEST_F(SolverTest, empty_coax_neumann) { // Coaxial case. const std::string CASE{ "empty_coax" }; @@ -296,7 +296,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_neumann) {1, 0.0}, // Outer boundary. } }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); exportSolution(s, getCaseName()); @@ -306,7 +306,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_neumann) EXPECT_LE(relError(-1.0, s.getChargeInBoundary(1)), rTol); // Boundary 1 is the external. } -TEST_F(ElectrostaticSolverTest, empty_coax_neumann_quadrupole) +TEST_F(SolverTest, empty_coax_neumann_quadrupole) { // Coaxial case. const std::string CASE{ "empty_coax" }; @@ -321,7 +321,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_neumann_quadrupole) }; Vector origin({ 0.0, 0.0 }); - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; // Sets multipolar expansion over internal boundary. { @@ -350,7 +350,7 @@ TEST_F(ElectrostaticSolverTest, empty_coax_neumann_quadrupole) EXPECT_NEAR(0.0, s.getChargeInBoundary(1), aTol); // Boundary 1 is the external. } -TEST_F(ElectrostaticSolverTest, wire_in_open_region) +TEST_F(SolverTest, wire_in_open_region) { // Coaxial case. const std::string CASE{ "empty_coax" }; @@ -362,7 +362,7 @@ TEST_F(ElectrostaticSolverTest, wire_in_open_region) } }; p.openBoundaries = { 1 }; // Outer boundary. - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); exportSolution(s, getCaseName()); @@ -391,7 +391,7 @@ TEST_F(ElectrostaticSolverTest, wire_in_open_region) } -TEST_F(ElectrostaticSolverTest, two_wires_coax) +TEST_F(SolverTest, two_wires_coax) { const std::string CASE{ "two_wires_coax" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -404,7 +404,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_coax) {3, 0.0}, // Conductor 2 bdr. } }; - ElectrostaticSolver s{m, p}; + tulip::Solver s{m, p}; s.Solve(); exportSolution(s, getCaseName()); @@ -418,7 +418,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_coax) EXPECT_LE(relError(C12Expected, s.getChargeInBoundary(3) / V), rTol); } -TEST_F(ElectrostaticSolverTest, two_wires_open_capacitance) +TEST_F(SolverTest, two_wires_open_capacitance) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -431,7 +431,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_capacitance) } }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); exportSolution(s, getCaseName()); @@ -457,7 +457,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_capacitance) EXPECT_LE(relError(CExpected, CComputedEnergy), rTol); } -TEST_F(ElectrostaticSolverTest, two_wires_open_monopolar_moment) +TEST_F(SolverTest, two_wires_open_monopolar_moment) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -469,7 +469,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_monopolar_moment) {2, 1.0}, // Conductor 2 bdr. } }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); auto Q1{ s.getChargeInBoundary(1) }; @@ -485,7 +485,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_monopolar_moment) exportSolution(s, getCaseName()); } -TEST_F(ElectrostaticSolverTest, two_wires_open_boundary_charges) +TEST_F(SolverTest, two_wires_open_boundary_charges) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -498,7 +498,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_boundary_charges) } }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); exportSolution(s, getTestCaseName()); @@ -522,7 +522,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_boundary_charges) EXPECT_LE(relError(CFromEnergy, CFromCharge), 1e-3); } -TEST_F(ElectrostaticSolverTest, two_wires_open_multipolarCoefficients_with_same_potential) +TEST_F(SolverTest, two_wires_open_multipolarCoefficients_with_same_potential) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -535,7 +535,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_multipolarCoefficients_with_same_ {2, 1.0}, // Conductor 2 bdr. } }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); auto Q1 = s.getChargeInBoundary(1); @@ -559,7 +559,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_multipolarCoefficients_with_same_ EXPECT_NEAR(0.0, ab[2].second, aTol); } -TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_same_potential) +TEST_F(SolverTest, two_wires_open_center_of_charge_with_same_potential) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -571,7 +571,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_same_potent {2, 1.0}, // Conductor 2 bdr. } }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); auto centerOfCharge{ s.getCenterOfCharge() }; EXPECT_NEAR(0.0, centerOfCharge[0], 5e-6); @@ -580,7 +580,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_same_potent exportSolution(s, getCaseName()); } -TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_floating_potential) +TEST_F(SolverTest, two_wires_open_center_of_charge_with_floating_potential) { const std::string CASE{ "two_wires_open" }; auto m{ Mesh::LoadFromFile(casesFolder() + CASE + "/" + CASE + ".msh") }; @@ -593,7 +593,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_floating_po {2, 0.48228164}, // Conductor 2, floating, zero charge. } }; - ElectrostaticSolver s{ m, p }; + tulip::Solver s{ m, p }; s.Solve(); ASSERT_NEAR(0.0, s.getChargeInBoundary(2), 5e-5); @@ -605,7 +605,7 @@ TEST_F(ElectrostaticSolverTest, two_wires_open_center_of_charge_with_floating_po exportSolution(s, getCaseName()); } -TEST_F(ElectrostaticSolverTest, three_wires_ribbon_zero_net_charge) +TEST_F(SolverTest, three_wires_ribbon_zero_net_charge) { // Three wires ribbon open problem. // Comparison with Clayton Paul's book: @@ -625,7 +625,7 @@ TEST_F(ElectrostaticSolverTest, three_wires_ribbon_zero_net_charge) }; SolverOptions solverOpts; - ElectrostaticSolver s{ m, p, solverOpts }; + tulip::Solver s{ m, p, solverOpts }; s.Solve(); exportSolution(s, getCaseName()); @@ -637,7 +637,7 @@ TEST_F(ElectrostaticSolverTest, three_wires_ribbon_zero_net_charge) EXPECT_NEAR(0.0, Q0+Q1+Q2+Qb, 1e-4); } -TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C00_with_floating) +TEST_F(SolverTest, lansink2024_fdtd_in_cell_C00_with_floating) { // From: // Rotgerink, J.L. et al. (2024, September). @@ -646,10 +646,10 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C00_with_floating) // EMC Europe(pp. 334 - 339). IEEE. const std::string CASE{ "lansink2024_fdtd_cell" }; - const std::string fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + const std::string fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ Parser{fn}.readModel() }; - auto fp = Driver::loadFromFile(fn).getFloatingPotentials().electric; + auto fp = Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric; SolverInputs p; p.dirichletBoundaries = { @@ -660,7 +660,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C00_with_floating) }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ *model.getMesh(), p }; + tulip::Solver s{ *model.getMesh(), p }; s.Solve(); auto avVVacuum = s.getAveragePotentialInDomain(5); @@ -692,7 +692,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C00_with_floating) EXPECT_NEAR(0.0, Q1, 0.005); } -TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C01_with_floating) +TEST_F(SolverTest, lansink2024_fdtd_in_cell_C01_with_floating) { // From: // Rotgerink, J.L. et al. (2024, September). @@ -701,10 +701,10 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C01_with_floating) // EMC Europe(pp. 334 - 339). IEEE. const std::string CASE{ "lansink2024_fdtd_cell" }; - const std::string fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + const std::string fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ Parser{fn}.readModel() }; - auto fp = Driver::loadFromFile(fn).getFloatingPotentials().electric; + auto fp = Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric; SolverInputs p; p.dirichletBoundaries = { @@ -715,7 +715,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C01_with_floating) }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ *model.getMesh(), p }; + tulip::Solver s{ *model.getMesh(), p }; s.Solve(); auto avVVacuum = s.getAveragePotentialInDomain(5); @@ -747,7 +747,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_fdtd_in_cell_C01_with_floating) EXPECT_NEAR(0.0, Q0, 0.005); } -TEST_F(ElectrostaticSolverTest, lansink2024_single_wire_L00_with_floating) +TEST_F(SolverTest, lansink2024_single_wire_L00_with_floating) { // From: // Rotgerink, J.L. et al. (2024, September). @@ -756,10 +756,10 @@ TEST_F(ElectrostaticSolverTest, lansink2024_single_wire_L00_with_floating) // EMC Europe(pp. 334 - 339). IEEE. const std::string CASE{ "lansink2024_single_wire" }; - const std::string fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + const std::string fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ Parser{fn}.readModel() }; - auto fp = Driver::loadFromFile(fn).getFloatingPotentials().electric; + auto fp = Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric; SolverInputs p; p.dirichletBoundaries = { @@ -769,7 +769,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_single_wire_L00_with_floating) }; p.openBoundaries = { 2 }; - ElectrostaticSolver s{ *model.getMesh(), p }; + tulip::Solver s{ *model.getMesh(), p }; s.Solve(); auto avVVacuum = s.getAveragePotentialInDomain(4); @@ -800,7 +800,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_single_wire_L00_with_floating) EXPECT_NEAR(0.0, relError(expectedL00, computedL00), rTol); } -TEST_F(ElectrostaticSolverTest, lansink2024_small_one_centered_bem_comparison) +TEST_F(SolverTest, lansink2024_small_one_centered_bem_comparison) { // Case from: // Rotgerink, J.L. et al. (2024, September). @@ -812,10 +812,10 @@ TEST_F(ElectrostaticSolverTest, lansink2024_small_one_centered_bem_comparison) // This test compares multipolar expansion results between Tulip and BEM. const std::string CASE{ "lansink2024_small_one_centered" }; - const std::string fn{ casesFolder() + CASE + "/" + CASE + ".pulmtln.in.json" }; + const std::string fn{ casesFolder() + CASE + "/" + CASE + ".tulip.adapted.json" }; auto model{ Parser{fn}.readModel() }; - auto fp = Driver::loadFromFile(fn).getFloatingPotentials().electric; + auto fp = Driver::loadFromAdaptedFile(fn).getFloatingPotentials().electric; SolverInputs p; p.dirichletBoundaries = { @@ -826,7 +826,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_small_one_centered_bem_comparison) }; p.openBoundaries = { 3 }; - ElectrostaticSolver s{ *model.getMesh(), p }; + tulip::Solver s{ *model.getMesh(), p }; s.Solve(); @@ -871,7 +871,7 @@ TEST_F(ElectrostaticSolverTest, lansink2024_small_one_centered_bem_comparison) // Computes and exports multipolar expansion with center of charge. { - ElectrostaticSolver s{ *model.getMesh(), p }; + tulip::Solver s{ *model.getMesh(), p }; s.Solve(); auto centerOfCharge = s.getCenterOfCharge(); auto mCoeff = s.getMultipolarCoefficients(order); diff --git a/test/TestUtils.h b/test/driver/TestUtils.h similarity index 94% rename from test/TestUtils.h rename to test/driver/TestUtils.h index e6253bc..6c98f1c 100644 --- a/test/TestUtils.h +++ b/test/driver/TestUtils.h @@ -18,7 +18,7 @@ static std::string smbCase(const std::string& name) static std::string inputCase(const std::string& name) { - return casesFolder() + name + "/" + name + ".pulmtln.in.json"; + return casesFolder() + name + "/" + name + ".tulip.adapted.json"; } static std::string getCaseName() diff --git a/test/mfemTest.cpp b/test/driver/mfemTest.cpp similarity index 98% rename from test/mfemTest.cpp rename to test/driver/mfemTest.cpp index c85e836..34d0b85 100644 --- a/test/mfemTest.cpp +++ b/test/driver/mfemTest.cpp @@ -3,7 +3,7 @@ #include "FES.h" using namespace mfem; -using namespace pulmtln; +using namespace tulip; class mfemTest : public ::testing::Test { }; diff --git a/test/multipolarExpansionTest.cpp b/test/driver/multipolarExpansionTest.cpp similarity index 96% rename from test/multipolarExpansionTest.cpp rename to test/driver/multipolarExpansionTest.cpp index 704724a..31e12cc 100644 --- a/test/multipolarExpansionTest.cpp +++ b/test/driver/multipolarExpansionTest.cpp @@ -3,7 +3,7 @@ #include "multipolarExpansion.h" using namespace mfem; -using namespace pulmtln; +using namespace tulip; class multipolarExpansionTest : public ::testing::Test { }; diff --git a/testData/ComplexNesting/ComplexNesting.FCStd b/testData/ComplexNesting/ComplexNesting.FCStd new file mode 100644 index 0000000..50fc6a8 Binary files /dev/null and b/testData/ComplexNesting/ComplexNesting.FCStd differ diff --git a/testData/ComplexNesting/ComplexNesting.json b/testData/ComplexNesting/ComplexNesting.json new file mode 100644 index 0000000..27d4154 --- /dev/null +++ b/testData/ComplexNesting/ComplexNesting.json @@ -0,0 +1,46 @@ +{ + "CrossSection":[ + { + "name":"Right", + "material":{ + "type":"PEC" + } + }, + { + "name":"Left", + "material":{ + "type":"PEC" + } + }, + { + "name":"SubLeftA", + "material":{ + "type":"PEC" + } + }, + { + "name":"SubLeftB", + "material":{ + "type":"PEC" + } + }, + { + "name":"SubLeftA1", + "material":{ + "type":"PEC" + } + }, + { + "name":"SubLeftA2", + "material":{ + "type":"PEC" + } + }, + { + "name":"SubRightA", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/ComplexNesting/ComplexNesting.step b/testData/ComplexNesting/ComplexNesting.step new file mode 100644 index 0000000..edb619f --- /dev/null +++ b/testData/ComplexNesting/ComplexNesting.step @@ -0,0 +1,458 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-10-01T13:48:29',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('DielectricShieldedPair','DielectricShieldedPair','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31,#35,#39),#43); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(20.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(-20.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(-29.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(-11.,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(-33.,0.,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,0.)); +#35 = AXIS2_PLACEMENT_3D('',#36,#37,#38); +#36 = CARTESIAN_POINT('',(-26.,0.,0.)); +#37 = DIRECTION('',(0.,0.,1.)); +#38 = DIRECTION('',(1.,0.,0.)); +#39 = AXIS2_PLACEMENT_3D('',#40,#41,#42); +#40 = CARTESIAN_POINT('',(20.,0.,0.)); +#41 = DIRECTION('',(0.,0.,1.)); +#42 = DIRECTION('',(1.,0.,0.)); +#43 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#47)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#44,#45,#46)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#44 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#45 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#46 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#47 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#44, + 'distance_accuracy_value','confusion accuracy'); +#48 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#49 = SHAPE_DEFINITION_REPRESENTATION(#50,#56); +#50 = PRODUCT_DEFINITION_SHAPE('','',#51); +#51 = PRODUCT_DEFINITION('design','',#52,#55); +#52 = PRODUCT_DEFINITION_FORMATION('','',#53); +#53 = PRODUCT('Right','Right','',(#54)); +#54 = PRODUCT_CONTEXT('',#2,'mechanical'); +#55 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#56 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#57),#76); +#57 = SHELL_BASED_SURFACE_MODEL('',(#58)); +#58 = OPEN_SHELL('',(#59)); +#59 = ADVANCED_FACE('',(#60),#71,.T.); +#60 = FACE_BOUND('',#61,.T.); +#61 = EDGE_LOOP('',(#62)); +#62 = ORIENTED_EDGE('',*,*,#63,.T.); +#63 = EDGE_CURVE('',#64,#64,#66,.T.); +#64 = VERTEX_POINT('',#65); +#65 = CARTESIAN_POINT('',(8.,0.,0.)); +#66 = CIRCLE('',#67,8.); +#67 = AXIS2_PLACEMENT_3D('',#68,#69,#70); +#68 = CARTESIAN_POINT('',(0.,0.,0.)); +#69 = DIRECTION('',(0.,0.,1.)); +#70 = DIRECTION('',(1.,0.,0.)); +#71 = PLANE('',#72); +#72 = AXIS2_PLACEMENT_3D('',#73,#74,#75); +#73 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#74 = DIRECTION('',(0.,0.,1.)); +#75 = DIRECTION('',(1.,0.,0.)); +#76 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#80)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#77,#78,#79)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#77 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#78 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#79 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#80 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#77, + 'distance_accuracy_value','confusion accuracy'); +#81 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#82,#84); +#82 = ( REPRESENTATION_RELATIONSHIP('','',#56,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#83) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#83 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#84 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#85); +#85 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('12','Right','',#5,#51,$); +#86 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#53)); +#87 = SHAPE_DEFINITION_REPRESENTATION(#88,#94); +#88 = PRODUCT_DEFINITION_SHAPE('','',#89); +#89 = PRODUCT_DEFINITION('design','',#90,#93); +#90 = PRODUCT_DEFINITION_FORMATION('','',#91); +#91 = PRODUCT('Left','Left','',(#92)); +#92 = PRODUCT_CONTEXT('',#2,'mechanical'); +#93 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#94 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#95),#114); +#95 = SHELL_BASED_SURFACE_MODEL('',(#96)); +#96 = OPEN_SHELL('',(#97)); +#97 = ADVANCED_FACE('',(#98),#109,.T.); +#98 = FACE_BOUND('',#99,.T.); +#99 = EDGE_LOOP('',(#100)); +#100 = ORIENTED_EDGE('',*,*,#101,.T.); +#101 = EDGE_CURVE('',#102,#102,#104,.T.); +#102 = VERTEX_POINT('',#103); +#103 = CARTESIAN_POINT('',(20.,0.,0.)); +#104 = CIRCLE('',#105,20.); +#105 = AXIS2_PLACEMENT_3D('',#106,#107,#108); +#106 = CARTESIAN_POINT('',(0.,0.,0.)); +#107 = DIRECTION('',(0.,0.,1.)); +#108 = DIRECTION('',(1.,0.,0.)); +#109 = PLANE('',#110); +#110 = AXIS2_PLACEMENT_3D('',#111,#112,#113); +#111 = CARTESIAN_POINT('',(-1.093952106032E-15,2.775209066E-16,0.)); +#112 = DIRECTION('',(0.,0.,1.)); +#113 = DIRECTION('',(1.,0.,0.)); +#114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#118)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#115,#116,#117)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#115 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#116 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#117 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#118 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#115, + 'distance_accuracy_value','confusion accuracy'); +#119 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#120,#122); +#120 = ( REPRESENTATION_RELATIONSHIP('','',#94,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#121) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#121 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#122 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#123 + ); +#123 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('13','Left','',#5,#89,$); +#124 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#91)); +#125 = SHAPE_DEFINITION_REPRESENTATION(#126,#132); +#126 = PRODUCT_DEFINITION_SHAPE('','',#127); +#127 = PRODUCT_DEFINITION('design','',#128,#131); +#128 = PRODUCT_DEFINITION_FORMATION('','',#129); +#129 = PRODUCT('SubLeftA','SubLeftA','',(#130)); +#130 = PRODUCT_CONTEXT('',#2,'mechanical'); +#131 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#132 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#133),#152); +#133 = SHELL_BASED_SURFACE_MODEL('',(#134)); +#134 = OPEN_SHELL('',(#135)); +#135 = ADVANCED_FACE('',(#136),#147,.T.); +#136 = FACE_BOUND('',#137,.T.); +#137 = EDGE_LOOP('',(#138)); +#138 = ORIENTED_EDGE('',*,*,#139,.T.); +#139 = EDGE_CURVE('',#140,#140,#142,.T.); +#140 = VERTEX_POINT('',#141); +#141 = CARTESIAN_POINT('',(8.,0.,0.)); +#142 = CIRCLE('',#143,8.); +#143 = AXIS2_PLACEMENT_3D('',#144,#145,#146); +#144 = CARTESIAN_POINT('',(0.,0.,0.)); +#145 = DIRECTION('',(0.,0.,1.)); +#146 = DIRECTION('',(1.,0.,0.)); +#147 = PLANE('',#148); +#148 = AXIS2_PLACEMENT_3D('',#149,#150,#151); +#149 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#150 = DIRECTION('',(0.,0.,1.)); +#151 = DIRECTION('',(1.,0.,0.)); +#152 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#156)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#153,#154,#155)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#153 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#154 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#155 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#156 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#153, + 'distance_accuracy_value','confusion accuracy'); +#157 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#158,#160); +#158 = ( REPRESENTATION_RELATIONSHIP('','',#132,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#159) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#159 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#160 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#161 + ); +#161 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('14','SubLeftA','',#5,#127,$); +#162 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#129)); +#163 = SHAPE_DEFINITION_REPRESENTATION(#164,#170); +#164 = PRODUCT_DEFINITION_SHAPE('','',#165); +#165 = PRODUCT_DEFINITION('design','',#166,#169); +#166 = PRODUCT_DEFINITION_FORMATION('','',#167); +#167 = PRODUCT('SubLeftB','SubLeftB','',(#168)); +#168 = PRODUCT_CONTEXT('',#2,'mechanical'); +#169 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#170 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#171),#190); +#171 = SHELL_BASED_SURFACE_MODEL('',(#172)); +#172 = OPEN_SHELL('',(#173)); +#173 = ADVANCED_FACE('',(#174),#185,.T.); +#174 = FACE_BOUND('',#175,.T.); +#175 = EDGE_LOOP('',(#176)); +#176 = ORIENTED_EDGE('',*,*,#177,.T.); +#177 = EDGE_CURVE('',#178,#178,#180,.T.); +#178 = VERTEX_POINT('',#179); +#179 = CARTESIAN_POINT('',(8.,0.,0.)); +#180 = CIRCLE('',#181,8.); +#181 = AXIS2_PLACEMENT_3D('',#182,#183,#184); +#182 = CARTESIAN_POINT('',(0.,0.,0.)); +#183 = DIRECTION('',(0.,0.,1.)); +#184 = DIRECTION('',(1.,0.,0.)); +#185 = PLANE('',#186); +#186 = AXIS2_PLACEMENT_3D('',#187,#188,#189); +#187 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#188 = DIRECTION('',(0.,0.,1.)); +#189 = DIRECTION('',(1.,0.,0.)); +#190 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#194)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#191,#192,#193)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#191 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#192 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#193 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#194 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#191, + 'distance_accuracy_value','confusion accuracy'); +#195 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#196,#198); +#196 = ( REPRESENTATION_RELATIONSHIP('','',#170,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#197) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#197 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#198 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#199 + ); +#199 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('15','SubLeftB','',#5,#165,$); +#200 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#167)); +#201 = SHAPE_DEFINITION_REPRESENTATION(#202,#208); +#202 = PRODUCT_DEFINITION_SHAPE('','',#203); +#203 = PRODUCT_DEFINITION('design','',#204,#207); +#204 = PRODUCT_DEFINITION_FORMATION('','',#205); +#205 = PRODUCT('SubLeftA1','SubLeftA1','',(#206)); +#206 = PRODUCT_CONTEXT('',#2,'mechanical'); +#207 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#208 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#209),#228); +#209 = SHELL_BASED_SURFACE_MODEL('',(#210)); +#210 = OPEN_SHELL('',(#211)); +#211 = ADVANCED_FACE('',(#212),#223,.T.); +#212 = FACE_BOUND('',#213,.T.); +#213 = EDGE_LOOP('',(#214)); +#214 = ORIENTED_EDGE('',*,*,#215,.T.); +#215 = EDGE_CURVE('',#216,#216,#218,.T.); +#216 = VERTEX_POINT('',#217); +#217 = CARTESIAN_POINT('',(2.,0.,0.)); +#218 = CIRCLE('',#219,2.); +#219 = AXIS2_PLACEMENT_3D('',#220,#221,#222); +#220 = CARTESIAN_POINT('',(0.,0.,0.)); +#221 = DIRECTION('',(0.,0.,1.)); +#222 = DIRECTION('',(1.,0.,0.)); +#223 = PLANE('',#224); +#224 = AXIS2_PLACEMENT_3D('',#225,#226,#227); +#225 = CARTESIAN_POINT('',(-1.281975124256E-16,3.821888340557E-18,0.)); +#226 = DIRECTION('',(0.,0.,1.)); +#227 = DIRECTION('',(1.,0.,0.)); +#228 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#232)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#229,#230,#231)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#229 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#230 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#231 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#232 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#229, + 'distance_accuracy_value','confusion accuracy'); +#233 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#234,#236); +#234 = ( REPRESENTATION_RELATIONSHIP('','',#208,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#235) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#235 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#236 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#237 + ); +#237 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('16','SubLeftA1','',#5,#203,$); +#238 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#205)); +#239 = SHAPE_DEFINITION_REPRESENTATION(#240,#246); +#240 = PRODUCT_DEFINITION_SHAPE('','',#241); +#241 = PRODUCT_DEFINITION('design','',#242,#245); +#242 = PRODUCT_DEFINITION_FORMATION('','',#243); +#243 = PRODUCT('SubLeftA2','SubLeftA2','',(#244)); +#244 = PRODUCT_CONTEXT('',#2,'mechanical'); +#245 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#246 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#247),#266); +#247 = SHELL_BASED_SURFACE_MODEL('',(#248)); +#248 = OPEN_SHELL('',(#249)); +#249 = ADVANCED_FACE('',(#250),#261,.T.); +#250 = FACE_BOUND('',#251,.T.); +#251 = EDGE_LOOP('',(#252)); +#252 = ORIENTED_EDGE('',*,*,#253,.T.); +#253 = EDGE_CURVE('',#254,#254,#256,.T.); +#254 = VERTEX_POINT('',#255); +#255 = CARTESIAN_POINT('',(4.,0.,0.)); +#256 = CIRCLE('',#257,4.); +#257 = AXIS2_PLACEMENT_3D('',#258,#259,#260); +#258 = CARTESIAN_POINT('',(0.,0.,0.)); +#259 = DIRECTION('',(0.,0.,1.)); +#260 = DIRECTION('',(1.,0.,0.)); +#261 = PLANE('',#262); +#262 = AXIS2_PLACEMENT_3D('',#263,#264,#265); +#263 = CARTESIAN_POINT('',(-2.563950248511E-16,7.643776681114E-18,0.)); +#264 = DIRECTION('',(0.,0.,1.)); +#265 = DIRECTION('',(1.,0.,0.)); +#266 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#270)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#267,#268,#269)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#267 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#268 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#269 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#270 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#267, + 'distance_accuracy_value','confusion accuracy'); +#271 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#272,#274); +#272 = ( REPRESENTATION_RELATIONSHIP('','',#246,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#273) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#273 = ITEM_DEFINED_TRANSFORMATION('','',#11,#35); +#274 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#275 + ); +#275 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('17','SubLeftA2','',#5,#241,$); +#276 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#243)); +#277 = SHAPE_DEFINITION_REPRESENTATION(#278,#284); +#278 = PRODUCT_DEFINITION_SHAPE('','',#279); +#279 = PRODUCT_DEFINITION('design','',#280,#283); +#280 = PRODUCT_DEFINITION_FORMATION('','',#281); +#281 = PRODUCT('SubRightA','SubRightA','',(#282)); +#282 = PRODUCT_CONTEXT('',#2,'mechanical'); +#283 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#284 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#285),#304); +#285 = SHELL_BASED_SURFACE_MODEL('',(#286)); +#286 = OPEN_SHELL('',(#287)); +#287 = ADVANCED_FACE('',(#288),#299,.T.); +#288 = FACE_BOUND('',#289,.T.); +#289 = EDGE_LOOP('',(#290)); +#290 = ORIENTED_EDGE('',*,*,#291,.T.); +#291 = EDGE_CURVE('',#292,#292,#294,.T.); +#292 = VERTEX_POINT('',#293); +#293 = CARTESIAN_POINT('',(2.,0.,0.)); +#294 = CIRCLE('',#295,2.); +#295 = AXIS2_PLACEMENT_3D('',#296,#297,#298); +#296 = CARTESIAN_POINT('',(0.,0.,0.)); +#297 = DIRECTION('',(0.,0.,1.)); +#298 = DIRECTION('',(1.,0.,0.)); +#299 = PLANE('',#300); +#300 = AXIS2_PLACEMENT_3D('',#301,#302,#303); +#301 = CARTESIAN_POINT('',(-1.281975124256E-16,3.821888340557E-18,0.)); +#302 = DIRECTION('',(0.,0.,1.)); +#303 = DIRECTION('',(1.,0.,0.)); +#304 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#308)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#305,#306,#307)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#305 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#306 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#307 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#308 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#305, + 'distance_accuracy_value','confusion accuracy'); +#309 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#310,#312); +#310 = ( REPRESENTATION_RELATIONSHIP('','',#284,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#311) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#311 = ITEM_DEFINED_TRANSFORMATION('','',#11,#39); +#312 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#313 + ); +#313 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('18','SubRightA','',#5,#279,$); +#314 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#281)); +#315 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#316) + ,#114); +#316 = STYLED_ITEM('color',(#317),#97); +#317 = PRESENTATION_STYLE_ASSIGNMENT((#318,#324)); +#318 = SURFACE_STYLE_USAGE(.BOTH.,#319); +#319 = SURFACE_SIDE_STYLE('',(#320)); +#320 = SURFACE_STYLE_FILL_AREA(#321); +#321 = FILL_AREA_STYLE('',(#322)); +#322 = FILL_AREA_STYLE_COLOUR('',#323); +#323 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#324 = CURVE_STYLE('',#325,POSITIVE_LENGTH_MEASURE(0.1),#326); +#325 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#326 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#327 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#328) + ,#266); +#328 = STYLED_ITEM('color',(#329),#249); +#329 = PRESENTATION_STYLE_ASSIGNMENT((#330,#335)); +#330 = SURFACE_STYLE_USAGE(.BOTH.,#331); +#331 = SURFACE_SIDE_STYLE('',(#332)); +#332 = SURFACE_STYLE_FILL_AREA(#333); +#333 = FILL_AREA_STYLE('',(#334)); +#334 = FILL_AREA_STYLE_COLOUR('',#323); +#335 = CURVE_STYLE('',#336,POSITIVE_LENGTH_MEASURE(0.1),#326); +#336 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#337 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#338) + ,#304); +#338 = STYLED_ITEM('color',(#339),#287); +#339 = PRESENTATION_STYLE_ASSIGNMENT((#340,#345)); +#340 = SURFACE_STYLE_USAGE(.BOTH.,#341); +#341 = SURFACE_SIDE_STYLE('',(#342)); +#342 = SURFACE_STYLE_FILL_AREA(#343); +#343 = FILL_AREA_STYLE('',(#344)); +#344 = FILL_AREA_STYLE_COLOUR('',#323); +#345 = CURVE_STYLE('',#346,POSITIVE_LENGTH_MEASURE(0.1),#326); +#346 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#347 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#348) + ,#228); +#348 = STYLED_ITEM('color',(#349),#211); +#349 = PRESENTATION_STYLE_ASSIGNMENT((#350,#355)); +#350 = SURFACE_STYLE_USAGE(.BOTH.,#351); +#351 = SURFACE_SIDE_STYLE('',(#352)); +#352 = SURFACE_STYLE_FILL_AREA(#353); +#353 = FILL_AREA_STYLE('',(#354)); +#354 = FILL_AREA_STYLE_COLOUR('',#323); +#355 = CURVE_STYLE('',#356,POSITIVE_LENGTH_MEASURE(0.1),#326); +#356 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#357 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#358) + ,#76); +#358 = STYLED_ITEM('color',(#359),#59); +#359 = PRESENTATION_STYLE_ASSIGNMENT((#360,#365)); +#360 = SURFACE_STYLE_USAGE(.BOTH.,#361); +#361 = SURFACE_SIDE_STYLE('',(#362)); +#362 = SURFACE_STYLE_FILL_AREA(#363); +#363 = FILL_AREA_STYLE('',(#364)); +#364 = FILL_AREA_STYLE_COLOUR('',#323); +#365 = CURVE_STYLE('',#366,POSITIVE_LENGTH_MEASURE(0.1),#326); +#366 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#367 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#368) + ,#152); +#368 = STYLED_ITEM('color',(#369),#135); +#369 = PRESENTATION_STYLE_ASSIGNMENT((#370,#375)); +#370 = SURFACE_STYLE_USAGE(.BOTH.,#371); +#371 = SURFACE_SIDE_STYLE('',(#372)); +#372 = SURFACE_STYLE_FILL_AREA(#373); +#373 = FILL_AREA_STYLE('',(#374)); +#374 = FILL_AREA_STYLE_COLOUR('',#323); +#375 = CURVE_STYLE('',#376,POSITIVE_LENGTH_MEASURE(0.1),#326); +#376 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#377 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#378) + ,#190); +#378 = STYLED_ITEM('color',(#379),#173); +#379 = PRESENTATION_STYLE_ASSIGNMENT((#380,#385)); +#380 = SURFACE_STYLE_USAGE(.BOTH.,#381); +#381 = SURFACE_SIDE_STYLE('',(#382)); +#382 = SURFACE_STYLE_FILL_AREA(#383); +#383 = FILL_AREA_STYLE('',(#384)); +#384 = FILL_AREA_STYLE_COLOUR('',#323); +#385 = CURVE_STYLE('',#386,POSITIVE_LENGTH_MEASURE(0.1),#326); +#386 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/DielectricShieldedPair/DielectricShieldedPair.FCStd b/testData/DielectricShieldedPair/DielectricShieldedPair.FCStd new file mode 100644 index 0000000..f9436fa Binary files /dev/null and b/testData/DielectricShieldedPair/DielectricShieldedPair.FCStd differ diff --git a/testData/DielectricShieldedPair/DielectricShieldedPair.json b/testData/DielectricShieldedPair/DielectricShieldedPair.json new file mode 100644 index 0000000..8df3142 --- /dev/null +++ b/testData/DielectricShieldedPair/DielectricShieldedPair.json @@ -0,0 +1,34 @@ +{ + "CrossSection":[ + { + "name":"ExternalShield", + "material":{ + "type":"PEC" + } + }, + { + "name":"RightConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftDielectric", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"RightDielectric", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/DielectricShieldedPair/DielectricShieldedPair.step b/testData/DielectricShieldedPair/DielectricShieldedPair.step new file mode 100644 index 0000000..b0fb692 --- /dev/null +++ b/testData/DielectricShieldedPair/DielectricShieldedPair.step @@ -0,0 +1,352 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-09-30T14:26:37',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('DielectricShieldedPair','DielectricShieldedPair','',( + #8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31),#35); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(20.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(-20.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(20.,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(-20.,0.,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,0.)); +#35 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#39)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#36,#37,#38)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#36 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#37 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#38 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#39 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#36, + 'distance_accuracy_value','confusion accuracy'); +#40 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#41 = SHAPE_DEFINITION_REPRESENTATION(#42,#48); +#42 = PRODUCT_DEFINITION_SHAPE('','',#43); +#43 = PRODUCT_DEFINITION('design','',#44,#47); +#44 = PRODUCT_DEFINITION_FORMATION('','',#45); +#45 = PRODUCT('RightConductor','RightConductor','',(#46)); +#46 = PRODUCT_CONTEXT('',#2,'mechanical'); +#47 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#48 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#49),#68); +#49 = SHELL_BASED_SURFACE_MODEL('',(#50)); +#50 = OPEN_SHELL('',(#51)); +#51 = ADVANCED_FACE('',(#52),#63,.T.); +#52 = FACE_BOUND('',#53,.T.); +#53 = EDGE_LOOP('',(#54)); +#54 = ORIENTED_EDGE('',*,*,#55,.T.); +#55 = EDGE_CURVE('',#56,#56,#58,.T.); +#56 = VERTEX_POINT('',#57); +#57 = CARTESIAN_POINT('',(8.,0.,0.)); +#58 = CIRCLE('',#59,8.); +#59 = AXIS2_PLACEMENT_3D('',#60,#61,#62); +#60 = CARTESIAN_POINT('',(0.,0.,0.)); +#61 = DIRECTION('',(0.,0.,1.)); +#62 = DIRECTION('',(1.,0.,0.)); +#63 = PLANE('',#64); +#64 = AXIS2_PLACEMENT_3D('',#65,#66,#67); +#65 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#66 = DIRECTION('',(0.,0.,1.)); +#67 = DIRECTION('',(1.,0.,0.)); +#68 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#72)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#69,#70,#71)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#69 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#70 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#71 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#72 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#69, + 'distance_accuracy_value','confusion accuracy'); +#73 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#74,#76); +#74 = ( REPRESENTATION_RELATIONSHIP('','',#48,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#75) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#75 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#76 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#77); +#77 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('18','RightConductor','',#5,#43,$); +#78 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#45)); +#79 = SHAPE_DEFINITION_REPRESENTATION(#80,#86); +#80 = PRODUCT_DEFINITION_SHAPE('','',#81); +#81 = PRODUCT_DEFINITION('design','',#82,#85); +#82 = PRODUCT_DEFINITION_FORMATION('','',#83); +#83 = PRODUCT('ExternalShield','ExternalShield','',(#84)); +#84 = PRODUCT_CONTEXT('',#2,'mechanical'); +#85 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#86 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#87),#106); +#87 = SHELL_BASED_SURFACE_MODEL('',(#88)); +#88 = OPEN_SHELL('',(#89)); +#89 = ADVANCED_FACE('',(#90),#101,.T.); +#90 = FACE_BOUND('',#91,.T.); +#91 = EDGE_LOOP('',(#92)); +#92 = ORIENTED_EDGE('',*,*,#93,.T.); +#93 = EDGE_CURVE('',#94,#94,#96,.T.); +#94 = VERTEX_POINT('',#95); +#95 = CARTESIAN_POINT('',(50.,0.,0.)); +#96 = CIRCLE('',#97,50.); +#97 = AXIS2_PLACEMENT_3D('',#98,#99,#100); +#98 = CARTESIAN_POINT('',(0.,0.,0.)); +#99 = DIRECTION('',(0.,0.,1.)); +#100 = DIRECTION('',(1.,0.,-0.)); +#101 = PLANE('',#102); +#102 = AXIS2_PLACEMENT_3D('',#103,#104,#105); +#103 = CARTESIAN_POINT('',(-3.5E-15,-2.04E-15,0.)); +#104 = DIRECTION('',(0.,0.,1.)); +#105 = DIRECTION('',(1.,0.,-0.)); +#106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#110)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#107,#108,#109)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#107 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#108 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#109 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#110 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#107, + 'distance_accuracy_value','confusion accuracy'); +#111 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#112,#114); +#112 = ( REPRESENTATION_RELATIONSHIP('','',#86,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#113) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#113 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#114 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#115 + ); +#115 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('19','ExternalShield','',#5,#81,$ + ); +#116 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#83)); +#117 = SHAPE_DEFINITION_REPRESENTATION(#118,#124); +#118 = PRODUCT_DEFINITION_SHAPE('','',#119); +#119 = PRODUCT_DEFINITION('design','',#120,#123); +#120 = PRODUCT_DEFINITION_FORMATION('','',#121); +#121 = PRODUCT('LeftConductor','LeftConductor','',(#122)); +#122 = PRODUCT_CONTEXT('',#2,'mechanical'); +#123 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#124 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#125),#144); +#125 = SHELL_BASED_SURFACE_MODEL('',(#126)); +#126 = OPEN_SHELL('',(#127)); +#127 = ADVANCED_FACE('',(#128),#139,.T.); +#128 = FACE_BOUND('',#129,.T.); +#129 = EDGE_LOOP('',(#130)); +#130 = ORIENTED_EDGE('',*,*,#131,.T.); +#131 = EDGE_CURVE('',#132,#132,#134,.T.); +#132 = VERTEX_POINT('',#133); +#133 = CARTESIAN_POINT('',(8.,0.,0.)); +#134 = CIRCLE('',#135,8.); +#135 = AXIS2_PLACEMENT_3D('',#136,#137,#138); +#136 = CARTESIAN_POINT('',(0.,0.,0.)); +#137 = DIRECTION('',(0.,0.,1.)); +#138 = DIRECTION('',(1.,0.,0.)); +#139 = PLANE('',#140); +#140 = AXIS2_PLACEMENT_3D('',#141,#142,#143); +#141 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#142 = DIRECTION('',(0.,0.,1.)); +#143 = DIRECTION('',(1.,0.,0.)); +#144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#148)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#145,#146,#147)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#145 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#146 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#147 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#148 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#145, + 'distance_accuracy_value','confusion accuracy'); +#149 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#150,#152); +#150 = ( REPRESENTATION_RELATIONSHIP('','',#124,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#151) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#151 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#152 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#153 + ); +#153 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('20','LeftConductor','',#5,#119,$ + ); +#154 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#121)); +#155 = SHAPE_DEFINITION_REPRESENTATION(#156,#162); +#156 = PRODUCT_DEFINITION_SHAPE('','',#157); +#157 = PRODUCT_DEFINITION('design','',#158,#161); +#158 = PRODUCT_DEFINITION_FORMATION('','',#159); +#159 = PRODUCT('RightDielectric','RightDielectric','',(#160)); +#160 = PRODUCT_CONTEXT('',#2,'mechanical'); +#161 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#162 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#163),#182); +#163 = SHELL_BASED_SURFACE_MODEL('',(#164)); +#164 = OPEN_SHELL('',(#165)); +#165 = ADVANCED_FACE('',(#166),#177,.T.); +#166 = FACE_BOUND('',#167,.T.); +#167 = EDGE_LOOP('',(#168)); +#168 = ORIENTED_EDGE('',*,*,#169,.T.); +#169 = EDGE_CURVE('',#170,#170,#172,.T.); +#170 = VERTEX_POINT('',#171); +#171 = CARTESIAN_POINT('',(16.,0.,0.)); +#172 = CIRCLE('',#173,16.); +#173 = AXIS2_PLACEMENT_3D('',#174,#175,#176); +#174 = CARTESIAN_POINT('',(0.,0.,0.)); +#175 = DIRECTION('',(0.,0.,1.)); +#176 = DIRECTION('',(1.,0.,0.)); +#177 = PLANE('',#178); +#178 = AXIS2_PLACEMENT_3D('',#179,#180,#181); +#179 = CARTESIAN_POINT('',(-1.03E-15,3.E-17,0.)); +#180 = DIRECTION('',(0.,0.,1.)); +#181 = DIRECTION('',(1.,0.,0.)); +#182 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#186)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#183,#184,#185)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#183 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#184 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#185 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#186 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#183, + 'distance_accuracy_value','confusion accuracy'); +#187 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#188,#190); +#188 = ( REPRESENTATION_RELATIONSHIP('','',#162,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#189) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#189 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#190 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#191 + ); +#191 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('21','RightDielectric','',#5,#157, + $); +#192 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#159)); +#193 = SHAPE_DEFINITION_REPRESENTATION(#194,#200); +#194 = PRODUCT_DEFINITION_SHAPE('','',#195); +#195 = PRODUCT_DEFINITION('design','',#196,#199); +#196 = PRODUCT_DEFINITION_FORMATION('','',#197); +#197 = PRODUCT('LeftDielectric','LeftDielectric','',(#198)); +#198 = PRODUCT_CONTEXT('',#2,'mechanical'); +#199 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#200 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#201),#220); +#201 = SHELL_BASED_SURFACE_MODEL('',(#202)); +#202 = OPEN_SHELL('',(#203)); +#203 = ADVANCED_FACE('',(#204),#215,.T.); +#204 = FACE_BOUND('',#205,.T.); +#205 = EDGE_LOOP('',(#206)); +#206 = ORIENTED_EDGE('',*,*,#207,.T.); +#207 = EDGE_CURVE('',#208,#208,#210,.T.); +#208 = VERTEX_POINT('',#209); +#209 = CARTESIAN_POINT('',(16.,0.,0.)); +#210 = CIRCLE('',#211,16.); +#211 = AXIS2_PLACEMENT_3D('',#212,#213,#214); +#212 = CARTESIAN_POINT('',(0.,0.,0.)); +#213 = DIRECTION('',(0.,0.,1.)); +#214 = DIRECTION('',(1.,0.,0.)); +#215 = PLANE('',#216); +#216 = AXIS2_PLACEMENT_3D('',#217,#218,#219); +#217 = CARTESIAN_POINT('',(-1.03E-15,3.E-17,0.)); +#218 = DIRECTION('',(0.,0.,1.)); +#219 = DIRECTION('',(1.,0.,0.)); +#220 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#224)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#221,#222,#223)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#221 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#222 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#223 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#224 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#221, + 'distance_accuracy_value','confusion accuracy'); +#225 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#226,#228); +#226 = ( REPRESENTATION_RELATIONSHIP('','',#200,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#227) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#227 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#228 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#229 + ); +#229 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('22','LeftDielectric','',#5,#195,$ + ); +#230 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#197)); +#231 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#232) + ,#106); +#232 = STYLED_ITEM('color',(#233),#89); +#233 = PRESENTATION_STYLE_ASSIGNMENT((#234,#242)); +#234 = SURFACE_STYLE_USAGE(.BOTH.,#235); +#235 = SURFACE_SIDE_STYLE('',(#236,#240)); +#236 = SURFACE_STYLE_FILL_AREA(#237); +#237 = FILL_AREA_STYLE('',(#238)); +#238 = FILL_AREA_STYLE_COLOUR('',#239); +#239 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#240 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #241)); +#241 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#242 = CURVE_STYLE('',#243,POSITIVE_LENGTH_MEASURE(0.1),#244); +#243 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#244 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#245 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#246) + ,#68); +#246 = STYLED_ITEM('color',(#247),#51); +#247 = PRESENTATION_STYLE_ASSIGNMENT((#248,#253)); +#248 = SURFACE_STYLE_USAGE(.BOTH.,#249); +#249 = SURFACE_SIDE_STYLE('',(#250)); +#250 = SURFACE_STYLE_FILL_AREA(#251); +#251 = FILL_AREA_STYLE('',(#252)); +#252 = FILL_AREA_STYLE_COLOUR('',#239); +#253 = CURVE_STYLE('',#254,POSITIVE_LENGTH_MEASURE(0.1),#244); +#254 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#255 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#256) + ,#144); +#256 = STYLED_ITEM('color',(#257),#127); +#257 = PRESENTATION_STYLE_ASSIGNMENT((#258,#263)); +#258 = SURFACE_STYLE_USAGE(.BOTH.,#259); +#259 = SURFACE_SIDE_STYLE('',(#260)); +#260 = SURFACE_STYLE_FILL_AREA(#261); +#261 = FILL_AREA_STYLE('',(#262)); +#262 = FILL_AREA_STYLE_COLOUR('',#239); +#263 = CURVE_STYLE('',#264,POSITIVE_LENGTH_MEASURE(0.1),#244); +#264 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#265 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#266) + ,#220); +#266 = STYLED_ITEM('color',(#267),#203); +#267 = PRESENTATION_STYLE_ASSIGNMENT((#268,#275)); +#268 = SURFACE_STYLE_USAGE(.BOTH.,#269); +#269 = SURFACE_SIDE_STYLE('',(#270,#273)); +#270 = SURFACE_STYLE_FILL_AREA(#271); +#271 = FILL_AREA_STYLE('',(#272)); +#272 = FILL_AREA_STYLE_COLOUR('',#239); +#273 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #274)); +#274 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#275 = CURVE_STYLE('',#276,POSITIVE_LENGTH_MEASURE(0.1),#244); +#276 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#277 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#278) + ,#182); +#278 = STYLED_ITEM('color',(#279),#165); +#279 = PRESENTATION_STYLE_ASSIGNMENT((#280,#287)); +#280 = SURFACE_STYLE_USAGE(.BOTH.,#281); +#281 = SURFACE_SIDE_STYLE('',(#282,#285)); +#282 = SURFACE_STYLE_FILL_AREA(#283); +#283 = FILL_AREA_STYLE('',(#284)); +#284 = FILL_AREA_STYLE_COLOUR('',#239); +#285 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #286)); +#286 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#287 = CURVE_STYLE('',#288,POSITIVE_LENGTH_MEASURE(0.1),#244); +#288 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.FCStd b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.FCStd new file mode 100644 index 0000000..f9436fa Binary files /dev/null and b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.FCStd differ diff --git a/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.json b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.json new file mode 100644 index 0000000..9c731bd --- /dev/null +++ b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.json @@ -0,0 +1,28 @@ +{ + "CrossSection":[ + { + "name":"RightConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftDielectric", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"RightDielectric", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.step b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.step new file mode 100644 index 0000000..d378b11 --- /dev/null +++ b/testData/DielectricUnshieldedPair/DielectricUnshieldedPair.step @@ -0,0 +1,287 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-09-30T15:34:24',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('DielectricUnshieldedPair','DielectricUnshieldedPair','',( + #8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27),#31); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(20.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(-20.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(20.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(-20.,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#35)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#32,#33,#34)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#32 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#33 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#34 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#35 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#32, + 'distance_accuracy_value','confusion accuracy'); +#36 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#37 = SHAPE_DEFINITION_REPRESENTATION(#38,#44); +#38 = PRODUCT_DEFINITION_SHAPE('','',#39); +#39 = PRODUCT_DEFINITION('design','',#40,#43); +#40 = PRODUCT_DEFINITION_FORMATION('','',#41); +#41 = PRODUCT('RightConductor','RightConductor','',(#42)); +#42 = PRODUCT_CONTEXT('',#2,'mechanical'); +#43 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#44 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#45),#64); +#45 = SHELL_BASED_SURFACE_MODEL('',(#46)); +#46 = OPEN_SHELL('',(#47)); +#47 = ADVANCED_FACE('',(#48),#59,.T.); +#48 = FACE_BOUND('',#49,.T.); +#49 = EDGE_LOOP('',(#50)); +#50 = ORIENTED_EDGE('',*,*,#51,.T.); +#51 = EDGE_CURVE('',#52,#52,#54,.T.); +#52 = VERTEX_POINT('',#53); +#53 = CARTESIAN_POINT('',(8.,0.,0.)); +#54 = CIRCLE('',#55,8.); +#55 = AXIS2_PLACEMENT_3D('',#56,#57,#58); +#56 = CARTESIAN_POINT('',(0.,0.,0.)); +#57 = DIRECTION('',(0.,0.,1.)); +#58 = DIRECTION('',(1.,0.,0.)); +#59 = PLANE('',#60); +#60 = AXIS2_PLACEMENT_3D('',#61,#62,#63); +#61 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#62 = DIRECTION('',(0.,0.,1.)); +#63 = DIRECTION('',(1.,0.,0.)); +#64 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#68)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#65,#66,#67)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#65 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#66 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#67 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#68 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#65, + 'distance_accuracy_value','confusion accuracy'); +#69 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#70,#72); +#70 = ( REPRESENTATION_RELATIONSHIP('','',#44,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#71) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#71 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#72 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#73); +#73 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','RightConductor','',#5,#39,$); +#74 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#41)); +#75 = SHAPE_DEFINITION_REPRESENTATION(#76,#82); +#76 = PRODUCT_DEFINITION_SHAPE('','',#77); +#77 = PRODUCT_DEFINITION('design','',#78,#81); +#78 = PRODUCT_DEFINITION_FORMATION('','',#79); +#79 = PRODUCT('LeftConductor','LeftConductor','',(#80)); +#80 = PRODUCT_CONTEXT('',#2,'mechanical'); +#81 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#82 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#83),#102); +#83 = SHELL_BASED_SURFACE_MODEL('',(#84)); +#84 = OPEN_SHELL('',(#85)); +#85 = ADVANCED_FACE('',(#86),#97,.T.); +#86 = FACE_BOUND('',#87,.T.); +#87 = EDGE_LOOP('',(#88)); +#88 = ORIENTED_EDGE('',*,*,#89,.T.); +#89 = EDGE_CURVE('',#90,#90,#92,.T.); +#90 = VERTEX_POINT('',#91); +#91 = CARTESIAN_POINT('',(8.,0.,0.)); +#92 = CIRCLE('',#93,8.); +#93 = AXIS2_PLACEMENT_3D('',#94,#95,#96); +#94 = CARTESIAN_POINT('',(0.,0.,0.)); +#95 = DIRECTION('',(0.,0.,1.)); +#96 = DIRECTION('',(1.,0.,0.)); +#97 = PLANE('',#98); +#98 = AXIS2_PLACEMENT_3D('',#99,#100,#101); +#99 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#100 = DIRECTION('',(0.,0.,1.)); +#101 = DIRECTION('',(1.,0.,0.)); +#102 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#106)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#103,#104,#105)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#103 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#104 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#105 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#106 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#103, + 'distance_accuracy_value','confusion accuracy'); +#107 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#108,#110); +#108 = ( REPRESENTATION_RELATIONSHIP('','',#82,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#109) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#109 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#110 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#111 + ); +#111 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','LeftConductor','',#5,#77,$); +#112 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#79)); +#113 = SHAPE_DEFINITION_REPRESENTATION(#114,#120); +#114 = PRODUCT_DEFINITION_SHAPE('','',#115); +#115 = PRODUCT_DEFINITION('design','',#116,#119); +#116 = PRODUCT_DEFINITION_FORMATION('','',#117); +#117 = PRODUCT('RightDielectric','RightDielectric','',(#118)); +#118 = PRODUCT_CONTEXT('',#2,'mechanical'); +#119 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#120 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#121),#140); +#121 = SHELL_BASED_SURFACE_MODEL('',(#122)); +#122 = OPEN_SHELL('',(#123)); +#123 = ADVANCED_FACE('',(#124),#135,.T.); +#124 = FACE_BOUND('',#125,.T.); +#125 = EDGE_LOOP('',(#126)); +#126 = ORIENTED_EDGE('',*,*,#127,.T.); +#127 = EDGE_CURVE('',#128,#128,#130,.T.); +#128 = VERTEX_POINT('',#129); +#129 = CARTESIAN_POINT('',(16.,0.,0.)); +#130 = CIRCLE('',#131,16.); +#131 = AXIS2_PLACEMENT_3D('',#132,#133,#134); +#132 = CARTESIAN_POINT('',(0.,0.,0.)); +#133 = DIRECTION('',(0.,0.,1.)); +#134 = DIRECTION('',(1.,0.,0.)); +#135 = PLANE('',#136); +#136 = AXIS2_PLACEMENT_3D('',#137,#138,#139); +#137 = CARTESIAN_POINT('',(-1.025580099405E-15,3.057510672446E-17,0.)); +#138 = DIRECTION('',(0.,0.,1.)); +#139 = DIRECTION('',(1.,0.,0.)); +#140 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#144)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#141,#142,#143)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#141 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#142 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#143 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#144 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#141, + 'distance_accuracy_value','confusion accuracy'); +#145 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#146,#148); +#146 = ( REPRESENTATION_RELATIONSHIP('','',#120,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#147) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#147 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#148 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#149 + ); +#149 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','RightDielectric','',#5,#115,$ + ); +#150 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#117)); +#151 = SHAPE_DEFINITION_REPRESENTATION(#152,#158); +#152 = PRODUCT_DEFINITION_SHAPE('','',#153); +#153 = PRODUCT_DEFINITION('design','',#154,#157); +#154 = PRODUCT_DEFINITION_FORMATION('','',#155); +#155 = PRODUCT('LeftDielectric','LeftDielectric','',(#156)); +#156 = PRODUCT_CONTEXT('',#2,'mechanical'); +#157 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#158 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#159),#178); +#159 = SHELL_BASED_SURFACE_MODEL('',(#160)); +#160 = OPEN_SHELL('',(#161)); +#161 = ADVANCED_FACE('',(#162),#173,.T.); +#162 = FACE_BOUND('',#163,.T.); +#163 = EDGE_LOOP('',(#164)); +#164 = ORIENTED_EDGE('',*,*,#165,.T.); +#165 = EDGE_CURVE('',#166,#166,#168,.T.); +#166 = VERTEX_POINT('',#167); +#167 = CARTESIAN_POINT('',(16.,0.,0.)); +#168 = CIRCLE('',#169,16.); +#169 = AXIS2_PLACEMENT_3D('',#170,#171,#172); +#170 = CARTESIAN_POINT('',(0.,0.,0.)); +#171 = DIRECTION('',(0.,0.,1.)); +#172 = DIRECTION('',(1.,0.,0.)); +#173 = PLANE('',#174); +#174 = AXIS2_PLACEMENT_3D('',#175,#176,#177); +#175 = CARTESIAN_POINT('',(-1.025580099405E-15,3.057510672446E-17,0.)); +#176 = DIRECTION('',(0.,0.,1.)); +#177 = DIRECTION('',(1.,0.,0.)); +#178 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#182)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#179,#180,#181)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#179 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#180 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#181 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#182 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#179, + 'distance_accuracy_value','confusion accuracy'); +#183 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#184,#186); +#184 = ( REPRESENTATION_RELATIONSHIP('','',#158,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#185) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#185 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#186 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#187 + ); +#187 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('4','LeftDielectric','',#5,#153,$ + ); +#188 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#155)); +#189 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#190) + ,#64); +#190 = STYLED_ITEM('color',(#191),#47); +#191 = PRESENTATION_STYLE_ASSIGNMENT((#192,#198)); +#192 = SURFACE_STYLE_USAGE(.BOTH.,#193); +#193 = SURFACE_SIDE_STYLE('',(#194)); +#194 = SURFACE_STYLE_FILL_AREA(#195); +#195 = FILL_AREA_STYLE('',(#196)); +#196 = FILL_AREA_STYLE_COLOUR('',#197); +#197 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#198 = CURVE_STYLE('',#199,POSITIVE_LENGTH_MEASURE(0.1),#200); +#199 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#200 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#201 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#202) + ,#102); +#202 = STYLED_ITEM('color',(#203),#85); +#203 = PRESENTATION_STYLE_ASSIGNMENT((#204,#209)); +#204 = SURFACE_STYLE_USAGE(.BOTH.,#205); +#205 = SURFACE_SIDE_STYLE('',(#206)); +#206 = SURFACE_STYLE_FILL_AREA(#207); +#207 = FILL_AREA_STYLE('',(#208)); +#208 = FILL_AREA_STYLE_COLOUR('',#197); +#209 = CURVE_STYLE('',#210,POSITIVE_LENGTH_MEASURE(0.1),#200); +#210 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#211 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#212) + ,#140); +#212 = STYLED_ITEM('color',(#213),#123); +#213 = PRESENTATION_STYLE_ASSIGNMENT((#214,#221)); +#214 = SURFACE_STYLE_USAGE(.BOTH.,#215); +#215 = SURFACE_SIDE_STYLE('',(#216,#219)); +#216 = SURFACE_STYLE_FILL_AREA(#217); +#217 = FILL_AREA_STYLE('',(#218)); +#218 = FILL_AREA_STYLE_COLOUR('',#197); +#219 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#197,( + #220)); +#220 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#221 = CURVE_STYLE('',#222,POSITIVE_LENGTH_MEASURE(0.1),#200); +#222 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#223 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#224) + ,#178); +#224 = STYLED_ITEM('color',(#225),#161); +#225 = PRESENTATION_STYLE_ASSIGNMENT((#226,#233)); +#226 = SURFACE_STYLE_USAGE(.BOTH.,#227); +#227 = SURFACE_SIDE_STYLE('',(#228,#231)); +#228 = SURFACE_STYLE_FILL_AREA(#229); +#229 = FILL_AREA_STYLE('',(#230)); +#230 = FILL_AREA_STYLE_COLOUR('',#197); +#231 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#197,( + #232)); +#232 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#233 = CURVE_STYLE('',#234,POSITIVE_LENGTH_MEASURE(0.1),#200); +#234 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.FCStd b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.FCStd new file mode 100644 index 0000000..f9436fa Binary files /dev/null and b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.FCStd differ diff --git a/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.json b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.json new file mode 100644 index 0000000..cd549fa --- /dev/null +++ b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.json @@ -0,0 +1,34 @@ +{ + "CrossSection":[ + { + "name":"RightConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftConductor", + "material":{ + "type":"PEC" + } + }, + { + "name":"LeftDielectric", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"RightDielectric", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"ExternalShield", + "material":{ + "type":"OpenBoundary" + } + } + ] +} \ No newline at end of file diff --git a/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.step b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.step new file mode 100644 index 0000000..b0fb692 --- /dev/null +++ b/testData/DielectricUnshieldedPairDefinedBoundary/DielectricUnshieldedPairDefinedBoundary.step @@ -0,0 +1,352 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-09-30T14:26:37',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('DielectricShieldedPair','DielectricShieldedPair','',( + #8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31),#35); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(20.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(-20.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(20.,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(-20.,0.,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,0.)); +#35 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#39)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#36,#37,#38)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#36 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#37 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#38 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#39 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#36, + 'distance_accuracy_value','confusion accuracy'); +#40 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#41 = SHAPE_DEFINITION_REPRESENTATION(#42,#48); +#42 = PRODUCT_DEFINITION_SHAPE('','',#43); +#43 = PRODUCT_DEFINITION('design','',#44,#47); +#44 = PRODUCT_DEFINITION_FORMATION('','',#45); +#45 = PRODUCT('RightConductor','RightConductor','',(#46)); +#46 = PRODUCT_CONTEXT('',#2,'mechanical'); +#47 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#48 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#49),#68); +#49 = SHELL_BASED_SURFACE_MODEL('',(#50)); +#50 = OPEN_SHELL('',(#51)); +#51 = ADVANCED_FACE('',(#52),#63,.T.); +#52 = FACE_BOUND('',#53,.T.); +#53 = EDGE_LOOP('',(#54)); +#54 = ORIENTED_EDGE('',*,*,#55,.T.); +#55 = EDGE_CURVE('',#56,#56,#58,.T.); +#56 = VERTEX_POINT('',#57); +#57 = CARTESIAN_POINT('',(8.,0.,0.)); +#58 = CIRCLE('',#59,8.); +#59 = AXIS2_PLACEMENT_3D('',#60,#61,#62); +#60 = CARTESIAN_POINT('',(0.,0.,0.)); +#61 = DIRECTION('',(0.,0.,1.)); +#62 = DIRECTION('',(1.,0.,0.)); +#63 = PLANE('',#64); +#64 = AXIS2_PLACEMENT_3D('',#65,#66,#67); +#65 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#66 = DIRECTION('',(0.,0.,1.)); +#67 = DIRECTION('',(1.,0.,0.)); +#68 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#72)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#69,#70,#71)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#69 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#70 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#71 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#72 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#69, + 'distance_accuracy_value','confusion accuracy'); +#73 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#74,#76); +#74 = ( REPRESENTATION_RELATIONSHIP('','',#48,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#75) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#75 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#76 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#77); +#77 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('18','RightConductor','',#5,#43,$); +#78 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#45)); +#79 = SHAPE_DEFINITION_REPRESENTATION(#80,#86); +#80 = PRODUCT_DEFINITION_SHAPE('','',#81); +#81 = PRODUCT_DEFINITION('design','',#82,#85); +#82 = PRODUCT_DEFINITION_FORMATION('','',#83); +#83 = PRODUCT('ExternalShield','ExternalShield','',(#84)); +#84 = PRODUCT_CONTEXT('',#2,'mechanical'); +#85 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#86 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#87),#106); +#87 = SHELL_BASED_SURFACE_MODEL('',(#88)); +#88 = OPEN_SHELL('',(#89)); +#89 = ADVANCED_FACE('',(#90),#101,.T.); +#90 = FACE_BOUND('',#91,.T.); +#91 = EDGE_LOOP('',(#92)); +#92 = ORIENTED_EDGE('',*,*,#93,.T.); +#93 = EDGE_CURVE('',#94,#94,#96,.T.); +#94 = VERTEX_POINT('',#95); +#95 = CARTESIAN_POINT('',(50.,0.,0.)); +#96 = CIRCLE('',#97,50.); +#97 = AXIS2_PLACEMENT_3D('',#98,#99,#100); +#98 = CARTESIAN_POINT('',(0.,0.,0.)); +#99 = DIRECTION('',(0.,0.,1.)); +#100 = DIRECTION('',(1.,0.,-0.)); +#101 = PLANE('',#102); +#102 = AXIS2_PLACEMENT_3D('',#103,#104,#105); +#103 = CARTESIAN_POINT('',(-3.5E-15,-2.04E-15,0.)); +#104 = DIRECTION('',(0.,0.,1.)); +#105 = DIRECTION('',(1.,0.,-0.)); +#106 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#110)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#107,#108,#109)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#107 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#108 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#109 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#110 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#107, + 'distance_accuracy_value','confusion accuracy'); +#111 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#112,#114); +#112 = ( REPRESENTATION_RELATIONSHIP('','',#86,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#113) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#113 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#114 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#115 + ); +#115 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('19','ExternalShield','',#5,#81,$ + ); +#116 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#83)); +#117 = SHAPE_DEFINITION_REPRESENTATION(#118,#124); +#118 = PRODUCT_DEFINITION_SHAPE('','',#119); +#119 = PRODUCT_DEFINITION('design','',#120,#123); +#120 = PRODUCT_DEFINITION_FORMATION('','',#121); +#121 = PRODUCT('LeftConductor','LeftConductor','',(#122)); +#122 = PRODUCT_CONTEXT('',#2,'mechanical'); +#123 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#124 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#125),#144); +#125 = SHELL_BASED_SURFACE_MODEL('',(#126)); +#126 = OPEN_SHELL('',(#127)); +#127 = ADVANCED_FACE('',(#128),#139,.T.); +#128 = FACE_BOUND('',#129,.T.); +#129 = EDGE_LOOP('',(#130)); +#130 = ORIENTED_EDGE('',*,*,#131,.T.); +#131 = EDGE_CURVE('',#132,#132,#134,.T.); +#132 = VERTEX_POINT('',#133); +#133 = CARTESIAN_POINT('',(8.,0.,0.)); +#134 = CIRCLE('',#135,8.); +#135 = AXIS2_PLACEMENT_3D('',#136,#137,#138); +#136 = CARTESIAN_POINT('',(0.,0.,0.)); +#137 = DIRECTION('',(0.,0.,1.)); +#138 = DIRECTION('',(1.,0.,0.)); +#139 = PLANE('',#140); +#140 = AXIS2_PLACEMENT_3D('',#141,#142,#143); +#141 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#142 = DIRECTION('',(0.,0.,1.)); +#143 = DIRECTION('',(1.,0.,0.)); +#144 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#148)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#145,#146,#147)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#145 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#146 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#147 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#148 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#145, + 'distance_accuracy_value','confusion accuracy'); +#149 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#150,#152); +#150 = ( REPRESENTATION_RELATIONSHIP('','',#124,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#151) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#151 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#152 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#153 + ); +#153 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('20','LeftConductor','',#5,#119,$ + ); +#154 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#121)); +#155 = SHAPE_DEFINITION_REPRESENTATION(#156,#162); +#156 = PRODUCT_DEFINITION_SHAPE('','',#157); +#157 = PRODUCT_DEFINITION('design','',#158,#161); +#158 = PRODUCT_DEFINITION_FORMATION('','',#159); +#159 = PRODUCT('RightDielectric','RightDielectric','',(#160)); +#160 = PRODUCT_CONTEXT('',#2,'mechanical'); +#161 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#162 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#163),#182); +#163 = SHELL_BASED_SURFACE_MODEL('',(#164)); +#164 = OPEN_SHELL('',(#165)); +#165 = ADVANCED_FACE('',(#166),#177,.T.); +#166 = FACE_BOUND('',#167,.T.); +#167 = EDGE_LOOP('',(#168)); +#168 = ORIENTED_EDGE('',*,*,#169,.T.); +#169 = EDGE_CURVE('',#170,#170,#172,.T.); +#170 = VERTEX_POINT('',#171); +#171 = CARTESIAN_POINT('',(16.,0.,0.)); +#172 = CIRCLE('',#173,16.); +#173 = AXIS2_PLACEMENT_3D('',#174,#175,#176); +#174 = CARTESIAN_POINT('',(0.,0.,0.)); +#175 = DIRECTION('',(0.,0.,1.)); +#176 = DIRECTION('',(1.,0.,0.)); +#177 = PLANE('',#178); +#178 = AXIS2_PLACEMENT_3D('',#179,#180,#181); +#179 = CARTESIAN_POINT('',(-1.03E-15,3.E-17,0.)); +#180 = DIRECTION('',(0.,0.,1.)); +#181 = DIRECTION('',(1.,0.,0.)); +#182 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#186)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#183,#184,#185)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#183 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#184 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#185 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#186 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#183, + 'distance_accuracy_value','confusion accuracy'); +#187 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#188,#190); +#188 = ( REPRESENTATION_RELATIONSHIP('','',#162,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#189) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#189 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#190 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#191 + ); +#191 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('21','RightDielectric','',#5,#157, + $); +#192 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#159)); +#193 = SHAPE_DEFINITION_REPRESENTATION(#194,#200); +#194 = PRODUCT_DEFINITION_SHAPE('','',#195); +#195 = PRODUCT_DEFINITION('design','',#196,#199); +#196 = PRODUCT_DEFINITION_FORMATION('','',#197); +#197 = PRODUCT('LeftDielectric','LeftDielectric','',(#198)); +#198 = PRODUCT_CONTEXT('',#2,'mechanical'); +#199 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#200 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#201),#220); +#201 = SHELL_BASED_SURFACE_MODEL('',(#202)); +#202 = OPEN_SHELL('',(#203)); +#203 = ADVANCED_FACE('',(#204),#215,.T.); +#204 = FACE_BOUND('',#205,.T.); +#205 = EDGE_LOOP('',(#206)); +#206 = ORIENTED_EDGE('',*,*,#207,.T.); +#207 = EDGE_CURVE('',#208,#208,#210,.T.); +#208 = VERTEX_POINT('',#209); +#209 = CARTESIAN_POINT('',(16.,0.,0.)); +#210 = CIRCLE('',#211,16.); +#211 = AXIS2_PLACEMENT_3D('',#212,#213,#214); +#212 = CARTESIAN_POINT('',(0.,0.,0.)); +#213 = DIRECTION('',(0.,0.,1.)); +#214 = DIRECTION('',(1.,0.,0.)); +#215 = PLANE('',#216); +#216 = AXIS2_PLACEMENT_3D('',#217,#218,#219); +#217 = CARTESIAN_POINT('',(-1.03E-15,3.E-17,0.)); +#218 = DIRECTION('',(0.,0.,1.)); +#219 = DIRECTION('',(1.,0.,0.)); +#220 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#224)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#221,#222,#223)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#221 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#222 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#223 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#224 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#221, + 'distance_accuracy_value','confusion accuracy'); +#225 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#226,#228); +#226 = ( REPRESENTATION_RELATIONSHIP('','',#200,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#227) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#227 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#228 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#229 + ); +#229 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('22','LeftDielectric','',#5,#195,$ + ); +#230 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#197)); +#231 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#232) + ,#106); +#232 = STYLED_ITEM('color',(#233),#89); +#233 = PRESENTATION_STYLE_ASSIGNMENT((#234,#242)); +#234 = SURFACE_STYLE_USAGE(.BOTH.,#235); +#235 = SURFACE_SIDE_STYLE('',(#236,#240)); +#236 = SURFACE_STYLE_FILL_AREA(#237); +#237 = FILL_AREA_STYLE('',(#238)); +#238 = FILL_AREA_STYLE_COLOUR('',#239); +#239 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#240 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #241)); +#241 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#242 = CURVE_STYLE('',#243,POSITIVE_LENGTH_MEASURE(0.1),#244); +#243 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#244 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#245 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#246) + ,#68); +#246 = STYLED_ITEM('color',(#247),#51); +#247 = PRESENTATION_STYLE_ASSIGNMENT((#248,#253)); +#248 = SURFACE_STYLE_USAGE(.BOTH.,#249); +#249 = SURFACE_SIDE_STYLE('',(#250)); +#250 = SURFACE_STYLE_FILL_AREA(#251); +#251 = FILL_AREA_STYLE('',(#252)); +#252 = FILL_AREA_STYLE_COLOUR('',#239); +#253 = CURVE_STYLE('',#254,POSITIVE_LENGTH_MEASURE(0.1),#244); +#254 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#255 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#256) + ,#144); +#256 = STYLED_ITEM('color',(#257),#127); +#257 = PRESENTATION_STYLE_ASSIGNMENT((#258,#263)); +#258 = SURFACE_STYLE_USAGE(.BOTH.,#259); +#259 = SURFACE_SIDE_STYLE('',(#260)); +#260 = SURFACE_STYLE_FILL_AREA(#261); +#261 = FILL_AREA_STYLE('',(#262)); +#262 = FILL_AREA_STYLE_COLOUR('',#239); +#263 = CURVE_STYLE('',#264,POSITIVE_LENGTH_MEASURE(0.1),#244); +#264 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#265 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#266) + ,#220); +#266 = STYLED_ITEM('color',(#267),#203); +#267 = PRESENTATION_STYLE_ASSIGNMENT((#268,#275)); +#268 = SURFACE_STYLE_USAGE(.BOTH.,#269); +#269 = SURFACE_SIDE_STYLE('',(#270,#273)); +#270 = SURFACE_STYLE_FILL_AREA(#271); +#271 = FILL_AREA_STYLE('',(#272)); +#272 = FILL_AREA_STYLE_COLOUR('',#239); +#273 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #274)); +#274 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#275 = CURVE_STYLE('',#276,POSITIVE_LENGTH_MEASURE(0.1),#244); +#276 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#277 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#278) + ,#182); +#278 = STYLED_ITEM('color',(#279),#165); +#279 = PRESENTATION_STYLE_ASSIGNMENT((#280,#287)); +#280 = SURFACE_STYLE_USAGE(.BOTH.,#281); +#281 = SURFACE_SIDE_STYLE('',(#282,#285)); +#282 = SURFACE_STYLE_FILL_AREA(#283); +#283 = FILL_AREA_STYLE('',(#284)); +#284 = FILL_AREA_STYLE_COLOUR('',#239); +#285 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#239,( + #286)); +#286 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#287 = CURVE_STYLE('',#288,POSITIVE_LENGTH_MEASURE(0.1),#244); +#288 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/FusedConductor/FusedConductor.FCStd b/testData/FusedConductor/FusedConductor.FCStd new file mode 100644 index 0000000..41d0503 Binary files /dev/null and b/testData/FusedConductor/FusedConductor.FCStd differ diff --git a/testData/FusedConductor/FusedConductor.json b/testData/FusedConductor/FusedConductor.json new file mode 100644 index 0000000..b90e55f --- /dev/null +++ b/testData/FusedConductor/FusedConductor.json @@ -0,0 +1,40 @@ +{ + "CrossSection":[ + { + "name":"Shield", + "material":{ + "type":"PEC" + } + }, + { + "name":"A", + "material":{ + "type":"PEC" + } + }, + { + "name":"B", + "material":{ + "type":"PEC" + } + }, + { + "name":"C", + "material":{ + "type":"PEC" + } + }, + { + "name":"D", + "material":{ + "type":"PEC" + } + }, + { + "name":"E", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/FusedConductor/FusedConductor.step b/testData/FusedConductor/FusedConductor.step new file mode 100644 index 0000000..1ff048b --- /dev/null +++ b/testData/FusedConductor/FusedConductor.step @@ -0,0 +1,401 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-10-01T13:24:21',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('FusedConductor','FusedConductor','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31,#35),#39); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(3.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(-8.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(-2.,7.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(-2.,30.,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,0.)); +#35 = AXIS2_PLACEMENT_3D('',#36,#37,#38); +#36 = CARTESIAN_POINT('',(16.,1.,0.)); +#37 = DIRECTION('',(0.,0.,1.)); +#38 = DIRECTION('',(1.,0.,0.)); +#39 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#43)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#40,#41,#42)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#40 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#41 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#42 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#43 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#40, + 'distance_accuracy_value','confusion accuracy'); +#44 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#45 = SHAPE_DEFINITION_REPRESENTATION(#46,#52); +#46 = PRODUCT_DEFINITION_SHAPE('','',#47); +#47 = PRODUCT_DEFINITION('design','',#48,#51); +#48 = PRODUCT_DEFINITION_FORMATION('','',#49); +#49 = PRODUCT('A','A','',(#50)); +#50 = PRODUCT_CONTEXT('',#2,'mechanical'); +#51 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#52 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#53),#72); +#53 = SHELL_BASED_SURFACE_MODEL('',(#54)); +#54 = OPEN_SHELL('',(#55)); +#55 = ADVANCED_FACE('',(#56),#67,.T.); +#56 = FACE_BOUND('',#57,.T.); +#57 = EDGE_LOOP('',(#58)); +#58 = ORIENTED_EDGE('',*,*,#59,.T.); +#59 = EDGE_CURVE('',#60,#60,#62,.T.); +#60 = VERTEX_POINT('',#61); +#61 = CARTESIAN_POINT('',(8.,0.,0.)); +#62 = CIRCLE('',#63,8.); +#63 = AXIS2_PLACEMENT_3D('',#64,#65,#66); +#64 = CARTESIAN_POINT('',(0.,0.,0.)); +#65 = DIRECTION('',(0.,0.,1.)); +#66 = DIRECTION('',(1.,0.,0.)); +#67 = PLANE('',#68); +#68 = AXIS2_PLACEMENT_3D('',#69,#70,#71); +#69 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#70 = DIRECTION('',(0.,0.,1.)); +#71 = DIRECTION('',(1.,0.,0.)); +#72 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#76)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#73,#74,#75)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#73 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#74 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#75 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#76 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#73, + 'distance_accuracy_value','confusion accuracy'); +#77 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#78,#80); +#78 = ( REPRESENTATION_RELATIONSHIP('','',#52,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#79) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#79 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#80 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#81); +#81 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('6','A','',#5,#47,$); +#82 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#49)); +#83 = SHAPE_DEFINITION_REPRESENTATION(#84,#90); +#84 = PRODUCT_DEFINITION_SHAPE('','',#85); +#85 = PRODUCT_DEFINITION('design','',#86,#89); +#86 = PRODUCT_DEFINITION_FORMATION('','',#87); +#87 = PRODUCT('Shield','Shield','',(#88)); +#88 = PRODUCT_CONTEXT('',#2,'mechanical'); +#89 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#90 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#91),#110); +#91 = SHELL_BASED_SURFACE_MODEL('',(#92)); +#92 = OPEN_SHELL('',(#93)); +#93 = ADVANCED_FACE('',(#94),#105,.T.); +#94 = FACE_BOUND('',#95,.T.); +#95 = EDGE_LOOP('',(#96)); +#96 = ORIENTED_EDGE('',*,*,#97,.T.); +#97 = EDGE_CURVE('',#98,#98,#100,.T.); +#98 = VERTEX_POINT('',#99); +#99 = CARTESIAN_POINT('',(50.,0.,0.)); +#100 = CIRCLE('',#101,50.); +#101 = AXIS2_PLACEMENT_3D('',#102,#103,#104); +#102 = CARTESIAN_POINT('',(0.,0.,0.)); +#103 = DIRECTION('',(0.,0.,1.)); +#104 = DIRECTION('',(1.,0.,-0.)); +#105 = PLANE('',#106); +#106 = AXIS2_PLACEMENT_3D('',#107,#108,#109); +#107 = CARTESIAN_POINT('',(-3.5E-15,-2.04E-15,0.)); +#108 = DIRECTION('',(0.,0.,1.)); +#109 = DIRECTION('',(1.,0.,-0.)); +#110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#114)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#111,#112,#113)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#111 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#112 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#113 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#114 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#111, + 'distance_accuracy_value','confusion accuracy'); +#115 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#116,#118); +#116 = ( REPRESENTATION_RELATIONSHIP('','',#90,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#117) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#117 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#118 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#119 + ); +#119 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('7','Shield','',#5,#85,$); +#120 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#87)); +#121 = SHAPE_DEFINITION_REPRESENTATION(#122,#128); +#122 = PRODUCT_DEFINITION_SHAPE('','',#123); +#123 = PRODUCT_DEFINITION('design','',#124,#127); +#124 = PRODUCT_DEFINITION_FORMATION('','',#125); +#125 = PRODUCT('B','B','',(#126)); +#126 = PRODUCT_CONTEXT('',#2,'mechanical'); +#127 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#128 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#129),#148); +#129 = SHELL_BASED_SURFACE_MODEL('',(#130)); +#130 = OPEN_SHELL('',(#131)); +#131 = ADVANCED_FACE('',(#132),#143,.T.); +#132 = FACE_BOUND('',#133,.T.); +#133 = EDGE_LOOP('',(#134)); +#134 = ORIENTED_EDGE('',*,*,#135,.T.); +#135 = EDGE_CURVE('',#136,#136,#138,.T.); +#136 = VERTEX_POINT('',#137); +#137 = CARTESIAN_POINT('',(8.,0.,0.)); +#138 = CIRCLE('',#139,8.); +#139 = AXIS2_PLACEMENT_3D('',#140,#141,#142); +#140 = CARTESIAN_POINT('',(0.,0.,0.)); +#141 = DIRECTION('',(0.,0.,1.)); +#142 = DIRECTION('',(1.,0.,0.)); +#143 = PLANE('',#144); +#144 = AXIS2_PLACEMENT_3D('',#145,#146,#147); +#145 = CARTESIAN_POINT('',(-5.1E-16,2.E-17,0.)); +#146 = DIRECTION('',(0.,0.,1.)); +#147 = DIRECTION('',(1.,0.,0.)); +#148 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#152)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#149,#150,#151)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#149 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#150 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#151 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#152 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#149, + 'distance_accuracy_value','confusion accuracy'); +#153 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#154,#156); +#154 = ( REPRESENTATION_RELATIONSHIP('','',#128,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#155) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#155 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#156 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#157 + ); +#157 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('8','B','',#5,#123,$); +#158 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#125)); +#159 = SHAPE_DEFINITION_REPRESENTATION(#160,#166); +#160 = PRODUCT_DEFINITION_SHAPE('','',#161); +#161 = PRODUCT_DEFINITION('design','',#162,#165); +#162 = PRODUCT_DEFINITION_FORMATION('','',#163); +#163 = PRODUCT('C','C','',(#164)); +#164 = PRODUCT_CONTEXT('',#2,'mechanical'); +#165 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#166 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#167),#186); +#167 = SHELL_BASED_SURFACE_MODEL('',(#168)); +#168 = OPEN_SHELL('',(#169)); +#169 = ADVANCED_FACE('',(#170),#181,.T.); +#170 = FACE_BOUND('',#171,.T.); +#171 = EDGE_LOOP('',(#172)); +#172 = ORIENTED_EDGE('',*,*,#173,.T.); +#173 = EDGE_CURVE('',#174,#174,#176,.T.); +#174 = VERTEX_POINT('',#175); +#175 = CARTESIAN_POINT('',(8.,0.,0.)); +#176 = CIRCLE('',#177,8.); +#177 = AXIS2_PLACEMENT_3D('',#178,#179,#180); +#178 = CARTESIAN_POINT('',(0.,0.,0.)); +#179 = DIRECTION('',(0.,0.,1.)); +#180 = DIRECTION('',(1.,0.,0.)); +#181 = PLANE('',#182); +#182 = AXIS2_PLACEMENT_3D('',#183,#184,#185); +#183 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#184 = DIRECTION('',(0.,0.,1.)); +#185 = DIRECTION('',(1.,0.,0.)); +#186 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#190)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#187,#188,#189)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#187 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#188 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#189 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#190 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#187, + 'distance_accuracy_value','confusion accuracy'); +#191 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#192,#194); +#192 = ( REPRESENTATION_RELATIONSHIP('','',#166,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#193) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#193 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#194 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#195 + ); +#195 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('9','C','',#5,#161,$); +#196 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#163)); +#197 = SHAPE_DEFINITION_REPRESENTATION(#198,#204); +#198 = PRODUCT_DEFINITION_SHAPE('','',#199); +#199 = PRODUCT_DEFINITION('design','',#200,#203); +#200 = PRODUCT_DEFINITION_FORMATION('','',#201); +#201 = PRODUCT('D','D','',(#202)); +#202 = PRODUCT_CONTEXT('',#2,'mechanical'); +#203 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#204 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#205),#224); +#205 = SHELL_BASED_SURFACE_MODEL('',(#206)); +#206 = OPEN_SHELL('',(#207)); +#207 = ADVANCED_FACE('',(#208),#219,.T.); +#208 = FACE_BOUND('',#209,.T.); +#209 = EDGE_LOOP('',(#210)); +#210 = ORIENTED_EDGE('',*,*,#211,.T.); +#211 = EDGE_CURVE('',#212,#212,#214,.T.); +#212 = VERTEX_POINT('',#213); +#213 = CARTESIAN_POINT('',(8.,0.,0.)); +#214 = CIRCLE('',#215,8.); +#215 = AXIS2_PLACEMENT_3D('',#216,#217,#218); +#216 = CARTESIAN_POINT('',(0.,0.,0.)); +#217 = DIRECTION('',(0.,0.,1.)); +#218 = DIRECTION('',(1.,0.,0.)); +#219 = PLANE('',#220); +#220 = AXIS2_PLACEMENT_3D('',#221,#222,#223); +#221 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#222 = DIRECTION('',(0.,0.,1.)); +#223 = DIRECTION('',(1.,0.,0.)); +#224 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#228)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#225,#226,#227)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#225 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#226 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#227 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#228 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#225, + 'distance_accuracy_value','confusion accuracy'); +#229 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#230,#232); +#230 = ( REPRESENTATION_RELATIONSHIP('','',#204,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#231) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#231 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#232 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#233 + ); +#233 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('10','D','',#5,#199,$); +#234 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#201)); +#235 = SHAPE_DEFINITION_REPRESENTATION(#236,#242); +#236 = PRODUCT_DEFINITION_SHAPE('','',#237); +#237 = PRODUCT_DEFINITION('design','',#238,#241); +#238 = PRODUCT_DEFINITION_FORMATION('','',#239); +#239 = PRODUCT('E','E','',(#240)); +#240 = PRODUCT_CONTEXT('',#2,'mechanical'); +#241 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#242 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#243),#262); +#243 = SHELL_BASED_SURFACE_MODEL('',(#244)); +#244 = OPEN_SHELL('',(#245)); +#245 = ADVANCED_FACE('',(#246),#257,.T.); +#246 = FACE_BOUND('',#247,.T.); +#247 = EDGE_LOOP('',(#248)); +#248 = ORIENTED_EDGE('',*,*,#249,.T.); +#249 = EDGE_CURVE('',#250,#250,#252,.T.); +#250 = VERTEX_POINT('',#251); +#251 = CARTESIAN_POINT('',(8.,0.,0.)); +#252 = CIRCLE('',#253,8.); +#253 = AXIS2_PLACEMENT_3D('',#254,#255,#256); +#254 = CARTESIAN_POINT('',(0.,0.,0.)); +#255 = DIRECTION('',(0.,0.,1.)); +#256 = DIRECTION('',(1.,0.,0.)); +#257 = PLANE('',#258); +#258 = AXIS2_PLACEMENT_3D('',#259,#260,#261); +#259 = CARTESIAN_POINT('',(-5.127900497023E-16,1.528755336223E-17,0.)); +#260 = DIRECTION('',(0.,0.,1.)); +#261 = DIRECTION('',(1.,0.,0.)); +#262 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#266)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#263,#264,#265)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#263 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#264 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#265 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#266 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#263, + 'distance_accuracy_value','confusion accuracy'); +#267 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#268,#270); +#268 = ( REPRESENTATION_RELATIONSHIP('','',#242,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#269) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#269 = ITEM_DEFINED_TRANSFORMATION('','',#11,#35); +#270 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#271 + ); +#271 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('11','E','',#5,#237,$); +#272 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#239)); +#273 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#274) + ,#262); +#274 = STYLED_ITEM('color',(#275),#245); +#275 = PRESENTATION_STYLE_ASSIGNMENT((#276,#282)); +#276 = SURFACE_STYLE_USAGE(.BOTH.,#277); +#277 = SURFACE_SIDE_STYLE('',(#278)); +#278 = SURFACE_STYLE_FILL_AREA(#279); +#279 = FILL_AREA_STYLE('',(#280)); +#280 = FILL_AREA_STYLE_COLOUR('',#281); +#281 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#282 = CURVE_STYLE('',#283,POSITIVE_LENGTH_MEASURE(0.1),#284); +#283 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#284 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#285 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#286) + ,#148); +#286 = STYLED_ITEM('color',(#287),#131); +#287 = PRESENTATION_STYLE_ASSIGNMENT((#288,#293)); +#288 = SURFACE_STYLE_USAGE(.BOTH.,#289); +#289 = SURFACE_SIDE_STYLE('',(#290)); +#290 = SURFACE_STYLE_FILL_AREA(#291); +#291 = FILL_AREA_STYLE('',(#292)); +#292 = FILL_AREA_STYLE_COLOUR('',#281); +#293 = CURVE_STYLE('',#294,POSITIVE_LENGTH_MEASURE(0.1),#284); +#294 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#295 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#296) + ,#72); +#296 = STYLED_ITEM('color',(#297),#55); +#297 = PRESENTATION_STYLE_ASSIGNMENT((#298,#303)); +#298 = SURFACE_STYLE_USAGE(.BOTH.,#299); +#299 = SURFACE_SIDE_STYLE('',(#300)); +#300 = SURFACE_STYLE_FILL_AREA(#301); +#301 = FILL_AREA_STYLE('',(#302)); +#302 = FILL_AREA_STYLE_COLOUR('',#281); +#303 = CURVE_STYLE('',#304,POSITIVE_LENGTH_MEASURE(0.1),#284); +#304 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#305 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#306) + ,#186); +#306 = STYLED_ITEM('color',(#307),#169); +#307 = PRESENTATION_STYLE_ASSIGNMENT((#308,#313)); +#308 = SURFACE_STYLE_USAGE(.BOTH.,#309); +#309 = SURFACE_SIDE_STYLE('',(#310)); +#310 = SURFACE_STYLE_FILL_AREA(#311); +#311 = FILL_AREA_STYLE('',(#312)); +#312 = FILL_AREA_STYLE_COLOUR('',#281); +#313 = CURVE_STYLE('',#314,POSITIVE_LENGTH_MEASURE(0.1),#284); +#314 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#315 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#316) + ,#224); +#316 = STYLED_ITEM('color',(#317),#207); +#317 = PRESENTATION_STYLE_ASSIGNMENT((#318,#323)); +#318 = SURFACE_STYLE_USAGE(.BOTH.,#319); +#319 = SURFACE_SIDE_STYLE('',(#320)); +#320 = SURFACE_STYLE_FILL_AREA(#321); +#321 = FILL_AREA_STYLE('',(#322)); +#322 = FILL_AREA_STYLE_COLOUR('',#281); +#323 = CURVE_STYLE('',#324,POSITIVE_LENGTH_MEASURE(0.1),#284); +#324 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#325 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#326) + ,#110); +#326 = STYLED_ITEM('color',(#327),#93); +#327 = PRESENTATION_STYLE_ASSIGNMENT((#328,#335)); +#328 = SURFACE_STYLE_USAGE(.BOTH.,#329); +#329 = SURFACE_SIDE_STYLE('',(#330,#333)); +#330 = SURFACE_STYLE_FILL_AREA(#331); +#331 = FILL_AREA_STYLE('',(#332)); +#332 = FILL_AREA_STYLE_COLOUR('',#281); +#333 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#281,( + #334)); +#334 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#335 = CURVE_STYLE('',#336,POSITIVE_LENGTH_MEASURE(0.1),#284); +#336 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/UnshieldedNested/UnshieldedNested.FCStd b/testData/UnshieldedNested/UnshieldedNested.FCStd new file mode 100644 index 0000000..faae23a Binary files /dev/null and b/testData/UnshieldedNested/UnshieldedNested.FCStd differ diff --git a/testData/UnshieldedNested/UnshieldedNested.json b/testData/UnshieldedNested/UnshieldedNested.json new file mode 100644 index 0000000..8b81c7c --- /dev/null +++ b/testData/UnshieldedNested/UnshieldedNested.json @@ -0,0 +1,22 @@ +{ + "CrossSection":[ + { + "name":"Conductor_2", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"ExtraConductor", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/UnshieldedNested/UnshieldedNested.step b/testData/UnshieldedNested/UnshieldedNested.step new file mode 100644 index 0000000..50b419d --- /dev/null +++ b/testData/UnshieldedNested/UnshieldedNested.step @@ -0,0 +1,230 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-10-14T12:52:45',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('nested_coax','nested_coax','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23),#27); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(5.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#31)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#28,#29,#30)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#28 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#29 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#30 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#31 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#28, + 'distance_accuracy_value','confusion accuracy'); +#32 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#33 = SHAPE_DEFINITION_REPRESENTATION(#34,#40); +#34 = PRODUCT_DEFINITION_SHAPE('','',#35); +#35 = PRODUCT_DEFINITION('design','',#36,#39); +#36 = PRODUCT_DEFINITION_FORMATION('','',#37); +#37 = PRODUCT('Conductor_1','Conductor_1','',(#38)); +#38 = PRODUCT_CONTEXT('',#2,'mechanical'); +#39 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#40 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#41),#71); +#41 = SHELL_BASED_SURFACE_MODEL('',(#42)); +#42 = OPEN_SHELL('',(#43)); +#43 = ADVANCED_FACE('',(#44,#55),#66,.T.); +#44 = FACE_BOUND('',#45,.T.); +#45 = EDGE_LOOP('',(#46)); +#46 = ORIENTED_EDGE('',*,*,#47,.T.); +#47 = EDGE_CURVE('',#48,#48,#50,.T.); +#48 = VERTEX_POINT('',#49); +#49 = CARTESIAN_POINT('',(2.8,0.,0.)); +#50 = CIRCLE('',#51,2.8); +#51 = AXIS2_PLACEMENT_3D('',#52,#53,#54); +#52 = CARTESIAN_POINT('',(0.,0.,0.)); +#53 = DIRECTION('',(0.,0.,1.)); +#54 = DIRECTION('',(1.,0.,0.)); +#55 = FACE_BOUND('',#56,.T.); +#56 = EDGE_LOOP('',(#57)); +#57 = ORIENTED_EDGE('',*,*,#58,.F.); +#58 = EDGE_CURVE('',#59,#59,#61,.T.); +#59 = VERTEX_POINT('',#60); +#60 = CARTESIAN_POINT('',(2.4,0.,0.)); +#61 = CIRCLE('',#62,2.4); +#62 = AXIS2_PLACEMENT_3D('',#63,#64,#65); +#63 = CARTESIAN_POINT('',(0.,0.,0.)); +#64 = DIRECTION('',(0.,0.,1.)); +#65 = DIRECTION('',(1.,0.,0.)); +#66 = PLANE('',#67); +#67 = AXIS2_PLACEMENT_3D('',#68,#69,#70); +#68 = CARTESIAN_POINT('',(-2.441857379535E-16,1.29885370033E-16,0.)); +#69 = DIRECTION('',(0.,0.,1.)); +#70 = DIRECTION('',(1.,0.,0.)); +#71 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#75)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#72,#73,#74)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#72 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#73 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#74 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#75 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#72, + 'distance_accuracy_value','confusion accuracy'); +#76 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#77,#79); +#77 = ( REPRESENTATION_RELATIONSHIP('','',#40,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#78) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#78 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#79 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#80); +#80 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','Conductor_1','',#5,#35,$); +#81 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#37)); +#82 = SHAPE_DEFINITION_REPRESENTATION(#83,#89); +#83 = PRODUCT_DEFINITION_SHAPE('','',#84); +#84 = PRODUCT_DEFINITION('design','',#85,#88); +#85 = PRODUCT_DEFINITION_FORMATION('','',#86); +#86 = PRODUCT('Conductor_2','Conductor_2','',(#87)); +#87 = PRODUCT_CONTEXT('',#2,'mechanical'); +#88 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#89 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#90),#109); +#90 = SHELL_BASED_SURFACE_MODEL('',(#91)); +#91 = OPEN_SHELL('',(#92)); +#92 = ADVANCED_FACE('',(#93),#104,.T.); +#93 = FACE_BOUND('',#94,.T.); +#94 = EDGE_LOOP('',(#95)); +#95 = ORIENTED_EDGE('',*,*,#96,.T.); +#96 = EDGE_CURVE('',#97,#97,#99,.T.); +#97 = VERTEX_POINT('',#98); +#98 = CARTESIAN_POINT('',(1.,0.,0.)); +#99 = CIRCLE('',#100,1.); +#100 = AXIS2_PLACEMENT_3D('',#101,#102,#103); +#101 = CARTESIAN_POINT('',(0.,0.,0.)); +#102 = DIRECTION('',(0.,0.,1.)); +#103 = DIRECTION('',(1.,0.,-0.)); +#104 = PLANE('',#105); +#105 = AXIS2_PLACEMENT_3D('',#106,#107,#108); +#106 = CARTESIAN_POINT('',(-6.409875621279E-17,1.910944170279E-18,0.)); +#107 = DIRECTION('',(0.,0.,1.)); +#108 = DIRECTION('',(1.,0.,-0.)); +#109 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#113)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#110,#111,#112)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#110 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#111 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#112 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#113 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#110, + 'distance_accuracy_value','confusion accuracy'); +#114 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#115,#117); +#115 = ( REPRESENTATION_RELATIONSHIP('','',#89,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#116) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#116 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#117 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#118 + ); +#118 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Conductor_2','',#5,#84,$); +#119 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#86)); +#120 = SHAPE_DEFINITION_REPRESENTATION(#121,#127); +#121 = PRODUCT_DEFINITION_SHAPE('','',#122); +#122 = PRODUCT_DEFINITION('design','',#123,#126); +#123 = PRODUCT_DEFINITION_FORMATION('','',#124); +#124 = PRODUCT('ExtraConductor','ExtraConductor','',(#125)); +#125 = PRODUCT_CONTEXT('',#2,'mechanical'); +#126 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#127 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#128),#147); +#128 = SHELL_BASED_SURFACE_MODEL('',(#129)); +#129 = OPEN_SHELL('',(#130)); +#130 = ADVANCED_FACE('',(#131),#142,.T.); +#131 = FACE_BOUND('',#132,.T.); +#132 = EDGE_LOOP('',(#133)); +#133 = ORIENTED_EDGE('',*,*,#134,.T.); +#134 = EDGE_CURVE('',#135,#135,#137,.T.); +#135 = VERTEX_POINT('',#136); +#136 = CARTESIAN_POINT('',(1.,0.,0.)); +#137 = CIRCLE('',#138,1.); +#138 = AXIS2_PLACEMENT_3D('',#139,#140,#141); +#139 = CARTESIAN_POINT('',(0.,0.,0.)); +#140 = DIRECTION('',(0.,0.,1.)); +#141 = DIRECTION('',(1.,0.,0.)); +#142 = PLANE('',#143); +#143 = AXIS2_PLACEMENT_3D('',#144,#145,#146); +#144 = CARTESIAN_POINT('',(-6.409875621279E-17,1.910944170279E-18,0.)); +#145 = DIRECTION('',(0.,0.,1.)); +#146 = DIRECTION('',(1.,0.,0.)); +#147 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#151)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#148,#149,#150)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#148 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#149 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#150 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#151 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#148, + 'distance_accuracy_value','confusion accuracy'); +#152 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#153,#155); +#153 = ( REPRESENTATION_RELATIONSHIP('','',#127,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#154) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#154 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#155 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#156 + ); +#156 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','ExtraConductor','',#5,#122,$ + ); +#157 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#124)); +#158 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#159) + ,#109); +#159 = STYLED_ITEM('color',(#160),#92); +#160 = PRESENTATION_STYLE_ASSIGNMENT((#161,#167)); +#161 = SURFACE_STYLE_USAGE(.BOTH.,#162); +#162 = SURFACE_SIDE_STYLE('',(#163)); +#163 = SURFACE_STYLE_FILL_AREA(#164); +#164 = FILL_AREA_STYLE('',(#165)); +#165 = FILL_AREA_STYLE_COLOUR('',#166); +#166 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#167 = CURVE_STYLE('',#168,POSITIVE_LENGTH_MEASURE(0.1),#169); +#168 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#169 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#170 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#171) + ,#147); +#171 = STYLED_ITEM('color',(#172),#130); +#172 = PRESENTATION_STYLE_ASSIGNMENT((#173,#178)); +#173 = SURFACE_STYLE_USAGE(.BOTH.,#174); +#174 = SURFACE_SIDE_STYLE('',(#175)); +#175 = SURFACE_STYLE_FILL_AREA(#176); +#176 = FILL_AREA_STYLE('',(#177)); +#177 = FILL_AREA_STYLE_COLOUR('',#166); +#178 = CURVE_STYLE('',#179,POSITIVE_LENGTH_MEASURE(0.1),#169); +#179 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#180 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#181) + ,#71); +#181 = STYLED_ITEM('color',(#182),#43); +#182 = PRESENTATION_STYLE_ASSIGNMENT((#183,#188)); +#183 = SURFACE_STYLE_USAGE(.BOTH.,#184); +#184 = SURFACE_SIDE_STYLE('',(#185)); +#185 = SURFACE_STYLE_FILL_AREA(#186); +#186 = FILL_AREA_STYLE('',(#187)); +#187 = FILL_AREA_STYLE_COLOUR('',#166); +#188 = CURVE_STYLE('',#189,POSITIVE_LENGTH_MEASURE(0.1),#169); +#189 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/agrawal1981/agrawal1981.FCStd b/testData/agrawal1981/agrawal1981.FCStd index 83fe8ef..91a3c8b 100644 Binary files a/testData/agrawal1981/agrawal1981.FCStd and b/testData/agrawal1981/agrawal1981.FCStd differ diff --git a/testData/agrawal1981/agrawal1981.json b/testData/agrawal1981/agrawal1981.json new file mode 100644 index 0000000..a103c67 --- /dev/null +++ b/testData/agrawal1981/agrawal1981.json @@ -0,0 +1,46 @@ +{ + "CrossSection":[ + { + "name":"Conductor_000", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_001", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_002", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_003", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_001", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_002", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_003", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/agrawal1981/agrawal1981.step b/testData/agrawal1981/agrawal1981.step new file mode 100644 index 0000000..5206452 --- /dev/null +++ b/testData/agrawal1981/agrawal1981.step @@ -0,0 +1,565 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2026-03-27T09:17:53',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('agrawal1981','agrawal1981','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31,#35,#39),#43); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(0.,84.527,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,84.527,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(-3.048,79.25,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(-3.048,79.248,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); +#32 = CARTESIAN_POINT('',(3.048,79.248,0.)); +#33 = DIRECTION('',(0.,0.,1.)); +#34 = DIRECTION('',(1.,0.,0.)); +#35 = AXIS2_PLACEMENT_3D('',#36,#37,#38); +#36 = CARTESIAN_POINT('',(3.048,79.248,0.)); +#37 = DIRECTION('',(0.,0.,1.)); +#38 = DIRECTION('',(1.,0.,0.)); +#39 = AXIS2_PLACEMENT_3D('',#40,#41,#42); +#40 = CARTESIAN_POINT('',(0.,0.,0.)); +#41 = DIRECTION('',(0.,0.,1.)); +#42 = DIRECTION('',(1.,0.,0.)); +#43 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#47)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#44,#45,#46)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#44 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#45 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#46 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#47 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#44, + 'distance_accuracy_value','confusion accuracy'); +#48 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#49 = SHAPE_DEFINITION_REPRESENTATION(#50,#56); +#50 = PRODUCT_DEFINITION_SHAPE('','',#51); +#51 = PRODUCT_DEFINITION('design','',#52,#55); +#52 = PRODUCT_DEFINITION_FORMATION('','',#53); +#53 = PRODUCT('Dielectric_001','Dielectric_001','',(#54)); +#54 = PRODUCT_CONTEXT('',#2,'mechanical'); +#55 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#56 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#57),#84); +#57 = SHELL_BASED_SURFACE_MODEL('',(#58)); +#58 = OPEN_SHELL('',(#59)); +#59 = ADVANCED_FACE('',(#60),#73,.T.); +#60 = FACE_BOUND('',#61,.T.); +#61 = EDGE_LOOP('',(#62)); +#62 = ORIENTED_EDGE('',*,*,#63,.T.); +#63 = EDGE_CURVE('',#64,#64,#66,.T.); +#64 = VERTEX_POINT('',#65); +#65 = CARTESIAN_POINT('',(3.048,0.,0.)); +#66 = SURFACE_CURVE('',#67,(#72),.PCURVE_S1.); +#67 = CIRCLE('',#68,3.048); +#68 = AXIS2_PLACEMENT_3D('',#69,#70,#71); +#69 = CARTESIAN_POINT('',(0.,0.,0.)); +#70 = DIRECTION('',(0.,0.,1.)); +#71 = DIRECTION('',(1.,0.,0.)); +#72 = PCURVE('',#73,#78); +#73 = PLANE('',#74); +#74 = AXIS2_PLACEMENT_3D('',#75,#76,#77); +#75 = CARTESIAN_POINT('',(-1.121588035219E-16,-1.226531127144E-17,0.)); +#76 = DIRECTION('',(0.,0.,1.)); +#77 = DIRECTION('',(1.,0.,0.)); +#78 = DEFINITIONAL_REPRESENTATION('',(#79),#83); +#79 = CIRCLE('',#80,3.048); +#80 = AXIS2_PLACEMENT_2D('',#81,#82); +#81 = CARTESIAN_POINT('',(1.121588035219E-16,1.226531127144E-17)); +#82 = DIRECTION('',(1.,0.)); +#83 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#84 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#88)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#85,#86,#87)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#85 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#86 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#87 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#88 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#85, + 'distance_accuracy_value','confusion accuracy'); +#89 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#90,#92); +#90 = ( REPRESENTATION_RELATIONSHIP('','',#56,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#91) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#91 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#92 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#93); +#93 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('13','Dielectric_001','',#5,#51,$); +#94 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#53)); +#95 = SHAPE_DEFINITION_REPRESENTATION(#96,#102); +#96 = PRODUCT_DEFINITION_SHAPE('','',#97); +#97 = PRODUCT_DEFINITION('design','',#98,#101); +#98 = PRODUCT_DEFINITION_FORMATION('','',#99); +#99 = PRODUCT('Conductor_001','Conductor_001','',(#100)); +#100 = PRODUCT_CONTEXT('',#2,'mechanical'); +#101 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#102 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#103),#130); +#103 = SHELL_BASED_SURFACE_MODEL('',(#104)); +#104 = OPEN_SHELL('',(#105)); +#105 = ADVANCED_FACE('',(#106),#119,.T.); +#106 = FACE_BOUND('',#107,.T.); +#107 = EDGE_LOOP('',(#108)); +#108 = ORIENTED_EDGE('',*,*,#109,.T.); +#109 = EDGE_CURVE('',#110,#110,#112,.T.); +#110 = VERTEX_POINT('',#111); +#111 = CARTESIAN_POINT('',(2.1463,0.,0.)); +#112 = SURFACE_CURVE('',#113,(#118),.PCURVE_S1.); +#113 = CIRCLE('',#114,2.1463); +#114 = AXIS2_PLACEMENT_3D('',#115,#116,#117); +#115 = CARTESIAN_POINT('',(0.,0.,0.)); +#116 = DIRECTION('',(0.,0.,1.)); +#117 = DIRECTION('',(1.,0.,0.)); +#118 = PCURVE('',#119,#124); +#119 = PLANE('',#120); +#120 = AXIS2_PLACEMENT_3D('',#121,#122,#123); +#121 = CARTESIAN_POINT('',(-1.194590806742E-16,-7.975927050832E-18,0.)); +#122 = DIRECTION('',(0.,0.,1.)); +#123 = DIRECTION('',(1.,0.,0.)); +#124 = DEFINITIONAL_REPRESENTATION('',(#125),#129); +#125 = CIRCLE('',#126,2.1463); +#126 = AXIS2_PLACEMENT_2D('',#127,#128); +#127 = CARTESIAN_POINT('',(1.194590806742E-16,7.975927050832E-18)); +#128 = DIRECTION('',(1.,0.)); +#129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#130 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#134)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#131,#132,#133)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#131 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#132 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#133 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#134 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#131, + 'distance_accuracy_value','confusion accuracy'); +#135 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#136,#138); +#136 = ( REPRESENTATION_RELATIONSHIP('','',#102,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#137) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#137 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#138 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#139 + ); +#139 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('14','Conductor_001','',#5,#97,$); +#140 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#99)); +#141 = SHAPE_DEFINITION_REPRESENTATION(#142,#148); +#142 = PRODUCT_DEFINITION_SHAPE('','',#143); +#143 = PRODUCT_DEFINITION('design','',#144,#147); +#144 = PRODUCT_DEFINITION_FORMATION('','',#145); +#145 = PRODUCT('Conductor_002','Conductor_002','',(#146)); +#146 = PRODUCT_CONTEXT('',#2,'mechanical'); +#147 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#148 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#149),#176); +#149 = SHELL_BASED_SURFACE_MODEL('',(#150)); +#150 = OPEN_SHELL('',(#151)); +#151 = ADVANCED_FACE('',(#152),#165,.T.); +#152 = FACE_BOUND('',#153,.T.); +#153 = EDGE_LOOP('',(#154)); +#154 = ORIENTED_EDGE('',*,*,#155,.T.); +#155 = EDGE_CURVE('',#156,#156,#158,.T.); +#156 = VERTEX_POINT('',#157); +#157 = CARTESIAN_POINT('',(2.1463,0.,0.)); +#158 = SURFACE_CURVE('',#159,(#164),.PCURVE_S1.); +#159 = CIRCLE('',#160,2.1463); +#160 = AXIS2_PLACEMENT_3D('',#161,#162,#163); +#161 = CARTESIAN_POINT('',(0.,0.,0.)); +#162 = DIRECTION('',(0.,0.,1.)); +#163 = DIRECTION('',(1.,0.,0.)); +#164 = PCURVE('',#165,#170); +#165 = PLANE('',#166); +#166 = AXIS2_PLACEMENT_3D('',#167,#168,#169); +#167 = CARTESIAN_POINT('',(-1.194590806742E-16,-7.975927050832E-18,0.)); +#168 = DIRECTION('',(0.,0.,1.)); +#169 = DIRECTION('',(1.,0.,0.)); +#170 = DEFINITIONAL_REPRESENTATION('',(#171),#175); +#171 = CIRCLE('',#172,2.1463); +#172 = AXIS2_PLACEMENT_2D('',#173,#174); +#173 = CARTESIAN_POINT('',(1.194590806742E-16,7.975927050832E-18)); +#174 = DIRECTION('',(1.,0.)); +#175 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#176 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#180)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#177,#178,#179)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#177 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#178 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#179 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#180 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#177, + 'distance_accuracy_value','confusion accuracy'); +#181 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#182,#184); +#182 = ( REPRESENTATION_RELATIONSHIP('','',#148,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#183) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#183 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#184 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#185 + ); +#185 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('15','Conductor_002','',#5,#143,$ + ); +#186 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#145)); +#187 = SHAPE_DEFINITION_REPRESENTATION(#188,#194); +#188 = PRODUCT_DEFINITION_SHAPE('','',#189); +#189 = PRODUCT_DEFINITION('design','',#190,#193); +#190 = PRODUCT_DEFINITION_FORMATION('','',#191); +#191 = PRODUCT('Dielectric_002','Dielectric_002','',(#192)); +#192 = PRODUCT_CONTEXT('',#2,'mechanical'); +#193 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#194 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#195),#222); +#195 = SHELL_BASED_SURFACE_MODEL('',(#196)); +#196 = OPEN_SHELL('',(#197)); +#197 = ADVANCED_FACE('',(#198),#211,.T.); +#198 = FACE_BOUND('',#199,.T.); +#199 = EDGE_LOOP('',(#200)); +#200 = ORIENTED_EDGE('',*,*,#201,.T.); +#201 = EDGE_CURVE('',#202,#202,#204,.T.); +#202 = VERTEX_POINT('',#203); +#203 = CARTESIAN_POINT('',(3.048,0.,0.)); +#204 = SURFACE_CURVE('',#205,(#210),.PCURVE_S1.); +#205 = CIRCLE('',#206,3.048); +#206 = AXIS2_PLACEMENT_3D('',#207,#208,#209); +#207 = CARTESIAN_POINT('',(0.,0.,0.)); +#208 = DIRECTION('',(0.,0.,1.)); +#209 = DIRECTION('',(1.,0.,0.)); +#210 = PCURVE('',#211,#216); +#211 = PLANE('',#212); +#212 = AXIS2_PLACEMENT_3D('',#213,#214,#215); +#213 = CARTESIAN_POINT('',(-1.121588035219E-16,-1.226531127144E-17,0.)); +#214 = DIRECTION('',(0.,0.,1.)); +#215 = DIRECTION('',(1.,0.,0.)); +#216 = DEFINITIONAL_REPRESENTATION('',(#217),#221); +#217 = CIRCLE('',#218,3.048); +#218 = AXIS2_PLACEMENT_2D('',#219,#220); +#219 = CARTESIAN_POINT('',(1.121588035219E-16,1.226531127144E-17)); +#220 = DIRECTION('',(1.,0.)); +#221 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#222 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#226)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#223,#224,#225)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#223 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#224 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#225 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#226 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#223, + 'distance_accuracy_value','confusion accuracy'); +#227 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#228,#230); +#228 = ( REPRESENTATION_RELATIONSHIP('','',#194,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#229) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#229 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#230 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#231 + ); +#231 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('16','Dielectric_002','',#5,#189,$ + ); +#232 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#191)); +#233 = SHAPE_DEFINITION_REPRESENTATION(#234,#240); +#234 = PRODUCT_DEFINITION_SHAPE('','',#235); +#235 = PRODUCT_DEFINITION('design','',#236,#239); +#236 = PRODUCT_DEFINITION_FORMATION('','',#237); +#237 = PRODUCT('Conductor_003','Conductor_003','',(#238)); +#238 = PRODUCT_CONTEXT('',#2,'mechanical'); +#239 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#240 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#241),#268); +#241 = SHELL_BASED_SURFACE_MODEL('',(#242)); +#242 = OPEN_SHELL('',(#243)); +#243 = ADVANCED_FACE('',(#244),#257,.T.); +#244 = FACE_BOUND('',#245,.T.); +#245 = EDGE_LOOP('',(#246)); +#246 = ORIENTED_EDGE('',*,*,#247,.T.); +#247 = EDGE_CURVE('',#248,#248,#250,.T.); +#248 = VERTEX_POINT('',#249); +#249 = CARTESIAN_POINT('',(2.1463,0.,0.)); +#250 = SURFACE_CURVE('',#251,(#256),.PCURVE_S1.); +#251 = CIRCLE('',#252,2.1463); +#252 = AXIS2_PLACEMENT_3D('',#253,#254,#255); +#253 = CARTESIAN_POINT('',(0.,0.,0.)); +#254 = DIRECTION('',(0.,0.,1.)); +#255 = DIRECTION('',(1.,0.,0.)); +#256 = PCURVE('',#257,#262); +#257 = PLANE('',#258); +#258 = AXIS2_PLACEMENT_3D('',#259,#260,#261); +#259 = CARTESIAN_POINT('',(-1.194590806742E-16,-7.975927050832E-18,0.)); +#260 = DIRECTION('',(0.,0.,1.)); +#261 = DIRECTION('',(1.,0.,0.)); +#262 = DEFINITIONAL_REPRESENTATION('',(#263),#267); +#263 = CIRCLE('',#264,2.1463); +#264 = AXIS2_PLACEMENT_2D('',#265,#266); +#265 = CARTESIAN_POINT('',(1.194590806742E-16,7.975927050832E-18)); +#266 = DIRECTION('',(1.,0.)); +#267 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#268 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#272)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#269,#270,#271)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#269 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#270 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#271 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#272 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#269, + 'distance_accuracy_value','confusion accuracy'); +#273 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#274,#276); +#274 = ( REPRESENTATION_RELATIONSHIP('','',#240,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#275) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#275 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#276 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#277 + ); +#277 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('17','Conductor_003','',#5,#235,$ + ); +#278 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#237)); +#279 = SHAPE_DEFINITION_REPRESENTATION(#280,#286); +#280 = PRODUCT_DEFINITION_SHAPE('','',#281); +#281 = PRODUCT_DEFINITION('design','',#282,#285); +#282 = PRODUCT_DEFINITION_FORMATION('','',#283); +#283 = PRODUCT('Dielectric_003','Dielectric_003','',(#284)); +#284 = PRODUCT_CONTEXT('',#2,'mechanical'); +#285 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#286 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#287),#314); +#287 = SHELL_BASED_SURFACE_MODEL('',(#288)); +#288 = OPEN_SHELL('',(#289)); +#289 = ADVANCED_FACE('',(#290),#303,.T.); +#290 = FACE_BOUND('',#291,.T.); +#291 = EDGE_LOOP('',(#292)); +#292 = ORIENTED_EDGE('',*,*,#293,.T.); +#293 = EDGE_CURVE('',#294,#294,#296,.T.); +#294 = VERTEX_POINT('',#295); +#295 = CARTESIAN_POINT('',(3.048,0.,0.)); +#296 = SURFACE_CURVE('',#297,(#302),.PCURVE_S1.); +#297 = CIRCLE('',#298,3.048); +#298 = AXIS2_PLACEMENT_3D('',#299,#300,#301); +#299 = CARTESIAN_POINT('',(0.,0.,0.)); +#300 = DIRECTION('',(0.,0.,1.)); +#301 = DIRECTION('',(1.,0.,0.)); +#302 = PCURVE('',#303,#308); +#303 = PLANE('',#304); +#304 = AXIS2_PLACEMENT_3D('',#305,#306,#307); +#305 = CARTESIAN_POINT('',(-1.121588035219E-16,-1.226531127144E-17,0.)); +#306 = DIRECTION('',(0.,0.,1.)); +#307 = DIRECTION('',(1.,0.,0.)); +#308 = DEFINITIONAL_REPRESENTATION('',(#309),#313); +#309 = CIRCLE('',#310,3.048); +#310 = AXIS2_PLACEMENT_2D('',#311,#312); +#311 = CARTESIAN_POINT('',(1.121588035219E-16,1.226531127144E-17)); +#312 = DIRECTION('',(1.,0.)); +#313 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#314 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#318)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#315,#316,#317)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#315 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#316 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#317 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#318 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#315, + 'distance_accuracy_value','confusion accuracy'); +#319 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#320,#322); +#320 = ( REPRESENTATION_RELATIONSHIP('','',#286,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#321) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#321 = ITEM_DEFINED_TRANSFORMATION('','',#11,#35); +#322 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#323 + ); +#323 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('18','Dielectric_003','',#5,#281,$ + ); +#324 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#283)); +#325 = SHAPE_DEFINITION_REPRESENTATION(#326,#332); +#326 = PRODUCT_DEFINITION_SHAPE('','',#327); +#327 = PRODUCT_DEFINITION('design','',#328,#331); +#328 = PRODUCT_DEFINITION_FORMATION('','',#329); +#329 = PRODUCT('Conductor_000','Conductor_000','',(#330)); +#330 = PRODUCT_CONTEXT('',#2,'mechanical'); +#331 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#332 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#333),#376); +#333 = SHELL_BASED_SURFACE_MODEL('',(#334)); +#334 = OPEN_SHELL('',(#335)); +#335 = ADVANCED_FACE('',(#336),#350,.T.); +#336 = FACE_BOUND('',#337,.T.); +#337 = EDGE_LOOP('',(#338,#361)); +#338 = ORIENTED_EDGE('',*,*,#339,.T.); +#339 = EDGE_CURVE('',#340,#342,#344,.T.); +#340 = VERTEX_POINT('',#341); +#341 = CARTESIAN_POINT('',(-2.E+03,0.,0.)); +#342 = VERTEX_POINT('',#343); +#343 = CARTESIAN_POINT('',(2.E+03,0.,0.)); +#344 = SURFACE_CURVE('',#345,(#349),.PCURVE_S1.); +#345 = LINE('',#346,#347); +#346 = CARTESIAN_POINT('',(-2.E+03,0.,0.)); +#347 = VECTOR('',#348,1.); +#348 = DIRECTION('',(1.,0.,0.)); +#349 = PCURVE('',#350,#355); +#350 = PLANE('',#351); +#351 = AXIS2_PLACEMENT_3D('',#352,#353,#354); +#352 = CARTESIAN_POINT('',(-8.96165565261E-14,7.973436582947E-15,0.)); +#353 = DIRECTION('',(0.,0.,1.)); +#354 = DIRECTION('',(1.,0.,0.)); +#355 = DEFINITIONAL_REPRESENTATION('',(#356),#360); +#356 = LINE('',#357,#358); +#357 = CARTESIAN_POINT('',(-2.E+03,-7.973436582947E-15)); +#358 = VECTOR('',#359,1.); +#359 = DIRECTION('',(1.,0.)); +#360 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#361 = ORIENTED_EDGE('',*,*,#362,.T.); +#362 = EDGE_CURVE('',#342,#340,#363,.T.); +#363 = SURFACE_CURVE('',#364,(#369),.PCURVE_S1.); +#364 = CIRCLE('',#365,2.E+03); +#365 = AXIS2_PLACEMENT_3D('',#366,#367,#368); +#366 = CARTESIAN_POINT('',(0.,0.,0.)); +#367 = DIRECTION('',(0.,0.,1.)); +#368 = DIRECTION('',(1.,0.,0.)); +#369 = PCURVE('',#350,#370); +#370 = DEFINITIONAL_REPRESENTATION('',(#371),#375); +#371 = CIRCLE('',#372,2.E+03); +#372 = AXIS2_PLACEMENT_2D('',#373,#374); +#373 = CARTESIAN_POINT('',(8.96165565261E-14,-7.973436582947E-15)); +#374 = DIRECTION('',(1.,0.)); +#375 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#376 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#380)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#377,#378,#379)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#377 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#378 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#379 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#380 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#377, + 'distance_accuracy_value','confusion accuracy'); +#381 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#382,#384); +#382 = ( REPRESENTATION_RELATIONSHIP('','',#332,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#383) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#383 = ITEM_DEFINED_TRANSFORMATION('','',#11,#39); +#384 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#385 + ); +#385 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('19','Conductor_000','',#5,#327,$ + ); +#386 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#329)); +#387 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#388) + ,#222); +#388 = STYLED_ITEM('color',(#389),#197); +#389 = PRESENTATION_STYLE_ASSIGNMENT((#390,#398)); +#390 = SURFACE_STYLE_USAGE(.BOTH.,#391); +#391 = SURFACE_SIDE_STYLE('',(#392,#396)); +#392 = SURFACE_STYLE_FILL_AREA(#393); +#393 = FILL_AREA_STYLE('',(#394)); +#394 = FILL_AREA_STYLE_COLOUR('',#395); +#395 = DRAUGHTING_PRE_DEFINED_COLOUR('red'); +#396 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#395,( + #397)); +#397 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#398 = CURVE_STYLE('',#399,POSITIVE_LENGTH_MEASURE(0.1),#400); +#399 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#400 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#401 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#402) + ,#84); +#402 = STYLED_ITEM('color',(#403),#59); +#403 = PRESENTATION_STYLE_ASSIGNMENT((#404,#411)); +#404 = SURFACE_STYLE_USAGE(.BOTH.,#405); +#405 = SURFACE_SIDE_STYLE('',(#406,#409)); +#406 = SURFACE_STYLE_FILL_AREA(#407); +#407 = FILL_AREA_STYLE('',(#408)); +#408 = FILL_AREA_STYLE_COLOUR('',#395); +#409 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#395,( + #410)); +#410 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#411 = CURVE_STYLE('',#412,POSITIVE_LENGTH_MEASURE(0.1),#400); +#412 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#413 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#414) + ,#314); +#414 = STYLED_ITEM('color',(#415),#289); +#415 = PRESENTATION_STYLE_ASSIGNMENT((#416,#423)); +#416 = SURFACE_STYLE_USAGE(.BOTH.,#417); +#417 = SURFACE_SIDE_STYLE('',(#418,#421)); +#418 = SURFACE_STYLE_FILL_AREA(#419); +#419 = FILL_AREA_STYLE('',(#420)); +#420 = FILL_AREA_STYLE_COLOUR('',#395); +#421 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#395,( + #422)); +#422 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#423 = CURVE_STYLE('',#424,POSITIVE_LENGTH_MEASURE(0.1),#400); +#424 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#425 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#426) + ,#376); +#426 = STYLED_ITEM('color',(#427),#335); +#427 = PRESENTATION_STYLE_ASSIGNMENT((#428,#436)); +#428 = SURFACE_STYLE_USAGE(.BOTH.,#429); +#429 = SURFACE_SIDE_STYLE('',(#430,#434)); +#430 = SURFACE_STYLE_FILL_AREA(#431); +#431 = FILL_AREA_STYLE('',(#432)); +#432 = FILL_AREA_STYLE_COLOUR('',#433); +#433 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#434 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#433,( + #435)); +#435 = SURFACE_STYLE_TRANSPARENT(0.990000009537); +#436 = CURVE_STYLE('',#437,POSITIVE_LENGTH_MEASURE(0.1),#400); +#437 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#438 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#439) + ,#176); +#439 = STYLED_ITEM('color',(#440),#151); +#440 = PRESENTATION_STYLE_ASSIGNMENT((#441,#447)); +#441 = SURFACE_STYLE_USAGE(.BOTH.,#442); +#442 = SURFACE_SIDE_STYLE('',(#443)); +#443 = SURFACE_STYLE_FILL_AREA(#444); +#444 = FILL_AREA_STYLE('',(#445)); +#445 = FILL_AREA_STYLE_COLOUR('',#446); +#446 = COLOUR_RGB('',1.,0.333333345507,0.); +#447 = CURVE_STYLE('',#448,POSITIVE_LENGTH_MEASURE(0.1),#400); +#448 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#449 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#450) + ,#130); +#450 = STYLED_ITEM('color',(#451),#105); +#451 = PRESENTATION_STYLE_ASSIGNMENT((#452,#457)); +#452 = SURFACE_STYLE_USAGE(.BOTH.,#453); +#453 = SURFACE_SIDE_STYLE('',(#454)); +#454 = SURFACE_STYLE_FILL_AREA(#455); +#455 = FILL_AREA_STYLE('',(#456)); +#456 = FILL_AREA_STYLE_COLOUR('',#446); +#457 = CURVE_STYLE('',#458,POSITIVE_LENGTH_MEASURE(0.1),#400); +#458 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#459 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#460) + ,#268); +#460 = STYLED_ITEM('color',(#461),#243); +#461 = PRESENTATION_STYLE_ASSIGNMENT((#462,#467)); +#462 = SURFACE_STYLE_USAGE(.BOTH.,#463); +#463 = SURFACE_SIDE_STYLE('',(#464)); +#464 = SURFACE_STYLE_FILL_AREA(#465); +#465 = FILL_AREA_STYLE('',(#466)); +#466 = FILL_AREA_STYLE_COLOUR('',#446); +#467 = CURVE_STYLE('',#468,POSITIVE_LENGTH_MEASURE(0.1),#400); +#468 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/agrawal1981/agrawal1981.pulmtln.in.json b/testData/agrawal1981/agrawal1981.tulip.adapted.json similarity index 91% rename from testData/agrawal1981/agrawal1981.pulmtln.in.json rename to testData/agrawal1981/agrawal1981.tulip.adapted.json index dfd6868..7040c41 100644 --- a/testData/agrawal1981/agrawal1981.pulmtln.in.json +++ b/testData/agrawal1981/agrawal1981.tulip.adapted.json @@ -10,7 +10,6 @@ "Conductor_1": {"type": "PEC", "tag": 4 }, "Conductor_2": {"type": "PEC", "tag": 3 }, "Conductor_3": {"type": "PEC", "tag": 2 }, - "OpenBoundary_0": {"type": "OpenBoundary", "tag": 5}, "Vacuum_0": {"type": "Vacuum", "tag": 6}, "Dielectric_1": {"type": "Dielectric", "eps_r": 2.26, "tag": 9}, "Dielectric_2": {"type": "Dielectric", "eps_r": 2.26, "tag": 8}, diff --git a/testData/check_exported_area/closed_case.FCStd b/testData/check_exported_area/closed_case.FCStd new file mode 100644 index 0000000..c1cbc85 Binary files /dev/null and b/testData/check_exported_area/closed_case.FCStd differ diff --git a/testData/check_exported_area/closed_case.step b/testData/check_exported_area/closed_case.step new file mode 100644 index 0000000..5ce4861 --- /dev/null +++ b/testData/check_exported_area/closed_case.step @@ -0,0 +1,149 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-05-12T12:26:04',(''),(''), + 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('Unnamed','Unnamed','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19),#23); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#27)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#24,#25,#26)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#24 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#25 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#26 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#27 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#24, + 'distance_accuracy_value','confusion accuracy'); +#28 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#29 = SHAPE_DEFINITION_REPRESENTATION(#30,#36); +#30 = PRODUCT_DEFINITION_SHAPE('','',#31); +#31 = PRODUCT_DEFINITION('design','',#32,#35); +#32 = PRODUCT_DEFINITION_FORMATION('','',#33); +#33 = PRODUCT('Conductor_1','Conductor_1','',(#34)); +#34 = PRODUCT_CONTEXT('',#2,'mechanical'); +#35 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#36 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#37),#56); +#37 = SHELL_BASED_SURFACE_MODEL('',(#38)); +#38 = OPEN_SHELL('',(#39)); +#39 = ADVANCED_FACE('',(#40),#51,.T.); +#40 = FACE_BOUND('',#41,.T.); +#41 = EDGE_LOOP('',(#42)); +#42 = ORIENTED_EDGE('',*,*,#43,.T.); +#43 = EDGE_CURVE('',#44,#44,#46,.T.); +#44 = VERTEX_POINT('',#45); +#45 = CARTESIAN_POINT('',(10.,0.,0.)); +#46 = CIRCLE('',#47,10.); +#47 = AXIS2_PLACEMENT_3D('',#48,#49,#50); +#48 = CARTESIAN_POINT('',(0.,0.,0.)); +#49 = DIRECTION('',(0.,0.,1.)); +#50 = DIRECTION('',(1.,0.,-0.)); +#51 = PLANE('',#52); +#52 = AXIS2_PLACEMENT_3D('',#53,#54,#55); +#53 = CARTESIAN_POINT('',(-5.469760530158E-16,1.387604533E-16,0.)); +#54 = DIRECTION('',(0.,0.,1.)); +#55 = DIRECTION('',(1.,0.,-0.)); +#56 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#60)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#57,#58,#59)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#57 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#58 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#59 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#60 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#57, + 'distance_accuracy_value','confusion accuracy'); +#61 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#62,#64); +#62 = ( REPRESENTATION_RELATIONSHIP('','',#36,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#63) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#63 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#64 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#65); +#65 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','Conductor_1','',#5,#31,$); +#66 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#33)); +#67 = SHAPE_DEFINITION_REPRESENTATION(#68,#74); +#68 = PRODUCT_DEFINITION_SHAPE('','',#69); +#69 = PRODUCT_DEFINITION('design','',#70,#73); +#70 = PRODUCT_DEFINITION_FORMATION('','',#71); +#71 = PRODUCT('Conductor_0','Conductor_0','',(#72)); +#72 = PRODUCT_CONTEXT('',#2,'mechanical'); +#73 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#74 = GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION('',(#11,#75), + #84); +#75 = GEOMETRIC_CURVE_SET('',(#76)); +#76 = TRIMMED_CURVE('',#77,(#82,PARAMETER_VALUE(0.)),(#83, + PARAMETER_VALUE(6.28318530718)),.T.,.PARAMETER.); +#77 = CIRCLE('',#78,50.); +#78 = AXIS2_PLACEMENT_3D('',#79,#80,#81); +#79 = CARTESIAN_POINT('',(0.,0.,0.)); +#80 = DIRECTION('',(0.,0.,1.)); +#81 = DIRECTION('',(1.,0.,-0.)); +#82 = CARTESIAN_POINT('',(50.,0.,0.)); +#83 = CARTESIAN_POINT('',(50.,0.,0.)); +#84 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#88)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#85,#86,#87)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#85 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#86 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#87 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#88 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#85, + 'distance_accuracy_value','confusion accuracy'); +#89 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#90,#92); +#90 = ( REPRESENTATION_RELATIONSHIP('','',#74,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#91) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#91 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#92 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#93); +#93 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Conductor_0','',#5,#69,$); +#94 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#71)); +#95 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#96), + #84); +#96 = STYLED_ITEM('color',(#97),#75); +#97 = PRESENTATION_STYLE_ASSIGNMENT((#98,#104)); +#98 = SURFACE_STYLE_USAGE(.BOTH.,#99); +#99 = SURFACE_SIDE_STYLE('',(#100)); +#100 = SURFACE_STYLE_FILL_AREA(#101); +#101 = FILL_AREA_STYLE('',(#102)); +#102 = FILL_AREA_STYLE_COLOUR('',#103); +#103 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#104 = CURVE_STYLE('',#105,POSITIVE_LENGTH_MEASURE(0.1),#106); +#105 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#106 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#107 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#108) + ,#56); +#108 = STYLED_ITEM('color',(#109),#39); +#109 = PRESENTATION_STYLE_ASSIGNMENT((#110,#115)); +#110 = SURFACE_STYLE_USAGE(.BOTH.,#111); +#111 = SURFACE_SIDE_STYLE('',(#112)); +#112 = SURFACE_STYLE_FILL_AREA(#113); +#113 = FILL_AREA_STYLE('',(#114)); +#114 = FILL_AREA_STYLE_COLOUR('',#103); +#115 = CURVE_STYLE('',#116,POSITIVE_LENGTH_MEASURE(0.1),#106); +#116 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.FCStd b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.FCStd new file mode 100644 index 0000000..8fda367 Binary files /dev/null and b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.FCStd differ diff --git a/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.json b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.json new file mode 100644 index 0000000..cf9fd42 --- /dev/null +++ b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.json @@ -0,0 +1,16 @@ +{ + "CrossSection":[ + { + "name":"Conductor_000", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_000", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.step b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.step new file mode 100644 index 0000000..9d4684f --- /dev/null +++ b/testData/conductor_and_outer_dielectric/conductor_and_outer_dielectric.step @@ -0,0 +1,202 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-09-05T12:34:40',(''),(''), + 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('conductor_and_outer_dielectric', + 'conductor_and_outer_dielectric','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19),#23); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(-1.209,5.934,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#27)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#24,#25,#26)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#24 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#25 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#26 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#27 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#24, + 'distance_accuracy_value','confusion accuracy'); +#28 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#29 = SHAPE_DEFINITION_REPRESENTATION(#30,#36); +#30 = PRODUCT_DEFINITION_SHAPE('','',#31); +#31 = PRODUCT_DEFINITION('design','',#32,#35); +#32 = PRODUCT_DEFINITION_FORMATION('','',#33); +#33 = PRODUCT('Conductor_000','Conductor_000','',(#34)); +#34 = PRODUCT_CONTEXT('',#2,'mechanical'); +#35 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#36 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#37),#64); +#37 = SHELL_BASED_SURFACE_MODEL('',(#38)); +#38 = OPEN_SHELL('',(#39)); +#39 = ADVANCED_FACE('',(#40),#53,.T.); +#40 = FACE_BOUND('',#41,.T.); +#41 = EDGE_LOOP('',(#42)); +#42 = ORIENTED_EDGE('',*,*,#43,.T.); +#43 = EDGE_CURVE('',#44,#44,#46,.T.); +#44 = VERTEX_POINT('',#45); +#45 = CARTESIAN_POINT('',(1.15,0.,0.)); +#46 = SURFACE_CURVE('',#47,(#52),.PCURVE_S1.); +#47 = CIRCLE('',#48,1.15); +#48 = AXIS2_PLACEMENT_3D('',#49,#50,#51); +#49 = CARTESIAN_POINT('',(0.,0.,0.)); +#50 = DIRECTION('',(0.,0.,1.)); +#51 = DIRECTION('',(1.,0.,0.)); +#52 = PCURVE('',#53,#58); +#53 = PLANE('',#54); +#54 = AXIS2_PLACEMENT_3D('',#55,#56,#57); +#55 = CARTESIAN_POINT('',(-1.5E-16,6.E-17,0.)); +#56 = DIRECTION('',(0.,0.,1.)); +#57 = DIRECTION('',(1.,0.,0.)); +#58 = DEFINITIONAL_REPRESENTATION('',(#59),#63); +#59 = CIRCLE('',#60,1.15); +#60 = AXIS2_PLACEMENT_2D('',#61,#62); +#61 = CARTESIAN_POINT('',(1.5E-16,-6.E-17)); +#62 = DIRECTION('',(1.,0.)); +#63 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#64 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#68)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#65,#66,#67)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#65 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#66 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#67 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#68 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#65, + 'distance_accuracy_value','confusion accuracy'); +#69 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#70,#72); +#70 = ( REPRESENTATION_RELATIONSHIP('','',#36,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#71) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#71 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#72 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#73); +#73 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('153','Conductor_000','',#5,#31,$); +#74 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#33)); +#75 = SHAPE_DEFINITION_REPRESENTATION(#76,#82); +#76 = PRODUCT_DEFINITION_SHAPE('','',#77); +#77 = PRODUCT_DEFINITION('design','',#78,#81); +#78 = PRODUCT_DEFINITION_FORMATION('','',#79); +#79 = PRODUCT('Dielectric_000','Dielectric_000','',(#80)); +#80 = PRODUCT_CONTEXT('',#2,'mechanical'); +#81 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#82 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#83),#129); +#83 = SHELL_BASED_SURFACE_MODEL('',(#84)); +#84 = OPEN_SHELL('',(#85)); +#85 = ADVANCED_FACE('',(#86,#110),#99,.T.); +#86 = FACE_BOUND('',#87,.T.); +#87 = EDGE_LOOP('',(#88)); +#88 = ORIENTED_EDGE('',*,*,#89,.T.); +#89 = EDGE_CURVE('',#90,#90,#92,.T.); +#90 = VERTEX_POINT('',#91); +#91 = CARTESIAN_POINT('',(8.05,0.,0.)); +#92 = SURFACE_CURVE('',#93,(#98),.PCURVE_S1.); +#93 = CIRCLE('',#94,8.05); +#94 = AXIS2_PLACEMENT_3D('',#95,#96,#97); +#95 = CARTESIAN_POINT('',(0.,0.,0.)); +#96 = DIRECTION('',(0.,0.,1.)); +#97 = DIRECTION('',(1.,0.,0.)); +#98 = PCURVE('',#99,#104); +#99 = PLANE('',#100); +#100 = AXIS2_PLACEMENT_3D('',#101,#102,#103); +#101 = CARTESIAN_POINT('',(-6.8E-16,-3.3E-16,0.)); +#102 = DIRECTION('',(0.,0.,1.)); +#103 = DIRECTION('',(1.,0.,0.)); +#104 = DEFINITIONAL_REPRESENTATION('',(#105),#109); +#105 = CIRCLE('',#106,8.05); +#106 = AXIS2_PLACEMENT_2D('',#107,#108); +#107 = CARTESIAN_POINT('',(6.8E-16,3.3E-16)); +#108 = DIRECTION('',(1.,0.)); +#109 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#110 = FACE_BOUND('',#111,.T.); +#111 = EDGE_LOOP('',(#112)); +#112 = ORIENTED_EDGE('',*,*,#113,.F.); +#113 = EDGE_CURVE('',#114,#114,#116,.T.); +#114 = VERTEX_POINT('',#115); +#115 = CARTESIAN_POINT('',(7.95,0.,0.)); +#116 = SURFACE_CURVE('',#117,(#122),.PCURVE_S1.); +#117 = CIRCLE('',#118,7.95); +#118 = AXIS2_PLACEMENT_3D('',#119,#120,#121); +#119 = CARTESIAN_POINT('',(0.,0.,0.)); +#120 = DIRECTION('',(0.,0.,1.)); +#121 = DIRECTION('',(1.,0.,0.)); +#122 = PCURVE('',#99,#123); +#123 = DEFINITIONAL_REPRESENTATION('',(#124),#128); +#124 = CIRCLE('',#125,7.95); +#125 = AXIS2_PLACEMENT_2D('',#126,#127); +#126 = CARTESIAN_POINT('',(6.8E-16,3.3E-16)); +#127 = DIRECTION('',(1.,0.)); +#128 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#129 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#133)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#130,#131,#132)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#130 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#131 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#132 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#133 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#130, + 'distance_accuracy_value','confusion accuracy'); +#134 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#135,#137); +#135 = ( REPRESENTATION_RELATIONSHIP('','',#82,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#136) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#136 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#137 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#138 + ); +#138 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('154','Dielectric_000','',#5,#77,$ + ); +#139 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#79)); +#140 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#141) + ,#64); +#141 = STYLED_ITEM('color',(#142),#39); +#142 = PRESENTATION_STYLE_ASSIGNMENT((#143,#149)); +#143 = SURFACE_STYLE_USAGE(.BOTH.,#144); +#144 = SURFACE_SIDE_STYLE('',(#145)); +#145 = SURFACE_STYLE_FILL_AREA(#146); +#146 = FILL_AREA_STYLE('',(#147)); +#147 = FILL_AREA_STYLE_COLOUR('',#148); +#148 = COLOUR_RGB('',0.333333345507,0.666666687201,1.); +#149 = CURVE_STYLE('',#150,POSITIVE_LENGTH_MEASURE(0.1),#151); +#150 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#151 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#152 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#153) + ,#129); +#153 = STYLED_ITEM('color',(#154),#85); +#154 = PRESENTATION_STYLE_ASSIGNMENT((#155,#161)); +#155 = SURFACE_STYLE_USAGE(.BOTH.,#156); +#156 = SURFACE_SIDE_STYLE('',(#157)); +#157 = SURFACE_STYLE_FILL_AREA(#158); +#158 = FILL_AREA_STYLE('',(#159)); +#159 = FILL_AREA_STYLE_COLOUR('',#160); +#160 = DRAUGHTING_PRE_DEFINED_COLOUR('red'); +#161 = CURVE_STYLE('',#162,POSITIVE_LENGTH_MEASURE(0.1),#151); +#162 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/empty_coax/empty_coax.json b/testData/empty_coax/empty_coax.json new file mode 100644 index 0000000..ba505d1 --- /dev/null +++ b/testData/empty_coax/empty_coax.json @@ -0,0 +1,16 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/empty_coax/empty_coax.step b/testData/empty_coax/empty_coax.step index eec4544..d18dff3 100644 --- a/testData/empty_coax/empty_coax.step +++ b/testData/empty_coax/empty_coax.step @@ -1,178 +1,178 @@ -ISO-10303-21; -HEADER; -FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); -FILE_NAME('Open CASCADE Shape Model','2023-06-22T17:28:23',(''),(''), - 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); -FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); -ENDSEC; -DATA; -#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', - 'automotive_design',2000,#2); -#2 = APPLICATION_CONTEXT( - 'core data for automotive mechanical design processes'); -#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); -#4 = PRODUCT_DEFINITION_SHAPE('','',#5); -#5 = PRODUCT_DEFINITION('design','',#6,#9); -#6 = PRODUCT_DEFINITION_FORMATION('','',#7); -#7 = PRODUCT('Unnamed','Unnamed','',(#8)); -#8 = PRODUCT_CONTEXT('',#2,'mechanical'); -#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#10 = SHAPE_REPRESENTATION('',(#11,#15,#19),#23); -#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); -#12 = CARTESIAN_POINT('',(0.,0.,0.)); -#13 = DIRECTION('',(0.,0.,1.)); -#14 = DIRECTION('',(1.,0.,-0.)); -#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); -#16 = CARTESIAN_POINT('',(0.,0.,0.)); -#17 = DIRECTION('',(0.,-0.,1.)); -#18 = DIRECTION('',(1.,6.123233995737E-17,0.)); -#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); -#20 = CARTESIAN_POINT('',(0.,0.,0.)); -#21 = DIRECTION('',(0.,-0.,1.)); -#22 = DIRECTION('',(1.,6.123233995737E-17,0.)); -#23 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#27)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#24,#25,#26)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#24 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#25 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#26 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#27 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#24, - 'distance_accuracy_value','confusion accuracy'); -#28 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); -#29 = SHAPE_DEFINITION_REPRESENTATION(#30,#36); -#30 = PRODUCT_DEFINITION_SHAPE('','',#31); -#31 = PRODUCT_DEFINITION('design','',#32,#35); -#32 = PRODUCT_DEFINITION_FORMATION('','',#33); -#33 = PRODUCT('Conductor_0','Conductor_0','',(#34)); -#34 = PRODUCT_CONTEXT('',#2,'mechanical'); -#35 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#36 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#37),#64); -#37 = SHELL_BASED_SURFACE_MODEL('',(#38)); -#38 = OPEN_SHELL('',(#39)); -#39 = ADVANCED_FACE('',(#40),#53,.T.); -#40 = FACE_BOUND('',#41,.T.); -#41 = EDGE_LOOP('',(#42)); -#42 = ORIENTED_EDGE('',*,*,#43,.T.); -#43 = EDGE_CURVE('',#44,#44,#46,.T.); -#44 = VERTEX_POINT('',#45); -#45 = CARTESIAN_POINT('',(50.,0.,0.)); -#46 = SURFACE_CURVE('',#47,(#52),.PCURVE_S1.); -#47 = CIRCLE('',#48,50.); -#48 = AXIS2_PLACEMENT_3D('',#49,#50,#51); -#49 = CARTESIAN_POINT('',(0.,0.,0.)); -#50 = DIRECTION('',(0.,0.,1.)); -#51 = DIRECTION('',(1.,0.,-0.)); -#52 = PCURVE('',#53,#58); -#53 = PLANE('',#54); -#54 = AXIS2_PLACEMENT_3D('',#55,#56,#57); -#55 = CARTESIAN_POINT('',(-3.500646739301E-15,-2.041077998579E-15,0.)); -#56 = DIRECTION('',(0.,0.,1.)); -#57 = DIRECTION('',(1.,0.,-0.)); -#58 = DEFINITIONAL_REPRESENTATION('',(#59),#63); -#59 = CIRCLE('',#60,50.); -#60 = AXIS2_PLACEMENT_2D('',#61,#62); -#61 = CARTESIAN_POINT('',(3.500646739301E-15,2.041077998579E-15)); -#62 = DIRECTION('',(1.,0.)); -#63 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#64 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#68)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#65,#66,#67)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#65 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#66 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#67 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#68 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#65, - 'distance_accuracy_value','confusion accuracy'); -#69 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#70,#72); -#70 = ( REPRESENTATION_RELATIONSHIP('','',#36,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#71) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#71 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); -#72 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#73); -#73 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('11','Conductor_0','',#5,#31,$); -#74 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#33)); -#75 = SHAPE_DEFINITION_REPRESENTATION(#76,#82); -#76 = PRODUCT_DEFINITION_SHAPE('','',#77); -#77 = PRODUCT_DEFINITION('design','',#78,#81); -#78 = PRODUCT_DEFINITION_FORMATION('','',#79); -#79 = PRODUCT('Conductor_1','Conductor_1','',(#80)); -#80 = PRODUCT_CONTEXT('',#2,'mechanical'); -#81 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#82 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#83),#110); -#83 = SHELL_BASED_SURFACE_MODEL('',(#84)); -#84 = OPEN_SHELL('',(#85)); -#85 = ADVANCED_FACE('',(#86),#99,.T.); -#86 = FACE_BOUND('',#87,.T.); -#87 = EDGE_LOOP('',(#88)); -#88 = ORIENTED_EDGE('',*,*,#89,.T.); -#89 = EDGE_CURVE('',#90,#90,#92,.T.); -#90 = VERTEX_POINT('',#91); -#91 = CARTESIAN_POINT('',(25.,0.,0.)); -#92 = SURFACE_CURVE('',#93,(#98),.PCURVE_S1.); -#93 = CIRCLE('',#94,25.); -#94 = AXIS2_PLACEMENT_3D('',#95,#96,#97); -#95 = CARTESIAN_POINT('',(0.,0.,0.)); -#96 = DIRECTION('',(0.,0.,1.)); -#97 = DIRECTION('',(1.,0.,-0.)); -#98 = PCURVE('',#99,#104); -#99 = PLANE('',#100); -#100 = AXIS2_PLACEMENT_3D('',#101,#102,#103); -#101 = CARTESIAN_POINT('',(-1.75032336965E-15,-1.020538999289E-15,0.)); -#102 = DIRECTION('',(0.,0.,1.)); -#103 = DIRECTION('',(1.,0.,-0.)); -#104 = DEFINITIONAL_REPRESENTATION('',(#105),#109); -#105 = CIRCLE('',#106,25.); -#106 = AXIS2_PLACEMENT_2D('',#107,#108); -#107 = CARTESIAN_POINT('',(1.75032336965E-15,1.020538999289E-15)); -#108 = DIRECTION('',(1.,0.)); -#109 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#114)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#111,#112,#113)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#111 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#112 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#113 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#114 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#111, - 'distance_accuracy_value','confusion accuracy'); -#115 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#116,#118); -#116 = ( REPRESENTATION_RELATIONSHIP('','',#82,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#117) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#117 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); -#118 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#119 - ); -#119 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('12','Conductor_1','',#5,#77,$); -#120 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#79)); -#121 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#122) - ,#64); -#122 = STYLED_ITEM('color',(#123),#39); -#123 = PRESENTATION_STYLE_ASSIGNMENT((#124,#130)); -#124 = SURFACE_STYLE_USAGE(.BOTH.,#125); -#125 = SURFACE_SIDE_STYLE('',(#126)); -#126 = SURFACE_STYLE_FILL_AREA(#127); -#127 = FILL_AREA_STYLE('',(#128)); -#128 = FILL_AREA_STYLE_COLOUR('',#129); -#129 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); -#130 = CURVE_STYLE('',#131,POSITIVE_LENGTH_MEASURE(0.1),#132); -#131 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#132 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, - 9.803921802644E-02); -#133 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#134) - ,#110); -#134 = STYLED_ITEM('color',(#135),#85); -#135 = PRESENTATION_STYLE_ASSIGNMENT((#136,#141)); -#136 = SURFACE_STYLE_USAGE(.BOTH.,#137); -#137 = SURFACE_SIDE_STYLE('',(#138)); -#138 = SURFACE_STYLE_FILL_AREA(#139); -#139 = FILL_AREA_STYLE('',(#140)); -#140 = FILL_AREA_STYLE_COLOUR('',#129); -#141 = CURVE_STYLE('',#142,POSITIVE_LENGTH_MEASURE(0.1),#132); -#142 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -ENDSEC; -END-ISO-10303-21; +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2023-06-22T17:28:23',(''),(''), + 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('Unnamed','Unnamed','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19),#23); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#17 = DIRECTION('',(0.,-0.,1.)); +#18 = DIRECTION('',(1.,6.123233995737E-17,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#21 = DIRECTION('',(0.,-0.,1.)); +#22 = DIRECTION('',(1.,6.123233995737E-17,0.)); +#23 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#27)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#24,#25,#26)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#24 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#25 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#26 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#27 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#24, + 'distance_accuracy_value','confusion accuracy'); +#28 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#29 = SHAPE_DEFINITION_REPRESENTATION(#30,#36); +#30 = PRODUCT_DEFINITION_SHAPE('','',#31); +#31 = PRODUCT_DEFINITION('design','',#32,#35); +#32 = PRODUCT_DEFINITION_FORMATION('','',#33); +#33 = PRODUCT('Conductor_0','Conductor_0','',(#34)); +#34 = PRODUCT_CONTEXT('',#2,'mechanical'); +#35 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#36 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#37),#64); +#37 = SHELL_BASED_SURFACE_MODEL('',(#38)); +#38 = OPEN_SHELL('',(#39)); +#39 = ADVANCED_FACE('',(#40),#53,.T.); +#40 = FACE_BOUND('',#41,.T.); +#41 = EDGE_LOOP('',(#42)); +#42 = ORIENTED_EDGE('',*,*,#43,.T.); +#43 = EDGE_CURVE('',#44,#44,#46,.T.); +#44 = VERTEX_POINT('',#45); +#45 = CARTESIAN_POINT('',(50.,0.,0.)); +#46 = SURFACE_CURVE('',#47,(#52),.PCURVE_S1.); +#47 = CIRCLE('',#48,50.); +#48 = AXIS2_PLACEMENT_3D('',#49,#50,#51); +#49 = CARTESIAN_POINT('',(0.,0.,0.)); +#50 = DIRECTION('',(0.,0.,1.)); +#51 = DIRECTION('',(1.,0.,-0.)); +#52 = PCURVE('',#53,#58); +#53 = PLANE('',#54); +#54 = AXIS2_PLACEMENT_3D('',#55,#56,#57); +#55 = CARTESIAN_POINT('',(-3.500646739301E-15,-2.041077998579E-15,0.)); +#56 = DIRECTION('',(0.,0.,1.)); +#57 = DIRECTION('',(1.,0.,-0.)); +#58 = DEFINITIONAL_REPRESENTATION('',(#59),#63); +#59 = CIRCLE('',#60,50.); +#60 = AXIS2_PLACEMENT_2D('',#61,#62); +#61 = CARTESIAN_POINT('',(3.500646739301E-15,2.041077998579E-15)); +#62 = DIRECTION('',(1.,0.)); +#63 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#64 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#68)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#65,#66,#67)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#65 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#66 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#67 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#68 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#65, + 'distance_accuracy_value','confusion accuracy'); +#69 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#70,#72); +#70 = ( REPRESENTATION_RELATIONSHIP('','',#36,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#71) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#71 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#72 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#73); +#73 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('11','Conductor_0','',#5,#31,$); +#74 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#33)); +#75 = SHAPE_DEFINITION_REPRESENTATION(#76,#82); +#76 = PRODUCT_DEFINITION_SHAPE('','',#77); +#77 = PRODUCT_DEFINITION('design','',#78,#81); +#78 = PRODUCT_DEFINITION_FORMATION('','',#79); +#79 = PRODUCT('Conductor_1','Conductor_1','',(#80)); +#80 = PRODUCT_CONTEXT('',#2,'mechanical'); +#81 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#82 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#83),#110); +#83 = SHELL_BASED_SURFACE_MODEL('',(#84)); +#84 = OPEN_SHELL('',(#85)); +#85 = ADVANCED_FACE('',(#86),#99,.T.); +#86 = FACE_BOUND('',#87,.T.); +#87 = EDGE_LOOP('',(#88)); +#88 = ORIENTED_EDGE('',*,*,#89,.T.); +#89 = EDGE_CURVE('',#90,#90,#92,.T.); +#90 = VERTEX_POINT('',#91); +#91 = CARTESIAN_POINT('',(25.,0.,0.)); +#92 = SURFACE_CURVE('',#93,(#98),.PCURVE_S1.); +#93 = CIRCLE('',#94,25.); +#94 = AXIS2_PLACEMENT_3D('',#95,#96,#97); +#95 = CARTESIAN_POINT('',(0.,0.,0.)); +#96 = DIRECTION('',(0.,0.,1.)); +#97 = DIRECTION('',(1.,0.,-0.)); +#98 = PCURVE('',#99,#104); +#99 = PLANE('',#100); +#100 = AXIS2_PLACEMENT_3D('',#101,#102,#103); +#101 = CARTESIAN_POINT('',(-1.75032336965E-15,-1.020538999289E-15,0.)); +#102 = DIRECTION('',(0.,0.,1.)); +#103 = DIRECTION('',(1.,0.,-0.)); +#104 = DEFINITIONAL_REPRESENTATION('',(#105),#109); +#105 = CIRCLE('',#106,25.); +#106 = AXIS2_PLACEMENT_2D('',#107,#108); +#107 = CARTESIAN_POINT('',(1.75032336965E-15,1.020538999289E-15)); +#108 = DIRECTION('',(1.,0.)); +#109 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#114)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#111,#112,#113)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#111 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#112 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#113 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#114 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#111, + 'distance_accuracy_value','confusion accuracy'); +#115 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#116,#118); +#116 = ( REPRESENTATION_RELATIONSHIP('','',#82,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#117) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#117 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#118 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#119 + ); +#119 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('12','Conductor_1','',#5,#77,$); +#120 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#79)); +#121 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#122) + ,#64); +#122 = STYLED_ITEM('color',(#123),#39); +#123 = PRESENTATION_STYLE_ASSIGNMENT((#124,#130)); +#124 = SURFACE_STYLE_USAGE(.BOTH.,#125); +#125 = SURFACE_SIDE_STYLE('',(#126)); +#126 = SURFACE_STYLE_FILL_AREA(#127); +#127 = FILL_AREA_STYLE('',(#128)); +#128 = FILL_AREA_STYLE_COLOUR('',#129); +#129 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#130 = CURVE_STYLE('',#131,POSITIVE_LENGTH_MEASURE(0.1),#132); +#131 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#132 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#133 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#134) + ,#110); +#134 = STYLED_ITEM('color',(#135),#85); +#135 = PRESENTATION_STYLE_ASSIGNMENT((#136,#141)); +#136 = SURFACE_STYLE_USAGE(.BOTH.,#137); +#137 = SURFACE_SIDE_STYLE('',(#138)); +#138 = SURFACE_STYLE_FILL_AREA(#139); +#139 = FILL_AREA_STYLE('',(#140)); +#140 = FILL_AREA_STYLE_COLOUR('',#129); +#141 = CURVE_STYLE('',#142,POSITIVE_LENGTH_MEASURE(0.1),#132); +#142 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/empty_coax/empty_coax.pulmtln.in.json b/testData/empty_coax/empty_coax.tulip.adapted.json similarity index 93% rename from testData/empty_coax/empty_coax.pulmtln.in.json rename to testData/empty_coax/empty_coax.tulip.adapted.json index f87fba2..6493ecd 100644 --- a/testData/empty_coax/empty_coax.pulmtln.in.json +++ b/testData/empty_coax/empty_coax.tulip.adapted.json @@ -1,5 +1,5 @@ { - "analysis": { + "DriverOptions": { "order": 3, "exportParaViewSolution": true, "exportFolder": "Results/empty_coax/" diff --git a/testData/five_wires/five_wires.json b/testData/five_wires/five_wires.json new file mode 100644 index 0000000..baf93aa --- /dev/null +++ b/testData/five_wires/five_wires.json @@ -0,0 +1,70 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_002", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_003", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_004", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_005", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_1", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_002", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_003", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_004", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_005", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/five_wires/five_wires.pulmtln.in.json b/testData/five_wires/five_wires.tulip.adapted.json similarity index 100% rename from testData/five_wires/five_wires.pulmtln.in.json rename to testData/five_wires/five_wires.tulip.adapted.json diff --git a/testData/lansink2024/lansink2024.pulmtln.in.json b/testData/lansink2024/lansink2024.tulip.adapted.json similarity index 100% rename from testData/lansink2024/lansink2024.pulmtln.in.json rename to testData/lansink2024/lansink2024.tulip.adapted.json diff --git a/testData/lansink2024_fdtd_cell/lansink2024_fdtd_cell.pulmtln.in.json b/testData/lansink2024_fdtd_cell/lansink2024_fdtd_cell.tulip.adapted.json similarity index 100% rename from testData/lansink2024_fdtd_cell/lansink2024_fdtd_cell.pulmtln.in.json rename to testData/lansink2024_fdtd_cell/lansink2024_fdtd_cell.tulip.adapted.json diff --git a/testData/lansink2024_inner/lansink2024_inner.pulmtln.in.json b/testData/lansink2024_inner/lansink2024_inner.tulip.adapted.json similarity index 100% rename from testData/lansink2024_inner/lansink2024_inner.pulmtln.in.json rename to testData/lansink2024_inner/lansink2024_inner.tulip.adapted.json diff --git a/testData/lansink2024_large_one_centered_fdtd_cell/lansink2024_large_one_centered_fdtd_cell.pulmtln.in.json b/testData/lansink2024_large_one_centered_fdtd_cell/lansink2024_large_one_centered_fdtd_cell.tulip.adapted.json similarity index 100% rename from testData/lansink2024_large_one_centered_fdtd_cell/lansink2024_large_one_centered_fdtd_cell.pulmtln.in.json rename to testData/lansink2024_large_one_centered_fdtd_cell/lansink2024_large_one_centered_fdtd_cell.tulip.adapted.json diff --git a/testData/lansink2024_single_wire/lansink2024_single_wire.pulmtln.in.json b/testData/lansink2024_single_wire/lansink2024_single_wire.tulip.adapted.json similarity index 100% rename from testData/lansink2024_single_wire/lansink2024_single_wire.pulmtln.in.json rename to testData/lansink2024_single_wire/lansink2024_single_wire.tulip.adapted.json diff --git a/testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.json b/testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.json new file mode 100644 index 0000000..d4a35a4 --- /dev/null +++ b/testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.json @@ -0,0 +1,16 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_0", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.pulmtln.in.json b/testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.tulip.adapted.json similarity index 100% rename from testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.pulmtln.in.json rename to testData/lansink2024_single_wire_multipolar/lansink2024_single_wire_multipolar.tulip.adapted.json diff --git a/testData/lansink2024_small_one_centered/lansink2024_small_one_centered.pulmtln.in.json b/testData/lansink2024_small_one_centered/lansink2024_small_one_centered.tulip.adapted.json similarity index 100% rename from testData/lansink2024_small_one_centered/lansink2024_small_one_centered.pulmtln.in.json rename to testData/lansink2024_small_one_centered/lansink2024_small_one_centered.tulip.adapted.json diff --git a/testData/lansink2024_small_one_centered_fdtd_cell/lansink2024_small_one_centered_fdtd_cell.pulmtln.in.json b/testData/lansink2024_small_one_centered_fdtd_cell/lansink2024_small_one_centered_fdtd_cell.tulip.adapted.json similarity index 100% rename from testData/lansink2024_small_one_centered_fdtd_cell/lansink2024_small_one_centered_fdtd_cell.pulmtln.in.json rename to testData/lansink2024_small_one_centered_fdtd_cell/lansink2024_small_one_centered_fdtd_cell.tulip.adapted.json diff --git a/testData/nested_coax/nested_coax.json b/testData/nested_coax/nested_coax.json new file mode 100644 index 0000000..c82189f --- /dev/null +++ b/testData/nested_coax/nested_coax.json @@ -0,0 +1,22 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_2", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/nested_coax/nested_coax.pulmtln.in.json b/testData/nested_coax/nested_coax.tulip.adapted.json similarity index 100% rename from testData/nested_coax/nested_coax.pulmtln.in.json rename to testData/nested_coax/nested_coax.tulip.adapted.json diff --git a/testData/partially_filled_coax/partially_filled_coax.json b/testData/partially_filled_coax/partially_filled_coax.json new file mode 100644 index 0000000..38c9723 --- /dev/null +++ b/testData/partially_filled_coax/partially_filled_coax.json @@ -0,0 +1,22 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_1", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/partially_filled_coax/partially_filled_coax.pulmtln.in.json b/testData/partially_filled_coax/partially_filled_coax.tulip.adapted.json similarity index 100% rename from testData/partially_filled_coax/partially_filled_coax.pulmtln.in.json rename to testData/partially_filled_coax/partially_filled_coax.tulip.adapted.json diff --git a/testData/realistic_case_with_dielectrics/realistic_case_with_dielectrics.pulmtln.in.json b/testData/realistic_case_with_dielectrics/realistic_case_with_dielectrics.tulip.adapted.json similarity index 100% rename from testData/realistic_case_with_dielectrics/realistic_case_with_dielectrics.pulmtln.in.json rename to testData/realistic_case_with_dielectrics/realistic_case_with_dielectrics.tulip.adapted.json diff --git a/testData/realistic_case_with_dielectrics_fdtd_cell/realistic_case_with_dielectrics_fdtd_cell.pulmtln.in.json b/testData/realistic_case_with_dielectrics_fdtd_cell/realistic_case_with_dielectrics_fdtd_cell.tulip.adapted.json similarity index 100% rename from testData/realistic_case_with_dielectrics_fdtd_cell/realistic_case_with_dielectrics_fdtd_cell.pulmtln.in.json rename to testData/realistic_case_with_dielectrics_fdtd_cell/realistic_case_with_dielectrics_fdtd_cell.tulip.adapted.json diff --git a/testData/single_wire/single_wire.FCStd b/testData/single_wire/single_wire.FCStd new file mode 100644 index 0000000..77f5d7e Binary files /dev/null and b/testData/single_wire/single_wire.FCStd differ diff --git a/testData/single_wire/single_wire.json b/testData/single_wire/single_wire.json new file mode 100644 index 0000000..e05d1c3 --- /dev/null +++ b/testData/single_wire/single_wire.json @@ -0,0 +1,10 @@ +{ + "CrossSection": [ + { + "name": "Conductor", + "material": { + "type": "PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/single_wire/single_wire.step b/testData/single_wire/single_wire.step new file mode 100644 index 0000000..fdf8559 --- /dev/null +++ b/testData/single_wire/single_wire.step @@ -0,0 +1,79 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2026-03-11T12:53:42',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('Conductor','Conductor','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#15),#42); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = SHELL_BASED_SURFACE_MODEL('',(#16)); +#16 = OPEN_SHELL('',(#17)); +#17 = ADVANCED_FACE('',(#18),#31,.T.); +#18 = FACE_BOUND('',#19,.T.); +#19 = EDGE_LOOP('',(#20)); +#20 = ORIENTED_EDGE('',*,*,#21,.T.); +#21 = EDGE_CURVE('',#22,#22,#24,.T.); +#22 = VERTEX_POINT('',#23); +#23 = CARTESIAN_POINT('',(21.,0.,0.)); +#24 = SURFACE_CURVE('',#25,(#30),.PCURVE_S1.); +#25 = CIRCLE('',#26,1.); +#26 = AXIS2_PLACEMENT_3D('',#27,#28,#29); +#27 = CARTESIAN_POINT('',(20.,0.,0.)); +#28 = DIRECTION('',(0.,0.,1.)); +#29 = DIRECTION('',(1.,0.,0.)); +#30 = PCURVE('',#31,#36); +#31 = PLANE('',#32); +#32 = AXIS2_PLACEMENT_3D('',#33,#34,#35); +#33 = CARTESIAN_POINT('',(20.,1.910944170279E-18,0.)); +#34 = DIRECTION('',(0.,0.,1.)); +#35 = DIRECTION('',(1.,0.,0.)); +#36 = DEFINITIONAL_REPRESENTATION('',(#37),#41); +#37 = CIRCLE('',#38,1.); +#38 = AXIS2_PLACEMENT_2D('',#39,#40); +#39 = CARTESIAN_POINT('',(0.,-1.910944170279E-18)); +#40 = DIRECTION('',(1.,0.)); +#41 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#42 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#46)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#43,#44,#45)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#43 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#44 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#45 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#46 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#43, + 'distance_accuracy_value','confusion accuracy'); +#47 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#48 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#49), + #42); +#49 = STYLED_ITEM('color',(#50),#17); +#50 = PRESENTATION_STYLE_ASSIGNMENT((#51,#57)); +#51 = SURFACE_STYLE_USAGE(.BOTH.,#52); +#52 = SURFACE_SIDE_STYLE('',(#53)); +#53 = SURFACE_STYLE_FILL_AREA(#54); +#54 = FILL_AREA_STYLE('',(#55)); +#55 = FILL_AREA_STYLE_COLOUR('',#56); +#56 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#57 = CURVE_STYLE('',#58,POSITIVE_LENGTH_MEASURE(0.1),#59); +#58 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#59 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/single_wire/single_wire.tulip.json b/testData/single_wire/single_wire.tulip.json new file mode 100644 index 0000000..6594cc7 --- /dev/null +++ b/testData/single_wire/single_wire.tulip.json @@ -0,0 +1,20 @@ +{ + "format": "Tulip input file", + "comments": "Single wire in an undefined open domain.", + "materials": [ + { + "name": "PEC", + "type": "conductor", + "id": 1 + } + ], + "model": { + "layers": [ + { + "name": "Wire_A", + "id": 1, + "materialId": 1 + } + ] + } +} \ No newline at end of file diff --git a/testData/three_wires_ribbon/three_wires_ribbon.FCStd b/testData/three_wires_ribbon/three_wires_ribbon.FCStd index a2ec1ce..86601d6 100644 Binary files a/testData/three_wires_ribbon/three_wires_ribbon.FCStd and b/testData/three_wires_ribbon/three_wires_ribbon.FCStd differ diff --git a/testData/three_wires_ribbon/three_wires_ribbon.json b/testData/three_wires_ribbon/three_wires_ribbon.json new file mode 100644 index 0000000..7fb2f54 --- /dev/null +++ b/testData/three_wires_ribbon/three_wires_ribbon.json @@ -0,0 +1,40 @@ +{ + "CrossSection":[ + { + "name":"Conductor_000", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_001", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_002", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_000", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_001", + "material":{ + "type":"Dielectric" + } + }, + { + "name":"Dielectric_002", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/three_wires_ribbon/three_wires_ribbon.step b/testData/three_wires_ribbon/three_wires_ribbon.step index bfe61ac..79a2814 100644 --- a/testData/three_wires_ribbon/three_wires_ribbon.step +++ b/testData/three_wires_ribbon/three_wires_ribbon.step @@ -1,8 +1,8 @@ ISO-10303-21; HEADER; FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); -FILE_NAME('Open CASCADE Shape Model','2025-05-09T11:04:02',(''),(''), - 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_NAME('Open CASCADE Shape Model','2026-03-27T09:06:29',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); ENDSEC; DATA; @@ -17,17 +17,17 @@ DATA; #7 = PRODUCT('three_wires_ribbon','three_wires_ribbon','',(#8)); #8 = PRODUCT_CONTEXT('',#2,'mechanical'); #9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31,#35,#39),#43); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27,#31,#35),#39); #11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); #12 = CARTESIAN_POINT('',(0.,0.,0.)); #13 = DIRECTION('',(0.,0.,1.)); #14 = DIRECTION('',(1.,0.,-0.)); #15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); -#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#16 = CARTESIAN_POINT('',(-1.27,0.,0.)); #17 = DIRECTION('',(0.,0.,1.)); #18 = DIRECTION('',(1.,0.,0.)); #19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); -#20 = CARTESIAN_POINT('',(0.,0.,0.)); +#20 = CARTESIAN_POINT('',(-1.27,0.,0.)); #21 = DIRECTION('',(0.,0.,1.)); #22 = DIRECTION('',(1.,0.,0.)); #23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); @@ -39,799 +39,433 @@ DATA; #29 = DIRECTION('',(0.,0.,1.)); #30 = DIRECTION('',(1.,0.,0.)); #31 = AXIS2_PLACEMENT_3D('',#32,#33,#34); -#32 = CARTESIAN_POINT('',(0.,2.E-16,0.)); +#32 = CARTESIAN_POINT('',(1.27,0.,0.)); #33 = DIRECTION('',(0.,0.,1.)); #34 = DIRECTION('',(1.,0.,0.)); #35 = AXIS2_PLACEMENT_3D('',#36,#37,#38); -#36 = CARTESIAN_POINT('',(-1.27,0.,0.)); +#36 = CARTESIAN_POINT('',(1.27,0.,0.)); #37 = DIRECTION('',(0.,0.,1.)); #38 = DIRECTION('',(1.,0.,0.)); -#39 = AXIS2_PLACEMENT_3D('',#40,#41,#42); -#40 = CARTESIAN_POINT('',(-1.27,0.,0.)); -#41 = DIRECTION('',(0.,0.,1.)); -#42 = DIRECTION('',(1.,0.,0.)); -#43 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#47)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#44,#45,#46)) REPRESENTATION_CONTEXT('Context #1', +#39 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#43)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#40,#41,#42)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#44 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#45 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#46 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#47 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#44, +#40 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#41 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#42 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#43 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#40, 'distance_accuracy_value','confusion accuracy'); -#48 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); -#49 = SHAPE_DEFINITION_REPRESENTATION(#50,#56); -#50 = PRODUCT_DEFINITION_SHAPE('','',#51); -#51 = PRODUCT_DEFINITION('design','',#52,#55); -#52 = PRODUCT_DEFINITION_FORMATION('','',#53); -#53 = PRODUCT('Domain_0','Domain_0','',(#54)); -#54 = PRODUCT_CONTEXT('',#2,'mechanical'); -#55 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#56 = SHAPE_REPRESENTATION('',(#11,#57,#61,#65,#69),#73); -#57 = AXIS2_PLACEMENT_3D('',#58,#59,#60); -#58 = CARTESIAN_POINT('',(0.,0.,0.)); -#59 = DIRECTION('',(0.,0.,1.)); -#60 = DIRECTION('',(1.,0.,0.)); -#61 = AXIS2_PLACEMENT_3D('',#62,#63,#64); -#62 = CARTESIAN_POINT('',(0.,0.,0.)); -#63 = DIRECTION('',(0.,0.,1.)); -#64 = DIRECTION('',(1.,0.,0.)); -#65 = AXIS2_PLACEMENT_3D('',#66,#67,#68); -#66 = CARTESIAN_POINT('',(0.,0.,0.)); -#67 = DIRECTION('',(0.,0.,1.)); -#68 = DIRECTION('',(1.,0.,0.)); -#69 = AXIS2_PLACEMENT_3D('',#70,#71,#72); -#70 = CARTESIAN_POINT('',(0.,1.E-16,0.)); -#71 = DIRECTION('',(0.,0.,1.)); -#72 = DIRECTION('',(1.,0.,0.)); -#73 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#77)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#74,#75,#76)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#74 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#75 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#76 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#77 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#74, - 'distance_accuracy_value','confusion accuracy'); -#78 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#79,#81); -#79 = ( REPRESENTATION_RELATIONSHIP('','',#56,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#80) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#80 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); -#81 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#82); -#82 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('56','Domain_0','',#5,#51,$); -#83 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#53)); -#84 = SHAPE_DEFINITION_REPRESENTATION(#85,#91); -#85 = PRODUCT_DEFINITION_SHAPE('','',#86); -#86 = PRODUCT_DEFINITION('design','',#87,#90); -#87 = PRODUCT_DEFINITION_FORMATION('','',#88); -#88 = PRODUCT('solid_wire_000','solid_wire_000','',(#89)); -#89 = PRODUCT_CONTEXT('',#2,'mechanical'); -#90 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#91 = SHAPE_REPRESENTATION('',(#11,#92,#96),#100); -#92 = AXIS2_PLACEMENT_3D('',#93,#94,#95); -#93 = CARTESIAN_POINT('',(-1.27,0.,0.)); -#94 = DIRECTION('',(0.,0.,1.)); -#95 = DIRECTION('',(1.,0.,0.)); -#96 = AXIS2_PLACEMENT_3D('',#97,#98,#99); -#97 = CARTESIAN_POINT('',(-1.27,0.,0.)); -#98 = DIRECTION('',(0.,0.,1.)); -#99 = DIRECTION('',(1.,0.,0.)); -#100 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#104)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#101,#102,#103)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#101 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#102 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#103 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#104 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#101, - 'distance_accuracy_value','confusion accuracy'); -#105 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#106,#108); -#106 = ( REPRESENTATION_RELATIONSHIP('','',#91,#56) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#107) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#107 = ITEM_DEFINED_TRANSFORMATION('','',#11,#57); -#108 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#109 - ); -#109 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('48','solid_wire_000','',#51,#86,$ - ); -#110 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#88)); -#111 = SHAPE_DEFINITION_REPRESENTATION(#112,#118); -#112 = PRODUCT_DEFINITION_SHAPE('','',#113); -#113 = PRODUCT_DEFINITION('design','',#114,#117); -#114 = PRODUCT_DEFINITION_FORMATION('','',#115); -#115 = PRODUCT('Conductor_0','Conductor_0','',(#116)); -#116 = PRODUCT_CONTEXT('',#2,'mechanical'); -#117 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#118 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#119),#146); -#119 = SHELL_BASED_SURFACE_MODEL('',(#120)); -#120 = OPEN_SHELL('',(#121)); -#121 = ADVANCED_FACE('',(#122),#135,.T.); -#122 = FACE_BOUND('',#123,.T.); -#123 = EDGE_LOOP('',(#124)); -#124 = ORIENTED_EDGE('',*,*,#125,.T.); -#125 = EDGE_CURVE('',#126,#126,#128,.T.); -#126 = VERTEX_POINT('',#127); -#127 = CARTESIAN_POINT('',(0.1905,0.,0.)); -#128 = SURFACE_CURVE('',#129,(#134),.PCURVE_S1.); -#129 = CIRCLE('',#130,0.1905); -#130 = AXIS2_PLACEMENT_3D('',#131,#132,#133); -#131 = CARTESIAN_POINT('',(0.,0.,0.)); -#132 = DIRECTION('',(0.,0.,1.)); -#133 = DIRECTION('',(1.,0.,-0.)); -#134 = PCURVE('',#135,#140); -#135 = PLANE('',#136); -#136 = AXIS2_PLACEMENT_3D('',#137,#138,#139); -#137 = CARTESIAN_POINT('',(-7.009925220121E-18,-7.665819544648E-19,0.)); -#138 = DIRECTION('',(0.,0.,1.)); -#139 = DIRECTION('',(1.,0.,-0.)); -#140 = DEFINITIONAL_REPRESENTATION('',(#141),#145); -#141 = CIRCLE('',#142,0.1905); -#142 = AXIS2_PLACEMENT_2D('',#143,#144); -#143 = CARTESIAN_POINT('',(7.009925220121E-18,7.665819544648E-19)); -#144 = DIRECTION('',(1.,0.)); -#145 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#44 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#45 = SHAPE_DEFINITION_REPRESENTATION(#46,#52); +#46 = PRODUCT_DEFINITION_SHAPE('','',#47); +#47 = PRODUCT_DEFINITION('design','',#48,#51); +#48 = PRODUCT_DEFINITION_FORMATION('','',#49); +#49 = PRODUCT('Conductor_000','Conductor_000','',(#50)); +#50 = PRODUCT_CONTEXT('',#2,'mechanical'); +#51 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#52 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#53),#80); +#53 = SHELL_BASED_SURFACE_MODEL('',(#54)); +#54 = OPEN_SHELL('',(#55)); +#55 = ADVANCED_FACE('',(#56),#69,.T.); +#56 = FACE_BOUND('',#57,.T.); +#57 = EDGE_LOOP('',(#58)); +#58 = ORIENTED_EDGE('',*,*,#59,.T.); +#59 = EDGE_CURVE('',#60,#60,#62,.T.); +#60 = VERTEX_POINT('',#61); +#61 = CARTESIAN_POINT('',(0.1905,0.,0.)); +#62 = SURFACE_CURVE('',#63,(#68),.PCURVE_S1.); +#63 = CIRCLE('',#64,0.1905); +#64 = AXIS2_PLACEMENT_3D('',#65,#66,#67); +#65 = CARTESIAN_POINT('',(0.,0.,0.)); +#66 = DIRECTION('',(0.,0.,1.)); +#67 = DIRECTION('',(1.,0.,0.)); +#68 = PCURVE('',#69,#74); +#69 = PLANE('',#70); +#70 = AXIS2_PLACEMENT_3D('',#71,#72,#73); +#71 = CARTESIAN_POINT('',(-1.E-17,0.,0.)); +#72 = DIRECTION('',(0.,0.,1.)); +#73 = DIRECTION('',(1.,0.,0.)); +#74 = DEFINITIONAL_REPRESENTATION('',(#75),#79); +#75 = CIRCLE('',#76,0.1905); +#76 = AXIS2_PLACEMENT_2D('',#77,#78); +#77 = CARTESIAN_POINT('',(1.E-17,0.)); +#78 = DIRECTION('',(1.,0.)); +#79 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#146 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#150)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#147,#148,#149)) REPRESENTATION_CONTEXT('Context #1', +#80 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#84)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#81,#82,#83)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#147 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#148 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#149 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#150 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#147, +#81 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#82 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#83 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#84 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#81, 'distance_accuracy_value','confusion accuracy'); -#151 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#152,#154); -#152 = ( REPRESENTATION_RELATIONSHIP('','',#118,#91) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#153) +#85 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#86,#88); +#86 = ( REPRESENTATION_RELATIONSHIP('','',#52,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#87) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#153 = ITEM_DEFINED_TRANSFORMATION('','',#11,#92); -#154 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#155 - ); -#155 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('46','Conductor_0','',#86,#113,$); -#156 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#115)); -#157 = SHAPE_DEFINITION_REPRESENTATION(#158,#164); -#158 = PRODUCT_DEFINITION_SHAPE('','',#159); -#159 = PRODUCT_DEFINITION('design','',#160,#163); -#160 = PRODUCT_DEFINITION_FORMATION('','',#161); -#161 = PRODUCT('Dielectric_0','Dielectric_0','',(#162)); -#162 = PRODUCT_CONTEXT('',#2,'mechanical'); -#163 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#164 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#165),#192); -#165 = SHELL_BASED_SURFACE_MODEL('',(#166)); -#166 = OPEN_SHELL('',(#167)); -#167 = ADVANCED_FACE('',(#168),#181,.T.); -#168 = FACE_BOUND('',#169,.T.); -#169 = EDGE_LOOP('',(#170)); -#170 = ORIENTED_EDGE('',*,*,#171,.T.); -#171 = EDGE_CURVE('',#172,#172,#174,.T.); -#172 = VERTEX_POINT('',#173); -#173 = CARTESIAN_POINT('',(0.4445,0.,0.)); -#174 = SURFACE_CURVE('',#175,(#180),.PCURVE_S1.); -#175 = CIRCLE('',#176,0.4445); -#176 = AXIS2_PLACEMENT_3D('',#177,#178,#179); -#177 = CARTESIAN_POINT('',(0.,0.,0.)); -#178 = DIRECTION('',(0.,0.,1.)); -#179 = DIRECTION('',(1.,0.,-0.)); -#180 = PCURVE('',#181,#186); -#181 = PLANE('',#182); -#182 = AXIS2_PLACEMENT_3D('',#183,#184,#185); -#183 = CARTESIAN_POINT('',(-1.201701466306E-17,5.888845918762E-18,0.)); -#184 = DIRECTION('',(0.,0.,1.)); -#185 = DIRECTION('',(1.,0.,-0.)); -#186 = DEFINITIONAL_REPRESENTATION('',(#187),#191); -#187 = CIRCLE('',#188,0.4445); -#188 = AXIS2_PLACEMENT_2D('',#189,#190); -#189 = CARTESIAN_POINT('',(1.201701466306E-17,-5.888845918762E-18)); -#190 = DIRECTION('',(1.,0.)); -#191 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#87 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#88 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#89); +#89 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('7','Conductor_000','',#5,#47,$); +#90 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#49)); +#91 = SHAPE_DEFINITION_REPRESENTATION(#92,#98); +#92 = PRODUCT_DEFINITION_SHAPE('','',#93); +#93 = PRODUCT_DEFINITION('design','',#94,#97); +#94 = PRODUCT_DEFINITION_FORMATION('','',#95); +#95 = PRODUCT('Dielectric_000','Dielectric_000','',(#96)); +#96 = PRODUCT_CONTEXT('',#2,'mechanical'); +#97 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#98 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#99),#126); +#99 = SHELL_BASED_SURFACE_MODEL('',(#100)); +#100 = OPEN_SHELL('',(#101)); +#101 = ADVANCED_FACE('',(#102),#115,.T.); +#102 = FACE_BOUND('',#103,.T.); +#103 = EDGE_LOOP('',(#104)); +#104 = ORIENTED_EDGE('',*,*,#105,.T.); +#105 = EDGE_CURVE('',#106,#106,#108,.T.); +#106 = VERTEX_POINT('',#107); +#107 = CARTESIAN_POINT('',(0.4445,0.,0.)); +#108 = SURFACE_CURVE('',#109,(#114),.PCURVE_S1.); +#109 = CIRCLE('',#110,0.4445); +#110 = AXIS2_PLACEMENT_3D('',#111,#112,#113); +#111 = CARTESIAN_POINT('',(0.,0.,0.)); +#112 = DIRECTION('',(0.,0.,1.)); +#113 = DIRECTION('',(1.,0.,0.)); +#114 = PCURVE('',#115,#120); +#115 = PLANE('',#116); +#116 = AXIS2_PLACEMENT_3D('',#117,#118,#119); +#117 = CARTESIAN_POINT('',(-1.E-17,1.E-17,0.)); +#118 = DIRECTION('',(0.,0.,1.)); +#119 = DIRECTION('',(1.,0.,0.)); +#120 = DEFINITIONAL_REPRESENTATION('',(#121),#125); +#121 = CIRCLE('',#122,0.4445); +#122 = AXIS2_PLACEMENT_2D('',#123,#124); +#123 = CARTESIAN_POINT('',(1.E-17,-1.E-17)); +#124 = DIRECTION('',(1.,0.)); +#125 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#192 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#196)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#193,#194,#195)) REPRESENTATION_CONTEXT('Context #1', +#126 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#130)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#127,#128,#129)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#193 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#194 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#195 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#196 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#193, +#127 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#128 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#129 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#130 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#127, 'distance_accuracy_value','confusion accuracy'); -#197 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#198,#200); -#198 = ( REPRESENTATION_RELATIONSHIP('','',#164,#91) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#199) +#131 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#132,#134); +#132 = ( REPRESENTATION_RELATIONSHIP('','',#98,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#133) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#199 = ITEM_DEFINED_TRANSFORMATION('','',#11,#96); -#200 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#201 +#133 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#134 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#135 ); -#201 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('47','Dielectric_0','',#86,#159,$ - ); -#202 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#161)); -#203 = SHAPE_DEFINITION_REPRESENTATION(#204,#210); -#204 = PRODUCT_DEFINITION_SHAPE('','',#205); -#205 = PRODUCT_DEFINITION('design','',#206,#209); -#206 = PRODUCT_DEFINITION_FORMATION('','',#207); -#207 = PRODUCT('solid_wire_001','solid_wire_001','',(#208)); -#208 = PRODUCT_CONTEXT('',#2,'mechanical'); -#209 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#210 = SHAPE_REPRESENTATION('',(#11,#211,#215),#219); -#211 = AXIS2_PLACEMENT_3D('',#212,#213,#214); -#212 = CARTESIAN_POINT('',(0.,0.,0.)); -#213 = DIRECTION('',(0.,0.,1.)); -#214 = DIRECTION('',(1.,0.,0.)); -#215 = AXIS2_PLACEMENT_3D('',#216,#217,#218); -#216 = CARTESIAN_POINT('',(0.,0.,0.)); -#217 = DIRECTION('',(0.,0.,1.)); -#218 = DIRECTION('',(1.,0.,0.)); -#219 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#223)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#220,#221,#222)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#220 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#221 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#222 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#223 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#220, - 'distance_accuracy_value','confusion accuracy'); -#224 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#225,#227); -#225 = ( REPRESENTATION_RELATIONSHIP('','',#210,#56) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#226) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#226 = ITEM_DEFINED_TRANSFORMATION('','',#11,#61); -#227 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#228 - ); -#228 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('51','solid_wire_001','',#51,#205, - $); -#229 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#207)); -#230 = SHAPE_DEFINITION_REPRESENTATION(#231,#237); -#231 = PRODUCT_DEFINITION_SHAPE('','',#232); -#232 = PRODUCT_DEFINITION('design','',#233,#236); -#233 = PRODUCT_DEFINITION_FORMATION('','',#234); -#234 = PRODUCT('Conductor_001','Conductor_001','',(#235)); -#235 = PRODUCT_CONTEXT('',#2,'mechanical'); -#236 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#237 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#238),#265); -#238 = SHELL_BASED_SURFACE_MODEL('',(#239)); -#239 = OPEN_SHELL('',(#240)); -#240 = ADVANCED_FACE('',(#241),#254,.T.); -#241 = FACE_BOUND('',#242,.T.); -#242 = EDGE_LOOP('',(#243)); -#243 = ORIENTED_EDGE('',*,*,#244,.T.); -#244 = EDGE_CURVE('',#245,#245,#247,.T.); -#245 = VERTEX_POINT('',#246); -#246 = CARTESIAN_POINT('',(0.1905,0.,0.)); -#247 = SURFACE_CURVE('',#248,(#253),.PCURVE_S1.); -#248 = CIRCLE('',#249,0.1905); -#249 = AXIS2_PLACEMENT_3D('',#250,#251,#252); -#250 = CARTESIAN_POINT('',(0.,0.,0.)); -#251 = DIRECTION('',(0.,0.,1.)); -#252 = DIRECTION('',(1.,0.,-0.)); -#253 = PCURVE('',#254,#259); -#254 = PLANE('',#255); -#255 = AXIS2_PLACEMENT_3D('',#256,#257,#258); -#256 = CARTESIAN_POINT('',(-7.009925220121E-18,-7.665819544648E-19,0.)); -#257 = DIRECTION('',(0.,0.,1.)); -#258 = DIRECTION('',(1.,0.,-0.)); -#259 = DEFINITIONAL_REPRESENTATION('',(#260),#264); -#260 = CIRCLE('',#261,0.1905); -#261 = AXIS2_PLACEMENT_2D('',#262,#263); -#262 = CARTESIAN_POINT('',(7.009925220121E-18,7.665819544648E-19)); -#263 = DIRECTION('',(1.,0.)); -#264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#135 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('8','Dielectric_000','',#5,#93,$); +#136 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#95)); +#137 = SHAPE_DEFINITION_REPRESENTATION(#138,#144); +#138 = PRODUCT_DEFINITION_SHAPE('','',#139); +#139 = PRODUCT_DEFINITION('design','',#140,#143); +#140 = PRODUCT_DEFINITION_FORMATION('','',#141); +#141 = PRODUCT('Conductor_001','Conductor_001','',(#142)); +#142 = PRODUCT_CONTEXT('',#2,'mechanical'); +#143 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#144 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#145),#172); +#145 = SHELL_BASED_SURFACE_MODEL('',(#146)); +#146 = OPEN_SHELL('',(#147)); +#147 = ADVANCED_FACE('',(#148),#161,.T.); +#148 = FACE_BOUND('',#149,.T.); +#149 = EDGE_LOOP('',(#150)); +#150 = ORIENTED_EDGE('',*,*,#151,.T.); +#151 = EDGE_CURVE('',#152,#152,#154,.T.); +#152 = VERTEX_POINT('',#153); +#153 = CARTESIAN_POINT('',(0.1905,0.,0.)); +#154 = SURFACE_CURVE('',#155,(#160),.PCURVE_S1.); +#155 = CIRCLE('',#156,0.1905); +#156 = AXIS2_PLACEMENT_3D('',#157,#158,#159); +#157 = CARTESIAN_POINT('',(0.,0.,0.)); +#158 = DIRECTION('',(0.,0.,1.)); +#159 = DIRECTION('',(1.,0.,-0.)); +#160 = PCURVE('',#161,#166); +#161 = PLANE('',#162); +#162 = AXIS2_PLACEMENT_3D('',#163,#164,#165); +#163 = CARTESIAN_POINT('',(-1.E-17,-0.,0.)); +#164 = DIRECTION('',(0.,0.,1.)); +#165 = DIRECTION('',(1.,0.,-0.)); +#166 = DEFINITIONAL_REPRESENTATION('',(#167),#171); +#167 = CIRCLE('',#168,0.1905); +#168 = AXIS2_PLACEMENT_2D('',#169,#170); +#169 = CARTESIAN_POINT('',(1.E-17,0.)); +#170 = DIRECTION('',(1.,0.)); +#171 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#265 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#269)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#266,#267,#268)) REPRESENTATION_CONTEXT('Context #1', +#172 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#176)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#173,#174,#175)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#266 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#267 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#268 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#269 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#266, +#173 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#174 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#175 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#176 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#173, 'distance_accuracy_value','confusion accuracy'); -#270 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#271,#273); -#271 = ( REPRESENTATION_RELATIONSHIP('','',#237,#210) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#272) +#177 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#178,#180); +#178 = ( REPRESENTATION_RELATIONSHIP('','',#144,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#179) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#272 = ITEM_DEFINED_TRANSFORMATION('','',#11,#211); -#273 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#274 +#179 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#180 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#181 ); -#274 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('49','Conductor_001','',#205,#232, - $); -#275 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#234)); -#276 = SHAPE_DEFINITION_REPRESENTATION(#277,#283); -#277 = PRODUCT_DEFINITION_SHAPE('','',#278); -#278 = PRODUCT_DEFINITION('design','',#279,#282); -#279 = PRODUCT_DEFINITION_FORMATION('','',#280); -#280 = PRODUCT('Dielectric_001','Dielectric_001','',(#281)); -#281 = PRODUCT_CONTEXT('',#2,'mechanical'); -#282 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#283 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#284),#311); -#284 = SHELL_BASED_SURFACE_MODEL('',(#285)); -#285 = OPEN_SHELL('',(#286)); -#286 = ADVANCED_FACE('',(#287),#300,.T.); -#287 = FACE_BOUND('',#288,.T.); -#288 = EDGE_LOOP('',(#289)); -#289 = ORIENTED_EDGE('',*,*,#290,.T.); -#290 = EDGE_CURVE('',#291,#291,#293,.T.); -#291 = VERTEX_POINT('',#292); -#292 = CARTESIAN_POINT('',(0.4445,0.,0.)); -#293 = SURFACE_CURVE('',#294,(#299),.PCURVE_S1.); -#294 = CIRCLE('',#295,0.4445); -#295 = AXIS2_PLACEMENT_3D('',#296,#297,#298); -#296 = CARTESIAN_POINT('',(0.,0.,0.)); -#297 = DIRECTION('',(0.,0.,1.)); -#298 = DIRECTION('',(1.,0.,-0.)); -#299 = PCURVE('',#300,#305); -#300 = PLANE('',#301); -#301 = AXIS2_PLACEMENT_3D('',#302,#303,#304); -#302 = CARTESIAN_POINT('',(-1.201701466306E-17,5.888845918762E-18,0.)); -#303 = DIRECTION('',(0.,0.,1.)); -#304 = DIRECTION('',(1.,0.,-0.)); -#305 = DEFINITIONAL_REPRESENTATION('',(#306),#310); -#306 = CIRCLE('',#307,0.4445); -#307 = AXIS2_PLACEMENT_2D('',#308,#309); -#308 = CARTESIAN_POINT('',(1.201701466306E-17,-5.888845918762E-18)); -#309 = DIRECTION('',(1.,0.)); -#310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#181 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('9','Conductor_001','',#5,#139,$); +#182 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#141)); +#183 = SHAPE_DEFINITION_REPRESENTATION(#184,#190); +#184 = PRODUCT_DEFINITION_SHAPE('','',#185); +#185 = PRODUCT_DEFINITION('design','',#186,#189); +#186 = PRODUCT_DEFINITION_FORMATION('','',#187); +#187 = PRODUCT('Dielectric_001','Dielectric_001','',(#188)); +#188 = PRODUCT_CONTEXT('',#2,'mechanical'); +#189 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#190 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#191),#218); +#191 = SHELL_BASED_SURFACE_MODEL('',(#192)); +#192 = OPEN_SHELL('',(#193)); +#193 = ADVANCED_FACE('',(#194),#207,.T.); +#194 = FACE_BOUND('',#195,.T.); +#195 = EDGE_LOOP('',(#196)); +#196 = ORIENTED_EDGE('',*,*,#197,.T.); +#197 = EDGE_CURVE('',#198,#198,#200,.T.); +#198 = VERTEX_POINT('',#199); +#199 = CARTESIAN_POINT('',(0.4445,0.,0.)); +#200 = SURFACE_CURVE('',#201,(#206),.PCURVE_S1.); +#201 = CIRCLE('',#202,0.4445); +#202 = AXIS2_PLACEMENT_3D('',#203,#204,#205); +#203 = CARTESIAN_POINT('',(0.,0.,0.)); +#204 = DIRECTION('',(0.,0.,1.)); +#205 = DIRECTION('',(1.,0.,-0.)); +#206 = PCURVE('',#207,#212); +#207 = PLANE('',#208); +#208 = AXIS2_PLACEMENT_3D('',#209,#210,#211); +#209 = CARTESIAN_POINT('',(-1.E-17,1.E-17,0.)); +#210 = DIRECTION('',(0.,0.,1.)); +#211 = DIRECTION('',(1.,0.,-0.)); +#212 = DEFINITIONAL_REPRESENTATION('',(#213),#217); +#213 = CIRCLE('',#214,0.4445); +#214 = AXIS2_PLACEMENT_2D('',#215,#216); +#215 = CARTESIAN_POINT('',(1.E-17,-1.E-17)); +#216 = DIRECTION('',(1.,0.)); +#217 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#311 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#315)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#312,#313,#314)) REPRESENTATION_CONTEXT('Context #1', +#218 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#222)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#219,#220,#221)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#312 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#313 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#314 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#315 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#312, +#219 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#220 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#221 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#222 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#219, 'distance_accuracy_value','confusion accuracy'); -#316 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#317,#319); -#317 = ( REPRESENTATION_RELATIONSHIP('','',#283,#210) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#318) +#223 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#224,#226); +#224 = ( REPRESENTATION_RELATIONSHIP('','',#190,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#225) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#318 = ITEM_DEFINED_TRANSFORMATION('','',#11,#215); -#319 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#320 +#225 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#226 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#227 ); -#320 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('50','Dielectric_001','',#205,#278 - ,$); -#321 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#280)); -#322 = SHAPE_DEFINITION_REPRESENTATION(#323,#329); -#323 = PRODUCT_DEFINITION_SHAPE('','',#324); -#324 = PRODUCT_DEFINITION('design','',#325,#328); -#325 = PRODUCT_DEFINITION_FORMATION('','',#326); -#326 = PRODUCT('solid_wire_002','solid_wire_002','',(#327)); -#327 = PRODUCT_CONTEXT('',#2,'mechanical'); -#328 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#329 = SHAPE_REPRESENTATION('',(#11,#330,#334),#338); -#330 = AXIS2_PLACEMENT_3D('',#331,#332,#333); -#331 = CARTESIAN_POINT('',(1.27,0.,0.)); -#332 = DIRECTION('',(0.,0.,1.)); -#333 = DIRECTION('',(1.,0.,0.)); -#334 = AXIS2_PLACEMENT_3D('',#335,#336,#337); -#335 = CARTESIAN_POINT('',(1.27,0.,0.)); -#336 = DIRECTION('',(0.,0.,1.)); -#337 = DIRECTION('',(1.,0.,0.)); -#338 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#342)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#339,#340,#341)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#339 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#340 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#341 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#342 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#339, - 'distance_accuracy_value','confusion accuracy'); -#343 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#344,#346); -#344 = ( REPRESENTATION_RELATIONSHIP('','',#329,#56) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#345) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#345 = ITEM_DEFINED_TRANSFORMATION('','',#11,#65); -#346 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#347 +#227 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('10','Dielectric_001','',#5,#185,$ ); -#347 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('54','solid_wire_002','',#51,#324, - $); -#348 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#326)); -#349 = SHAPE_DEFINITION_REPRESENTATION(#350,#356); -#350 = PRODUCT_DEFINITION_SHAPE('','',#351); -#351 = PRODUCT_DEFINITION('design','',#352,#355); -#352 = PRODUCT_DEFINITION_FORMATION('','',#353); -#353 = PRODUCT('Conductor_002','Conductor_002','',(#354)); -#354 = PRODUCT_CONTEXT('',#2,'mechanical'); -#355 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#356 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#357),#384); -#357 = SHELL_BASED_SURFACE_MODEL('',(#358)); -#358 = OPEN_SHELL('',(#359)); -#359 = ADVANCED_FACE('',(#360),#373,.T.); -#360 = FACE_BOUND('',#361,.T.); -#361 = EDGE_LOOP('',(#362)); -#362 = ORIENTED_EDGE('',*,*,#363,.T.); -#363 = EDGE_CURVE('',#364,#364,#366,.T.); -#364 = VERTEX_POINT('',#365); -#365 = CARTESIAN_POINT('',(0.1905,0.,0.)); -#366 = SURFACE_CURVE('',#367,(#372),.PCURVE_S1.); -#367 = CIRCLE('',#368,0.1905); -#368 = AXIS2_PLACEMENT_3D('',#369,#370,#371); -#369 = CARTESIAN_POINT('',(0.,0.,0.)); -#370 = DIRECTION('',(0.,0.,1.)); -#371 = DIRECTION('',(1.,0.,-0.)); -#372 = PCURVE('',#373,#378); -#373 = PLANE('',#374); -#374 = AXIS2_PLACEMENT_3D('',#375,#376,#377); -#375 = CARTESIAN_POINT('',(-7.009925220121E-18,-7.665819544648E-19,0.)); -#376 = DIRECTION('',(0.,0.,1.)); -#377 = DIRECTION('',(1.,0.,-0.)); -#378 = DEFINITIONAL_REPRESENTATION('',(#379),#383); -#379 = CIRCLE('',#380,0.1905); -#380 = AXIS2_PLACEMENT_2D('',#381,#382); -#381 = CARTESIAN_POINT('',(7.009925220121E-18,7.665819544648E-19)); -#382 = DIRECTION('',(1.,0.)); -#383 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#228 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#187)); +#229 = SHAPE_DEFINITION_REPRESENTATION(#230,#236); +#230 = PRODUCT_DEFINITION_SHAPE('','',#231); +#231 = PRODUCT_DEFINITION('design','',#232,#235); +#232 = PRODUCT_DEFINITION_FORMATION('','',#233); +#233 = PRODUCT('Conductor_002','Conductor_002','',(#234)); +#234 = PRODUCT_CONTEXT('',#2,'mechanical'); +#235 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#236 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#237),#264); +#237 = SHELL_BASED_SURFACE_MODEL('',(#238)); +#238 = OPEN_SHELL('',(#239)); +#239 = ADVANCED_FACE('',(#240),#253,.T.); +#240 = FACE_BOUND('',#241,.T.); +#241 = EDGE_LOOP('',(#242)); +#242 = ORIENTED_EDGE('',*,*,#243,.T.); +#243 = EDGE_CURVE('',#244,#244,#246,.T.); +#244 = VERTEX_POINT('',#245); +#245 = CARTESIAN_POINT('',(0.1905,0.,0.)); +#246 = SURFACE_CURVE('',#247,(#252),.PCURVE_S1.); +#247 = CIRCLE('',#248,0.1905); +#248 = AXIS2_PLACEMENT_3D('',#249,#250,#251); +#249 = CARTESIAN_POINT('',(0.,0.,0.)); +#250 = DIRECTION('',(0.,0.,1.)); +#251 = DIRECTION('',(1.,0.,0.)); +#252 = PCURVE('',#253,#258); +#253 = PLANE('',#254); +#254 = AXIS2_PLACEMENT_3D('',#255,#256,#257); +#255 = CARTESIAN_POINT('',(-1.E-17,0.,0.)); +#256 = DIRECTION('',(0.,0.,1.)); +#257 = DIRECTION('',(1.,0.,0.)); +#258 = DEFINITIONAL_REPRESENTATION('',(#259),#263); +#259 = CIRCLE('',#260,0.1905); +#260 = AXIS2_PLACEMENT_2D('',#261,#262); +#261 = CARTESIAN_POINT('',(1.E-17,0.)); +#262 = DIRECTION('',(1.,0.)); +#263 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#384 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#388)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#385,#386,#387)) REPRESENTATION_CONTEXT('Context #1', +#264 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#268)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#265,#266,#267)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#385 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#386 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#387 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#388 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#385, +#265 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#266 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#267 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#268 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#265, 'distance_accuracy_value','confusion accuracy'); -#389 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#390,#392); -#390 = ( REPRESENTATION_RELATIONSHIP('','',#356,#329) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#391) +#269 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#270,#272); +#270 = ( REPRESENTATION_RELATIONSHIP('','',#236,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#271) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#391 = ITEM_DEFINED_TRANSFORMATION('','',#11,#330); -#392 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#393 +#271 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); +#272 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#273 ); -#393 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('52','Conductor_002','',#324,#351, - $); -#394 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#353)); -#395 = SHAPE_DEFINITION_REPRESENTATION(#396,#402); -#396 = PRODUCT_DEFINITION_SHAPE('','',#397); -#397 = PRODUCT_DEFINITION('design','',#398,#401); -#398 = PRODUCT_DEFINITION_FORMATION('','',#399); -#399 = PRODUCT('Dielectric_002','Dielectric_002','',(#400)); -#400 = PRODUCT_CONTEXT('',#2,'mechanical'); -#401 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#402 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#403),#430); -#403 = SHELL_BASED_SURFACE_MODEL('',(#404)); -#404 = OPEN_SHELL('',(#405)); -#405 = ADVANCED_FACE('',(#406),#419,.T.); -#406 = FACE_BOUND('',#407,.T.); -#407 = EDGE_LOOP('',(#408)); -#408 = ORIENTED_EDGE('',*,*,#409,.T.); -#409 = EDGE_CURVE('',#410,#410,#412,.T.); -#410 = VERTEX_POINT('',#411); -#411 = CARTESIAN_POINT('',(0.4445,0.,0.)); -#412 = SURFACE_CURVE('',#413,(#418),.PCURVE_S1.); -#413 = CIRCLE('',#414,0.4445); -#414 = AXIS2_PLACEMENT_3D('',#415,#416,#417); -#415 = CARTESIAN_POINT('',(0.,0.,0.)); -#416 = DIRECTION('',(0.,0.,1.)); -#417 = DIRECTION('',(1.,0.,-0.)); -#418 = PCURVE('',#419,#424); -#419 = PLANE('',#420); -#420 = AXIS2_PLACEMENT_3D('',#421,#422,#423); -#421 = CARTESIAN_POINT('',(-1.201701466306E-17,5.888845918762E-18,0.)); -#422 = DIRECTION('',(0.,0.,1.)); -#423 = DIRECTION('',(1.,0.,-0.)); -#424 = DEFINITIONAL_REPRESENTATION('',(#425),#429); -#425 = CIRCLE('',#426,0.4445); -#426 = AXIS2_PLACEMENT_2D('',#427,#428); -#427 = CARTESIAN_POINT('',(1.201701466306E-17,-5.888845918762E-18)); -#428 = DIRECTION('',(1.,0.)); -#429 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#430 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#434)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#431,#432,#433)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#431 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#432 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#433 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#434 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#431, - 'distance_accuracy_value','confusion accuracy'); -#435 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#436,#438); -#436 = ( REPRESENTATION_RELATIONSHIP('','',#402,#329) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#437) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#437 = ITEM_DEFINED_TRANSFORMATION('','',#11,#334); -#438 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#439 +#273 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('11','Conductor_002','',#5,#231,$ ); -#439 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('53','Dielectric_002','',#324,#397 - ,$); -#440 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#399)); -#441 = SHAPE_DEFINITION_REPRESENTATION(#442,#448); -#442 = PRODUCT_DEFINITION_SHAPE('','',#443); -#443 = PRODUCT_DEFINITION('design','',#444,#447); -#444 = PRODUCT_DEFINITION_FORMATION('','',#445); -#445 = PRODUCT('OpenBoundary_0','OpenBoundary_0','',(#446)); -#446 = PRODUCT_CONTEXT('',#2,'mechanical'); -#447 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#448 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#449),#476); -#449 = SHELL_BASED_SURFACE_MODEL('',(#450)); -#450 = OPEN_SHELL('',(#451)); -#451 = ADVANCED_FACE('',(#452),#465,.T.); -#452 = FACE_BOUND('',#453,.T.); -#453 = EDGE_LOOP('',(#454)); -#454 = ORIENTED_EDGE('',*,*,#455,.T.); -#455 = EDGE_CURVE('',#456,#456,#458,.T.); -#456 = VERTEX_POINT('',#457); -#457 = CARTESIAN_POINT('',(20.,0.,0.)); -#458 = SURFACE_CURVE('',#459,(#464),.PCURVE_S1.); -#459 = CIRCLE('',#460,20.); -#460 = AXIS2_PLACEMENT_3D('',#461,#462,#463); -#461 = CARTESIAN_POINT('',(0.,0.,0.)); -#462 = DIRECTION('',(0.,0.,1.)); -#463 = DIRECTION('',(1.,0.,-0.)); -#464 = PCURVE('',#465,#470); -#465 = PLANE('',#466); -#466 = AXIS2_PLACEMENT_3D('',#467,#468,#469); -#467 = CARTESIAN_POINT('',(-1.093952106032E-15,2.775209066E-16,0.)); -#468 = DIRECTION('',(0.,0.,1.)); -#469 = DIRECTION('',(1.,0.,-0.)); -#470 = DEFINITIONAL_REPRESENTATION('',(#471),#475); -#471 = CIRCLE('',#472,20.); -#472 = AXIS2_PLACEMENT_2D('',#473,#474); -#473 = CARTESIAN_POINT('',(1.093952106032E-15,-2.775209066E-16)); -#474 = DIRECTION('',(1.,0.)); -#475 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#274 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#233)); +#275 = SHAPE_DEFINITION_REPRESENTATION(#276,#282); +#276 = PRODUCT_DEFINITION_SHAPE('','',#277); +#277 = PRODUCT_DEFINITION('design','',#278,#281); +#278 = PRODUCT_DEFINITION_FORMATION('','',#279); +#279 = PRODUCT('Dielectric_002','Dielectric_002','',(#280)); +#280 = PRODUCT_CONTEXT('',#2,'mechanical'); +#281 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#282 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#283),#310); +#283 = SHELL_BASED_SURFACE_MODEL('',(#284)); +#284 = OPEN_SHELL('',(#285)); +#285 = ADVANCED_FACE('',(#286),#299,.T.); +#286 = FACE_BOUND('',#287,.T.); +#287 = EDGE_LOOP('',(#288)); +#288 = ORIENTED_EDGE('',*,*,#289,.T.); +#289 = EDGE_CURVE('',#290,#290,#292,.T.); +#290 = VERTEX_POINT('',#291); +#291 = CARTESIAN_POINT('',(0.4445,0.,0.)); +#292 = SURFACE_CURVE('',#293,(#298),.PCURVE_S1.); +#293 = CIRCLE('',#294,0.4445); +#294 = AXIS2_PLACEMENT_3D('',#295,#296,#297); +#295 = CARTESIAN_POINT('',(0.,0.,0.)); +#296 = DIRECTION('',(0.,0.,1.)); +#297 = DIRECTION('',(1.,0.,0.)); +#298 = PCURVE('',#299,#304); +#299 = PLANE('',#300); +#300 = AXIS2_PLACEMENT_3D('',#301,#302,#303); +#301 = CARTESIAN_POINT('',(-1.E-17,1.E-17,0.)); +#302 = DIRECTION('',(0.,0.,1.)); +#303 = DIRECTION('',(1.,0.,0.)); +#304 = DEFINITIONAL_REPRESENTATION('',(#305),#309); +#305 = CIRCLE('',#306,0.4445); +#306 = AXIS2_PLACEMENT_2D('',#307,#308); +#307 = CARTESIAN_POINT('',(1.E-17,-1.E-17)); +#308 = DIRECTION('',(1.,0.)); +#309 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#476 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#480)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#477,#478,#479)) REPRESENTATION_CONTEXT('Context #1', +#310 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#314)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#311,#312,#313)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#477 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#478 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#479 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#480 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#477, +#311 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#312 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#313 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#314 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#311, 'distance_accuracy_value','confusion accuracy'); -#481 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#482,#484); -#482 = ( REPRESENTATION_RELATIONSHIP('','',#448,#56) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#483) +#315 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#316,#318); +#316 = ( REPRESENTATION_RELATIONSHIP('','',#282,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#317) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#483 = ITEM_DEFINED_TRANSFORMATION('','',#11,#69); -#484 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#485 - ); -#485 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('55','OpenBoundary_0','',#51,#443,$ +#317 = ITEM_DEFINED_TRANSFORMATION('','',#11,#35); +#318 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#319 ); -#486 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#445)); -#487 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#488,#490); -#488 = ( REPRESENTATION_RELATIONSHIP('','',#91,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#489) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#489 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); -#490 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#491 - ); -#491 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('57','solid_wire_000','',#5,#86,$ - ); -#492 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#493,#495); -#493 = ( REPRESENTATION_RELATIONSHIP('','',#210,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#494) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#494 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); -#495 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#496 - ); -#496 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('58','solid_wire_001','',#5,#205,$ - ); -#497 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#498,#500); -#498 = ( REPRESENTATION_RELATIONSHIP('','',#329,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#499) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#499 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); -#500 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#501 - ); -#501 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('59','solid_wire_002','',#5,#324,$ - ); -#502 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#503,#505); -#503 = ( REPRESENTATION_RELATIONSHIP('','',#448,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#504) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#504 = ITEM_DEFINED_TRANSFORMATION('','',#11,#31); -#505 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#506 - ); -#506 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('60','OpenBoundary_0','',#5,#443,$); -#507 = SHAPE_DEFINITION_REPRESENTATION(#508,#514); -#508 = PRODUCT_DEFINITION_SHAPE('','',#509); -#509 = PRODUCT_DEFINITION('design','',#510,#513); -#510 = PRODUCT_DEFINITION_FORMATION('','',#511); -#511 = PRODUCT('Conductor_0','Conductor_0','',(#512)); -#512 = PRODUCT_CONTEXT('',#2,'mechanical'); -#513 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#514 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#515),#542); -#515 = SHELL_BASED_SURFACE_MODEL('',(#516)); -#516 = OPEN_SHELL('',(#517)); -#517 = ADVANCED_FACE('',(#518),#531,.T.); -#518 = FACE_BOUND('',#519,.T.); -#519 = EDGE_LOOP('',(#520)); -#520 = ORIENTED_EDGE('',*,*,#521,.T.); -#521 = EDGE_CURVE('',#522,#522,#524,.T.); -#522 = VERTEX_POINT('',#523); -#523 = CARTESIAN_POINT('',(0.1905,0.,0.)); -#524 = SURFACE_CURVE('',#525,(#530),.PCURVE_S1.); -#525 = CIRCLE('',#526,0.1905); -#526 = AXIS2_PLACEMENT_3D('',#527,#528,#529); -#527 = CARTESIAN_POINT('',(0.,0.,0.)); -#528 = DIRECTION('',(0.,0.,1.)); -#529 = DIRECTION('',(1.,0.,0.)); -#530 = PCURVE('',#531,#536); -#531 = PLANE('',#532); -#532 = AXIS2_PLACEMENT_3D('',#533,#534,#535); -#533 = CARTESIAN_POINT('',(-7.009925220121E-18,-7.665819544648E-19,0.)); -#534 = DIRECTION('',(0.,0.,1.)); -#535 = DIRECTION('',(1.,0.,0.)); -#536 = DEFINITIONAL_REPRESENTATION('',(#537),#541); -#537 = CIRCLE('',#538,0.1905); -#538 = AXIS2_PLACEMENT_2D('',#539,#540); -#539 = CARTESIAN_POINT('',(7.009925220121E-18,7.665819544648E-19)); -#540 = DIRECTION('',(1.,0.)); -#541 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#542 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#546)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#543,#544,#545)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#543 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#544 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#545 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#546 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#543, - 'distance_accuracy_value','confusion accuracy'); -#547 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#548,#550); -#548 = ( REPRESENTATION_RELATIONSHIP('','',#514,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#549) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#549 = ITEM_DEFINED_TRANSFORMATION('','',#11,#35); -#550 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#551 - ); -#551 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('61','Conductor_0','',#5,#509,$); -#552 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#511)); -#553 = SHAPE_DEFINITION_REPRESENTATION(#554,#560); -#554 = PRODUCT_DEFINITION_SHAPE('','',#555); -#555 = PRODUCT_DEFINITION('design','',#556,#559); -#556 = PRODUCT_DEFINITION_FORMATION('','',#557); -#557 = PRODUCT('Dielectric_0','Dielectric_0','',(#558)); -#558 = PRODUCT_CONTEXT('',#2,'mechanical'); -#559 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#560 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#561),#588); -#561 = SHELL_BASED_SURFACE_MODEL('',(#562)); -#562 = OPEN_SHELL('',(#563)); -#563 = ADVANCED_FACE('',(#564),#577,.T.); -#564 = FACE_BOUND('',#565,.T.); -#565 = EDGE_LOOP('',(#566)); -#566 = ORIENTED_EDGE('',*,*,#567,.T.); -#567 = EDGE_CURVE('',#568,#568,#570,.T.); -#568 = VERTEX_POINT('',#569); -#569 = CARTESIAN_POINT('',(0.4445,0.,0.)); -#570 = SURFACE_CURVE('',#571,(#576),.PCURVE_S1.); -#571 = CIRCLE('',#572,0.4445); -#572 = AXIS2_PLACEMENT_3D('',#573,#574,#575); -#573 = CARTESIAN_POINT('',(0.,0.,0.)); -#574 = DIRECTION('',(0.,0.,1.)); -#575 = DIRECTION('',(1.,0.,0.)); -#576 = PCURVE('',#577,#582); -#577 = PLANE('',#578); -#578 = AXIS2_PLACEMENT_3D('',#579,#580,#581); -#579 = CARTESIAN_POINT('',(-1.201701466306E-17,5.888845918762E-18,0.)); -#580 = DIRECTION('',(0.,0.,1.)); -#581 = DIRECTION('',(1.,0.,0.)); -#582 = DEFINITIONAL_REPRESENTATION('',(#583),#587); -#583 = CIRCLE('',#584,0.4445); -#584 = AXIS2_PLACEMENT_2D('',#585,#586); -#585 = CARTESIAN_POINT('',(1.201701466306E-17,-5.888845918762E-18)); -#586 = DIRECTION('',(1.,0.)); -#587 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#588 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#592)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#589,#590,#591)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#589 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#590 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#591 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#592 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#589, - 'distance_accuracy_value','confusion accuracy'); -#593 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#594,#596); -#594 = ( REPRESENTATION_RELATIONSHIP('','',#560,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#595) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#595 = ITEM_DEFINED_TRANSFORMATION('','',#11,#39); -#596 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#597 +#319 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('12','Dielectric_002','',#5,#277,$ ); -#597 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('62','Dielectric_0','',#5,#555,$); -#598 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#557)); -#599 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#600) - ,#265); -#600 = STYLED_ITEM('color',(#601),#240); -#601 = PRESENTATION_STYLE_ASSIGNMENT((#602,#608)); -#602 = SURFACE_STYLE_USAGE(.BOTH.,#603); -#603 = SURFACE_SIDE_STYLE('',(#604)); -#604 = SURFACE_STYLE_FILL_AREA(#605); -#605 = FILL_AREA_STYLE('',(#606)); -#606 = FILL_AREA_STYLE_COLOUR('',#607); -#607 = COLOUR_RGB('',1.,0.333333345507,0.); -#608 = CURVE_STYLE('',#609,POSITIVE_LENGTH_MEASURE(0.1),#610); -#609 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#610 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, +#320 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#279)); +#321 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#322) + ,#80); +#322 = STYLED_ITEM('color',(#323),#55); +#323 = PRESENTATION_STYLE_ASSIGNMENT((#324,#330)); +#324 = SURFACE_STYLE_USAGE(.BOTH.,#325); +#325 = SURFACE_SIDE_STYLE('',(#326)); +#326 = SURFACE_STYLE_FILL_AREA(#327); +#327 = FILL_AREA_STYLE('',(#328)); +#328 = FILL_AREA_STYLE_COLOUR('',#329); +#329 = COLOUR_RGB('',1.,0.333333345507,0.); +#330 = CURVE_STYLE('',#331,POSITIVE_LENGTH_MEASURE(0.1),#332); +#331 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#332 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, 9.803921802644E-02); -#611 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#612) - ,#146); -#612 = STYLED_ITEM('color',(#613),#121); -#613 = PRESENTATION_STYLE_ASSIGNMENT((#614,#619)); -#614 = SURFACE_STYLE_USAGE(.BOTH.,#615); -#615 = SURFACE_SIDE_STYLE('',(#616)); -#616 = SURFACE_STYLE_FILL_AREA(#617); -#617 = FILL_AREA_STYLE('',(#618)); -#618 = FILL_AREA_STYLE_COLOUR('',#607); -#619 = CURVE_STYLE('',#620,POSITIVE_LENGTH_MEASURE(0.1),#610); -#620 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#621 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#622) - ,#430); -#622 = STYLED_ITEM('color',(#623),#405); -#623 = PRESENTATION_STYLE_ASSIGNMENT((#624,#632)); -#624 = SURFACE_STYLE_USAGE(.BOTH.,#625); -#625 = SURFACE_SIDE_STYLE('',(#626,#630)); -#626 = SURFACE_STYLE_FILL_AREA(#627); -#627 = FILL_AREA_STYLE('',(#628)); -#628 = FILL_AREA_STYLE_COLOUR('',#629); -#629 = DRAUGHTING_PRE_DEFINED_COLOUR('red'); -#630 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#629,( - #631)); -#631 = SURFACE_STYLE_TRANSPARENT(0.899999976158); -#632 = CURVE_STYLE('',#633,POSITIVE_LENGTH_MEASURE(0.1),#610); -#633 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#634 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#635) - ,#384); -#635 = STYLED_ITEM('color',(#636),#359); -#636 = PRESENTATION_STYLE_ASSIGNMENT((#637,#642)); -#637 = SURFACE_STYLE_USAGE(.BOTH.,#638); -#638 = SURFACE_SIDE_STYLE('',(#639)); -#639 = SURFACE_STYLE_FILL_AREA(#640); -#640 = FILL_AREA_STYLE('',(#641)); -#641 = FILL_AREA_STYLE_COLOUR('',#607); -#642 = CURVE_STYLE('',#643,POSITIVE_LENGTH_MEASURE(0.1),#610); -#643 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#644 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#645) - ,#476); -#645 = STYLED_ITEM('color',(#646),#451); -#646 = PRESENTATION_STYLE_ASSIGNMENT((#647,#653)); -#647 = SURFACE_STYLE_USAGE(.BOTH.,#648); -#648 = SURFACE_SIDE_STYLE('',(#649)); -#649 = SURFACE_STYLE_FILL_AREA(#650); -#650 = FILL_AREA_STYLE('',(#651)); -#651 = FILL_AREA_STYLE_COLOUR('',#652); -#652 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); -#653 = CURVE_STYLE('',#654,POSITIVE_LENGTH_MEASURE(0.1),#610); -#654 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#655 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#656) - ,#192); -#656 = STYLED_ITEM('color',(#657),#167); -#657 = PRESENTATION_STYLE_ASSIGNMENT((#658,#665)); -#658 = SURFACE_STYLE_USAGE(.BOTH.,#659); -#659 = SURFACE_SIDE_STYLE('',(#660,#663)); -#660 = SURFACE_STYLE_FILL_AREA(#661); -#661 = FILL_AREA_STYLE('',(#662)); -#662 = FILL_AREA_STYLE_COLOUR('',#629); -#663 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#629,( - #664)); -#664 = SURFACE_STYLE_TRANSPARENT(0.899999976158); -#665 = CURVE_STYLE('',#666,POSITIVE_LENGTH_MEASURE(0.1),#610); -#666 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#667 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#668) - ,#311); -#668 = STYLED_ITEM('color',(#669),#286); -#669 = PRESENTATION_STYLE_ASSIGNMENT((#670,#677)); -#670 = SURFACE_STYLE_USAGE(.BOTH.,#671); -#671 = SURFACE_SIDE_STYLE('',(#672,#675)); -#672 = SURFACE_STYLE_FILL_AREA(#673); -#673 = FILL_AREA_STYLE('',(#674)); -#674 = FILL_AREA_STYLE_COLOUR('',#629); -#675 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#629,( - #676)); -#676 = SURFACE_STYLE_TRANSPARENT(0.899999976158); -#677 = CURVE_STYLE('',#678,POSITIVE_LENGTH_MEASURE(0.1),#610); -#678 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#333 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#334) + ,#126); +#334 = STYLED_ITEM('color',(#335),#101); +#335 = PRESENTATION_STYLE_ASSIGNMENT((#336,#344)); +#336 = SURFACE_STYLE_USAGE(.BOTH.,#337); +#337 = SURFACE_SIDE_STYLE('',(#338,#342)); +#338 = SURFACE_STYLE_FILL_AREA(#339); +#339 = FILL_AREA_STYLE('',(#340)); +#340 = FILL_AREA_STYLE_COLOUR('',#341); +#341 = DRAUGHTING_PRE_DEFINED_COLOUR('red'); +#342 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#341,( + #343)); +#343 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#344 = CURVE_STYLE('',#345,POSITIVE_LENGTH_MEASURE(0.1),#332); +#345 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#346 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#347) + ,#264); +#347 = STYLED_ITEM('color',(#348),#239); +#348 = PRESENTATION_STYLE_ASSIGNMENT((#349,#354)); +#349 = SURFACE_STYLE_USAGE(.BOTH.,#350); +#350 = SURFACE_SIDE_STYLE('',(#351)); +#351 = SURFACE_STYLE_FILL_AREA(#352); +#352 = FILL_AREA_STYLE('',(#353)); +#353 = FILL_AREA_STYLE_COLOUR('',#329); +#354 = CURVE_STYLE('',#355,POSITIVE_LENGTH_MEASURE(0.1),#332); +#355 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#356 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#357) + ,#172); +#357 = STYLED_ITEM('color',(#358),#147); +#358 = PRESENTATION_STYLE_ASSIGNMENT((#359,#364)); +#359 = SURFACE_STYLE_USAGE(.BOTH.,#360); +#360 = SURFACE_SIDE_STYLE('',(#361)); +#361 = SURFACE_STYLE_FILL_AREA(#362); +#362 = FILL_AREA_STYLE('',(#363)); +#363 = FILL_AREA_STYLE_COLOUR('',#329); +#364 = CURVE_STYLE('',#365,POSITIVE_LENGTH_MEASURE(0.1),#332); +#365 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#366 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#367) + ,#218); +#367 = STYLED_ITEM('color',(#368),#193); +#368 = PRESENTATION_STYLE_ASSIGNMENT((#369,#376)); +#369 = SURFACE_STYLE_USAGE(.BOTH.,#370); +#370 = SURFACE_SIDE_STYLE('',(#371,#374)); +#371 = SURFACE_STYLE_FILL_AREA(#372); +#372 = FILL_AREA_STYLE('',(#373)); +#373 = FILL_AREA_STYLE_COLOUR('',#341); +#374 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#341,( + #375)); +#375 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#376 = CURVE_STYLE('',#377,POSITIVE_LENGTH_MEASURE(0.1),#332); +#377 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#378 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#379) + ,#310); +#379 = STYLED_ITEM('color',(#380),#285); +#380 = PRESENTATION_STYLE_ASSIGNMENT((#381,#388)); +#381 = SURFACE_STYLE_USAGE(.BOTH.,#382); +#382 = SURFACE_SIDE_STYLE('',(#383,#386)); +#383 = SURFACE_STYLE_FILL_AREA(#384); +#384 = FILL_AREA_STYLE('',(#385)); +#385 = FILL_AREA_STYLE_COLOUR('',#341); +#386 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#341,( + #387)); +#387 = SURFACE_STYLE_TRANSPARENT(0.899999976158); +#388 = CURVE_STYLE('',#389,POSITIVE_LENGTH_MEASURE(0.1),#332); +#389 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); ENDSEC; END-ISO-10303-21; diff --git a/testData/three_wires_ribbon/three_wires_ribbon.pulmtln.in.json b/testData/three_wires_ribbon/three_wires_ribbon.tulip.adapted.json similarity index 100% rename from testData/three_wires_ribbon/three_wires_ribbon.pulmtln.in.json rename to testData/three_wires_ribbon/three_wires_ribbon.tulip.adapted.json diff --git a/testData/two_wires_coax/two_wires_coax.json b/testData/two_wires_coax/two_wires_coax.json new file mode 100644 index 0000000..c82189f --- /dev/null +++ b/testData/two_wires_coax/two_wires_coax.json @@ -0,0 +1,22 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_2", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/two_wires_coax/two_wires_coax.pulmtln.in.json b/testData/two_wires_coax/two_wires_coax.tulip.adapted.json similarity index 100% rename from testData/two_wires_coax/two_wires_coax.pulmtln.in.json rename to testData/two_wires_coax/two_wires_coax.tulip.adapted.json diff --git a/testData/two_wires_open/two_wires_open.FCStd b/testData/two_wires_open/two_wires_open.FCStd index 90457aa..293c117 100644 Binary files a/testData/two_wires_open/two_wires_open.FCStd and b/testData/two_wires_open/two_wires_open.FCStd differ diff --git a/testData/two_wires_open/two_wires_open.json b/testData/two_wires_open/two_wires_open.json new file mode 100644 index 0000000..78c6839 --- /dev/null +++ b/testData/two_wires_open/two_wires_open.json @@ -0,0 +1,16 @@ +{ + "CrossSection":[ + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_2", + "material":{ + "type":"PEC" + } + } + ] +} \ No newline at end of file diff --git a/testData/two_wires_open/two_wires_open.step b/testData/two_wires_open/two_wires_open.step index 4db92c0..62213eb 100644 --- a/testData/two_wires_open/two_wires_open.step +++ b/testData/two_wires_open/two_wires_open.step @@ -1,8 +1,8 @@ ISO-10303-21; HEADER; FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); -FILE_NAME('Open CASCADE Shape Model','2023-09-19T18:30:37',(''),(''), - 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_NAME('Open CASCADE Shape Model','2026-03-26T11:23:45',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); ENDSEC; DATA; @@ -14,239 +14,165 @@ DATA; #4 = PRODUCT_DEFINITION_SHAPE('','',#5); #5 = PRODUCT_DEFINITION('design','',#6,#9); #6 = PRODUCT_DEFINITION_FORMATION('','',#7); -#7 = PRODUCT('two_wires_coax','two_wires_coax','',(#8)); +#7 = PRODUCT('two_wires_open','two_wires_open','',(#8)); #8 = PRODUCT_CONTEXT('',#2,'mechanical'); #9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23),#27); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19),#23); #11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); #12 = CARTESIAN_POINT('',(0.,0.,0.)); #13 = DIRECTION('',(0.,0.,1.)); #14 = DIRECTION('',(1.,0.,-0.)); #15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); -#16 = CARTESIAN_POINT('',(0.,0.,0.)); +#16 = CARTESIAN_POINT('',(-25.,0.,0.)); #17 = DIRECTION('',(0.,0.,1.)); #18 = DIRECTION('',(1.,0.,0.)); #19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); -#20 = CARTESIAN_POINT('',(-25.,0.,0.)); +#20 = CARTESIAN_POINT('',(25.,0.,0.)); #21 = DIRECTION('',(0.,0.,1.)); #22 = DIRECTION('',(1.,0.,0.)); -#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); -#24 = CARTESIAN_POINT('',(25.,0.,0.)); -#25 = DIRECTION('',(0.,0.,1.)); -#26 = DIRECTION('',(1.,0.,0.)); -#27 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#31)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#28,#29,#30)) REPRESENTATION_CONTEXT('Context #1', +#23 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#27)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#24,#25,#26)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#28 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#29 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#30 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#31 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#28, +#24 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#25 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#26 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#27 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#24, 'distance_accuracy_value','confusion accuracy'); -#32 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); -#33 = SHAPE_DEFINITION_REPRESENTATION(#34,#40); -#34 = PRODUCT_DEFINITION_SHAPE('','',#35); -#35 = PRODUCT_DEFINITION('design','',#36,#39); -#36 = PRODUCT_DEFINITION_FORMATION('','',#37); -#37 = PRODUCT('OpenBoundary_0','OpenBoundary_0','',(#38)); -#38 = PRODUCT_CONTEXT('',#2,'mechanical'); -#39 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#40 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#41),#68); -#41 = SHELL_BASED_SURFACE_MODEL('',(#42)); -#42 = OPEN_SHELL('',(#43)); -#43 = ADVANCED_FACE('',(#44),#57,.T.); -#44 = FACE_BOUND('',#45,.T.); -#45 = EDGE_LOOP('',(#46)); -#46 = ORIENTED_EDGE('',*,*,#47,.T.); -#47 = EDGE_CURVE('',#48,#48,#50,.T.); -#48 = VERTEX_POINT('',#49); -#49 = CARTESIAN_POINT('',(500.,0.,0.)); -#50 = SURFACE_CURVE('',#51,(#56),.PCURVE_S1.); -#51 = CIRCLE('',#52,500.); -#52 = AXIS2_PLACEMENT_3D('',#53,#54,#55); -#53 = CARTESIAN_POINT('',(0.,0.,0.)); -#54 = DIRECTION('',(0.,0.,1.)); -#55 = DIRECTION('',(1.,0.,-0.)); -#56 = PCURVE('',#57,#62); -#57 = PLANE('',#58); -#58 = AXIS2_PLACEMENT_3D('',#59,#60,#61); -#59 = CARTESIAN_POINT('',(-2.240413913153E-14,1.993359145737E-15,0.)); -#60 = DIRECTION('',(0.,0.,1.)); -#61 = DIRECTION('',(1.,0.,-0.)); -#62 = DEFINITIONAL_REPRESENTATION('',(#63),#67); -#63 = CIRCLE('',#64,500.); -#64 = AXIS2_PLACEMENT_2D('',#65,#66); -#65 = CARTESIAN_POINT('',(2.240413913153E-14,-1.993359145737E-15)); -#66 = DIRECTION('',(1.,0.)); -#67 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#28 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#29 = SHAPE_DEFINITION_REPRESENTATION(#30,#36); +#30 = PRODUCT_DEFINITION_SHAPE('','',#31); +#31 = PRODUCT_DEFINITION('design','',#32,#35); +#32 = PRODUCT_DEFINITION_FORMATION('','',#33); +#33 = PRODUCT('Conductor_1','Conductor_1','',(#34)); +#34 = PRODUCT_CONTEXT('',#2,'mechanical'); +#35 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#36 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#37),#64); +#37 = SHELL_BASED_SURFACE_MODEL('',(#38)); +#38 = OPEN_SHELL('',(#39)); +#39 = ADVANCED_FACE('',(#40),#53,.T.); +#40 = FACE_BOUND('',#41,.T.); +#41 = EDGE_LOOP('',(#42)); +#42 = ORIENTED_EDGE('',*,*,#43,.T.); +#43 = EDGE_CURVE('',#44,#44,#46,.T.); +#44 = VERTEX_POINT('',#45); +#45 = CARTESIAN_POINT('',(2.,0.,0.)); +#46 = SURFACE_CURVE('',#47,(#52),.PCURVE_S1.); +#47 = CIRCLE('',#48,2.); +#48 = AXIS2_PLACEMENT_3D('',#49,#50,#51); +#49 = CARTESIAN_POINT('',(0.,0.,0.)); +#50 = DIRECTION('',(0.,0.,1.)); +#51 = DIRECTION('',(1.,0.,0.)); +#52 = PCURVE('',#53,#58); +#53 = PLANE('',#54); +#54 = AXIS2_PLACEMENT_3D('',#55,#56,#57); +#55 = CARTESIAN_POINT('',(-1.281975124256E-16,3.821888340557E-18,0.)); +#56 = DIRECTION('',(0.,0.,1.)); +#57 = DIRECTION('',(1.,0.,0.)); +#58 = DEFINITIONAL_REPRESENTATION('',(#59),#63); +#59 = CIRCLE('',#60,2.); +#60 = AXIS2_PLACEMENT_2D('',#61,#62); +#61 = CARTESIAN_POINT('',(1.281975124256E-16,-3.821888340557E-18)); +#62 = DIRECTION('',(1.,0.)); +#63 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#68 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#72)) GLOBAL_UNIT_ASSIGNED_CONTEXT( -(#69,#70,#71)) REPRESENTATION_CONTEXT('Context #1', +#64 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#68)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#65,#66,#67)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#69 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#70 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#71 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#72 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#69, +#65 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#66 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#67 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#68 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#65, 'distance_accuracy_value','confusion accuracy'); -#73 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#74,#76); -#74 = ( REPRESENTATION_RELATIONSHIP('','',#40,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#75) +#69 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#70,#72); +#70 = ( REPRESENTATION_RELATIONSHIP('','',#36,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#71) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#75 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); -#76 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#77); -#77 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','OpenBoundary_0','',#5,#35,$); -#78 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#37)); -#79 = SHAPE_DEFINITION_REPRESENTATION(#80,#86); -#80 = PRODUCT_DEFINITION_SHAPE('','',#81); -#81 = PRODUCT_DEFINITION('design','',#82,#85); -#82 = PRODUCT_DEFINITION_FORMATION('','',#83); -#83 = PRODUCT('Conductor_1','Conductor_1','',(#84)); -#84 = PRODUCT_CONTEXT('',#2,'mechanical'); -#85 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#86 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#87),#114); -#87 = SHELL_BASED_SURFACE_MODEL('',(#88)); -#88 = OPEN_SHELL('',(#89)); -#89 = ADVANCED_FACE('',(#90),#103,.T.); -#90 = FACE_BOUND('',#91,.T.); -#91 = EDGE_LOOP('',(#92)); -#92 = ORIENTED_EDGE('',*,*,#93,.T.); -#93 = EDGE_CURVE('',#94,#94,#96,.T.); -#94 = VERTEX_POINT('',#95); -#95 = CARTESIAN_POINT('',(2.,0.,0.)); -#96 = SURFACE_CURVE('',#97,(#102),.PCURVE_S1.); -#97 = CIRCLE('',#98,2.); -#98 = AXIS2_PLACEMENT_3D('',#99,#100,#101); -#99 = CARTESIAN_POINT('',(0.,0.,0.)); -#100 = DIRECTION('',(0.,0.,1.)); -#101 = DIRECTION('',(1.,0.,0.)); -#102 = PCURVE('',#103,#108); -#103 = PLANE('',#104); -#104 = AXIS2_PLACEMENT_3D('',#105,#106,#107); -#105 = CARTESIAN_POINT('',(-1.3E-16,0.,0.)); -#106 = DIRECTION('',(0.,0.,1.)); -#107 = DIRECTION('',(1.,0.,0.)); -#108 = DEFINITIONAL_REPRESENTATION('',(#109),#113); -#109 = CIRCLE('',#110,2.); -#110 = AXIS2_PLACEMENT_2D('',#111,#112); -#111 = CARTESIAN_POINT('',(1.3E-16,0.)); -#112 = DIRECTION('',(1.,0.)); -#113 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +#71 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#72 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#73); +#73 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','Conductor_1','',#5,#31,$); +#74 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#33)); +#75 = SHAPE_DEFINITION_REPRESENTATION(#76,#82); +#76 = PRODUCT_DEFINITION_SHAPE('','',#77); +#77 = PRODUCT_DEFINITION('design','',#78,#81); +#78 = PRODUCT_DEFINITION_FORMATION('','',#79); +#79 = PRODUCT('Conductor_2','Conductor_2','',(#80)); +#80 = PRODUCT_CONTEXT('',#2,'mechanical'); +#81 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#82 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#83),#110); +#83 = SHELL_BASED_SURFACE_MODEL('',(#84)); +#84 = OPEN_SHELL('',(#85)); +#85 = ADVANCED_FACE('',(#86),#99,.T.); +#86 = FACE_BOUND('',#87,.T.); +#87 = EDGE_LOOP('',(#88)); +#88 = ORIENTED_EDGE('',*,*,#89,.T.); +#89 = EDGE_CURVE('',#90,#90,#92,.T.); +#90 = VERTEX_POINT('',#91); +#91 = CARTESIAN_POINT('',(2.,0.,0.)); +#92 = SURFACE_CURVE('',#93,(#98),.PCURVE_S1.); +#93 = CIRCLE('',#94,2.); +#94 = AXIS2_PLACEMENT_3D('',#95,#96,#97); +#95 = CARTESIAN_POINT('',(0.,0.,0.)); +#96 = DIRECTION('',(0.,0.,1.)); +#97 = DIRECTION('',(1.,0.,0.)); +#98 = PCURVE('',#99,#104); +#99 = PLANE('',#100); +#100 = AXIS2_PLACEMENT_3D('',#101,#102,#103); +#101 = CARTESIAN_POINT('',(-1.281975124256E-16,3.821888340557E-18,0.)); +#102 = DIRECTION('',(0.,0.,1.)); +#103 = DIRECTION('',(1.,0.,0.)); +#104 = DEFINITIONAL_REPRESENTATION('',(#105),#109); +#105 = CIRCLE('',#106,2.); +#106 = AXIS2_PLACEMENT_2D('',#107,#108); +#107 = CARTESIAN_POINT('',(1.281975124256E-16,-3.821888340557E-18)); +#108 = DIRECTION('',(1.,0.)); +#109 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' ) ); -#114 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#118)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#115,#116,#117)) REPRESENTATION_CONTEXT('Context #1', +#110 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#114)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#111,#112,#113)) REPRESENTATION_CONTEXT('Context #1', '3D Context with UNIT and UNCERTAINTY') ); -#115 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#116 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#117 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#118 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#115, +#111 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#112 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#113 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#114 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#111, 'distance_accuracy_value','confusion accuracy'); -#119 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#120,#122); -#120 = ( REPRESENTATION_RELATIONSHIP('','',#86,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#121) +#115 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#116,#118); +#116 = ( REPRESENTATION_RELATIONSHIP('','',#82,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#117) SHAPE_REPRESENTATION_RELATIONSHIP() ); -#121 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); -#122 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#123 +#117 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#118 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#119 ); -#123 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Conductor_1','',#5,#81,$); -#124 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#83)); -#125 = SHAPE_DEFINITION_REPRESENTATION(#126,#132); -#126 = PRODUCT_DEFINITION_SHAPE('','',#127); -#127 = PRODUCT_DEFINITION('design','',#128,#131); -#128 = PRODUCT_DEFINITION_FORMATION('','',#129); -#129 = PRODUCT('Conductor_2','Conductor_2','',(#130)); -#130 = PRODUCT_CONTEXT('',#2,'mechanical'); -#131 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); -#132 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#133),#160); -#133 = SHELL_BASED_SURFACE_MODEL('',(#134)); -#134 = OPEN_SHELL('',(#135)); -#135 = ADVANCED_FACE('',(#136),#149,.T.); -#136 = FACE_BOUND('',#137,.T.); -#137 = EDGE_LOOP('',(#138)); -#138 = ORIENTED_EDGE('',*,*,#139,.T.); -#139 = EDGE_CURVE('',#140,#140,#142,.T.); -#140 = VERTEX_POINT('',#141); -#141 = CARTESIAN_POINT('',(2.,0.,0.)); -#142 = SURFACE_CURVE('',#143,(#148),.PCURVE_S1.); -#143 = CIRCLE('',#144,2.); -#144 = AXIS2_PLACEMENT_3D('',#145,#146,#147); -#145 = CARTESIAN_POINT('',(0.,0.,0.)); -#146 = DIRECTION('',(0.,0.,1.)); -#147 = DIRECTION('',(1.,0.,0.)); -#148 = PCURVE('',#149,#154); -#149 = PLANE('',#150); -#150 = AXIS2_PLACEMENT_3D('',#151,#152,#153); -#151 = CARTESIAN_POINT('',(-1.281975124256E-16,3.821888340557E-18,0.)); -#152 = DIRECTION('',(0.,0.,1.)); -#153 = DIRECTION('',(1.,0.,0.)); -#154 = DEFINITIONAL_REPRESENTATION('',(#155),#159); -#155 = CIRCLE('',#156,2.); -#156 = AXIS2_PLACEMENT_2D('',#157,#158); -#157 = CARTESIAN_POINT('',(1.281975124256E-16,-3.821888340557E-18)); -#158 = DIRECTION('',(1.,0.)); -#159 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) -PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' - ) ); -#160 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) -GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#164)) GLOBAL_UNIT_ASSIGNED_CONTEXT -((#161,#162,#163)) REPRESENTATION_CONTEXT('Context #1', - '3D Context with UNIT and UNCERTAINTY') ); -#161 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); -#162 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); -#163 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); -#164 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#161, - 'distance_accuracy_value','confusion accuracy'); -#165 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#166,#168); -#166 = ( REPRESENTATION_RELATIONSHIP('','',#132,#10) -REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#167) -SHAPE_REPRESENTATION_RELATIONSHIP() ); -#167 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); -#168 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#169 - ); -#169 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','Conductor_2','',#5,#127,$); -#170 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#129)); -#171 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#172) - ,#160); -#172 = STYLED_ITEM('color',(#173),#135); -#173 = PRESENTATION_STYLE_ASSIGNMENT((#174,#180)); -#174 = SURFACE_STYLE_USAGE(.BOTH.,#175); -#175 = SURFACE_SIDE_STYLE('',(#176)); -#176 = SURFACE_STYLE_FILL_AREA(#177); -#177 = FILL_AREA_STYLE('',(#178)); -#178 = FILL_AREA_STYLE_COLOUR('',#179); -#179 = COLOUR_RGB('',1.,0.666666687201,0.); -#180 = CURVE_STYLE('',#181,POSITIVE_LENGTH_MEASURE(0.1),#182); -#181 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#182 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, +#119 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Conductor_2','',#5,#77,$); +#120 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#79)); +#121 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#122) + ,#64); +#122 = STYLED_ITEM('color',(#123),#39); +#123 = PRESENTATION_STYLE_ASSIGNMENT((#124,#130)); +#124 = SURFACE_STYLE_USAGE(.BOTH.,#125); +#125 = SURFACE_SIDE_STYLE('',(#126)); +#126 = SURFACE_STYLE_FILL_AREA(#127); +#127 = FILL_AREA_STYLE('',(#128)); +#128 = FILL_AREA_STYLE_COLOUR('',#129); +#129 = COLOUR_RGB('',1.,0.666666687201,0.); +#130 = CURVE_STYLE('',#131,POSITIVE_LENGTH_MEASURE(0.1),#132); +#131 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#132 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, 9.803921802644E-02); -#183 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#184) - ,#114); -#184 = STYLED_ITEM('color',(#185),#89); -#185 = PRESENTATION_STYLE_ASSIGNMENT((#186,#191)); -#186 = SURFACE_STYLE_USAGE(.BOTH.,#187); -#187 = SURFACE_SIDE_STYLE('',(#188)); -#188 = SURFACE_STYLE_FILL_AREA(#189); -#189 = FILL_AREA_STYLE('',(#190)); -#190 = FILL_AREA_STYLE_COLOUR('',#179); -#191 = CURVE_STYLE('',#192,POSITIVE_LENGTH_MEASURE(0.1),#182); -#192 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); -#193 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#194) - ,#68); -#194 = STYLED_ITEM('color',(#195),#43); -#195 = PRESENTATION_STYLE_ASSIGNMENT((#196,#204)); -#196 = SURFACE_STYLE_USAGE(.BOTH.,#197); -#197 = SURFACE_SIDE_STYLE('',(#198,#202)); -#198 = SURFACE_STYLE_FILL_AREA(#199); -#199 = FILL_AREA_STYLE('',(#200)); -#200 = FILL_AREA_STYLE_COLOUR('',#201); -#201 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); -#202 = SURFACE_STYLE_RENDERING_WITH_PROPERTIES(.NORMAL_SHADING.,#201,( - #203)); -#203 = SURFACE_STYLE_TRANSPARENT(0.990000009537); -#204 = CURVE_STYLE('',#205,POSITIVE_LENGTH_MEASURE(0.1),#182); -#205 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#133 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#134) + ,#110); +#134 = STYLED_ITEM('color',(#135),#85); +#135 = PRESENTATION_STYLE_ASSIGNMENT((#136,#141)); +#136 = SURFACE_STYLE_USAGE(.BOTH.,#137); +#137 = SURFACE_SIDE_STYLE('',(#138)); +#138 = SURFACE_STYLE_FILL_AREA(#139); +#139 = FILL_AREA_STYLE('',(#140)); +#140 = FILL_AREA_STYLE_COLOUR('',#129); +#141 = CURVE_STYLE('',#142,POSITIVE_LENGTH_MEASURE(0.1),#132); +#142 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); ENDSEC; END-ISO-10303-21; diff --git a/testData/two_wires_open/two_wires_open.pulmtln.in.json b/testData/two_wires_open/two_wires_open.tulip.adapted.json similarity index 100% rename from testData/two_wires_open/two_wires_open.pulmtln.in.json rename to testData/two_wires_open/two_wires_open.tulip.adapted.json diff --git a/testData/two_wires_shielded/two_wires_shielded.pulmtln.in.json b/testData/two_wires_shielded/two_wires_shielded.tulip.adapted.json similarity index 100% rename from testData/two_wires_shielded/two_wires_shielded.pulmtln.in.json rename to testData/two_wires_shielded/two_wires_shielded.tulip.adapted.json diff --git a/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.FCStd b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.FCStd new file mode 100644 index 0000000..303da56 Binary files /dev/null and b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.FCStd differ diff --git a/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.json b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.json new file mode 100644 index 0000000..d893a30 --- /dev/null +++ b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.json @@ -0,0 +1,30 @@ +{ + "CrossSection": [ + { + "name": "LeftConductor", + "material": { + "type": "PEC" + } + }, + { + "name": "RightConductor", + "material": { + "type": "PEC" + } + }, + { + "name": "RightDielectric", + "material": { + "type": "Dielectric", + "permittivity": 3.0 + } + }, + { + "name": "LeftDielectric", + "material": { + "type": "Dielectric", + "permittivity": 3.0 + } + } + ] +} \ No newline at end of file diff --git a/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.step b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.step new file mode 100644 index 0000000..5002b34 --- /dev/null +++ b/testData/two_wires_with_touching_dielectric/two_wires_with_touching_dielectric.step @@ -0,0 +1,320 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2026-03-20T09:26:47',(''),(''), + 'Open CASCADE STEP processor 7.8','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('Cable002','Cable002','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23,#27),#31); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(-1.2,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(1.2,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(1.2,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = AXIS2_PLACEMENT_3D('',#28,#29,#30); +#28 = CARTESIAN_POINT('',(-1.2,0.,0.)); +#29 = DIRECTION('',(0.,0.,1.)); +#30 = DIRECTION('',(1.,0.,0.)); +#31 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#35)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#32,#33,#34)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#32 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#33 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#34 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#35 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#32, + 'distance_accuracy_value','confusion accuracy'); +#36 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#37 = SHAPE_DEFINITION_REPRESENTATION(#38,#44); +#38 = PRODUCT_DEFINITION_SHAPE('','',#39); +#39 = PRODUCT_DEFINITION('design','',#40,#43); +#40 = PRODUCT_DEFINITION_FORMATION('','',#41); +#41 = PRODUCT('LeftConductor','LeftConductor','',(#42)); +#42 = PRODUCT_CONTEXT('',#2,'mechanical'); +#43 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#44 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#45),#72); +#45 = SHELL_BASED_SURFACE_MODEL('',(#46)); +#46 = OPEN_SHELL('',(#47)); +#47 = ADVANCED_FACE('',(#48),#61,.T.); +#48 = FACE_BOUND('',#49,.T.); +#49 = EDGE_LOOP('',(#50)); +#50 = ORIENTED_EDGE('',*,*,#51,.T.); +#51 = EDGE_CURVE('',#52,#52,#54,.T.); +#52 = VERTEX_POINT('',#53); +#53 = CARTESIAN_POINT('',(1.,0.,0.)); +#54 = SURFACE_CURVE('',#55,(#60),.PCURVE_S1.); +#55 = CIRCLE('',#56,1.); +#56 = AXIS2_PLACEMENT_3D('',#57,#58,#59); +#57 = CARTESIAN_POINT('',(0.,0.,0.)); +#58 = DIRECTION('',(0.,0.,1.)); +#59 = DIRECTION('',(1.,0.,0.)); +#60 = PCURVE('',#61,#66); +#61 = PLANE('',#62); +#62 = AXIS2_PLACEMENT_3D('',#63,#64,#65); +#63 = CARTESIAN_POINT('',(-6.E-17,0.,0.)); +#64 = DIRECTION('',(0.,0.,1.)); +#65 = DIRECTION('',(1.,0.,0.)); +#66 = DEFINITIONAL_REPRESENTATION('',(#67),#71); +#67 = CIRCLE('',#68,1.); +#68 = AXIS2_PLACEMENT_2D('',#69,#70); +#69 = CARTESIAN_POINT('',(6.E-17,0.)); +#70 = DIRECTION('',(1.,0.)); +#71 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#72 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#76)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#73,#74,#75)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#73 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#74 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#75 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#76 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#73, + 'distance_accuracy_value','confusion accuracy'); +#77 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#78,#80); +#78 = ( REPRESENTATION_RELATIONSHIP('','',#44,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#79) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#79 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#80 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#81); +#81 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','LeftConductor','',#5,#39,$); +#82 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#41)); +#83 = SHAPE_DEFINITION_REPRESENTATION(#84,#90); +#84 = PRODUCT_DEFINITION_SHAPE('','',#85); +#85 = PRODUCT_DEFINITION('design','',#86,#89); +#86 = PRODUCT_DEFINITION_FORMATION('','',#87); +#87 = PRODUCT('RightConductor','RightConductor','',(#88)); +#88 = PRODUCT_CONTEXT('',#2,'mechanical'); +#89 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#90 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#91),#118); +#91 = SHELL_BASED_SURFACE_MODEL('',(#92)); +#92 = OPEN_SHELL('',(#93)); +#93 = ADVANCED_FACE('',(#94),#107,.T.); +#94 = FACE_BOUND('',#95,.T.); +#95 = EDGE_LOOP('',(#96)); +#96 = ORIENTED_EDGE('',*,*,#97,.T.); +#97 = EDGE_CURVE('',#98,#98,#100,.T.); +#98 = VERTEX_POINT('',#99); +#99 = CARTESIAN_POINT('',(1.,0.,0.)); +#100 = SURFACE_CURVE('',#101,(#106),.PCURVE_S1.); +#101 = CIRCLE('',#102,1.); +#102 = AXIS2_PLACEMENT_3D('',#103,#104,#105); +#103 = CARTESIAN_POINT('',(0.,0.,0.)); +#104 = DIRECTION('',(0.,0.,1.)); +#105 = DIRECTION('',(1.,0.,0.)); +#106 = PCURVE('',#107,#112); +#107 = PLANE('',#108); +#108 = AXIS2_PLACEMENT_3D('',#109,#110,#111); +#109 = CARTESIAN_POINT('',(-6.E-17,0.,0.)); +#110 = DIRECTION('',(0.,0.,1.)); +#111 = DIRECTION('',(1.,0.,0.)); +#112 = DEFINITIONAL_REPRESENTATION('',(#113),#117); +#113 = CIRCLE('',#114,1.); +#114 = AXIS2_PLACEMENT_2D('',#115,#116); +#115 = CARTESIAN_POINT('',(6.E-17,0.)); +#116 = DIRECTION('',(1.,0.)); +#117 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#118 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#122)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#119,#120,#121)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#119 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#120 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#121 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#122 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#119, + 'distance_accuracy_value','confusion accuracy'); +#123 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#124,#126); +#124 = ( REPRESENTATION_RELATIONSHIP('','',#90,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#125) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#125 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#126 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#127 + ); +#127 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','RightConductor','',#5,#85,$); +#128 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#87)); +#129 = SHAPE_DEFINITION_REPRESENTATION(#130,#136); +#130 = PRODUCT_DEFINITION_SHAPE('','',#131); +#131 = PRODUCT_DEFINITION('design','',#132,#135); +#132 = PRODUCT_DEFINITION_FORMATION('','',#133); +#133 = PRODUCT('RightDielectric','RightDielectric','',(#134)); +#134 = PRODUCT_CONTEXT('',#2,'mechanical'); +#135 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#136 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#137),#164); +#137 = SHELL_BASED_SURFACE_MODEL('',(#138)); +#138 = OPEN_SHELL('',(#139)); +#139 = ADVANCED_FACE('',(#140),#153,.T.); +#140 = FACE_BOUND('',#141,.T.); +#141 = EDGE_LOOP('',(#142)); +#142 = ORIENTED_EDGE('',*,*,#143,.T.); +#143 = EDGE_CURVE('',#144,#144,#146,.T.); +#144 = VERTEX_POINT('',#145); +#145 = CARTESIAN_POINT('',(1.2,0.,0.)); +#146 = SURFACE_CURVE('',#147,(#152),.PCURVE_S1.); +#147 = CIRCLE('',#148,1.2); +#148 = AXIS2_PLACEMENT_3D('',#149,#150,#151); +#149 = CARTESIAN_POINT('',(0.,0.,0.)); +#150 = DIRECTION('',(0.,0.,1.)); +#151 = DIRECTION('',(1.,0.,0.)); +#152 = PCURVE('',#153,#158); +#153 = PLANE('',#154); +#154 = AXIS2_PLACEMENT_3D('',#155,#156,#157); +#155 = CARTESIAN_POINT('',(-1.424416804729E-16,2.223496827053E-17,0.)); +#156 = DIRECTION('',(0.,0.,1.)); +#157 = DIRECTION('',(1.,0.,0.)); +#158 = DEFINITIONAL_REPRESENTATION('',(#159),#163); +#159 = CIRCLE('',#160,1.2); +#160 = AXIS2_PLACEMENT_2D('',#161,#162); +#161 = CARTESIAN_POINT('',(1.424416804729E-16,-2.223496827053E-17)); +#162 = DIRECTION('',(1.,0.)); +#163 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#164 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#168)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#165,#166,#167)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#165 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#166 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#167 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#168 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#165, + 'distance_accuracy_value','confusion accuracy'); +#169 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#170,#172); +#170 = ( REPRESENTATION_RELATIONSHIP('','',#136,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#171) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#171 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#172 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#173 + ); +#173 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','RightDielectric','',#5,#131,$ + ); +#174 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#133)); +#175 = SHAPE_DEFINITION_REPRESENTATION(#176,#182); +#176 = PRODUCT_DEFINITION_SHAPE('','',#177); +#177 = PRODUCT_DEFINITION('design','',#178,#181); +#178 = PRODUCT_DEFINITION_FORMATION('','',#179); +#179 = PRODUCT('LeftDielectric','LeftDielectric','',(#180)); +#180 = PRODUCT_CONTEXT('',#2,'mechanical'); +#181 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#182 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#183),#210); +#183 = SHELL_BASED_SURFACE_MODEL('',(#184)); +#184 = OPEN_SHELL('',(#185)); +#185 = ADVANCED_FACE('',(#186),#199,.T.); +#186 = FACE_BOUND('',#187,.T.); +#187 = EDGE_LOOP('',(#188)); +#188 = ORIENTED_EDGE('',*,*,#189,.T.); +#189 = EDGE_CURVE('',#190,#190,#192,.T.); +#190 = VERTEX_POINT('',#191); +#191 = CARTESIAN_POINT('',(1.2,0.,0.)); +#192 = SURFACE_CURVE('',#193,(#198),.PCURVE_S1.); +#193 = CIRCLE('',#194,1.2); +#194 = AXIS2_PLACEMENT_3D('',#195,#196,#197); +#195 = CARTESIAN_POINT('',(0.,0.,0.)); +#196 = DIRECTION('',(0.,0.,1.)); +#197 = DIRECTION('',(1.,0.,0.)); +#198 = PCURVE('',#199,#204); +#199 = PLANE('',#200); +#200 = AXIS2_PLACEMENT_3D('',#201,#202,#203); +#201 = CARTESIAN_POINT('',(-1.424416804729E-16,2.223496827053E-17,0.)); +#202 = DIRECTION('',(0.,0.,1.)); +#203 = DIRECTION('',(1.,0.,0.)); +#204 = DEFINITIONAL_REPRESENTATION('',(#205),#209); +#205 = CIRCLE('',#206,1.2); +#206 = AXIS2_PLACEMENT_2D('',#207,#208); +#207 = CARTESIAN_POINT('',(1.424416804729E-16,-2.223496827053E-17)); +#208 = DIRECTION('',(1.,0.)); +#209 = ( GEOMETRIC_REPRESENTATION_CONTEXT(2) +PARAMETRIC_REPRESENTATION_CONTEXT() REPRESENTATION_CONTEXT('2D SPACE','' + ) ); +#210 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#214)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#211,#212,#213)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#211 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#212 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#213 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#214 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#211, + 'distance_accuracy_value','confusion accuracy'); +#215 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#216,#218); +#216 = ( REPRESENTATION_RELATIONSHIP('','',#182,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#217) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#217 = ITEM_DEFINED_TRANSFORMATION('','',#11,#27); +#218 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#219 + ); +#219 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('4','LeftDielectric','',#5,#177,$ + ); +#220 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#179)); +#221 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#222) + ,#118); +#222 = STYLED_ITEM('color',(#223),#93); +#223 = PRESENTATION_STYLE_ASSIGNMENT((#224,#230)); +#224 = SURFACE_STYLE_USAGE(.BOTH.,#225); +#225 = SURFACE_SIDE_STYLE('',(#226)); +#226 = SURFACE_STYLE_FILL_AREA(#227); +#227 = FILL_AREA_STYLE('',(#228)); +#228 = FILL_AREA_STYLE_COLOUR('',#229); +#229 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#230 = CURVE_STYLE('',#231,POSITIVE_LENGTH_MEASURE(0.1),#232); +#231 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#232 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#233 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#234) + ,#210); +#234 = STYLED_ITEM('color',(#235),#185); +#235 = PRESENTATION_STYLE_ASSIGNMENT((#236,#241)); +#236 = SURFACE_STYLE_USAGE(.BOTH.,#237); +#237 = SURFACE_SIDE_STYLE('',(#238)); +#238 = SURFACE_STYLE_FILL_AREA(#239); +#239 = FILL_AREA_STYLE('',(#240)); +#240 = FILL_AREA_STYLE_COLOUR('',#229); +#241 = CURVE_STYLE('',#242,POSITIVE_LENGTH_MEASURE(0.1),#232); +#242 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#243 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#244) + ,#164); +#244 = STYLED_ITEM('color',(#245),#139); +#245 = PRESENTATION_STYLE_ASSIGNMENT((#246,#251)); +#246 = SURFACE_STYLE_USAGE(.BOTH.,#247); +#247 = SURFACE_SIDE_STYLE('',(#248)); +#248 = SURFACE_STYLE_FILL_AREA(#249); +#249 = FILL_AREA_STYLE('',(#250)); +#250 = FILL_AREA_STYLE_COLOUR('',#229); +#251 = CURVE_STYLE('',#252,POSITIVE_LENGTH_MEASURE(0.1),#232); +#252 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#253 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#254) + ,#72); +#254 = STYLED_ITEM('color',(#255),#47); +#255 = PRESENTATION_STYLE_ASSIGNMENT((#256,#261)); +#256 = SURFACE_STYLE_USAGE(.BOTH.,#257); +#257 = SURFACE_SIDE_STYLE('',(#258)); +#258 = SURFACE_STYLE_FILL_AREA(#259); +#259 = FILL_AREA_STYLE('',(#260)); +#260 = FILL_AREA_STYLE_COLOUR('',#229); +#261 = CURVE_STYLE('',#262,POSITIVE_LENGTH_MEASURE(0.1),#232); +#262 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/testData/unshielded_multiwire/unshielded_multiwire.FCStd b/testData/unshielded_multiwire/unshielded_multiwire.FCStd new file mode 100644 index 0000000..68075dc Binary files /dev/null and b/testData/unshielded_multiwire/unshielded_multiwire.FCStd differ diff --git a/testData/unshielded_multiwire/unshielded_multiwire.json b/testData/unshielded_multiwire/unshielded_multiwire.json new file mode 100644 index 0000000..38c9723 --- /dev/null +++ b/testData/unshielded_multiwire/unshielded_multiwire.json @@ -0,0 +1,22 @@ +{ + "CrossSection":[ + { + "name":"Conductor_0", + "material":{ + "type":"PEC" + } + }, + { + "name":"Conductor_1", + "material":{ + "type":"PEC" + } + }, + { + "name":"Dielectric_1", + "material":{ + "type":"Dielectric" + } + } + ] +} \ No newline at end of file diff --git a/testData/unshielded_multiwire/unshielded_multiwire.step b/testData/unshielded_multiwire/unshielded_multiwire.step new file mode 100644 index 0000000..02fa787 --- /dev/null +++ b/testData/unshielded_multiwire/unshielded_multiwire.step @@ -0,0 +1,218 @@ +ISO-10303-21; +HEADER; +FILE_DESCRIPTION(('FreeCAD Model'),'2;1'); +FILE_NAME('Open CASCADE Shape Model','2025-05-05T08:20:10',(''),(''), + 'Open CASCADE STEP processor 7.6','FreeCAD','Unknown'); +FILE_SCHEMA(('AUTOMOTIVE_DESIGN { 1 0 10303 214 1 1 1 1 }')); +ENDSEC; +DATA; +#1 = APPLICATION_PROTOCOL_DEFINITION('international standard', + 'automotive_design',2000,#2); +#2 = APPLICATION_CONTEXT( + 'core data for automotive mechanical design processes'); +#3 = SHAPE_DEFINITION_REPRESENTATION(#4,#10); +#4 = PRODUCT_DEFINITION_SHAPE('','',#5); +#5 = PRODUCT_DEFINITION('design','',#6,#9); +#6 = PRODUCT_DEFINITION_FORMATION('','',#7); +#7 = PRODUCT('unshielded_multiwire','unshielded_multiwire','',(#8)); +#8 = PRODUCT_CONTEXT('',#2,'mechanical'); +#9 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#10 = SHAPE_REPRESENTATION('',(#11,#15,#19,#23),#27); +#11 = AXIS2_PLACEMENT_3D('',#12,#13,#14); +#12 = CARTESIAN_POINT('',(0.,0.,0.)); +#13 = DIRECTION('',(0.,0.,1.)); +#14 = DIRECTION('',(1.,0.,-0.)); +#15 = AXIS2_PLACEMENT_3D('',#16,#17,#18); +#16 = CARTESIAN_POINT('',(-10.,0.,0.)); +#17 = DIRECTION('',(0.,0.,1.)); +#18 = DIRECTION('',(1.,0.,0.)); +#19 = AXIS2_PLACEMENT_3D('',#20,#21,#22); +#20 = CARTESIAN_POINT('',(10.,0.,0.)); +#21 = DIRECTION('',(0.,0.,1.)); +#22 = DIRECTION('',(1.,0.,0.)); +#23 = AXIS2_PLACEMENT_3D('',#24,#25,#26); +#24 = CARTESIAN_POINT('',(10.,0.,0.)); +#25 = DIRECTION('',(0.,0.,1.)); +#26 = DIRECTION('',(1.,0.,0.)); +#27 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#31)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#28,#29,#30)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#28 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#29 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#30 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#31 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#28, + 'distance_accuracy_value','confusion accuracy'); +#32 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#7)); +#33 = SHAPE_DEFINITION_REPRESENTATION(#34,#40); +#34 = PRODUCT_DEFINITION_SHAPE('','',#35); +#35 = PRODUCT_DEFINITION('design','',#36,#39); +#36 = PRODUCT_DEFINITION_FORMATION('','',#37); +#37 = PRODUCT('Conductor_0','Conductor_0','',(#38)); +#38 = PRODUCT_CONTEXT('',#2,'mechanical'); +#39 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#40 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#41),#60); +#41 = SHELL_BASED_SURFACE_MODEL('',(#42)); +#42 = OPEN_SHELL('',(#43)); +#43 = ADVANCED_FACE('',(#44),#55,.T.); +#44 = FACE_BOUND('',#45,.T.); +#45 = EDGE_LOOP('',(#46)); +#46 = ORIENTED_EDGE('',*,*,#47,.T.); +#47 = EDGE_CURVE('',#48,#48,#50,.T.); +#48 = VERTEX_POINT('',#49); +#49 = CARTESIAN_POINT('',(10.,0.,0.)); +#50 = CIRCLE('',#51,10.); +#51 = AXIS2_PLACEMENT_3D('',#52,#53,#54); +#52 = CARTESIAN_POINT('',(0.,0.,0.)); +#53 = DIRECTION('',(0.,0.,1.)); +#54 = DIRECTION('',(1.,0.,0.)); +#55 = PLANE('',#56); +#56 = AXIS2_PLACEMENT_3D('',#57,#58,#59); +#57 = CARTESIAN_POINT('',(-5.469760530158E-16,1.387604533E-16,0.)); +#58 = DIRECTION('',(0.,0.,1.)); +#59 = DIRECTION('',(1.,0.,0.)); +#60 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#64)) GLOBAL_UNIT_ASSIGNED_CONTEXT( +(#61,#62,#63)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#61 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#62 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#63 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#64 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#61, + 'distance_accuracy_value','confusion accuracy'); +#65 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#66,#68); +#66 = ( REPRESENTATION_RELATIONSHIP('','',#40,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#67) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#67 = ITEM_DEFINED_TRANSFORMATION('','',#11,#15); +#68 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#69); +#69 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('1','Conductor_0','',#5,#35,$); +#70 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#37)); +#71 = SHAPE_DEFINITION_REPRESENTATION(#72,#78); +#72 = PRODUCT_DEFINITION_SHAPE('','',#73); +#73 = PRODUCT_DEFINITION('design','',#74,#77); +#74 = PRODUCT_DEFINITION_FORMATION('','',#75); +#75 = PRODUCT('Conductor_1','Conductor_1','',(#76)); +#76 = PRODUCT_CONTEXT('',#2,'mechanical'); +#77 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#78 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#79),#98); +#79 = SHELL_BASED_SURFACE_MODEL('',(#80)); +#80 = OPEN_SHELL('',(#81)); +#81 = ADVANCED_FACE('',(#82),#93,.T.); +#82 = FACE_BOUND('',#83,.T.); +#83 = EDGE_LOOP('',(#84)); +#84 = ORIENTED_EDGE('',*,*,#85,.T.); +#85 = EDGE_CURVE('',#86,#86,#88,.T.); +#86 = VERTEX_POINT('',#87); +#87 = CARTESIAN_POINT('',(5.,0.,0.)); +#88 = CIRCLE('',#89,5.); +#89 = AXIS2_PLACEMENT_3D('',#90,#91,#92); +#90 = CARTESIAN_POINT('',(0.,0.,0.)); +#91 = DIRECTION('',(0.,0.,1.)); +#92 = DIRECTION('',(1.,0.,0.)); +#93 = PLANE('',#94); +#94 = AXIS2_PLACEMENT_3D('',#95,#96,#97); +#95 = CARTESIAN_POINT('',(-2.734880265079E-16,6.938022664999E-17,0.)); +#96 = DIRECTION('',(0.,0.,1.)); +#97 = DIRECTION('',(1.,0.,0.)); +#98 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#102)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#99,#100,#101)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#99 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#100 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#101 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#102 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#99, + 'distance_accuracy_value','confusion accuracy'); +#103 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#104,#106); +#104 = ( REPRESENTATION_RELATIONSHIP('','',#78,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#105) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#105 = ITEM_DEFINED_TRANSFORMATION('','',#11,#19); +#106 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#107 + ); +#107 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('2','Conductor_1','',#5,#73,$); +#108 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#75)); +#109 = SHAPE_DEFINITION_REPRESENTATION(#110,#116); +#110 = PRODUCT_DEFINITION_SHAPE('','',#111); +#111 = PRODUCT_DEFINITION('design','',#112,#115); +#112 = PRODUCT_DEFINITION_FORMATION('','',#113); +#113 = PRODUCT('Dielectric_1','Dielectric_1','',(#114)); +#114 = PRODUCT_CONTEXT('',#2,'mechanical'); +#115 = PRODUCT_DEFINITION_CONTEXT('part definition',#2,'design'); +#116 = MANIFOLD_SURFACE_SHAPE_REPRESENTATION('',(#11,#117),#136); +#117 = SHELL_BASED_SURFACE_MODEL('',(#118)); +#118 = OPEN_SHELL('',(#119)); +#119 = ADVANCED_FACE('',(#120),#131,.T.); +#120 = FACE_BOUND('',#121,.T.); +#121 = EDGE_LOOP('',(#122)); +#122 = ORIENTED_EDGE('',*,*,#123,.T.); +#123 = EDGE_CURVE('',#124,#124,#126,.T.); +#124 = VERTEX_POINT('',#125); +#125 = CARTESIAN_POINT('',(7.5,0.,0.)); +#126 = CIRCLE('',#127,7.5); +#127 = AXIS2_PLACEMENT_3D('',#128,#129,#130); +#128 = CARTESIAN_POINT('',(0.,0.,0.)); +#129 = DIRECTION('',(0.,0.,1.)); +#130 = DIRECTION('',(1.,0.,0.)); +#131 = PLANE('',#132); +#132 = AXIS2_PLACEMENT_3D('',#133,#134,#135); +#133 = CARTESIAN_POINT('',(-3.646507020105E-16,5.848900222367E-17,0.)); +#134 = DIRECTION('',(0.,0.,1.)); +#135 = DIRECTION('',(1.,0.,0.)); +#136 = ( GEOMETRIC_REPRESENTATION_CONTEXT(3) +GLOBAL_UNCERTAINTY_ASSIGNED_CONTEXT((#140)) GLOBAL_UNIT_ASSIGNED_CONTEXT +((#137,#138,#139)) REPRESENTATION_CONTEXT('Context #1', + '3D Context with UNIT and UNCERTAINTY') ); +#137 = ( LENGTH_UNIT() NAMED_UNIT(*) SI_UNIT(.MILLI.,.METRE.) ); +#138 = ( NAMED_UNIT(*) PLANE_ANGLE_UNIT() SI_UNIT($,.RADIAN.) ); +#139 = ( NAMED_UNIT(*) SI_UNIT($,.STERADIAN.) SOLID_ANGLE_UNIT() ); +#140 = UNCERTAINTY_MEASURE_WITH_UNIT(LENGTH_MEASURE(1.E-07),#137, + 'distance_accuracy_value','confusion accuracy'); +#141 = CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#142,#144); +#142 = ( REPRESENTATION_RELATIONSHIP('','',#116,#10) +REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#143) +SHAPE_REPRESENTATION_RELATIONSHIP() ); +#143 = ITEM_DEFINED_TRANSFORMATION('','',#11,#23); +#144 = PRODUCT_DEFINITION_SHAPE('Placement','Placement of an item',#145 + ); +#145 = NEXT_ASSEMBLY_USAGE_OCCURRENCE('3','Dielectric_1','',#5,#111,$); +#146 = PRODUCT_RELATED_PRODUCT_CATEGORY('part',$,(#113)); +#147 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#148) + ,#60); +#148 = STYLED_ITEM('color',(#149),#43); +#149 = PRESENTATION_STYLE_ASSIGNMENT((#150,#156)); +#150 = SURFACE_STYLE_USAGE(.BOTH.,#151); +#151 = SURFACE_SIDE_STYLE('',(#152)); +#152 = SURFACE_STYLE_FILL_AREA(#153); +#153 = FILL_AREA_STYLE('',(#154)); +#154 = FILL_AREA_STYLE_COLOUR('',#155); +#155 = COLOUR_RGB('',0.800000010877,0.800000010877,0.800000010877); +#156 = CURVE_STYLE('',#157,POSITIVE_LENGTH_MEASURE(0.1),#158); +#157 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#158 = COLOUR_RGB('',9.803921802644E-02,9.803921802644E-02, + 9.803921802644E-02); +#159 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#160) + ,#98); +#160 = STYLED_ITEM('color',(#161),#81); +#161 = PRESENTATION_STYLE_ASSIGNMENT((#162,#167)); +#162 = SURFACE_STYLE_USAGE(.BOTH.,#163); +#163 = SURFACE_SIDE_STYLE('',(#164)); +#164 = SURFACE_STYLE_FILL_AREA(#165); +#165 = FILL_AREA_STYLE('',(#166)); +#166 = FILL_AREA_STYLE_COLOUR('',#155); +#167 = CURVE_STYLE('',#168,POSITIVE_LENGTH_MEASURE(0.1),#158); +#168 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +#169 = MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#170) + ,#136); +#170 = STYLED_ITEM('color',(#171),#119); +#171 = PRESENTATION_STYLE_ASSIGNMENT((#172,#177)); +#172 = SURFACE_STYLE_USAGE(.BOTH.,#173); +#173 = SURFACE_SIDE_STYLE('',(#174)); +#174 = SURFACE_STYLE_FILL_AREA(#175); +#175 = FILL_AREA_STYLE('',(#176)); +#176 = FILL_AREA_STYLE_COLOUR('',#155); +#177 = CURVE_STYLE('',#178,POSITIVE_LENGTH_MEASURE(0.1),#158); +#178 = DRAUGHTING_PRE_DEFINED_CURVE_FONT('continuous'); +ENDSEC; +END-ISO-10303-21; diff --git a/triplets/x64-linux.cmake b/triplets/x64-linux.cmake new file mode 100644 index 0000000..6ebbd61 --- /dev/null +++ b/triplets/x64-linux.cmake @@ -0,0 +1,6 @@ +include("${VCPKG_ROOT_DIR}/triplets/x64-linux.cmake") + +if(PORT STREQUAL "gmsh") + list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "-DENABLE_MESH=ON") + list(APPEND VCPKG_CMAKE_CONFIGURE_OPTIONS "-DENABLE_EIGEN=ON") +endif() diff --git a/vcpkg.json b/vcpkg.json index d4bf1b3..d114129 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -4,6 +4,10 @@ "gtest", "nlohmann-json", "boost-graph", - "boost-program-options" + "boost-program-options", + { + "name": "gmsh", + "features": ["occ"] + } ] } \ No newline at end of file