diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit.png b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit.png new file mode 100644 index 000000000..c8a0d5ad8 Binary files /dev/null and b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit.png differ diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit2.png b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit2.png new file mode 100644 index 000000000..140c9133c Binary files /dev/null and b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit2.png differ diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit3.png b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit3.png new file mode 100644 index 000000000..119bff9ab Binary files /dev/null and b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit3.png differ diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit_4.png b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit_4.png new file mode 100644 index 000000000..04729984d Binary files /dev/null and b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/Images/Qiskit_4.png differ diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/LICENSE b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/PR_1_Qiskit_logo.ipynb b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/PR_1_Qiskit_logo.ipynb new file mode 100644 index 000000000..a9409f466 --- /dev/null +++ b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/PR_1_Qiskit_logo.ipynb @@ -0,0 +1,363 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "06f56503", + "metadata": {}, + "source": [ + "## Import packages" + ] + }, + { + "cell_type": "markdown", + "id": "0b7be54f", + "metadata": {}, + "source": [ + "Package PIL is needed in order to work with images. Other packages are for Qiskit Metal" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4e4fb03c", + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from qiskit_metal import draw, Dict\n", + "from qiskit_metal.toolbox_metal import math_and_overrides\n", + "from qiskit_metal.qlibrary.core import QComponent\n", + "import qiskit_metal as metal" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c40be05d", + "metadata": {}, + "outputs": [], + "source": [ + "design = metal.designs.DesignPlanar()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f5ffe998", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['TOOLTIP',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__i_am_component__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_add_to_design',\n", + " '_check_pin_inputs',\n", + " '_delete_evaluation',\n", + " '_gather_all_children_metadata',\n", + " '_gather_all_children_options',\n", + " '_get_specific_table_values_from_renderers',\n", + " '_get_table_values_from_renderers',\n", + " '_get_unique_class_name',\n", + " '_is_name_used',\n", + " '_register_class_with_design',\n", + " 'add_dependency',\n", + " 'add_pin',\n", + " 'add_qgeometry',\n", + " 'class_name',\n", + " 'component_metadata',\n", + " 'connect_components_already_in_design',\n", + " 'default_options',\n", + " 'delete',\n", + " 'design',\n", + " 'get_pin',\n", + " 'get_template_options',\n", + " 'id',\n", + " 'logger',\n", + " 'make',\n", + " 'name',\n", + " 'options',\n", + " 'parse_options',\n", + " 'parse_value',\n", + " 'pin_names',\n", + " 'populate_to_track_table_usage',\n", + " 'qgeometry_bounds',\n", + " 'qgeometry_dict',\n", + " 'qgeometry_list',\n", + " 'qgeometry_plot',\n", + " 'qgeometry_table',\n", + " 'qgeometry_types',\n", + " 'rebuild',\n", + " 'to_script']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(QComponent)" + ] + }, + { + "cell_type": "markdown", + "id": "36486562", + "metadata": {}, + "source": [ + "## Component (logo) definition" + ] + }, + { + "cell_type": "markdown", + "id": "8b88ed4c", + "metadata": {}, + "source": [ + "In this section we define our logo. \n", + "USER MUST: INCLUDE PATH TO IMAGE FILE\n", + "USER CAN: adjust position of logo by adjusting offset values\n", + "USER CAN: adjust scale of logo by scale value" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0f424d61", + "metadata": {}, + "outputs": [], + "source": [ + "class MyQComponent(QComponent):\n", + " \"\"\"\n", + " Use this class as a template for your components - have fun\n", + "\n", + " Description:\n", + "\n", + " Options:\n", + " \"\"\"\n", + "\n", + " # Edit these to define your own tempate options for creation\n", + " # Default drawing options\n", + " default_options = Dict(width='500um',\n", + " height='300um',\n", + " pos_x='0um',\n", + " pos_y='0um',\n", + " orientation='0',\n", + " layer='1')\n", + " \"\"\"Default drawing options\"\"\"\n", + "\n", + " # Name prefix of component, if user doesn't provide name\n", + " component_metadata = Dict(short_name='component',\n", + " _qgeometry_table_poly='True')\n", + " \"\"\"Component metadata\"\"\"\n", + " \n", + " def make(self):\n", + " \"\"\"Convert self.options into QGeometry.\"\"\"\n", + " p = self.parse_options() # Parse the string options into numbers\n", + " # EDIT HERE - Replace the following with your code\n", + " \n", + " \n", + " \"\"\"User input here\"\"\"\n", + " #CODE FOR LOGO IMPORT MADE BY SIMON MAREK\n", + " with Image.open(\"logo2.jpg\") as im:\n", + " offsetx = 10 # HERE YOU CAN MOVE IMAGE\n", + " offsety = 3 # HERE YOU CAN MOVE IMAGE\n", + " scale = 0.125 # HERE YOU CAN CHANGE SCALE OF IMAGE\n", + " \n", + " \n", + " \"\"\"Image processing here\"\"\"\n", + " im=im.convert(\"1\")\n", + " im = im.transpose(Image.ROTATE_270)\n", + " numpydata = np.asarray(im)\n", + " \n", + " \n", + " \"\"\"Debugging here\"\"\"\n", + " print(im.height)\n", + " print(im.width)\n", + " #im.show()\n", + " #print (numpydata)\n", + " #print (numpydata[1][2])\n", + " \n", + " \"\"\"Image drawing here\"\"\"\n", + " fwidth=(im.width)-1\n", + " fheight=(im.height)\n", + " \n", + " logo = draw.rectangle((im.height-1)*scale,(im.width-1)*scale,(((im.height-1)/2)*scale)+offsetx,(((im.width-1)/2)*scale)+offsety)\n", + " for x in range(fheight):\n", + " for y in range(fwidth):\n", + " if False == (numpydata[x][y]):\n", + " logo1 = draw.rectangle(1*scale,1*scale,(x*scale)+offsetx+(0.5*scale),(y*scale)+offsety+(0.5*scale))\n", + " logo = draw.subtract(logo, logo1)\n", + " logo\n", + " geom = {'my_polygon': logo}\n", + " self.add_qgeometry('poly', geom, layer=p.layer, subtract=False)" + ] + }, + { + "cell_type": "markdown", + "id": "789d6d0c", + "metadata": {}, + "source": [ + "## Etch rectangle" + ] + }, + { + "cell_type": "markdown", + "id": "557e55da", + "metadata": {}, + "source": [ + "User might want to add etch rectangle around logo. Please substitute x,y,posx,posy by cordinates of your etch rectangle" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0c0cf3d7", + "metadata": {}, + "outputs": [], + "source": [ + " #etch=draw.rectangle(x,y,posx,posy) #Please substitute x,y,posx,posy by cordinates of your etch rectangle\n", + " #self.add_qgeometry('poly', dict(etch=etch), subtract=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4563807a", + "metadata": {}, + "outputs": [], + "source": [ + "design = metal.designs.DesignPlanar()\n", + "gui = metal.MetalGUI(design)" + ] + }, + { + "cell_type": "markdown", + "id": "26b310f5", + "metadata": {}, + "source": [ + "## Render to Qiskit Metal" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8454191c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:py.warnings:C:\\Users\\simon\\AppData\\Local\\Temp\\ipykernel_44632\\3132832583.py:41: DeprecationWarning: ROTATE_270 is deprecated and will be removed in Pillow 10 (2023-07-01). Use Transpose.ROTATE_270 instead.\n", + " im = im.transpose(Image.ROTATE_270)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "249\n", + "140\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:py.warnings:C:\\Users\\simon\\AppData\\Local\\Temp\\ipykernel_44632\\3132832583.py:41: DeprecationWarning: ROTATE_270 is deprecated and will be removed in Pillow 10 (2023-07-01). Use Transpose.ROTATE_270 instead.\n", + " im = im.transpose(Image.ROTATE_270)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "249\n", + "140\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 500 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "face = MyQComponent(design,'logo')\n", + "gui.rebuild()\n", + "gui.autoscale()\n", + "gui.screenshot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4fa68978", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SIMI_KERNEL", + "language": "python", + "name": "simi_kernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/README.md b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/README.md new file mode 100644 index 000000000..ab2924a6f --- /dev/null +++ b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/README.md @@ -0,0 +1,44 @@ + +# Qiskit Metal - Add Logo + +Import component to Qiskit Metal using Image + + +## Features + +- Scaling +- Moving along axies +- Automatic image converting to correct formats + + + + +## Demonstration + +#### Image to be imported to Qiskit +![App Screenshot](Images/Qiskit_4.png) + +#### Qiskit Metal Logo +![App Screenshot](Images/Qiskit.png) + +#### Qiskit Metal Logo 2 +![App Screenshot](Images/Qiskit2.png) + +#### Qiskit Metal Logo 2 - different etch profile +![App Screenshot](Images/Qiskit3.png) + + + + + +## Appendix + +Any additional information goes here + + +## Documentation + +[QMetal](https://qiskit.org/documentation/metal/) +[Pillow](https://pillow.readthedocs.io/en/stable/) + + diff --git a/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/download.png b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/download.png new file mode 100644 index 000000000..4a00ddd0f Binary files /dev/null and b/tutorials/5 Logo_from_img/Qiskit_Metal-Add_Logo/download.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit1.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit1.png new file mode 100644 index 000000000..cf6c4bb06 Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit1.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit2.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit2.png new file mode 100644 index 000000000..d9ab0eb57 Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit2.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit3.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit3.png new file mode 100644 index 000000000..ee764abe6 Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit3.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit4.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit4.png new file mode 100644 index 000000000..d2598ff9d Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit4.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit5.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit5.png new file mode 100644 index 000000000..356ef27ab Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit5.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit6.png b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit6.png new file mode 100644 index 000000000..9cbc479e1 Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/Images/qiskit6.png differ diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/LICENSE b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/PR_2_Qiskit_Qcomp_from_img.ipynb b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/PR_2_Qiskit_Qcomp_from_img.ipynb new file mode 100644 index 000000000..7ca3d9de9 --- /dev/null +++ b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/PR_2_Qiskit_Qcomp_from_img.ipynb @@ -0,0 +1,590 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "56cf03ac", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "markdown", + "id": "196ae3d1", + "metadata": {}, + "source": [ + "Package called PIL is used for image processing. Other packages are needed to run Qiskit Metal" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "1c7b3fa1", + "metadata": {}, + "outputs": [], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "from qiskit_metal import draw, Dict\n", + "from qiskit_metal.toolbox_metal import math_and_overrides\n", + "from qiskit_metal.qlibrary.core import QComponent\n", + "import qiskit_metal as metal" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c40be05d", + "metadata": {}, + "outputs": [], + "source": [ + "design = metal.designs.DesignPlanar()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f5ffe998", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['TOOLTIP',\n", + " '__class__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__eq__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__i_am_component__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_add_to_design',\n", + " '_check_pin_inputs',\n", + " '_delete_evaluation',\n", + " '_gather_all_children_metadata',\n", + " '_gather_all_children_options',\n", + " '_get_specific_table_values_from_renderers',\n", + " '_get_table_values_from_renderers',\n", + " '_get_unique_class_name',\n", + " '_is_name_used',\n", + " '_register_class_with_design',\n", + " 'add_dependency',\n", + " 'add_pin',\n", + " 'add_qgeometry',\n", + " 'class_name',\n", + " 'component_metadata',\n", + " 'connect_components_already_in_design',\n", + " 'default_options',\n", + " 'delete',\n", + " 'design',\n", + " 'get_pin',\n", + " 'get_template_options',\n", + " 'id',\n", + " 'logger',\n", + " 'make',\n", + " 'name',\n", + " 'options',\n", + " 'parse_options',\n", + " 'parse_value',\n", + " 'pin_names',\n", + " 'populate_to_track_table_usage',\n", + " 'qgeometry_bounds',\n", + " 'qgeometry_dict',\n", + " 'qgeometry_list',\n", + " 'qgeometry_plot',\n", + " 'qgeometry_table',\n", + " 'qgeometry_types',\n", + " 'rebuild',\n", + " 'to_script']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dir(QComponent)" + ] + }, + { + "cell_type": "markdown", + "id": "dd4679a9", + "metadata": {}, + "source": [ + "## Create your own component here " + ] + }, + { + "cell_type": "markdown", + "id": "fc4f68b2", + "metadata": {}, + "source": [ + "In this section We create our component. \n", + "User must paste link to the image in this section. Next set up etch rectangle and assign pins. \n", + "All the user inputs are commented. Please follow instructions what to add in commented sections in code: \"\"\"User input here\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "e75a2945", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'QComponent' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[1], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mclass\u001b[39;00m \u001b[38;5;21;01mMyQComponent\u001b[39;00m(\u001b[43mQComponent\u001b[49m):\n\u001b[0;32m 2\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;124;03m Use this class as a template for your components - have fun\u001b[39;00m\n\u001b[0;32m 4\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[38;5;124;03m Options:\u001b[39;00m\n\u001b[0;32m 8\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m 10\u001b[0m \u001b[38;5;66;03m# Edit these to define your own tempate options for creation\u001b[39;00m\n\u001b[0;32m 11\u001b[0m \u001b[38;5;66;03m# Default drawing options\u001b[39;00m\n", + "\u001b[1;31mNameError\u001b[0m: name 'QComponent' is not defined" + ] + } + ], + "source": [ + "class MyQComponent(QComponent):\n", + " \"\"\"\n", + " Use this class as a template for your components - have fun\n", + "\n", + " Description:\n", + "\n", + " Options:\n", + " \"\"\"\n", + "\n", + " # Edit these to define your own tempate options for creation\n", + " # Default drawing options\n", + " default_options = Dict(width='500um',\n", + " height='300um',\n", + " pos_x='0um',\n", + " pos_y='0um',\n", + " orientation='0',\n", + " layer='1')\n", + " \"\"\"Default drawing options\"\"\"\n", + "\n", + " # Name prefix of component, if user doesn't provide name\n", + " component_metadata = Dict(short_name='component',\n", + " _qgeometry_table_poly='True')\n", + " \"\"\"Component metadata\"\"\"\n", + " \n", + " def make(self):\n", + " \"\"\"Convert self.options into QGeometry.\"\"\"\n", + " p = self.parse_options() # Parse the string options into numbers\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \"\"\"User input here\"\"\"\n", + " \"\"\"ADD IMAGE HERE - path to your image\"\"\"\n", + " #EXAMPLE MADE BY SIMON MAREK :)\n", + " with Image.open(\"test31.jpg\") as im: #HERE copy name of image Assuming you have image file in same folder as this py file\n", + " \n", + " \"\"\"USER DEFINED STUFF HERE\"\"\"\n", + " #offsetx = 0 #Image movement\n", + " #offsety = 0 #Image movement\n", + " scale = 0.0625 #Scale of Image TO GET GOOD RESULTS SCALE ONLY IN this order (0.5; 0.25; 0.125; ...)\n", + " mode = True #modes True/False == ETCHING STYLES\n", + " \n", + " \n", + " \n", + " \"\"\"Do not touch\"\"\"\n", + " \"\"\"Some Image processing \"\"\"\n", + " im=im.convert(\"1\")\n", + " im = im.transpose(Image.ROTATE_270)\n", + " numpydata = np.asarray(im)\n", + " \n", + " \"\"\"For debugging \"\"\"\n", + " print(im.height)\n", + " print(im.width)\n", + " #im.show() #For debugging image = correct colours-black&white (should be rotated)\n", + " #print (numpydata) #For debugging binary array\n", + " #print (numpydata[1][2]) #For debugging binary array\n", + " \n", + " fwidth=(im.width)-1\n", + " fheight=(im.height)\n", + " \n", + " \"\"\"Image drawing \"\"\"\n", + " face = draw.rectangle((im.height-1)*scale,(im.width-1)*scale,((im.height-1)/2)*scale,((im.width-1)/2)*scale)\n", + " for x in range(fheight):\n", + " for y in range(fwidth):\n", + " if mode == (numpydata[x][y]):\n", + " #face1 = draw.rectangle(1*scale,1*scale,(x*scale)+\"\"\"offsetx\"\"\"+(0.5*scale),(y*scale)+\"\"\"offsety\"\"\"+(0.5*scale))\n", + " face1 = draw.rectangle(1*scale,1*scale,(x*scale)+(0.5*scale),(y*scale)+(0.5*scale))\n", + " face = draw.subtract(face, face1)\n", + " \n", + " face\n", + " geom = {'my_polygon': face}\n", + " self.add_qgeometry('poly', geom, layer=1, subtract=False)\n", + "\n", + " \n", + " \n", + " \n", + " \"\"\"User input here\"\"\"\n", + " \"\"\"Etch rectangle \"\"\"\n", + " #Etch rectangle\n", + " #etch=draw.rectangle(((im.width-1)*scale),((im.height-1)*scale),(((im.width-1)/2)*scale),(((im.height-1)/2)*scale))\n", + " etch=draw.rectangle(32.5,6,16.25,3)\n", + " self.add_qgeometry('poly', dict(etch=etch), subtract=True)\n", + "\n", + " \n", + " \n", + " \n", + " \"\"\"User input here\"\"\"\n", + " #Assign pins manually (if you are not sure how this works check out metal docs)\n", + " #You can check if you did it correctly in Qiskit Metal GUI later on\n", + " self.add_pin('p1', [(0, -48), (0,72)], (im.width*scale)) #HERE YOU NEED TO ASSIGN PIN we will call p1 (depends on your design)\n", + " self.add_pin('p2', [(130, 48),(130,-24)], (im.width*scale)) " + ] + }, + { + "cell_type": "markdown", + "id": "996f3900", + "metadata": {}, + "source": [ + "## Rendering into Qiskit Metal" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4563807a", + "metadata": {}, + "outputs": [], + "source": [ + "design = metal.designs.DesignPlanar()\n", + "gui = metal.MetalGUI(design)" + ] + }, + { + "cell_type": "markdown", + "id": "fb81641b", + "metadata": {}, + "source": [ + "## Assigning terminations to correct places" + ] + }, + { + "cell_type": "markdown", + "id": "597bc041", + "metadata": {}, + "source": [ + "User must assign correct terminations to component (used for sim in Ansys) " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8454191c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:py.warnings:C:\\Users\\simon\\AppData\\Local\\Temp\\ipykernel_51628\\1267855053.py:49: DeprecationWarning: ROTATE_270 is deprecated and will be removed in Pillow 10 (2023-07-01). Use Transpose.ROTATE_270 instead.\n", + " im = im.transpose(Image.ROTATE_270)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "521\n", + "96\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:py.warnings:C:\\Users\\simon\\AppData\\Local\\Temp\\ipykernel_51628\\1267855053.py:49: DeprecationWarning: ROTATE_270 is deprecated and will be removed in Pillow 10 (2023-07-01). Use Transpose.ROTATE_270 instead.\n", + " im = im.transpose(Image.ROTATE_270)\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "521\n", + "96\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "width": 500 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "from qiskit_metal.qlibrary.terminations.open_to_ground import OpenToGround\n", + "from qiskit_metal.qlibrary.terminations.short_to_ground import ShortToGround\n", + "\n", + "\n", + "\"\"\"User input here\"\"\"\n", + "#Assign correct location and width to the terminations manually\n", + "#You can check if you did it correctly in Qiskit Metal GUI later on\n", + "otg = OpenToGround(design, 'open_to_ground', options=dict(pos_x='32.49mm', pos_y='3mm', orientation='0',width='6mm')) #Need to assign to correct location (width is width of your trace)\n", + "stg = ShortToGround(design, 'short_to_ground', options=dict(pos_x='0mm', pos_y='3mm', orientation='180',width='6mm'))\n", + "\n", + "\n", + "\n", + "face = MyQComponent(design,'face',Dict(\n", + " pin_inputs=Dict(\n", + " start_pin=Dict(component='short_to_ground', pin='short'),\n", + " end_pin=Dict(component='open_to_ground', pin='open')), ))\n", + "gui.rebuild()\n", + "gui.autoscale()\n", + "gui.screenshot()" + ] + }, + { + "cell_type": "markdown", + "id": "12491792", + "metadata": {}, + "source": [ + "## EPR Analysis" + ] + }, + { + "cell_type": "markdown", + "id": "871dbbcb", + "metadata": {}, + "source": [ + "In this section we export your created QComponent to Ansys in order to perform simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4fa68978", + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit_metal.analyses.quantization import EPRanalysis\n", + "eig_res = EPRanalysis(design, \"hfss\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5f9a6c2e", + "metadata": {}, + "outputs": [], + "source": [ + "hfss = eig_res.sim.renderer" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "91079000", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 12:13PM [connect_project]: Connecting to Ansys Desktop API...\n", + "INFO 12:13PM [load_ansys_project]: \tOpened Ansys App\n", + "INFO 12:13PM [load_ansys_project]: \tOpened Ansys Desktop v2021.2.0\n", + "INFO 12:13PM [load_ansys_project]: \tOpened Ansys Project\n", + "\tFolder: C:/Users/simon/Documents/Ansoft/\n", + "\tProject: Project12\n", + "INFO 12:13PM [connect_design]: No active design found (or error getting active design).\n", + "INFO 12:13PM [connect]: \t Connected to project \"Project12\". No design detected\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hfss.start()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "617b4dad", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "12:13PM 01s WARNING [activate_ansys_design]: The design_name=Readout was not in active project. Designs in active project are: \n", + "[]. A new design will be added to the project. \n", + "INFO 12:13PM [connect_design]: \tOpened active design\n", + "\tDesign: Readout [Solution type: Eigenmode]\n", + "WARNING 12:13PM [connect_setup]: \tNo design setup detected.\n", + "WARNING 12:13PM [connect_setup]: \tCreating eigenmode default setup.\n", + "INFO 12:13PM [get_setup]: \tOpened setup `Setup` ()\n" + ] + } + ], + "source": [ + "hfss.activate_ansys_design(\"Readout\", 'eigenmode')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "84252e42", + "metadata": {}, + "outputs": [], + "source": [ + "hfss.render_design(['face'], [])\n", + "#hfss.save_screenshot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0aa4ac52", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO 12:13PM [analyze]: Analyzing setup Setup\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Number of eigenmodes to find = 1\n", + "Number of simulation passes = 20\n", + "Convergence freq max delta percent diff = 0.1\n", + "\n" + ] + } + ], + "source": [ + "setup = hfss.pinfo.setup\n", + "setup.passes = 20\n", + "print(f\"\"\"\n", + "Number of eigenmodes to find = {setup.n_modes}\n", + "Number of simulation passes = {setup.passes}\n", + "Convergence freq max delta percent diff = {setup.delta_f}\n", + "\"\"\")\n", + "\n", + "# Next 2 lines are counterinuitive, since there is no junction in this resonator.\n", + "# However, these are necessary to make pyEPR work correctly. Please do note delete\n", + "hfss.pinfo.design.set_variable('Lj', '10 nH')\n", + "hfss.pinfo.design.set_variable('Cj', '0 fF')\n", + "\n", + "setup.analyze()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "82ca74b1", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "12:23PM 28s INFO [get_f_convergence]: Saved convergences to C:\\Users\\simon\\Documents\\Python Scripts\\hfss_eig_f_convergence.csv\n" + ] + } + ], + "source": [ + "eig_res.sim.convergence_t, eig_res.sim.convergence_f, _ = hfss.get_convergences()\n", + "eig_res.sim.plot_convergences()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cc5fb690", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "12:23PM 30s WARNING [plot_ansys_fields]: This method is deprecated. Change your scripts to use plot_fields()\n", + "12:23PM 33s CRITICAL [_qt_message_handler]: line: 0, func: None(), file: None CRITICAL: QEventDispatcherWin32::wakeUp: Failed to post a message (Not enough quota is available to process this command.)\n", + "\n", + "12:23PM 33s CRITICAL [_qt_message_handler]: line: 0, func: None(), file: None CRITICAL: QEventDispatcherWin32::wakeUp: Failed to post a message (Not enough quota is available to process this command.)\n", + "\n" + ] + } + ], + "source": [ + "hfss.modeler._modeler.ShowWindow()\n", + "hfss.plot_ansys_fields('main')\n", + "#hfss.save_screenshot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SIMI_KERNEL", + "language": "python", + "name": "simi_kernel" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/README.md b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/README.md new file mode 100644 index 000000000..7933ac2bb --- /dev/null +++ b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/README.md @@ -0,0 +1,49 @@ + +# Qiskit Metal - Qlib creation + +Import component to Qiskit Metal using Image + + +## Features + +- Scaling +- Automatic image converting to correct formats +- Exporting to Ansys + + + + +## Demonstration + +#### WorkFlow +![App Screenshot](Images/qiskit1.png) + +#### Qiskit Metal +![App Screenshot](Images/qiskit2.png) + +#### Ansys +![App Screenshot](Images/qiskit3.png) + +#### Ansys Sim - EPR +![App Screenshot](Images/qiskit4.png) + +#### Simple Qiskit +![App Screenshot](Images/qiskit5.png) + +#### Simple Ansys +![App Screenshot](Images/qiskit6.png) + + + + +## Appendix + +Any additional information goes here + + +## Documentation + +[QMetal](https://qiskit.org/documentation/metal/) +[Pillow](https://pillow.readthedocs.io/en/stable/) + + diff --git a/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/test31.jpg b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/test31.jpg new file mode 100644 index 000000000..55cbf61e1 Binary files /dev/null and b/tutorials/6 Qcomponent_from_img/Qiskit_Metal-Qlib_from_Img/test31.jpg differ