structdyn 0.5.1__tar.gz

structdyn-0.5.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abinash Mandal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

structdyn-0.5.1/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include structdyn/ground_motions/data *.AT2
+recursive-include structdyn/ground_motions/data *.csv
+

structdyn-0.5.1/PKG-INFO

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: structdyn
+Version: 0.5.1
+Summary: StructDyn: An open-source Python library for structural dynamics analysis
+Author-email: Abinash Mandal <abinashmandal33486@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: importlib-resources; python_version < "3.9"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# Structural Dynamics Library (`structdyn`)
+
+A Python library for structural dynamics analysis.
+
+[![Documentation Status](https://readthedocs.org/projects/structdyn/badge/?version=latest)](https://structdyn.readthedocs.io/en/latest/)
+
+
+## Citing `structdyn`
+
+If you use `structdyn` in your research or work, please cite it as follows:
+
+> Mandal, A. (2026). structdyn: A Python library for structural dynamics analysis (Version 0.5.0) [Computer software]. https://github.com/learnstructure/structdyn.git
+
+Here is the citation in BibTeX format:
+
+```bibtex
+@software{Mandal_structdyn_2026,
+  author = {Mandal, Abinash},
+  title = {{structdyn: A Python library for structural dynamics analysis}},
+  version = {0.5.0},
+  year = {2026},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/learnstructure/structdyn.git}
+}
+```
+
+## Features
+
+*   **Single-Degree-of-Freedom (SDF) Systems:**
+    *   Define linear and nonlinear SDF systems.
+    *   Analyze free and forced vibrations.
+    *   Calculate responses using analytical and numerical methods.
+*   **Multi-Degree-of-Freedom (MDF) Systems:**
+    *   Define MDF systems with custom mass and stiffness matrices.
+    *   Perform modal analysis to determine natural frequencies and mode shapes.
+    *   Analyze the dynamic response using modal superposition.
+*   **Ground Motion Analysis:**
+    *   Load and scale ground motion records.
+    *   Generate response spectra.
+    *   Analyze the response of structures to earthquake excitations.
+*   **Numerical Methods:**
+    *   A suite of numerical solvers, including:
+        *   Central Difference Method
+        *   Newmark-Beta Method
+        *   Linear Interpolation Method
+*   **Material Models:**
+    *   Elastic-perfectly plastic material model for nonlinear analysis.
+
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install git+https://github.com/learnstructure/structdyn.git
+```
+
+## Usage
+
+Here's a quick example of how to use `structdyn` to solve a simple SDF system:
+
+```python
+import numpy as np
+from structdyn.sdf.sdf import SDF
+
+# 1. Define the structure
+m = 45594  # mass (kg)
+k = 18e5  # stiffness (N/m)
+ji = 0.05  # damping ratio
+sdf = SDF(m, k, ji)
+
+# 2. Define the dynamic loading
+dt = 0.1
+time = np.arange(0, 10.01, dt)
+load = np.zeros_like(time)
+load[time <= 2] = 1000 * np.sin(np.pi * time[time <= 2])
+
+# 3. Solve the equation of motion
+# Available methods: 'newmark_beta', 'central_difference', 'interpolation'
+results = sdf.find_response(time, load, method="newmark_beta")
+
+# 4. Print the results
+print(results)
+```
+
+## Examples
+
+To run the examples provided in the `examples` directory, clone the repository and run the desired example file:
+
+```bash
+git clone https://github.com/learnstructure/structdyn.git
+cd structdyn
+pip install -e .
+python -m examples.sdf.eg_newmark
+```
+
+### Analytical Methods
+
+`structdyn` can also solve for the response of an SDF system analytically for certain cases.
+
+#### Free Vibration
+
+```python
+from structdyn import SDF
+from structdyn.sdf.analytical_methods.analytical_response import AnalyticalResponse
+
+sdf = SDF(m=1.0, k=100.0, ji=0.05)
+
+analytical = AnalyticalResponse(sdf)
+
+# Free vibration response
+df_free = analytical.free_vibration(u0=0.01, v0=0.0)
+print(df_free)
+```
+
+#### Harmonic Forcing
+
+```python
+from structdyn import SDF
+from structdyn.sdf.analytical_methods.analytical_response import AnalyticalResponse
+
+sdf = SDF(m=1.0, k=100.0, ji=0.05)
+
+analytical = AnalyticalResponse(sdf)
+
+# Harmonic sine forcing response
+df_harm = analytical.harmonic_response(p0=10.0, w=5.0, excitation="sine")
+print(df_harm)
+```
+
+### Ground Motion Analysis
+
+`structdyn` can be used to analyze the response of a structure to ground motion. The library includes several ground motion records, which can be loaded as follows:
+
+```python
+from structdyn.sdf.sdf import SDF
+from structdyn.ground_motions.ground_motion import GroundMotion
+
+# Load the El Centro ground motion record
+gm = GroundMotion.from_event("el_centro_1940", component="RSN6_IMPVALL.I_I-ELC180")
+
+# Define an SDF system
+sdf = SDF(45594, 18 * 10**5, 0.05)
+
+# Solve for the response of the SDF system to the ground motion
+results = sdf.find_response_ground_motion(gm, method='central_difference')
+
+# Print the results
+print(results)
+```
+
+### Nonlinear Analysis
+
+`structdyn` supports nonlinear analysis using the `fd` parameter of the `SDF` class. Currently, the only available nonlinear model is the elastic-perfectly plastic model.
+
+```python
+import numpy as np
+from structdyn.sdf.sdf import SDF
+
+# Define an elastic-perfectly plastic SDF system
+sdf_epp = SDF(m=45594, k=18e5, ji=0.05, fd="elastoplastic", f_y=200000)
+
+# Define the dynamic loading
+dt = 0.1
+time = np.arange(0, 10.01, dt)
+load = np.zeros_like(time)
+load[time <= 2] = 1000 * np.sin(np.pi * time[time <= 2])
+
+
+# Solve for the response of the nonlinear system
+results_epp = sdf_epp.find_response(time, load)
+
+# Print the results
+print(results_epp)
+```
+
+### Response Spectrum Analysis
+
+`structdyn` can be used to compute the response spectrum of a ground motion.
+
+```python
+import numpy as np
+from structdyn.ground_motions.ground_motion import GroundMotion
+from structdyn.sdf.response_spectrum import ResponseSpectrum
+
+# Load the El Centro ground motion record
+gm = GroundMotion.from_event("el_centro_1940", component="RSN6_IMPVALL.I_I-ELC180")
+
+# Define the periods for which to compute the response spectrum
+periods = np.arange(0, 5.01, 0.1)
+
+# Create a ResponseSpectrum object
+rs = ResponseSpectrum(periods, 0.02, gm)
+
+# Compute the response spectrum
+results = rs.compute()
+
+# Print the results
+print(results)
+```
+
+## Running Tests
+
+To run the tests, you will need to install `pytest`. You can then run the tests from the root directory of the project:
+
+```bash
+pip install pytest
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! If you would like to contribute to the project, please follow these steps:
+
+1.  Fork the repository.
+2.  Create a new branch for your feature or bug fix.
+3.  Make your changes and add tests.
+4.  Run the tests to ensure that everything is working correctly.
+5.  Submit a pull request.

structdyn-0.5.1/README.md

@@ -0,0 +1,220 @@
+# Structural Dynamics Library (`structdyn`)
+
+A Python library for structural dynamics analysis.
+
+[![Documentation Status](https://readthedocs.org/projects/structdyn/badge/?version=latest)](https://structdyn.readthedocs.io/en/latest/)
+
+
+## Citing `structdyn`
+
+If you use `structdyn` in your research or work, please cite it as follows:
+
+> Mandal, A. (2026). structdyn: A Python library for structural dynamics analysis (Version 0.5.0) [Computer software]. https://github.com/learnstructure/structdyn.git
+
+Here is the citation in BibTeX format:
+
+```bibtex
+@software{Mandal_structdyn_2026,
+  author = {Mandal, Abinash},
+  title = {{structdyn: A Python library for structural dynamics analysis}},
+  version = {0.5.0},
+  year = {2026},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  url = {https://github.com/learnstructure/structdyn.git}
+}
+```
+
+## Features
+
+*   **Single-Degree-of-Freedom (SDF) Systems:**
+    *   Define linear and nonlinear SDF systems.
+    *   Analyze free and forced vibrations.
+    *   Calculate responses using analytical and numerical methods.
+*   **Multi-Degree-of-Freedom (MDF) Systems:**
+    *   Define MDF systems with custom mass and stiffness matrices.
+    *   Perform modal analysis to determine natural frequencies and mode shapes.
+    *   Analyze the dynamic response using modal superposition.
+*   **Ground Motion Analysis:**
+    *   Load and scale ground motion records.
+    *   Generate response spectra.
+    *   Analyze the response of structures to earthquake excitations.
+*   **Numerical Methods:**
+    *   A suite of numerical solvers, including:
+        *   Central Difference Method
+        *   Newmark-Beta Method
+        *   Linear Interpolation Method
+*   **Material Models:**
+    *   Elastic-perfectly plastic material model for nonlinear analysis.
+
+
+## Installation
+
+Install the package using pip:
+
+```bash
+pip install git+https://github.com/learnstructure/structdyn.git
+```
+
+## Usage
+
+Here's a quick example of how to use `structdyn` to solve a simple SDF system:
+
+```python
+import numpy as np
+from structdyn.sdf.sdf import SDF
+
+# 1. Define the structure
+m = 45594  # mass (kg)
+k = 18e5  # stiffness (N/m)
+ji = 0.05  # damping ratio
+sdf = SDF(m, k, ji)
+
+# 2. Define the dynamic loading
+dt = 0.1
+time = np.arange(0, 10.01, dt)
+load = np.zeros_like(time)
+load[time <= 2] = 1000 * np.sin(np.pi * time[time <= 2])
+
+# 3. Solve the equation of motion
+# Available methods: 'newmark_beta', 'central_difference', 'interpolation'
+results = sdf.find_response(time, load, method="newmark_beta")
+
+# 4. Print the results
+print(results)
+```
+
+## Examples
+
+To run the examples provided in the `examples` directory, clone the repository and run the desired example file:
+
+```bash
+git clone https://github.com/learnstructure/structdyn.git
+cd structdyn
+pip install -e .
+python -m examples.sdf.eg_newmark
+```
+
+### Analytical Methods
+
+`structdyn` can also solve for the response of an SDF system analytically for certain cases.
+
+#### Free Vibration
+
+```python
+from structdyn import SDF
+from structdyn.sdf.analytical_methods.analytical_response import AnalyticalResponse
+
+sdf = SDF(m=1.0, k=100.0, ji=0.05)
+
+analytical = AnalyticalResponse(sdf)
+
+# Free vibration response
+df_free = analytical.free_vibration(u0=0.01, v0=0.0)
+print(df_free)
+```
+
+#### Harmonic Forcing
+
+```python
+from structdyn import SDF
+from structdyn.sdf.analytical_methods.analytical_response import AnalyticalResponse
+
+sdf = SDF(m=1.0, k=100.0, ji=0.05)
+
+analytical = AnalyticalResponse(sdf)
+
+# Harmonic sine forcing response
+df_harm = analytical.harmonic_response(p0=10.0, w=5.0, excitation="sine")
+print(df_harm)
+```
+
+### Ground Motion Analysis
+
+`structdyn` can be used to analyze the response of a structure to ground motion. The library includes several ground motion records, which can be loaded as follows:
+
+```python
+from structdyn.sdf.sdf import SDF
+from structdyn.ground_motions.ground_motion import GroundMotion
+
+# Load the El Centro ground motion record
+gm = GroundMotion.from_event("el_centro_1940", component="RSN6_IMPVALL.I_I-ELC180")
+
+# Define an SDF system
+sdf = SDF(45594, 18 * 10**5, 0.05)
+
+# Solve for the response of the SDF system to the ground motion
+results = sdf.find_response_ground_motion(gm, method='central_difference')
+
+# Print the results
+print(results)
+```
+
+### Nonlinear Analysis
+
+`structdyn` supports nonlinear analysis using the `fd` parameter of the `SDF` class. Currently, the only available nonlinear model is the elastic-perfectly plastic model.
+
+```python
+import numpy as np
+from structdyn.sdf.sdf import SDF
+
+# Define an elastic-perfectly plastic SDF system
+sdf_epp = SDF(m=45594, k=18e5, ji=0.05, fd="elastoplastic", f_y=200000)
+
+# Define the dynamic loading
+dt = 0.1
+time = np.arange(0, 10.01, dt)
+load = np.zeros_like(time)
+load[time <= 2] = 1000 * np.sin(np.pi * time[time <= 2])
+
+
+# Solve for the response of the nonlinear system
+results_epp = sdf_epp.find_response(time, load)
+
+# Print the results
+print(results_epp)
+```
+
+### Response Spectrum Analysis
+
+`structdyn` can be used to compute the response spectrum of a ground motion.
+
+```python
+import numpy as np
+from structdyn.ground_motions.ground_motion import GroundMotion
+from structdyn.sdf.response_spectrum import ResponseSpectrum
+
+# Load the El Centro ground motion record
+gm = GroundMotion.from_event("el_centro_1940", component="RSN6_IMPVALL.I_I-ELC180")
+
+# Define the periods for which to compute the response spectrum
+periods = np.arange(0, 5.01, 0.1)
+
+# Create a ResponseSpectrum object
+rs = ResponseSpectrum(periods, 0.02, gm)
+
+# Compute the response spectrum
+results = rs.compute()
+
+# Print the results
+print(results)
+```
+
+## Running Tests
+
+To run the tests, you will need to install `pytest`. You can then run the tests from the root directory of the project:
+
+```bash
+pip install pytest
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! If you would like to contribute to the project, please follow these steps:
+
+1.  Fork the repository.
+2.  Create a new branch for your feature or bug fix.
+3.  Make your changes and add tests.
+4.  Run the tests to ensure that everything is working correctly.
+5.  Submit a pull request.

structdyn-0.5.1/docs/source/conf.py

@@ -0,0 +1,37 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath("../../"))
+
+project = "structdyn"
+copyright = "2026, Abinash Mandal"
+author = "Abinash Mandal"
+release = "0.1.0"
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.napoleon",  # for NumPy-style docstrings
+    "sphinx.ext.viewcode",
+]
+
+
+templates_path = ["_templates"]
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = "sphinx_rtd_theme"
+
+html_static_path = ["_static"]

structdyn-0.5.1/examples/mdf/eg1_mdf.py

@@ -0,0 +1,21 @@
+# Example 10.4; Chopra A. K., Dynamics of structure, 5th edn
+import numpy as np
+from structdyn.mdf.mdf import MDF
+
+# Define mdf system: 2-story shear building
+masses = [2, 1]
+stiffness = [2, 1]
+mdf = MDF.from_shear_building(masses, stiffness)
+# print(mdf.M, mdf.K)
+
+# Modal analysis
+omega, phi = mdf.modal.modal_analysis(
+    dof_normalize=-1
+)  # -1 means: mode shape normalized based on roof dof
+
+print("Natural Frequencies (rad/s):", omega)  # omegas = [0.70710678 1.41421356]
+print("Mode shapes:", phi)
+
+# u = np.array([1, 1])
+# qn = mdf.modal.modal_coordinates(u)
+# print("Modal coordinates:", qn)

structdyn-0.5.1/examples/mdf/eg2_mdf.py

@@ -0,0 +1,26 @@
+# Example 10.9; Chopra A. K., Dynamics of structure, 5th edn
+import numpy as np
+from structdyn.mdf.mdf import MDF
+import matplotlib.pyplot as plt
+
+# Define mdf mdf: 2-story shear building
+masses = [2, 1]
+stiffness = [2, 1]
+mdf = MDF.from_shear_building(masses, stiffness)
+
+# Modal analysis
+omega, phi = mdf.modal.modal_analysis(
+    dof_normalize=-1
+)  # -1 means: mode shape normalized based on roof dof
+
+# Initial conditions
+u0 = [0.5, 1]
+v0 = [0, 0]
+time = np.arange(0, 20, 0.01)
+
+# Run analysis
+response = mdf.modal.free_vibration_response(u0, v0, time)
+print(response["u1"].abs().max())  # result = 0.49999999999999994
+
+response.plot(x="time", y="u1")
+plt.show()

structdyn-0.5.1/examples/mdf/eg_cdm.py

@@ -0,0 +1,19 @@
+import numpy as np
+from structdyn.mdf.mdf import MDF
+import matplotlib.pyplot as plt
+
+# Define MDF system
+masses = [2 * 45594, 45594]
+stiffness = [2 * 18 * 10**5, 18 * 10**5]
+mdf = MDF.from_shear_building(masses, stiffness)
+
+# Define external load
+dt = 0.01
+time = np.arange(0, 1.01, dt)
+load = 50 * np.sin(np.pi * time / 0.6) * 1000
+load[time >= 0.6] = 0
+load = np.column_stack((load, np.zeros_like(load)))
+
+res = mdf.find_response(time, load)
+print(res)
+print(res.shape)

structdyn-0.5.1/examples/mdf/eg_damping_mat.py

@@ -0,0 +1,14 @@
+# Example 11.4; Chopra A. K., Dynamics of structure, 5th edn
+from structdyn.mdf.mdf import MDF
+
+# Define MDF system
+masses = [2e5, 2e5, 1e5]
+stiffness = [1e8, 1e8, 1e8]
+mdf = MDF.from_shear_building(masses, stiffness)
+
+# Create damping matrix based on modal damping ratios; zeta
+mdf.set_modal_damping(zeta=[0.05, 0.05, 0.05])
+
+# Damping matrix
+print(mdf.C)
+print(mdf.C.flatten()[-1])  # result = 287983.44117400126

structdyn-0.5.1/examples/mdf/eg_newmark.py

@@ -0,0 +1,18 @@
+import numpy as np
+from structdyn.mdf.mdf import MDF
+import matplotlib.pyplot as plt
+
+# Define MDF system
+masses = [2 * 45594, 45594]
+stiffness = [2 * 18 * 10**5, 18 * 10**5]
+mdf = MDF.from_shear_building(masses, stiffness)
+
+# Define external load
+dt = 0.01
+time = np.arange(0, 1.01, dt)
+load = 50 * np.sin(np.pi * time / 0.6) * 1000
+load[time >= 0.6] = 0
+load = np.column_stack((load, np.zeros_like(load)))
+
+res = mdf.find_response(time, load, method="newmark_beta")
+print(res)

structdyn-0.5.1/examples/mdf/eg_newmark_gm.py

@@ -0,0 +1,32 @@
+# Example 16.1; Chopra A. K., Dynamics of structure, 5th edn
+import numpy as np
+from structdyn.mdf.mdf import MDF
+import matplotlib.pyplot as plt
+from structdyn.ground_motions.ground_motion import GroundMotion
+
+# Define MDF system
+masses = np.ones(5) * 0.2591 * 1e5
+stiffness = np.ones(5) * 100 * 1e5
+mdf = MDF.from_shear_building(masses, stiffness)
+mdf.set_modal_damping(zeta=np.ones(5) * 0.05)  # set damping matrix
+
+# Define ground motion as given in the same example
+time = np.arange(0, 2.01, 0.1)
+acc = (1.93 / 9.81) * np.sin(2 * np.pi * time)
+acc[time > 1.0] = 0
+gm = GroundMotion.from_arrays(acc, 0.1)
+
+# Influence vector
+inf_vec = np.ones(5)
+
+# Run analysis
+response = mdf.find_response_ground_motion(
+    gm, inf_vec, method="newmark_beta", use_modal=True, n_modes=2
+)
+# Note we can get more accurate results by considering more modes. Also if we remove use_modal, then direct integration of coupled equations would give more accurate results.
+print(response)
+print(response["u5"][20])  # result = 0.05888401249961952
+
+# Plot response
+# res.plot(x="time", y="u5")
+# plt.show()

structdyn-0.5.1/examples/sdf/eg_analytical.py

@@ -0,0 +1,18 @@
+from structdyn import SDF
+import matplotlib.pyplot as plt
+from structdyn.sdf.analytical_methods.analytical_response import AnalyticalResponse
+
+# Create SDF object
+sdf = SDF(m=1.0, k=100.0, ji=0.05)
+analytical = AnalyticalResponse(sdf)  # analytical solver
+
+# Free vibration
+df_free = analytical.free_vibration(u0=0.01, v0=0.0)
+# print(df_free)
+df_free.plot(x="time", y="displacement")
+plt.show()
+
+# Harmonic sine forcing
+df_harm = analytical.harmonic_response(p0=10.0, w=5.0, excitation="sine")
+df_harm.plot(x="time", y="displacement")
+plt.show()