def make_figures(entry):
from larcv import larcv
larcv.load_pyutil()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={}".format(entry))
global tree
global ioll
tree.GetEntry(entry)
ioll.go_to(entry)
npts = tree.triplet_v.front()._pos_v.size()
pos_v = np.zeros((npts, 4))
for i in xrange(npts):
for j in xrange(3):
pos_v[i, j] = tree.triplet_v.front()._pos_v[i][j]
pos_v[i, 3] = tree.triplet_v.front()._truth_v[i]
print("number of triplet positions: ",
tree.triplet_v.front()._pos_v.size())
trace = {
"type": "scatter3d",
"x": pos_v[:, 0],
"y": pos_v[:, 1],
"z": pos_v[:, 2],
"mode": "markers",
"name": "larmatch",
"marker": {
"color": pos_v[:, 3],
"size": 1,
"opacity": 0.8,
"colorscale": "Viridis"
},
}
cluster_traces_v = [trace]
# MC info to compare
ev_mctrack = ioll.get_data(larlite.data.kMCTrack, "mcreco")
print("number of mctracks: ", ev_mctrack.size())
cluster_traces_v += lardly.data.visualize_larlite_event_mctrack(ev_mctrack)
return detdata.getlines() + cluster_traces_v
def make_figures(entry,
plotby="larmatch",
treename="trueshowerhits",
minprob=-1.0):
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} plot-by={}".format(entry, plotby))
global io
io.go_to(entry)
ev_lfhits = io.get_data(larlite.data.kLArFlow3DHit, treename)
npoints = ev_lfhits.size()
traces_v = []
if plotby == "larmatch":
lfhit_v = [
lardly.data.visualize_larlite_larflowhits(ev_lfhits,
"trueshowerhits",
score_threshold=minprob)
]
traces_v += lfhit_v
elif plotby in ["keypoint"]:
hitindex = 13
xyz = np.zeros((npoints, 4))
ptsused = 0
for ipt in xrange(npoints):
hit = ev_lfhits.at(ipt)
if hit.track_score < minprob:
continue
xyz[ptsused, 0] = hit[0]
xyz[ptsused, 1] = hit[1]
xyz[ptsused, 2] = hit[2]
if plotby == "ssn-class":
idx = np.argmax(np.array((hit[10], hit[11], hit[12])))
xyz[ptsused, 3] = float(idx) / 2.0
else:
xyz[ptsused, 3] = hit[hitindex]
#print(xyz[ptsused,3])
ptsused += 1
print("make hit data[", plotby, "] npts=", npoints,
" abovethreshold(plotted)=", ptsused)
larflowhits = {
"type": "scatter3d",
"x": xyz[:ptsused, 0],
"y": xyz[:ptsused, 1],
"z": xyz[:ptsused, 2],
"mode": "markers",
"name": plotby,
"marker": {
"color": xyz[:ptsused, 3],
"size": 1,
"opacity": 0.8,
"colorscale": 'Viridis'
},
}
traces_v.append(larflowhits)
# PCA
ev_pca = io.get_data(larlite.data.kPCAxis, "truthshower")
pca_v = lardly.data.visualize_event_pcaxis(ev_pca)
traces_v += pca_v
# MC
ev_mcshower = io.get_data(larlite.data.kMCShower, "truthshower")
if ev_mcshower.size() > 0:
for ishower in xrange(ev_mcshower.size()):
shower_traces_v = lardly.data.visualize3d_larlite_mcshower(
ev_mcshower.at(ishower), return_dirplot=True)
traces_v += shower_traces_v[1:]
#traces_v.append( shower_traces_v[1] )
# end of loop over treenames
traces_v += detdata.getlines()
return traces_v
from __future__ import print_function
import os, sys, argparse, json
parser = argparse.ArgumentParser("Plot Keypoint output")
parser.add_argument("input_hits", type=str, help="larflow input")
args = parser.parse_args()
import numpy as np
import ROOT as rt
from larlite import larlite
from larcv import larcv
from larflow import larflow
larcv.SetPyUtil()
import dash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output, State
from dash.exceptions import PreventUpdate
import lardly
color_by_options = ["larmatch"]
colorscale = "Viridis"
option_dict = []
for opt in color_by_options:
option_dict.append({"label": opt, "value": opt})
io = larlite.storage_manager(larlite.storage_manager.kREAD)
io.add_in_filename(args.input_hits)
io.open()
def make_figures(entry, plotby="ssnet", treenames=["pcacluster", "lfshower"]):
from larcv import larcv
larcv.load_pyutil()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} plot-by={}".format(entry, plotby))
global io
io.go_to(entry)
if plotby == "shower":
treenames = ["lfshower"]
elif plotby == "noise":
treenames = ["lfnoise"]
cluster_traces_v = []
for treename in treenames:
evclusters = io.get_data(larlite.data.kLArFlowCluster, treename)
evpcaxis = io.get_data(larlite.data.kPCAxis, treename)
nclusters = evclusters.size()
print("[tree %s] num clusters=%d; num pcaxis=%d" %
(treename, nclusters, evpcaxis.size()))
for icluster in xrange(nclusters):
cluster = evclusters.at(icluster)
nhits = cluster.size()
if plotby in ["ssnet", "cluster", "shower", "noise"]:
pts = larflow.reco.PyLArFlow.as_ndarray_larflowcluster_wssnet(
cluster)
elif plotby == "charge":
pts = larflow.reco.PyLArFlow.as_ndarray_larflowcluster_wcharge(
cluster)
elif plotby == "prob":
pts = larflow.reco.PyLArFlow.as_ndarray_larflowcluster_wprob(
cluster)
elif plotby == "dead":
pts = larflow.reco.PyLArFlow.as_ndarray_larflowcluster_wdeadch(
cluster)
if plotby in ["ssnet", "charge", "prob", "dead"]:
colors = pts[:, 3]
elif plotby in ["cluster", "shower", "noise"]:
r3 = np.random.randint(255, size=3)
colors = "rgb(%d,%d,%d)" % (r3[0], r3[1], r3[2])
clusterplot = {
"type": "scatter3d",
"x": pts[:, 0],
"y": pts[:, 1],
"z": pts[:, 2],
"mode": "markers",
"name": "%s[%d]" % (treename, icluster),
"marker": {
"color": colors,
"size": 1,
"colorscale": colorscale
}
}
cluster_traces_v.append(clusterplot)
# PCA-axis
llpca = evpcaxis.at(icluster)
pca_pts = np.zeros((3, 3))
for i in range(3):
pca_pts[0, i] = llpca.getEigenVectors()[3][i]
pca_pts[1, i] = llpca.getAvePosition()[i]
pca_pts[2, i] = llpca.getEigenVectors()[4][i]
pca_plot = {
"type": "scatter3d",
"x": pca_pts[:, 0],
"y": pca_pts[:, 1],
"z": pca_pts[:, 2],
"mode": "lines",
"name": "%s-pca[%d]" % (treename, icluster),
"line": {
"color": "rgb(255,255,255)",
"size": 2
}
}
cluster_traces_v.append(pca_plot)
# end of loop over treenames
return cluster_traces_v
def make_figures(entry,vtxid,plotby="larmatch",treename="larmatch",minprob=0.0):
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} plot-by={}".format(entry,plotby))
global io
global kpsanatree
io.go_to(entry)
nbytes = kpsanatree.GetEntry(entry)
if nbytes==0:
return []
traces_v = []
if args.draw_flash:
ev_flash = io.get_data(larlite.data.kOpFlash,"simpleFlashBeam")
nflashes = 0
for iflash in range(ev_flash.size()):
flash = ev_flash.at(iflash)
if flash.Time()>2.94 and flash.Time()<4.86:
flash_trace_v = lardly.data.visualize_larlite_opflash_3d( flash )
traces_v += flash_trace_v
nflashes += 1
break
if nflashes==0:
traces_v += lardly.data.visualize_empty_opflash()
# PLOT TRACK PCA-CLUSTERS: FULL/COSMIC
clusters = [("cosmic","trackprojsplit_full","rgb(150,150,150)",True),
("wctrack","trackprojsplit_wcfilter","rgb(0,255,0)",True),
("wcshower","showergoodhit","rgb(255,0,0)",True)]
for (name,producer,rgbcolor,plotme) in clusters:
if not plotme:
continue
ev_cosmic_trackcluster = io.get_data(larlite.data.kLArFlowCluster, producer )
ev_cosmic_pcacluster = io.get_data(larlite.data.kPCAxis, producer )
for icluster in range(ev_cosmic_trackcluster.size()):
lfcluster = ev_cosmic_trackcluster.at( icluster )
cluster_trace = lardly.data.visualize_larlite_larflowhits( lfcluster, name="%s[%d]"%(name,icluster) )
cluster_trace["marker"]["color"] = rgbcolor
cluster_trace["marker"]["opacity"] = 0.5
cluster_trace["marker"]["size"] = 3
traces_v.append(cluster_trace)
pcaxis = ev_cosmic_pcacluster.at( icluster )
pcatrace = lardly.data.visualize_pcaxis( pcaxis )
pcatrace["name"] = "%s-pca[%d]"%(name,icluster)
pcatrace["line"]["color"] = "rgb(0,0,0)"
pcatrace["line"]["width"] = 3
pcatrace["line"]["opacity"] = 1.0
traces_v.append( pcatrace )
# PLOT FITTED TRACK SEGMENTS
lineseg_producer = "trackprojsplit_wcfilter"
ev_lineseg_track = io.get_data( larlite.data.kTrack, lineseg_producer )
print("Number of line-segment tracks: ",ev_lineseg_track.size())
for itrack in range(ev_lineseg_track.size()):
lineseg_track = ev_lineseg_track.at(itrack)
lineseg_trace = lardly.data.visualize_larlite_track( lineseg_track )
traces_v.append( lineseg_trace )
# KEYPOINTS
# ============
ev_keypoints = io.get_data( larlite.data.kLArFlow3DHit, "keypoint" )
ev_kpaxis = io.get_data( larlite.data.kPCAxis, "keypoint" )
# KEYPOINT PLOT: WCFILTER KEYPOINTS
nkp = ev_keypoints.size()
print("Number of reco'd WC-FILTERED Keypoints in event: ",nkp)
for ikp in range(nkp):
kptype = int(ev_keypoints.at(ikp).at(3))
kptrace = {
"type":"scatter3d",
"x": [ev_keypoints[ikp][0]],
"y": [ev_keypoints[ikp][1]],
"z": [ev_keypoints[ikp][2]],
"mode":"markers",
"name":"KP-%s[%d]"%(keypoint_names[kptype],ikp),
"marker":{"color":keypoint_colors[kptype],"size":5,"opacity":0.5},
}
traces_v.append(kptrace)
# PCA-AXIS PLOTS
pca_traces_v = lardly.data.visualize_event_pcaxis( ev_kpaxis, color="rgb(50,50,50)" )
traces_v += pca_traces_v
# KEYPOINT PLOT: COSMIC TRACK KEYPOINT
ev_cosmic_keypoints = io.get_data( larlite.data.kLArFlow3DHit, "keypointcosmic" )
ev_cosmic_kpaxis = io.get_data( larlite.data.kPCAxis, "keypointcosmic" )
nkp = ev_cosmic_keypoints.size()
print("Number of reco'd COSMIC Keypoints in event: ",nkp)
for ikp in range(nkp):
kptype = int(ev_cosmic_keypoints.at(ikp).at(3))
kptrace = {
"type":"scatter3d",
"x": [ev_cosmic_keypoints[ikp][0]],
"y": [ev_cosmic_keypoints[ikp][1]],
"z": [ev_cosmic_keypoints[ikp][2]],
"mode":"markers",
"name":"KP%d"%(ikp),
"marker":{"color":"rgb(0,0,200)","size":5,"opacity":0.5},
}
traces_v.append(kptrace)
# COSMIC PCA-AXIS PLOTS
pca_traces_v = lardly.data.visualize_event_pcaxis( ev_cosmic_kpaxis, color="rgb(50,50,50)" )
traces_v += pca_traces_v
if HAS_MC:
mctrack_v = lardly.data.visualize_larlite_event_mctrack( io.get_data(larlite.data.kMCTrack, "mcreco"), origin=1)
traces_v += mctrack_v
mcshower_v = lardly.data.visualize_larlite_event_mcshower( io.get_data(larlite.data.kMCShower, "mcreco"), return_dirplot=True )
traces_v += mcshower_v
# add detector outline
traces_v += detdata.getlines(color=(10,10,10))
return traces_v
def make_figures(entry, plotby="larmatch", treename="larmatch", minprob=0.3):
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} plot-by={}".format(entry, plotby))
global io
io.go_to(entry)
traces_v = []
# TRACK FROM TrackReco2KP
if False:
ev_tracks = io.get_data(larlite.data.kTrack, "track2kp")
ev_cluster = io.get_data(larlite.data.kLArFlowCluster, "track2kp")
for itrack in range(ev_tracks.size()):
track = ev_tracks.at(itrack)
color = (np.random.randint(0, 256), np.random.randint(0, 256),
np.random.randint(0, 256))
track_trace = lardly.data.visualize_larlite_track(track,
track_id=itrack,
color=color)
track_points = lardly.data.visualize_larlite_larflowhits(
ev_cluster.at(itrack), name="track%d" % (itrack))
traces_v.append(track_trace)
traces_v.append(track_points)
# unused points
ev_unused = io.get_data(larlite.data.kLArFlow3DHit, "track2kpunused")
unused_trace = lardly.data.visualize_larlite_larflowhits(ev_unused,
name="unused")
unused_trace["marker"]["color"] = "rgb(125,125,125)"
unused_trace["marker"]["opacity"] = 0.1
traces_v.append(unused_trace)
# keypoints
if True:
ev_kp = io.get_data(larlite.data.kLArFlow3DHit, "keypoint_bigcluster")
for ikp in range(ev_kp.size()):
kptrace = {
"type": "scatter3d",
"x": [ev_kp[ikp][0]],
"y": [ev_kp[ikp][1]],
"z": [ev_kp[ikp][2]],
"mode": "markers",
"name": "KP%d" % (ikp),
"marker": {
"color": "rgb(255,0,0)",
"size": 5,
"opacity": 0.5
},
}
traces_v.append(kptrace)
ev_kp2 = io.get_data(larlite.data.kLArFlow3DHit,
"keypoint_smallcluster")
for ikp2 in range(ev_kp2.size()):
kptrace = {
"type": "scatter3d",
"x": [ev_kp2[ikp2][0]],
"y": [ev_kp2[ikp2][1]],
"z": [ev_kp2[ikp2][2]],
"mode": "markers",
"name": "KP%d" % (ikp2),
"marker": {
"color": "rgb(0,0,255)",
"size": 5,
"opacity": 0.5
},
}
traces_v.append(kptrace)
# HITS BY SSNET: SHOWER
if False:
ev_showerhit = io.get_data(larlite.data.kLArFlow3DHit, "maxshowerhit")
shower_hit_trace = lardly.data.visualize_larlite_larflowhits(
ev_showerhit, name="showerhit", score_threshold=0.5)
shower_hit_trace["marker"]["color"] = "rgb(255,125,255)"
shower_hit_trace["marker"]["opacity"] = 0.5
traces_v.append(shower_hit_trace)
# HITS BY SSNET: TRACK
if False:
ev_trackhit = io.get_data(larlite.data.kLArFlow3DHit, "maxtrackhit")
track_hit_trace = lardly.data.visualize_larlite_larflowhits(
ev_trackhit, name="trackhit", score_threshold=0.1)
track_hit_trace["marker"]["color"] = "rgb(0,0,255)"
track_hit_trace["marker"]["opacity"] = 0.5
traces_v.append(track_hit_trace)
# SHOWER-KP RECO
if True:
ev_showerkp = io.get_data(larlite.data.kLArFlowCluster, "showerkp")
ev_showerkp_pca = io.get_data(larlite.data.kPCAxis, "showerkp")
print("Number of shower clusters: ", ev_showerkp.size())
for ishr in range(ev_showerkp.size()):
showercluster = ev_showerkp.at(ishr)
showertrace = lardly.data.visualize_larlite_larflowhits(
showercluster, "[%d]shower" % (ishr))
r3 = np.random.randint(255, size=3)
colors = "rgb(%d,%d,%d)" % (r3[0], r3[1], r3[2])
showertrace["marker"]["color"] = colors
showertrace["marker"]["opacity"] = 0.2
traces_v.append(showertrace)
shower_pcatrace_v = lardly.data.visualize_event_pcaxis(ev_showerkp_pca)
for tr in shower_pcatrace_v:
tr["line"]["color"] = "rgb(255,0,0)"
tr["line"]["width"] = 3
tr["line"]["opacity"] = 1.0
traces_v += shower_pcatrace_v
if True:
ev_shower_goodhit = io.get_data(larlite.data.kLArFlowCluster,
"showergoodhit")
ev_shower_goodhit_pca = io.get_data(larlite.data.kPCAxis,
"showergoodhit")
for ishr in range(ev_shower_goodhit.size()):
showercluster = ev_shower_goodhit.at(ishr)
showertrace = lardly.data.visualize_larlite_larflowhits(
showercluster, "[%d]shrgood" % (ishr))
r3 = np.random.randint(255, size=3)
colors = "rgb(%d,%d,%d)" % (r3[0], r3[1], r3[2])
showertrace["marker"]["color"] = colors
showertrace["marker"]["opacity"] = 0.2
traces_v.append(showertrace)
goodhit_pcatrace_v = lardly.data.visualize_event_pcaxis(
ev_shower_goodhit_pca)
for itr, tr in enumerate(goodhit_pcatrace_v):
tr["line"]["color"] = "rgb(150,150,150)"
tr["line"]["width"] = 3
tr["line"]["opacity"] = 1.0
tr["name"] = "[%d]pca-shrgood" % (itr)
traces_v += goodhit_pcatrace_v
if False:
ev_kpshower = io.get_data(larlite.data.kLArFlow3DHit, "showerkp")
ev_showerkp_unused = io.get_data(larlite.data.kLArFlow3DHit,
"showerkpunused")
for ikp in range(ev_kpshower.size()):
kptrace = {
"type": "scatter3d",
"x": [ev_kpshower[ikp][0]],
"y": [ev_kpshower[ikp][1]],
"z": [ev_kpshower[ikp][2]],
"mode": "markers",
"name": "SHR:KP%d" % (ikp),
"marker": {
"color": "rgb(0,0,255)",
"size": 5,
"opacity": 0.5
},
}
traces_v.append(kptrace)
unusedtrace = lardly.data.visualize_larlite_larflowhits(
ev_showerkp_unused, "shrnotused")
unusedtrace["marker"]["color"] = "rgb(125,125,125)"
unusedtrace["marker"]["opacity"] = 0.1
#traces_v.append( unusedtrace )
# TRACK/SHOWER PCA CLUSTER OUTPUT
if True:
# TRACK
treename = "trackprojsplit"
evclusters = io.get_data(larlite.data.kLArFlowCluster, treename)
evpcaxis = io.get_data(larlite.data.kPCAxis, treename)
nclusters = evclusters.size()
print("[tree %s] num clusters=%d; num pcaxis=%d" %
(treename, nclusters, evpcaxis.size()))
for icluster in xrange(nclusters):
cluster = evclusters.at(icluster)
nhits = cluster.size()
print(" [%d] track projection cluster, nhits=%d" %
(icluster, nhits))
clusterplot = lardly.data.visualize_larlite_larflowhits(cluster)
clusterplot["name"] = "[%d]%s" % (icluster, treename)
traces_v.append(clusterplot)
# PCA-axis
llpca = evpcaxis.at(icluster)
pca_pts = np.zeros((3, 3))
for i in range(3):
pca_pts[0, i] = llpca.getEigenVectors()[3][i]
pca_pts[1, i] = llpca.getAvePosition()[i]
pca_pts[2, i] = llpca.getEigenVectors()[4][i]
pca_plot = {
"type": "scatter3d",
"x": pca_pts[:, 0],
"y": pca_pts[:, 1],
"z": pca_pts[:, 2],
"mode": "lines",
"name": "[%d]pca-%s" % (icluster, treename),
"line": {
"color": "rgb(0,0,255)",
"size": 2
}
}
traces_v.append(pca_plot)
if False:
# SHOWER PCA
ev_pcacluster = io.get_data(larlite.data.kLArFlowCluster, "lfshower")
evpcaxis = io.get_data(larlite.data.kPCAxis, "lfshower")
nclusters = ev_pcacluster.size()
print("[tree %s] num shower clusters=%d; num pcaxis=%d" %
("lfshower", nclusters, evpcaxis.size()))
for icluster in xrange(nclusters):
cluster = ev_pcacluster.at(icluster)
nhits = cluster.size()
pts = larflow.reco.PyLArFlow.as_ndarray_larflowcluster_wssnet(
cluster)
r3 = np.random.randint(255, size=3)
colors = "rgb(%d,%d,%d)" % (r3[0], r3[1], r3[2])
clusterplot = {
"type": "scatter3d",
"x": pts[:, 0],
"y": pts[:, 1],
"z": pts[:, 2],
"mode": "markers",
"name": "%s[%d]" % (treename, icluster),
"marker": {
"color": colors,
"size": 1,
"colorscale": colorscale
}
}
traces_v.append(clusterplot)
# PCA-axis
llpca = evpcaxis.at(icluster)
pca_pts = np.zeros((3, 3))
for i in range(3):
pca_pts[0, i] = llpca.getEigenVectors()[3][i]
pca_pts[1, i] = llpca.getAvePosition()[i]
pca_pts[2, i] = llpca.getEigenVectors()[4][i]
pca_plot = {
"type": "scatter3d",
"x": pca_pts[:, 0],
"y": pca_pts[:, 1],
"z": pca_pts[:, 2],
"mode": "lines",
"name": "%s-pca[%d]" % (treename, icluster),
"line": {
"color": "rgb(255,255,255)",
"size": 2
}
}
traces_v.append(pca_plot)
if False:
ev_tracker = io.get_data(larlite.data.kTrack, "pcatracker")
for itrack in range(ev_tracker.size()):
track_trace = lardly.data.visualize_larlite_track(
ev_tracker.at(itrack), itrack, color="rgb(0,0,0)")
traces_v.append(track_trace)
# add detector outline
traces_v += detdata.getlines()
return traces_v
def make_figures(entry, clustername):
"""
if clustername is None return all clusters.
else if string, return specific cluster
"""
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} cluster={}".format(entry, clustername))
global io
global kpsanatree
io.go_to(entry)
traces_v = []
cluster_list = []
plot_producer = None
plot_index = None
if clustername != "all":
plot_producer = clustername.split(":")[0]
plot_index = int(clustername.split(":")[1])
# PLOT TRACK PCA-CLUSTERS: FULL/COSMIC
clusters = [
("cosmic", "trackprojsplit_full", "rgb(150,150,150)", 0.15, False),
("wctrack", "trackprojsplit_wcfilter", "rgb(125,200,125)", 1.0, True),
("wcshower", "showergoodhit", "rgb(200,125,125)", 0.5, False)
]
for (name, producer, rgbcolor, opa, drawme) in clusters:
if not drawme:
continue
ev_trackcluster = io.get_data(larlite.data.kLArFlowCluster, producer)
ev_pcacluster = io.get_data(larlite.data.kPCAxis, producer)
for icluster in range(ev_trackcluster.size()):
lfcluster = ev_trackcluster.at(icluster)
cluster_trace = lardly.data.visualize_larlite_larflowhits(
lfcluster, name="%s[%d]" % (name, icluster))
clabel = "%s:%d (%d hits)" % (producer, icluster, lfcluster.size())
cvalue = "%s:%d" % (producer, icluster)
cluster_list.append({"label": clabel, "value": cvalue})
if clustername != "all":
cluster_trace["marker"]["color"] = "rgb(50,50,50)"
else:
r3 = np.random.randint(255, size=3)
rand_color = "rgb(%d,%d,%d)" % (r3[0], r3[1], r3[2])
cluster_trace["marker"]["color"] = rand_color
cluster_trace["marker"]["opacity"] = opa
cluster_trace["marker"]["width"] = 5.0
pcaxis = ev_pcacluster.at(icluster)
pcatrace = lardly.data.visualize_pcaxis(pcaxis)
pcatrace["name"] = "%s-pca[%d]" % (name, icluster)
pcatrace["line"]["color"] = "rgb(0,0,0)"
pcatrace["line"]["width"] = 1
pcatrace["line"]["opacity"] = 1.0
if plot_producer is not None and plot_producer == producer and plot_index == icluster:
cluster_trace["marker"]["color"] = rgbcolor
traces_v.append(cluster_trace)
traces_v.append(pcatrace)
# add detector outline
traces_v += detdata.getlines(color=(10, 10, 10))
print("Number of clusters in event: ", len(cluster_list))
return traces_v, cluster_list
def make_figures(entry, trackname):
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} trackname={}".format(entry, trackname))
global io
io.go_to(entry)
traces_v = []
if args.draw_flash:
ev_flash = io.get_data(larlite.data.kOpFlash, "simpleFlashBeam")
nflashes = 0
for iflash in range(ev_flash.size()):
flash = ev_flash.at(iflash)
if flash.Time() > 2.94 and flash.Time() < 4.86:
flash_trace_v = lardly.data.visualize_larlite_opflash_3d(flash)
traces_v += flash_trace_v
nflashes += 1
break
if nflashes == 0:
traces_v += lardly.data.visualize_empty_opflash()
# PLOT TRACK PCA-CLUSTERS: FULL/COSMIC
clusters = [("wctrack", "trackprojsplit_wcfilter", "rgb(255,0,255)"),
("wcshower", "showergoodhit", "rgb(255,0,0)")]
for (name, producer, rgbcolor) in clusters:
if args.no_hits:
continue
ev_cosmic_trackcluster = io.get_data(larlite.data.kLArFlowCluster,
producer)
ev_cosmic_pcacluster = io.get_data(larlite.data.kPCAxis, producer)
for icluster in range(ev_cosmic_trackcluster.size()):
lfcluster = ev_cosmic_trackcluster.at(icluster)
cluster_trace = lardly.data.visualize_larlite_larflowhits(
lfcluster, name="%s[%d]" % (name, icluster))
cluster_trace["marker"]["color"] = rgbcolor
cluster_trace["marker"]["opacity"] = 0.3
cluster_trace["marker"]["size"] = 2
traces_v.append(cluster_trace)
pcaxis = ev_cosmic_pcacluster.at(icluster)
pcatrace = lardly.data.visualize_pcaxis(pcaxis)
pcatrace["name"] = "%s-pca[%d]" % (name, icluster)
pcatrace["line"]["color"] = "rgb(0,0,0)"
pcatrace["line"]["width"] = 1
pcatrace["line"]["opacity"] = 1.0
traces_v.append(pcatrace)
# KEYPOINTS
# ============
#ev_keypoints = io.get_data( larlite.data.kLArFlow3DHit, "keypoint" )
#ev_kpaxis = io.get_data( larlite.data.kPCAxis, "keypoint" )
# TRACKS
# ========
tracklist = []
for producer, rgbcolor, width in [("nutrack", "rgb(50,0,100)", 2),
("nutrack_fitted", "rgb(0,200,255)", 5)]:
ev_track = io.get_data(larlite.data.kTrack, producer)
for itrack in xrange(ev_track.size()):
trktrace = lardly.data.visualize_larlite_track(ev_track[itrack])
thistrackname = "nutrack:%02d" % (itrack)
print(producer, ": ", itrack, " len=",
ev_track[itrack].NumberTrajectoryPoints())
trktrace["name"] = "TRK[%d]" % (itrack)
trktrace["line"]["color"] = rgbcolor
trktrace["line"]["width"] = width
trktrace["line"]["opacity"] = 1.0
if producer == "nutrack":
tracklist.append({
"label": thistrackname,
"value": thistrackname
})
if trackname == "all" or trackname == thistrackname:
traces_v.append(trktrace)
tracklist.append({"label": "all", "value": "all"})
if HAS_MC:
mctrack_v = lardly.data.visualize_larlite_event_mctrack(io.get_data(
larlite.data.kMCTrack, "mcreco"),
origin=1)
traces_v += mctrack_v
mcshower_v = lardly.data.visualize_larlite_event_mcshower(
io.get_data(larlite.data.kMCShower, "mcreco"), return_dirplot=True)
traces_v += mcshower_v
# add detector outline
traces_v += detdata.getlines(color=(10, 10, 10))
return traces_v, tracklist
def make_figures(entry,
plotby="larmatch",
treename="larmatch",
keypoint_tree="keypoint",
minprob=0.1):
from larcv import larcv
larcv.load_pyutil()
detdata = lardly.DetectorOutline()
from larflow import larflow
larcv.SetPyUtil()
print("making figures for entry={} plot-by={}".format(entry, plotby))
global io
io.go_to(entry)
lfname = treename
#lfname = "taggerfilterhit" # output of WC filter
#lfname = "ssnetsplit_wcfilter_trackhit" # SSNet split
#lfname = "maxtrackhit_wcfilter"
ev_lfhits = io.get_data(larlite.data.kLArFlow3DHit, lfname)
npoints = ev_lfhits.size()
ev_keypoints = io.get_data(larlite.data.kLArFlow3DHit, keypoint_tree)
ev_kpaxis = io.get_data(larlite.data.kPCAxis, keypoint_tree)
traces_v = []
if plotby == "larmatch":
print("Plotting Hits: produername=", lfname)
lfhit_v = [
lardly.data.visualize_larlite_larflowhits(ev_lfhits,
lfname,
score_threshold=minprob)
]
traces_v += lfhit_v
elif plotby in ["keypoint"]:
hitindex = 13
xyz = np.zeros((npoints, 4))
ptsused = 0
for ipt in xrange(npoints):
hit = ev_lfhits.at(ipt)
if hit.track_score < minprob:
continue
xyz[ptsused, 0] = hit[0]
xyz[ptsused, 1] = hit[1]
xyz[ptsused, 2] = hit[2]
if plotby == "ssn-class":
idx = np.argmax(np.array((hit[10], hit[11], hit[12])))
xyz[ptsused, 3] = float(idx) / 2.0
else:
xyz[ptsused, 3] = hit[hitindex]
#print(xyz[ptsused,3])
ptsused += 1
np.clip(xyz[:, 3], 0, 1.0, out=xyz[:, 3])
print("make hit data[", plotby, "] npts=", npoints,
" abovethreshold(plotted)=", ptsused)
larflowhits = {
"type": "scatter3d",
"x": xyz[:ptsused, 0],
"y": xyz[:ptsused, 1],
"z": xyz[:ptsused, 2],
"mode": "markers",
"name": plotby,
"marker": {
"color": xyz[:ptsused, 3],
"size": 1,
"opacity": 0.8,
"colorscale": 'Viridis'
},
}
traces_v.append(larflowhits)
# KEYPOINT PLOT: WCFILTER KEYPOINTS
nkp = ev_keypoints.size()
print("Number of reco'd WC-FILTERED Keypoints in event: ", nkp)
for ikp in range(nkp):
kptype = int(ev_keypoints.at(ikp).at(3))
kptrace = {
"type": "scatter3d",
"x": [ev_keypoints[ikp][0]],
"y": [ev_keypoints[ikp][1]],
"z": [ev_keypoints[ikp][2]],
"mode": "markers",
"name": "KP%d" % (ikp),
"marker": {
"color": keypoint_colors[kptype],
"size": 5,
"opacity": 0.5
},
}
traces_v.append(kptrace)
# PCA-AXIS PLOTS
pca_traces_v = lardly.data.visualize_event_pcaxis(ev_kpaxis,
color="rgb(50,50,50)")
traces_v += pca_traces_v
# KEYPOINT PLOT: COSMIC TRACK KEYPOINT
ev_cosmic_keypoints = io.get_data(larlite.data.kLArFlow3DHit,
"keypointcosmic")
ev_cosmic_kpaxis = io.get_data(larlite.data.kPCAxis, "keypointcosmic")
nkp = ev_cosmic_keypoints.size()
print("Number of reco'd COSMIC Keypoints in event: ", nkp)
for ikp in range(nkp):
kptype = int(ev_cosmic_keypoints.at(ikp).at(3))
kptrace = {
"type": "scatter3d",
"x": [ev_cosmic_keypoints[ikp][0]],
"y": [ev_cosmic_keypoints[ikp][1]],
"z": [ev_cosmic_keypoints[ikp][2]],
"mode": "markers",
"name": "KP%d" % (ikp),
"marker": {
"color": "rgb(150,150,150)",
"size": 5,
"opacity": 0.5
},
}
traces_v.append(kptrace)
# COSMIC PCA-AXIS PLOTS
pca_traces_v = lardly.data.visualize_event_pcaxis(ev_cosmic_kpaxis,
color="rgb(50,50,50)")
traces_v += pca_traces_v
# end of loop over treenames
traces_v += detdata.getlines()
return traces_v
