msg += "Usage 1: %s $INPUT_ROOT_FILE\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import larlight as fmwk
import ROOT
#shit has to be loaded like this
ROOT.gSystem.Load("libBase")
ROOT.gSystem.Load("libDataFormat")
ROOT.gSystem.Load("libSNTest")
# Create ana_processor instance
my_proc = fmwk.ana_processor()
my_proc.set_verbosity(fmwk.MSG.NORMAL)
# Set input root files... need MCShower and shower reco in 1 or many files
for x in xrange(len(sys.argv)):
if x < 1: continue
my_proc.add_input_file(sys.argv[x])
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.READ)
# Attach a template process
my_ana= fmwk.HeaderCheck()
my_proc.add_process(my_ana)
#
# Load libraries
import os, ROOT, sys
from ROOT import gSystem
import time
gSystem.Load("libAnalysis")
gSystem.Load("libLArUtil")
gSystem.Load("libDavidAna")
gSystem.Load("libGeoAlgo")
# Now import ana_processor & your class. For this example, ana_base.
from ROOT import larlight as fmwk
# Create ana_processor instance
my_proc = fmwk.ana_processor()
# Specify IO mode
my_proc.set_io_mode(fmwk.storage_manager.READ)
#my_proc.set_io_mode(storage_manager.WRITE)
#my_proc.set_io_mode(storage_manager.BOTH)
# Specify what data to read
my_proc.set_data_to_read(fmwk.DATA.MCTruth)
my_proc.set_data_to_read(fmwk.DATA.MCParticle)
# Set input root file: this is decoder output root file.
# This time, we use a sample file prepared.
#my_proc.add_input_file("./../../../NevisDecoder/Decoder/mac/xmit_subrun_2014_01_13_1_dma_no_1.root")
#my_proc.add_input_file("./../../../NevisDecoder/Decoder/mac/xmit_subrun_2014_01_13_1_trigger.root")
my_proc.add_input_file(sys.argv[1])
import ROOT,sys
ROOT.gSystem.Load("libClusterRecoUtil")
from ROOT import *
from ROOT import larlight as fmwk
mgr = fmwk.ana_processor()
#arg1 should be input file name
mgr.add_input_file(sys.argv[1])
mgr.set_input_rootdir("scanner")
mgr.set_output_rootdir("scanner")
#arg2 should be output file name
mgr.set_output_file(sys.argv[2])
mgr.set_io_mode(fmwk.storage_manager.BOTH)
mgr.set_ana_output_file("")
proc = fmwk.ClusterMerger()
#secondmerger starts with Cluster data type (not Fuzzy!)
#and outputs Cluster... it overwrites now
proc.SetClusterType(larlight.DATA.Cluster)
proc.SaveOutputCluster(True)
########################################
# attach merge algos here
########################################
import sys
from ROOT import *
from ROOT import larlight as fmwk
processor = fmwk.ana_processor()
#need to use BOTH so output from first module is used as input to second
processor.set_io_mode(fmwk.storage_manager.BOTH)
#processor.set_io_mode(fmwk.storage_manager.READ)
processor.set_rootdir('scanner')
for x in xrange(len(sys.argv)):
if x < 1: continue
processor.add_input_file(sys.argv[x])
#need to save output file from shower module otherwise it won't work
processor.set_output_file("out.root")
processor.set_output_rootdir("scanner")
processor.set_ana_output_file("")
mod = fmwk.MCShowerClusterer()
#whether to group overlapping hits into single hit objects. TRUE by default
#reduces number of hits by a factor of ~10
mod.SetGroupOverlappingHits(False)
msg = '\n'
msg += "Usage 1: %s $INPUT_ROOT_FILE merge_algo_cut_value\n" % sys.argv[0]
msg += '\n'
sys.stderr.write(msg)
sys.exit(1)
from ROOT import gSystem
gSystem.Load("libCMergePerformance")
from ROOT import larlight, cluster
filename = sys.argv[1]
angle_cutval = float(sys.argv[2])
dist_cutval = float(sys.argv[3])
# Create ana_processor instance
my_proc = larlight.ana_processor()
# Set input root file
my_proc.add_input_file(filename)
# Specify IO mode
my_proc.set_io_mode(larlight.storage_manager.READ)
# Specify input TDirectory name
my_proc.set_input_rootdir("scanner")
# Specify output root file name
#this split bs is to just isolate the filename (cut out path, cut out .root)
output_filename = "CMP_ana_out_%s_cut%s_%s.root"%(filename.split('/')[-1][:-5],angle_cutval,dist_cutval)
my_proc.set_ana_output_file(output_filename)
print "output_filename is %s" % output_filename
def main(pv_ptr):
proc = fmwk.ana_processor()
# proc.set_verbosity(MSG.DEBUG)
proc.set_ana_output_file("ana.root")
proc.set_io_mode(fmwk.storage_manager.READ)
# proc.set_data_to_read(fmwk.DATA.Pulse)
# proc.set_data_to_read(fmwk.DATA.PMTPulse_FixedWin)
proc.set_data_to_read(fmwk.DATA.PMTPulse_ThresWin)
proc.add_input_file(sys.argv[1])
proc.set_ana_output_file("")
proc.add_process(pv_ptr)
while 1:
proc.process_event()
if not proc.get_process_status() == proc.PROCESSING:
break
# get list of channels that got a pulse
ch = pv_ptr.next_channel()
while not ch == fmwk.FEM.INVALID_CH:
for x in xrange(pv_ptr.get_npulse(ch)):
print "pulse %d/%d" % (x + 1, pv_ptr.get_npulse(ch))
h = pv_ptr.next_pulse(ch)
if not h:
break
options = ['n', 's', 'q', 'c']
user_input = ''
while not user_input in options:
if user_input:
print
print "\033[91m" + 'Invalid option: \"%s\"' % user_input + "\033[0m"
print
sys.stdout.write("\033[95m" + "Options:" + "\033[0m")
sys.stdout.write(
" ... \"s\" to save image, \"n\" for next pulse, \"c\" to alter cut values, \"q\" to exit.\n"
)
sys.stdout.flush()
print
sys.stdout.write("\033[93m" + 'Input [s/n/c/q]: ' +
"\033[0m")
sys.stdout.flush()
user_input = sys.stdin.readline().rstrip('\n')
if user_input == 'q':
terminate = True
sys.exit(1)
if user_input == 'n':
break
if user_input == 's':
out_name = 'pulse_image.gif'
pv_ptr.get_canvas().SaveAs("%s+100" % out_name)
print 'Image saved in %s ... ' % out_name
user_input = ''
if user_input == 'c':
change_cut_values(pv_ptr)
user_input = ''
ch = pv_ptr.next_channel()
