### Install ugropy with pip

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/getting_started.ipynb.txt

Installs the latest version of ugropy from PyPI.

```bash
pip install ugropy
```

--------------------------------

### Install ugropy in development mode

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/getting_started.ipynb.txt

Installs ugropy in development mode for contributors who have cloned the repository.

```bash
pip install -e .
```

--------------------------------

### Install XPRESS solver

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Install the XPRESS solver package, which is required before changing the default ILP solver in ugropy.

```bash
pip install xpress

```

--------------------------------

### Install XPRESS solver

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/power_user.ipynb.txt

Installs the XPRESS solver via pip to be used as an alternative to the default CBC solver.

```shell
pip install xpress
```

--------------------------------

### Validation results output example

Source: https://ipqa-research.github.io/ugropy/tests_book/against_ddbst/ddbst_tests.html

Example output showing the formatted validation results table.

```text
=============================================
          UGROPY VALIDATION RESULTS
=============================================
  Total molecules:      28675
  Skipped (??):            29
  Compared:             28646
---------------------------------------------
  ✅ Correct (first):      26567  (92.649%)
  ✅ Correct (multiple):    1817  (6.337%)
                          ───────────────────
  ✅ Total correct:        28384  (98.985%)
  ❌ Incorrect:              291  (1.015%)
=============================================
```

--------------------------------

### Define a cyclohexane ring

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/power_user.ipynb.txt

Example showing how to define a cyclohexane ring structure in Ugropy.

```python
from ugropy import structure

cyclohexane = structure.Ring("C1CCCCC1")
```

--------------------------------

### Expected fragmentation output

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/getting_started.ipynb.txt

Shows the correct fragmentation for the example molecule as a dictionary with fragment names as keys and counts as values.

```text
{'ACH': 10, 'AC': 1, 'ACCH2': 1}
```

--------------------------------

### Install ugropy in Google Colab

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/failing_fragmentations.ipynb.txt

Installs the ugropy package when running in Google Colab. The try/except block checks for the google.colab module and only runs the pip install if it is present, otherwise it passes silently.

```python
try:
  import google.colab
  %pip install -q ugropy
  except ImportError:
  pass
```

--------------------------------

### Install ugropy in Colab

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/writers.ipynb.txt

Installs the ugropy package in a Google Colab environment if it is not already present.

```python
try:
  import google.colab
  %pip install -q ugropy
except ImportError:
  pass
```

--------------------------------

### GibbsModel

Source: https://ipqa-research.github.io/ugropy/core/frag_classes/gibbs_model/gibbs_model.html

Documentation for the GibbsModel class, including its constructor, attributes, and methods for getting groups and filtering solutions.

```APIDOC
## GibbsModel

### Description
GibbsModel is a fragmentation model dedicated to Gibbs excess models. It is used to detect functional groups in molecules based on SMARTS patterns and optionally calculate R and Q values.

### Constructor

#### Parameters
- **subgroups** (pd.DataFrame) - Required - Model's subgroups. Index: 'group' (subgroups names). Mandatory columns: 'smarts' (SMARTS representations of the group to detect its presence in the molecule).
- **subgroups_info** (Union[pd.DataFrame, None], optional) - Information of the model's subgroups (R, Q, subgroup_number, main_group), by default None.
- **calculate_r_q** (bool, optional) - Whether calculate R and Q values or not, by default True.

### Attributes
- **subgroups** (pd.DataFrame) - Model's subgroups. Index: 'group' (subgroups names). Columns: 'smarts' (SMARTS representations of the group to detect its presence in the molecule).
- **detection_mols** (dict) - Dictionary containing all the rdkit Mol objects from the detection_smarts subgroups column.
- **subgroups_info** (pd.DataFrame) - Information of the model's subgroups. Columns: R, Q, subgroup_number, main_group. Index: 'group' (subgroups names).

### Methods

#### get_groups(identifier, identifier_type='name', solver=DefaultSolver, search_multiple_solutions=False, search_nonoptimal=False, solver_arguments={})

##### Description
Get the groups of a molecule.

##### Parameters
- **identifier** (Union[str, Chem.rdchem.Mol]) - Required - Identifier of the molecule. You can use either the name of the molecule, the SMILES of the molecule, or a rdkit Mol object.
- **identifier_type** (str, optional) - Identifier type of the molecule. Use "name" if you are providing the molecule's name, "smiles" if you are providing the SMILES, or "mol" if you are providing a rdkit Mol object. Default: "name".
- **solver** (ILPSolver, optional) - ILP solver class. Default: DefaultSolver.
- **search_multiple_solutions** (bool, optional) - Whether to search for multiple solutions or not. Default: False. If False, the return will be a FragmentationResult object; if True, the return will be a list of FragmentationResult objects.
- **search_nonoptimal** (bool, optional) - If True, the solver will search for non-optimal solutions along with the optimal ones. Default: False. If search_multiple_solutions is False, this parameter will be ignored.
- **solver_arguments** (dict, optional) - Dictionary with the arguments to be passed to the solver. For the DefaultSolver of ugropy, you can change the PulP solver by passing a dictionary like {"solver": "PULP_CBC_CMD"}. If empty, it will use the default solver arguments. Default: {}.

##### Returns
- **Union[GibbsFragmentationResult, List[GibbsFragmentationResult]]** - Fragmentation result. If search_multiple_solutions is False, the return will be a FragmentationResult object; if True, the return will be a list of FragmentationResult objects.

#### filter_bigger_polyatomics(solutions, criteria='Q')

##### Description
Filter multiple solutions based on the R or Q values of the groups. The method analyzes all provided solutions and filters them according to the cumulative contribution of the R or Q values of their polyatomic groups. The returned solutions are those with the maximum sum of the selected R or Q parameter weighted by the occurrence of each polyatomic group.

##### Parameters
- **solutions** (List[GibbsFragmentationResult]) - Required - List of Gibbs fragmentation results to filter.
- **criteria** ({"R", "Q"}, optional) - The criteria to use for filtering, either "R" or "Q". Default: "Q".

##### Returns
- **List[GibbsFragmentationResult]** - Filtered list of Gibbs fragmentation results.
```

--------------------------------

### Internal RDKit Mol creation

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Example of how RDKit Mol objects are created internally from SMARTS strings.

```python
from rdkit import Chem

mol = Chem.MolFromSmarts(smarts)
```

--------------------------------

### Get group contributions

Source: https://ipqa-research.github.io/ugropy/models/init.html

Demonstrates how to obtain the contribution of each group to the properties for various models, including the primary, secondary, and tertiary subgroups of the Abdulelah-Gani model.

```python
joback.get_groups("n-hexane").subgroups
unifac.get_groups("toluene").subgroups
psrk.get_groups("CCO", "smiles").subgroups
abdulelah_gani.get_groups("CCO", "smiles").primary.subgroups
abdulelah_gani.get_groups("CCO", "smiles").secondary.subgroups
abdulelah_gani.get_groups("CCO", "smiles").tertiary.subgroups

```

--------------------------------

### Filter solutions with filter_mostly_polyatomic

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/filtering.ipynb.txt

Use the filter_mostly_polyatomic method on a UNIFAC model to filter a list of solutions. The filter returns a list of solutions that meet the criteria, and the example shows how to get the length of the filtered list.

```python
filtered = unifac.filter_mostly_polyatomic(solutions)

len(filtered)
```

--------------------------------

### Initialize Joback with experimental boiling point

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/properties_estimators.ipynb.txt

Initializes the Joback model for toluene by providing an experimental normal boiling point to improve estimation accuracy.

```python
toluene = joback.get_groups("toluene", normal_boiling_point=(110.6 + 273.15))
```

--------------------------------

### GibbsModel.__init__

Source: https://ipqa-research.github.io/ugropy/_modules/ugropy/core/frag_classes/gibbs_model/gibbs_model.html

Initializes a GibbsModel instance with the model's subgroups and optional subgroup information.

```APIDOC
## GibbsModel.__init__

### Description
Initializes a GibbsModel instance with the model's subgroups and optional subgroup information.

### Method
Constructor

### Parameters
- **subgroups** (pd.DataFrame) - Required - Model's subgroups. Index: 'group' (subgroups names). Mandatory columns: 'smarts' (SMARTS representations of the group to detect its presence in the molecule).
- **subgroups_info** (Union[pd.DataFrame, None]) - Optional - Information of the model's subgroups (R, Q, subgroup_number, main_group). Default: None
- **calculate_r_q** (bool) - Optional - Whether calculate R and Q values or not. Default: True

### Returns
None
```

--------------------------------

### Visualize first primary solution

Source: https://ipqa-research.github.io/ugropy/tutorial/properties_estimators.html

Visualize the primary structure of the first fragmentation solution.

```python
mol[0].primary.draw(width=600)
```

--------------------------------

### Get UNIFAC subgroups for carvone by name

Source: https://ipqa-research.github.io/ugropy/tutorial/easy_way.html

Creates a Groups object using the default identifier type 'name' and accesses the .unifac.subgroups property to get the UNIFAC subgroup counts.

```python
from ugropy import Groups

carvone = Groups("carvone")

carvone.unifac.subgroups

```

--------------------------------

### Inspect JobackModel configuration

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Demonstrates how to access configuration attributes and detection objects for the JobackModel instance.

```python
from ugropy import joback

# Commented out to avoid printing a large DataFrame
# print("Fragments of the model:", joback.subgroups)

print("Allow overlapping:", joback.allow_overlapping)
print("Allow free atoms:", joback.allow_free_atoms)
print("Fragmentation result class:", joback.fragmentation_result)
print("Detection mol objects:", joback.detection_mols)

# Commented out to avoid printing a large DataFrame
# print("Properties contributions:", joback.properties_contributions)
```

--------------------------------

### Get raw magnitude of property

Source: https://ipqa-research.github.io/ugropy/tutorial/properties_estimators.html

Extract the numerical magnitude of the critical pressure.

```python
toluene.critical_pressure.magnitude
```

```text
np.float64(41.144119209325225)
```

--------------------------------

### RDKit Detection Output

Source: https://ipqa-research.github.io/ugropy/tutorial/getting_started.html

The output generated by the direct RDKit fragment detection example.

```text
====================================================================
Atoms occupied by each fragment:
--------------------------------------------------------------------
CH2: ((6,),)
ACH: ((0,), (1,), (2,), (3,), (4,), (8,), (9,), (10,), (11,), (12,))
AC: ((5,), (7,))
ACCH2: ((5, 6), (7, 6))

====================================================================
Occurrence of each fragment:
--------------------------------------------------------------------
{'CH2': 1, 'ACH': 10, 'AC': 2, 'ACCH2': 2}
```

--------------------------------

### Visualize first solution

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Draws the first solution from the returned list.

```python
solutions[0].draw(width=600)
```

--------------------------------

### Convert units and get magnitude

Source: https://ipqa-research.github.io/ugropy/tutorial/properties_estimators.html

Convert critical pressure to mmHg and extract the magnitude.

```python
toluene.critical_pressure.to("mmHg").magnitude
```

```text
np.float64(30860.62289092802)
```

--------------------------------

### Instantiate FragmentationModel

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Initialize the model with the defined subgroups and configuration parameters for overlapping and free atoms.

```python
our_model = FragmentationModel(
    subgroups=subgroups,
    allow_overlapping=False,
    allow_free_atoms=False,
    fragmentation_result=FragmentationResult
)
```

--------------------------------

### Display Ketones Cases

Source: https://ipqa-research.github.io/ugropy/_sources/tests_book/internal_tests/ketones.ipynb.txt

Imports the display utility and ketone cases, then renders the module cases.

```python
from _display import display_case_module

from cases import ketones_cases

display_case_module(ketones_cases)
```

--------------------------------

### Get groups with PSRK model

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/gibbs_models.ipynb.txt

Imports the psrk module and retrieves the subgroups for toluene.

```python
from ugropy import psrk

toluene = psrk.get_groups("toluene")

toluene.subgroups
```

--------------------------------

### Display Silicon Test Cases

Source: https://ipqa-research.github.io/ugropy/tests_book/internal_tests/silicon.html

Initializes the display of silicon test cases using the internal display module.

```python
from _display import display_case_module

from cases import silicon_cases

display_case_module(silicon_cases)
```

--------------------------------

### Get Joback model subgroups

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/properties_estimators.ipynb.txt

Uses the joback module to identify and print the subgroups for toluene.

```python
from ugropy import joback

toluene = joback.get_groups("toluene")

print(toluene.subgroups)
```

--------------------------------

### Get UNIFAC groups for n-hexane

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/gibbs_models.ipynb.txt

Uses the UNIFAC model to retrieve and print the subgroup composition for n-hexane.

```python
from ugropy import unifac

hexane = unifac.get_groups("n-hexane")

print(hexane.subgroups)
```

--------------------------------

### Inspect instantiate_mol_object documentation

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Displays the help documentation for the instantiate_mol_object function, which converts molecule identifiers into RDKit Mol objects.

```python
from ugropy import instantiate_mol_object

help(instantiate_mol_object)
```

--------------------------------

### Display Epoxides Case Module

Source: https://ipqa-research.github.io/ugropy/_sources/tests_book/internal_tests/epoxides.ipynb.txt

Imports the display utility and epoxide cases, then renders the module.

```python
from _display import display_case_module

from cases import epoxides_cases

display_case_module(epoxides_cases)
```

--------------------------------

### Obtaining Multiple Fragmentation Solutions

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/easy_way.ipynb.txt

Configure the solver to return multiple fragmentation solutions by setting search_multiple_solutions to True.

```python
# Example of multiple solutions
molecule = Groups("CCCC1=CC=C(CC(=O)OC)C=C1", "smiles", search_multiple_solutions=True)

molecule.unifac
```

--------------------------------

### Groups class full signature with DefaultSolver

Source: https://ipqa-research.github.io/ugropy/tutorial/easy_way.html

Shows the complete signature of the Groups constructor, including the solver, search_multiple_solutions, and normal_boiling_temperature parameters.

```python
from ugropy import DefaultSolver

carvone = Groups(
    identifier="carvone",
    identifier_type="name",
    solver=DefaultSolver,
    search_multiple_solutions=False,
    normal_boiling_temperature=None
)

```

--------------------------------

### Import ugropy Groups and writers

Source: https://ipqa-research.github.io/ugropy/tutorial/writers.html

Imports the Groups class and the writers module from ugropy, which are required for the examples that follow.

```python
from ugropy import Groups, writers

```

--------------------------------

### Get Substructure Matches for CH2

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/getting_started.ipynb.txt

Retrieves the atom indices for all CH2 substructures in a hexane molecule using RDKit.

```python
ch2_detections = hexane.GetSubstructMatches(ch2)

ch2_detections
```

--------------------------------

### Import and use Joback FragmentationModel

Source: https://ipqa-research.github.io/ugropy/models/jobackmod.html

Demonstrates how to import the joback module and retrieve molecular subgroups using either a molecule name or a SMILES string.

```python
from ugropy import joback

# Get groups from molecule's name
tol = joback.get_groups("toluene")

print(tol.subgroups)

# Get groups from molecule's SMILES
eth = joback.get_groups("CCO", "smiles")

print(eth.subgroups)
```

--------------------------------

### Detecting Aliphatic CH2 Groups with SMARTS

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/power_user.ipynb.txt

Demonstrates using a basic SMARTS pattern to identify aliphatic CH2 groups in propene.

```python
propene = Chem.MolFromSmiles("C=CC") # propene

smt = Chem.MolFromSmarts("[CH2]")

matches = propene.GetSubstructMatches(smt)

print(matches)

propene
```

--------------------------------

### Print all estimable properties for 2,3-dimethylhexane

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/properties_estimators.ipynb.txt

Print all properties that can be estimated with the Abdulelah-Gani model for 2,3-dimethylhexane, including critical temperature, critical pressure, critical volume, acentric factor, enthalpy of formation, and Gibbs energy of formation.

```python
print(hexa23.critical_temperature)
print(hexa23.critical_pressure)
print(hexa23.critical_volume)
print(hexa23.acentric_factor)
print(hexa23.enthalpy_formation)
print(hexa23.gibbs_energy_formation)
```

--------------------------------

### Get multiple fragmentation solutions

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/filtering.ipynb.txt

Retrieves multiple fragmentation solutions for a given SMILES string using the UNIFAC model.

```python
solutions = unifac.get_groups("COC(=O)CC1=CC=CC=C1", "smiles", search_multiple_solutions=True) 
```

--------------------------------

### GibbsModel.get_groups

Source: https://ipqa-research.github.io/ugropy/_modules/ugropy/core/frag_classes/gibbs_model/gibbs_model.html

Gets the groups of a molecule using the GibbsModel fragmentation. Returns a GibbsFragmentationResult or a list of results if multiple solutions are requested.

```APIDOC
## GibbsModel.get_groups

### Description
Gets the groups of a molecule using the GibbsModel fragmentation. Returns a GibbsFragmentationResult or a list of results if multiple solutions are requested.

### Method
Method

### Parameters
- **identifier** (Union[str, Chem.rdchem.Mol]) - Required - Identifier of the molecule. Can be the name, SMILES, or rdkit Mol object.
- **identifier_type** (str) - Optional - Identifier type: "name", "smiles", or "mol". Default: "name"
- **solver** (ILPSolver) - Optional - ILP solver class. Default: DefaultSolver
- **search_multiple_solutions** (bool) - Optional - Whether to search for multiple solutions. If False, returns a single FragmentationResult; if True, returns a list. Default: False
- **search_nonoptimal** (bool) - Optional - If True, the solver will search for non-optimal solutions along with optimal ones. Only used if search_multiple_solutions is True. Default: False
- **solver_arguments** (dict) - Optional - Dictionary of arguments to pass to the solver. For DefaultSolver, can change the PuLP solver, e.g., {"solver": "PULP_CBC_CMD"}. Default: {}

### Returns
- **Union[GibbsFragmentationResult, List[GibbsFragmentationResult]]** - The fragmentation result(s).
```

--------------------------------

### Import and use PSRK FragmentationModel

Source: https://ipqa-research.github.io/ugropy/models/psrkmod.html

Demonstrates how to import the psrk module and retrieve groups for a molecule using its name or SMILES representation.

```python
from ugropy import psrk

# Get groups from molecule's name
tol = psrk.get_groups("toluene")

print(tol.subgroups)

# Get groups from molecule's SMILES
eth = psrk.get_groups("CCO", "smiles")

print(eth.subgroups)
```

--------------------------------

### FragmentationResult.draw

Source: https://ipqa-research.github.io/ugropy/core/frag_classes/base/fragmentation_result.html

Creates an IPython SVG object of the fragmentation result for direct display in Jupyter notebooks. Requires the IPython library to be installed.

```APIDOC
## FragmentationResult.draw(title: str = '', width: float = 400, height: float = 200, title_font_size: float = 12, legend_font_size: float = 12, font: str = 'Helvetica')

### Description
Creates an IPython SVG object of the fragmentation result. This function is meant to be used in Jupyter notebooks to directly obtain the visual SVG figure on the notebook. It requires the IPython library to be installed.

### Method
N/A (Python method)

### Endpoint
N/A (Python method)

### Parameters
- **title** (str, optional) - Graph title, by default ''
- **width** (int, optional) - Graph width, by default 400
- **height** (int, optional) - Graph height, by default 200
- **title_font_size** (int, optional) - Font size of graph's title, by default 12
- **legend_font_size** (int, optional) - Legend font size, by default 12
- **font** (str, optional) - Text font, by default 'Helvetica'

### Returns
- **IPython.display.SVG** - SVG object of the fragmentation result.

### Return Type
IPython.display.SVG

### Raises
- **ImportError** - IPython is not installed.

### Example
```python
result = FragmentationResult(molecule, subgroups, subgroups_atoms_indexes)
result.draw(title='My Molecule', width=500, height=300)
```
```

--------------------------------

### Import all models

Source: https://ipqa-research.github.io/ugropy/models/init.html

Imports the main fragmentation models from the ugropy package.

```python
from ugropy import joback, psrk, unifac, abdulelah_gani

```

--------------------------------

### Inspect model instance configuration and detection objects

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Displays the configuration state of a model instance, including boolean flags, the fragmentation result class, and a mapping of detected chemical groups to their corresponding RDKit molecule objects.

```text
Allow overlapping: False
Allow free atoms: False
Fragmentation result class: <class 'ugropy.core.frag_classes.joback.joback_result.JobackFragmentationResult'>
Detection mol objects: {'-CH3': <rdkit.Chem.rdchem.Mol object at 0x7f25691d68f0>, '-CH2-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6960>, '>CH-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d69d0>, '>C<': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6a40>, '=CH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6ab0>, '=CH-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6b20>, '=C<': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6b90>, '=C=': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6c00>, 'CH': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6c70>, 'C': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6ce0>, 'ring-CH2-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6d50>, 'ring>CH-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6dc0>, 'ring>C<': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6e30>, 'ring=CH-': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6ea0>, 'ring=C<': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6f10>, '-F': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6f80>, '-Cl': <rdkit.Chem.rdchem.Mol object at 0x7f25691d6ff0>, '-Br': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7060>, '-I': <rdkit.Chem.rdchem.Mol object at 0x7f25691d70d0>, '-OH (alcohol)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7140>, '-OH (phenol)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d71b0>, '-O- (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7220>, '-O- (ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7290>, '>C=O (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7300>, '>C=O (ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7370>, 'O=CH- (aldehyde)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d73e0>, '-COOH (acid)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7450>, '-COO- (ester)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d74c0>, '=O (other than above)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7530>, '-NH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691d75a0>, '>NH (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7610>, '>NH (ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7680>, '>N- (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d76f0>, '-N= (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7760>, '-N= (ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d77d0>, '=NH': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7840>, '-CN': <rdkit.Chem.rdchem.Mol object at 0x7f25691d78b0>, '-NO2': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7920>, '-SH': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7990>, '-S- (non-ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7a00>, '-S- (ring)': <rdkit.Chem.rdchem.Mol object at 0x7f25691d7a70>}
```

--------------------------------

### Get SMARTS for ACOH group

Source: https://ipqa-research.github.io/ugropy/tutorial/failing_fragmentations.html

Retrieves the SMARTS pattern for the ACOH group, which represents a hydroxyl group bonded to an aromatic carbon.

```python
unifac.subgroups.loc["ACOH", "smarts"]

```

--------------------------------

### Get critical temperature of first solution

Source: https://ipqa-research.github.io/ugropy/_sources/tutorial/properties_estimators.ipynb.txt

Returns the critical temperature of the first solution as a Quantity object. The output is 750.949961574131 kelvin.

```python
mol[0].critical_temperature
```

--------------------------------

### Create molecule and draw image

Source: https://ipqa-research.github.io/ugropy/tutorial/failing_fragmentations.html

Creates a molecule from a SMILES string and generates an image of it. This example uses a molecule that cannot be represented by UNIFAC groups.

```python
from rdkit.Chem import Draw


mol = unifac.get_groups("C1(=CC=CC=C1)OC(C)(C)C", "smiles")

Draw.MolToImage(mol.molecule)

```

--------------------------------

### Visualize second primary solution

Source: https://ipqa-research.github.io/ugropy/tutorial/properties_estimators.html

Visualize the primary structure of the second fragmentation solution.

```python
mol[1].primary.draw(width=600)
```

--------------------------------

### Inspect GibbsModel configuration attributes

Source: https://ipqa-research.github.io/ugropy/tutorial/power_user.html

Accesses and prints the configuration settings and detection molecule objects for the unifac model instance.

```python
from ugropy import unifac

# Commented out to avoid printing a large DataFrame
# print("Fragments of the model:", unifac.subgroups)

print("Allow overlapping:", unifac.allow_overlapping)
print("Allow free atoms:", unifac.allow_free_atoms)
print("Fragmentation result class:", unifac.fragmentation_result)
print("Detection mol objects:", unifac.detection_mols)
```

```text
Allow overlapping: False
Allow free atoms: False
Fragmentation result class: <class 'ugropy.core.frag_classes.gibbs_model.gibbs_result.GibbsFragmentationResult'>
Detection mol objects: {'CH3': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4040>, 'CH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f40b0>, 'CH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4120>, 'C': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4190>, 'CH2=CH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4200>, 'CH=CH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4270>, 'CH2=C': <rdkit.Chem.rdchem.Mol object at 0x7f25691f42e0>, 'CH=C': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4350>, 'ACH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f43c0>, 'AC': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4430>, 'ACCH3': <rdkit.Chem.rdchem.Mol object at 0x7f25691f44a0>, 'ACCH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4510>, 'ACCH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4580>, 'OH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f45f0>, 'CH3OH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4660>, 'H2O': <rdkit.Chem.rdchem.Mol object at 0x7f25691f46d0>, 'ACOH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4740>, 'CH3CO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f47b0>, 'CH2CO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4820>, 'HCO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4890>, 'CH3COO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4900>, 'CH2COO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4970>, 'HCOO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f49e0>, 'CH3O': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4a50>, 'CH2O': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4ac0>, 'CHO': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4b30>, 'THF': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4ba0>, 'CH3NH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4c10>, 'CH2NH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4c80>, 'CHNH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4cf0>, 'CH3NH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4d60>, 'CH2NH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4dd0>, 'CHNH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4e40>, 'CH3N': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4eb0>, 'CH2N': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4f20>, 'ACNH2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f4f90>, 'C5H5N': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5000>, 'C5H4N': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5070>, 'C5H3N': <rdkit.Chem.rdchem.Mol object at 0x7f25691f50e0>, 'CH3CN': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5150>, 'CH2CN': <rdkit.Chem.rdchem.Mol object at 0x7f25691f51c0>, 'COOH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5230>, 'HCOOH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f52a0>, 'CH2CL': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5310>, 'CHCL': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5380>, 'CCL': <rdkit.Chem.rdchem.Mol object at 0x7f25691f53f0>, 'CH2CL2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5460>, 'CHCL2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f54d0>, 'CCL2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5540>, 'CHCL3': <rdkit.Chem.rdchem.Mol object at 0x7f25691f55b0>, 'CCL3': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5620>, 'CCL4': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5690>, 'ACCL': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5700>, 'CH3NO2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5770>, 'CH2NO2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f57e0>, 'CHNO2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5850>, 'ACNO2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f58c0>, 'CS2': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5930>, 'CH3SH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f59a0>, 'CH2SH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5a10>, 'FURFURAL': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5a80>, 'DOH': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5af0>, 'I': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5b60>, 'BR': <rdkit.Chem.rdchem.Mol object at 0x7f25691f5bd0>}
```