def __add_floating_block(self, block): """ Add a floating block to be tracked by the miner. This is a block from a chain with a greater or equal cost. If the floating block can be added to an existing chain undergoing chain resolution then it will be; otherwise, a new chain will be created to undergo chain resolution. :param block: The floating block to be added. :return: None if the floating block was added to an already tracked chain; otherwise, the newly created chain to undergo chain resolution. """ for chain in self.floating_chains: cur = chain.blocks[-1] if block.is_valid(cur.hash()): logging.debug("Add to existing floating chain") block.set_previous_hash(cur.hash()) chain.add(block) if chain.is_complete(): self.__receive_complete_chain(chain) return None elif block in chain.blocks: return None logging.debug("Create new floating chain") chain = Chain() chain.add(block) self.floating_chains.append(chain) return chain
def sync_overall(save=False, sync_es=False): local_chain = sync_local(sync_es) NODES = nodes.get_list_node(mongo_conn) for peer in NODES: endpoint = peer + '/blockchain' try: r = requests.get(endpoint, timeout=5) chain_data = r.json() peer_blocks = [Block(block_dict) for block_dict in chain_data] peer_chain = Chain(peer_blocks) # check valid , if valid and longer, sync local if peer_chain.is_valid() and len(peer_chain) > len(local_chain): ## insert new block to elasticsearch ## find a new block ## m is length of local_chains ## n la so block moi can them m = len(local_chain) n = len(peer_chain) - len(local_chain) peer_blocks = peer_chain.blocks local_blocks = local_chain.blocks for i in range(0, n): block = local_blocks[i + m] block_dict = block.dict() es.insert_document(block_dict) local_chain = peer_chain except Exception as e: pass if save: local_chain.self_save() return local_chain
def sync_overall(peers, save=False): best_chain = local_chain for peer in peers: # try to connect to peer peer_chain_url = peer + '/chain' try: r = requests.get(peer_chain_url, timeout=5) peer_chain_dict = r.json() peer_blocks = [Block(block_dict) for block_dict in peer_chain_dict] peer_chain = Chain(peer_blocks) if peer_chain.is_valid() and peer_chain > best_chain: best_chain = peer_chain except requests.exceptions.ConnectionError: print("Peer at %s not running. Continuing to next peer." % peer) except requests.exceptions.Timeout: print("Timeout when connecting peer at %s." % peer) else: print( "Peer at %s is running. Gathered their blochchain for analysis." % peer) print("Longest blockchain has %s blocks" % len(best_chain)) # for now, save the new blockchain over whatever was there if save: best_chain.save() return best_chain
def run(self): # The main ETL processing log.info("START") t1 = Util.start_timer("total ETL") # Get the ETL Chain pipeline config strings # Default is to use the section [etl], but may be overidden on cmd line config_section = self.options_dict.get('config_section') if config_section is None: config_section = 'etl' chains_str = self.configdict.get(config_section, 'chains') if not chains_str: raise ValueError('ETL chain entry not defined in section [etl]') # Multiple Chains may be specified in the config chains_str_arr = chains_str.split(',') for chain_str in chains_str_arr: # Build single Chain of components and let it run chain = Chain(chain_str, self.configdict) chain.assemble2() # Run the ETL for this Chain chain.run() Util.end_timer(t1, "total ETL") log.info("ALL DONE")
def __init__(self, **kwargs): self.chain = Chain() self.walkers = [] self.times = np.zeros(1) self.dt = 1e-7 self.update_time_unit_(**kwargs) self.error = 1e-7 self.update_error_(**kwargs) pop = None dat = None try: pop = kwargs['node_population'] except: KeyError try: dat = kwargs['node_data'] except: KeyError self.memory_safe = False #self.population = [] if 'memory_safe' in kwargs.keys(): self.memory_safe = True self.add_nodes_(pop, dat, **kwargs)
class Master: def __init__(self, pos, screen): self.images = [\ pygame.image.load(path.join('data','master_norm.png')).convert_alpha(),\ pygame.image.load(path.join('data','master_whip1.png')).convert_alpha(),\ pygame.image.load(path.join('data','master_whip2.png')).convert_alpha(),\ pygame.image.load(path.join('data','master_whip3.png')).convert_alpha()] if pos == 'right': for i in range(len(self.images)): self.images[i] = pygame.transform.flip(self.images[i], 1, 0) self.image = self.images[0] self.rect = self.image.get_rect() self.width = self.rect.width self.height = self.rect.height self.state = 0 # for image self.chain = Chain(pos, screen) if pos == 'left': self.rect = self.rect.move(self.width + 30, 500-self.height) if pos == 'right': self.rect = self.rect.move(800-94-self.width, 500-self.height) def whip(self): # Change the state of chain self.chain.change() def update(self): self.state += 1 if self.state == 4: self.state = 0 # turn over self.image = self.images[self.state] self.whip()
def __init__(self, table, base_t=None, tool_t=None): self.table = table if base_t is None: self.base_t = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.base_t = base_t if tool_t is None: self.tool_t = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.tool_t = tool_t self.joints = get_joints_from_table(self.table) # List of actuated joints self.ajoints = self.get_ajoints() # List of passive joints self.pjoints = self.get_pjoints() # Actuated joints' variables self.q = self.get_q() # Passive joints' variables self.qp = self.get_qp() # Chains self.chain = Chain(self.joints) # Tuples (root, end) for each loop self.loops = get_loops(self.joints) # List of loop solvers from loop_solver import LoopSolver self.loopsolvers = [LoopSolver(self.joints, *l) for l in self.loops]
class TestChain(unittest.TestCase): """Test basic chain functionality.""" def setUp(self): self.chain = Chain() self.first = self.chain.first() def test_chain_get_first(self): first = self.first self.assertEqual(0, first.index) self.assertEqual('First block', first.data) self.assertEqual("0", first.previous_hash) self.assertTrue(len(first.previous_hash), 1) self.assertNotEqual(first.previous_hash, first.hash) def test_chain_get_next(self): first = self.first second = self.chain.next(first, "Second block") self.assertEqual(first.index + 1, second.index) self.assertEqual(second.data, "Second block") def test_chain_three_block(self): first = self.first tA = {'from': 'user1', 'to': 'user2', 'item': 'token', 'q': 10} tB = {'from': 'user3', 'to': 'user5', 'item': 'token', 'q': 7} tC = {'from': 'user0', 'to': 'user15', 'item': 'token', 'q': 3} second = self.chain.next(first, tA) third = self.chain.next(second, tB) fourth = self.chain.next(third, tC) # print first, second, third, fourth self.assertIsNotNone(fourth)
def setUp(self): super(ChainTest, self).setUp() self.executor = MagicMock() self.strategy = MagicMock() self.chain = Chain(self.executor, self.strategy, test_util.genesis_hash) self.chain.strategy = MagicMock()
def __init__(self, graphics_item, slot, use_this_polyline=None): self.graphics_item = graphics_item self.graphics_item.setVisible(False) road_item = graphics_item.road_item graphics_scene = graphics_item.scene() self.balls = list() if use_this_polyline: polyline = use_this_polyline else: polyline = road_item.polyline for i, point in enumerate(polyline): ball = Ball(point.x, point.y, Observer(slot, i)) ball.is_selectable = False graphics_scene.addItem(ball) self.balls.append(ball) self.chains = list() for i in range(len(self.balls) - 1): ball1 = self.balls[i] ball2 = self.balls[i + 1] chain = Chain(ball1, ball2) chain.is_selectable = False graphics_scene.addItem(chain) self.chains.append(chain)
def train(disease_group_id): """ Use data extracted from request JSON to create structure in a training phase. """ # Extract training data from JSON try: data = request.json['points'] except KeyError: return _log_response('Invalid JSON', disease_group_id, 400) # Initialise empty structures predictor = Chain() feed_classes = {} # Train predictor (if enough data) and save structures if len(data) >= 50: try: feed_classes = _construct_feed_classes(data) X = _convert_training_data_to_matrix(data, feed_classes) y = _convert_expert_weighting_to_labels(data) except KeyError: return _log_response('Invalid JSON', disease_group_id, 400) else: predictor.train(X, y) _save_pickles(disease_group_id, predictor, feed_classes) return _log_response('Trained predictor saved', disease_group_id, 200) else: _save_pickles(disease_group_id, predictor, feed_classes) return _log_response('Insufficient training data - empty predictor saved', disease_group_id, 200)
def sync_overall(save=False): best_chain = sync_local() for peer in PEERS: # try to connect to peer peer_blockchain_url = peer + 'blockchain.json' try: r = requests.get(peer_blockchain_url) peer_blockchain_dict = r.json() peer_blocks = [Block(bdict) for bdict in peer_blockchain_dict] peer_chain = Chain(peer_blocks) if peer_chain.is_valid() and peer_chain > best_chain: best_chain = peer_chain except requests.exceptions.ConnectionError: print("Peer at %s not running. Continuing to next peer." % peer) else: print( "Peer at %s is running. Gathered their blockchain for analysis." % peer) print("Longest blockchain is %s blocks" % len(best_chain)) if save: best_chain.self_save() return best_chain
def run_attacks(algos, pools, expected_blocks, fork_block): attack_settings = [ hash_rent_11, hash_rent_8, mining_pool_ethermine, mining_pool_ethermine70, mining_pool_ethermine_and_hashrent, mining_pool_ethermine_nanopool # protocol incentivized # mining_pool_40_incentivized, # mining_pool_40_and_hashrent_incentivized ] total_seconds = expected_blocks * 14 results = defaultdict(list) for chain_rule, algo_name in algos: for attack in attack_settings: mainnet = Chain('mainnet', pools, parent_chain_blocks=None, chain_score_fn=chain_rule) attacker_chain = None active_chains = [mainnet] lost_at_block = None forked = False for seconds in range(total_seconds): for _chain in active_chains: if _chain.mines_a_block(seconds): _chain.create_block(seconds) if _chain.name == 'mainnet' and _chain.height == fork_block and not forked: print "Chain block time and pools before fork:" print " - mainnet: block_time:{}, pools:{}".format( mainnet.block_time, mainnet.pools) attacker_chain = mainnet.fork(attack.name, attack.pools) mainnet = mainnet.remove_pools(attack.pools) active_chains = [] active_chains.append(mainnet) active_chains.append(attacker_chain) forked = True print "Chain block time and pools after fork:" print " - {}: block_time:{}, pools:{}".format( attacker_chain.name, attacker_chain.block_time, attacker_chain.pools) print " - mainnet: block_time:{}, pools:{}".format( mainnet.block_time, mainnet.pools) # Check if the mainnet lost. We lost when the attacker is more than # 30 blocks ahead and has a higher score if lost_at_block is None and has_attacker_won( active_chains): lost_at_block = active_chains[0].height print "Lost to attacker at block: {}".format( lost_at_block) # Print results after simulation with the chain score over a range of blocks print_winner(algo_name, active_chains, expected_blocks, fork_block) results[algo_name].append( Result(algo_name, active_chains[0], active_chains[1], lost_at_block, attack)) return results
def syncLocalChain(self): localChain = Chain([]) for block in self.database["blockchain"].find({}, { "_id": 0 }).sort([("index", 1)]): localBlock = Block(block) localChain.addBlock(localBlock) return localChain
def __init__(self, file_lst): # Instantiate parse file on instantion self.file_lst = file_lst self.tempo = None self.tpb = None self.chain = Chain() self._parse()
def main(): fname = sys.argv[1] chain = Chain() with open(fname, "r") as f: print "Reading " + fname chain.record_string(f.read()) with open("definitions/" + sys.argv[2], "w") as fout: print "Writing " + sys.argv[2] fout.write(zlib.compress(chain.serialize()))
def draw_lane_edge(self, lane_edge, tool_box): color = QtCore.Qt.blue group = tool_box.lane_edge_type(lane_edge.type) info = "lane-edge section=%d index=%d type=%s" \ % (lane_edge.section_id, lane_edge.index, lane_edge.type) balls = list() for i, point in enumerate(lane_edge.polyline): ball = Ball(point.x, point.y, color) if i: ball.info = info else: ball.info = info + " polyline-first-point" ball.road_item = lane_edge ball.lane_edge = lane_edge ball.point_index = i ball.setZValue(1) ball.is_a_line = False ball.is_selectable = True self.addItem(ball) balls.append(ball) group.items.append(ball) ball0 = balls[0] for ball in balls: chain = Chain(ball0, ball, color) ball0 = ball chain.info = info chain.road_item = lane_edge chain.lane_edge = lane_edge chain.setZValue(1) chain.is_a_line = True chain.is_selectable = True self.addItem(chain) group.items.append(chain)
def draw_balls_and_chains(self, lane_edge_or_center_line, info, group, color): balls = list() for i, point in enumerate(lane_edge_or_center_line.polyline): ball = Ball(point.x, point.y, color) if i: ball.info = info else: ball.info = info + "polyline-first-point" ball.road_item = lane_edge_or_center_line ball.lane_edge = lane_edge_or_center_line ball.point_index = i ball.setZValue(1) ball.is_a_line = False ball.is_selectable = True self.addItem(ball) balls.append(ball) group.items.append(ball) ball0 = balls[0] for ball in balls: chain = Chain(ball0, ball, color) ball0 = ball chain.info = info chain.road_item = lane_edge_or_center_line chain.lane_edge = lane_edge_or_center_line chain.setZValue(1) chain.is_a_line = True chain.is_selectable = True self.addItem(chain) group.items.append(chain)
def test(): test_chain = Chain() test_num_blocks = 10 for i in range(1, test_num_blocks + 1): token = "".join( random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for x in range(16)) test_chain.next_block(test_chain.tail, token) print(test_chain)
def set_ball_and_chain(self): if len(self.polyline) == 1: point = self.polyline[0] self.ball = Ball(point.x, point.y) self.ball.is_selectable = False #self.graphics_scene.addItem(self.ball) self.chain = Chain(self.ball, None) self.chain.is_selectable = False self.graphics_scene.addItem(self.chain) return self.set_fixed_end(self.polyline[-1])
def sync_local(): local_chain = Chain([]) #We're assuming that the folder and at least initial block exists if os.path.exists(CHAINDATA_DIR): for filepath in glob.glob(os.path.join(CHAINDATA_DIR, '*.json')): with open(filepath, 'r') as block_file: try: block_info = json.load(block_file) except: print filepath local_block = Block(block_info) local_chain.add_block(local_block) return local_chain
def __init__(self, tree, interval=60): """sets up the async event loop Parameters: tree - the same merkle tree instance being anchored interval - the optional parameter for setting the time interval of the anchor. Returns: an object that tracks the current phase, spawns subtasks """ self.tree = tree self.loop = Timeloop() self.chain = Chain() self.interval = interval logger.info("The reactor was started at time: {time}", time=datetime.timestamp(datetime.now()))
def test(self): """ Gerenal test. """ # Creates a new chain chain = Chain() # Puts some blocks into the chain block_1 = Block("apple", "0") chain.add(block_1) block_1.mine() block_2 = Block("banana", block_1.hash) chain.add(block_2) block_2.mine() block_3 = Block("cat", block_2.hash) chain.add(block_3) # Check if the chain is "not valid" if the last block is not mined self.assertFalse(chain.is_valid) block_3.mine() # Checks if the chain is valid self.assertTrue(chain.is_valid)
def infer(self): Flow().defaults() model = Model().make_fcn() model.load_weights('model_weights.h5') chain = Chain().make() angle_scale = Scale([-1.0, 1.0], [-0.5, 0.5]) position_scale = Scale([-3.0, 3.0], [-0.5, 0.5]) # Reference angles theta1_ref = 0.3 theta2_ref = 0.4 theta3_ref = 0.35 ref = np.array([theta1_ref, theta2_ref, theta3_ref]) print('\nReference angles:') print(ref) # Forward kinematic positions px, py, pz = chain.forward({ 'theta1': theta1_ref, 'theta2': theta2_ref, 'theta3': theta3_ref }) print('\nComputed positions:') print(np.array([px, py, pz])) # Normalize the position px = position_scale.forward_scale(px) py = position_scale.forward_scale(py) pz = position_scale.forward_scale(pz) p = np.array([[px, py, pz]]) # Inference returns normalized angle r = model.predict(p) # De-normalized inference angles theta1_ik = angle_scale.reverse_scale(r[0][0]) theta2_ik = angle_scale.reverse_scale(r[0][1]) theta3_ik = angle_scale.reverse_scale(r[0][2]) inf = np.array([theta1_ik, theta2_ik, theta3_ik]) print('\nInferred IK angles:') print(inf) # Relative error err = np.abs(ref - inf) / ref print('\nAngle error (relative):') print(err)
def get_chains(self): """Return a list of serial chains constituting the mechanism Each serial chain starts with the joint following self.root and ends with self.end or a joint with sameas == self.end. """ from chain import Chain chain = Chain(self.joints) chains = [] for end_joint in self.end_joints: subchain = chain.get_subchain_to(end_joint) remove_upto_root(subchain, self.root) chains.append(subchain) return chains
def get_data(self, index): blocks = [] # We're assuming that the folder and at least initial block exists if os.path.exists(CHAINDATA_DIR): for filepath in glob.glob(os.path.join(CHAINDATA_DIR, '*.json')): with open(filepath, 'r') as block_file: try: block_info = json.load(block_file) except: print(filepath) local_block = Block(block_info) blocks.append(local_block) blocks.sort(key=lambda block: block.index) local_chain = Chain(blocks) print(Chain.find_block_by_index(local_chain, index))
def sync_local(sync_es=False): local_chain = Chain([]) if os.path.exists(CHAINDATA_DIR): for filepath in sorted(glob.glob(os.path.join(CHAINDATA_DIR, '*.json'))): with open(filepath, 'r') as block_file: try: block_info = json.load(block_file) except: raise Exception("block error") if sync_es: es.insert_document(block_info) local_block = Block(block_info) local_chain.add_block(local_block) return local_chain
def __init__(self): self.chain = Chain() self.C = Canvas() self.e = Entry(self.C) self.l = Label(self.C, text="File name:") self.addbutton = Button(self.C, text="Add file", command=self.addfile) self.genbutton = Button(self.C, text="Generate", command=self.generate) self.T = Text(self.C) self.C.pack() self.l.pack(side=LEFT) self.e.pack(side=LEFT) self.addbutton.pack(side=LEFT) self.genbutton.pack() self.T.pack() mainloop()
def sync(self, chain: Chain): new_blocks = chain.get_new() if len(new_blocks) < 1: print('no new blocks') return if not chain.verify(): print('invalid chain') return print(f'syncing chain, {len(new_blocks)} new blocks') self.add_many(new_blocks) chain.synced()
class MKParser: def __init__(self, file_lst): # Instantiate parse file on instantion self.file_lst = file_lst self.tempo = None self.tpb = None self.chain = Chain() self._parse() # Parse midi file: # - Group in notes if they occur simultaneously # - Look for tempo messages # - Sequence them into the MK Dictionary def _parse(self): for file in self.file_lst: mid = mido.MidiFile(file) self.tpb = mid.ticks_per_beat old_lst = [] temp_lst = [] for track in mid.tracks: for message in track: #print (message) if message.type == "set_tempo": self.tempo = message.tempo elif message.type == "note_on": if message.time == 0: temp_lst.append(message.note) else: temp_lst.append(message.note) self._sequence(old_lst,temp_lst,message.time) old_lst = temp_lst temp_lst = [] # Add note permutations to MK Chain def _sequence(self, old_lst,temp_lst, duration): for i in old_lst: for j in temp_lst: self.chain.add(i,j,self._time(duration)) # Get time using tempo and time from midi file def _time(self,ticks): time_ms = ((ticks*self.tempo)/self.tpb)/1000 return int(time_ms - (time_ms % 30) + 30) def return_chain(self): return self.chain
def get_looproot(joints, joint): """Return the loop root for loop ending at joint Argument 2, joint, must be the end joint with non-None sameas attribute. The loop root is the last common joints of the two subchains ending at, respectively joint and joint.sameas. """ chain = Chain(joints) subchain1 = chain.get_subchain_to(joint) subchain2 = chain.get_subchain_to(joint.sameas) #returns the first common antecedant for both loops for jnt in subchain2[::-1]: if (jnt in subchain1): return jnt return None
def __init__(self, table, base_t=None, tool_t=None): self.table = table if base_t is None: self.base_t = [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.base_t = base_t if tool_t is None: self.tool_t = [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.tool_t = tool_t self.joints = get_joints_from_table(self.table) # List of actuated joints self.ajoints = self.get_ajoints() # List of passive joints self.pjoints = self.get_pjoints() # Actuated joints' variables self.q = self.get_q() # Passive joints' variables self.qp = self.get_qp() # Chains self.chain = Chain(self.joints) # Tuples (root, end) for each loop self.loops = get_loops(self.joints) # List of loop solvers from loop_solver import LoopSolver self.loopsolvers = [LoopSolver(self.joints, *l) for l in self.loops]
def generate(self): """ Generate iptables-rules for this firewall rule. """ inface = "" outface = "" # look up interfaces if self.client: inface = self.client.iface if self.server: outface = self.server.iface if inface == outface \ and self.client and not self.client.islocalhost() \ and self.server and not self.server.islocalhost(): return # skip forwarding chains when not forwarding if not Firewall.forwarding: if not ((self.client and self.client.islocalhost()) or \ (self.server and self.server.islocalhost())): return chain = Chain.get_chain(inface, outface, \ self.client, self.server, self.loginfo) vrules4, vrules6 = [""], [""] if self.service: vrules4 = self.service.get_filter("d", 4) vrules6 = self.service.get_filter("d", 6) for vr in vrules4: chain.append4("%s -j %s" % (vr, self.target), self.loginfo) for vr in vrules6: chain.append6("%s -j %s" % (vr, self.target), self.loginfo)
def wrapper(self, *args, **kwargs): self.elapsed, id, cash, chain = time.time(), True if len( args) == 4 else False, self.get_cash(), Chain( args[0]) if not len(args) == 4 else None option = chain.get_option( args[1], args[2], args[3]) if not id else ClientMethods.fetch_by_id( self.client, args[1]) self.direction = 'debit' if args[ 4 if not id else 2] == 'buy' else 'credit' self.legs = [{ 'option': option['url'], 'side': args[4 if not id else 2], 'position_effect': args[5 if not id else 3], 'ratio_quantity': kwargs.get('ratio_quantity', 1) }] self.price = option[ 'high_fill_rate_buy_price' if args[4 if not id else 2] == 'buy' else 'high_fill_rate_sell_price'] if not kwargs.get( 'price') else kwargs['price'] self.quantity = kwargs.get( 'quantity', 1) if not kwargs.get('max_quantity') else ( math.floor(cash / self.price) if math.floor( cash / self.price) <= kwargs['max_quantity'] else 1) return func(self, *args, **kwargs)
def test_load_2(self): '''Test chaining of two files.''' tmpfile = testfname.replace('test_tree', 'test_tree_2_tmp') shutil.copyfile(testfname, tmpfile) chain = Chain(testfname.replace('.root', '*.root'), 'test_tree') self.assertEqual(len(chain), 200) os.remove(tmpfile)
def find_blocks(self): curr_chain = Chain.get_current() for i in curr_chain: if i[user_from] == self.address or i[user_to] == self.address: self.blocks.append(i)
def run(self): # Phase 1 - Detection of BarCode self.bc = BarCode(self.bam) sys.stderr.write("[%s] Starting BarCode Analysis \n" % (self.get_time(),)) self.bc.simple_approach() sys.stderr.write("[%s] Analyzed BarCodes \n" % (self.get_time(),)) self.bc.write_barcodes(self.barcodes) sys.stderr.write("[%s] Wrote BarCodes\n" % (self.get_time(),)) # Phase 2 - Rewrite BAM sys.stderr.write("[%s] Starting Sort and Rewrite BAM\n" % (self.get_time(),)) self.bc.load_barcodes(self.barcodes) sys.stderr.write("[%s] Loaded BarCodes\n" % (self.get_time(),)) self.bc.bam.reset() self.bc.sort_and_rewrite_bam(self.rewritten_bam) pysam.sort("-n", self.rewritten_bam, self.rewritten_sorted_bam.replace(".bam", "")) sys.stderr.write("[%s] Sort and Rewrite BAM\n" % (self.get_time(),)) # Phase 3 - Build Consensus self.consensus = Consensus(self.rewritten_sorted_bam, self.ref) sys.stderr.write("[%s] Starting Consensus Building\n" % (self.get_time(),)) self.consensus.build() sys.stderr.write("[%s] Built and Calculated Consensus\n" % (self.get_time(),)) self.consensus.infer_consensus(self.consensus_reference) sys.stderr.write("[%s] Inferred Consensus\n" % (self.get_time(),)) # Phase 4 - Call Variants and Haplotypes self.consensus.output_consensus_genomes(self.consensus_genomes) sys.stderr.write("[%s] Output Consensus Genomes\n" % (self.get_time(),)) self.consensus.output_haplotype_distribution(self.haplotype_distribution) sys.stderr.write("[%s] Output Haplotype Distribution\n" % (self.get_time(),)) self.ovcf = VCF(self.vcf, crossmap=self.crossmap) self.ovcf.get_variants(self.ref.sequence, self.consensus.consensus_genomes) self.ovcf.output_vcf(self.ref.sequence) sys.stderr.write("[%s] Output VCF\n" % (self.get_time(),)) # Phase 5 - Summary Statistics and Chain Files f_out = open(self.out, "w") self.consensus.output_consensus_coverage(f_out) self.ovcf.output_variants_distribution(f_out) self.bc.output_reads_in_barcode_distribution(f_out) f_out.close() sys.stderr.write("[%s] Output Summary Statistics\n" % (self.get_time(),)) self.ochain = Chain(self.chain) self.ochain.output_chain(self.ref, self.consensus.inferred_consensus, self.consensus.inferred_structure) sys.stderr.write("[%s] Output Chain File\n" % (self.get_time(),))
def __init__(self, joints, pjoints, mjoints): self.joints = joints self.pjoints = pjoints self.mjoints = mjoints from numpy import inf self.ub_prismatic = inf # Chains self.chain = Chain(self.joints) self.loops = get_loops(self.joints) #self.end_joints = self.get_end_joints() self.chains = self.get_chains()
def sync_overall(save=False): best_chain = sync_local() for peer in PEERS: #try to connect to peer peer_blockchain_url = peer + 'blockchain.json' try: r = requests.get(peer_blockchain_url) peer_blockchain_dict = r.json() peer_blocks = [Block(bdict) for bdict in peer_blockchain_dict] peer_chain = Chain(peer_blocks) print peer_chain.is_valid() if peer_chain.is_valid() and len(peer_chain) > len(best_chain): best_chain = peer_chain except requests.exceptions.ConnectionError: print "Peer at %s not running. Continuing to next peer." % peer else: print "Peer at %s is running. Gathered their blochchain for analysis." % peer print "Longest blockchain is %s blocks" % len(best_chain) #for now, save the new blockchain over whatever was there if save: best_chain.self_save() return best_chain
def assemble_consensus_genomes(self): # build consensus self.consensus = Consensus(self.rewritten_sorted_bam, self.ref) sys.stderr.write("[%s] Starting Consensus Building\n" % (self.get_time(),)) self.consensus.build(debug=self.debug) sys.stderr.write("[%s] Built and Calculated Consensus\n" % (self.get_time(),)) self.consensus.infer_consensus(self.consensus_reference) sys.stderr.write("[%s] Inferred Consensus\n" % (self.get_time(),)) self.consensus.output_consensus_genomes(self.consensus_genomes) sys.stderr.write("[%s] Output Consensus Genomes\n" % (self.get_time(),)) self.consensus.output_haplotype_distribution(self.haplotype_distribution) sys.stderr.write("[%s] Output Haplotype Distribution\n" % (self.get_time(),)) self.quark = Quark(self.ref.sequence) self.quark.distance_matrix(sorted(self.consensus.freq_distribution.items(), key=lambda q: q[1], reverse=True)) self.quark.graph_it() self.quark.rank_it(self.rank) sys.stderr.write("[%s] Output Quark Analysis\n" % (self.get_time(),)) self.ovcf = VCF(self.vcf, crossmap=self.crossmap) self.ovcf.get_variants(self.ref.sequence, self.consensus.consensus_genomes) self.ovcf.output_vcf(self.ref.sequence) sys.stderr.write("[%s] Output VCF\n" % (self.get_time(),)) self.summary_statistics() sys.stderr.write("[%s] Output Summary Statistics\n" % (self.get_time(),)) self.ochain = Chain(self.chain) self.ochain.output_chain(self.ref, self.consensus.inferred_consensus, self.consensus.inferred_structure) sys.stderr.write("[%s] Output Chain File\n" % (self.get_time(),))
def get_chain(self, name=None, data_keys=None, filters=None, x=None, y=None, views=None, post_process=True, orient_on=None, select=None): """ Construct a "chain" shaped subset of Links and their Views from the Stack. A chain is a one-to-one or one-to-many relation with an orientation that defines from which axis (x or y) it is build. Parameters ---------- name : str, optional If not provided the name of the chain is generated automatically. data_keys, filters, x, y, views : str or list of str Views will be added reflecting the order in ``views`` parameter. If both ``x`` and ``y`` have multiple items, you must specify the ``orient_on`` parameter. post_process : bool, default True If file meta is found, views inside the chain will get their Values- axes codes checked against the category lists and missing codes will be added. orient_on : {'x', 'y'}, optional Must be specified if both ``x`` and ``y`` are lists of multiple items. select : tbc. :TODO: document this! Returns ------- chain : Chain object instance """ #Make sure all the given keys are in lists data_keys = self._force_key_as_list(data_keys) # filters = self._force_key_as_list(filters) views = self._force_key_as_list(views) if orient_on: if x is None: x = self.describe()['x'].drop_duplicates().values.tolist() if y is None: y = self.describe()['y'].drop_duplicates().values.tolist() if views is None: views = self._Stack__view_keys views = [v for v in views if '|default|' not in v] return self.__get_chains(name=name, data_keys=data_keys, filters=filters, x=x, y=y, views=views, post_process=post_process, orientation=orient_on, select=select) else: chain = Chain(name) found_views = [] missed_views = [] #Make sure all the given keys are in lists x = self._force_key_as_list(x) y = self._force_key_as_list(y) if data_keys is None: # Apply lazy data_keys if none given data_keys = self.keys() the_filter = "no_filter" if filters is None else filters if self.__has_list(data_keys): for key in data_keys: # Use describe method to get x keys if not supplied. if x is None: x_keys = self.describe()['x'].drop_duplicates().values.tolist() else: x_keys = x # Use describe method to get y keys if not supplied. if y is None: y_keys = self.describe()['y'].drop_duplicates().values.tolist() else: y_keys = y # Use describe method to get view keys if not supplied. if views is None: v_keys = self.describe()['view'].drop_duplicates().values.tolist() v_keys = [v_key for v_key in v_keys if '|default|' not in v_key] else: v_keys = views chain._validate_x_y_combination(x_keys, y_keys, orient_on) chain._derive_attributes(key,the_filter,x_keys,y_keys,views) # Apply lazy name if none given if name is None: chain._lazy_name() for x_key in x_keys: for y_key in y_keys: if views is None: chain[key][the_filter][x_key][y_key] = self[key][the_filter][x_key][y_key] else: for view in views: try: chain[key][the_filter][x_key][y_key][view] = self[key][the_filter][x_key][y_key][view] if view not in found_views: found_views.append(view) except KeyError: if view not in missed_views: missed_views.append(view) else: raise ValueError('One or more of your data_keys ({data_keys}) is not in the stack ({stack_keys})'.format(data_keys=data_keys, stack_keys=self.keys())) if found_views: chain.views = [view for view in chain.views if view in found_views] for view in missed_views: if view in found_views: missed_views.remove(view) if post_process: chain._post_process_shapes(self[chain.data_key].meta) if select is not None: for view in chain[key][the_filter][x_key][y_key]: df = chain[key][the_filter][x_key][y_key][view].dataframe levels = df.index.levels selection = {} for var in select: level = functions.find_variable_level(levels, var) if level is not None: selection[var] = level #Don't do anything if the selection doesnt produce a result if selection: # selection = {var: functions.find_variable_level(levels, var) for var in select} list_of_dfs = [df.xs(var, level=selection[var]) for var in selection.keys()] new_df = pd.concat(list_of_dfs) # Reconstruct the index new_df.index= pd.MultiIndex.from_product([levels[0],selection.keys()], names=df.index.names) chain[key][the_filter][x_key][y_key][view].dataframe = new_df return chain
class BaseSeq(Helper): def __init__(self, bam, barcodes=None, out=None, ref=None, rewritten_bam=None, consensus_reference=None, consensus_genomes=None, haplotype_distribution=None, vcf=None, chain=None, crossmap=None, export=None, rank=None, debug=None): self.bam = bam self.barcodes = barcodes self.out = out self.ref = Reference(ref) self.rewritten_bam = rewritten_bam self.rewritten_sorted_bam = rewritten_bam.replace(".bam", ".sorted.bam") if rewritten_bam else None self.consensus_reference = consensus_reference self.consensus_genomes = consensus_genomes self.haplotype_distribution = haplotype_distribution self.vcf = vcf self.chain = chain self.crossmap = crossmap self.export = export self.rank = rank self.debug = int(debug) def get_barcodes(self): # simple approach - align, take soft-clipped, and use the arbitrary 20 bases # intermediate approach - use the seed and extend approach out = open(self.out, "w") self.bc = BarCode(self.bam) self.bc.simple_approach() for k, v in sorted(self.bc.barcode_to_read.items()): q = sorted(v) out.write("%s\t%s\n" % (k, ",".join(q))) out.close() def error_correction_barcodes(self): # start analysis self.bc = BarCode(self.bam) sys.stdout.write("[%s] Starting Error Correction Analysis\n" % (self.get_time(),)) # load barcodes self.bc.load_barcodes(self.barcodes) sys.stdout.write("[%s] Loaded BarCodes\n" % (self.get_time(),)) # cluster barcodes self.bc.cluster_barcodes() sys.stdout.write("[%s] Clustered BarCodes\n" % (self.get_time(),)) def filter_barcodes(self, barcode, export="fastq"): list_of_ids = [] with open(self.barcodes, "r") as f: for line in f: data = line.strip("\r\n").split("\t") if barcode == data[0]: list_of_ids = data[1].split(",") break self.bc = BarCode(self.bam) self.bc.filter_and_export(list_of_ids, self.out, export=export) def sort_and_rewrite_bam(self): self.bc = BarCode(self.bam) sys.stderr.write("[%s] Starting Sort and Rewrite BAM\n" % (self.get_time(),)) self.bc.load_barcodes(self.barcodes) sys.stderr.write("[%s] Loaded BarCodes\n" % (self.get_time(),)) self.bc.sort_and_rewrite_bam(self.rewritten_bam) pysam.sort("-n", self.rewritten_bam, self.rewritten_sorted_bam.replace(".bam", "")) sys.stderr.write("[%s] Sort and Rewrite BAM\n" % (self.get_time(),)) def split_bam_by_barcode(self): self.bc = BarCode(self.bam) sys.stderr.write("[%s] Starting procedure to split BAM by barcode\n" % (self.get_time(),)) self.bc.split_bam_into_barcodes(self.ref, self.out, self.export) sys.stderr.write("[%s] Finished splitting BAM by barcode id\n" % (self.get_time(),)) def assemble_consensus_genomes(self): # build consensus self.consensus = Consensus(self.rewritten_sorted_bam, self.ref) sys.stderr.write("[%s] Starting Consensus Building\n" % (self.get_time(),)) self.consensus.build(debug=self.debug) sys.stderr.write("[%s] Built and Calculated Consensus\n" % (self.get_time(),)) self.consensus.infer_consensus(self.consensus_reference) sys.stderr.write("[%s] Inferred Consensus\n" % (self.get_time(),)) self.consensus.output_consensus_genomes(self.consensus_genomes) sys.stderr.write("[%s] Output Consensus Genomes\n" % (self.get_time(),)) self.consensus.output_haplotype_distribution(self.haplotype_distribution) sys.stderr.write("[%s] Output Haplotype Distribution\n" % (self.get_time(),)) self.quark = Quark(self.ref.sequence) self.quark.distance_matrix(sorted(self.consensus.freq_distribution.items(), key=lambda q: q[1], reverse=True)) self.quark.graph_it() self.quark.rank_it(self.rank) sys.stderr.write("[%s] Output Quark Analysis\n" % (self.get_time(),)) self.ovcf = VCF(self.vcf, crossmap=self.crossmap) self.ovcf.get_variants(self.ref.sequence, self.consensus.consensus_genomes) self.ovcf.output_vcf(self.ref.sequence) sys.stderr.write("[%s] Output VCF\n" % (self.get_time(),)) self.summary_statistics() sys.stderr.write("[%s] Output Summary Statistics\n" % (self.get_time(),)) self.ochain = Chain(self.chain) self.ochain.output_chain(self.ref, self.consensus.inferred_consensus, self.consensus.inferred_structure) sys.stderr.write("[%s] Output Chain File\n" % (self.get_time(),)) def summary_statistics(self): # coverage per genome # variants per genome # estimate PCR and sequencing errors # barcode distribution f_out = open(self.out, "w") self.bc = BarCode(self.bam) #TEMP self.bc.load_barcodes(self.barcodes) #TEMP self.consensus.output_consensus_coverage(f_out) self.ovcf.output_variants_distribution(f_out) self.bc.output_reads_in_barcode_distribution(f_out) f_out.close() def run(self): # Phase 1 - Detection of BarCode self.bc = BarCode(self.bam) sys.stderr.write("[%s] Starting BarCode Analysis \n" % (self.get_time(),)) self.bc.simple_approach() sys.stderr.write("[%s] Analyzed BarCodes \n" % (self.get_time(),)) self.bc.write_barcodes(self.barcodes) sys.stderr.write("[%s] Wrote BarCodes\n" % (self.get_time(),)) # Phase 2 - Rewrite BAM sys.stderr.write("[%s] Starting Sort and Rewrite BAM\n" % (self.get_time(),)) self.bc.load_barcodes(self.barcodes) sys.stderr.write("[%s] Loaded BarCodes\n" % (self.get_time(),)) self.bc.bam.reset() self.bc.sort_and_rewrite_bam(self.rewritten_bam) pysam.sort("-n", self.rewritten_bam, self.rewritten_sorted_bam.replace(".bam", "")) sys.stderr.write("[%s] Sort and Rewrite BAM\n" % (self.get_time(),)) # Phase 3 - Build Consensus self.consensus = Consensus(self.rewritten_sorted_bam, self.ref) sys.stderr.write("[%s] Starting Consensus Building\n" % (self.get_time(),)) self.consensus.build() sys.stderr.write("[%s] Built and Calculated Consensus\n" % (self.get_time(),)) self.consensus.infer_consensus(self.consensus_reference) sys.stderr.write("[%s] Inferred Consensus\n" % (self.get_time(),)) # Phase 4 - Call Variants and Haplotypes self.consensus.output_consensus_genomes(self.consensus_genomes) sys.stderr.write("[%s] Output Consensus Genomes\n" % (self.get_time(),)) self.consensus.output_haplotype_distribution(self.haplotype_distribution) sys.stderr.write("[%s] Output Haplotype Distribution\n" % (self.get_time(),)) self.ovcf = VCF(self.vcf, crossmap=self.crossmap) self.ovcf.get_variants(self.ref.sequence, self.consensus.consensus_genomes) self.ovcf.output_vcf(self.ref.sequence) sys.stderr.write("[%s] Output VCF\n" % (self.get_time(),)) # Phase 5 - Summary Statistics and Chain Files f_out = open(self.out, "w") self.consensus.output_consensus_coverage(f_out) self.ovcf.output_variants_distribution(f_out) self.bc.output_reads_in_barcode_distribution(f_out) f_out.close() sys.stderr.write("[%s] Output Summary Statistics\n" % (self.get_time(),)) self.ochain = Chain(self.chain) self.ochain.output_chain(self.ref, self.consensus.inferred_consensus, self.consensus.inferred_structure) sys.stderr.write("[%s] Output Chain File\n" % (self.get_time(),)) def assemble_genomes(self): pass def assemble_genomes_from_fastq(self): pass
def run_scft(D): abn_melt=Scft_Obj("ABn_melt") cell=[D] #cell=[1.70] print "D=",D box=SimBox(1,cell) Nx=128 grid=Grid(box,box.shape,[Nx]) XN=100.0 AB=Chem(2,grid,XN) N_intpo=1 Ns=500 N_blk=10 ABn_multiblk=Chain(N_blk,Ns,"ABn",N_intpo,grid) # prepare the initial lamellar field field_param=[0,2] # on X axis, one period Fields_Init(ABn_multiblk,AB,grid,"lamellar",field_param) #pl.plot(grid.x,AB.W[0,:,0,0],'ro') for i in range(300): pesudo_spectrum_mde(ABn_multiblk,AB,grid) density(ABn_multiblk,AB,grid,abn_melt) SimpleMixing_AB(AB,ABn_multiblk,grid) free_energy_abmelt(ABn_multiblk,AB,grid,abn_melt) #io=Scft_IO(["Dump_Field","Dump_Result"],chem=AB) print "FE:",abn_melt.f_tot, abn_melt.f_FH pl.plot(grid.x,AB.R[0,:,0,0],'ro') pl.plot(grid.x,AB.R[1,:,0,0],'b^') pl.show() #crank_nickson_mde(ABn_multiblk,AB,grid) #t=np.arange(Ns+1) #pl.plot(grid.x,AB.R[0,:,0,0] ,'bo',label="RA") #pl.plot(grid.x,AB.R[1,:,0,0] ,'r^',label="RB") #pl.plot(t[0:Ns+1],np.log(ABn_multiblk.qf[0:Ns+1,0,0,0]) ,'ro',label="qf") #pl.plot(t[0:501],ABn_multiblk.qf[0:501,120,0,0],'go',label="qf") #pl.plot(t[0:Ns+1],np.log(ABn_multiblk.qf1[0:Ns+1,0,0,0]),'b^',label="qf1") #data=ABn_multiblk.qf[0:Ns,:,0,0]-ABn_multiblk.qf1[0:Ns,:,0,0] #print "shape",np.shape(data) #data=np.reshape(data,(Ns,len(grid.x))) #pl.imshow(data) #pl.plot(grid.x,data[100,:],'r^',label="qf") #pl.plot(grid.x,data[300,:],'b^',label="qf") #pl.show() return abn_melt.f_tot pl.plot(grid.x,AB.R[0,:,0,0]) t=np.arange(501) t1=np.arange(500*N_intpo+1) t1=t1/N_intpo #pl.plot(t[0:501],np.log(ABn_multiblk.qf[0:501,0,0,0]),'bo',label="qf") #pl.show() #pl.plot(t[0:501],np.log(ABn_multiblk.qf[0:501,0,0,0]),'bo',label="qf") crank_nickson_mde(ABn_multiblk,AB,grid) ABn_multiblk.qf[:,:,:,:]=ABn_multiblk.qf1[:,:,:,:] ABn_multiblk.qb[:,:,:,:]=ABn_multiblk.qb1[:,:,:,:] #density(ABn_multiblk,AB,grid,abn_melt) pl.plot(grid.x,AB.R[0,:,0,0],'ro') pl.plot(grid.x,AB.R[1,:,0,0],'b^') #pl.show() #pl.plot(t,np.log(ABn_multiblk.qloop[:,0,0,0])) #pl.show() #crank_nickson_mde(ABn_multiblk,AB,grid) #print "q_loop",ABn_multiblk.qloop[:,0,0,0] #pl.plot(t,ABn_multiblk.qloop[:,0,0,0]-ABn_multiblk.qf[:,0,0,0]) #pl.plot(t1[0:1000],ABn_multiblk.qloop[0:1000,0,0,0],label="qloop") #pl.plot(t[0:501],ABn_multiblk.qf[0:501,0,0,0],'bo',label="qf") #pl.plot(t[0:501],np.log(ABn_multiblk.qf1[0:501,0,0,0]),'r^',label="qf1") #pl.plot(grid.x,AB.R[0,:,0,0],'ro',label="RA") #pl.plot(grid.x,AB.R[1,:,0,0],'bo',label="RB") pl.showbar() pl.show() print "RA",AB.R[0,:,0,0]
def update(self, **kwargs): """Update (or build) hierarchical view of atoms. This method is called at instantiation, but can be used to rebuild the hierarchical view when attributes of atoms change.""" atoms = self._atoms if isinstance(atoms, AtomGroup): ag = atoms selstr = False _indices = arange(atoms._n_atoms) else: ag = atoms.getAtomGroup() _indices = atoms._getIndices() selstr = atoms.getSelstr() set_indices = False if atoms == ag: set_indices = True _dict = dict() _residues = list() _segments = list() _chains = list() # also set the attributes, so that when no segments or chains # are available, num/iter methods won't raise exceptions self._dict = _dict self._residues = _residues self._segments = _segments self._chains = _chains acsi = atoms.getACSIndex() n_atoms = len(ag) # identify segments if set_indices: segindex = -1 segindices = zeros(n_atoms, int) sgnms = ag._getSegnames() if sgnms is None: _segments = None else: if selstr: sgnms = sgnms[_indices] s = sgnms[0] if len(unique(sgnms)) == 1: if s != '': segment = Segment(ag, _indices, acsi=acsi, unique=True, selstr=selstr) _dict[s] = segment _segments.append(segment) LOGGER.info('Hierarchical view contains segments.') else: _segments = None else: ps = None # previous segment name for i, s in enumerate(sgnms): if s == ps or s in _dict: continue ps = s idx = _indices[i:][sgnms[i:] == s] segment = Segment(ag, idx, acsi=acsi, unique=True, selstr=selstr) if set_indices: segindex += 1 segindices[idx] = segindex _dict[s] = segment _segments.append(segment) LOGGER.info('Hierarchical view contains segments.') if set_indices: ag._data['segindices'] = segindices chindex = -1 chindices = zeros(n_atoms, int) # identify chains chids = ag._getChids() if chids is None: _chains = None else: if selstr: chids = chids[_indices] if _segments is None: if len(unique(chids)) == 1: chain = Chain(ag, _indices, acsi=acsi, unique=True, selstr=selstr) _dict[(None, chids[0] or None)] = chain _chains.append(chain) else: pc = None for i, c in enumerate(chids): if c == pc or (None, c) in _dict: continue pc = c idx = _indices[i:][chids[i:] == c] chain = Chain(ag, idx, acsi=acsi, unique=True, selstr=selstr) if set_indices: chindex += 1 chindices[idx] = chindex _dict[(None, c)] = chain _chains.append(chain) else: pc = chids[0] ps = sgnms[0] _i = 0 for i, c in enumerate(chids): s = sgnms[i] if c == pc and s == ps: continue s_c = (ps, pc or None) chain = _dict.get(s_c) if chain is None: segment = _dict[ps] idx = _indices[_i:i] chain = Chain(ag, idx, acsi=acsi, segment=segment, unique=True, selstr=selstr) if set_indices: chindex += 1 chindices[idx] = chindex _dict[s_c] = chain _chains.append(chain) else: idx = _indices[_i:i] chindices[idx] = chain._indices[0] chain._indices = concatenate((chain._indices, idx)) pc = c ps = s _i = i s_c = (ps, pc or None) chain = _dict.get(s_c) idx = _indices[_i:] if chain is None: segment = _dict[ps] if set_indices: chindex += 1 chindices[idx] = chindex chain = Chain(ag, idx, acsi=acsi, segment=segment, unique=True, selstr=selstr) _dict[s_c] = chain _chains.append(chain) else: if set_indices: chindices[idx] = chain._indices[0] chain._indices = concatenate((chain._indices, idx)) if set_indices: ag._data['chindices'] = chindices if kwargs.get('chain') == True: return if set_indices: resindex = -1 resindices = zeros(n_atoms, int) rnums = ag._getResnums() if rnums is None: raise ValueError('resnums are not set') if selstr: rnums = rnums[_indices] nones = None if _segments is None: if nones is None: nones = [None] * len(rnums) sgnms = nones if _chains is None: if nones is None: nones = [None] * len(rnums) chids = nones icods = ag._getIcodes() if icods is None: if nones is None: nones = [None] * len(rnums) icods = nones elif selstr: icods = icods[_indices] pr = rnums[0] pi = icods[0] or None pc = chids[0] ps = sgnms[0] _j = 0 _append = _residues.append _get = _dict.get _set = _dict.__setitem__ for j, r in enumerate(rnums): i = icods[j] or None c = chids[j] s = sgnms[j] if r != pr or i != pi or c != pc or s != ps: s_c_r_i = (ps, pc, pr, pi) res = _get(s_c_r_i) if res is None: chain = _get((ps, pc)) idx = _indices[_j:j] res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, selstr=selstr) if set_indices: resindex += 1 resindices[idx] = resindex _append(res) _set(s_c_r_i, res) else: res._indices = concatenate((res._indices, _indices[_j:j])) ps = s pc = c pr = r pi = i _j = j s_c_r_i = (ps, pc, pr, pi) res = _get(s_c_r_i) idx = _indices[_j:] if res is None: chain = _get((ps, pc)) res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, selstr=selstr) if set_indices: resindex += 1 resindices[idx] = resindex _append(res) _set(s_c_r_i, res) else: if set_indices: resindices[idx] = res._indices[0] res._indices = concatenate((res._indices, idx)) if set_indices: ag._data['resindices'] = resindices
class LoopSolver(): def __init__(self, joints, pjoints, mjoints): self.joints = joints self.pjoints = pjoints self.mjoints = mjoints from numpy import inf self.ub_prismatic = inf # Chains self.chain = Chain(self.joints) self.loops = get_loops(self.joints) #self.end_joints = self.get_end_joints() self.chains = self.get_chains() def get_qm(self, index=None): """Returns the list of joint variables of moving joints""" if (index is None): return [jnt.q for jnt in self.mjoints] else: return self.mjoints[index].q def get_qp(self, index=None): """Returns the list of joint variables of passive joints""" if (index is None): return [jnt.q for jnt in self.pjoints] else: return self.pjoints[index].q def set_qp(self, q): """Sets the joint variables of passive joints""" for i, jnt in enumerate(self.pjoints): jnt.q = q[i] def set_qm(self, q): """Sets the joint variables of moving joints""" for i, jnt in enumerate(self.mjoints): jnt.q = q[i] def get_end_joints(self): """Return the list of self.end and all joints with sameas == end.""" ends = [] for start, end in self.loops: l = ([end] + [jnt for jnt in self.joints if jnt.sameas is end]) ends += l return ends def get_chains(self): """Return a list of serial chains constituting the mechanism Each serial chain starts with the joint following self.root and ends with self.end or a joint with sameas == self.end. """ chains = [] for root, end in self.loops: subchain = self.chain.get_subchain_to(end) remove_upto_root(subchain, root) chains.append(subchain) return chains def J(self, x): """Returns the squared difference of transformation matrices calculated from the common root for 2 chains of a loop as a cost function Is calculated for each loop at the same time.""" from numpy import identity from numpy import dot, sum J = 0 matrices = [] for chain in self.chains: T = identity(4) for jnt in chain: T = dot(T, jnt.T) matrices.append(T) # There are 2 chains for each loop starting as transformation matrix from the common joint for i in range(0, len(matrices), 2): J += sum((matrices[i] - matrices[i+1])**2) return J def least_J(self, x): from numpy import identity from numpy import dot J = 0 matrices = [] for chain in self.chains: T = identity(4) for jnt in chain: T = dot(T, jnt.T) matrices.append(T) from numpy import zeros dy = zeros(12 * (len(matrices) // 2)) for i in range(0, len(matrices), 2): dy[(i // 2) * 12: ((i // 2) + 1) * 12] = ((matrices[i][:3, :] - matrices[i+1][:3, :])**2).flatten() return dy def cost(self, x): self.set_qp(x) return self.J(x) def set_ub(self, ub_prismatic): self.ub_prismatic = ub_prismatic def solve(self): if len(self.pjoints) == 0: return from numpy import array from scipy.optimize import minimize qs = self.get_qp() x0 = array(qs) #bounds = self.set_bounds(self.pjoints) obj = minimize(self.cost, x0, tol=1e-7, method='L-BFGS-B')#, bounds=bounds) x = obj.x self.set_qp(x) return obj.fun def cost_all(self, x): self.set_qm(x) return self.J(x) def set_bounds(self, jnts): from math import pi bounds = [] for i, jnt in enumerate(jnts): b = (-pi, pi) if jnt.isrevolute() else (0, self.ub_prismatic) bounds.append(b) return bounds def find_close(self): """Finds a solution by including active joints into optimization problem""" from numpy import array from scipy.optimize import minimize qs = self.get_qm() x0 = array(qs) #bounds = self.set_bounds(self.mjoints) obj = minimize(self.cost_all, x0, tol=1e-7, method = 'L-BFGS-B') x = obj.x self.set_qm(x) return obj.fun def find_random(self, max_cost): """Finds a solution by including active joints and initializing all the joints randomly""" from numpy import array from scipy.optimize import minimize qs = self.get_qm() x0 = array(qs) bounds = self.set_bounds(self.mjoints) from random import uniform for j in range(10): for i, jnt in enumerate(self.mjoints): x0[i] = uniform(bounds[i][0], bounds[i][1]) obj = minimize(self.cost_all, x0, tol=1e-7, method = 'L-BFGS-B') if obj.fun < max_cost: break x = obj.x self.set_qm(x) return obj.fun
def serialKinematicJacobian(joints): """Return the kinematic Jacobian of a serial chain Passive joints are considered to be as if they were actuated. The end joint is the last joint in the list and the base joint is its farest antecedent. """ from chain import Chain from chain import get_subchain_to chain = Chain(get_subchain_to(joint=joints[-1], joints=joints)) # We need the position of last joint frame in the base joints frame from serialmechanism import end_transform Tend = end_transform(chain.joints) Pend = Tend[0:3, 3] from numpy.matlib import zeros, identity, cross # jacobian only includes moving joints jacobian = zeros((6, len(chain.get_mjoints()))) T = identity(4) k = 0 for jnt in chain.joints: T *= jnt.T # Take P and a vectors P = T[0:3, 3] a = T[0:3, 2] if jnt.isrevolute(): # revolute: [ahat*(Pend-P), a] DP = Pend - P a_hat = zeros((3,3)) a_hat[0, 1] = -a[2] a_hat[0, 2] = a[1] a_hat[1, 0] = a[2] a_hat[1, 2] = -a[0] a_hat[2, 0] = -a[1] a_hat[2, 1] = a[0] jacobian_trans = a_hat * DP #jacobian_trans = cross(P, DP, axis=0) jacobian_rot = a if jnt.isprismatic(): # prismatic: [a, 0] jacobian_trans = a jacobian_rot = zeros((3, 1)) # skip fixed joints if not(jnt.isfixed()): jacobian[:3, k] = jacobian_trans jacobian[3:, k] = jacobian_rot k += 1 # If the last joint is fixed, apply the Jacobian transposition if (joints[-1].isfixed()): P = jnt.T[0:3, 2] jac_transposition = identity(6) jac_transposition[3, 1] = -P[2] jac_transposition[3, 2] = P[1] jac_transposition[4, 0] = P[2] jac_transposition[4, 2] = -P[0] jac_transposition[5, 0] = -P[1] jac_transposition[5, 1] = P[0] jacobian = jac_transposition * jacobian return jacobian
def testNone(self): chain1 = Chain(self.space, 20, pm.Vec2d(250, 0)) self.assertFalse(None, chain1) self.assertFalse(None, chain1.get_end()) self.assertFalse(None, chain1.get())
class Kinematics(): def __init__(self, table, base_t=None, tool_t=None): self.table = table if base_t is None: self.base_t = [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.base_t = base_t if tool_t is None: self.tool_t = [ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] else: self.tool_t = tool_t self.joints = get_joints_from_table(self.table) # List of actuated joints self.ajoints = self.get_ajoints() # List of passive joints self.pjoints = self.get_pjoints() # Actuated joints' variables self.q = self.get_q() # Passive joints' variables self.qp = self.get_qp() # Chains self.chain = Chain(self.joints) # Tuples (root, end) for each loop self.loops = get_loops(self.joints) # List of loop solvers from loop_solver import LoopSolver self.loopsolvers = [LoopSolver(self.joints, *l) for l in self.loops] # TODO: ajoints as property def get_ajoints(self): """Return the list of active joints, always in the same order""" ajoints = [] for jnt in self.joints: if (jnt.isactuated()): ajoints.append(jnt) return ajoints # TODO: pjoints as property def get_pjoints(self): """Return the list of passive joints, always in the same order""" pjoints = [] for jnt in self.joints: if (jnt.ispassive()): pjoints.append(jnt) return pjoints # TODO: cjoints as property def get_cjoints(self): """Return the list of cut joints, always in the same order""" cjoints = [] for jnt in self.joints: if not(jnt.sameas is None): cjoints.append(jnt) # TODO: define q as property def get_q(self, index=None): """Returns the list of joint variables of active joints""" if (index is None): return [jnt.q for jnt in self.ajoints] else: return self.ajoints[index].q # TODO: define qp as property def get_qp(self, index=None): """Returns the list of joint variables of passive joints""" if (index is None): return [jnt.q for jnt in self.pjoints] else: return self.pjoints[index].q def set_q(self, q, index=None): if (index is None): index = range(len(self.ajoints)) try: self.ajoints[index].q = q except (AttributeError, TypeError): for i in index: self.ajoints[i].q = q[i] def set_qp(self, q, index=None): if (index is None): index = range(len(self.pjoints)) try: self.pjoints[index].q = q except (AttributeError, TypeError): for i in index: self.pjoints[i].q = q[i] def get_joint_transform(self, joint): """Return the transform from base to joint Return a tuple (m, Pjminus1), where m is the transformation matrix from base (not base joint) to the joint, and Pjminus1 is the position of previous joint. """ # Get the list of joints from base to joint # The transform from the base to the base joint is given by # self.base_t. l = self.base_t[0] + self.base_t[1] + self.base_t[2] + self.base_t[3] from FreeCAD import Base m = Base.Matrix(*l) Pj = Base.Vector(0, 0, 0) for jnt in self.chain.get_subchain_to(joint): # Pjminus1 is Pj from the step before Pjminus1 = Pj m *= Ttomatrix(jnt.T) Pj = Base.Vector(m.A14, m.A24, m.A34) return m, Pjminus1 def solve_loops(self): for ls in self.loopsolvers: ls.solve()
block_one_dir_invalid = {"nonce": "1225518", "index": "1", "hash": "00000c575050241e0a4df1acd7e6fb90cc1f599e2cc2908ec8225e10915006cc", "timestamp": "1508895386", "prev_hash": "0000010101193736271818923939229219283747438293874548392789878987", "data": "I block #1"} block_one_invalid_obj = Block(block_one_dir_invalid) assert not block_one_invalid_obj.is_valid() #nonce doesn't give it the correct hash block_one_dir_invalid = {"nonce": "1000000", "index": "1", "hash": "00000c575050241e0a4df1acd7e6fb90cc1f599e2cc2908ec8225e10915006cc", "timestamp": "1508895386", "prev_hash": "000002f9c703dc80340c08462a0d6acdac9d0e10eb4190f6e57af6bb0850d03c", "data": "I block #1"} block_one_invalid_obj = Block(block_one_dir_invalid) assert not block_one_invalid_obj.is_valid() ##################################### # # Bringing Chains into play # ##################################### blockchain = Chain([block_zero, block_one, block_two]) assert blockchain.is_valid() assert len(blockchain) == 3 empty_chain = Chain([]) assert len(empty_chain) == 0 empty_chain.add_block(block_zero) assert len(empty_chain) == 1 empty_chain = Chain([]) assert len(empty_chain) == 0 another_blockchain = Chain([another_block_zero, another_block_one, another_block_two]) assert another_blockchain.is_valid() assert len(another_blockchain) == 3 assert blockchain == another_blockchain
def identify_chains(mol, rings=None): """ Identify all chains in the molecule. """ def build_connect_mat(mol): """Build a connection matrix we can use in Floyd's algorithm""" inf = float('Infinity') # 'Not connected' is repr by infinity newMat = [[inf for x in range(mol.size)] for y in range(mol.size)] for i in range(mol.size): for j in range(mol.size): val = mol.connectMat[i][j] val = inf if not val else 1 newMat[i][j] = val return newMat def get_core_vertices(coreFlags): """Get a list of core vertices from core chain flags""" core = [] for i in range(len(coreFlags)): if coreFlags[i]: core.append(i) return core def get_noncore_vertices(coreFlags): """Get a list of non-core vertices from core chain flags.""" noncore = [] for i in range(len(coreFlags)): if not coreFlags[i]: noncore.append(i) return noncore def disconnect_vertices(matrix, removeVerts = []): """Disconnect the vertices specified from the adj matrix""" inf = float('Infinity') length = len(matrix) for vert in removeVerts: for i in range(length): matrix[i][vert] = inf matrix[vert][i] = inf def find_maxweight_verts(shortestPaths): """ Find the maximum weight in a ShortestPaths object. We want to find the longest chains, not the shortest ones. """ inf = float('Infinity') DNE = [inf, -inf, None] length = shortestPaths.size() maxWeight = -1 maxPath = (-1, -1) for i in range(length): for j in range(length): weight = shortestPaths.getWeight(i, j) if weight in DNE: continue if weight > maxWeight: maxWeight = weight maxPath = (i, j) return maxPath # Ring atoms cannot be considered in chain perception. ringAtoms = [] if rings: ratoms = [] for r in rings: ratoms += r ringAtoms = list(set(ratoms)) # Find, identify the "core chain" atoms coreFlags = _identify_core_chain_atoms(mol, ringAtoms) # Copy the molecule's connectivity matrix, then specify that all # non-"core chain" atoms are to be removed in the first pass. connectMat = build_connect_mat(mol) removeAtoms = get_noncore_vertices(coreFlags) # Don't reuse capping substituents. unusableCaps = [] # Get all of the chains, starting with the longest. # Assign arbitrary capping substituents. chains = [] while True: # Disconnect the specified atoms from the connection matrix # This ensures no two chains consist of the same atoms. disconnect_vertices(connectMat, removeAtoms) # (Re)calculate the shortest paths, and extract the longest chain s = ShortestPaths(connectMat) verts = find_maxweight_verts(s) chain = s.findPath(verts[0], verts[1], include=True) # FIXME: I assume this is the only condition that breaks the loop... if type(chain) != list: break def reserve_end_cap(chain, pos): """ Choose an end cap atom arbitrarily; the cap cannot be part of the chain, nor can it be previously selected. """ atom = chain[pos] diff = frozenset(mol.alphaAtoms[atom]) - frozenset(chain) diff -= frozenset(unusableCaps) if not diff: cap = chain.pop(pos) else: cap = list(diff)[0] unusableCaps.append(cap) unusableCaps.extend(list(chain)) return cap end1 = reserve_end_cap(chain, 0) end2 = reserve_end_cap(chain, -1) # Save the chain, end caps, then set up the removal of all # atoms that were in it. removeAtoms = chain[:] removeAtoms.extend([end1, end2]) chain = Chain(chain) chain.caps = (end1, end2) # FIXME: Not a good interface! chains.append(chain) return chains
'r': 0, } jnt1 = Joint(antc=None, **dummy_jnt_parameters) jnt2 = Joint(antc=jnt1, **dummy_jnt_parameters) jnt3 = Joint(antc=jnt2, **dummy_jnt_parameters) jnt4 = Joint(antc=jnt2, **dummy_jnt_parameters) jnt5 = Joint(antc=jnt4, **dummy_jnt_parameters) joints = [jnt1, jnt2, jnt3] #print(jnt1) #print(jnt2) #print(jnt3) #print(jnt4) #print(jnt5) chain = Chain(joints) #print([chain.get_subchain_from(jnt) for jnt in get_children(joints, jnt1)]) assert(chain.base == jnt1) assert(chain.tools == [jnt3]) assert(get_children(joints, jnt1) == [jnt2]) assert(get_children(joints, jnt2) == [jnt3]) assert(chain.get_subchain_from(jnt3) == [jnt3]) assert(chain.get_subchain_from(jnt2) == [jnt2, jnt3]) assert(chain.get_subchain_from(jnt1) == [jnt1, jnt2, jnt3]) assert(chain.get_subchain_to(jnt1) == [jnt1]) assert(chain.get_subchain_to(jnt2) == [jnt1, jnt2]) assert(chain.get_subchain_to(jnt3) == [jnt1, jnt2, jnt3]) joints = [jnt1, jnt2, jnt3, jnt4] chain = Chain(joints) assert(chain.base == jnt1)
def update(self, **kwargs): """Rebuild hierarchical view of atoms. This method is called at instantiation, but can be used to rebuild the hierarchical view when attributes of atoms change.""" array = np.array atoms = self._atoms if isinstance(atoms, AtomGroup): ag = atoms _indices = np.arange(ag._n_atoms) selstr = False else: ag = atoms.getAtomGroup() _indices = atoms._indices selstr = atoms.getSelstr() acsi = self._atoms.getACSIndex() n_atoms = len(ag) self._dict = _dict = dict() self._chains = _chains = list() self._residues = _residues = list() self._segments = _segments = list() segindex = -1 segindices = np.zeros(n_atoms, int) chindex = -1 chindices = np.zeros(n_atoms, int) resindex = -1 resindices = np.zeros(n_atoms, int) sgnms = ag._getSegnames() if sgnms is None: _segments = None else: if selstr: sgnms = sgnms[_indices] unique = np.unique(sgnms) s = sgnms[0] if len(unique) == 1: if s != '': segment = Segment(ag, _indices, acsi=acsi, unique=True, selstr=selstr) _dict[s] = segment _segments.append(segment) LOGGER.info('Hierarchical view contains segments.') else: _segments = None else: ps = None for i, s in enumerate(sgnms): if s == ps or s in _dict: continue ps = s segindex += 1 idx = _indices[i:][sgnms[i:] == s] segment = Segment(ag, idx, acsi=acsi, unique=True, selstr=selstr) segindices[idx] = segindex _dict[s] = segment _segments.append(segment) LOGGER.info('Hierarchical view contains segments.') chids = ag._getChids() if chids is None: _chains = None else: if selstr: chids = chids[_indices] if _segments is None: if len(np.unique(chids)) == 1: chain = Chain(ag, _indices, acsi=acsi, unique=True) _dict[(None, chids[0] or None)] = chain _chains.append(chain) else: pc = None for i, c in enumerate(chids): if c == pc or (None, c) in _dict: continue pc = c chindex += 1 idx = _indices[i:][chids[i:] == c] chain = Chain(ag, idx, acsi=acsi, unique=True) chindices[idx] = chindex _dict[(None, c)] = chain _chains.append(chain) else: pc = chids[0] ps = sgnms[0] _i = 0 for i, c in enumerate(chids): s = sgnms[i] if c == pc and s == ps: continue s_c = (ps, pc or None) chain = _dict.get(s_c) if chain is None: segment = _dict[ps] chindex += 1 idx = _indices[_i:i] chain = Chain(ag, idx, acsi=acsi, segment=segment, unique=True) chindices[idx] = chindex _dict[s_c] = chain segment._dict[pc] = len(segment._list) segment._list.append(chain) _chains.append(chain) else: idx = _indices[_i:i] chindices[idx] = chain._indices[0] chain._indices = np.concatenate((chain._indices, idx)) pc = c ps = s _i = i s_c = (ps, pc or None) chain = _dict.get(s_c) idx = _indices[_i:] if chain is None: segment = _dict[ps] chindex += 1 chindices[idx] = chindex chain = Chain(ag, idx, acsi=acsi, segment=segment, unique=True) _dict[s_c] = chain segment._dict[pc] = len(segment._list) segment._list.append(chain) _chains.append(chain) else: chindices[idx] = chain._indices[0] chain._indices = np.concatenate((chain._indices, idx)) if kwargs.get('chain') == True: return rnums = ag._getResnums() if rnums is None: raise ValueError('resnums are not set') if selstr: rnums = rnums[_indices] nones = None if _segments is None: if nones is None: nones = [None] * len(rnums) sgnms = nones if _chains is None: if nones is None: nones = [None] * len(rnums) chids = nones icods = ag._getIcodes() if icods is None: if nones is None: nones = [None] * len(rnums) icods = nones elif selstr: icods = icods[_indices] pr = rnums[0] pi = icods[0] or None pc = chids[0] ps = sgnms[0] or None _j = 0 for j, r in enumerate(rnums): i = icods[j] or None c = chids[j] or None s = sgnms[j] if r != pr or i != pi or c != pc or s != ps: s_c_r_i = (ps, pc, pr, pi) res = _dict.get(s_c_r_i) if res is None: chain = _dict.get((ps, pc)) resindex += 1 idx = _indices[_j:j] res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, selstr=selstr) resindices[idx] = resindex if chain is not None: chain._dict[(pr, pi)] = len(chain._list) chain._list.append(res) _residues.append(res) _dict[s_c_r_i] = res else: res._indices = np.concatenate((res._indices, _indices[_j:j])) ps = s pc = c pr = r pi = i _j = j s_c_r_i = (ps, pc, pr, pi) res = _dict.get(s_c_r_i) idx = _indices[_j:] if res is None: chain = _dict.get((ps, pc)) resindex += 1 res = Residue(ag, idx, acsi=acsi, chain=chain, unique=True, selstr=selstr) resindices[idx] = resindex if chain is not None: chain._dict[(pr, pi)] = len(chain._list) chain._list.append(res) _residues.append(res) _dict[s_c_r_i] = res else: resindices[idx] = res._indices[0] res._indices = np.concatenate((res._indices, idx)) ag._data['segindices'] = segindices ag._data['chindices'] = chindices ag._data['resindices'] = resindices