week3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Textural Maturity of Clastic Sedimentary Rocks\n",
    "\n",
    "#### By: Abby Eckland\n",
    "#### Final Problem Set (Week 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Goals\n",
    "\n",
    "#### After completing this exercise, you will be able to...\n",
    "##### ***Programming goals:*** \n",
    "\n",
    "1) Learn the basics of flow control in the Python language, including conditional statements and for loops\n",
    "\n",
    "2) Practice executing flow control problems to solve problems pertaining to sedimentary geology\n",
    "\n",
    "##### ***Learning goals:***\n",
    "\n",
    "1) Describe the key characteristics of clastic sedimentary rock texture\n",
    "\n",
    "2) Determine the textrual maturity of rock and sediment samples\n",
    "\n",
    "3) Identify the textural maturity of sedimentary rocks using thin sections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites\n",
    "\n",
    "##### ***Programming prerequisites:*** \n",
    "Students should have some prior experience executing Python code and working with data structures, including dictionaries. No prior knowledge about flow control is required.\n",
    "\n",
    "##### ***Learning prerequesites:***\n",
    "Students should have completed an introductory geology course and must currently be taking Sedimentology and Stratigraphy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lesson Background\n",
    "\n",
    "In Sedimentology, it is important to understand the concept of textural maturity as it pertains to clastic sedimentary rocks. The purpose of this notebook is to introduce the four basic characteristics of clastic sedimentary rock texture. The 4 key characteristis include:\n",
    "- Textural maturity\n",
    "- Grain size\n",
    "- Grain sorting\n",
    "- Roundness & sphericity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Textural Maturity\n",
    "\n",
    "Textural maturity is an important textural characteristic. Recall that sedimentary texture is defined as the physical characteristics of grains and matrix. Textural maturity, however, is a concept that sums up the textural state of a sediment. Sediment becomes increasingly mature in 3 steps (with increasingly more work done from 1-3):\n",
    "\n",
    "1. **Winnowing (washing out) of fines** - size segregation; happens relatively easily near source area\n",
    "2. **Sorting of framework grain sizes** - greater total energy worked and further segregates sediment\n",
    "3. **Rounding** - takes even more transport (total energy) than washing out or sorting. Maximum rounding is a rare phenomena. \n",
    "\n",
    "Textural maturity integrates the amount of matrix, sorting, and roundness of a clastic sedimenatry rock. Supermature is characterized by rounded clasts of uniform grain size and no matrix. Immature sediments are the antithesis. The categories of textural maturity are: immature, submature, mature, and supermature.\n",
    "\n",
    "The flow chart below is used for classyfing the textural maturity of clastic sedimentary rocks. We will be using flow control with Python to convert the visual flow chart into a conditional statement, which will be discussed further in the programming section. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Textural maturity of clastic sedimentary rocks flow chart](data/textural_maturity.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Grain size\n",
    "\n",
    "Grain size describes the average diameter of grains in a sediment sample. Categories range from clay being the smallest and boulders being the largest grains. See the Udden-Wentworth grain size scale below to see how grains are classified based on their size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Udden-Wentworth grain size scale](data/grain_size.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Grain sorting\n",
    "\n",
    "Grain sorting describes the range of diamters, or grain sizes, in a sediment sample. Categories range from very poorly sorted, with a wide range of grain sizes, to very well sorted, with a very small range of grain sizes. See image below for how grain sorting is visually determined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Grain sorting in clastic sedimentary rocks.](data/grain_sorting.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Roundness & sphericity\n",
    "\n",
    "Sphericity describes how the closeness of sediment grains to a sphere, where low sphericity in sediments is seen as discoid or needle-shaped grains. Roudness refers to the degree of abrasian of grains, with very angular grains having rough edges and rounded grains having smooth edges. See figure below for how roundness and sphericity are visually determined."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Roundness & sphericity chart](data/grain_roundness.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flow Control Background\n",
    "\n",
    "#### For loops\n",
    "\n",
    "In the context of most data science work, Python for loops are used to loop through an iterable object (like a list, tuple, set, etc.) and perform the same action for each entry. For example, a for loop would allow us to iterate through a list, performing the same action on each item in the list. \n",
    "\n",
    "(An interable object, by the way, is any Python object we can iterate through, or “loop” through, and return a single element at a time. Lists, for example, are iterable and return a single list entry at a time, in the order entries are listed.)\n",
    "\n",
    "You create a for loop by first defining the *iterable object you’d like to loop through*, and then defining the *actions you’d like to perform on each item in that iterable object*. For example, when iterating through a list, you first specify the list you’d like to iterate through, and then specify what action you’d like to perform on each list item.\n",
    "\n",
    "Let’s look at a quick example: if we had a list of sedimentary rock types stored in Python, we could use a for loop to iterate through that list, printing each name until it reached the end. Below, we’ll create our list of rock types, and then write a for loop that iterates through it, printing each entry on the list in sequence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rock_types = ['Sandstone', 'Siltstone', 'Shale', 'Conglomerate', 'Mudstone']\n",
    "\n",
    "for rock in rock_types:\n",
    "    print(rock)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might be wondering, where did the variable \"rock\" come from? We haven’t defined it previously in our code! But because for loops iterate through lists, tuples, etc. in sequence, this variable can actually be called almost anything. Python will interpret any variable name we put in that spot as referring to each list entry in sequence as the loop executes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditional Statements\n",
    "\n",
    "In the real world, we commonly must evaluate information around us and then choose one course of action or another based on what we observe: \n",
    "\n",
    "<font color=grey>If the weather is nice, then I will conduct fieldwork. (It’s implied that if the weather isn’t nice, then I will not conduct fieldwork.)\n",
    "\n",
    "In a Python program, the if statement is how you perform this sort of decision-making. It allows for conditional execution of a statement or group of statements based on the value of an expression.\n",
    "    \n",
    "Sometimes, you want to evaluate a condition and take one path if it is true but specify an alternative path if it is not. This is accomplished with an else clause:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weather = ['The sky is blue']\n",
    "if weather == 'The sky is not blue':\n",
    "    message = 'I will not conduct fieldwork'\n",
    "else:\n",
    "    message= 'I will conduct fieldwork'\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If 'The sky is blue' is true, the first suite is not executed and is skipped. If 'The sky is blue' is false, the first suite is skipped and the second is executed. Either way, execution then resumes after the second suite. Both suites are defined by indentation, as described above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also syntax for branching execution based on several alternatives. For this, use one or more elif (short for else if) clauses. Python evaluates each expression in turn and executes the suite corresponding to the first that is true. If none of the expressions are true, and an else clause is specified, then its suite is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Siltsone'\n",
    "if name == 'Sandstone':\n",
    "    print('Visible grains')\n",
    "elif name == 'Siltsone':\n",
    "    print('Visible grains with hand lens')\n",
    "elif name == 'Shale':\n",
    "    print('Cannot distinguish grains')\n",
    "elif name == 'Conglomerate':\n",
    "    print('Cannot miss those grains')\n",
    "else:\n",
    "    print('No idea how porous')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While loops\n",
    "\n",
    "With the while loop we can execute a set of statements as long as a condition is true. Therefore, a while loop becomes infinite loop if a condition never becomes FALSE. Let's see an example. Since Gneiss is not a sedimentary rock, the condition is false, and the while loop will not print to infinity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Sedimentary = ['Sandstone', 'Siltstone', 'Shale', 'Conglomerate']\n",
    "Metamorphic = ['Gneiss', 'Slate', 'Schist', 'Quartzite']\n",
    "rock = 'Gneiss'\n",
    "while rock == Sedimentary:\n",
    "    print('This is a sedimentary rock')\n",
    "    break\n",
    "else:\n",
    "    print('This is a metamorphic rock')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "In this example, we will determine the textural maturity of a sediment, given known information about the mud content, sorting, and rounding. Below is a **dictionary** to describe the sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_1 = {'Mud Content': '<15% (Arenite)', 'Sorting': 'Poorly sorted', 'Clast Shape': 'Angular to subangular'} # Submature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's run a simple **for loop** to print the dictionary key to make sure they match the flow chart guidelines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for key in sample_1:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks good. Now, let's write a **conditional statement** to describe the textural maturity of the sediment sample. Recall the flow chart above for determining the textural maturity of a clastic sedimentary rock."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maturity = []\n",
    "if sample_1['Mud Content'] == '>15% (Wacke)':\n",
    "    maturity = 'Immature'\n",
    "elif sample_1['Sorting'] == 'Poorly sorted':\n",
    "    maturity = 'Submature' # this sample should be sub-mature\n",
    "elif 'Angular' or 'angular' in sample_2['Clast Shape']:\n",
    "    maturity = 'Mature'\n",
    "else:\n",
    "    maturity = 'Supermature'\n",
    "print(maturity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question\n",
    "\n",
    "1. Below two more samples are described. What are their textural maturities?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_2 = {'Mud Content': '<15% (Arenite)', 'Sorting': 'Well sorted', 'Clast Shape': 'Angular to subangular'} # Mature\n",
    "sample_3 = {'Mud Content': '>15% (Wacke)', 'Sorting': 'Poorly sorted', 'Clast Shape': 'Subangular to subrounded'} #Immature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code for sample 2 textural maturity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code for sample 3 textural maturity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. If a sedimentary rock has rounded clasts, is well sorted, and has >15% mud content, is the rock's textural maturity supermature? If it's not supermature, what is its textural maturity? Explain your reasoning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Short answer for question 2 here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Examine the thin sections of the sedimentary rocks below and determine their textural maturity. Explain your reasoning for each sample."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sample ID 1** \n",
    "\n",
    "![Sample 1](data/sample_1_id.jpeg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample ID 1 textural maturity here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sample ID 2**\n",
    "\n",
    "![Sample 2](data/sample_2_id.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample ID 2 textural maturity here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sample ID 3**\n",
    "\n",
    "![Sample 3](data/sample_3_id.jpeg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample ID 3 textural maturity here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congratulations! You have finished the exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for loops: https://www.dataquest.io/blog/python-for-loop-tutorial/#:~:text=In%20the%20context%20of%20most,each%20item%20in%20the%20list.\n",
    "    \n",
    "conditional statements: https://realpython.com/python-conditional-statements/#:~:text=In%20a%20Python%20program%2C%20the,statement%20in%20its%20simplest%20form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}