def to_alignment(self): """Converts the profile to alignment format""" aln = alignment.alignment(self.env) _modeller.mod_profile_to_aln(prf=self.modpt, aln=aln.modpt, libs=self.env.libs.modpt) return aln
def compute_matrices(self): #change to compute_matrixes #self.TDMA_MODE = 0; #eps_vec = .5*np.ones(self.N) self.eps_vec = 0*np.ones(self.N) #self.i = 1 #while np.any(np.isnan(self.final_messages)): Kprime = len(self.map); if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node if Kprime == 1: self.TOTAL_TRANSMISSIONS += 1 while not transmit_messages(1, self.eps_vec[self.map]): self.TOTAL_TRANSMISSIONS += 1 self.final_messages[self.map] = self.W[self.map] else: ## Generate next m transmissions (self.V, U) = alignment('mixed', self.J, 1e-4, 100, False) #try changing it here?? self.V = np.asarray(self.V) print 'new V is ' print self.V #print 'type of new V is ', type(self.V) #print 'type of an element of new V is ', type(self.V[0,0]) self.m = np.shape(self.V)[0] if self.verbose: print 'Minimum rank is ', self.m # generate next symbol based on current V L = len(self.tx_symbols); if self.i == 1: L = 0 self.unsolved = np.ones(Kprime) > 0
def test_model_pathway(): m = test_model1() bd = bigg_data.bigg_data(m.model.id) bd.load_metabolite_kegg_ids() bd.load_reaction_ECs() p = test_pathway1() p.load_ECs("test_pathway") align = alignment.alignment() align.load_model_pathway(p, m, bd)#, max_metabolite_occurance, compartment = "c") #align.load_pathway_pathway(p, p) distance_to_remove = 3 #b, score = align.make_alignment(alignment_type = "Greedy", K_m = 3, to_many = 0, from_many = 0, remove_borders = 1, topological_weight = 0, homological_weight_EC = 10, homological_weight_KEGG = 10, homological_additive = 0, remove_too_distant = 1, remove_too_close = 1, distance_to_remove = distance_to_remove) b, score = align.make_alignment(alignment_type = "Greedy", K_m = 3, to_many = 0, from_many = 0, remove_borders = 1, topological_weight = 10, homological_weight_EC = 10, homological_weight_KEGG = 10, homological_additive = 0, remove_too_distant = 1, remove_too_close = 0, distance_to_remove = distance_to_remove) align.print_alignment(b) #print() #print(align.KEGG_metabolites_dst) #print() #print(align.KEGG_metabolites_src) #print() #print() align.print_T_sim() c = align.get_anchors() align.print_alignment(c) #align.T_sim[:,:] = 1 #align.print_T_sim() #align.adjust_similarities(align.T_sim, 0, 5, 0, 0, remove_too_close=0, remove_too_distant=1, distance_to_remove=distance_to_remove) #align.print_T_sim() print() #paths.get_reaction_connectivity(m) #paths.shortest_path(m, "r1", "r_out_5", compartment = "c") #align.print_matrix("dst", "in") #align.print_matrix("dst", "out") #align.print_matrix("src", "in") #align.print_matrix("src", "out") #print(align.reactions_dst) #print() #for i in align.M_dst: # for j in i: # print(j, end= " ") # print() return (align, m)
def _makeAlignment(self): ''' Construct a pseudo-FASTA string to create a new alignment from. ''' pseudofasta = '' sequences = self.database.iterRecords('alignment') for sequence in sequences: _, name, seq = sequence if name != '' and seq != '': pseudofasta += '>%s\n%s\n' % (name, seq) if pseudofasta != '': self.alignment = alignment(str(pseudofasta))
def build_sequence(self, sequence, special_patches=None, patch_default=True): """Build an extended chain from a string of one-letter residue codes""" a = alignment.alignment(self.env) a.append_sequence(sequence) self.clear_topology() self.generate_topology(a[0], patch_default=patch_default) if special_patches: special_patches(self) self.build(initialize_xyz=True, build_method='INTERNAL_COORDINATES') self.prottyp = 'structure'
def _makeAlignment(self): ''' Construct a pseudo-FASTA string to create a new alignment from. ''' pseudofasta = '' sequences = self.database.iterRecords('alignment') for sequence in sequences: _,name,seq = sequence if name != '' and seq != '': pseudofasta += '>%s\n%s\n' % (name,seq) if pseudofasta != '': self.alignment = alignment(str(pseudofasta))
def compute_matrices(self): #change to compute_matrixes #self.TDMA_MODE = 0; #eps_vec = .5*np.ones(self.N) self.eps_vec = 0 * np.ones(self.N) #self.i = 1 #while np.any(np.isnan(self.final_messages)): Kprime = len(self.map) if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node #doesnt make sense anymore, must change if Kprime == 1: #smsgx.set_V_row(self.V[self.m_i,:]) #self.TOTAL_TRANSMISSIONS += 1 #while not transmit_messages(1, self.eps_vec[self.map]): #self.TOTAL_TRANSMISSIONS += 1 #print 'map is ', self.map #print 'W is ', self.W #print 'final messages are', self.final_messages #self.final_messages[self.map] = self.W[self.map] #make a new V to transmit instead, just what W needs self.V = np.zeros((1, self.N)) self.V[0, self.map] = 1 self.m = 1 else: ## Generate next m transmissions #(self.V, U) = alignment('mixed', self.J, 1e-4, 100, True) (self.V, U) = alignment('greedy', self.J, 1e-4, 100, False) #try changing it here?? self.V = np.asarray(self.V) #RANDOM INSTEAD??? even easier, change right before transmission! #self.V = np.random. print 'new V is ' print self.V #print 'type of new V is ', type(self.V) #print 'type of an element of new V is ', type(self.V[0,0]) self.m = np.shape(self.V)[0] if self.verbose: print 'Minimum rank is ', self.m # generate next symbol based on current V L = len(self.tx_symbols) if self.i == 1: L = 0 self.unsolved = np.ones(Kprime) > 0
def compute_matrices(self): #change to compute_matrixes #self.TDMA_MODE = 0; #eps_vec = .5*np.ones(self.N) self.eps_vec = 0*np.ones(self.N) #self.i = 1 #while np.any(np.isnan(self.final_messages)): Kprime = len(self.map); if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node #doesnt make sense anymore, must change if Kprime == 1: #smsgx.set_V_row(self.V[self.m_i,:]) #self.TOTAL_TRANSMISSIONS += 1 #while not transmit_messages(1, self.eps_vec[self.map]): #self.TOTAL_TRANSMISSIONS += 1 #print 'map is ', self.map #print 'W is ', self.W #print 'final messages are', self.final_messages #self.final_messages[self.map] = self.W[self.map] #make a new V to transmit instead, just what W needs self.V = np.zeros((1,self.N)) self.V[0,self.map] = 1 self.m = 1 else: ## Generate next m transmissions #(self.V, U) = alignment('mixed', self.J, 1e-4, 100, True) (self.V, U) = alignment('greedy', self.J, 1e-4, 100, False) #try changing it here?? self.V = np.asarray(self.V) #RANDOM INSTEAD??? even easier, change right before transmission! #self.V = np.random. print 'new V is ' print self.V #print 'type of new V is ', type(self.V) #print 'type of an element of new V is ', type(self.V[0,0]) self.m = np.shape(self.V)[0] if self.verbose: print 'Minimum rank is ', self.m # generate next symbol based on current V L = len(self.tx_symbols); if self.i == 1: L = 0 self.unsolved = np.ones(Kprime) > 0
def align_sequence(self, other_sample): '''Sets maximum length of sequence and returns algorithm score''' seq_1 = self.sequence[:MAX_ALIGN_LENGTH] seq_2 = other_sample.sequence[:MAX_ALIGN_LENGTH] max_score = alignment.alignment(seq_1, seq_2) return max_score
def main(): """Run the entry point.""" parser = argparse.ArgumentParser() parser.add_argument("output", help="Report output file.") parser.add_argument("alignment_stats", help="Alignment stats file.") parser.add_argument("quality", help="Fastcat quality results.") parser.add_argument( "threshold", help="Threashold percentage expected for consensus accuracy") parser.add_argument("references", help="Reference file input at start") parser.add_argument("--revision", default='unknown', help="git branch/tag of the executed workflow") parser.add_argument("--commit", default='unknown', help="git commit of the executed workflow") parser.add_argument("--summaries", nargs='+', help="Read summary file.") parser.add_argument("--flagstats", nargs='+', help="Flag stat summaries") parser.add_argument("--consensus", nargs='+', help="consensus fasta sequences") parser.add_argument("--bedFiles", nargs='+', help="bed files for sequence depth") parser.add_argument("--unmapped", nargs='+', help="unmapped fastcat stats") parser.add_argument( "--versions", required=True, help="directory containing CSVs containing name,version.") args = parser.parse_args() report_doc = report.WFReport("Transcript target report", "wf-transcript-target", revision=args.revision, commit=args.commit) flag_stats = read_flag_stat_files(args.flagstats) # Retrieve flag and consensus stats and create df seq_summary = read_files(args.summaries) statsdf = seq_summary statsdf = statsdf.drop(['rstart', 'rend'], 1) ref_names, accuracy_list = list(statsdf['ref']), list(statsdf['acc']) accuracy_list = list(np.around(np.array(accuracy_list), 2)) align_stats = args.alignment_stats align_stats = pd.read_csv(align_stats, sep='\t', header=None) align_stats.reset_index() # Retrieve total flag stats total_seq = int(align_stats.iat[0, 0]) mapped = int(align_stats.iat[4, 0]) percent_mapped = (mapped / total_seq) * 100 percentage_aligned = list( map((lambda x: (x / total_seq) * 100), flag_stats)) percentage_aligned = list(np.around(np.array(percentage_aligned), 2)) # Output all in a table threshold = int(args.threshold) table_consensus = { 'Reference name': ref_names, 'Consensus Accuracy %': accuracy_list, 'Number of reads aligned': flag_stats, 'Total Aligned %': percentage_aligned } consensus_df = pd.DataFrame(table_consensus) consensus_df[''] = np.where( consensus_df['Consensus Accuracy %'] < threshold, 'Warning', '') section = report_doc.add_section() section.markdown("## Summary") section.markdown(" This table summarises the consensus accuracy", "and alignment stats for each reference.") section.table(consensus_df, index=False) if consensus_df[''].isin({'': ['Warning']}).any(): section.markdown('**Warning: Some references < threshold accuracy**') else: pass # Exec Summary infographic unmapped = args.unmapped print(unmapped) unmapped_df = pd.read_csv(unmapped[0], delimiter='\t') unmapped_read_qual = unmapped_df["mean_quality"].mean() unmapped_read_length = unmapped_df["read_length"].mean() section = report_doc.add_section() section.markdown("## Total aligned reads") exec_summary = aplanat.graphics.InfoGraphItems() exec_summary.append("Total reads", str(total_seq), "calculator", '') exec_summary.append("On target reads", str("%.2f" % round(percent_mapped, 2)) + '%', "percent", '') exec_summary.append("Unmapped mean Q", str("%.2f" % round(unmapped_read_qual, 2)), "clipboard-check", '') exec_summary.append("Unmapped mean len", str("%.0f" % round(unmapped_read_length, 0)), "calculator", '') exec_plot = aplanat.graphics.infographic(exec_summary.values(), ncols=4) section.plot(exec_plot, key="exec-plot") # Quality quality = args.quality quality_df = pd.read_csv(quality, sep='\t') read_qual = fastcat.read_quality_plot(quality_df) read_length = fastcat.read_length_plot(quality_df) section = report_doc.add_section() section.markdown("## Read Quality Control") section.markdown("This sections displays basic QC" " metrics indicating read data quality.") section.plot( layout([[read_length, read_qual]], sizing_mode="stretch_width")) # Depth Coverage section = report_doc.add_section() section.markdown("## Depth of coverage") section.markdown("The depth of coverage of alignments " "across the reference.") depth = args.bedFiles depth_graphs = depth_graph(depth) section.plot( gridplot(depth_graphs, ncols=2, plot_width=300, plot_height=300)) # Assembly section = report_doc.add_section() section.markdown("## Consensus Alignment Statistics") section.markdown( "The following summarises the statistics from the consensus" "aligned with the reference") seq_summary = statsdf.drop(['name'], 1) seq_summary = seq_summary.rename(columns={'ref': 'Name'}) seq_summary = seq_summary.round({'ref_coverage': 4, 'iden': 4, 'acc': 4}) section.table(seq_summary) # Reference and consensus alignments section = report_doc.add_section() section.markdown("## Alignment of Consensus and Reference") section.markdown("Sequence alignment using Levenshtein (edit) distance.") ref_file = args.references refseq = alignment.referenceSeq(str(ref_file)) cons = read_consensus(args.consensus) for item in (cons.keys()): section.markdown("###" + str(item)) p = alignment.alignment(cons[str(item)], refseq[str(item)], 50) section.markdown(str(p[1])) section.markdown('Length of Consensus: ' + str(p[2])) section.markdown('Length of Reference: ' + str(p[3])) section.markdown("<pre>" + p[0] + "</pre>") section = report_doc.add_section() section.markdown("## Software versions") section.markdown('''The table below highlights versions of key software used within the analysis''') section = report_doc.add_section( section=scomponents.version_table(args.versions)) # write report report_doc.write(args.output)
# Turn off default if some partial analysis is requested if NO_ALN or ALN_ONLY or SUBSET is not None: DEF_RUN = False else: DEF_RUN = True print( 'Default: Running alignment on current workstation and carrying out SNP analysis:' ) # ALIGNMENT only run if ALN_ONLY: print('This is an alignment only run of pySNPCAllingPipeline') if RUN_ENV: align = alignment(CONF_FILE) align.do_alignments() else: # Prepare SLURM files align = scinet_alignment(CONF_FILE) align.do_scinet_alignments(submit_JOB=SUBMIT) # DEFAULT RUN: Alignmnet --> getHQSNPs --> checkSNPs --> FilterSNPs --> write VCF if DEF_RUN: # 1. Do alignments if RUN_ENV: align = alignment(CONF_FILE) align.do_alignments() else: align = scinet_alignment(CONF_FILE)
def main_loop(self): eps_vec = .5 * np.ones(self.N) i = 1 while np.any(np.isnan(self.final_messages)): Kprime = len(self.map) if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node if Kprime == 1: self.TOTAL_TRANSMISSIONS += 1 while not transmit_messages(1, eps_vec[self.map]): self.TOTAL_TRANSMISSIONS += 1 self.final_messages[self.map] = self.W[self.map] else: ## Generate next m transmissions (V, U) = alignment('mixed', self.J, 1e-4, 100, False) m = np.shape(V)[0] if self.verbose: print 'Minimum rank is ', m # generate next symbol based on current V L = len(self.tx_symbols) if i == 1: L = 0 unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(unsolved) and m_i < m: self.tx_symbols = np.append( self.tx_symbols, Symbol(V[m_i, :], self.W, self.map)) R = transmit_messages(1, eps_vec[self.map]) if i == 1: self.rx_symbols = R else: self.rx_symbols = np.bmat([self.rx_symbols, R]) if self.verbose: print 'Transmission ', m_i + 1, '/', m print self.rx_symbols.astype(int) self.TOTAL_TRANSMISSIONS += 1 # solve for messages if possible #SEND TO TARGET HERE (unsolved, final_messages) = bs_decode_messages( self.dest, Kprime, self.map, self.rx_symbols, self.tx_symbols, self.A, self.I, self.J, self.W, self.final_messages, self.verbose) #RECEIVE FROM TARGET HERE #INTERPRET ACKS HERE m_i += 1 i += 1 self.final_messages = final_messages # update data structures self.map = np.nonzero(np.isnan( self.final_messages.reshape(-1)))[0] self.rx_symbols = self.rx_symbols[unsolved, :] self.J = self.J[unsolved, :] self.I = self.I[unsolved, :] self.A = self.A[unsolved, :] if self.verbose: print 'Total number of transmissions: ', self.TOTAL_TRANSMISSIONS return self.TOTAL_TRANSMISSIONS
imgArray.append(frame) maskArray.append(mask) alignedFolderNum = len(os.listdir(txtFolder)) # save inpainting frames result outputInpaintPath = txtFolder + '/inpainting/' if not os.path.exists(outputInpaintPath): os.makedirs(outputInpaintPath) else: alignedFolderNum -= 1 for i in trange(alignedFolderNum): # alignment curFrame = alignment(txtFolder, i, imgArray, maskArray) # inpainting if args.mode == 'N': newFrame, newMask = noWeightInpainting(txtFolder, outputInpaintPath, i, curFrame) elif args.mode == 'O': newFrame, newMask = oneLookInpainting(txtFolder, outputInpaintPath, i, curFrame) elif args.mode == 'G': newFrame, newMask = gaussianInpainting(txtFolder, outputInpaintPath, i, curFrame) else: print("Undefined inpainting mode! Use default inpainting mode.")
def main_loop(self): eps_vec = 0.5 * np.ones(self.N) i = 1 while np.any(np.isnan(self.final_messages)): Kprime = len(self.map) if self.verbose: print "Remaining ", Kprime, " nodes are: " print self.map ## special case for one remaining node if Kprime == 1: self.TOTAL_TRANSMISSIONS += 1 while not transmit_messages(1, eps_vec[self.map]): self.TOTAL_TRANSMISSIONS += 1 self.final_messages[self.map] = self.W[self.map] else: ## Generate next m transmissions (V, U) = alignment("mixed", self.J, 1e-4, 100, False) m = np.shape(V)[0] if self.verbose: print "Minimum rank is ", m # generate next symbol based on current V L = len(self.tx_symbols) if i == 1: L = 0 unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(unsolved) and m_i < m: self.tx_symbols = np.append(self.tx_symbols, Symbol(V[m_i, :], self.W, self.map)) R = transmit_messages(1, eps_vec[self.map]) if i == 1: self.rx_symbols = R else: self.rx_symbols = np.bmat([self.rx_symbols, R]) if self.verbose: print "Transmission ", m_i + 1, "/", m print self.rx_symbols.astype(int) self.TOTAL_TRANSMISSIONS += 1 # solve for messages if possible # SEND TO TARGET HERE (unsolved, final_messages) = bs_decode_messages( self.dest, Kprime, self.map, self.rx_symbols, self.tx_symbols, self.A, self.I, self.J, self.W, self.final_messages, self.verbose, ) # RECEIVE FROM TARGET HERE # INTERPRET ACKS HERE m_i += 1 i += 1 self.final_messages = final_messages # update data structures self.map = np.nonzero(np.isnan(self.final_messages.reshape(-1)))[0] self.rx_symbols = self.rx_symbols[unsolved, :] self.J = self.J[unsolved, :] self.I = self.I[unsolved, :] self.A = self.A[unsolved, :] if self.verbose: print "Total number of transmissions: ", self.TOTAL_TRANSMISSIONS return self.TOTAL_TRANSMISSIONS
import model_data as md import pathway_data as pd from alignment import alignment from bigg_data import bigg_data """ model = md.model_data() #model.load_model_sbml("iCHOv1_final.xml") #model.load_model_cobra_sbml("iCHOv1_final.xml") #model.load_model_mat("gimmeDG44.mat") model.load_model_mat("gimmeS.mat") #model.load_model_mat("gimmeK1.mat") """ align = alignment() dummy = -1 reload = 0 if dummy == 1: align.load_dummy() elif dummy == -1: model = md.model_data() #model.load_model_mat("gimmeS.mat") # omogociti uporabniku, da izbere tip modela iz seznama modelov, ki ga pridobimo iz bigg-a #model.load_model_cobra_sbml("iCHOv1_bigg.xml") model.load_model_cobra_sbml("e_coli_core.xml") #if reload: # model.get_ECs() # model.save_ECs("ec.txt") #else: # model.get_ECs_from_file("ec.txt")
def bs_index_coding(K, eps, verbose=True, dest=False): if dest == False: rand_dest = True else: rand_dest = False eps_vec = eps*np.ones(K) if verbose: print ' ' print 'Number of receivers/nodes: ', K print 'Erasure prob is ', eps print '-----------' # generate random messages W = np.random.randint(1,257, (K,1)) # store final received messages. goal is to "de-NaN" by the end final_messages = np.nan*np.zeros((K, 1)) # keep track of all transmitted and received messages/symbols tx_symbols = np.array([]) # [1 -by- # of transmissions] # keep track of number of transmissions TOTAL_TRANSMISSIONS = 0 ## Base Station - to - cellular model # Uplink is assumed perfect, i.e. the BS has access to all messages and # their destinations if rand_dest: if verbose: print 'Message destinations chosen randomly' dest = singlerandperm(K); # receiver i wants message dest(i) print dest A = np.diag(W.reshape(-1)) # receiver (row) i has access to the message it plans to send mat_dest = (np.arange(K), np.array(dest)) signal_space = np.zeros((K,K))>0 signal_space[mat_dest] = True; I = compute_interferers(A, signal_space) J = I.astype(float) J[mat_dest] = -1 map = np.arange(K) if verbose: print 'Interferer matrix is:' print J i = 1 while np.any(np.isnan(final_messages)): Kprime = len(map); if verbose: print 'Remaining ', Kprime, ' nodes are: ' print map ## special case for one remaining node if Kprime == 1: TOTAL_TRANSMISSIONS = TOTAL_TRANSMISSIONS + 1 while not transmit_messages(1, eps_vec[map]): TOTAL_TRANSMISSIONS = TOTAL_TRANSMISSIONS + 1 final_messages[map] = W[map] else: ## Generate next m transmissions (V, U) = alignment('mixed', J, 1e-4, 100, False) m = np.shape(V)[0] if verbose: print 'Minimum rank is ', m # generate next symbol based on current V L = len(tx_symbols); if i == 1: L = 0 unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(unsolved) and m_i < m: tx_symbols = np.append(tx_symbols, Symbol(V[m_i,:], W, map)) R = transmit_messages(1, eps_vec[map]) if i == 1: rx_symbols = R else: rx_symbols = np.bmat([rx_symbols, R]) if verbose: print 'Transmission ', m_i+1, '/', m print rx_symbols.astype(int) TOTAL_TRANSMISSIONS += 1 # solve for messages if possible (unsolved, final_messages) = bs_decode_messages(dest, Kprime, map, rx_symbols, tx_symbols, A, I, J, W, final_messages, verbose) m_i += 1 i += 1 # update data structures map = np.nonzero(np.isnan(final_messages.reshape(-1)))[0] rx_symbols = rx_symbols[unsolved, :] J = J[unsolved, :] I = I[unsolved, :] A = A[unsolved, :] if verbose: print 'Total number of transmissions: ', TOTAL_TRANSMISSIONS return TOTAL_TRANSMISSIONS
def main_loop(self): #change to compute_matrixes smsgx = TxSerialMsg() self.TDMA_MODE = 0; eps_vec = .5*np.ones(self.N) i = 1 while np.any(np.isnan(self.final_messages)): Kprime = len(self.map); if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node if Kprime == 1: self.TOTAL_TRANSMISSIONS += 1 while not transmit_messages(1, eps_vec[self.map]): self.TOTAL_TRANSMISSIONS += 1 self.final_messages[self.map] = self.W[self.map] else: ## Generate next m transmissions (V, U) = alignment('mixed', self.J, 1e-4, 100, False) m = np.shape(V)[0] if self.verbose: print 'Minimum rank is ', m # generate next symbol based on current V L = len(self.tx_symbols); if i == 1: L = 0 self.unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(self.unsolved) and m_i < m: self.tx_symbols = np.append(self.tx_symbols, Symbol(V[m_i,:], self.W, self.map)) R = transmit_messages(1, eps_vec[self.map]) if i == 1: self.rx_symbols = R else: self.rx_symbols = np.bmat([self.rx_symbols, R]) if self.verbose: print 'Transmission ', m_i+1, '/', m print self.rx_symbols.astype(int) self.TOTAL_TRANSMISSIONS += 1 # solve for messages if possible (self.unsolved, final_messages) = bs_decode_messages(self.dest, Kprime, self.map, self.rx_symbols, self.tx_symbols, self.A, self.I, self.J, self.W, self.final_messages, self.verbose) time.sleep(.2) print 'UNSOLVED: ', self.unsolved print 'MAP: ' , self.map #SEND TO TARGET HERE, rewrite these lines #smsg.set_crow print 'tx map ', self.map smsgx.set_messageid(255) #now something to represent index coding, 255? smsgx.set_data(np.dot(V[m_i],self.W,)) ##also send own message w[i] for comparison???? smsgx.set_V_row(V[m_i]) smsgx.set_current_transmission(self.TOTAL_TRANSMISSIONS) self.mif.sendMsg(self.source, 0xFFFF, smsgx.get_amType(), 0, smsgx) #time.sleep(1) #.125 too fast? #INTERPRET ACKS IN RECEIVE FUNCTION m_i += 1 i += 1 self.final_messages = final_messages #still need final messages?? # update data structures self.map = np.nonzero(np.isnan(self.final_messages.reshape(-1)))[0] self.rx_symbols = self.rx_symbols[self.unsolved, :] self.J = self.J[self.unsolved, :] self.I = self.I[self.unsolved, :] self.A = self.A[self.unsolved, :] if self.verbose: print 'Total number of transmissions: ', self.TOTAL_TRANSMISSIONS return self.TOTAL_TRANSMISSIONS
def bs_index_coding(K, eps, verbose=True, dest=False): if dest == False: rand_dest = True else: rand_dest = False eps_vec = eps * np.ones(K) if verbose: print ' ' print 'Number of receivers/nodes: ', K print 'Erasure prob is ', eps print '-----------' # generate random messages W = np.random.randint(1, 257, (K, 1)) # store final received messages. goal is to "de-NaN" by the end final_messages = np.nan * np.zeros((K, 1)) # keep track of all transmitted and received messages/symbols tx_symbols = np.array([]) # [1 -by- # of transmissions] # keep track of number of transmissions TOTAL_TRANSMISSIONS = 0 ## Base Station - to - cellular model # Uplink is assumed perfect, i.e. the BS has access to all messages and # their destinations if rand_dest: if verbose: print 'Message destinations chosen randomly' dest = singlerandperm(K) # receiver i wants message dest(i) print dest A = np.diag(W.reshape( -1)) # receiver (row) i has access to the message it plans to send mat_dest = (np.arange(K), np.array(dest)) signal_space = np.zeros((K, K)) > 0 signal_space[mat_dest] = True I = compute_interferers(A, signal_space) J = I.astype(float) J[mat_dest] = -1 map = np.arange(K) if verbose: print 'Interferer matrix is:' print J i = 1 while np.any(np.isnan(final_messages)): Kprime = len(map) if verbose: print 'Remaining ', Kprime, ' nodes are: ' print map ## special case for one remaining node if Kprime == 1: TOTAL_TRANSMISSIONS = TOTAL_TRANSMISSIONS + 1 while not transmit_messages(1, eps_vec[map]): TOTAL_TRANSMISSIONS = TOTAL_TRANSMISSIONS + 1 final_messages[map] = W[map] else: ## Generate next m transmissions (V, U) = alignment('mixed', J, 1e-4, 100, False) m = np.shape(V)[0] if verbose: print 'Minimum rank is ', m # generate next symbol based on current V L = len(tx_symbols) if i == 1: L = 0 unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(unsolved) and m_i < m: tx_symbols = np.append(tx_symbols, Symbol(V[m_i, :], W, map)) R = transmit_messages(1, eps_vec[map]) if i == 1: rx_symbols = R else: rx_symbols = np.bmat([rx_symbols, R]) if verbose: print 'Transmission ', m_i + 1, '/', m print rx_symbols.astype(int) TOTAL_TRANSMISSIONS += 1 # solve for messages if possible (unsolved, final_messages) = bs_decode_messages( dest, Kprime, map, rx_symbols, tx_symbols, A, I, J, W, final_messages, verbose) m_i += 1 i += 1 # update data structures map = np.nonzero(np.isnan(final_messages.reshape(-1)))[0] rx_symbols = rx_symbols[unsolved, :] J = J[unsolved, :] I = I[unsolved, :] A = A[unsolved, :] if verbose: print 'Total number of transmissions: ', TOTAL_TRANSMISSIONS return TOTAL_TRANSMISSIONS
def main_loop(self): #change to compute_matrixes smsgx = TxSerialMsg() self.TDMA_MODE = 0 eps_vec = .5 * np.ones(self.N) i = 1 while np.any(np.isnan(self.final_messages)): Kprime = len(self.map) if self.verbose: print 'Remaining ', Kprime, ' nodes are: ' print self.map ## special case for one remaining node if Kprime == 1: self.TOTAL_TRANSMISSIONS += 1 while not transmit_messages(1, eps_vec[self.map]): self.TOTAL_TRANSMISSIONS += 1 self.final_messages[self.map] = self.W[self.map] else: ## Generate next m transmissions (V, U) = alignment('mixed', self.J, 1e-4, 100, False) m = np.shape(V)[0] if self.verbose: print 'Minimum rank is ', m # generate next symbol based on current V L = len(self.tx_symbols) if i == 1: L = 0 self.unsolved = np.ones(Kprime) > 0 m_i = 0 while np.all(self.unsolved) and m_i < m: self.tx_symbols = np.append( self.tx_symbols, Symbol(V[m_i, :], self.W, self.map)) R = transmit_messages(1, eps_vec[self.map]) if i == 1: self.rx_symbols = R else: self.rx_symbols = np.bmat([self.rx_symbols, R]) if self.verbose: print 'Transmission ', m_i + 1, '/', m print self.rx_symbols.astype(int) self.TOTAL_TRANSMISSIONS += 1 # solve for messages if possible (self.unsolved, final_messages) = bs_decode_messages( self.dest, Kprime, self.map, self.rx_symbols, self.tx_symbols, self.A, self.I, self.J, self.W, self.final_messages, self.verbose) time.sleep(.2) print 'UNSOLVED: ', self.unsolved print 'MAP: ', self.map #SEND TO TARGET HERE, rewrite these lines #smsg.set_crow print 'tx map ', self.map smsgx.set_messageid( 255) #now something to represent index coding, 255? smsgx.set_data(np.dot( V[m_i], self.W, )) ##also send own message w[i] for comparison???? smsgx.set_V_row(V[m_i]) smsgx.set_current_transmission(self.TOTAL_TRANSMISSIONS) self.mif.sendMsg(self.source, 0xFFFF, smsgx.get_amType(), 0, smsgx) #time.sleep(1) #.125 too fast? #INTERPRET ACKS IN RECEIVE FUNCTION m_i += 1 i += 1 self.final_messages = final_messages #still need final messages?? # update data structures self.map = np.nonzero(np.isnan( self.final_messages.reshape(-1)))[0] self.rx_symbols = self.rx_symbols[self.unsolved, :] self.J = self.J[self.unsolved, :] self.I = self.I[self.unsolved, :] self.A = self.A[self.unsolved, :] if self.verbose: print 'Total number of transmissions: ', self.TOTAL_TRANSMISSIONS return self.TOTAL_TRANSMISSIONS