Mutation Simulator

#!/usr/bin/env python3

###############################################################################
##  Title: Mutation Simulator
##  Author: Michael Sieler
##  Date: May 10th, 2021
##  Description: A mutation simulator that calculates sequence similarity of
##              two or more organisms and prints the result to the screen.
##  Notes:
##      - User must define number of organisms, genome size and mutation rate
##      - Script is organised by Classes, Functions, and Main script
##      - Script is saved to ACTF as well under the following directory:
##          `/ACTF/Course/mgb_s21/home/sielerjm/Exams/Exam_2/mutationSimulator.py`
##      - To run script, enter: `./mutationSimulator.py`
###############################################################################


## Import Libraries
import random


###############################################################################
################################# CLASSES #####################################
###############################################################################


class Organism():
    """
    Organism class
        Defines functions for creating an organism object with the following attributes:
            ID: integar
            Generation: counter of how many times the object has "reproduced"
            Size: integar of genome size, defined by user
            Genome: list of nucleotides
            mutCount: mutation counter
            mutRate: mutation rate, defined by user
    """

    def __init__(self, id, generation, size, genome, mutCount, mutRate):
        self.id = id  # name of organism
        self.generation = generation  # generation counter
        self.size = size  # genome size
        self.genome = genome[:]  # genome sequence
        self.mutCount = mutCount  # mutation counter
        self.mutRate = mutRate  # Default rate is 1 in a million

    # Getters
    def get_id(self):
        return self.id

    def get_genome(self):
        return self.genome[:]

    def get_generation(self):
        return self.generation

    def get_size(self):
        return self.size

    def get_mutRate(self):
        return self.mutRate

    def get_mutCount(self):
        return self.mutCount

    def reproduce(self):
        temp_genome = self.get_genome()[:]  # copies genome from previous generation

        for index in range(100): # repeat 100 times
            if ((index + 1) % 10) == 0:
                print("Generation #{}:".format(index+1))
                print("\tMutation Count: {}".format(self.get_mutCount()))

            for index in range(self.get_size()):  # copies one base at a time with a chance of mutation
                temp_mutation = random.randint(0, (self.mutRate - 1) )  # subtract one because starts at zero

                if temp_mutation == 0:  # arbitrary number
                    temp_genome[index] = self.mutation(temp_genome[index])
                    self.set_mutCount()

            self.set_generation()  # Increases generation by 1

        self.set_genome(temp_genome)


    # Setters

    def set_id(self, num):
        self.id = num

    def mutation(self, base):
        temp_base = base

        if temp_base == "A":
            TGC = {0:"T", 1:"G", 2:"C"}
            temp_base = random.choice(list(TGC.values()))

        elif temp_base == "T":
            AGC = {0:"A", 1:"G", 2:"C"}
            temp_base = random.choice(list(AGC.values()))

        elif temp_base == "G":
            ATC = {0:"A", 1:"T", 2:"C"}
            temp_base = random.choice(list(ATC.values()))

        elif temp_base == "C":
            ATG = {0:"A", 1:"T", 2:"G"}
            temp_base = random.choice(list(ATG.values()))

        return temp_base

    def set_mutCount(self):  # Increases the mutation count by 1
        self.mutCount += 1

    def set_newGenome(self):
        self.genome = self.randomsequence(self.get_size())

    def set_genome(self, sequence):
        self.genome = sequence[:]

    def set_generation(self):
        self.generation += 1

    def randomsequence(self, size):
        ATGC = ["A", "T", "G", "C"]
        temp = []  # Creates an empty string

        for index in range(size):
            temp.append(ATGC[random.randint(0, 3)])  # randomly picks a nucleotide and adds to empty string
            #print("inside randomsequence(): #{}".format(index))

        return temp


###############################################################################
################################ FUNCTIONS ####################################
###############################################################################


# Calculates the difference and returns sequence similarity between two organisms
def calcNumDiff(org1, org2):
    temp_diff = 0
    seqA = org1.get_genome()[:]
    seqB = org2.get_genome()[:]
    for index in range(len(seqA)):
        if seqA[index] != seqB[index]:
            temp_diff += 1
    return (1 - (temp_diff/org1.get_size()))


# Prints basic information about the organism
def printOrganismInfo(org):
    print("\nOrganism #{} \n  Genome size: {} \n  Number of generations: {} \n  Mutation count: {} \n  Mutation rate: {}  \n  First 20 nucleotides: {}\n".format(org.get_id(), org.get_size(), org.get_generation(), org.get_mutCount(), org.get_mutRate(), org.get_genome()[0:20]))


###############################################################################
############################# START OF SCRIPT #################################
###############################################################################

print("Running Mutation Simulator, written by Michael Sieler 2021\n")

# Initialize Variables
numOrganisms = 3
organism = []
diffCount = 0
setGenomeSize = 2*10**6
setMutRate = 1*10**6

for number in range(numOrganisms):
    if number == 0: # Generates a parent organism
        organism.append(number)

        # id, generation, size, genome, mutCount, mutRate
        organism[number] = Organism(0, 0, setGenomeSize, "", 0, setMutRate)

        organism[number].set_newGenome()
        printOrganismInfo(organism[number])

    elif number > 0: # Generates child organisms
        organism.append(number)

        # Copies genome from parent organism
        organism[number] = Organism(number, 0, organism[0].get_size(), organism[0].get_genome()[:], 0, organism[0].get_mutRate())

        printOrganismInfo(organism[number]) # Prints some basic info BEFORE mutations
        organism[number].reproduce()
        printOrganismInfo(organism[number]) # Prints some basic info AFTER mutations



# Sequence similarity between organisms 1 and 2
print("Sequence similarity between 1 and 2: {}".format(calcNumDiff(organism[1], organism[2])))

# Sequence Similarity of child organisms to parent
print("Sequence similarity between 1 and 0: {}".format(calcNumDiff(organism[1], organism[0])))
print("Sequence similarity between 2 and 0: {}".format(calcNumDiff(organism[2], organism[0])))