Coverage for qhist/v3/core.py : 99%

#!/usr/bin/env python 

# -*- coding: utf-8 -*- 

""" 

Further implementation of QHistV3, providing the descriptor tailored for 

each attribute. 

""" 

from __future__ import absolute_import 

import os 

import types 

import __main__ 

import ROOT 

from datetime import datetime 

from .. import logger, utils 

from ..decorators import ( 

equiplist_nullcheck_typecheck, 

equiplist_typecheck, 

override_getter_default, 

getter_plus_doc, 

setter_isinstance, 

setter_from_return_plus_doc 

) 

from .stats import Stats 

from .anchors import Anchors 

from .wrappers import Wrapper 

from .proto import ProtoQHist 

## 3rd-party 

from PythonCK.decorators import lazy_property, report_debug 

#============================================================================== 

class QHist(ProtoQHist): 

""" 

Provide suite of small test here since most of them are already tested in 

its origin's implementation, just to make sure that the inheritance does not 

interfere with the mechanism. 

Use `prefix` field since it's simplest and has no extra mechanism 

Doctest:: 

## check default 

>>> h = QHist() 

>>> h.prefix is None 

True 

## check assignment 

>>> h.prefix = 'hello' 

>>> h.prefix 

'hello' 

## check static assigment 

>>> h.prefix = 'hola' 

Traceback (most recent call last): 

... 

AttributeError: Attribute "prefix" already set to 'hello' 

## Check slots protection 

>>> h.xxx = 123 

Traceback (most recent call last): 

... 

AttributeError: 'QHist' object has no attribute 'xxx' 

## check copying 

>>> h2 = h() 

>>> h2.prefix 

'hello' 

>>> h2.prefix = 'world' 

Traceback (most recent call last): 

... 

AttributeError: Attribute "prefix" already set to 'hello' 

## check clearing 

>>> h2.clear() 

>>> h2.prefix is None 

True 

>>> h2.prefix = 'hello2' 

>>> h2.prefix 

'hello2' 

""" 

__slots__ = ProtoQHist.__slots__ + ( 

## From lazy_property 

'_lazy_timestamp', 

'_lazy_wrapper', 

'_lazy_filename', 

## New attribute 

'_stats', 

'_anchors', 

'_histos', 

) 

#---------------# 

# Inner methods # 

#---------------# 

def __init__(self, **kwargs): 

""" 

Allow the init with kwargs. 

Doctest:: 

## Assert that two methods are equivalent. 

>>> h1 = QHist(name='somename') 

>>> h1.name 

'somename' 

>>> h2 = QHist() 

>>> h2.name = 'somename' 

>>> h1.name == h2.name 

True 

""" 

## Note: The order below is very important. 

## 1. Super class first 

super(QHist, self).__init__() 

## 2. Initialize local initial value 

self._stats = Stats() 

self._anchors = Anchors() 

self._histos = [] 

## 3. Supplied attributes 

# prefer these first 

fast_tracks = 'tpc', 'trees', 'params' 

for key in fast_tracks: 

if key in kwargs: 

setattr(self, key, kwargs[key]) 

kwargs.pop(key) 

# the rest alphabetically 

for key, val in sorted(kwargs.iteritems()): 

setattr(self, key, val) 

def __call__(self, **kwargs): 

""" 

Override the functionality of copy.copy, such that only the attribute at the 

level of static_struct is transfered, not at QHist level. 

Usage:: 

## Transfer & Independent 

>>> h1 = QHist(name='myname') 

>>> h2 = h1() 

>>> h2.title = 'newtitle' 

>>> h1.name 

'myname' 

>>> h2.name 

'myname' 

""" 

## Prepare queue, list of attrs that existed only in baseclass and used for prop. 

res = self.__class__() 

queue = ProtoQHist.__slots__ 

## Transfer queue 

for key in queue: 

if hasattr(self, key): 

setattr(res, key, getattr(self, key)) 

## Initialize local initial value 

self.__class__.__init__(res, **kwargs) 

## Finally, return 

return res 

## For iterator protocol 

def __len__(self): 

""" 

>>> len(QHist()) 

0 

""" 

return len(self._histos) 

def __getitem__( self, index ): 

""" 

Get the member histograms, available only after draw. 

""" 

return self._histos[index] 

#-----------------------------# 

# Read-only property -- AdHoc # 

#-----------------------------# 

@property 

def has_name(self): 

""" 

Check if name is originally provided or not. 

>>> h = QHist() 

>>> h.has_name 

False 

>>> h.name = 'analysis' 

>>> h.has_name 

True 

""" 

return ProtoQHist.name.fget(self) is not None 

@property 

def is_advance_stack(self): 

""" 

True if TPC stack is advance mode. 

Note to self: This is actually much easier than `is_simple_stack`. 

Doctest:: 

## Default fails 

>>> QHist().is_advance_stack 

False 

## Not-advance, fails 

>>> QHist(params='PT').is_advance_stack 

False 

>>> QHist(trees=tree).is_advance_stack 

False 

>>> QHist(trees=tree, params=['PX','PY']).is_advance_stack 

False 

## Genuine advance TPC 

>>> QHist(tpc=[[tree, 'PT', '']]).is_advance_stack 

True 

>>> QHist(tpc=tpc).is_advance_stack 

True 

""" 

return ProtoQHist.tpc.fget(self) is not None 

@property 

def is_simple_stack(self): 

""" 

True if condition of simple stack is met, i.e., 

only one or less of (trees, params, cuts) is a collection, 

the rest is a single entry. 

Doctest:: 

## Default fails 

>>> QHist().is_simple_stack 

False 

## Incomplete, consider True to disable advance-TPC 

>>> QHist(trees=tree).is_simple_stack 

True 

>>> QHist(params='PT').is_simple_stack 

True 

>>> QHist(cuts='c').is_simple_stack 

True 

## TPC is valid, success 

>>> QHist(trees=tree, params='PT').is_simple_stack 

True 

>>> QHist(trees=[tree,tree], params='PT').is_simple_stack 

True 

>>> QHist(trees=tree, params=['PT','PZ']).is_simple_stack 

True 

## False if already an advance stack 

>>> QHist(tpc=[[tree, 'PT', '']]).is_simple_stack 

False 

""" 

## Require this to avoid circular self.tree, self.params 

if self.is_advance_stack: 

return False 

## Because I already have the setter exclude the multiple-stacking, 

# I have to only check for the empty-inital-condition. 

nt,np,nc = len(self.trees), len(self.params), len(self.cuts) 

return not (nt==0 and np==0 and nc==0) 

@lazy_property 

def filename(self): 

""" 

Return the current filename (without path, nor extension), 

deduce from the script that the instance is made. 

>>> getfixture('mainfile') 

>>> QHist().filename 

'mainfile' 

""" 

return os.path.splitext(os.path.split(__main__.__file__)[-1])[0] 

@property 

def dim(self): 

""" 

Doctest::  

## Default is zero 

>>> QHist().dim 

0 

## Simple TPC 

>>> QHist(params='PT').dim 

1 

>>> QHist(params='PT:PZ').dim 

2 

>>> QHist(params='TMath::Log10(PT)').dim 

1 

>>> QHist(params='TMath::Log10(PT):PZ').dim 

2 

>>> QHist(params='PX:PY:PZ').dim 

3 

>>> QHist(params=('PT:PZ','P:PZ')).dim 

2 

## 'prof' flag does not change the dim 

>>> QHist(params='PX:PY:PZ', options='prof').dim 

3 

## Advance TPC 

>>> QHist(tpc=[(tree, 'PT', '')]).dim 

1 

>>> QHist(tpc=[(tree, 'PX:PY', 'nPVs>1')]).dim 

2 

""" 

tpc = self.tpc 

if len(tpc)==0: # incomplete spec, try params 

if not self.params: 

return 0 

return utils.dim(self.params[0]) 

return utils.dim(tpc[0][1]) 

@property 

def height_legend_console(self): 

""" 

Return expected height of legend console. 

""" 

return 15*(len(self.tpc)+1) 

@property 

def height_debug_console(self): 

"""Return expected height of debug console""" 

return 15*(len(list(self.debug_messages))) 

@property 

def is_profile(self): 

""" 

>>> QHist().is_profile 

False 

>>> QHist(options='prof').is_profile 

True 

>>> QHist(options='blah').is_profile 

False 

>>> QHist(options='sameprof').is_profile 

True 

""" 

return any('prof' in opt for opt in self.options) 

@property 

def debug_messages(self): 

""" 

Generate pair of (header,message) to be put in debug console. 

>>> getfixture('mainfile'); getfixture('freeze_time') 

>>> h = QHist() 

>>> h.trees = tree 

>>> h.params = 'mu_PT: DPHI' 

>>> h.cuts = 'M > 20e3' 

>>> h.xmin = 1 

>>> h.xmax = 100 

>>> h.ymin = 0. 

>>> h.ymax = 3.14 

>>> h.ybin = 20 

>>> h.filters = {'mu_BPVIP<0.1', 'pi_BPVIP<0.1'} 

>>> h.comment = 'trying new optmz' 

>>> for line in h.debug_messages: 

... print('{:12} {:}'.format(*line)) 

Filters (pi_BPVIP<0.1) | (mu_BPVIP<0.1) 

Tree h1_mu [#303] 

Param[0] mu_PT: DPHI 

Cut[0] M > 20e3 

Axis X=[ 1.0, 100.0 ]/Auto=None, Y=[ 0.0, 3.14 ]/20 

Comment trying new optmz 

Timestamp 20200101_000000000000 

Script /mainfile 

""" 

## Filters 

# show raw because it's with AND/OR complexity. 

yield 'Filters', utils.join(self.filters) 

## Trees 

used_names = set() 

for t in self.trees: 

if t: 

tname = t.GetTitle() 

if tname not in used_names: 

used_names.add(tname) 

entries = t.GetEntries() 

yield 'Tree', '{} [#{}]'.format(tname, entries) 

## Params & cuts 

for i,p in enumerate(self.params): 

yield 'Param[%i]'%i, p 

for i,c in enumerate(self.cuts): 

yield 'Cut[%i]'%i, c 

## Axis 

qfirst = utils.prefer_first 

qround = utils.pretty_round 

xmin = qfirst( ProtoQHist.xmin.fget(self), 'Auto=%s'%qround(self.stats.xmin)) 

xmax = qfirst( ProtoQHist.xmax.fget(self), 'Auto=%s'%qround(self.stats.xmax)) 

xbin = qfirst( ProtoQHist.xbin.fget(self), 'Auto=%s'%self.stats.nbin ) 

ymin = qfirst( ProtoQHist.ymin.fget(self), 'Auto=%s'%qround(self.stats.ymin)) 

ymax = qfirst( ProtoQHist.ymax.fget(self), 'Auto=%s'%qround(self.stats.ymax)) 

ybin = qfirst( ProtoQHist.ybin.fget(self), 'Auto=%s'%self.stats.nbin ) 

fmt = 'X=[ {}, {} ]/{}, Y=[ {}, {} ]/{}' 

yield 'Axis', fmt.format( xmin, xmax, xbin, ymin, ymax, ybin ) 

## Misc 

if self.comment: 

yield 'Comment', self.comment 

yield 'Timestamp', self.timestamp 

yield 'Script', os.path.abspath(getattr(__main__, '__file__', '(interactive)')) 

#--------------------------------------------------# 

# Read-only property -- Stored # 

# These has to be explicitly declared in __slots__ # 

#--------------------------------------------------# 

@lazy_property 

def wrapper(self): 

""" 

Once this has been called, it's considered initialized. 

""" 

return Wrapper(self) 

@lazy_property 

def timestamp(self): 

""" 

Lazy-method (to freeze value) of the timestamp string. 

Note: The timestamp is thus made the first time this method is called. 

>>> ## Timestamp should be unique 

>>> h1 = QHist() 

>>> h2 = QHist() 

>>> h1.timestamp == h2.timestamp 

False 

>>> ## ...even for the clones 

>>> h3 = h2() 

>>> h3.timestamp == h2.timestamp 

False 

""" 

return datetime.now().strftime("%Y%m%d_%H%M%S%f") 

@property 

def guessname(self): 

""" 

Specialize method to try to return a good naming, for saving file. 

Note that it only helps in the `name` part if missing. 

It won't concern prefix/suffix, which is why this method should be called 

inside `name` getter. 

>>> ## Ignore the prefix/suffix 

>>> QHist(trees=tree, params='M', prefix='pf', suffix='sf').guessname 

'M' 

>>> ## Ignore scale 

>>> QHist(trees=tree, params='M/1e3').guessname 

'M' 

""" 

## 1. If single param 

queue = list({ p for _,p,_ in self.tpc }) 

if len(queue)==1 and queue[0]: 

res = queue[0] 

else: 

res = None 

## Correction: scale 

# note: this part is similar to safename 

if res: 

res = utils.safename(res) 

## Finally 

return res 

## No public setter available 

@property 

def stats(self): 

""" 

Return the stats object, contains array of statistics (min, max, count) 

for each entry queue in this QHist instance. 

>>> ## Initially is empty stat 

>>> QHist().stats 

<Stats> len=0 nbin=None X=[None, None] 

>>> ## Read-only 

>>> QHist().stats = {} 

Traceback (most recent call last): 

... 

AttributeError: can't set attribute 

""" 

return self._stats 

@property 

def anchors(self): 

""" 

Return the anchor object, which hold 'pointers' to different TObject  

involved in this QHist instance. 

>>> ## Initially empty 

>>> print(QHist().anchors) 

------------------... 

KEY | VALUE ( * differs from default ) 

canvas | None 

debug | None 

debugpad | None 

legend | None 

legendpad | None 

mainpad | None 

stack | None 

----------------------------------------------------... 

>>> ## Read-only 

>>> QHist().anchors = {} 

Traceback (most recent call last): 

... 

AttributeError: can't set attribute 

""" 

return self._anchors 

@property 

def xarr(self): 

""" 

Return the python list representing array of bins in xaxis 

>>> ## uninitialized case 

>>> QHist().xarr is None 

True 

>>> ## Linear bins 

>>> QHist(xmin=0, xmax=10, xbin=4).xarr 

array('d', [0.0, 2.5, 5.0, 7.5, 10.0]) 

>>> ## Logarithmic bins 

>>> QHist(xmin=1, xmax=256, xbin=2).xarr 

array('d', [1.0, 16.0, 256.0]) 

""" 

if any(getattr(self, key) is None for key in ('xmin', 'xmax', 'xbin')): 

return None 

return utils.make_bins( self.xmin, self.xmax, self.xbin, self.xlog ) 

@property 

def yarr(self): 

""" 

>>> QHist().yarr is None 

True 

>>> QHist(ymin=0, ymax=10, ybin=4).yarr 

array('d', [0.0, 2.5, 5.0, 7.5, 10.0]) 

>>> QHist(ymin=1, ymax=256, ybin=2).yarr 

array('d', [1.0, 16.0, 256.0]) 

""" 

if any(getattr(self, key) is None for key in ('ymin', 'ymax', 'ybin')): 

return None 

return utils.make_bins( self.ymin, self.ymax, self.ybin, self.ylog ) 

#-------------------# 

# Overridden getter # 

#-------------------# 

@getter_plus_doc(ProtoQHist.name) 

def name(self): 

""" 

>>> ## final name = prefix + name + suffix 

>>> h = QHist(name='test', prefix='prelim') 

>>> h.name 

'prelim_test' 

>>> h.suffix = 'v0' 

>>> h.name 

'prelim_test_v0' 

>>> ## Default to timestamp, ignoring prefix 

>>> getfixture('freeze_time') 

>>> QHist(prefix='blah').name 

'temp_20200101_000000000000' 

""" 

## Check if there's name, guessing if needed. 

name = ProtoQHist.name.fget(self) 

if not name: 

if self.auto_name: 

name = self.guessname 

else: 

return 'temp_'+self.timestamp 

## Construct the name = prefix + name0 + suffix 

name = utils.concat( self.prefix, name, self.suffix ) 

## Finally, clean name (can be very weird name disturbing the namespace). 

return utils.safename(name) 

@getter_plus_doc(ProtoQHist.title) 

def title(self): 

""" 

>>> ## If title is missing, fallback to name 

>>> h = QHist(name='somename') 

>>> h.title 

'somename' 

>>> ## If given, it's now different from name 

>>> h.title = 'mytitle' 

>>> h.title != h.name 

True 

>>> h.prefix = 'prelim' 

>>> h.title 

'prelim_mytitle' 

>>> ## Title doesn't need safename 

>>> QHist(title='TMath::Abs(phi)').title 

'TMath::Abs(phi)' 

""" 

## Borrow from name immediately if null 

title0 = ProtoQHist.title.fget(self) 

if not title0: 

return self.name 

## Construct the same way as name, but no need for safename. 

# in order to show it entirely on canvas 

return utils.concat( self.prefix, title0, self.suffix ) 

## TPC: Equiplist on default value (None) 

# By equiping, I mean the value is already a list. The check for initial 

# value is then performed on the first element, e.g., self.trees[0] is None 

# - null of trees : None 

# - null of params: blank string 

# - null of cuts : blank string 

# Therefore, their setter has to also guard against there null value. 

@getter_plus_doc(ProtoQHist.trees) 

@override_getter_default 

def trees(self): 

""" 

>>> QHist().trees 

[] 

>>> QHist(tpc=tpc).trees 

[<ROOT.TTree ...>, <ROOT.TTree ...>] 

""" 

if self.is_advance_stack: 

return [t for t,_,_ in self.tpc] 

return [] 

@getter_plus_doc(ProtoQHist.params) 

@override_getter_default 

def params(self): 

""" 

>>> QHist().params 

[] 

>>> QHist(tpc=tpc).params 

['pi_BPVIP', 'mu_BPVIP'] 

""" 

if self.is_advance_stack: 

return [p for _,p,_ in self.tpc] 

return [] 

@getter_plus_doc(ProtoQHist.cuts) 

@override_getter_default 

def cuts(self): 

""" 

>>> QHist().cuts 

[] 

>>> QHist(tpc=tpc).cuts 

['pi_BPVIP > 0', 'mu_BPVIP > 0'] 

""" 

if self.is_advance_stack: 

return [c for _,_,c in self.tpc] 

return [] 

@getter_plus_doc(ProtoQHist.filters) 

@override_getter_default 

def filters(self): 

# return ('',) 

return [] 

@getter_plus_doc(ProtoQHist.tpc) 

@override_getter_default 

def tpc(self): 

""" 

Return current TPC state with given inputs. 

>>> ## Simple TPC, no stacking 

>>> h = QHist(trees=tree, params='p') 

>>> h.tpc 

[(<ROOT.TTree ...>, 'p', '')] 

>>> h.cuts = 'PT>20' 

>>> h.tpc 

[(<ROOT.TTree ...>, 'p', 'PT>20')] 

>>> ## TPC with stacking 

>>> h = QHist(trees=tree, params=['P1', 'P2'], cuts='PT>20') 

>>> h.tpc 

[(<ROOT.TTree ...>, 'P1', 'PT>20'), (<ROOT.TTree ...>, 'P2', 'PT>20')] 

""" 

cuts = self.cuts if self.cuts else [''] # it's optional in TPC formulation 

return [(t,p,c) for t in self.trees for p in self.params for c in cuts] 

@getter_plus_doc(ProtoQHist.normalize) 

def normalize(self): 

""" 

Always return list of matched length with TPC. 

Doctest:: 

## default is tuple of length-0 

>>> QHist().normalize 

() 

## Length to TPC, correct stack level. 

>>> QHist(tpc=tpc, normalize=True).normalize 

(True, True) 

>>> QHist(tpc=tpc, normalize=None).normalize 

(None, None) 

>>> QHist(tpc=tpc, normalize=[154, 100]).normalize 

(154, 100) 

## In some case, TPC is not ready, but norms are given. Show them regardless. 

# The validation will make sure that the length matches. 

>>> QHist(normalize=[154, 100]).normalize 

(154, 100) 

""" 

n0 = ProtoQHist.normalize.fget(self) 

ntpc = len(self.tpc) 

if ntpc == 0: # no TPC, return normally 

return n0 if n0 is not None else tuple() 

elif n0 is None: 

return (True,)*ntpc 

elif len(n0) == ntpc: 

return n0 

return n0*ntpc 

@getter_plus_doc(ProtoQHist.comment) 

@override_getter_default 

def comment(self): 

""" 

No extra logic. 

>>> QHist().comment 

'' 

""" 

return '' 

@getter_plus_doc(ProtoQHist.legends) 

@override_getter_default 

def legends(self): 

""" 

Handles the educated-guess of legends to be used. 

>>> ## From multiple trees/params/cuts 

>>> QHist(trees=(tree,tree), params='P').legends 

('h1_mu', 'h1_mu') 

>>> QHist(trees=tree, params=('P1','P2')).legends 

('P1', 'P2') 

>>> QHist(trees=tree, params='P', cuts=('C1','C2')).legends 

('C1', 'C2') 

>>> ## From advance TPC 

>>> for leg in QHist(tpc=tpc).legends: 

... print leg 

[0] tree='h1_mu', param='pi_BPVIP', cut='pi_BPVIP > 0' 

[1] tree='h1_mu', param='mu_BPVIP', cut='mu_BPVIP > 0' 

""" 

## Do generically for advance stacking 

if self.is_advance_stack: 

res = ["[%i] tree=%r, param=%r, cut=%r"%(i,t.GetName(),p,c) for i,(t,p,c) in enumerate(self.tpc)] 

else: 

res = None 

## Simple stacking guesswork. 

lt = len(self.trees) 

lp = len(self.params) 

lc = len(self.cuts) 

# by trees (REMARK: T >= 1) 

if lt>=1 and lp<=1 and lc<=1: 

## Remove Ganga's prefix. It'll be in debug console later. 

# res = tuple(t.GetTitle().split('::')[-1].split('/')[-1] for t in self.trees) 

# disable backslash in case of genuine usage (GeV/c) 

res = tuple(t.GetTitle().split('::')[-1] for t in self.trees) 

if lt<=1 and lp>1 and lc<=1: # by params 

res = self.params 

if lt<=1 and lp<=1 and lc>1: # by cuts 

res = self.cuts 

return res 

@getter_plus_doc(ProtoQHist.options) 

@override_getter_default 

def options(self): 

""" 

>>> ## default to empty string like ROOT:TTree 

>>> QHist().options 

[''] 

""" 

return [''] 

@getter_plus_doc(ProtoQHist.save_types) 

@override_getter_default 

def save_types(self): 

""" 

>>> ## default to root/pdf 

>>> QHist().save_types 

set(['pdf', 'root']) 

""" 

return {'pdf', 'root'} 

#----------------------------- 

@ProtoQHist.xmin.getter 

@override_getter_default 

def xmin(self): 

return self.stats.xmin 

@ProtoQHist.xmax.getter 

@override_getter_default 

def xmax(self): 

return self.stats.xmax 

@ProtoQHist.xbin.getter 

@override_getter_default 

def xbin(self): 

return self.stats.nbin 

@getter_plus_doc(ProtoQHist.xlog) 

@override_getter_default 

def xlog(self): 

""" 

1. Use explicit value. 

2. Use from explicit bound. 

3. Use from scanned bound. 

>>> QHist().xlog is None 

True 

>>> QHist(xlog=True).xlog 

True 

""" 

val1 = utils.auto_log( self.xmin, self.xmax ) 

val2 = self.stats.xlog 

return utils.prefer_first( val1, val2 ) 

@getter_plus_doc(ProtoQHist.xlabel) 

@override_getter_default 

def xlabel(self): 

""" 

>>> QHist().xlabel 

'' 

>>> QHist(params='P').xlabel # guess 

'P' 

>>> QHist(params='PX:PY').xlabel # guess 

'PX' 

>>> QHist(tpc=[(tree, 'P', '')]).xlabel # guess 

'P' 

>>> QHist(tpc=[(tree, 'P', 'c1'), (tree, 'P', 'c2')]).xlabel # guess 

'P' 

>>> QHist(tpc=tpc).xlabel # complex, don't guess 

'' 

""" 

## Guess from params if it's simple enough. 

l = list(set(self.params)) 

if l and len(l)==1: 

## make sure to return the first dim. 

return utils.split_dim(l[0])[0] 

## Prefer blank string than None for easy SetTitle later 

return '' 

@ProtoQHist.ymin.getter 

@override_getter_default 

def ymin(self): 

return self.stats.ymin 

@ProtoQHist.ymax.getter 

@override_getter_default 

def ymax(self): 

return self.stats.ymax 

@ProtoQHist.ybin.getter 

@override_getter_default 

def ybin(self): 

return self.stats.nbin 

@ProtoQHist.ylog.getter 

@override_getter_default 

def ylog(self): 

val1 = utils.auto_log( self.ymin, self.ymax ) 

val2 = self.stats.ylog 

return utils.prefer_first( val1, val2 ) 

@getter_plus_doc(ProtoQHist.ylabel) 

@override_getter_default 

def ylabel(self): 

""" 

Attempt to guess from the params if it's not ambigious 

>>> QHist().ylabel 

'' 

>>> QHist(params='P').ylabel # not enough dim 

'' 

>>> QHist(params='PX:PY').ylabel # guess 

'PY' 

>>> QHist(tpc=[(tree, 'P', '')]).ylabel # not enough dim 

'' 

>>> QHist(tpc=[(tree, 'PX:PY', '')]).ylabel # guess 

'PY' 

>>> QHist(tpc=tpc).ylabel # complex, don't guess 

'' 

""" 

## Fast check from global dim 

if self.dim < 2: 

return '' 

## Guess from params if it's simple enough. 

l = list(set(self.params)) 

if l and len(l)==1: 

p = l[0] 

if p and utils.dim(p)>=2: 

## make sure to return the first dim. 

return utils.split_dim(p)[1] 

## Prefer blank string than None for easy SetTitle later 

return '' 

@ProtoQHist.zbin.getter 

@override_getter_default 

def zbin(self): 

return self.stats.nbin 

@ProtoQHist.zlog.getter 

@override_getter_default 

def zlog(self): 

return self.stats.zlog 

@getter_plus_doc(ProtoQHist.zlabel) 

@override_getter_default 

def zlabel(self): 

""" 

Attempt to guess from the params if it's not ambigious 

>>> QHist().zlabel 

'' 

>>> QHist(params='P').zlabel # not enough dim 

'' 

>>> QHist(params='PX:PY:PZ').zlabel # guess 

'PZ' 

>>> QHist(tpc=[(tree, 'P', '')]).zlabel # not enough dim 

'' 

>>> QHist(tpc=[(tree, 'PX:PY:PZ', '')], options='prof').zlabel # guess