diff --git a/.codeboarding/Auxiliary_Utilities_Loss_Geometry_.md b/.codeboarding/Auxiliary_Utilities_Loss_Geometry_.md
new file mode 100644
index 000000000..01cb93a5a
--- /dev/null
+++ b/.codeboarding/Auxiliary_Utilities_Loss_Geometry_.md
@@ -0,0 +1,179 @@
+```mermaid
+
+graph LR
+
+ Loss_Functions["Loss Functions"]
+
+ Geometric_Utilities["Geometric Utilities"]
+
+ AlphaFold_Model["AlphaFold Model"]
+
+ AmberRelaxation["AmberRelaxation"]
+
+ Config["Config"]
+
+ StructureModule["StructureModule"]
+
+ DataPipeline["DataPipeline"]
+
+ FeaturePipeline["FeaturePipeline"]
+
+ Loss_Functions -- "Used by" --> AlphaFold_Model
+
+ Loss_Functions -- "Used by" --> AmberRelaxation
+
+ Loss_Functions -- "Configured by" --> Config
+
+ Geometric_Utilities -- "Used by" --> StructureModule
+
+ Geometric_Utilities -- "Used by" --> AlphaFold_Model
+
+ Geometric_Utilities -- "Used by" --> DataPipeline
+
+ Geometric_Utilities -- "Used by" --> FeaturePipeline
+
+ Geometric_Utilities -- "Used by" --> AmberRelaxation
+
+ StructureModule -- "Part of" --> AlphaFold_Model
+
+ click AlphaFold_Model href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//AlphaFold_Model.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+One paragraph explaining the functionality which is represented by this graph. What the main flow is and what is its purpose.
+
+
+
+### Loss Functions
+
+This component implements various loss functions essential for training the AlphaFold model. These functions quantify the discrepancy between the model's predictions and the ground truth, guiding the optimization process. Key losses include FAPE (Frame Aligned Point Error) loss, distogram loss, and masked MSA loss. Additionally, certain loss components might be leveraged during post-prediction refinement steps like energy minimization.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/utils/loss.py` (1:1)
+
+
+
+
+
+### Geometric Utilities
+
+This component provides a comprehensive set of fundamental operations for 3D geometry, rigid body transformations, and all-atom coordinate manipulations. It is indispensable for representing protein structures, performing geometric calculations, and refining atomic positions throughout the prediction pipeline. This includes handling rotations, translations, and operations on rigid bodies and individual atoms.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/utils/geometry/quat_rigid.py` (1:1)
+
+- `openfold/utils/geometry/rigid_matrix_vector.py` (1:1)
+
+- `openfold/utils/geometry/rotation_matrix.py` (1:1)
+
+- `openfold/utils/geometry/vector.py` (1:1)
+
+- `openfold/utils/rigid_utils.py` (1:1)
+
+- `openfold/utils/all_atom_multimer.py` (1:1)
+
+
+
+
+
+### AlphaFold Model [[Expand]](./AlphaFold_Model.md)
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### AmberRelaxation
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Config
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### StructureModule
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### DataPipeline
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### FeaturePipeline
+
+
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Configuration_Management.md b/.codeboarding/Configuration_Management.md
new file mode 100644
index 000000000..bab501fc9
--- /dev/null
+++ b/.codeboarding/Configuration_Management.md
@@ -0,0 +1,193 @@
+```mermaid
+
+graph LR
+
+ Configuration_Manager["Configuration Manager"]
+
+ AlphaFold_Model["AlphaFold Model"]
+
+ Data_Pipeline["Data Pipeline"]
+
+ Feature_Pipeline["Feature Pipeline"]
+
+ OpenFoldDataModule_OpenFoldDataset["OpenFoldDataModule/OpenFoldDataset"]
+
+ Loss_Functions["Loss Functions"]
+
+ Tools_External_["Tools (External)"]
+
+ Configuration_Manager -- "configures" --> AlphaFold_Model
+
+ AlphaFold_Model -- "uses" --> Configuration_Manager
+
+ Configuration_Manager -- "configures" --> Data_Pipeline
+
+ Data_Pipeline -- "uses" --> Configuration_Manager
+
+ Configuration_Manager -- "configures" --> Feature_Pipeline
+
+ Feature_Pipeline -- "uses" --> Configuration_Manager
+
+ Configuration_Manager -- "configures" --> OpenFoldDataModule_OpenFoldDataset
+
+ OpenFoldDataModule_OpenFoldDataset -- "uses" --> Configuration_Manager
+
+ Configuration_Manager -- "configures" --> Loss_Functions
+
+ Loss_Functions -- "uses" --> Configuration_Manager
+
+ Configuration_Manager -- "validates against" --> Tools_External_
+
+ Configuration_Manager -- "configures" --> Tools_External_
+
+ click AlphaFold_Model href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//AlphaFold_Model.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `openfold.config` module is central to the `OpenFold` project, acting as the **Configuration Manager**. It's responsible for defining, loading, and validating all configurable parameters, ensuring consistency and flexibility across various experimental setups. Its output highlights the extensive dependencies on configuration throughout the `openfold` package, particularly within the `model` and `data` sub-modules. This confirms its role as a foundational component.
+
+
+
+### Configuration Manager
+
+Centralized system for defining, loading, and managing all configurable parameters for the model, data pipelines, and training/inference processes. It leverages `ml_collections.ConfigDict` for hierarchical configuration and includes validation logic.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.config` (1:1)
+
+
+
+
+
+### AlphaFold Model [[Expand]](./AlphaFold_Model.md)
+
+The core deep learning model responsible for predicting protein structures. It consumes features generated by the data pipeline and is configured by the `Configuration Manager`.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.model.model` (1:1)
+
+
+
+
+
+### Data Pipeline
+
+Handles the entire process of preparing raw biological data (sequences, templates) into the structured features required by the `AlphaFold Model`. This includes alignment, feature generation, and data loading.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.data_pipeline` (1:1)
+
+
+
+
+
+### Feature Pipeline
+
+A sub-component of the `Data Pipeline` specifically responsible for transforming raw inputs into the numerical features consumed by the `AlphaFold Model`.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.feature_pipeline` (1:1)
+
+
+
+
+
+### OpenFoldDataModule/OpenFoldDataset
+
+PyTorch Lightning `DataModule` and `Dataset` implementations that encapsulate the data loading logic, integrating with the `Data Pipeline` and `Feature Pipeline` to provide data to the training loop.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.data_modules` (1:1)
+
+
+
+
+
+### Loss Functions
+
+Implementations of various loss functions used during model training (e.g., FAPE loss, distogram loss, masked MSA loss).
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.utils.loss` (1:1)
+
+
+
+
+
+### Tools (External)
+
+Wrappers for external bioinformatics tools (e.g., HHBlits, Jackhmmer) used by the `Data Pipeline` for tasks like MSA generation and template searching.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.tools.hhblits` (1:1)
+
+- `openfold.data.tools.jackhmmer` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Core_AlphaFold_Model.md b/.codeboarding/Core_AlphaFold_Model.md
new file mode 100644
index 000000000..122ead153
--- /dev/null
+++ b/.codeboarding/Core_AlphaFold_Model.md
@@ -0,0 +1,301 @@
+```mermaid
+
+graph LR
+
+ AlphaFold_Model["AlphaFold Model"]
+
+ Input_Embedders["Input Embedders"]
+
+ Template_Embedders["Template Embedders"]
+
+ Evoformer_Stack["Evoformer Stack"]
+
+ Structure_Module["Structure Module"]
+
+ Prediction_Heads["Prediction Heads"]
+
+ Model_Primitives["Model Primitives"]
+
+ Input_Features["Input Features"]
+
+ 3D_Protein_Coordinates["3D Protein Coordinates"]
+
+ Loss_Functions["Loss Functions"]
+
+ Config["Config"]
+
+ AmberRelaxation["AmberRelaxation"]
+
+ AlphaFold_Model -- "orchestrates" --> Input_Embedders
+
+ AlphaFold_Model -- "orchestrates" --> Template_Embedders
+
+ AlphaFold_Model -- "orchestrates" --> Evoformer_Stack
+
+ AlphaFold_Model -- "orchestrates" --> Structure_Module
+
+ AlphaFold_Model -- "orchestrates" --> Prediction_Heads
+
+ Input_Embedders -- "process" --> Input_Features
+
+ Input_Embedders -- "pass representations to" --> Evoformer_Stack
+
+ Template_Embedders -- "process" --> Input_Features
+
+ Template_Embedders -- "integrate information into representations for" --> Evoformer_Stack
+
+ Evoformer_Stack -- "receives refined representations from" --> Input_Embedders
+
+ Evoformer_Stack -- "receives refined representations from" --> Template_Embedders
+
+ Evoformer_Stack -- "passes refined representations to" --> Structure_Module
+
+ Evoformer_Stack -- "passes refined representations to" --> Prediction_Heads
+
+ Structure_Module -- "receives refined representations from" --> Evoformer_Stack
+
+ Structure_Module -- "generates" --> 3D_Protein_Coordinates
+
+ Prediction_Heads -- "receive outputs from" --> Evoformer_Stack
+
+ Prediction_Heads -- "receive outputs from" --> Structure_Module
+
+ Prediction_Heads -- "are used by" --> Loss_Functions
+
+ Model_Primitives -- "are utilized by" --> Input_Embedders
+
+ Model_Primitives -- "are utilized by" --> Template_Embedders
+
+ Model_Primitives -- "are utilized by" --> Evoformer_Stack
+
+ Model_Primitives -- "are utilized by" --> Structure_Module
+
+ Model_Primitives -- "are utilized by" --> Prediction_Heads
+
+ Config -- "configures" --> AlphaFold_Model
+
+ Config -- "configures" --> Input_Embedders
+
+ Config -- "configures" --> Template_Embedders
+
+ Config -- "configures" --> Evoformer_Stack
+
+ Config -- "configures" --> Structure_Module
+
+ Config -- "configures" --> Prediction_Heads
+
+ Config -- "configures" --> Model_Primitives
+
+ Structure_Module -- "can be further refined by" --> AmberRelaxation
+
+ click AlphaFold_Model href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//AlphaFold_Model.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Core AlphaFold Model` subsystem is the heart of the protein structure prediction framework, orchestrating the complex interplay of various neural network modules to transform raw sequence data into a 3D protein structure. Its design reflects the "Modular Deep Learning Architecture" pattern, where specialized components handle distinct aspects of the prediction task, promoting reusability and maintainability.
+
+
+
+### AlphaFold Model [[Expand]](./AlphaFold_Model.md)
+
+The top-level orchestrator of the entire protein structure prediction pipeline. It integrates and manages the flow between its internal sub-modules, processing input features to generate the final structural outputs. This is the main entry point for running a prediction.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `AlphaFold Model` (1:1)
+
+
+
+
+
+### Input Embedders
+
+These modules are responsible for the initial transformation of raw input features (e.g., multiple sequence alignments, amino acid sequences) into dense, high-dimensional numerical representations (embeddings) that the neural network can process.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Input Embedders` (1:1)
+
+
+
+
+
+### Template Embedders
+
+Modules specifically designed to process and embed information derived from known structural templates. This allows the model to leverage existing structural knowledge, which can significantly improve prediction accuracy, especially for proteins with homologous structures.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Template Embedders` (1:1)
+
+- `Template Embedders` (1:1)
+
+
+
+
+
+### Evoformer Stack
+
+The computational core of the model, consisting of a stack of Evoformer blocks. It iteratively refines the multiple sequence alignment (MSA) and pairwise residue representations through a series of attention mechanisms and triangular multiplicative updates. This module is key to capturing complex evolutionary and spatial relationships within the protein.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Evoformer Stack` (1:1)
+
+
+
+
+
+### Structure Module
+
+This module takes the refined representations from the Evoformer and iteratively constructs the 3D atomic coordinates of the protein. It predicts backbone and side-chain atom positions using invariant point attention and a series of angle predictions, effectively translating abstract features into a concrete physical structure.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Structure Module` (1:1)
+
+
+
+
+
+### Prediction Heads
+
+A collection of specialized neural network heads that produce various auxiliary predictions from the Evoformer and Structure Module outputs. These predictions (e.g., distograms, masked MSA, per-residue LDDT-Ca scores) are crucial for calculating diverse loss functions during training, guiding the model's learning process.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Prediction Heads` (1:1)
+
+
+
+
+
+### Model Primitives
+
+A collection of fundamental, reusable neural network layers and operations (e.g., attention mechanisms, linear transformations, layer normalization). These serve as the basic building blocks for constructing the more complex modules within the AlphaFold model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `Model Primitives` (1:1)
+
+
+
+
+
+### Input Features
+
+Raw input data for the AlphaFold model.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### 3D Protein Coordinates
+
+The final predicted 3D structure of the protein.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Loss Functions
+
+Functions used during training to guide the model's learning process.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### Config
+
+Configuration parameters for the AlphaFold model and its components.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### AmberRelaxation
+
+A post-processing step to refine the predicted protein structure using Amber force fields.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Data_Processing_Pipeline.md b/.codeboarding/Data_Processing_Pipeline.md
new file mode 100644
index 000000000..daa6d3a4d
--- /dev/null
+++ b/.codeboarding/Data_Processing_Pipeline.md
@@ -0,0 +1,223 @@
+```mermaid
+
+graph LR
+
+ Data_Pipeline["Data Pipeline"]
+
+ Feature_Pipeline["Feature Pipeline"]
+
+ Data_Transforms["Data Transforms"]
+
+ Tools["Tools"]
+
+ Parsers["Parsers"]
+
+ Templates["Templates"]
+
+ MSA_Pairing["MSA Pairing"]
+
+ Data_Modules["Data Modules"]
+
+ Data_Pipeline -- "Orchestrates" --> Tools
+
+ Data_Pipeline -- "Orchestrates" --> Parsers
+
+ Data_Pipeline -- "Feeds into" --> Feature_Pipeline
+
+ Feature_Pipeline -- "Receives input from" --> Data_Pipeline
+
+ Feature_Pipeline -- "Utilizes" --> Data_Transforms
+
+ Feature_Pipeline -- "Feeds into" --> Data_Modules
+
+ Data_Transforms -- "Used by" --> Feature_Pipeline
+
+ Tools -- "Called by" --> Data_Pipeline
+
+ Tools -- "Outputs consumed by" --> Parsers
+
+ Parsers -- "Used by" --> Data_Pipeline
+
+ Parsers -- "Used by" --> Templates
+
+ Templates -- "Used by" --> Data_Pipeline
+
+ Templates -- "Relies on" --> Parsers
+
+ MSA_Pairing -- "Used by" --> Data_Pipeline
+
+ MSA_Pairing -- "Used by" --> Feature_Pipeline
+
+ Data_Modules -- "Consumes data from" --> Feature_Pipeline
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The Data Processing Pipeline in OpenFold is a critical subsystem responsible for transforming raw biological data into a format suitable for the deep learning model. It encompasses several key components that work in concert to achieve this.
+
+
+
+### Data Pipeline
+
+This is the orchestrator of the entire data processing workflow. It manages the execution of external bioinformatics tools to generate MSAs and templates, and coordinates the initial stages of data preparation. It includes specialized logic for multimer data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `data_pipeline`
+
+
+
+
+
+### Feature Pipeline
+
+Responsible for transforming raw biological data (sequences, MSAs, templates) into the numerical features (tensors) that can be directly consumed by the neural network. It applies various data transformations and prepares the input for the model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `feature_pipeline`
+
+
+
+
+
+### Data Transforms
+
+A collection of functions and classes that apply various transformations, augmentations, and normalizations to the raw and intermediate data. This includes operations like cropping, padding, and converting data into model-consumable formats, with specific implementations for multimer data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `data_transforms`
+
+- `data_transforms_multimer`
+
+
+
+
+
+### Tools
+
+Provides Python wrappers and utilities for executing external bioinformatics tools (e.g., HHblits, Jackhmmer, HHsearch, Kalign). These tools are crucial for generating Multiple Sequence Alignments (MSAs) and identifying structural templates, which are essential inputs for the model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `tools`
+
+
+
+
+
+### Parsers
+
+Handles the parsing of various bioinformatics data formats, including A3M, FASTA, PDB, and MMCIF files. This component extracts relevant information from these files for downstream processing by other parts of the data pipeline.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `parsers`
+
+- `mmcif_parsing`
+
+
+
+
+
+### Templates
+
+Manages the identification, processing, and featurization of structural templates. This involves searching for homologous structures, parsing their data, and preparing them as input features for the model. It includes logic for handling various template sources and potential errors.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `templates`
+
+
+
+
+
+### MSA Pairing
+
+Specifically handles the pairing and processing of Multiple Sequence Alignments for multimeric protein complexes. This is a critical step for correctly representing inter-chain relationships and generating accurate features for multimer prediction.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `msa_pairing`
+
+- `feature_processing_multimer`
+
+
+
+
+
+### Data Modules
+
+Provides the interface for PyTorch Lightning, handling data loading, batching, and dataset management for training and inference. It wraps the DataPipeline and FeaturePipeline to provide model-ready data in an efficient and structured manner.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `data_modules`
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Training_Inference_Orchestration.md b/.codeboarding/Training_Inference_Orchestration.md
new file mode 100644
index 000000000..ff9b0fa6f
--- /dev/null
+++ b/.codeboarding/Training_Inference_Orchestration.md
@@ -0,0 +1,257 @@
+```mermaid
+
+graph LR
+
+ train_openfold_py["train_openfold.py"]
+
+ run_pretrained_openfold_py["run_pretrained_openfold.py"]
+
+ openfold_train_openfold_OpenFoldWrapper["openfold.train_openfold.OpenFoldWrapper"]
+
+ openfold_data_data_modules_OpenFoldDataModule["openfold.data.data_modules.OpenFoldDataModule"]
+
+ openfold_utils_loss_AlphaFoldLoss["openfold.utils.loss.AlphaFoldLoss"]
+
+ openfold_config["openfold.config"]
+
+ openfold_data_data_pipeline_AlignmentRunner["openfold.data.data_pipeline.AlignmentRunner"]
+
+ openfold_data_feature_pipeline_FeaturePipeline["openfold.data.feature_pipeline.FeaturePipeline"]
+
+ openfold_model_model_AlphaFold["openfold.model.model.AlphaFold"]
+
+ openfold_utils_callbacks["openfold.utils.callbacks"]
+
+ train_openfold_py -- "Orchestrates" --> openfold_train_openfold_OpenFoldWrapper
+
+ train_openfold_py -- "Configures" --> openfold_data_data_modules_OpenFoldDataModule
+
+ train_openfold_py -- "Utilizes" --> openfold_utils_loss_AlphaFoldLoss
+
+ train_openfold_py -- "Integrates" --> openfold_utils_callbacks
+
+ run_pretrained_openfold_py -- "Orchestrates" --> openfold_model_model_AlphaFold
+
+ run_pretrained_openfold_py -- "Utilizes" --> openfold_data_data_pipeline_AlignmentRunner
+
+ run_pretrained_openfold_py -- "Utilizes" --> openfold_data_feature_pipeline_FeaturePipeline
+
+ openfold_train_openfold_OpenFoldWrapper -- "Encapsulates" --> openfold_model_model_AlphaFold
+
+ openfold_train_openfold_OpenFoldWrapper -- "Uses" --> openfold_utils_loss_AlphaFoldLoss
+
+ openfold_data_data_modules_OpenFoldDataModule -- "Uses" --> openfold_data_feature_pipeline_FeaturePipeline
+
+ openfold_config -- "Configures" --> openfold_train_openfold_OpenFoldWrapper
+
+ openfold_config -- "Configures" --> openfold_data_data_modules_OpenFoldDataModule
+
+ openfold_config -- "Configures" --> openfold_model_model_AlphaFold
+
+ openfold_config -- "Configures" --> openfold_data_data_pipeline_AlignmentRunner
+
+ openfold_data_data_pipeline_AlignmentRunner -- "Produces data consumed by" --> openfold_data_feature_pipeline_FeaturePipeline
+
+ openfold_data_feature_pipeline_FeaturePipeline -- "Produces input for" --> openfold_model_model_AlphaFold
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The Training & Inference Orchestration subsystem in OpenFold is responsible for managing the entire lifecycle of protein structure prediction, from model training to inference. It provides the main entry points and control flow, integrating with PyTorch Lightning for efficient execution and resource management.
+
+
+
+### train_openfold.py
+
+This script serves as the primary entry point for initiating and managing the training process. It sets up the PyTorch Lightning Trainer, configures the OpenFoldWrapper, OpenFoldDataModule, loss functions, learning rate schedulers, and various callbacks for monitoring and saving the training progress.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `train_openfold.py`
+
+
+
+
+
+### run_pretrained_openfold.py
+
+This script is the main entry point for executing the inference pipeline. It orchestrates the entire prediction workflow, including parsing command-line arguments, loading model configurations and weights, precomputing alignments, generating input features, running the AlphaFold Model, and performing post-processing steps like Amber relaxation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `run_pretrained_openfold.py`
+
+
+
+
+
+### openfold.train_openfold.OpenFoldWrapper
+
+This is the core PyTorch Lightning module that encapsulates the AlphaFold Model, defines the forward pass, computes the loss, and manages the training and validation steps. It handles the integration with PyTorch Lightning's training loop, including Exponential Moving Average (EMA) updates and metric logging.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.train_openfold.OpenFoldWrapper` (44:268)
+
+
+
+
+
+### openfold.data.data_modules.OpenFoldDataModule
+
+This PyTorch Lightning DataModule handles the loading, preprocessing, and batching of data specifically for training and validation. It integrates with the DataPipeline and FeaturePipeline to prepare the input features for the model.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.data_modules.OpenFoldDataModule` (847:1058)
+
+
+
+
+
+### openfold.utils.loss.AlphaFoldLoss
+
+This class defines the composite loss function used during the training of the AlphaFold Model. It combines various individual loss terms (e.g., FAPE, distogram, masked MSA loss) to guide the model's learning.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.utils.loss.AlphaFoldLoss` (1684:1792)
+
+
+
+
+
+### openfold.config
+
+This centralized module defines all hyperparameters, model architectures, data pipeline settings, and training/inference parameters. It ensures reproducibility and flexibility in experimentation by providing a single source of truth for configuration.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.config`
+
+
+
+
+
+### openfold.data.data_pipeline.AlignmentRunner
+
+Utilized by run_pretrained_openfold.py, this class is responsible for generating Multiple Sequence Alignments (MSAs) and identifying structural templates using external bioinformatics tools.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.data_pipeline.AlignmentRunner` (333:561)
+
+
+
+
+
+### openfold.data.feature_pipeline.FeaturePipeline
+
+This component transforms the raw biological data and generated alignments into the numerical feature dictionaries (tensors) that the AlphaFold Model can directly consume. It is crucial for both training and inference data preparation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.data.feature_pipeline.FeaturePipeline` (131:152)
+
+
+
+
+
+### openfold.model.model.AlphaFold
+
+The core deep learning model responsible for predicting protein structures. It is the central computational engine for both training and inference.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.model.model.AlphaFold` (64:590)
+
+
+
+
+
+### openfold.utils.callbacks
+
+This module provides a collection of PyTorch Lightning callbacks, such as EarlyStoppingVerbose and ModelCheckpoint, which are crucial for monitoring training progress, saving model checkpoints, and preventing overfitting.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold.utils.callbacks`
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 000000000..714d6348d
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,307 @@
+```mermaid
+
+graph LR
+
+ Configuration_Management["Configuration Management"]
+
+ Data_Processing_Pipeline["Data Processing Pipeline"]
+
+ Core_AlphaFold_Model["Core AlphaFold Model"]
+
+ Structure_Post_processing_Utilities["Structure Post-processing & Utilities"]
+
+ Auxiliary_Utilities_Loss_Geometry_["Auxiliary Utilities (Loss & Geometry)"]
+
+ General_System_Utilities["General System Utilities"]
+
+ Training_Inference_Orchestration["Training & Inference Orchestration"]
+
+ Configuration_Management -- "Provides configuration to" --> Data_Processing_Pipeline
+
+ Configuration_Management -- "Provides configuration to" --> Core_AlphaFold_Model
+
+ Configuration_Management -- "Provides configuration to" --> Training_Inference_Orchestration
+
+ Data_Processing_Pipeline -- "Receives configuration from" --> Configuration_Management
+
+ Data_Processing_Pipeline -- "Provides processed features to" --> Core_AlphaFold_Model
+
+ Data_Processing_Pipeline -- "Provides batched data to" --> Training_Inference_Orchestration
+
+ Core_AlphaFold_Model -- "Receives processed features from" --> Data_Processing_Pipeline
+
+ Core_AlphaFold_Model -- "Outputs predictions/structures to" --> Structure_Post_processing_Utilities
+
+ Core_AlphaFold_Model -- "Outputs intermediate representations for" --> Auxiliary_Utilities_Loss_Geometry_
+
+ Core_AlphaFold_Model -- "Receives configuration from" --> Configuration_Management
+
+ Structure_Post_processing_Utilities -- "Receives predicted structures from" --> Core_AlphaFold_Model
+
+ Structure_Post_processing_Utilities -- "Provides refined structures to" --> Training_Inference_Orchestration
+
+ Structure_Post_processing_Utilities -- "Utilizes" --> Auxiliary_Utilities_Loss_Geometry_
+
+ Auxiliary_Utilities_Loss_Geometry_ -- "Receives predictions/intermediate representations from" --> Core_AlphaFold_Model
+
+ Auxiliary_Utilities_Loss_Geometry_ -- "Provides computed loss values to" --> Training_Inference_Orchestration
+
+ Auxiliary_Utilities_Loss_Geometry_ -- "Utilized by" --> Structure_Post_processing_Utilities
+
+ General_System_Utilities -- "Provides functionalities to" --> Training_Inference_Orchestration
+
+ General_System_Utilities -- "Provides functionalities to" --> Core_AlphaFold_Model
+
+ Training_Inference_Orchestration -- "Receives configuration from" --> Configuration_Management
+
+ Training_Inference_Orchestration -- "Initiates and manages" --> Data_Processing_Pipeline
+
+ Training_Inference_Orchestration -- "Executes" --> Core_AlphaFold_Model
+
+ Training_Inference_Orchestration -- "Receives loss values from" --> Auxiliary_Utilities_Loss_Geometry_
+
+ Training_Inference_Orchestration -- "Receives refined structures from" --> Structure_Post_processing_Utilities
+
+ Training_Inference_Orchestration -- "Leverages" --> General_System_Utilities
+
+ click Configuration_Management href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//Configuration_Management.md" "Details"
+
+ click Data_Processing_Pipeline href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//Data_Processing_Pipeline.md" "Details"
+
+ click Core_AlphaFold_Model href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//Core_AlphaFold_Model.md" "Details"
+
+ click Auxiliary_Utilities_Loss_Geometry_ href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//Auxiliary_Utilities_Loss_Geometry_.md" "Details"
+
+ click Training_Inference_Orchestration href "https://github.com/aqlaboratory/openfold/blob/main/.codeboarding//Training_Inference_Orchestration.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `openfold` project, a research-oriented deep learning framework for protein structure prediction, exhibits a modular and configuration-driven architecture. The core data flow revolves around preparing biological sequence data, feeding it into a sophisticated deep learning model, and then post-processing the predicted structures.
+
+
+
+### Configuration Management [[Expand]](./Configuration_Management.md)
+
+Centralized system for defining, loading, and managing all configurable parameters for the model, data pipelines, and training/inference processes. It ensures consistency and flexibility across different experimental setups.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/config.py`
+
+
+
+
+
+### Data Processing Pipeline [[Expand]](./Data_Processing_Pipeline.md)
+
+Manages the entire lifecycle of input data, from raw sequences and external tool outputs (e.g., MSAs, templates) to model-ready features. This includes interfacing with bioinformatics tools, parsing various data formats, applying complex transformations, and preparing data batches for efficient model consumption.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/data/tools/`
+
+- `openfold/data/parsers.py`
+
+- `openfold/data/data_pipeline.py`
+
+- `openfold/data/feature_pipeline.py`
+
+- `openfold/data/data_transforms.py`
+
+- `openfold/data/data_modules.py`
+
+- `openfold/data/input_pipeline.py`
+
+- `openfold/data/msa_pairing.py`
+
+- `openfold/data/templates.py`
+
+- `openfold/data/mmcif_parsing.py`
+
+- `openfold/data/data_transforms_multimer.py`
+
+- `openfold/data/feature_processing_multimer.py`
+
+- `openfold/data/input_pipeline_multimer.py`
+
+
+
+
+
+### Core AlphaFold Model [[Expand]](./Core_AlphaFold_Model.md)
+
+The primary deep learning model responsible for predicting protein structures. It orchestrates its internal sub-modules (Embedders, Evoformer, Structure Module, Prediction Heads) and fundamental primitives to process input features and generate structural outputs.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/model/model.py`
+
+- `openfold/model/embedders.py`
+
+- `openfold/model/evoformer.py`
+
+- `openfold/model/structure_module.py`
+
+- `openfold/model/heads.py`
+
+- `openfold/model/primitives.py`
+
+- `openfold/model/dropout.py`
+
+- `openfold/model/msa.py`
+
+- `openfold/model/outer_product_mean.py`
+
+- `openfold/model/pair_transition.py`
+
+- `openfold/model/template.py`
+
+- `openfold/model/triangular_attention.py`
+
+- `openfold/model/triangular_multiplicative_update.py`
+
+
+
+
+
+### Structure Post-processing & Utilities
+
+Provides NumPy-based utilities for handling protein structures (e.g., PDB/ModelCIF conversion, atom mask generation) and integrates molecular mechanics (Amber minimization) for refining predicted structures to improve geometry and resolve clashes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/np/protein.py`
+
+- `openfold/np/residue_constants.py`
+
+- `openfold/np/relax/`
+
+
+
+
+
+### Auxiliary Utilities (Loss & Geometry) [[Expand]](./Auxiliary_Utilities_Loss_Geometry_.md)
+
+Implements various loss components crucial for training the AlphaFold model and provides fundamental operations for 3D geometry, rigid body transformations, and all-atom coordinate manipulations, essential for protein structure representation and calculations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/utils/loss.py`
+
+- `openfold/utils/geometry/`
+
+- `openfold/utils/rigid_utils.py`
+
+- `openfold/utils/all_atom_multimer.py`
+
+
+
+
+
+### General System Utilities
+
+A collection of miscellaneous helper functions and modules that support various aspects of the framework, including learning rate scheduling, callbacks, model weight management (EMA, checkpointing, loading), memory optimization (chunking), mixed precision handling, and command-line argument parsing.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `openfold/utils/exponential_moving_average.py`
+
+- `openfold/utils/lr_schedulers.py`
+
+- `openfold/utils/callbacks.py`
+
+- `openfold/utils/logger.py`
+
+- `openfold/utils/multi_chain_permutation.py`
+
+- `openfold/utils/import_weights.py`
+
+- `openfold/utils/checkpointing.py`
+
+- `openfold/utils/chunk_utils.py`
+
+- `openfold/utils/precision_utils.py`
+
+- `openfold/utils/tensor_utils.py`
+
+- `openfold/utils/trace_utils.py`
+
+- `openfold/utils/script_utils.py`
+
+- `openfold/utils/argparse_utils.py`
+
+
+
+
+
+### Training & Inference Orchestration [[Expand]](./Training_Inference_Orchestration.md)
+
+The main entry points and control flow for executing training and inference tasks. It integrates with PyTorch Lightning, manages the training loop, optimizers, logging, model loading, and output saving.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `train_openfold.py`
+
+- `run_pretrained_openfold.py`
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file