def init_manager(self, _file):
# For the larcv manager, using the IOManager to get at the data
self._driver = larcv.ProcessDriver('ProcessDriver')
self._driver.configure(self._config)
self._io_manager = self._driver.io()
# Meta keeps track of information about number of planes, visible
# regions, etc.:
self._meta = event_meta3D()
# Drawn classes is a list of things getting drawn, as well.
self._drawnClasses = dict()
if _file != None:
flist = larcv.VectorOfString()
if type(_file) is list:
for f in _file:
flist.push_back(f)
self._driver.override_input_file(flist)
else:
flist.push_back(_file)
self._driver.override_input_file(flist)
self._driver.initialize()
self.go_to_entry(0)
self.refresh_meta()
def CosmicSegger(a):
proc = larcv.ProcessDriver('ProcessDriver')
#ABSOLUTELY NEED DOUBLE QUOTES??
if a == 1:
proc.configure('/user/jhenzerling/work/NEUsoft/Modules/SS/NEWCFG.cfg')
elif a == 2:
proc.configure('/user/jhenzerling/work/NEUsoft/Modules/SS/NEWCFG2.cfg')
else:
print('why')
proc.initialize()
proc.batch_process()
proc.finalize()
def deploy_sparselarflow_on_files(larcv_outfile,
larlite_outfile,
filelist,
weightfile,
model_name="dualflow_classvec_v2",
adc_producer="wire",
chstatus_producer='wire',
cropper_cfg="cropflow_processor.cfg",
flow="dual",
devicename="cpu",
run_reco_flowhits=True,
run_truth_flowhits=True,
save_full_adc=False,
save_cropped_adc=False,
save_cropped_trueflow=False,
run_stitcher=False,
has_mc=False,
threshold=10.0,
maxentries=-1):
import numpy as np
import torch
from larlite import larlite
from larcv import larcv
from ublarcvapp import ublarcvapp
from larflow import larflow
from ROOT import std
from sparsemodels import load_models
from load_cropped_sparse_dualflow import load_croppedset_sparse_dualflow_nomc
device = torch.device(devicename)
model = load_models(model_name, weight_file=weightfile, device=devicename)
model.eval()
out = larcv.IOManager(larcv.IOManager.kWRITE, "stitched")
out.set_out_file(larcv_outfile)
out.initialize()
out_ll = larlite.storage_manager(larlite.storage_manager.kWRITE)
out_ll.set_out_filename(larlite_outfile)
out_ll.open()
dt_tot = 0.0
dt_net = 0.0 # running the network
dt_data = 0.0 # preparing data (split/crop)
dt_aten = 0.0 # turn data into torch tensors
dt_flow = 0.0 # making flow
dt_result = 0.0 # preparing output images
ttot = time.time()
# first create cfg file if does not exist
if not os.path.exists(cropper_cfg):
print("Writing new copper config: ", cropper_cfg)
from crop_processor_cfg import fullsplit_processor_config
f = open(cropper_cfg, 'w')
f.write(fullsplit_processor_config(adc_producer, chstatus_producer))
f.close()
splitter = larcv.ProcessDriver("ProcessDriver")
print("CONFIGURE SPLITTER: ", cropper_cfg)
splitter.configure(cropper_cfg)
# add files to iomanager
io = splitter.io_mutable()
if type(filelist) is str:
filelist = [filelist]
for inputfile in filelist:
io.add_in_file(inputfile)
# initialize splitter
splitter.initialize()
nentries = io.get_n_entries()
if maxentries > 0 and maxentries < nentries:
nentries = maxentries
nimgs = 0
nevents = 0
for ientry in xrange(nentries):
tdata = time.time()
io.read_entry(ientry)
ev_img = io.get_data(larcv.kProductImage2D, adc_producer)
run = ev_img.run()
subrun = ev_img.subrun()
event = ev_img.event()
print("[Entry {}] {}".format(ientry, (run, subrun, event)))
adc_v = ev_img.Image2DArray()
adc_copy_v = std.vector("larcv::Image2D")()
for i in xrange(adc_v.size()):
adc_copy_v.push_back(adc_v.at(i))
splitter.process_entry(ientry, False, False)
if run_stitcher:
stitcher = ublarcvapp.UBSparseFlowStitcher(adc_v)
ev_crops = io.get_data(larcv.kProductImage2D, "croppedadc")
crop_v = ev_crops.Image2DArray()
print(" number of crops: {}".format(crop_v.size()))
# get sparse numpy arrays
data = load_croppedset_sparse_dualflow_nomc(io)
dt_data += time.time() - tdata
# container for network output
ev_outdualflow_v = out.get_data(larcv.kProductSparseImage,
"cropdualflow")
# torch tensors
for iset, sparse_np in enumerate(data["pixadc"]):
taten = time.time()
ncoords = sparse_np.shape[0]
print("deploy net: iset[{}] ncoords={}".format(iset, ncoords))
# make tensor for coords (row,col,batch)
coord_t = torch.from_numpy(sparse_np[:, 0:2].astype(
np.int32)).to(device)
# tensor for src pixel adcs
srcpix_t = torch.from_numpy(sparse_np[:, 4].reshape(
(ncoords, 1))).to(device)
# tensor for target pixel adcs
tarpix_flow1_t = torch.from_numpy(sparse_np[:, 2].reshape(
(ncoords, 1))).to(device)
if flow == 'dual':
tarpix_flow2_t = torch.from_numpy(sparse_np[:, 3].reshape(
(ncoords, 1))).to(device)
else:
tarpix_flow2_t = None
dt_aten += time.time() - taten
# Run NETWORK
tnet = time.time()
with torch.set_grad_enabled(False):
predict1_t, predict2_t = model(coord_t, srcpix_t,
tarpix_flow1_t, tarpix_flow2_t,
1)
dt_net += time.time() - tnet
#print("predict1_t shape",predict1_t.features.shape)
# convert class vector output back to flow
# find max, then subtract off source pix
if model_name in ['dualflow_classvec_v2']:
# get arg max
maxcol1 = torch.argmax(predict1_t.features.detach(), 1)
maxcol2 = torch.argmax(predict2_t.features.detach(), 1)
# subtract source column
flowout1_t = (maxcol1.type(torch.FloatTensor) -
coord_t[:, 1].type(torch.FloatTensor)).reshape(
(ncoords, 1))
flowout2_t = (maxcol2.type(torch.FloatTensor) -
coord_t[:, 1].type(torch.FloatTensor)).reshape(
(ncoords, 1))
else:
flowout1_t = predict1_t.features
flowout2_t = predict2_t.features
# back to numpy array
tresult = time.time()
meta_v = std.vector("larcv::ImageMeta")()
yplane_meta = crop_v.at(iset * 3 + 2).meta()
meta_v.push_back(yplane_meta)
meta_v.push_back(yplane_meta)
result_np = np.zeros((ncoords, 4), dtype=np.float32)
result_np[:, 0:2] = sparse_np[:, 0:2]
result_np[:, 2] = flowout1_t.detach().cpu().numpy()[:, 0]
result_np[:, 3] = flowout2_t.detach().cpu().numpy()[:, 0]
# store raw result
sparse_raw = larcv.sparseimg_from_ndarray(result_np, meta_v,
larcv.msg.kDEBUG)
ev_outdualflow_v.Append(sparse_raw)
# prepare for stitcher
if run_stitcher:
result_np[:, 2][sparse_np[:, 4] < 10.0] = -1000
result_np[:, 3][sparse_np[:, 4] < 10.0] = -1000
sparse_result = larcv.sparseimg_from_ndarray(
result_np, meta_v, larcv.msg.kDEBUG)
stitcher.addSparseData(sparse_result,
crop_v.at(iset * 3 + 0).meta(),
crop_v.at(iset * 3 + 1).meta())
dt_result += time.time() - tresult
nimgs += 1
# make flow hits
# --------------
tflow = time.time()
if run_reco_flowhits:
print("Make Reco Flow Hits")
larflowhits_v = larflow.makeFlowHitsFromSparseCrops(
adc_v, ev_outdualflow_v.SparseImageArray(), threshold,
"ubcroptrueflow.cfg", larcv.msg.kINFO)
if has_mc and run_truth_flowhits:
print("Make Truth Flow Hits")
ev_chstatus = io.get_data(larcv.kProductChStatus,
chstatus_producer)
ev_trueflow = io.get_data(larcv.kProductImage2D, "larflow")
trueflowhits_v = larflow.makeTrueFlowHitsFromWholeImage(
adc_v, ev_chstatus, ev_trueflow.Image2DArray(), threshold,
"ubcroptrueflow.cfg", larcv.msg.kINFO)
dt_flow += time.time() - tflow
# store
# --------
# full image
tresult = time.time()
if save_full_adc:
out_wire = out.get_data(larcv.kProductImage2D, "wire")
for p in xrange(3):
out_wire.Append(adc_v.at(p))
# cropped image
if save_cropped_adc:
out_crop = out.get_data(larcv.kProductImage2D, "cropadc")
for iimg in xrange(crop_v.size()):
out_crop.Append(crop_v.at(iimg))
print("saved ", crop_v.size(), " adc crops")
if save_cropped_trueflow:
ev_trueflow_crops = io.get_data(larcv.kProductImage2D,
"croppedflow")
out_trueflow_crops = out.get_data(larcv.kProductImage2D,
"croptrueflow")
for iimg in xrange(ev_trueflow_crops.Image2DArray().size()):
out_trueflow_crops.Append(
ev_trueflow_crops.Image2DArray().at(iimg))
print("saved ",
out_trueflow_crops.Image2DArray().size(), " true flow crops")
# save stitched output
if run_stitcher:
out_y2u = out.get_data(larcv.kProductImage2D, "larflowy2u")
out_y2u.Append(stitcher._outimg_v.at(0))
out_y2v = out.get_data(larcv.kProductImage2D, "larflowy2v")
out_y2v.Append(stitcher._outimg_v.at(1))
# save larflow hits
if run_reco_flowhits:
ev_larflowhits = out_ll.get_data(larlite.data.kLArFlow3DHit,
"flowhits")
for ihit in xrange(larflowhits_v.size()):
ev_larflowhits.push_back(larflowhits_v.at(ihit))
if has_mc and run_truth_flowhits:
ev_trueflowhits = out_ll.get_data(larlite.data.kLArFlow3DHit,
"trueflowhits")
for ihit in xrange(trueflowhits_v.size()):
ev_trueflowhits.push_back(trueflowhits_v.at(ihit))
# set id
out.set_id(run, subrun, event)
out_ll.set_id(run, subrun, event)
# save entry
out.save_entry()
out_ll.next_event()
dt_result = time.time() - tresult
# clear processor iomanager of the entry
io.clear_entry()
nevents += 1
dt_tot = time.time() - ttot
print("Total run time: %.3f secs" % (dt_tot))
print(" Data loading time: %.3f secs (%.3f secs/event)" %
(dt_data, dt_data / nevents))
print(" Prepare data for net: %.3f secs (%.3f secs/image)" %
(dt_aten, dt_aten / nevents))
print(" Net running time: %.3f secs (%.3f secs/event, %.3f secs/image)" %
(dt_net, dt_net / nevents, dt_net / nimgs))
print(" FlowHits running time: %.3f secs (%.3f secs/image)" %
(dt_flow, dt_flow / nevents))
print(" Result conversion: %.3f secs (%.3f secs/image)" %
(dt_result, dt_result / nevents))
out.finalize()
out_ll.close()
splitter.finalize()
return None
from larcv import larcv
import ROOT, sys
from ROOT import std
if len(sys.argv) < 2:
print 'Usage: python', sys.argv[
0], 'CONFIG_FILE [LARCV_FILE1 LARCV_FILE2 ...]'
sys.exit(1)
proc = larcv.ProcessDriver('ProcessDriver')
print "ARGS: ", str(sys.argv)
print "Loading config... ", sys.argv[1]
proc.configure(sys.argv[1])
print "Loaded"
print sys.argv
if len(sys.argv) > 1:
flist = ROOT.std.vector('std::string')()
for x in xrange(len(sys.argv) - 4):
print "Pushing back...", sys.argv[x + 4]
flist.push_back(sys.argv[x + 4])
proc.override_input_file(flist)
proc.override_ana_file(sys.argv[2] + ".root")
proc.override_output_file(sys.argv[3] + ".root")
proc.initialize()
larbys_cheater_id = proc.process_id("LArbysImageCheater")
larbys_cheater = proc.process_ptr(larbys_cheater_id)
print "GOT: ", larbys_cheater, "@ id=", larbys_cheater_id
def __init__(self,
input_rootfile,
output_rootfile,
batch_size,
identity,
broker_ipaddress,
product_dict,
random_access=False,
copy_input=False,
port=5559,
timeout_secs=30,
max_tries=3,
do_compress=True,
process_croi=False,
print_msg_sizes=False,
input_croiprocessor_cfg="input_croiprocessor_default.cfg",
input_precropped_cfg="input_precropped_default.cfg",
output_croiprocessor_cfg="output_croiprocessor_default.cfg"):
# Call Mother
super(CaffeLArCV1Client, self).__init__(identity,
broker_ipaddress,
port=port,
timeout_secs=timeout_secs,
max_tries=max_tries,
do_compress=do_compress)
# Save paths for ROOT Files
# ----------------------
if type(input_rootfile) is str:
self.input_rootfiles = [input_rootfile]
elif type(input_rootfile) is list:
self.input_rootfiles = [input_rootfile]
else:
raise ValueError("input_rootfile argument should be str or list")
self.output_rootfile = output_rootfile
if self.output_rootfile in self.input_rootfiles:
raise ValueError("input and output rootfiles are the same!")
# number of planes
# ----------------
self.NPLANES = 3
# setup input
# -----------
# we handle input via a larcv::ProcessDriver. how we process input depends on if process_croi is True.
# [to do] we want to be able to override the producer names in the file
# so we use a template. but if user supplies config, we just trust they set things up correctly.
if process_croi:
# we assume we have to crop out of the CROI regions
self.input_processor_cfg = input_croiprocessor_cfg
else:
self.input_processor_cfg = input_precropped_cfg
self.in_proc = larcv.ProcessDriver('InputProcessDriver')
self.in_proc.configure(self.input_processor_cfg)
infiles_v = std.vector("string")()
for infile in self.input_rootfiles:
infiles_v.push_back(infile)
self.in_proc.override_input_file(infiles_v)
self.in_proc.initialize()
self.io = self.in_proc.io()
if process_croi:
# get access to processors. we will get our cropped images from them
self.croicroppers = []
for p in range(self.NPLANES):
self.croicroppers.append(
self.in_proc.process_ptr(
self.in_proc.process_id("MultiROICropperP%d" % (p))))
# setup output
# ------------
if process_croi:
# if we are processing CROIs, we need to use the PyStitcher Processor
self.output_processor_cfg = output_croiprocessor_cfg
self.out_proc = larcv.ProcessDriver('OutputProcessDriver')
self.out_proc.configure(self.output_processor_cfg)
self.py_image_makers = []
for p in range(self.NPLANES):
self.py_image_makers.append(
self.out_proc.process_ptr(
self.out_proc.process_id("PyImageStitcherP%d" % (p))))
self.py_image_makers[p].set_producer_name('uburn_plane%d' %
(p))
self.out_proc.override_output_file(self.output_rootfile)
self.out_proc.initialize()
self.io_out = self.out_proc.io()
else:
# if we are just processing precropped images
if not copy_input:
self.io_out = larcv.IOManager(larcv.IOManager.kWRITE)
else:
self.io_out = larcv.IOManager(larcv.IOManager.kBOTH)
self.io_out.add_in_file(self.input_rootfile)
# set output file
self.io_out.set_out_file(self.output_rootfile)
self.io_out.initialize()
# other parameters
# ----------------
self.batch_size = batch_size
self.nentries = self.io.get_n_entries()
self.randomize = random_access
self.last_entry = 0
self.delivered = 0
self.permuted = None
self.totserved = 0
self.compression_level = 6
self.print_msg_sizes = print_msg_sizes
self.process_croi = process_croi
if process_croi:
# if processing croi, we override the 'batchsize' to be 1,
# i.e. we process one event at a time
self.batch_size = 1
if type(product_dict) is dict:
self.product_dict = product_dict
elif product_dict is None:
pass
else:
raise ValueError(
"product_dict should be a dictionary of {larcv product enum:producer name }"
)
# dictonary used to store event/image data
# -----------------------------------------
self.imgdata_shape = {}
self.imgdata_dict = {}
self.imgmeta_dict = {}
self.batch2rse = None
self.current_rse = None
for ktype, producer_name in self.product_dict.items():
if ktype != larcv.kProductImage2D:
raise RuntimeError(
"Does not support loading product id=%d, currently" %
(ktype))
self.imgdata_shape[(ktype, producer_name)] = None
self.imgdata_dict[(ktype, producer_name)] = None
self.imgmeta_dict[producer_name] = None
# timing trackers to monitor performance
# -----------------------------------------
self._ttracker["getbatch::indexing"] = 0.0
self._ttracker["getbatch::total"] = 0.0
self._ttracker["getbatch::fileio"] = 0.0
self._ttracker["getbatch::fill"] = 0.0
self._ttracker["makemessage::total"] = 0.0
self._ttracker["savereply::total"] = 0.0
if argv == 'plane1':
PLANEID = argv
MODEL = MODELMAP['plane1']
if argv == 'plane2':
PLANEID = argv
MODEL = MODELMAP['plane2']
if not PLANEID or not MODEL:
print 'Valid plane id not provided!'
raise Exception()
INCFG = 'pyana_in_%s.cfg' % PLANEID
print "Using input config:", INCFG
debug = 'debug' in sys.argv
out_proc = larcv.ProcessDriver('OutputProcessDriver')
out_proc.configure(OUTCFG)
py_image_maker = out_proc.process_ptr(out_proc.process_id("PyImageStitcher"))
py_image_maker.set_producer_name('uburn_%s' % PLANEID)
out_proc.override_output_file('larcv_fcn_plane%s.root' % PLANEID)
out_proc.initialize()
in_proc = larcv.ProcessDriver('InputProcessDriver')
in_proc.configure(INCFG)
in_proc.override_input_file(flist)
in_proc.initialize()
cropper = in_proc.process_ptr(in_proc.process_id("WholeImageCropper"))
il._rows = cropper.target_rows()
il._cols = cropper.target_cols()
net = caffe.Net(PROTO, MODEL, caffe.TEST)
args = parser.parse_args(sys.argv[1:])
import ROOT as rt
from ROOT import std
from larcv import larcv
larcv.load_pyutil()
from ublarcvapp import ublarcvapp
from larflow import larflow
rt.gStyle.SetOptStat(0)
inputfiles = std.vector("string")()
for inputfile in args.input_larcv:
inputfiles.push_back(inputfile)
driver = larcv.ProcessDriver("ProcessDriver")
driver.configure(args.config)
driver.override_input_file(inputfiles)
driver.override_ana_file(args.out)
processors = driver.process_map()
tripletmaker = driver.process_ptr(
processors.find("MatchTripletProcessor").second)
driver.initialize()
nentries = driver.io().get_n_entries()
if args.num_events is not None and nentries > args.num_events:
nentries = args.num_events
for ientry in xrange(nentries):
def __init__(self,
broker_address,
larcv_supera_file,
output_larcv_filename,
adc_producer="wire",
input_mode=0,
cropper_cfg=None,
larlite_opreco_file=None,
opflash_producer="simpleFlashBeam",
tick_backwards=False,
sparseout_tree_name="uresnet",
use_compression=False,
use_sparseimg=True,
planes=None,
intimewin_min_tick=190,
intimewin_max_tick=320,
**kwargs):
"""
broker_address [str] IP address and port of broker. e.g.: tcp://my.server.somwhere:6000
larcv_supera_file [str] path to LArCV root file with whole images
output_larcv_filename [str] path to LArCV root where we will write output
adc_producer [str] name of Tree containing input images. e.g. 'wire'
skip_detsplit [bool] if true, process whole image at once. if false, process crops.
opflash_producer [str] name of tree carrying opflash information (used to make CROI from flash) (deprecated)
tick_backwards [bool] if true, expect input LArCV images to be stored in tick-backward format
mrcnn_tree_name [str] name of output tree contaning MRCN
use_compression [bool] if false (default), do not compress byte string sent and received
use_sparseimg [bool] if false (default), do not convert whole image into sparse. otherwisek, do.
To save bytes transferred.
planes [list of int] if not None, only run in the specified planes
intime_min_tick [int] Start of Time window for trigger
intime_max_tick [int] End of Time window for trigger
"""
super(SparseSSNetClient, self).__init__(broker_address, **kwargs)
# setup the input and output larcv iomanager, input larlite manager
tick_direction = larcv.IOManager.kTickForward
if tick_backwards:
tick_direction = larcv.IOManager.kTickBackward
self._input_mode = input_mode
self._use_compression = use_compression
self._cropper_cfg = cropper_cfg
self._planes = planes
if self._input_mode == SparseSSNetClient.SPLIT:
# SPLIT WHOLEVIEW IMAGE
if cropper_cfg == None:
# create config
default_cfg = """ProcessDriver: {
Verbosity: 0
RandomAccess: false
EnableFilter: false
InputFiles: [""]
IOManager: {
IOMode: 2
Name: "larflowinput"
OutFileName: "tmp_out.root"
}
ProcessName: ["ubsplit"]
ProcessType: ["UBSplitDetector"]
ProcessList: {
ubsplit: {
Verbosity: 0
InputProducer:\"%s\"
OutputBBox2DProducer: \"detsplit\"
CropInModule: true
OutputCroppedProducer: \"detsplit\"
BBoxPixelHeight: 512
BBoxPixelWidth: 832
CoveredZWidth: 310
FillCroppedYImageCompletely: true
DebugImage: false
MaxImageS: -1
RandomizeCrops: false
MaxRandomAttempts: 1
MinFracPixelsInCrop: 0.0
}
}
}
""" % (adc_producer)
print(default_cfg, file=open("default_ubsplit.cfg", 'w'))
cropper_cfg = "default_ubsplit.cfg"
self._splitter = larcv.ProcessDriver("ProcessDriver")
self._splitter.configure(cropper_cfg)
infiles = std.vector("std::string")()
infiles.push_back(larcv_supera_file)
self._splitter.override_input_file(infiles)
self._splitter.initialize()
self._inlarcv = self._splitter.io_mutable()
else:
self._inlarcv = larcv.IOManager(larcv.IOManager.kREAD, "",
tick_direction)
self._inlarcv.add_in_file(larcv_supera_file)
self._inlarcv.initialize()
# LARLITE INPUT (used when cropping based on OPFLASH)
self._inlarlite = None
if self._input_mode == SparseSSNetClient.OPFLASH_ROI:
if larlite_opreco_file is None or os.path.exists(
larlite_opreco_file):
raise ValueError(
"larlite opreco file needed or not found when input mode is OPFLASH_ROI"
)
self._inlarlite = LArliteManager(larlite.storage_manager.kREAD)
self._inlarlite.add_in_filename(larlite_opreco_file)
self._inlarlite.open()
#self._inlarlite.set_verbosity(0)
self._outlarcv = larcv.IOManager(larcv.IOManager.kWRITE)
self._outlarcv.set_out_file(output_larcv_filename)
self._outlarcv.set_verbosity(larcv.msg.kDEBUG)
self._outlarcv.initialize()
self._log = logging.getLogger(__name__)
#FixedCROIFromFlash = ublarcvapp.ubdllee.FixedCROIFromFlashAlgo
self._sparseout_tree_name = sparseout_tree_name
self._adc_producer = adc_producer
self._opflash_producer = opflash_producer
self._ubsplitdet = None
# MESSAGES TO LOOKFOR
self._ERROR_NOMSGS = "ERROR:nomessages".encode('utf-8')
def __init__(self,
broker_address,
larcv_supera_file,
output_larcv_filename,
adc_producer="wire",
sparseimage_input_producer="larflow",
sparseimage_output_producer="dualflow",
has_sparseimage_data=False,
save_as_sparseimg=False,
tick_backwards=False,
use_compression=False,
cropper_cfg="ubcrop.cfg",
**kwargs):
"""
this class loads either larcv::sparseimage or larcv::image2d data from
the input file, prepares the data into a binary json (bson) message to
be sent to the broker. when the broker replies with worker output,
save it to larcv root file.
"""
super(UBSparseLArFlowClient, self).__init__(broker_address, **kwargs)
# setup the input iomanager
tick_direction = larcv.IOManager.kTickForward
if tick_backwards:
tick_direction = larcv.IOManager.kTickBackward
# setup splitter: for processing wholeview images
if not has_sparseimage_data:
self.splitter = larcv.ProcessDriver("ProcessDriver")
self.splitter.configure(cropper_cfg)
infiles = std.vector("std::string")()
infiles.push_back(larcv_supera_file)
self.splitter.override_input_file(infiles)
self.splitter.initialize()
self._inlarcv = self.splitter.io_mutable()
else:
self._inlarcv = larcv.IOManager(larcv.IOManager.kREAD, "",
tick_direction)
self._inlarcv.add_in_file(larcv_supera_file)
self._inlarcv.initialize()
# setup output iomanager
self._outlarcv = larcv.IOManager(larcv.IOManager.kWRITE)
self._outlarcv.set_out_file(output_larcv_filename)
self._outlarcv.initialize()
# setup config
self._adc_producer = adc_producer
self._sparseimage_input_producer = sparseimage_input_producer
self._sparseimage_output_producer = sparseimage_output_producer
self._use_sparseimage_data = has_sparseimage_data
self._save_as_sparseimg = save_as_sparseimg
self._use_compression = use_compression
# thresholds: adc values must be above this value to be included
self._threshold_v = std.vector("float")(3, 10.0)
# cuton flag: if pixel passes in the given plane, we save values in all three
# this is required because of the submanifold structure
self._cuton_pixel_v = std.vector("int")(3, 1)
# setup logger
self._log = logging.getLogger(__name__)
from ROOT import std
from larcv import larcv
from ublarcvapp import ublarcvapp
factory = ublarcvapp.dltagger.DLTaggerProcessFactory(
) # load the library, which registers the factory
print factory
inputfiles = std.vector("std::string")()
if type(args.input_larcv) is str:
#inputfiles.push_back( "testset1/out_larcv_test.root" )
inputfiles.push_back(args.input_larcv)
elif type(args.input_larcv) is list:
for f in args.input_larcv:
inputfiles.push_back(f)
driver = larcv.ProcessDriver("DLTagger")
driver.configure(args.config)
driver.override_input_file(inputfiles)
driver.override_output_file(args.out_larcv)
# get processor, add larlite files
processors = driver.process_map()
it_process = processors.find("DLTaggerProcess")
dltagger = driver.process_ptr(it_process.second)
dltagger.add_larlite_infile(args.opreco)
dltagger.set_larlite_outfile(args.out_larlite)
driver.initialize()
nentries = driver.io().get_n_entries()
