| # Gaudi Framework, version v21r6 |

Home |  | Generated: 11 Nov 2009

# GaudiPython::HistoUtils Namespace Reference

## Classes
class | HistoFile
## Functions
def | _getAppMgr
| Helper private auxiliary function to get Application Manager.
def | _getHistoSvc
| Helper private auxiliary function to get iHistogramSvs.
def | _getEvtSvc
| Helper private auxiliary function to get iDataSvs.
def | book
| The trivial function to book the various 1D,2D&3D-histograms.
def | bookProf
| The trivial function to book 1D&2D profile histograms:.
def | getAsAIDA
| The most trivial function to retrieve the histogram from Histogram Transient Store.
def | getAsROOT
| The most trivial function to retrieve the histogram from Histogram Transient Store.
def | fill
| The function which allows 'the smart fill' of 1D-histogram.
def | _to_root_
| Convert AIDA to ROOT.
def | _moment_
| Evaluate 'bin-by-bin' momentum of certain order around the value.
def | _momentErr_
| Evaluate error in 'bin-by-bin' momentum of certain order around the value.
def | _centralMoment_
| Evaluate 'bin-by-bin' central momentum (around mean value).
def | _centralMomentErr_
| Evaluate error in 'bin-by-bin' momentum of certain order around the value.
def | _skewness_
| Evaluate 'bin-by-bin' skewness for 1D histogram.
def | _skewnessErr_
| Evaluate error for 'bin-by-bin' skewness for 1D histogram.
def | _kurtosis_
| Evaluate 'bin-by-bin' kurtosis for 1D histogram.
def | _kurtosisErr_
| Evaluate error for 'bin-by-bin' kurtosis for 1D histogram.
def | _nEff_
def | _mean_
def | _meanErr_
def | _rms_
def | _rmsErr_
def | _sumBinHeightErr_
def | _sumAllBinHeightErr_
def | _overflowEntriesFrac_
def | _overflowEntriesFracErr_
def | _underflowEntriesFrac_
def | _underflowEntriesFracErr_
def | _overflowIntegralFrac_
def | _overflowIntegralFracErr_
def | _underflowIntegralFrac_
def | _underflowIntegralFracErr_
def | _nEntries_
| get number of entries in histogram up to the certain bin (not-included) get number of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)
def | _nEntriesFrac_
def | _nEntriesFracErr_
def | _path_
| ============================================================================
def | __dumpHisto__
| =============================================================================
## Variables
string | __author__ = "Vanya BELYAEV ibelyaev@physics.syr.edu"
| This module contains set of simple and useful utilities for booking and manipulations with Gaudi-AIDA histograms, inspired by Thomas' request.
tuple | __all__
| HID = cpp.GaudiAlg.ID
| aida2root = cpp.Gaudi.Utils.Aida2ROOT.aida2root
| AIDA -> ROOT converter.
| HistoStats = cpp.Gaudi.Utils.HistoStats
| i1DH = cpp.AIDA.IHistogram1D
| iBH = cpp.AIDA.IBaseHistogram
| histoDump = __dumpHisto__
| the actual function for text dump of the histogram
| dumpHisto = __dumpHisto__

## Function Documentation

def GaudiPython::HistoUtils::__dumpHisto__ | ( |  | histo,
|  |  | args |
| ) |  |  |

=============================================================================

    Dump the histogram/profile in text format (a'la HBOOK)

    >>> histo
    >>> print dumpHisto ( histo )

    >>> print histo.dump()
    >>> print histo.dump( 20 , 20 )
    >>> print histo.dump( 20 , 20 , True )

    Uses:

Definition at line 754 of file HistoUtils.py.

    00754                                     :
    00755     """
    00756
    00757     Dump the histogram/profile in text format (a'la HBOOK)
    00758
    00759     >>> histo
    00760     >>> print dumpHisto ( histo )
    00761
    00762     >>> print histo.dump()
    00763     >>> print histo.dump( 20 , 20 )
    00764     >>> print histo.dump( 20 , 20 , True )
    00765
    00766     Uses:
    00767
    00768     """
    00769     return cpp.Gaudi.Utils.Histos.histoDump ( histo , *args )
    00770
    __dumpHisto__ .__doc__ = '\n'  + cpp.Gaudi.Utils.Histos.histoDump . __doc__

def GaudiPython::HistoUtils::_centralMoment_ | ( |  | self,
|  |  | order |
| ) |  |  | `[private]`

Evaluate 'bin-by-bin' central momentum (around mean value).

    Evaluate 'bin-by-bin' central momentum (around mean value)
    for 1D histogram

    >>> h1 = ...
    >>> print h1.centralMoment ( 5 )

Definition at line 478 of file HistoUtils.py.

    00478                                      :
    00479     """
    00480     Evaluate 'bin-by-bin' central momentum (around mean value)
    00481     for 1D histogram
    00482
    00483     >>> h1 = ...
    00484     >>> print h1.centralMoment ( 5 )
    00485
    00486     """
    00487     return HistoStats.centralMoment ( self , order )
    00488
    00489 # =============================================================================
    ## Evaluate error in 'bin-by-bin' momentum of certain order around the value

def GaudiPython::HistoUtils::_centralMomentErr_ | ( |  | self,
|  |  | order |
| ) |  |  | `[private]`

Evaluate error in 'bin-by-bin' momentum of certain order around the value.

    Evaluate error for 'bin-by-bin' central momentum (around mean value)
    for 1D histogram

    >>> h1 = ...
    >>> print h1.centralMomentErr ( 5 )

Definition at line 491 of file HistoUtils.py.

    00491                                         :
    00492     """
    00493     Evaluate error for 'bin-by-bin' central momentum (around mean value)
    00494     for 1D histogram
    00495
    00496     >>> h1 = ...
    00497     >>> print h1.centralMomentErr ( 5 )
    00498
    00499     """
    00500     return HistoStats.centralMomentErr ( self , order )
    00501
    00502 # =============================================================================
    ## Evaluate 'bin-by-bin' skewness for 1D histogram

def GaudiPython::HistoUtils::_getAppMgr | ( |  | kwargs | ) | `[private]`

Helper private auxiliary function to get Application Manager.

    Helper private auxiliary function to get Application Manager

Definition at line 51 of file HistoUtils.py.

    00051                                :
    00052     """
    00053     Helper private auxiliary function to get Application Manager
    00054     """
    00055     gaudi = kwargs.get ( 'gaudi' , None )
    00056     if not gaudi : gaudi = AppMgr()
    00057     if not gaudi : raise RuntimeError, 'Unable to get valid ApplicationMgr'
    00058     return gaudi                                               ## RETURN
    00059
    00060 # =============================================================================
    ## Helper private auxiliary function to get iHistogramSvs

def GaudiPython::HistoUtils::_getEvtSvc | ( |  | kwargs | ) | `[private]`

Helper private auxiliary function to get iDataSvs.

    Helper private auxiliary function to get iDataSvs

Definition at line 74 of file HistoUtils.py.

    00074                             :
    00075     """
    00076     Helper private auxiliary function to get iDataSvs
    00077     """
    00078     svc = kwargs.get ( 'service' , None )
    00079     if not svc : svc = kwargs.get ( 'svc' , None )
    00080     else       : return svc                                    ## RETURN
    00081     gaudi = _getAppMgr ( **kwargs )
    00082     return gaudi.evtsvc()                                      ## RETURN
    00083
    00084 # =============================================================================
    ## The trivial function to book the various 1D,2D&3D-histograms

def GaudiPython::HistoUtils::_getHistoSvc | ( |  | kwargs | ) | `[private]`

Helper private auxiliary function to get iHistogramSvs.

    Helper private auxiliary function to get iHistogramSvs

Definition at line 62 of file HistoUtils.py.

    00062                               :
    00063     """
    00064     Helper private auxiliary function to get iHistogramSvs
    00065     """
    00066     svc = kwargs.get ( 'service' , None )
    00067     if not svc : svc = kwargs.get ( 'svc' , None )
    00068     else       : return svc                                    ## RETURN
    00069     gaudi = _getAppMgr ( **kwargs )
    00070     return gaudi.histsvc ()                                    ## RETURN
    00071
    00072 # =============================================================================
    ## Helper private auxiliary function to get iDataSvs

def GaudiPython::HistoUtils::_kurtosis_ | ( |  | self | ) | `[private]`

Evaluate 'bin-by-bin' kurtosis for 1D histogram.

    Evaluate 'bin-by-bin' kurtosis for 1D histogram

    >>> h1 = ...
    >>> print h1.kurtosis ()

Definition at line 528 of file HistoUtils.py.

    00528                         :
    00529     """
    00530     Evaluate 'bin-by-bin' kurtosis for 1D histogram
    00531
    00532     >>> h1 = ...
    00533     >>> print h1.kurtosis ()
    00534
    00535     """
    00536     return HistoStats.kurtosis ( self )
    00537
    00538 # =============================================================================
    ## Evaluate error for 'bin-by-bin' kurtosis for 1D histogram

def GaudiPython::HistoUtils::_kurtosisErr_ | ( |  | self | ) | `[private]`

Evaluate error for 'bin-by-bin' kurtosis for 1D histogram.

    Evaluate error for 'bin-by-bin' kurtotis for 1D histogram

    >>> h1 = ...
    >>> print h1.kurtotisErr()

Definition at line 540 of file HistoUtils.py.

    00540                            :
    00541     """
    00542     Evaluate error for 'bin-by-bin' kurtotis for 1D histogram
    00543
    00544     >>> h1 = ...
    00545     >>> print h1.kurtotisErr()
    00546
    00547     """
    00548     return HistoStats.kurtosisErr ( self )
    00549
    00550 # =============================================================================
    def _nEff_    ( self ) :

def GaudiPython::HistoUtils::_mean_ | ( |  | self | ) | `[private]`

    Evaluate the MEAN value

Definition at line 557 of file HistoUtils.py.

    00557                        :
    00558     """
    00559     Evaluate the MEAN value
    00560     """
    00561     return HistoStats.mean ( self )
    00562 # =============================================================================
    def _meanErr_ ( self ) :

def GaudiPython::HistoUtils::_meanErr_ | ( |  | self | ) | `[private]`

    Evaluate the error for MEAN estimate

Definition at line 563 of file HistoUtils.py.

    00563                        :
    00564     """
    00565     Evaluate the error for MEAN estimate
    00566     """
    00567     return HistoStats.meanErr ( self )
    00568
    00569 # =============================================================================
    def _rms_    ( self ) :

def GaudiPython::HistoUtils::_moment_ | ( |  | self,
|  |  | order,
|  |  | value = `0` |
| ) |  |  | `[private]`

Evaluate 'bin-by-bin' momentum of certain order around the value.

    Evaluate 'bin-by-bin' momentum of order 'order' around the value 'value'
    for 1D histogram

    >>> h1 = ...
    >>> print h1.moment ( 5 )

Definition at line 453 of file HistoUtils.py.

    00453                                           :
    00454     """
    00455     Evaluate 'bin-by-bin' momentum of order 'order' around the value 'value'
    00456     for 1D histogram
    00457
    00458     >>> h1 = ...
    00459     >>> print h1.moment ( 5 )
    00460
    00461     """
    00462     return HistoStats.moment ( self , order , value )
    00463
    00464 # =============================================================================
    ## Evaluate error in 'bin-by-bin' momentum of certain order around the value

def GaudiPython::HistoUtils::_momentErr_ | ( |  | self,
|  |  | order |
| ) |  |  | `[private]`

Evaluate error in 'bin-by-bin' momentum of certain order around the value.

    Evaluate error for 'bin-by-bin' momentum of order 'order' around the value 'value'
    for 1D histogram

    >>> h1 = ...
    >>> print h1.momentErr ( 5 )

Definition at line 466 of file HistoUtils.py.

    00466                                  :
    00467     """
    00468     Evaluate error for 'bin-by-bin' momentum of order 'order' around the value 'value'
    00469     for 1D histogram
    00470
    00471     >>> h1 = ...
    00472     >>> print h1.momentErr ( 5 )
    00473
    00474     """
    00475     return HistoStats.momentErr ( self , order )
    00476 # =============================================================================
    ## Evaluate 'bin-by-bin' central momentum (around mean value)

def GaudiPython::HistoUtils::_nEff_ | ( |  | self | ) | `[private]`

    Number of equivalent entries

Definition at line 551 of file HistoUtils.py.

    00551                        :
    00552     """
    00553     Number of equivalent entries
    00554     """
    00555     return HistoStats.nEff ( self )
    00556 # =============================================================================
    def _mean_    ( self ) :

def GaudiPython::HistoUtils::_nEntries_ | ( |  | self,
|  |  | i1,
|  |  | i2 = `-10000000` |
| ) |  |  | `[private]`

get number of entries in histogram up to the certain bin (not-included) get number of entries in histogram form the certain minimal bin up to the certain maximal bin (not-included)

    Get number of entries in histogram up to  the certain bin (not-included)

    attention: underflow bin is included!

    >>> h1
    >>> print h1.nEntries ( 10 )

    Get number of entries in histogram form the certain
    minimal bin up to the certain maximal bin (not-included)

    >>> h1
    >>> print h1.nEntries ( 10 , 15 )

Definition at line 648 of file HistoUtils.py.

    00648                                               :
    00649     """
    00650     Get number of entries in histogram up to  the certain bin (not-included)
    00651
    00652     attention: underflow bin is included!
    00653
    00654     >>> h1
    00655     >>> print h1.nEntries ( 10 )
    00656
    00657     Get number of entries in histogram form the certain
    00658     minimal bin up to the certain maximal bin (not-included)
    00659
    00660     >>> h1
    00661     >>> print h1.nEntries ( 10 , 15 )
    00662
    00663     """
    00664     if  i2 < i1 or i2 < 0 : return HistoStats.nEntries ( self , i1 )
    00665     return HistoStats.nEntries ( self , i1 , i2 )
    00666 # =============================================================================
    def _nEntriesFrac_ ( self , i1 , i2 = -10000000 ) :

def GaudiPython::HistoUtils::_nEntriesFrac_ | ( |  | self,
|  |  | i1,
|  |  | i2 = `-10000000` |
| ) |  |  | `[private]`

    Get the fraction of entries in histogram up to  the certain bin (not-included)

    attention: underflow bin is included!

    >>> h1
    >>> print h1.nEntriesFrac ( 10 )

    Get the fraction of entries in histogram form the certain
    minimal bin up to the certain maximal bin (not-included)

    >>> h1
    >>> print h1.nEntriesFrac ( 10 , 15 )

Definition at line 667 of file HistoUtils.py.

    00667                                                   :
    00668     """
    00669     Get the fraction of entries in histogram up to  the certain bin (not-included)
    00670
    00671     attention: underflow bin is included!
    00672
    00673     >>> h1
    00674     >>> print h1.nEntriesFrac ( 10 )
    00675
    00676     Get the fraction of entries in histogram form the certain
    00677     minimal bin up to the certain maximal bin (not-included)
    00678
    00679     >>> h1
    00680     >>> print h1.nEntriesFrac ( 10 , 15 )
    00681
    00682     """
    00683     if  i2 < i1 or i2 < 0 : return HistoStats.nEntriesFrac ( self , i1 )
    00684     return HistoStats.nEntriesFrac ( self , i1 , i2 )
    00685 # =============================================================================
    def _nEntriesFracErr_ ( self , i1 , i2 = -10000000 ) :

def GaudiPython::HistoUtils::_nEntriesFracErr_ | ( |  | self,
|  |  | i1,
|  |  | i2 = `-10000000` |
| ) |  |  | `[private]`

    Get error for  fraction of entries in histogram up to  the certain bin (not-included)

    attention: underflow bin is included!

    >>> h1
    >>> print h1.nEntriesFracErr( 10 )

    Get error  fraction of entries in histogram form the certain
    minimal bin up to the certain maximal bin (not-included)

    >>> h1
    >>> print h1.nEntriesFracErr ( 10 , 15 )

Definition at line 686 of file HistoUtils.py.

    00686                                                      :
    00687     """
    00688     Get error for  fraction of entries in histogram up to  the certain bin (not-included)
    00689
    00690     attention: underflow bin is included!
    00691
    00692     >>> h1
    00693     >>> print h1.nEntriesFracErr( 10 )
    00694
    00695     Get error  fraction of entries in histogram form the certain
    00696     minimal bin up to the certain maximal bin (not-included)
    00697
    00698     >>> h1
    00699     >>> print h1.nEntriesFracErr ( 10 , 15 )
    00700
    00701     """
    00702     if  i2 < i1 or i2 < 0 : return HistoStats.nEntriesFracErr ( self , i1 )
    00703     return HistoStats.nEntriesFracErr ( self , i1 , i2 )
    00704
    00705 # =============================================================================
    i1DH = cpp.AIDA.IHistogram1D

def GaudiPython::HistoUtils::_overflowEntriesFrac_ | ( |  | self | ) | `[private]`

    The fraction of overflow entries  (useful for shape comparison)

Definition at line 595 of file HistoUtils.py.

    00595                                        :
    00596     """
    00597     The fraction of overflow entries  (useful for shape comparison)
    00598     """
    00599     return HistoStats.overflowEntriesFrac     ( self )
    00600 # =============================================================================
    def _overflowEntriesFracErr_  ( self ) :

def GaudiPython::HistoUtils::_overflowEntriesFracErr_ | ( |  | self | ) | `[private]`

    The error for fraction of overflow entries  (useful for shape comparison)

Definition at line 601 of file HistoUtils.py.

    00601                                        :
    00602     """
    00603     The error for fraction of overflow entries  (useful for shape comparison)
    00604     """
    00605     return HistoStats.overflowEntriesFracErr  ( self )
    00606 # =============================================================================
    def _underflowEntriesFrac_    ( self ) :

def GaudiPython::HistoUtils::_overflowIntegralFrac_ | ( |  | self | ) | `[private]`

    The fraction of overflow integral  (useful for shape comparison)

Definition at line 620 of file HistoUtils.py.

    00620                                         :
    00621     """
    00622     The fraction of overflow integral  (useful for shape comparison)
    00623     """
    00624     return HistoStats.overflowIntegralFrac     ( self )
    00625 # =============================================================================
    def _overflowIntegralFracErr_  ( self ) :

def GaudiPython::HistoUtils::_overflowIntegralFracErr_ | ( |  | self | ) | `[private]`

    The error for fraction of overflow integral  (useful for shape comparison)

Definition at line 626 of file HistoUtils.py.

    00626                                         :
    00627     """
    00628     The error for fraction of overflow integral  (useful for shape comparison)
    00629     """
    00630     return HistoStats.overflowIntegralFracErr  ( self )
    00631 # =============================================================================
    def _underflowIntegralFrac_    ( self ) :

def GaudiPython::HistoUtils::_path_ | ( |  | self | ) | `[private]`

============================================================================

    Get the path in THS for the given AIDA object:

    >>> aida =
    >>> print aida.path()

Definition at line 737 of file HistoUtils.py.

    00737                     :
    00738     """
    00739     Get the path in THS for the given AIDA object:
    00740
    00741     >>> aida =
    00742     >>> print aida.path()
    00743
    00744     """
    00745     return cpp.Gaudi.Utils.Histos.path ( self )
    00746
    iBH = cpp.AIDA.IBaseHistogram

def GaudiPython::HistoUtils::_rms_ | ( |  | self | ) | `[private]`

    Evaluate the RMS

Definition at line 570 of file HistoUtils.py.

    00570                       :
    00571     """
    00572     Evaluate the RMS
    00573     """
    00574     return HistoStats.rms ( self )
    00575 # =============================================================================
    def _rmsErr_ ( self ) :

def GaudiPython::HistoUtils::_rmsErr_ | ( |  | self | ) | `[private]`

    Evaluate the error for RMS estimate

Definition at line 576 of file HistoUtils.py.

    00576                       :
    00577     """
    00578     Evaluate the error for RMS estimate
    00579     """
    00580     return HistoStats.rmsErr ( self )
    00581
    00582 # =============================================================================
    def _sumBinHeightErr_    ( self ) :

def GaudiPython::HistoUtils::_skewness_ | ( |  | self | ) | `[private]`

Evaluate 'bin-by-bin' skewness for 1D histogram.

    Evaluate 'bin-by-bin' skewness for 1D histogram

    >>> h1 = ...
    >>> print h1.skewness()

Definition at line 504 of file HistoUtils.py.

    00504                         :
    00505     """
    00506     Evaluate 'bin-by-bin' skewness for 1D histogram
    00507
    00508     >>> h1 = ...
    00509     >>> print h1.skewness()
    00510
    00511     """
    00512     return HistoStats.skewness ( self )
    00513
    00514 # =============================================================================
    ## Evaluate error for 'bin-by-bin' skewness for 1D histogram

def GaudiPython::HistoUtils::_skewnessErr_ | ( |  | self | ) | `[private]`

Evaluate error for 'bin-by-bin' skewness for 1D histogram.

    Evaluate error for 'bin-by-bin' skewness for 1D histogram

    >>> h1 = ...
    >>> print h1.skewnessErr()

Definition at line 516 of file HistoUtils.py.

    00516                            :
    00517     """
    00518     Evaluate error for 'bin-by-bin' skewness for 1D histogram
    00519
    00520     >>> h1 = ...
    00521     >>> print h1.skewnessErr()
    00522
    00523     """
    00524     return HistoStats.skewnessErr ( self )
    00525
    00526 # =============================================================================
    ## Evaluate 'bin-by-bin' kurtosis for 1D histogram

def GaudiPython::HistoUtils::_sumAllBinHeightErr_ | ( |  | self | ) | `[private]`

    Get an error in the sum bin height ('in-range integral')

Definition at line 590 of file HistoUtils.py.

    00590                                   :
    00591     """ Get an error in the sum bin height ('in-range integral') """
    00592     return HistoStats.sumAllBinHeightErr ( self )
    00593
    00594 # =============================================================================
    def _overflowEntriesFrac_     ( self ) :

def GaudiPython::HistoUtils::_sumBinHeightErr_ | ( |  | self | ) | `[private]`

    Get an error in the sum bin height ('in-range integral')

Definition at line 583 of file HistoUtils.py.

    00583                                   :
    00584     """
    00585     Get an error in the sum bin height ('in-range integral')
    00586     """
    00587     return HistoStats.sumBinHeightErr ( self )
    00588
    00589 # =============================================================================
    def _sumAllBinHeightErr_ ( self ) :

def GaudiPython::HistoUtils::_to_root_ | ( |  | self | ) | `[private]`

Convert AIDA to ROOT.

    Convert AIDA to ROOT

    >>> aida = ...            ## get AIDA histogram
    >>> root = aida.toROOT()  ## convert it to ROOT

Definition at line 424 of file HistoUtils.py.

    00424                        :
    00425     """
    00426     Convert AIDA to ROOT
    00427
    00428     >>> aida = ...            ## get AIDA histogram
    00429     >>> root = aida.toROOT()  ## convert it to ROOT
    00430
    00431     """
    00432     return aida2root ( self )
    00433
    _to_root_ . __doc__  += aida2root . __doc__

def GaudiPython::HistoUtils::_underflowEntriesFrac_ | ( |  | self | ) | `[private]`

    The fraction of underflow entries  (useful for shape comparison)

Definition at line 607 of file HistoUtils.py.

    00607                                        :
    00608     """
    00609     The fraction of underflow entries  (useful for shape comparison)
    00610     """
    00611     return HistoStats.underflowEntriesFrac    ( self )
    00612 # =============================================================================
    def _underflowEntriesFracErr_ ( self ) :

def GaudiPython::HistoUtils::_underflowEntriesFracErr_ | ( |  | self | ) | `[private]`

    The error for fraction of underflow entries  (useful for shape comparison)

Definition at line 613 of file HistoUtils.py.

    00613                                        :
    00614     """
    00615     The error for fraction of underflow entries  (useful for shape comparison)
    00616     """
    00617     return HistoStats.underflowEntriesFracErr ( self )
    00618
    00619 # =============================================================================
    def _overflowIntegralFrac_     ( self ) :

def GaudiPython::HistoUtils::_underflowIntegralFrac_ | ( |  | self | ) | `[private]`

    The fraction of underflow integral  (useful for shape comparison)

Definition at line 632 of file HistoUtils.py.

    00632                                         :
    00633     """
    00634     The fraction of underflow integral  (useful for shape comparison)
    00635     """
    00636     return HistoStats.underflowIntegralFrac    ( self )
    00637 # =============================================================================
    def _underflowIntegralFracErr_ ( self ) :

def GaudiPython::HistoUtils::_underflowIntegralFracErr_ | ( |  | self | ) | `[private]`

    The error for fraction of underflow integral (useful for shape comparison)

Definition at line 638 of file HistoUtils.py.

    00638                                         :
    00639     """
    00640     The error for fraction of underflow integral (useful for shape comparison)
    00641     """
    00642     return HistoStats.underflowIntegralFracErr ( self )
    00643
    00644 # =============================================================================
    ## get number of entries in histogram up to  the certain bin (not-included)

def GaudiPython::HistoUtils::book | ( |  | args,
|  |  | kwargs |
| ) |  |  |

The trivial function to book the various 1D,2D&3D-histograms.

    The trivial function to book the various 1D,2D&3D-histograms

    (1) book the trivial 1D histogram with full path

    >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
                     'cosine of decay angle ' , ## histogram title
                      100                     , ## number of bins
                      -1                      , ## low edge
                      100                     ) ## high edge

    (2) book the trivial 1D histogram with directory path and string ID :

    >>> h1D = book ( 'path/to/directory'      , ## the path to directory in HTS
                     'H1'                     , ## string histogram identifier
                     'cosine of decay angle ' , ## histogram title
                      100                     , ## number of bins
                      -1                      , ## low edge
                      100                     ) ## high edge

    (3) book the trivial 1D histogram with directory path and integer ID :

    >>> h1D = book ( 'path/to/directory'      , ## the path to directory in HTS
                     124                      , ## integer histogram identifier
                     'cosine of decay angle ' , ## histogram title
                      100                     , ## number of bins
                      -1                      , ## low edge
                      100                     ) ## high edge

    (4) book the trivial 2D histogram with full path

    >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
                     'm12**2 versus m13**2'   , ## histogram title
                      50                      , ## number of X-bins
                      1.0                     , ## low X-edge
                      4.0                     , ## high X-edge
                      50                      , ## number of Y-bins
                      1                       , ## low Y-edge
                      2                       ) ## high Y-edge

    (5) book the trivial 2D histogram with directory path and literal ID

    >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
                     'Dalitz1'                , ## literal histogram identifier
                     'm12**2 versus m13**2'   , ## histogram title
                      50                      , ## number of X-bins
                      1.0                     , ## low X-edge
                      4.0                     , ## high X-edge
                      50                      , ## number of Y-bins
                      1                       , ## low Y-edge
                      2                       ) ## high Y-edge

    (6) book the trivial 2D histogram with directory path and integer ID

    >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
                     854                      , ## integer histogram identifier
                     'm12**2 versus m13**2'   , ## histogram title
                      50                      , ## number of X-bins
                      1.0                     , ## low X-edge
                      4.0                     , ## high X-edge
                      50                      , ## number of Y-bins
                      1.0                     , ## low Y-edge
                      4.0                     ) ## high Y-edge

    (7) book the trivial 3D histogram with full path

    >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
                     'x vs y vs z '           , ## histogram title
                      10                      , ## number of X-bins
                      -1.0                    , ## low X-edge
                      1.0                     , ## high X-edge
                      10                      , ## number of Y-bins
                      -1.0                    , ## low Y-edge
                      1.0                     , ## high Y-edge
                      10                      , ## number of Z-bins
                      -1.0                    , ## low Z-edge
                      1.0                     ) ## high Z-edge

    (8) book the trivial 3D histogram with directory path and literal ID

    >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
                     'xyz'                    , ## literal histogram identifier
                     'x vs y vs z'            , ## histogram title
                      10                      , ## number of X-bins
                      -1.0                    , ## low X-edge
                      1.0                     , ## high X-edge
                      10                      , ## number of Y-bins
                      -1.0                    , ## low Y-edge
                      1.0                     , ## high Y-edge
                      10                      , ## number of Z-bins
                      -1.0                    , ## low Z-edge
                      1.0                     ) ## high Z-edge

    (9) book the trivial 3D histogram with directory path and integer ID

    >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
                     888                      , ## integer histogram identifier
                     'x vs y vs z'            , ## histogram title
                      10                      , ## number of X-bins
                      -1.0                    , ## low X-edge
                      1.0                     , ## high X-edge
                      10                      , ## number of Y-bins
                      -1.0                    , ## low Y-edge
                      1.0                     , ## high Y-edge
                      10                      , ## number of Z-bins
                      -1.0                    , ## low Z-edge
                      1.0                     ) ## high Z-edge

    Many other booking methods are available,
    e.g. for the histograms with non-equidistant bins, see IHistogamSvc::book

Definition at line 86 of file HistoUtils.py.

    00086                               :
    00087     """
    00088     The trivial function to book the various 1D,2D&3D-histograms
    00089
    00090     (1) book the trivial 1D histogram with full path
    00091
    00092     >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
    00093                      'cosine of decay angle ' , ## histogram title
    00094                       100                     , ## number of bins
    00095                       -1                      , ## low edge
    00096                       100                     ) ## high edge
    00097
    00098     (2) book the trivial 1D histogram with directory path and string ID :
    00099
    00100     >>> h1D = book ( 'path/to/directory'      , ## the path to directory in HTS
    00101                      'H1'                     , ## string histogram identifier
    00102                      'cosine of decay angle ' , ## histogram title
    00103                       100                     , ## number of bins
    00104                       -1                      , ## low edge
    00105                       100                     ) ## high edge
    00106
    00107     (3) book the trivial 1D histogram with directory path and integer ID :
    00108
    00109     >>> h1D = book ( 'path/to/directory'      , ## the path to directory in HTS
    00110                      124                      , ## integer histogram identifier
    00111                      'cosine of decay angle ' , ## histogram title
    00112                       100                     , ## number of bins
    00113                       -1                      , ## low edge
    00114                       100                     ) ## high edge
    00115
    00116     (4) book the trivial 2D histogram with full path
    00117
    00118     >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
    00119                      'm12**2 versus m13**2'   , ## histogram title
    00120                       50                      , ## number of X-bins
    00121                       1.0                     , ## low X-edge
    00122                       4.0                     , ## high X-edge
    00123                       50                      , ## number of Y-bins
    00124                       1                       , ## low Y-edge
    00125                       2                       ) ## high Y-edge
    00126
    00127     (5) book the trivial 2D histogram with directory path and literal ID
    00128
    00129     >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
    00130                      'Dalitz1'                , ## literal histogram identifier
    00131                      'm12**2 versus m13**2'   , ## histogram title
    00132                       50                      , ## number of X-bins
    00133                       1.0                     , ## low X-edge
    00134                       4.0                     , ## high X-edge
    00135                       50                      , ## number of Y-bins
    00136                       1                       , ## low Y-edge
    00137                       2                       ) ## high Y-edge
    00138
    00139     (6) book the trivial 2D histogram with directory path and integer ID
    00140
    00141     >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
    00142                      854                      , ## integer histogram identifier
    00143                      'm12**2 versus m13**2'   , ## histogram title
    00144                       50                      , ## number of X-bins
    00145                       1.0                     , ## low X-edge
    00146                       4.0                     , ## high X-edge
    00147                       50                      , ## number of Y-bins
    00148                       1.0                     , ## low Y-edge
    00149                       4.0                     ) ## high Y-edge
    00150
    00151     (7) book the trivial 3D histogram with full path
    00152
    00153     >>> h1D = book ( 'path/to/my/histo'       , ## path in Histogram Transient Store
    00154                      'x vs y vs z '           , ## histogram title
    00155                       10                      , ## number of X-bins
    00156                       -1.0                    , ## low X-edge
    00157                       1.0                     , ## high X-edge
    00158                       10                      , ## number of Y-bins
    00159                       -1.0                    , ## low Y-edge
    00160                       1.0                     , ## high Y-edge
    00161                       10                      , ## number of Z-bins
    00162                       -1.0                    , ## low Z-edge
    00163                       1.0                     ) ## high Z-edge
    00164
    00165     (8) book the trivial 3D histogram with directory path and literal ID
    00166
    00167     >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
    00168                      'xyz'                    , ## literal histogram identifier
    00169                      'x vs y vs z'            , ## histogram title
    00170                       10                      , ## number of X-bins
    00171                       -1.0                    , ## low X-edge
    00172                       1.0                     , ## high X-edge
    00173                       10                      , ## number of Y-bins
    00174                       -1.0                    , ## low Y-edge
    00175                       1.0                     , ## high Y-edge
    00176                       10                      , ## number of Z-bins
    00177                       -1.0                    , ## low Z-edge
    00178                       1.0                     ) ## high Z-edge
    00179
    00180     (9) book the trivial 3D histogram with directory path and integer ID
    00181
    00182     >>> h1D = book ( 'path/to/directory'      , ## path in Histogram Transient Store
    00183                      888                      , ## integer histogram identifier
    00184                      'x vs y vs z'            , ## histogram title
    00185                       10                      , ## number of X-bins
    00186                       -1.0                    , ## low X-edge
    00187                       1.0                     , ## high X-edge
    00188                       10                      , ## number of Y-bins
    00189                       -1.0                    , ## low Y-edge
    00190                       1.0                     , ## high Y-edge
    00191                       10                      , ## number of Z-bins
    00192                       -1.0                    , ## low Z-edge
    00193                       1.0                     ) ## high Z-edge
    00194
    00195     Many other booking methods are available,
    00196     e.g. for the histograms with non-equidistant bins, see IHistogamSvc::book
    00197
    00198     """
    00199     svc = _getHistoSvc ( **kwargs )
    00200     if not svc : raise RuntimeError, 'Unable to get valid HistogramService '
    00201     ## book the histogram using the service
    00202     return svc.book(*args)                                          ## RETURN
    00203
    00204 book.__doc__ += '\n\n' + '\thelp(iHistogramSvc.book) : \n\n' \
    00205                 + iHistogramSvc.book       . __doc__
    00206 book.__doc__ += '\n\n' + '\thelp(IHistogramSvc::book) : \n\n'            \
    00207                 + cpp.IHistogramSvc.book . __doc__
    00208
    00209 # =============================================================================
    ## The trivial function to book 1D&2D profile histograms:

def GaudiPython::HistoUtils::bookProf | ( |  | args,
|  |  | kwargs |
| ) |  |  |

The trivial function to book 1D&2D profile histograms:.

    The trivial function to book 1D&2D profile histograms:

    (1) book 1D-profile histogram with full path in Histogram Transient Store:
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           'Energy Correction'   , ## the histogram title
                           100                   , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   ) ## high X-edge

    (2) book 1D-profile histogram with directory path and literal ID
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           'Calibration'         , ## the histogram literal identifier
                           'Energy Correction'   , ## the histogram title
                           100                   , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   ) ## high X-edge

    (3) book 1D-profile histogram with directory path and integer  ID
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           418                   , ## the histogram integer identifier
                           'Energy Correction'   , ## the histogram title
                           100                   , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   ) ## high X-edge

    (4) book 2D-profile histogram with full path in Histogram Transient Store:
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           'Energy Correction'   , ## the histogram title
                           50                    , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   , ## high X-edge
                           50                    , ## number of Y-bins
                           0.0                   , ## low Y-edge
                           100                   ) ## high Y-edge

    (5) book 2D-profile histogram with directory path and literal ID
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           'Calibration'         , ## the histogram literal identifier
                           'Energy Correction'   , ## the histogram title
                           50                    , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   , ## high X-edge
                           50                    , ## number of Y-bins
                           0.0                   , ## low Y-edge
                           100                   ) ## high Y-edge

    (6) book 2D-profile histogram with directory path and integer  ID
    >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
                           418                   , ## the histogram integer identifier
                           'Energy Correction'   , ## the histogram title
                           50                    , ## number of X-bins
                           0.0                   , ## low X-edge
                           100                   , ## high X-edge
                           50                    , ## number of Y-bins
                           0.0                   , ## low Y-edge
                           100                   ) ## high Y-edge

    Many other booking methods are available,
    e.g. for the histograms with non-equidistant bins, see IHistogamSvc::book

Definition at line 211 of file HistoUtils.py.

    00211                                   :
    00212     """
    00213
    00214     The trivial function to book 1D&2D profile histograms:
    00215
    00216     (1) book 1D-profile histogram with full path in Histogram Transient Store:
    00217     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00218                            'Energy Correction'   , ## the histogram title
    00219                            100                   , ## number of X-bins
    00220                            0.0                   , ## low X-edge
    00221                            100                   ) ## high X-edge
    00222
    00223     (2) book 1D-profile histogram with directory path and literal ID
    00224     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00225                            'Calibration'         , ## the histogram literal identifier
    00226                            'Energy Correction'   , ## the histogram title
    00227                            100                   , ## number of X-bins
    00228                            0.0                   , ## low X-edge
    00229                            100                   ) ## high X-edge
    00230
    00231     (3) book 1D-profile histogram with directory path and integer  ID
    00232     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00233                            418                   , ## the histogram integer identifier
    00234                            'Energy Correction'   , ## the histogram title
    00235                            100                   , ## number of X-bins
    00236                            0.0                   , ## low X-edge
    00237                            100                   ) ## high X-edge
    00238
    00239     (4) book 2D-profile histogram with full path in Histogram Transient Store:
    00240     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00241                            'Energy Correction'   , ## the histogram title
    00242                            50                    , ## number of X-bins
    00243                            0.0                   , ## low X-edge
    00244                            100                   , ## high X-edge
    00245                            50                    , ## number of Y-bins
    00246                            0.0                   , ## low Y-edge
    00247                            100                   ) ## high Y-edge
    00248
    00249     (5) book 2D-profile histogram with directory path and literal ID
    00250     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00251                            'Calibration'         , ## the histogram literal identifier
    00252                            'Energy Correction'   , ## the histogram title
    00253                            50                    , ## number of X-bins
    00254                            0.0                   , ## low X-edge
    00255                            100                   , ## high X-edge
    00256                            50                    , ## number of Y-bins
    00257                            0.0                   , ## low Y-edge
    00258                            100                   ) ## high Y-edge
    00259
    00260     (6) book 2D-profile histogram with directory path and integer  ID
    00261     >>> histo = bookProf ( 'path/to/my/profile'  , ## path in Histogram Transient Store
    00262                            418                   , ## the histogram integer identifier
    00263                            'Energy Correction'   , ## the histogram title
    00264                            50                    , ## number of X-bins
    00265                            0.0                   , ## low X-edge
    00266                            100                   , ## high X-edge
    00267                            50                    , ## number of Y-bins
    00268                            0.0                   , ## low Y-edge
    00269                            100                   ) ## high Y-edge
    00270
    00271     Many other booking methods are available,
    00272     e.g. for the histograms with non-equidistant bins, see IHistogamSvc::book
    00273
    00274     """
    00275     svc = _getHistoSvc ( **kwargs )
    00276     if not svc : raise RuntimeError, 'Unable to get valid HistogramService '
    00277     ## book the histogram using the service
    00278     return svc.bookProf(*args)                                      ## RETURN
    00279
    00280
    00281 bookProf.__doc__ += '\n\n' + '\thelp(iHistogramSvc.bookProf) : \n\n' \
    00282                     + iHistogramSvc.bookProf . __doc__
    00283 bookProf.__doc__ += '\n\n' + '\thelp(IHistogramSvc::bookProf) : \n\n'             \
    00284                     + cpp.IHistogramSvc.bookProf . __doc__
    00285
    00286 # =============================================================================
    ## The most trivial function to retrieve the histogram from Histogram Transient Store

def GaudiPython::HistoUtils::fill | ( |  | histo,
|  |  | data,
|  |  | fun = `lambda x : x`,
|  |  | cut = `lambda x : True`,
|  |  | kwargs |
| ) |  |  |

The function which allows 'the smart fill' of 1D-histogram.

    The function which allows 'the smart fill' of 1D-histogram

    >>> histo = ...

    The most trivial case, fill with the value
    >>> fill ( histo , 1.0 )

    Fill from any iterable object (sequence)
    >>> fill ( histo , [1,,2,3,4,5,10] )

    Fill from iterable object and apply the function:
    >>> fill ( histo , [1,2,3,4,5] , math.sin )

    Use lambda form:
    >>> fill ( histo , [1,2,3,4,5] , lambda x : x*x )

    The same
    >>> fill ( histo , [1,2,3,4,5] , fun = lambda x : x*x )

    Use internal attributes:
    >>> tracks = evtSvc['Rec/Track/Best']    ## iterable container of tracks
    >>> fill ( histo , tracks , lambda t : t.pt() )

    Apply the predicate: fill only even numbers:
    >>> fill ( histo , [1,2,3,4,5,6,7] , lambda x : x , lambda y : y%2 )

    The same (omit the trivial function) :
    >>> fill ( histo , [1,2,3,4,5,6,7] , cut = lambda y : y%2 )

    Apply the predicate: fill only pt for positively charged tracks:
    >>> tracks = evtSvc['Rec/Track/Best']
    >>> fill ( histo , tracks , lambda t : t.pt() , lambda t : 0<t.charge() )

    The same:
    >>> fill ( histo , tracks ,
               fun = lambda t : t.pt()       ,
               cut = lambda t : 0<t.charge() )

    Ordinary functions are also fine:
    >>> def myfun ( track ) : return sin( track.pt() + track.p() )
    >>> def mycut ( track ) : return track.p() > 100 * GeV
    >>> fill ( histo , tracks , myfun , mycut )

    The 'data' could be the address in TES, in this case the object
    is retrieved from TES and the method is applied to the objects,
    retrieved from TES:
    >>> fill (  histo             , ## the reference to the histogram
               'Rec/Track/Best'   , ## the location of objects in TES
                lambda t : t.pt() ) ## function to be used for histogram fill
    >>> fill (  histo             , ## the reference to the histogram
               'Rec/Track/Best'   , ## the address of objects in TES
                lambda t : t.pt() , ## the function to be used for histogram fill
                lambda t : t.charge()>0 ) ## the criteria to select tracks

    The arguments 'fun' and 'cut' could be strings, in this case
    they are evaluated by python before usage.
    This option could be often very useful.

Definition at line 329 of file HistoUtils.py.

    00331                             : x    ,   ## function to be used
    00332            cut   = lambda x : True ,   ## cut to be applied
    00333            **kwargs                ) : ## optional extra arguments
    00334     """
    00335
    00336     The function which allows 'the smart fill' of 1D-histogram
    00337
    00338     >>> histo = ...
    00339
    00340     The most trivial case, fill with the value
    00341     >>> fill ( histo , 1.0 )
    00342
    00343     Fill from any iterable object (sequence)
    00344     >>> fill ( histo , [1,,2,3,4,5,10] )
    00345
    00346     Fill from iterable object and apply the function:
    00347     >>> fill ( histo , [1,2,3,4,5] , math.sin )
    00348
    00349     Use lambda form:
    00350     >>> fill ( histo , [1,2,3,4,5] , lambda x : x*x )
    00351
    00352     The same
    00353     >>> fill ( histo , [1,2,3,4,5] , fun = lambda x : x*x )
    00354
    00355     Use internal attributes:
    00356     >>> tracks = evtSvc['Rec/Track/Best']    ## iterable container of tracks
    00357     >>> fill ( histo , tracks , lambda t : t.pt() )
    00358
    00359     Apply the predicate: fill only even numbers:
    00360     >>> fill ( histo , [1,2,3,4,5,6,7] , lambda x : x , lambda y : y%2 )
    00361
    00362     The same (omit the trivial function) :
    00363     >>> fill ( histo , [1,2,3,4,5,6,7] , cut = lambda y : y%2 )
    00364
    00365     Apply the predicate: fill only pt for positively charged tracks:
    00366     >>> tracks = evtSvc['Rec/Track/Best']
    00367     >>> fill ( histo , tracks , lambda t : t.pt() , lambda t : 0<t.charge() )
    00368
    00369     The same:
    00370     >>> fill ( histo , tracks ,
    00371                fun = lambda t : t.pt()       ,
    00372                cut = lambda t : 0<t.charge() )
    00373
    00374     Ordinary functions are also fine:
    00375     >>> def myfun ( track ) : return sin( track.pt() + track.p() )
    00376     >>> def mycut ( track ) : return track.p() > 100 * GeV
    00377     >>> fill ( histo , tracks , myfun , mycut )
    00378
    00379     The 'data' could be the address in TES, in this case the object
    00380     is retrieved from TES and the method is applied to the objects,
    00381     retrieved from TES:
    00382     >>> fill (  histo             , ## the reference to the histogram
    00383                'Rec/Track/Best'   , ## the location of objects in TES
    00384                 lambda t : t.pt() ) ## function to be used for histogram fill
    00385     >>> fill (  histo             , ## the reference to the histogram
    00386                'Rec/Track/Best'   , ## the address of objects in TES
    00387                 lambda t : t.pt() , ## the function to be used for histogram fill
    00388                 lambda t : t.charge()>0 ) ## the criteria to select tracks
    00389
    00390     The arguments 'fun' and 'cut' could be strings, in this case
    00391     they are evaluated by python before usage.
    00392     This option could be often very useful.
    00393
    00394     """
    00395
    00396     # if value is a string, try to get the objects from TES
    00397     if type ( data ) == str :
    00398         svc  = _getEvtSvc ( **kwargs )
    00399         data = svc[data]
    00400         return fill ( histo , data , fun , cut , **kwargs )
    00401
    00402     # if the function  is a string: evaluate it!
    00403     if type ( fun  ) == str : fun  = eval ( fun  , globals() )
    00404
    00405     # if the criterion is a string: evaluate it!
    00406     if type ( cut  ) == str : cut  = eval ( cut  , globals() )
    00407
    00408     if not hasattr ( data , '__iter__' ) : data = [ data ]
    00409
    00410     if not hasattr ( histo , 'fill' ) and hasattr ( histo , 'Fill' ) :
    00411         setattr ( histo , 'fill' , getattr ( histo , 'Fill' ) )
    00412
    00413     for item in data :
    00414         if not cut ( item )         : continue             ## CONTINUE
    00415         histo.fill ( fun ( item ) )
    00416
    00417     return histo                                           ## RETURN
    00418
    00419 # =============================================================================

def GaudiPython::HistoUtils::getAsAIDA | ( |  | path,
|  |  | kwargs |
| ) |  |  |

The most trivial function to retrieve the histogram from Histogram Transient Store.

    The most trivial function to retrieve the histogram from Histogram Transient Store
    The histogram is returned by reference to its AIDA-representation (if possible)

    >>> h = getAsAIDA ( 'some/path/to/my/histogram' )

Definition at line 288 of file HistoUtils.py.

    00288                                   :
    00289     """
    00290
    00291     The most trivial function to retrieve the histogram from Histogram Transient Store
    00292     The histogram is returned by reference to its AIDA-representation (if possible)
    00293
    00294     >>> h = getAsAIDA ( 'some/path/to/my/histogram' )
    00295
    00296     """
    00297     svc = _getHistoSvc ( **kwargs )
    00298     if not svc : raise RuntimeError, 'Unable to get valid HistogramService '
    00299     ## return the histogram
    00300     return svc.getAsAIDA( path )                                   ## RETURN
    00301
    00302 getAsAIDA.__doc__ += '\n\n' + '\thelp(iHistogramSvc.getAsAIDA) : \n\n' \
    00303                      + iHistogramSvc.getAsAIDA . __doc__
    00304 getAsAIDA.__doc__ += '\n\n' + '\thelp(iHistogramSvc.retrieve)  : \n\n' \
    00305                      + iHistogramSvc.retrieve  . __doc__
    00306
    00307 # =============================================================================
    ## The most trivial function to retrieve the histogram from Histogram Transient Store

def GaudiPython::HistoUtils::getAsROOT | ( |  | path,
|  |  | kwargs |
| ) |  |  |

The most trivial function to retrieve the histogram from Histogram Transient Store.

    The most trivial function to retrieve the histogram from Histogram Transient Store
    The histogram is returned by reference to its underlying native ROOT-representation (if possible)

    >>> h = getAsROOT ( 'some/path/to/my/histogram' )

Definition at line 309 of file HistoUtils.py.

    00309                                   :
    00310     """
    00311
    00312     The most trivial function to retrieve the histogram from Histogram Transient Store
    00313     The histogram is returned by reference to its underlying native ROOT-representation (if possible)
    00314
    00315     >>> h = getAsROOT ( 'some/path/to/my/histogram' )
    00316
    00317     """
    00318     svc = _getHistoSvc ( **kwargs )
    00319     if not svc : raise RuntimeError, 'Unable to get valid HistogramService '
    00320     ## return the histogram
    00321     return svc.getAsROOT( path )                                   ## RETURN
    00322
    00323 getAsROOT.__doc__ += '\n\n' + '\thelp(iHistogramSvc.getAsROOT) : \n\n' \
    00324                      + iHistogramSvc.getAsROOT . __doc__
    00325
    00326
    00327 # =============================================================================
    ## The function which allows 'the smart fill' of 1D-histogram

## Variable Documentation

tuple GaudiPython::HistoUtils::__all__

Initial value:

    (
        'book'      , ##                book AIDA histogram using Histogram Service
        'bookProf'  , ##        book AIDA profile histogram using Histogram Service
        'getAsAIDA' , ## get the histogram form Histogram Service as AIDA histogram
        'getAsROOT' , ## get the histogram form Histogram Service as AIDA histogram
        'fill'      , ##              "power-fill" method for filling of histograms
        'aida2root' , ##                                     AIDA -> ROOT converter
        'HistoStats', ##                  statistical information for 1D-histograms
        'HistoFile' , ##                     class for storing histograms to a file
        'histoDump' , ##                     dump histogramintext format a'la HBOOK
        'dumphisto'   ##                     dump histogramintext format a'la HBOOK
        )

Definition at line 29 of file HistoUtils.py.

string GaudiPython::HistoUtils::__author__ = "Vanya BELYAEV ibelyaev@physics.syr.edu"

This module contains set of simple and useful utilities for booking and manipulations with Gaudi-AIDA histograms, inspired by Thomas' request.

Author:
  Vanya BELYAEV ibelyaev@physics.syr.edu

Date:
  2007-08-03 =============================================================================

Definition at line 27 of file HistoUtils.py.

GaudiPython::HistoUtils::aida2root = cpp.Gaudi.Utils.Aida2ROOT.aida2root

AIDA -> ROOT converter.

Definition at line 421 of file HistoUtils.py.

GaudiPython::HistoUtils::dumpHisto = __dumpHisto__

Definition at line 776 of file HistoUtils.py.

GaudiPython::HistoUtils::HID = cpp.GaudiAlg.ID

Definition at line 47 of file HistoUtils.py.

GaudiPython::HistoUtils::histoDump = __dumpHisto__

the actual function for text dump of the histogram

Definition at line 775 of file HistoUtils.py.

GaudiPython::HistoUtils::HistoStats = cpp.Gaudi.Utils.HistoStats

Definition at line 449 of file HistoUtils.py.

GaudiPython::HistoUtils::i1DH = cpp.AIDA.IHistogram1D

Definition at line 706 of file HistoUtils.py.

GaudiPython::HistoUtils::iBH = cpp.AIDA.IBaseHistogram

Definition at line 747 of file HistoUtils.py.