Author: Msc. Ing. Carlos Andrés Celi Sánchez
Semester: FEB – 2026
This repository has been created to support the teaching process of the Computational Methods course during the current academic semester. It will progressively include Python-based educational tools, numerical examples, notebooks, and class materials focused on the post-processing and complementary analysis of results obtained from commercial structural software such as ETABS and SAP2000.
This repository is currently under construction and will continue to be updated throughout the semester as new topics are covered in class.
This repository is expected to progressively cover topics such as:
- Basic Python tools for engineering applications
- Data extraction and post-processing workflows
- Processing results exported from ETABS and SAP2000
- Tabular data handling with Pandas
- Numerical verification of structural results
- Basic matrix operations for engineering problems
- Introductory finite element processing
- Visualization of engineering data and structural responses
At its current stage, the repository includes:
- The initial base structure of the course repository
- Introductory notebooks for computational processing
- A progressive framework for organizing examples and package-based tools
- Setup files for future computational implementations
- Initial examples related to lateral force distribution and simple FEM processing
Repo_Computational_Methods/
│── examples/
│ ├── Lateral_Force_Distrib_NEC2024.ipynb
│ └── Simple_FEM_processing.ipynb
│── repo_computational_methods/
│ ├── __init__.py
│ └── core_simple_class_MC.py
│── repo_seismic_desing.egg-info/
│── LICENSE
│── README.md
│── requirements.txt
│── setup.py
Note: The repository structure may evolve during the semester as new material is incorporated.
Before working with this repository, students should make sure that the following software is installed on their computers:
- Python 3.10 or newer
- Git
- Visual Studio Code
- Python extension for VS Code
- Jupyter extension for VS Code
These tools are necessary to clone the repository, create the Python environment, open the project correctly in Visual Studio Code, and run both Python scripts and notebooks.
This section explains how to correctly install and run the repository on Windows using Visual Studio Code.
Before doing anything else, students should first open a standard Windows terminal.
They may use any of the following:
- Command Prompt
- Windows PowerShell
For this course, the recommended option is:
Command Prompt
This helps avoid confusion with terminal commands, file paths, and virtual environment activation steps.
Once the Windows terminal is open, run:
git clone https://github.com/Normando1945/Repo_Computational_Methods.gitThis command will download the repository to the current folder.
After cloning the repository, enter the project folder with:
cd Repo_Computational_MethodsFrom this point on, all commands should be executed inside this folder.
Now that the repository already exists on the computer, open it in Visual Studio Code by running:
code .If this command does not work, students can simply open Visual Studio Code manually and then select the cloned repository folder.
Once the repository has been opened in VS Code, it is recommended that students continue working from the integrated terminal inside VS Code.
To open the terminal in VS Code:
- Press Ctrl + Shift + `
- Or go to the top menu and select:
Terminal > New Terminal
A terminal panel will appear at the bottom of Visual Studio Code.
Inside VS Code, verify that the selected terminal is:
- Command Prompt
If another terminal appears and students want to change it:
- Click the dropdown menu in the terminal panel
- Select Command Prompt
- Open a new terminal
From this point on, it is recommended that all commands be executed from this terminal in VS Code.
It is strongly recommended to create a virtual environment so that all students work with the same isolated Python setup.
Run:
python -m venv venvThis command will create a folder called venv inside the repository.
If students are using Command Prompt, run:
venv\Scripts\activateAfter activation, (venv) should appear at the beginning of the terminal line. This indicates that the virtual environment is active.
Once the virtual environment has been activated, install the required Python libraries with:
pip install -r requirements.txtThis step installs all the packages needed by the repository.
To allow Python to recognize the package correctly while developing and testing the code, run:
pip install -e .This is useful because the package can be modified during the semester without reinstalling it every time.
If students are going to work with notebooks in VS Code, it is recommended to also install ipykernel:
pip install ipykernelThen register the environment as a Jupyter kernel:
python -m ipykernel install --user --name=venv --display-name "Python (Computational Methods)"This will allow students to select the correct Python environment when opening notebooks.
Inside Visual Studio Code, follow these steps:
- Press Ctrl + Shift + P
- Search for:
Python: Select Interpreter - Choose the interpreter corresponding to the
venvenvironment
If a notebook is opened, also make sure that the selected kernel is:
Python (Computational Methods)
A simple way to verify the installation is to open Python and try importing the main package.
Run:
pythonThen type:
import repo_computational_methods
print("Package imported successfully")If no error appears, the installation was completed correctly.
Since the repository is still being developed, the first stage is focused on building a solid educational base for the course. This may include:
- Introductory notebooks
- Basic data processing workflows
- Initial numerical examples
- Post-processing tools for ETABS and SAP2000 outputs
- Class-based Python tools for future applications
- Progressive organization of notebooks and supporting files
As the semester advances, more files and examples will be added.
For each class session, students are encouraged to follow the workflow below:
- Open the repository folder in VS Code
- Open the integrated Command Prompt terminal
- Activate the virtual environment
- Verify that the correct Python interpreter has been selected
- Open the corresponding notebook or Python file
- Run the examples step by step
- Modify the examples progressively as discussed in class
- Use the repository to complement and process results exported from commercial software
- Save the updated work in an organized manner
This workflow helps maintain consistency during the semester and reduces the most common installation and execution errors.
Since the repository will be updated progressively during the semester, students should regularly download the latest changes from GitHub.
Open Command Prompt or the integrated terminal in VS Code.
cd Repo_Computational_MethodsIf students are using Command Prompt, run:
venv\Scripts\activate git pullThis command downloads and merges the most recent changes from the remote repository into the local copy.
Students are encouraged to run git pull before starting each class session in order to work with the latest version of the repository.
git clone https://github.com/Normando1945/Repo_Computational_Methods.git
cd Repo_Computational_Methods
python -m venv venv
venv\Scripts\activate
pip install -r requirements.txt
pip install -e . cd Repo_Computational_Methods
venv\Scripts\activate
git pullAt the current stage, the repository already includes the following notebooks inside the examples folder:
This notebook introduces a simple computational workflow for the distribution of lateral seismic forces according to NEC 2024 criteria. It is intended as an educational complement for checking and organizing structural results.
This notebook presents an introductory example related to simple finite element processing, serving as a first computational step for students working with structural data and basic numerical procedures.
- If Git is not recognized in the terminal, it must be installed and added correctly to the system path.
- If Python is not recognized in the terminal, verify that Python was installed correctly and added to the system path.
- If a notebook does not run, first verify that the correct Python interpreter and Jupyter kernel have been selected.
- It is recommended that all package installations be done only after activating the virtual environment.
- Students should avoid installing packages globally unless it is absolutely necessary.
- Since the repository is installed in editable mode, updates to the package files will be reflected directly without reinstalling the package in most cases.
- Because the repository is still under development, some folders or files may appear progressively during the semester.
- Some internal file names may still reflect the initial development stage of the repository and may be refined later.
This repository is maintained exclusively by the course author.
Students are expected to clone the repository and update their local copies during the semester. They should not modify the original online repository.
If students wish to experiment with the code, they are encouraged to do so in their local copies or in personal forks of the repository.
If you use this repository in academic work, class projects, reports, or educational material, please cite it as follows.
@misc{celi2026computationalmethods,
author = {Carlos Andrés Celi Sánchez},
title = {Computational Methods: Educational Repository for Computational Methods and Structural Engineering Applications},
year = {2026},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/Normando1945/Repo_Computational_Methods}}
}
Celi Sánchez, C. A. (2026). Computational Methods: Educational Repository for Computational Methods and Structural Engineering Applications [Structural Engineering]. GitHub. https://github.com/Normando1945/Repo_Computational_Methods
This project is licensed under the MIT License. See the LICENSE file for more details.
This repository is maintained by the author as the official course repository for Computational Methods.
Students are encouraged to use the repository, report bugs, and suggest improvements whenever necessary. Nevertheless, the official development and organization of the repository remain under the supervision of the author.
Suggestions for improvement may be shared through issues or pull requests, which will be reviewed before any change is incorporated into the repository.
Students are encouraged to keep this repository updated throughout the semester and use it as the main reference point for class notes, numerical examples, post-processing routines, and the progressive development of computational tools for structural engineering applications.