Ejemplo n.º 1
0
def number_of_lp_lattice():
 
    for D in [2]:   
        myfile = open(str(D)+'number_lp_lattice', 'w')
        myfile.write('N_side' + '\t' + 'N'+ '\t'+ 'lp length' +  '\t'+ 'no. lp'+ '\n')
        start_time = time.time()
        for N_side in range(10,16,1):
            N = N_side**2

    #        model = models.COd(2, N)
            model = models.square_lattice_model(D, N_side)
            DAG = model[0]
            extremes = model[1]
            tr_DAG = tr.trans_red(DAG)
            lp = dl.lpd(tr_DAG, extremes[1], extremes[0])
            length_lp = lp[2]
            
            j=0
            paths_list = list(nx.all_simple_paths(tr_DAG, extremes[1], extremes[0], cutoff=length_lp+1))
            for i in range(len(paths_list)):
                if len(paths_list[i])==length_lp+1:
                    j+=1
    
            myfile.write(str(N_side) + '\t' + str(N) +'\t' + str(length_lp)+ '\t' + str(j) + '\n')
            print 'done', N_side
        elapsed = time.time() - start_time
        
        print 'finished.',D,'Dimension. Time elapsed = ',elapsed
        
    return
Ejemplo n.º 2
0
def draw_lattice_model(D, N_side):
    model = models.square_lattice_model(D, N_side)
    DAG = model[0]
    #lp = dl.lpd(DAG, extremes[1], extremes[0])  # recursion depth exceeded --> loop in DAG
    #print lp[2]

    #
    #Check this is a DAG
    if nx.is_directed_acyclic_graph(DAG):
        print "lattice DAG"
    else: print "damn"
    
    coords_list = DAG.nodes()
    
    G=nx.DiGraph()

    dict_of_points = {}
    
    for j in range(len(coords_list)):
        coords_list[j] = tuple(coords_list[j])
        dict_of_points[j] = coords_list[j]
        
    for point in dict_of_points:
        G.add_node(point)  
        
    #    for d in range(D):
    #        if node_a[d] == node_b[d]+1:
    #            for j in range(D):
    #                if j != d:
    #                    if node_a[j] == node_b[j]:
    #                        return True
    #                    else: return False  
    
    for a in dict_of_points:
        for b in dict_of_points:
            connect_a_b = False
            coords_a = dict_of_points[a] #this is the tuple x,y for point a
            coords_b = dict_of_points[b]
            for d in range(2):
                point_a_coord_d = coords_a[d]
                point_b_coord_d = coords_b[d]
                if point_a_coord_d == point_b_coord_d+1:
                    for j in range(2):
                        if j != d:
                            if coords_a[j] == coords_b[j]:
                                connect_a_b = True
            if connect_a_b:
                G.add_edge(a,b)

    
    xy_coords_list=[]
    xt_coords_dict = {}
    #                rc.set_rc_params(figure_size = [6,6])
    for i in range(len(dict_of_points)):
        xy_coords_list.append([])
        for j in range(2):
            xy_coords_list[i].append(dict_of_points[i][j])
            xt_coords_dict[i] = xy_coords_list[i]
        xlabel("x")
        ylabel("y")
    nx.draw_networkx(G, pos=xt_coords_dict, alpha = 1, width = 0.1, node_color = 'red', with_labels=False, node_size=15, linewidths=0.5)
    #                nx.draw_networkx(G, pos=xt_coords_dict, alpha = 0.9, width = 0.2, node_color = 'red', ege_color = 'gray',with_labels=False, node_size=20,linewidths=0.5)
    #plt.savefig("2dBox.pdf")
    show() 
    
    return