Vibration Modeling and Analysis using Python

Learn the Python basics essential for vibration analysis: variables, data types, printing, math operations, and core list, dictionary, and tuple operations in a Jupyter notebook.

Explore Python loops, including for and while, to perform iterative calculations. Use range and NumPy linspace to generate values, build arrays with append, and compute sums or products.

Master Python's if statements, elif, and else to classify numbers as positive, negative, or zero, with practical examples and conditional branching.

Operate with while loops as iterative loops driven by a condition, contrasting them with for loops, and use break to stop after five iterations while summing first n numbers.

Define and call Python functions to organize large code, compute outputs like cube volume and cylinder area, and emphasize parameter order and returning results.

Learn numpy, a core Python library for numerical calculations and arrays, covering installation, importing as np, using sine and cos, and building matrices in Jupyter notebooks.

Explore numpy arrays by expanding matrices and inspecting shape. Use zero-based indexing and slicing to access elements and extract submatrices, then initialize with zeros or ones.

Explore numpy basics with linspace and arange to create evenly spaced arrays, convert radians to degrees for sin calculations, and perform matrix addition and dot products on 3x3 arrays.

Explore simple and multi-plot charts with Matplotlib in Python. Plot data points, add a legend, and customize axis labels, limits, colors, and line styles for y1 and y2.

Learn to control plots with matplotlib using figure and axis to set size and dpi, add axes, plot data, and create two plots side by side with zoom options.

Explore how to create and arrange multiple plots in matplotlib using subplots, define layouts (1x2, 2x1, 2x2), assign data to axes, label axes, and adjust spacing with tight_layout and padding.

Master creating complex subplot layouts with Matplotlib grid spec, including a full-width top row and bottom subplots. Set face colors, grid lines, legends, and math-mode titles for clear data visualization.

Master 2d contour plots with Matplotlib and NumPy by building an x-y grid, computing z = sin(x) + y^2, and rendering filled contours with levels and a color bar.

Explore basic concepts of mechanical vibration, including free and forced vibration, damping, and the mass–spring–damper model, with the governing equation, degrees of freedom, and natural frequency.

Explore the free vibration of an undamped single-degree-of-freedom system, derive the equation of motion m x'' + k x = 0, and discuss initial conditions and analytical versus numerical solutions.

Explain the solution to the undamped SDOF equation m x'' + k x = 0, deriving x(t) = x0 cos(ωn t) + (x˙0/ωn) sin(ωn t) with ωn = sqrt(k/m).

Demonstrate a Python program for the free vibration of an undamped single-degree-of-freedom system with given initial displacement and velocity, computing the natural frequency and displacement over time.

Derive the free vibration amplitude for an undamped SDOF, with A = sqrt(x0^2 + (xdot0/omega_n)^2) and tan phi = xdot0/(omega_n x0), giving x(t) = A cos(omega_n t − phi).

Learn critical damping and the damping factor, defining the critical damping constant Cc and the damping factor zeta. Relate lambda roots to zeta and omega_n; classify underdamped, overdamped, and critical.

Derives the underdamped response of a damped single-degree-of-freedom system with zeta<1, expressing x(t) as an exponentially decaying cosine-sine form using omega_n and initial conditions.

explores the critically damped case (zeta = 1), where the roots coalesce, and derives the displacement response using initial conditions x(0)=x0 and x'(0)=xdot0.

Derive the overdamped free vibration solution for a damped system using x(t) with C1 and C2 under initial conditions, involving omega_n and zeta.

Learn to model the free vibration response of a damped SDOF system in Python, distinguishing underdamped, critically damped, and overdamped cases with zeta and the natural frequency omega n.

Create an interactive matplotlib plot for the free vibration of a damped SDOF system using sliders to adjust stiffness and damping, updating the response and zeta in real time.

Design a 1.5 second spring-damper lunar lander in Python by modeling four inclined springs as an equivalent system, and trialing k and c values to meet the period.

this lecture extends spring-damper design for a lunar lander, scans k and c to target a 1.5 s period within 0.01 s, and selects the lowest amplitude for underdamped responses.

Study the undamped single-degree-of-freedom response to a harmonic external force, combining the free and particular solutions, and note resonance when the forcing frequency nears the natural frequency.

Define the magnification factor for an undamped system under harmonic forcing as the ratio of vibration amplitude to static deflection, with the frequency ratio omega/omega_n; discuss r<1, r>1, and resonance.

Plot the harmonic response of an undamped system using the analytical solution and compare it with SciPy's odeint solver for vibration modeling.

solve vibrational ordinary differential equations with SciPy odeint, illustrating numerical methods through dy/dt = -y t + 3 and y0 = 1 over t from 0 to 5.

solve the harmonic motion equation using SciPy's odeint by converting the second-order ode to a first-order system, then compute displacement and velocity and validate against the analytical solution.

Plot the magnification factor and phase angle for various frequency ratios and zeta values using a Python program with NumPy and Matplotlib, creating two subplots and clear axis labeling.

Analyze the base-excited mass-spring-damper response under harmonic motion, deriving the steady-state displacement and phase as functions of m, c, k, and ω.

Simulate a vehicle on a surface at 5 Hz with 0.2 m using a Python mass–spring–damper model, and compute omega, omega_n, zeta, and phi while plotting the response x.

model a two-mass ic engine and chassis system to analyze harmonic vibrations from crank rotation, using mass, damping, and stiffness matrices and solving via an ode solver.

Explore arbitrary loading of a single-degree-of-freedom system. Learn to compute responses to irregular forcing using the standard vibration equation and integrate broken force portions.

We analyze the response of a single-degree-of-freedom system to an impulse load, showing how a short force creates an initial velocity of 1/m and initiates free vibration.

Model a direct impulse on a 15 kg, 1000 N/m, 20 N s/m system in Python, computing natural frequency and damping to reveal the damped vibration response.

Demonstrates calculating the response to a double impulse in Python by superimposing responses from two impulses with a 0.5 s delay, using numpy and plotting with matplotlib.

Learn to compute the step force response of a single-degree-of-freedom vibration system via convolution with the impulse response, and compare analytical and numerical results in Python.

Apply a time-delayed step force in a python vibration model and use convolution to obtain the response, noting that only the numerical solution is shown.

Compute the displacement response of a 1 kg, 50 N/m, 0.5 damping mass spring damper under time-dependent forces using the convolution integral with numpy, plotting forces and displacement.

Model the response of a vehicle on a road bump with a single-degree-of-freedom system in Python, using convolution and a half-sine bump to derive displacement, acceleration, and vehicle response.

Explore two degree of freedom vibration systems, expanding from single to multi degree of freedom models with masses and springs, and introduce coordinates and the equation of motion.

Derive the two degree of freedom equation of motion for undamped free vibration with two masses and three springs; form mass, stiffness, and force matrices to solve x1 and x2.

Explore normal modes in a two-degree-of-freedom undamped system, derive natural frequencies from a two-by-two matrix equation, and learn in-phase and out-of-phase mode shapes.

Explore normal modes of vibration in a two-degree-of-freedom mass-spring system, derive amplitude ratios a1/a2 for first and second modes, and express x1 and x2 as mode superpositions.

Learn to calculate natural frequencies and mode shapes for a two-degree-of-freedom system with Python, using NumPy and SciPy to solve eigenvalues and plot mode shapes.

Plot normal modes and their natural frequencies, and normalize the displacement for two masses, displaying mode one and mode two with proper labels.

Analyze the free vibration response of a two-degree-of-freedom undamped system, deriving mode shapes and natural frequencies, and compute displacements from initial conditions using Python.

Provide a python program to analyze the free vibration of a 2 dof system using numpy, scipy, and matplotlib, computing eigenvalues/eigenvectors, natural frequencies, mode shapes, initial conditions, and plots.

Compute the 2 dof system vibration response with SciPy odeint. Formulate M x'' + K x = 0 and convert to first-order ODEs; integrate to obtain displacements and velocities.

Explore forced vibration of a 2 dof system using Python and SciPy odeint, applying a harmonic force to mass one and neglecting damping to study response changes.

Explore the frequency response of a two-degree-of-freedom system under harmonic forcing, deriving the impedance matrix and solving for displacement to reveal natural frequencies as resonant peaks.

compute the frequency response of a two dof system in python using mass, damping, and stiffness matrices; analyze natural frequencies and displacement across a frequency range.

Explore the longitudinal vibration of a bar as a continuous system, derive the one-dimensional wave equation, and identify the free-end modes and natural frequencies.

Derive the transverse beam equation of motion from a distributed load and Euler beam theory. Apply finite element methods and numerical approaches to solve beam and bar vibration problems.

Learn to derive the bar element's mass and stiffness matrices from its equation of motion using shape functions, and express kinetic and strain energies in matrix form.

Explains bar element modeling with one and two elements, forming mass and stiffness matrices and solving the eigenvalue problem to obtain natural frequencies; highlights global matrix assembly and boundary elimination.

Compute the natural frequencies of a bar using the finite element method in Python by assembling global mass and stiffness matrices and solving eigenvalues with SciPy.

Explore beam element finite element analysis by deriving and assembling two-element beam stiffness and mass matrices, detailing degrees of freedom, boundary conditions, and global assembly.

Learn to compute natural frequencies of a simply supported beam with multiple finite elements by assembling global stiffness and mass matrices in Python, iterating element counts to improve accuracy.