Upload 8 files

README.md

@@ -1,3 +1,48 @@
----
-license: mit
----
+
+# pinn_electromagnetics
+
+A Python package for simulating electromagnetic fields using Physics-Informed Neural Networks (PINNs).
+
+This package implements custom neural network architectures and loss functions to solve Maxwell's equations, particularly focusing on wave propagation problems in complex geometries.
+
+## Installation
+
+To install the package, navigate to the root directory of the package and run:
+
+```bash
+pip install .
+```
+
+## Usage
+
+See `example_usage.py` for a detailed example of how to use the models and loss functions, load pre-trained weights, and visualize results.
+
+## Models Included
+
+-   `HashGridEncoder`: Efficient multi-resolution hash grid encoder for spatial coordinates.
+-   `GeoNetHash`: A geometry network that learns Signed Distance Functions (SDFs) of complex objects using `HashGridEncoder`.
+-   `PositionalEncoder4D`: A standard positional encoder for 4D (x, y, z, t) inputs.
+-   `MaxwellPINN`: The core physics-informed neural network that predicts electromagnetic fields (E, B) based on space and time coordinates.
+
+## Loss Functions Included
+
+-   `compute_all_derivatives`: Helper function to compute all necessary partial derivatives of E and B fields with respect to x, y, z, and t.
+-   `compute_maxwell_loss`: Implements the physics-based loss derived from Maxwell's equations (Gauss's laws, Faraday's law, Ampere-Maxwell law).
+-   `compute_data_loss`: Computes the data-driven loss from initial conditions (E0, B0) and source boundary conditions (e.g., oscillating E-field at an antenna).
+
+## Data Format
+
+The `example_usage.py` expects a `ground_truth.npz` file containing:
+
+-   `coords`: (N, 3) array of 3D coordinates.
+-   `sdf`: (N,) array of Signed Distance Function values for `coords`.
+-   `E0`: (N, 3) array of initial E-field values at `coords`.
+-   `B0`: (N, 3) array of initial B-field values at `coords`.
+-   `source_position`: (3,) array for the (x,y,z) coordinates of the antenna source.
+-   `source_orientation`: (3,) array for the orientation of the source E-field (e.g., [1,0,0] for x-polarized).
+-   `source_signal`: (T_steps,) array for the time-varying signal of the source.
+-   `t`: (T_steps,) array of time points corresponding to `source_signal`.
+
+## License
+
+MIT License

__init__.py

@@ -0,0 +1,3 @@
+from .models import DualNetwork
+from .models import HashGridEncoder, GeoNetHash, PositionalEncoder4D, MaxwellPINN
+from .losses import compute_all_derivatives, compute_maxwell_loss, compute_data_loss

dualmaxwell.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f03307c4ea1b4e5fd84cebb7773e2ab2827ab774c19eadf6718dd285ff7aa40a
+size 174347

example_usage.py

@@ -0,0 +1,157 @@
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+
+# Import models and losses from the package
+from pinn_electromagnetics.models import GeoNetHash, MaxwellPINN
+from pinn_electromagnetics.losses import compute_all_derivatives, compute_maxwell_loss, compute_data_loss
+
+# --- Configuration Parameters ---
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Paths to pre-trained model weights (assuming they are in the same directory as this script or specified otherwise)
+# For Google Colab, these paths might need to be adjusted to '/content/drive/MyDrive/Colab_PINN_Projects/'
+MODEL_DIR = "."
+GEO_MODEL_PATH = os.path.join(MODEL_DIR, "geonet_real_v30.pth")
+PHYS_MODEL_PATH = os.path.join(MODEL_DIR, "physnet_v31_real.pth")
+NPZ_FILE_PATH = os.path.join(MODEL_DIR, "ground_truth.npz")
+
+# Simulation parameters (should match training parameters)
+BOX_SIZE_GEO = 2.0 # The full extent of geometry data, e.g., [-2, 2]
+
+# --- 1. Load Data ---
+print(f"Loading data from {NPZ_FILE_PATH}...")
+try:
+    ground_truth_data = np.load(NPZ_FILE_PATH)
+    coords_np = ground_truth_data['coords']
+    sdf_np = ground_truth_data['sdf']
+    E0_np = ground_truth_data['E0']
+    B0_np = ground_truth_data['B0']
+    source_pos_np = ground_truth_data['source_position']
+    source_orientation_np = ground_truth_data['source_orientation']
+    source_signal_np = ground_truth_data['source_signal']
+    t_np = ground_truth_data['t']
+
+    # Convert to PyTorch tensors
+    coords_tensor = torch.tensor(coords_np, dtype=torch.float32).to(DEVICE)
+    sdf_tensor = torch.tensor(sdf_np, dtype=torch.float32).view(-1, 1).to(DEVICE)
+    E0_tensor = torch.tensor(E0_np, dtype=torch.float32).to(DEVICE)
+    B0_tensor = torch.tensor(B0_np, dtype=torch.float32).to(DEVICE)
+    source_pos_tensor = torch.tensor(source_pos_np, dtype=torch.float32).to(DEVICE)
+    source_orientation_tensor = torch.tensor(source_orientation_np, dtype=torch.float32).to(DEVICE)
+    source_signal_tensor = torch.tensor(source_signal_np, dtype=torch.float32).to(DEVICE)
+    t_tensor = torch.tensor(t_np, dtype=torch.float32).to(DEVICE)
+
+    if t_tensor.dim() == 1: t_tensor = t_tensor.view(-1, 1)
+    if source_signal_tensor.dim() == 1: source_signal_tensor = source_signal_tensor.view(-1, 1)
+
+    T_MAX = t_tensor.max().item()
+    print("Data loaded successfully.")
+except FileNotFoundError:
+    print(f"Error: {NPZ_FILE_PATH} not found. Please ensure it's in the correct directory.")
+    exit()
+except Exception as e:
+    print(f"Error loading NPZ data: {e}")
+    exit()
+
+# --- 2. Load Models ---
+print("Loading pre-trained models...")
+
+# GeoNet (Geometry Network)
+model_geo = GeoNetHash().to(DEVICE)
+# The normalize_coords method sets self.min/max, crucial for GeoNet's forward pass
+model_geo.normalize_coords(coords_tensor) 
+model_geo.load_state_dict(torch.load(GEO_MODEL_PATH, map_location=DEVICE))
+model_geo.eval()
+
+# MaxwellPINN (Physics Network)
+model_phys = MaxwellPINN(num_freqs=8, hidden_dim=128).to(DEVICE)
+model_phys.load_state_dict(torch.load(PHYS_MODEL_PATH, map_location=DEVICE))
+model_phys.eval()
+
+print("Models loaded successfully.")
+
+# --- 3. Example Usage: Compute Losses on a Subset of Data (Optional) ---
+print("
+--- Computing example losses (physics and data) ---")
+# For demonstration, let's take a small random subset of points
+n_test_points = 1024
+idx_test_colloc = torch.randperm(coords_tensor.shape[0], device=DEVICE)[:n_test_points * 2]
+coords_test_all = coords_tensor[idx_test_colloc]
+
+with torch.no_grad():
+    coords_test_norm = model_geo.normalize_coords(coords_test_all)
+    sdf_vals_test = model_geo(coords_test_norm)
+mask_outside_cube = (sdf_vals_test > 0.05).flatten()
+coords_test_colloc = coords_test_all[mask_outside_cube][:n_test_points]
+
+x_c = coords_test_colloc[:, 0:1].requires_grad_(True)
+y_c = coords_test_colloc[:, 1:2].requires_grad_(True)
+z_c = coords_test_colloc[:, 2:3].requires_grad_(True)
+t_c = (torch.rand(coords_test_colloc.shape[0], 1, device=DEVICE) * T_MAX).requires_grad_(True)
+
+# Physics Loss
+_, derivs = compute_all_derivatives(model_phys, x_c, y_c, z_c, t_c)
+loss_physics_example = compute_maxwell_loss(derivs)
+print(f"Example Physics Loss: {loss_physics_example.item():.6f}")
+
+# Data Loss
+loss_data_example = compute_data_loss(model_phys,
+                                       coords_tensor, E0_tensor, B0_tensor,
+                                       source_pos_tensor, source_orientation_tensor,
+                                       source_signal_tensor, t_tensor,
+                                       n_samples_ic=256, n_samples_source=t_tensor.shape[0])
+print(f"Example Data Loss: {loss_data_example.item():.6f}")
+
+# --- 4. Visualization ---
+print("
+--- Generating visualization of predicted Ex field ---")
+
+with torch.no_grad():
+    resolution = 100
+    min_vals = coords_tensor.min(dim=0)[0]
+    max_vals = coords_tensor.max(dim=0)[0]
+
+    # Slice in the X-Z plane (at the center of Y)
+    x_range = np.linspace(min_vals[0].item(), max_vals[0].item(), resolution)
+    z_range = np.linspace(min_vals[2].item(), max_vals[2].item(), resolution)
+    xx, zz = np.meshgrid(x_range, z_range)
+    yy = np.full_like(xx, (min_vals[1] + max_vals[1]).item() / 2.0)
+
+    # Visualize at 75% of the total simulation time
+    T_VISUALIZATION = T_MAX * 0.75
+    tt = np.ones_like(xx) * T_VISUALIZATION
+
+    x_grid = torch.tensor(xx.flatten(), dtype=torch.float32).to(DEVICE).view(-1, 1)
+    y_grid = torch.tensor(yy.flatten(), dtype=torch.float32).to(DEVICE).view(-1, 1)
+    z_grid = torch.tensor(zz.flatten(), dtype=torch.float32).to(DEVICE).view(-1, 1)
+    t_grid = torch.tensor(tt.flatten(), dtype=torch.float32).to(DEVICE).view(-1, 1)
+
+    # Predict E-field
+    pred_all = model_phys(x_grid, y_grid, z_grid, t_grid)
+    Ex_pred_flat = pred_all[:, 0] # Get Ex component
+    Ex_pred_grid = Ex_pred_flat.cpu().numpy().reshape(resolution, resolution)
+
+    # Get geometry (SDF) for this slice
+    coords_viz = torch.cat([x_grid, y_grid, z_grid], dim=1)
+    coords_viz_norm = model_geo.normalize_coords(coords_viz)
+    sdf_grid = model_geo(coords_viz_norm).cpu().numpy().reshape(resolution, resolution)
+
+    # Zero out values inside the geometry for clearer visualization
+    Ex_pred_grid[sdf_grid < 0.0] = 0.0
+
+    plt.figure(figsize=(8, 6))
+    cf = plt.contourf(xx, zz, Ex_pred_grid, levels=50, cmap='RdBu_r', vmin=-1.0, vmax=1.0) # Using RdBu_r for E-field
+
+    # Plot geometry contour (SDF=0)
+    plt.contour(xx, zz, sdf_grid, levels=[0], colors='black', linewidths=3)
+
+    plt.title(f'Predicted $	ilde{{E}}_x$ field at $t={T_VISUALIZATION:.2f}$ (Example Usage)')
+    plt.xlabel('x (m)'); plt.ylabel('z (m)'); plt.colorbar(cf, label='E_x field value')
+    plt.axis('equal')
+    plt.tight_layout()
+    plt.show()
+
+print("Example usage script finished successfully.")

hubconf.py

@@ -0,0 +1,17 @@
+from huggingface_hub import hf_hub_download
+import torch
+from pinn_electromagnetics.models import GeoNetHash, MaxwellPINN
+
+def geonet(pretrained=False, map_location="cpu"):
+    model = GeoNetHash()
+    if pretrained:
+        file_path = hf_hub_download(repo_id="Ayda138000/DualMaxwell", filename="geonet_real_v34.pth")
+        model.load_state_dict(torch.load(file_path, map_location=map_location))
+    return model
+
+def maxwell(pretrained=False, map_location="cpu"):
+    model = MaxwellPINN()
+    if pretrained:
+        file_path = hf_hub_download(repo_id="Ayda138000/DualMaxwell", filename="physnet_v34_real.pth")
+        model.load_state_dict(torch.load(file_path, map_location=map_location))
+    return model

losses.py

@@ -0,0 +1,93 @@
+
+import torch
+import numpy as np # Used for constants like pi if needed elsewhere
+
+# --- Derivative Computation (from v28) ---
+def compute_all_derivatives(model_phys, x, y, z, t):
+    outputs = model_phys(x, y, z, t)
+    Ex, Ey, Ez = outputs[:, 0:1], outputs[:, 1:2], outputs[:, 2:3]
+    Bx, By, Bz = outputs[:, 3:4], outputs[:, 4:5], outputs[:, 5:6]
+
+    # Use .sum() for scalar output when computing gradients over multiple components
+    dEx_grads = torch.autograd.grad(Ex.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+    dEy_grads = torch.autograd.grad(Ey.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+    dEz_grads = torch.autograd.grad(Ez.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+    dBx_grads = torch.autograd.grad(Bx.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+    dBy_grads = torch.autograd.grad(By.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+    dBz_grads = torch.autograd.grad(Bz.sum(), [x, y, z, t], create_graph=True, allow_unused=True)
+
+    # Ensure gradients are not None if allow_unused=True
+    def get_grad(grad_tuple, idx):
+        return grad_tuple[idx] if grad_tuple[idx] is not None else torch.zeros_like(x)
+
+    derivs = {
+        'dEx_dx': get_grad(dEx_grads, 0), 'dEx_dy': get_grad(dEx_grads, 1), 'dEx_dz': get_grad(dEx_grads, 2), 'dEx_dt': get_grad(dEx_grads, 3),
+        'dEy_dx': get_grad(dEy_grads, 0), 'dEy_dy': get_grad(dEy_grads, 1), 'dEy_dz': get_grad(dEy_grads, 2), 'dEy_dt': get_grad(dEy_grads, 3),
+        'dEz_dx': get_grad(dEz_grads, 0), 'dEz_dy': get_grad(dEz_grads, 1), 'dEz_dz': get_grad(dEz_grads, 2), 'dEz_dt': get_grad(dEz_grads, 3),
+        'dBx_dx': get_grad(dBx_grads, 0), 'dBx_dy': get_grad(dBx_grads, 1), 'dBx_dz': get_grad(dBx_grads, 2), 'dBx_dt': get_grad(dBx_grads, 3),
+        'dBy_dx': get_grad(dBy_grads, 0), 'dBy_dy': get_grad(dBy_grads, 1), 'dBy_dz': get_grad(dBy_grads, 2), 'dBy_dt': get_grad(dBy_grads, 3),
+        'dBz_dx': get_grad(dBz_grads, 0), 'dBz_dy': get_grad(dBz_grads, 1), 'dBz_dz': get_grad(dBz_grads, 2), 'dBz_dt': get_grad(dBz_grads, 3),
+    }
+    return outputs, derivs
+
+# --- Maxwell Loss (from v28) ---
+def compute_maxwell_loss(derivs):
+    # Maxwell's Equations (dimensionless units)
+
+    # Gauss's Law for E: div(E) = 0
+    loss_gauss_E = (derivs['dEx_dx'] + derivs['dEy_dy'] + derivs['dEz_dz'])**2
+
+    # Gauss's Law for B: div(B) = 0
+    loss_gauss_B = (derivs['dBx_dx'] + derivs['dBy_dy'] + derivs['dBz_dz'])**2
+
+    # Faraday's Law: curl(E) = -dB/dt
+    loss_faraday_x = (derivs['dEz_dy'] - derivs['dEy_dz'] + derivs['dBx_dt'])**2
+    loss_faraday_y = (derivs['dEx_dz'] - derivs['dEz_dx'] + derivs['dBy_dt'])**2
+    loss_faraday_z = (derivs['dEy_dx'] - derivs['dEx_dy'] + derivs['dBz_dt'])**2
+    loss_faraday = loss_faraday_x + loss_faraday_y + loss_faraday_z
+
+    # Ampere-Maxwell Law: curl(B) = dE/dt (assuming no current J)
+    loss_ampere_x = (derivs['dBz_dy'] - derivs['dBy_dz'] - derivs['dEx_dt'])**2
+    loss_ampere_y = (derivs['dBx_dz'] - derivs['dBz_dx'] - derivs['dEy_dt'])**2
+    loss_ampere_z = (derivs['dBy_dx'] - derivs['dBx_dy'] - derivs['dEz_dt'])**2
+    loss_ampere = loss_ampere_x + loss_ampere_y + loss_ampere_z
+
+    return torch.mean(loss_gauss_E + loss_gauss_B + loss_faraday + loss_ampere)
+
+# --- Data Loss (from v31.2, adapted for NPZ data) ---
+def compute_data_loss(model_phys,
+                      coords_tensor, E0_tensor, B0_tensor,
+                      source_pos_tensor, source_orientation_tensor,
+                      source_signal_tensor, t_tensor,
+                      n_samples_ic=1024, n_samples_source=128):
+    loss_data = 0.0
+
+    # 1. Initial Conditions (t=0): E=E0, B=B0
+    idx_ic = torch.randperm(coords_tensor.shape[0], device=coords_tensor.device)[:n_samples_ic]
+    x_ic, y_ic, z_ic = coords_tensor[idx_ic, 0:1], coords_tensor[idx_ic, 1:2], coords_tensor[idx_ic, 2:3]
+    t_ic = torch.zeros_like(x_ic)
+
+    pred_ic = model_phys(x_ic, y_ic, z_ic, t_ic)
+    E_actual_ic, B_actual_ic = E0_tensor[idx_ic], B0_tensor[idx_ic]
+
+    loss_data += torch.mean((pred_ic[:, 0:3] - E_actual_ic)**2)
+    loss_data += torch.mean((pred_ic[:, 3:6] - B_actual_ic)**2)
+
+    # 2. Source Boundary (time-varying E-field, B=0)
+    # We use all time points for the source signal
+    n_times_source = t_tensor.shape[0]
+    # Source position needs to be expanded to match the number of time samples
+    x_s = source_pos_tensor[0:1].expand(n_times_source, -1)
+    y_s = source_pos_tensor[1:2].expand(n_times_source, -1)
+    z_s = source_pos_tensor[2:3].expand(n_times_source, -1)
+    t_s = t_tensor # shape (n_times_source, 1)
+
+    pred_source = model_phys(x_s, y_s, z_s, t_s)
+
+    # E_actual = signal * orientation. Expand orientation to match time samples.
+    E_actual_source = source_signal_tensor * source_orientation_tensor.view(1, 3)
+
+    loss_data += torch.mean((pred_source[:, 0:3] - E_actual_source)**2)
+    loss_data += torch.mean(pred_source[:, 3:6]**2) # B=0 at the source
+
+    return loss_data

models.py

@@ -0,0 +1,117 @@
+
+import torch
+import torch.nn as nn
+import numpy as np
+
+# --- Hash Grid Encoder (from v26) ---
+class HashGridEncoder(nn.Module):
+    def __init__(self, n_levels=16, n_features_per_level=2,
+                 log2_hashmap_size=19, base_resolution=16,
+                 per_level_scale=1.5):
+        super(HashGridEncoder, self).__init__()
+        self.n_levels = n_levels
+        self.n_features_per_level = n_features_per_level
+        self.log2_hashmap_size = log2_hashmap_size
+        self.base_resolution = base_resolution
+        self.per_level_scale = per_level_scale
+        self.hashmap_size = 2**self.log2_hashmap_size
+        self.embeddings = nn.ModuleList([
+            nn.Embedding(self.hashmap_size, self.n_features_per_level)
+            for i in range(self.n_levels)
+        ])
+        for emb in self.embeddings: nn.init.uniform_(emb.weight, -1e-4, 1e-4)
+
+    def hash_fn(self, coords_int, level):
+        primes = torch.tensor([1, 2654435761, 805459861], dtype=torch.int64, device=coords_int.device)
+        hashed_indices = (coords_int * primes).sum(dim=-1) % self.hashmap_size
+        return hashed_indices
+
+    def trilinear_interp(self, x, v000, v001, v010, v011, v100, v101, v110, v111):
+        w0 = (1 - x[..., 0:1]); w1 = x[..., 0:1]
+        c00 = v000 * w0 + v100 * w1; c01 = v001 * w0 + v101 * w1
+        c10 = v010 * w0 + v110 * w1; c11 = v011 * w0 + v111 * w1
+        c0 = c00 * (1 - x[..., 1:2]) + c10 * x[..., 1:2]
+        c1 = c01 * (1 - x[..., 1:2]) + c11 * x[..., 1:2]
+        c = c0 * (1 - x[..., 2:3]) + c1 * x[..., 2:3]
+        return c
+
+    def forward(self, x_coords): # x_coords: [N, 3] in [0, 1]
+        all_features = []
+        for l in range(self.n_levels):
+            res = int(self.base_resolution * (self.per_level_scale ** l))
+            x_scaled = x_coords * res
+            x_floor = torch.floor(x_scaled).to(torch.int64)
+            x_local = (x_scaled - x_floor)
+            corners = torch.tensor([[0,0,0],[0,0,1],[0,1,0],[0,1,1],[1,0,0],[1,0,1],[1,1,0],[1,1,1]], dtype=torch.int64, device=x_coords.device)
+            cell_corners_int = x_floor.unsqueeze(1) + corners.unsqueeze(0)
+            hashed_indices = self.hash_fn(cell_corners_int, l)
+            embedded_features = self.embeddings[l](hashed_indices)
+            interp_features = self.trilinear_interp(
+                x_local,
+                embedded_features[:, 0], embedded_features[:, 1],
+                embedded_features[:, 2], embedded_features[:, 3],
+                embedded_features[:, 4], embedded_features[:, 5],
+                embedded_features[:, 6], embedded_features[:, 7]
+            )
+            all_features.append(interp_features)
+        return torch.cat(all_features, dim=-1)
+
+# --- GeoNetHash (for geometry, from v26) ---
+class GeoNetHash(nn.Module):
+    def __init__(self, box_size_scale=1.0):
+        super(GeoNetHash, self).__init__()
+        self.box_size_scale = box_size_scale
+        self.encoder = HashGridEncoder(n_levels=16, n_features_per_level=2)
+        self.mlp = nn.Sequential(
+            nn.Linear(self.encoder.n_levels * self.encoder.n_features_per_level, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1)
+        )
+        # Placeholder for min/max for normalization
+        self.min = None
+        self.max = None
+
+    def normalize_coords(self, coords):
+        # Stores min/max from the original dataset for consistent normalization
+        self.min = coords.min(dim=0, keepdim=True)[0]
+        self.max = coords.max(dim=0, keepdim=True)[0]
+        self.max[self.max == self.min] += 1e-6 # Avoid division by zero
+        return (coords - self.min) / (self.max - self.min)
+
+    def forward(self, coords_input_normalized): # input is already normalized [0, 1]
+        features = self.encoder(coords_input_normalized)
+        return self.mlp(features)
+
+# --- Positional Encoder 4D (for MaxwellPINN, from v19/v22) ---
+class PositionalEncoder4D(nn.Module):
+    def __init__(self, input_dims, num_freqs):
+        super(PositionalEncoder4D, self).__init__()
+        self.input_dims = input_dims
+        self.num_freqs = num_freqs
+        self.freq_bands = 2.**torch.linspace(0., num_freqs-1, num_freqs)
+        self.output_dims = self.input_dims * (2 * self.num_freqs + 1)
+
+    def forward(self, x): # x is [N, input_dims]
+        encoding = [x]
+        x_freq = x.unsqueeze(-1) * self.freq_bands.to(x.device)
+        encoding.append(torch.sin(x_freq).view(x.shape[0], -1))
+        encoding.append(torch.cos(x_freq).view(x.shape[0], -1))
+        return torch.cat(encoding, dim=1)
+
+# --- MaxwellPINN (for electromagnetics, from v28) ---
+class MaxwellPINN(nn.Module):
+    def __init__(self, num_freqs=8, hidden_dim=128):
+        super(MaxwellPINN, self).__init__()
+        self.encoder = PositionalEncoder4D(input_dims=4, num_freqs=num_freqs)
+        encoder_output_dims = self.encoder.output_dims
+        self.network = nn.Sequential(
+            nn.Linear(encoder_output_dims, hidden_dim), nn.Tanh(),
+            nn.Linear(hidden_dim, hidden_dim), nn.Tanh(),
+            nn.Linear(hidden_dim, hidden_dim), nn.Tanh(),
+            nn.Linear(hidden_dim, 6) # Outputs (Ex, Ey, Ez, Bx, By, Bz)
+        )
+
+    def forward(self, x, y, z, t):
+        coords = torch.cat([x, y, z, t], dim=1)
+        x_encoded = self.encoder(coords)
+        return self.network(x_encoded)

setup.py

@@ -0,0 +1,28 @@
+
+from setuptools import setup, find_packages
+
+setup(
+    name='pinn_electromagnetics',
+    version='0.1.0',
+    packages=find_packages(),
+    install_requires=[
+        'torch>=1.9.0',
+        'numpy>=1.20.0',
+        'matplotlib>=3.3.0',
+        'scikit-learn>=0.24.0' # If StandardScaler is used in example_usage or other scripts
+    ],
+    author='PINN Electromagnetics Team',
+    description='A Python package for simulating electromagnetic fields using Physics-Informed Neural Networks.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/yourusername/pinn_electromagnetics', # Replace with your repo URL
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Intended Audience :: Science/Research',
+        'Topic :: Scientific/Engineering :: Artificial Intelligence',
+        'Topic :: Scientific/Engineering :: Physics'
+    ],
+    python_requires='>=3.7',
+)