def __init__(self, x_start, y_start, x_goal, y_goal): self.path = [] self.s_start = State(x_start, y_start, Pair(0, 0)) self.s_goal = State(x_goal, y_goal, Pair(0, 0)) self.clear_fields()
def scheme_read(src): """Read the next expression from SRC, a Buffer of tokens. >>> scheme_read(Buffer(tokenize_lines(['nil']))) nil >>> scheme_read(Buffer(tokenize_lines(['1']))) 1 >>> scheme_read(Buffer(tokenize_lines(['true']))) True >>> scheme_read(Buffer(tokenize_lines(['(+ 1 2)']))) Pair('+', Pair(1, Pair(2, nil))) """ if src.current is None: raise EOFError val = src.pop_first() # Get and remove the first token if val == 'nil': # BEGIN PROBLEM 2 "*** YOUR CODE HERE ***" return nil # END PROBLEM 2 elif val == '(': # BEGIN PROBLEM 2 "*** YOUR CODE HERE ***" return read_tail(src) # END PROBLEM 2 elif val == "'": # BEGIN PROBLEM 3 "*** YOUR CODE HERE ***" return Pair('quote', Pair(scheme_read(src), nil)) # END PROBLEM 3 elif val not in DELIMITERS: return val else: raise SyntaxError('unexpected token: {0}'.format(val))
def move(self): """Move self to a new position in its world, by adding the x and y coordinates of its velocity vector to the x, y coordinates of its current position.""" width = self._world.get_width() height = self._world.get_height() new_x = self._position[0] + self._velocity[0] new_x = min(max(0, new_x), width - 1) new_y = self._position[1] + self._velocity[1] new_y = min(max(0, new_y), height - 1) if self._world[new_x, new_y] == None: self._world[new_x, new_y] = self del self._world[self._position.get()] self._position = Pair(new_x, new_y) self._turtle.goto(new_x, new_y) # If the boid is approaching a boundary of world, have it turn # in the next step: if (self._velocity[0] < 0 and new_x < 5) or \ (self._velocity[0] > 0 and new_x > width - 5) or \ (self._velocity[1] < 0 and new_y < 5) or \ (self._velocity[1] > 0 and new_y > height - 5): self._velocity.turn( TURN_ANGLE) # Turn angle is a constant in the sim
def get_candidates(self, word, gold=False, top=False): candidates = set() if self.supervised: if word in self.gold_parents: candidates.add(self.gold_parents[word]) if gold: return candidates if word in self.candidates_cache: return self.candidates_cache[word] candidates.add((word, 'STOP')) if len(word) < 3: return candidates for pos in xrange(1, len(word)): parent = word[:pos] if self.compounding and parent in self.word_cnt and word[pos:] in self.word_cnt: if self.word_cnt[parent] >= self.freq_thresh and self.word_cnt[word[pos:]] >= self.freq_thresh: candidates.add(((parent, word[pos:]), 'COM_LEFT')) candidates.add(((parent, word[pos:]), 'COM_RIGHT')) if 2 * len(parent) >= len(word): pair = Pair(word, parent, 'SUFFIX') suf, _ = pair.get_affix_and_transformation() if not self.pruner or suf not in self.pruner['suf']: candidates.add((parent, 'SUFFIX')) if self.transform: if pos < len(word) - 1 and word[pos - 1] == word[pos]: pair = Pair(word, parent, 'REPEAT') suf, trans = pair.get_affix_and_transformation() if not self.pruner or suf not in self.pruner['suf']: if not self.pruner or trans not in self.pruner['REPEAT']: candidates.add((parent, 'REPEAT')) if parent[-1] in self.alphabet: for char in self.alphabet: if char == parent[-1]: continue new_parent = parent[:-1] + char if self.get_similarity(new_parent, word) > 0.2: pair = Pair(word, new_parent, 'MODIFY') suf, trans = pair.get_affix_and_transformation() if not self.pruner or suf not in self.pruner['suf']: if not self.pruner or trans not in self.pruner['MODIFY']: candidates.add((new_parent, 'MODIFY')) if pos < len(word) - 1 and word[pos:] in self.suffixes: for char in self.alphabet: new_parent = parent + char if word == new_parent: continue if new_parent in self.word_cnt: pair = Pair(word, new_parent, 'DELETE') suf, trans = pair.get_affix_and_transformation() if not self.pruner or suf not in self.pruner['suf']: if not self.pruner or trans not in self.pruner['DELETE']: candidates.add((new_parent, 'DELETE')) parent = word[pos:] if len(parent) * 2 >= len(word): pair = Pair(word, parent, 'PREFIX') pre, _ = pair.get_affix_and_transformation() if not self.pruner or pre not in self.pruner['pre']: candidates.add((parent, 'PREFIX')) self.candidates_cache[word] = candidates return candidates
def _check_targetrc(self, pair): rcpair = Pair() rcpair.set_from_data(pair.identifier, reverse_complement(pair.r1.original_seq), reverse_complement(pair.r2.original_seq)) if self._run.cotrans: rcpair.r2.linker_start = pair.r2.linker_start self._find_matches(rcpair) if rcpair.matched or (self._run.cotrans and self._cotrans_find_short_matches(rcpair)): self.counters.dna_residual_pairs += 1
def list(args, env): p = None pt = None while len(args) > 0: o = Native.ARG(args) if p == None: p = Pair(o, None) pt = p else: pt.cdr = Pair(o, None) pt = pt.cdr return p
def get_predecessors(self, u): s = [] tmp = State(u.x + 1, u.y, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x + 1, u.y + 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x, u.y + 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x - 1, u.y + 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x - 1, u.y, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x - 1, u.y - 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x, u.y - 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) tmp = State(u.x + 1, u.y - 1, Pair(-1, -1)) if not self.occupied(tmp): s.append(tmp) return s
def match_feature(self): """ Brute force feature Matching :return: None """ number_of_image = len(self.frame_set) for i in range(number_of_image): for j in range(i+1, number_of_image): temp_pair = Pair(self.frame_set[i], self.frame_set[j]) feature_matcher = cv2.BFMatcher(cv2.NORM_L2SQR, True) all_matches = feature_matcher.match( self.frame_set[i].feature_descriptor, self.frame_set[j].feature_descriptor) temp_pair.matches = all_matches self.pair_set.append(temp_pair)
def preprocess(xml_file='', senna_path='/media/raid-vapnik/tools/senna/', tt_path='/home/tools/treetagger/'): entailment_pairs = [] tree = ET.parse(xml_file) pairs = tree.getroot() (filepath, filename) = os.path.split(xml_file) (name, extension) = os.path.splitext(filename) for pair in pairs: attrib = pair.attrib id = attrib['id'] value = attrib['entailment'] task = attrib['task'] texts = pairs.findall("./pair[@id='%s']/t" % id) hypos = pairs.findall("./pair[@id='%s']/h" % id) text = texts[0].text hypo = hypos[0].text features_text = run_senna(text, id, name, senna_path, tt_path) features_hypo = run_senna(hypo, id, name, senna_path, tt_path) pair = Pair(id, text, hypo, value, task, features_text, features_hypo) entailment_pairs.append(pair) pickle_name = '%s.pickle' % name with open(pickle_name, 'w') as f: pickle.dump(entailment_pairs, f) f.close() return
def measure(self, n=16, corrections=False): serial = input(_C.YEL + 'Insert 1st electrode with calibration ring and scan serial: ' + _C.ENDC) electrodes = [] times = [] for i in range(2): if i == 1: input(_C.YEL + 'Insert 2nd electrode with calibration and press [Enter]') t0 = time.time() CoupledCapture(n=n, directory='combined', stp=self.stp, cam=self.cam) print(_C.CYAN + _C.BOLD + 'Evaluating electrode' + _C.ENDC) spiral, calibration = CombinedSequence(n=n, directory='hardware/combined', env=env) print(_C.CYAN + _C.BOLD + 'Measurement completed in ' + str(round(time.time() - t0, 2)) + 's' + _C.ENDC) localElectrode = Electrode(serial, spiral, calibration) electrodes.append(copy.copy(localElectrode)) times.append(time.time() - t0) print(_C.CYAN + _C.BOLD + 'Pair completed in ' + str(round(sum(times), 2)) + 's' + _C.ENDC) pair = Pair(env=env, electrodes=tuple(electrodes), serial=serial, corrections=corrections) return pair
def read_tail(src): """Return the remainder of a list in SRC, starting before an element or ). >>> read_tail(Buffer(tokenize_lines([')']))) nil >>> read_tail(Buffer(tokenize_lines(['2 3)']))) Pair(2, Pair(3, nil)) """ try: while src.end_of_line(): src.pop_first() if src.current is None: raise SyntaxError('unexpected end of file') elif src.current == ')': # BEGIN PROBLEM 2 "*** YOUR CODE HERE ***" src.pop_first() return nil # END PROBLEM 2 else: # BEGIN PROBLEM 2 "*** YOUR CODE HERE ***" first = scheme_read(src) second = read_tail(src) pair = Pair(first, second) return pair # END PROBLEM 2 except EOFError: raise SyntaxError('unexpected end of file')
def preprocess(parc_file='', score_file='', task='sts', senna_path='/media/raid-vapnik/tools/senna/', tt_path='/home/tools/treetagger/'): entailment_pairs = [] scores = load_scores(score_file) (filepath, filename) = os.path.split(parc_file) (name, extension) = os.path.splitext(filename) with open(parc_file, 'r') as parc_f: id = 0 for line in parc_f: if not line.strip(): continue line = line.rstrip('\n') (text, hypo) = line.split('|||') features_text = run_senna(text, id, name, senna_path, tt_path) features_hypo = run_senna(hypo, id, name, senna_path, tt_path) value = scores.popleft() id += 1 pair = Pair(id, text, hypo, value, task, features_text, features_hypo) entailment_pairs.append(pair) (filepath, filename) = os.path.split(parc_file) (pickle_name, extension) = os.path.splitext(filename) pickle_name = '%s.pickle' % pickle_name with open(pickle_name, 'w') as f: pickle.dump(entailment_pairs, f) f.close() return
def sexp(tokens): o = tokens.pop(0) if len(tokens) == 0: return None elif isinstance(o, str) and o == "\"": #quote nx = tokens.pop(0) ss = nx while len(tokens) > 0 and nx != "\"": ss += nx nx = tokens.pop(0) if nx != "\"": raise ValueError("Unterminated string constant") return ss elif isinstance(o, str) and o == "(": return Parse.next_list(tokens) elif isinstance(o, str) and o == "'": #casiquote return Pair("quote", Parse.sexp(tokens)) else: if o.isnumeric() or Parse.is_valid_decimal(o): if ("." in o): return float(o) else: return int(o) return o
def next_list(tokens): cur = Parse.sexp(tokens) p = None pt = None while len(tokens) > 0 and cur != None and cur != ")": if p == None: p = Pair(cur, None) pt = p else: pt.cdr = Pair(cur, None) pt = pt.cdr cur = Parse.sexp(tokens) return p
def update_cell(self, x, y, val): u = State(x, y, Pair(0, 0)) if u == self.s_start or u == self.s_goal: return self.make_new_cell(u) self.cell_hash[u].cost = val self.update_vertex(u)
def match_feature(self): """ Brute force feature Matching :return: None """ number_of_image = len(self.frame_set) self._read_projection_matrix() for i in range(number_of_image): for j in range(i + 1, number_of_image): temp_pair = Pair(self.frame_set[i], self.frame_set[j]) temp_pair.projection_matrix_1 = self.projection_matrix[i] temp_pair.projection_matrix_2 = self.projection_matrix[j] feature_matcher = cv2.BFMatcher(cv2.NORM_L1, True) all_matches = feature_matcher.match( self.frame_set[i].feature_descriptor, self.frame_set[j].feature_descriptor) temp_pair.matches = all_matches self.pair_set.append(temp_pair)
def map_explosions(pair: Pair, explosions: list = []) -> None: if pair is None: return else: if pair.get_depth() >= 4 and pair.value is None: explosions.append(pair) else: map_explosions(pair.left, explosions) map_explosions(pair.right, explosions)
def Import(self, file): f = open(file, 'r') status = 'outside' current = None stored = [] linec = 0 try: while True: line = f.readline().strip().replace('\n', '') linec = linec + 1 if line.startswith('<chat>'): status = self.check(status, 'outside', 'chat', linec) line = line[6:] if line.startswith('</chat>'): status = self.check(status, 'chat', 'outside', linec) break if line.startswith('<message>'): status = self.check(status, 'chat', 'message', linec) current = bufferedMsg() if line.startswith('</message>'): status = self.check(status, 'message', 'chat', linec) stored.append(current) current = None if line.startswith('<me>'): status = self.check(status, 'message', None, linec) current.isMe = line[4:5] == '1' if line.startswith('<media>'): status = self.check(status, 'message', None, linec) current.hasMedia = True if line.startswith('<msg>'): status = self.check(status, 'message', None, linec) current.text = line[5:-6] if line.startswith('<date>'): status = self.check(status, 'message', None, linec) # ignore date for now continue f.close() if status != 'outside' or current: print('this file is malformed, try to continue. ', status) print('\n', len(stored), 'Chat messages read. Processing...') stored.reverse() saved = [] # list of all pairs to return for i in range(1, len(stored) - 1): # 0. muss nicht angeschaut werden. # print(stored[i]) if stored[i].isMe and not stored[i].hasMedia: if not stored[i - 1].isMe and not stored[i - 1].hasMedia: saved = addPair( Pair(stored[i - 1].text, stored[i].text), saved) return saved except Exception as e: print('unexpected Error', e, status) return []
def match_feature(self): """ Brute force feature Matching :return: None """ number_of_image = len(self.frame_set) self._read_projection_matrix() for i in range(number_of_image): for j in range(i+1, number_of_image): temp_pair = Pair(self.frame_set[i], self.frame_set[j]) temp_pair.projection_matrix_1 = self.projection_matrix[i] temp_pair.projection_matrix_2 = self.projection_matrix[j] feature_matcher = cv2.BFMatcher(cv2.NORM_L1, True) all_matches = feature_matcher.match( self.frame_set[i].feature_descriptor, self.frame_set[j].feature_descriptor) temp_pair.matches = all_matches self.pair_set.append(temp_pair)
def associateDescriptionsWithImages(descriptionsFolder, imagesFolder): pairs = [] descriptionsFolderContent = descriptionsFolder.getListOfFiles() for descriptionFile in descriptionsFolderContent: imageFile = findCorrespondingImage(descriptionFile, imagesFolder) if (imageFile is not None): pair = Pair(descriptionFile, imageFile) pairs.append(pair) return pairs
def _segment_iter(self, node): type_ = self.types[node] parent = self.parents[node] pair = Pair(node, parent, type_) if type_ == 'STOP': return Segment(node, node, 'stem') if type_ in ['COM_LEFT', 'COM_RIGHT', 'HYPHEN']: p1, p2 = self.parents[node] return self._segment_iter(p1).splice(self._segment_iter(p2)) else: return self._segment_iter(parent).extend(pair)
def create_random_pairs_help(participants: []): not_yet_receiver = participants.copy() pairs = [] for imp in participants: receiver = not_yet_receiver[randint(0, len(not_yet_receiver) - 1)] try: pairs.append(Pair(imp, receiver)) except ValueError: return None not_yet_receiver.remove(receiver) return pairs
def __init__(self, env, ord): #cria uma dupla aleatoria, que sera o ponto de inicio da tempera self.pair = Pair() #inicializa variaveis de ambiente aleatórias self.environment = env #inicializa variaveis da ordem de entrega aleatórias self.order = ord self.tempo = 0 self.iteracoes = 100000 #inicializa o grafico, com o plot da curva de risco self.create_plt()
def __init__(self, myworld): """Construct a boid at a random position in the given world. Args: myworld (World object): a World object. """ self._world = myworld (x, y) = (random.randrange(self._world.get_width()), random.randrange(self._world.get_height())) while self._world[x, y] != None: (x, y) = (random.randrange(self._world.get_width()), random.randrange(self._world.get_height())) self._position = Pair(x, y) self._world[x, y] = self self._velocity = Vector( (random.uniform(-1, 1), random.uniform(-1, 1))).unit() self._turtle = turtle.Turtle() self._turtle.speed(0) self._turtle.up() self._turtle.setheading(self._velocity.angle())
def create_pairs(g, r): givers = g[:] receivers = r[:] pairs = [] for giver in givers: try: receiver = choose_receiver(giver, receivers) receivers.remove(receiver) pairs.append(Pair(giver, receiver)) except: return create_pairs(g, r) return pairs
def computePaires(self, instances): maxDelta = 0 result = Pair() paires = [] for i in range(self.genNumber): if i == self.classIndex: None else: j = i + 1 while j < self.genNumber: j = j + 1 if j == self.classIndex: None result = computeSingleDelta(instances,i,j) if maxDelta < result.getDelta(): maxDelta = result.getDelta() paires.clear() paires.append(result) if maxDelta == result.getDelta(): paires.append(result)
def _worker(self, worker_id): try: processor = self._processor processor.reset_counts() if self._pair_db: self._pair_db.worker_id = worker_id writeback = bool(self._result_set_id) tagged = processor.uses_tags use_quality = self._run._parse_quality pair = Pair() while True: pairs = self._pairs_to_do.get() if not pairs: break results = [] for lines in pairs: pair.set_from_data(lines[3], str(lines[1]), str(lines[2]), lines[0]) if use_quality: pair.r1.quality = str(lines[4]) pair.r2.quality = str(lines[5]) if self.force_mask: pair.set_mask(self.force_mask) processor.process_pair(pair) #if pair.failure: # print('FAIL: {}'.format(pair.failure)) if writeback: results.append(self._make_result(lines[3], pair, tagged)) if writeback: self._results.put(results) if not self._run.quiet: sys.stdout.write('.')#str(worker_id)) sys.stdout.flush() self._pairs_done.put(processor.counters.count_data()) except: print("**** Worker exception, aborting...") raise
def Import(self, file): saved = [] f = open(file, 'r') i = 0 while True: line = f.readline() i = i + 1 if not line: break if '\0' in line: line = line.rstrip() # remove trailing newline q, a = line.split('\0', 1) asplit = a.split('\0') pair = Pair(q, None) for awns in asplit: pair.addawns(awns) saved.append(pair) else: print('wired line:', i) f.close() return saved
def create_pairs(matrixes, parts): small_pair_lists = [] for i in range(parts): small_pair_lists.append([]) j = 0 for i in range(len(matrixes)): if j == parts: j = 0 small_pair_lists[j].append(Pair(matrixes[i])) j = j + 1 return small_pair_lists
def get_positive_pairs(folder, all_pairs): files1 = os.listdir(folder) shuffle(files1) last_len = len(all_pairs) files1 = files1[:83] for file1 in files1: pair_count = 0 for file2 in files1[files1.index(file1) + 1:]: if file1 == file2: # not necessary, actually continue pair_count += 1 par = Pair(folder + '/' + file1, folder + '/' + file2, 1) # Same class all_pairs.append(par)
def update_goal(self, x, y): to_add = [] for state in self.cell_hash: if not self.close(self.cell_hash[state], self.STRAIGHT_DIST): to_add.append( Pair(Point(state.x, state.y), self.cell_hash[state].cost)) self.s_goal.x = x self.s_goal.y = y self.clear_fields() for p in to_add: self.update_cell(p.first().x, p.first().y, p.second())
def get_successors(self, u): s = [] if self.occupied(u): return s s.append(State(u.x + 1, u.y, Pair(-1, -1))) s.append(State(u.x + 1, u.y + 1, Pair(-1, -1))) s.append(State(u.x, u.y + 1, Pair(-1, -1))) s.append(State(u.x - 1, u.y + 1, Pair(-1, -1))) s.append(State(u.x - 1, u.y, Pair(-1, -1))) s.append(State(u.x - 1, u.y - 1, Pair(-1, -1))) s.append(State(u.x, u.y - 1, Pair(-1, -1))) s.append(State(u.x + 1, u.y - 1, Pair(-1, -1))) return s
def run_simple(self, pair_iterator): quiet = self._run.quiet run_limit = self._run._run_limit more_pairs = True pair_db = self._pair_db writeback = bool(self._result_set_id) sam = bool(self._run.generate_sam) channel_reads = bool(self._run.generate_channel_reads) use_quality = self._run._parse_quality total = 0 if writeback: result_set_id = self._result_set_id processor = self._processor if self._pair_db: self._pair_db.worker_id = 0 tagged = processor.uses_tags pair = Pair() if sam: sam_writer = SamWriter(self._run.generate_sam, processor._targets.targets) if channel_reads: plus_writer = FastqWriter('R1_plus.fastq', 'R2_plus.fastq') minus_writer = FastqWriter('R1_minus.fastq', 'R2_minus.fastq') while more_pairs: try: while True: pair_info = next(pair_iterator) if not quiet: sys.stdout.write('^') sys.stdout.flush() results = [] for lines in pair_info: pair.set_from_data(lines[3], str(lines[1]), str(lines[2]), lines[0]) if use_quality: pair.r1.quality = str(lines[4]) pair.r2.quality = str(lines[5]) if self.force_mask: pair.set_mask(self.force_mask) try: processor.process_pair(pair) except: print("**** Error processing pair: {} / {}".format(pair.r1.original_seq, pair.r2.original_seq)) raise if sam: sam_writer.write(pair) if channel_reads and pair.has_site: if pair.mask.chars == self._run.masks[0]: plus_writer.write(pair) else: minus_writer.write(pair) total += pair.multiplicity if writeback: results.append(self._make_result(lines[3], pair, tagged)) if not quiet: sys.stdout.write('v') sys.stdout.flush() if results: pair_db.add_results(self._result_set_id, results) if not quiet: sys.stdout.write('.') sys.stdout.flush() if run_limit and total > run_limit: raise StopIteration() except StopIteration: more_pairs = False if not self._run.quiet: print("\nAggregating data...") processor.counters.total_pairs = total if self._pair_db: processor.counters.unique_pairs = self._pair_db.unique_pairs()
def generate_interactions_o(self,interaction_name,bond="harmonic",SPB=False,radius=10,cutoff=1.15,reducedv_factor=1,khun=1.): if bond == "harmonic" : temp1 = "bond_style harmonic\n" temp2 = "bond_coeff %i %.2f %.2f" ene = 350 if bond == "fene": if SPB: temp1 = "bond_style hybrid harmonic fene\n" temp2 = "bond_coeff %i fene %.2f %.2f %.2f %.2f" else: temp1 = "bond_style fene\n" temp2 = "bond_coeff %i %.2f %.2f %.2f %.2f" ene = 30 * 1 Bond = [temp1] if bond == "fene": Bond.append("special_bonds fene\n") ene_ratio=1#.35 #Bond.append("special_bonds 0.0 1.0 1.0\n") if SPB and False: #print radius Pair = ["pair_style hybrid lj/cut 3.0 gauss/cut %.2f \n"%(2*radius) + "pair_modify shift yes\n"] else: Pair = ["pair_style lj/cut 1.4 \n" + "pair_modify shift yes\n"] Angle = ["angle_style cosine/delta\n"] Angle = ["angle_style harmonic\n"] keyl = range(1,len(self.natom)+1) for t1 in keyl: for t2 in keyl: if t2 >= t1: if not self.liaison.has_key("%s-%s"%(t1,t2)): print "Warning liaison between {0} and {1} not defined".format(t1,t2) dist,tybe_b = self.liaison["%s-%s"%(t1,t2)] if cutoff is not None: cut = dist*cutoff else: cut = dist*pow(2.,1/6.) odist = copy.deepcopy(dist) #dist=1 if bond == "fene": Bond.append(temp2 % (tybe_b,ene_ratio * ene/(dist*dist),1.5*dist,ene_ratio,dist) +"\n") else: Bond.append(temp2 % (tybe_b, ene,dist) +"\n") dist = odist precise ="" if SPB and False: precise = "lj/cut" reduced = 1 if t1 == t2 and t1 == 3: reduced = 1 else: reduced = reducedv_factor Pair.append("""pair_coeff %s %s %s %.1f %.2f %.2f\n"""%(t1,t2,precise,ene_ratio,dist*reduced,cut*reduced)) if self.angle_def is not None and self.Angle != []: for t3 in keyl: if t3 >= t2: dist,tybe_b = self.angle_def["%s-%s-%s"%(t1,t2,t3)] k=khun/2. * dist # dist = 1 if no ribo involved else 0 Angle.append("angle_coeff %i %.3f 180.0\n"%(tybe_b,k)) if SPB: if bond == "fene": Bond.append("bond_coeff %i harmonic 0 0 \n"%(self.liaison["spb"][1])) spbond = "bond_coeff %i harmonic %.1f %.1f\n"%(self.liaison["spb"][1],10,microtubule/realsigma) else: Bond.append("bond_coeff %i 0 0 \n"%(self.liaison["spb"][1])) spbond = "bond_coeff %i %.1f %.1f\n"%(self.liaison["spb"][1],10,microtubule/realsigma) n_i = len(diameter)/2 for t1 in range(len(diameter) ): Pair.append("""pair_coeff %i %i %s 0. %.2f %.2f\n"""%(t1+1,num_particle["spb"],precise,dist,cut)) Pair.append("""pair_coeff %i %i %s 0. %.2f %.2f\n"""%(num_particle["spb"],num_particle["spb"],precise,dist,cut)) g = open(interaction_name,"w") g.write("".join(Bond)+"\n") g.write("".join(Pair)+"\n") if self.Angle != []: g.write("".join(Angle))