@wentorai/research-plugins 1.0.0

package/skills/domains/pharma/clinical-pharmacology-guide/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: clinical-pharmacology-guide
+description: "Clinical pharmacology principles for dosing, drug interactions, and patient s..."
+metadata:
+  openclaw:
+    emoji: "syringe"
+    category: "domains"
+    subcategory: "pharma"
+    keywords: ["drug development", "pharmacokinetics", "clinical trial", "nursing", "pharmacodynamics", "drug interactions"]
+    source: "wentor"
+---
+
+# Clinical Pharmacology Guide
+
+A skill for applying clinical pharmacology principles to research and practice. Covers pharmacokinetic/pharmacodynamic modeling, drug interaction assessment, therapeutic drug monitoring, and special population dosing.
+
+## Pharmacokinetic-Pharmacodynamic (PK/PD) Relationships
+
+### The Emax Model
+
+The most widely used PK/PD model relates drug concentration to effect:
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+
+def emax_model(concentration: np.ndarray, emax: float, ec50: float,
+                hill: float = 1, baseline: float = 0) -> np.ndarray:
+    """
+    Sigmoid Emax (Hill) model.
+
+    Args:
+        concentration: Drug concentration array
+        emax: Maximum effect
+        ec50: Concentration producing 50% of Emax
+        hill: Hill coefficient (steepness)
+        baseline: Baseline effect (E0)
+    """
+    effect = baseline + (emax * concentration**hill) / (ec50**hill + concentration**hill)
+    return effect
+
+# Example: dose-response curve
+conc = np.logspace(-2, 3, 200)
+effect = emax_model(conc, emax=100, ec50=10, hill=1.5)
+
+fig, ax = plt.subplots(figsize=(8, 5))
+ax.semilogx(conc, effect)
+ax.set_xlabel('Concentration (ng/mL)')
+ax.set_ylabel('Effect (%)')
+ax.set_title('Sigmoid Emax Model')
+ax.axhline(y=50, color='gray', linestyle='--', alpha=0.5)
+ax.axvline(x=10, color='gray', linestyle='--', alpha=0.5)
+ax.annotate('EC50', xy=(10, 50), fontsize=12)
+plt.tight_layout()
+```
+
+## Drug Interaction Assessment
+
+### Cytochrome P450 Interaction Prediction
+
+```python
+def predict_cyp_interaction(victim_drug: dict, perpetrator_drug: dict) -> dict:
+    """
+    Predict metabolic drug-drug interaction potential.
+
+    Args:
+        victim_drug: {'name': str, 'primary_cyp': str, 'fraction_metabolized': float}
+        perpetrator_drug: {'name': str, 'cyp_effects': dict}
+            cyp_effects maps CYP enzyme to 'inhibitor'|'inducer'|'none'
+    """
+    cyp = victim_drug['primary_cyp']
+    fm = victim_drug['fraction_metabolized']  # fraction metabolized by this CYP
+
+    perp_effect = perpetrator_drug['cyp_effects'].get(cyp, 'none')
+
+    if perp_effect == 'inhibitor':
+        # AUC ratio = 1 / (1 - fm) for complete inhibition
+        auc_ratio = 1 / (1 - fm) if fm < 1 else float('inf')
+        risk = 'high' if auc_ratio > 5 else 'moderate' if auc_ratio > 2 else 'low'
+    elif perp_effect == 'inducer':
+        # Induction decreases exposure
+        auc_ratio = 1 - fm * 0.7  # approximate 70% induction
+        risk = 'high' if auc_ratio < 0.3 else 'moderate' if auc_ratio < 0.5 else 'low'
+    else:
+        auc_ratio = 1.0
+        risk = 'none'
+
+    return {
+        'victim': victim_drug['name'],
+        'perpetrator': perpetrator_drug['name'],
+        'affected_cyp': cyp,
+        'interaction_type': perp_effect,
+        'predicted_auc_ratio': round(auc_ratio, 2),
+        'clinical_risk': risk,
+        'recommendation': (
+            'Dose adjustment required' if risk == 'high'
+            else 'Monitor closely' if risk == 'moderate'
+            else 'No action needed'
+        )
+    }
+```
+
+## Therapeutic Drug Monitoring (TDM)
+
+### Narrow Therapeutic Index Drugs
+
+Drugs requiring routine TDM due to narrow therapeutic windows:
+
+| Drug | Therapeutic Range | Toxic Level | Monitoring Frequency |
+|------|------------------|-------------|---------------------|
+| Vancomycin | AUC/MIC 400-600 | AUC/MIC > 600 | Trough before 4th dose |
+| Lithium | 0.6-1.2 mEq/L | > 1.5 mEq/L | Weekly initially, then monthly |
+| Digoxin | 0.8-2.0 ng/mL | > 2.0 ng/mL | At steady state (5-7 days) |
+| Phenytoin | 10-20 mcg/mL | > 20 mcg/mL | 2 weeks after dose change |
+| Tacrolimus | 5-15 ng/mL | > 20 ng/mL | Twice weekly post-transplant |
+
+### Bayesian TDM
+
+```python
+def bayesian_dose_adjustment(prior_cl: float, prior_cl_cv: float,
+                              measured_conc: float, expected_conc: float,
+                              current_dose: float) -> dict:
+    """
+    Simple Bayesian dose adjustment using one-point TDM.
+
+    Args:
+        prior_cl: Population clearance estimate (L/hr)
+        prior_cl_cv: CV of clearance in population (0-1)
+        measured_conc: Observed trough concentration
+        expected_conc: Expected concentration at population CL
+        current_dose: Current dose (mg)
+    """
+    # Individual clearance estimate (MAP approach, simplified)
+    ratio = expected_conc / measured_conc
+    individual_cl = prior_cl * ratio
+
+    # Bayesian shrinkage toward population
+    weight = 1 / (1 + prior_cl_cv**2)
+    posterior_cl = weight * prior_cl + (1 - weight) * individual_cl
+
+    # New dose to achieve target
+    target_conc = (measured_conc + expected_conc) / 2  # midpoint of range
+    new_dose = current_dose * (posterior_cl / prior_cl)
+
+    return {
+        'individual_CL': round(individual_cl, 2),
+        'posterior_CL': round(posterior_cl, 2),
+        'recommended_dose': round(new_dose, 1),
+        'dose_change_pct': round((new_dose - current_dose) / current_dose * 100, 1)
+    }
+```
+
+## Special Populations
+
+Dosing considerations for specific patient groups:
+
+- **Renal impairment**: Use Cockcroft-Gault or CKD-EPI for GFR estimation; adjust doses for renally cleared drugs proportionally
+- **Hepatic impairment**: Use Child-Pugh score; reduce doses of hepatically metabolized drugs by 25-50% for moderate impairment
+- **Pediatric**: Use allometric scaling (CL proportional to body weight^0.75) rather than simple mg/kg dosing
+- **Geriatric**: Account for decreased renal function, polypharmacy, and altered body composition
+- **Pregnancy**: Increased clearance for many drugs due to increased blood volume and GFR
+
+## Regulatory Considerations
+
+All clinical pharmacology studies should follow ICH guidelines (E4 for dose-response, E5 for ethnic factors, E7 for geriatric, E11 for pediatric). Report results in standardized population PK/PD formats compatible with FDA and EMA submission requirements.

package/skills/domains/pharma/drug-development-guide/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: drug-development-guide
+description: "End-to-end drug development pipeline from target identification to regulatory..."
+metadata:
+  openclaw:
+    emoji: "pill"
+    category: "domains"
+    subcategory: "pharma"
+    keywords: ["drug development", "pharmacokinetics", "clinical trial", "drug discovery", "lead optimization"]
+    source: "wentor"
+---
+
+# Drug Development Guide
+
+A comprehensive skill covering the drug development pipeline from target identification through regulatory approval. Designed for pharmaceutical researchers, medicinal chemists, and clinical scientists conducting academic or industry research.
+
+## Drug Discovery Pipeline Overview
+
+```
+Target ID -> Hit Finding -> Lead Optimization -> Preclinical -> Phase I -> Phase II -> Phase III -> Regulatory Filing
+  (1-2 yr)    (1-2 yr)      (1-3 yr)            (1-2 yr)      (1 yr)     (2 yr)      (3 yr)       (1-2 yr)
+
+Total timeline: ~10-15 years | Success rate: ~5-10% from Phase I to approval
+Estimated cost: $1.3B-$2.8B per approved drug (DiMasi et al., 2016)
+```
+
+## Target Identification and Validation
+
+### Computational Target Discovery
+
+```python
+import pandas as pd
+from scipy import stats
+
+def differential_expression_analysis(expression_data: pd.DataFrame,
+                                      disease_group: list[str],
+                                      control_group: list[str],
+                                      fdr_threshold: float = 0.05) -> pd.DataFrame:
+    """
+    Identify differentially expressed genes as potential drug targets.
+
+    Args:
+        expression_data: Gene x Sample expression matrix
+        disease_group: Sample IDs in disease condition
+        control_group: Sample IDs in control condition
+        fdr_threshold: False discovery rate threshold
+    """
+    results = []
+    for gene in expression_data.index:
+        disease_vals = expression_data.loc[gene, disease_group]
+        control_vals = expression_data.loc[gene, control_group]
+        t_stat, p_value = stats.ttest_ind(disease_vals, control_vals)
+        fold_change = disease_vals.mean() / (control_vals.mean() + 1e-10)
+        results.append({
+            'gene': gene,
+            'fold_change': fold_change,
+            'log2_fc': np.log2(abs(fold_change) + 1e-10),
+            'p_value': p_value,
+            't_statistic': t_stat
+        })
+
+    df = pd.DataFrame(results)
+    # Benjamini-Hochberg FDR correction
+    from statsmodels.stats.multitest import multipletests
+    df['fdr'] = multipletests(df['p_value'], method='fdr_bh')[1]
+    df['significant'] = df['fdr'] < fdr_threshold
+    return df.sort_values('fdr')
+```
+
+### Target Validation Criteria
+
+A robust drug target should satisfy multiple criteria:
+
+| Criterion | Method | Evidence Strength |
+|-----------|--------|------------------|
+| Genetic association | GWAS, Mendelian randomization | Strong |
+| Expression in disease tissue | RNA-seq, immunohistochemistry | Moderate |
+| Functional role | CRISPR knockout, siRNA | Strong |
+| Druggability | Structural analysis, binding pockets | Essential |
+| Safety (anti-target) | Phenotype of loss-of-function mutations | Essential |
+
+## Lead Optimization
+
+### ADMET Property Prediction
+
+Assess absorption, distribution, metabolism, excretion, and toxicity early:
+
+```python
+def lipinski_rule_of_five(molecular_weight: float, logp: float,
+                           hbd: int, hba: int) -> dict:
+    """
+    Evaluate Lipinski's Rule of Five for oral bioavailability.
+
+    Args:
+        molecular_weight: Molecular weight in Da
+        logp: Calculated LogP (lipophilicity)
+        hbd: Number of hydrogen bond donors
+        hba: Number of hydrogen bond acceptors
+    """
+    violations = 0
+    details = []
+
+    if molecular_weight > 500:
+        violations += 1
+        details.append(f"MW {molecular_weight} > 500")
+    if logp > 5:
+        violations += 1
+        details.append(f"LogP {logp} > 5")
+    if hbd > 5:
+        violations += 1
+        details.append(f"HBD {hbd} > 5")
+    if hba > 10:
+        violations += 1
+        details.append(f"HBA {hba} > 10")
+
+    return {
+        'violations': violations,
+        'passes': violations <= 1,
+        'details': details,
+        'assessment': 'Likely orally bioavailable' if violations <= 1
+                      else 'Poor oral bioavailability expected'
+    }
+```
+
+## Pharmacokinetics Modeling
+
+### Compartmental PK Analysis
+
+```python
+import numpy as np
+from scipy.optimize import curve_fit
+
+def one_compartment_iv(t, dose, V, CL):
+    """One-compartment IV bolus model."""
+    k_el = CL / V
+    return (dose / V) * np.exp(-k_el * t)
+
+def compute_pk_parameters(time_points: np.ndarray,
+                           concentrations: np.ndarray,
+                           dose: float) -> dict:
+    """
+    Fit one-compartment model and derive PK parameters.
+    """
+    popt, pcov = curve_fit(
+        lambda t, V, CL: one_compartment_iv(t, dose, V, CL),
+        time_points, concentrations,
+        p0=[10, 1], bounds=(0, [1000, 100])
+    )
+    V, CL = popt
+    t_half = 0.693 * V / CL
+    auc = dose / CL
+
+    return {
+        'volume_of_distribution_L': round(V, 2),
+        'clearance_L_hr': round(CL, 2),
+        'half_life_hr': round(t_half, 2),
+        'AUC_mg_hr_L': round(auc, 2)
+    }
+```
+
+## Clinical Trial Design
+
+### Phase Selection and Endpoints
+
+| Phase | Primary Goal | Typical N | Key Endpoints |
+|-------|-------------|-----------|---------------|
+| Phase I | Safety, dose finding | 20-80 | MTD, DLT, PK |
+| Phase II | Efficacy signal | 100-300 | ORR, PFS, biomarkers |
+| Phase III | Confirmatory efficacy | 300-3000 | OS, PFS, PROs |
+| Phase IV | Post-marketing surveillance | 1000+ | ADRs, real-world effectiveness |
+
+Always pre-register clinical trials on ClinicalTrials.gov and follow CONSORT guidelines for reporting. Use adaptive trial designs (e.g., Bayesian adaptive randomization, seamless Phase II/III) when appropriate to improve efficiency.
+
+## References
+
+- DiMasi, J. A., Grabowski, H. G., & Hansen, R. W. (2016). Innovation in the pharmaceutical industry. *Journal of Health Economics*, 47, 20-33.
+- Lipinski, C. A. (2004). Lead- and drug-like compounds. *Advanced Drug Delivery Reviews*, 56(3), 215-217.

package/skills/domains/physics/computational-physics-guide/SKILL.md

@@ -0,0 +1,300 @@
+---
+name: computational-physics-guide
+description: "Computational physics methods, simulations, and research tools"
+metadata:
+  openclaw:
+    emoji: "atom"
+    category: "domains"
+    subcategory: "physics"
+    keywords: ["computational physics", "quantum mechanics", "statistical physics", "condensed matter"]
+    source: "wentor-research-plugins"
+---
+
+# Computational Physics Guide
+
+Apply computational methods to physics research, including molecular dynamics, Monte Carlo simulations, quantum computing, and numerical methods for solving physical systems.
+
+## Computational Methods Overview
+
+| Method | Application | Scale | Key Software |
+|--------|-------------|-------|-------------|
+| **Molecular Dynamics (MD)** | Atomic-scale dynamics, materials | Atoms-molecules | LAMMPS, GROMACS, NAMD |
+| **Density Functional Theory (DFT)** | Electronic structure, quantum chemistry | Electrons | VASP, Gaussian, Quantum ESPRESSO |
+| **Monte Carlo (MC)** | Statistical mechanics, phase transitions | Configurable | Custom, CASINO |
+| **Finite Element Method (FEM)** | Continuum mechanics, electrostatics | Macroscopic | COMSOL, FEniCS, Abaqus |
+| **Finite Difference (FDTD)** | Electrodynamics, wave propagation | Macroscopic | Meep, Lumerical |
+| **N-body Simulation** | Gravitational dynamics, plasma | Stars/particles | GADGET, REBOUND |
+| **Lattice QCD** | Quantum chromodynamics | Subatomic | MILC, openQCD |
+
+## Molecular Dynamics
+
+### Basic MD Algorithm
+
+```python
+import numpy as np
+
+def lennard_jones(r, epsilon=1.0, sigma=1.0):
+    """Lennard-Jones potential and force."""
+    r6 = (sigma / r) ** 6
+    r12 = r6 ** 2
+    potential = 4 * epsilon * (r12 - r6)
+    force = 24 * epsilon * (2 * r12 - r6) / r
+    return potential, force
+
+def velocity_verlet(positions, velocities, forces, masses, dt):
+    """Velocity Verlet integration step."""
+    # Half-step velocity update
+    velocities += 0.5 * forces / masses * dt
+    # Full-step position update
+    positions += velocities * dt
+    # Compute new forces
+    new_forces = compute_forces(positions)
+    # Complete velocity update
+    velocities += 0.5 * new_forces / masses * dt
+    return positions, velocities, new_forces
+
+def md_simulation(n_atoms, n_steps, dt=0.001, temperature=1.0):
+    """Simple NVE molecular dynamics simulation."""
+    # Initialize positions on a grid
+    positions = initialize_fcc_lattice(n_atoms, box_size=10.0)
+    velocities = np.random.randn(n_atoms, 3) * np.sqrt(temperature)
+    velocities -= velocities.mean(axis=0)  # Remove center of mass motion
+
+    forces = compute_forces(positions)
+    trajectory = []
+
+    for step in range(n_steps):
+        positions, velocities, forces = velocity_verlet(
+            positions, velocities, forces,
+            masses=np.ones(n_atoms), dt=dt
+        )
+        if step % 100 == 0:
+            ke = 0.5 * np.sum(velocities**2)
+            pe = compute_potential_energy(positions)
+            print(f"Step {step}: KE={ke:.4f}, PE={pe:.4f}, Total={ke+pe:.4f}")
+            trajectory.append(positions.copy())
+
+    return trajectory
+```
+
+### LAMMPS Input Script Example
+
+```
+# LAMMPS input: Lennard-Jones fluid simulation
+units           lj
+atom_style      atomic
+boundary        p p p
+
+# Create simulation box and atoms
+lattice         fcc 0.8442
+region          box block 0 10 0 10 0 10
+create_box      1 box
+create_atoms    1 box
+
+# Set mass and interactions
+mass            1 1.0
+pair_style      lj/cut 2.5
+pair_coeff      1 1 1.0 1.0 2.5
+
+# Initialize velocities at T=1.0
+velocity        all create 1.0 87287 dist gaussian
+
+# Thermostat: Nose-Hoover NVT
+fix             1 all nvt temp 1.0 1.0 0.1
+
+# Output settings
+thermo          100
+thermo_style    custom step temp pe ke etotal press
+dump            1 all custom 1000 trajectory.lammpstrj id x y z vx vy vz
+
+# Run simulation
+timestep        0.005
+run             100000
+```
+
+## Monte Carlo Methods
+
+### Metropolis Algorithm for Ising Model
+
+```python
+import numpy as np
+
+def ising_monte_carlo(L, temperature, n_steps):
+    """2D Ising model simulation using Metropolis algorithm."""
+    # Initialize random spin configuration
+    spins = np.random.choice([-1, 1], size=(L, L))
+    beta = 1.0 / temperature
+
+    energies = []
+    magnetizations = []
+
+    for step in range(n_steps):
+        for _ in range(L * L):  # One sweep = L^2 single spin flips
+            # Choose random spin
+            i, j = np.random.randint(0, L, size=2)
+
+            # Calculate energy change for flipping spin (i,j)
+            neighbors = (
+                spins[(i+1)%L, j] + spins[(i-1)%L, j] +
+                spins[i, (j+1)%L] + spins[i, (j-1)%L]
+            )
+            delta_E = 2 * spins[i, j] * neighbors
+
+            # Metropolis acceptance criterion
+            if delta_E <= 0 or np.random.random() < np.exp(-beta * delta_E):
+                spins[i, j] *= -1
+
+        # Measure observables
+        if step % 10 == 0:
+            E = -np.sum(spins * (np.roll(spins, 1, 0) + np.roll(spins, 1, 1)))
+            M = np.abs(np.sum(spins))
+            energies.append(E / L**2)
+            magnetizations.append(M / L**2)
+
+    return energies, magnetizations
+
+# Run near the critical temperature (T_c ≈ 2.269 for 2D Ising)
+E, M = ising_monte_carlo(L=32, temperature=2.269, n_steps=10000)
+print(f"Mean energy: {np.mean(E[-100:]):.4f}")
+print(f"Mean magnetization: {np.mean(M[-100:]):.4f}")
+```
+
+## Density Functional Theory
+
+### Quantum ESPRESSO Workflow
+
+```bash
+# Step 1: Self-consistent field (SCF) calculation
+cat > si_scf.in << 'EOF'
+&CONTROL
+  calculation = 'scf'
+  prefix = 'silicon'
+  outdir = './tmp/'
+  pseudo_dir = './pseudo/'
+/
+&SYSTEM
+  ibrav = 2
+  celldm(1) = 10.26  ! Lattice constant in Bohr
+  nat = 2
+  ntyp = 1
+  ecutwfc = 30.0     ! Kinetic energy cutoff (Ry)
+  ecutrho = 300.0    ! Charge density cutoff (Ry)
+/
+&ELECTRONS
+  conv_thr = 1.0d-8
+/
+ATOMIC_SPECIES
+  Si 28.086 Si.pbe-n-rrkjus_psl.1.0.0.UPF
+ATOMIC_POSITIONS crystal
+  Si 0.00 0.00 0.00
+  Si 0.25 0.25 0.25
+K_POINTS automatic
+  8 8 8 0 0 0
+EOF
+
+pw.x < si_scf.in > si_scf.out
+
+# Step 2: Band structure calculation
+# (requires nscf + bands post-processing)
+```
+
+### Python Interface (ASE + GPAW)
+
+```python
+from ase.build import bulk
+from gpaw import GPAW, PW
+
+# Create silicon crystal structure
+si = bulk('Si', 'diamond', a=5.43)
+
+# DFT calculation with GPAW
+calc = GPAW(mode=PW(300),       # Plane-wave cutoff: 300 eV
+            kpts=(8, 8, 8),      # k-point mesh
+            xc='PBE',            # Exchange-correlation functional
+            txt='si_gpaw.txt')   # Output file
+
+si.calc = calc
+energy = si.get_potential_energy()
+print(f"Total energy: {energy:.4f} eV")
+print(f"Energy per atom: {energy/len(si):.4f} eV")
+
+# Equation of state (find equilibrium lattice constant)
+from ase.eos import EquationOfState
+volumes, energies = [], []
+for a in np.linspace(5.3, 5.6, 10):
+    si = bulk('Si', 'diamond', a=a)
+    si.calc = GPAW(mode=PW(300), kpts=(8,8,8), xc='PBE', txt=None)
+    volumes.append(si.get_volume())
+    energies.append(si.get_potential_energy())
+
+eos = EquationOfState(volumes, energies)
+v0, e0, B = eos.fit()
+print(f"Equilibrium volume: {v0:.2f} A^3, Bulk modulus: {B:.1f} GPa")
+```
+
+## Numerical Methods
+
+### Solving ODEs (Runge-Kutta)
+
+```python
+from scipy.integrate import solve_ivp
+import matplotlib.pyplot as plt
+
+# Example: Damped harmonic oscillator
+# m*x'' + gamma*x' + k*x = 0
+def damped_oscillator(t, y, gamma=0.1, omega0=1.0):
+    x, v = y
+    dxdt = v
+    dvdt = -2*gamma*v - omega0**2 * x
+    return [dxdt, dvdt]
+
+sol = solve_ivp(damped_oscillator, [0, 50], [1.0, 0.0],
+                t_eval=np.linspace(0, 50, 1000),
+                method='RK45', rtol=1e-10)
+
+plt.plot(sol.t, sol.y[0])
+plt.xlabel('Time')
+plt.ylabel('Displacement')
+plt.title('Damped Harmonic Oscillator')
+plt.savefig('oscillator.pdf', dpi=300)
+```
+
+### Solving PDEs (Finite Differences)
+
+```python
+# 2D Heat equation: du/dt = alpha * (d2u/dx2 + d2u/dy2)
+def heat_equation_2d(Nx, Ny, Nt, alpha=0.01, dt=0.001):
+    dx = dy = 1.0 / max(Nx, Ny)
+    u = np.zeros((Nx, Ny))
+    u[Nx//4:3*Nx//4, Ny//4:3*Ny//4] = 1.0  # Initial hot region
+
+    for t in range(Nt):
+        u_new = u.copy()
+        u_new[1:-1, 1:-1] = u[1:-1, 1:-1] + alpha * dt / dx**2 * (
+            u[2:, 1:-1] + u[:-2, 1:-1] + u[1:-1, 2:] + u[1:-1, :-2]
+            - 4 * u[1:-1, 1:-1]
+        )
+        u = u_new
+    return u
+```
+
+## HPC and Parallelization
+
+| Approach | Tool | Best For |
+|----------|------|----------|
+| Shared memory (threads) | OpenMP | Multi-core CPU parallelism |
+| Distributed memory (MPI) | mpi4py, MPI | Multi-node cluster computing |
+| GPU computing | CUDA, CuPy, JAX | Massively parallel computations |
+| Workflow management | Snakemake, Nextflow | Complex simulation pipelines |
+| Job scheduling | SLURM, PBS | HPC cluster job submission |
+
+## Research Resources
+
+| Resource | Description |
+|----------|-------------|
+| arXiv cond-mat | Condensed matter preprints |
+| arXiv hep-lat | Lattice field theory preprints |
+| Journal of Computational Physics | Top computational physics journal |
+| Physical Review E | Statistical, nonlinear, soft matter |
+| Computer Physics Communications | Methods + software papers |
+| NIST databases | Physical constants, atomic data |