Evaluation Cherenkov signal

CHAOSa.py

@@ -30,27 +30,27 @@ parser.add_argument("-res", type=str, nargs='+', help = "multiplies resolution w
 parser.add_argument("-equal", action='store_true', help = "puts temperature correction to BGO data")  # on/off flag
 parser.add_argument("-cut",type=str, nargs='+',help=("Choose cut definitions for specific detectors and apply corresponding conditions:\n"
         "- D: Applies a condition on D1H and D2H that D2H lies within 15% of D1H, with a tolerance of ±30 units.\n"
-        "- B: Ensures B channel is inside the range [106.38, 366.46].\n"
+        "- B: Ensures B channel is above 35.\n"
-        "- nB: Ensures B channel is outside the range [106.38, 366.46].\n"
+        "- nB: Ensures B channel is lower 35.\n"
-        "- As: For detector A, requires either A1H or A2H to be above threshold.\n"
+        "- A: For detector A\n"
-        "- Ah: For detector A, requires one of A1H or A2H to be above threshold, while the other is below.\n"
+        "- C: For detector C\n"
-        "- Cs: For detector C, requires either C1H or C2H to be above threshold.\n"
+        "- E123: For detector group E123, requires at least one of E1, E2, or E3 to be above threshold.\n"
-        "- Ch: For detector C, requires one of C1H or C2H to be above threshold, while the other is below.\n"
-        "- E123s: For detector group E123, requires at least one of E1, E2, or E3 to be above threshold.\n"
-        "- E123h: For detector group E123, requires one of E1, E2, or E3 to be above threshold, while the others are below.\n"
         "- E123_two: For detector group E123, requires at least two of E1, E2, or E3 to be above threshold."
     )
 )
 parser.add_argument("-mask",type=str, nargs='+',help=("Choose mask definitions and apply corresponding conditions:\n"
         "- HeA: Applies He-mask using A/E123 vs D (fishplot).\n"
-        "- HeC: Applies He-mask using C/E123 vs D (fishplot).\n"))
+        "- HeC: Applies He-mask using C/E123 vs D (fishplot).\n"
+        "- He1: Applies He-mask for min(A,C)-D plot"))
 
 parser.add_argument("-deltaT", action='store_true', help = "saves deltatimes between events")
 
 parser.add_argument("-nameadd", type=str, nargs='+', help = "custom nameadd to add to filename")
 
 
-parser.add_argument("-Denergy",  action='store_true', help = ' ')
+parser.add_argument("-Denergy",  action='store_true', help = 'Histogramm of Detector D in MeV ')
+
+parser.add_argument("-Denergylog",  action='store_true', help = 'Histogramm of Detector D in MeV and log scale')
 
 args = parser.parse_args()
 
@@ -74,6 +74,8 @@ from histframe import get_T
 from histframe import CmV
 from histframe import CmV_v
 from histframe import isCut
+from histframe import isMask
+from histframe import isMask_other
 from histframe import isMask_1D
 from histframe import get_MeV_mean
 from histframe import get_MeV
@@ -100,7 +102,7 @@ if args.tdhist and not args.res:
 if args.tdhistlog and not args.res:
     resV = 60*resV
 if args.res != None:
-    resV=resV*int(args.res[0])
+    resV=resV*float(args.res[0])
     
 if args.lim:
     minV = int(args.lim[0])
@@ -127,11 +129,14 @@ if args.notrig:
     for t in args.notrig:
         notrig.append(t) 
 
+mask=[]
 if args.cut:
     nameadd += "_cut-" + "".join(args.cut)
     
 if args.mask:
     nameadd += "_mask-" + "".join(args.mask)
+    for m in args.mask:
+        mask.append(m) 
     
     
 if args.lim:
@@ -222,6 +227,9 @@ def main():
     if args.Denergy:
         generate_hist_D_MeV()
         
+    if args.Denergylog:
+        generate_hist_D_MeV_log()
+        
     if args.hist:
         generate_hist()
         
@@ -330,10 +338,10 @@ def generate_hist():
                 if l[0] == 'H':
                     timestamp = int(l[1])
                     T = get_T(float(l[8]))
-                if l[0] == 'EI' and len(l)>3*18 and conditions(l,args) and isFloat(args,timestamp):
+                if l[0] == 'EI' and len(l)>3*18 and conditions(l,args) and isMask_other(l,T,mask) and isFloat(args,timestamp):
                     for i,chan in enumerate(chans):
                         b = value_HL(l,chan,u) 
-                        b = value
+                        #b = value
                         if minV <= b <= maxV:
                             xb = int((b-minV)/resV)
                             hist[xb,i+1] += 1                                                               
@@ -344,11 +352,11 @@ def generate_hist():
     
     ################ 1D HISTOGRAM D in MeV ############################################################
 def generate_hist_D_MeV():
-    #minV = 0
-    #maxV = 50
-    #resV = 0.1
     minV = 0
-    maxV = 1000
+    maxV = 100
+    resV = 0.5
+    #minV = 0
+    #maxV = 1000
     bin = int((maxV-minV)/resV)
         
     hist = np.zeros((bin+1,2))
@@ -370,19 +378,59 @@ def generate_hist_D_MeV():
                 if l[0] == 'EI' and len(l)>3*18 and conditions(l,args) and isFloat(args,timestamp):
                     #T=15
                     b = value_HL(l,'D1',u)+value_HL(l,'D2',u) 
-                    bx = b #get_MeV(b,T)
+                    bx = get_MeV(b, T)
                     if minV <= bx <= maxV:
                         xb = int((bx-minV)/resV)
                         hist[xb,1] += 1                                                               
                                     
-    frame = pd.DataFrame(hist, columns = ['keV'] + ['D'])
+    frame = pd.DataFrame(hist, columns = ['MeV'] + ['D'])
-    frame.to_csv(f'histograms/{filename}_D_keV.1dhist', sep = ' ', index = False)
+    frame.to_csv(f'histograms/{filename}{nameadd}_D_MeV.1dhist', sep = ' ', index = False)
-    print(f'histograms/{filename}_D_keV.1dhist was created')
+    print(f'histograms/{filename}{nameadd}_D_MeV.1dhist was created')
+    
+def generate_hist_D_MeV_log():
+    minX = 1
+    maxX = 10000
+    resX = 190*resV
+    #minV = 0
+    bin_x = int((maxX-minX)/resX)
+    
+    edges_x = np.logspace(np.log10(minX), np.log10(maxX), bin_x)
+    
+    hist = np.zeros((bin_x,2))
+      
+    for i, edge in enumerate(edges_x):
+        hist[i][0] = edge
+
+    with fileinput.input(files=(file), encoding="utf-8", errors='ignore') as f: 
+        timestamp = 0
+        T=None
+        for line in f:
+            if not line.strip() or len(line.split()) < 9:
+                continue
+            l = line.split()
+            if not any(x in l for x in ['EOF', 'X', 'xF']):
+                if l[0] == 'H':
+                    timestamp = int(l[1])
+                    T = get_T(float(l[8]))
+                if l[0] == 'EI' and len(l)>3*18 and conditions(l,args):
+                    #T=15
+                    b = value_HL(l,'D1',u)+value_HL(l,'D2',u) 
+                    bx = get_MeV(b, T)
+                    if minX <= bx <= maxX:
+                        xb = np.digitize(bx, edges_x)-1
+                        hist[xb,1] += 1                                                               
+                                    
+    frame = pd.DataFrame(hist, columns = ['MeV'] + ['D'])
+    frame.to_csv(f'histograms/{filename}{nameadd}_D_MeV.1dhistlog', sep = ' ', index = False)
+    print(f'histograms/{filename}{nameadd}_D_MeV.1dhistlog was created')
+        
+        
+##########################################################################################
     
 def generate_hist_xlog():
-    minX = 0.01
+    minX = 1
-    maxX = 100
+    maxX = 3500
-    resX = resV
+    resX = 100*resV
     bin_x = int((maxX-minX)/resX)
     
     edges_x = np.logspace(np.log10(minX), np.log10(maxX), bin_x)
@@ -403,13 +451,13 @@ def generate_hist_xlog():
                 if l[0] == 'H':
                     timestamp = int(l[1])
                     T = get_T(float(l[8]))
-                if l[0] == 'EI' and len(l)>3*18 and conditions(l,args):
+                if l[0] == 'EI' and len(l)>3*18 and conditions(l,args) and isMask_other(l,T,mask):
                     for i,chan in enumerate(chans):
                         #b = value_HL(l,chan,u) 
                         x_expr, x_op, x_next_op, x_next_channel = parse_channel_expression(chan)
                         try: b = get_channel_value(l, u,x_expr, x_op, x_next_op, x_next_channel,T)
                         except: b = 0
-                        if minV <= b <= maxX and isMask_1D(l,args.mask,T):
+                        if minV <= b <= maxX:
                             xb = np.digitize(b, edges_x)-1
                             hist[xb,i+1] += 1                                                           
                                 

CHAOScustom.py

@@ -13,6 +13,7 @@ from histframe import get_T
 from histframe import get_MeV
 from histframe import CmV
 from histframe import isCut
+from histframe import isMask
 
 
 name = hf.names
@@ -27,15 +28,16 @@ resV = hf.resV
 
 pol = hf.pol
 
-#file = "2024-10-02-flight-2.EI"
+file = "2024-10-02-flight-2.EI"
-file = "chaos_sd_float.EI"
+# file = "chaos_sd_float.EI"
-#file = "data_sim/proton.EI"
+# file = "data_sim/proton.EI"
-#file = "data_sim/e-.EI"
+# file = "data_sim/e-.EI"
-#file = "data_sim/mu.EI"
+# file = "data_sim/mu.EI"file = "data_sim/he.EI"
-#file = "data_sim/he.EI"
 
 
-def main():
+def do_hist(cuts,val):
+    print('do ' + val)
+    print('with cuts: ' +str(cuts))
     bin_x = int((maxX-minX)/resX)
     bin_y = bin_x+1
     edges_x = np.logspace(np.log10(minX), np.log10(maxX), bin_x)
@@ -60,8 +62,13 @@ def main():
                 T = get_T(float(l[8]))
             if l[0] == 'EI' and len(l)>3*18 and isCut(l,cuts) and T != None:
                 if int(int(l[4].split(':')[0])/3) > deltacut:
+                    if val=='fish':
+                        bx,by = get_values_fish(l,T)
+                    elif val =='other':
+                        bx,by = get_values_other(l,T)
+                    else:
                         bx,by = get_values(l,T)
-                    if minX <= bx <= maxX and minY <= by <= maxY:
+                    if minX <= bx <= maxX and minY <= by <= maxY and isMask(bx,by,masks):
                         bxx = np.digitize(bx, edges_x) - 1
                         #bxx = int((bx-minX)/resX)
                         byy = np.digitize(by, edges_y)
@@ -70,106 +77,112 @@ def main():
             
     frame = pd.DataFrame(hist, columns = ['MeV']+edges_y.astype(str).tolist())
     frame.to_csv(f'{folder}/{filename}', sep = ' ', index = False)
-    print(f'{folder}/{filename} was created')
+    print(f'{folder}/{filename} was created \n')
-    
-# def mainZ():
-#     bin_x = int((maxX-minX)/resX)
-#     bin_y = bin_x+1
-#     edges_x = np.logspace(np.log10(minX), np.log10(maxX), bin_x)
-#     #edges_x = [minX + i*resX for i in range(bin_x+1)]
-#     edges_y = np.logspace(np.log10(minY), np.log10(maxY), bin_y)
-    
-#     #hist = np.zeros((bin_x+1, bin_y+1))
-#     hist = np.zeros((bin_x, bin_y+1))
-    
-#     for i, edge in enumerate(edges_x):
-#         hist[i][0] = edge
-        
-        
-#     with fileinput.input(files=("2024-10-02-flight-2.EI"), encoding="utf-8", errors='ignore') as f: 
-#         T=None
-#         timestamp=0
-#         for line in f:
-#             if not line.strip():
-#                 continue
-#             l = line.split()
-#             if l[0] == 'H':
-#                 timestamp = int(l[1])
-#                 T = get_T(float(l[8]))
-#             if l[0] == 'EI' and len(l)>3*18 and isCut(l,cuts) and 1727859780 < timestamp < 1727872980 and T != None:
-#                 if int(int(l[4].split(':')[0])/3) > deltacut:
-#                     bx,by,z = get_valuesZ(l,T)
-#                     if minX <= bx <= maxX and minY <= by <= maxY:
-#                         bxx = np.digitize(bx, edges_x) - 1
-#                         #bxx = int((bx-minX)/resX)
-#                         byy = np.digitize(by, edges_y) - 1
-#                         if 0 <= bxx < bin_x and 0 <= byy < bin_y:
-#                             hist[bxx, byy] = z    
-            
-#     frame = pd.DataFrame(hist, columns = ['MeV']+edges_y.astype(str).tolist())
-#     frame.to_csv(f'{folder}/{filename}', sep = ' ', index = False)
-#     print(f'{folder}/{filename} was created')
-    
-
-##################################################################################################
-def get_valuesZ(l,T):
-    y = min(max(value(l,"A1H"),value(l,"A2H")),max(value(l,"C1H"),value(l,"C2H")))/max(value(l,"E1"),value(l,"E2"),value(l,"E3"))
-    x = value(l,"D1H")+value(l,"D2H")
-    x2 = get_MeV(x,T)
-    z = value(l,"B")
-    return x2,y,z
 
 ###################################################################################################
 
-def get_values(l,T):
+def get_values_fish(l,T):
-    #y = max(value(l,"C1H"),value(l,"C2H"))/value(l,"EH")q
     y = min(value_HL(l,"A",u),value_HL(l,"C",u))/max(value(l,"E1",u),value(l,"E2",u),value(l,"E3",u)) 
+    #y = value_HL(l,"A",u)/max(value(l,"E1",u),value(l,"E2",u),value(l,"E3",u)) 
+    x = value_HL(l,"D1",u)+value_HL(l,"D2",u)
+    x2 = get_MeV(x,T)
+    return x2,y
 
-    #y = value(l,"A",u)/1000
+def get_values_other(l,T):
-    #y = value(l,"C",u)/1000
+    y = min(value_HL(l,"A",u),value_HL(l,"C",u))/1000
-    
+    #y = value_HL(l,"A",u)/1000
-    #y = min(value_HL(l,"A",u),value_HL(l,"C",u))/1000
-    
     x = value_HL(l,"D1",u)+value_HL(l,"D2",u)
     x2 = get_MeV(x,T)
     return x2,y
 
 
-cuts = ['A','hB','C','AeqC','D','E123']
+def get_values(l,T):
+    y = min(value_HL(l,"A",u),value_HL(l,"C",u))/max(value(l,"E1",u),value(l,"E2",u),value(l,"E3",u))   
+    #y = value(l,"A",u)/1000
+    #y = value(l,"C",u)/1000   
+    #y = min(value_HL(l,"A",u),value_HL(l,"C",u))/1000  
+    x = value_HL(l,"D1",u)+value_HL(l,"D2",u)
+    x2 = get_MeV(x,T)
+    return x2,y
+
+
+deltacut = 0
+
+allcuts = [['A','B','C','AeqC','D'],['A','nB','C','AeqC','D']]
+#allcuts = [['A','D'],['A','B','D'],['A','nB','D']]
+allcuts = [['A','C','AeqC','D']]
+
+#masks = ['He1']
+masks=[]
+
+allfish = True
+allother = True
 
-filename = "chaos20_Cut"+ "".join(cuts)+"~min(A,C)dE-D.2dhist2log"
-#filename = "chaos20_Cut"+ "".join(cuts)+"~min(A,C)-D.2dhist2log"
 folder = "hists_fish"
+#folder = "hists_sim"
+
+minX = 2
+maxX = 10000
+minY = 0.02
+maxY = 20
+resV = 50*80*resV
+resX = resV/0.00362/polynom(15,*pol)
+
+if allother:
+    for cut in allcuts:
+        filename = "chaos_Cut"+ "".join(cut)+"~min(A,C)-D.2dhist2log"
+        #filename = "chaosB35_Cut"+ "".join(cut)+"~A-D.2dhist2log"
+        #filename = "simHe-chaos_Cut"+ "".join(cut)+"~min(A,C)-D.2dhist2log"
+        do_hist(cut,'other') 
+        
+if allfish:
+    for cut in allcuts:
+        cut.append('E123')
+        filename = "chaos_Cut"+ "".join(cut)+"~min(A,C)dE-D.2dhist2log"
+        #filename = "chaosB35_Cut"+ "".join(cut)+"~AdE-D.2dhist2log"
+        #filename = "simHe-chaos_Cut"+ "".join(cut)+"~min(A,C)dE-D.2dhist2log"
+        do_hist(cut,'fish')
+
+
+
+        
+        
+
+#cuts = ['A','hB','C','AeqC','D','E123']
+
+#filename = "chaos35_Cut"+ "".join(cuts)+"~min(A,C)dE-D.2dhist2log"
+#filename = "chaos35_Cut"+ "".join(cuts)+"~min(A,C)-D.2dhist2log"
+#folder = "hists_fish"
 
 # filename = "chaos-dE-cut"+ "".join(cuts)+"~A-D.2dhist2log"
 # folder = "hists_dEdx"
 
 #chaos
 #resV = 50*resV
-minY = 0.05
+# minY = 0.05
-maxY = 10
+# maxY = 10
 
-minX = 10
+# minX = 10
-maxX = 170
+# maxX = 170
 
-minX = 7
+# minX = 7
-maxX = 10000
+# maxX = 10000
 
-#fish
+# #fish
-resV = 80*resV
+# resV = 80*resV
-minY = 0.01
+# minY = 0.01
-maxY = 100
+# maxY = 100
-minX = 5
+# minX = 5
-maxX = 500
+# maxX = 500
-maxX = 10000
+# maxX = 10000
-resV = 50*resV
+# resV = 50*resV
 
-# minY = 0.02
+# # minY = 0.02
-# maxY = 20
+# # maxY = 20
 
-mask_He = False
+# mask_He = False
-if mask_He:    
+# if mask_He:    
-    minX,minY,maxX,maxY= 64,0.6,102, 1.5
+#     minX,minY,maxX,maxY= 64,0.6,102, 1.5
 
 #kontur
 # resV=3*resV
@@ -182,15 +195,9 @@ if mask_He:
 # minX = 1
 # maxX = 1000
 
-
+#resX = resV/0.00362/polynom(15,*pol)
-resX = resV/0.00362/polynom(15,*pol)
 #resX = resV/0.00362
 
-deltacut = 0
 
-###############################################
-
-if __name__ == '__main__':
-    main()
 
 #mainZ()

histframe.py

@@ -35,17 +35,17 @@ names[15] = "E1";  ch[15] = 8;  thr[15] = 8;  s[15] = 2.2;  u[15] = 11.32
 names[16] = "E2";  ch[16] = 5;  thr[16] = 8;  s[16] = 2.2;  u[16] = 11.32
 names[17] = "E3";  ch[17] = 2;  thr[17] = 8;  s[17] = 2.2;  u[17] = 11.32
 
-thr[9]=60
+thr[9]=18
-thr[11]=60
+thr[11]=18
 
 thr[0] = 8
 thr[2] = 14
 thr[5] = 7
 thr[7] = 13
 
-thr[13] = 14.73
+thr[13] = 13.19
 
-thr[15] = 6.64; thr[16] = 6.54; thr[17] = 6.54
+thr[15] = 5.92; thr[16] = 5.92; thr[17] = 5.92
 
 names_a = ["A1", "A2", "B", "C1", "C2", "D1", "D2", "E", "E1", "E2", "E3"]
 boundary = 2500 #mV
@@ -55,7 +55,7 @@ boundary = 2500 #mV
 
 
 mV = 14000
-minV = 0
+minV = -100
 maxV = 3500
 resV = 0.838214/2
 
@@ -83,7 +83,7 @@ def get_MeV(keV,T):
     return keV/0.00362/polynom(T,*pol)
 
 def get_MeV_mean(keV):
-    return keV/0.00362/polynom(15,*pol)
+    return keV/0.00362/polynom(14.92,*pol)
 
 def get_MeV_H(keV,T):
     return keV/0.00362/line_H(T)
@@ -148,22 +148,24 @@ def isCut(l, cut):
         if d1 < thresholds['D1H'] or d2 < thresholds['D2H']: return False
         if not (0.85 * (d1 - 30) < d2 < d1/0.85 + 30): return False
         
-    # Cut für B oder nB
+    elif "nD" in cut:
-    # if "B" in cut:
+        d1 = value_HL(l,'D1',u)
-    #     b = value(l,"B",u)
+        d2 = value_HL(l,'D2',u)
-    #     if not (106.38 < b < 366.46): return False
+        if d1 > thresholds['D1H'] and d2 > thresholds['D2H']: return False
-    # elif "nB" in cut:
+        if (0.85 * (d1 - 30) < d2 < d1/0.85 + 30): return False
-    #     b = value(l,"B",u)
+        
-    #     if 106.38 < b < 366.46: return False
+    if "B" in cut or "hB" in cut:
-    elif "nB" or "lB" in cut:
         b = value(l,"B",u)
-        if b > 35: return False
+        if b < 17: return False
         #if b > 106.38: return False
-    elif "B" or "hB" in cut:
+        
+    elif "nB" in cut or "lB" in cut:
         b = value(l,"B",u)
-        #if b < 366.46:
+        if b > 17: return False
-        #if b < 106.38: return False
+        
-        if b < 35: return False
+    elif "rB" in cut or "lB" in cut:
+        b = value(l,"B",u)
+        if b < 17 or b > 43: return False
         
     if "A" in cut:
         a1 = value_HL(l,"A1",u)
@@ -206,6 +208,35 @@ def isCut(l, cut):
 
     return True
 
+###########################################################################################
+
+def get_values_fish(l,T):
+    y = min(value_HL(l,"A",u),value_HL(l,"C",u))/max(value(l,"E1",u),value(l,"E2",u),value(l,"E3",u)) 
+    #y = value_HL(l,"A",u)/max(value(l,"E1",u),value(l,"E2",u),value(l,"E3",u)) 
+    x = value_HL(l,"D1",u)+value_HL(l,"D2",u)
+    x2 = get_MeV(x,T)
+    return x2,y
+
+def get_values_other(l,T):
+    y = min(value_HL(l,"A",u),value_HL(l,"C",u))/1000
+    #y = value_HL(l,"A",u)/1000
+    x = value_HL(l,"D1",u)+value_HL(l,"D2",u)
+    x2 = get_MeV(x,T)
+    return x2,y
+
+def isMask(x,y,mask):
+    if 'He1' in mask:
+        if x<60 or x>100: return False
+        if y<0.26 or y>0.61:return False
+    return True
+
+def isMask_other(l,T,mask):
+    x,y = get_values_other(l, T)
+    if 'He1' in mask:
+        if x<60 or x>100: return False
+        if y<0.26 or y>0.61:return False
+    return True
+                    
 
 def isMask_1D(l, mask,T):
     if not mask:

plotAC_5d.py

@@ -106,7 +106,7 @@ def do_2dhist():
     y_edges = data.columns[1:].astype(float).tolist()
 
     # Hauptplot: 2D-Histogramm
-    cb = ax_main.pcolormesh(x_edges, y_edges, c, cmap=cmap, shading='nearest', vmin=1, norm='log')
+    cb = ax_main.pcolormesh(x_edges, y_edges, c, cmap=cmap, shading='nearest', vmin=1git status, norm='log')
     ax_main.set_yscale('log')  # Logarithmische Skala für y
     
     # Summenberechnung

xplot.py

@@ -106,10 +106,16 @@ def do_1dhist():
     #plt.axvline(x=6.5, color='k', linestyle = '--', lw=2, label = 'thr(E123) = 6.5 mV') 6.593
     #plt.axvline(x=14, color='r', linestyle = '--', lw=2, label = 'thr(E) = 14 mV') 
     #plt.axvline(x=67, color='k', linestyle = '--', lw=2, label = 'thr(E123) = 67 keV') 
-    #plt.axvline(x=60, color='r', linestyle = '--', lw=2, label = 'thr(E) = 67 keV')
+    #plt.axvline(x=60, color='r', linestyle = '--', lw=2, label = 'thr(E) = 60 keV')
     
     #plt.axvline(x=20, color='blue', linestyle='--', linewidth=2, label='20 mV (flight)')
-    #plt.axvline(x=60, color='black', linestyle='--', linewidth=2, label='60 mV (data analysis)')
+    #plt.axvline(x=18, color='black', linestyle='--', linewidth=2, label='18 mV (2 MeV)')
+    #plt.axvline(x=2, color='black', linestyle='--', linewidth=2, label='2 MeV')
+    #plt.axvline(x=9, color='r', linestyle='--', linewidth=2, label='9 mV (1 MeV)')
+    
+    plt.axvline(x=17, color='red', linestyle='--', linewidth=2, label='17 mV')
+    plt.axvline(x=43, color='black', linestyle='--', linewidth=2, label='43 mV')
+   
     
     plot_layout(title, energy, limits,None,None,None)
     
@@ -182,7 +188,7 @@ def do_2dhist():
     c = np.array(data)[:,1:].T
     
     Dcuts = False
-    ACcuts = True
+    ACcuts = False
     AeqC = False
     Ecuts = False
     Lowcal = False
@@ -192,13 +198,13 @@ def do_2dhist():
         vmin = 1
         if Dcuts:
             plt.plot(x_edges, np.multiply(np.add(x_edges,-30), 0.85), 'r-', lw=2, 
-                     label=("Cuts: $0.85 \\cdot (D1H - 30$ mV$)< D2H < D1H/0.85 + 30$mV"))
+                     label=("Cuts: $0.85 \\cdot (D1 - 30$ mV$)< D2 < D1/0.85 + 30$mV"))
             #plt.plot(x_edges,np.multiply(x_edges,1.15)+30, 'r-', lw=1.5)
             plt.plot(x_edges,np.add(np.divide(x_edges,0.85),30), 'r-', lw=2)
             #plt.plot([0, 30], [30, 30], 'r--', lw=2)
             #plt.plot([30, 30], [30, 0], 'r--', lw=2)
-            plt.axhline(y=60, color='r', linestyle = '--', lw=1.5,label = "         $D1H, D2H > 60$ mV")
+            plt.axhline(y=25, color='r', linestyle = '--', lw=1.5,label = "         $D1, D2 > 25$ mV")
-            plt.axvline(x=60, color='r', linestyle = '--', lw=1.5,)
+            plt.axvline(x=25, color='r', linestyle = '--', lw=1.5,)
             
         if ACcuts:
             plt.axhline(y=15, color='r', linestyle = '-', lw=1.5, label = "thr['C1H'] = 10 mV; thr['C2H'] = 15 mV")
@@ -217,13 +223,13 @@ def do_2dhist():
         
         if Dcuts:
             plt.plot(x_edges, np.multiply(np.add(x_edges,-30), 0.85), 'r-', lw=2, 
-                     label=("Cuts: $0.85 \\cdot (D1H - 30$ mV$)< D2H < D1H/0.85 + 30$mV"))
+                     label=("Cuts: $0.85 \\cdot (D1 - 30$ mV$)< D2 < D1/0.85 + 30$mV"))
             #plt.plot(x_edges,np.multiply(x_edges,1.15)+30, 'r-', lw=1.5)
             plt.plot(x_edges,np.add(np.divide(x_edges,0.85),30), 'r-', lw=2)
             #plt.plot([0, 30], [30, 30], 'r--', lw=2)
             #plt.plot([30, 30], [30, 0], 'r--', lw=2)
-            plt.axhline(y=60, color='r', linestyle = '--', lw=1.5,label = "         $D1H, D2H > 60$ mV")
+            plt.axhline(y=18, color='r', linestyle = '--', lw=1.5,label = "         $D1, D2 > 18$ mV")
-            plt.axvline(x=60, color='r', linestyle = '--', lw=1.5,)
+            plt.axvline(x=18, color='r', linestyle = '--', lw=1.5,)
             
             
         if Ecuts:
@@ -298,8 +304,8 @@ def do_2dhist():
         cbar = plt.colorbar(contour, orientation = 'vertical', shrink = 0.95, pad = 0.1)
      
     else:
-        cb = plt.pcolormesh(x_edges, y_edges,c, cmap = cmap, shading='nearest', vmin=vmin, vmax = 2000,norm='log')  
+        #cb = plt.pcolormesh(x_edges, y_edges,c, cmap = cmap, shading='nearest', vmin=vmin, vmax = 2000,norm='log')  
-        #cb = plt.pcolormesh(x_edges, y_edges,c, cmap = cmap, shading='auto', vmin=vmin, norm='log')
+        cb = plt.pcolormesh(x_edges, y_edges,c, cmap = cmap, shading='auto', vmin=vmin, norm='log')
         #cb = plt.pcolormesh(np.multiply(x_edges,f), y_edges,c, cmap = cmap, shading='nearest', vmin=vmin, vmax=30, norm='log')    
         cbar = plt.colorbar(cb, orientation = 'vertical', shrink = 0.95, pad = 0.1)