In translational mechanical systems, we often encounter networks of springs, dampers, and masses. For many modeling tasks, especially when focusing on a single generalized displacement, it is convenient to replace a sub-network by a single equivalent element that has the same input–output behavior (at given connection nodes) as the original network.

We recall the constitutive relations of ideal linear elements:

\[ \begin{aligned} &\text{Spring: } && f_s(t) = k\,x(t), \quad k > 0, \\ &\text{Damper: } && f_d(t) = c\,\dot{x}(t), \quad c > 0, \\ &\text{Mass: } && f_m(t) = m\,\ddot{x}(t), \quad m > 0, \end{aligned} \]

Here \( x(t) \) is the relative displacement between the two terminals of the element, \( \dot{x}(t) \) its velocity, and \( \ddot{x}(t) \) its acceleration. For equivalent elements, we search for constants \( m_{\text{eq}}, k_{\text{eq}}, c_{\text{eq}} \) such that, as seen from specified external nodes, the simplified element produces exactly the same force for any admissible motion.

For this to be valid, we rely on:

• Linearity of each element (force proportional to displacement, velocity, or acceleration).
• Small deformations so that geometric nonlinearities can be ignored.
• Massless connectors (rods, links) unless explicitly modeled as masses.

flowchart TD
  A["Start with mechanical network (m, k, c)"] --> B["Choose generalized coordinate x(t) of interest"]
  B --> C["Identify series and parallel groups of springs/dampers"]
  C --> D["Apply combination rules for k_eq, c_eq, m_eq"]
  D --> E["Replace group by equivalent element"]
  E --> F["Repeat until single DOF model"]
  F --> G["Write governing ODE: m_eq x'' + c_eq x' + k_eq x = F(t)"]
        

Consider linear springs with stiffnesses \( k_1, k_2, \dots, k_n \). We derive the equivalent stiffness for two canonical interconnections: parallel and series. The derivations use equilibrium and compatibility (displacement relations) at the connection nodes.

2.1 Springs in Parallel

Two springs connected in parallel have their end nodes shared; hence they undergo the same displacement \( x(t) \), but their forces add. For two springs:

\[ \begin{aligned} f_1(t) &= k_1 x(t), \\ f_2(t) &= k_2 x(t), \\ f(t) &= f_1(t) + f_2(t) = (k_1 + k_2)x(t). \end{aligned} \]

Define an equivalent spring with stiffness \( k_{\text{eq}} \) such that \( f(t) = k_{\text{eq}} x(t) \). Then

\[ k_{\text{eq}} = k_1 + k_2. \]

For \( n \) springs in parallel:

\[ k_{\text{eq}} = \sum_{i=1}^{n} k_i. \]

The same result follows from energy. The total strain energy stored in parallel springs is

\[ U = \frac{1}{2} \sum_{i=1}^{n} k_i x^2 = \frac{1}{2} \left( \sum_{i=1}^{n} k_i \right) x^2 = \frac{1}{2} k_{\text{eq}} x^2. \]

2.2 Springs in Series

For series springs, the same force passes through each element (equilibrium), while the total displacement is the sum of individual displacements. Consider two springs in series under a force \( f(t) \):

\[ \begin{aligned} f(t) &= k_1 x_1(t) = k_2 x_2(t), \\ x(t) &= x_1(t) + x_2(t). \end{aligned} \]

Thus,

\[ x(t) = \frac{f(t)}{k_1} + \frac{f(t)}{k_2} = f(t) \left( \frac{1}{k_1} + \frac{1}{k_2} \right). \]

For the equivalent spring, \( f(t) = k_{\text{eq}} x(t) \), so

\[ x(t) = \frac{f(t)}{k_{\text{eq}}} \quad \Rightarrow \quad \frac{1}{k_{\text{eq}}} = \frac{1}{k_1} + \frac{1}{k_2}. \]

Generalizing to \( n \) springs in series,

\[ \frac{1}{k_{\text{eq}}} = \sum_{i=1}^{n} \frac{1}{k_i}. \]

Again, an energy-based derivation leads to the same result: for a given force \( f \) and total displacement \( x \), the sum of the individual energies \( \tfrac{1}{2} k_i x_i^2 \) equals \( \tfrac{1}{2} k_{\text{eq}} x^2 \) when the above relation for \( k_{\text{eq}} \) holds.

Viscous dampers obey \( f_d(t) = c\,\dot{x}(t) \). Their series and parallel combinations follow rules analogous to springs, with displacement replaced by velocity.

3.1 Dampers in Parallel

For two dampers in parallel:

\[ \begin{aligned} f_1(t) &= c_1 \dot{x}(t), \\ f_2(t) &= c_2 \dot{x}(t), \\ f(t) &= f_1(t) + f_2(t) = (c_1 + c_2)\dot{x}(t). \end{aligned} \]

Hence the equivalent damping coefficient is

\[ c_{\text{eq}} = c_1 + c_2, \quad c_{\text{eq}} = \sum_{i=1}^{n} c_i \text{ for } n \text{ dampers in parallel}. \]

The instantaneous power dissipated is \( P = f(t)\dot{x}(t) = c_{\text{eq}} \dot{x}^2(t) \), equal to the sum of the individual powers \( c_i \dot{x}^2(t) \).

3.2 Dampers in Series

For series dampers, the same force passes through each damper, but the total relative velocity is the sum of the individual relative velocities. With two dampers:

\[ \begin{aligned} f(t) &= c_1 \dot{x}_1(t) = c_2 \dot{x}_2(t), \\ \dot{x}(t) &= \dot{x}_1(t) + \dot{x}_2(t). \end{aligned} \]

Substituting,

\[ \dot{x}(t) = \frac{f(t)}{c_1} + \frac{f(t)}{c_2} = f(t)\left( \frac{1}{c_1} + \frac{1}{c_2} \right). \]

For an equivalent damper, \( f(t) = c_{\text{eq}}\dot{x}(t) \), so

\[ \frac{1}{c_{\text{eq}}} = \frac{1}{c_1} + \frac{1}{c_2}, \quad \frac{1}{c_{\text{eq}}} = \sum_{i=1}^{n} \frac{1}{c_i} \text{ for } n \text{ dampers in series}. \]

These relations hold for arbitrary time-varying forces because they are derived from instantaneous linear constitutive laws and kinematic constraints.

Mass is an inertial element. Unlike springs and dampers, there is no direct notion of a series connection of masses that preserves a single degree of freedom; connecting masses with springs inherently introduces additional coordinates. However, if multiple masses move rigidly together with the same acceleration (for example, connected by rigid, massless links), they can be replaced by a single equivalent mass.

Consider \( n \) point masses constrained to have the same displacement \( x(t) \); each has mass \( m_i \) and acceleration \( \ddot{x}(t) \). Let an external force \( F(t) \) act on the rigid assembly. Newton's second law gives

\[ F(t) = \sum_{i=1}^{n} m_i \ddot{x}(t) = \left( \sum_{i=1}^{n} m_i \right) \ddot{x}(t). \]

Define the equivalent mass by \( F(t) = m_{\text{eq}} \ddot{x}(t) \). Then

\[ m_{\text{eq}} = \sum_{i=1}^{n} m_i. \]

The same result follows from kinetic energy:

\[ T = \frac{1}{2}\sum_{i=1}^{n} m_i \dot{x}^2(t) = \frac{1}{2} \left( \sum_{i=1}^{n} m_i \right) \dot{x}^2(t) = \frac{1}{2} m_{\text{eq}} \dot{x}^2(t). \]

This \( m_{\text{eq}} \) may be interpreted as the total mass associated with the chosen generalized coordinate. More complicated notions such as reduced mass for relative motion arise in multi-degree-of-freedom systems and will be studied when multi-degree-of-freedom dynamics is introduced later in the course.

Consider a translational system whose motion can be described by a single generalized displacement \( x(t) \) (for example, a platform that remains rigid while supported by several springs and dampers connected to ground). Assume:

• Several rigidly attached components contribute to the inertia.
• Multiple springs connect the platform to ground in series/parallel networks.
• Multiple viscous dampers connect the platform to ground.

Using the equivalent parameters derived above, we define:

\[ m_{\text{eq}} = \sum_{i} m_i, \quad k_{\text{eq}} = \text{result of series/parallel reduction of all springs}, \\ c_{\text{eq}} = \text{result of series/parallel reduction of all dampers}. \]

Let \( F(t) \) be the generalized external force acting in the direction of \( x(t) \). The net spring force opposing motion is \( k_{\text{eq}} x(t) \), and the net viscous damping force is \( c_{\text{eq}} \dot{x}(t) \). Newton's second law yields the single second-order ODE:

\[ m_{\text{eq}} \ddot{x}(t) + c_{\text{eq}} \dot{x}(t) + k_{\text{eq}} x(t) = F(t). \]

This is the same structural form as the single mass–spring–damper equation from the previous lesson, but with parameters that encode the complexity of the original network.

Python, together with libraries such as numpy and scipy, is well suited for prototyping dynamic models. Below, we implement utility functions for equivalent stiffness, damping, and mass, then simulate the response of an equivalent single-degree-of-freedom system using scipy.integrate.solve_ivp.

import numpy as np
from math import isclose

# Optional: SciPy for ODE integration
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt

def k_parallel(ks):
    """Equivalent stiffness for springs in parallel: k_eq = sum(ks)."""
    ks = np.asarray(ks, dtype=float)
    return ks.sum()

def k_series(ks):
    """Equivalent stiffness for springs in series: 1/k_eq = sum(1/k_i)."""
    ks = np.asarray(ks, dtype=float)
    if np.any(ks <= 0.0):
        raise ValueError("Stiffnesses must be positive.")
    return 1.0 / np.sum(1.0 / ks)

def c_parallel(cs):
    """Equivalent damping for dampers in parallel: c_eq = sum(cs)."""
    cs = np.asarray(cs, dtype=float)
    return cs.sum()

def c_series(cs):
    """Equivalent damping for dampers in series: 1/c_eq = sum(1/c_i)."""
    cs = np.asarray(cs, dtype=float)
    if np.any(cs <= 0.0):
        raise ValueError("Damping coefficients must be positive.")
    return 1.0 / np.sum(1.0 / cs)

def m_parallel(ms):
    """Equivalent mass for rigidly connected masses: m_eq = sum(ms)."""
    ms = np.asarray(ms, dtype=float)
    if np.any(ms <= 0.0):
        raise ValueError("Masses must be positive.")
    return ms.sum()


# Example network:
# - Two springs in series between mass and ground: k1, k2
# - One spring in parallel with the series pair: k3
# - Two dampers in parallel: c1, c2
# - Two rigidly connected masses: m1, m2

k1, k2, k3 = 100.0, 200.0, 150.0  # N/m
c1, c2 = 8.0, 12.0                # N·s/m
m1, m2 = 1.0, 1.5                 # kg

k12_series = k_series([k1, k2])
k_eq = k_parallel([k12_series, k3])
c_eq = c_parallel([c1, c2])
m_eq = m_parallel([m1, m2])

print("k_series(k1,k2) =", k12_series)
print("k_eq =", k_eq, "N/m")
print("c_eq =", c_eq, "N·s/m")
print("m_eq =", m_eq, "kg")


# Simulate step response: m_eq x'' + c_eq x' + k_eq x = F0 (unit step at t >= 0)
F0 = 1.0  # N

def msd_ode(t, y):
    x, v = y
    dxdt = v
    dvdt = (F0 - c_eq * v - k_eq * x) / m_eq
    return [dxdt, dvdt]

t_span = (0.0, 5.0)
y0 = [0.0, 0.0]

sol = solve_ivp(msd_ode, t_span, y0, dense_output=True, max_step=0.01)
t_eval = np.linspace(t_span[0], t_span[1], 1000)
x_eval = sol.sol(t_eval)[0]

plt.figure()
plt.plot(t_eval, x_eval)
plt.xlabel("t [s]")
plt.ylabel("x(t) [m]")
plt.title("Step response of equivalent mass-spring-damper system")
plt.grid(True)
plt.show()
      

In more advanced workflows, Python libraries such as scipy.signal or sympy can be used to analyze system poles, symbolic expressions, and to verify equivalences between different network reductions.

In performance-critical applications, C++ is often used together with libraries such as Eigen for linear algebra and boost::numeric::odeint for ODE solving. Here we implement the equivalent-parameter formulas and a simple explicit Euler integrator without relying on external libraries, so that the core ideas are clear.

#include <iostream>
#include <vector>
#include <cmath>

double kParallel(const std::vector<double>& ks) {
    double sum = 0.0;
    for (double k : ks) sum += k;
    return sum;
}

double kSeries(const std::vector<double>& ks) {
    double inv_sum = 0.0;
    for (double k : ks) {
        if (k <= 0.0) throw std::runtime_error("k must be positive");
        inv_sum += 1.0 / k;
    }
    return 1.0 / inv_sum;
}

double cParallel(const std::vector<double>& cs) {
    double sum = 0.0;
    for (double c : cs) sum += c;
    return sum;
}

double cSeries(const std::vector<double>& cs) {
    double inv_sum = 0.0;
    for (double c : cs) {
        if (c <= 0.0) throw std::runtime_error("c must be positive");
        inv_sum += 1.0 / c;
    }
    return 1.0 / inv_sum;
}

double mParallel(const std::vector<double>& ms) {
    double sum = 0.0;
    for (double m : ms) {
        if (m <= 0.0) throw std::runtime_error("m must be positive");
        sum += m;
    }
    return sum;
}

int main() {
    // Example parameters
    double k1 = 100.0, k2 = 200.0, k3 = 150.0;
    double c1 = 8.0, c2 = 12.0;
    double m1 = 1.0, m2 = 1.5;
    double F0 = 1.0;

    double k12 = kSeries({k1, k2});
    double k_eq = kParallel({k12, k3});
    double c_eq = cParallel({c1, c2});
    double m_eq = mParallel({m1, m2});

    std::cout << "k_eq = " << k_eq << " N/m\n";
    std::cout << "c_eq = " << c_eq << " N·s/m\n";
    std::cout << "m_eq = " << m_eq << " kg\n";

    // Explicit Euler integration of m_eq x'' + c_eq x' + k_eq x = F0
    double t = 0.0, tEnd = 5.0, dt = 1e-3;
    double x = 0.0, v = 0.0;

    while (t < tEnd) {
        double a = (F0 - c_eq * v - k_eq * x) / m_eq;
        // Euler update
        x += dt * v;
        v += dt * a;
        t += dt;
        // In practice, you might store (t, x, v) or write them to file.
    }

    return 0;
}
      

For more advanced work, the same equivalent models can be embedded into larger finite-element or multibody codes, and the ODE can be integrated using higher-order or adaptive schemes from numerical libraries.

In Java, one can implement the same formulas, and for more advanced numerical analysis use libraries such as Apache Commons Math (which provides ODE solvers and linear algebra structures). Here we provide a minimal self-contained implementation with a simple Euler integrator.

public class EquivalentMSD {

    public static double kParallel(double[] ks) {
        double sum = 0.0;
        for (double k : ks) sum += k;
        return sum;
    }

    public static double kSeries(double[] ks) {
        double invSum = 0.0;
        for (double k : ks) {
            if (k <= 0.0) throw new IllegalArgumentException("k must be positive");
            invSum += 1.0 / k;
        }
        return 1.0 / invSum;
    }

    public static double cParallel(double[] cs) {
        double sum = 0.0;
        for (double c : cs) sum += c;
        return sum;
    }

    public static double cSeries(double[] cs) {
        double invSum = 0.0;
        for (double c : cs) {
            if (c <= 0.0) throw new IllegalArgumentException("c must be positive");
            invSum += 1.0 / c;
        }
        return 1.0 / invSum;
    }

    public static double mParallel(double[] ms) {
        double sum = 0.0;
        for (double m : ms) {
            if (m <= 0.0) throw new IllegalArgumentException("m must be positive");
            sum += m;
        }
        return sum;
    }

    public static void main(String[] args) {
        double k1 = 100.0, k2 = 200.0, k3 = 150.0;
        double c1 = 8.0, c2 = 12.0;
        double m1 = 1.0, m2 = 1.5;
        double F0 = 1.0;

        double k12 = kSeries(new double[]{k1, k2});
        double kEq = kParallel(new double[]{k12, k3});
        double cEq = cParallel(new double[]{c1, c2});
        double mEq = mParallel(new double[]{m1, m2});

        System.out.println("k_eq = " + kEq + " N/m");
        System.out.println("c_eq = " + cEq + " N·s/m");
        System.out.println("m_eq = " + mEq + " kg");

        // Euler integration of mEq x'' + cEq x' + kEq x = F0
        double t = 0.0, tEnd = 5.0, dt = 1e-3;
        double x = 0.0, v = 0.0;

        while (t < tEnd) {
            double a = (F0 - cEq * v - kEq * x) / mEq;
            x += dt * v;
            v += dt * a;
            t += dt;
        }

        // For teaching purposes we just print final state
        System.out.println("Final displacement x(tEnd) = " + x);
        System.out.println("Final velocity v(tEnd) = " + v);
    }
}
      

In a more advanced Java-based modeling environment, one would typically wrap these dynamics in a class implementing an ODE interface, and then delegate the time integration to a library solver.

9.1 MATLAB Script

MATLAB offers built-in ODE solvers (e.g. ode45) and integrates seamlessly with Simulink for block-diagram modeling. The following script computes equivalent parameters and simulates the step response of the resulting second-order system.

% Equivalent parameters and step response in MATLAB

k1 = 100; k2 = 200; k3 = 150;   % N/m
c1 = 8;   c2 = 12;              % N·s/m
m1 = 1;   m2 = 1.5;             % kg
F0 = 1;                        % N

k12 = 1 / (1/k1 + 1/k2);        % series
k_eq = k12 + k3;                % parallel
c_eq = c1 + c2;                 % parallel
m_eq = m1 + m2;                 % rigidly connected

fprintf("k_eq = %g N/m\n", k_eq);
fprintf("c_eq = %g N·s/m\n", c_eq);
fprintf("m_eq = %g kg\n", m_eq);

msd = @(t, y) [ ...
    y(2); ...
    (F0 - c_eq * y(2) - k_eq * y(1)) / m_eq ...
];

tspan = [0 5];
y0 = [0; 0];
[t, y] = ode45(msd, tspan, y0);

figure;
plot(t, y(:,1));
xlabel('t [s]');
ylabel('x(t) [m]');
title('Equivalent MSD step response');
grid on;
      

In Simulink, one would create a new model, place a Sum block for the force balance, a Gain block with gain 1/m_eq to compute acceleration, and integrate twice (using Integrator blocks) to obtain velocity and displacement. A constant block with value F0 provides the step input, and gain blocks with values c_eq and k_eq model the damping and spring forces.

9.2 Wolfram Mathematica

Mathematica provides symbolic and numerical tools. We can define equivalent parameters and use NDSolve to integrate the ODE.

(* Equivalent mass-spring-damper parameters *)
k1 = 100.; k2 = 200.; k3 = 150.;
c1 = 8.;   c2 = 12.;
m1 = 1.;   m2 = 1.5;
F0 = 1.0;

k12 = 1.0/(1.0/k1 + 1.0/k2);
kEq = k12 + k3;
cEq = c1 + c2;
mEq = m1 + m2;

(* ODE: mEq x''[t] + cEq x'[t] + kEq x[t] == F0 *)
ode = mEq x''[t] + cEq x'[t] + kEq x[t] == F0;
ic  = {x[0] == 0, x'[0] == 0};

sol = NDSolve[{ode, ic}, x, {t, 0, 5}];

Plot[Evaluate[x[t] /. sol], {t, 0, 5},
  AxesLabel -> {"t [s]", "x(t) [m]"},
  PlotLabel -> "Equivalent MSD step response"
]
      

Mathematica can also be used symbolically (e.g. to verify equivalence between different reductions) by leaving \( k_i, c_i, m_i \) as symbolic parameters and manipulating the resulting expressions.

The following problems reinforce the derivation and application of equivalent mass, stiffness, and damping in translational mechanical systems.

Problem 1 (Series–Parallel Spring Network): Three springs of stiffnesses \( k_1, k_2, k_3 > 0 \) are connected such that \( k_1 \) and \( k_2 \) are in parallel, and this parallel combination is in series with \( k_3 \) between a rigid mass and ground. Derive the equivalent stiffness \( k_{\text{eq}} \) seen by the mass.

Solution: First combine \( k_1 \) and \( k_2 \) in parallel:

\[ k_{12} = k_1 + k_2. \]

This \( k_{12} \) is in series with \( k_3 \), so

\[ \frac{1}{k_{\text{eq}}} = \frac{1}{k_{12}} + \frac{1}{k_3} = \frac{1}{k_1 + k_2} + \frac{1}{k_3}. \]

Hence

\[ k_{\text{eq}} = \left( \frac{1}{k_1 + k_2} + \frac{1}{k_3} \right)^{-1} = \frac{(k_1 + k_2)k_3}{k_1 + k_2 + k_3}. \]

Problem 2 (Equivalent Damping and ODE): A rigid platform of equivalent mass \( m_{\text{eq}} \) is connected to ground by a viscous damper \( c_1 \) in parallel with the series combination of viscous dampers \( c_2 \) and \( c_3 \). No springs are present. A horizontal force \( F(t) \) acts on the platform. Derive the equivalent damping coefficient and the governing ODE.

Solution: First, the series combination of \( c_2 \) and \( c_3 \) has

\[ \frac{1}{c_{23}} = \frac{1}{c_2} + \frac{1}{c_3} \quad \Rightarrow \quad c_{23} = \frac{c_2 c_3}{c_2 + c_3}. \]

This is in parallel with \( c_1 \), so the equivalent damping coefficient is

\[ c_{\text{eq}} = c_1 + c_{23} = c_1 + \frac{c_2 c_3}{c_2 + c_3}. \]

The force balance on the platform is then

\[ m_{\text{eq}} \ddot{x}(t) + c_{\text{eq}} \dot{x}(t) = F(t). \]

Problem 3 (Equivalent Mass for Rigidly Connected Bodies): Two blocks of masses \( m_1 \) and \( m_2 \) are rigidly connected and slide on a horizontal frictionless surface. A horizontal force \( F(t) \) is applied to block 1. Show that the motion of the assembly can be described as a single mass \( m_{\text{eq}} \) and determine \( m_{\text{eq}} \).

Solution: Because the blocks are rigidly connected, their displacements and accelerations are identical: \( x_1(t) = x_2(t) = x(t) \), \( \ddot{x}_1(t) = \ddot{x}_2(t) = \ddot{x}(t) \). Neglecting any internal forces (which cancel by Newton's third law), the external force satisfies

\[ F(t) = m_1 \ddot{x}(t) + m_2 \ddot{x}(t) = (m_1 + m_2)\ddot{x}(t). \]

Hence the equivalent mass is

\[ m_{\text{eq}} = m_1 + m_2, \]

and the governing ODE is simply

\[ m_{\text{eq}} \ddot{x}(t) = F(t). \]

Problem 4 (Combined Equivalent Parameters and Step Response Parameters): A rigid mass of \( m = 2\,\text{kg} \) is connected to ground by two springs in series, \( k_1 = 100\,\text{N/m} \) and \( k_2 = 300\,\text{N/m} \), and by a single viscous damper of \( c = 20\,\text{N·s/m} \) in parallel with the spring pair. Compute \( k_{\text{eq}} \) and \( c_{\text{eq}} \), then write the governing ODE for the displacement under an external force \( F(t) \).

Solution: The equivalent stiffness of the series springs is

\[ k_{\text{eq}} = \frac{1}{\frac{1}{k_1} + \frac{1}{k_2}} = \frac{1}{\frac{1}{100} + \frac{1}{300}} = \frac{1}{\frac{3 + 1}{300}} = \frac{300}{4} = 75\,\text{N/m}. \]

The damper is directly in parallel with this spring pair, so \( c_{\text{eq}} = c = 20\,\text{N·s/m} \). The ODE is therefore

\[ 2\,\ddot{x}(t) + 20\,\dot{x}(t) + 75\,x(t) = F(t). \]

Problem 5 (Decision Logic for Series/Parallel Identification): Sketch the logical steps you would follow to reduce an arbitrary 1-DOF spring–damper network connected between a mass and ground to equivalent parameters \( k_{\text{eq}} \) and \( c_{\text{eq}} \).

Solution (flowchart):

flowchart TD
  S["Start from full network between mass and ground"] --> N1["Locate elements sharing same two nodes"]
  N1 --> P["Combine these as parallel (sum k or c)"]
  P --> N2["Locate elements with same force path and sequential nodes"]
  N2 --> Q["Combine these as series (sum 1/k or 1/c)"]
  Q --> R["Replace group with single equivalent element"]
  R --> C["Check if more than one element remains"]
  C -->|yes| N1
  C -->|no| D["Use final k_eq, c_eq in m_eq x'' + c_eq x' + k_eq x = F(t)"]
        

In this lesson, we introduced the concept of equivalent mass, stiffness, and damping for translational mechanical systems. For springs and dampers, series and parallel combinations obey algebraic rules analogous to electrical resistors:

• Springs: parallel → stiffnesses add; series → reciprocals add.
• Dampers: parallel → damping coefficients add; series → reciprocals add.
• Masses: rigidly connected masses moving together can be added to form an equivalent mass.

These equivalent parameters allow us to replace complex networks with a single effective mass–spring–damper element and write a compact ODE of the form \( m_{\text{eq}}\ddot{x}(t) + c_{\text{eq}}\dot{x}(t) + k_{\text{eq}}x(t) = F(t) \). The resulting models form the basis for subsequent analysis of time-domain responses and frequency-domain properties in later chapters.