Belle II Software development
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
nntd Class Reference
Inheritance diagram for nntd:

Public Member Functions

 param (self, params)
 
 initialize (self)
 
 costotheta (self, x)
 
 getrecovalsold (self, evlist, fitres)
 
 getrecovals (self, evlist, state)
 
 getneurovals (self, evlist, neuro, status="")
 
 gettwodvals (self, evlist, twod)
 
 getswtwodvals (self, evlist, twod)
 
 event (self)
 
 terminate (self)
 
 save (self, filename=None, netname=None, dataname=None)
 
 loadmore (self, filenames)
 
 load (self, filename)
 
 makearray (self, evlist)
 

Public Attributes

 data = None
 
list eventlist = []
 
str networkname = "unspecified net"
 
str dataname = "unspecified runs"
 
str recotracksname = "RecoTracks"
 
str neurotracksname = "TSimNeuroTracks"
 
str hwneurotracksname = "CDCTriggerNeuroTracks"
 
str swneurotracksname = "TRGCDCNeuroTracks"
 
str twodtracksname = "CDCTriggerNNInput2DFinderTracks"
 
str swtwodtracksname = "TRGCDC2DFinderTracks"
 
str etfname = "CDCTriggerNeuroETFT0"
 
str tsname = "CDCTriggerNNInputSegmentHits"
 
 recotracks = Belle2.PyStoreArray(self.recotracksname)
 
 neurotracks = Belle2.PyStoreArray(self.neurotracksname)
 
 hwneurotracks = Belle2.PyStoreArray(self.hwneurotracksname)
 
 swneurotracks = Belle2.PyStoreArray(self.swneurotracksname)
 
 twodtracks = Belle2.PyStoreArray(self.twodtracksname)
 
 swtwodtracks = Belle2.PyStoreArray(self.swtwodtracksname)
 
 ts = Belle2.PyStoreArray(self.tsname)
 
 etf = Belle2.PyStoreObj(self.etfname)
 
list debuglist = []
 

Static Public Attributes

int version = 2
 
int maxtracks = 100
 
dict varnum = {}
 
list nonelist = []
 

Detailed Description

This class represents a dataset.

Definition at line 15 of file nntd.py.

Member Function Documentation

◆ costotheta()

costotheta ( self,
x )

Definition at line 149 of file nntd.py.

149 def costotheta(self, x):
150 import numpy as np # noqa
151 if isinstance(x, list):
152 ret = []
153 for y in x:
154 ret.append(self.costotheta(y))
155 return ret
156 else:
157 ret = None
158 if not x:
159 return None
160 else:
161 if x < -1 or x > 1:
162 x = np.round(x)
163 return 180. / np.pi * np.arccos(x)
164

◆ event()

event ( self)

Definition at line 237 of file nntd.py.

237 def event(self):
238 from ROOT import Belle2, TVector3, XYZVector # noqa
239 # TODO: update the plots every nth time
240 # if self.showplots != 0:
241 # if eventnumber % self.showplots = 0:
242 # show plots
243
244 # loop over events
245 event = []
246 for reco in self.recotracks:
247 track = reco.getRelatedFrom("Tracks")
248
249 fitres = None
250 state = None
251
252 # method should be either 'old' for the old method or anything else for the new one
253 method = 'old'
254
255 if method == 'old':
256 # # old way: ########################################################################
257
258 if not track:
259 print("no track found for recotrack")
260 continue
261 whishPdg = 211 # pion
262 fitres = track.getTrackFitResultWithClosestMass(Belle2.Const.ChargedStable(whishPdg))
263 if not fitres:
264 continue
265 else:
266 # # new way: ########################################################################
267
268 reps = reco.getRepresentations()
269 irep = 0
270 for irep, rep in enumerate(reps):
271 if not reco.wasFitSuccessful(rep):
272 continue
273 try:
274 state = reco.getMeasuredStateOnPlaneClosestTo(XYZVector(0, 0, 0), rep)
275 rep.extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000))
276 except BaseException:
277 continue
278 if not state:
279 continue
280
281
282
283 neuro = reco.getRelatedTo(self.neurotracksname)
284 event.append(self.nonelist.copy())
285 try:
286 neuro = reco.getRelatedTo(self.neurotracksname)
287 except BaseException:
288 neuro = None
289 try:
290 swneuro = reco.getRelatedTo(self.swneurotracksname)
291 except BaseException:
292 swneuro = None
293 try:
294 hwneuro = neuro.getRelatedFrom(self.hwneurotracksname)
295 except BaseException:
296 hwneuro = None
297 try:
298 twod = reco.getRelatedTo(self.twodtracksname)
299 except BaseException:
300 twod = None
301 if method == 'old':
302 event[-1] = self.getrecovalsold(event[-1], fitres)
303 else:
304 event[-1] = self.getrecovals(event[-1], state)
305 event[-1] = self.getneurovals(event[-1], neuro)
306 event[-1] = self.gettwodvals(event[-1], twod)
307 event[-1] = self.getneurovals(event[-1], hwneuro, status="hw")
308 event[-1] = self.getneurovals(event[-1], swneuro, status="sw")
309
310 for neuro in self.neurotracks:
311 # print("neuroloop")
312 # print(len(neuro.getRelationsFrom(self.recotracksname)))
313 if len(neuro.getRelationsFrom(self.recotracksname)) > 0:
314 # this track is already stored in a recoline
315 # print("skipping...")
316 continue
317 event.append(self.nonelist.copy())
318 try:
319 twod = reco.getRelatedTo(self.twodtracksname)
320 except BaseException:
321 twod = None
322 try:
323 hwneuro = neuro.getRelatedFrom(self.hwneurotracksname)
324 except BaseException:
325 hwneuro = None
326 event[-1] = self.getneurovals(event[-1], neuro)
327 event[-1] = self.gettwodvals(event[-1], twod)
328 event[-1] = self.getneurovals(event[-1], hwneuro, status="hw")
329 for swneuro in self.swneurotracks:
330 # print("neuroloop")
331 # print(len(neuro.getRelationsFrom(self.recotracksname)))
332 if len(swneuro.getRelationsFrom(self.recotracksname)) > 0:
333 # this track is already stored in a recoline
334 # print("skipping...")
335 continue
336 event.append(self.nonelist.copy())
337 try:
338 swtwod = reco.getRelatedTo(self.swtwodtracksname)
339 except BaseException:
340 swtwod = None
341 event[-1] = self.getneurovals(event[-1], swneuro, status="sw")
342 event[-1] = self.getswtwodvals(event[-1], swtwod)
343 for twod in self.twodtracks:
344 # print("twodloop")
345 # print(len(twod.getRelationsFrom(self.neurotracksname)))
346 if len(twod.getRelationsFrom(self.neurotracksname)) > 0:
347 # print("skipping...")
348 # this track is already stored in a recoline or twodline
349 continue
350 event.append(self.nonelist.copy())
351 event[-1] = self.gettwodvals(event[-1], twod)
352 for swtwod in self.swtwodtracks:
353 # print("twodloop")
354 # print(len(twod.getRelationsFrom(self.neurotracksname)))
355 if len(swtwod.getRelationsFrom(self.swneurotracksname)) > 0:
356 # print("skipping...")
357 # this track is already stored in a recoline or twodline
358 continue
359 event.append(self.nonelist.copy())
360 event[-1] = self.getswtwodvals(event[-1], swtwod)
361
362 # attach an array for every event
363 if len(event) > self.maxtracks:
364 event = event[0:self.maxtracks]
365 elif len(event) < self.maxtracks:
366 for i in range(self.maxtracks - len(event)):
367 event.append(self.nonelist.copy())
368 self.eventlist.append(event)
369
Belle2::Const::ChargedStable
Provides a type-safe way to pass members of the chargedStableSet set.
Definition Const.h:589

◆ getneurovals()

getneurovals ( self,
evlist,
neuro,
status = "" )

Definition at line 183 of file nntd.py.

183 def getneurovals(self, evlist, neuro, status=""):
184 from ROOT import Belle2 # noqa
185 import numpy as np # noqa
186 pre = status
187 if neuro:
188
189 evlist[self.varnum[pre + "neuroz"][0]] = neuro.getZ0()
190 evlist[self.varnum[pre + "neurotheta"][0]] = self.costotheta(neuro.getCotTheta() / np.sqrt(1 + neuro.getCotTheta()**2))
191 evlist[self.varnum[pre + "neurophi"][0]] = neuro.getPhi0()
192 evlist[self.varnum[pre + "neuropt"][0]] = neuro.getPt()
193 evlist[self.varnum[pre + "neurop"][0]] = neuro.getPt()/np.sin(self.costotheta(neuro.getCotTheta() /
194 np.sqrt(1 + neuro.getCotTheta()**2)))
195 evlist[self.varnum[pre + "neuroval"][0]] = neuro.getValidStereoBit()
196 evlist[self.varnum[pre + "neuroqual"][0]] = neuro.getQualityVector()
197 evlist[self.varnum[pre + "neurots"][0]] = int("".join([str(x) for x in neuro.getTSVector()]))
198 xx = sum([int(i != 0) for i in neuro.getTSVector()][::2])
199 if xx is None:
200 xx = 0
201 evlist[self.varnum[pre + "neuroats"][0]] = xx
202 evlist[self.varnum[pre + "neuroexp"][0]] = neuro.getExpert()
203 evlist[self.varnum[pre + "neurodriftth"][0]] = int("".join([str(int(x)) for x in neuro.getDriftThreshold()]))
204 evlist[self.varnum[pre + "neuroquad"][0]] = neuro.getQuadrant()
205 fpt = 9999
206 for ts in neuro.getRelationsTo(self.tsname):
207 if ts.priorityTime() < fpt:
208 fpt = ts.priorityTime()
209 if self.etf.hasBinnedEventT0(Belle2.Const.CDC):
210 eft = self.etf.getBinnedEventT0(Belle2.Const.CDC)
211 else:
212 eft = None
213
214 # overwrite the etf temporarily with the etfcc
215
216 evlist[self.varnum[pre + "neurofp"][0]] = fpt
217 evlist[self.varnum[pre + "neuroetf"][0]] = eft
218 if pre != "sw":
219 evlist[self.varnum[pre + "neuroetfcc"][0]] = neuro.getETF_unpacked()
220 evlist[self.varnum[pre + "neurohwtime"][0]] = neuro.getETF_recalced()
221 return evlist
222

◆ getrecovals()

getrecovals ( self,
evlist,
state )

Definition at line 174 of file nntd.py.

174 def getrecovals(self, evlist, state):
175 if state:
176 evlist[self.varnum["recoz"][0]] = state.getPos().Z()
177 evlist[self.varnum["recotheta"][0]] = state.getMom().Theta() # self.costotheta(fitres.getMomentum().CosTheta())
178 evlist[self.varnum["recophi"][0]] = state.getMom().Phi()
179 evlist[self.varnum["recopt"][0]] = state.getMom().Pt()
180 evlist[self.varnum["recop"][0]] = state.getMomMag()
181 return evlist
182

◆ getrecovalsold()

getrecovalsold ( self,
evlist,
fitres )

Definition at line 165 of file nntd.py.

165 def getrecovalsold(self, evlist, fitres):
166 if fitres:
167 evlist[self.varnum["recoz"][0]] = fitres.getPosition().Z()
168 evlist[self.varnum["recotheta"][0]] = fitres.getMomentum().Theta() # self.costotheta(fitres.getMomentum().CosTheta())
169 evlist[self.varnum["recophi"][0]] = fitres.getMomentum().Phi()
170 evlist[self.varnum["recopt"][0]] = fitres.getTransverseMomentum()
171 evlist[self.varnum["recop"][0]] = fitres.getMomentum().R()
172 return evlist
173

◆ getswtwodvals()

getswtwodvals ( self,
evlist,
twod )

Definition at line 230 of file nntd.py.

230 def getswtwodvals(self, evlist, twod):
231 if twod:
232 evlist[self.varnum["swtwodphi"][0]] = twod.getPhi0()
233 evlist[self.varnum["swtwodpt"][0]] = twod.getPt()
234 # evlist[self.varnum["twodfot"][0]] = int(twod.getFoundOldTrack())
235 return evlist
236

◆ gettwodvals()

gettwodvals ( self,
evlist,
twod )

Definition at line 223 of file nntd.py.

223 def gettwodvals(self, evlist, twod):
224 if twod:
225 evlist[self.varnum["twodphi"][0]] = twod.getPhi0()
226 evlist[self.varnum["twodpt"][0]] = twod.getPt()
227 # evlist[self.varnum["twodfot"][0]] = int(twod.getFoundOldTrack())
228 return evlist
229

◆ initialize()

initialize ( self)

Definition at line 88 of file nntd.py.

88 def initialize(self):
89 from ROOT import Belle2 # noqa
90 # TODO:
91 # check if folder is present or create it
92 # initialize all plots somehow
93 # initialize filters somehow, so they can be looped over in the evetn function
94 # setup histograms
95 self.data = None
96 self.eventlist = []
97 self.networkname = "unspecified net"
98 self.dataname = "unspecified runs"
99 # TODO
100 # # dict of plots, which should be plotted during the processing and updated every 5000 events.
101 # self.plotdict = {}
102 self.recotracksname = "RecoTracks" # recotracksname
103 # if not hasattr(self, "neurotracksname"):
104 self.neurotracksname = "TSimNeuroTracks" # "TRGCDCNeuroTracks" # neurotracksname
105 self.hwneurotracksname = "CDCTriggerNeuroTracks" # "TRGCDCNeuroTracks" # neurotracksname
106 self.swneurotracksname = "TRGCDCNeuroTracks" # neurotracksname
107 self.twodtracksname = "CDCTriggerNNInput2DFinderTracks" # "TRGCDC2DFinderTracks" # twodtracksname
108 self.swtwodtracksname = "TRGCDC2DFinderTracks" # twodtracksname
109 self.etfname = "CDCTriggerNeuroETFT0"
110 self.tsname = "CDCTriggerNNInputSegmentHits"
111
112 # storearrays
113 self.recotracks = Belle2.PyStoreArray(self.recotracksname)
114 try:
115 self.neurotracks = Belle2.PyStoreArray(self.neurotracksname)
116 except ValueError:
117 self.neurotracks = None
118 try:
119 self.hwneurotracks = Belle2.PyStoreArray(self.hwneurotracksname)
120 except ValueError:
121 self.hwneurotracks = None
122 try:
123 self.swneurotracks = Belle2.PyStoreArray(self.swneurotracksname)
124 except ValueError:
125 self.swneurotracks = None
126 try:
127 self.twodtracks = Belle2.PyStoreArray(self.twodtracksname)
128 except ValueError:
129 self.twodtracks = None
130 try:
131 self.swtwodtracks = Belle2.PyStoreArray(self.swtwodtracksname)
132 except ValueError:
133 self.swtwodtracks = None
134 try:
135 self.ts = Belle2.PyStoreArray(self.tsname)
136 except ValueError:
137 self.ts = None
138 try:
139 self.etf = Belle2.PyStoreObj(self.etfname)
140 except ValueError:
141 self.etf = None
142
143 self.varnum = nntd.varnum
144
145 self.debuglist = []
146# if not self.networkname: self.networknamne = "default"
147# if not self.filename: self.filename = "default.pkl"
148
Belle2::PyStoreArray
A (simplified) python wrapper for StoreArray.
Definition PyStoreArray.h:73
Belle2::PyStoreObj
a (simplified) python wrapper for StoreObjPtr.
Definition PyStoreObj.h:67

◆ load()

load ( self,
filename )

Definition at line 438 of file nntd.py.

438 def load(self, filename):
439 # load a given pickle file
440 f = open(filename, 'rb')
441 savedict = pickle.load(f)
442 f.close()
443 if self.version != savedict["version"]:
444 print("Error! loaded file was made with different version of nntd! exiting ... ")
445 exit()
446 self.eventlist = savedict["eventlist"]
447 self.varnum = savedict["varnum"]
448 self.networkname = savedict["networkname"]
449 self.dataname = savedict["dataname"]
450 # self.eventfilters()
451 self.makearray(self.eventlist)
452

◆ loadmore()

loadmore ( self,
filenames )

Definition at line 398 of file nntd.py.

398 def loadmore(self, filenames):
399 # first, check the amount of events and limit them to NNTD_EVLIMIT
400 evlim = 0
401 evnumber = 0
402 skipev = 0
403 if "NNTD_EVLIMIT" in os.environ:
404 evlim = int(os.environ["NNTD_EVLIMIT"])
405 else:
406 evlim = 50000
407 for i, x in enumerate(filenames):
408 print("checking file: " + str(i) + "/" + str(len(filenames)))
409 f = open(x, 'rb')
410 evnumber += len(pickle.load(f)["eventlist"])
411 if evnumber > evlim:
412 print("total number of available events is " + str(evnumber))
413 skipev = int(evnumber/evlim)
414 print("Number of events more than " + str(evlim) + " only taking every " + str(skipev) + " event")
415 else:
416 skipev = 1
417 for x in filenames:
418 f = open(x, 'rb')
419 savedict = pickle.load(f)
420 f.close()
421 if self.version != savedict["version"]:
422 print("Error! loaded file was made with different version of nntd! exiting ... ")
423 exit()
424 self.networkname = savedict["networkname"]
425 if "dataname" in savedict:
426 self.dataname = savedict["dataname"]
427 templim = evlim-len(self.eventlist)
428 self.eventlist += savedict["eventlist"][::skipev][:templim]
429 self.varnum = savedict["varnum"]
430 print("Loaded file: " + x)
431 print("length of eventlist: " + str(len(self.eventlist)))
432 if evlim <= len(self.eventlist):
433 print("stop loading, maximum event number reached")
434 break
435 self.makearray(self.eventlist)
436 print("all files loaded, array.size: " + str(self.data.size) + ", array.shape: " + str(self.data.shape))
437

◆ makearray()

makearray ( self,
evlist )

Definition at line 453 of file nntd.py.

453 def makearray(self, evlist):
454 import numpy as np # noqa
455 # TODO: apply filters
456 self.data = np.array(evlist)

◆ param()

param ( self,
params )

Definition at line 84 of file nntd.py.

84 def param(self, params):
85 for key, value in params.items():
86 setattr(self, key, value)
87

◆ save()

save ( self,
filename = None,
netname = None,
dataname = None )

Definition at line 378 of file nntd.py.

378 def save(self, filename=None, netname=None, dataname=None):
379 if not filename:
380 filename = self.filename
381 if not netname:
382 netname = self.netname
383 if not dataname:
384 dataname = self.dataname
385 # save the dataset as an array, the corresponding varnum,
386 # and a description about the dataset into a pickle file
387 savedict = {}
388 savedict["eventlist"] = self.eventlist
389 savedict["varnum"] = self.varnum
390 savedict["networkname"] = netname
391 savedict["dataname"] = dataname
392 savedict["version"] = nntd.version
393 f = open(filename, 'wb')
394 pickle.dump(savedict, f)
395 f.close()
396 print('file ' + filename + ' has been saved. ')
397

◆ terminate()

terminate ( self)

Definition at line 370 of file nntd.py.

370 def terminate(self):
371 # self.eventfilters()
372 # self.makearray(self.eventlist)
373 # convert eventlist to data array
374 # initialize histograms and fill them
375 # both save histograms to file and show them in the plots
376 self.save()
377

Member Data Documentation

◆ data

data = None

Definition at line 95 of file nntd.py.

◆ dataname

str dataname = "unspecified runs"

Definition at line 98 of file nntd.py.

◆ debuglist

list debuglist = []

Definition at line 145 of file nntd.py.

◆ etf

etf = Belle2.PyStoreObj(self.etfname)

Definition at line 139 of file nntd.py.

◆ etfname

str etfname = "CDCTriggerNeuroETFT0"

Definition at line 109 of file nntd.py.

◆ eventlist

eventlist = []

Definition at line 96 of file nntd.py.

◆ hwneurotracks

hwneurotracks = Belle2.PyStoreArray(self.hwneurotracksname)

Definition at line 119 of file nntd.py.

◆ hwneurotracksname

str hwneurotracksname = "CDCTriggerNeuroTracks"

Definition at line 105 of file nntd.py.

◆ maxtracks

int maxtracks = 100
static

Definition at line 20 of file nntd.py.

◆ networkname

str networkname = "unspecified net"

Definition at line 97 of file nntd.py.

◆ neurotracks

neurotracks = Belle2.PyStoreArray(self.neurotracksname)

Definition at line 115 of file nntd.py.

◆ neurotracksname

neurotracksname = "TSimNeuroTracks"

Definition at line 104 of file nntd.py.

◆ nonelist

list nonelist = []
static

Definition at line 80 of file nntd.py.

◆ recotracks

recotracks = Belle2.PyStoreArray(self.recotracksname)

Definition at line 113 of file nntd.py.

◆ recotracksname

recotracksname = "RecoTracks"

Definition at line 102 of file nntd.py.

◆ swneurotracks

swneurotracks = Belle2.PyStoreArray(self.swneurotracksname)

Definition at line 123 of file nntd.py.

◆ swneurotracksname

swneurotracksname = "TRGCDCNeuroTracks"

Definition at line 106 of file nntd.py.

◆ swtwodtracks

swtwodtracks = Belle2.PyStoreArray(self.swtwodtracksname)

Definition at line 131 of file nntd.py.

◆ swtwodtracksname

str swtwodtracksname = "TRGCDC2DFinderTracks"

Definition at line 108 of file nntd.py.

◆ ts

ts = Belle2.PyStoreArray(self.tsname)

Definition at line 135 of file nntd.py.

◆ tsname

tsname = "CDCTriggerNNInputSegmentHits"

Definition at line 110 of file nntd.py.

◆ twodtracks

twodtracks = Belle2.PyStoreArray(self.twodtracksname)

Definition at line 127 of file nntd.py.

◆ twodtracksname

str twodtracksname = "CDCTriggerNNInput2DFinderTracks"

Definition at line 107 of file nntd.py.

◆ varnum

dict varnum = {}
static

Definition at line 22 of file nntd.py.

◆ version

int version = 2
static

Definition at line 19 of file nntd.py.

The documentation for this class was generated from the following file: