Upload 20 files

models/__init__.py

@@ -0,0 +1 @@
+ 

models/wgan_gp.py

@@ -0,0 +1,114 @@
+# wgan_gp.py
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Generator(nn.Module):
+    """
+    Generator for WGAN-GP with structured output heads.
+    Outputs continuous node coordinates, node existence logits, and edge logits.
+    """
+    def __init__(self, latent_dim=128, nmax=121, cond_dim=4):  # n_nodes, n_edges, height, spacing
+        super(Generator, self).__init__()
+        d = 512
+        self.fc = nn.Sequential(
+            nn.Linear(latent_dim + cond_dim, d),
+            nn.LeakyReLU(0.2, True),
+            nn.Linear(d, d),
+            nn.LeakyReLU(0.2, True),
+        )
+        self.out_nodes = nn.Linear(d, nmax * 2)          # coords
+        self.out_nmask = nn.Linear(d, nmax)              # node logits
+        self.out_edges = nn.Linear(d, nmax * nmax)       # edge logits (will symmetrize)
+
+        self.nmax = nmax
+
+    def forward(self, z, cond):
+        h = self.fc(torch.cat([z, cond], dim=1))
+        nodes = torch.tanh(self.out_nodes(h)).view(-1, self.nmax, 2)
+        nlog  = self.out_nmask(h).view(-1, self.nmax)
+        elog  = self.out_edges(h).view(-1, self.nmax, self.nmax)
+
+        # enforce symmetry and zero diagonal
+        elog = 0.5 * (elog + elog.transpose(-1, -2))
+        elog[:, torch.arange(self.nmax), torch.arange(self.nmax)] = 0
+        node_mask = torch.sigmoid(nlog)
+        m = node_mask.unsqueeze(-1) * node_mask.unsqueeze(-2)
+        A_soft = torch.sigmoid(elog) * m
+        return nodes, node_mask, A_soft, elog, nlog
+
+
+class Discriminator(nn.Module):
+    """
+    Discriminator for WGAN-GP with a light graph-aware critic.
+    """
+    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.nmax = nmax
+
+    def forward(self, nodes, A_soft, node_mask, cond):
+        # nodes: [B,N,2], A_soft: [B,N,N], node_mask: [B,N]
+        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))
+        x = torch.cat([node_feat, cond], dim=-1)
+        return self.head(x)
+
+
+def gradient_penalty(discriminator, real_data, fake_data, lambda_gp=10):
+    """
+    Computes gradient penalty for structured inputs.
+    """
+    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)
+
+    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)
+
+    d_interpolates = discriminator(nodes_i, adj_i, mask_i, cond_i)
+    fake = torch.ones_like(d_interpolates, device=device)
+    grads = torch.autograd.grad(
+        outputs=d_interpolates,
+        inputs=[nodes_i, mask_i, adj_i, cond_i],
+        grad_outputs=fake,
+        create_graph=True,
+        retain_graph=True,
+        only_inputs=True
+    )
+    grads = torch.cat([g.reshape(B, -1) for g in grads], dim=1)
+    gp = ((grads.norm(2, dim=1) - 1) ** 2).mean()
+    return lambda_gp * gp
+
+
+def aux_losses(nodes, node_mask, elog, nodes_real, node_mask_real, A_real):
+    """
+    Masked auxiliary supervised reconstruction losses.
+    """
+    m_node = node_mask_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)
+    L_mask = F.binary_cross_entropy_with_logits(
+        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)
+    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

requirements.txt

@@ -0,0 +1,7 @@
+--extra-index-url https://download.pytorch.org/whl/cu126
+torch
+torchvision
+matplotlib
+scipy
+cython
+sympy

test.py

@@ -0,0 +1,151 @@
+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
+
+def reconstruct_sample(sample_np, metadata, full_output_dim, index=None):
+    """
+    Reconstruct nodal coordinates, ele_nod, pel from flattened 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]
+
+    return nodal_coord, ele_nod, pel
+
+def plot_truss(nodal_coord, ele_nod, title="Generated Truss", ax=None):
+    """
+    Plot truss structure.
+    """
+    if ax is None:
+        fig, ax = plt.subplots(figsize=(8, 6))
+
+    # Plot nodes
+    ax.scatter(nodal_coord[:, 0], nodal_coord[:, 1], c='blue', s=50, 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):
+            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.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'):
+    """
+    Load best generator, generate samples, visualize, and show 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)
+
+    generator = Generator(latent_dim=128, output_dim=metadata['total_dim']).to(device)
+    generator.load_state_dict(generator_state)
+    generator.eval()
+
+    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
+    real_data, _ = preprocess_s1(normalize_type=None)
+    real_samples = real_data[:n_samples]
+
+    # Generate fake samples
+    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]
+
+    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])
+
+    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)

train.py

@@ -0,0 +1,202 @@
+import os
+import torch
+import torch.optim as optim
+import numpy as np
+from torch.utils.data import DataLoader, TensorDataset
+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
+
+
+def connectivity_penalty(fake_samples, metadata):
+    """
+    Penalize generated trusses if disconnected (few valid edges per node).
+    """
+    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):
+    """
+    Evaluate connectivity and degree stats from generated graphs.
+    """
+    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',
+                  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'):
+    """
+    Train WGAN-GP with structured Generator and Discriminator.
+    Includes keyboard interrupt save and best-model checkpointing.
+    """
+    device = torch.device(device)
+
+    # Load data
+    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']
+
+    # Init models
+    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)
+
+    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')
+    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)
+
+    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)
+
+                # ---- 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)
+                    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)
+                    loss_d = -(d_real.mean() - d_fake.mean()) + gp
+                    opt_d.zero_grad()
+                    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)
+                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)
+                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)
+
+                opt_g.zero_grad()
+                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)
+            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}")
+
+                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.")
+
+        # Final save
+        np.save(os.path.join(save_path, 'epoch_losses.npy'), epoch_losses)
+        print(f"Training complete. Models saved to {save_path}.")
+
+    except KeyboardInterrupt:
+        print("\n⚠️ Training interrupted by user. Saving current state...")
+        os.makedirs(save_path, exist_ok=True)
+        np.save(os.path.join(save_path, 'epoch_losses.npy'), epoch_losses)
+        torch.save(generator.state_dict(), os.path.join(save_path, 'generator_interrupted.pth'))
+        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
+
+
+if __name__ == '__main__':
+    train_wgan_gp(device='cuda' if torch.cuda.is_available() else 'cpu')

train_utils/__init__.py

@@ -0,0 +1 @@
+ 

train_utils/preprocess_s1.py

@@ -0,0 +1,156 @@
+# preprocess_s1.py
+import numpy as np
+import os
+from collections import defaultdict
+from scipy.stats import zscore
+
+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)
+
+    # 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 pad_to_length(array, max_len):
+    """
+    Pad 1D array to max_len with zeros.
+    """
+    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)
+
+def preprocess_s1(dataset_folder="dataset", normalize_type=None):
+    """
+    Preprocesses truss dataset into flattened, padded vectors for Stage 1 GAN.
+
+    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.
+    """
+    # 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}")
+
+    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))
+        nodal = data['nodal_coord'].flatten()  # (n_nodes * 2,)
+        ele_nod = data['ele_nod'].flatten()  # (n_elements * 2,)
+        pel = data['pel'].flatten()  # (n_elements * 4,)
+
+        # 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)
+
+        # Concatenate
+        sample = np.concatenate([nodal_padded, ele_nod_padded, pel_padded])
+        samples.append(sample)
+        data.close()
+
+    data_array = np.array(samples)  # (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)
+    elif normalize_type == 'z_score':
+        data_array = zscore(data_array, axis=0)  # Per feature
+    elif normalize_type is None:
+        pass  # Already normalized in generator
+    else:
+        raise ValueError(f"Unknown normalize_type: {normalize_type}")
+
+    metadata = {
+        'max_nodes': max_nodes,
+        'max_elements': max_elements,
+        'total_dim': total_dim,
+        'n_samples': len(samples),
+        'normalize_type': normalize_type
+    }
+    return data_array, metadata

truss_generator.py

@@ -0,0 +1,301 @@
+import os
+import math
+import random
+import logging
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+from sympy import Matrix, lambdify
+from utils.truss_geometric import *
+from utils.truss_constraints import *
+from utils.truss_helpers import *
+from utils.simple_beam_helper import calculate_simple_essential_elements, calculate_simple_element_node
+from sympy.utilities.codegen import codegen
+from collections import defaultdict
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s')
+
+import numpy as np
+import os
+import logging
+
+# Assume the following functions are defined as provided in the original code:
+# calculate_max_height, try_angles, calculate_bridge (modified), calculate_essential_elements,
+# calculate_element_node, boundary_conditions, truss_design, calculate_element_properties
+# Also assume nodal_coords, pel_ele, fill_ele_nod are defined elsewhere in your codebase.
+
+# Default values for dimensions and parameters (based on context)
+n_dim = 2
+n_par_nod = 2
+
+# Default material properties (example values for steel-like; adjust as needed)
+width_properties = {'beam': 0.3, 'column': 0.4, 'rod': 0.1}  # in m
+height_properties = {'beam': 0.35, 'column': 0.4, 'rod': 0.1}  # in m
+unit_weight_properties = {'beam': 78.5, 'column': 78.5, 'rod': 78.5}  # kN/m^3
+elastic_mod_properties = {'beam': 2e8, 'column': 2e8, 'rod': 2e8}  # kN/m^2
+shear_mod = 8e7  # kN/m^2
+
+# Parameters for dataset generation
+span = 1.0  # Normalized span
+truss_modes = ["pratt", "howe", "warren"]
+n_div_range = range(2, 61, 1)  # 5,10,15,20,25,30
+angle_range = range(30, 61, 1)  # 30,35,40,45,50,55,60
+dataset_folder = "dataset"
+os.makedirs(dataset_folder, exist_ok=True)
+
+num_generated = 0
+
+for truss_mode in truss_modes:
+    for n_div in n_div_range:
+        for angle in angle_range:
+            skip_rod = []
+            # Calculate geometry using modified calculate_bridge with n_div
+            height, spacing, diag = calculate_bridge(span, angle=angle, n_div=n_div, truss_mode=truss_mode)
+            
+            # Recalculate skip_rod for design
+            n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_essential_elements(
+                span, spacing, truss_mode, 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)
+            
+            # Generate 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)
+            
+            # Separate nodal coordinates
+            X = nodal_coord[:, 0]
+            Y = nodal_coord[:, 1]
+            
+            # Boundary conditions (assuming non-simple modes)
+            W = boundary_conditions(n_bot_beams, n_par_nod, n_nod_tot, supports=["pin", "roller"])
+            
+            # Element properties
+            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 to NPZ file (compresses multiple arrays; suitable for GNN/Transformer input)
+            # Extensible: Add more arrays (e.g., new properties) as keys later without breaking format
+            filename = f"{dataset_folder}/truss_{truss_mode}_{n_div}_{angle}.npz"
+            np.savez(filename, 
+                     nodal_coord=nodal_coord,
+                     pel=pel,
+                     ele_nod=ele_nod,
+                     W=W,
+                     J=J,
+                     A=A,
+                     h=h,
+                     beta=beta,
+                     ro=ro,
+                     E=E,
+                     G=G,
+                     par=par,  # Nodal-param 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)  # For reproducibility
+            )
+            num_generated += 1
+
+print(f"Generated and saved {num_generated} truss configurations to '{dataset_folder}'.")
+
+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
+
+compute_sequence_lengths(dataset_folder="dataset", show_details=True)
+samples = load_and_visualize_random_truss(num_samples=9, save_fig=True)

utils/cython/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+import numpy as np
+import os
+
+# Get the absolute path of the current file
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Define the sources
+sources = [
+    os.path.join(current_dir, 'assemble_matrices.pyx'),
+    os.path.join(current_dir, 'K_beam_func.c'),
+    os.path.join(current_dir, 'X_beam_func.c'),
+]
+
+# Verify files exist
+for file_path in sources:
+    if not os.path.exists(file_path):
+        print(f"Warning: File not found: {file_path}")
+
+# Define the extension
+extensions = [
+    Extension(
+        "assemble_matrices",
+        sources,
+        include_dirs=[np.get_include(), current_dir],
+        extra_compile_args=["/Ox"] if os.name == 'nt' else ["-O3"],
+    )
+]
+
+setup(
+    name="assemble_matrices",
+    ext_modules=cythonize(extensions),
+)

utils/frame_constraints.py

@@ -0,0 +1,32 @@
+# Frame constants
+N_columns = 2
+N_floors = 5
+N_nod_tot = (N_floors + 1) * N_columns
+N_par_nod = 3
+N_par_tot = N_nod_tot * N_par_nod
+N_ele_tot = N_floors * (2 * N_columns - 1)
+N_nod_ele = 2
+N_par_ele = N_par_nod * N_nod_ele
+N_tot_bound = 6
+N_plots = 4
+
+# Number of points for plotting
+N_discritizations = 10
+
+# Distance between nodes in meters
+X_dist = 4
+Y_dist = 3
+
+# Columns 40x40 and beams 30x35 in cm
+width_beam = 0.3
+height_beam = 0.35
+width_column = 0.4
+height_column = 0.4
+
+# 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 = 78.5
+elastic_mod = 21*10**7

utils/frame_helpers.py

@@ -0,0 +1,382 @@
+import numpy as np
+import sympy as sp
+import matplotlib.pyplot as plt
+from sympy import Matrix, lambdify
+
+
+def calculate_X_positions(indices, N_columns, X_dist):
+    """
+    Calculate the X positions of the nodes.
+
+    Args:
+        indices (list): List or numpy array of indices from 1 to N_nod_tot
+        N_columns (int): Number of columns
+        X_dist (int): Distance between columns
+
+    Returns:
+        List of X positions of the nodes
+    """
+    X = np.zeros(len(indices))
+    X = ((indices % N_columns) - 1) * X_dist
+    np.putmask(X, X < 0, (N_columns - 1) * X_dist)
+    return X
+
+
+def calculate_Y_positions(indices, N_columns, Y_dist):
+    """
+    Calculate the Y positions of the nodes.
+
+    Args:
+        indices (list): List or numpy array of indices from 1 to N_nod_tot
+        N_columns (int): Number of columns
+        Y_dist (int): Distance between columns
+
+    Returns:
+        List of Y positions of the nodes
+    """
+    Y = np.zeros(len(indices))
+    h_assigner = np.ceil(indices / N_columns - 1)
+    h_assigner[h_assigner < 1] = 0
+    Y = Y_dist * h_assigner
+    return Y
+
+
+def calculate_element_node_indices(N_floors, N_columns):
+    """
+    Calculate the element node indices.
+
+    Args:
+        N_floors (int): Number of floors in the frame
+        N_columns (int): Number of columns
+
+    Returns:
+        Numpy array of element node indices
+    """
+    # Initialize the ele_nod array
+    ele_nod = np.zeros((N_floors * (2 * N_columns - 1), 2), dtype=int)
+
+    # Calculate the indices for the vertical and horizontal elements
+    for i in range(1, N_floors + 1):
+        for j in range(1, N_columns + 1):
+            index = (i - 1) * (2 * N_columns - 1) + j - 1
+            ele_nod[index, 0] = j + (i - 1) * N_columns
+            ele_nod[index, 1] = ele_nod[index, 0] + N_columns
+        for j in range(1, N_columns):
+            index = (i - 1) * (2 * N_columns - 1) + N_columns + j - 1
+            ele_nod[index, 0] = i * N_columns + j
+            ele_nod[index, 1] = ele_nod[index, 0] + 1
+
+    return ele_nod
+
+
+def calculate_element_length(N_ele_tot, N_columns, X_dist, Y_dist):
+    """
+    Calculate the length of the elements.
+
+    Args:
+        N_ele_tot (int): Number of elements in the frame
+        N_columns (int): Number of columns
+        X_dist (int): Distance between columns
+        Y_dist (int): Height of the columns
+
+    Returns:
+        Numpy array of element lengths
+    """
+    h = np.zeros(N_ele_tot)
+
+    # Calculate h, length of the elements
+    for i in range(1, N_ele_tot+1):
+        if i % (N_columns+1) != 0:
+            h[i-1] = Y_dist
+        else:
+            h[i-1] = X_dist
+
+    return h
+
+
+#### Heavy functions
+def initialize_symbols(N_par_ele):
+    """
+    Create and return the symbolic variables used in the calculations.
+
+    Args:
+        N_par_ele (int): Number of parameter per element
+
+    Returns:
+        Returns a tuple of the symbolic variables
+    """
+    # Define symbolic variables
+    x, h_e, beta_e, beta_curr = sp.symbols('x h_e beta_e beta_curr')
+    qe = sp.Array([sp.Symbol(f'q{i}') for i in range(1, N_par_ele+1)])
+    a0, a1, c0, c1, c2, c3 = sp.symbols('a0 a1 c0 c1 c2 c3')
+    A_e, E_e, J_e, ro_e, T, fo_E = sp.symbols('A_e E_e J_e ro_e T fo_E')
+    Qglo_pel_curr1_mode, Qglo_pel_curr2_mode, Qglo_pel_curr3_mode, Qglo_pel_curr4_mode, Qglo_pel_curr5_mode, Qglo_pel_curr6_mode= sp.symbols('Qglo_pel_curr1_mode Qglo_pel_curr2_mode Qglo_pel_curr3_mode Qglo_pel_curr4_mode Qglo_pel_curr5_mode Qglo_pel_curr6_mode')
+    X_old, Y_old = sp.symbols('X_old Y_old')
+
+    return (x, h_e, beta_e, beta_curr, qe, a0, a1, c0, c1, c2, c3, A_e, E_e, J_e, ro_e, 
+            T, fo_E, Qglo_pel_curr1_mode, Qglo_pel_curr2_mode, Qglo_pel_curr3_mode, 
+            Qglo_pel_curr4_mode, Qglo_pel_curr5_mode, Qglo_pel_curr6_mode, X_old, Y_old)
+
+
+def calculate_energies(x, qe, h_e, beta_e, E_e, J_e, A_e, ro_e, ve_beam, ue_beam):
+    """
+    Calculate the potential and kinetic energy of the beam.
+
+    Args:
+        x (symbol): Symbolic variable for the x-coordinate
+        qe (list): List of symbolic variables for the beam parameters
+        h_e (float): Height of the beam element
+        beta_e (float): Angle of the beam element
+        E_e (float): Young's modulus of the beam material
+        J_e (float): Polar moment of inertia of the beam cross-section
+        A_e (float): Cross-sectional area of the beam
+        ro_e (float): Density of the beam material
+        ve_beam (sympy expression): Vertical displacement of the beam
+        ue_beam (sympy expression): Horizontal displacement of the beam
+
+    Returns:
+        Pot_beam (sympy expression): Potential energy of the beam
+        Kin_beam (sympy expression): Kinetic energy of the beam
+        chi_beam (sympy expression): Curvature of the beam
+        eps_beam (sympy expression): Strain of the beam
+    """
+    # Calculate chi_beam and eps_beam
+    chi_beam = sp.diff(sp.diff(ve_beam, x), x)
+    eps_beam = sp.diff(ue_beam, x)
+
+    # Calculate potential energy (Pot_beam) and kinetic energy (Kin_beam)
+    Pot_beam = 1 / 2 * sp.integrate(E_e * J_e * chi_beam**2 + E_e * A_e * eps_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))
+    
+    return Pot_beam, Kin_beam, chi_beam, eps_beam
+
+
+def calculate_beam_displacement_equations(x, h_e, beta_e, qe, a0, a1, c0, c1, c2, c3):
+    """
+    Calculate the beam displacement equations.
+
+    Returns:
+        Displacement functions for the beam in the u and v directions
+    """
+    # Compute v1, u1, v2, u2
+    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)
+
+    # Define beam displacement equations
+    u_beam = a0 + a1 * x 
+    v_beam = c0 + c1 * x + c2 * x**2 + c3 * x**3 
+
+    # Define equilibrium equations
+    equations = [
+        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
+    ]
+
+    # Solve and assign the solution
+    sol = sp.solve(equations, (c0, c1, c2, c3, a0, a1))
+    ve_beam = v_beam.subs(sol)
+    ue_beam = u_beam.subs(sol)
+
+    # 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")
+
+    return ve_beam_func, ue_beam_func, ve_beam, ue_beam
+
+
+def assemble_global_matrices(N_par_ele, N_par_tot, N_ele_tot, Pot_beam, Kin_beam, qe, h, 
+                             A, E, J, beta, ro, pel, h_e, A_e, E_e, J_e, beta_e, ro_e, x):
+    """
+    Assemble the global stiffness and mass matrices by assembling the 
+    symbolic element stiffness and mass matrices and converting them to
+    numeric arrays.
+
+    Returns:
+        Numeric arrays of the global stiffness and mass matrices
+    """
+    K_beam = np.zeros((N_par_ele, N_par_ele), dtype=object)
+    M_beam = np.zeros((N_par_ele, N_par_ele), dtype=object)
+
+    # 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.lambdify((x, h_e, A_e, E_e, J_e, beta_e, ro_e),
+                                sp.diff(sp.diff(Pot_beam, qe[i]), qe[j]), 'numpy')
+            M_beam[i][j] = sp.lambdify((x, h_e, A_e, E_e, J_e, beta_e, ro_e),
+                                sp.diff(sp.diff(Kin_beam, qe[i]), qe[j]), 'numpy')
+
+    # 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))
+
+    # Compute Ke, Me and assemble K, M using NumPy operations
+    for e in range(N_ele_tot):
+        for i in range(N_par_ele):
+            for j in range(N_par_ele):
+                K[pel[e, i]-1, pel[e, j]-1] += K_beam[i, j](0, h[e], A[e], E[e], J[e], beta[e], ro[e])
+                M[pel[e, i]-1, pel[e, j]-1] += M_beam[i, j](0, h[e], A[e], E[e], J[e], beta[e], ro[e])
+
+    return K, M
+
+
+def apply_boundary_conditions(N_par_tot, N_nod_tot, N_par_nod, w, K, M):
+    """
+    Applies the boundary conditions to the stiffness and mass matrices.
+
+    Returns:
+        Numpy arrays of the stiffness and mass matrices with the boundary conditions applied
+    """
+    mask = w == 1
+
+    K[mask, :] = 0
+    K[:, mask] = 0
+    M[mask, :] = 0
+    M[:, mask] = 0
+
+    # Set the diagonal elements where W is 1 to 1 or 1e-30
+    np.fill_diagonal(K, np.where(mask, 1, K.diagonal()))
+    np.fill_diagonal(M, np.where(mask, 1e-30, M.diagonal()))
+
+    return K, M
+
+
+def compute_eigenvalues_and_eigenvectors(K, M):
+    """
+    Compute the eigenvalues and eigenvectors of the stiffness and mass matrices.
+
+
+    Returns:
+        The real part of the eigenvalues (frequency) and the normalized eigenvectors (modes of vibration)
+    """
+    # Compute eigenvalues (lamb) and eigenvectors (phis)
+    lamb, phis = np.linalg.eig(np.linalg.inv(M) @ K)
+
+    # Get the indices that would sort lamb in descending order
+    idx = np.argsort(lamb)[::-1]
+
+    # Sort lamb and phis
+    lamb_r = lamb[idx]
+    phis_r = phis[:, idx]
+
+    # Normalize eigenvectors
+    N_par_tot = len(lamb)
+    phis_norm = np.zeros((N_par_tot, 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
+
+    return lamb_r, phis_norm
+
+
+def get_mode_indices(lamb_r, phis_norm, N_plots):
+    """
+    Calculate the periods to get the top contributing index_modes.
+
+    Returns:
+        Numpy array of the indices of the largest N_plots periods
+    """
+    # Calculate periods
+    period = 2 * np.pi / np.sqrt(lamb_r)
+
+    # 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]
+
+    # Extract lambdas and corresponding eigenvectors (No longer used)
+    # lamb_plots = lamb_r[index_modes]
+    # phis_plots = phis_norm[:, index_modes]
+
+    return index_modes, period
+
+
+def calculate_global_displacements(Qglo_pel_curr1_mode, Qglo_pel_curr2_mode, Qglo_pel_curr3_mode, Qglo_pel_curr4_mode, 
+                           Qglo_pel_curr5_mode, Qglo_pel_curr6_mode, beta_curr, h_e):
+    """
+    Calculate the global displacements by solving the local symbolic
+    equilibrium equations.
+
+    Returns:
+        Lambda functions for the global displacements
+    """
+    # Define symbols
+    x, f0, f1, g0, g1, g2, g3, X_old, Y_old = sp.symbols('x f0 f1 g0 g1 g2 g3 X_old Y_old')
+
+    # Define local displacements
+    u_loc_i = Qglo_pel_curr1_mode * sp.cos(beta_curr) + Qglo_pel_curr2_mode * sp.sin(beta_curr)
+    v_loc_i = -Qglo_pel_curr1_mode * sp.sin(beta_curr) + Qglo_pel_curr2_mode * sp.cos(beta_curr)
+    u_loc_j = Qglo_pel_curr4_mode * sp.cos(beta_curr) + Qglo_pel_curr5_mode * sp.sin(beta_curr)
+    v_loc_j = -Qglo_pel_curr4_mode * sp.sin(beta_curr) + Qglo_pel_curr5_mode * sp.cos(beta_curr)
+
+    # Define beam displacements
+    u_beam = f1 * x + f0
+    v_beam = g3 * x**3 + g2 * x**2 + g1 * x + g0
+
+    # Define equilibrium equations
+    equations = [
+        v_beam.subs(x, 0) - v_loc_i,
+        sp.diff(v_beam, x).subs(x, 0) - Qglo_pel_curr3_mode,
+        v_beam.subs(x, h_e) - v_loc_j,
+        sp.diff(v_beam, x).subs(x, h_e) - Qglo_pel_curr6_mode,
+        u_beam.subs(x, 0) - u_loc_i,
+        u_beam.subs(x, h_e) - u_loc_j
+    ]
+
+    # Solve the equations
+    sol = sp.solve(equations, (f0, f1, g0, g1, g2, g3))
+
+    # Assign the solution
+    f0, f1, g0, g1, g2, g3 = sol.values()
+    u_beam = u_beam.subs(sol)
+    v_beam = v_beam.subs(sol)
+
+
+    # Define new coordinates using the same expressions as in the original code
+    X_new_expr = X_old + x * sp.cos(beta_curr) + u_beam * sp.cos(beta_curr) - v_beam * sp.sin(beta_curr)
+    Y_new_expr = Y_old + x * sp.sin(beta_curr) + u_beam * sp.sin(beta_curr) + v_beam * sp.cos(beta_curr)
+
+    # Substitute the solution into the expressions
+    X_new_expr_sub = X_new_expr.subs(sol)
+    Y_new_expr_sub = Y_new_expr.subs(sol)
+
+    # Convert X_new and Y_new to lambda functions
+    X_new_sub_func = lambdify(
+        (x, X_old, Y_old, beta_curr, Qglo_pel_curr1_mode, Qglo_pel_curr2_mode, Qglo_pel_curr3_mode, Qglo_pel_curr4_mode, Qglo_pel_curr5_mode, Qglo_pel_curr6_mode, h_e),
+        X_new_expr_sub,
+        "numpy",
+    )
+
+    Y_new_sub_func = lambdify(
+        (x, X_old, Y_old, beta_curr, Qglo_pel_curr1_mode, Qglo_pel_curr2_mode, Qglo_pel_curr3_mode, Qglo_pel_curr4_mode, Qglo_pel_curr5_mode, Qglo_pel_curr6_mode, h_e),
+        Y_new_expr_sub,
+        "numpy",
+    )
+
+    return X_new_sub_func, Y_new_sub_func
+
+
+def print_matrix(matrix, width=8, precision=3, row_labels=None, col_labels=None):
+    if row_labels is None:
+        row_labels = range(1, matrix.shape[0] + 1)
+    if col_labels is None:
+        col_labels = range(1, matrix.shape[1] + 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:
+            print(f"{val:{width}.{precision}f}", end="")
+        print()

utils/simple_beam_analysis.py

@@ -0,0 +1,128 @@
+import numpy as np
+from typing import List, Optional
+
+def define_forces(W: np.ndarray, node_idxs: List, force_list: List, 
+                  n_par_nod: int, node_pos: Optional[List] = None):
+    """
+    Define the forces acting on the beam. Index is 0-based.
+    """
+    ext_forces = np.zeros((W.shape[0]), dtype=np.float32)
+
+    if len(node_idxs) != len(force_list) // n_par_nod:
+        raise ValueError("# of forces/n_par_nod != # nodes.")
+    if node_pos and len(node_pos) != len(force_list) // n_par_nod:
+        raise ValueError("# of forces/n_par_nod != # nodes positions.")
+
+    if not node_pos:
+        for i, idx in enumerate(node_idxs):
+            ext_idx = idx * n_par_nod
+            force_idx = i * n_par_nod
+            ext_forces[ext_idx:ext_idx + n_par_nod] = force_list[force_idx:force_idx + n_par_nod]
+    else:
+        for i, pos in enumerate(node_pos):
+            ext_idx = pos * n_par_nod
+            force_idx = i * n_par_nod
+            ext_forces[ext_idx:ext_idx + n_par_nod] = force_list[force_idx:force_idx + n_par_nod]
+    
+    # Apply boundary conditions by making all the places where there is 1 in W to be 0 in ext_forces
+    ext_forces = ext_forces * (1 - W)
+
+    return ext_forces
+
+
+################## Direct Stiffness Method for 2D Bernoulli Beam ##################
+def direct_assemble_global_matrices(n_par_ele: int, n_par_tot: int, n_ele_tot: int,
+                                    ele_nod: np.ndarray, h: np.ndarray,
+                                    E: np.ndarray, J: np.ndarray, A: np.ndarray,
+                                    beta: np.ndarray, pel: np.ndarray) -> np.ndarray:
+    """
+    Assemble the global stiffness matrix for 2D Bernoulli beam elements dynamically.
+
+    Args:
+        n_par_ele: Number of parameters per element (6 for 2 nodes with 3 DOFs each)
+        n_par_tot: Total number of DOFs in the system
+        n_ele_tot: Total number of elements
+        ele_nod: Element-node connectivity array (n_ele_tot x 2)
+        h: Element lengths array
+        E: Young's modulus array
+        J: Second moment of inertia array
+        A: Cross-sectional area array
+        beta: Element angles array (in radians)
+        pel: DOF mapping array (n_ele_tot x n_par_ele)
+
+    Returns:
+        K: Global stiffness matrix of size (n_par_tot x n_par_tot)
+    """
+    K = np.zeros((n_par_tot, n_par_tot), dtype=np.float64)
+
+    for e in range(n_ele_tot):
+        L = h[e]
+        EA = E[e] * A[e]
+        EI = E[e] * J[e]
+        
+        # Local stiffness matrix for a Bernoulli beam element (6x6)
+        EA_L = EA / L
+        EI_L3 = EI / L**3
+        EI_L2 = EI / L**2
+        EI_L1 = EI / L
+
+        # Assemble the local stiffness matrix in the local coordinate system
+        k_local = np.array([
+            [ EA_L,        0,         0,      -EA_L,       0,         0],
+            [  0,     12*EI_L3,   6*EI_L2,      0,  -12*EI_L3,   6*EI_L2],
+            [  0,      6*EI_L2,   4*EI_L1,      0,   -6*EI_L2,   2*EI_L1],
+            [ -EA_L,       0,         0,       EA_L,       0,         0],
+            [  0,   -12*EI_L3,  -6*EI_L2,      0,   12*EI_L3,  -6*EI_L2],
+            [  0,      6*EI_L2,   2*EI_L1,      0,   -6*EI_L2,   4*EI_L1]
+        ])
+        
+        # Transformation matrix for element orientation (6x6)
+        c = np.cos(beta[e])
+        s = np.sin(beta[e])
+        T = np.array([
+            [ c,   s,  0,   0,   0,  0],
+            [-s,   c,  0,   0,   0,  0],
+            [ 0,   0,  1,   0,   0,  0],
+            [ 0,   0,  0,   c,   s,  0],
+            [ 0,   0,  0,  -s,   c,  0],
+            [ 0,   0,  0,   0,   0,  1]
+        ])
+        
+        # Rotate local stiffness matrix to global coordinates
+        k_global = T.T @ k_local @ T
+        
+        # Get global DOF indices
+        idx = pel[e, :] - 1 # Global DOF indices for element 'e'
+        
+        # Assemble into global stiffness matrix
+        K[np.ix_(idx, idx)] += k_global
+
+    return K
+
+def direct_apply_boundary_conditions(K: np.ndarray, W: np.ndarray) -> np.ndarray:
+    """
+    Apply boundary conditions to global stiffness matrix using W array.
+    W[i] = 1 means DOF i is restrained, W[i] = 0 means DOF i is free.
+    
+    Args:
+        K: Global stiffness matrix
+        W: Boundary condition array (1 for restrained, 0 for free DOFs)
+    
+    Returns:
+        K: Modified stiffness matrix with boundary conditions applied
+    """
+    # Make copy to avoid modifying original
+    K_bc = K.copy()
+    max_k = np.max(np.abs(np.diag(K))) # Double check this
+    
+    # Find restrained DOFs
+    restrained_dofs = np.where(W == 1)[0]
+    
+    # For each restrained DOF
+    for dof in restrained_dofs:
+        # Zero out row and column
+        K_bc[dof, :] = 0
+        K_bc[:, dof] = 0
+        K_bc[dof, dof] = max_k
+
+    return K_bc

utils/simple_beam_constraints.py

@@ -0,0 +1,69 @@
+# General parameters
+span = 1.4 # 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
+
+# For paper verification, steel beams are 4x4 cm and concrete beams are 12x27 in cm 
+width_beam = 0.04
+height_beam = 0.04
+width_beam_conc = 0.12
+height_beam_conc = 0.27
+
+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 # Steel 78.5 typically
+elastic_mod = 183*10**6 # Steel 210 GPA typically
+elastic_mod_rod = 210*10**6
+
+# Compressive 51 Mpa and tensile 3.6 Mpa
+# Unit weight and elastic modulus in kN/m^3 and kN/m^2
+unit_weight_conc = 18.7 # Steel 78.5, concrete 1870
+elastic_mod_conc = 24*10**6 # Steel 210, concrete 24
+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/simple_beam_helper.py

@@ -0,0 +1,449 @@
+import logging
+import numpy as np
+from typing import List, Optional, Tuple, Union
+
+# Get the logger
+logger = logging.getLogger(__name__)
+
+def calculate_simple_essential_elements(span: float, spacing: Optional[float] = 0,
+                                        truss_mode: str = "simple", beam_partition: int = 1,
+                                        col_placements: Optional[List[float]] = None,
+                                        skip_col: Optional[List[int]] = None,
+                                        cantilever_sides: int = 1,
+                                        add_extra_pt: bool = False) -> Tuple[int, int, int, int, int, int]:
+    """
+    Calculate the number of columns, nodes, rods, beams, and total elements for a simple beam.
+
+    Args:
+        span (float): The total length of the beam.
+        spacing (float or List[float]): Distance between nodes or list of node positions.
+        truss_mode (str): The type of beam ("simple", "simple_cant").
+        beam_partition (int): Number of divisions in the beam.
+        col_placements (List[float], optional): Custom positions of the columns (supports).
+        skip_col (List[int], optional): Indices of columns to skip.
+
+    Returns:
+        Tuple[int, int, int, int, int, int]: Number of columns, total nodes, rods, beams, total elements, and bottom beams.
+    """
+    if not spacing:
+        print("Spacing was not provided. Defaulting to 1. Hence a simply supported beam.")
+        spacing = 1.0
+    assert span % spacing == 0, "Spacing does not divide the span evenly."
+
+    
+    n_columns = int(span // spacing) + 1
+    n_rods = 0  # Simple beams have no rods
+    n_beams = (n_columns - 1) * beam_partition
+    if truss_mode != "simple":
+        if cantilever_sides > 2:
+            print("Cantilever sides cannot be more than 2. Defaulting to 2.")
+            cantilever_sides = 2
+        n_beams += cantilever_sides * beam_partition
+    
+    n_nod_tot = n_beams + 1  # Number of nodes is one more than the number of beams
+
+    if add_extra_pt and span/2 == n_nod_tot/2 * spacing:
+        print("Extra point cannot be added at the center. Defaulting to False.")
+        add_extra_pt = False
+
+    if skip_col:
+        n_nod_tot -= len(skip_col)
+
+    if add_extra_pt:
+        n_nod_tot += 1
+        n_beams += 1
+
+    n_ele_tot = n_beams  # Only beams are considered elements here
+    n_bot_beams = 0  # Not applicable for simple beams
+
+    return n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams
+
+
+def calculate_simple_element_node(span: float, spacing: Union[float, List[float]], n_dim: int,
+                                  n_par_nod: int, truss_mode: str = "simple",
+                                  beam_partition: int = 1,
+                                  col_placements: Optional[List[float]] = None,
+                                  skip_col: Optional[List[int]] = None,
+                                  cantilever_sides: int = 1,
+                                  add_extra_pt: bool = False) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int]:
+    """
+    Calculate nodal coordinates, nodal-param relation, and element-node relationships for a simple beam.
+
+    Args:
+        span (float): The total length of the beam.
+        spacing (float or List[float]): Distance between nodes or list of node positions.
+        n_dim (int): Number of dimensions (usually 2).
+        n_par_nod (int): Number of parameters per node (e.g., 2 for x and y coordinates).
+        truss_mode (str): The type of beam ("simple", "simple_cant").
+        skip_rod (List[int], optional): Rods to skip (not applicable for simple beams).
+        beam_partition (int): Number of divisions in the beam.
+        col_placements (List[float], optional): Custom positions of the columns (supports).
+        skip_col (List[int], optional): Indices of columns to skip.
+
+    Returns:
+        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, int]: Nodal coordinates, parameter matrix, parameter-element relation, element-node relation, and total parameters.
+    """
+    # Get essential elements
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_simple_essential_elements(
+        span, spacing, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides, add_extra_pt)
+
+    n_par_tot = n_nod_tot * n_par_nod
+    
+    # Generate nodal coordinates
+    nodal_coord = nodal_coords_simple(n_nod_tot, n_dim, spacing, span, n_beams,
+                                      col_placements, skip_col, beam_partition,
+                                      truss_mode, cantilever_sides, add_extra_pt)
+
+    # Generate nodal parameters
+    par = np.arange(1, n_par_tot + 1).reshape(n_nod_tot, n_par_nod)
+
+    # Generate element-parameter relationships
+    pel = pel_ele_simple(par, n_beams, n_par_nod)
+
+    # Generate element-node relationships
+    ele_nod = fill_ele_nod_simple(n_beams, n_par_nod, pel)
+
+    return nodal_coord, par, pel, ele_nod, n_par_tot
+
+
+def nodal_coords_simple(n_nod_tot: int, n_dim: int, spacing: Union[float, List[float]],
+                        span: float, n_beams: int,
+                        col_placements: Optional[List[float]] = None,
+                        skip_col: Optional[List[int]] = None, beam_partition: int = 1,
+                        truss_mode: str = "simple", cantilever_sides: int = 2,
+                        add_extra_pt: bool = False) -> np.ndarray:
+    """
+    Generate nodal coordinates for a simple beam.
+
+    Args:
+        n_nod_tot (int): Total number of nodes.
+        n_dim (int): Number of dimensions.
+        spacing (float or List[float]): Spacing between nodes or list of node positions.
+        span (float): Total length of the beam.
+        col_placements (List[float], optional): Custom positions of the columns (supports).
+        skip_col (List[int], optional): Indices of columns to skip.
+        beam_partition (int): Number of divisions in the beam.
+        truss_mode (str): The type of beam ("simple", "simple_cant").
+        cantilever_sides (int): Number of cantilever sides. It will default to left side then right. 
+
+    Returns:
+        np.ndarray: The nodal coordinates.
+    """
+    if cantilever_sides > 2:
+        print("Cantilever sides cannot be more than 2. Defaulting to 2.")
+        cantilever_sides = 2
+    
+    if col_placements:
+        node_positions = col_placements
+    else:
+        if isinstance(spacing, list):
+            # Generate node positions from spacing list
+            node_positions = [0]
+            for s in spacing:
+                node_positions.append(node_positions[-1] + s)
+        else:
+            # Evenly spaced nodes
+            if truss_mode != "simple":
+                # extra_span = (n_beams - cantilever_sides * beam_partition) * spacing
+                # extra_nodes = (cantilever_sides * beam_partition) - (cantilever_sides - 1)
+                if not add_extra_pt:
+                    node_positions = [i * (span + span * cantilever_sides) / n_beams for i in range(n_nod_tot)]
+                else:
+                    node_positions = [i * (span + span * cantilever_sides) / n_beams for i in range(n_nod_tot-1)]
+                    node_positions = node_positions[:n_nod_tot//2] + [span + span * cantilever_sides] + node_positions[n_nod_tot//2:]
+
+            else:
+                if not add_extra_pt:
+                    node_positions = [i * span / n_beams for i in range(n_nod_tot)]
+                else:
+                    node_positions = [i * span / n_beams for i in range(n_nod_tot-1)]
+                    node_positions = node_positions[:n_nod_tot//2] + [span] + node_positions[n_nod_tot//2:]
+    
+    # Apply skip_col if provided
+    if skip_col:
+        node_positions = [pos for idx, pos in enumerate(node_positions) if idx not in skip_col]
+    
+    nodal_coord = np.zeros((n_nod_tot, n_dim))
+    
+    logging.debug("In the nodal_coord_simple function we have: n_nod_tot: %d, \n\
+                  node_positions: %s, n_beams: %d", n_nod_tot, node_positions, n_beams)
+    for i in range(n_nod_tot):
+        nodal_coord[i, 0] = node_positions[i]
+        nodal_coord[i, 1] = 0 
+
+    return nodal_coord
+
+
+def pel_ele_simple(par: np.ndarray, n_beams: int, n_par_nod: int) -> np.ndarray:
+    """
+    Generate the parameter-element numbering relation for a simple beam with 2 nodes
+
+    Args:
+        par (np.ndarray): Parameter matrix.
+        n_beams (int): Number of beams (elements).
+        n_par_nod (int): Number of parameters per node.
+
+    Returns:
+        np.ndarray: The parameter-element numbering relation.
+    """
+    pel = np.zeros((n_beams, 2 * n_par_nod), dtype=int)
+    for i in range(n_beams):
+        pel[i, :n_par_nod] = par[i]
+        pel[i, n_par_nod:] = par[i + 1]
+
+    return pel
+
+
+def fill_ele_nod_simple(n_beams: int, n_par_nod: int, pel: np.ndarray) -> np.ndarray:
+    """
+    Generate the element-node relationships for a simple beam.
+
+    Args:
+        n_beams (int): Number of beams (elements).
+        n_par_nod (int): Number of parameters per node.
+        pel (np.ndarray): Parameter-element numbering relation.
+
+    Returns:
+        np.ndarray: The element-node relationships.
+    """
+    ele_nod = np.zeros((n_beams, 2), dtype=int)
+    # print(ele_nod, pel, n_beams)
+    logging.debug("In the fill_ele_nod_simple function we have: n_beams: %d, \n\
+                  ele_nod: %s, pel: %s", n_beams, ele_nod, pel)
+    for i in range(n_beams):
+        ele_nod[i, 0] = (pel[i, 0] - 1) // n_par_nod
+        ele_nod[i, 1] = (pel[i, n_par_nod] - 1) // n_par_nod
+
+    return ele_nod
+
+
+def boundary_conditions_simple(spacing: int, n_par_nod: int, n_nod_tot: int, n_columns: int, col_placements: List,
+                               cantilever_sides: int, beam_partition: int, truss_mode: str = "simple",
+                               default_support: str = "roller", supports: List = ["pin", "roller"]) -> np.ndarray:
+    """
+    Generate boundary conditions for a simple beam or cantilever.
+    If custom column placements are provided, it uses those; otherwise, 
+    it defaults to evenly spaced supports. The function ensures that there are enough supports
+    by defaulting to the specified default support type if necessary
+
+    Args:
+        spacing (int): Distance between nodes.
+        n_par_nod (int): Number of parameters per node (e.g., 2 for x and y coordinates).
+        n_nod_tot (int): Total number of nodes.
+        n_columns (int): Number of columns (supports).
+        col_placements (List): Custom positions of the columns (supports).
+        beam_partition (int): Number of divisions in the beam.
+        truss_mode (str, optional): The type of beam ("simple", "simple_cant"). Defaults to "simple".
+        default_support (str, optional): Default support type if not enough supports are provided. Defaults to "roller".
+        supports (List, optional): List of support types (e.g., ["pin", "roller"]). Defaults to ["pin", "roller"].
+
+    Returns:
+        np.ndarray: Array representing the boundary conditions for each node.
+    """
+    # 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
+    
+    # TODO: Implement 
+    adj_nod = 0 # Adjust the starting node
+    adj_nod_end = 0 # Adjust the ending node
+    adj_mode = 1 if truss_mode == "simple" else 0
+    if truss_mode != "simple":
+        adj_nod = beam_partition
+        if cantilever_sides >= 2:
+            adj_nod_end = beam_partition - 1
+    
+    if col_placements:
+        if len(supports) < len(col_placements):
+            print("Not enough supports provided. Defaulting to pin and roller.")
+            supports = [supports[0]]
+            supports.extend(default_support * (len(col_placements) - 1))
+    elif len(supports) < n_columns:
+        print(f"Not enough supports provided for boundary conditions. \
+              Defaulting to pin then {default_support} for {n_columns - 1} columns.")
+        supports = [supports[0]]
+        supports.extend([default_support] * (n_columns - 1))
+    
+    temp = np.zeros((n_nod_tot * n_par_nod), dtype=int)
+    counter = 0
+    # Counter for incrementing supports
+    # Range starts from the first non-cantiliver node till the last non-cantilever node
+    # Movevment is based on the original beam subtracted by the number of columns
+    try:
+        for i in range(adj_nod, n_nod_tot - adj_nod_end, max(n_nod_tot - adj_nod - adj_nod_end - len(supports) + adj_mode, 1)):
+            temp[i * n_par_nod:(i + 1) * n_par_nod] = support_dof(supports[counter], n_par_nod)
+            counter += 1
+    except IndexError:
+        logging.error(f"Check the last non-cantilever node or support indexes \n\
+                      adj_nod: {adj_nod}, n_nod_tot: {n_nod_tot}, adj_nod_end: {adj_nod_end}, n_columns: {n_columns} supports: {supports}")
+    
+    return temp
+
+
+def insert_simple_node(node_pos: float, x_pos: np.ndarray, n_par_nod: int,
+                       length_arr: np.ndarray, same_property_list: List[np.ndarray],
+                       node_list: List[np.ndarray], W: np.ndarray, n_ele_tot: int,
+                       n_par_tot: int, n_nod_tot: int) -> Tuple:
+    """
+    Insert a new node into the existing structure.
+    This function updates the node positions, lengths, and relationships accordingly.
+
+    Returns:
+        Updated node positions, lengths, relationships, and counts.
+    """
+    if node_pos in x_pos:
+        print("Attempted node insertion. Node already exists")
+        return (x_pos, length_arr, *same_property_list, *node_list, W, n_ele_tot, n_par_tot, n_nod_tot)
+
+    n_ele_tot += 1
+    n_nod_tot += 1
+    n_par_tot += n_par_nod
+    node_idx = np.searchsorted(x_pos, node_pos)
+    x_pos = np.insert(x_pos, node_idx, node_pos)
+    W = np.insert(W, node_idx * n_par_nod, np.zeros(n_par_nod, dtype=np.int32), axis=0)
+
+    length_arr = np.insert(length_arr, node_idx, x_pos[node_idx+1] - node_pos)
+    length_arr[node_idx - 1] = node_pos - x_pos[node_idx - 1]
+
+    def insert_node(node_idx, node_arr, n_par_nod, increment: int = 0):
+        if not increment:
+            node_arr = np.insert(node_arr, node_idx, node_arr[node_idx - 1], axis=0)
+        else:
+            node_arr = np.append(node_arr, [node_arr[-1] + np.arange(1, len(node_arr[-1]) + 1)], axis=0)
+        return node_arr
+    
+    for i in range(len(same_property_list)):
+        same_property_list[i] = insert_node(node_idx, same_property_list[i], n_par_nod)
+
+    for i in range(len(node_list)):
+        node_list[i] = insert_node(node_idx, node_list[i], n_par_nod, increment=1)
+    
+    # Fix pel
+    last_pel = node_list[0][-2][n_par_nod:]  
+    new_pel = last_pel + n_par_nod  
+    node_list[0][-1] = np.concatenate((last_pel, new_pel))
+
+    return (x_pos, length_arr, *same_property_list, *node_list, W, n_ele_tot, n_par_tot, n_nod_tot)
+
+
+# Run some test cases if its the main module
+if __name__ == "__main__":
+    # Test case 1 with beam partition
+    test_case = 1
+    span = 25
+    spacing = 12.5
+    n_dim = 2
+    n_par_nod = 3
+    truss_mode = "simple"
+    beam_partition = 2
+    col_placements = None
+    skip_col = None
+    cantilever_sides = 2
+
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_simple_essential_elements(
+        span, spacing, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print(
+        f"There are {n_columns} columns, {n_nod_tot} total nodes, {n_beams} beams and {n_ele_tot} total elements (excluding columns)"
+    )
+
+    nodal_coord, par, pel, ele_nod, n_par_tot = calculate_simple_element_node(
+        span, spacing, n_dim, n_par_nod, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print("Nodal Coordinates:\n", nodal_coord)
+    print("Parameter Matrix:\n", par)
+    print("Parameter-Element Relationship:\n", pel)
+    print("Element-Node Relationship:\n", ele_nod)
+    print("Total Parameters:", n_par_tot)
+
+    print(f"Test {test_case} test done successfully\n\n")
+
+    # Test case 2 without beam partition
+    test_case = 2
+    span = 25
+    spacing = 25
+    n_dim = 2
+    n_par_nod = 2
+    truss_mode = "simple"
+    beam_partition = 1
+    col_placements = None
+    skip_col = None
+
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_simple_essential_elements(
+        span, spacing, truss_mode, beam_partition, col_placements, skip_col)
+    print(
+        f"There are {n_columns} columns, {n_nod_tot} total nodes, {n_beams} beams and {n_ele_tot} total elements (excluding columns)"
+    )
+
+    nodal_coord, par, pel, ele_nod, n_par_tot = calculate_simple_element_node(
+        span, spacing, n_dim, n_par_nod, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print("Nodal Coordinates:\n", nodal_coord)
+    print("Parameter Matrix:\n", par)
+    print("Parameter-Element Relationship:\n", pel)
+    print("Element-Node Relationship:\n", ele_nod)
+    print("Total Parameters:", n_par_tot)
+
+    print(f"Test {test_case} test done successfully\n\n")
+
+
+    # Test case 3 without beam partition simple cant
+    test_case = 3
+    span = 25
+    spacing = 25
+    n_dim = 2
+    n_par_nod = 2
+    truss_mode = "simple_cant"
+    beam_partition = 1
+    col_placements = None
+    skip_col = None
+    cantilever_sides = 2
+
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_simple_essential_elements(
+        span, spacing, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print(
+        f"There are {n_columns} columns, {n_nod_tot} total nodes, {n_beams} beams and {n_ele_tot} total elements (excluding columns)"
+    )
+
+    nodal_coord, par, pel, ele_nod, n_par_tot = calculate_simple_element_node(
+        span, spacing, n_dim, n_par_nod, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print("Nodal Coordinates:\n", nodal_coord)
+    print("Parameter Matrix:\n", par)
+    print("Parameter-Element Relationship:\n", pel)
+    print("Element-Node Relationship:\n", ele_nod)
+    print("Total Parameters:", n_par_tot)
+
+    print(f"Test {test_case} test done successfully\n\n")
+
+
+    # Test case 4 with beam partition simple cant
+    test_case = 3
+    span = 25
+    spacing = 25
+    n_dim = 2
+    n_par_nod = 2
+    truss_mode = "simple_cant"
+    beam_partition = 2
+    col_placements = None
+    skip_col = None
+    cantilever_sides = 1
+
+    n_columns, n_nod_tot, n_rods, n_beams, n_ele_tot, n_bot_beams = calculate_simple_essential_elements(
+        span, spacing, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print(
+        f"There are {n_columns} columns, {n_nod_tot} total nodes, {n_beams} beams and {n_ele_tot} total elements (excluding columns)"
+    )
+
+    nodal_coord, par, pel, ele_nod, n_par_tot = calculate_simple_element_node(
+        span, spacing, n_dim, n_par_nod, truss_mode, beam_partition, col_placements, skip_col, cantilever_sides)
+    print("Nodal Coordinates:\n", nodal_coord)
+    print("Parameter Matrix:\n", par)
+    print("Parameter-Element Relationship:\n", pel)
+    print("Element-Node Relationship:\n", ele_nod)
+    print("Total Parameters:", n_par_tot)
+
+    print(f"Test {test_case} test done successfully\n\n")

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}")