Instantly share code, notes, and snippets.

@jeanpat /Cellular.py
Last active Jul 15, 2018

Embed
What would you like to do?
Modules used in telomere length modelisation
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 30 13:04:37 2016
@author: jeanpat
"""
import pandas as pn
from itertools import product
import ClassChromosome as K
import Genome as G
def init_genome(telomeres_distribution =
{"1":(15000,18000,9000,12000),
"2":(11000, 20000, 11050,19950)}):
'''telomeres_distribution is a dictionary:
{"1":(15000,18000,9000,12000), "2":(11000, 20000, 11050,19950)}
'''
if type(telomeres_distribution) != type(dict()):
raise NameError('Telomere length must be a dictionary "chrom1":(p1,q1,p2,q2)')
chrom_set = []
for tels in telomeres_distribution.keys():
t0 = telomeres_distribution[tels][0]#first homolog at pter
t1 = telomeres_distribution[tels][1]#first homolog at qter
t2 = telomeres_distribution[tels][2]#other homolog at pter
t3 = telomeres_distribution[tels][3]#other homolog at qter
w1 = K.Watson(ttaggg = t0, ccctaa = t1)
c1 = K.Crick(ttaggg = t1, ccctaa = t0)
w2 = K.Watson(ttaggg= t2, ccctaa = t3)
c2 = K.Crick(ttaggg= t3, ccctaa = t2)
#chrom_set.ap
chrom_set.append(K.Chromosome(watson=w1,crick=c1, name =str(tels),homolog='mat'))
chrom_set.append(K.Chromosome(watson=w2,crick=c2, name =str(tels),homolog='pat'))
return G.Genome(*chrom_set)
class Cell(object):
# def init_genome(self, telomeres_distribution = {"1":(15000,18000,9000,12000),
# "2":(11000, 20000, 11050,19950)}):
# '''telomeres_distribution is a dictionary:
# {"1":(15000,18000,9000,12000), "2":(11000, 20000, 11050,19950)}
#
# '''
# print "init_genome"
# if type(telomeres_distribution)<>type(dict()):
# raise NameError('Telomere length must be a dictionary "chrom1":(p1,q1,p2,q2)')
# chrom_set = []
# for tels in telomeres_distribution.keys():
# t0 = telomeres_distribution[tels][0]#first homolog at pter
# t1 = telomeres_distribution[tels][1]#first homolog at qter
# t2 = telomeres_distribution[tels][2]#other homolog at pter
# t3 = telomeres_distribution[tels][3]#other homolog at qter
#
# w1 = K.Watson(ttaggg = t0, ccctaa = t1)
# c1 = K.Crick(ttaggg = t1, ccctaa = t0)
#
# w2 = K.Watson(ttaggg= t2, ccctaa = t3)
# c2 = K.Crick(ttaggg= t3, ccctaa = t2)
# #chrom_set.ap
# chrom_set.append(K.Chromosome(watson=w1,crick=c1, name =str(tels),homolog='mat'))
# chrom_set.append(K.Chromosome(watson=w2,crick=c2, name =str(tels),homolog='pat'))
# return G.Genome(*chrom_set)
#
def __init__(self,division = 0,
genome = init_genome(),
short_telomere_threshold = 200,
telomerase = {'ON':False,
'Docking':(1000,0.95),
'Elongation':(200,0.95)}
):
self.division = division
#
#telomerase parametres
self.telomerase_par = telomerase
self.telomerase_ON = self.telomerase_par['ON']
#telomere lenght theshold (bp)for telomerase docking
#simulation of the D-loop opening:
self.docking_threshold = self.telomerase_par['Docking'][0]
#docking probability: bellow the docking threshold,
#the probability for the telomerase to dock is:
self.docking_proba = self.telomerase_par['Docking'][1]
# When telomerase is docked the TTAGGG motif is elongated
# by n bases (ex:200) with a probability of p (p=0.95):
self.tel_elongation = self.telomerase_par['Elongation'][0]
self.elongation_prob = self.telomerase_par['Elongation'][1]
#### GENOME initialization ####
self.genome = genome
self.short_telomere_threshold = short_telomere_threshold
self.genome_dataframe()
self.shortest_telo = self.scan_shortest_telomere()
if self.shortest_telo <= self.short_telomere_threshold:
## The cell becomes senescent, blocked in G0
self.G0 = True
else:
self.G0 = False
#def scan_shortest_telomere(self):
# df = self.genome_dataframe()
# return df.T.min()[0]
def scan_shortest_telomere(self):
df = self.genome_dataframe()
#telomeres_list = df.columns-['division']
telomeres_list = df.columns[1:]
shortest_telo = df.ix[:, telomeres_list ].min().min()
#print shortest_telo
return shortest_telo
def mitose(self):
# check if G_0 can be left
#print type(self.genome)
# trigger genome replication
self.shortest_telo = self.scan_shortest_telomere()
#print type(shortest_telo[0]),shortest_telo[0]
if self.shortest_telo <= self.short_telomere_threshold:
## The cell becomes senescent, blocked in G0
self.G0 = True
#return None
else:
self.genome.set_G1_to_G2()
#trigger telophase
son_genome = self.genome.G2_to_M()
#print self.division
self.division = self.division +1
self.genome_dataframe()
daughter_cell = Cell(division = self.division,
genome = son_genome,
telomerase = self.telomerase_par,
short_telomere_threshold = self.short_telomere_threshold)
# Check post replication if the shortest telomere is bellow threshold
#Check mother cell
self.shortest_telo = self.scan_shortest_telomere()
if self.shortest_telo <= self.short_telomere_threshold:
## The cell becomes senescent, blocked in G0
self.G0 = True
#Daughter cell: the telomere length is checked on initialisation. If the shortest telo
#of the daughter cell is bellow threshold, the daughter cell is blocked in G0
return daughter_cell
def genome_dataframe(self):
'''Return all the telomere in a pandas data_frame, one column per telomere
the homologs must be distinguished by a tag: eg:maternal,paternal
'''
chroms = self.genome.get_chromosomes_list()
homogs = self.genome.get_homologous_tags()
telo = {}
#telo['division'] = self.division
div_df = pn.DataFrame({'division' : self.division}, index = [0])
for telomeric in product(chroms,['pter','qter'], '_',homogs):
telo[''.join(telomeric)]= [self.genome.get_telo_length(pair=telomeric[0],
hog=telomeric[3],
tel=telomeric[1])]
self.telo_df = pn.DataFrame(telo)#pandas dataframe
self.telo_df = pn.concat([div_df,self.telo_df], axis = 1)
return self.telo_df
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 6 11:29:52 2012
@author: Jean-Patrick Pommier
"""
from WatsonCrick import Watson, Crick
import random
class Chromosome(object):
def __init__(self,watson = Watson(ttaggg = 10001, ccctaa = 5000), crick = Crick(ttaggg = 5000, ccctaa = 10000), name ='1', homolog ='a'):
#print 'new chromosome'
watson.in_use = True
crick.in_use = True
self.name = name
self.homolog = homolog
self.phase = 'G1'
self.watson = watson
self.crick = crick
#Double strand DNA
self.chromatide = []
self.chromatide.append(self.watson)
self.chromatide.append(self.crick)
self.chromosome = []
self.chromosome.append(self.chromatide)#chromosome with one chromatid
def set_G1_to_G2(self):
self.phase = 'G2'
self.sister_chromatid1 = []
self.sister_chromatid2 = []
# temporary variables
self.ctd = self.chromosome.pop()
self.strand1 = self.ctd.pop()
self.strand2 = self.ctd.pop()
self.sister_chromatid1.append(self.strand1)
self.sister_chromatid1.append(self.strand1.replicate())
self.sister_chromatid2.append(self.strand2)
self.sister_chromatid2.append(self.strand2.replicate())
self.chromosome.append(self.sister_chromatid1)
self.chromosome.append(self.sister_chromatid2)
def segregate(self) :
'''gives two sister chromatids from metaphasic chromosome
'''
def getWatsonCrick_Index_in(chromatid):
if type(chromatid[0]) == Watson:
return 0, 1
else:
return 1, 0
if self.phase == 'G2':
index = random.randint(0,1)
#print index
# get one of the two chromatids of the G2 chromosome
self.sister_ctd1 = self.chromosome.pop(index)
w, c = getWatsonCrick_Index_in(self.sister_ctd1)
#Back to G1 state in the cell cycle after chromosome segregation
self.phase = 'G1'
son = Chromosome(self.sister_ctd1.pop(w),self.sister_ctd1.pop(), name = self.name, homolog=self.homolog)
return son
else:
raise NameError ('chromosome segregation only on metaphasic chrom!')
#==============================================================================
#
#==============================================================================
def get_Crick(self):
'''Returns a single strand of type Crick
'''
if type(self.chromosome[0][0]) == Crick:
return self.chromosome[0][0]
else:
return self.chromosome[0][1]
def get_Watson(self):
'''Returns a single strand of type Watson
'''
if type(self.chromosome[0][0]) == Watson:
return self.chromosome[0][0]
else:
return self.chromosome[0][1]
def get_pter_G1(self, motif='ccctaa'):
'''telomere length at pter = nber of ccctaa motifs on Crick single strand
telomere length at pter = nber of ttaggg motifs on Watson single strand
'''
#get index of crick strand in chromatid[]
if motif == 'ccctaa':
if self.phase == 'G1':
if type(self.chromosome[0][0]) == Crick:
return self.chromosome[0][0].getCCCTAA()
else:
return self.chromosome[0][1].getCCCTAA()
else:
raise NameError('only on G1 chromosome')
elif motif =='ttaggg':
if self.phase == 'G1':
if type(self.chromosome[0][0]) == Watson:
return self.chromosome[0][0].getTTAGGG()
else:
return self.chromosome[0][1].getTTAGGG()
else:
raise NameError('only on G1 chromosome')
def get_qter_G1(self,motif='ccctaa'):
'''telomere length at qter = nber of ccctaa motifs on Watson single strand
telomere length at qter = nber of ttaggg motifs on Crick single strand
'''
#get index of crick strand in chromatid[]
if motif == 'ccctaa':
if self.phase == 'G1':
if type(self.chromosome[0][0]) == Watson:
return self.chromosome[0][0].getCCCTAA()
else:
return self.chromosome[0][1].getCCCTAA()
else:
raise NameError('only on G1 chromosome')
elif motif =='ttaggg':#ERROR
if self.phase == 'G1':
if type(self.chromosome[0][0]) == Crick:
return self.chromosome[0][0].getTTAGGG()
else:
return self.chromosome[0][1].getTTAGGG()
else:
raise NameError('only on G1 chromosome')
def get_pter_G2(self,motif='ccctaa'):
'''telomere length at pter = nber of ccctaa motifs on Crick single strand
telomere length at pter = nber of ttaggg motifs on Watson single strand
'''
def getCrickindex_chromatid1():
'''get the index of the Crick strand in chromatid1
'''
if type(self.sister_chromatid1[0]) == Crick:
return 0
else:
return 1
def getCrickindex_chromatid2():
'''get the index of the Crick strand in chromatid2
'''
if type(self.sister_chromatid2[0]) == Crick:
return 0
else:
return 1
def getWatsonindex_chromatid1():
if type(self.sister_chromatid1[0]) == Watson:
return 0
else:
return 1
def getWatsonindex_chromatid2():
if type(self.sister_chromatid2[0]) == Watson:
return 0
else:
return 1
if self.phase == 'G2':
if motif == 'ccctaa':
c1 = getCrickindex_chromatid1()
c2 = getCrickindex_chromatid2()
return self.sister_chromatid1[c1].getCCCTAA(),self.sister_chromatid2[c2].getCCCTAA()
elif motif == 'ttaggg':
w1 = getWatsonindex_chromatid1()
w2 = getWatsonindex_chromatid2()
ttaggg1 = self.sister_chromatid1[w1].getTTAGGG()
ttaggg2 = self.sister_chromatid2[w2].getTTAGGG()
return ttaggg1, ttaggg2
else:
raise NameError('only on G2 chromosome')
def get_qter_G2(self,motif='ccctaa'):
'''telomere length at qter = nber of ccctaa motifs on Watson single strand
telomere length at qter = nber of ttaggg motifs on Crick single strand
on each chromatid
'''
#get index of Watson strand in chromatid[]
def getWatsonindex_chromatid1():
'''get the index of the Watson strand in chromatid1
'''
if type(self.sister_chromatid1[0]) == Watson:
return 0
else:
return 1
def getWatsonindex_chromatid2():
'''get the index of the Watson strand in chromatid2
'''
if type(self.sister_chromatid2[0]) == Watson:
return 0
else:
return 1
def getCrickindex_chromatid1():
'''get the index of the Crick strand in chromatid1
'''
if type(self.sister_chromatid1[0]) == Crick:
return 0
else:
return 1
def getCrickindex_chromatid2():
'''get the index of the Crick strand in chromatid2
'''
if type(self.sister_chromatid2[0]) == Crick:
return 0
else:
return 1
if self.phase == 'G2':
if motif == 'ccctaa':
w1 = getWatsonindex_chromatid1()
w2 = getWatsonindex_chromatid2()
return self.sister_chromatid1[w1].getCCCTAA(),self.sister_chromatid2[w2].getCCCTAA()
elif motif == 'ttaggg':
c1 = getCrickindex_chromatid1()
c2 = getCrickindex_chromatid2()
ttaggg1 = self.sister_chromatid1[c1].getTTAGGG()
ttaggg2 = self.sister_chromatid2[c2].getTTAGGG()
return ttaggg1, ttaggg2
else:
raise NameError('only on G2 chromosome')
def telomere_length(self,end = 'pter', motif = 'ccctaa'):
'''returns the telomere length (TTAGGG with motif='ttaggg' or CCCTAA with motif='ccctaa')
of a chromosome, given the location:end='pter' or end='qter'.
For a chromosome in G1 cell cycle, the length is a single number.
For a chromosome in G2, the length is a tuple, one value for each chromatid.
'''
if self.phase == 'G1':
if end == 'pter':
if motif =='ccctaa':
return self.get_pter_G1(motif)
elif motif =='ttaggg':
return self.get_pter_G1(motif)
elif end =='qter':
if motif =='ccctaa':
return self.get_qter_G1(motif)
elif motif =='ttaggg':
return self.get_qter_G1(motif)
elif self.phase =='G2':
if end == 'pter':
if motif =='ccctaa':
return self.get_pter_G2(motif)
elif motif =='ttaggg':
return self.get_pter_G2(motif)
elif end =='qter':
if motif =='ccctaa':
return self.get_qter_G2(motif)
elif motif =='ttaggg':
return self.get_qter_G2(motif)
#==============================================================================
#
# S
#
#
#==============================================================================
def test_get_pter():
k = Chromosome()
print( k)
print( 'G1+ccctaa:k.get_pter_G1() ',k.get_pter_G1())
print( "G1+ccctaa:k.get_pter_G1(motif='ccctaa') ",k.get_pter_G1(motif='ccctaa'))
print( "G1+ttaggg:k.get_pter_G1(motif='ttaggg') ",k.get_pter_G1(motif='ttaggg'))
print()
print( '----------------------')
k.set_G1_to_G2()
print( k)
print( "G2+ccctaa:k.get_pter_G1(motif='ccctaa') ",k.get_pter_G2(motif='ccctaa'))
print( "G2+ttaggg:k.get_pter_G1(motif='ttaggg') ",k.get_pter_G2(motif='ttaggg'))
print()
print()
def test_one_replication():
k = Chromosome()
#print k.chromosome
print( 'telomere p/q length G1 (ccctaa):',k.get_pter_G1(motif='ccctaa'),' ',k.get_qter_G1(motif='ccctaa'))
print( 'telomere p/q length G1 (ttaggg):',k.get_pter_G1(motif='ttaggg'),' ',k.get_qter_G1(motif='ttaggg'))
k.set_G1_to_G2()
motif='ccctaa'
print( 'ccctaa G2:','pter',k.get_pter_G2(motif),'qter',k.get_qter_G2(motif))
motif='ttaggg'
print( 'ttaggg G2:','pter',k.get_pter_G2(motif),'qter',k.get_qter_G2(motif))
print( k.chromosome)
neo = k.segregate()
print( 'neo',neo.get_pter_G1(),' ',neo.get_qter_G1())
print( 'c post seg:',k.get_pter_G1(),' ',k.get_qter_G1())
def test_replication(n):
k = Chromosome()
for i in range(n):
k.set_G1_to_G2()
k1 = k.segregate()
print( i,' ',k.get_pter_G1(),',',k.get_qter_G1(),' ',k1.get_pter_G1())
def test_rep(n):
import numpy as np
klist0 = []
k = Chromosome()
print( 'chrom name', k.name)
klist0.append(k)
generation = {}
motif = 'ttaggg'
generation[0] = (k.get_pter_G1(motif), k.get_qter_G1(motif))
for i in range(n):
klist1 = []
for c in klist0:
c.set_G1_to_G2()
for c in klist0:
klist1.append(c.segregate())
klist0 = klist0 + klist1
pq = []
for c in klist0:
pq.append((c.get_pter_G1(motif), c.get_qter_G1(motif)))
generation[i+1] = pq
# print generation.keys()
# print ((0,generation[0][0],generation[0][1]))
table = np.asarray((0,generation[0][0],generation[0][1]))
# print table.dtype
# print 'gen 0:',generation[0]
for g in generation.keys():
# print g,type(generation[g])
for pair in generation[g]:
if g == 0:
break
else:
# print 'g:',g,'pair:',pair,' ',pair[0],pair[1]
tmp = np.asarray((g,pair[0],pair[1]))
table = np.vstack([table,tmp])
return table
#==============================================================================
# Tests
#==============================================================================
if __name__ == "__main__":
test_get_pter()
test_one_replication()
telomeres=test_rep(9)
pter=telomeres[:,1]
print( pter)
qter=telomeres[:,2]
gen=telomeres[:,0]
import matplotlib.pyplot as plt
#import matplotlib.mlab as mlab
from scipy import stats
#import scipy as sc
fig = plt.figure(1)
plt.subplot(312, frameon = True)
plt.scatter(pter,qter,c=gen,s=50)
slope, intercept, r_value, p_value, slope_std_error = stats.linregress(gen, pter)
print( 'slope, intercept:',slope, intercept)
print( telomeres[gen ==4,1])
#plt.scatter(gen,pter)
plt.subplot(311, frameon = True)
# ax = fig.add_subplot(311)
# mu = sc.mean
# y = mlab.normpdf(bincenters, mu, sigma)
plt.hist(telomeres[gen==9,1], bins=100)
plt.subplot(313, frameon = True)
plt.scatter(gen, pter)
plt.show()
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 13 18:25:58 2012
@author: JeanPat
"""
#from WatsonCrick import *
import ClassChromosome as K
import numpy as np
#import pdb
class Genome(object):
''' a genome is a collection of chromosomes
'''
def __init__(self, *args):
def tuplesChrom_to_dict(tu):
''' convert a tuple (('1','a'), ('1','A'), ('2','b'), ('2','B'))
into a dict {'1':('a','A'),'2':('b','B')}
'''
g={}
for c,krom in enumerate(tu):
if krom.name in g:
g[krom.name]=g[krom.name],krom
else:
g[krom.name]=krom
return g
#print type(args)
if len(args) % 2 ==0:
self.ploidy = (len(args) / 2)
else:
self.ploidy = len(args) / 2 , 1
#print('WARNING: Non diploïd genome, delta p/q will crash')
#========================================================================
# Let's populate the genome with chromosomes
#========================================================================
for count, chrom in enumerate(args):
#pdb.set_trace()
if type(chrom) != type(K.Chromosome()):
raise NameError('Genome only loves Chromosomes')
#==============================================================================
# self.genome is dictionary where :
# key= chromosome name (1, 2, 3...)
# values: pair of homologous chromosomes (a or b for ex)
#==============================================================================
self.genome = tuplesChrom_to_dict(args)
#==============================================================================
#
#Let's define what we can get from a genome object:
# * telomere length :
# -of a given chromosome/homolog
# -mean telomere length for the whole genome
# -std dev
# * difference of length:
# -between two homologs
# -distribution of telomere length
# * telomere length ratio:
# -pter / qter for a given chromosome/homolog
# -ratio distribution
# * ordered list of telomeres : ex 1pa, 2pB, 2qA, 1pA, 1qB ...
#==============================================================================
def get_chrom_phase(self, pair='1', hog='a'):
'''get if a chrom '1' homolog 'a' is G1 or G2
'''
homolog = self.get_homologous_chromosome(pair,hog)
return homolog.phase
def get_chromosomes_list(self):
return self.genome.keys()
def get_chrom_pair(self,pair='1'):
return self.genome[pair]#should be a tuple
def get_homologous_tags(self, pair='1'):
'''given a pair of chromosomes, returns the values
of Chromosome.homolog ex ['a','A']
'''
pair = self.get_chrom_pair(pair)
tags=[]
for k in pair:
tags.append(k.homolog)#k should be a Chromosome instance
#print 'tags ', tags
return tags
def get_homologous_chromosome(self,pair,hog):
'''Return one of the two chromosomes: ex
Need chromosome 1, homolog a? ask get_homologous_chromosome('1','a')
'''
pair = self.get_chrom_pair(pair)
chrom1 = pair[0]
chrom2 = pair[1]
if chrom1.homolog == hog:
return chrom1
elif chrom2.homolog == hog:
return chrom2
def get_telo_length(self, pair='1',hog='a', tel='pter',cycle='G1',motif='ccctaa'):
#==============================================================================
# Should use .homolog.phase to know if chromosome is in G1 or G2
#==============================================================================
homolog = self.get_homologous_chromosome(pair, hog)
if (tel == 'pter') and (cycle == 'G1'):
return homolog.get_pter_G1(motif)
elif tel == 'qter' and cycle == 'G1':
return homolog.get_qter_G1(motif)
elif tel == 'pter' and cycle == 'G2':
return homolog.get_pter_G2(motif)
elif tel == 'qter' and cycle == 'G2':
return homolog.get_qter_G2(motif)
else:
raise NameError('Can only get length at pter or qter in G1 or G2 cell cycle')
def get_telomere_length(self,pair='1',hog='a', tel='pter', motif='ccctaa'):
'''need not to know if G1 or G2
'''
homolog = self.get_homologous_chromosome(pair, hog)
return homolog.telomere_length(end = tel, motif = motif)
def get_mean_std_telo_lenght(self, cycle='G1',motif='ccctaa'):
'''compute the mean and standard deviation telomere length in one genome
'''
telomeres = []#an array containing all the telomeres
#print 'genome:',self.genome
for c,kpair in self.genome.items():
homolog1=kpair[0]
homolog2=kpair[1]
#==============================================================================
# Uses ccctaa motifs and chromosomes when G1 cycle is 'on'
#==============================================================================
p1=self.get_telomere_length(pair=homolog1.name, hog=homolog1.homolog,tel='pter')
q1=self.get_telomere_length(pair=homolog1.name, hog=homolog1.homolog,tel='qter')
p2=self.get_telomere_length(pair=homolog2.name, hog=homolog2.homolog,tel='pter')
q2=self.get_telomere_length(pair=homolog2.name, hog=homolog2.homolog,tel='qter')
telomeres.append(p1)
telomeres.append(q1)
telomeres.append(p2)
telomeres.append(q2)
tel = np.asarray(telomeres)
mean_telo = tel.mean()
std_telo = tel.std()
# print telomeres
# print (tel-mean_telo)/std_telo# centrée réduites
return mean_telo,std_telo
def get_pq_ratio(self,pair='1',hog='a',motif='ccctaa'):
'''Compute ratio (length pter)/(length qter) for
a given homologous chromsome
'''
p = self.get_telomere_length(pair,hog,motif,tel='pter')
q = self.get__telomere_length(pair,hog,motif,tel='qter')
if q>0:
return 1.0*p/q
else:
return None
def delta_telo(self,chromPair='1',tel='pter', cycle='G1',motif='ccctaa'):
''' calculate the difference of length between two homologous telomeres
'''
hmlog_tags = self.get_homologous_tags(chromPair)
first_hmlog = hmlog_tags[0]
second_hmlog = hmlog_tags[1]
if cycle == 'G1':
telo1 = self.get_telomere_length(chromPair, first_hmlog, tel,motif)
# print 'telo1',telo1
telo2 = self.get_telomere_length(chromPair, second_hmlog, tel,motif)
# print 'telo2',telo2
# print telo1-telo2
return telo1-telo2
elif cycle == 'G2':
pass
else:
raise NameError('only G1 or G2 cell cycle state')
def distribution_delta_telo(self, mode='raw'):
''' Should return all the difference between all the telomeres two by two
'''
pass
#==================================================
# Let's define what we can do with a genome
# * cell cycle from G1 to G2
# * segregating :1 Genome -----> 2 Genomes
#==================================================
def set_G1_to_G2(self):
for n,pair_krom in self.genome.items():
pair_krom[0].set_G1_to_G2()
pair_krom[1].set_G1_to_G2()
def G2_to_M(self):
#
chromosomes_list=[]
for n, pair_krom in self.genome.items():
rosalind = pair_krom[0].segregate()# one chromatid of one homologous chromosome
franklin = pair_krom[1].segregate()# one chromatid of the other homologous chromosome
chromosomes_list.append(rosalind)
chromosomes_list.append(franklin)
return Genome(*chromosomes_list)
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 5 11:05:01 2012
@author: Jean-Pat
"""
import unittest as ut
import WatsonCrick as ss# single strand DNA
class Test_Wa(ut.TestCase):
""" class for unit tests for Watson class """
def test_initW(self):
""" Watson constructor test"""
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
self.assertEqual(w.getTTAGGG(), 10400)
self.assertEqual(w.getCCCTAA(), 5000)
def test_initCr(self):
""" Crick constructor test"""
c = ss.Crick(ttaggg = 5000, ccctaa = 10400)
self.assertEqual(c.getTTAGGG(), 5000)
self.assertEqual(c.getCCCTAA(), 10400)
def test_delete5prime(self):
""" test 5' ccctaa deletion with No exonuclease"""
ss.deletion = 1
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
w.delete5prime()
self.assertLess(w.getCCCTAA(), 5000)
c = ss.Crick(ttaggg = 5000, ccctaa = 10400)
c.delete5prime()
self.assertLess(c.getCCCTAA(), 10400)
def test_replicate1(self):
""" Check that Watson replication gives Crick and reciprocally"""
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
self.assertIsInstance(w.replicate(),ss.Crick)
c = ss.Crick(ttaggg = 5000, ccctaa = 10400)
self.assertIsInstance(c.replicate(),ss.Watson)
def test_replicate2(self):
""" Check Watson.replicate(),or Crick, reduces Watson (Crick) CCCTAA"""
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
w.replicate()
self.assertLess(w.getCCCTAA(),5000)
c = ss.Crick(ttaggg = 5000, ccctaa = 10400)
c.replicate()
self.assertLess(c.getCCCTAA(), 10400)
def test_replicate3(self):
""" Take a Watson strand
replicate it
Check that the new Crick CCCTAA< Watson TTAGGG"""
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
c = w.replicate()
self.assertLess(c.getCCCTAA(),w.getTTAGGG())
def test_replicate4(self):
""" Take a Crick strand
replicate it
Check that the new Watson CCCTAA< Crick TTAGGG"""
c = ss.Crick(ttaggg = 10400, ccctaa = 5000)
w = c.replicate()
self.assertLess(w.getCCCTAA(),c.getTTAGGG())
def test_lengthenTTAGGG(self):
""" Check that Watson (Crick) TTAGGG can be lengthened (telomerase)"""
w = ss.Watson(ttaggg = 10400, ccctaa = 5000)
w.lengthen_ttaggg(200)
self.assertGreater(w.getTTAGGG(),10400)
c = ss.Crick(ttaggg = 5000, ccctaa = 10000)
c.lengthen_ttaggg(200)
self.assertGreater(c.getTTAGGG(),5000)
if __name__ == '__main__':
ut.main()
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 30 16:52:42 2016
@author: jeanpat
"""
import unittest as ut
import Cellular as C
class test_cell(ut.TestCase):
def test_initDivision(self):
cell = C.Cell()
self.assertEqual(cell.division, 0)
def test_initDivision1(self):
cell = C.Cell()
cell.mitose()
self.assertEqual(cell.division, 1)
def test_length1(self):
tel=(15000,18000,9000,201)
distrib = {"1":tel}
tgen = C.init_genome(telomeres_distribution = distrib)
tcell = C.Cell(genome = tgen, short_telomere_threshold= 200)
df = tcell.genome_dataframe()
self.assertEqual(df['1pter_mat'][0], 15000)
def test_cell_cycle1(self):
tel=(15000,18000,9000,201)
distrib = {"1":tel}
tgen = C.init_genome(telomeres_distribution = distrib)
tcell = C.Cell(genome = tgen, short_telomere_threshold= 200)
self.assertEqual(tcell.G0, False)
def test_cell_cycle2(self):
tel=(15000,18000,9000,201)
distrib = {"1":tel}
tgen = C.init_genome(telomeres_distribution = distrib)
mother_cell = C.Cell(genome = tgen, short_telomere_threshold= 200)
daughter_cell = mother_cell.mitose()
self.assertEqual(mother_cell.G0, True)
self.assertEqual(daughter_cell.G0, True)
if __name__ == '__main__':
ut.main()
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 5 15:01:23 2012
@author: Jean-Pat
"""
import unittest as ut
import ClassChromosome as K
class Test_Chromosome(ut.TestCase):
""" class for unit tests for Chromosome class """
def test_initK(self):
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k=K.Chromosome(watson=w,crick=c)
self.assertIsInstance(k,K.Chromosome)
def test_Chromatid1(self):
""" check if a chromatid (Chromosome) has two
Watson an Crick obj
"""
k=K.Chromosome()
self.assertIsInstance(k.get_Crick(),K.Crick)
self.assertIsInstance(k.get_Watson(),K.Watson)
def test_1_telomere_length(self):
""" check telomere length on instanciation
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k=K.Chromosome(w, c)
length_pter = k.get_pter_G1()
length_qter = k.get_qter_G1()
self.assertEqual(length_pter,10000)
self.assertEqual(length_qter,5000)
def test_2a_telomere_length_G2(self):
""" check telomere length after G1 to G2 is tupple
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k=K.Chromosome(w, c)
k.set_G1_to_G2()
cell_cycle ='G2'
motif='ccctaa'
self.assertEqual(k.phase,cell_cycle)
self.assertIsInstance(k.get_pter_G2(motif),tuple)
self.assertIsInstance(k.get_qter_G2(motif),tuple)
def test_2b_telomere_length_G2(self):
""" check telomere length after G1 to G2 is tupple
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k=K.Chromosome(w, c)
k.set_G1_to_G2()
cell_cycle ='G2'
motif='ttaggg'
self.assertEqual(k.phase,cell_cycle)#self.assertEquals(k.phase,cell_cycle)
self.assertIsInstance(k.get_pter_G2(motif),tuple)
self.assertIsInstance(k.get_qter_G2(motif),tuple)
def test_3_telomere_G1_pter_GStrand(self):
""" Take a chromosome :
*G1 to G2
*segregate (mitosis and back to G1)
Check telomere ttaggg longer than ccctaa for
the two G1 chromosomes (pter)
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k0=K.Chromosome(w, c)
k0.set_G1_to_G2()
k1 = k0.segregate()
#---------------------
ccctaa0 = k0.get_pter_G1(motif='ccctaa')
ttaggg0 = k0.get_pter_G1(motif='ttaggg')
#print ccctaa0, ttaggg0
ccctaa1 = k1.get_pter_G1(motif='ccctaa')
ttaggg1 = k1.get_pter_G1(motif='ttaggg')
#Check at pter
self.assertLess(ccctaa0,ttaggg0)
self.assertLess(ccctaa1,ttaggg1)
def test_4_telomere_G1_qter_GStrand(self):
""" Take a chromosome :
*G1 to G2
*segregate (mitosis)
Check telomere ttaggg longer than ccctaa(qter)
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k0=K.Chromosome(w, c)
k0.set_G1_to_G2()
k1 = k0.segregate()
#---------------------------------------
ccctaa0 = k0.get_qter_G1(motif='ccctaa')
ttaggg0 = k0.get_qter_G1(motif='ttaggg')
#print ccctaa0, ttaggg0
ccctaa1 = k1.get_qter_G1(motif='ccctaa')
ttaggg1 = k1.get_qter_G1(motif='ttaggg')
self.assertLess(ccctaa0,ttaggg0)
self.assertLess(ccctaa1,ttaggg1)
def test_5_telomere_G2_(self):
""" Take a chromosome :
*G1 to G2
* compute telomre lenghth on G2 chrom
Check that telomere length on both chromatids are similar
"""
w=K.Watson(ttaggg=10000, ccctaa = 5000)
c=K.Crick(ttaggg=5000, ccctaa = 10000)
k0=K.Chromosome(w, c)
k0.set_G1_to_G2()
motif='ccctaa'
pter = k0.get_pter_G2(motif)
p1 = pter[0]
p2 = pter[1]
self.assertAlmostEqual(p1,p2,delta=400)
qter = k0.get_qter_G2(motif)
q1 = qter[0]
q2 = qter[1]
self.assertAlmostEqual(q1,q2,delta=400)
motif='ttaggg'
pter = k0.get_pter_G2(motif)
p1 = pter[0]
p2 = pter[1]
self.assertAlmostEqual(p1,p2,delta=400)
qter = k0.get_qter_G2(motif)
q1 = qter[0]
q2 = qter[1]
self.assertAlmostEqual(q1,q2,delta=400)
def test_6_telomere_length_method(self):
'''Check that telomere_length() method gives the same results than
the other methods get_pter|qter_G1|G2(motif='ccctaa'|'ttaggg'),
with an easier to use interface.
'''
w = K.Watson(ttaggg=10000, ccctaa = 5000)
c = K.Crick(ttaggg=5000, ccctaa = 10000)
k0 = K.Chromosome(w, c)
L = k0.telomere_length(end='pter', motif='ccctaa')
self.assertEqual(L,10000)
L = k0.telomere_length(end='qter', motif='ccctaa')
self.assertEqual(L,5000)
L = k0.telomere_length(end='pter', motif='ttaggg')
self.assertEqual(L,10000)
L = k0.telomere_length(end='qter', motif='ttaggg')
self.assertEqual(L,5000)
#Switch to G2:Two chromatids Chromosome
k0.set_G1_to_G2()
self.assertIsInstance(k0.telomere_length(end='pter', motif='ccctaa'),tuple)
self.assertIsInstance(k0.telomere_length(end='qter', motif='ccctaa'),tuple)
p1, p2 = k0.telomere_length(end='pter', motif='ccctaa')
q1, q2 = k0.telomere_length(end='qter', motif='ccctaa')
self.assertAlmostEqual(p1,p2,delta=300)
self.assertAlmostEqual(q1,q2,delta=300)
#Switch from G2 to M:One chromatid Chromosome
k0.segregate()
self.assertIsInstance(k0.telomere_length(end='pter', motif='ccctaa'),int)
if __name__ == '__main__':
ut.main()
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 11 14:20:03 2012
@author: Jean-Pat
"""
import unittest as ut
import ClassChromosome as K
import Genome as G
class Test_Genome(ut.TestCase):
""" class for unit tests for Genome class """
def test_genome01(self):
'''Check creation of a genome instance
'''
watson = K.Watson(ttaggg=1200, ccctaa=5500)
crick = K.Crick(ttaggg=5500, ccctaa=1200)
c1 = K.Chromosome(watson, crick, name='1', homolog='a')
c2 = K.Chromosome(homolog='b')
x = K.Chromosome(K.Watson(ttaggg=12000, ccctaa=4000),
K.Crick(ttaggg=4000, ccctaa=12000),
name='2', homolog='X')
y = K.Chromosome(K.Watson(ttaggg=20000, ccctaa=7000),
K.Crick(ttaggg=7000, ccctaa=20000),
name='2', homolog='Y')
g = G.Genome(c1, c2, x, y)
self.assertIsInstance(g, G.Genome)
def test_genome02(self):
''' Check can get the chromosomes name & homologous chrom name
'''
watson = K.Watson(ttaggg=1200, ccctaa=5500)
crick = K.Crick(ttaggg=5500, ccctaa=1200)
c1 = K.Chromosome(watson, crick, name='1', homolog='a')
c2 = K.Chromosome(homolog='b')
x = K.Chromosome(K.Watson(ttaggg=12000, ccctaa=4000),
K.Crick(ttaggg=4000, ccctaa=12000),
name='2', homolog='X')
y = K.Chromosome(K.Watson(ttaggg=20000, ccctaa=7000),
K.Crick(ttaggg=7000, ccctaa=20000),
name='2', homolog='Y')
g = G.Genome(c1, c2, x, y)
ploidy = g.get_chromosomes_list()
#print(ploidy)
self.assertEqual(list(ploidy), ['1','2'])
homologous = g.get_homologous_tags(pair='1')
self.assertEqual(homologous, ['a','b'])
homologous = g.get_homologous_tags(pair='2')
self.assertEqual(homologous, ['X','Y'])
def test_genome03(self):
'''Check can get chromosome phase
'''
watson=K.Watson(ttaggg = 1200, ccctaa = 5500)
crick=K.Crick(ttaggg = 5500, ccctaa = 1200)
c1 = K.Chromosome(watson, crick, name='1',homolog='a')
c2 = K.Chromosome(homolog='b')
g = G.Genome(c1, c2)
f1=g.get_chrom_phase(pair='1',hog='a')
self.assertEqual(f1,'G1')
f2=g.get_chrom_phase(pair='1',hog='b')
self.assertEqual(f1,'G1')
g.set_G1_to_G2()
f1=g.get_chrom_phase(pair='1',hog='a')
self.assertEqual(f1,'G2')
f2=g.get_chrom_phase(pair='1',hog='b')
self.assertEqual(f2,'G2')
def test_genome31(self):
'''check can get a pair of chrom with
'''
#TODO:Check that can get a pair of chromosomes with G.get...
pass
def test_genome04(self):
'''Check can get telomere length with self.get_telo_length method
'''
watson=K.Watson(ttaggg = 1200, ccctaa = 5500)
crick=K.Crick(ttaggg = 5500, ccctaa = 1200)
c1 = K.Chromosome(watson, crick, name='1',homolog='a')
c2 = K.Chromosome(homolog='b')
g = G.Genome(c1, c2)
p1a = g.get_telo_length()
p1a = g.get_telo_length(pair='1',hog='a', tel='pter',cycle='G1',motif='ccctaa')
self.assertEqual(p1a,1200)
def test_genome05(self):
'''Check can get telomere length with self.get_telomere_length method
'''
watson = K.Watson(ttaggg=1200, ccctaa=5500)
crick = K.Crick(ttaggg=5500, ccctaa=1200)
c1 = K.Chromosome(watson, crick, name='1', homolog='a')
c2 = K.Chromosome(homolog='b')
g = G.Genome(c1, c2)
p1a = g.get_telomere_length()
self.assertEqual(p1a, 1200)
q1a = g.get_telomere_length(tel='qter')
self.assertEqual(q1a, 5500)
def test_genome06(self):
'''Check telomere length difference between homologs
'''
watson = K.Watson(ttaggg=1200, ccctaa=5500)
crick = K.Crick(ttaggg=5500, ccctaa=1200)
wat1 = K.Watson(ttaggg=7500, ccctaa=9708)
crk1 = K.Crick(ttaggg=9708, ccctaa=7500)
c1 = K.Chromosome(watson, crick, name='1', homolog='a')
c2 = K.Chromosome(wat1, crk1, name='1', homolog='b')
g = G.Genome(c1, c2)
self.assertEqual(g.delta_telo(), 1200 - 7500)
self.assertEqual(g.delta_telo(tel='pter'), 1200 - 7500)
self.assertEqual(g.delta_telo(tel='qter'), 5500 - 9708)
def test_genome_state(self):
'''Check genome state:
'''
if __name__ == '__main__':
ut.main()
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 5 11:05:37 2012
@author: Jean-Patrick Pommier
"""
import numpy as np
#The 5' ccctaa exonuclease deletion is simulated
#by a Binomial law(n=deletion, p=p_deletion)
#RNA = 20
#deletion = 400
#p_deletion = 0.40
#==============================================================================
# Watson & Crick seems to be the same class.but they are symetrical. A Watson
# object produces a Crick object and reciprocally as DNA replication does.
#==============================================================================
class Watson(object):
#Better to put these cte as class variables, same value for all instances
RNA = 20
deletion = 400
p_deletion = 0.40
def __init__(self, ttaggg = 5000, ccctaa = 10000):
self.__ttaggg = ttaggg
self.__ccctaa = ccctaa
self.in_use = False
def delete5prime(self):
#simulation action of 5' exonuclease (Makarov 1997)
self.__ccctaa = self.__ccctaa - (Watson.RNA+np.random.binomial(Watson.deletion,Watson.p_deletion))
def replicate(self):
self.__neottaggg = self.__ccctaa
self.__neoccctaa = self.__ttaggg
#make a complementary single strand
self.compstrand = Crick(self.__neottaggg,self.__neoccctaa)
#now delete Watson strand and Crick strand on 5' side
self.delete5prime()
self.compstrand.delete5prime()
return self.compstrand
def lengthen_ttaggg(self, l):
#use for telomerase
self.__ttaggg = self.__ttaggg+l
def lengthen_ccctaa(self, l):
#use for telomerase+DNA pol
self.__ccctaa = self.__ccctaa+l
def getTTAGGG(self):
return self.__ttaggg
def getCCCTAA(self):
return self.__ccctaa
ttaggg = property(fget=getTTAGGG, fset=None)
ccctaa = property(fget=getTTAGGG, fset=None)
class Crick(object):
RNA = 20
deletion = 400
p_deletion = 0.40
def __init__(self,ttaggg = 10000, ccctaa = 5000):
self.__ttaggg = ttaggg
self.__ccctaa = ccctaa
self.in_use = False
def delete5prime(self):
self.__ccctaa = self.__ccctaa - (Crick.RNA+np.random.binomial(Crick.deletion,Crick.p_deletion))
def replicate(self):
self.__neottaggg = self.__ccctaa
self.__neoccctaa = self.__ttaggg
#make a complementary single strand
self.compstrand = Watson(self.__neottaggg,self.__neoccctaa)
#now delete Watson strand and Crick strand on 5' side
self.delete5prime()
self.compstrand.delete5prime()
return self.compstrand
def lengthen_ttaggg(self, l):
#use for telomerase
self.__ttaggg = self.__ttaggg+l
def lengthen_ccctaa(self, l):
#use for telomerase+DNA pol
self.__ccctaa = self.__ccctaa+l
def getTTAGGG(self):
return self.__ttaggg
def getCCCTAA(self):
return self.__ccctaa
ttaggg = property(fget = getTTAGGG, fset = None)
ccctaa = property(fget = getTTAGGG, fset = None)
#==============================================================================
#
#==============================================================================
def test_watson_replication():
w = Watson()
print( 'w TTAGGG:',w.getTTAGGG())
print( 'w CCCTAA:',w.getCCCTAA())
neoc = w.replicate()
print( 'w post replication CCCTAA:',w.getCCCTAA())
print( 'Crick strand post rep, CCCTAA:',neoc.getCCCTAA())
w.__ccctaa = 200
print( w.getCCCTAA())
if __name__ == "__main__":
test_watson_replication()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment