updates on code

Author: michellekwok2

.ipynb_checkpoints/michelle-checkpoint.ipynb

@@ -46,11 +46,11 @@ def generateGridLines(self, n=100):
 
     def generateEvenGrid(self, n=100):
 
-        ycoor = 25
+        ycoor = 25 #set to radius of outermost layer when list of radii is avaliable
         xcoor = np.linspace(-self.env.top_layer_lim, self.env.top_layer_lim, n)
 
         slopes = ycoor/(xcoor-self.start)
-        return [Line(self.env, self.start, slope) for slope in slopes] 
+        return [Line(self.env, self.start, slope) for slope in slopes]
 
     def generateRandomLines(self, n=100): 
 

Figures/1dhist.png

@@ -26,7 +26,7 @@
 cover = Cover(env, data)
 cover.solve(z0 = 0, lining='solveS', n = 16, show = True)
 cover.plot()
-'''
+
 
 env = Environment()
 data = DataSet(env, n_points=150, equal_spacing = True) 
@@ -38,7 +38,7 @@
 cover.plot()
 #cover.plot()
 #data.plot()
-
+'''
 
 '''
 
@@ -147,6 +147,8 @@
 #wedge_test(lining = 'solveS_reverse', solve_at = 0, n =16, z0 = np.arange(-15, 15.5, 0.5), wedges = [0,30], savefig = False, v = 'v3')
 #wedge_test(lining = 'solveQ', solve_at = [-10,0,10], n =16, z0 = np.arange(-15, 15.5, 0.5), wedges = [0,128], savefig = True, v = 'v3')
 
+
+'''
 def odd_loop(lining = 'solveS', v = 'v2'):
     accep = 0.0
     zvalues = 3
@@ -165,4 +167,15 @@ def even_loop(lining = 'solveS', v = 'v2'):
     
 
 #odd_loop('solveS_reverse', v = 'v3')
-#even_loop('solveS_reverse', v = 'v3')
+#even_loop('solveS_reverse', v = 'v3')
+
+
+
+env = Environment()
+events = readFile('wedgeData_v2_128.txt', 10)
+wedge1 = convertToDataset(events[5])
+cover = wedgeCover(env, wedge1)
+cover.solve(lining = 'solveS_center2', z0 = 15)
+cover.plot()
+'''
+z099(lining =  "solveS_reverse",wedges = [0,128], savefig=True, v = 'v2')

Figures/2dhist.png

@@ -65,9 +65,9 @@ def wedge_test(lining:str = "solveS", solve_at = 0, z0 = np.arange(-15, 15.5, 0.
 
             for i in range(len(test_lines)): 
                 for patch in cover.patches:
-                    if patch.contains(test_lines[i]): 
+                    if patch.contains(test_lines[i]):
                         percentage_accepted += 1 
-                        break 
+                        break
 
 
             percentage_accepted = percentage_accepted/lines
@@ -104,6 +104,235 @@ def wedge_test(lining:str = "solveS", solve_at = 0, z0 = np.arange(-15, 15.5, 0.
         plt.savefig(f"Figures/wedge_test({lining}_{v.replace('.','')}_{at}_n{n})")
     plt.show()
 
+def z099(lining:str = "solveS", accept = 0.999, start = 'odd', n = 16, wedges = [0, 128], v = 'v3', savefig = False):
+    solve_at = [0]
+    real_solve = [0]
+    reached = False
+    z0 = np.arange(-15, 15.5, 0.5)
+    lines = 1000
+    left_index = 0
+    right_index = 60
+    last_left = 30
+    last_right = 31
+    rf = False
+    lf = False
+
+    while reached == False:
+        mean_list = np.zeros((len(z0), wedges[1]-wedges[0]))
+        num_covers = []
+        PRF = []
+        file = f'wedgeData_{v}_128.txt'
+
+        with open(file) as f:
+            for ik, k in enumerate(np.arange(wedges[0], wedges[1])):
+                d = np.array(ast.literal_eval(f.readline()))
+                env = Environment()
+                data = DataSet(env = env)
+                data.input_data(d, add = True)
+                cover = Cover(env, data)
+                cover.solve(z0 = solve_at, lining=lining, n = n, show = False)
+                num_covers.append(cover.n_patches)
+                out = [] 
+
+                for layer in range(env.layers): 
+                    for point in data.array[layer]: 
+                        
+                        num_in = 0
+                        for patch in cover.patches: 
+                            if patch.contains_p(point, layer): 
+                                num_in += 1
+                                
+                        out.append(num_in)
+                PRF.append(out)
+
+                for iz, z in enumerate(np.array(z0)):
+                    percentage_accepted = 0 
+                        
+                    lg = LineGenerator(env, z)
+                    test_lines = lg.generateEvenGrid(lines)
+                    
+                    for i in range(len(test_lines)): 
+                        for patch in cover.patches:
+                            if patch.contains(test_lines[i]): 
+                                percentage_accepted += 1 
+                                break 
+
+                    
+                    percentage_accepted = percentage_accepted/lines
+                    mean_list[iz, ik] = mean_list[iz, ik] + percentage_accepted
+        z0_means = np.mean(mean_list, axis = 1)
+        if np.all(z0_means > accept):
+            break
+        if np.all(z0_means[left_index:last_left] > accept):
+            real_solve = np.append(real_solve, [z0[left_index]])
+            print('new left', z0[left_index])
+            last_left = left_index
+            left_index = -1
+        if np.all(z0_means[last_right:right_index] > accept):
+            real_solve = np.append(real_solve, [z0[right_index]])
+            print('new right', z0[right_index])
+            last_right = right_index
+            right_index = 61
+        left_index +=1
+        right_index -=1
+        real_solve = np.unique(real_solve)
+        solve_at = np.copy(real_solve)
+
+        solve_at = np.append(solve_at, z0[left_index])
+        solve_at = np.append(solve_at,z0[right_index])
+        solve_at = np.unique(solve_at)
+        print(left_index)
+        print(right_index)
+        print(np.sort(real_solve))
+
+    ymin = accept
+    mean_num = format(np.mean(num_covers), ".1f")
+    std_num = format(np.std(num_covers), ".1f")
+
+    plt.scatter(z0, np.mean(mean_list, axis = 1), color = 'r', s = 10)
+    plt.plot(z0, np.mean(mean_list, axis = 1), color = 'k')
+    plt.xlabel('z0 offset [cm]', fontsize = 16)
+    plt.ylabel('Acceptance',  fontsize = 16)
+    plt.ylim(ymin, 1.0)
+    plt.title(f'{lining}', fontsize = 16)
+    PRFm = format(np.mean(out), '.2f')
+    PRFs = format(np.std(out), '.2f')
+    plt.legend([f"Number of Patches: {mean_num}" + r'$\pm$' + f"{std_num}\nPoint Repetition Factor: {PRFm}" + r'$\pm$' + f"{PRFs}\nPatches with " + r'$z_0$' + f" = {np.sort(np.round(np.array(solve_at), 2), axis = 0)}\nppl = {n}, " + r'$N_{wedges}$ ' + f"= {wedges[1]}, {v} events"],
+        loc = 8, fontsize = 12)
+    if savefig == True:
+        try:
+            at = len(solve_at)
+        except:
+            at = solve_at
+        plt.savefig(f"Figures/minimal_z0_odd_({lining}_{v.replace('.','')}_n{n})")
+    plt.show()
+
+
+def wedge_test_old(lining:str = "solveS", solve_at = 0, z0 = np.arange(-15, 15.5, 0.5), n = 16, wedges = [0, 128], lines=1000, savefig=False, v = 'v2'):
+    mean_list = np.zeros((len(z0), wedges[1]-wedges[0]))
+    num_covers = []
+    PRF = []
+    file = f'wedgeData_{v}_128.txt'
+
+    with open(file) as f:
+        for ik, k in enumerate(np.arange(wedges[0], wedges[1])):
+            d = np.array(ast.literal_eval(f.readline()))
+            env = Environment()
+            data = DataSet(env = env, n_points = 150)
+            data.input_data(d, add = True)
+            cover = Cover(env, data)
+            cover.solve(z0 = solve_at, lining=lining, n = n, show = False)
+            #data.plot(True)
+            num_covers.append(cover.n_patches)
+            out = [] 
+
+            for layer in range(env.layers): 
+                for point in data.array[layer]: 
+                    
+                    num_in = 0
+                    for patch in cover.patches: 
+                        if patch.contains_p(point, layer): 
+                            num_in += 1
+                            
+                    out.append(num_in)
+            PRF.append(out)
+
+            for iz, z in enumerate(np.array(z0)):
+                percentage_accepted = 0 
+                    
+                lg = LineGenerator(env, z)
+                test_lines = lg.generateEvenGrid(lines)
+                
+                for i in range(len(test_lines)): 
+                    for patch in cover.patches:
+                        if patch.contains(test_lines[i]): 
+                            percentage_accepted += 1 
+                            break 
+
+                
+                percentage_accepted = percentage_accepted/lines
+                mean_list[iz, ik] = mean_list[iz, ik] + percentage_accepted
+            #print(ik)
+    mean_accept = format(np.mean(mean_list), ".3f")
+    mean_num = format(np.mean(num_covers), ".1f")
+    std_num = format(np.std(num_covers), ".1f")
+    if type(solve_at) == float:
+        ymin = 0
+    elif type(solve_at) == int:
+        ymin = 0
+    else:
+        ymin = 0.90
+
+    plt.scatter(z0, np.mean(mean_list, axis = 1), color = 'r', s = 10)
+    plt.plot(z0, np.mean(mean_list, axis = 1), color = 'k')
+    plt.xlabel('z0 offset [cm]', fontsize = 16)
+    plt.ylabel('Acceptance',  fontsize = 16)
+    plt.ylim(ymin, 1.0)
+    plt.title(f'{lining}', fontsize = 16)
+    PRFm = format(np.mean(out), '.2f')
+    PRFs = format(np.std(out), '.2f')
+    plt.legend([f"Number of Patches: {mean_num}" + r'$\pm$' + f"{std_num}\nPoint Repetition Factor: {PRFm}" + r'$\pm$' + f"{PRFs}\nPatches with " + r'$z_0$' + f" = {np.round(np.array(solve_at), 2)}\nppl = {n}, " + r'$N_{wedges}$ ' + f"= {wedges[1]}, {v} events"],
+        loc = 8, fontsize = 12)
+    if savefig == True:
+        try:
+            at = len(solve_at)
+        except:
+            at = solve_at
+        plt.savefig(f"Figures/wedge_test({lining}_{v.replace('.','')}_{at}_n{n})")
+    if np.mean(np.mean(mean_list, axis = 1)) > 0.999:
+        plt.show()
+        return np.mean(np.mean(mean_list, axis = 1))
+    else:
+        plt.clf()
+        return np.mean(np.mean(mean_list, axis = 1))
+
+def wedgeSlopePlot(lining:str = "solveS", events=128, lines=1000, z0 = 0, savefig=False, show = True, v = 'v2'):
+
+    percentage_accepted = [0 for _ in range(lines)]
+
+    
+    file = open(f'wedgeData_{v}_128.txt')
+    '''    for i in range(7):
+        line = file.readline()'''
+    for k in range(events):
+        line = file.readline()
+        env = Environment()
+        data = DataSet(env, n_points=150)
+        d = np.array(ast.literal_eval(line))
+        data.input_data(d, add = True)
+        cover = Cover(env, data) 
+        cover.solve(lining=lining, z0 = z0, show = False)
+        
+        lg = LineGenerator(env, z0)
+        test_lines = lg.generateEvenGrid(lines)
+        co_tan = []
+        
+        
+        for i in range(len(test_lines)):
+            co_tan.append(100/test_lines[i].slope)
+            for patch in cover.patches: 
+                if patch.contains(test_lines[i]): 
+                    percentage_accepted[i] += 1 
+                    break
+
+
+    percentage_accepted = [x / events for x in percentage_accepted]
+    mean_accept = format(np.mean(percentage_accepted), ".3f")
+    
+    if show == False:
+        return np.mean(percentage_accepted)
+
+    print(f"({lining}) - {mean_accept}")
+    plt.plot(co_tan, percentage_accepted, c="b", label = "Mean acceptance: "+mean_accept)
+    
+    plt.title(f"Acceptance Rate ({lining})", fontsize = '20')
+    plt.xlabel("dZ/dr", fontsize = '16')
+    plt.ylabel("Acceptance Probability", fontsize = '16')
+    plt.legend(fontsize = '16')
+    if savefig == True: 
+        plt.savefig(f"Figures/Acceptance_Rate_({lining})")
+    plt.show() 
+
 def numCovers(clustering:str = "", lining:str = "solveS", events=1000, savefig=False, ideal=False): 
     # Runs a bunch of iterations by generating 1000 datasets and 
     # computing the cover. Then, it just looks at how many covers is
@@ -341,127 +570,3 @@ def duplicates(lining:str = "solveS", z0 = 0, events=1000, ideal=False):
 
     print(f'{lining} - mean: {np.mean(dupes)} std: {np.std(dupes)}')
 
-def wedge_test_old(lining:str = "solveS", solve_at = 0, z0 = np.arange(-15, 15.5, 0.5), n = 16, wedges = [0, 128], lines=1000, savefig=False, v = 'v2'):
-    mean_list = np.zeros((len(z0), wedges[1]-wedges[0]))
-    num_covers = []
-    PRF = []
-    file = f'wedgeData_{v}_128.txt'
-
-    with open(file) as f:
-        for ik, k in enumerate(np.arange(wedges[0], wedges[1])):
-            d = np.array(ast.literal_eval(f.readline()))
-            env = Environment()
-            data = DataSet(env = env, n_points = 150)
-            data.input_data(d, add = True)
-            cover = Cover(env, data)
-            cover.solve(z0 = solve_at, lining=lining, n = n, show = False)
-            #data.plot(True)
-            num_covers.append(cover.n_patches)
-            out = [] 
-
-            for layer in range(env.layers): 
-                for point in data.array[layer]: 
-                    
-                    num_in = 0
-                    for patch in cover.patches: 
-                        if patch.contains_p(point, layer): 
-                            num_in += 1
-                            
-                    out.append(num_in)
-            PRF.append(out)
-
-            for iz, z in enumerate(np.array(z0)):
-                percentage_accepted = 0 
-                    
-                lg = LineGenerator(env, z)
-                test_lines = lg.generateEvenGrid(lines)
-                
-                for i in range(len(test_lines)): 
-                    for patch in cover.patches:
-                        if patch.contains(test_lines[i]): 
-                            percentage_accepted += 1 
-                            break 
-
-                
-                percentage_accepted = percentage_accepted/lines
-                mean_list[iz, ik] = mean_list[iz, ik] + percentage_accepted
-            #print(ik)
-    mean_accept = format(np.mean(mean_list), ".3f")
-    mean_num = format(np.mean(num_covers), ".1f")
-    std_num = format(np.std(num_covers), ".1f")
-    if type(solve_at) == float:
-        ymin = 0
-    elif type(solve_at) == int:
-        ymin = 0
-    else:
-        ymin = 0.90
-
-    plt.scatter(z0, np.mean(mean_list, axis = 1), color = 'r', s = 10)
-    plt.plot(z0, np.mean(mean_list, axis = 1), color = 'k')
-    plt.xlabel('z0 offset [cm]', fontsize = 16)
-    plt.ylabel('Acceptance',  fontsize = 16)
-    plt.ylim(ymin, 1.0)
-    plt.title(f'{lining}', fontsize = 16)
-    PRFm = format(np.mean(out), '.2f')
-    PRFs = format(np.std(out), '.2f')
-    plt.legend([f"Number of Patches: {mean_num}" + r'$\pm$' + f"{std_num}\nPoint Repetition Factor: {PRFm}" + r'$\pm$' + f"{PRFs}\nPatches with " + r'$z_0$' + f" = {np.round(np.array(solve_at), 2)}\nppl = {n}, " + r'$N_{wedges}$ ' + f"= {wedges[1]}, {v} events"],
-        loc = 8, fontsize = 12)
-    if savefig == True:
-        try:
-            at = len(solve_at)
-        except:
-            at = solve_at
-        plt.savefig(f"Figures/wedge_test({lining}_{v.replace('.','')}_{at}_n{n})")
-    if np.mean(np.mean(mean_list, axis = 1)) > 0.999:
-        plt.show()
-        return np.mean(np.mean(mean_list, axis = 1))
-    else:
-        plt.clf()
-        return np.mean(np.mean(mean_list, axis = 1))
-
-def wedgeSlopePlot(lining:str = "solveS", events=128, lines=1000, z0 = 0, savefig=False, show = True, v = 'v2'):
-    
-    percentage_accepted = [0 for _ in range(lines)]
-
-    
-    file = open(f'wedgeData_{v}_128.txt')
-    '''    for i in range(7):
-        line = file.readline()'''
-    for k in range(events):
-        line = file.readline()
-        env = Environment()
-        data = DataSet(env, n_points=150)
-        d = np.array(ast.literal_eval(line))
-        data.input_data(d, add = True)
-        cover = Cover(env, data) 
-        cover.solve(lining=lining, z0 = z0, show = False)
-        
-        lg = LineGenerator(env, z0)
-        test_lines = lg.generateEvenGrid(lines)
-        co_tan = []
-        
-        
-        for i in range(len(test_lines)):
-            co_tan.append(100/test_lines[i].slope)
-            for patch in cover.patches: 
-                if patch.contains(test_lines[i]): 
-                    percentage_accepted[i] += 1 
-                    break
-
-
-    percentage_accepted = [x / events for x in percentage_accepted]
-    mean_accept = format(np.mean(percentage_accepted), ".3f")
-    
-    if show == False:
-        return np.mean(percentage_accepted)
-
-    print(f"({lining}) - {mean_accept}")
-    plt.plot(co_tan, percentage_accepted, c="b", label = "Mean acceptance: "+mean_accept)
-    
-    plt.title(f"Acceptance Rate ({lining})", fontsize = '20')
-    plt.xlabel("dZ/dr", fontsize = '16')
-    plt.ylabel("Acceptance Probability", fontsize = '16')
-    plt.legend(fontsize = '16')
-    if savefig == True: 
-        plt.savefig(f"Figures/Acceptance_Rate_({lining})")
-    plt.show() 

Figures/minimal_z0_odd_(solveQ_v2_n16).png

@@ -0,0 +1,194 @@
+import numpy as np 
+import matplotlib.pyplot as plt 
+from data import * 
+from cover import *
+from test_modules import *
+import math
+import cv2 
+import os 
+import glob
+import matplotlib
+import ast
+import time
+from reader import *
+from converter import *
+from wedgecover import *
+import matplotlib as mpl
+
+def create_triplets(version = 'v2', random = False, anchor_layer = 1):
+    if (anchor_layer < 1) or (anchor_layer > 3):
+        raise('Anchor layer must not be the top or bottom layer')
+    env = Environment()
+    events = readFile(f'wedgeData_{version}_128.txt', 128)
+    tripletsz = []
+    tripletsphi = []
+    hitres = 0.005 #50 microns
+    for i in range(len(events)):
+        wedge1 = convertToDataset(events[i])
+        cover = wedgeCover(env, wedge1)
+        cover.solveS_center2()
+        for patch1 in cover.patches:
+            
+            if random == True:
+                layer1 = np.random.rand(16) * hitres
+                layer2 = np.random.rand(16) * hitres 
+                layer3 = np.random.rand(16) * hitres
+                for point2 in layer2:
+                    for point1 in layer1:
+                        for point3 in layer3:
+                            tripletsz.append([point1, point2, point3])
+                            tripletsphi.append([point1/15, point2/20, point3/25])
+            
+            else:
+                layer1 = patch1.superpoints[anchor_layer - 1]
+                layer2 = patch1.superpoints[anchor_layer]
+                layer3 = patch1.superpoints[anchor_layer + 1]
+                
+                for point2 in layer2.points:
+                    for point1 in layer1.points:
+                        for point3 in layer3.points:
+                            tripletsz.append([point1.z, point2.z, point3.z])
+                            phi1 = point1.phi
+                            phi2 = point2.phi
+                            phi3 = point3.phi
+                            if ((point1.phi - point2.phi) > np.pi):
+                                phi1 = point1.phi-(2*np.pi)
+                            if ((point2.phi - point1.phi) > np.pi):
+                                phi2 =  point2.phi-(2*np.pi)
+                            if ((point1.phi - point3.phi) > np.pi):
+                                phi1 = point1.phi-(2*np.pi)
+                            if ((point3.phi - point1.phi) > np.pi):
+                                phi3 =  point3.phi-(2*np.pi)
+                            if ((point2.phi - point3.phi) > np.pi):
+                                phi2 = point2.phi-(2*np.pi)
+                            if ((point3.phi - point2.phi) > np.pi):
+                                phi3 =  point3.phi-(2*np.pi)
+                            tripletsphi.append([phi1, phi2, phi3])
+    return np.array([np.array(tripletsz), np.array(tripletsphi)])
+
+def second_deriv(triplets):
+    term1 = triplets[:,:,2]/(10-15)/(5-15)
+    term2 = triplets[:,:,1]/(15-10)/(5-10)
+    term3 = triplets[:,:,0]/(15-5)/(10-5)
+    return 2*(term1+term2+term3)
+
+def ratio(data, z_cutoff = -3, phi_cutoff = -4):
+    z = np.log10(np.abs(second_deriv(data)))[0]
+    phi = np.log10(np.abs(second_deriv(data)))[1]
+    z_ratio = 0
+    phi_ratio = 0
+    both_ratio = 0 
+    for i in range(len(z)):
+        if (z[i] <= z_cutoff):
+            z_ratio += 1
+        if(phi[i] <= phi_cutoff):
+            phi_ratio += 1
+        if (z[i] <= z_cutoff)&(phi[i] <= phi_cutoff):
+            both_ratio += 1
+    z_ratio = z_ratio/len(z)
+    phi_ratio = phi_ratio/len(z)
+    both_ratio = both_ratio/len(z)
+    return [z_ratio, phi_ratio, both_ratio]
+
+triplets_rand = create_triplets(random = True, anchor_layer = 3)
+triplets_v2 = create_triplets('v2', anchor_layer = 3)
+triplets_v3 = create_triplets('v3', anchor_layer = 3)
+
+log_second_deriv_rand = np.log10(np.abs(second_deriv(triplets_rand)))
+log_second_deriv_v2 = np.log10(np.abs(second_deriv(triplets_v2)))
+log_second_deriv_v3 = np.log10(np.abs(second_deriv(triplets_v3)))
+
+rand_ratios = ratio(triplets_rand)
+v2_ratios = ratio(triplets_v2)
+v3_ratios = ratio(triplets_v3)
+
+bins = [np.arange(-11, 1, .3), np.arange(-12, -1, 0.3)]
+plt.figure(figsize = (15, 10))
+
+plt.subplot(2, 3, 1)
+plt.hist(log_second_deriv_rand[0], edgecolor='black', rwidth=0.8, bins = bins[0], label = f'Ratio: {np.round(rand_ratios[0], 5)}')
+plt.title('Random z')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$(|z"|)')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-3, ls = '--', color = 'r')
+
+plt.subplot(2, 3, 2)
+plt.hist(log_second_deriv_v2[0], edgecolor='black', rwidth=0.8, bins =bins[0], label = f'Ratio: {np.round(v2_ratios[0], 5)}')
+plt.title('v2 z')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$(|z"|)')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-3, ls = '--', color = 'r')
+
+plt.subplot(2, 3, 3)
+plt.hist(log_second_deriv_v3[0], edgecolor='black', rwidth=0.8, bins = bins[0], label = f'Ratio: {np.round(v3_ratios[0], 5)}')
+plt.title('v3 z')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$( |z"| )')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-3, ls = '--', color = 'r')
+
+plt.subplot(2, 3, 4)
+plt.hist(log_second_deriv_rand[1], edgecolor='black', rwidth=0.8, bins = bins[1], label = f'Ratio: {np.round(rand_ratios[1], 5)}')
+plt.title('Random phi')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$(|$\phi$"|)')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-4, ls = '--', color = 'r')
+
+plt.subplot(2, 3, 5)
+plt.hist(log_second_deriv_v2[1], edgecolor='black', rwidth=0.8, bins = bins[1], label = f'Ratio: {np.round(v2_ratios[1], 5)}')
+plt.title('v2 phi')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$(|$\phi$" |)')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-4, ls = '--', color = 'r')
+
+plt.subplot(2, 3, 6)
+plt.hist(log_second_deriv_v3[1], edgecolor='black', rwidth=0.8, bins = bins[1], label = f'Ratio: {np.round(v3_ratios[1], 5)}')
+plt.title('v3 phi')
+plt.ylabel('Count')
+plt.xlabel(r'$log_{10}$(|$\phi$" |)')
+plt.legend(loc = 'upper left')
+plt.yscale('log')
+plt.axvline(-4, ls = '--', color = 'r')
+
+ranges = [[-11, 1], [-12, -1]]
+vbound = (-4 - ranges[1][0])/(ranges[1][1]-ranges[1][0])
+hbound = (-3 - ranges[0][0])/(ranges[0][1]-ranges[0][0])
+plt.figure(figsize = (17, 5))
+plt.subplot(1, 3, 1)
+plt.hist2d(log_second_deriv_rand[0],log_second_deriv_rand[1],range = ranges, bins = 25, norm=mpl.colors.LogNorm())
+plt.title('Random')
+plt.xlabel(r'$log_{10}$(|z"|)')
+plt.ylabel(r'$log_{10}$(|$\phi$" |)')
+plt.axvline(-3, 0, vbound, ls = '--', color = 'r')
+plt.axhline(-4, 0, hbound, ls = '--', color = 'r')
+plt.text(ranges[0][0]+0.5, ranges[1][1]-0.7, f'Ratio: {np.round(rand_ratios[2], 5)}', bbox=dict(boxstyle="square", fc = 'None'))
+
+plt.subplot(1, 3, 2)
+plt.hist2d(log_second_deriv_v2[0],log_second_deriv_v2[1],range = ranges, bins = 25, norm=mpl.colors.LogNorm())
+plt.title('v2')
+plt.xlabel(r'$log_{10}$(|z"|)')
+plt.ylabel(r'$log_{10}$(|$\phi$" |)')
+plt.axvline(-3, 0, vbound, ls = '--', color = 'r')
+plt.axhline(-4, 0, hbound, ls = '--', color = 'r')
+plt.text(ranges[0][0]+0.5, ranges[1][1]-0.7, f'Ratio: {np.round(v2_ratios[2], 7)}', bbox=dict(boxstyle="square", fc = 'None'))
+
+plt.subplot(1, 3, 3)
+plt.hist2d(log_second_deriv_v3[0],log_second_deriv_v3[1], range = ranges, bins = 25, norm=mpl.colors.LogNorm())
+plt.title('v3')
+plt.xlabel(r'$log_{10}$(|z"|)')
+plt.ylabel(r'$log_{10}$(|$\phi$" |)')
+plt.colorbar()
+plt.axvline(-3, 0, vbound, ls = '--', color = 'r')
+plt.axhline(-4, 0, hbound, ls = '--', color = 'r')
+plt.text(ranges[0][0]+0.5, ranges[1][1]-0.7, f'Ratio: {np.round(v3_ratios[2], 7)}', bbox=dict(boxstyle="square", fc = 'None'))
+
+plt.show()

Figures/minimal_z0_odd_(solveQ_v3_n16).png

@@ -129,10 +129,6 @@ def solve(self, lining:str = "SolveS", z0=0, n = 16, nlines:int=100, show = True
                 self.solveS_reverse(z0=z0, stop = -1, n = n)
             return
 
-        elif lining == "solveS_center1": 
-            self.solveS_center1(n = n)
-            return 
-
         elif lining == "solveS_center2":
             try:
                 for s in z0:
@@ -204,14 +200,16 @@ def S_loop15(self, z0 = 0, stop = 1, n = 16):
         Args:
             z0 (num, optional): Places to generate patch. Defaults to 0.
             stop (num, optional): stopping location, normalized to 1m. Defaults to 1.
-            n (int, optional): points per layer per patch. Defaults to 16.
+            n (int, optional): points per patch per layer. Defaults to 16.
 
         Returns:
             function: reruns loop if it hasn't reached the end of the dataset
         """
 
         #count how many times this has been run
         loops = self.n_patches - 1
+        #reads last patch made
+        last_patch = self.patches[loops].superpoints
         #create list for points closest to starting line and patch ingredients
         mins = []
         patch_ingredients = []
@@ -221,8 +219,6 @@ def S_loop15(self, z0 = 0, stop = 1, n = 16):
         #loops through layers
         for i in range(5):
             y = 5*(i+1)
-            #reads last patch made
-            last_patch = self.patches[loops].superpoints
             #create compatible arrays from data structure
             row_data = last_patch[i].points
             row_list = np.array([row_data[x].z for x in range(len(row_data))])
@@ -234,11 +230,11 @@ def S_loop15(self, z0 = 0, stop = 1, n = 16):
         min_index = np.argmin(np.array(mins))
         min_value = (last_patch[min_index].points[n-1].z-z0)/(5*(min_index+1)/100)
 
+        #row_data[layer] gives spacepoints in layer
+        row_data = self.data.array
         #loops through layers again
         for i in range(5):
             y = 5*(i+1)
-            #create compatible array from data structure
-            row_data = self.data.array
             row_list = np.array([row_data[i][x].z for x in range(len(row_data[i]))])
             #finds point closest to line from (z0, 0) to leftmost rescaled point
             closest_index = np.argmin(np.abs((row_list-z0)/(y/100) - min_value))
@@ -267,17 +263,16 @@ def S_loop15(self, z0 = 0, stop = 1, n = 16):
                 #closest_index - 1 insures point is to left of line ie ensuring patches overlap
                 patch_ingredients.append(wedgeSuperPoint(row_data[i][closest_index-1:closest_index + n - 1]))
 
-        #creates new patch
+        #add superpoints to patch
         new_patch = wedgePatch(self.env, tuple(patch_ingredients))
-
-        #if all layers have points beyond stop index, add patch and stop
+        #add patch to cover
+        self.add_patch(new_patch)
+        
+        #if all layers have points beyond stop index, stop
         if term == 5:
-            self.add_patch(new_patch)
             return
-
-        #if new patches are still being created, add patch to cover instance and repeat loop
+        #if new patches are still being created, repeat loop
         else:
-            self.add_patch(new_patch)
             return self.S_loop15(z0, stop, n = n)
 
     def S_rloop15(self, z0 = 0, stop = -1, n = 16):
@@ -367,29 +362,30 @@ def solveS(self, z0 = 0, stop = 1, n = 16):
         Args:
             z0 (num, optional): Places to generate patch. Defaults to 0.
             stop (num, optional): stopping location, normalized to 1m. Defaults to 1.
-            n (int, optional): points per layer per patch. Defaults to 16.
+            n (int, optional): points per patch per layer. Defaults to 16.
 
         Returns:
             function: runs loop to make patches
         """
         #create list for inital patch
         init_patch = []
 
+        #row_data[layer] contains spacepoints for each layer
+        row_data = self.data.array
         #loops through each layer and picks n points closest to (z0, 0) and (-100, 25)
         for row in range(5):
             y = 5*(row + 1)
             #create compatible arrays from data structure
-            row_data = self.data.array
             row_list = np.array([row_data[row][x].z for x in range(len(row_data[row]))])
-            #picks picks n points closest to (z0, 0) and (-100, 25) 
+            #picks picks n points closest to line from (z0, 0) to (-100, 25) 
             start_index = np.argmin(np.abs(row_list - (((-z0-100)*y)/25+z0)))
             #subtract one from stop index in case it is right of the line from (z0, 0) to (-100, 25)
             if start_index != 0:
                 start_index -= 1
-            #add superpoint
+            #add superpoint to patch
             init_patch.append(wedgeSuperPoint(row_data[row][start_index:start_index+n]))
 
-        #add to patch
+        #add patch to cover
         self.add_patch(wedgePatch(self.env, tuple(init_patch)))
 
         #run main algorithm