notebook.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KiRjUzNQ5QvV"
      },
      "source": [
        "# Welcome \n",
        "\n",
        "Welcome to Virus Tracker! Guided by the presentation, as you work through each activity in this notebook you will learn the fundamental concepts of bioinformatics, whilst applying your analytical and problem-solving skills to track down the most recent COVID-19 virus cluster. \n",
        "\n",
        "In order to tackle the most contemporary problem that governments are facing today, we will begin by walking through the concepts of Command Line Interface (CLI) computing, DNA sequencing and phylogenetic trees. To use this notebook, follow the steps outlined by your presenters - and when there is a section for you to complete interactively, there will be a corresponding activity in this document for you to do. \n",
        "\n",
        "Enjoy!"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Initial setup\n",
        "\n",
        "Copy and paste the following commands into your terminal and press enter to run them:\n",
        "\n",
        "```\n",
        "pip install ete3\n",
        "\n",
        "```\n",
        "A demonstrator might need to come around and help you with this one, so just put your hand up!\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# How to Use the Notebook\n",
        "This notebook contains a variety of cells, some of which hold information and others hold computer code. For the code cells, you can run the program by typing the commands into the terminal and pressing enter.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can also write your own segment of code - which you will be doing throughout this workshop. To do this, try and print the words 'Hello World' using the cell below in Python."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## What is Bioinformatics?\n",
        "Bioinformatics is one of the most exciting fields on the forefront of innovation. Whilst the six-syllable word has most people scratching their heads, this workshop aims to demystify the career field and highlight some of the key responsibilties of bioinformaticians during the COVID-19 pandemic.\n",
        "\n",
        "So what exactly *is* it? \n",
        "\n",
        "Bioinformatics is a key discipline that applies the fundamentals of the life sciences, mathematics and engineering to computationally analyse and process the rapidly growing repository of information developed from genetics, biotechnology and biochemistry. At UNSW, through studying the core concepts of software and information technologies to extract, interpret, analyse and utilise data and genetic information, students apply the methods of computer science to achieve the goals of life sciences space.\n",
        "\n",
        "In essence, it's about using computers to answer biological questions. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## The Challenge\n",
        "\n",
        "In anticipation for the 2022 Australian Open, famous tennis player Dovak Njokovic has entered the country as an unvaccinated individual and unfortunately contracted COVID-19. Before Dovak was aware of the fact that he was COVID positive, he had attended several venues across Melbourne, including Melbourne Park, The Park Hotel, the Federal Circuit Court and McDonald’s Bourke St. As a result, new clusters of positive cases have been emerging across the city and COVID tracers need your help to track the spread of the virus!\n",
        "\n",
        "In order to solve this problem, we must step through the application of bioinformatics to **genomic epidemiology**.\n",
        "\n",
        "####  What is genomic epidemiology?\n",
        "The study of distribution and determinants of disease in a population, and the application of this to identify and control health outcomes. Essentially, it enables us to use genomic data to understand the distribution of infectious disease."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "![](epidem.jpeg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "13kngp8jUHfW"
      },
      "source": [
        "## Module 1: The Genome \n",
        "\n",
        "The genome is the set of genetic instructions, which determine the features of an organism and how it will grow and develop. The genome is comprised of nucleotides sequences of DNA, which dictate all the information needed for life.\n",
        "\n",
        "As seen in the diagram below, the genome can be broken down into the following parts:\n",
        "* **Base pairs**: DNA has four different types of bases, Adenine (A), Cytosine (C), Guanine (G) and Thymine (T). Each of these bases are represented by a single letter, A, C, G and T respectively. In the double-helix structure of DNA, each base is paired with another base that such that they are complementary paired. So, thymine (T) pairs with adenine (A) and cytosine (C) pairs with guanine (G). This is because the chemical structure and shape of thymine and adenine can form strong chemical bonds, and likewise between cytosine and guanine, which is necessary to maintain the double helix shape of DNA.\n",
        "\n",
        "* **DNA**: Deoxyribonucleic Acid (DNA) is a double-stranded structure that has a sugar-phosphate backbone, and base pairs between each strand. The sequence of base pairs that make up DNA is what gives each organism its genetic blueprint, and differentiates organisms from each other.\n",
        "\n",
        "* **Genes**: Genes are the collection of long strands of DNA. DNA strands code for different kinds of genes, for example, the HERC2 and OCA2 genes determine your eye colour.\n",
        "\n",
        "* **Histones**: Histones are basic proteins which act as a spool that DNA can wind around. Eight histones then join together to form a structural unit of DNA, being a nucleosome.\n",
        "\n",
        "* **Nucleosomes**: Nucleosomes are units of DNA that are made up of eight histone proteins that are bound together in a tight structure.\n",
        "\n",
        "* **Chromosomes**: Units of nucleosomes join are connected (like beads on a string), which are tightly woven to form chromosomes. The chromosomes contain the organised DNA, and typically exists as a pair. In humans, there are normally 23 pairs of chromosomes, with the X and Y chromosomes determining the sex of an individual."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "![](genome.jpeg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "All of these biological components form the genome. The human genome is extremely long, consisting of 3.05 billion base pairs. In fact, the human genome is so long that it was not until 2021 that scientists had confidently deciphered the entire sequence. \n",
        "\n",
        "The Human Genome Project, which began in the late 20th century was an international investigation which was conducted to investigate the length and contents of the human genome. The outcome of this effort, which ended in 2003, was that geneticists could map the number, location, size and sequence of genes, as well as screen for specific genes to determine their function. However, through this process only 85% of the human genome was deciphered, and through the acceleration of technology available it has taken until 2021 to determine the final 15%.\n",
        "\n",
        "In comparison, the genome for SARS-CoV-2 (commonly referred to as COVID-19) is 27-32 kb (kilobases) in size. This means that COVID-19 is on average 0.000885245% of the size of the human genome, making it much easier to analyse by a computer (and faster). "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### **Figure 1** All the genes contained in Chromosome 1 of the Human Genome: \n",
        "\n",
        "![](images/Chrom01.jpg)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### **Figure 2a** The SARS-CoV-2 Genome is contained on one piece of DNA much smaller than a human chromosome. \n",
        "\n",
        "![](images/SARS-CoV-2_genome.jpg)\n",
        "\n",
        "\n",
        "#### **Figure 2b** Various notable genes responsible for COVID-19 \n",
        "\n",
        "![](images/corona-genome.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Module 2: Sequencing\n",
        "So how is it possible to take this biological information and use computers to analyse it?\n",
        "\n",
        "In order to understand the genome, we must first perform genomic sequencing. \n",
        "\n",
        "At its core, a genomic sequence is the source code of an organism, and is simply a series of letters representing the order of nucleotides. So something as small as \"AGCGTA\" could be a genomic sequence (but not a very complicated one). By storing long sequences of these letters into a simple file on a computer, we can use programming techniques and algorithms to analyse it. A common type of file that these sequences are stored in are called `FASTA` files, which have a simple structure containing a header (marked by a `>` character) as the first line, which contains the key information about the sequence, followed by the sequence itself on the lines following. This can be seen in the example below:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        ">example_genomic_sequence\n",
        "ATTAAAGGTTTATACCTTCCCAGGTAACAAACCAACCAACTTTCGATCTCTTGTAGATCTGTTCTCTAAACGAACTTTAAAATCTGTGTGGCTGTCACTCGGCTGCATGCTTAGTGCACTCACGCAGTATAATTAATAACTAATTACTGTCGTTGACAGGACACGAGTAACTCGTCTATCTTCTGCAGGCTGCTTACGGT"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Genetic Fingerprinting\n",
        "Genetic fingerprinting is a technique that is used in a range of contexts. A virus sequence has the ability to mutate, or change, as it spreads. Sequencing gives you the ‘fingerprint’ of that particular virus sample, at that point in time. \n",
        "\n",
        "You may have heard genetic fingerprinting being used in *forensics* to match DNA from a crime scene to a list of suspects, as seen below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "![](dna_fingerprinting.jpg)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "In a similar way, mutations can be found by looking at the 'fingerprint' and comparing them to other fingerprints. Then, by comparing within a population of interest, scientists can see how they are related to eachother. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### RNA Whole-Genome Sequencing (WGS)\n",
        "To do this, RNA whole-genome sequencing (WGS) is used. RNA WGS enables scientific bodies like WHO (World Health Organisation) to identify and confirm if the Coronavirus has mutated to such an extent that a new variant emerges (like the Delta or Omicron strains). "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Question: Fill in the steps below so that they are in the correct order which is used in the whole-genome sequencing process."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "1. \n",
        "2.\n",
        "3.\n",
        "4.\n",
        "5.\n",
        "\n",
        "\n",
        "*Options:*\n",
        "* Patient sample collected \n",
        "* Raw data is generated (into the computer!)\n",
        "* Library prepared\n",
        "* RNA extraction \n",
        "* RNA is sequenced "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Variants\n",
        "A variant of a virus is the specific lineage from a common ancestor, and is often a defining mutation. So, this makes the Omicron variant genetically distant from the Delta variant. \n",
        "\n",
        "When mutations occur to such an extent that a new variant is formed, there are specific aspects of the virus that change, like the spike protein. The spike protein in COVID is the target for vaccines and has changed across mutations, with some versions being:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "##### Spike D614G  \n",
        "<div>\n",
        "    <p style=\"float: left;\"><img src=\"virus_1.png\" height=\"200px\" width=\"345px\" border=\"1px\"></p>\n",
        "    <p><div style = \"position:relative; left:10px; top:50px;\">One of the original variants - emerged early in pandemic as it spread across North America and Europe. With altered viral properties like increased transmissibility, it became the globally dominant variant.</p>\n",
        "</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "##### Spike D614G  \n",
        "<div>\n",
        "    <p style=\"float: left;\"><img src=\"virus_2.png\" height=\"300px\" width=\"300px\" border=\"1px\"></p>\n",
        "    <p><div style = \"position:relative; left: 20px; top:150px;\">Exhibited increased infection and binding ability\n",
        "</p>\n",
        "</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Due to the continual nature of evolution, new lineages are being developed all the time. This lineages result in the virus having altered properties, such as faster transmission or larger impacts on the immune system. Whilst multiple variants beginning are typically rare and the result from a random mutation, the frequency of this occurring increases when there is high rates of transmission across large populations."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Identify which of the following events would have a higher likelihood of enabling epidemiological changes to the virus? [multiple answers correct]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "1. An infection at a family dinner\n",
        "2. An infection at a large music concert, held indoors\n",
        "3. An infection at the dentist\n",
        "4. An infection throughout a nursing home"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "List your answer here:\n",
        "\n",
        "#"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This is why genomic surveillance is critical for detecting emerging variants that may spread more quickly, have altered disease states, evade diagnostics, or even vaccine immunity.\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "fRfvVF-zU9qx"
      },
      "source": [
        "## Module 3: Multiple Sequence Alignment (MSA)\n",
        "How do we compare sequences, and answer questions like the following?\n",
        "\n",
        "* Which sequences came from the same infected person?\n",
        "* Which variant is a given sequence?\n",
        "* Which cluster is a sequence a part of?\n",
        "\n",
        "This is where multiple sequence alignment (MSA) comes in.\n",
        "\n",
        "A common problem in biology is understanding how two sequences \"fit together\" or *align*.  This is another way of saying how two different sequences arose independently from an *ancestor* sequence, via evolution.  For example, the sequence `AACC` might evolve to `ATCC` (the `A` being *substituted* for a `T`), and it also might evolve to a sequence `AACG`.  The two current sequences are thus \n",
        "\n",
        "```\n",
        "ATCC\n",
        "AACG\n",
        "```\n",
        "'Aligning' these two sequences thus helps us identify the *differences* between them, and how they might have come to be without knowing the direct ancestor sequence.   \n",
        "\n",
        "It's also important to 'score' an alignment, in order to find the best match between two sequences.  Sometimes this might not be so easy.  \n",
        "\n",
        "### Gaps \n",
        "\n",
        "Let's look at another example.  Perhaps we have sequences \n",
        "\n",
        "```\n",
        "CAT\n",
        "CAAT \n",
        "CAR \n",
        "CATT \n",
        "```\n",
        "\n",
        "Note that the sequences are not the same length, which means some letters must have been deleted or inserted through the evolutionary process.\n",
        "\n",
        ">Hint: alignments often are written using `-` characters, which represents a gap in one sequence.  \n",
        "\n",
        "The alignment might look something like \n",
        "\n",
        "```\n",
        "CA-T\n",
        "CAAT\n",
        "CA-R\n",
        "CATT\n",
        "``` \n",
        "\n",
        "Notice that we placed gaps in `CAT` and `CAR` such that the 2nd column only consists of `A`s, and the last column is mostly `T` with only one `R`.  Generally, the least amount of mistmatches between letters you have, the better; and the less gaps you put in the better. \n",
        "\n",
        "Let's go through an example with english words instead of DNA bases.   We have a set of sequences stored in a file called `sam.fasta`. \n",
        "\n",
        "```\n",
        "SAM \n",
        "SPAM\n",
        "SPLAT\n",
        "SPAT \n",
        "CLAMS\n",
        "```\n",
        "\n",
        "\n",
        "#### Activity\n",
        "How might an alignment between these sequences look like? Try working out for yourself how to best align these on a piece of paper before running the program.  \n",
        "\n",
        ">Remember, you may need to add gaps in certain sequences to make sure the alignment is the same length. \n",
        "\n",
        "\n",
        "\n",
        "\n",
        "## Using ClustalW to make an alignment\n",
        "\n",
        "To test our alignment done by hand, let's use a computer algorithm that is designed for this exact task.\n",
        "\n",
        "Type in the terminal:\n",
        "\n",
        "```\n",
        "git clone https://github.com/kamurani/virustracker.git\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "Navigate to a directory containing the file `sam.fasta`.  \n",
        "\n",
        "```\n",
        "cd virustracker\n",
        "```\n",
        "\n",
        "`cd` stands for 'change directory'.\n",
        "\n",
        "You can see what files are in this directory by typing `ls`, for 'list'.\n",
        "You can view the contents of this file by typing on the command line `cat sam.fasta`.  `cat` stands for \"concatenate\" and outputs the contents of a file to the terminal so we can quickly see what's in it.\n",
        "\n",
        "\n",
        "\n",
        "Notice that each sequence is divided by a header (the header starts with a `>` character). \n",
        "\n",
        "Now, run `clustalw` on the commandline.  The first step is to type `1` to load the sequence file from disk.  When prompted, give the program the name of the file we want to use (`sam.fasta`).  \n",
        "\n",
        ">Note: you will need to make sure you're in the same directory as the file, otherwise `clustalw` will not be able to load it in. \n",
        "\n",
        "Now, we want to go to the `Multiple Alignments` menu by pressing `2`.  Then input `1` for `Do a complete multiple alignment now`.  \n",
        "\n",
        "We can press enter for the remaining prompts to use the default values. Finally, `clustalw` should give us a display of the alignment!\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Run ClustalW using this cell\n",
        "\n",
        "!clustalw"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Next, type `2` from the main menu to perform a **multiple alignment**. \n",
        "\n",
        "\n",
        "From here, press `1` to perform the alignment.  The program will prompt you for the output file names, but you can just hit `Enter` to use the default names.  \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Step through the ClustalW settings to perform a multiple alignment\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "Continue the prompts to exit the program, and type `ls` to confirm that the output files are indeed there."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DxLCkWuxVuNH"
      },
      "outputs": [],
      "source": [
        "# Exit the program and type `ls` to confirm you generated the output files\n",
        "# Enter your code below"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        " \n",
        "\n",
        "If you ran the program correctly, your output from the `clustalw` program in the terminal should look something like this:\n",
        "\n",
        "\n",
        "```\n",
        "CLUSTAL 2.1 multiple sequence alignment\n",
        "\n",
        "\n",
        "2               SP-AM-\n",
        "4               SP-AT-\n",
        "3               SPLAT-\n",
        "1               -S-AM-\n",
        "5               CL-AMS\n",
        "                   *\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "> Was the alignment similar to the one you came up with?  Where abouts in the sequences did the program choose something different to you? \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        ">Bonus question:  Do we know for certain if the program is \"right\"?  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Module 4: Phylogenetic Trees\n",
        "In order to visualise our alignment, and understand the differences between sequences, biologists will often use **phylogenetic trees**. \n",
        "\n",
        "Phylogeny is the study of evolutionary relations amongst biological entities. One of the most simple examples is that of a family tree.\n",
        "\n",
        "\n",
        "### Family Trees\n",
        "\n",
        "\n",
        "Picture your family.  You might have siblings, cousins, etc... whilst you are no doubt all different in your own ways, you are also all related.  You are most closely related to your parents and siblings, sharing about 50% of your DNA with them.  If you have an identical twin, then your DNA is 100% identical with theirs.  Further 'distance' away from your close relatives are people who share less DNA with you in common.  \n",
        "\n",
        "We can represent the relationships between family members as a family 'tree', and it might look something like this. \n",
        "\n",
        "![](images/family_tree.jpg)\n",
        "\n",
        "Even your pet dog will fall on this tree somewhere -- you just have to go back a lot of generations to find the common ancestor! \n",
        "\n",
        "Recall that this is because all life on earth is related. \n",
        "\n",
        "![](images/phylo-tree-animals.jpg)\n",
        "\n",
        "\n",
        "### Related sequences\n",
        "\n",
        "With this principle in mind, we can use phylogenetic trees to determine which sequences are related to each other once they have been aligned. Let’s start with a simple example.\n",
        "\n",
        "> In the sequences of the 4 viruses below, see if you can identify the *differences* between them.  Can you work out what has changed between the samples in the past to give rise to the current samples `A`, `B`, `C` and `D`?  \n",
        "\n",
        "> BONUS QUESTION: Is it possible from this information alone to tell which mutation has occurred from which 'ancestor'? I.e., which 'direction' has evolution gone? \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "```\n",
        "virus_A     ACGAAGTGAA\n",
        "virus_B     ACGACGTTAG\n",
        "virus_C     TCGACGTGAA\n",
        "virus_D     TCGAGGTGAA\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "These differences, or mutations (assuming that these are all variations of virus_A), are substitutions. This means that one letter (nucleotide) has been altered to another. Other types of mutations include insertions (the addition of one more letter) or deletions (the removal of a letter in the sequence).\n",
        "\n",
        "The corresponding tree to these sequences is below.\n",
        "\n",
        "![](images/example_phylo_graphic.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Transmission networks\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "In this diagram, each red circle indicates an infected person.  However, since we can only collect so many samples, we will never be able to know the true pattern of infection, and thus the blue circles represent known, collected samples of infected patients.  \n",
        "\n",
        "\n",
        "\n",
        "![](images/tree-question-labelled.png)\n",
        "\n",
        "#### Q1\n",
        "\n",
        "Order the cases from earlier to later (i.e. who got infected first?)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q2\n",
        "Who has the variant with the *green* mutation? "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q3\n",
        "Who has the variant with the *red* mutation? "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q4\n",
        "Which sample is most closely related to D? "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q5\n",
        "Which sample is most closely related to A? "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Viewing Transmission as Phylogeny \n",
        "\n",
        "Sequences that have the same mutations are more closely related, so we can use this property to group samples into groups.  \n",
        "\n",
        "This can be seen in the following diagram:\n",
        "\n",
        "\n",
        "![](images/tree-question.png)\n",
        "\n",
        "> Image from https://docs.nextstrain.org \n",
        "\n",
        "The individual colours represent separate mutation events.  For example, sample `C` has a 'red' mutation that is not shared by any other sample, making it unique in a particular spot in the genome. \n",
        "\n",
        "The longer the line from the *left* to the *right* means more mutations have occurred.  Note that each point where the tree branches represents a 'common ancestor' that we do not have the sample of.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q6\n",
        "Are there any sequences that are identical?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q7\n",
        "Which mutation is likely to have been 'first'? \n",
        "\n",
        "> Hint: what mutation does the common ancestor of all samples have? "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Put your answer here"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Module 5: The Solution\n",
        "Now let’s apply this to our initial problem. Thanks to the high testing rates, there is a wide variety of genomic samples that have been collected, which are listed below:\n",
        "\n",
        "* Sample A: Australia/VIC01/2020\n",
        "* Sample B: Australia/VIC02/2020\n",
        "* Sample C: Australia/VIC03/2020\n",
        "* Sample D: Australia/VIC04/2020\n",
        "* Sample E: Australia/VIC05/2020\n",
        "* Root: Wuhan/Hu-1/2019\n",
        "\n",
        "Let's get these sequences to our computer by typing these commands:\n",
        "\n",
        "```\n",
        "git clone https://github.com/kamurani/Virus-Tracker-Sequences\n",
        "cd Virus-Tracker-Sequences\n",
        "```\n",
        "\n",
        "You can view these sequences by opening the file called `inputseq_S.fasta` (if you are in the `Virus-Tracker-Sequences` directory) which contains all the sequences, specifically extracted at the region of the SARS-CoV-2 genome that encodes the *spike protein*. \n",
        "\n",
        "The root is the original sequence of COVID-19 that was sampled from Wuhan.\n",
        "\n",
        ">Perform a multiple sequence alignment of these samples, generating a tree output on ClustalW."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Navigate to the directory containing the .fasta file\n",
        "clustalw -quicktree -infile=inputseq_S.fasta \n",
        "clustalw -tree -infile=inputseq_S.aln\n",
        "\n",
        "# View the tree file\n",
        "ete3 view --text -t inputseq_S.ph\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# This time, we want to do the same alignment but include the wastewater.fasta file. \n",
        "# We can use the `cat` command to join our two sequence files.\n",
        "cat inputseq_S.fasta wastewater.fasta > all.fasta\n",
        "\n",
        "# Here, the `>` character sends the program output to a saved file called `all.fasta`.  "
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "You can copy and paste the following commands to run the alignment again."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Run clustalw on the wastewater sample to generate an MSA\n",
        "clustalw -quicktree -infile=all.fasta \n",
        "\n",
        "# Create a tree file [all.ph]\n",
        "clustalw -tree -infile=all.aln "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# View the new created tree \n",
        "ete3 view --text -t all.ph"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q1\n",
        "From this output, which strains are most closely related?\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Insert your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### Q2 \n",
        "Predict which samples are from the same location?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Insert your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\n",
        "Now let’s investigate the locations of these strains using Nextstrain."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MpDw3C9QVwHi"
      },
      "source": [
        "# Nextstrain\n",
        "\n",
        "You should work through this section at your own pace. \n",
        "\n",
        "## Overview\n",
        "\n",
        "Nextstrain is an open-source visualisation tool created for genomic epidemiology.  Since the pandemic started, it has gained popularity amongst researchers studying outbreaks, and government workers who aim to understand and control transmission at local, state, and national levels.  \n",
        "\n",
        "To get an overview of what Nextstrain does, have a look at a particular Nextstrain *build* [here](https://nextstrain.org/community/parkercline/CSU-SARS-CoV-2/ncovupdate).  \n",
        "\n",
        "## The web interface \n",
        "\n",
        "The first thing you should see is a pretty complicated phylogenetic tree, filled with all the samples that have been collected in infected individuals.  Remember that the phylogenetic tree relates different samples based on how *similar* or *close* they are to eachother; and this is dependent on how similar the genetic code is for each sample.  \n",
        "\n",
        "If you scroll down, you'll see a world map.  This links the genomic data (the samples in the tree) to the *metadata* collected on each sample; specifically, the geolocation of where the sample was collected.  This map shows the inferred movement of the virus across various continents.  \n",
        "\n",
        "The next pane shows the *genome* of the reference sequence, and the vertical lines show how many mutations have ocurred across all samples at that specific point in the SARS-CoV-2 genome.  Note that the x-axis (horizontal line at the bottom) extends from `0` to `30,000`.  Can you work out what this number represents? \n",
        "\n",
        "\n",
        "\n",
        "## Using the command line interface\n",
        "\n",
        "The command line is an incredibly powerful and simple way to interact with programs on your own machine and over the internet.  It may take some effort to work with it if you're used to moving and clicking a mouse to interact with your computer."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Steps\n",
        "\n",
        "Before we can visualise our trees using Nextstrain, we should first try processing the data *locally*.   \n",
        "\n",
        "\n",
        "The first step is to retrieve our samples.  We can do this by copying the files from the internet, into a *directory*. \n",
        "\n",
        ">TIP: You can think of a 'directory' as just a 'folder' on your computer, or in this case, in this web-based environment\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3VOftqUsa9YN"
      },
      "source": [
        "### MAKE A DIRECTORY \n",
        "\n",
        "To visualise where we are in the *file system*, we can use the command `pwd` to see which directory we are currently accessing.  The command has already been written for you, so press the play button on the code cell to run it.\n",
        "\n",
        "\n",
        "> TIP: The `!` symbol before the command just tells the notebook to treat what we've typed as a *shell command*. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xU6iFH1ublB9",
        "outputId": "c39d54cc-48e8-4f7c-f5cb-a3a3b70d952f"
      },
      "outputs": [],
      "source": [
        "!pwd"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApxuB5eZbt1F"
      },
      "source": [
        "Excellent! So we're in the `/content` directory.  Notice that we input some text (by clicking play on the cell) and we got back some text as *output*.  This is the main idea of using a command line interface.  \n",
        "\n",
        "To see what is in this current directory, type `!ls` (abbreviation for 'list').\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B_p6YbuUcMEM"
      },
      "outputs": [],
      "source": [
        "!ls"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QXRNJBxhcO4t"
      },
      "source": [
        "We get nothing back, so that means that this directory is empty.  We'd like to create a new one to keep our files for this project neat and tidy.  To create a new directory in the current directory, we can use the command `mkdir`, which stands for \"make directory\".  `mkdir` also requires an *argument* to be passed to it, to specify the name of the directory.  For example, typing `mkdir cat-pictures` would create a new directory called 'cat-pictures'.  Notice that we added a `-` between the words `cat` and `pictures`, as we can't name files with spaces.  \n",
        "\n",
        "Make a new directory called \"\". \n",
        "\n",
        "> TIP: remember the `!` symbol!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RO3r4PNHdPZf"
      },
      "outputs": [],
      "source": [
        "!mkdir samples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-7z8UV00iExg"
      },
      "source": [
        "To navigate to various directories, you can use `cd` (change directory) and then specify the directory name.  Try navigating into the one you've just made.  To confirm which directory you're in, you can also use `pwd` again.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w9b5LDpUiThW",
        "outputId": "3879f0da-1537-4416-ce26-de4dbc219eef"
      },
      "outputs": [],
      "source": [
        "!ls"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ZfMhvCkiULr"
      },
      "source": [
        "Now that we're in the *samples* directory, let's retrieve our sequences.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Wos2hKWRizfq"
      },
      "outputs": [],
      "source": [
        "# Clone samples from GitHub repositiory into the current directory. \n",
        "!rm -R Virus-Tracker-Sequences/\n",
        "!git clone https://github.com/cimranm/Virus-Tracker-Sequences.git "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vb7zeeAvi-BP"
      },
      "source": [
        "This should give you two new directories in *samples* called *sequences* and *ncov*.\n",
        "\n",
        "*ncov* contains the architecture that will allow us to use Nextrain on the command line, by running the code below."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create a Nextstrain build to investigate our sample sequences\n",
        "%%bash\n",
        "source activate base\n",
        "conda activate nextstrain\n",
        "cd Virus-Tracker-Sequences/ncov/\n",
        "# nextstrain check-setup\n",
        "nextstrain build . --cores 1 --use-conda --configfile ./my_profiles/getting_started/builds.yaml"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The output of the above code should generate a .json file in the directory `./Virus-Tracker-Sequences/ncov/auspice/ncov_australia_victoria.json`. Download this file, and drag it onto Nextstrain's visualisation page, by opening [this link](https://auspice.us/) into your browser.\n",
        "\n",
        "> Does the Nextstrain phylogenetic tree match the on you created on ClustalW?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Metadata collected from QR code scans has also come in from Health Victoria for these samples. \n",
        "\n",
        "* Sample A location: McDonald's Bourke St\n",
        "* Sample B location: Schmucks Bagels\n",
        "* Sample C location:  the Federal Circuit Court \n",
        "* Sample D location:  the Federal Circuit Court \n",
        "* Sample E location: Melbourne park\n",
        "\n",
        ">Does this confirm your prediction from Q2?\n",
        "\n",
        "As you can see, sample E is from a different cluster from the other sequences. As Health Victoria performs weekly waste water testing, a new sample of COVID-19 has been collected.\n",
        "\n",
        "* Sample F: Australia/VIC06/2020\n",
        "\n",
        "> Recreate the tree, with the new sample.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "As you can see from your new graph, sample F is connected by an extra branch now that the sequence has been added to the databank.\n",
        "\n",
        "#### Q3 \n",
        "What signficance does Sample F have in enhancing our understanding of identifing clustered outbreaks?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Insert your answer here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Conclusion\n",
        "In conclusion, we can see that Dovak Njokovic did transmit the virus, and through investigating the genomic sequences we can identify more precisely which locations he was at, and their corresponding clusters.\n",
        "\n",
        "Bioinformatics doesn't just help us when we are in a global pandemic! In fact, there are a wide range of disciplines from forensic genomics to artificial intelligence (AI) applications that are innovating the field day by day.  It's a diverse area that includes many aspects of research, from understanding big questions like how life began on earth; through to anti-ageing research and curing diseases. \n",
        "\n",
        "If today's course interested you, please seek the below resources to find the next steps in your bioinformatics journey.\n",
        "\n",
        "## Feedback\n",
        "Please fill out the [feedback survey](https://forms.gle/jjRzUfn34LYSKBuf9), so we can improve participants' experience in this workshop.\n",
        "\n",
        "We hope you enjoyed this session, and learned something new that you didn't know before.  This workshop was created thanks to the School of Computer Science and Engineering at UNSW, and they run courses in bioinformatics at uni.  Feel free to explore the following resources for more information. \n",
        "\n",
        "##### RESOURCES\n",
        "[UNSW Bioinformatics](https://www.unsw.edu.au/study/undergraduate/bachelor-of-engineering-honours-bioinformatics?studentType=Domestic) - explore the bioinformatics engineering program offered at UNSW.  In it you'll learn about genetics, key principles of biology, some biochemistry, maths and stats, and computer programming.  \n",
        "\n",
        "[UNSW Science Degree](https://www.handbook.unsw.edu.au/undergraduate/programs/2022/3970) - have a look at other majors you can do that are related to bioinformatics such as Biotechnology, as part of a Science degree at UNSW. \n",
        "\n",
        "[UNSW Bioinformatics Society](https://www.unswbinfsoc.com) - a student run society on campus for those studying bioinformatics.\n",
        "\n",
        "[NIH Bioinformatics Resources](https://www.nihlibrary.nih.gov/services/bioinformatics-support/online-bioinformatics-tutorials) - includes lectures, tutorials, etc.     "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Homework\n",
        "Now that we have solved the Health Victoria's challenge, there is still a wide range of genomic investigations that you can conduct yourself. Work through the below activities at your own pace to expand your skills."
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {
        "id": "usSC6JXujDp2"
      },
      "source": [
        "### RETRIEVE REFERENCE GENOME\n",
        "\n",
        "Now, we need to get the SARS-CoV-2 **reference genome** to compare our sequences with.  To do this, we can obtain the data from the \n",
        "*National Center for Biotechnology Information* or NCBI; a branch of the *National Institutes of Health* in the United States.  \n",
        "\n",
        "Go to the NCBI SARS-CoV-2 website [here](https://www.ncbi.nlm.nih.gov/sars-cov-2/) and scroll down to **SARS-CoV-2 Sequence Resources**.  Here you can have a look around the graphical dislpay of the genome (click `View Display`). \n",
        "\n",
        "\n",
        "Go ahead and click `View Record` for '**NCBI RefSeq** SARS-CoV-2 genome sequence record'.  This will take you to the NCBI reference sequence isolated from Wuhan.  You can scroll through and look at the structure of the file on the webpage, noting that at the top there are various data on the collected sample, and the protein coding regions.  Towards the bottom, the actual 4-letter code of the genome can be seen. \n",
        "\n",
        "At the top left, change the format from `GenBank` to `FASTA` by clicking on `FASTA`.  \n",
        "\n",
        "\\# link should be https://www.ncbi.nlm.nih.gov/nuccore/NC_045512.2?report=fasta \n",
        "\n",
        "Download the sequence using the `Send to:` button on the top right, and choosing `Complete Record` and `File`. The format should be `FASTA`, and click `Create File`.  The file will download to your local computer, so you may have to move it to your working directory.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3qZOG25Ci7aS",
        "outputId": "8ffdf1b6-afb2-4f24-ecf2-35b44ca423e1"
      },
      "outputs": [],
      "source": [
        "!wget https://www.ncbi.nlm.nih.gov/nuccore/NC_045512.2?report=fasta"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jmgkV1jbuOba",
        "outputId": "2bb1ca3c-be3e-4266-f990-1b5666050e19"
      },
      "outputs": [],
      "source": [
        "!ls"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "45fsYfetzgWn",
        "outputId": "aef3f5ca-064f-405e-f891-eb967900b738"
      },
      "outputs": [],
      "source": [
        "!wget  \"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nucleotide&id=NC_045512.2&rettype=fasta\" -O refgenome.fasta\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nyrEOjygyEYx"
      },
      "source": [
        "Now that we have our reference sequence `refgenome.fasta`, we have something to compare our samples to.  However, we are only interested in the particular region of interest: the **coding region** for the **spike protein**, or *S*.  We need to 'trim' our sequence data to just this region so that our alignment program only compares the sequences by looking at differences in *S*. \n",
        "\n",
        "To do this, we can use some text-editing tools on the command line.  Because the FASTA file format stores nucleotide sequences (such as the genome of SARS-CoV-2) as just simply text characters (i.e. A, G, C and T) we can use programs designed for text manipulation and they'll work just fine.  \n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cY6HiLyt5PNg"
      },
      "source": [
        "Let's use `extractseq` on the command line to take just a subset of the genome sequence.  But we first need to work out which subset to take!\n",
        "\n",
        "Go back to the NCBI webpage, and make sure you have the **GenBank** format open.  Remember, you can switch this with the button on the top left.  The FASTA format (which is the one we downloaded) only has the raw sequence information (just the letters) and a single header line.  The GenBank file has details in the header about the genome, including where different genes are located.  \n",
        "\n",
        "> TIP: Positions along a genome are given in 'base pairs', or letters.  For example, the range **1...10** of a genome means the first 10 letters of the sequence.  \n",
        "\n",
        "\n",
        "See if you can find the location of the *S* gene, or the spike glycoprotein in SARS-CoV-2.  You'll need two numbers; one for the **start position** of the gene, and one for the **end position**.  \n",
        "\n",
        "> HINT: use Ctrl+F!\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8Ix2cbK17p0e"
      },
      "outputs": [],
      "source": [
        "# \\ Location is 21563-25384 "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8pKAFKBh7whZ"
      },
      "source": [
        "Now that you know where the *S* gene is, let's extract this region from our reference sequence and save it as a new file.  \n",
        "\n",
        "Type `extractseq` on the command line and follow the prompts.  At the end it should ask you for an output file, you can call this anything you like or just press `Enter` to let it pick a default name.  However, you should be mindful of which number sequence you obtained the extraction from.  \n",
        "\n",
        ">Tip: calling your file something like `seq1_S.fasta` to indicate that it's the *S* protein section may be useful later on.\n",
        "\n",
        "After saving, you can type `ls` again to confirm that the file is indeed in the current directory.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PxWn0SNN8Mds",
        "outputId": "5dcb7958-6f87-431f-839b-78523deb7606"
      },
      "outputs": [],
      "source": [
        "!extractseq"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qPZcU9NO8SnJ"
      },
      "source": [
        "### REPEATING FOR OUR SAMPLE SEQUENCES\n",
        "Great! We just extracted the *S* protein region from the reference genome.  \n",
        "\n",
        "But we also need to do the same for our sample sequences.  We could just repeat the same steps manually for each file, but imagine if we wanted to do this extraction on 100 files! The beauty of the command line comes in when we can do repetetive tasks easily by automating them.  \n",
        "\n",
        "If we were really serious about this part, we would probably write a *shell script* to execute the commands for us in a predictable way.  For now, just repeat what you did before by hand by typing in the commands and creating the new files for each sequence.  "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Run extractseq for each of the remaining files \n",
        "!extractseq"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### CONCATENATING FILES\n",
        "\n",
        "Now that we have our individual *S* protein sequences, we need to combine them into one `.fasta` file before we can build the phylogenetic tree.  A very easy way to do this is with the command `cat`, short for con*cat*enate.  \n",
        "\n",
        "If you named the extracted sequences with consistent names (such as appending each original name with `_S.fasta` or similar), then we can use a **wildcard** character to combine all these files.  \n",
        "\n",
        "For example, to combine all `.fasta` files in the current directory, you could type \n",
        "\n",
        "```bash \n",
        "cat *.fasta\n",
        "```\n",
        "\n",
        "This would find all files in the current directory that end with `.fasta` and run the program on all of them.  This `*` symbol is a placeholder for any character, any amount of times (or no characters).  \n",
        "\n",
        "\n",
        "Try running `cat` with all the sequences you got from using `extractseq`. \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        " !cat <FILENAMES GO HERE>  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "If you've done this correctly, you should get one blob of text output -- which will be each individual FASTA file connected to eachother.  \n",
        "\n",
        "But we want to *save* this output as a new file.  To save the output of any command to a file, we can **redirect** the output by using the `>` character on the command line.  \n",
        "\n",
        ">Tip: don't be confused with the `>` character as part of a command; and the same character '>' showing up *within* a FASTA file.  They mean two different things and are ony coincidentally the same character!\n",
        "\n",
        "For example, to put the words \"hello world\" into a file called `greeting.txt` (and create the file if it does not already exist), the following command could be run: \n",
        "\n",
        "```\n",
        "echo \"hello world\" > greeting.txt\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "!echo \"hello world\" > greeting.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Try putting all this together, and re-running the previous `cat` command with all the fasta files that contain the *S* protein sequences -- only this time, *redirect* the output into a new file called `all_seqs.fasta`. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Your code goes here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Let's also bring in the reference genome sequence that we created earlier.  Again, we can use `cat` -- only this time we can give it the `all_seqs.fasta` file, and the reference genome file.  We can add `> inputseqs.fasta` to the same line, and this will effectively combine `all_seqs.fasta` and the reference genome into this new file `inputseqs.fasta`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fo1cpd618lRJ"
      },
      "source": [
        "### ALIGNMENT \n",
        "\n",
        "Let's align our samples and reference sequence together.  This is the step that allows us to produce a phylogenetic tree that relates all the sequences to eachother.  For this, we'll use `clustalw` again.  Recall that this is the same program we used in the *multiple sequence alignment* example earlier.  Once again, run the program and follow the prompts.  \n",
        "\n",
        "Remember to `Load sequence from disk` first, and to use the `inputseqs.fasta` file. \n",
        "\n",
        ">Tip: use the `Multiple alignment` option afterwards. \n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Npj7ddvz9EqJ",
        "outputId": "7ea2681c-e0d8-444e-d9d5-f37bf92cdb62"
      },
      "outputs": [],
      "source": [
        "!clustalw -interactive -infile=inputseq_S.fasta"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "To create a phylogenetic tree using clustalw, we will use option `4`.  Use the alignment that we created earlier (the `.aln` file) as the input.\n",
        "\n",
        "You may also need to use option `6` to change the output.  We want a PHYLIP output file, so toggle this `ON` and the other formats to `OFF`.  Go back to the previous menu and choose `Draw tree now`.  We can exit the program, and there should be a `.ph` file in our directory (remember what name the program saved it as!)\n",
        "\n",
        ">Hint: you can use the `cat` command to view the contents of files on the command line without having to open a text editor. \n",
        "\n",
        "We can visualise our tree by using a commandline program just for this purpose.  \n",
        "\n",
        "Run the following command, replacing `<FILENAME>` with your `.ph` file. \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Add your filename and run \n",
        "!ete3 view --text -t <TREEFILE>.ph  "
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "virus-tracker-interactive.ipynb",
      "provenance": []
    },
    "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.8.10 (default, Jun 22 2022, 20:18:18) \n[GCC 9.4.0]"
    },
    "vscode": {
      "interpreter": {
        "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}