SOFTWARE LAB (ME-406) - Unit 2 Short Notes

2.1 Introduction to Unit 2 & Prerequisites

• Recap from Unit 1: Fundamental software concepts (CAD basics, simulation workflow, numerical methods).

• Unit 2 Objective: Integrate analysis (FEA, CFD, MBD), simulation (solving physics), and automation (scripting, optimization) for comprehensive engineering problem-solving.

• Common Software Ecosystems:

  • ANSYS: Multi-physics (FEA, CFD, EM).

  • SolidWorks/Siemens NX: Integrated CAD + Simulation (FEA, CFD, MBD).

  • MATLAB: Numerical computing, algorithm development, control systems.

  • Python (with libraries): Open-source automation, data analysis, pre/post-processing.

[!TIP] Exam Focus: Understand the purpose of each software category (CAD vs. CAE vs. scripting) and typical workflow integration (CAD → Pre-process → Solve → Post-process).

2.2 Finite Element Analysis (FEA) – Theory and Application

Fundamental Concepts

• Strong Form: Original differential equations (e.g., $$\displaystyle \nabla \cdot \sigma + F = 0 $$). Hard to solve for complex geometry.

• Weak Form: Integral form derived by multiplying by a test function and integrating. Basis for Galerkin method. Enforces equilibrium in an average sense.

• Discretization: Subdivide domain into elements connected at nodes.

  • Shape Functions ($$\displaystyle N_i $$): Interpolate field variable (e.g., displacement $u$) within an element: $$\displaystyle u(x) = \sum_{i=1}^{n} N_i(x) u_i $$.

  • Element Types:

    | Dimension | Common Elements | Primary Use | | :--- | :--- | :--- | | 1D | Truss (2 nodes), Beam (2-3 nodes) | Axial loads, bending | | 2D | Triangular (3-6 nodes), Quadrilateral (4-8 nodes) | Plane stress/strain, shells | | 3D | Tetrahedral (4-10 nodes), Hexahedral (8-20 nodes) | Solid mechanics |

• Stiffness Matrix Assembly: Element stiffness $$\displaystyle [k^e] = \int_{V^e} [B]^T [D] [B] dV $$, where $[B]$ is strain-displacement matrix, $[D]$ is material matrix. Assemble global stiffness $[K]$ from all $$\displaystyle [k^e] $$.

• System Equation:

$$[K] \{u\} = \{F\}$$

*   $\{u\}$: Nodal displacement vector.

*   $\{F\}$: Nodal force vector (including applied loads & reactions).

*   **Solution:** $$\displaystyle \{u\} = [K]^{-1} \{F\} $$ (for linear static).

Pre-processing

• Geometry: Cleanup (remove small features, fix gaps), idealization (symmetry exploitation, mid-surface extraction for shells).

• Meshing:

  • Structured: Regular grid (quad/hex). Better accuracy, harder on complex geometry.

  • Unstructured: Irregular (tri/tet). Automatic, flexible, may need more elements.

  • Element Quality Metrics:

    • Skewness: Deviation from ideal shape (0=perfect, <0.85 acceptable).

    • Aspect Ratio: Longest edge / shortest edge (close to 1 ideal).

    • Warpage: For shells/2D elements.

• Material Models: Linear Elastic (Hooke's Law), Hyperelastic (Rubber), Plasticity (Yield criteria: von Mises, Tresca).

• Boundary Conditions (BCs):

  • Constraints (Displacement/Rotation): Fix supports, symmetry.

  • Loads: Forces, pressures, temperatures (for thermal-structural), gravity.

  • Critical: Prevent rigid body motion (6 DOF in 3D must be constrained).

Solving

• Solver Types:

  • Direct (Sparse): Gaussian elimination. Robust for small/medium problems. Memory intensive.

  • Iterative (e.g., Conjugate Gradient): For large, sparse systems. Requires good preconditioning.

• Analysis Types:

  • Static: Time-invariant loads, inertia ignored.

  • Dynamic: Implicit (Newmark-β) vs. Explicit (central difference). For impact, vibration.

• Non-linearities:

  • Geometric: Large deformations, stress stiffening (NLGEOM, ON).

  • Material: Plasticity, hyperelasticity.

  • Contact: Surface-to-surface, penalty/MPC methods.

• Convergence: Monitor residual force, displacement increments. Criteria: $$\displaystyle \frac{\|R_{i}\|}{\|R_{0}\|} < \text{tol} $$.

Post-processing

• Visualization:

  • Contour Plots: Stress (von Mises $$\displaystyle \sigma_{vm} = \sqrt{\frac{(\sigma_1-\sigma_2)^2 + (\sigma_2-\sigma_3)^2 + (\sigma_3-\sigma_1)^2}{2}} $$), strain, temperature.

  • Deformation: Scaled (exaggerated) undeformed/deformed overlay.

  • Vector Plots: Displacement, velocity, heat flux.

• Interpretation:

  • Factor of Safety (FOS): $$\displaystyle \text{FOS} = \frac{\sigma_{\text{yield}}}{\sigma_{\text{max, von Mises}}} $$ (for ductile).

  • Principal Stresses ($$\displaystyle \sigma_1, \sigma_2, \sigma_3 $$): Max normal stresses at a point.

  • Path/Probe: Extract data along a line or at a point.

• Validation: Compare with hand calculations, textbook examples, or experimental data.

[!TIP] Common Pitfalls: Singular stiffness matrix (under-constrained), distorted elements (poor mesh quality), ignoring non-linearity when needed, misinterpreting stress concentrations.

2.3 Computational Fluid Dynamics (CFD) – Fundamentals

Governing Equations

• Navier-Stokes (for incompressible Newtonian fluid):

  • Continuity (Mass): $$\displaystyle \nabla \cdot \vec{V} = 0 $$

  • Momentum: $$\displaystyle \rho \left( \frac{\partial \vec{V}}{\partial t} + \vec{V} \cdot \nabla \vec{V} \right) = -\nabla p + \mu \nabla^2 \vec{V} + \vec{f} $$

  • Energy: $$\displaystyle \rho c_p \left( \frac{\partial T}{\partial t} + \vec{V} \cdot \nabla T \right) = k \nabla^2 T + \Phi $$ ( viscous dissipation $\Phi$)

• Turbulence Modeling (RANS - Reynolds-Averaged):

  | Model | Key Equations | Use Case | | :--- | :--- | :--- | | k-ε | Turbulent kinetic energy $k$, dissipation rate $\varepsilon$ | General purpose, external flows | | k-ω | $k$, specific dissipation $\omega$ | Near-wall flows, adverse pressure gradients | | SST (k-ω) | Blended k-ε (free stream) / k-ω (near wall) | Widely applicable, robust |

Pre-processing for CFD

• Domain & Mesh:

  • Inflation Layers: High-aspect-ratio cells near walls for boundary layer resolution ($$\displaystyle y^+ \approx 1 $$ for laminar, $$\displaystyle y^+ < 5 $$ for wall functions).

  • Mesh Quality: Skewness, orthogonality, smoothness.

• Boundary Conditions (BCs):

  • Inlet: Velocity, pressure, mass flow, turbulent intensity/length scale.

  • Outlet: Pressure (static/total), outflow.

  • Wall: No-slip (velocity=0), adiabatic/heat flux, symmetry.

  • Symmetry/Periodic: Reduce domain size.

• Fluid Properties: Density ($\rho$), viscosity ($\mu$), specific heat ($$\displaystyle c_p $$), thermal conductivity ($k$).

Solving and Convergence

• Pressure-Velocity Coupling:

  • SIMPLE (Semi-Implicit Method for Pressure-Linked Equations): Standard for steady-state.

  • PISO (Pressure Implicit with Splitting of Operators): For transient, better stability.

• Discretization Schemes:

  • Gradient: Least squares cell-based, node-based.

  • Pressure: PRESTO!, second-order.

  • Momentum/Energy: Upwind (stable, diffusive), Central (accurate, unstable), Second-Order Upwind (SOU).

• Convergence Monitoring: Residuals (mass, momentum, energy) should drop 3-4 orders of magnitude. Monitor integral quantities (e.g., drag coefficient, average outlet temperature) for plateau.

• Under-Relaxation: Factors (0.3-0.7) to stabilize iterative process. Increase as solution progresses.

Post-processing

• Visualization: Velocity vectors, pressure contours, streamlines, pathlines.

• Quantitative Analysis:

  • Flow Rate: $$\displaystyle \dot{m} = \rho A V_{\text{avg}} $$ (integral at surface).

  • Pressure Drop: $$\displaystyle \Delta p = p_{\text{inlet}} - p_{\text{outlet}} $$.

  • Heat Transfer Coefficient (HTC): $$\displaystyle h = \frac{q''}{T_{\text{wall}} - T_{\text{bulk}}} $$.

• Animation: Transient flow development, vortex shedding.

[!TIP] Common Pitfalls: Poor near-wall mesh ($$\displaystyle y^+ $$ mismatch), incorrect turbulence model for flow type, reversed flow at outlet, lack of under-relaxation causing divergence.

2.4 Multibody Dynamics (MBD) and Kinematic Analysis

System Modeling

• Rigid vs. Flexible: Rigid (infinite stiffness) vs. Flexible (deformable, requires FEA coupling).

• Joints/Constraints (Degrees of Freedom - DOF):

  | Joint | DOF Allowed | DOF Restricted | | :--- | :--- | :--- | | Revolute (Pin) | 1 (Rotation about axis) | 2 translations, 2 rotations | | Prismatic (Slider) | 1 (Translation along axis) | 2 translations, 2 rotations | | Spherical (Ball) | 3 (Rotation) | 3 translations | | Fixed/Ground | 0 | All 6 |

• Forces/Torques: Gravity, Spring-damper (linear/non-linear), Contact (penetration-based), Motors (prescribed motion/force).

Analysis Types

• Kinematic: Solve for position, velocity, acceleration given motion drivers (e.g., cam profile). No force calculation. Over-constrained if too many joints.

• Dynamic (Force-Driven):

  • Forward Dynamics: Given forces/torques → solve for motion. (e.g., vehicle acceleration from engine torque).

  • Inverse Dynamics: Given motion (trajectory) → solve for required forces/torques. (e.g., actuator forces for robot arm path).

• Static Equilibrium: Solve for positions/forces when all velocities/accelerations are zero.

• Quasi-Static: Slow dynamics, inertia negligible.

Results Interpretation

• Motion Plots: Displacement, velocity, acceleration vs. time for markers/parts.

• Force Reactions: Joint forces/torques, bearing loads, actuator efforts.

• Trajectory Tracing: Path of a point in space (e.g., end-effector).

• Animation: Visual check for interference, range of motion.

[!TIP] Common Pitfalls: Mechanism "locked" (kinematic singularity), incorrect joint axes, missing gravity, unrealistic contact stiffness.

2.5 Programming and Scripting for Engineering Automation

Python for Engineering Applications

• Core Libraries:

  • NumPy: ndarray, linear algebra (np.linalg.solve, eig), random numbers.

  • SciPy: Optimization (scipy.optimize.minimize), integration (scipy.integrate.quad), interpolation (scipy.interpolate), FFT.

  • Matplotlib: pyplot for 2D plots (plot, scatter, contourf), 3D (mplot3d).

• File I/O:

  
  # CSV
  
  import pandas as pd
  
  df = pd.read_csv('data.csv')
  
  # Text/Engineering formats
  
  with open('results.txt', 'w') as f:
  
      f.write(str(value))
  
  

• Data Structures: Lists, tuples, dictionaries for parametric data management.

API Scripting in CAD/CAE Software

• Concept: Use software's built-in language (VBA for SolidWorks, Python for ANSYS ACT, JavaScript for Onshape) to control GUI operations programmatically.

• Automation Tasks:

  • Geometry creation/modification (dimensions, features).

  • Mesh generation (element size, method).

  • Apply loads/BCs in loops.

  • Result Extraction: Query nodal stresses, reaction forces, integration values.

• Parametric Studies & Optimization:

  
  for thickness in [0.01, 0.015, 0.02]:
  
      model.ChangeParameter('Thickness', thickness)
  
      model.Solve()
  
      max_stress = model.GetResult('MaxVonMises')
  
      print(f"Thickness: {thickness}, Stress: {max_stress}")
  
  

Data Analysis and Visualization

• Statistical Analysis: Mean, std, min/max (numpy.mean, pandas.describe).

• Curve Fitting: scipy.optimize.curve_fit for polynomial, exponential fits to simulation/experimental data.

• Publication-Quality Plots: Use matplotlib with LaTeX fonts (plt.rc('text', usetex=True)), custom legends, subplots, inset plots.

[!TIP] Exam Focus: Know why to automate (repetitive tasks, design studies, batch processing). Be familiar with basic NumPy array operations and for loops for parameter sweeps.

2.6 Integrated Design and Analysis Projects

Project Workflow

1. Problem Definition: Objective, constraints (stress, displacement, temperature), design variables.

2. CAD Model Preparation: Simplify geometry (fillets, holes), ensure watertight body, define parts/assemblies.

3. Simulation Setup (Multi-physics):

   • Sequential: e.g., CFD (heat flux) → Thermal FEA (temperature gradient) → Structural FEA (thermal stress).

   • Coupled: Direct solver coupling (e.g., ANSYS Multiphysics) for strong interaction (FSI).

4. Validation: Compare initial run with hand calculation (e.g., beam deflection, pipe flow pressure drop).

5. Iterative Design: Modify CAD based on results (e.g., add fillet, change thickness), re-run.

Sample Project Themes

• Pressure Vessel: Internal pressure → Hoop stress ($$\displaystyle \sigma_h = \frac{pr}{t} $$) vs. FEA. Optimize thickness.

• Electronic Cooling: Heat generation (W), convection → Temperature distribution. Optimize heatsink fin geometry.

• Fluid-Structure Interaction (FSI): Valve under flow → Pressure on disc → Deformation → Flow change. (Simplified: one-way coupling).

• Four-Bar Linkage: Kinematic synthesis (Grashof condition) → MBD for coupler curve, velocity/acceleration analysis.

• Bracket Optimization: Minimize mass subject to $$\displaystyle \sigma_{vm} < \sigma_{\text{yield}} $$, displacement limit.

[!TIP] Key Skill: Ability to map a real engineering problem to the correct sequence of simulation types and identify the primary physics.

2.7 Best Practices, Validation, and Troubleshooting

Model Validation Techniques

• Hand Calculation Check: Use simplified formulas (e.g., beam theory, pipe flow) on a representative cut-section.

• Mesh Convergence Study:

  1. Solve with coarse mesh (M1).

  2. Refine mesh (M2 = 2x elements).

  3. Compare key result (e.g., max stress). If change < 5%, mesh adequate.

• Sensitivity Analysis: Vary one parameter (e.g., friction coefficient, Young's modulus) ±10% and observe result change. Identifies critical inputs.

Common Errors and Debugging

Documentation and Reporting

• Simulation Report Structure:

  1. Objective & Scope: What was analyzed, assumptions.

  2. Methodology: Software version, element type/size, material model, BCs, solver settings.

  3. Results: Key plots (contours, graphs), tabulated data.

  4. Validation: Comparison with hand calc/exp data.

  5. Conclusions & Recommendations: Design changes, safety assessment.

• Version Control (Git): Track changes to CAD files, simulation input decks, scripts. Commit messages like "Added fillet to bracket, updated mesh".

• Archiving: Save entire project folder (CAD, mesh, results, script). Use descriptive names (Bracket_Analysis_v3_20231027).

[!TIP] Golden Rule: "Garbage In, Garbage Out." Spend 70% time on pre-processing (clean CAD, good mesh, correct BCs).

2.8 Advanced Topics and Emerging Trends

Design Optimization

• Gradient-Based: (e.g., SQP, Method of Feasible Directions). Need sensitivity derivatives. Efficient for smooth problems.

• Non-Gradient: (e.g., Genetic Algorithms, Particle Swarm). Good for discrete, non-smooth, multi-modal problems. Computationally expensive.

• Topology Optimization:

  • Density-Based (SIMP): Material density ($$\displaystyle \rho_e \in [0,1] $$) as design variable. Penalizes intermediate densities ($p \geq 3$). Output: material distribution.

  • Level-Set: Boundary represented implicitly. Handles topology changes smoothly.

• Design of Experiments (DOE): Systematic sampling of design space (e.g., factorial, Latin Hypercube). Builds Response Surface Model (RSM) for cheap evaluation.

Multi-physics Coupling

• Sequential (One-Way): Output of Physics A is input to Physics B. (e.g., CFD heat flux → Thermal FEA). Simpler, faster.

• Coupled (Two-Way): Physics A and B solved simultaneously with exchanged boundary conditions. (e.g., FSI: fluid pressure deforms structure, deformed structure changes flow). More accurate, computationally heavy.

• Common Couplings: Thermo-mechanical (thermal expansion stress), Fluid-Structure (flutter, valve), Piezoelectric (voltage → strain).

Introduction to Machine Learning in Engineering Simulation

• Surrogate Modeling: Replace expensive, high-fidelity simulation (e.g., 3D FEA) with fast, approximate ML model (e.g., Neural Network, Gaussian Process).

• Workflow:

  1. Design of Experiments (DOE): Generate $N$ design points.

  2. Run High-Fidelity Simulations: Get outputs (e.g., max stress) for all $N$ points.

  3. Train ML Model: Input = design variables, Output = simulation result.

  4. Use Surrogate: Predict result for new designs instantly. Enables optimization.

• Key Concepts: Training/Test split, overfitting (model memorizes noise), cross-validation.

• Tool: scikit-learn (Python) for regression (Random Forest, Gradient Boosting, SVM).

[!TIP] Future Trend: "Simulation-Informed ML" and "ML-Informed Simulation" (e.g., using ML to generate better initial guesses for CFD, or to correct RANS turbulence models).