Skip to content
BranchesTags

Repository files navigation

Automated Martini 3 Coarse-Graining Framework

A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.
This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.

Overview

The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.
This has traditionally been a slow, manual process requiring significant chemical expertise.

This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.

Key Features

  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.

Installation

This project relies on RDKit for processing chemical structures.
The recommended way to set up the environment is by using Anaconda.

If you don’t already have Anaconda installed, you can download it here:
Install Anaconda

Setup Steps

# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py

You will be prompted for:

  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.

Example Session

$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O

Output Files

After running, the script will generate three files in the same directory:

  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.

Limitations

This framework is under active development. The current version has the following limitations:

  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.

Future Directions

  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.

Citation

If you use this work in your research, please cite our upcoming paper:

License

About

Algorithm to map molecules using Martini 3 beads

Resources

Readme
Activity

Stars

5 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - eliobaby/Martini_mapping: Algorithm to map molecules using Martini 3 beads · GitHub
Skip to content
BranchesTags
Repository files navigation
Automated Martini 3 Coarse-Graining Framework
A Python-based framework for automatically generating Martini 3 coarse-grained models directly from SMILES strings.

This tool is designed to transform the complex, manual process of creating coarse-grained topologies into a fast, systematic, and reproducible workflow.
Overview
The Martini 3 force field is a powerful tool for large-scale molecular simulations, but its use depends on a crucial mapping step where atoms are grouped into coarse-grained beads.

This has traditionally been a slow, manual process requiring significant chemical expertise.
This framework automates that entire process. It uses a sophisticated, rule-based algorithm to intelligently partition a molecule and assign the correct bead types, producing simulation-ready files without any manual intervention.
Key Features
  • Fully Automated: Go from a SMILES string to simulation-ready GROMACS files in a single step.
  • Rule-Based and Extensible: Uses a detailed, internal dictionary of chemical fragments that can be expanded to map new structures.
  • Hierarchical Mapping: Employs a "most-constrained-first" strategy, mapping rigid ring systems before flexible chains to ensure a robust and chemically sound model.
  • Standardized Outputs: Generates GROMACS-compatible .gro (coordinate) and .itp (topology) files.
Installation
This project relies on RDKit for processing chemical structures.

The recommended way to set up the environment is by using Anaconda.
If you don’t already have Anaconda installed, you can download it here:
Install Anaconda
Setup Steps
# Clone the repository
git clone https://github.com/eliobaby/Martini_3.git
cd Martini_3
# Create a new Conda environment
conda create -n martini_mapper python=3.9
# Activate the environment
conda activate martini_mapper
# Install RDKit
conda install -c conda-forge rdkit
## Usage
The script is run interactively from the command line.
```bashpython main.py
You will be prompted for:
  • Name: The name of your molecule.
  • SMILES: The SMILES string representation of your molecule.
Example Session
$ python main.py
Name: Aspirin
SMILES: CC(=O)OC1=CC=CC=C1C(=O)O
Output Files
After running, the script will generate three files in the same directory:
  • <MOLECULE_NAME>.gro: A GROMACS coordinate file containing the 3D positions of each coarse-grained bead.
  • <MOLECULE_NAME>.itp: A GROMACS topology file that defines the bead types, bonds, and other parameters for the simulation.
  • <MOLECULE_NAME>.txt: A detailed summary file showing how each atom was mapped, which bead it belongs to, and how the beads are connected. This file is very useful for debugging and validating the mapping.
Limitations
This framework is under active development. The current version has the following limitations:
  • The internal mapping dictionary has been primarily developed using molecules containing Carbon, Oxygen, and Nitrogen.
  • Support for other elements like Sulfur, Phosphorus, and halogens is still experimental.
  • The algorithm may fail on molecules containing highly unusual or complex chemical fragments that are not yet present in the dictionary.
Future Directions
  • Expand the Dictionary: Systematically test the framework on more diverse chemical datasets to add new rules and increase the mapping success rate.
  • Integrate Machine Learning: Develop a machine learning model to assist with the tuning of bead parameters, which is currently a manual process.
Citation
If you use this work in your research, please cite our upcoming paper:
License
About
Algorithm to map molecules using Martini 3 beads 
Resources
Readme
Activity
Stars
5 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages