emerge 0.5.6__tar.gz → 0.6.1__tar.gz

{emerge-0.5.6 → emerge-0.6.1}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.5.6"
+current_version = "0.6.1"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.5.6 → emerge-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.5.6
+Version: 0.6.1
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
@@ -64,7 +64,7 @@ import emerge as em
 def main():
     # setup simulation
 
-    model.mw.frequency_domain(True, ..., multi_processing=True)
+    model.mw.run_sweep(True, ..., multi_processing=True)
 
 if __name__ == "__main__":
     main()

{emerge-0.5.6 → emerge-0.6.1}/README.md

@@ -38,7 +38,7 @@ import emerge as em
 def main():
     # setup simulation
 
-    model.mw.frequency_domain(True, ..., multi_processing=True)
+    model.mw.run_sweep(True, ..., multi_processing=True)
 
 if __name__ == "__main__":
     main()

{emerge-0.5.6 → emerge-0.6.1}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.5.6"
+__version__ = "0.6.1"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -44,7 +44,7 @@ from loguru import logger
 LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
-from ._emerge.simmodel import Simulation3D
+from ._emerge.simmodel import Simulation
 from ._emerge.material import Material
 from ._emerge import bc
 from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/elements/nedleg2.py

@@ -28,13 +28,13 @@ from ..const import MU0, C0
 
 class FieldFunctionClass:
     """ This Class serves as a picklable class so that ModalPort boundary conditions
-    can actually be stored with the Simulation3D class. Functions aren't picklable in 
+    can actually be stored with the Simulation class. Functions aren't picklable in 
     Python. 
     
     I am not happy with the existence of this class, it feels too ad-hoc but for now it
     is the simplest way. It stores all actually required information needed to do a
     surface field interpolation without needing to store the Mesh3D and SurfaceMesh class
-    objects plus the NedelecLegrange2 classes with the Simulation3D. 
+    objects plus the NedelecLegrange2 classes with the Simulation. 
 
     As it stands currently, only the GMSH mesh is stored plus the geometry objects. The
     mesh is reconstructed as it is deterministic.

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/geo/__init__.py

@@ -18,7 +18,7 @@
 from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
-from .shapes import Cyllinder, CoaxCyllinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
+from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment
 from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect
 from .polybased import XYPolygon, GeoPrism
 from .step import STEPItems

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/geo/modeler.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 import numpy as np
 from typing import Callable, Iterable
-from .shapes import Box, Cyllinder, Alignment
+from .shapes import Box, Cylinder, Alignment
 from ..geometry import GeoVolume, GeoObject
 from .operations import rotate, mirror, translate, add, subtract, embed
 from numbers import Number
@@ -400,7 +400,7 @@ class Modeler:
                 if NPoly:
                     cyl = XYPolygon.circle(r, Nsections=NPoly).extrude(h, cs2)
                 else:
-                    cyl  = Cyllinder(r,h, cs2)
+                    cyl  = Cylinder(r,h, cs2)
                 cyls.append(cyl)
 
         self.ndimcont.set_copies(N)

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/geo/pcb.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
-from .shapes import Box, Plate, Cyllinder
+from .shapes import Box, Plate, Cylinder
 from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
@@ -1079,7 +1079,7 @@ class PCB:
         plane = change_coordinate_system(plane, self.cs) # type: ignore
         return plane # type: ignore
     
-    def gen_pcb(self, 
+    def generate_pcb(self, 
                 split_z: bool = True,
                 layer_tolerance: float = 1e-6,
                 merge: bool = True) -> GeoVolume:
@@ -1119,7 +1119,7 @@ class PCB:
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
-    def gen_air(self, height: float) -> GeoVolume:
+    def generate_air(self, height: float) -> GeoVolume:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
@@ -1247,14 +1247,14 @@ class PCB:
         plate = change_coordinate_system(plate, self.cs)
         return plate # type: ignore
 
-    def generate_vias(self, merge=False) -> list[Cyllinder] | Cyllinder:
+    def generate_vias(self, merge=False) -> list[Cylinder] | Cylinder:
         """Generates the via objects.
 
         Args:
             merge (bool, optional): Whether to merge the result into a final object. Defaults to False.
 
         Returns:
-            list[Cyllinder] | Cyllinder: Either al ist of cylllinders or a single one (merge=True)
+            list[Cylinder] | Cylinder: Either al ist of cylllinders or a single one (merge=True)
         """
         vias = []
         for via in self.vias:
@@ -1263,7 +1263,7 @@ class PCB:
             z0 = via.z1*self.unit
             xg, yg, zg = self.cs.in_global_cs(x0, y0, z0)
             cs = CoordinateSystem(self.cs.xax, self.cs.yax, self.cs.zax, np.array([xg, yg, zg]))
-            cyl = Cyllinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
+            cyl = Cylinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
             cyl.material = COPPER
             vias.append(cyl)
         if merge:

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/geo/shapes.py

@@ -172,26 +172,26 @@ class Plate(GeoSurface):
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
         super().__init__(tags)
 
-class Cyllinder(GeoVolume):
+class Cylinder(GeoVolume):
 
     def __init__(self, 
                  radius: float,
                  height: float,
                  cs: CoordinateSystem = None,
                  Nsections: int = None):
-        """Generates a Cyllinder object in 3D space.
+        """Generates a Cylinder object in 3D space.
         The cyllinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom cyllinder plane is always placed in the XY-plane. The lenth of the cyllinder is
         oriented along the Z-axis.
 
         By default the cyllinder uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -233,7 +233,7 @@ class Cyllinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
 
-class CoaxCyllinder(GeoVolume):
+class CoaxCylinder(GeoVolume):
     """A coaxial cylinder with an inner and outer radius."""
     
     def __init__(self, 
@@ -249,12 +249,12 @@ class CoaxCyllinder(GeoVolume):
 
         By default the coax uses the Open Cascade modeling for a cyllinder. In this representation
         the surface of the cyllinder is approximated with a tolerance thay may be irregular.
-        As an alternative, the argument Nsections may be provided in which case the Cyllinder is replaced
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
-            radius (float): The radius of the Cyllinder
-            height (float): The height of the Cyllinder
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
             cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
@@ -267,8 +267,8 @@ class CoaxCyllinder(GeoVolume):
         self.rin = rin
         self.height = height
 
-        self.cyl_out = Cyllinder(rout, height, cs, Nsections=Nsections)
-        self.cyl_in = Cyllinder(rin, height, cs, Nsections=Nsections)
+        self.cyl_out = Cylinder(rout, height, cs, Nsections=Nsections)
+        self.cyl_in = Cylinder(rin, height, cs, Nsections=Nsections)
         self.cyl_in._exists = False
         self.cyl_out._exists = False
         cyltags, _ = gmsh.model.occ.cut(self.cyl_out.dimtags, self.cyl_in.dimtags)

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/howto.py

@@ -27,11 +27,11 @@ class _HowtoClass:
         """
         To start a simulation simply create a model object through:
 
-        >>> model = emerge.Simulation3D('MyProjectName')
+        >>> model = emerge.Simulation('MyProjectName')
 
         Optionally, you can use a context manager for a more explicit handling of exiting the GMSH api and storing data after simulations.
 
-        >>> with emerge.Simulation3D('MyProjectName') as model:
+        >>> with emerge.Simulation('MyProjectName') as model:
 
         """
         pass
@@ -45,7 +45,7 @@ class _HowtoClass:
         >>> sphere = emerge.geo.Sphere(...)
         >>> pcb_layouter = emerge.geo.PCBLayout(...)
         >>> plate = emerge.geo.Plate(...)
-        >>> cyl = emerge.geo.Cyllinder(...)
+        >>> cyl = emerge.geo.Cylinder(...)
 
         After making geometries, you should pass all of them to
         the simulation object
@@ -77,7 +77,7 @@ class _HowtoClass:
         >>> face = cutout.face('front', tool=box)
         
         Exclusions or specific isolations can be added with optional arguments.
-        There is also a select object in your Simulation3D class that has various convenient selection options
+        There is also a select object in your Simulation class that has various convenient selection options
         >>> faces = model.select.face.inlayer()
         >>> faces = model.select.inplane()
         >>> faces = model.select.face.near(x,y,z)
@@ -99,15 +99,15 @@ class _HowtoClass:
 
         """
 
-    def run_frequency_domain(self):
+    def run_sweep(self):
         """
         You can run a frequency domain study by simply calling:\
         
-        >>> results = model.mw.frequency_domain(...)
+        >>> results = model.mw.run_sweep(...)
 
         You can distribute your frequency sweep across multiple threads using
         
-        >>> results = model.mw.frequency_domain(parallel=True, njobs=3)
+        >>> results = model.mw.run_sweep(parallel=True, njobs=3)
 
         The frequency domain study will return an MWSimData object that contains all data.
         """
@@ -154,7 +154,7 @@ class _HowtoClass:
     def save_and_load(self):
         """
         You can save your project data by setting save_file to True:
-        >>> model = emerge.Simulation3D(..., save_file=True)
+        >>> model = emerge.Simulation(..., save_file=True)
 
         Whenever you want, you can save all data by calling the .save() method
 
@@ -166,7 +166,7 @@ class _HowtoClass:
         
         You can load the data from a simulation using:
 
-        >>> model = emerge.Simulation3D(..., load_file=True)
+        >>> model = emerge.Simulation(..., load_file=True)
 
         The data from a simulation can be found in:
 

{emerge-0.5.6 → emerge-0.6.1}/emerge/_emerge/physics/microwave/microwave_3d.py

@@ -577,14 +577,14 @@ class Microwave3D:
         logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
         return None
     
-    def frequency_domain(self, 
-                         parallel: bool = False,
-                         njobs: int = 2, 
-                         harddisc_threshold: int | None = None,
-                         harddisc_path: str = 'EMergeSparse',
-                         frequency_groups: int = -1,
-                         multi_processing: bool = False,
-                         automatic_modal_analysis: bool = True) -> MWData:
+    def run_sweep(self, 
+                parallel: bool = False,
+                njobs: int = 2, 
+                harddisc_threshold: int | None = None,
+                harddisc_path: str = 'EMergeSparse',
+                frequency_groups: int = -1,
+                multi_processing: bool = False,
+                automatic_modal_analysis: bool = True) -> MWData:
         """Executes a frequency domain study
 
         The study is distributed over "njobs" workers.
@@ -1017,179 +1017,13 @@ class Microwave3D:
             mode_p = sparam_mode_power(self.mesh.nodes, tri_vertices, bc, k0, const, 5)
             return field_p, mode_p
 
-    # def frequency_domain_single(self, automatic_modal_analysis: bool = False) -> MWData:
-    #     """Execute a frequency domain study without distributed frequency sweep.
 
-    #     Args:
-    #         automatic_modal_analysis (bool, optional): Automatically compute port modes. Defaults to False.
+    ############################################################
+    #                     DEPRICATED FUNCTIONS                #
+    ############################################################
 
-    #     Raises:
-    #         SimulationError: _description_
-
-    #     Returns:
-    #         MWSimData: The Simulation data.
-    #     """
-    #     T0 = time.time()
-    #     mesh = self.mesh
-    #     if self.bc._initialized is False:
-    #         raise SimulationError('Cannot run a modal analysis because no boundary conditions have been assigned.')
-        
-    #     self._initialize_field()
-    #     self._initialize_bc_data()
-        
-    #     er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-    #     ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-    #     cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
-
-    #     ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-    #     urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-    #     condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
-
-    #     for itri in range(self.mesh.n_tris):
-    #         itet = self.mesh.tri_to_tet[0,itri]
-    #         ertri[:,:,itri] = er[:,:,itet]
-    #         urtri[:,:,itri] = ur[:,:,itet]
-    #         condtri[itri] = cond[itet]
-        
-    #     #### Port settings
-
-    #     all_ports = self.bc.oftype(PortBC)
-    #     port_numbers = [port.port_number for port in all_ports]
-
-    #     ##### FOR PORT SWEEP SET ALL ACTIVE TO FALSE. THIS SHOULD BE FIXED LATER
-    #     ### COMPUTE WHICH TETS ARE CONNECTED TO PORT INDICES
-
-    #     all_port_tets = []
-    #     for port in all_ports:
-    #         port.active=False
-            
-    #     all_port_tets = mesh.get_face_tets(*[port.tags for port in all_ports])
-        
-
-    #     logger.debug(f'Starting the simulation of {len(self.frequencies)} frequency points.')
-
-    #     # ITERATE OVER FREQUENCIES
-    #     for freq in self.frequencies:
-    #         logger.info(f'Simulation frequency = {freq/1e9:.3f} GHz') 
-            
-    #         # Assembling matrix problem
-    #         if automatic_modal_analysis:
-    #             self._compute_modes(freq)
-            
-    #         job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, self.bc.boundary_conditions, freq, cache_matrices=self.cache_matrices)
-
-    #         logger.debug(f'Routine: {self.solveroutine}')
-
-    #         for A, b, ids, reuse in job.iter_Ab():
-    #             solution, report = self.solveroutine.solve(A, b, ids, reuse)
-    #             job.submit_solution(solution, report)
-
-    #         self.data.setreport(job.reports, freq=freq, **self._params)
-
-    #         k0 = 2*np.pi*freq/299792458
-
-    #         scalardata = self.data.scalar.new(freq=freq, **self._params)
-    #         scalardata.init_sp(port_numbers)
-    #         scalardata.freq = freq
-    #         scalardata.k0 = k0
-
-    #         fielddata = self.data.field.new(freq=freq, **self._params)
-    #         fielddata.freq = freq
-    #         fielddata.er = np.squeeze(er[0,0,:])
-    #         fielddata.ur = np.squeeze(ur[0,0,:])
-
-    #         # Recording port information
-    #         for i, port in enumerate(all_ports):
-    #             fielddata.add_port_properties(port.port_number,
-    #                                      mode_number=port.mode_number,
-    #                                      k0 = k0,
-    #                                      beta = port.get_beta(k0),
-    #                                      Z0 = port.portZ0(k0),
-    #                                      Pout= port.power)
-            
-    #         for active_port in all_ports:
-                
-    #             active_port.active = True
-    #             solution = job._fields[active_port.port_number]
-
-    #             fielddata._fields[active_port.port_number] = solution # TODO: THIS IS VERY FRAIL
-    #             fielddata.basis = self.basis
-
-    #             # Compute the S-parameters
-    #             # Define the field interpolation function
-    #             fieldf = self.basis.interpolate_Ef(solution, tetids=all_port_tets)
-
-    #             # Active port power
-    #             logger.debug('Active ports:')
-    #             tris = mesh.get_triangles(active_port.tags)
-    #             tri_vertices = mesh.tris[:,tris]
-    #             pfield, pmode = self._compute_s_data(active_port, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #             logger.debug(f'Field Amplitude = {np.abs(pfield):.3f}, Excitation = {np.abs(pmode):.2f}')
-    #             Pout = pmode
-                
-    #             #Passive ports
-    #             logger.debug('Passive ports:')
-    #             for bc in all_ports:
-    #                 tris = mesh.get_triangles(bc.tags)
-    #                 tri_vertices = mesh.tris[:,tris]
-    #                 pfield, pmode = self._compute_s_data(bc, fieldf, tri_vertices, k0, ertri[:,:,tris], urtri[:,:,tris])
-    #                 logger.debug(f'Field amplitude = {np.abs(pfield):.3f}, Excitation= {np.abs(pmode):.2f}')
-    #                 scalardata.write_S(bc.port_number, active_port.port_number, pfield/Pout)
-
-    #             active_port.active=False
-            
-    #         fielddata.set_field_vector()
-
-    #     logger.info('Simulation Complete!')
-    #     T2 = time.time()    
-    #     logger.info(f'Elapsed time = {(T2-T0):.2f} seconds.')
-    #     return self.data
-## DEPRICATED
-
-
-
-    # 
-    # def eigenmode(self, mesh: Mesh3D, solver = None, num_sols: int = 6):
-    #     if solver is None:
-    #         logger.info('Defaulting to BiCGStab.')
-    #         solver = sparse.linalg.eigs
-
-    #     if self.order == 1:
-    #         logger.info('Detected 1st order elements.')
-    #         from ...elements.nedelec1.assembly import assemble_eig_matrix
-    #         ft = FieldType.VEC_LIN
-
-    #     elif self.order == 2:
-    #         logger.info('Detected 2nd order elements.')
-    #         from ...elements.nedelec2.assembly import assemble_eig_matrix_E
-    #         ft = FieldType.VEC_QUAD
-        
-    #     er = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fer3d(x,y,z))
-    #     ur = self.mesh.retreive(mesh.centers, lambda mat,x,y,z: mat.fur3d(x,y,z))
-        
-    #     dataset = Dataset3D(mesh, self.frequencies, 0, ft)
-    #     dataset.er = er
-    #     dataset.ur = ur
-    #     logger.info('Solving eigenmodes.')
-        
-    #     f_target = self.frequencies[0]
-    #     sigma = (2 * np.pi * f_target / 299792458)**2
-
-    #     A, B, solvenodes = assemble_eig_matrix(mesh, er, ur, self.boundary_conditions)
-        
-    #     A = A[np.ix_(solvenodes, solvenodes)]
-    #     B = B[np.ix_(solvenodes, solvenodes)]
-    #     #A = sparse.csc_matrix(A)
-    #     #B = sparse.csc_matrix(B)
-        
-    #     w, v = sparse.linalg.eigs(A, k=num_sols, M=B, sigma=sigma, which='LM')
-        
-    #     logger.info(f'Eigenvalues: {np.sqrt(w)*299792458/(2*np.pi) * 1e-9} GHz')
-
-    #     Esol = np.zeros((num_sols, mesh.nfield), dtype=np.complex128)
-
-    #     Esol[:, solvenodes] = v.T
-        
-    #     dataset.set_efield(Esol)
-
-    #     self.basis = dataset
+    def frequency_domain(self, *args, **kwargs):
+        """DEPRICATED VERSION: Use run_sweep() instead.
+        """
+        logger.warning('This function is depricated. Please use run_sweep() instead')
+        self.run_sweep(*args, **kwargs)