Ejecuta cualquier Skill en Manus
con un clic

Ejecuta cualquier Skill en Manus con un clic

linear-solvers

Select and configure linear solvers for Ax=b systems arising in numerical simulations — choose between direct (LU, Cholesky) and iterative (CG, GMRES, BiCGSTAB, MINRES) methods, analyze sparsity patterns and matrix conditioning, recommend preconditioners (AMG, ILU, IC), apply row/column scaling, and diagnose convergence stagnation from residual histories. Use when setting up a linear solve for FEM/FVM assembly, debugging slow or stalled Krylov iterations, choosing a preconditioner for SPD or nonsymmetric systems, or investigating ill-conditioning, even if the user only says "my solver is slow" or "GMRES won't converge."

Ejecutar en Manus

Resumen

Comando de instalación

npx skills add https://github.com/HeshamFS/materials-simulation-skills --skill linear-solvers

Copia y pega este comando en Claude Code para instalar la habilidad

Fuente

HeshamFS/materials-simulation-skills

Estrellas40

Forks3

Actualizado18 de mayo de 2026, 08:58

Explorador de archivos

13 archivos

SKILL.md

readonly

Más de este repositorio

mismo repositorio

convergence-study

HeshamFS/materials-simulation-skills

Perform spatial and temporal convergence analysis for solution verification — compute observed convergence orders from grid or timestep refinement studies, apply Richardson extrapolation to estimate discretization error, and calculate the Grid Convergence Index (GCI) per ASME V&V 20 standards. Use when verifying that a numerical solution converges at the expected rate, estimating the error on the finest mesh, checking whether grids are in the asymptotic range, or preparing formal verification reports, even if the user only asks "is my mesh fine enough" or "how accurate is my solution."

2026-05-1840

differentiation-schemes

HeshamFS/materials-simulation-skills

Select and apply numerical differentiation schemes for PDE and ODE discretization — generate finite-difference stencils at arbitrary order and accuracy, choose between central, upwind, compact (Pade), and spectral methods, handle boundary stencils, and estimate truncation error scaling. Use when discretizing spatial derivatives, picking a scheme for advection- or diffusion-dominated problems, building custom stencils for nonstandard operators, or comparing dispersion and dissipation properties of candidate schemes, even if the user just says "how do I approximate this derivative" or "my solution is too diffusive."

2026-05-1840

mesh-generation

HeshamFS/materials-simulation-skills

Plan and evaluate mesh generation for numerical simulations — estimate grid resolution from physics scales (interface width, boundary layers, wavelengths), check aspect ratios and skewness against quality thresholds, choose between structured, unstructured, and adaptive mesh refinement strategies, and compute grid sizing for 1D/2D/3D domains. Use when setting up a new mesh, diagnosing poor solver convergence caused by mesh quality, deciding how many points to place across a phase-field interface or boundary layer, or preparing a mesh convergence study, even if the user only asks "what resolution do I need" or "why is my solver failing."

2026-05-1840

nonlinear-solvers

HeshamFS/materials-simulation-skills

Select and configure nonlinear solvers for root-finding f(x)=0, optimization min F(x), and least-squares problems — choose among Newton, Newton-Krylov, quasi-Newton (BFGS, L-BFGS), Broyden, Anderson acceleration, and Levenberg-Marquardt methods, configure line search or trust-region globalization, diagnose convergence rate (quadratic, linear, stagnated), and assess Jacobian quality and conditioning. Use when a Newton solver converges slowly or diverges, choosing between line search and trust region, debugging nonlinear iteration failures in FEM or phase-field codes, or selecting a solver for large-scale unconstrained optimization, even if the user only says "my Newton iterations aren't converging."

2026-05-1840

numerical-integration

HeshamFS/materials-simulation-skills

Select and configure time integration methods for ODE and PDE simulations — choose among explicit Runge-Kutta, BDF, Rosenbrock, and Adams families, set relative and absolute error tolerances, implement adaptive step-size control with I/PI/PID controllers, plan IMEX operator splitting for mixed stiff and non-stiff terms, and estimate splitting errors. Use when picking an integrator for a new simulation, diagnosing step rejections or tolerance failures, setting up operator splitting for phase-field or reaction-diffusion problems, or deciding between explicit and implicit time marching, even if the user only says "my solver keeps rejecting steps" or "which ODE method should I use."

2026-05-1840

numerical-stability

HeshamFS/materials-simulation-skills

Analyze numerical stability for time-dependent PDE simulations — check CFL and Fourier criteria, perform von Neumann stability analysis, detect stiffness, evaluate matrix conditioning, and recommend explicit vs implicit time-stepping schemes. Use when selecting time steps, diagnosing numerical blow-up or solver divergence, checking convergence criteria, or evaluating scheme stability for advection, diffusion, or reaction problems, even if the user doesn't explicitly mention "stability" or "CFL."

2026-05-1840

Fuente

HeshamFS

HeshamFS/materials-simulation-skills

Abrir repositorio de GitHub Ver repositorios del creador

Comando de instalación

Descarga

Ejecutar en Manus

Útil paraSOC

Desarrolladores de softwareOcupaciones informáticas y matemáticas15-1252L4

name	linear-solvers
description	Select and configure linear solvers for Ax=b systems arising in numerical simulations — choose between direct (LU, Cholesky) and iterative (CG, GMRES, BiCGSTAB, MINRES) methods, analyze sparsity patterns and matrix conditioning, recommend preconditioners (AMG, ILU, IC), apply row/column scaling, and diagnose convergence stagnation from residual histories. Use when setting up a linear solve for FEM/FVM assembly, debugging slow or stalled Krylov iterations, choosing a preconditioner for SPD or nonsymmetric systems, or investigating ill-conditioning, even if the user only says "my solver is slow" or "GMRES won't converge."
allowed-tools	Read, Write, Grep, Glob
metadata	{"author":"HeshamFS","version":"1.1.0","security_tier":"medium","security_reviewed":true,"tested_with":["claude-code","gemini-cli","vs-code-copilot"],"eval_cases":4,"last_reviewed":"2026-03-26"}

Linear Solvers

Goal

Provide a universal workflow to select a solver, assess conditioning, and diagnose convergence for linear systems arising in numerical simulations.

Requirements

Python 3.10+
NumPy, SciPy (for matrix operations)
See individual scripts for dependencies

Inputs to Gather

Input	Description	Example
Matrix size	Dimension of system	`n = 1000000`
Sparsity	Fraction of nonzeros	`0.01%`
Symmetry	Is A = Aᵀ?	`yes`
Definiteness	Is A positive definite?	`yes (SPD)`
Conditioning	Estimated condition number	`10⁶`

Decision Guidance

Solver Selection Flowchart

Is matrix small (n < 5000) and dense?
├── YES → Use direct solver (LU, Cholesky)
└── NO → Is matrix symmetric?
    ├── YES → Is it positive definite?
    │   ├── YES → Use CG with AMG/IC preconditioner
    │   └── NO → Use MINRES
    └── NO → Is it nearly symmetric?
        ├── YES → Use BiCGSTAB
        └── NO → Use GMRES with ILU/AMG

Quick Reference

Matrix Type	Solver	Preconditioner
SPD, sparse	CG	AMG, IC
Symmetric indefinite	MINRES	ILU
Nonsymmetric	GMRES, BiCGSTAB	ILU, AMG
Dense	LU, Cholesky	None
Saddle point	Schur complement, Uzawa	Block preconditioner

Script Outputs (JSON Fields)

Script	Key Outputs
`scripts/solver_selector.py`	`recommended`, `alternatives`, `notes`
`scripts/convergence_diagnostics.py`	`rate`, `stagnation`, `recommended_action`
`scripts/sparsity_stats.py`	`nnz`, `density`, `bandwidth`, `symmetry`
`scripts/preconditioner_advisor.py`	`suggested`, `notes`
`scripts/scaling_equilibration.py`	`row_scale`, `col_scale`, `notes`
`scripts/residual_norms.py`	`residual_norms`, `relative_norms`, `converged`

Workflow

Characterize matrix - symmetry, definiteness, sparsity
Analyze sparsity - Run scripts/sparsity_stats.py
Select solver - Run scripts/solver_selector.py
Choose preconditioner - Run scripts/preconditioner_advisor.py
Apply scaling - If ill-conditioned, use scripts/scaling_equilibration.py
Monitor convergence - Use scripts/convergence_diagnostics.py
Diagnose issues - Check residual history with scripts/residual_norms.py

Conversational Workflow Example

User: My GMRES solver is stagnating after 50 iterations. The residual drops to 1e-3 then stops improving.

Agent workflow:

Diagnose convergence:

python3 scripts/convergence_diagnostics.py --residuals 1,0.1,0.01,0.005,0.003,0.002,0.002,0.002 --json

Check for preconditioning advice:

python3 scripts/preconditioner_advisor.py --matrix-type nonsymmetric --sparse --stagnation --json

Recommend: Increase restart parameter, try ILU(k) with higher k, or switch to AMG.

Pre-Solve Checklist

Confirm matrix symmetry/definiteness
Decide direct vs iterative based on size and sparsity
Set residual tolerance relative to physics scale
Choose preconditioner appropriate to matrix structure
Apply scaling/equilibration if needed
Track convergence and adjust if stagnation occurs

CLI Examples

# Analyze sparsity pattern
python3 scripts/sparsity_stats.py --matrix A.npy --json

# Select solver for SPD sparse system
python3 scripts/solver_selector.py --symmetric --positive-definite --sparse --size 1000000 --json

# Get preconditioner recommendation
python3 scripts/preconditioner_advisor.py --matrix-type spd --sparse --json

# Diagnose convergence from residual history
python3 scripts/convergence_diagnostics.py --residuals 1,0.2,0.05,0.01 --json

# Apply scaling
python3 scripts/scaling_equilibration.py --matrix A.npy --symmetric --json

# Compute residual norms
python3 scripts/residual_norms.py --residual 1,0.1,0.01 --rhs 1,0,0 --json

Error Handling

Error	Cause	Resolution
`Matrix file not found`	Invalid path	Check file exists
`Matrix must be square`	Non-square input	Verify matrix dimensions
`Residuals must be positive`	Invalid residual data	Check input format

Interpretation Guidance

Convergence Rate

Rate	Meaning	Action
< 0.1	Excellent	Current setup optimal
0.1 - 0.5	Good	Acceptable for most problems
0.5 - 0.9	Slow	Consider better preconditioner
> 0.9	Stagnation	Change solver or preconditioner

Stagnation Diagnosis

Pattern	Likely Cause	Fix
Flat residual	Poor preconditioner	Improve preconditioner
Oscillating	Near-singular or indefinite	Check matrix, try different solver
Very slow decay	Ill-conditioned	Apply scaling, use AMG

Security

Input Validation

All numeric inputs (residuals, tolerances, matrix entries) are validated as finite numbers
Comma-separated residual/vector inputs are capped at 100,000 entries
The solver_selector.py --size parameter is bounded at 10 billion
--matrix-type is validated against a fixed allowlist (spd, symmetric, nonsymmetric)
Boolean flags (--symmetric, --positive-definite, --sparse, --stagnation) are type-safe argparse flags

File Access

sparsity_stats.py and scaling_equilibration.py read a single matrix file (.npy format) specified by --matrix
np.load() is called with allow_pickle=False to prevent arbitrary code execution via crafted .npy files
Matrix files are rejected if they exceed 500 MB before any parsing occurs
Matrix dimension limits (100,000 per dimension) prevent memory exhaustion
All other scripts read no external files; inputs are provided via CLI arguments

Tool Restrictions

Read: Used to inspect script source, references, and matrix files
Write: Used to save analysis results or solver recommendations; writes are scoped to the user's working directory
Grep/Glob: Used to locate relevant files and search references
The skill's allowed-tools excludes Bash to prevent the agent from executing arbitrary commands when processing untrusted matrix files or numeric inputs

Safety Measures

No eval(), exec(), or dynamic code generation
All subprocess calls use explicit argument lists (no shell=True)
Reduced tool surface (no Bash) limits the agent to read/write operations only
JSON output mode produces structured, parseable results without shell-interpretable content

Limitations

Large dense matrices: Direct solvers may run out of memory
Highly indefinite: Standard preconditioners may fail
Saddle-point: Requires specialized block preconditioners

References

references/solver_decision_tree.md - Selection logic
references/preconditioner_catalog.md - Preconditioner options
references/convergence_patterns.md - Diagnosing failures
references/scaling_guidelines.md - Equilibration guidance

Version History

v1.1.0 (2024-12-24): Enhanced documentation, decision guidance, examples
v1.0.0: Initial release with 6 solver analysis scripts