gsim 0.0.0__py3-none-any.whl → 0.0.2__py3-none-any.whl

gsim/palace/models/ports.py

@@ -0,0 +1,138 @@
+"""Port configuration models for Palace simulations.
+
+This module contains Pydantic models for port definitions:
+- PortConfig: Single-element lumped port configuration
+- CPWPortConfig: Coplanar waveguide (two-element) port configuration
+- TerminalConfig: Terminal for electrostatic simulations
+- WavePortConfig: Wave port (domain boundary with mode solving)
+"""
+
+from __future__ import annotations
+
+from typing import Literal, Self
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class PortConfig(BaseModel):
+    """Configuration for a single-element lumped port.
+
+    Lumped ports can be inplane (horizontal, on single layer) or
+    via (vertical, between two layers).
+
+    Attributes:
+        name: Port name (must match component port name)
+        layer: Target layer for inplane ports
+        from_layer: Bottom layer for via ports
+        to_layer: Top layer for via ports
+        length: Port extent along direction (um)
+        impedance: Port impedance (Ohms)
+        excited: Whether this port is excited
+        geometry: Port geometry type ("inplane" or "via")
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    name: str
+    layer: str | None = None
+    from_layer: str | None = None
+    to_layer: str | None = None
+    length: float | None = Field(default=None, gt=0)
+    impedance: float = Field(default=50.0, gt=0)
+    excited: bool = True
+    geometry: Literal["inplane", "via"] = "inplane"
+
+    @model_validator(mode="after")
+    def validate_layer_config(self) -> Self:
+        """Validate layer configuration based on geometry type."""
+        if self.geometry == "inplane" and self.layer is None:
+            raise ValueError("Inplane ports require 'layer' to be specified")
+        if self.geometry == "via":
+            if self.from_layer is None or self.to_layer is None:
+                raise ValueError(
+                    "Via ports require both 'from_layer' and 'to_layer'"
+                )
+        return self
+
+
+class CPWPortConfig(BaseModel):
+    """Configuration for a coplanar waveguide (CPW) port.
+
+    CPW ports consist of two elements (upper and lower gaps) that are
+    excited with opposite E-field directions to create the CPW mode.
+
+    Attributes:
+        upper: Name of the upper gap port on the component
+        lower: Name of the lower gap port on the component
+        layer: Target conductor layer
+        length: Port extent along direction (um)
+        impedance: Port impedance (Ohms)
+        excited: Whether this port is excited
+        name: Optional name for the CPW port (default: "cpw_{lower}")
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    upper: str = Field(description="Name of upper gap port")
+    lower: str = Field(description="Name of lower gap port")
+    layer: str = Field(description="Target conductor layer")
+    length: float = Field(gt=0, description="Port extent in um")
+    impedance: float = Field(default=50.0, gt=0)
+    excited: bool = True
+    name: str | None = Field(
+        default=None, description="CPW port name (default: cpw_{lower})"
+    )
+
+    @property
+    def effective_name(self) -> str:
+        """Get the effective port name."""
+        return self.name if self.name else f"cpw_{self.lower}"
+
+
+class TerminalConfig(BaseModel):
+    """Configuration for a terminal (for electrostatic capacitance extraction).
+
+    Terminals define conductor surfaces for capacitance matrix extraction
+    in electrostatic simulations.
+
+    Attributes:
+        name: Terminal name
+        layer: Target conductor layer
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    name: str
+    layer: str
+
+
+class WavePortConfig(BaseModel):
+    """Configuration for a wave port (domain boundary with mode solving).
+
+    Wave ports are used for domain-boundary ports where mode solving
+    is needed. This is an alternative to lumped ports for more accurate
+    S-parameter extraction.
+
+    Attributes:
+        name: Port name (must match component port name)
+        layer: Target conductor layer
+        mode: Mode number to excite
+        excited: Whether this port is excited
+        offset: De-embedding distance in um
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    name: str
+    layer: str
+    mode: int = Field(default=1, ge=1, description="Mode number to excite")
+    excited: bool = True
+    offset: float = Field(default=0.0, ge=0, description="De-embedding distance in um")
+
+
+__all__ = [
+    "CPWPortConfig",
+    "PortConfig",
+    "TerminalConfig",
+    "WavePortConfig",
+]

gsim/palace/models/problems.py

@@ -0,0 +1,195 @@
+"""Problem-specific configuration models for Palace simulations.
+
+This module contains Pydantic models for different simulation types:
+- DrivenConfig: Frequency-domain driven simulation (S-parameters)
+- EigenmodeConfig: Eigenmode/resonance simulation
+- ElectrostaticConfig: Electrostatic capacitance extraction
+- MagnetostaticConfig: Magnetostatic inductance extraction
+- TransientConfig: Time-domain simulation
+"""
+
+from __future__ import annotations
+
+from typing import Literal, Self
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class DrivenConfig(BaseModel):
+    """Configuration for driven (frequency sweep) simulation.
+
+    This is used for S-parameter extraction and frequency response analysis.
+
+    Attributes:
+        fmin: Minimum frequency in Hz
+        fmax: Maximum frequency in Hz
+        num_points: Number of frequency points
+        scale: Frequency spacing ("linear" or "log")
+        adaptive_tol: Adaptive tolerance (0 disables adaptive)
+        adaptive_max_samples: Maximum samples for adaptive refinement
+        compute_s_params: Whether to compute S-parameters
+        reference_impedance: Reference impedance for S-params (Ohms)
+        excitation_port: Name of port to excite (None = first port)
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    fmin: float = Field(default=1e9, gt=0, description="Min frequency in Hz")
+    fmax: float = Field(default=100e9, gt=0, description="Max frequency in Hz")
+    num_points: int = Field(default=40, ge=1, description="Number of frequency points")
+    scale: Literal["linear", "log"] = "linear"
+
+    # Adaptive options
+    adaptive_tol: float = Field(
+        default=0.02, ge=0, description="Adaptive tolerance (0 disables adaptive)"
+    )
+    adaptive_max_samples: int = Field(default=20, ge=1)
+
+    # S-parameter options
+    compute_s_params: bool = True
+    reference_impedance: float = Field(default=50.0, gt=0)
+
+    # Excitation
+    excitation_port: str | None = Field(
+        default=None, description="Port to excite (None = first port)"
+    )
+
+    @model_validator(mode="after")
+    def validate_frequency_range(self) -> Self:
+        """Validate that fmin < fmax."""
+        if self.fmin >= self.fmax:
+            raise ValueError(f"fmin ({self.fmin}) must be less than fmax ({self.fmax})")
+        return self
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        freq_step = (self.fmax - self.fmin) / max(1, self.num_points - 1) / 1e9
+        return {
+            "Samples": [
+                {
+                    "Type": "Linear" if self.scale == "linear" else "Log",
+                    "MinFreq": self.fmin / 1e9,
+                    "MaxFreq": self.fmax / 1e9,
+                    "FreqStep": freq_step,
+                    "SaveStep": 0,
+                }
+            ],
+            "AdaptiveTol": self.adaptive_tol if self.adaptive_tol > 0 else 0,
+        }
+
+
+class EigenmodeConfig(BaseModel):
+    """Configuration for eigenmode (resonance) simulation.
+
+    This is used for finding resonant frequencies and mode shapes.
+
+    Attributes:
+        num_modes: Number of modes to find
+        target: Target frequency in Hz for mode search
+        tolerance: Eigenvalue solver tolerance
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    num_modes: int = Field(
+        default=10, ge=1, alias="N", description="Number of modes to find"
+    )
+    target: float | None = Field(default=None, description="Target frequency in Hz")
+    tolerance: float = Field(
+        default=1e-6, gt=0, description="Eigenvalue solver tolerance"
+    )
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        config: dict = {
+            "N": self.num_modes,
+            "Tol": self.tolerance,
+        }
+        if self.target is not None:
+            config["Target"] = self.target / 1e9  # Convert to GHz
+        return config
+
+
+class ElectrostaticConfig(BaseModel):
+    """Configuration for electrostatic (capacitance matrix) simulation.
+
+    Attributes:
+        save_fields: Number of field solutions to save
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    save_fields: int = Field(default=0, ge=0, description="Number of fields to save")
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        return {
+            "Save": self.save_fields,
+        }
+
+
+class MagnetostaticConfig(BaseModel):
+    """Configuration for magnetostatic (inductance matrix) simulation.
+
+    Attributes:
+        save_fields: Number of field solutions to save
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    save_fields: int = Field(default=0, ge=0, description="Number of fields to save")
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        return {
+            "Save": self.save_fields,
+        }
+
+
+class TransientConfig(BaseModel):
+    """Configuration for transient (time-domain) simulation.
+
+    Attributes:
+        max_time: Maximum simulation time in ns
+        excitation: Excitation waveform type
+        excitation_freq: Excitation frequency in Hz (for sinusoidal)
+        excitation_width: Pulse width in ns (for gaussian)
+        time_step: Time step in ns (None = adaptive)
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    excitation: Literal["sinusoidal", "gaussian", "ramp", "smoothstep"] = "sinusoidal"
+    excitation_freq: float | None = Field(
+        default=None, description="Excitation frequency in Hz"
+    )
+    excitation_width: float | None = Field(
+        default=None, description="Pulse width in ns (for gaussian)"
+    )
+    max_time: float = Field(description="Maximum simulation time in ns")
+    time_step: float | None = Field(
+        default=None, description="Time step in ns (None = adaptive)"
+    )
+
+    def to_palace_config(self) -> dict:
+        """Convert to Palace JSON config format."""
+        config: dict = {
+            "Type": self.excitation.capitalize(),
+            "MaxTime": self.max_time,
+        }
+        if self.excitation_freq is not None:
+            config["ExcitationFreq"] = self.excitation_freq / 1e9  # Convert to GHz
+        if self.excitation_width is not None:
+            config["ExcitationWidth"] = self.excitation_width
+        if self.time_step is not None:
+            config["TimeStep"] = self.time_step
+        return config
+
+
+__all__ = [
+    "DrivenConfig",
+    "EigenmodeConfig",
+    "ElectrostaticConfig",
+    "MagnetostaticConfig",
+    "TransientConfig",
+]

gsim/palace/models/results.py

@@ -0,0 +1,159 @@
+"""Result models for Palace simulations.
+
+This module contains Pydantic models for simulation results and validation.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ValidationResult(BaseModel):
+    """Result of simulation configuration validation.
+
+    Attributes:
+        valid: Whether the configuration is valid
+        errors: List of error messages
+        warnings: List of warning messages
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    valid: bool
+    errors: list[str] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)
+
+    def __bool__(self) -> bool:
+        return self.valid
+
+    def __str__(self) -> str:
+        lines = []
+        if self.valid:
+            lines.append("Validation: PASSED")
+        else:
+            lines.append("Validation: FAILED")
+        if self.errors:
+            lines.append("Errors:")
+            lines.extend([f"  - {e}" for e in self.errors])
+        if self.warnings:
+            lines.append("Warnings:")
+            lines.extend([f"  - {w}" for w in self.warnings])
+        return "\n".join(lines)
+
+
+class SimulationResult(BaseModel):
+    """Result from running a Palace simulation.
+
+    Attributes:
+        mesh_path: Path to the generated mesh file
+        output_dir: Output directory path
+        config_path: Path to the Palace config file
+        results: Dictionary mapping result filenames to paths
+        conductor_groups: Physical group info for conductors
+        dielectric_groups: Physical group info for dielectrics
+        port_groups: Physical group info for ports
+        boundary_groups: Physical group info for boundaries
+        port_info: Port metadata
+    """
+
+    model_config = ConfigDict(validate_assignment=True, arbitrary_types_allowed=True)
+
+    mesh_path: Path
+    output_dir: Path
+    config_path: Path | None = None
+    results: dict[str, Path] = Field(default_factory=dict)
+
+    # Physical group info for Palace
+    conductor_groups: dict = Field(default_factory=dict)
+    dielectric_groups: dict = Field(default_factory=dict)
+    port_groups: dict = Field(default_factory=dict)
+    boundary_groups: dict = Field(default_factory=dict)
+
+    # Port metadata
+    port_info: list = Field(default_factory=list)
+
+    # Mesh statistics
+    mesh_stats: dict = Field(default_factory=dict)
+
+    def __str__(self) -> str:
+        lines = ["Mesh Summary"]
+        lines.append("=" * 40)
+
+        # Dimensions
+        if self.mesh_stats:
+            bbox = self.mesh_stats.get("bbox", {})
+            if bbox:
+                dx = bbox.get("xmax", 0) - bbox.get("xmin", 0)
+                dy = bbox.get("ymax", 0) - bbox.get("ymin", 0)
+                dz = bbox.get("zmax", 0) - bbox.get("zmin", 0)
+                lines.append(f"Dimensions: {dx:.1f} x {dy:.1f} x {dz:.1f} µm")
+
+            # Mesh info
+            nodes = self.mesh_stats.get("nodes", 0)
+            elements = self.mesh_stats.get("elements", 0)
+            tets = self.mesh_stats.get("tetrahedra", 0)
+            if nodes or elements:
+                lines.append(f"Nodes:      {nodes:,}")
+                lines.append(f"Elements:   {elements:,}")
+                if tets:
+                    lines.append(f"Tetrahedra: {tets:,}")
+
+            # Edge lengths
+            edge = self.mesh_stats.get("edge_length", {})
+            if edge:
+                lines.append(
+                    f"Edge length: {edge.get('min', 0):.2f} - {edge.get('max', 0):.2f} µm"
+                )
+
+            # Mesh quality (gamma)
+            quality = self.mesh_stats.get("quality", {})
+            if quality:
+                q_min = quality.get("min", 0)
+                q_mean = quality.get("mean", 0)
+                lines.append(f"Quality:    {q_mean:.3f} (min: {q_min:.3f})")
+
+            # SICN quality (shows invalid elements)
+            sicn = self.mesh_stats.get("sicn", {})
+            if sicn:
+                invalid = sicn.get("invalid", 0)
+                if invalid > 0:
+                    lines.append(f"SICN:       {sicn.get('mean', 0):.3f} ({invalid} invalid!)")
+                else:
+                    lines.append(f"SICN:       {sicn.get('mean', 0):.3f} (all valid)")
+
+            # Physical groups
+            groups = self.mesh_stats.get("groups", {})
+            if groups:
+                volumes = groups.get("volumes", [])
+                surfaces = groups.get("surfaces", [])
+                lines.append("-" * 40)
+                if volumes:
+                    lines.append(f"Volumes ({len(volumes)}):")
+                    for v in volumes:
+                        name = v["name"] if isinstance(v, dict) else v
+                        tag = v.get("tag", "") if isinstance(v, dict) else ""
+                        lines.append(f"  - {name}" + (f" [{tag}]" if tag else ""))
+                if surfaces:
+                    lines.append(f"Surfaces ({len(surfaces)}):")
+                    for s in surfaces:
+                        name = s["name"] if isinstance(s, dict) else s
+                        tag = s.get("tag", "") if isinstance(s, dict) else ""
+                        lines.append(f"  - {name}" + (f" [{tag}]" if tag else ""))
+
+        lines.append("-" * 40)
+        lines.append(f"Mesh:   {self.mesh_path}")
+        if self.config_path:
+            lines.append(f"Config: {self.config_path}")
+
+        return "\n".join(lines)
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+__all__ = [
+    "SimulationResult",
+    "ValidationResult",
+]

gsim/palace/models/stack.py

@@ -0,0 +1,59 @@
+"""Material configuration model for Palace simulations.
+
+This module contains the MaterialConfig Pydantic model for material property overrides
+in simulations. Layer and stack configuration is handled by gsim.common.stack.
+"""
+
+from __future__ import annotations
+
+from typing import Literal, Self
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MaterialConfig(BaseModel):
+    """EM properties for a material.
+
+    Used for material property overrides in simulation classes.
+
+    Attributes:
+        type: Material type (conductor, dielectric, or semiconductor)
+        conductivity: Conductivity in S/m (for conductors)
+        permittivity: Relative permittivity (for dielectrics)
+        loss_tangent: Dielectric loss tangent
+    """
+
+    model_config = ConfigDict(validate_assignment=True)
+
+    type: Literal["conductor", "dielectric", "semiconductor"]
+    conductivity: float | None = Field(default=None, ge=0)
+    permittivity: float | None = Field(default=None, ge=1.0)
+    loss_tangent: float | None = Field(default=None, ge=0, le=1)
+
+    @classmethod
+    def conductor(cls, conductivity: float = 5.8e7) -> Self:
+        """Create a conductor material."""
+        return cls(type="conductor", conductivity=conductivity)
+
+    @classmethod
+    def dielectric(cls, permittivity: float, loss_tangent: float = 0.0) -> Self:
+        """Create a dielectric material."""
+        return cls(
+            type="dielectric", permittivity=permittivity, loss_tangent=loss_tangent
+        )
+
+    def to_dict(self) -> dict[str, object]:
+        """Convert to dictionary for YAML output."""
+        d: dict[str, object] = {"type": self.type}
+        if self.conductivity is not None:
+            d["conductivity"] = self.conductivity
+        if self.permittivity is not None:
+            d["permittivity"] = self.permittivity
+        if self.loss_tangent is not None:
+            d["loss_tangent"] = self.loss_tangent
+        return d
+
+
+__all__ = [
+    "MaterialConfig",
+]

gsim/palace/ports/config.py

@@ -11,7 +11,7 @@ from enum import Enum
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from gsim.palace.stack import LayerStack
+    from gsim.common.stack import LayerStack
 
 
 class PortType(Enum):

{gsim-0.0.0.dist-info → gsim-0.0.2.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: gsim
-Version: 0.0.0
+Version: 0.0.2
 Author-email: flaport <floris.laporte@gmail.com>
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Requires-Python: <3.14,>=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: gdsfactory>=8.32.2
+Requires-Dist: gdsfactory>=9.32.0
 Requires-Dist: gdsfactoryplus>=1.3.7
 Requires-Dist: gmsh
 Requires-Dist: meshio>=5.0.0
@@ -43,8 +43,10 @@ Requires-Dist: towncrier>=24.0.0; extra == "dev"
 Requires-Dist: vega-datasets>=0.9.0; extra == "dev"
 Requires-Dist: nbstripout>=0.8.1; extra == "dev"
 Requires-Dist: ty>=0.0.13; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: ihp-gdsfactory>=0.1.4; extra == "docs"
 
-# Gsim 0.0.0
+# Gsim 0.0.2
 
 > a GDSFactory Simulation Plugin
 

gsim-0.0.2.dist-info/RECORD

@@ -0,0 +1,32 @@
+gsim/__init__.py,sha256=ltF9Dg54VN5FFluo_Ixh2hEEsCv603Cqs9omInOjyyc,288
+gsim/gcloud.py,sha256=ulYaNyGXCRoTbud0im1qHyuwcvIpNpk1RRvnRxekCe4,5155
+gsim/viz.py,sha256=cakE-oH_O0wuL51gURl5YjLeCZQz-FFUzfr2jn2-MI4,2645
+gsim/common/__init__.py,sha256=76hHcbSSJw45_Xz-WNTPzAhxJXqacs9Vx5BOKaMk3xw,1415
+gsim/common/geometry.py,sha256=WdFhbHFZjKM7HL35UDmNgmgwWJHPf3YFs-sxMd4w6f4,2170
+gsim/common/stack/__init__.py,sha256=0v44u-BQSnW7Gb9t7a9tZ0HFxBVaCFKIAbXf40C3sFU,4023
+gsim/common/stack/extractor.py,sha256=u9ZAf8PjBig_OJefSocONE2NIAEDzE_ys1QQa2ALlYQ,17745
+gsim/common/stack/materials.py,sha256=Eq8u1LwrY03Ewc5BSRTILofp_sqNXP-DAhUmORf3cM8,5168
+gsim/common/stack/visualization.py,sha256=JwUDmdWqKYjSfeBX_EA1vp3ggxYAX8lI5soNIKHpwkg,19216
+gsim/palace/__init__.py,sha256=XOA8ZmwFu3hJm7wlm7HNGqIgPxMhIpOdyEslfmwhxao,3997
+gsim/palace/base.py,sha256=GHbiVhxeXJ7IL_3_OqZIL_Kpi0dpUFOUv_4XzqrjNE0,2002
+gsim/palace/driven.py,sha256=kgF-jncBD0ffXZkUfyiV5zX6E88PpGYtDZJj6UQ8ggw,34190
+gsim/palace/eigenmode.py,sha256=NIEEW7U8haD_JZyC3gSADV627jdzuae-19_NJ3TP5Pw,26341
+gsim/palace/electrostatic.py,sha256=oeHg4B3RS3oPgh0Aa2yJX3ttKxkpQDN9CajZrkiLEis,20928
+gsim/palace/mesh/__init__.py,sha256=vif960c46QbH1fkr4J9ydFh5ODcmxRS_Nx3D6JaVlMw,1207
+gsim/palace/mesh/generator.py,sha256=uWIK4c5VkehYPUFjDb5rqQKyziaDR1SUm_1OT2pfkO8,36845
+gsim/palace/mesh/gmsh_utils.py,sha256=G8JJUSlUL2Rr1tcM9G0M6F9UjxePFpWSUGfmJ-LWh8E,13801
+gsim/palace/mesh/pipeline.py,sha256=cMGyuHuY6ZJYoT3cjf1Jneck2UZQTgGQQhG-D-0oz9Q,6695
+gsim/palace/models/__init__.py,sha256=15of4sl3Q3qJ88BWWF0bldey5_Mijdkq-TyTuKghpPI,1592
+gsim/palace/models/geometry.py,sha256=9jD2HKeJKYhyaBLLCNc4LyuW-OpIouX32WYiE2XP9wg,987
+gsim/palace/models/mesh.py,sha256=vPFR5toiWLIpyYd0ZW2hN8oIOvBohJqDE5alFMpgiBc,3119
+gsim/palace/models/numerical.py,sha256=fH57yFemH2myHWjj9Si5F7Op7jauleqaK2wbdkKf_Uw,1792
+gsim/palace/models/ports.py,sha256=NpL3w1uwsMGOX8NsnmOj1mV87xUtDWXGn2VUOyODJVw,4550
+gsim/palace/models/problems.py,sha256=mmWuXg-gU0BxXPB5oyOPTcV459gsyD4JK0FZu8sKLGY,6592
+gsim/palace/models/results.py,sha256=clyHwLAGvKWWtfwm9yzv-OhaFLXhID130gShBDidwO4,5555
+gsim/palace/models/stack.py,sha256=g3cw-YliXAoMqEoynMXYUY2Ys39llpN-9nPhRBQYfYU,1975
+gsim/palace/ports/__init__.py,sha256=IoP11atw-Uf447AkZC5ixNcgqlNrC3GCnTGugjR_wgw,803
+gsim/palace/ports/config.py,sha256=DK8TwspCsghQFl1uqKzu-YYEhjfu37rMDuHErOLPPgU,12289
+gsim-0.0.2.dist-info/METADATA,sha256=1siJwZ2ue0Ipqk1dcI3fgsWG_5lHfqwtd1Dl8Ae20Ho,4300
+gsim-0.0.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+gsim-0.0.2.dist-info/top_level.txt,sha256=USwf5QaCLsXq3JCR6ejGvHANZmIifvuQAAl7w-cUE0Y,5
+gsim-0.0.2.dist-info/RECORD,,

gsim-0.0.0.dist-info/RECORD

@@ -1,18 +0,0 @@
-gsim/__init__.py,sha256=FmMjn3al4lB-2cGAlMcYoDpfEgb1CotlaBTKbfCCbfA,288
-gsim/gcloud.py,sha256=ulYaNyGXCRoTbud0im1qHyuwcvIpNpk1RRvnRxekCe4,5155
-gsim/viz.py,sha256=cakE-oH_O0wuL51gURl5YjLeCZQz-FFUzfr2jn2-MI4,2645
-gsim/palace/__init__.py,sha256=FHY3L9NRGx5xFCU-mLHKIDjJZc_G0kcIMoq6pX9RHyo,2938
-gsim/palace/mesh/__init__.py,sha256=vif960c46QbH1fkr4J9ydFh5ODcmxRS_Nx3D6JaVlMw,1207
-gsim/palace/mesh/generator.py,sha256=wQR64aqRMuHwA6klLHIASr03Z6tIUqHvvuwvovtwOBY,30735
-gsim/palace/mesh/gmsh_utils.py,sha256=G8JJUSlUL2Rr1tcM9G0M6F9UjxePFpWSUGfmJ-LWh8E,13801
-gsim/palace/mesh/pipeline.py,sha256=K5G1mb5kk9_y_lVHQH7fOOUquarlGEBtw3NTcNpni60,5936
-gsim/palace/ports/__init__.py,sha256=IoP11atw-Uf447AkZC5ixNcgqlNrC3GCnTGugjR_wgw,803
-gsim/palace/ports/config.py,sha256=LHgKqpk4w7rutUBEf-368bRu2l4N02m-Y8qPdKOuQmk,12289
-gsim/palace/stack/__init__.py,sha256=xcofg-9HuAiymv_77_AuEtTyVnpAjBbxOqRC3-kjQXs,3910
-gsim/palace/stack/extractor.py,sha256=elQn4aEux9_gslyPB1zDTdcOpdiBbCADF7B9vVPd6hg,20440
-gsim/palace/stack/materials.py,sha256=IzUGuPufWu7tx4uTuERodygsh8mA-BZh7NQfSBYLLBU,4637
-gsim/palace/stack/visualization.py,sha256=JwUDmdWqKYjSfeBX_EA1vp3ggxYAX8lI5soNIKHpwkg,19216
-gsim-0.0.0.dist-info/METADATA,sha256=ZNJ5JOBN4ruqnQszxFq9jP-Z1lxDpRP3lEI_RHvaxt4,4225
-gsim-0.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-gsim-0.0.0.dist-info/top_level.txt,sha256=USwf5QaCLsXq3JCR6ejGvHANZmIifvuQAAl7w-cUE0Y,5
-gsim-0.0.0.dist-info/RECORD,,