Example #1
0
 def loopOverRecords(self, cuts, energyScaler, 
                     use_baseline_cut = True, 
                     opposite_baseline_cut = False):
     server = SoudanServer()
     file_list = server.get_accepted_runs()
     for id in file_list:
         print id
         rundoc = server.get_run(id.id) 
         file_name = rundoc.output_data_file_tier_2.pfn 
         wf_file_name = rundoc.root_data_file_tier_1.pfn 
         open_file = ROOT.TFile(file_name)
         main_tree = open_file.Get("wf_analysis") 
         coinc_tree = open_file.Get("event_coincidence") 
         wf_open_file = ROOT.TFile(wf_file_name)
         wf_tree = wf_open_file.Get("gretaDec")
         main_tree.AddFriend(coinc_tree)
         real_cuts = cuts
         main_tree.GetEntry(0)
         if use_baseline_cut:
             not_string = ""
             if opposite_baseline_cut:
                 not_string = "!"
             additional_cuts = " && %s(abs(fitConstant-%f) <= 3*%f) " % (not_string, \
                rundoc.baseline_dict.average_fit_constant, \
                rundoc.baseline_dict.average_fit_rms)
             real_cuts += additional_cuts
         if not self.printWaveformToPS(main_tree, wf_tree, real_cuts, energyScaler): break
Example #2
0
def insert_view_into_database(view):
    """
    Function inserts a view into the database.
    Type of view should be an couchdb.schema.ViewDefinition 
    """
    
    server = SoudanServer()
    view.sync(server.get_database())
 def __init__(self, percentage=90):
     ROOT.gROOT.cd()
     self.microphonics_list = ROOT.TEventList("microphonics_list", "microphonics_list")
     self.risetime_list = ROOT.TEventList("risetime_list", "risetime_list")
     self.LN_cut_list = ROOT.TEventList("LN_cut_list", "LN_cut_list")
     self.odd_pulse_cut_list = ROOT.TEventList("odd_pulse_cut_list", "odd_pulse_cut_list")
     self.LN_cut_on_list = ROOT.TEventList("LN_cut_on_list", "LN_cut_on_list")
     self.combination_list = ROOT.TEventList("combination_list", "combination_list")
    
     # The risetime cut is a dump from the results of the rise-time fit. 
     server = SoudanServer()
    
     # Grab the trigger efficiency 
     trigger_doc = server.get_trigger_efficiency_doc()
     self.erfc_function = trigger_doc.trigger_efficiency['standard'].efficiency_function
    
     # Grab the microphonics cuts
     microdoc = server.get_microphonics_cut_doc( )
     temp = microdoc.all_micro_cuts[99]
     self.lower_cut, self.upper_cut, self.microphonics_efficiency = \
           temp.lower_cut, temp.upper_cut, temp.efficiency_function
    
     # Grab the risetime cuts
     risedoc = server.get_rise_time_cut_doc() 
     temp = risedoc.all_rise_cuts[percentage] 
     self.risetime_cut, self.upper_risetime_cut, self.risetime_efficiency = \
           temp.low_energy_function, temp.high_energy_function, temp.efficiency_function
    
     self.cuts_list = [self.get_risetime_cut_list,
                       self.get_microphonics_cuts_list,
                       self.get_LN_fill_cut_list,
                       self.get_odd_pulse_cut_list]
     self.eff_list =  [self.risetime_efficiency,
                       self.microphonics_efficiency,
                       self.erfc_function]
     self.odd_pulse_cut = server.get_pulse_cut_doc().pulse_cut
Example #4
0
def analyze_timing(outputfile='temp.root', force_overwrite=False):
    
    force_overwrite = True
    timing_list_name = "timing_list"
    time_run_list_name = "time_of_run_list"
    server = SoudanServer()
    file_to_output = ROOT.TFile(outputfile, 'recreate');
    objects_to_write = []
    apickle = None
    if server.pickle_is_in_database(timing_list_name):
        print "Already exists"
        apickle = server.get_pickle(timing_list_name)
        time_list = apickle.pickle
        timing_list_name = None
    else:
        apickle = PickleDocumentClass()
        force_overwrite = True
    if force_overwrite:
        time_list = []
        file_list = server.get_accepted_runs()
        
        # generate final plots
        start_time = None
        for id in file_list:
            print id
            rundoc = server.get_run(id.id) 
            if not start_time:
                start_time = rundoc.time_of_start_of_run
            timeofstart = rundoc.time_of_start_of_run
            file_name = rundoc.output_data_file_tier_2.pfn
            open_file = ROOT.TFile(file_name)
            main_tree = open_file.Get("wf_analysis") 
            coinc_tree = open_file.Get("event_coincidence") 
            main_tree.AddFriend(coinc_tree)
            main_tree.GetEntry(0)
            first_time = main_tree.eventTime 
            main_tree.GetEntry(main_tree.GetEntries()-1)
            last_time = main_tree.eventTime 
            time_list.append((time.mktime(timeofstart.timetuple()), \
                              first_time, last_time, \
                              main_tree.runNumber))
            
            open_file.Close()
        apickle.pickle = time_list
        server.insert_pickle(apickle, timing_list_name) 


    conversion_code = "convert_gretina_time_to_real_time"
    dynamic_function = None
    pickle = None
    if server.pickle_is_in_database(conversion_code):
        pickle = server.get_pickle(conversion_code)
        if not force_overwrite:
            dynamic_function = pickle.pickle
        conversion_code = None
    if not pickle:
        pickle = PickleDocumentClass()
    if not dynamic_function:
        start_run_number = time_list[0][3]
        start_time = time_list[0][0]
        last_time = time_list[0][0]
        
        scrap_list = []
        
        def find_offset(scrap_list):    
            agraph = ROOT.TGraph(len(scrap_list))
            for i in range(len(scrap_list)):
                agraph.SetPoint(i, scrap_list[i][1], scrap_list[i][0])
            pol1 = ROOT.TF1("pol1", "pol1")
            agraph.Fit(pol1)
            return pol1.GetParameter(0)
        
        
        run_dict = {}
        for start, event, last, runN in time_list:
            if event < last_time: 
                # We have cycled, do the fitting
                run_dict[start_run_number] = find_offset(scrap_list)
                del scrap_list[:]
                start_run_number = runN
            last_time = event
            scrap_list.append((start, event*1e-8, runN))
        run_dict[start_run_number] = find_offset(scrap_list)
        # Now make some dynamic code
        
        run_numbers = run_dict.keys()
        run_numbers.sort()
        run_numbers.reverse()
        code = """
def dynamic_function(run_number, event_time):  
    if run_number >= %i:
        return %f + event_time*1e-8 """ % (run_numbers[0], run_dict[run_numbers[0]]) 
        for i in range(1, len(run_numbers)):
            code += """
    elif run_number >= %i:
        return %f + event_time*1e-8""" % (run_numbers[i], run_dict[run_numbers[i]]) 
        code += """
    return 0 """

        pickle.pickle = code
        server.insert_pickle(pickle, conversion_code) 
        code_obj = compile(code,'<string>', 'exec')
  
        dynamic_function = types.FunctionType(code_obj.co_consts[0], globals())

    apickle = None
    mydict = None
    if not server.pickle_is_in_database(time_run_list_name):
        apickle = PickleDocumentClass() 
    else:
        apickle = server.get_pickle(time_run_list_name)
        time_run_list_name = None
        mydict = apickle.pickle
    if force_overwrite:
        scratch_list = {} 
        start_time = 0
        for start, event, last, runN in time_list:
            if runN == 1933: print "Yes"
            print runN
            if start_time == 0: start_time = dynamic_function(runN, event)
            scratch_list[runN] = (dynamic_function( runN, event ) - start_time,
                                 dynamic_function( runN, last ) - start_time)
        apickle.pickle = scratch_list
        server.insert_pickle(apickle, time_run_list_name)
        mydict = scratch_list
       
    keys = mydict.keys()
    new_graph = ROOT.TGraph(len(keys))
    keys.sort() 
    for i in range(len(keys)):
        first, last = mydict[keys[i]]
        new_graph.SetPoint(i, keys[i], last - first)
    
    c1 = ROOT.TCanvas()
    new_graph.Draw("APL")

    c1.Update()
    raw_input("E")
    #c1.Print("temp.eps")
    file_to_output.cd()
    for object in objects_to_write:
        object.Write(object.GetName(), TObject.kOverwrite)
    file_to_output.Close()
 def get_available_rise_cuts(cls):
     server = SoudanServer()
     risedoc = server.get_rise_time_cut_doc() 
     return risedoc.all_rise_cuts.keys()