diff --git a/doc/source/User_guide/emit_modeler.rst b/doc/source/User_guide/emit_modeler.rst new file mode 100644 index 00000000000..a0365181733 --- /dev/null +++ b/doc/source/User_guide/emit_modeler.rst @@ -0,0 +1,156 @@ +EMIT modeler +============ +The ``EMIT Modeling`` module includes several classes to enable +modeling in EMIT: + + +* ``modeler`` to return the schematic modeler for an EMIT design. +* ``couplings`` to return a list of all linked couplings within an EMIT design. +* ``version`` to provide the EMIT version information. +* ``set_units`` to set the units globally for the EMIT design. +* ``get_units`` to get the value of the current EMIT design global units. + +EMIT version check and set units example: + +.. code:: python + + import pyaedt + from pyaedt import Emit + + emit = Emit(pyaedt.generate_unique_project_name(), + specified_version="2024.1", non_graphical=False, + new_desktop_session=True, close_on_exit=True) + + # This call returns detailed version info for EMIT + ver = emit.version(detailed=True) + + # This call sets the global units for EMIT + unit_types = ["Power", "Frequency", "Length", "Time"] + unit_vals = ["kW", "kHz", "meter", "ns"] + emit.set_units(unit_types, unit_vals) + + # This call gets all the global units for the EMIT design + all_units = emit.get_units() + + # This call gets the global Frequency units for the EMIT design + freq_units = emit.get_units("Frequency") + + # Close AEDT + emit.release_desktop(close_projects=True, close_desktop=True) + +EMIT-HFSS link creation example: + +.. code:: python + + import os + import pyaedt + from pyaedt import Emit + from pyaedt.generic.filesystem import Scratch + + scratch_path = pyaedt.generate_unique_folder_name() + temp_folder = os.path.join(scratch_path, ("EmitHFSSExample")) + if not os.path.exists(temp_folder): + os.mkdir(temp_folder) + + # Launch AEDT + aedtapp = pyaedt.launch_desktop(specified_version="2024.1", non_graphical=False, + new_desktop_session=True, close_on_exit=True) + + # Verify the ``Cell Phone RFT Defense`` example exists + example_name = "Cell Phone RFI Desense" + example_aedt = example_name + ".aedt" + example_results = example_name + ".aedtresults" + example_lock = example_aedt + ".lock" + example_pdf_file = example_name + " Example.pdf" + + example_dir = os.path.join(aedtapp.install_path, "Examples\\EMIT") + example_project = os.path.join(example_dir, example_aedt) + example_results_folder = os.path.join(example_dir, example_results) + example_pdf = os.path.join(example_dir, example_pdf_file) + + # If the ``Cell Phone RFT Defense`` example is not + # in the installation directory, exit from this example. + if not os.path.exists(example_project): + exit() + + # Copy the project to a temp directory + my_project = os.path.join(temp_folder, example_aedt) + my_results_folder = os.path.join(temp_folder, example_results) + my_project_lock = os.path.join(temp_folder, example_lock) + my_project_pdf = os.path.join(temp_folder, example_pdf_file) + + if os.path.exists(my_project): + os.remove(my_project) + + if os.path.exists(my_project_lock): + os.remove(my_project_lock) + + with Scratch(scratch_path) as local_scratch: + local_scratch.copyfile(example_project, my_project) + local_scratch.copyfolder(example_results_folder, my_results_folder) + if os.path.exists(example_pdf): + local_scratch.copyfile(example_pdf, my_project_pdf) + + emit = Emit(my_project) + + # Remove all existing links + for link in emit.couplings.coupling_names: + emit.couplings.delete_link(link) + + # Add the HFSS design as a coupling in EMIT + for link in emit.couplings.linkable_design_names: + emit.couplings.add_link(link) + + # Get all the antennas in the EMIT design + antennas = emit.couplings.antenna_nodes + for ant in antennas: + print(ant) + + # Close AEDT + emit.release_desktop(close_projects=True, close_desktop=True) + +Create and Analyze an EMIT project: + +.. code:: python + + import pyaedt + from pyaedt import Emit + from pyaedt.emit_core.emit_constants import TxRxMode, ResultType + + emit = Emit(pyaedt.generate_unique_project_name(), + specified_version="2024.1", non_graphical=False, + new_desktop_session=True, close_on_exit=True) + + # Create a radio and connect an antenna to it + rad1 = emit.modeler.components.create_component("New Radio") + ant1 = emit.modeler.components.create_component("Antenna") + if rad1 and ant1: + ant1.move_and_connect_to(rad1) + + # Quickly create 2 more radios with antennas automatically + # connected to them + rad2, ant2 = emit.modeler.components.create_radio_antenna("GPS Receiver") + rad3, ant3 = emit.modeler.components.create_radio_antenna("Bluetooth Low Energy (LE)", "Bluetooth") + + # Create a new ``Revision`` + rev = emit.results.analyze() + + # Get the receive bands enabled for the GPS Rx + rx_bands = rev.get_band_names(rad2.name, TxRxMode.RX) + + # Get the transmit bands enabled for the Bluetooth radio + tx_bands = rev.get_band_names(rad3.name, TxRxMode.TX) + + # Configure the interaction domain that will be analyzed + domain = emit.results.interaction_domain() + domain.set_receiver(rad2.name, rx_bands[0], -1) + domain.set_interferer(rad3.name,tx_bands[0]) + + # Analzye the domain and get the worst case interference + interaction = rev.run(domain) + worst = interaction.get_worst_instance(ResultType.EMI) + emi = worst.get_value(ResultType.EMI) + print("Worst case interference is: {} dB".format(emi)) + + # Close AEDT + emit.release_desktop(close_projects=True, close_desktop=True) \ No newline at end of file diff --git a/doc/source/User_guide/index.rst b/doc/source/User_guide/index.rst index 14b7e795d3a..677cccca066 100644 --- a/doc/source/User_guide/index.rst +++ b/doc/source/User_guide/index.rst @@ -61,6 +61,13 @@ For additional practical demonstrations, see How to generate reports, images, and PDF files. + .. grid-item-card:: EMIT Modeler + :link: emit_modeler + :link-type: doc + :margin: 2 2 0 0 + + How to create and analyze EMIT designs. + .. toctree:: :hidden: :maxdepth: 2 @@ -72,3 +79,4 @@ For additional practical demonstrations, see variables files postprocessing + emit_modeler diff --git a/examples/07-EMIT/EMIT_HFSS_Example.py b/examples/07-EMIT/EMIT_HFSS_Example.py index cb0745f1c36..e33ebfc1e66 100644 --- a/examples/07-EMIT/EMIT_HFSS_Example.py +++ b/examples/07-EMIT/EMIT_HFSS_Example.py @@ -117,7 +117,7 @@ ############################################################################### # Run EMIT simulation # ~~~~~~~~~~~~~~~~~~~ -# Run the EMIT simulation. This portion of the EMIT API is not yet implemented. +# Run the EMIT simulation. # # This part of the example requires Ansys AEDT 2023 R2. diff --git a/pyaedt/emit.py b/pyaedt/emit.py index b5c5d552857..f216a9b4081 100644 --- a/pyaedt/emit.py +++ b/pyaedt/emit.py @@ -85,16 +85,16 @@ class Emit(Design, object): Once the schematic is generated, the ``Emit`` object can be analyzed to generate a revision. Each revision is added as an element of the ``Emit`` object member's - revisions_list. + ``Results.revisions`` list. - >>> aedtapp.analyze() + >>> revision = aedtapp.results.analyze() A revision within PyAEDT is analogous to a revision in AEDT. An interaction domain must be defined and then used as the input to the run command used on that revision. - >>> domain = aedtapp.interaction_domain() + >>> domain = aedtapp.results.interaction_domain() >>> domain.rx_radio_name = "UE - HandHeld" - >>> interaction = aedtapp.revisions_list[0].run(domain) + >>> interaction = revision.run(domain) The output of the run command is an ``interaction`` object. This object summarizes the interaction data that is defined in the interaction domain. @@ -215,7 +215,7 @@ def version(self, detailed=False): @pyaedt_function_handler() def set_units(self, unit_type, unit_value): - """Set units for the component. + """Set units for the EMIT design. Parameters ---------- @@ -277,7 +277,7 @@ def set_units(self, unit_type, unit_value): @pyaedt_function_handler() def get_units(self, unit_type=""): - """Get units for the component. + """Get units for the EMIT design. Parameters ---------- diff --git a/pyaedt/emit_core/results/revision.py b/pyaedt/emit_core/results/revision.py index 309de2105f6..8dd53fc2444 100644 --- a/pyaedt/emit_core/results/revision.py +++ b/pyaedt/emit_core/results/revision.py @@ -497,9 +497,7 @@ def interference_type_classification(self, domain, use_filter=False, filter_list # should just be skipped continue else: - tx_prob = ( - instance.get_largest_problem_type(ResultType.EMI).replace(" ", "").split(":")[1] - ) + tx_prob = instance.get_largest_emi_problem_type().replace(" ", "").split(":")[1] power = instance.get_value(ResultType.EMI) if ( rx_start_freq - rx_channel_bandwidth / 2 @@ -521,7 +519,7 @@ def interference_type_classification(self, domain, use_filter=False, filter_list if power > max_power and in_filters: max_power = power largest_rx_prob = rx_prob - prob = instance.get_largest_problem_type(ResultType.EMI) + prob = instance.get_largest_emi_problem_type() largest_tx_prob = prob.replace(" ", "").split(":") if max_power > -200: