Repository: uncscode/particula

Issue:
particle class notebook + doc
For the upcoming release, we should improve the particle class notebook and documentation so that is a template for our work going forward: 
- [x] improve the docs for Particle Class
- [x] add docstrings (or open issues thereof) as necessary

In particular, we should pay close attention to how the docstrings would appear in a help call, e.g. see this: 

```python
help(particle)
```

```
Help on module particula.aerosol_dynamics.particle in particula.aerosol_dynamics:

NAME
    particula.aerosol_dynamics.particle - Class for creating particles.

CLASSES
    builtins.object
        Particle
    
    class Particle(builtins.object)
     |  Particle(name: str, radius, density, charge)
     |  
     |  Class for creating particles:
     |  Framework for particle--particle and gas--particle interactions.
     |  
     |  Attributes:
     |      name    (str)   [no units]
     |      radius  (float) [m]
     |      density (float) [kg/m**3]
     |      charge  (int)   [dimensionless]
     |      mass    (float) [kg]
     |  
     |  Methods defined here:
     |  
     |  __init__(self, name: str, radius, density, charge)
     |      Constructs the particle object.
     |      
     |      Parameters:
     |          name    (str)   [no units]
     |          radius  (float) [m]
     |          density (float) [kg/m**3]
     |          charge  (int)   [dimensionless]
     |  
     |  charge(self) -> int
     |      Returns charge of particle.
     |      Checks units: [dimensionless]
     |  
     |  collision_kernel_continuum_limit(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Continuum limit of collision kernel.
     |      Checks units: [dimensionless]
     |  
     |  collision_kernel_kinetic_limit(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Kinetic limit of collision kernel.
     |      Checks units: [dimensionless]
     |  
     |  coulomb_enhancement_continuum_limit(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Continuum limit of Coulomb enhancement for particle--particle coagulation.
     |      Checks units: [dimensionless]
     |  
     |  coulomb_enhancement_kinetic_limit(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Kinetic limit of Coulomb enhancement for particle--particle cooagulation.
     |      Checks units: [dimensionless]
     |  
     |  coulomb_potential_ratio(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Calculates the Coulomb potential ratio.
     |      Checks units: [dimensionless]
     |  
     |  density(self) -> int
     |      Returns density of particle.
     |      Checks units: [kg/m**3]
     |  
     |  diffusive_knudsen_number(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Diffusive Knudsen number.
     |      Checks units: [dimensionless]
     |      
     |      The *diffusive* Knudsen number is different from Knudsen number.
     |      Ratio of:
     |          - numerator: mean persistence of one particle
     |          - denominator: effective length scale of
     |              particle--particle Coulombic interaction
     |  
     |  dimensionless_coagulation_kernel_hard_sphere(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Dimensionless particle--particle coagulation kernel.
     |      Checks units: [dimensionless]
     |  
     |  friction_factor(self, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Returns a particle's friction factor.
     |      Checks units: [N*s/m]
     |      
     |      Property of the particle's size and surrounding medium.
     |      Multiplying the friction factor by the fluid velocity
     |      yields the drag force on the particle.
     |  
     |  knudsen_number(self, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Returns particle's Knudsen number.
     |      Checks units: [dimensionless]
     |      
     |      The Knudsen number reflects the relative length scales of
     |      the particle and the suspending fluid (air, water, etc.).
     |      This is calculated by the mean free path of the medium
     |      divided by the particle radius.
     |  
     |  mass(self) -> float
     |      Returns mass of particle.
     |      Checks units: [kg]
     |  
     |  name(self) -> str
     |      Returns the name of particle.
     |  
     |  radius(self) -> float
     |      Returns radius of particle.
     |      Checks units: [m]
     |  
     |  reduced_friction_factor(self, other, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Returns the reduced friction factor between two particles.
     |      Checks units: [N*s/m]
     |      
     |      Similar to the reduced mass.
     |      The reduced friction factor allows a two-body problem
     |      to be solved as a one-body problem.
     |  
     |  reduced_mass(self, other) -> float
     |      Returns the reduced mass of two particles.
     |      Checks units: [kg]
     |      
     |      The reduced mass is an "effective inertial" mass.
     |      Allows a two-body problem to be solved as a one-body problem.
     |  
     |  slip_correction_factor(self, environment: particula.aerosol_dynamics.environment.Environment) -> float
     |      Returns particle's Cunningham slip correction factor.
     |      Checks units: [dimensionless]
     |      
     |      Dimensionless quantity accounting for non-continuum effects
     |      on small particles. It is a deviation from Stokes' Law.
     |      Stokes assumes a no-slip condition that is not correct at
     |      high Knudsen numbers. The slip correction factor is used to
     |      calculate the friction factor.
     |      
     |      See Eq 9.34 in Atmos. Chem. & Phys. (2016) for more informatiom.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)

DATA
    u = <pint.registry.UnitRegistry object>

FILE
    /opt/hostedtoolcache/Python/3.7.12/x64/lib/python3.7/site-packages/particula/aerosol_dynamics/particle.py
```

Discussion:
ngam: because of holiday times and doc-heavy nature of this, bypassing regular review process. 

Patch:
diff --git a/docs/001_ParticleClass.ipynb b/docs/001_ParticleClass.ipynb
index 2e15a328f..dca96ae03 100644
--- a/docs/001_ParticleClass.ipynb
+++ b/docs/001_ParticleClass.ipynb
@@ -1,37 +1,22 @@
 {
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "name": "Untitled21.ipynb",
-      "provenance": []
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
   "cells": [
     {
       "cell_type": "markdown",
-      "source": [
-        "## Startup"
-      ],
       "metadata": {
         "id": "mYSYN2FTC7JX"
-      }
+      },
+      "source": [
+        "## Startup"
+      ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "First, install `particula` from PyPI using `!pip install -U particula` or `%pip install -U particula`. In this, the `!` or `%` are so-called magic signs prefixing \"magic functions\". In this case, the magic function is `%pip` --- which is one way to install Python packages from the PyPI (the Python Package Index). The `-U` is to instruct `pip` to update particula to the latest version."
-      ],
       "metadata": {
         "id": "B9ip8rJNBgZF"
-      }
+      },
+      "source": [
+        "First, install `particula` from PyPI using `!pip install -U particula` or `%pip install -U particula`. In this, the `!` or `%` are so-called magic signs prefixing \"magic functions\". In this case, the magic function is `%pip` --- which is one way to install Python packages from the PyPI (the Python Package Index). The `-U` is to instruct `pip` to update particula to the latest version."
+      ]
     },
     {
       "cell_type": "code",
@@ -45,8 +30,8 @@
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Requirement already satisfied: particula in /usr/local/lib/python3.7/dist-packages (0.0.2)\n",
             "Requirement already satisfied: python-version>=\"3.7\" in /usr/local/lib/python3.7/dist-packages (from particula) (0.0.2)\n",
@@ -66,29 +51,27 @@
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "After installing `particula`, we can import it into our workspace with `import particula`. Let's check the version with `.__version__` and let's call `help` on the overall package to see what we have. "
-      ],
       "metadata": {
         "id": "EoTypuRQCsfA"
-      }
+      },
+      "source": [
+        "After installing `particula`, we can import it into our workspace with `import particula`. Let's check the version with `.__version__` and let's call `help` on the overall package to see what we have. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "import particula"
-      ],
+      "execution_count": 2,
       "metadata": {
         "id": "U5UTLkYi-R_2"
       },
-      "execution_count": 2,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "import particula"
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particula.__version__"
-      ],
+      "execution_count": 3,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -97,10 +80,8 @@
         "id": "7wnlcZmb-YVJ",
         "outputId": "fc1ecc6b-3c57-4563-b7a5-442436840e52"
       },
-      "execution_count": 3,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
             "application/vnd.google.colaboratory.intrinsic+json": {
               "type": "string"
@@ -109,16 +90,18 @@
               "'0.0.2'"
             ]
           },
+          "execution_count": 3,
           "metadata": {},
-          "execution_count": 3
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particula.__version__"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "help(particula)"
-      ],
+      "execution_count": 4,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -126,11 +109,10 @@
         "id": "4wp25bbh-bw5",
         "outputId": "b5b1eaaf-e211-4932-b31c-d0c7dcf35faf"
       },
-      "execution_count": 4,
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Help on package particula:\n",
             "\n",
@@ -149,28 +131,34 @@
             "\n"
           ]
         }
+      ],
+      "source": [
+        "help(particula)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "The above two code cells show that we have the prerelease version `0.0.2` (our latest as of writing this). We still are in the process of writing more thorough documentation, and so a help call on `particula` yields a shout --- maybe a shout for help? `PARTICULA!` However, we get a hint about what else is inside this package, `aerosol_dynamics` package/module. We will check this now."
-      ],
       "metadata": {
         "id": "wXPNsoC7DFmv"
-      }
+      },
+      "source": [
+        "The above two code cells show that we have the prerelease version `0.0.2` (our latest as of writing this). We still are in the process of writing more thorough documentation, and so a help call on `particula` yields a shout --- maybe a shout for help? `PARTICULA!` However, we get a hint about what else is inside this package, `aerosol_dynamics` package/module. We will check this now."
+      ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "## A peek into `aerosol_dynamics`"
-      ],
       "metadata": {
         "id": "zrNnQDp0C-N2"
-      }
+      },
+      "source": [
+        "## A peek into `aerosol_dynamics`"
+      ]
     },
     {
       "cell_type": "markdown",
+      "metadata": {
+        "id": "podJg5bWEg0Q"
+      },
       "source": [
         "We can import `aerosol_dynamics` either via \n",
         "\n",
@@ -185,27 +173,22 @@
         "```\n",
         "\n",
         "to check it out. We will call help again to see what we have. "
-      ],
-      "metadata": {
-        "id": "podJg5bWEg0Q"
-      }
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "from particula import aerosol_dynamics"
-      ],
+      "execution_count": 5,
       "metadata": {
         "id": "wAAzjh6A-hVN"
       },
-      "execution_count": 5,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "from particula import aerosol_dynamics"
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "help(aerosol_dynamics)"
-      ],
+      "execution_count": 6,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -213,11 +196,10 @@
         "id": "8QtMsgOz-uvK",
         "outputId": "6c9943c1-221b-476d-e68a-811e8038bf7d"
       },
-      "execution_count": 6,
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Help on package particula.aerosol_dynamics in particula:\n",
             "\n",
@@ -245,33 +227,34 @@
             "\n"
           ]
         }
+      ],
+      "source": [
+        "help(aerosol_dynamics)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Now! We have some package contents that look promising. We will only check out `particle` in this case. Again, import it and call help on it."
-      ],
       "metadata": {
         "id": "K7twy8pqE7-S"
-      }
+      },
+      "source": [
+        "Now! We have some package contents that look promising. We will only check out `particle` in this case. Again, import it and call help on it."
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "from particula.aerosol_dynamics import particle"
-      ],
+      "execution_count": 7,
       "metadata": {
         "id": "G8u_QMMT-sfx"
       },
-      "execution_count": 7,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "from particula.aerosol_dynamics import particle"
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "help(particle)"
-      ],
+      "execution_count": 8,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/"
@@ -279,11 +262,10 @@
         "id": "1_yFPZr9--_L",
         "outputId": "d1d6c776-e67f-4267-f558-41a06cc6f2a1"
       },
-      "execution_count": 8,
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Help on module particula.aerosol_dynamics.particle in particula.aerosol_dynamics:\n",
             "\n",
@@ -433,64 +415,65 @@
             "\n"
           ]
         }
+      ],
+      "source": [
+        "help(particle)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "We see there is more documentation now. The `help` call lists a \"class\" called \"Particle\" and all its available \"methods\" (read: functions) alphabetically. For now, you can think of a class as a super-function (it is more than that). Note also, that classes follow `CamelCase` (hence, `Particle`) whereas methods/functions follow snake_case (hence, `reduced_mass`). We make a lot of use of unit registry (called `u`) to ensure all our calculations have proper units, even if dimensionless. Without further ado, let's look at an example."
-      ],
       "metadata": {
         "id": "3-mgI7yBFegi"
-      }
+      },
+      "source": [
+        "We see there is more documentation now. The `help` call lists a \"class\" called \"Particle\" and all its available \"methods\" (read: functions) alphabetically. For now, you can think of a class as a super-function (it is more than that). Note also, that classes follow `CamelCase` (hence, `Particle`) whereas methods/functions follow snake_case (hence, `reduced_mass`). We make a lot of use of unit registry (called `u`) to ensure all our calculations have proper units, even if dimensionless. Without further ado, let's look at an example."
+      ]
     },
     {
       "cell_type": "markdown",
+      "metadata": {
+        "id": "B-dwE5_tGYpv"
+      },
       "source": [
         "## An example... \n",
         "\n",
-        "... to calculate the dimensionless coagulation rate. Let's define to particles, `particla_a` and `particle_b`."
-      ],
-      "metadata": {
-        "id": "B-dwE5_tGYpv"
-      }
+        "... to calculate the dimensionless coagulation rate. Let's define to particles, `particle_a` and `particle_b`."
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a = particle.Particle(name='a', radius=1e-9, density=1e3, charge=0)"
-      ],
+      "execution_count": 9,
       "metadata": {
         "id": "2u7Lo1wb_Adx"
       },
-      "execution_count": 9,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "particle_a = particle.Particle(name='a', radius=1e-9, density=1e3, charge=0)"
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_b = particle.Particle(name='b', radius=2e-9, density=1e3, charge=0)"
-      ],
+      "execution_count": 10,
       "metadata": {
         "id": "2jpUw274_ZA5"
       },
-      "execution_count": 10,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "particle_b = particle.Particle(name='b', radius=2e-9, density=1e3, charge=0)"
+      ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Then, if we call the `radius` method of particle_a (as suffix), we get its radius printed with a unit. Alternatively, we can call the `radius` method from the class itself, not prefixed to a certain particle (same result)."
-      ],
       "metadata": {
         "id": "qeje43ycGo93"
-      }
+      },
+      "source": [
+        "Then, if we call the `radius` method of particle_a (as suffix), we get its radius printed with a unit. Alternatively, we can call the `radius` method from the class itself, not prefixed to a certain particle (same result)."
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.radius()"
-      ],
+      "execution_count": 11,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -499,29 +482,31 @@
         "id": "FMms9WdJ_Sca",
         "outputId": "afa8ba50-5f00-4f98-d086-4d0506761fd5"
       },
-      "execution_count": 11,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$1\\times 10^{-9}\\ \\mathrm{meter}$",
             "text/html": [
               "1×10<sup>-9</sup> meter"
             ],
+            "text/latex": [
+              "$1\\times 10^{-9}\\ \\mathrm{meter}$"
+            ],
             "text/plain": [
               "1e-09 meter"
             ]
           },
+          "execution_count": 11,
           "metadata": {},
-          "execution_count": 11
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.radius()"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle.Particle.radius(particle_a)"
-      ],
+      "execution_count": 12,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -530,38 +515,40 @@
         "id": "zDPQ1em5G6kK",
         "outputId": "d0007e92-46c1-4d8d-ee48-d5b47517a009"
       },
-      "execution_count": 12,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$1\\times 10^{-9}\\ \\mathrm{meter}$",
             "text/html": [
               "1×10<sup>-9</sup> meter"
             ],
+            "text/latex": [
+              "$1\\times 10^{-9}\\ \\mathrm{meter}$"
+            ],
             "text/plain": [
               "1e-09 meter"
             ]
           },
+          "execution_count": 12,
           "metadata": {},
-          "execution_count": 12
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle.Particle.radius(particle_a)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Same for the `mass` and `charge` methods. Note `charge` here is the number of charges. "
-      ],
       "metadata": {
         "id": "tQl8XvpLHBTk"
-      }
+      },
+      "source": [
+        "Same for the `mass` and `charge` methods. Note `charge` here is the number of charges. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_b.mass()"
-      ],
+      "execution_count": 13,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -570,29 +557,31 @@
         "id": "JLlT1gix_uCf",
         "outputId": "27dfd306-e700-4620-c72b-6339e12527b3"
       },
-      "execution_count": 13,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$3.3510321638291136\\times 10^{-23}\\ \\mathrm{kilogram}$",
             "text/html": [
               "3.3510321638291136×10<sup>-23</sup> kilogram"
             ],
+            "text/latex": [
+              "$3.3510321638291136\\times 10^{-23}\\ \\mathrm{kilogram}$"
+            ],
             "text/plain": [
               "3.3510321638291136e-23 kilogram"
             ]
           },
+          "execution_count": 13,
           "metadata": {},
-          "execution_count": 13
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_b.mass()"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.charge()"
-      ],
+      "execution_count": 14,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -601,69 +590,71 @@
         "id": "LbymGF8g_wXp",
         "outputId": "aa6fb492-cac9-4ac1-e5a0-181c64ecdad6"
       },
-      "execution_count": 14,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$0\\ dimensionless$",
             "text/html": [
               "0 dimensionless"
             ],
+            "text/latex": [
+              "$0\\ dimensionless$"
+            ],
             "text/plain": [
               "0 dimensionless"
             ]
           },
+          "execution_count": 14,
           "metadata": {},
-          "execution_count": 14
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.charge()"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "We should also define the environment we are in. We will get that module and invoke with 300 K and $10^5$ Pa. "
-      ],
       "metadata": {
         "id": "Bjp_PcNpHJHa"
-      }
+      },
+      "source": [
+        "We should also define the environment we are in. We will get that module and invoke with 300 K and $10^5$ Pa. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "from particula.aerosol_dynamics import environment"
-      ],
+      "execution_count": 15,
       "metadata": {
         "id": "3QdNH5tY_Uwm"
       },
-      "execution_count": 15,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "from particula.aerosol_dynamics import environment"
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "std_environment = environment.Environment(temperature=300, pressure=1e5)"
-      ],
+      "execution_count": 16,
       "metadata": {
         "id": "akifp3gw_g9O"
       },
-      "execution_count": 16,
-      "outputs": []
+      "outputs": [],
+      "source": [
+        "std_environment = environment.Environment(temperature=300, pressure=1e5)"
+      ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Now, we can calculate the Knudsen number of particle \"a\" in this \"standard\" environment. And the slip correction factor. And the friction factor. "
-      ],
       "metadata": {
         "id": "UlzbZwXVHXhl"
-      }
+      },
+      "source": [
+        "Now, we can calculate the Knudsen number of particle \"a\" in this \"standard\" environment. And the slip correction factor. And the friction factor. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.knudsen_number(std_environment)"
-      ],
+      "execution_count": 17,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -672,29 +663,31 @@
         "id": "HAgIJr2T_qZg",
         "outputId": "74ceedb5-fa04-4f28-e100-59f30a3246f0"
       },
-      "execution_count": 17,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$67.8918099704083\\ dimensionless$",
             "text/html": [
               "67.8918099704083 dimensionless"
             ],
+            "text/latex": [
+              "$67.8918099704083\\ dimensionless$"
+            ],
             "text/plain": [
               "67.8918099704083 dimensionless"
             ]
           },
+          "execution_count": 17,
           "metadata": {},
-          "execution_count": 17
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.knudsen_number(std_environment)"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.slip_correction_factor(std_environment)"
-      ],
+      "execution_count": 18,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -703,29 +696,31 @@
         "id": "XSNrw_6ZARM3",
         "outputId": "aebcb5b2-5208-4997-aef7-dac0bcc558a5"
       },
-      "execution_count": 18,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$113.060274442495\\ dimensionless$",
             "text/html": [
               "113.060274442495 dimensionless"
             ],
+            "text/latex": [
+              "$113.060274442495\\ dimensionless$"
+            ],
             "text/plain": [
               "113.060274442495 dimensionless"
             ]
           },
+          "execution_count": 18,
           "metadata": {},
-          "execution_count": 18
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.slip_correction_factor(std_environment)"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.friction_factor(std_environment)"
-      ],
+      "execution_count": 19,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -734,38 +729,40 @@
         "id": "HK8bC6UBAVro",
         "outputId": "c7f32961-ce86-4d52-884a-bfdb0af7e73a"
       },
-      "execution_count": 19,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$3.0775355689697488\\times 10^{-15}\\ \\frac{\\mathrm{kilogram}}{\\mathrm{second}}$",
             "text/html": [
               "3.0775355689697488×10<sup>-15</sup> kilogram/second"
             ],
+            "text/latex": [
+              "$3.0775355689697488\\times 10^{-15}\\ \\frac{\\mathrm{kilogram}}{\\mathrm{second}}$"
+            ],
             "text/plain": [
               "3.0775355689697488e-15 kilogram/second"
             ]
           },
+          "execution_count": 19,
           "metadata": {},
-          "execution_count": 19
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.friction_factor(std_environment)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Now, let's calculate the reduced mass of two particles, \"a\" and \"b\". Again, there are two ways to do this: by suffixing the method to a particle or by calling the method from the class --- they yield the same result. "
-      ],
       "metadata": {
         "id": "6w_hMzlZHjWI"
-      }
+      },
+      "source": [
+        "Now, let's calculate the reduced mass of two particles, \"a\" and \"b\". Again, there are two ways to do this: by suffixing the method to a particle or by calling the method from the class --- they yield the same result. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.reduced_mass(particle_b)"
-      ],
+      "execution_count": 20,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -774,29 +771,31 @@
         "id": "_PKC3LnwAcQ-",
         "outputId": "ecbd4add-fc74-40a4-8bdc-3b1c57a1864c"
       },
-      "execution_count": 20,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$3.7233690709212374\\times 10^{-24}\\ \\mathrm{kilogram}$",
             "text/html": [
               "3.7233690709212374×10<sup>-24</sup> kilogram"
             ],
+            "text/latex": [
+              "$3.7233690709212374\\times 10^{-24}\\ \\mathrm{kilogram}$"
+            ],
             "text/plain": [
               "3.7233690709212374e-24 kilogram"
             ]
           },
+          "execution_count": 20,
           "metadata": {},
-          "execution_count": 20
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.reduced_mass(particle_b)"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle.Particle.reduced_mass(particle_a, particle_b)"
-      ],
+      "execution_count": 21,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -805,38 +804,40 @@
         "id": "5OcaX-MzAntA",
         "outputId": "e821eed8-dde3-4cec-e8f4-6294275315c6"
       },
-      "execution_count": 21,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$3.7233690709212374\\times 10^{-24}\\ \\mathrm{kilogram}$",
             "text/html": [
               "3.7233690709212374×10<sup>-24</sup> kilogram"
             ],
+            "text/latex": [
+              "$3.7233690709212374\\times 10^{-24}\\ \\mathrm{kilogram}$"
+            ],
             "text/plain": [
               "3.7233690709212374e-24 kilogram"
             ]
           },
+          "execution_count": 21,
           "metadata": {},
-          "execution_count": 21
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle.Particle.reduced_mass(particle_a, particle_b)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Like the reduced mass, we can also look at the reduced friction. "
-      ],
       "metadata": {
         "id": "CkRfw2aUHxJ4"
-      }
+      },
+      "source": [
+        "Like the reduced mass, we can also look at the reduced friction. "
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.reduced_friction_factor(particle_b, std_environment)"
-      ],
+      "execution_count": 22,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -845,40 +846,40 @@
         "id": "5k5DMlpXArBI",
         "outputId": "1e51e1f1-3b5f-41df-fae3-a24d6492c0c9"
       },
-      "execution_count": 22,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$2.4595460300833962\\times 10^{-15}\\ \\frac{\\mathrm{kilogram}}{\\mathrm{second}}$",
             "text/html": [
               "2.4595460300833962×10<sup>-15</sup> kilogram/second"
             ],
+            "text/latex": [
+              "$2.4595460300833962\\times 10^{-15}\\ \\frac{\\mathrm{kilogram}}{\\mathrm{second}}$"
+            ],
             "text/plain": [
               "2.4595460300833962e-15 kilogram/second"
             ]
           },
+          "execution_count": 22,
           "metadata": {},
-          "execution_count": 22
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.reduced_friction_factor(particle_b, std_environment)"
       ]
     },
     {
       "cell_type": "markdown",
-      "source": [
-        "Finally, we can calculate the coagulation rate coefficient between particles \"a\" and \"b\" in this environment. Note that we could have called this directly after defining \"a\" and \"b\"."
-      ],
       "metadata": {
         "id": "_fhngrQaH1dM"
-      }
+      },
+      "source": [
+        "Finally, we can calculate the coagulation rate coefficient between particles \"a\" and \"b\" in this environment. Note that we could have called this directly after defining \"a\" and \"b\"."
+      ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle.Particle.dimensionless_coagulation_kernel_hard_sphere(\n",
-        "    particle_a, particle_b, std_environment\n",
-        ")"
-      ],
+      "execution_count": 23,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -887,31 +888,33 @@
         "id": "BNtlCy0DBByx",
         "outputId": "24eee266-c8a4-418f-c8e6-e8de4e560ad3"
       },
-      "execution_count": 23,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$83.4628646051075\\ dimensionless$",
             "text/html": [
               "83.4628646051075 dimensionless"
             ],
+            "text/latex": [
+              "$83.4628646051075\\ dimensionless$"
+            ],
             "text/plain": [
               "83.4628646051075 dimensionless"
             ]
           },
+          "execution_count": 23,
           "metadata": {},
-          "execution_count": 23
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle.Particle.dimensionless_coagulation_kernel_hard_sphere(\n",
+        "    particle_a, particle_b, std_environment\n",
+        ")"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        "particle_a.dimensionless_coagulation_kernel_hard_sphere(\n",
-        "    particle_b, std_environment\n",
-        ")"
-      ],
+      "execution_count": 24,
       "metadata": {
         "colab": {
           "base_uri": "https://localhost:8080/",
@@ -920,34 +923,53 @@
         "id": "k1Ku87U5IdgE",
         "outputId": "370f69da-5fdd-407e-bae9-b80402fd9a3d"
       },
-      "execution_count": 24,
       "outputs": [
         {
-          "output_type": "execute_result",
           "data": {
-            "text/latex": "$83.4628646051075\\ dimensionless$",
             "text/html": [
               "83.4628646051075 dimensionless"
             ],
+            "text/latex": [
+              "$83.4628646051075\\ dimensionless$"
+            ],
             "text/plain": [
               "83.4628646051075 dimensionless"
             ]
           },
+          "execution_count": 24,
           "metadata": {},
-          "execution_count": 24
+          "output_type": "execute_result"
         }
+      ],
+      "source": [
+        "particle_a.dimensionless_coagulation_kernel_hard_sphere(\n",
+        "    particle_b, std_environment\n",
+        ")"
       ]
     },
     {
       "cell_type": "code",
-      "source": [
-        ""
-      ],
+      "execution_count": 24,
       "metadata": {
         "id": "1rsNCSSEIhM8"
       },
-      "execution_count": 24,
-      "outputs": []
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "name": "Untitled21.ipynb",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
     }
-  ]
-}
\ No newline at end of file
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/particula/__init__.py b/particula/__init__.py
index 71537e766..860a42cb4 100644
--- a/particula/__init__.py
+++ b/particula/__init__.py
@@ -1,5 +1,22 @@
+""" a simple, fast, and powerful particle simulator.
+
+    particula is a simple, fast, and powerful particle simulator,
+    or at least two of the three, we hope. It is a simple particle
+    system that is designed to be easy to use and easy to extend.
+    The goal is to have a robust aerosol (gas phase + particle phase)
+    simulation system that can be used to answer scientific questions
+    that arise for experiments and research discussions.
+
+    The main features of particula are:
+    ...
+
+    More details to follow.
 """
-PARTICULA!
-"""
+
+# Import pint here to avoid using a different registry in each module.
+from pint import UnitRegistry
+
+# u is the unit registry name.
+u = UnitRegistry()
 
 __version__ = '0.0.2'
diff --git a/particula/aerosol_dynamics/__init__.py b/particula/aerosol_dynamics/__init__.py
index 8c9d8cba2..b53405df0 100644
--- a/particula/aerosol_dynamics/__init__.py
+++ b/particula/aerosol_dynamics/__init__.py
@@ -1,14 +1,13 @@
-"""
-This is the aerosol_dynamics module.
-
-It can do the following:
+""" module to perform calculations related to aerosol dynamics.
 
-"""
+    This module contains functions to perform calculations related
+    to aerosol dynamics. It inherits the unit registry, u, from
+    particula. The pacakge contents below are callablle. For example,
+    the particle module is callable as:
 
-# Import pint here
-# to avoid creating a different registry
-# in each module.
+    >>> from particula.aerosol_dynamics import particle
 
-from pint import UnitRegistry
+    ...
 
-u = UnitRegistry()
+    More details to follow.
+"""
diff --git a/particula/aerosol_dynamics/environment.py b/particula/aerosol_dynamics/environment.py
index 64d0cd1b3..cd4bc325c 100644
--- a/particula/aerosol_dynamics/environment.py
+++ b/particula/aerosol_dynamics/environment.py
@@ -1,13 +1,10 @@
-"""
-Environment Class
+"""environment class
 """
 
 import numpy as np
-
+from particula import u
 from particula.aerosol_dynamics import physical_parameters as pp
 
-from particula.aerosol_dynamics import u
-
 
 class Environment:
     """
diff --git a/particula/aerosol_dynamics/parcel.py b/particula/aerosol_dynamics/parcel.py
index fa7b3a742..edd1f2bf5 100644
--- a/particula/aerosol_dynamics/parcel.py
+++ b/particula/aerosol_dynamics/parcel.py
@@ -1,8 +1,9 @@
+"""class for creating a air parcel to put particles and gases in.
 """
-Class for creating a air parcel to put particles and gases in.
-"""
+
 import numpy as np
-from particula.aerosol_dynamics import particle, u
+from particula import u
+from particula.aerosol_dynamics import particle
 
 
 class Parcel:
diff --git a/particula/aerosol_dynamics/particle.py b/particula/aerosol_dynamics/particle.py
index efb77bd1e..6278c52cc 100644
--- a/particula/aerosol_dynamics/particle.py
+++ b/particula/aerosol_dynamics/particle.py
@@ -1,21 +1,45 @@
-"""
-Class for creating particles.
+""" to instantiate particles and calculate their properties.
+
+    This module contains the Particle class, which is used to
+    instantiate the particles and calculate their properties.
+    Particles are introduced and defined by calling Particle
+    class, for example:
+
+    >>> from particula import Particle
+    >>> p1 = Particle(name='my_particle', radius=1e-9, density=1e3, charge=1)
+
+    Then, it is possible to return the properties of the particle p1:
+
+    >>> p1.mass()
+
+    The environment is defined by the following parameters:
+    >>> from particula.aerosol_dynamics import environment
+    >>> env = environment.Environment(temperature=300, pressure=1e5)
+
+    If another particle is introduced, it is possible to calculate
+    the binary coagulation coefficient:
+
+    >>> p2 = Particle(name='my_particle2', radius=1e-9, density=1e3, charge=1)
+    >>> p1.dimensioned_coagulation_kernel(p2, env)
+
+    For more details, see below. More information to follow.
 """
 
 import numpy as np
-
+from particula import u
 from particula.aerosol_dynamics import physical_parameters as pp
 from particula.aerosol_dynamics.environment import Environment
 
-from particula.aerosol_dynamics import u
-
 
 class Particle:
-    """
-    Class for creating particles:
-    Framework for particle--particle and gas--particle interactions.
+    """Class to instantiate particles and calculate their properties.
+
+    This class represents the underlying framework for both
+    particle--particle and gas--particle interactions. See detailed
+    methods and functions below.
 
     Attributes:
+
         name    (str)   [no units]
         radius  (float) [m]
         density (float) [kg/m**3]
@@ -24,15 +48,16 @@ class Particle:
     """
 
     def __init__(self, name: str, radius, density, charge):
-        """
-        Constructs the particle object.
+        """Constructs particle objects.
 
         Parameters:
+
             name    (str)   [no units]
             radius  (float) [m]
             density (float) [kg/m**3]
             charge  (int)   [dimensionless]
         """
+
         self._name = name
         self._radius = radius
         self._density = density
@@ -40,47 +65,65 @@ class Particle:
         self._mass = density * (4*np.pi/3) * (radius**3)
 
     def name(self) -> str:
-        """Returns the name of particle."""
+        """Returns the name of particle.
+        """
+
         return self._name
 
     @u.wraps(u.kg, [None])
     def mass(self) -> float:
         """Returns mass of particle.
-        Checks units: [kg]"""
+
+        Checks units: [kg]
+        """
+
         return self._mass
 
     @u.wraps(u.m, [None])
     def radius(self) -> float:
         """Returns radius of particle.
-        Checks units: [m]"""
+
+        Checks units: [m]
+        """
+
         return self._radius
 
     @u.wraps(u.kg / u.m**3, [None])
     def density(self) -> int:
         """Returns density of particle.
-        Checks units: [kg/m**3]"""
+
+        Checks units: [kg/m**3]
+        """
+
         return self._density
 
     @u.wraps(u.dimensionless, [None])
     def charge(self) -> int:
-        """Returns charge of particle.
-        Checks units: [dimensionless]"""
+        """Returns number of charges on particle.
+
+        Checks units: [dimensionless]
+        """
+
         return self._charge
 
     @u.wraps(u.dimensionless, [None, None])
     def knudsen_number(self, environment: Environment) -> float:
         """Returns particle's Knudsen number.
+
         Checks units: [dimensionless]
 
         The Knudsen number reflects the relative length scales of
         the particle and the suspending fluid (air, water, etc.).
         This is calculated by the mean free path of the medium
-        divided by the particle radius."""
+        divided by the particle radius.
+        """
+
         return environment.mean_free_path_air() / self.radius()
 
     @u.wraps(u.dimensionless, [None, None])
     def slip_correction_factor(self, environment: Environment) -> float:
         """Returns particle's Cunningham slip correction factor.
+
         Checks units: [dimensionless]
 
         Dimensionless quantity accounting for non-continuum effects
@@ -90,6 +133,7 @@ class Particle:
         calculate the friction factor.
 
         See Eq 9.34 in Atmos. Chem. & Phys. (2016) for more informatiom."""
+
         knudsen_number: float = self.knudsen_number(environment)
         return 1 + knudsen_number * (
             1.257 + 0.4*np.exp(-1.1/knudsen_number)
@@ -98,11 +142,14 @@ class Particle:
     @u.wraps(u.kg / u.s, [None, None])
     def friction_factor(self, environment: Environment) -> float:
         """Returns a particle's friction factor.
+
         Checks units: [N*s/m]
 
         Property of the particle's size and surrounding medium.
         Multiplying the friction factor by the fluid velocity
-        yields the drag force on the particle."""
+        yields the drag force on the particle.
+        """
+
         slip_correction_factor: float = self.slip_correction_factor(
             environment
         )
@@ -114,10 +161,13 @@ class Particle:
     @u.wraps(u.kg, [None, None])
     def reduced_mass(self, other) -> float:
         """Returns the reduced mass of two particles.
+
         Checks units: [kg]
 
         The reduced mass is an "effective inertial" mass.
-        Allows a two-body problem to be solved as a one-body problem."""
+        Allows a two-body problem to be solved as a one-body problem.
+        """
+
         return self.mass() * other.mass() / (self.mass() + other.mass())
 
     @u.wraps(u.kg / u.s, [None, None, None])
@@ -125,11 +175,14 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Returns the reduced friction factor between two particles.
+
         Checks units: [N*s/m]
 
         Similar to the reduced mass.
         The reduced friction factor allows a two-body problem
-        to be solved as a one-body problem."""
+        to be solved as a one-body problem.
+        """
+
         return (
             self.friction_factor(environment)
             * other.friction_factor(environment)
@@ -144,7 +197,10 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Calculates the Coulomb potential ratio.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
+
         numerator = -1 * self.charge() * other.charge() * (
             pp.ELEMENTARY_CHARGE_VALUE ** 2
         )
@@ -161,7 +217,10 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Kinetic limit of Coulomb enhancement for particle--particle cooagulation.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
+
         coulomb_potential_ratio = self.coulomb_potential_ratio(
             other, environment
         )
@@ -176,7 +235,9 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Continuum limit of Coulomb enhancement for particle--particle coagulation.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
 
         coulomb_potential_ratio = self.coulomb_potential_ratio(
             other, environment
@@ -190,13 +251,16 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Diffusive Knudsen number.
+
         Checks units: [dimensionless]
 
         The *diffusive* Knudsen number is different from Knudsen number.
         Ratio of:
+
             - numerator: mean persistence of one particle
             - denominator: effective length scale of
-                particle--particle Coulombic interaction"""
+                particle--particle Coulombic interaction
+        """
 
         numerator = (
             (
@@ -217,7 +281,9 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Dimensionless particle--particle coagulation kernel.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
 
         # Constants for the chargeless hard-sphere limit
         # see doi:
@@ -247,7 +313,10 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Continuum limit of collision kernel.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
+
         diffusive_knudsen_number = self.diffusive_knudsen_number(
             other, environment
         )
@@ -258,7 +327,10 @@ class Particle:
         self, other, environment: Environment
     ) -> float:
         """Kinetic limit of collision kernel.
-        Checks units: [dimensionless]"""
+
+        Checks units: [dimensionless]
+        """
+
         diffusive_knudsen_number = self.diffusive_knudsen_number(
             other, environment
         )
@@ -272,9 +344,11 @@ class Particle:
         authors: str = "cg2019",
     ) -> float:
         """Dimensionless particle--particle coagulation kernel.
+
         Checks units: [dimensionless]
 
         Paramaters:
+
             self:           particle 1
             other:          particle 2
             environment:    environment conditions
@@ -353,7 +427,7 @@ class Particle:
             )
 
         if authors not in ["gh2012", "hard_sphere", "cg2019"]:
-            raise ValueError("We don't have this parameterization")
+            raise ValueError("We don't have this parameterization.")
 
         return answer
 
@@ -365,9 +439,11 @@ class Particle:
         authors: str = "cg2019",
     ) -> float:
         """Dimensioned particle--particle coagulation kernel.
+
         Checks units: [m**3/s]
 
         Paramaters:
+
             self:           particle 1
             other:          particle 2
             environment:    environment conditions
@@ -377,6 +453,7 @@ class Particle:
                 - hard_sphere (from above)
                 (default: cg2019)
         """
+
         return (
             self.dimensionless_coagulation_kernel_parameterized(
                 other, environment, authors
diff --git a/particula/aerosol_dynamics/physical_parameters.py b/particula/aerosol_dynamics/physical_parameters.py
index b36d51a66..11eb5d462 100644
--- a/particula/aerosol_dynamics/physical_parameters.py
+++ b/particula/aerosol_dynamics/physical_parameters.py
@@ -1,8 +1,7 @@
-"""
-Centralized location for physical parameters.
+"""centralized location for physical parameters.
 """
 
-from particula.aerosol_dynamics import u
+from particula import u
 
 # Boltzmann's constant in m^2 kg s^-2 K^-1
 BOLTZMANN_CONSTANT = 1.380649e-23 * u.m**2 * u.kg / u.s**2 / u.K


Test patch:
diff --git a/particula/aerosol_dynamics/tests/__init__.py b/particula/aerosol_dynamics/tests/__init__.py
new file mode 100644
index 000000000..b84d7b4b8
--- /dev/null
+++ b/particula/aerosol_dynamics/tests/__init__.py
@@ -0,0 +1,2 @@
+"""test suite for aerosol_dynamics module.
+"""
diff --git a/particula/aerosol_dynamics/environment_test.py b/particula/aerosol_dynamics/tests/environment_test.py
similarity index 91%
rename from particula/aerosol_dynamics/environment_test.py
rename to particula/aerosol_dynamics/tests/environment_test.py
index 71e0ec4f0..dd07ddfba 100644
--- a/particula/aerosol_dynamics/environment_test.py
+++ b/particula/aerosol_dynamics/tests/environment_test.py
@@ -1,13 +1,10 @@
-"""
-Tests for the Environment class.
+"""tests for the environment module.
 """
 
 import pytest
-
+from particula import u
 from particula.aerosol_dynamics import environment
 
-from particula.aerosol_dynamics import u
-
 standard_environment = environment.Environment(
     temperature=298,  # * u.K,
     pressure=101325,  # * u.Pa,
diff --git a/particula/aerosol_dynamics/parcel_test.py b/particula/aerosol_dynamics/tests/parcel_test.py
similarity index 95%
rename from particula/aerosol_dynamics/parcel_test.py
rename to particula/aerosol_dynamics/tests/parcel_test.py
index a57080e68..eedb63423 100644
--- a/particula/aerosol_dynamics/parcel_test.py
+++ b/particula/aerosol_dynamics/tests/parcel_test.py
@@ -1,8 +1,8 @@
-"""
-Test suites for parcel class.
+"""tests for the parcel module.
 """
 
-from particula.aerosol_dynamics import parcel, particle, environment, u
+from particula import u
+from particula.aerosol_dynamics import environment, parcel, particle
 
 small_particle = particle.Particle(
     name="small_particle",
diff --git a/particula/aerosol_dynamics/particle_test.py b/particula/aerosol_dynamics/tests/particle_test.py
similarity index 86%
rename from particula/aerosol_dynamics/particle_test.py
rename to particula/aerosol_dynamics/tests/particle_test.py
index d08ccf8fd..bd4fec200 100644
--- a/particula/aerosol_dynamics/particle_test.py
+++ b/particula/aerosol_dynamics/tests/particle_test.py
@@ -1,26 +1,23 @@
-"""
-Test suites for particle class.
+"""Test suites for particle class.
 """
 
 import numpy as np
 import pint
 import pytest
-
+from particula import u
 from particula.aerosol_dynamics import environment, particle
 
-from particula.aerosol_dynamics import u
-
 small_particle = particle.Particle(
     name="small_particle",
     radius=1.0e-9 * u.m,
-    density=1.0 * u.kg / u.m**3,
+    density=1.0 * u.kg / u.m**3,  # need fixing, add e3
     charge=1,
 )
 
 large_particle = particle.Particle(
     name="large_particle",
     radius=1.0e-7 * u.m,
-    density=1.8 * u.kg / u.m**3,
+    density=1.8 * u.kg / u.m**3,  # need fixing, add e3
     charge=1,
 )
 
@@ -39,14 +36,14 @@ standard_environment = environment.Environment(
 negative_ion = particle.Particle(
     name="negative_ion",
     radius=0.5e-9 * u.m,
-    density=1.84 * u.kg / u.m**3,
+    density=1.84e3 * u.kg / u.m**3,
     charge=-1,
 )
 
 positive_particle = particle.Particle(
     name="positive_particle",
     radius=3e-9 * u.m,
-    density=1.7 * u.kg / u.m**3,
+    density=1.7e3 * u.kg / u.m**3,
     charge=1,
 )
 
@@ -57,8 +54,7 @@ standard_environment_ip = environment.Environment(
 
 
 def test_getters():
-    """
-    Test that the getters work.
+    """Test that the getters work.
     """
 
     assert small_particle.name() == "small_particle"
@@ -72,8 +68,7 @@ def test_getters():
 
 
 def test_knudsen_number():
-    """
-    Test that the knudsen number is calculated correctly.
+    """Test that the knudsen number is calculated correctly.
     """
 
     assert small_particle.knudsen_number(
@@ -98,8 +93,7 @@ def test_knudsen_number():
 
 
 def test_slip_correction_factor():
-    """"
-    Test that the slip correction factor is calculated correctly.
+    """"Test that the slip correction factor is calculated correctly.
     """
 
     assert small_particle.slip_correction_factor(
@@ -116,8 +110,7 @@ def test_slip_correction_factor():
 
 
 def test_friction_factor():
-    """
-    Test that the friction factor is calculated correctly.
+    """Test that the friction factor is calculated correctly.
     """
 
     assert small_particle.friction_factor(
@@ -134,8 +127,7 @@ def test_friction_factor():
 
 
 def test_reduced_mass():
-    """
-    Test that the reduced mass is calculated correctly.
+    """Test that the reduced mass is calculated correctly.
     """
 
     reduced_mass_1_2 = small_particle.reduced_mass(large_particle)
@@ -144,8 +136,7 @@ def test_reduced_mass():
 
 
 def test_reduced_friction_factor():
-    """
-    Test that the reduced friction factor is calculated correctly.
+    """Test that the reduced friction factor is calculated correctly.
     """
 
     reduced_friction_factor_1_2 = small_particle.reduced_friction_factor(
@@ -155,8 +146,7 @@ def test_reduced_friction_factor():
 
 
 def test_dimensionless_coagulation_kernel_parameterized():
-    """
-    Test that the paramaterized dimensionless coagulation kernel
+    """Test that the paramaterized dimensionless coagulation kernel
     is calculated correctly.
     """
 
@@ -169,8 +159,7 @@ def test_dimensionless_coagulation_kernel_parameterized():
 
 
 def test_dimensioned_coagulation_kernel():
-    """
-    Test: dimensioned coagulation kernel is calculated correctly.
+    """Tests dimensioned coagulation kernel is calculated correctly.
     """
 
     assert small_particle.dimensioned_coagulation_kernel(