Upload 12 files

models/wgan_gp.py

@@ -7,8 +7,9 @@ class Generator(nn.Module):
     """
     Generator for WGAN-GP with structured output heads.
     Outputs continuous node coordinates, node existence logits, and edge logits.
+    NOTE: Keeps a fixed 'nmax' head, but we will DYNAMICALLY SLICE per batch in train.py.
     """
-    def __init__(self, latent_dim=128, nmax=121, cond_dim=4):  # n_nodes, n_edges, height, spacing
+    def __init__(self, latent_dim=128, nmax=121, cond_dim=4):
         super(Generator, self).__init__()
         d = 512
         self.fc = nn.Sequential(
@@ -31,7 +32,8 @@ class Generator(nn.Module):
 
         # enforce symmetry and zero diagonal
         elog = 0.5 * (elog + elog.transpose(-1, -2))
-        elog[:, torch.arange(self.nmax), torch.arange(self.nmax)] = 0
+        diag_idx = torch.arange(self.nmax, device=elog.device)
+        elog[:, diag_idx, diag_idx] = float('-inf')  # prevent self-edges BEFORE sigmoid/BCE
         node_mask = torch.sigmoid(nlog)
         m = node_mask.unsqueeze(-1) * node_mask.unsqueeze(-2)
         A_soft = torch.sigmoid(elog) * m
@@ -41,26 +43,42 @@ class Generator(nn.Module):
 class Discriminator(nn.Module):
     """
     Discriminator for WGAN-GP with a light graph-aware critic.
+    Uses one-hop message passing with masked mean pooling.
+    Accepts dynamically sliced [B, N_b, ...] tensors (train loop will slice).
     """
     def __init__(self, nmax=121, cond_dim=4, hid=256):
         super(Discriminator, self).__init__()
-        self.node_mlp = nn.Sequential(nn.Linear(2, hid), nn.LeakyReLU(0.2, True),
-                                      nn.Linear(hid, hid), nn.LeakyReLU(0.2, True))
-        self.edge_mlp = nn.Sequential(nn.Linear(2*hid+1, hid), nn.LeakyReLU(0.2, True),
-                                      nn.Linear(hid, hid), nn.LeakyReLU(0.2, True))
-        self.head = nn.Sequential(nn.Linear(2*hid + 1 + cond_dim, hid),  # note +1 fix
-                                  nn.LeakyReLU(0.2, True),
-                                  nn.Linear(hid, 1))
+        self.node_mlp = nn.Sequential(
+            nn.Linear(2, hid), nn.LeakyReLU(0.2, True),
+            nn.Linear(hid, hid), nn.LeakyReLU(0.2, True)
+        )
+        self.edge_mlp = nn.Sequential(
+            nn.Linear(2*hid + 1, hid), nn.LeakyReLU(0.2, True),
+            nn.Linear(hid, hid), nn.LeakyReLU(0.2, True)
+        )
+        self.head = nn.Sequential(
+            nn.Linear(2*hid + 1 + cond_dim, hid),
+            nn.LeakyReLU(0.2, True),
+            nn.Linear(hid, 1)
+        )
         self.nmax = nmax
 
     def forward(self, nodes, A_soft, node_mask, cond):
-        # nodes: [B,N,2], A_soft: [B,N,N], node_mask: [B,N]
+        """
+        nodes:     [B, N, 2]
+        A_soft:    [B, N, N]
+        node_mask: [B, N]  (float in [0,1])
+        cond:      [B, C]
+        """
         B, N, _ = nodes.shape
-        m = node_mask.unsqueeze(-1)  # [B,N,1]
-        h = self.node_mlp(nodes) * m
-        h_msg = torch.matmul(A_soft, h)  # [B,N,hid]
-        pair = torch.cat([h, h_msg, A_soft.mean(dim=-1, keepdim=True)], dim=-1) * m
-        node_feat = (pair.sum(dim=1) / (node_mask.sum(dim=1, keepdim=True)+1e-6))
+        m = node_mask.unsqueeze(-1)                   # [B,N,1]
+        h = self.node_mlp(nodes) * m                  # [B,N,hid]
+        h_msg = torch.matmul(A_soft, h)               # [B,N,hid]
+        edge_stat = A_soft.mean(dim=-1, keepdim=True) # [B,N,1]
+        pair = torch.cat([h, h_msg, edge_stat], dim=-1) * m
+        # masked mean over nodes
+        denom = node_mask.sum(dim=1, keepdim=True).clamp_min(1e-6)  # [B,1]
+        node_feat = (pair.sum(dim=1) / denom)                        # [B, 2*hid+1]
         x = torch.cat([node_feat, cond], dim=-1)
         return self.head(x)
 
@@ -68,19 +86,21 @@ class Discriminator(nn.Module):
 def gradient_penalty(discriminator, real_data, fake_data, lambda_gp=10):
     """
     Computes gradient penalty for structured inputs.
+    real_data: (nodes, node_mask, A_soft, cond)
+    fake_data: (nodes, node_mask, A_soft, cond)
     """
     device = real_data[0].device
     B = real_data[0].size(0)
     # Interpolation coefficients
     alpha_nodes = torch.rand(B, 1, 1, device=device)
-    alpha_mask = torch.rand(B, 1, device=device)
-    alpha_adj = torch.rand(B, 1, 1, device=device)
-    alpha_cond = torch.rand(B, 1, device=device)
+    alpha_mask  = torch.rand(B, 1, device=device)
+    alpha_adj   = torch.rand(B, 1, 1, device=device)
+    alpha_cond  = torch.rand(B, 1, device=device)
 
     nodes_i = (alpha_nodes * real_data[0] + (1 - alpha_nodes) * fake_data[0]).requires_grad_(True)
-    mask_i = (alpha_mask * real_data[1] + (1 - alpha_mask) * fake_data[1]).requires_grad_(True)
-    adj_i = (alpha_adj * real_data[2] + (1 - alpha_adj) * fake_data[2]).requires_grad_(True)
-    cond_i = (alpha_cond * real_data[3] + (1 - alpha_cond) * fake_data[3]).requires_grad_(True)
+    mask_i  = (alpha_mask  * real_data[1] + (1 - alpha_mask)  * fake_data[1]).requires_grad_(True)
+    adj_i   = (alpha_adj   * real_data[2] + (1 - alpha_adj)   * fake_data[2]).requires_grad_(True)
+    cond_i  = (alpha_cond  * real_data[3] + (1 - alpha_cond)  * fake_data[3]).requires_grad_(True)
 
     d_interpolates = discriminator(nodes_i, adj_i, mask_i, cond_i)
     fake = torch.ones_like(d_interpolates, device=device)
@@ -105,10 +125,14 @@ def aux_losses(nodes, node_mask, elog, nodes_real, node_mask_real, A_real):
     m_edges = (m_node.unsqueeze(-1) * m_node.unsqueeze(-2)).bool()
     L_nodes = ((nodes - nodes_real)**2).sum(dim=-1)
     L_nodes = (L_nodes * m_node).sum() / (m_node.sum() + 1e-6)
+
+    # encourage node mask to match
     L_mask = F.binary_cross_entropy_with_logits(
-        torch.logit(node_mask.clamp(1e-6,1-1e-6)), node_mask_real, reduction='mean')
+        torch.logit(node_mask.clamp(1e-6, 1-1e-6)), node_mask_real, reduction='mean')
+
     triu = torch.triu(torch.ones_like(A_real), diagonal=1).bool()
     mask_tri = (m_edges & triu)
+    # use elog (pre-sigmoid) v.s. binary target
     L_edges = F.binary_cross_entropy_with_logits(
         elog[mask_tri], (A_real*1.0)[mask_tri], reduction='mean')
     return L_nodes, L_mask, L_edges

test.py

@@ -1,151 +1,173 @@
+# test.py
 import os
 import torch
 import numpy as np
 import matplotlib.pyplot as plt
 from models.wgan_gp import Generator
 from train_utils.preprocess_s1 import preprocess_s1
+from train import compute_graph_metrics
 
-def reconstruct_sample(sample_np, metadata, full_output_dim, index=None):
+
+# ---------------------------------------------------------------
+# Helper: reconstruct and plot real samples
+# ---------------------------------------------------------------
+def reconstruct_sample(sample_np, metadata, index=None):
     """
-    Reconstruct nodal coordinates, ele_nod, pel from flattened sample.
+    Reconstruct nodal coordinates, ele_nod, pel from a flattened dataset sample.
     """
-    if index is not None:
-        # Get per-sample metadata if available
-        per_sample_metadata = metadata.get('per_sample_metadata', [])
-        actual_nodes = per_sample_metadata[index]['n_nod_tot'] if index < len(per_sample_metadata) else metadata['max_nodes']
-        actual_elements = per_sample_metadata[index]['n_ele_tot'] if index < len(per_sample_metadata) else metadata['max_elements']
-    else:
-        actual_nodes = metadata['max_nodes']
-        actual_elements = metadata['max_elements']
-
     max_nodes = metadata['max_nodes']
     max_elements = metadata['max_elements']
 
-    # Indices
-    nodal_start = 0
     nodal_end = max_nodes * 2
-    ele_nod_start = nodal_end
-    ele_nod_end = ele_nod_start + max_elements * 2
-    pel_start = ele_nod_end
-    pel_end = pel_start + max_elements * 4
-
-    # Extract and reshape
-    nodal_flat = sample_np[nodal_start:nodal_end][:actual_nodes * 2]  # (actual_nodes * 2,)
-    nodal_coord = nodal_flat.reshape(-1, 2)  # (actual_nodes, 2)
-    ele_nod_flat = sample_np[ele_nod_start:ele_nod_end][:actual_elements * 2]  # (actual_elements * 2,)
-    ele_nod = ele_nod_flat.reshape(-1, 2).astype(int)  # (actual_elements, 2)
-    pel_flat = sample_np[pel_start:pel_end][:actual_elements * 4]  # (actual_elements * 4,)
-    pel = pel_flat.reshape(-1, 4)  # (actual_elements, 4)
-
-    # Filter valid edges: only if node indices are valid and exist
-    valid_mask = (ele_nod[:, 0] < actual_nodes) & (ele_nod[:, 1] < actual_nodes) & (ele_nod[:, 0] >= 0) & (ele_nod[:, 1] >= 0)
-    ele_nod = ele_nod[valid_mask]
-    pel = pel[valid_mask]
+    ele_end = nodal_end + max_elements * 2
+    pel_end = ele_end + max_elements * 4
+
+    nodal_flat = sample_np[:nodal_end]
+    ele_flat = sample_np[nodal_end:ele_end]
+    pel_flat = sample_np[ele_end:pel_end]
+
+    # Estimate actual counts (nonzero or non-negative)
+    nodal_coord = nodal_flat.reshape(-1, 2)
+    valid_nodes = np.where(np.abs(nodal_coord).sum(-1) > 0)[0]
+    nodal_coord = nodal_coord[valid_nodes]
+
+    ele_nod = ele_flat.reshape(-1, 2).astype(int)
+    valid_edges = (ele_nod[:, 0] >= 0) & (ele_nod[:, 1] >= 0)
+    ele_nod = ele_nod[valid_edges]
+    pel = pel_flat.reshape(-1, 4)[valid_edges]
+
+    # Filter to existing node indices
+    ele_nod = ele_nod[
+        (ele_nod[:, 0] < len(nodal_coord)) & (ele_nod[:, 1] < len(nodal_coord))
+    ]
 
     return nodal_coord, ele_nod, pel
 
-def plot_truss(nodal_coord, ele_nod, title="Generated Truss", ax=None):
-    """
-    Plot truss structure.
-    """
+
+def plot_truss(nodal_coord, ele_nod, title="Truss", ax=None, color_nodes="blue"):
+    """Plot truss structure with nodes and connecting edges."""
     if ax is None:
-        fig, ax = plt.subplots(figsize=(8, 6))
+        fig, ax = plt.subplots(figsize=(5, 4))
+    if len(nodal_coord) == 0:
+        return ax
 
     # Plot nodes
-    ax.scatter(nodal_coord[:, 0], nodal_coord[:, 1], c='blue', s=50, label='Nodes')
+    ax.scatter(nodal_coord[:, 0], nodal_coord[:, 1], c=color_nodes, s=40, label="nodes")
 
     # Plot edges
     for e in ele_nod:
-        if len(e) == 2 and e[0] < len(nodal_coord) and e[1] < len(nodal_coord):
+        if 0 <= e[0] < len(nodal_coord) and 0 <= e[1] < len(nodal_coord):
             x1, y1 = nodal_coord[e[0]]
             x2, y2 = nodal_coord[e[1]]
-            ax.plot([x1, x2], [y1, y2], 'k-', lw=1.5, alpha=0.7)
+            ax.plot([x1, x2], [y1, y2], "k-", lw=1.2, alpha=0.7)
 
-    ax.set_aspect('equal')
+    ax.set_aspect("equal")
     ax.set_title(title)
     ax.grid(alpha=0.3)
-    ax.legend()
     return ax
 
-def evaluate_and_visualize(checkpoints_path, n_samples=9, device='cpu'):
+
+# ---------------------------------------------------------------
+# Main evaluation + visualization
+# ---------------------------------------------------------------
+def evaluate_and_visualize(checkpoints_path, n_samples=6, device="cpu"):
     """
-    Load best generator, generate samples, visualize, and show metrics.
+    Load the trained generator, generate samples, plot real vs generated trusses,
+    show loss curves, and basic topology metrics.
     """
     device = torch.device(device)
 
-    # Load metadata and models
-    metadata = np.load(os.path.join(checkpoints_path, 'metadata.npy'), allow_pickle=True).item()
-    generator_state = torch.load(os.path.join(checkpoints_path, 'generator.pth'), map_location=device)
-    epoch_losses = np.load(os.path.join(checkpoints_path, 'epoch_losses.npy'), allow_pickle=True)
+    # ---- Load model + metadata ----
+    metadata = np.load(os.path.join(checkpoints_path, "metadata.npy"), allow_pickle=True).item()
+    generator_state = torch.load(os.path.join(checkpoints_path, "generator.pth"), map_location=device)
+    epoch_losses = np.load(os.path.join(checkpoints_path, "epoch_losses.npy"), allow_pickle=True)
 
-    generator = Generator(latent_dim=128, output_dim=metadata['total_dim']).to(device)
+    generator = Generator(latent_dim=128, nmax=metadata["max_nodes"], cond_dim=4).to(device)
     generator.load_state_dict(generator_state)
     generator.eval()
+    print(f"✅ Generator loaded. Using max_nodes={metadata['max_nodes']}, max_elements={metadata['max_elements']}")
 
-    print("Generator loaded. Metadata:", {k: v for k, v in metadata.items() if k != 'per_sample_metadata' and k != 'npz_files'})
-
-    # Load real data for comparison
+    # ---- Load some real samples ----
     real_data, _ = preprocess_s1(normalize_type=None)
     real_samples = real_data[:n_samples]
 
-    # Generate fake samples
+    # ---- Generate fake trusses ----
     with torch.no_grad():
         z = torch.randn(n_samples, 128, device=device)
-        fake_samples = generator(z).cpu().numpy()
-
-    # Plot real vs generated
-    fig, axes = plt.subplots(2, n_samples, figsize=(4*n_samples, 8))
-    axes = axes.flatten() if n_samples > 1 else [axes]
+        # Conditioning: average-case normalized values
+        cond_vals = [1.0, 1.0, 0.5, 0.5]
+        cond = torch.tensor([cond_vals] * n_samples, dtype=torch.float32, device=device)
+        nodes, node_mask, A_soft, _, _ = generator(z, cond)
+
+        nodes = nodes.cpu().numpy()
+        node_mask = node_mask.cpu().numpy()
+        A_soft = A_soft.cpu().numpy()
+
+    # ---- Build graph structures from generator outputs ----
+    fake_nodal_coords, fake_ele_nods = [], []
+    for b in range(n_samples):
+        valid_nodes = np.where(node_mask[b] > 0.5)[0]
+        coords = nodes[b, valid_nodes]
+        edges = []
+        for i in range(len(valid_nodes)):
+            for j in range(i + 1, len(valid_nodes)):
+                if A_soft[b, valid_nodes[i], valid_nodes[j]] > 0.5:
+                    edges.append([i, j])
+        fake_nodal_coords.append(coords)
+        fake_ele_nods.append(np.array(edges, dtype=int))
+
+    # ---- Plot real vs generated ----
+    fig, axes = plt.subplots(2, n_samples, figsize=(3 * n_samples, 6))
+    axes = axes.flatten()
 
     for i in range(n_samples):
-        # Real
-        nodal_real, ele_nod_real, _ = reconstruct_sample(real_samples[i], metadata, metadata['total_dim'], i)
-        plot_truss(nodal_real, ele_nod_real, f"Real {i+1}", ax=axes[i])
-
-        # Generated
-        nodal_fake, ele_nod_fake, _ = reconstruct_sample(fake_samples[i], metadata, metadata['total_dim'], i)
-        plot_truss(nodal_fake, ele_nod_fake, f"Gen {i+1}", ax=axes[i + n_samples])
+        nodal_real, ele_nod_real, _ = reconstruct_sample(real_samples[i], metadata)
+        plot_truss(nodal_real, ele_nod_real, f"Real {i+1}", ax=axes[i], color_nodes="tab:blue")
+        plot_truss(fake_nodal_coords[i], fake_ele_nods[i], f"Gen {i+1}", ax=axes[i + n_samples], color_nodes="tab:orange")
 
     plt.tight_layout()
     plt.show()
 
-    # Training metrics plot
-    losses = epoch_losses
-    epochs = [loss['epoch'] for loss in losses]
-    d_losses = [loss['d_loss'] for loss in losses]
-    g_losses = [loss['g_loss'] for loss in losses]
-
-    fig2, ax1 = plt.subplots(figsize=(10, 5))
-    ax1.plot(epochs, d_losses, label='Discriminator Loss', c='red')
-    ax1.plot(epochs, g_losses, label='Generator Loss', c='blue')
-    ax1.set_xlabel('Epoch')
-    ax1.set_ylabel('Loss')
-    ax1.set_title('Training Losses')
-    ax1.legend()
-    ax1.grid(alpha=0.3)
-    plt.show()
-
-    print("Training complete! Final epoch losses:")
-    final = losses[-1] if losses else {'d_loss': 0, 'g_loss': 0}
-    print(f"Final D Loss: {final['d_loss']:.4f}, G Loss: {final['g_loss']:.4f}")
-
-    # Generated metrics (using batch of fakes for quick eval)
-    from train_utils.preprocess_s1 import compute_sequence_lengths
-    fake_metrics = []
-    for sample_np in fake_samples[:min(5, n_samples)]:  # Small batch
-        fake_tensor = torch.tensor([sample_np], dtype=torch.float32)
-        metrics = compute_graph_metrics(fake_tensor, metadata)
-        fake_metrics.append(metrics)
-
-    avg_metrics = {k: np.mean([m[k] for m in fake_metrics]) for k in fake_metrics[0]}
-    print(f"Generated Metrics: {avg_metrics}")
-
-def compute_graph_metrics(fake_samples, metadata):
-    """
-    Quick graph metrics for generated samples.
-    """
-    from train import compute_graph_metrics as train_compute  # Reuse
-    return train_compute(fake_samples, metadata)
-
-if __name__ == '__main__':
-    evaluate_and_visualize('models/checkpoints', n_samples=6)
+    # ---- Plot training losses ----
+    if isinstance(epoch_losses, np.ndarray) and epoch_losses.size > 0:
+        # Convert to list of dicts if needed
+        if not isinstance(epoch_losses[0], dict):
+            epoch_losses = list(epoch_losses)
+    else:
+        print("⚠️ No training losses found.")
+        epoch_losses = []
+
+    if len(epoch_losses) > 0:
+        epochs = [e["epoch"] for e in epoch_losses]
+        d_losses = [e["d_loss"] for e in epoch_losses]
+        g_losses = [e["g_loss"] for e in epoch_losses]
+
+        plt.figure(figsize=(9, 4))
+        plt.plot(epochs, d_losses, "r-", label="Discriminator Loss")
+        plt.plot(epochs, g_losses, "b-", label="Generator Loss")
+        plt.xlabel("Epoch")
+        plt.ylabel("Loss")
+        plt.title("Training Loss Curves (WGAN-GP)")
+        plt.grid(alpha=0.3)
+        plt.legend()
+        plt.show()
+
+        final = epoch_losses[-1]
+        print(f"📉 Final Epoch {final['epoch']}: D={final['d_loss']:.3f}, G={final['g_loss']:.3f}")
+    else:
+        print("⚠️ No losses to plot.")
+
+    # ---- Compute metrics for generated batch ----
+    batch_size = min(5, n_samples)
+    nodes_batch = torch.tensor(nodes[:batch_size], dtype=torch.float32)
+    node_mask_batch = torch.tensor(node_mask[:batch_size], dtype=torch.float32)
+    A_soft_batch = torch.tensor(A_soft[:batch_size], dtype=torch.float32)
+    metrics = compute_graph_metrics(nodes_batch, A_soft_batch, node_mask_batch)
+    print(f"📊 Generated graph metrics:\n{metrics}")
+
+
+# ---------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------
+if __name__ == "__main__":
+    evaluate_and_visualize("models/checkpoints", n_samples=6)

train.py

@@ -1,187 +1,340 @@
+# train.py
 import os
 import torch
 import torch.optim as optim
 import numpy as np
-from torch.utils.data import DataLoader, TensorDataset
+from torch.utils.data import DataLoader, Dataset
+import torch.nn.functional as F
+import math
+
 from models.wgan_gp import Generator, Discriminator, gradient_penalty, aux_losses
 from train_utils.preprocess_s1 import preprocess_s1
-import networkx as nx
-import torch.nn.functional as F
+
+# ----------------------------
+# Utility: vectorized adjacency
+# ----------------------------
+def build_adj_from_eleblock_vectorized(ele_block, nmax_batch):
+    """
+    Vectorized adjacency build from a padded ele_nod block.
+    ele_block: float tensor [B, max_elems*2] (padded with -1 for invalid)
+    nmax_batch: int, number of nodes to consider for this batch (<= global nmax)
+    Returns:
+        A_real: float tensor [B, nmax_batch, nmax_batch] with 0/1 entries.
+    """
+    B = ele_block.size(0)
+    device = ele_block.device
+    # reshape to [B, M, 2]
+    pairs = ele_block.view(B, -1, 2).long()
+    rows = pairs[..., 0]  # [B, M]
+    cols = pairs[..., 1]  # [B, M]
+    # valid entries: both in [0, nmax_batch)
+    valid = (rows >= 0) & (cols >= 0) & (rows < nmax_batch) & (cols < nmax_batch)
+    if valid.any():
+        bidx = torch.arange(B, device=device).unsqueeze(1).expand_as(rows)
+        b_sel = bidx[valid]
+        r_sel = rows[valid]
+        c_sel = cols[valid]
+        A = torch.zeros(B, nmax_batch, nmax_batch, device=device)
+        A[b_sel, r_sel, c_sel] = 1.0
+        A[b_sel, c_sel, r_sel] = 1.0
+        # zero diagonal
+        idx = torch.arange(nmax_batch, device=device)
+        A[:, idx, idx] = 0.0
+        return A
+    else:
+        return torch.zeros(B, nmax_batch, nmax_batch, device=device)
 
 
-def connectivity_penalty(fake_samples, metadata):
+# ----------------------------
+# Dataset with size info (from legacy padded matrix)
+# ----------------------------
+class TrussFlatDataset(Dataset):
     """
-    Penalize generated trusses if disconnected (few valid edges per node).
+    Uses preprocess_s1() output (padded flat vectors), but carries per-sample sizes.
     """
-    batch_size = fake_samples.size(0)
-    max_nodes = metadata['max_nodes']
-    penalty = 0.0
-    for i in range(batch_size):
-        sample = fake_samples[i].detach().cpu().numpy()
-        node_block = sample[:max_nodes * 2]
-        ele_block = sample[max_nodes * 2 : max_nodes * 2 + metadata['max_elements'] * 2]
-        node_ids = np.unique(ele_block.astype(int))
-        valid_nodes = [n for n in node_ids if 0 <= n < max_nodes]
-        penalty += (max_nodes - len(valid_nodes))
-    return torch.tensor(penalty, dtype=torch.float32, device=fake_samples.device)
-
-
-def compute_graph_metrics(nodes, A_soft, node_mask):
+    def __init__(self, data_array: np.ndarray, metadata: dict):
+        super().__init__()
+        self.data = torch.tensor(data_array, dtype=torch.float32)
+        self.meta = metadata
+        self.max_nodes = int(self.meta['max_nodes'])
+        self.max_elems = int(self.meta['max_elements'])
+        self.size_info = torch.tensor(self.meta['size_info'], dtype=torch.long)  # [N, 2] = (n_nodes, n_elems)
+
+    def __len__(self):
+        return self.data.size(0)
+
+    def __getitem__(self, idx):
+        flat = self.data[idx]
+        n_nodes, n_elems = self.size_info[idx].tolist()
+        return flat, n_nodes, n_elems
+
+
+# ----------------------------
+# Length-bucketed sampler
+# ----------------------------
+def make_length_buckets(size_info: np.ndarray, bucket_width_nodes=16, bucket_width_elems=32):
     """
-    Evaluate connectivity and degree stats from generated graphs.
+    Assign samples to (node_bucket, elem_bucket) bins to reduce padding overhead per batch.
+    Returns: list of lists of indices (buckets).
     """
-    metrics = {'connectivity': [], 'degree_mean': [], 'degree_var': []}
-    nodes = nodes.detach().cpu().numpy()
-    A = (A_soft.detach().cpu().numpy() > 0.5).astype(int)
-    node_mask = node_mask.detach().cpu().numpy()
-    B, N, _ = nodes.shape
-    for b in range(B):
-        valid = node_mask[b] > 0.5
-        G = nx.Graph()
-        idxs = np.where(valid)[0]
-        G.add_nodes_from(idxs)
-        for i in idxs:
-            for j in idxs:
-                if i < j and A[b, i, j] > 0:
-                    G.add_edge(i, j)
-        if len(G.nodes) > 0:
-            degs = [d for _, d in G.degree()]
-            metrics['connectivity'].append(nx.number_connected_components(G))
-            metrics['degree_mean'].append(np.mean(degs))
-            metrics['degree_var'].append(np.var(degs))
-        else:
-            metrics['connectivity'].append(0)
-            metrics['degree_mean'].append(0)
-            metrics['degree_var'].append(0)
-    return {k: np.mean(v) if v else 0 for k, v in metrics.items()}
-
-
-def train_wgan_gp(device='cuda' if torch.cuda.is_available() else 'cpu',
+    buckets = {}
+    for i, (n, e) in enumerate(size_info):
+        bn = (int(n) // bucket_width_nodes) * bucket_width_nodes
+        be = (int(e) // bucket_width_elems) * bucket_width_elems
+        key = (bn, be)
+        buckets.setdefault(key, []).append(i)
+    # Return buckets sorted by size (optional)
+    return [idxs for _, idxs in sorted(buckets.items(), key=lambda kv: (kv[0][0], kv[0][1]))]
+
+
+def bucketed_batch_sampler(size_info: np.ndarray, batch_size=16,
+                           bucket_width_nodes=16, bucket_width_elems=32):
+    """
+    Yields lists of indices; each batch comes from a single bucket.
+    """
+    buckets = make_length_buckets(size_info, bucket_width_nodes, bucket_width_elems)
+    for idxs in buckets:
+        # shuffle within each bucket:
+        idxs = np.array(idxs)
+        perm = np.random.permutation(len(idxs))
+        idxs = idxs[perm]
+        # emit batches
+        for start in range(0, len(idxs), batch_size):
+            yield idxs[start:start+batch_size].tolist()
+
+
+# ----------------------------
+# Collate: dynamic per-batch padding & masks
+# ----------------------------
+def collate_truss(batch, max_nodes_global, max_elems_global):
+    """
+    batch: list of (flat, n_nodes, n_elems)
+    Returns tensors cropped to per-batch maximum sizes (dramatically smaller than global),
+    along with masks and split blocks.
+    """
+    flats, n_nodes_list, n_elems_list = zip(*batch)
+    B = len(flats)
+    # Per-batch maxima
+    nmax_b = max(n_nodes_list)
+    emax_b = max(n_elems_list)
+
+    flats = torch.stack(flats, 0)  # [B, total_dim]
+    # split from flat (global layout)
+    node_end = max_nodes_global * 2
+    ele_end  = node_end + max_elems_global * 2
+
+    nodes_full = flats[:, :node_end].view(B, max_nodes_global, 2)
+    ele_block_full = flats[:, node_end:ele_end]  # [B, max_elems_global*2]
+
+    # Crop to batch maxima (big speed/memory win)
+    nodes = nodes_full[:, :nmax_b, :]                     # [B, nmax_b, 2]
+    ele_block = ele_block_full[:, : (emax_b * 2)]         # [B, emax_b*2]
+
+    # Node mask from coords (nonzero rows). More robust: consider a tiny eps.
+    node_mask = (nodes.abs().sum(-1) > 0).float()         # [B, nmax_b]
+
+    # Build dense adjacency (vectorized) for real graphs
+    A_real = build_adj_from_eleblock_vectorized(ele_block, nmax_b)
+    # Mask adjacency by node existence
+    m = node_mask.unsqueeze(-1) * node_mask.unsqueeze(-2)
+    A_real = A_real * m
+    # Ensure zero diagonal
+    idx = torch.arange(nmax_b, device=A_real.device)
+    A_real[:, idx, idx] = 0.0
+
+    # Prepare conditioning per sample (normalized by GLOBAL maxima)
+    n_nodes_norm = torch.tensor([n / max_nodes_global for n in n_nodes_list], dtype=torch.float32, device=flats.device).unsqueeze(1)
+    n_elems_norm = torch.tensor([e / max_elems_global for e in n_elems_list], dtype=torch.float32, device=flats.device).unsqueeze(1)
+    # If height/spacing are needed here, you can plug them from file; for now random as before
+    height = torch.rand(B, 1, device=flats.device) * 0.8 + 0.2
+    spacing = torch.rand(B, 1, device=flats.device) * 0.8 + 0.2
+    cond = torch.cat([n_nodes_norm, n_elems_norm, height, spacing], dim=1)  # [B,4]
+
+    return nodes, node_mask, A_real, cond, nmax_b
+
+
+# ----------------------------
+# Connectivity penalty (vectorized)
+# ----------------------------
+def connectivity_penalty(fake_nodes_mask, fake_A_soft):
+    """
+    Penalize if too many isolated/invalid nodes: encourages edges incident to active nodes.
+    fake_nodes_mask: [B, N]
+    fake_A_soft:     [B, N, N]
+    Returns scalar tensor.
+    """
+    # degree per node = sum_j A_ij
+    deg = fake_A_soft.sum(dim=-1)  # [B, N]
+    active = (fake_nodes_mask > 0.5).float()
+    iso = (deg < 1e-3).float() * active
+    # penalty: mean number of isolated active nodes
+    return iso.mean()
+
+
+# ----------------------------
+# Training
+# ----------------------------
+def train_wgan_gp(device='cuda',
                   n_epochs=100, batch_size=16, latent_dim=128,
-                  n_critic=3, lr_g=2e-4, lr_d=1e-4,
-                  lambda_gp=10, lambda_connect=0.0,
-                  save_path='models/checkpoints'):
+                  n_critic=5, lr_g=2e-4, lr_d=1e-4,
+                  lambda_gp=10, lambda_connect=5.0,
+                  save_path='models/checkpoints',
+                  bucket_width_nodes=16, bucket_width_elems=32):
     """
-    Train WGAN-GP with structured Generator and Discriminator.
-    Includes keyboard interrupt save and best-model checkpointing.
+    Train WGAN-GP with:
+      - vectorized adjacency build
+      - length-bucketed batching
+      - dynamic per-batch padding & masking
     """
+    if not torch.cuda.is_available():
+        print("⚠️ CUDA not available, training on CPU will be slow.")
+        device = 'cpu'
     device = torch.device(device)
 
-    # Load data
+    # Load preprocessed (legacy padded) data but with size_info for bucketing
     data_array, metadata = preprocess_s1()
-    dataset = TensorDataset(torch.tensor(data_array, dtype=torch.float32))
-    dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
-    nmax = metadata['max_nodes']
-    max_elems = metadata['max_elements']
+    dataset = TrussFlatDataset(data_array, metadata)
+
+    # Bucketed batch sampler (reduces padding)
+    size_info = metadata['size_info']
+    sampler = list(bucketed_batch_sampler(size_info,
+                                          batch_size=batch_size,
+                                          bucket_width_nodes=bucket_width_nodes,
+                                          bucket_width_elems=bucket_width_elems))
 
-    # Init models
+    # We’ll build our own DataLoader-like loop b/c we use a custom sampler + collate
+    max_nodes_global = metadata['max_nodes']
+    max_elems_global = metadata['max_elements']
+
+    # Init models at GLOBAL maxima; we’ll slice per-batch for the critic pass
     cond_dim = 4  # [normed n_nodes, n_elems, height, spacing]
-    generator = Generator(latent_dim=latent_dim, nmax=nmax, cond_dim=cond_dim).to(device)
-    discriminator = Discriminator(nmax=nmax, cond_dim=cond_dim).to(device)
+    generator = Generator(latent_dim=latent_dim, nmax=max_nodes_global, cond_dim=cond_dim).to(device)
+    discriminator = Discriminator(nmax=max_nodes_global, cond_dim=cond_dim).to(device)
 
     opt_g = optim.Adam(generator.parameters(), lr=lr_g, betas=(0.0, 0.99))
     opt_d = optim.Adam(discriminator.parameters(), lr=lr_d, betas=(0.0, 0.99))
 
-    best_g_loss = float('inf')
+    best_score = float('-inf')
+    g_loss_ema = 0.0
     epoch_losses = []
     os.makedirs(save_path, exist_ok=True)
 
-    def make_cond(meta_batch, bs):
-        """Create conditioning vector matching current batch size."""
-        n_nodes = meta_batch['max_nodes'] / metadata['max_nodes']
-        n_elems = meta_batch['max_elements'] / metadata['max_elements']
-        height = np.random.uniform(0.2, 1.0)
-        spacing = np.random.uniform(0.2, 1.0)
-        cond = np.array([n_nodes, n_elems, height, spacing], dtype=np.float32)
-        cond = np.tile(cond, (bs, 1))
-        return torch.tensor(cond, device=device)
+    print(f"Starting training on {len(dataset)} samples with {len(sampler)} bucketed batches per epoch...")
 
     try:
-        print(f"Starting training on {len(dataset)} samples...")
         for epoch in range(n_epochs):
-            epoch_d_loss, epoch_g_loss = 0, 0
-
-            for real_flat, in dataloader:
-                real_flat = real_flat.to(device)
-                bs = real_flat.size(0)
-                cond = make_cond(metadata, bs)
-
-                # Extract structured tensors
-                nodes_real = real_flat[:, : nmax * 2].view(bs, nmax, 2)
-                node_mask_real = (nodes_real.abs().sum(-1) > 0).float()
-
-                # Build adjacency from ele_nod
-                ele_block = real_flat[:, nmax * 2 : nmax * 2 + max_elems * 2]
-                A_real = torch.zeros(bs, nmax, nmax, device=device)
-                for b in range(bs):
-                    for i in range(0, max_elems * 2, 2):
-                        n1 = int(ele_block[b, i].item())
-                        n2 = int(ele_block[b, i + 1].item())
-                        if 0 <= n1 < nmax and 0 <= n2 < nmax:
-                            A_real[b, n1, n2] = 1
-                            A_real[b, n2, n1] = 1
-                A_real = A_real * (node_mask_real.unsqueeze(-1) * node_mask_real.unsqueeze(-2))
-                A_real[:, torch.arange(nmax), torch.arange(nmax)] = 0  # zero diagonal per batch
-
-                cond = make_cond(metadata, bs)
+            epoch_d_loss, epoch_g_loss = 0.0, 0.0
+
+            # Shuffle order of batches each epoch for better mixing
+            perm_batches = np.random.permutation(len(sampler)).tolist()
+
+            for b_id in perm_batches:
+                idxs = sampler[b_id]
+                batch = [dataset[i] for i in idxs]
+
+                # --- Collate (dynamic crop + vectorized adjacency)
+                nodes_real, node_mask_real, A_real, cond, nmax_b = collate_truss(
+                    batch, max_nodes_global, max_elems_global
+                )
+                nodes_real = nodes_real.to(device)
+                node_mask_real = node_mask_real.to(device)
+                A_real = A_real.to(device)
+                cond = cond.to(device)
+                bs = nodes_real.size(0)
 
                 # ---- Train Discriminator ----
                 for _ in range(n_critic):
                     z = torch.randn(bs, latent_dim, device=device)
                     nodes_f, nmask_f, A_f, elog_f, nlog_f = generator(z, cond)
+
+                    # Slice generator outputs to per-batch effective size for the critic:
+                    nodes_f_b = nodes_f[:, :nmax_b, :]
+                    nmask_f_b = nmask_f[:, :nmax_b]
+                    A_f_b = A_f[:, :nmax_b, :nmax_b]
+                    elog_f_b = elog_f[:, :nmax_b, :nmax_b]  # just for aux losses later
+
                     d_real = discriminator(nodes_real, A_real, node_mask_real, cond)
-                    d_fake = discriminator(nodes_f.detach(), A_f.detach(), nmask_f.detach(), cond)
-                    gp = gradient_penalty(discriminator,
-                                          (nodes_real, node_mask_real, A_real, cond),
-                                          (nodes_f.detach(), nmask_f.detach(), A_f.detach(), cond),
-                                          lambda_gp)
+                    d_fake = discriminator(nodes_f_b.detach(), A_f_b.detach(), nmask_f_b.detach(), cond)
+
+                    gp = gradient_penalty(
+                        discriminator,
+                        (nodes_real, node_mask_real, A_real, cond),
+                        (nodes_f_b.detach(), nmask_f_b.detach(), A_f_b.detach(), cond),
+                        lambda_gp
+                    )
                     loss_d = -(d_real.mean() - d_fake.mean()) + gp
-                    opt_d.zero_grad()
+                    opt_d.zero_grad(set_to_none=True)
                     loss_d.backward()
                     opt_d.step()
 
                 # ---- Train Generator ----
                 z = torch.randn(bs, latent_dim, device=device)
                 nodes_f, nmask_f, A_f, elog_f, nlog_f = generator(z, cond)
-                d_fake = discriminator(nodes_f, A_f, nmask_f, cond)
+                nodes_f_b = nodes_f[:, :nmax_b, :]
+                nmask_f_b = nmask_f[:, :nmax_b]
+                A_f_b = A_f[:, :nmax_b, :nmax_b]
+                elog_f_b = elog_f[:, :nmax_b, :nmax_b]
+
+                d_fake = discriminator(nodes_f_b, A_f_b, nmask_f_b, cond)
                 adv_loss = -d_fake.mean()
 
-                L_nodes, L_mask, L_edges = aux_losses(nodes_f, nmask_f, elog_f,
-                                                      nodes_real, node_mask_real, A_real)
+                L_nodes, L_mask, L_edges = aux_losses(
+                    nodes_f_b, nmask_f_b, elog_f_b,
+                    nodes_real, node_mask_real, A_real
+                )
+
                 loss_g = adv_loss + 10 * L_nodes + 1 * L_mask + 5 * L_edges
 
                 if lambda_connect > 0:
-                    flat_fake = torch.cat([nodes_f.view(bs, -1),
-                                           A_f.view(bs, -1)], dim=1)
-                    loss_g += lambda_connect * connectivity_penalty(flat_fake, metadata)
+                    loss_g += lambda_connect * connectivity_penalty(nmask_f_b, A_f_b)
 
-                opt_g.zero_grad()
+                opt_g.zero_grad(set_to_none=True)
                 loss_g.backward()
                 opt_g.step()
 
                 epoch_d_loss += loss_d.item()
                 epoch_g_loss += loss_g.item()
 
-            # ---- Logging and checkpointing ----
-            epoch_d_loss /= len(dataloader)
-            epoch_g_loss /= len(dataloader)
+            # ---- Logging & checkpointing ----
+            num_batches = len(sampler)
+            epoch_d_loss /= num_batches
+            epoch_g_loss /= num_batches
             epoch_losses.append({'epoch': epoch + 1,
                                  'd_loss': epoch_d_loss,
                                  'g_loss': epoch_g_loss})
 
-            if (epoch + 1) % 5 == 0:
-                metrics = compute_graph_metrics(nodes_f, A_f, nmask_f)
-                print(f"[{epoch+1}/{n_epochs}] D Loss: {epoch_d_loss:.2f}, "
-                      f"G Loss: {epoch_g_loss:.2f}, "
-                      f"DegMean: {metrics['degree_mean']:.2f}, "
-                      f"Conn: {metrics['connectivity']:.2f}")
+            # quick graph stats (last batch’s fakes)
+            with torch.no_grad():
+                deg_mean = float(A_f_b.mean().item() * nmax_b)  # rough proxy
+                conn_proxy = float((A_f_b.sum(dim=-1) > 0.5).float().mean().item())
+
+            print(f"[{epoch+1}/{n_epochs}] D: {epoch_d_loss:.3f} | G: {epoch_g_loss:.3f} "
+                  f"| N_b:{nmax_b:3d} | DegMean~{deg_mean:.2f} | Conn~{conn_proxy:.2f}")
+
+            # Use exponential moving average to judge improvement
+            ema_beta = 0.9
+            if epoch == 0:
+                g_loss_ema = epoch_g_loss
+            else:
+                g_loss_ema = ema_beta * g_loss_ema + (1 - ema_beta) * epoch_g_loss
+
+            # Evaluate composite "stability score"
+            # Here we prioritize low |G_loss| (close to zero) and high connectivity
+            score = -abs(epoch_g_loss) + 0.5 * conn_proxy  # weights can be tuned
+
+            if score > best_score:
+                best_score = score
+                torch.save(generator.state_dict(), os.path.join(save_path, f'generator_best.pth'))
+                torch.save(discriminator.state_dict(), os.path.join(save_path, f'discriminator_best.pth'))
+                np.save(os.path.join(save_path, 'metadata.npy'), metadata)
+                print(f"✅ New best model at epoch {epoch+1}: score={score:.3f}, G_loss={epoch_g_loss:.3f}, Conn={conn_proxy:.2f}")
 
-                if epoch_g_loss < best_g_loss:
-                    best_g_loss = epoch_g_loss
-                    torch.save(generator.state_dict(), os.path.join(save_path, 'generator.pth'))
-                    torch.save(discriminator.state_dict(), os.path.join(save_path, 'discriminator.pth'))
-                    np.save(os.path.join(save_path, 'metadata.npy'), metadata)
-                    print(f"✅ New best G loss {best_g_loss:.2f} — models saved.")
+            # Also save periodic checkpoints (for recovery)
+            if (epoch + 1) % 10 == 0:
+                torch.save(generator.state_dict(), os.path.join(save_path, f'generator_epoch{epoch+1}.pth'))
+                torch.save(discriminator.state_dict(), os.path.join(save_path, f'discriminator_epoch{epoch+1}.pth'))
+                np.save(os.path.join(save_path, 'metadata.npy'), metadata)
+                print(f"💾 Periodic checkpoint saved at epoch {epoch+1}")
 
         # Final save
         np.save(os.path.join(save_path, 'epoch_losses.npy'), epoch_losses)
@@ -195,7 +348,7 @@ def train_wgan_gp(device='cuda' if torch.cuda.is_available() else 'cpu',
         torch.save(discriminator.state_dict(), os.path.join(save_path, 'discriminator_interrupted.pth'))
         np.save(os.path.join(save_path, 'metadata.npy'), metadata)
         print(f"🟡 Interrupted state saved to {save_path}.")
-        raise  # Re-raise to exit
+        raise
 
 
 if __name__ == '__main__':

train_utils/preprocess_s1.py

@@ -3,15 +3,13 @@ import numpy as np
 import os
 from collections import defaultdict
 from scipy.stats import zscore
+from typing import List, Dict, Any, Tuple
 
 def compute_sequence_lengths(dataset_folder="dataset", show_details=False):
     """
     Compute and print min/max sequence lengths (nodes, elements) across all trusses in the dataset.
     Uses only min/max n_div files per mode for efficiency.
 
-    Args:
-        dataset_folder (str): Path to the dataset folder containing .npz files.
-
     Returns:
         Dict with keys 'min_nodes', 'max_nodes', 'min_elements', 'max_elements'.
     """
@@ -50,14 +48,14 @@ def compute_sequence_lengths(dataset_folder="dataset", show_details=False):
     for mode in sorted(min_max_div):
         # For min
         if min_div_files[mode]:
-            min_file = min_div_files[mode][0]  # Pick first
+            min_file = min_div_files[mode][0]
             data_min = np.load(os.path.join(dataset_folder, min_file))
             min_n_nod = min(min_n_nod, int(data_min['n_nod_tot']))
             min_n_ele = min(min_n_ele, int(data_min['n_ele_tot']))
             data_min.close()
         # For max
         if max_div_files[mode]:
-            max_file = max_div_files[mode][0]  # Pick first
+            max_file = max_div_files[mode][0]
             data_max = np.load(os.path.join(dataset_folder, max_file))
             max_n_nod = max(max_n_nod, int(data_max['n_nod_tot']))
             max_n_ele = max(max_n_ele, int(data_max['n_ele_tot']))
@@ -66,8 +64,7 @@ def compute_sequence_lengths(dataset_folder="dataset", show_details=False):
     print(f"Overall min sequence lengths: nodes={min_n_nod}, elements={min_n_ele}")
     print(f"Overall max sequence lengths: nodes={max_n_nod}, elements={max_n_ele}")
 
-    # Additionally print out for one structure type how the keys inside look like
-    if show_details == True:
+    if show_details:
         example_mode = next(iter(max_div_files))
         example_file = max_div_files[example_mode][0]
         example_data = np.load(os.path.join(dataset_folder, example_file))
@@ -77,72 +74,112 @@ def compute_sequence_lengths(dataset_folder="dataset", show_details=False):
         example_data.close()
 
     return {
-        'min_nodes': min_n_nod,
-        'max_nodes': max_n_nod,
-        'min_elements': min_n_ele,
-        'max_elements': max_n_ele
+        'min_nodes': int(min_n_nod),
+        'max_nodes': int(max_n_nod),
+        'min_elements': int(min_n_ele),
+        'max_elements': int(max_n_ele),
+    }
+
+
+def _pad_1d(arr: np.ndarray, max_len: int, pad_val=0):
+    """Pad 1D array to max_len with pad_val."""
+    out = np.full((max_len,), pad_val, dtype=arr.dtype)
+    n = min(len(arr), max_len)
+    out[:n] = arr[:n]
+    return out
+
+
+def _pack_sample(data: np.lib.npyio.NpzFile) -> Dict[str, Any]:
+    """Extract a single sample (no padding) with lengths."""
+    nodal = data['nodal_coord']        # (n_nodes, 2)
+    ele_nod = data['ele_nod']          # (n_elems, 2) int
+    pel = data['pel']                  # (n_elems, 4) int (may be redundant for topology)
+
+    sample = {
+        'nodal': nodal.astype(np.float32),
+        'ele_nod': ele_nod.astype(np.int64),
+        'pel': pel.astype(np.int64),
+        'n_nodes': int(nodal.shape[0]),
+        'n_elems': int(ele_nod.shape[0]),
+        # Optional globals (kept here for conditioning/analysis)
+        'height': float(np.array(data['height']).item()) if 'height' in data else None,
+        'spacing': float(np.array(data['spacing']).item()) if 'spacing' in data else None,
+        'meta': {
+            'n_rods': int(np.array(data['n_rods']).item()) if 'n_rods' in data else None,
+            'n_beams': int(np.array(data['n_beams']).item()) if 'n_beams' in data else None,
+            'mode': str(np.array(data['truss_mode']).item()) if 'truss_mode' in data else None,
+        }
     }
+    return sample
+
 
-def pad_to_length(array, max_len):
+def load_truss_samples(dataset_folder="dataset") -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
     """
-    Pad 1D array to max_len with zeros.
+    Load ALL samples WITHOUT padding.
+    Returns:
+        samples: list of dicts with variable-length arrays and lengths.
+        metadata: dict with global min/max lengths and counts.
     """
-    if len(array) < max_len:
-        padded = np.zeros(max_len)
-        padded[:len(array)] = array
-        return padded
-    else:
-        return array[:max_len]  # Truncate if larger (shouldn't happen)
+    lengths = compute_sequence_lengths(dataset_folder)
+    npz_files = [f for f in os.listdir(dataset_folder) if f.endswith('.npz')]
+    samples = []
+    for f in npz_files:
+        data = np.load(os.path.join(dataset_folder, f))
+        samples.append(_pack_sample(data))
+        data.close()
 
-def preprocess_s1(dataset_folder="dataset", normalize_type=None):
-    """
-    Preprocesses truss dataset into flattened, padded vectors for Stage 1 GAN.
+    metadata = {
+        'max_nodes': lengths['max_nodes'],
+        'max_elements': lengths['max_elements'],
+        'n_samples': len(samples),
+    }
+    return samples, metadata
 
-    Args:
-        dataset_folder (str): Folder with .npz files.
-        normalize_type (str or None): 'min_max', 'z_score', or None (no normalization).
 
-    Returns:
-        np.ndarray: Shape (n_samples, total_dim), normalized if specified.
-        dict: Preprocessing metadata.
+def preprocess_s1(dataset_folder="dataset", normalize_type=None):
+    """
+    Backwards-compatible preprocessor: still returns a big padded matrix
+    for legacy code, but now:
+      - pads integer index arrays with -1 (safe),
+      - also returns per-sample (n_nodes, n_elems) for bucketing.
     """
-    # Get max lengths dynamically
     lengths = compute_sequence_lengths(dataset_folder)
     max_nodes = lengths['max_nodes']
     max_elements = lengths['max_elements']
-    total_dim = max_nodes * 2 + max_elements * 2 + max_elements * 4  # nodal (x,y) + ele_nod (2 nodes) + pel (4 props)
-
-    print(f"Max nodes: {max_nodes}, max elements: {max_elements}, total dim: {total_dim}")
+    total_dim = max_nodes * 2 + max_elements * 2 + max_elements * 4
 
     npz_files = [f for f in os.listdir(dataset_folder) if f.endswith('.npz')]
     samples = []
+    size_info = []
     for f in npz_files:
         data = np.load(os.path.join(dataset_folder, f))
-        nodal = data['nodal_coord'].flatten()  # (n_nodes * 2,)
-        ele_nod = data['ele_nod'].flatten()  # (n_elements * 2,)
-        pel = data['pel'].flatten()  # (n_elements * 4,)
+        nodal = data['nodal_coord'].flatten().astype(np.float32)     # (n_nodes * 2,)
+        ele_nod = data['ele_nod'].flatten().astype(np.int64)         # (n_elems * 2,)
+        pel = data['pel'].flatten().astype(np.int64)                 # (n_elems * 4,)
+
+        n_nodes = int(data['nodal_coord'].shape[0])
+        n_elems = int(data['ele_nod'].shape[0])
+        size_info.append([n_nodes, n_elems])
 
-        # Pad each
-        nodal_padded = pad_to_length(nodal, max_nodes * 2)
-        ele_nod_padded = pad_to_length(ele_nod, max_elements * 2)
-        pel_padded = pad_to_length(pel, max_elements * 4)
+        # Pad with safe values: floats→0.0, ints→-1
+        nodal_padded = _pad_1d(nodal, max_nodes * 2, pad_val=0.0)
+        ele_nod_padded = _pad_1d(ele_nod, max_elements * 2, pad_val=-1)
+        pel_padded = _pad_1d(pel, max_elements * 4, pad_val=-1)
 
-        # Concatenate
-        sample = np.concatenate([nodal_padded, ele_nod_padded, pel_padded])
+        sample = np.concatenate([nodal_padded, ele_nod_padded, pel_padded]).astype(np.float32)
         samples.append(sample)
         data.close()
 
-    data_array = np.array(samples)  # (n_samples, total_dim)
+    data_array = np.stack(samples, axis=0)  # (n_samples, total_dim)
 
-    # Normalize if requested
     if normalize_type == 'min_max':
         data_min = data_array.min()
         data_max = data_array.max()
-        data_array = (data_array - data_min) / (data_max - data_min)
+        data_array = (data_array - data_min) / (data_max - data_min + 1e-12)
     elif normalize_type == 'z_score':
-        data_array = zscore(data_array, axis=0)  # Per feature
+        data_array = zscore(data_array, axis=0)
     elif normalize_type is None:
-        pass  # Already normalized in generator
+        pass
     else:
         raise ValueError(f"Unknown normalize_type: {normalize_type}")
 
@@ -151,6 +188,7 @@ def preprocess_s1(dataset_folder="dataset", normalize_type=None):
         'max_elements': max_elements,
         'total_dim': total_dim,
         'n_samples': len(samples),
-        'normalize_type': normalize_type
+        'normalize_type': normalize_type,
+        'size_info': np.array(size_info, dtype=np.int32)  # (n_samples, 2)
     }
     return data_array, metadata

utils/dataset_helper.py

@@ -0,0 +1,167 @@
+import os
+import numpy as np
+import logging
+from utils.truss_geometric import calculate_bridge
+from utils.truss_constraints import (
+    calculate_essential_elements,
+    truss_design,
+    boundary_conditions,
+    calculate_element_properties,
+)
+from utils.truss_helpers import calculate_element_node
+
+# ------------------------------------------------------------
+# Logging configuration
+# ------------------------------------------------------------
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
+
+# ------------------------------------------------------------
+# Default parameters
+# ------------------------------------------------------------
+n_dim = 2
+n_par_nod = 2
+
+# Material & geometry properties
+width_properties = {"beam": 0.3, "column": 0.4, "rod": 0.1}  # m
+height_properties = {"beam": 0.35, "column": 0.4, "rod": 0.1}  # m
+unit_weight_properties = {"beam": 78.5, "column": 78.5, "rod": 78.5}  # kN/m³
+elastic_mod_properties = {"beam": 2e8, "column": 2e8, "rod": 2e8}  # kN/m²
+shear_mod = 8e7  # kN/m²
+
+# ------------------------------------------------------------
+# Dataset generation parameters
+# ------------------------------------------------------------
+span = 1.0
+truss_modes = ["pratt", "howe", "warren"]
+n_div_range = range(2, 61)
+angle_range = range(30, 61)
+dataset_folder = "dataset"
+os.makedirs(dataset_folder, exist_ok=True)
+
+# ------------------------------------------------------------
+# Main generation loop
+# ------------------------------------------------------------
+def generate_truss_dataset():
+    # num_generated = len(truss_modes) * len(n_div_range) * len(angle_range) # Currently it can be pre-calculated
+    num_generated = 0
+
+    for truss_mode in truss_modes:
+        for n_div in n_div_range:
+            for angle in angle_range:
+                skip_rod = []
+
+                # Geometry
+                height, spacing, diag = calculate_bridge(
+                    span, angle=angle, n_div=n_div, truss_mode=truss_mode
+                )
+
+                # Structural elements
+                n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_essential_elements(
+                    span, spacing, truss_mode, skip_rod
+                )
+                # Re-calculate for skip_rod
+                skip_rod = truss_design(n_bot_beams, n_rods, truss_mode)
+                n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_essential_elements(
+                    span, spacing, truss_mode, skip_rod
+                )
+
+                # Nodes and elements
+                nodal_coord, par, pel, ele_nod, n_par_tot = calculate_element_node(
+                    span,
+                    spacing,
+                    height,
+                    n_dim,
+                    n_par_nod,
+                    truss_mode,
+                    skip_rod,
+                )
+
+                X = nodal_coord[:, 0]
+                Y = nodal_coord[:, 1]
+
+                # Boundary conditions
+                W = boundary_conditions(
+                    n_bot_beams, n_par_nod, n_nod_tot, supports=["pin", "roller"]
+                )
+
+                # Initialize element property arrays
+                h = np.zeros(n_ele_tot, dtype=np.float32)
+                J = np.zeros(n_ele_tot, dtype=np.float32)
+                A = np.zeros(n_ele_tot, dtype=np.float32)
+                beta = np.zeros(n_ele_tot, dtype=np.float32)
+                ro = np.zeros(n_ele_tot, dtype=np.float32)
+                E = np.zeros(n_ele_tot, dtype=np.float32)
+
+                J, A, h, beta, ro, E, G = calculate_element_properties(
+                    n_ele_tot,
+                    n_columns,
+                    n_beams,
+                    diag,
+                    spacing,
+                    height,
+                    J,
+                    A,
+                    h,
+                    beta,
+                    ro,
+                    E,
+                    X,
+                    Y,
+                    ele_nod,
+                    shear_mod,
+                    width_properties,
+                    height_properties,
+                    unit_weight_properties,
+                    elastic_mod_properties,
+                    truss_mode,
+                )
+
+                # Save dataset
+                filename = f"{dataset_folder}/truss_{truss_mode}_{n_div}_{angle}.npz"
+                np.savez(
+                    filename,
+                    nodal_coord=nodal_coord,
+                    pel=pel,  # Element-DoF relation
+                    ele_nod=ele_nod,    # Element-node connectivity
+                    W=W,
+                    J=J,
+                    A=A,
+                    h=h,
+                    beta=beta,
+                    ro=ro,
+                    E=E,
+                    G=G,
+                    par=par,  # Nodal-DoF relation
+                    X=X,
+                    Y=Y,
+                    height=height,
+                    spacing=spacing,
+                    diag=diag,
+                    truss_mode=truss_mode,  # String saved as array of chars
+                    n_div=n_div,
+                    angle=angle,
+                    n_columns=n_columns,
+                    n_nod_tot=n_nod_tot,
+                    n_rods=n_rods,
+                    n_beams=n_beams,
+                    n_ele_tot=n_ele_tot,
+                    n_bot_beams=n_bot_beams,
+                    skip_rod=np.array(skip_rod),
+                )
+
+                num_generated += 1
+
+                logging.info(
+                    f"Saved truss {truss_mode}, n_div={n_div}, angle={angle} → {filename}"
+                )
+
+    logging.info(
+        f"✅ Generated and saved {num_generated} truss configurations to '{dataset_folder}'."
+    )
+
+
+# ------------------------------------------------------------
+# Script entry point
+# ------------------------------------------------------------
+if __name__ == "__main__":
+    generate_truss_dataset()

utils/dataset_verifier.py

@@ -0,0 +1,185 @@
+import os
+import math
+import random
+import numpy as np
+import matplotlib.pyplot as plt
+from collections import defaultdict
+
+
+def compute_sequence_lengths(dataset_folder="dataset", show_details=False):
+    """
+    Compute and print min/max sequence lengths (nodes, elements) across all trusses in the dataset.
+    Uses only min/max n_div files per mode for efficiency.
+    
+    Args:
+        dataset_folder (str): Path to the dataset folder containing .npz files.
+    
+    Returns:
+        Dict with keys 'min_nodes', 'max_nodes', 'min_elements', 'max_elements'.
+    """
+    npz_files = [f for f in os.listdir(dataset_folder) if f.endswith('.npz')]
+    if not npz_files:
+        raise ValueError(f"No .npz files found in '{dataset_folder}'.")
+
+    # First pass: compute min/max n_div per mode
+    min_max_div = defaultdict(lambda: (float('inf'), float('-inf')))
+    for f in npz_files:
+        parts = f[:-4].rsplit('_', 2)  # e.g., ['truss_pratt', '15', '39']
+        if len(parts) == 3 and parts[0].startswith('truss_'):
+            mode = parts[0][6:]  # Remove 'truss_'
+            n_div = int(parts[1])
+            min_d, max_d = min_max_div[mode]
+            min_max_div[mode] = (min(min_d, n_div), max(max_d, n_div))
+
+    # Second pass: collect one file per min/max per mode
+    min_div_files = defaultdict(list)
+    max_div_files = defaultdict(list)
+    for f in npz_files:
+        parts = f[:-4].rsplit('_', 2)
+        if len(parts) == 3 and parts[0].startswith('truss_'):
+            mode = parts[0][6:]
+            n_div = int(parts[1])
+            if n_div == min_max_div[mode][0]:
+                min_div_files[mode].append(f)
+            if n_div == min_max_div[mode][1]:
+                max_div_files[mode].append(f)
+
+    # # Print min/max n_div per mode
+    # print("Per truss type min/max segments (n_div):")
+    # for mode in sorted(min_max_div):
+    #     mn, mx = min_max_div[mode]
+    #     print(f"{mode}: {mn} - {mx}")
+
+    # Compute overall min/max sequence lengths by loading one min/max file per mode
+    min_n_nod = float('inf')
+    max_n_nod = 0
+    min_n_ele = float('inf')
+    max_n_ele = 0
+    for mode in sorted(min_max_div):
+        # For min
+        if min_div_files[mode]:
+            min_file = min_div_files[mode][0]  # Pick first
+            data_min = np.load(os.path.join(dataset_folder, min_file))
+            min_n_nod = min(min_n_nod, int(data_min['n_nod_tot']))
+            min_n_ele = min(min_n_ele, int(data_min['n_ele_tot']))
+            data_min.close()
+        # For max
+        if max_div_files[mode]:
+            max_file = max_div_files[mode][0]  # Pick first
+            data_max = np.load(os.path.join(dataset_folder, max_file))
+            max_n_nod = max(max_n_nod, int(data_max['n_nod_tot']))
+            max_n_ele = max(max_n_ele, int(data_max['n_ele_tot']))
+            data_max.close()
+
+    print(f"Overall min sequence lengths: nodes={min_n_nod}, elements={min_n_ele}")
+    print(f"Overall max sequence lengths: nodes={max_n_nod}, elements={max_n_ele}")
+    
+    # Additionally print out for one structure type how the keys inside look like
+    if show_details == True:
+        example_mode = next(iter(max_div_files))
+        example_file = max_div_files[example_mode][0]
+        example_data = np.load(os.path.join(dataset_folder, example_file))
+        print(f"\nExample data keys from '{example_file}': {example_data.files}")
+        for key in example_data.files:
+            print(f" - {key}: shape {example_data[key].shape}, dtype {example_data[key].dtype}")
+        example_data.close()
+    
+
+
+    return {
+        'min_nodes': min_n_nod,
+        'max_nodes': max_n_nod,
+        'min_elements': min_n_ele,
+        'max_elements': max_n_ele
+    }
+
+def load_and_visualize_random_truss(dataset_folder="dataset", num_samples=1, save_fig=False):
+    """
+    Load random truss(es) from the dataset folder and visualize them.
+    Arranges plots vertically in figures of 3 per row (or 2 if divisible by 2 but not 3).
+
+    Args:
+        dataset_folder (str): Path to the dataset folder containing .npz files.
+        num_samples (int): Number of random trusses to load and plot (default: 1).
+        save_fig (bool): If True, saves each multi-plot figure to dataset_folder.
+
+    Returns:
+        List of dicts with loaded data for each sample (for further use).
+    """
+    npz_files = [f for f in os.listdir(dataset_folder) if f.endswith('.npz')]
+    if not npz_files:
+        raise ValueError(f"No .npz files found in '{dataset_folder}'.")
+
+    samples = []
+    random.shuffle(npz_files)
+    npz_files = npz_files[:num_samples]
+
+    # Determine layout per figure
+    if num_samples % 3 == 0 or num_samples > 3:
+        n_cols = 3
+    elif num_samples % 2 == 0:
+        n_cols = 2
+    else:
+        n_cols = 1
+    n_rows = math.ceil(num_samples / n_cols)
+
+    fig, axes = plt.subplots(n_rows, n_cols, figsize=(5*n_cols, 3.5*n_rows))
+    axes = np.atleast_1d(axes).flatten()
+
+    for i, filename in enumerate(npz_files):
+        filepath = os.path.join(dataset_folder, filename)
+        data = np.load(filepath)
+
+        nodal_coord = data['nodal_coord']
+        ele_nod = data['ele_nod']
+        truss_mode = str(data['truss_mode'])
+        n_div = int(data['n_div'])
+        angle = float(data['angle'])
+
+        n_beams = int(data['n_beams'])
+        n_columns = int(data['n_columns'])
+        n_rods = int(data['n_rods'])
+        n_ele_tot = int(data['n_ele_tot'])
+
+        ax = axes[i]
+        ax.set_xlim(-0.05, 1.05)
+        ax.set_ylim(-0.05, max(nodal_coord[:,1]) * 1.1)
+        ax.set_aspect('equal')
+        ax.set_title(f"{truss_mode} (n_div={n_div}, angle={angle:.0f}°)")
+        ax.grid(True, alpha=0.3)
+
+        # Plot nodes
+        bottom_mask = np.abs(nodal_coord[:,1]) < 1e-6
+        ax.scatter(nodal_coord[bottom_mask, 0], nodal_coord[bottom_mask, 1],
+                   c='blue', s=45, label='Bottom Nodes')
+        ax.scatter(nodal_coord[~bottom_mask, 0], nodal_coord[~bottom_mask, 1],
+                   c='red', s=45, label='Top Nodes')
+
+        # Plot elements
+        for j in range(n_ele_tot):
+            node1, node2 = ele_nod[j]
+            x1, y1 = nodal_coord[node1]
+            x2, y2 = nodal_coord[node2]
+            if j < n_beams:
+                ax.plot([x1, x2], [y1, y2], 'g-', lw=2, label='Beams' if j == 0 else "")
+            elif j < n_beams + n_columns:
+                ax.plot([x1, x2], [y1, y2], 'k-', lw=3, label='Columns' if j == n_beams else "")
+            else:
+                ax.plot([x1, x2], [y1, y2], 'purple', ls='--', lw=1.5, label='Rods' if j == n_beams + n_columns else "")
+
+        ax.legend(loc='upper right', fontsize=8)
+        samples.append({k: data[k] for k in data.files})
+
+    # Hide any unused axes
+    for j in range(num_samples, len(axes)):
+        axes[j].axis('off')
+
+    plt.tight_layout()
+
+    if save_fig:
+        out_path = os.path.join(dataset_folder, f"random_truss_grid_{num_samples}.png")
+        plt.savefig(out_path, dpi=150, bbox_inches='tight')
+        print(f"Saved figure to {out_path}")
+
+    plt.show()
+    return samples

utils/truss_constraints.py

@@ -0,0 +1,60 @@
+# General parameters
+span = 50 # in m
+angle = 0 # in degrees
+n_dim = 2 # Number of dimensions
+n_nod_ele = 2 # Number of nodes per element
+n_par_nod = 3 # Number of parameters per node
+n_par_ele = n_par_nod * n_nod_ele # Number of parameters per element
+
+# Plot settings
+n_discritizations = 10 # Number of points for plotting
+n_plots = 4 # Number of plots for bridge's truss
+
+# Columns 40x40 and beams 30x35 in cm and rods 10x10 in cm
+width_beam = 0.3
+height_beam = 0.35
+
+width_column = 0.4
+height_column = 0.4
+
+width_rod = 0.1
+height_rod = 0.1
+
+# Horizontal load on columns and angle in kN and degrees
+po = 100
+theta = 0
+
+# Unit weight and elastic modulus in kN/m^3 and kN/m^2
+unit_weight_steel = 78.5
+elastic_mod = 21*10**7
+elastic_mod_rod = 21*10**7
+
+# Shear modulus in kN/m^2
+shear_mod = 8*10**6
+k_shear = 0.9
+
+
+
+################## HASHMAPS ##################
+
+# put them all in a hashmap for easy access
+width_properties = {}
+height_properties = {}
+unit_weight_properties = {}
+elastic_mod_properties = {}
+
+width_properties['beam'] = width_beam
+width_properties['column'] = width_column
+width_properties['rod'] = width_rod
+
+height_properties['beam'] = height_beam
+height_properties['column'] = height_column
+height_properties['rod'] = height_rod
+
+unit_weight_properties['beam'] = unit_weight_steel
+unit_weight_properties['column'] = unit_weight_steel
+unit_weight_properties['rod'] = unit_weight_steel
+
+elastic_mod_properties['beam'] = elastic_mod
+elastic_mod_properties['column'] = elastic_mod
+elastic_mod_properties['rod'] = elastic_mod_rod

utils/truss_element_assembly.py

@@ -0,0 +1,211 @@
+import numpy as np
+from typing import List, Tuple
+
+
+def nodal_coords(n_nod_tot: int, n_dim: int, n_columns: int, spacing: float, 
+                 height: float, n_bot_beams: int, truss_mode: str) -> np.ndarray:
+    """
+    Calculate the coordinate of the nodes in the assembly.
+
+    Args:
+        n_nod_tot (int): Total number of nodes.
+        n_dim (int): Number of dimensions.
+        n_columns (int): Number of columns.
+        spacing (float): Spacing between columns (length of beams)
+        height (float): Height of the columns .
+        n_bot_beams (int): Number of bottom beams.
+        truss_mode (str): Mode of the truss ("warren" or other)
+                        currently supports pratt and howe as other.
+
+    Returns:
+        np.ndarray: The nodal coordinates of the assembly.
+    """
+    nodal_coord = np.zeros((n_nod_tot, n_dim), dtype=float)
+
+    # Calculate the nodal coordinates
+    if truss_mode == "simple" or truss_mode == "simple_cant":
+        for i in range(n_nod_tot):
+            nodal_coord[i] += [i * spacing, 0]
+    elif truss_mode != "warren":
+        for i in range(n_columns + 2):
+            nodal_coord[i] += [i * spacing, 0]
+            if 0 < i < n_columns + 1:
+                nodal_coord[i + n_columns + 1] += [i * spacing, height]
+    else:
+        for i in range(n_nod_tot - n_bot_beams):
+            nodal_coord[i] += [i * spacing, 0]
+            if i > 0:
+                nodal_coord[i + n_bot_beams] += [i * spacing - spacing / 2, height]
+
+    return nodal_coord
+
+
+def pel_ele(par: np.ndarray, n_columns: int, n_beams: int, n_rods: int, 
+            n_par_nod: int, n_nod_tot: int, n_ele_tot: int, n_bot_beams: int, 
+            truss_mode: str, skip_rod: List[int] = []) -> np.ndarray:
+    """
+    Calculate the parameter-element numbering relation.
+    Built from Beam -> Column -> Rods (considering skipped rods).
+
+    Args:
+        par (np.ndarray): Parameters for the elements.
+        n_columns (int): Number of columns.
+        n_beams (int): Number of beams.
+        n_rods (int): Number of rods.
+        n_par_nod (int): Number of parameters per node.
+        n_nod_tot (int): Total number of nodes.
+        n_ele_tot (int): Total number of elements.
+        n_bot_beams (int): Number of bottom beams.
+        truss_mode (str): Mode of the truss ("warren", "pratt", etc.).
+        skip_rod (List[int]): Rods to skip. 0-indexed.
+
+    Returns:
+        np.ndarray: The parameter-element numbering relation.
+    """
+    if "simple" in truss_mode:
+        pel = beam_pars(par, n_beams, n_par_nod, n_nod_tot, n_bot_beams, truss_mode)
+    else:
+        pel = np.zeros((n_ele_tot - len(skip_rod), 2 * n_par_nod), dtype=int)
+
+        # Calculate the element parameter relations
+        pel[:n_beams] = beam_pars(par, n_beams, n_par_nod, n_nod_tot, n_bot_beams, truss_mode)
+        if truss_mode != "warren":
+            pel[n_beams:n_beams + n_columns] = column_pars(par, n_columns, n_par_nod)
+        pel[n_beams + n_columns:] = rod_pars(par, n_rods, n_par_nod, n_nod_tot, n_bot_beams, truss_mode, skip_rod)
+    
+    return pel
+
+
+def beam_pars(par: np.ndarray, n_beams: int, n_par_nod: int,
+              n_nod_tot: int, n_bot_beams: int,
+              truss_mode: str) -> np.ndarray:
+    """
+    Calculate the relevant beam DoFs.
+
+    Args:
+        par (np.ndarray): Parameters for the elements.
+        n_beams (int): Number of beams.
+        n_par_nod (int): Number of parameters per node.
+        n_nod_tot (int): Total number of nodes.
+        n_bot_beams (int): Number of bottom beams.
+
+    Returns:
+        np.ndarray: The beam DoFs.
+    """
+    beams = np.zeros((n_beams, 2 * n_par_nod))
+
+    if "simple" in truss_mode:
+        for i in range(n_beams):
+            beams[i, :n_par_nod] = par[i]
+            beams[i, n_par_nod:] = par[i + 1]
+    else:
+        beams[:n_bot_beams, :n_par_nod] = par[:n_bot_beams]
+        beams[:n_bot_beams, n_par_nod:] = par[1:n_bot_beams + 1]
+
+        beams[n_bot_beams:, :n_par_nod] = par[n_bot_beams + 1:n_nod_tot - 1]
+        beams[n_bot_beams:, n_par_nod:] = par[n_bot_beams + 2:]
+
+    return beams
+
+
+def column_pars(par: np.ndarray, n_columns: int, n_par_nod: int) -> np.ndarray:
+    """
+    Calculate the relevant column DoFs.
+
+    Args:
+        par (np.ndarray): Parameters for the elements.
+        n_columns (int): Number of columns.
+        n_par_nod (int): Number of parameters per node.
+
+    Returns:
+        np.ndarray: The column DoFs.
+    """
+    columns = np.zeros((n_columns, 2 * n_par_nod))
+    for i in range(1, n_columns + 1):
+        columns[i - 1][:n_par_nod] = par[i]
+        columns[i - 1][n_par_nod:] = par[i + n_columns + 1]
+
+    return columns
+
+
+def rod_pars(par: np.ndarray, n_rods: int, n_par_nod: int, n_nod_tot: int, 
+             n_bot_beams: int, truss_mode: str, skip_rod: List[int] = []) -> np.ndarray:
+    """
+    Calculate the relevant rod DoFs.
+
+    Args:
+        par (np.ndarray): Parameters for the elements.
+        n_rods (int): Number of rods.
+        n_par_nod (int): Number of parameters per node.
+        n_nod_tot (int): Total number of nodes.
+        n_bot_beams (int): Number of bottom beams.
+        truss_mode (str): Mode of the truss ("warren" or other).
+        skip_rod (List[int]): The rods to skip. From left to right.
+
+    Returns:
+        np.ndarray: The rod DoFs.
+    """
+    rods = np.zeros((n_rods - len(skip_rod), 2 * n_par_nod))
+    
+    count = 0
+    skips = 0
+
+    for i in range(n_nod_tot - n_bot_beams - 1):
+        for j in range(2):
+            if count not in skip_rod:
+                rods[count - skips][n_par_nod:] = par[i + n_bot_beams + 1]
+                if j > 0 and truss_mode != "warren":
+                    rods[count - skips][:n_par_nod] = par[2 * j + i]
+                else:
+                    rods[count - skips][:n_par_nod] = par[j + i]
+            else:
+                skips += 1
+            count += 1
+
+    return rods
+
+
+def fill_ele_nod(n_ele_tot: int, n_par_nod: int, pel: np.ndarray, 
+                 skip_rod: List[int] = []) -> np.ndarray:
+    """
+    Fill the element-nodal matrix.
+
+    Args:
+        n_ele_tot (int): Total number of elements.
+        n_par_nod (int): Number of parameters per node.
+        pel (np.ndarray): Parameter-element numbering relation.
+        skip_rod (List[int]): Rods to skip.
+
+    Returns:
+        np.ndarray: The element-nodal matrix.
+    """
+    ele_nod = np.zeros((n_ele_tot - len(skip_rod), 2), dtype=int)
+
+    ele_nod[:, 0] = pel[:, 0] // n_par_nod
+    ele_nod[:, 1] = pel[:, n_par_nod] // n_par_nod
+
+    return ele_nod
+
+
+# If main is called, run the test
+if __name__ == "__main__":
+    n_par_nod = 3
+    par = np.arange(1, 7*n_par_nod+1).reshape(7, n_par_nod)
+    n_beams = 5
+    truss_mode = "warren"
+    n_bot_beams = 3
+    n_nod_tot = 7
+    n_rods = 6
+    n_dim = 3
+    n_columns = 2
+
+    if truss_mode == "warren":
+        n_columns = 0
+    n_ele_tot = n_beams + n_columns + n_rods
+
+    print(par)
+    # beams =  beam_pars(par, n_beams, n_par_nod, n_nod_tot, n_bot_beams)
+    # rods = rod_pars(par, n_rods, n_par_nod, n_bot_beams, skip_rod=[])
+    pel = pel_ele(par, n_columns, n_beams, n_rods, n_par_nod, n_nod_tot, n_ele_tot, n_bot_beams, truss_mode, skip_rod)
+
+    print(pel)

utils/truss_geometric.py

@@ -0,0 +1,496 @@
+import logging
+import numpy as np
+import matplotlib.pyplot as plt
+from typing import Dict, Tuple, List, Optional
+from utils.truss_element_assembly import nodal_coords, pel_ele, fill_ele_nod
+
+MIN_ANGLE = np.pi / 6
+MAX_ANGLE = np.pi / 3
+
+# Get the logger
+logger = logging.getLogger(__name__)
+
+
+################## Geometric Functions ##################
+def calculate_max_height(span: float, angle: float, spacing: float = 0,
+                         tol_round: Optional[List] = None) -> Tuple[float, float]:
+    """
+    Calculate the maximum height and spacing for the given span and angle.
+    If spacing is given, no span/spacing ratio is respected.
+
+    Args:
+        span: The total length of the bridge.
+        angle: The angle of the diagonal rods in radians.
+        spacing: Pre-defined spacing between columns. If 0, it will be calculated.
+        allowed_round: The number of decimal places to round the height to. first value is for height, second for spacing.
+                    More angles will be found with higher values.
+
+    Returns:
+        A tuple containing the height and spacing if valid, otherwise (-1, 0).
+    """
+    if tol_round is None:
+        tol_round = [3, 1]
+
+    if not MIN_ANGLE <= angle <= MAX_ANGLE:
+        logging.warning("The angle should be between %d and %d. "
+                        "Defaulting to 45 degrees.", np.degrees(MIN_ANGLE), np.degrees(MAX_ANGLE))
+        angle = np.radians(45)
+    
+    if spacing:
+        height = round(spacing * np.tan(angle), tol_round[0])
+        return height, spacing
+
+    for i in range(15, 21):
+        height = round(span / i, tol_round[0])
+        spacing = round(height / np.tan(angle), tol_round[1])
+        if span % spacing == 0: 
+            return height, spacing
+
+    return -1, 0
+
+
+def try_angles(span: float, base_angle: int, lower_limit: float = 30, upper_limit: float = 60,
+               tol_round: Optional[List] = None) -> Tuple[float, float, float]:
+    """
+    Try to find a valid height and spacing by adjusting the angle.
+    
+    Args:
+        span: The total length of the bridge.
+        base_angle: The base angle of the diagonal rods in degrees.
+
+    Returns:
+        A tuple containing the height, spacing, and adjusted angle in degrees if found, otherwise (-1, -1, -1).
+    """
+    if tol_round is None:
+        tol_round = [3, 1]
+        
+    # Calculate the distance of the angle from pi/3 and pi/6 to use in range
+    angle_diff = int(max(abs(base_angle - lower_limit), abs(base_angle - upper_limit)))
+
+    for shift in range(angle_diff):
+        for sign in [1, -1]:
+            adjusted_angle = np.radians(base_angle + sign * shift)
+            height, spacing = calculate_max_height(span, adjusted_angle, tol_round=tol_round)
+
+            # If a suitable height is found
+            if spacing:
+                return height, spacing, base_angle + sign * shift
+    return -1, -1, -1
+
+
+def calculate_bridge(span: float, angle: int = 45, n_div: int = None, spacing: float = 0,
+                     truss_mode: str = "pratt", lower_limit: int = 30,
+                     upper_limit: int = 60, tol_round: Optional[List] = None) -> Tuple[float, float, float]:
+    """
+    Calculate the height of the bridge, spacing of columns, and diagonal length of rods.
+    If n_div is provided, spacing is set as span / n_div and height is adjusted accordingly (priority: n_div > spacing > angle search).
+    Span can be normalized to 1 for dataset generation.
+
+    Args:
+        span (float): The total length of the bridge (e.g., 1 for normalized).
+        angle (float): The angle of the diagonal rods in degrees. Default is 45 degrees.
+        n_div (int, optional): Number of divisions (panels/segments). If provided, sets spacing = span / n_div.
+        spacing (float, optional): Pre-defined spacing. Used if n_div is None.
+        truss_mode (str): The mode of the truss bridge (warren, pratt, howe). Defaults to pratt.
+
+    Returns:
+        (float, float, float): The height of the bridge, the distance between columns,
+                               and the length of the diagonal elements (rods).
+    """
+    space_divisor = 1 
+    if truss_mode == "warren":
+        space_divisor = 2  # Since nodes are in the middle of the beams
+
+    if n_div is not None:
+        if n_div <= 0:
+            raise ValueError("n_div must be a positive integer.")
+        spacing = span / n_div
+        angle_rad = np.radians(angle)
+        height = (spacing / space_divisor) * np.tan(angle_rad)  # Consistent angle across modes
+    elif spacing:
+        angle_rad = np.radians(angle)
+        height, spacing = calculate_max_height(span, angle_rad, spacing, tol_round=tol_round)
+    else:
+        logging.info("Trying to find a suitable height and spacing based on the angle.")
+        height, spacing, used_angle = try_angles(span, angle, lower_limit,
+                                                 upper_limit, tol_round=tol_round)
+        used_angle = round(used_angle, 2)
+
+        if height == -1:
+            raise RuntimeError("A suitable height for the bridge could not be found. Please adjust the span")
+
+        if angle != used_angle:
+            logging.warning("Adjusted angle to %.2f degrees to find a solution.", used_angle)
+
+    diag = np.sqrt((spacing / space_divisor)**2 + height**2)
+    return height, spacing, diag
+
+
+def calculate_essential_elements(span: float, spacing: float, truss_mode: str ="pratt", 
+                                 skip_rod: Optional[List] = None) -> Tuple[int, int, int, int, int, int]:
+    """
+    Calculate the number of columns, nodes, rods, beams and total elements.
+    (Unchanged docstring and rest.)
+    """
+    if skip_rod is None:
+        skip_rod = []
+
+    ratio = int(round(span / spacing))  # Fixed: Use round to handle float precision
+    if truss_mode != "warren":
+        n_columns = ratio - 1
+        n_beams = int(ratio * 2 - 2)
+        n_bot_beams = int(n_beams // 2 + 1)
+        n_rods = n_beams
+    else:
+        n_columns = 0
+        n_beams = int(ratio * 2 - 1)
+        n_bot_beams = int(np.ceil(n_beams / 2))
+        n_rods = n_beams + 1 
+
+    n_rods = n_rods - len(skip_rod)
+    n_nod_tot = n_beams + 2
+    n_ele_tot = n_columns + n_rods + n_beams
+
+    return n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams
+
+
+def calculate_simple_elements(span: float, spacing: float, truss_mode: str, col_placements: Optional[List] = None,
+                              skip_col: Optional[List] = None, beam_partition: int = 1) -> Tuple[int, int, int, int, int, int]:
+    """
+    Calculate the number of columns and beams for a simple bridge, along with their spacing.
+
+    Args:
+        span (float): The total length of the bridge.
+        spacing (float): The distance between nodes (columns) in the bridge.
+        truss_mode (str): The mode of the truss bridge (simple, simple_cant)
+                        Defaults to pratt.
+
+    Returns:
+        (int, int, int, int, int): The number of columns, nodes, 
+                                rods, beams, and total elements.
+    """
+    extra_beams = 0 # Extra beams for cantilevered bridges
+    if col_placements:
+        n_columns = len(col_placements)
+    else:
+        n_columns = int(span // spacing) + 1
+    
+    if skip_col:
+        n_columns -= len(skip_col)
+
+    if truss_mode != "simple":
+        extra_beams = 1
+
+    if beam_partition > 1:
+        if col_placements:
+            raise ValueError("Cannot partition beams with custom column placements.")
+        if spacing // beam_partition < spacing / beam_partition:
+            raise ValueError("Beam partition should be a divisor of the spacing.")
+        n_beams = (n_columns - 1 + extra_beams) * beam_partition
+    else:
+        print("Defaulting partition to 1.")
+        n_beams = n_columns - 1 + extra_beams
+    
+    n_nod_tot = n_beams + 2
+    n_ele_tot = n_columns + n_beams
+
+    return n_columns, n_nod_tot, 0, n_beams, n_ele_tot, 0
+
+
+def calculate_element_node(span: float, spacing: float, height: float, n_dim: int,
+                           n_par_nod: int, truss_mode: str = "pratt",
+                           skip_rod: Optional[List] = None) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int]:
+    """
+    Calculate the nodal coordinates, nodal-param relation and 
+    element-node relationships for a truss bridge.
+
+    Args:
+        span (float): The total length of the bridge.
+        spacing (float): The distance between nodes (columns) in the bridge.
+        height (float): The height of the bridge.
+        diag (float): The length of the diagonal elements (rods) in the bridge.
+        n_dim (int): The number of dimensions in the bridge 
+                    (usually 2 for 2D bridges).
+        n_par_nod (int): The number of parameters per node 
+                        (usually 2 for 2D bridges: x and y coordinates).
+
+    Returns:
+        nodal_coord (numpy.ndarray): A 2D array where each row represents a 
+                                    node and the columns are the x and y coordinates of the node.
+        par (numpy.ndarray): A 2D array where each row represents a node and 
+                            the columns are the parameters associated with the node.
+        pel (numpy.ndarray): A 2D array where each row represents an element (beam, column, or rod) 
+                            and the columns are the nodes associated with the element.
+        ele_nod (numpy.ndarray): A 2D array where each row represents an element and 
+                                the columns are the nodes associated with the element.
+        n_par_tot (int): The total number of parameters in the bridge.
+    """
+    # Calculate the number of columns, rods, beams, total nodes and total parameters
+    if skip_rod is None:
+        skip_rod = []
+        
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_essential_elements(span, spacing, truss_mode)
+    n_par_tot = n_nod_tot * n_par_nod
+
+    # Calculate the positions of the nodes
+    nodal_coord = nodal_coords(n_nod_tot, n_dim, n_columns, spacing, height, n_bot_beams, truss_mode)
+
+    # Calculate the nodal-param relation
+    par = np.arange(1, n_nod_tot * n_par_nod + 1).reshape(n_nod_tot, n_par_nod)
+
+    # Calculate the element-param relationships
+    pel = pel_ele(par, n_columns, n_beams, n_rods, n_par_nod, n_nod_tot, 
+                  n_ele_tot, n_bot_beams, truss_mode, skip_rod)
+
+    # Calculate the element-node relationships
+    ele_nod = fill_ele_nod(n_ele_tot, n_par_nod, pel, skip_rod)
+    
+    return nodal_coord, par, pel, ele_nod, n_par_tot
+
+
+def calculate_element_properties(n_ele_tot: int, n_columns: int, n_beams: int, diag: float, spacing: float, 
+                                 height: float, J: np.array, A: np.array, h: np.array, beta: np.array,
+                                 ro: np.array, E: np.array, X: np.array, Y: np.array, ele_nod: List,
+                                 shear_mod: int, width_properties: Dict, height_properties: Dict,
+                                 unit_weight_properties: Dict, elastic_mod_properties: Dict,
+                                 truss_mode: str, beam_partition: int = 1) -> Tuple[np.array, np.array, np.array, np.array, np.array, np.array, np.array]:
+    """
+    Calculate the properties of the elements in the truss bridge.
+
+    Returns:
+        J, A, h, beta, ro, E: Numpy arrays of the moments of inertia, areas and heights, angles, 
+        unit weights and elastic moduli of the elements. With J in m^4, A in m^2 and h in m, beta 
+        in radians, ro in kN/m^3 and E in kN/m^2.
+    """
+    # Calculate the areas
+    area_beam = width_properties['beam'] * height_properties['beam']
+    area_column = width_properties['column'] * height_properties['column']
+    area_rod = width_properties['rod'] * height_properties['rod']
+
+    # Calculate the moments of inertia
+    inertia_beam = width_properties['beam']**3 * height_properties['beam'] / 12
+    inertia_column = width_properties['column']**3 * height_properties['column'] / 12
+    inertia_rod = width_properties['rod']**3 * height_properties['rod'] / 12
+
+    # Calculate the properties of the elements
+    J[:n_beams] = inertia_beam
+    A[:n_beams] = area_beam
+    if "simple" in truss_mode:
+        h[:n_beams] = spacing / beam_partition
+    else:
+        h[:n_beams] = spacing
+    ro[:n_beams] = unit_weight_properties['beam']
+    E[:n_beams] = elastic_mod_properties['beam']
+
+    if n_beams != n_ele_tot:
+        J[n_beams:n_beams + n_columns] = inertia_column
+        A[n_beams:n_beams + n_columns] = area_column
+        h[n_beams:n_beams + n_columns] = height
+        ro[n_beams:n_beams + n_columns] = unit_weight_properties['column']
+        E[n_beams:n_beams + n_columns] = elastic_mod_properties['column']
+
+        J[n_beams + n_columns:] = inertia_rod
+        A[n_beams + n_columns:] = area_rod
+        h[n_beams + n_columns:] = diag
+        ro[n_beams + n_columns:] = unit_weight_properties['rod']
+        E[n_beams + n_columns:] = elastic_mod_properties['rod']
+    
+    # Debugging for any errors
+    if np.any(J == 0) or np.any(A == 0) or np.any(h == 0) or np.any(ro == 0) or np.any(E == 0):
+        raise ValueError("There are materials with no property")
+
+    for i, _ in enumerate(beta):
+        dx = X[ele_nod[i, 1]] - X[ele_nod[i, 0]]
+        if abs(h[i]) < 1e-10:  # Avoid division by zero
+            beta[i] = 0
+        else:
+            # Ensure value is within [-1, 1] for arccos
+            cos_val = np.clip(dx / abs(h[i]), -1.0, 1.0)
+            beta[i] = np.arccos(cos_val)
+
+    G = np.full(len(E), shear_mod, dtype=np.float32)
+
+    h = h.astype(np.float32)
+    A = A.astype(np.float32)
+    E = E.astype(np.float32)
+    J = J.astype(np.float32)
+    beta = beta.astype(np.float32)
+    ro = ro.astype(np.float32)
+
+    return J, A, h, beta, ro, E, G
+
+
+def boundary_conditions(n_bot_beams: int, n_par_nod: int, n_nod_tot: int,
+                        supports: Optional[List[str]] = None) -> np.ndarray:
+    """
+    Calculate the boundary conditions for the truss bridge.
+
+    Returns:
+        A numpy array where the ith element is 1 if the i-th parameter is a boundary condition and 0 otherwise.
+        Defaults to pin and roller supports. Considers fixed supp if not a pin or roller.
+    """
+    if supports is None:
+        supports = ["pin", "roller"]
+
+    # Initialize the boundary conditions
+    def support_dof(support, n_par_nod):
+        temp = np.zeros(n_par_nod, dtype=int)
+        if support == "roller":
+            temp[1] = 1
+        elif support == "pin":
+            temp[:2] = 1
+        else:
+            temp[:] = 1
+        return temp
+
+    # Create the boundary array and set the boundary conditions
+    temp = np.zeros(n_nod_tot * n_par_nod, dtype=np.int32)
+    temp[:n_par_nod] = support_dof(supports[0], n_par_nod)
+    temp[n_par_nod*n_bot_beams:n_par_nod*(n_bot_beams+1)] = support_dof(supports[1], n_par_nod)
+
+    return temp
+
+
+def truss_design(n_bot_beams: int, n_rods: int,
+                 truss_mode: str ="pratt") -> np.ndarray:
+    """
+    Modify the number of rods to skip based on the design of the truss bridge.
+
+    Returns:
+        A numpy array of the rods to skip based on the truss design.
+    """
+    truss_mode = truss_mode.lower()
+    def pratt_howe(n_bot_beams, n_rods, start=3, mid=0):
+        left_side = np.arange(start, n_bot_beams, 2)
+        right_side = np.arange(n_bot_beams+mid, n_rods, 2)
+
+        # Check if the last rod is included in the right side and remove it to avoid invalid indexing
+        if truss_mode == "howe" and right_side.size > 0 and right_side[-1] == n_rods - 1:
+            right_side = right_side[:-1]
+        return np.concatenate((left_side, right_side)).tolist()
+
+    if truss_mode == "pratt":
+        return pratt_howe(n_bot_beams-1, n_rods-1, 2)
+
+    elif truss_mode == "howe":
+        return pratt_howe(n_bot_beams-1, n_rods, 1, 1)
+
+    else:
+        return np.array([])
+
+
+def col_pos(W: np.ndarray, n_par_nod: int, X: np.ndarray, Y: Optional[np.ndarray] = None) -> np.ndarray:
+    """
+    Calculate the column positions for the truss bridge.
+
+    Args:
+        W: Boundary condition array (1 for column, 0 for no column)
+        n_par_nod: Number of parameters per node
+        X: X coordinates of nodes
+        Y: Y coordinates of nodes (optional)
+
+    Returns:
+        A tuple of numpy arrays (X_col, Y_col) representing the x and y coordinates of the columns.
+    """
+    y_col = []
+    x_col = []
+
+    for i, pos in enumerate(X):
+        if 1 in W[i*n_par_nod:(i+1)*n_par_nod]:  # Check if there is a column at this node
+            x_col.append(pos)
+            y_col.append(0)
+            if Y is not None:
+                y_col[-1] = Y[i]
+    
+    # Change to numpy arrays
+    x_col = np.array(x_col)
+    y_col = np.array(y_col)
+
+    return x_col, y_col
+
+
+################## Plotting Functions ##################
+def plot_elements(ax, truss_mode, ele_nod, X, Y, h, beta):
+    """
+    Plot the structural elements (1D or 2D) on the given axes.
+
+    Args:
+        ax: Matplotlib axes object.
+        truss_mode: String indicating the truss mode ("simple" for 1D, others for 2D).
+        ele_nod: Numpy array of element-node connectivity.
+        X: Numpy array of X coordinates of nodes.
+        Y: Numpy array of Y coordinates of nodes.
+        h: Numpy array of element lengths.
+        beta: Numpy array of element angles in radians.
+    """
+    if "simple" in truss_mode:
+        # Plot each element as a horizontal line
+        for i in range(len(ele_nod)):
+            x1 = X[ele_nod[i, 0]]  # Start node X
+            length = h[i]
+            x2 = x1 + length
+
+            ax.plot([x1, x2], [0, 0], 'b')  # Plot element
+            ax.text((x1 + x2) / 2, 0, str(i), verticalalignment='bottom')  # Label element
+
+        ax.plot(X, np.zeros_like(X), 'ro')  # Plot nodes as red circles on the x-axis
+        ax.set_title('1D Element Plot')
+    else:
+        # Plot each element based on angle beta
+        for i in range(len(ele_nod)):
+            x1, y1 = X[ele_nod[i, 0]], Y[ele_nod[i, 0]]  # Start node coordinates
+            length = h[i]
+            x2 = x1 + length * np.cos(beta[i])
+            y2 = y1 + length * np.sin(beta[i])
+
+            ax.plot([x1, x2], [y1, y2], 'b')  # Plot element
+            ax.text((x1 + x2) / 2, (y1 + y2) / 2, str(i))  # Label element
+
+        ax.plot(X, Y, 'ro')  # Plot nodes
+        ax.set_title('2D Element Plot')
+
+
+def plot_supports(ax, X_col, Y_col, W, n_par_nod, X):
+    """
+    Plot supports (roller, pin, fixed) on the structure.
+
+    Args:
+        ax: Matplotlib axes object.
+        X_col: Numpy array of X coordinates where supports are located.
+        Y_col: Numpy array of Y coordinates where supports are located.
+        W: Numpy array representing boundary conditions (1 for restrained, 0 for free).
+        n_par_nod: Number of parameters per node.
+        support_types: List of support types to cycle through.
+    """
+    for i, _ in enumerate(X_col):
+        x = X_col[i]
+        y = Y_col[i]
+        
+        # Find the node index
+        idx = np.where(X == x)[0][0]
+        support_type = sum(W[idx * n_par_nod:(idx + 1) * n_par_nod])
+
+        if support_type == 1:
+            # Larger circle for roller
+            circle_radius = 0.03  # Increased size
+            circle = plt.Circle((x, y - circle_radius), circle_radius, color='k', fill=True)
+            ax.add_patch(circle)
+        elif support_type == 2:
+            # Larger triangle for pin
+            triangle_base = 0.1
+            triangle_height = 0.05
+
+            tri_x = [x - triangle_base/2, x + triangle_base/2, x]
+            tri_y = [y - triangle_height, y - triangle_height, y]
+            ax.fill(tri_x, tri_y, 'k')
+        elif support_type == 3:
+            # Fixed support with lines
+            line_height = 0.015
+            line_width = 0.05
+
+            ax.plot([x - line_width/2, x + line_width/2], 
+                    [y - line_height, y - line_height], 'k', linewidth=2)
+            for j in range(5):
+                gap = line_width / 4
+                ax.plot([x - line_width/2 + j * gap, x - line_width/2 + j * gap],
+                        [y - line_height, y - line_height - 0.02], 'k')

utils/truss_helpers.py

@@ -0,0 +1,612 @@
+import logging
+import numpy as np
+import sympy as sp
+import scipy.linalg
+from typing import Tuple, List, Optional
+from sympy import Matrix, lambdify
+import multiprocessing as mp
+
+# Get the logger
+logger = logging.getLogger(__name__)
+
+################## Basic Functions ##################
+def initialize_symbols(n_par_ele: int) -> Tuple:
+    """
+    Create and return the symbolic variables used in the calculations.
+
+    Args:
+        n_par_ele: Number of parameter per element
+
+    Returns:
+        Returns a tuple of the symbolic variables
+    """
+    # Define symbolic variables
+    x, xi, h_e, beta_e, beta_curr = sp.symbols('x xi h_e beta_e beta_curr')
+    A_e, E_e, J_e, ro_e, T, fo_E = sp.symbols('A_e E_e J_e ro_e T fo_E')
+    qe = sp.symbols(f'qe:{n_par_ele}')
+
+    a_arr = sp.symbols('a:2') # for axial
+    b_arr = sp.symbols('b:2') # Rods
+    d_arr = sp.symbols('d:2') # Rods
+    c_arr = sp.symbols('c:4') # transversal
+    e_arr = sp.symbols('e:3') # timoshenko
+
+    # For global displacements
+    Qglo_pel_curr = sp.symbols(f'Qglo_pel_curr:{n_par_ele}')
+    w_arr = sp.symbols('w:2')
+    r_arr = sp.symbols('r:2')
+    f_arr = sp.symbols('f:2')
+    g_arr = sp.symbols('g:4')
+    X_old, Y_old = sp.symbols('X_old Y_old')
+
+
+    return (x, xi, h_e, beta_e, beta_curr, qe, a_arr, b_arr,
+            c_arr, d_arr, e_arr, A_e, E_e, J_e, ro_e, T, fo_E, X_old, Y_old,
+            Qglo_pel_curr, w_arr, r_arr, f_arr, g_arr)
+
+
+def define_newton_equation(x: sp.Symbol, coeffs: List[sp.symbols]) -> sp.Expr:
+    """
+    Define a Newton polynomial equation.
+
+    Args:
+        x (sp.Symbol): The variable of the polynomial
+        coeffs (List[sp.Symbol]): The coefficients of the polynomial
+
+    Returns:
+        sp.Expr: The final polynomial equation
+    """
+    equation = sum(c * x**i for i, c in enumerate(coeffs))
+    return equation
+
+
+def define_langrange_equation(xi: sp.Symbol, he: sp.Symbol, 
+                              type_beam: Optional[int] = 1) -> Tuple[sp.Matrix, sp.Matrix]:
+    """
+    Define the Langrange shape functions for the beam and rod elements.
+    This uses the Hermite cubic shape functions.
+
+    Args:
+        xi: The local coordinate
+        he: The element length
+
+    Returns:
+        Tuple[List[sp.Expr], List[sp.Expr]]: The beam and rod shape functions
+    """
+    if type_beam == 1:
+        N_beam_shape = sp.zeros(4, 1)  # Use sp.zeros to initialize a column matrix
+        N_beam_shape[0] = 1 - 3*xi**2 + 2*xi**3
+        N_beam_shape[1] = he * (xi - 2*xi**2 + xi**3)  # Corrected variable name to he
+        N_beam_shape[2] = 3*xi**2 - 2*xi**3
+        N_beam_shape[3] = he * (-xi**2 + xi**3)  # Corrected variable name to he
+        return N_beam_shape
+    
+    N_rod_shape = sp.zeros(2, 1)
+    N_rod_shape[0] = 1 - xi
+    N_rod_shape[1] = xi
+
+    return N_rod_shape
+
+
+def compute_v_u(qe: List[sp.symbols], beta_e: sp.Symbol
+                ) -> Tuple[sp.Expr, sp.Expr, sp.Expr, sp.Expr]:
+    """
+    Compute the local displacements v and u.
+
+    Args:
+        qe (List[sp.Symbol]): The local displacement vector
+        beta_e (sp.Symbol): The angle of displacement
+
+    Returns:
+        Tuple[sp.Expr, sp.Expr, sp.Expr, sp.Expr]: The local displacements v and u
+    """
+    v1 = -qe[0] * sp.sin(beta_e) + qe[1] * sp.cos(beta_e)
+    u1 = qe[0] * sp.cos(beta_e) + qe[1] * sp.sin(beta_e)
+    v2 = -qe[3] * sp.sin(beta_e) + qe[4] * sp.cos(beta_e)
+    u2 = qe[3] * sp.cos(beta_e) + qe[4] * sp.sin(beta_e)
+    return v1, u1, v2, u2
+
+
+def define_equilibrium_langrange(beam_type: str, u_beam: sp.Expr, v_beam: sp.Expr, alpha_beam: sp.Expr,
+                                  xi: sp.Symbol, h_e: sp.Symbol, v1: sp.Expr, u1: sp.Expr, v2: sp.Expr,
+                                  u2: sp.Expr, qe: List[sp.symbols]) -> Tuple[sp.Expr, sp.Expr, sp.Expr, sp.Expr, sp.Expr]:
+    """
+    Define the equilibrium equations for the beam or rod using Lagrange shape functions.
+
+    Returns:
+        List[sp.Expr]: The equilibrium equations for the beam or rod
+    """
+    N_beam_shape = define_langrange_equation(xi, h_e, type_beam=1)
+    N_rod_shape = define_langrange_equation(xi, h_e, type_beam=0)
+    theta_beam = sp.Expr(0)
+    
+    # Compute local displacements
+    v_rod = N_rod_shape[0] * v1 + N_rod_shape[1] * v2
+    u_rod = N_rod_shape[0] * u1 + N_rod_shape[1] * u2
+
+    if beam_type == "bernoulli":
+        v_beam = N_beam_shape[0]*v1 + N_beam_shape[1]*qe[2] + N_beam_shape[2]*v2 + N_beam_shape[3]*qe[5]
+        u_beam = N_rod_shape[0]*u1 + N_rod_shape[1]*u2 - z * sp.diff(v_beam, xi)
+    else:  # Timoshenko
+        v_beam = N_beam_shape[0]*v1 + N_beam_shape[1]*qe[2] + N_beam_shape[2]*v2 + N_beam_shape[3]*qe[5]
+        theta_beam = N_beam_shape[0]*qe[2] + N_beam_shape[2]*qe[5]
+        u_beam = N_rod_shape[0]*u1 + N_rod_shape[0]*u2 - z * theta_beam
+
+    return v_beam, u_beam, theta_beam, v_rod, u_rod,
+
+
+def define_equilibrium_equations(beam_type: str, expressions: List[sp.Expr],
+                                 x: sp.Symbol, h_e: sp.Symbol, v1: sp.Expr, u1: sp.Expr, v2: sp.Expr,
+                                 u2: sp.Expr, qe: List[sp.symbols]) -> List[sp.Expr]:
+    """
+    Define the equilibrium equations for the beam or rod.
+
+    Returns:
+        List[sp.Expr]: The equilibrium equations for the beam or rod
+    """
+    if beam_type == "bernoulli":
+        v_beam, u_beam = expressions[1], expressions[0]
+        return [
+            v_beam.subs(x, 0) - v1,
+            sp.diff(v_beam, x).subs(x, 0) - qe[2],
+            v_beam.subs(x, h_e) - v2,
+            sp.diff(v_beam, x).subs(x, h_e) - qe[5],
+            u_beam.subs(x, 0) - u1,
+            u_beam.subs(x, h_e) - u2
+        ]
+    else:
+        v_beam, u_beam, alpha_beam = expressions[1], expressions[0], expressions[2]
+        return [
+            u_beam.subs(x, 0) - u1,
+            u_beam.subs(x, h_e) - u2,
+            v_beam.subs(x, 0) - v1,
+            v_beam.subs(x, h_e) - v2,
+            alpha_beam.subs(x, 0) - qe[2],
+            alpha_beam.subs(x, h_e) - qe[5]
+        ]
+
+
+def define_rod_equations(u_rod: sp.Expr, v_rod: sp.Expr, x: sp.Symbol, 
+                         h_e: sp.Symbol, v1: sp.Expr, u1: sp.Expr, v2: sp.Expr,
+                         u2: sp.Expr) -> List[sp.Expr]:
+    """
+    Define the equilibrium equations for the rod
+
+    Returns:
+        List[sp.Expr]: The equilibrium equations for the rod
+    """
+    return [
+        v_rod.subs(x, 0) - v1,
+        u_rod.subs(x, 0) - u1,
+        v_rod.subs(x, h_e) - v2,
+        u_rod.subs(x, h_e) - u2
+    ]
+
+
+def apply_boundary_conditions(K: np.array, M: np.array, W: np.array,
+                              tol: float = 1e-5) -> Tuple[np.array, np.array]:
+    """
+    Applies the boundary conditions to the stiffness and mass matrices.
+
+    Returns:
+        Numpy arrays of the stiffness and mass matrices with the boundary conditions applied
+    """
+    indices = np.where(W == 1)[0]
+
+    # take the max value from the diagonal
+    max_k = np.max(np.abs(np.diag(K)))
+    min_m = np.max(np.abs(np.diag(M)))
+    max_freq_sqrd = np.sqrt(max_k / min_m)
+
+    # Set rows and columns to zero
+    K[indices, :] = 0
+    K[:, indices] = 0
+    M[indices, :] = 0
+    M[:, indices] = 0
+
+    # Correctly set diagonal elements for these indices
+    for index in indices:
+        K[index, index] = max_freq_sqrd / tol
+        M[index, index] = max_freq_sqrd * tol
+
+    return K, M
+
+
+
+################## Analysis Functions ##################
+def calculate_energies(beam_type, ve_beam, ue_beam, alpha_e_beam, ve_rod,
+                       ue_rod, x, h_e, E_e, J_e, A_e, ro_e, G, k_shear):
+    """
+    Calculate the potential and kinetic energies of beams and rods.
+
+    Returns:
+        The potential and kinetic energies.
+    """
+    # Calculate chi_beam and eps_beam
+    if beam_type == "bernoulli":
+        chi_beam = sp.diff(sp.diff(ve_beam, x), x)
+        eps_beam = sp.diff(ue_beam, x)
+        pot_beam = 1 / 2 * sp.integrate(E_e * J_e * chi_beam**2 + E_e * A_e * eps_beam**2, (x, 0, h_e))
+    else:
+        eps_beam = sp.diff(ue_beam, x)
+        gamma_beam = sp.diff(ve_beam, x) - alpha_e_beam
+        chi_beam = sp.diff(alpha_e_beam, x)
+
+        # Note that k_shear and G must be changed in case they are not constant
+        pot_beam = 1 / 2 * sp.integrate(E_e * J_e * chi_beam**2 + E_e * A_e * eps_beam**2 + k_shear * G[0] * A_e * gamma_beam**2, (x, 0, h_e))
+    
+    kin_beam = 1 / 2 * ro_e * A_e * sp.integrate(ve_beam**2 + ue_beam**2, (x, 0, h_e))
+    
+    eps_rod = sp.diff(ue_rod, x)
+    pot_rod = 1 / 2 * sp.integrate(E_e * A_e * eps_rod**2, (x, 0, h_e))
+    kin_rod = 1 / 2 * ro_e * A_e * sp.integrate(ve_rod**2 + ue_rod**2, (x, 0, h_e))
+    
+    return pot_beam, kin_beam, pot_rod, kin_rod
+
+
+def calculate_displacement_equations(x, xi, h_e, beta_e, qe, a_arr, b_arr, c_arr, d_arr, e_arr,
+                                     beam_type, use_lagrangian: bool = True):
+    """
+    Calculate the beam displacement equations for beam (bernoulli or
+    timoshenko) and rod.
+
+    Returns:
+        Displacement functions for the beam in the u and v directions
+    """
+    # Compute local displacements
+    v1, u1, v2, u2 = compute_v_u(qe, beta_e)
+
+    # Define beam displacement equations
+    if use_lagrangian:
+        v_beam, u_beam, theta_beam, v_rod, u_rod = define_equilibrium_langrange(beam_type, u_beam, v_beam, alpha_beam,
+                                                                    xi, h_e, v1, u1, v2, u2, qe)
+        # Lambdify ve_beam and ue_beam
+        ve_beam_func = lambdify((xi, qe, h_e, beta_e), ve_beam, "numpy")
+        ue_beam_func = lambdify((xi, qe, h_e, beta_e), ue_beam, "numpy")
+        ve_rod_func = lambdify((xi, qe, h_e, beta_e), ve_rod, "numpy")
+        ue_rod_func = lambdify((xi, qe, h_e, beta_e), ue_rod, "numpy")
+    else: # Newton Interpolation
+        if beam_type == "bernoulli":
+            u_beam = define_newton_equation(x, a_arr)
+            v_beam = define_newton_equation(x, c_arr)
+            alpha_beam = sp.Expr(0)
+        else:
+            u_beam = define_newton_equation(x, a_arr)
+            v_beam = define_newton_equation(x, b_arr)
+            alpha_beam = define_newton_equation(x, e_arr)
+        
+        u_rod = define_newton_equation(x, b_arr)
+        v_rod = define_newton_equation(x, d_arr)
+
+        # Define equilibrium equations
+        equations = define_equilibrium_equations(beam_type, [u_beam, v_beam, alpha_beam],
+                                                x, h_e, v1, u1, v2, u2, qe)
+        equations_rod = define_rod_equations(u_rod, v_rod, x, h_e, v1, u1, v2, u2)
+
+        # Define equilibrium equations
+        if beam_type == "bernoulli":
+            sol = sp.solve(equations, a_arr + c_arr)
+            alpha_e_beam = sp.Expr(0)
+        else:
+            sol = sp.solve(equations, a_arr + b_arr + e_arr)
+            alpha_e_beam = alpha_beam.subs(sol)
+
+        ve_beam = v_beam.subs(sol)
+        ue_beam = u_beam.subs(sol)
+
+        sol_rod = sp.solve(equations_rod, b_arr + d_arr)
+        ve_rod = v_rod.subs(sol_rod)
+        ue_rod = u_rod.subs(sol_rod)
+
+        # Lambdify ve_beam and ue_beam
+        ve_beam_func = lambdify((x, qe, h_e, beta_e), ve_beam, "numpy")
+        ue_beam_func = lambdify((x, qe, h_e, beta_e), ue_beam, "numpy")
+
+        ve_rod_func = lambdify((x, qe, h_e, beta_e), ve_rod, "numpy")
+        ue_rod_func = lambdify((x, qe, h_e, beta_e), ue_rod, "numpy")
+
+    return ve_beam_func, ue_beam_func, ve_beam, ue_beam, ve_rod_func, ue_rod_func, ve_rod, ue_rod, alpha_e_beam
+
+
+def construct_lambdified_matrices(n_par_ele, pot_beam, kin_beam, pot_rod, kin_rod, qe, h_e, A_e, E_e, J_e, beta_e, ro_e):
+    """
+    Constructs and lambdifies the local K and M matrices.
+    
+    Returns:
+        Lambdified functions for K and M matrices for beams and rods.
+    """
+    K_beam = sp.Matrix.zeros(n_par_ele)
+    M_beam = sp.Matrix.zeros(n_par_ele)
+    K_rod = sp.Matrix.zeros(n_par_ele)
+    M_rod = sp.Matrix.zeros(n_par_ele)
+
+    # Compute K_beam and M_beam
+    for i in range(n_par_ele):
+        for j in range(n_par_ele):
+            K_beam[i, j] = sp.diff(sp.diff(pot_beam, qe[i]), qe[j])
+            M_beam[i, j] = sp.diff(sp.diff(kin_beam, qe[i]), qe[j])
+            K_rod[i, j] = sp.diff(sp.diff(pot_rod, qe[i]), qe[j])
+            M_rod[i, j] = sp.diff(sp.diff(kin_rod, qe[i]), qe[j])
+
+    # Create lambdified functions for K and M matrices
+    K_beam_func = lambdify((h_e, A_e, E_e, J_e, beta_e), K_beam)
+    M_beam_func = lambdify((h_e, A_e, E_e, J_e, beta_e, ro_e), M_beam)
+    K_rod_func = lambdify((h_e, A_e, E_e, J_e, beta_e), K_rod)
+    M_rod_func = lambdify((h_e, A_e, E_e, J_e, beta_e, ro_e), M_rod)
+
+    return K_beam, M_beam, K_rod, M_rod, K_beam_func, M_beam_func, K_rod_func, M_rod_func
+
+
+def assemble_global_matrices(n_par_ele: int, n_par_tot: int, n_ele_tot: int, K_beam_func: sp.lambdify,
+                             M_beam_func: sp.lambdify, K_rod_func: sp.lambdify, M_rod_func: sp.lambdify,
+                             h: sp.Symbol, A: sp.Symbol, E: sp.Symbol, J: sp.Symbol, beta: sp.Symbol,
+                             ro: sp.Symbol, pel: List, n_rods: int) -> Tuple[np.array, np.array]:
+    """
+    Assembles the global stiffness and mass matrices using the lambdified functions for element matrices.
+
+    Returns:
+        Numeric arrays of the global stiffness and mass matrices.
+    """
+    # Initialize element stiffness matrix (Ke) and global stiffness matrix (K)
+    K = np.zeros((n_par_tot, n_par_tot))
+    M = np.zeros((n_par_tot, n_par_tot))
+
+    # Pre-compute beam and rod indices
+    beam_indices = np.arange(n_ele_tot - n_rods)
+    rod_indices = np.arange(n_ele_tot - n_rods, n_ele_tot)
+    logging.debug(f"Beam indices: {beam_indices} \nRod indices: {rod_indices}")
+    
+    # Process beams
+    for e in beam_indices:
+        Ke = K_beam_func(h[e], A[e], E[e], J[e], beta[e])
+        Me = M_beam_func(h[e], A[e], E[e], J[e], beta[e], ro[e])
+        idx = pel[e, :] - 1  # Adjust for 0-based indexing
+        K[np.ix_(idx, idx)] += Ke
+        M[np.ix_(idx, idx)] += Me
+
+    # Process rods
+    for e in rod_indices:
+        Ke = K_rod_func(h[e], A[e], E[e], J[e], beta[e])
+        Me = M_rod_func(h[e], A[e], E[e], J[e], beta[e], ro[e])
+        idx = pel[e, :] - 1  # Adjust for 0-based indexing
+        K[np.ix_(idx, idx)] += Ke
+        M[np.ix_(idx, idx)] += Me
+
+    # Convert K and M to NumPy arrays
+    K = np.array(K).astype(np.float32)
+    M = np.array(M).astype(np.float32)
+
+    return K, M
+
+
+def compute_eigenvalues_and_eigenvectors(K: np.array, M: np.array, method: str = 'numpy',
+                                         filter_numerical_stability: bool = False,
+                                         threshold: float = 1e-10) -> Tuple[np.array, np.array]:
+    """
+    Compute the eigenvalues (λ: w**2 natural frequencies)and 
+    eigenvectors (ϕ: mode shape) of the stiffness and mass matrices.
+
+    Args:
+        K: Stiffness matrix
+        M: Mass matrix
+        method: 'scipy' for scipy.linalg.eigh or 'numpy' for np.linalg.eig
+        filter_numerical_stability: Boolean to indicate if filtering should be applied
+        threshold: Threshold for filtering small eigenvalues for numerical stability
+
+    Returns:
+        The real part of the eigenvalues (frequency) and the normalized eigenvectors (modes of vibration)
+    """
+    if method == 'numpy':
+        lamb, phis = np.linalg.eig(np.linalg.inv(M) @ K)
+    else:
+        if method != 'scipy':
+            print("Invalid method. Defaulting to scipy.")
+        lamb, phis = scipy.linalg.eigh(K, M)
+
+
+    # Get the indices that would sort lamb in descending order
+    idx = np.argsort(lamb)[::-1]
+
+    # Sort lamb and phis and take the real part
+    lamb_r = np.real(lamb[idx])
+    phis_r = np.real(phis[:, idx])
+
+    if filter_numerical_stability:
+        # Filter for numerical stability
+        valid_indices = lamb_r > threshold
+        lamb_r = lamb_r[valid_indices]
+        phis_r = phis_r[:, valid_indices]
+
+    # Normalize eigenvectors
+    n_par_tot = len(lamb_r)
+    phis_norm = np.zeros((phis_r.shape[0], n_par_tot))
+
+    for i in range(n_par_tot):
+        c = np.sqrt(np.dot(phis_r[:, i].T, M @ phis_r[:, i]))
+        phis_norm[:, i] = phis_r[:, i] / c
+
+    verification = np.array([np.dot(phis_norm[:, i].T, M @ phis_norm[:, i]) for i in range(n_par_tot)])
+    if not np.allclose(verification, 1):
+        logging.warning("Verification failed for eigenvectors. Results may be inaccurate.")
+    logging.debug("Verification results for each eigenvector (should all be 1):\n%s", verification)
+
+    verification_sum = np.sum(verification)
+    if not np.isclose(verification_sum, n_par_tot):
+        logging.warning("Sum of verification values is not equal to number of eigenvectors. Results may be inaccurate.")
+    logging.debug("Sum of verification values (should be equal to number of eigenvectors): %s", verification_sum)
+
+    return lamb_r, phis_norm
+
+
+def get_mode_indices(lamb_r: np.array, phis_norm: np.array, 
+                     n_plots: int) -> Tuple[np.array, np.array]:
+    """
+    Calculate the periods to get the top contributing index_modes.
+    Periods are validated to be real numbers and positive.
+
+    Args:
+        lamb_r: Real part of the eigenvalues
+        phis_norm: Normalized eigenvectors
+        n_plots: Number of modes to plot
+
+    Returns:
+        Numpy array of the indices of the largest n_plots periods and sorted periods
+    """
+    # Calculate periods
+    period = 2 * np.pi / np.sqrt(lamb_r)
+
+    # Show how many invalid periods are there
+    logging.debug("Number of invalid periods: %s", np.sum(~np.isfinite(period)))
+    logging.debug("Number of negative periods: %s", np.sum(period < 0))
+
+    # Ensure periods are all real numbers and valid
+    valid_indices = np.isfinite(period) & (period > 0)
+    period = period[valid_indices]
+    phis_norm = phis_norm[:, valid_indices]
+
+    # Sort periods for better representation
+    sorted_period = np.sort(period)
+
+    # Find the indices of the largest n_plots periods
+    index_modes = np.argpartition(period, -n_plots)[-n_plots:]
+
+    # Sort index_modes so that the modes are in descending order of period
+    index_modes = index_modes[np.argsort(period[index_modes])][::-1]
+
+    return index_modes, sorted_period, period
+
+
+def calculate_global_displacements(Qglo_pel_curr, beta_e, h_e, x, xi, f_arr, 
+                                    g_arr, w_arr, r_arr, beam_type,
+                                    X_old, Y_old, use_lagrangian: bool = False) -> Tuple:
+    """
+    Calculate the global displacements by solving the local symbolic
+    equilibrium equations.
+
+    Returns:
+        Lambda functions for the global displacements
+    """
+
+    _, _, v_beam, u_beam, _, _, v_rod, u_rod, _ = calculate_displacement_equations(x, xi, h_e, beta_e, Qglo_pel_curr, f_arr, r_arr, g_arr, w_arr, g_arr,
+                                     beam_type, use_lagrangian)
+
+    # Define global displacements
+    u_glo_beam = u_beam * sp.cos(beta_e) - v_beam * sp.sin(beta_e)
+    v_glo_beam = u_beam * sp.sin(beta_e) + v_beam * sp.cos(beta_e)
+    u_glo_rod = u_rod * sp.cos(beta_e) - v_rod * sp.sin(beta_e)
+    v_glo_rod = u_rod * sp.sin(beta_e) + v_rod * sp.cos(beta_e)
+    
+
+    # Define new coordinates
+    if use_lagrangian:
+        X_new_beam = X_old + xi * h_e * sp.cos(beta_e) + u_glo_beam
+        Y_new_beam = Y_old + xi * h_e * sp.sin(beta_e) + v_glo_beam
+        X_new_rod = X_old + xi * h_e * sp.cos(beta_e) + u_glo_rod
+        Y_new_rod = Y_old + xi * h_e * sp.sin(beta_e) + v_glo_rod
+    else:
+        X_new_beam = X_old + x * sp.cos(beta_e) + u_glo_beam
+        Y_new_beam = Y_old + x * sp.sin(beta_e) + v_glo_beam
+        X_new_rod = X_old + x * sp.cos(beta_e) + u_glo_rod
+        Y_new_rod = Y_old + x * sp.sin(beta_e) + v_glo_rod
+
+
+    args = (X_old, Y_old, beta_e, h_e) + tuple(Qglo_pel_curr)
+    if use_lagrangian:
+        X_new_beam_func = sp.lambdify((xi,) + args, X_new_beam, "numpy")
+        Y_new_beam_func = sp.lambdify((xi,) + args, Y_new_beam, "numpy")
+        X_new_rod_func = sp.lambdify((xi,) + args, X_new_rod, "numpy")
+        Y_new_rod_func = sp.lambdify((xi,) + args, Y_new_rod, "numpy")
+    else:
+        X_new_beam_func = sp.lambdify((x,) + args, X_new_beam, "numpy")
+        Y_new_beam_func = sp.lambdify((x,) + args, Y_new_beam, "numpy")
+        X_new_rod_func = sp.lambdify((x,) + args, X_new_rod, "numpy")
+        Y_new_rod_func = sp.lambdify((x,) + args, Y_new_rod, "numpy")
+
+    return X_new_beam, Y_new_beam, X_new_rod, Y_new_rod, X_new_beam_func, Y_new_beam_func, X_new_rod_func, Y_new_rod_func
+
+
+
+################## Verifications functions ##################
+def print_matrix(matrix: np.array, width: int = 9, precision: int = 1, row_labels: Optional[List[str]] = None,
+                 col_labels: Optional[List[str]] = None) -> None:
+    """
+    Print a matrix in a more readable format.
+
+    Args:
+        matrix: The matrix to print
+        width: The width of each column
+        precision: The number of decimal places to show
+        row_labels (Optional[List[str]], optional): Row labels. Defaults to numbering from 1 to n.
+        col_labels (Optional[List[str]], optional): Column labels. Defaults to numbering from 1 to n.
+    """
+    if row_labels is None:
+        row_labels = range(1, len(matrix) + 1)
+    if col_labels is None:
+        col_labels = range(1, len(matrix[0]) + 1)
+
+    # Header row
+    print(" " * width, end="")
+    for label in col_labels:
+        print(f"{label:>{width}}", end="")
+    print()
+
+    # Matrix rows
+    for i, row in enumerate(matrix):
+        print(f"{row_labels[i]:>{width}}", end="")
+        for val in row:
+            # Ensure the value is treated as a float for formatting
+            try:
+                formatted_val = f"{float(val):.{precision}e}"
+            except ValueError:
+                # If conversion to float fails, print as is
+                formatted_val = str(val)
+            print(f"{formatted_val:>{width}}", end="")
+        print()
+
+
+import numpy as np
+
+def check_matrix(matrix: np.ndarray, atol: float = 1e-8) -> None:
+    """
+    Check if a matrix is symmetric, well-conditioned, positive definite, and diagonally dominant.
+    
+    Args:
+        matrix: The matrix to check
+        atol: The absolute tolerance for the condition check
+    """
+    # Symmetry check
+    if np.allclose(matrix, matrix.T, atol=atol):
+        print("Matrix is symmetric.")
+    else:
+        print("Matrix is not symmetric.")
+    
+    # Conditioning check
+    try:
+        cond_number = np.linalg.cond(matrix)
+        if cond_number < 1 / atol:
+            print(f"Matrix is well-conditioned (Condition number: {cond_number:.2e}).")
+        else:
+            print(f"Matrix is ill-conditioned (Condition number: {cond_number:.2e}).")
+    except np.linalg.LinAlgError:
+        print("Condition number could not be computed (possibly singular matrix).")
+    
+    # Positive definiteness check
+    try:
+        eigenvalues = np.linalg.eigvalsh(matrix)
+        if np.any(eigenvalues < 0):
+            print("Matrix is not positive definite.")
+        else:
+            print("Matrix is positive definite.")
+    except np.linalg.LinAlgError:
+        print("Eigenvalues could not be computed.")
+    
+    # Diagonal dominance check
+    row_sums = np.sum(np.abs(matrix), axis=1) - np.abs(np.diag(matrix))
+    diagonal_elements = np.abs(np.diag(matrix))
+    is_dominant = diagonal_elements >= row_sums
+    num_wrong = np.size(matrix, 0) - np.sum(is_dominant)
+    
+    if num_wrong == 0:
+        print("Matrix is diagonally dominant.")
+    else:
+        print(f"Number of rows not diagonally dominant: {num_wrong}")