科研 Skill
COMSOL多物理场耦合仿真
comsol-multiphysics
Sets up coupled fluid-structure interaction simulations in COMSOL Multiphysics, focused on pump vibration analysis. Use when a user wants to script or automate a COMSOL FSI model.
SKILL.md
COMSOL Multiphysics Integration
Comprehensive guide for setting up and automating coupled fluid-structure interaction (FSI) simulations using COMSOL Multiphysics, with a focus on pump vibration analysis and related multiphysics applications.
Overview
COMSOL Multiphysics is a leading commercial simulation platform for modeling and solving complex multiphysics problems. It provides:
- Unified Environment: Single platform for multiple physics domains
- Flexible Coupling: Built-in tools for coupling different physics
- Equation-Based Modeling: Direct access to underlying PDEs
- Java API: Programmatic control and automation
- MATLAB LiveLink: Integration with MATLAB for pre/post-processing
- Application Builder: Create custom simulation apps
COMSOL excels at coupled physics problems including:
- Fluid-structure interaction (FSI)
- Thermal-structural coupling
- Electromagnetics with thermal effects
- Acoustics-structure interaction
- Electrochemistry with transport phenomena
COMSOL Architecture
Model Structure
- Component: Independent geometry and physics
- Study: Solution sequence with one or more steps
- Physics Interfaces: Pre-configured PDE systems for specific phenomena
- Multiphysics Couplings: Automatic or manual coupling between physics
- Solver Configurations: Automatic or customized solver sequences
Solver Technology
- COMSOL Solver: Direct and iterative solvers
- Fully Coupled Approach: Simultaneous solution of all equations
- Segregated Solver: Physics-based segregation for large models
- Time-Stepping: Implicit methods for transient analysis
- Mesh Adaptation: Automatic refinement based on solution
Licensing Requirements
Commercial Licensing
COMSOL Multiphysics requires commercial licenses for all production use:
-
Base Package:
- COMSOL Multiphysics license (required for all users)
- Includes basic PDE interfaces and computational tools
- License managed via FlexNet License Server
-
Module Licenses:
- Individual modules purchased separately
- Floating licenses (checked out during use)
- Batch mode requires license checkout
- HPC add-ons for parallel computing
-
License Server Setup:
# Set license server environment variable (Linux/Mac) export LMCOMSOL_LICENSE_FILE=1718@license-server.company.com # Or in Windows set LMCOMSOL_LICENSE_FILE=1718@license-server.company.com -
License Types:
- Floating Network License: Shared among users
- Node-Locked License: Tied to specific machine
- HPC License: Additional cores for parallel computing
- Batch License: For batch/automated simulations
Academic Licensing
- Classroom Kit: Limited to educational use
- Research licenses: Available for academic institutions
- Restrictions on commercial applications
- May have feature or model size limitations
Important Licensing Notes
- License Check: Always verify license availability before batch runs
- License Release: Properly close COMSOL to release licenses
- Batch Operations: Require special batch/HPC licenses
- Module Dependencies: Some modules require others (e.g., FSI needs CFD + Structural)
- API Access: Requires base license plus relevant modules
Key Modules for Pump Applications
CFD Module
Comprehensive computational fluid dynamics for single-phase and multiphase flows:
Capabilities:
-
Turbulence Models:
- RANS: k-epsilon, k-omega, SST
- LES and DES for high-fidelity simulations
- Wall functions and low-Re formulations
-
Flow Types:
- Incompressible and compressible
- Laminar and turbulent
- Steady-state and transient
- Rotating machinery (frozen rotor, sliding mesh)
-
Multiphase Flow:
- Euler-Euler multiphase
- Phase field methods
- Level set tracking
- Bubbly flow models
Pump-Specific Features:
- Rotating reference frames for impellers
- Mixing plane interfaces
- Cavitation modeling
- Pressure pulsation analysis
Structural Mechanics Module
Comprehensive structural analysis including linear and nonlinear behavior:
Capabilities:
-
Analysis Types:
- Static structural analysis
- Eigenfrequency analysis (modal analysis)
- Frequency response analysis
- Transient dynamics
- Prestressed analysis
-
Material Models:
- Linear elastic
- Hyperelastic (rubber, polymers)
- Plasticity (metals under high stress)
- Composite materials
- Contact and friction
-
Dynamic Analysis:
- Modal analysis for natural frequencies
- Harmonic response
- Time-dependent loading
- Damping models (Rayleigh, modal)
Pump-Specific Features:
- Rotating machinery stress analysis
- Bolt preload and assembly stress
- Fatigue analysis
- Contact between impeller and casing
Fluid-Structure Interaction (FSI)
Couples CFD and Structural Mechanics for two-way interaction:
Coupling Approaches:
-
One-Way FSI:
- Fluid loads applied to structure
- Structure does not affect fluid
- Faster computation
- Suitable for rigid-like structures
-
Two-Way FSI:
- Fully coupled fluid and structure
- Deforming mesh methods
- Accounts for large deformations
- Required for flexible structures
-
Weak Coupling:
- Sequential solution (staggered approach)
- Fluid → Structure → Fluid iteration
- Better for loosely coupled problems
-
Strong Coupling:
- Fully implicit simultaneous solution
- Better convergence for tightly coupled problems
- Higher computational cost
FSI Features:
- Automatic mesh deformation (ALE method)
- Remeshing for large deformations
- Fluid loads computed automatically
- Pressure and viscous forces transferred
- Support for multiple solid bodies
Pump FSI Applications:
- Impeller blade vibration under fluid forces
- Casing vibration and acoustic radiation
- Seal deflection under pressure
- Shaft deflection and critical speeds
- Cavitation-induced vibration
Additional Relevant Modules
Acoustics Module:
- Pressure pulsation analysis
- Noise radiation from pump casing
- Structure-borne noise
- Coupled acoustic-structure-fluid problems
Heat Transfer Module:
- Thermal loads in pumps
- Coupled thermal-structural analysis
- Conjugate heat transfer (fluid-solid)
- Thermal expansion effects
Optimization Module:
- Design optimization
- Topology optimization
- Shape optimization
- Parameter sweeps
Java API for Automation
COMSOL provides a comprehensive Java API for programmatic model building and automation:
API Structure
Core Components:
- Model object: Top-level container
- Component: Geometry and physics
- Physics interfaces: Add and configure physics
- Study: Define solution procedures
- Results: Post-processing and visualization
Basic Java API Workflow
import com.comsol.model.*;
import com.comsol.model.util.*;
public class PumpFSI {
public static Model run() {
// Create model
Model model = ModelUtil.create("PumpFSI");
// Create component
model.component().create("comp1", true);
// Create geometry
model.component("comp1").geom().create("geom1", 3);
// Import CAD geometry
model.component("comp1").geom("geom1").create("imp1", "Import");
model.component("comp1").geom("geom1").feature("imp1")
.set("filename", "/path/to/pump_geometry.step");
model.component("comp1").geom("geom1").run();
// Add fluid physics (CFD)
model.component("comp1").physics().create("spf", "LaminarFlow", "geom1");
model.component("comp1").physics("spf").selection()
.named("geom1_fluid_domain");
// Add structural physics
model.component("comp1").physics().create("solid", "SolidMechanics", "geom1");
model.component("comp1").physics("solid").selection()
.named("geom1_solid_domain");
// Add FSI coupling
model.component("comp1").multiphysics().create("fsi1", "FluidStructureInteraction", 3);
model.component("comp1").multiphysics("fsi1")
.selection().named("geom1_fsi_boundary");
// Create mesh
model.component("comp1").mesh().create("mesh1");
model.component("comp1").mesh("mesh1").automatic(true);
model.component("comp1").mesh("mesh1").run();
// Create study
model.study().create("std1");
model.study("std1").create("time", "Transient");
model.study("std1").feature("time").set("tlist", "range(0,0.01,1)");
// Solve
model.sol().create("sol1");
model.sol("sol1").study("std1");
model.sol("sol1").feature().create("st1", "StudyStep");
model.sol("sol1").feature().create("v1", "Variables");
model.sol("sol1").feature().create("t1", "Time");
model.sol("sol1").attach("std1");
model.sol("sol1").runAll();
// Save model
model.save("/path/to/pump_fsi_model.mph");
return model;
}
public static void main(String[] args) {
run();
}
}
Running Java API Scripts
# Compile Java file
comsol compile PumpFSI.java
# Run with COMSOL
comsol batch -inputfile PumpFSI.class -outputfile results.mph
# Or run directly
java -cp /path/to/comsol/plugins/*:. PumpFSI
API Advantages
- Reproducibility: Scripts ensure consistent model building
- Parametric Studies: Easy to vary parameters
- Batch Processing: Run multiple cases automatically
- Integration: Connect with other tools and databases
- Version Control: Track model changes in source control
MATLAB LiveLink
COMSOL integrates seamlessly with MATLAB for enhanced scripting and data processing:
LiveLink Features
Model Control from MATLAB:
- Build and modify COMSOL models
- Run simulations from MATLAB scripts
- Extract results into MATLAB workspace
- Use MATLAB's data analysis tools
Installation:
- Requires separate LiveLink for MATLAB license
- Configure MATLAB path to COMSOL installation
- Start COMSOL server or use direct connection
Basic MATLAB LiveLink Usage
% Initialize COMSOL with MATLAB
import com.comsol.model.*
import com.comsol.model.util.*
% Start COMSOL server (if not already running)
mphstart
% Create or load model
model = mphload('pump_model.mph');
% Modify parameters
model.param.set('inlet_velocity', '5[m/s]');
model.param.set('outlet_pressure', '101325[Pa]');
% Run study
model.study('std1').run();
% Extract results
pressure = mpheval(model, 'p', 'dataset', 'dset1');
velocity = mpheval(model, 'u', 'dataset', 'dset1');
% Process in MATLAB
mean_pressure = mean(pressure.d1);
max_velocity = max(sqrt(velocity.d1.^2 + velocity.d2.^2 + velocity.d3.^2));
% Plot using MATLAB
figure;
plot(pressure.p, pressure.d1);
xlabel('Position');
ylabel('Pressure [Pa]');
title('Pressure Distribution');
% Save results
save('pump_results.mat', 'pressure', 'velocity');
% Close COMSOL
ModelUtil.remove('model');
Parametric Study with MATLAB
% Parametric study of inlet velocity effects
velocities = 1:1:10; % m/s
results = struct();
for i = 1:length(velocities)
fprintf('Running case %d: velocity = %.1f m/s\n', i, velocities(i));
% Set parameter
model.param.set('inlet_velocity', sprintf('%f[m/s]', velocities(i)));
% Solve
model.study('std1').run();
% Extract force on impeller
force = mphint2(model, 'spf.Fp_x', 'surface', 'selection', 5);
results(i).velocity = velocities(i);
results(i).force = force;
% Extract vibration amplitude
displacement = mphmax(model, 'sqrt(u^2+v^2+w^2)', 'volume', 'selection', 3);
results(i).max_displacement = displacement;
end
% Plot results
figure;
subplot(2,1,1);
plot([results.velocity], [results.force], '-o');
xlabel('Inlet Velocity [m/s]');
ylabel('Force on Impeller [N]');
grid on;
subplot(2,1,2);
plot([results.velocity], [results.max_displacement]*1e6, '-o');
xlabel('Inlet Velocity [m/s]');
ylabel('Max Displacement [μm]');
grid on;
% Save results
save('parametric_results.mat', 'results');
Common Workflows
Workflow 1: Pump Casing Vibration Under Fluid Loads
Application: Analyze vibration of pump casing due to pressure pulsations from fluid flow.
Approach: One-way FSI (fluid loads mapped to structure)
Steps:
-
Geometry Setup:
- Import pump casing geometry
- Create fluid domain inside casing
- Define FSI boundary (fluid-structure interface)
-
CFD Setup:
- Define inlet and outlet boundaries
- Set up turbulence model (k-epsilon or k-omega SST)
- Configure transient solver
- Apply rotating reference frame if analyzing flow with rotating impeller
-
Structural Setup:
- Define material properties (steel, cast iron)
- Apply boundary conditions (fixed support at mounting points)
- Set up transient structural analysis
- Include damping if known
-
FSI Coupling:
- Map fluid pressure and shear stress to structure
- One-way coupling (structure assumed rigid relative to fluid)
- Time synchronization between fluid and structural solvers
-
Solution:
- Solve transient CFD first
- Extract time-varying pressure loads
- Apply loads to structural model
- Solve structural dynamics
-
Post-Processing:
- Extract displacement at critical points
- FFT analysis for frequency content
- Compare with natural frequencies
- Stress concentration analysis
Workflow 2: Impeller FSI Analysis
Application: Coupled analysis of impeller blade deformation under fluid forces.
Approach: Two-way FSI with moving mesh
Steps:
-
Geometry and Mesh:
- Import impeller geometry
- Create fluid domain around impeller
- Define FSI interface at blade surfaces
- Mesh solid impeller and fluid domain
- Fine mesh at FSI boundary
-
Fluid Physics:
- Turbulent flow (k-omega SST recommended)
- Rotating reference frame for impeller
- Inlet velocity or mass flow boundary
- Outlet pressure boundary
- Moving mesh (ALE) enabled
-
Structural Physics:
- Linear elastic material initially
- Fixed at shaft connection
- Prestress from centrifugal loading
- Include rotation effects
-
Two-Way FSI Coupling:
- Fluid applies loads to structure
- Structure deformation moves mesh
- Iterative coupling within each time step
- Convergence criteria for FSI iteration
-
Prestressed FSI:
- First: Stationary structural analysis with centrifugal load
- Second: Use prestressed state as initial condition for FSI
- Improves convergence and accuracy
-
Solution Strategy:
- Start with coarse time steps for initial transient
- Refine time stepping for periodic solution
- Monitor residuals and FSI iterations
- Expect longer solve times for strong coupling
-
Post-Processing:
- Blade tip displacement vs. time
- Stress distribution on blades
- Effect of deformation on flow field
- Comparison of rigid vs. flexible results
Workflow 3: Coupled Thermal-Flow Analysis
Application: Thermal effects in pumps handling hot fluids.
Approach: Conjugate heat transfer with thermal expansion
Steps:
-
Multi-Domain Setup:
- Fluid domain (hot liquid)
- Solid domains (casing, impeller)
- Define fluid-solid boundaries
-
Coupled Physics:
- CFD for fluid flow
- Heat Transfer in Fluids (energy equation)
- Heat Transfer in Solids (conduction)
- Thermal Stress in solids
- Automatic temperature coupling at boundaries
-
Boundary Conditions:
- Inlet: Temperature and velocity
- Outlet: Pressure outflow
- External surfaces: Convection or radiation
- Solid boundaries: Fixed temperature or insulation
-
Material Properties:
- Temperature-dependent viscosity
- Thermal expansion coefficients
- Thermal conductivity
-
Solution Sequence:
- Steady-state thermal-flow first
- Use as initial condition for thermal stress
- Or fully coupled transient simulation
-
Post-Processing:
- Temperature distribution
- Thermal stresses
- Thermal expansion displacements
- Effect on clearances and fits
Workflow 4: Modal Analysis with Fluid Loading
Application: Natural frequencies of pump casing in contact with fluid.
Approach: Eigenfrequency analysis with fluid-structure coupling
Steps:
-
Geometry:
- Pump casing structure
- Surrounding or contained fluid
- FSI boundaries
-
Physics Setup:
- Pressure Acoustics for fluid
- Solid Mechanics for structure
- Acoustic-Structure Boundary coupling
-
Boundary Conditions:
- Structural: Fixed supports
- Acoustic: Sound hard walls at rigid boundaries
- FSI: Acceleration coupling
-
Study:
- Eigenfrequency study
- Search for eigenfrequencies in range of interest
- Acoustic-structure coupling included automatically
-
Results:
- Natural frequencies with fluid loading
- Mode shapes
- Comparison with in-air and in-vacuum modes
- Fluid added mass effect
Batch Execution
Command Line Execution
COMSOL can run in batch mode without GUI:
# Run existing model file
comsol batch -inputfile pump_model.mph -outputfile results.mph
# Run Java method file
comsol batch -inputfile PumpFSI.java -outputfile results.mph
# Run with specific study
comsol batch -inputfile pump_model.mph -outputfile results.mph -study std1
# Run with parameter override
comsol batch -inputfile pump_model.mph -outputfile results.mph \
-pname inlet_velocity -plist 5,10,15,20
# Run MATLAB script
comsol batch -inputfile pump_analysis.m -outputfile results.mph
# Specify number of processors
comsol batch -np 8 -inputfile pump_model.mph -outputfile results.mph
Batch Script Example (Linux)
#!/bin/bash
# batch_comsol.sh
# Set license server
export LMCOMSOL_LICENSE_FILE=1718@license-server.com
# Set number of processors
NPROCS=8
# Input/output files
INPUT_MODEL="pump_fsi_base.mph"
OUTPUT_DIR="results"
# Create output directory
mkdir -p ${OUTPUT_DIR}
# Parameter sweep: inlet velocities
VELOCITIES="2 4 6 8 10"
for VEL in ${VELOCITIES}; do
echo "Running simulation with inlet velocity = ${VEL} m/s"
OUTPUT_FILE="${OUTPUT_DIR}/pump_fsi_v${VEL}.mph"
LOG_FILE="${OUTPUT_DIR}/pump_fsi_v${VEL}.log"
# Run COMSOL in batch mode
comsol batch -np ${NPROCS} \
-inputfile ${INPUT_MODEL} \
-outputfile ${OUTPUT_FILE} \
-pname inlet_velocity \
-plist ${VEL} \
> ${LOG_FILE} 2>&1
# Check exit status
if [ $? -eq 0 ]; then
echo " Simulation completed successfully"
else
echo " ERROR: Simulation failed - check ${LOG_FILE}"
exit 1
fi
done
echo "All simulations completed"
Python Automation with JPype
Use JPype to call COMSOL Java API from Python:
import jpype
import jpype.imports
from jpype.types import *
import numpy as np
# Start JVM with COMSOL
comsol_root = '/usr/local/comsol56/multiphysics'
jvm_path = jpype.getDefaultJVMPath()
jpype.startJVM(
jvm_path,
f"-Djava.library.path={comsol_root}/lib/glnxa64",
f"-Dcs.lic.path={comsol_root}/license",
classpath=f"{comsol_root}/plugins/*"
)
# Import COMSOL packages
from com.comsol.model.util import ModelUtil
# Load model
model = ModelUtil.load('/path/to/pump_model.mph')
# Parametric study
velocities = np.linspace(2, 10, 5)
results = []
for vel in velocities:
print(f"Running velocity = {vel:.1f} m/s")
# Set parameter
model.param().set('inlet_velocity', f'{vel}[m/s]')
# Run study
model.study('std1').run()
# Extract results (example)
# Add actual result extraction here
# Save case
model.save(f'results/pump_v{vel:.1f}.mph')
results.append({
'velocity': vel,
# Add extracted results here
})
# Cleanup
ModelUtil.remove('model')
jpype.shutdownJVM()
print("Parametric study completed")
Best Practices
Model Setup
- Geometry: Clean, defeatured geometry suitable for meshing
- Selections: Use named selections for boundary conditions
- Parameters: Use global parameters for easy modification
- Units: Consistent unit system throughout model
- Symmetry: Exploit symmetry when possible
Meshing
- Mesh Quality: Check mesh quality metrics (skewness, growth rate)
- Boundary Layers: Critical for turbulent flow
- FSI Interface: Fine mesh at fluid-structure boundary
- Mesh Independence: Verify solution mesh convergence
- Adaptive Meshing: Use for complex flows
Physics Setup
- Appropriate Models: Select physics models suitable for application
- Material Properties: Verify material data accuracy
- Boundary Conditions: Ensure physical consistency
- Initial Conditions: Provide good initial guess
- Coupling Settings: Check FSI coupling parameters
Solver Strategy
- Solver Selection: Automatic vs. manual solver configuration
- Convergence Criteria: Appropriate tolerances
- Time Stepping: Adaptive time stepping for transient
- Linearization: Check nonlinear solver settings
- Parallel Computing: Use multiple cores effectively
Automation
- Version Control: Track model files and scripts
- Documentation: Comment code and document workflow
- Error Handling: Implement checks and error recovery
- Testing: Validate automation on simple cases first
- License Management: Check license availability in batch jobs
Post-Processing
- Data Extraction: Export only necessary data
- Visualization: Standardized plots for comparison
- Validation: Compare with experimental or analytical results
- Reporting: Automated report generation
- Data Management: Organize results systematically
Troubleshooting
Common Issues
Licensing Problems:
- Verify license server connectivity
- Check module availability
- Ensure batch licenses for automated runs
Meshing Failures:
- Simplify geometry (remove small features)
- Adjust mesh size parameters
- Use different mesh sequence
Convergence Issues:
- Reduce load step or time step
- Improve initial conditions
- Adjust solver tolerances
- Check for poor mesh quality
- Review boundary conditions
FSI-Specific Issues:
- Mesh deformation failures: Remesh or adjust smoothing
- Slow FSI convergence: Adjust relaxation factors
- Large deformations: Consider remeshing strategies
- Time step too large: Reduce for stability
Performance Issues:
- Use coarser mesh initially
- Simplify physics models
- Exploit symmetry
- Increase parallel cores
- Use segregated solver for large models
Additional Resources
Documentation
- COMSOL Multiphysics User's Guide: Core functionality
- CFD Module User's Guide: Fluid flow physics
- Structural Mechanics Module User's Guide: Solid mechanics
- COMSOL API Reference: Java API documentation
- LiveLink for MATLAB User's Guide: MATLAB integration
Online Resources
- COMSOL Website: https://www.comsol.com
- COMSOL Blog: Application examples and tips
- COMSOL Support Center: Knowledge base and downloads
- Application Gallery: Example models and tutorials
- COMSOL Forums: Community discussions
Training
- COMSOL Training Courses: Official training programs
- Webinar Archive: Recorded training sessions
- Learning Center: Video tutorials and guides
Support
- Technical Support: support@comsol.com
- Regional Support: Contact local COMSOL office
- Application Engineers: Assistance with complex problems
示例提示词
帮我在COMSOL里搭建泵壳振动的流固耦合仿真模型。
所属插件
安装该插件会一并获得同领域的 36 个 Skill / MCP。
同插件的其他科研 Skill
- ANSYS Fluent CFD仿真自动化Automates ANSYS Fluent CFD setup, meshing, and batch runs via Python scripting, journal files, and the PyAnsys ecosystem. Use when a user wants to script or automate an ANSYS Fluent simulation.
- Cantera燃烧仿真Runs Cantera combustion simulations: flame temperature, ignition delay, laminar flame speed, PSR. Use for mechanism-based combustion analysis tasks.
- 离心泵气蚀风险评估Calculates NPSHa and NPSHr and assesses cavitation risk for centrifugal pumps, with prevention and detection guidance. Use when sizing suction piping or diagnosing pump cavitation.
- 气蚀评估物性数据库Looks up vapor pressure, NPSHr data, and correlations for cavitation risk assessment in pumps. Use when cavitation-analysis needs reference property or NPSHr data.
- 离心泵设计计算Designs centrifugal pumps from first principles using Euler equations, velocity triangles, and specific speed. Use for impeller sizing or new centrifugal pump design.
- CoolProp流体物性查询Queries thermodynamic and transport properties for 100+ pure and pseudo-pure fluids via the CoolProp library. Use when a calculation needs fluid density, viscosity, or enthalpy data.
- 工程计算环境初始化Sets up a Python session with engineering constants, Pint units, and plotting defaults. Use at the start of a calculation session.
- 流体计算数值错误校验Handles common numerical errors in fluid calculations, such as division by zero and out-of-range physical values, with validation checks. Use when fluid code fails or returns unphysical results.
- 流体力学分析工作流Guides a systematic fluid dynamics analysis from problem setup and domain definition through model selection to validation. Use when planning a CFD or analytical fluid mechanics study end to end.
- 经验公式流体物性速算Computes quick fluid property estimates (density, viscosity, vapor pressure) from empirical correlations without needing a database. Use for fast order-of-magnitude property checks.
- 管道流动与泵选型计算Computes pipe flow, pump sizing, friction factor, and compressible flow results with the fluids Python package. Use for quick, code-based fluid mechanics calculations.
- 工程工具与数据库清点Enumerates installed Python packages, databases, and simulation tools available in the current environment. Use at the start of a session to avoid recommending unavailable tools.
- 管路元件损失系数查询Looks up loss coefficients (K-values) and equivalent lengths for pipes, valves, and fittings in pump and piping systems. Use when computing system head loss.
- 流体与材料物性查询Looks up temperature-dependent fluid viscosities, densities, and other material properties for pump and heat-transfer calculations. Use when a calculation needs property data at a given temperature.
- 泵性能曲线绘制Creates professional engineering plots such as pump performance curves, CFD velocity contours, and publication-quality figures with matplotlib. Use when a result needs a plotted figure.
- NASA大气与航空流体数据Accesses atmospheric property profiles and standard-atmosphere models from NASA Earthdata for high-altitude and aerospace fluid analysis. Use when a task needs altitude-dependent atmospheric data.
- 管网图论建模Models hydraulic piping networks and multi-pump systems as graphs using NetworkX flow algorithms. Use for analyzing flow distribution across a branched or looped piping network.
- REFPROP高精度物性查询Queries high-accuracy thermodynamic and transport properties from the commercial NIST REFPROP database. Use when a calculation needs reference-quality fluid property data and REFPROP is licensed.
- 数值数组计算Performs numerical array operations with NumPy: velocity field processing, pump curve interpolation, linear systems, and matrix methods. Use for general numerical computation in engineering code.
- OpenFOAM仿真与后处理Runs and post-processes OpenFOAM CFD simulations with PyFoam, pyvista, and vtk for mesh setup, solver control, and visualization. Use for scripted OpenFOAM workflows outside ParaView.
- 泵性能曲线与相似定律Generates and interprets pump H-Q/efficiency/power/NPSH curves, applies affinity laws, and predicts off-design performance. Use for pump curve analysis.
- 工程单位换算与量纲分析Handles engineering units with automatic conversion and dimensional-consistency checking using the Pint library. Use whenever a calculation mixes units or needs unit safety.
- 容积式泵设计分析Designs and analyzes gear, piston, and screw positive-displacement pumps, including volumetric efficiency and slip. Use when the pump is positive-displacement rather than centrifugal.
- 泵效率优化Maximizes pump efficiency through hydraulic design changes and operational strategies such as trimming, VFD control, and system matching. Use when a pump is running inefficiently.
常见问题
COMSOL多物理场耦合仿真能做什么?
Sets up coupled fluid-structure interaction simulations in COMSOL Multiphysics, focused on pump vibration analysis. Use when a user wants to script or automate a COMSOL FSI model。
如何安装COMSOL多物理场耦合仿真?
在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「COMSOL多物理场耦合仿真」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。
COMSOL多物理场耦合仿真需要哪些权限?
该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。
COMSOL多物理场耦合仿真经过官方审核吗?
是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。