emerge 0.6.11__py3-none-any.whl → 1.0.1__py3-none-any.whl

emerge/_emerge/simmodel.py

@@ -26,7 +26,9 @@ from .logsettings import LOG_CONTROLLER
 from .plot.pyvista import PVDisplay
 from .dataset import SimulationDataset
 from .periodic import PeriodicCell
-from .bc import BoundaryCondition
+from .cacherun import get_build_section, get_run_section
+from .settings import DEFAULT_SETTINGS, Settings
+from .solver import EMSolver, Solver
 from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
@@ -94,21 +96,26 @@ class Simulation:
         
         self.mesh: Mesh3D = Mesh3D(self.mesher)
         self.select: Selector = Selector()
+        
+        self.settings: Settings = DEFAULT_SETTINGS
 
+        ## Display
+        self.display: PVDisplay = PVDisplay(self.mesh)
+        
+        ## Dataset
+        self.data: SimulationDataset = SimulationDataset()
+        
         ## STATES
         self.__active: bool = False
         self._defined_geometries: bool = False
         self._cell: PeriodicCell | None = None
-
-        self.display: PVDisplay = PVDisplay(self.mesh)
-
         self.save_file: bool = save_file
         self.load_file: bool = load_file
-
-        self.data: SimulationDataset = SimulationDataset()
-
+        self._cache_run: bool = False
+        self._file_lines: str = ''
+        
         ## Physics
-        self.mw: Microwave3D = Microwave3D(self.mesher, self.data.mw)
+        self.mw: Microwave3D = Microwave3D(self.mesher, self.settings, self.data.mw)
 
         self._initialize_simulation()
 
@@ -216,14 +223,6 @@ class Simulation:
     def _update_data(self) -> None:
         """Writes the stored physics data to each phyics class insatnce"""
         self.mw.data = self.data.mw
-
-    def all_geometries(self) -> list[GeoObject]:
-        """Returns all geometries stored in the simulation file."""
-        return [obj for obj in self.data.sim.default.values() if isinstance(obj, GeoObject)]
-    
-    def all_bcs(self) -> list[BoundaryCondition]:
-        """Returns all boundary condition objects stored in the simulation file"""
-        return [obj for obj in self.data.sim.default.values() if isinstance(obj, BoundaryCondition)]
     
     def _set_mesh(self, mesh: Mesh3D) -> None:
         """Set the current model mesh to a given mesh."""
@@ -235,34 +234,141 @@ class Simulation:
     #                       PUBLIC FUNCTIONS                  #
     ############################################################
 
-    def check_version(self, version: str) -> None:
-        """Compares the provided version number with the version number of EMerge that is running the script.
+    def cache_build(self) -> bool:
+        """Checks if all the lines inside this if statement block are the same as those
+        stored from a previous run. If so, then it returns false. Else it returns True.
         
-        You may remove any call to check_version to suppress VersionErrors and warnings.
+        Can be used to capture an entire model simulation.
         
-        Args:
-            version (str): The EMerge version you intend to write this code for.
+        Example:
+        
+        >>> if model.cache_build():
+        >>>     box = em.geo.Box(...)
+        >>>     # Other lines
+        >>>     model.mw.run_sweep()
+        >>> data = model.data.mw
 
-        Raises:
-            VersionError: A potential version error if incompatibility is possible
+        Returns:
+            bool: If the code is not the same
+        """
+        
+        self.save_file = True
+        self._cache_run = True
+        filestr = get_build_section()
+        self._file_lines = filestr
+        cachepath = self.modelpath / 'pylines.txt'
+        
+        # If there is not pylines file, simulate (can't have been run).
+        if not cachepath.exists():
+            logger.info('No cached data detected, running file')
+            return True
+        
+        with open(cachepath, 'r') as file:
+            lines = file.read()
+        
+        if lines==filestr:
+            logger.info('Cached data detected! Loading data!')
+            self.load()
+            return False
+        logger.info('Different cached data detected, rebuilding file.')
+        return True
+    
+    def cache_run(self) -> bool:
+        """Checks if all the lines before this call are the same as the lines
+        stored from a previous run. If so, then it returns false. Else it returns True.
+        
+        Can be used to capture a run_sweep() call.
+        
+        Example:
+        
+        >>> if model.cache_run():
+        >>>     model.mw.run_sweep()
+        >>> data = model.data.mw
+
+        Returns:
+            bool: If the code is not the same
+        """
+        self.save_file = True
+        self._cache_run = True
+        filestr = get_run_section()
+        self._file_lines = filestr
+        cachepath = self.modelpath / 'pylines.txt'
+        
+        # If there is not pylines file, simulate (can't have been run).
+        if not cachepath.exists():
+            logger.info('No cached data detected, running simulation!')
+            return True
+        
+        with open(cachepath, 'r') as file:
+            lines = file.read()
+        
+        if lines==filestr:
+            logger.info('Cached data detected! Loading data!')
+            self.load()
+            return False
+        logger.info('Different cached data detected, rerunning simulation.')
+        return True
+    
+    def check_version(self, target_version: str, *, log: bool = False) -> None:
+        """
+        Ensure the script targets an EMerge version compatible with the current runtime.
+
+        Parameters
+        ----------
+        target_version : str
+            The EMerge version this script was written for (e.g. "1.4.0").
+        log : bool, optional
+            If True and a `logger` is available, emit a single WARNING with the same
+            message as the exception. Defaults to False.
+
+        Raises
+        ------
+        VersionError
+            If the script's target version differs from the running EMerge version.
         """
-        vM, vm, vp = [float(x) for x in version.split('.')]
-        cM, cm, cp = [float(x) for x in __version__.split('.')]
-        if vM != cM:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
-        if vm != cm:
-            raise VersionError(f"You are running a script designed for version {version} with a possibly incompatible version of EMerge {__version__}. \n You can upgrade your version of emerge with: pip --upgrade emerge")
-        if vp != cp:
-            logger.warning("You are running a script designed for a different version of EMerge.")
-            logger.warning(f"The script version: {version}")
-            logger.warning(f"EMerge version:     {__version__}")
-            logger.warning("Usually EMerge works without a problem but Errors may occur.")
-            logger.warning("You can upgrade your version of emerge with: pip --upgrade emerge")
-            logger.warning("You may suppress this error by removing the call to .check_version().")
-            logger.warning("Press Ctrl+C to abort.")
-            ans = input('Press enter to proceed or [Q] to quit:')
-            if ans.lower().strip()=='q':
-                quit()
+        try:
+            from packaging.version import Version as _V
+            v_script = _V(target_version)
+            v_runtime = _V(__version__)
+            newer = v_script > v_runtime
+            older = v_script < v_runtime
+        except Exception:
+            def _parse(v: str):
+                try:
+                    return tuple(int(p) for p in v.split("."))
+                except Exception:
+                    # Last-resort: compare as strings to avoid crashing the check itself
+                    return tuple(v.split("."))
+            v_script = _parse(target_version)
+            v_runtime = _parse(__version__)
+            newer = v_script > v_runtime
+            older = v_script < v_runtime
+
+        if not newer and not older:
+            return  # exact match
+
+        if newer:
+            msg = (
+                f"Script targets EMerge {target_version}, but runtime is {__version__}. "
+                "The script may rely on features added after your installed version. "
+                "Recommended: upgrade EMerge (`pip install --upgrade emerge`). "
+                "If you know the script is compatible, you may remove this check."
+            )
+        else:  # older
+            msg = (
+                f"Script targets EMerge {target_version}, but runtime is {__version__}. "
+                "APIs may have changed since the targeted version. "
+                "Recommended: update the script for the current EMerge, or run a matching older release. "
+                "If you know the script is compatible, you may remove this check."
+            )
+
+        if log:
+            try:
+                logger.warning(msg)
+            except Exception:
+                pass
+
+        raise VersionError(msg)
 
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
@@ -289,6 +395,12 @@ class Simulation:
         data_path = self.modelpath / 'simdata.emerge'
         with open(str(data_path), "wb") as f_out:
             cloudpickle.dump(dataset, f_out)
+            
+        if self._cache_run:
+            cachepath = self.modelpath / 'pylines.txt'
+            with open(str(cachepath), 'w') as f_out:
+                f_out.write(self._file_lines)
+            
         logger.info(f"Saved simulation data to: {data_path}")
 
     def load(self) -> None:
@@ -334,7 +446,8 @@ class Simulation:
              use_gmsh: bool = False,
              plot_mesh: bool = False,
              volume_mesh: bool = True,
-             opacity: float | None = None) -> None:
+             opacity: float | None = None,
+             labels: bool = False) -> None:
         """View the current geometry in either the BaseDisplay object (PVDisplay only) or
         the GMSH viewer.
 
@@ -344,21 +457,21 @@ class Simulation:
             plot_mesh (bool, optional): If the mesh should be plot instead of the object. Defaults to False.
             volume_mesh (bool, optional): If the internal mesh should be plot instead of only the surface boundary mesh. Defaults to True
             opacity (float | None, optional): The object/mesh opacity. Defaults to None.
-
+            labels: (bool, optional): If geometry name labels should be shown. Defaults to False.
         """
         if not (self.display is not None and self.mesh.defined) or use_gmsh:
             gmsh.model.occ.synchronize()
             gmsh.fltk.run()
             return
         for geo in _GEOMANAGER.all_geometries():
-            self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh)
+            self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh, label=labels)
         if selections:
-            [self.display.add_object(sel, color='red', opacity=0.3) for sel in selections]
+            [self.display.add_object(sel, color='red', opacity=0.3, label=labels) for sel in selections]
         self.display.show()
 
         return None
         
-    def set_periodic_cell(self, cell: PeriodicCell, excluded_faces: list[FaceSelection] | None = None):
+    def set_periodic_cell(self, cell: PeriodicCell, included_faces: FaceSelection | None = None):
         """Set the given periodic cell object as the simulations peridicity.
 
         Args:
@@ -367,6 +480,7 @@ class Simulation:
         """
         self.mw.bc._cell = cell
         self._cell = cell
+        self._cell.included_faces = included_faces
 
     def commit_geometry(self, *geometries: GeoObject | list[GeoObject]) -> None:
         """Finalizes and locks the current geometry state of the simulation.
@@ -380,11 +494,19 @@ class Simulation:
         else:
             geometries_parsed = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
         
-        self.data.sim['geometries'] = geometries_parsed
+        self.data.sim['geos'] = {geo.name: geo for geo in geometries_parsed}
         self.mesher.submit_objects(geometries_parsed)
         self._defined_geometries = True
         self.display._facetags = [dt[1] for dt in gmsh.model.get_entities(2)]
-          
+    
+    def all_geos(self) -> list[GeoObject]:
+        """Returns all geometries in a list
+
+        Returns:
+            list[GeoObject]: A list of all GeoObjects
+        """
+        return _GEOMANAGER.all_geometries()  
+    
     def generate_mesh(self) -> None:
         """Generate the mesh. 
         This can only be done after commit_geometry(...) is called and if frequencies are defined.
@@ -402,7 +524,7 @@ class Simulation:
         if self._cell is not None:
             self.mesher.set_periodic_cell(self._cell)
             
-        self.mw._initialize_bcs()
+        self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
 
         # Check if frequencies are defined: TODO: Replace with a more generic check
         if self.mw.frequencies is None:
@@ -424,9 +546,11 @@ class Simulation:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)
             raise
+        
         self.mesh.update(self.mesher._get_periodic_bcs())
         self.mesh.exterior_face_tags = self.mesher.domain_boundary_face_tags
         gmsh.model.occ.synchronize()
+        
         self._set_mesh(self.mesh)
 
     def parameter_sweep(self, clear_mesh: bool = True, **parameters: np.ndarray) -> Generator[tuple[float,...], None, None]:
@@ -490,6 +614,16 @@ class Simulation:
             filename (str): The filename
         """
         gmsh.write(filename)
+        
+    def set_solver(self, solver: EMSolver | Solver):
+        """Set a given Solver class instance as the main solver. 
+        Solvers will be checked on validity for the given problem.
+
+        Args:
+            solver (EMSolver | Solver): The solver objects
+        """
+        self.mw.solveroutine.set_solver(solver)
+        
     ############################################################
     #                     DEPRICATED FUNCTIONS                #
     ############################################################

emerge/_emerge/solver.py

@@ -15,8 +15,8 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-
 from __future__ import annotations
+
 from scipy.sparse import csr_matrix # type: ignore
 from scipy.sparse.csgraph import reverse_cuthill_mckee # type: ignore
 from scipy.sparse.linalg import bicgstab, gmres, gcrotmk, eigs, splu # type: ignore
@@ -286,6 +286,7 @@ class Solver:
     """
     real_only: bool = False
     req_sorter: bool = False
+    released_gil: bool = False
 
     def __init__(self):
         self.own_preconditioner: bool = False
@@ -479,7 +480,8 @@ class SolverSuperLU(Solver):
     """ Implements Scipi's direct SuperLU solver."""
     req_sorter: bool = False
     real_only: bool = False
-    
+    released_gil: bool = True
+
     def __init__(self):
         super().__init__()
         self.atol = 1e-5
@@ -502,6 +504,7 @@ class SolverSuperLU(Solver):
     
     def solve(self, A, b, precon, reuse_factorization: bool = False, id: int = -1) -> tuple[np.ndarray, SolveReport]:
         logger.info(f'[ID={id}] Calling SuperLU Solver.')
+
         self.single = True
         if not reuse_factorization:
             logger.trace('Computing LU-Decomposition')
@@ -903,6 +906,10 @@ class SolveRoutine:
             bool: If the solver is legal
         """
         if any(isinstance(solver, solvertype) for solvertype in self.disabled_solver):
+            logger.warning(f'The selected solver {solver} cannot be used as it is disabled.')
+            return False
+        if self.parallel=='MT' and not solver.released_gil:
+            logger.warning(f'The selected solver {solver} cannot be used in MultiThreading as it does not release the GIL')
             return False
         return True
     

emerge/beta/dxf.py

@@ -0,0 +1 @@
+from .._emerge.geo.pcb_tools.dxf import import_dxf

emerge/lib.py

@@ -12,8 +12,10 @@
 ║  Verify critical values independently before use.                    ║
 ╚══════════════════════════════════════════════════════════════════════╝
 """
-from ._emerge.material import Material, AIR, COPPER
+from ._emerge.material import Material, AIR, COPPER, PEC
 from ._emerge.const import C0, Z0, PI, EPS0, MU0
+from .materials import isola
+from .materials import rogers
 
 EISO: float = (Z0/(2*PI))**0.5
 EOMNI = (3*Z0/(4*PI))**0.5
@@ -280,6 +282,7 @@ DIEL_XT_Duroid_8100              = Material(er=3.54, tand=0.0049, color="#21912b
 DIEL_XT_Duroid_81000_004IN_Thick = Material(er=3.32, tand=0.0038, color="#21912b", opacity=0.3, name="Rogers XT/duroid 81000 0.004in")
 DIEL_TEFLON = Material(er=2.1, tand=0.0003, color='#eeeeee', opacity=0.3, name="Teflon")
 
+DIEL_IS420_approx   = Material(er=4.5, tand=0.018, color="#CCDE30", opacity=0.3, name="ISOLA420 approximate")
 
 # Legacy FR Materials
 DIEL_FR1 = Material(er=4.8,  tand=0.025, color="#3c9747", opacity=0.3, name="FR-1 (Paper Phenolic)")

emerge/materials/__init__.py

@@ -0,0 +1 @@
+from . import isola