diff --git a/docs/source/tutorial/easy_way.ipynb b/docs/source/tutorial/easy_way.ipynb index c4f490d..9249992 100644 --- a/docs/source/tutorial/easy_way.ipynb +++ b/docs/source/tutorial/easy_way.ipynb @@ -7,11 +7,11 @@ "### The easy way\n", "\n", "#### The Groups class\n", - "`ugropy` is kind of easy to use, but let's see what's has to offer.\n", - "Now let's start with the easy ways...\n", + "`ugropy` is relatively straightforward to use, but let's explore what it has to \n", + "offer. Now, let's start with the easy methods...\n", "\n", - "Let's use the `Groups` class to obtain the subgroups of all\n", - "the models supported by `ugropy`." + "We'll utilize the Groups class to retrieve the subgroups of all the models \n", + "supported by `ugropy`." ] }, { @@ -42,13 +42,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Well, that was easy... `ugropy` uses\n", - "`PubChemPy` (https://github.com/mcs07/PubChemPy) to access to pubchem and\n", - "obtain the SMILES representation of the molecule. ugropy uses the SMILES\n", - "representation and the `rdkit` (https://github.com/rdkit/rdkit) library to\n", - "obtain the functional groups of the molecules.\n", + "Well, that was easy... `ugropy` utilizes `PubChemPy` \n", + "([link](https://github.com/mcs07/PubChemPy)) to access `PubChem` and \n", + "retrieve the SMILES representation of the molecule. `ugropy` then employs the \n", + "SMILES representation along with the `rdkit` \n", + "([link](https://github.com/rdkit/rdkit)) library to identify the \n", + "functional groups of the molecules.\n", "\n", - "The complete signature of the `Groups` class is the following:" + "The complete signature of the Groups class is as follows:" ] }, { @@ -108,9 +109,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "If you are familiar with the `rdkit` library you will now that is a tone of\n", - "way to define a molecule (eg. SMILES, SMARTS, pdb file, InChIKey, etc). \n", - "`ugropy` supports that you provide a Mol object from the `rdkit` library." + "If you are familiar with the `rdkit` library, you'll know that there are\n", + "numerous ways to define a molecule (e.g., SMILES, SMARTS, PDB file, InChIKey,\n", + "etc.). `ugropy` supports the provision of a Mol object from the `rdkit`\n", + "library." ] }, { @@ -181,14 +183,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You may notice that the joback attribute is and object. That's because \n", - "is an Joback object, inside has all the properties that the Joback model can\n", - "estimate. This will be discoused later in the Joback tutorial, but an example:" + "You may notice that the joback attribute is an object. That's because it's a\n", + "Joback object, which contains all the properties that the Joback model can\n", + "estimate. This will be discussed later in the Joback tutorial. As an example:" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -197,7 +199,7 @@ "516.47" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -210,22 +212,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Finally, the normal_boiling_temperature, if provided, parameter is used in the\n", - "Joback properties calculations instead of the Joback estimated normal boiling\n", - "temperature (see Joback tutorial)." + "Finally, if the normal_boiling_temperature parameter is provided, it is used in\n", + "the Joback properties calculations instead of the Joback-estimated normal\n", + "boiling temperature (refer to the Joback tutorial)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The full documentation of the `Groups` class may be accessed by here.\n", - "Or you can do..." + "The full documentation of the `Groups` class may be accessed in the API\n", + "documentation. Or you can do..." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -285,38 +287,6 @@ "Groups?" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If you are in an interactive environment you can do this cool thing thank to\n", - "`rdkit`." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from rdkit.Chem import Draw\n", - "\n", - "Draw.MolToImage(carvone.chem_object)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -351,7 +321,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/docs/source/tutorial/hard_way.ipynb b/docs/source/tutorial/hard_way.ipynb index 965eee0..66c68d5 100644 --- a/docs/source/tutorial/hard_way.ipynb +++ b/docs/source/tutorial/hard_way.ipynb @@ -81,10 +81,12 @@ "source": [ "#### Joback\n", "\n", - "For context, check the Joback's article: https://doi.org/10.1080/00986448708960487\n", + "For context, check the Joback's article:\n", + "https://doi.org/10.1080/00986448708960487\n", "\n", - "The Joback object is instantiated by the Group object as we saw in the previous \n", - "tutorial but, a Joback object can be instantiated individually:" + "The Joback object is instantiated by the Group object, as we saw in the\n", + "previous tutorial. However, a Joback object can also be instantiated\n", + "individually:" ] }, { @@ -115,8 +117,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As a `Groups` object, `Joback` object's signature is (as in the `Groups` class\n", - "you can use \"name\", \"smiles\" or \"mol\" as identifier type):" + "As with a `Groups` object, the signature of a `Joback` object is as follows\n", + "(similarly, in the `Groups` class, you can use \"name,\" \"smiles,\" or \"mol\" as\n", + "the identifier type):" ] }, { @@ -136,14 +139,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The normal_boiling_temperature, if provided, parameter is used in the\n", - "Joback properties calculations instead of the Joback estimated normal boiling\n", - "temperature. Let's see an example from the original Joback's article:" + "The normal_boiling_temperature parameter, if provided, is used in the Joback\n", + "properties calculations instead of the Joback-estimated normal boiling\n", + "temperature. Let's examine an example from the original Joback article:" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -166,14 +169,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The critical temperature requires the normal boiling point to be estimated.\n", - "Joback recommends that if the experimental value of the normal boiling point\n", - "is known, it must be used instead of the estimated value." + "The critical temperature necessitates the estimation of the normal boiling\n", + "point. Joback recommends that if the experimental value of the normal boiling\n", + "point is known, it should be used instead of the estimated value." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -198,16 +201,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The experimental value of the critical temperature of p-dichlorobenzene is\n", - "685 K. In this example the error is not so big but Joback warns that the errors\n", - "could be important in other cases.\n", + "The experimental value of the critical temperature for p-dichlorobenzene is 685\n", + "K. In this example, the error is not significant, but Joback warns that errors\n", + "could be more significant in other cases.\n", "\n", - "Check the full Joback object documentation for units and more explanation:" + "Refer to the full documentation of the Joback object for information on units\n", + "and further explanation." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -277,16 +281,6 @@ "vapor_pressure_params : dict\n", " Vapor pressure G and k parameters for the Riedel-Plank-Miller [2]\n", " equation [bar].\n", - "\n", - "Bibliography\n", - "------------\n", - "[1] Joback, K. G., & Reid, R. C. (1987). ESTIMATION OF PURE-COMPONENT\n", - "PROPERTIES FROM GROUP-CONTRIBUTIONS. Chemical Engineering Communications,\n", - "57(1–6), 233–243. https://doi.org/10.1080/00986448708960487\n", - "\n", - "[2] Joback, K. G. (1989). Designing molecules possessing desired physical\n", - "property values [Thesis (Ph. D.), Massachusetts Institute of Technology].\n", - "https://dspace.mit.edu/handle/1721.1/14191\n", "\u001b[0;31mFile:\u001b[0m ~/code/ugropy/ugropy/joback.py\n", "\u001b[0;31mType:\u001b[0m type\n", "\u001b[0;31mSubclasses:\u001b[0m " @@ -314,7 +308,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/docs/source/tutorial/ugropy_failing.ipynb b/docs/source/tutorial/ugropy_failing.ipynb index 6b16f29..04e42d6 100644 --- a/docs/source/tutorial/ugropy_failing.ipynb +++ b/docs/source/tutorial/ugropy_failing.ipynb @@ -6,13 +6,13 @@ "source": [ "### Failing\n", "\n", - "ugropy may fail obtaining the subgroups of a molecule for a certain model. This\n", - "can be due two reasons: a bug or the molecule can't be represented by the \n", - "subgroups of the failing method.\n", + "ugropy may fail to obtain the subgroups of a molecule for a certain model for\n", + "two reasons: either there is a bug, or the molecule cannot be represented by\n", + "the subgroups of the failing model.\n", "\n", - "ugropy uses SMARTS for the functional groups representation to \"ask\" to the \n", - "molecule if it has those structures. Let's check the functional group list for\n", - "the classic liquid-vapor UNIFAC model." + "ugropy utilizes SMARTS for the representation of functional groups to inquire\n", + "whether the molecule contains those structures. Let's examine the functional\n", + "group list for the classic liquid-vapor UNIFAC model." ] }, { @@ -317,26 +317,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The library \"fails\" to obtain the any functional groups to represent correctly\n", - "the molecule. This fail is represented by an empty dictionary. In this case the\n", - "\"fail\" it's intended, but it could fail by an error in the groups in the SMARTS\n", - "representations or the algorithm and the result will be also an empty \n", - "dictionary. At the moment the supported models are tested against these numbers\n", - "of molecules:\n", + "The library \"fails\" to obtain any functional groups to accurately represent the\n", + "molecule. This failure is represented by an empty dictionary. In this case, the\n", + "\"fail\" is intentional, but it could fail due to errors in the groups SMARTS\n", + "representations or the algorithm, resulting in an empty dictionary as well.\n", + "Currently, the supported models are tested against the following numbers of\n", + "molecules:\n", "\n", "- Classic liquid-vapor UNIFAC: 406\n", "- Predictive Soave-Redlich-Kwong (PSRK): 440\n", "- Joback: 285\n", "\n", - "If you find a failing representation you can check the structure of the \n", - "molecule, the list of functional groups of the failing model and, if you find\n", - "that the molecule can be modeled you found a bug. Feel free to leave an issue\n", - "with that information on the repository.\n", + "If you encounter a failing representation, you can examine the structure of the\n", + "molecule and the list of functional groups of the failing model. If you\n", + "determine that the molecule can indeed be modeled, you may have discovered a\n", + "bug. Feel free to report the issue on the repository along with this\n", + "information.\n", "\n", "#### More than one solution\n", - "Models like UNIFAC or PSRK can have multiple solutions to represent a molecule\n", - "and ugropy tries its best to find them all. In that case you will have in\n", - "a list of dictionaries containing each solution found. Let's check it out." + "Models like UNIFAC or PSRK can have multiple solutions to represent a molecule,\n", + "and ugropy tries its best to find them all. In such cases, you will receive a\n", + "list of dictionaries, each containing one of the solutions found. Let's take a\n", + "look." ] }, { @@ -371,10 +373,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This molecule can be modeled in two ways depending on what we do with the CH2\n", - "bounded to the ring and the ester carbon (highlighted in red), we can form an\n", - "ACCH2 group and model the ester group with COO, or we can use an AC group and\n", - "model the ester group with CH2COO." + "This molecule can be modeled in two ways depending on how we treat the CH2\n", + "attached to the ring and the ester carbon (highlighted in red). We can either\n", + "form an ACCH2 group and model the ester group with COO, or we can use an AC\n", + "group and model the ester group with CH2COO." ] }, { @@ -406,9 +408,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This could be useful in cases were some group has more interaction parameters\n", - "than other in the mixture that you want to model with UNIFAC. Or maybe you can\n", - "try both and check if there are differences." + "This could be useful in cases where some groups have more interaction\n", + "parameters than others in the mixture that you want to model with UNIFAC.\n", + "Alternatively, you can try both approaches and compare if there are any\n", + "differences." ] } ], diff --git a/docs/source/tutorial/writers.ipynb b/docs/source/tutorial/writers.ipynb index 368e376..fea6848 100644 --- a/docs/source/tutorial/writers.ipynb +++ b/docs/source/tutorial/writers.ipynb @@ -7,10 +7,10 @@ "### Writers\n", "\n", "#### Clapeyron\n", - "ugropy provides a writers module to build the input files of different \n", - "thermodynamic libraries. For now, the only library supported is Clapeyron.jl\n", + "ugropy provides a writers module for constructing input files for various\n", + "thermodynamic libraries. Currently, the only supported library is Clapeyron.jl.\n", "\n", - "To use this function you must:" + "To utilize this function, you must import the module as follows:" ] }, { @@ -26,11 +26,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "You must provide a list of dictionaries for the functional groups of UNIFAC and\n", - "PSRK where each dictionary contains the functional groups of the molecules.\n", + "To utilize the function, you need to provide a list of dictionaries for the\n", + "functional groups of UNIFAC and PSRK, where each dictionary contains the\n", + "functional groups of the molecules.\n", "\n", - "If the user desire to write critical properties .csv files, the user must \n", - "provide a list of Joback objects. Let's do it with a simple example:" + "If the user wishes to write critical properties .csv files, they must provide a\n", + "list of Joback objects. Let's illustrate this with a simple example:" ] }, { @@ -59,21 +60,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In the example we create Groups object to obtain all the information of all\n", - "the molecules. Then we use list comprehension to create the lists for the\n", - "to_clapeyron function.\n", + "In the example provided, we create a Groups object to obtain all the\n", + "information of the molecules. Then, we use list comprehension to create the\n", + "lists for the to_clapeyron function.\n", "\n", - "The molecules_name argument receives in this case the names used to create the\n", - "Groups objects, but could be different if you desire. This names will be set\n", - "as the molecules names in the .csv files.\n", + "The molecules_name argument in this case receives the names used to create the\n", + "Groups objects, but it can be different if desired. These names will be set as\n", + "the molecule names in the .csv files.\n", "\n", - "You can omit some arguments if you desire:\n", + "You can omit certain arguments if desired:\n", "\n", - "If you omit the psrk_groups argument: the PSRK_groups.csv will not be created.\n", - "\n", - "If you omit the unifac_groups argument: the ogUNIFAC_groups.csv will not be created.\n", - "\n", - "If you omit the joback_objects argument: the critical.csv will not be created." + "- If you omit the psrk_groups argument: the PSRK_groups.csv file will not be created.\n", + "- If you omit the unifac_groups argument: the ogUNIFAC_groups.csv file will not be created.\n", + "- If you omit the joback_objects argument: the critical.csv file will not be created." ] } ],