################################## # # # Last modified 06/19/2015 # # # # Georgi Marinov # # # ################################## import sys import string import os DNADict = {'A':'T','T':'A','G':'C','C':'G','N':'N'} def run(): if len(sys.argv) < 7: print 'usage: python %s config RTT GTF ORFs genomic_fasta outfile [-ATP] [-NCBIGFFFNAProk] [-MultiplyCellCycleBy factor]' % sys.argv[0] print '\tNote: RTT parameter: R-- will only calculate Replication cost. RT- will only calulate replicaiton and transcription cost, etc.' print '\tNote: The -ATP option will shift the hardcoded values to units of ATP rather than P' sys.exit(1) doATP = False if '-ATP' in sys.argv: doATP = True config = sys.argv[1] RTT = sys.argv[2] type = sys.argv[3] GTF = sys.argv[4] ORF = sys.argv[5] fasta = sys.argv[6] outfilename = sys.argv[7] doNCBIGFFFNAProk = False if '-NCBIGFFFNAProk' in sys.argv: doNCBIGFFFNAProk = True MCCBF = 1 if '-MultiplyCellCycleBy' in sys.argv: MCCBF = float(sys.argv[sys.argv.index('-MultiplyCellCycleBy') + 1]) ConfigDict = {} linelist = open(config) for line in linelist: if line.startswith('#') or line.strip() == '': continue fields = line.strip().split('\t') q = fields[0] print fields if q in ['H1','H2A','H2B','H3','H4']: if len(fields) == 1: ConfigDict[q] = '' else: ConfigDict[q] = fields[1] else: if len(fields) == 1 or fields[1] == '': ConfigDict[q] = 0 else: ConfigDict[q] = float(fields[1]) ORFDict = {} linelist = open(ORF) for line in linelist: if line.startswith('#') or line.strip() == '': continue fields = line.strip().split('\t') geneID = fields[0] if ORFDict.has_key(geneID): pass else: ORFDict[geneID] = {} if len(fields) < 12: ORF == '' else: ORF = fields[11] transcriptID = fields[2] ORFDict[geneID][transcriptID] = ORF GeneDict = {} linelist = open(GTF) for line in linelist: if line.startswith('#') or line.strip() == '': continue fields = line.strip().split('\t') if doNCBIGFFFNAProk: if fields[2] != 'CDS': continue else: if fields[2] != 'exon' and fields[2] != 'CDS': continue if doNCBIGFFFNAProk: geneID = fields[8].split('ID=')[1].split(';')[0] transcriptID = geneID geneName = fields[8].split(';product=')[1].split(';')[0] transcriptName = geneName else: geneID=fields[8].split('gene_id "')[1].split('"')[0] transcriptID=fields[8].split('transcript_id "')[1].split('"')[0] if 'gene_name "' in fields[8]: geneName=fields[8].split('gene_name "')[1].split('"')[0] else: geneName = geneID chr = fields[0] left = int(fields[3]) right = int(fields[4]) strand = fields[6] if GeneDict.has_key(geneID): pass else: GeneDict[geneID]={} GeneDict[geneID]['gene_name'] = geneName if GeneDict[geneID].has_key(transcriptID): pass else: GeneDict[geneID][transcriptID] = {} GeneDict[geneID][transcriptID]['exons'] = [] GeneDict[geneID][transcriptID]['CDS'] = [] if doNCBIGFFFNAProk: GeneDict[geneID][transcriptID]['exons'].append((chr,left,right,strand)) GeneDict[geneID][transcriptID]['CDS'].append((chr,left,right,strand)) else: if fields[2] == 'exon': GeneDict[geneID][transcriptID]['exons'].append((chr,left,right,strand)) if fields[2] == 'CDS': GeneDict[geneID][transcriptID]['CDS'].append((chr,left,right,strand)) GenomeDict={} sequence='' inputdatafile = open(fasta) for line in inputdatafile: if line[0]=='>': if sequence != '': GenomeDict[chr] = ''.join(sequence) if doNCBIGFFFNAProk: chr = line.strip().split('>')[1].split('ref|')[1].split('|')[0] else: chr = line.strip().split('>')[1] print chr sequence=[] continue else: sequence.append(line.strip().upper()) GenomeDict[chr] = ''.join(sequence) genes = ORFDict.keys() genes.sort() ConfigDict['nuc:N'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:K'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:Y'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:S'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:W'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:R'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 ConfigDict['nuc:M'] = (ConfigDict['nuc:A'] + ConfigDict['nuc:G'] + ConfigDict['nuc:T'] + ConfigDict['nuc:C'])/4 if type == 'euk': SCH1 = 0 SCH2B = 0 SCH2A = 0 SCH3 = 0 SCH4 = 0 for AA in ConfigDict['H1']: SCH1 += ConfigDict['aa:' + AA] for AA in ConfigDict['H2A']: SCH2A += ConfigDict['aa:' + AA] for AA in ConfigDict['H2B']: SCH2B += ConfigDict['aa:' + AA] for AA in ConfigDict['H3']: SCH3 += ConfigDict['aa:' + AA] for AA in ConfigDict['H4']: SCH4 += ConfigDict['aa:' + AA] SCH4 += ConfigDict['Translation_initiation'] SCH4 += ConfigDict['Translation_termination'] # SCH4 += len(ConfigDict['H4'])*ConfigDict['Translation_degradation_per_AA'] SCH4 += len(ConfigDict['H4'])*ConfigDict['Translation_Elongation_per_AA'] SCH3 += ConfigDict['Translation_initiation'] SCH3 += ConfigDict['Translation_termination'] # SCH3 += len(ConfigDict['H3'])*ConfigDict['Translation_degradation_per_AA'] SCH3 += len(ConfigDict['H3'])*ConfigDict['Translation_Elongation_per_AA'] SCH2A += ConfigDict['Translation_initiation'] SCH2A += ConfigDict['Translation_termination'] # SCH2A += len(ConfigDict['H2A'])*ConfigDict['Translation_degradation_per_AA'] SCH2A += len(ConfigDict['H2A'])*ConfigDict['Translation_Elongation_per_AA'] SCH2B += ConfigDict['Translation_initiation'] SCH2B += ConfigDict['Translation_termination'] # SCH2B += len(ConfigDict['H2B'])*ConfigDict['Translation_degradation_per_AA'] SCH2B += len(ConfigDict['H2B'])*ConfigDict['Translation_Elongation_per_AA'] SCH1 += ConfigDict['Translation_initiation'] SCH1 += ConfigDict['Translation_termination'] # SCH1 += len(ConfigDict['H1'])*ConfigDict['Translation_degradation_per_AA'] SCH1 += len(ConfigDict['H1'])*ConfigDict['Translation_Elongation_per_AA'] outfile = open(outfilename,'w') AverageGene = {} ORFAAcomposition = {} GeneBPcomposition = {} TranscriptBPcomposition = {} ORFLengths = [] transcriptLengths = [] geneLengths = [] UTR5Lengths = [] UTR3Lengths = [] IntronNumbers = [] IntronLengths = [] for geneID in genes: if ORFDict.has_key(geneID): pass else: continue longestTranscript = ('',0) longestORF = ('',0) coordinates = [] for transcriptID in GeneDict[geneID]: TL = 0 if transcriptID == 'gene_name': continue GeneDict[geneID][transcriptID]['exons'].sort() GeneDict[geneID][transcriptID]['CDS'].sort() for (chr,left,right,strand) in GeneDict[geneID][transcriptID]['exons']: coordinates.append(left) coordinates.append(right) TL += (right-left) if TL >= longestTranscript[1]: longestTranscript = (transcriptID,TL) if ORFDict[geneID].has_key(transcriptID): pass else: continue if len(ORFDict[geneID][transcriptID]) > longestORF[1]: longestORF = (transcriptID,len(ORFDict[geneID][transcriptID])) transcriptID = longestORF[0] ORFLengths.append(len(ORFDict[geneID][transcriptID])) for A in ORFDict[geneID][transcriptID]: if ORFAAcomposition.has_key(A): pass else: ORFAAcomposition[A] = 0 ORFAAcomposition[A]+=1 TL = 0 for (chr,left,right,strand) in GeneDict[geneID][transcriptID]['exons']: TL += (right-left) transcriptLengths.append(TL) if len(GeneDict[geneID][transcriptID]['CDS']) > 0 and len(GeneDict[geneID][transcriptID]['exons']) == 0: continue geneLengths.append(GeneDict[geneID][transcriptID]['exons'][-1][2] - GeneDict[geneID][transcriptID]['exons'][0][1]) NumInt = len(GeneDict[geneID][transcriptID]['exons']) - 1 IntronNumbers.append(NumInt) # if NumInt > 0: # print geneID if NumInt == 0: pass else: for i in range(NumInt): (chr,left1,right1,strand) = GeneDict[geneID][transcriptID]['exons'][i] (chr,left2,right2,strand) = GeneDict[geneID][transcriptID]['exons'][i+1] IL = (left2 - right1) IntronLengths.append(IL) leftUTR = 0 rightUTR = 0 leftCDScoordinate = GeneDict[geneID][transcriptID]['CDS'][0][1] rightCDScoordinate = GeneDict[geneID][transcriptID]['CDS'][-1][2] leftExoncoordinate = GeneDict[geneID][transcriptID]['exons'][0][1] rightExoncoordinate = GeneDict[geneID][transcriptID]['exons'][-1][2] if leftCDScoordinate == leftExoncoordinate: pass else: for (chr,left,right,strand) in GeneDict[geneID][transcriptID]['exons']: for i in range(left,right): if i >= leftCDScoordinate: break else: leftUTR += 1 if rightCDScoordinate == rightExoncoordinate: pass else: for (chr,left,right,strand) in GeneDict[geneID][transcriptID]['exons']: for i in range(left,right): if i <= rightCDScoordinate: continue else: leftUTR += 1 if strand == '+': UTR5Lengths.append(leftUTR) UTR3Lengths.append(rightUTR) if strand == '-': UTR5Lengths.append(rightUTR) UTR3Lengths.append(leftUTR) for i in range(leftExoncoordinate,min(rightExoncoordinate,len(GenomeDict[chr]))): B = GenomeDict[chr][i] if GeneBPcomposition.has_key(B): pass else: GeneBPcomposition[B]=0 GeneBPcomposition[B]+=1 for (chr,left,right,strand) in GeneDict[geneID][transcriptID]['exons']: for i in range(left,min(right,len(GenomeDict[chr]))): B = GenomeDict[chr][i] if TranscriptBPcomposition.has_key(B): pass else: TranscriptBPcomposition[B] = 0 TranscriptBPcomposition[B]+=1 TotalAA = 0.0 for A in ORFAAcomposition.keys(): TotalAA += ORFAAcomposition[A] for A in ORFAAcomposition.keys(): ORFAAcomposition[A] = ORFAAcomposition[A]/TotalAA TotalGbp = 0.0 for B in GeneBPcomposition.keys(): TotalGbp += GeneBPcomposition[B] for B in GeneBPcomposition.keys(): GeneBPcomposition[B] = GeneBPcomposition[B]/TotalGbp TotalTbp = 0.0 for B in TranscriptBPcomposition.keys(): TotalTbp += TranscriptBPcomposition[B] for B in TranscriptBPcomposition.keys(): TranscriptBPcomposition[B] = TranscriptBPcomposition[B]/TotalTbp meanORFlength = sum(ORFLengths)/(len(ORFLengths) + 0.0) meanGlength = sum(geneLengths)/(len(geneLengths) + 0.0) meanTlength = sum(transcriptLengths)/(len(transcriptLengths) + 0.0) meanIntronNumber = sum(IntronNumbers)/(len(IntronNumbers) + 0.0) outline = 'Mean Intron Number:\t' + str(meanIntronNumber) outfile.write(outline + '\n') meanIntronNumber = round(meanIntronNumber) if len(IntronLengths) == 0: meanIntronLength = 0 else: meanIntronLength = sum(IntronLengths)/(len(IntronLengths) + 0.0) meanUTR5length = sum(UTR5Lengths)/(len(UTR5Lengths) + 0.0) meanUTR3length = sum(UTR3Lengths)/(len(UTR3Lengths) + 0.0) meanCDSLength = (meanTlength - meanUTR5length - meanUTR3length)/(meanIntronNumber + 1.0) P = 0 if meanIntronNumber > 0: outline = '5UTR' + '\t' + str(meanUTR5length) + '\t' + str(meanUTR5length) outfile.write(outline + '\n') P += meanUTR5length outline = 'CDS' + '\t' + str(P + meanCDSLength) + '\t' + str(meanCDSLength) outfile.write(outline + '\n') P += meanCDSLength for i in range(max(int(meanIntronNumber) - 1,0)): outline = 'intron' + '\t' + str(P + meanIntronLength) + '\t' + str(meanIntronLength) P += meanIntronLength outfile.write(outline + '\n') outline = 'CDS' + '\t' + str(P + meanCDSLength) + '\t' + str(meanCDSLength) P += meanCDSLength outfile.write(outline + '\n') outline = 'intron' + '\t' + str(P + meanIntronLength) + '\t' + str(meanIntronLength) P += meanIntronLength outfile.write(outline + '\n') outline = 'CDS' + '\t' + str(P + meanCDSLength) + '\t' + str(meanCDSLength) P += meanCDSLength outfile.write(outline + '\n') outline = '3UTR' + '\t' + str(P + meanUTR3length) + '\t' + str(meanUTR3length) outfile.write(outline + '\n') if meanIntronNumber == 0: outline = '5UTR' + '\t' + str(meanUTR5length) + '\t' + str(meanUTR5length) outfile.write(outline + '\n') P += meanUTR5length outline = 'CDS' + '\t' + str(P + meanCDSLength) + '\t' + str(meanCDSLength) P += meanCDSLength outfile.write(outline + '\n') outline = '3UTR' + '\t' + str(P + meanUTR3length) + '\t' + str(meanUTR3length) outfile.write(outline + '\n') CostReplication_Nucleotides = 0 CostReplication_Processive = 0 CostReplication_Okazaki = 0 CostReplication_Repair = 0 CostReplication_Histones = 0 CostTranscription_Nucleotides = 0 CostTranscription_Activaiton = 0 CostTranscription_Abortive = 0 CostTranscription_Initiation = 0 CostTranscription_Processive = 0 CostTranscription_Cap = 0 CostTranscription_CTD = 0 CostTranscription_Export = 0 CostTranscription_Splicing = 0 CostTranscription_Histone = 0 CostTranscription_PolyA = 0 CostTranscription_Readthrough = 0 CostTranslation_AA = 0 CostTranslation_Processive = 0 CostTranslation_Initiation = 0 CostTranslation_Termination = 0 CostTranslation_Degradation = 0 NumberRNAs = ConfigDict['Total_Transcripts_per_cell']/(len(genes) + 0.0) NumberProteins = ConfigDict['Total_Proteins_per_cell']/(len(genes) + 0.0) outline = '#geneID\tgeneName\tgeneLength\tLongestORFLength\tLongestORFTranscriptLength\tLongestORFNumberIntrons\tRNA_level\tNumber_transcripts' outline = outline + '\tRF_level\tNumber_proteins\tReplicationCost\tTranscriptionCost\tTranslationCost\tTotalCost\tReplicationCostFraction\tTranscriptionCostFraction' outline = outline + '\tTranslationCostFraction\tReplication_Nucleotides\tReplication_Processive\tReplication_Okazaki\tReplication_Repair' outline = outline + '\tReplication_Histones\tTranscription_Nucleotides\tTranscription_Activaiton\tCostTranscription_Abortive\tTranscription_Initiation\tTranscription_Processive' outline = outline + '\tTranscription_Cap\tTranscription_CTD\tTranscription_Export\tTranscription_Splicing\tTranscription_Histone\tTranscription_PolyA\tCostTranscription_Readthrough' outline = outline + '\tTranslation_AA\tTranslation_Processive\tTranslation_Initiation\tTranslation_Termination\tTranslation_Degradation' outfile.write(outline + '\n') if RTT[0] == '-': ReplicationCost = '-' if RTT[0] == 'R': ReplicationCost = 0 for B in GeneBPcomposition.keys(): ReplicationCost += (ConfigDict['nuc:' + B] + 1.5)*GeneBPcomposition[B]*meanGlength*2 CostReplication_Nucleotides += (ConfigDict['nuc:' + B] + 1.5)*GeneBPcomposition[B]*meanGlength*2 if doATP: ReplicationCost += 3*meanGlength CostReplication_Processive += 3*meanGlength ReplicationCost += 1*(meanGlength/ConfigDict['Okazaki_fragment_length'])*ConfigDict['Replication_primer_length'] CostReplication_Okazaki += 1*(meanGlength/ConfigDict['Okazaki_fragment_length'])*ConfigDict['Replication_primer_length'] else: ReplicationCost += 6*meanGlength CostReplication_Processive += 6*meanGlength ReplicationCost += 2*(meanGlength/ConfigDict['Okazaki_fragment_length'])*ConfigDict['Replication_primer_length'] CostReplication_Okazaki += 2*(meanGlength/ConfigDict['Okazaki_fragment_length'])*ConfigDict['Replication_primer_length'] ReplicationCost += meanGlength*ConfigDict['DNA_repair_per_bp'] CostReplication_Repair += meanGlength*ConfigDict['DNA_repair_per_bp'] if type == 'euk': ReplicationCost += (meanGlength/(ConfigDict['Nucleosome_length'] + ConfigDict['Linker_length']))*(SCH1 + 2*(SCH2A + SCH2B + SCH3 + SCH4)) CostReplication_Histones += (meanGlength/(ConfigDict['Nucleosome_length'] + ConfigDict['Linker_length']))*(SCH1 + 2*(SCH2A + SCH2B + SCH3 + SCH4)) if RTT[1] == '-': TranscriptionCost = '-' else: TranscriptionCost = 0 for B in TranscriptBPcomposition.keys(): TranscriptionCost += NumberRNAs*ConfigDict['nuc:' + B]*TranscriptBPcomposition[B]*meanTlength CostTranscription_Nucleotides += NumberRNAs*ConfigDict['nuc:' + B]*TranscriptBPcomposition[B]*meanTlength TranscriptionRate = ConfigDict['Average_Transcription_rate'] TranscriptionCycles = ConfigDict['time']*TranscriptionRate*MCCBF TranscriptionCost += TranscriptionCycles*ConfigDict['Transcription_activation']/ConfigDict['initiations_per_transcription_cycle'] CostTranscription_Activaiton += TranscriptionCycles*ConfigDict['Transcription_activation']/ConfigDict['initiations_per_transcription_cycle'] TranscriptionCost += TranscriptionCycles*ConfigDict['Transcription_initiation'] CostTranscription_Initiation += TranscriptionCycles*ConfigDict['Transcription_initiation'] TranscriptionCost += TranscriptionCycles*ConfigDict['Abortive_transcripts'] CostTranscription_Abortive += TranscriptionCycles*ConfigDict['Abortive_transcripts'] TranscriptionCost += TranscriptionCycles*(meanGlength + ConfigDict['readthrough_length'])*ConfigDict['Transcription_elongation'] CostTranscription_Processive += TranscriptionCycles*(meanGlength)*ConfigDict['Transcription_elongation'] CostTranscription_Readthrough += TranscriptionCycles*(ConfigDict['readthrough_length'])*ConfigDict['Transcription_elongation'] if type == 'euk': TranscriptionCost += NumberRNAs*ConfigDict['nuc:G'] CostTranscription_Cap += NumberRNAs*ConfigDict['nuc:G'] TranscriptionCost += NumberRNAs*ConfigDict['PolyA_length']*ConfigDict['nuc:A'] CostTranscription_PolyA += NumberRNAs*ConfigDict['PolyA_length']*ConfigDict['nuc:A'] TranscriptionCost += TranscriptionCycles*ConfigDict['mRNA_capping'] CostTranscription_Cap += TranscriptionCycles*ConfigDict['mRNA_capping'] TranscriptionCost += TranscriptionCycles*ConfigDict['CTD_cost'] CostTranscription_CTD += TranscriptionCycles*ConfigDict['CTD_cost'] TranscriptionCost += TranscriptionCycles*ConfigDict['PolyA_length']*ConfigDict['Transcription_elongation'] CostTranscription_PolyA += TranscriptionCycles*ConfigDict['PolyA_length']*ConfigDict['Transcription_elongation'] TranscriptionCost += TranscriptionCycles*ConfigDict['mRNA_export'] CostTranscription_Export += TranscriptionCycles*ConfigDict['mRNA_export'] TranscriptionCost += TranscriptionCycles*(meanIntronNumber)*ConfigDict['Splicing_cost'] CostTranscription_Splicing += TranscriptionCycles*(meanIntronNumber)*ConfigDict['Splicing_cost'] TranscriptionCost += TranscriptionCycles*((meanGlength + ConfigDict['readthrough_length'])/(ConfigDict['Nucleosome_length'] + ConfigDict['Linker_length']))*ConfigDict['Elongation_histone_modificiations'] CostTranscription_Histone += TranscriptionCycles*((meanGlength + ConfigDict['readthrough_length'])/(ConfigDict['Nucleosome_length'] + ConfigDict['Linker_length']))*ConfigDict['Elongation_histone_modificiations'] if RTT[2] == '-': TranslationCost = '-' else: TranslationCost = 0 TranslationRate = ConfigDict['Average_Translation_rate'] TranslationCycles = ConfigDict['time']*TranslationRate*MCCBF for AA in ORFAAcomposition.keys(): TranslationCost += NumberProteins*meanORFlength*ORFAAcomposition[AA]*ConfigDict['aa:' + AA] CostTranslation_AA += NumberProteins*meanORFlength*ORFAAcomposition[AA]*ConfigDict['aa:' + AA] if type == 'euk': TranslationCost += TranslationCycles*ConfigDict['Translation_mRNA_remodelling']/ConfigDict['Translation_rounds_per_mRNA_remodelling'] CostTranslation_Initiation += TranslationCycles*ConfigDict['Translation_mRNA_remodelling']/ConfigDict['Translation_rounds_per_mRNA_remodelling'] TranslationCost += TranslationCycles*ConfigDict['Translation_initiation'] CostTranslation_Initiation += TranslationCycles*ConfigDict['Translation_initiation'] TranslationCost += TranslationCycles*ConfigDict['Translation_termination'] CostTranslation_Termination += TranslationCycles*ConfigDict['Translation_termination'] TranslationCost += (TranslationCycles - NumberProteins)*meanORFlength*ConfigDict['Translation_degradation_per_AA'] if TranslationCycles < NumberProteins: print 'translation cycles fewere than the number of proteins, exiting' sys.exit(1) CostTranslation_Degradation += (TranslationCycles - NumberProteins)*meanORFlength*ConfigDict['Translation_degradation_per_AA'] TranslationCost += TranslationCycles*meanORFlength*ConfigDict['Translation_Elongation_per_AA'] CostTranslation_Processive += TranslationCycles*meanORFlength*ConfigDict['Translation_Elongation_per_AA'] outline = 'average_gene' + '\t' + 'average_gene' + '\t' + str(meanGlength) + '\t' + str(meanORFlength) + '\t' + str(meanTlength) outline = outline + '\t' + str(meanIntronNumber) + '\t' + str('nan') + '\t' + str(NumberRNAs) + '\t' + str('nan') + '\t' + str(NumberProteins) + '\t' + str(ReplicationCost) + '\t' + str(TranscriptionCost) + '\t' + str(TranslationCost) TotalCost = ReplicationCost + TranscriptionCost + TranslationCost outline = outline + '\t' + str(TotalCost) + '\t' + str(ReplicationCost/TotalCost) + '\t' + str(TranscriptionCost/TotalCost) + '\t' + str(TranslationCost/TotalCost) outline = outline + '\t' + str(CostReplication_Nucleotides) outline = outline + '\t' + str(CostReplication_Processive) outline = outline + '\t' + str(CostReplication_Okazaki) outline = outline + '\t' + str(CostReplication_Repair) outline = outline + '\t' + str(CostReplication_Histones) outline = outline + '\t' + str(CostTranscription_Nucleotides) outline = outline + '\t' + str(CostTranscription_Activaiton) outline = outline + '\t' + str(CostTranscription_Abortive) outline = outline + '\t' + str(CostTranscription_Initiation) outline = outline + '\t' + str(CostTranscription_Processive) outline = outline + '\t' + str(CostTranscription_Cap) outline = outline + '\t' + str(CostTranscription_CTD) outline = outline + '\t' + str(CostTranscription_Export) outline = outline + '\t' + str(CostTranscription_Splicing) outline = outline + '\t' + str(CostTranscription_Histone) outline = outline + '\t' + str(CostTranscription_PolyA) outline = outline + '\t' + str(CostTranscription_Readthrough) outline = outline + '\t' + str(CostTranslation_AA) outline = outline + '\t' + str(CostTranslation_Processive) outline = outline + '\t' + str(CostTranslation_Initiation) outline = outline + '\t' + str(CostTranslation_Termination) outline = outline + '\t' + str(CostTranslation_Degradation) outfile.write(outline + '\n') outfile.close() run()