| |
- Boost.Python.enum(__builtin__.int)
-
- ColorValue
- Line
- Symbol
- Boost.Python.instance(__builtin__.object)
-
- Canvas
- CanvasWindow
- CutController
- DataArray
- DataRep
- DataSource
-
- FitsNTuple
- ListTuple
- NTupleInternal
-
- CircularBuffer
- NTuple
- NumArrayTuple
- Display
-
- Cut
- FCNBase
-
- StatedFCN
-
- NTupleFCN
- FactoryPointRep
-
- PointRepFactory
- FitsController
- Fitter
- FitterFactory
- Function
- FunctionBase
- FunctionFactory
- HDApp
- NTupleController
- Observable
- Observer
- RepBase
class Canvas(Boost.Python.instance) |
|
The HippoDraw canvas.
This class provides an interface to the canvas.
One can take various actions that are also
available from menu items in the canvas window. |
|
- Method resolution order:
- Canvas
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
- __reduce__ = (...)
- addDisplay(...)
- addDisplay( (Canvas)arg1, (Display)arg2) -> None :
addDisplay ( Display ) -> None
Adds a display to the canvas.
C++ signature :
void addDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- addText(...)
- addText( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
addText ( Display, string ) -> None
Adds text to display.
C++ signature :
void addText(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
- addTextAt(...)
- addTextAt( (Canvas)arg1, (Display)arg2, (str)arg3, (float)arg4, (float)arg5) -> None :
addTextAt ( Display, string, value, value ) -> None
Adds text to a display at specified position
Position is fraction of width and height.
C++ signature :
void addTextAt(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string,double,double)
- addTextAtAbs(...)
- addTextAtAbs( (Canvas)arg1, (Display)arg2, (str)arg3, (float)arg4, (float)arg5) -> None :
addTextAt ( Display, string, value, value ) -> None
Adds text to a display at specified position
Position is absolute value of the date point.
C++ signature :
void addTextAtAbs(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string,double,double)
- addTextRep(...)
- addTextRep( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
addTextRep ( Display, string ) -> None
Adds textual data representation to display. Use
Canvas.getTextRepTypes() to see available types.
C++ signature :
void addTextRep(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
- clear(...)
- clear( (Canvas)arg1) -> None :
clear () -> None
Removes all items from the canvas
C++ signature :
void clear(hippodraw::PyCanvas {lvalue})
- close(...)
- close( (Canvas)arg1) -> None :
close () -> None
Closes the window.
C++ signature :
void close(hippodraw::PyCanvas {lvalue})
- getCut(...)
- getCut( (Canvas)arg1) -> Cut :
getCut () -> Cut
Returns the currently selected Cut object.
C++ signature :
hippodraw::QtCut* getCut(hippodraw::PyCanvas {lvalue})
- getDisplay(...)
- getDisplay( (Canvas)arg1) -> Display :
getDisplay () -> Display
Returns the selected Display object.
C++ signature :
hippodraw::QtDisplay* getDisplay(hippodraw::PyCanvas {lvalue})
- getDisplays(...)
- getDisplays( (Canvas)arg1) -> object :
getDisplays () -> tuple
Returns a tuple of all Display objects on the canvas.
C++ signature :
std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> > getDisplays(hippodraw::PyCanvas {lvalue})
- getHeight(...)
- getHeight( (Canvas)arg1, (Display)arg2) -> int :
getHeight ( Display ) -> value
Returns the height of the Display.
C++ signature :
int getHeight(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- getPickTable(...)
- getPickTable( (Canvas)arg1, (Display)arg2) -> NTupleInternal :
getPickTable ( Display ) -> NTuple
Gets the pick table of the Display.
C++ signature :
hippodraw::NTuple* getPickTable(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- getSelPickTable(...)
- getSelPickTable( (Canvas)arg1) -> NTupleInternal :
getSelPickTable () -> NTuple
Gets the pick table for selected Display.
C++ signature :
hippodraw::NTuple* getSelPickTable(hippodraw::PyCanvas {lvalue})
- getTextRepTypes(...)
- getTextRepTypes( (Canvas)arg1) -> object :
getTextRepTypes () -> tuple
Returns the types of textual data representations available.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getTextRepTypes(hippodraw::PyCanvas {lvalue})
- getWidth(...)
- getWidth( (Canvas)arg1, (Display)arg2) -> int :
getWidth ( Display ) -> value
Returns the width of the Display.
C++ signature :
int getWidth(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- getX(...)
- getX( (Canvas)arg1, (Display)arg2) -> int :
getX ( Display ) -> value
Returns the X coordinate of the Display.
C++ signature :
int getX(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- getY(...)
- getY( (Canvas)arg1, (Display)arg2) -> int :
getY ( Display ) -> value
Returns the Y coordinate of the Display. Note that Y=0 is
at the top and Y increases downward.
C++ signature :
int getY(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- mouseData(...)
- mouseData( (Canvas)arg1) -> object :
mouseData () -> tuple
Returns a tuple of picked data.
C++ signature :
std::vector<double, std::allocator<double> > mouseData(hippodraw::PyCanvas {lvalue})
- printTo(...)
- printTo( (Canvas)arg1, (str)arg2) -> None :
printTo ( string ) -> None
Prints the canvas to PostScript file.
C++ signature :
void printTo(hippodraw::PyCanvas {lvalue},std::string)
- removeDisplay(...)
- removeDisplay( (Canvas)arg1, (Display)arg2) -> None :
removeDisplay ( Display ) -> None
Removes the display from the canvas.
C++ signature :
void removeDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- saveAs(...)
- saveAs( (Canvas)arg1, (str)arg2) -> None :
saveAs ( string ) -> None
Save the canvas as a XML file.
C++ signature :
void saveAs(hippodraw::PyCanvas {lvalue},std::string)
- saveAsImage(...)
- saveAsImage( (Canvas)arg1, (Display)arg2, (str)arg3) -> None :
saveAsImage ( Display, string ) -> None
Save a display as an image file.
The suffix of the file name controls the image type.
C++ signature :
void saveAsImage(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,std::string)
- saveSelectedImages(...)
- saveSelectedImages( (Canvas)arg1, (str)arg2) -> None :
saveSelectedImages ( string ) -> None
Save the selected displays as an image file.
The suffix of the file name controls the image type.
C++ signature :
void saveSelectedImages(hippodraw::PyCanvas {lvalue},std::string)
- selectAllDisplays(...)
- selectAllDisplays( (Canvas)arg1, (bool)arg2) -> None :
selectAllDisplays ( Boolean ) -> None
Sets all displays to selected state or not.
C++ signature :
void selectAllDisplays(hippodraw::PyCanvas {lvalue},bool)
- selectDisplay(...)
- selectDisplay( (Canvas)arg1, (Display)arg2) -> None :
selectDisplay ( Display ) -> None
Sets a display to selected state.
C++ signature :
void selectDisplay(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*)
- setHeight(...)
- setHeight( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
setHeight ( Display, value ) -> None
Sets the height of the Display.
C++ signature :
void setHeight(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
- setPlotMatrix(...)
- setPlotMatrix( (Canvas)arg1, (int)arg2, (int)arg3) -> None :
setPlotMatrix ( columns, rows ) -> None
Sets the number of columns and rows of plots for each page.
C++ signature :
void setPlotMatrix(hippodraw::PyCanvas {lvalue},unsigned int,unsigned int)
- setWidth(...)
- setWidth( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
setWidth ( Display, value ) -> None
Sets the width of the Display.
C++ signature :
void setWidth(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
- setX(...)
- setX( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
setX ( Display, value ) -> None
Sets the X coordinate of the Display
C++ signature :
void setX(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
- setY(...)
- setY( (Canvas)arg1, (Display)arg2, (float)arg3) -> None :
setY ( Display, value ) -> None
Sets the Y coordinate of the Display. Note that Y = 0 is
at the top and Y increases downward.
C++ signature :
void setY(hippodraw::PyCanvas {lvalue},hippodraw::QtDisplay*,double)
- show(...)
- show( (Canvas)arg1) -> None :
show () -> None
Displays the canvas window on the screen. One only needs
to use this method if running HippoDraw in the Python
thread.
C++ signature :
void show(hippodraw::PyCanvas {lvalue})
- swapOrientation(...)
- swapOrientation( (Canvas)arg1) -> None :
swapOrientation ( ) -> None
Swaps the canvas' orientation from portrait to landscape
or vice verse.
C++ signature :
void swapOrientation(hippodraw::PyCanvas {lvalue})
Data and other attributes defined here:
- __instance_size__ = 64
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class CanvasWindow(Boost.Python.instance) |
|
The CanvasWindow class contains the Canvas and some controls via
menu items and dialogs. |
|
- Method resolution order:
- CanvasWindow
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- fileNew(...)
- fileNew( (CanvasWindow)arg1) -> None :
fileNew ( None ) -> None
Creates a new CanvasWindow.
C++ signature :
void fileNew(hippodraw::CanvasWindow {lvalue})
- show(...)
- show( (CanvasWindow)arg1) -> None :
show ( None ) -> None
Brings the canvas window onto the screen.
C++ signature :
void show(hippodraw::CanvasWindow {lvalue})
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class CircularBuffer(NTupleInternal) |
|
A circular buffer in a NTuple that adds rows up to a defined number,
then starts replacing the oldest rows. |
|
- Method resolution order:
- CircularBuffer
- NTupleInternal
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
CircularBuffer ( None ) -> CircularBuffer
CircularBuffer ( value ) -> CircularBuffer
CircularBuffer ( string ) -> CircularBuffer
CircularBuffer ( sequence ) -> CircularBuffer
CircularBuffer ( CircularBuffer ) -> CircularBuffer
There are five forms of construction of a CircularBuffer. The
first form creates an empty one. The second from creates an empty
one with `value' number of columns. The third from creates an
empty one the number of columns equal to the size of the sequence.
The column labels are taken from the sequence. The final form is
the copy constructor.
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (int)arg2) -> None :
C++ signature :
void __init__(_object*,int)
__init__( (object)arg1, (str)arg2) -> None :
C++ signature :
void __init__(_object*,std::string)
__init__( (object)arg1, (object)arg2) -> None :
C++ signature :
void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (CircularBuffer)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::CircularBuffer)
- __reduce__ = (...)
- addRow(...)
- addRow( (CircularBuffer)arg1, (object)arg2) -> None :
addRow ( sequence ) -> None
Append a row at the end of the table until it is full,
then replace the oldest row.
C++ signature :
void addRow(hippodraw::CircularBuffer {lvalue},std::vector<double, std::allocator<double> >)
- clear(...)
- clear( (CircularBuffer)arg1) -> None :
clear ( None ) -> None
Clears the contents of the buffer
C++ signature :
void clear(hippodraw::CircularBuffer {lvalue})
- reserve(...)
- reserve( (CircularBuffer)arg1, (int)arg2) -> None :
reserve ( value ) -> None
Sets the maximum size of the buffer
C++ signature :
void reserve(hippodraw::CircularBuffer {lvalue},unsigned int)
Data descriptors defined here:
- columns
- rows
Data and other attributes defined here:
- __instance_size__ = 240
Methods inherited from NTupleInternal:
- getLabel(...)
- getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
getLabel ( index ) -> string
Returns the label at column index.
C++ signature :
std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
- getRow(...)
- getRow( (NTupleInternal)arg1, (int)arg2) -> object :
getRow ( index ) -> list
Returns the index row as list floats.
C++ signature :
std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
- setIntervalCount(...)
- setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
setIntervalCount ( count ) -> None
Sets the interval count between updates to the observers.
C++ signature :
void setIntervalCount(hippodraw::NTuple {lvalue},int)
- setIntervalEnabled(...)
- setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
setIntervalEnable ( Boolean ) -> None
Sets the interval counting on or off
C++ signature :
void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
- setLabels(...)
- setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
setLabels ( sequence ) -> None
Sets the labels of the columns from the list of strings. If the
NTuple is empty, then also sets the number of columns to be the
size of the list. If the number of columns has already been
set, the the size of the list should be the same, otherwise
a RuntimeError exception is thrown.
C++ signature :
void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)
Methods inherited from DataSource:
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- replaceColumn(...)
- replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( label, list ) -> None
Replaces the column of data by abel.
C++ signature :
void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class ColorValue(Boost.Python.enum) |
| |
- Method resolution order:
- ColorValue
- Boost.Python.enum
- __builtin__.int
- __builtin__.object
Data and other attributes defined here:
- black = hippo.ColorValue.black
- blue = hippo.ColorValue.blue
- cyan = hippo.ColorValue.cyan
- darkgray = hippo.ColorValue.darkgray
- green = hippo.ColorValue.green
- lightgray = hippo.ColorValue.lightgray
- magenta = hippo.ColorValue.magenta
- orange = hippo.ColorValue.orange
- red = hippo.ColorValue.red
- values = {0: hippo.ColorValue.red, 1: hippo.ColorValue.green, 2: hippo.ColorValue.blue, 3: hippo.ColorValue.yellow, 4: hippo.ColorValue.orange, 5: hippo.ColorValue.cyan, 6: hippo.ColorValue.magenta, 7: hippo.ColorValue.black, 8: hippo.ColorValue.darkgray, 9: hippo.ColorValue.lightgray, ...}
- white = hippo.ColorValue.white
- yellow = hippo.ColorValue.yellow
Methods inherited from Boost.Python.enum:
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data descriptors inherited from Boost.Python.enum:
- name
Methods inherited from __builtin__.int:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- __xor__(...)
- x.__xor__(y) <==> x^y
- conjugate(...)
- Returns self, the complex conjugate of any int.
Data descriptors inherited from __builtin__.int:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
Data and other attributes inherited from __builtin__.int:
- __new__ = <built-in method __new__ of type object at 0xfffff801002ca208>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Cut(Display) |
|
An object of this class applies a cut or filter on the data that is
used as input to its target displays. |
|
- Method resolution order:
- Cut
- Display
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1, (DataSource)arg2, (object)arg3) -> None :
Cut ( DataSource, sequence ) -> Cut
Cut ( DataArray, sequence ) -> Cut
Cut ( DataSource, sequence, Display, value, value ) -> Cut
Cut ( DataArray, sequence, Display, value, value ) -> Cut
Creates a Cut bound to DataSource. For each form, the first
argument is the DataSource and the second argument is sequence of
strings specifying the binding. The latter two forms apply the
Cut to a Display with low and high values for the Cut range.
C++ signature :
void __init__(_object*,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (DataSource)arg2, (object)arg3, (Display)arg4, (float)arg5, (float)arg6) -> None :
C++ signature :
void __init__(_object*,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >,hippodraw::QtDisplay*,double,double)
__init__( (object)arg1, (DataArray)arg2, (object)arg3) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (DataArray)arg2, (object)arg3, (Display)arg4, (float)arg5, (float)arg6) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >,hippodraw::QtDisplay*,double,double)
__init__( (object)arg1, (DataArray)arg2, (str)arg3, (object)arg4, (Display)arg5) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array,hippodraw::QtDisplay*)
- __reduce__ = (...)
- addTarget(...)
- addTarget( (Cut)arg1, (Display)arg2) -> None :
addTarget ( Display ) -> None
Adds a Display to the list of targets.
C++ signature :
void addTarget(hippodraw::QtCut {lvalue},hippodraw::QtDisplay*)
- addTargets(...)
- addTargets( (Cut)arg1, (object)arg2) -> None :
addTargets ( sequence ) -> None
Adds Display objects in the sequence to the list targets
C++ signature :
void addTargets(hippodraw::QtCut {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
- cutRange(...)
- cutRange( (Cut)arg1) -> object :
cutRange () -> tuple
Returns a pair of values of the range of each Cut.
C++ signature :
std::vector<double, std::allocator<double> > cutRange(hippodraw::QtCut {lvalue})
- setCutRange(...)
- setCutRange( (Cut)arg1, (float)arg2, (float)arg3, (str)arg4) -> None :
setCutRange ( value, value, string ) -> None
Sets the range of the Cut. Arguments are low and high values,
and the axis.
C++ signature :
void setCutRange(hippodraw::QtCut {lvalue},double,double,std::string)
- setEnabled(...)
- setEnabled( (Cut)arg1, (bool)arg2) -> None :
setEnabled ( Boolean ) -> None
Sets the cut to be enabled or not
C++ signature :
void setEnabled(hippodraw::QtCut {lvalue},bool)
- toggleInverted(...)
- toggleInverted( (Cut)arg1) -> None :
toggleInverted () -> None
Toggles the inversion status
C++ signature :
void toggleInverted(hippodraw::QtCut {lvalue})
Static methods defined here:
- createFits(...)
- createFits( (object)arg1, (object)arg2, (DataSource)arg3, (str)arg4, (str)arg5) -> None :
createFits ( sequence, sequence, DataSource, string, string )->None
Create a new FITS file using cut list and column list.
This method is deprecated, use the FitsController instead.
C++ signature :
void createFits(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*,std::string,std::string)
- createNTuple(...)
- createNTuple( (object)arg1, (object)arg2, (DataSource)arg3) -> NTupleInternal :
createNTuple ( sequence, sequence, DataSource ) -> NTuple
Create a new NTuple using cut list and column list.
C++ signature :
hippodraw::NTuple* createNTuple(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*)
- createTnt(...)
- createTnt( (object)arg1, (object)arg2, (DataSource)arg3, (str)arg4, (str)arg5) -> None :
createTnt ( sequence, sequence, DataSource, string, string )-> None
Create a new TNT file using cut list and column list.
C++ signature :
void createTnt(std::vector<std::string, std::allocator<std::string> >,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,hippodraw::DataSource*,std::string,std::string)
Data and other attributes defined here:
- __instance_size__ = 144
Methods inherited from Display:
- addDataRep(...)
- addDataRep( (Display)arg1, (DataRep)arg2) -> None :
addDataRep ( DataRep ) -> Display
addDataRep ( Function ) -> Display
addDataRep ( string, DataSource, tuple ) -> Display
Adds a DataRep to the display sharing the same Y axis range
The first two methods adds existing DataRep or Function to the
Display. The third method creates and adds DataRep to the
Display. Arguments are same as Display constructor.
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyDataRep*)
addDataRep( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
addDataRep( (Display)arg1, (Function)arg2) -> None :
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyFunctionRep*)
- addDataRepStacked(...)
- addDataRepStacked( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
addDataRepStacked ( string, DataSource, tuple ) -> Display
Creates and adds a DataRep with independent Y axis ranges.
The arguments are the same as Display constructor.
C++ signature :
void addDataRepStacked(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
- addFunction(...)
- addFunction( (Display)arg1, (FunctionBase)arg2) -> None :
addFunction ( FunctionBase ) -> None
Adds a FunctionBase object to the display by appropriately
wrapping it with a Function.
C++ signature :
void addFunction(hippodraw::QtDisplay {lvalue},hippodraw::FunctionBase*)
- addObserver(...)
- addObserver( (Display)arg1, (Observer)arg2) -> None :
addObserver ( Observer ) -> None
Adds an Observer to the Display object.
C++ signature :
void addObserver(hippodraw::QtDisplay {lvalue},hippodraw::Observer*)
- addValues(...)
- addValues( (Display)arg1, (object)arg2) -> None :
addValue ( tuple ) -> None
For static histograms, adds a value to the accumulation.
For 1D histogram, the tuple should contain one or two values,
the second used as a weight. For 2D histogram, the tuple should
contain two or three elements, the third being the weight.
non static Displays do nothing.
C++ signature :
void addValues(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
- applyCut(...)
- applyCut( (Display)arg1, (Display)arg2) -> None :
applyCut ( Cut ) -> None
Apply a Cut to the Display
C++ signature :
void applyCut(hippodraw::QtDisplay {lvalue},hippodraw::QtDisplay*)
- applyCuts(...)
- applyCuts( (Display)arg1, (object)arg2) -> None :
applyCuts ( sequence ) -> None
Apply each Cut in the sequence to the Display
C++ signature :
void applyCuts(hippodraw::QtDisplay {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
- createDataArray(...)
- createDataArray( (Display)arg1) -> DataArray :
createDataArray ( ) -> DataArray
Returns a DataArray representation of the Display's contents
(This method available if configured with numarray)
C++ signature :
hippodraw::PyDataSource* createDataArray(hippodraw::QtDisplay {lvalue})
- currentView(...)
- currentView( (Display)arg1) -> int :
currentView ( ) -> int
Index of the current view.
C++ signature :
int currentView(hippodraw::QtDisplay {lvalue})
- deleteView(...)
- deleteView( (Display)arg1, (int)arg2) -> None :
deleteView ( int ) -> None
Delete a view by index.
C++ signature :
void deleteView(hippodraw::QtDisplay {lvalue},int)
- getBinWidth(...)
- getBinWidth( (Display)arg1, (str)arg2) -> float :
getBinWidth ( string ) -> value
Returns the bin width on axis specified as a string,
e.g., 'x'.
C++ signature :
double getBinWidth(hippodraw::QtDisplay {lvalue},std::string)
- getDataRep(...)
- getDataRep( (Display)arg1) -> DataRep :
getDataRep ( ) -> DataRep
Returns a reference to the active DataRep or if all DataRep objects are
active, returns a reference to the first one.
C++ signature :
hippodraw::PyDataRep* getDataRep(hippodraw::QtDisplay {lvalue})
- getDataReps(...)
- getDataReps( (Display)arg1) -> object :
getDataReps ( ) -> list
Returns a list of DataRep objects contained by the Display..
C++ signature :
std::vector<hippodraw::PyDataRep*, std::allocator<hippodraw::PyDataRep*> > getDataReps(hippodraw::QtDisplay {lvalue})
- getLabel(...)
- getLabel( (Display)arg1, (str)arg2) -> str :
getLabel ( string ) -> string
Returns the label of the axis specified as a string,
e.g., 'x'.
C++ signature :
std::string getLabel(hippodraw::QtDisplay {lvalue},std::string)
- getLog(...)
- getLog( (Display)arg1, (str)arg2) -> int :
getLog ( string ) -> value
Returns True if axis specified as a string, e.g. 'x', is being
displayed on a logarithmic scale.
C++ signature :
int getLog(hippodraw::QtDisplay {lvalue},std::string)
- getRange(...)
- getRange( (Display)arg1, (str)arg2) -> object :
getRange ( string ) -> tuple
Returns the tuple representing the range for the axis specified
as a string, e.g., 'x'.
C++ signature :
std::vector<double, std::allocator<double> > getRange(hippodraw::QtDisplay {lvalue},std::string)
- getTitle(...)
- getTitle( (Display)arg1) -> str :
getTitle () -> string
Returns the current title. The title will be the title of
the DataSource unless it has been explicitly changed.
C++ signature :
std::string getTitle(hippodraw::QtDisplay {lvalue})
- nextView(...)
- nextView( (Display)arg1, (bool)arg2) -> int :
nextView ( bool ) -> int
Cycle to the next view in the view buffer. Set the argument to True to cycle for wards, False to cycle back wards.
Returns the index of the new view.
C++ signature :
int nextView(hippodraw::QtDisplay {lvalue},bool)
- numViews(...)
- numViews( (Display)arg1) -> int :
numViews ( ) -> int
Return the number of stored views.
C++ signature :
int numViews(hippodraw::QtDisplay {lvalue})
- numberOfEntries(...)
- numberOfEntries( (Display)arg1) -> float :
numberOfEntries ( ) -> value
Returns the number of entries in the Display.
C++ signature :
double numberOfEntries(hippodraw::QtDisplay {lvalue})
- plotterId(...)
- plotterId( (Display)arg1) -> int :
plotterId () -> value
Returns a unique identifier for the Display.
C++ signature :
int plotterId(hippodraw::QtDisplay {lvalue})
- reset(...)
- reset( (Display)arg1) -> None :
reset () -> None
Resets the contents of all bins. Only applicable to static
histograms.
C++ signature :
void reset(hippodraw::QtDisplay {lvalue})
- resize(...)
- resize( (Display)arg1) -> None :
resize () -> None
Resizes the Display to its saved values.
C++ signature :
void resize(hippodraw::QtDisplay {lvalue})
- saveView(...)
- saveView( (Display)arg1) -> int :
saveView ( ) -> int
Saves the current set of x and y ranges and returns the index of the saved view.
C++ signature :
int saveView(hippodraw::QtDisplay {lvalue})
- setAspectRatio(...)
- setAspectRatio( (Display)arg1, (float)arg2) -> None :
setAspectRatio ( value ) -> None
Sets the required aspect ratio of the Display to value, the
ratio of the width to the height.
C++ signature :
void setAspectRatio(hippodraw::QtDisplay {lvalue},double)
- setAutoRanging(...)
- setAutoRanging( (Display)arg1, (str)arg2, (bool)arg3) -> None :
setAutoRanging ( string, Boolean ) -> None
Sets auto-ranging on axis specified as a string, e.g. 'x',non or off.
C++ signature :
void setAutoRanging(hippodraw::QtDisplay {lvalue},std::string,bool)
- setAutoTicks(...)
- setAutoTicks( (Display)arg1, (str)arg2, (bool)arg3) -> None :
setAutoTicks ( Boolean ) -> None
Set the ticks generation to be automatic (the default) or
manually.
C++ signature :
void setAutoTicks(hippodraw::QtDisplay {lvalue},std::string,bool)
- setBinWidth(...)
- setBinWidth( (Display)arg1, (str)arg2, (float)arg3, (bool)arg4) -> None :
Set the bin width, explicitly saving the value or not.
C++ signature :
void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double,bool)
setBinWidth( (Display)arg1, (str)arg2, (float)arg3) -> None :
setBinWidth ( string, value ) -> None
Set the bin width to value on axis specified as a string,
e.g., 'x'.
C++ signature :
void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double)
- setColorMap(...)
- setColorMap( (Display)arg1, (str)arg2) -> None :
setColorMap ( string ) -> None
Set the value-to-color map to one named by the argument.
C++ signature :
void setColorMap(hippodraw::QtDisplay {lvalue},std::string)
- setContourLevels(...)
- setContourLevels( (Display)arg1, (object)arg2) -> None :
setContourLevels ( sequence ) -> None
Sets the contour levels if the Display is using contour point
representation from the values in the sequence.
C++ signature :
void setContourLevels(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
- setLabel(...)
- setLabel( (Display)arg1, (str)arg2, (str)arg3) -> None :
setLabel ( string, string ) -> None
Sets the label for the axis specified by first argument to value
of the second argument.
C++ signature :
void setLabel(hippodraw::QtDisplay {lvalue},std::string,std::string)
- setLog(...)
- setLog( (Display)arg1, (str)arg2, (int)arg3) -> None :
setLog ( string, Boolean ) -> None
Sets the axis specified by the first argument on log scale.
C++ signature :
void setLog(hippodraw::QtDisplay {lvalue},std::string,int)
- setNumberOfBins(...)
- setNumberOfBins( (Display)arg1, (str)arg2, (int)arg3) -> None :
setNumberOfBins ( string, value ) -> None
Sets the number of bins on named axis, e.g. 'x' to the given
value.
C++ signature :
void setNumberOfBins(hippodraw::QtDisplay {lvalue},std::string,unsigned int)
- setOffset(...)
- setOffset( (Display)arg1, (str)arg2, (float)arg3) -> None :
setOffset ( string, value ) -> None
Sets the offset of the bins relative to their current width on
specified axis.
C++ signature :
void setOffset(hippodraw::QtDisplay {lvalue},std::string,double)
- setPointRep(...)
- setPointRep( (Display)arg1, (RepBase)arg2) -> None :
setPointRep ( RepBase ) -> None
Sets the point representation to be used.
C++ signature :
void setPointRep(hippodraw::QtDisplay {lvalue},hippodraw::RepBase*)
- setRange(...)
- setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
C++ signature :
void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double)
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4, (bool)arg5) -> None :
setRange ( string, value, value ) -> None
setRange ( string, value, value, Boolean ) -> None
Set the upper and lower bounds for the specified axis. For the
second form, also save them if the Boolean argument is true.
C++ signature :
void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double,bool)
- setTicks(...)
- setTicks( (Display)arg1, (str)arg2, (object)arg3, (object)arg4) -> None :
setTicks ( string, sequence, sequence ) -> None
Sets the tick locations and labels. The first argument is the
axis, the second argument is a sequence containing the
locations, and the third argument is a sequence of tick labels.
C++ signature :
void setTicks(hippodraw::QtDisplay {lvalue},std::string,std::vector<double, std::allocator<double> >,std::vector<std::string, std::allocator<std::string> >)
- setTitle(...)
- setTitle( (Display)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the display.
C++ signature :
void setTitle(hippodraw::QtDisplay {lvalue},std::string)
- setTransform(...)
- setTransform( (Display)arg1, (str)arg2) -> None :
setTransform ( string ) -> None
Sets the transform object.
C++ signature :
void setTransform(hippodraw::QtDisplay {lvalue},std::string)
- setView(...)
- setView( (Display)arg1, (int)arg2) -> None :
setView ( int ) -> None
Set the view by its index.
C++ signature :
void setView(hippodraw::QtDisplay {lvalue},int)
- unlock(...)
- unlock( (Display)arg1) -> None :
unlock () -> None
Unlock the application thread.
C++ signature :
void unlock(hippodraw::QtDisplay {lvalue})
- update(...)
- update( (Display)arg1) -> None :
update () -> None
Updates the display.
C++ signature :
void update(hippodraw::QtDisplay {lvalue})
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class DataArray(Boost.Python.instance) |
|
A DataArray wraps a DataSource object so that numerical Python
arrays can be used as both input and output. The numerical array
can be either a numarray.array or Numeric.array depending on
how the hippo module was configured.
Access to the array is done like a Python list or dictionary.
array = my_data_array [ index ] # list form
array = my_data_array [ 'my_label' ] # dict form
Storage to the array is also done like a Python list or dictionary.
my_data_array [ index ] = ... # list form
my_data_array [ 'my_label' ] = ... # dict form |
|
- Method resolution order:
- DataArray
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __getitem__(...)
- __getitem__( (DataArray)arg1, (str)arg2) -> NDArray :
__getitem__ ( value ) -> array
Returns a copy of the column as numerical array. 'value' can
be either the column label or its index.
C++ signature :
boost::python::numeric::array __getitem__(hippodraw::PyDataSource {lvalue},std::string)
__getitem__( (DataArray)arg1, (int)arg2) -> NDArray :
C++ signature :
boost::python::numeric::array __getitem__(hippodraw::PyDataSource {lvalue},unsigned int)
- __init__(...)
- __init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (str)arg2) -> None :
DataArray ( string ) -> DataArray
Creates a DataArray. The string can be one of
ListTuple
NTuple
NumArrayTuple
C++ signature :
void __init__(_object*,std::string)
- __reduce__ = (...)
- __setitem__(...)
- __setitem__( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
__setitem__ ( label, sequence ) -> None
Copies the contensts of the sequence. If column with label
already exists, replaces it, otherwise add a new column.
C++ signature :
void __setitem__(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
__setitem__( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
__setitem__ ( value, array ) -> None
Copies the contents of array. If `'value' is an index, then
replaces the contents of the existing column. If 'value' is
a label then either replaces existing column with that label
or adds a new column.
C++ signature :
void __setitem__(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
__setitem__( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
C++ signature :
void __setitem__(hippodraw::PyDataSource {lvalue},unsigned int,boost::python::numeric::array)
- addColumn(...)
- addColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> int :
addColumn ( string, list ) -> value
addColumn ( string, array ) -> value
Adds a column. The string will be the label of the column.
A copy of the list or array values will be the contents.
The second form is only available if HippoDraw was configured
with numerical Python support. Returns the new column's index.
C++ signature :
int addColumn(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
addColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> int :
C++ signature :
int addColumn(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
- addRow(...)
- addRow( (DataArray)arg1, (object)arg2) -> None :
addRow ( sequence ) -> None
Adds a row to the held DataSource object if supported, otherwise throws Runtime exception.
C++ signature :
void addRow(hippodraw::PyDataSource {lvalue},std::vector<double, std::allocator<double> >)
- append(...)
- append( (DataArray)arg1, (DataSource)arg2) -> None :
append ( DataArray ) -> None
append ( DataSource ) -> None
Appends contents of DataSource or DataArray to the DataArray.
C++ signature :
void append(hippodraw::PyDataSource {lvalue},hippodraw::DataSource const*)
append( (DataArray)arg1, (DataArray)arg2) -> None :
C++ signature :
void append(hippodraw::PyDataSource {lvalue},hippodraw::PyDataSource const*)
- dataSource(...)
- dataSource( (DataArray)arg1) -> DataSource :
dataSource () -> DataSource
Returns reference to underlying DataSource
C++ signature :
hippodraw::DataSource dataSource(hippodraw::PyDataSource {lvalue})
- getColumn(...)
- getColumn( (DataArray)arg1, (int)arg2) -> object :
getColumn ( value ) -> list
Returns a column as list of floats. 'value' maybe either
the column label or its index.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::PyDataSource {lvalue},unsigned int)
getColumn( (DataArray)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::PyDataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataArray)arg1) -> object :
getLabels () -> list
Returns the list of string objects of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::PyDataSource {lvalue})
- getTitle(...)
- getTitle( (DataArray)arg1) -> str :
getTitle () -> string
Returns title of the DataSource.
C++ signature :
std::string getTitle(hippodraw::PyDataSource {lvalue})
- has_key(...)
- has_key( (DataArray)arg1, (str)arg2) -> bool :
has_key ( string ) -> Boolean
Returns True if column with label exists.
C++ signature :
bool has_key(hippodraw::PyDataSource {lvalue},std::string)
- keys(...)
- keys( (DataArray)arg1) -> object :
keys () -> list
Returns the list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > keys(hippodraw::PyDataSource {lvalue})
- register(...)
- register( (DataArray)arg1, (str)arg2) -> None :
register ( string ) -> None
register ( ) -> string
Register the underlying DataSource with the
DataSourceController. The first form registers it with the
given name, while the second from returns a unique name
generated by the controller.
C++ signature :
void register(hippodraw::PyDataSource {lvalue},std::string)
register( (DataArray)arg1) -> str :
C++ signature :
std::string register(hippodraw::PyDataSource {lvalue})
- replaceColumn(...)
- replaceColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( value, list ) -> None
replaceColumn ( value, array ) -> None
Replace column by its label or index. The second form is
only available if HippoDraw was configure with numerical
arrays.
C++ signature :
void replaceColumn(hippodraw::PyDataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
replaceColumn( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
C++ signature :
void replaceColumn(hippodraw::PyDataSource {lvalue},unsigned int,std::vector<double, std::allocator<double> >)
replaceColumn( (DataArray)arg1, (str)arg2, (object)arg3) -> None :
C++ signature :
void replaceColumn(hippodraw::PyDataSource {lvalue},std::string,boost::python::numeric::array)
replaceColumn( (DataArray)arg1, (int)arg2, (object)arg3) -> None :
C++ signature :
void replaceColumn(hippodraw::PyDataSource {lvalue},unsigned int,boost::python::numeric::array)
- setName(...)
- setName( (DataArray)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the DataSource. The name should be unique
with one application and may appear in the Inspector panel.
C++ signature :
void setName(hippodraw::PyDataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataArray)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the DataSource. The title is what appears,
by default, at the top of a Display.
C++ signature :
void setTitle(hippodraw::PyDataSource {lvalue},std::string)
Static methods defined here:
- getCurrent(...)
- getCurrent() -> DataArray :
getCurrent () -> DataArray
Returns a DataArray that wraps the current DataSource.
C++ signature :
hippodraw::PyDataSource* getCurrent()
Data descriptors defined here:
- columns
- rows
Data and other attributes defined here:
- __instance_size__ = 40
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class DataRep(Boost.Python.instance) |
|
A base class for representing data in various ways. For example, a
a histogram is a way to represent a column of data. |
|
- Method resolution order:
- DataRep
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
DataRep ( string ) -> DataRep
DataRep ( string, DataSource, sequence ) -> DataRep
DataRep ( DataRep ) -> DataRep
Constructors for DataRep objects. The first form creates a
static version. The second form creates a dynamic version
bound to a DataSource with bindings taken from the strings in
the sequence. The final version makes a copy of existing
DataRep.
For the names of the types of DataRep classes available
see names().
C++ signature :
void __init__(_object*,std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (str)arg2, (DataArray)arg3, (object)arg4) -> None :
C++ signature :
void __init__(_object*,std::string,hippodraw::PyDataSource const*,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (DataRep)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyDataRep*)
- __reduce__ = (...)
- addCut(...)
- addCut( (DataRep)arg1) -> None :
addCut ( ) -> None
Adds a cut to limit the region given to a fitter.
C++ signature :
void addCut(hippodraw::PyDataRep {lvalue})
- applyCut(...)
- applyCut( (DataRep)arg1, (Cut)arg2) -> None :
applyCut ( Cut ) -> None
Applies a Cut to limit the rows of the DataSource used by
the Display.
C++ signature :
void applyCut(hippodraw::PyDataRep {lvalue},hippodraw::QtCut*)
- applyCuts(...)
- applyCuts( (DataRep)arg1, (object)arg2) -> None :
applyCuts ( sequence ) -> None
Applies a sequence of Cut object to limit the rows of
the DataSource used by the Display.
C++ signature :
void applyCuts(hippodraw::PyDataRep {lvalue},std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >)
- colorNames(...)
- colorNames( (DataRep)arg1) -> object :
colorNames () -> tuple
Returns a list of available color names.
C++ signature :
std::vector<std::string, std::allocator<std::string> > colorNames(hippodraw::PyDataRep {lvalue})
- createNTuple(...)
- createNTuple( (DataRep)arg1) -> NTupleInternal :
createNTuple () -> NTuple
Creates and returns an NTuple representation of the object.
C++ signature :
hippodraw::NTuple const* createNTuple(hippodraw::PyDataRep {lvalue})
- createNTupleUnderRegion(...)
- createNTupleUnderRegion( (DataRep)arg1) -> NTupleInternal :
createNTupleUnderRegion () -> NTuple
Creates and returns a NTuple contain only rows that pass the
region cuts.
C++ signature :
hippodraw::NTuple* createNTupleUnderRegion(hippodraw::PyDataRep {lvalue})
- getBinWidth(...)
- getBinWidth( (DataRep)arg1, (str)arg2) -> float :
getBinWidth ( string ) -> value
Returns the bin width on specified axis. Only meaningful if
object is histogram type.
C++ signature :
double getBinWidth(hippodraw::PyDataRep {lvalue},std::string)
- getColumnWithCuts(...)
- getColumnWithCuts( (DataRep)arg1, (str)arg2) -> object :
getColumnWithCuts ( column ) -> tuple
Creates and returns the named column, with cuts applied.
C++ signature :
std::vector<double, std::allocator<double> > getColumnWithCuts(hippodraw::PyDataRep {lvalue},std::string)
- getMean(...)
- getMean( (DataRep)arg1, (str)arg2) -> float :
getMean ( string ) -> value
Returns the mean of the data along specified axis
C++ signature :
double getMean(hippodraw::PyDataRep {lvalue},std::string)
- getNTupleWithCuts(...)
- getNTupleWithCuts( (DataRep)arg1) -> NTupleInternal :
getNTupleWithCuts () -> NTuple
Creates and returns to NTuple being used, with cuts applied.
C++ signature :
hippodraw::NTuple* getNTupleWithCuts(hippodraw::PyDataRep {lvalue})
- getRMS(...)
- getRMS( (DataRep)arg1, (str)arg2) -> float :
getRMS ( string ) -> value
Returns root mean squared of data along specified axis
C++ signature :
double getRMS(hippodraw::PyDataRep {lvalue},std::string)
- name(...)
- name( (DataRep)arg1) -> str :
name ( ) -> string
Returns the type of DataRep.
C++ signature :
std::string name(hippodraw::PyDataRep {lvalue})
- normalizeTo(...)
- normalizeTo( (DataRep)arg1, (DataRep)arg2) -> None :
normalizeTo ( DataRep ) -> None
Sets the object to normalize itself to a target one
C++ signature :
void normalizeTo(hippodraw::PyDataRep {lvalue},hippodraw::PyDataRep const*)
- numberOfEntries(...)
- numberOfEntries( (DataRep)arg1) -> float :
numberOfEntries ( ) -> value
Returns the number of entries.
C++ signature :
double numberOfEntries(hippodraw::PyDataRep {lvalue})
- set(...)
- set( (DataRep)arg1, (ColorValue)arg2) -> None :
set ( ColorValue ) -> None
set ( Line ) -> None
set ( Symbol ) -> None
Sets the color, line style or Symbol of the RepBase object.
Use ColorValue.values, Line.values, or Symbol.values to see
available values.
C++ signature :
void set(hippodraw::PyDataRep {lvalue},hippodraw::Color::Value)
set( (DataRep)arg1, (Line)arg2) -> None :
C++ signature :
void set(hippodraw::PyDataRep {lvalue},hippodraw::Line::Style)
set( (DataRep)arg1, (Symbol)arg2) -> None :
C++ signature :
void set(hippodraw::PyDataRep {lvalue},hippodraw::Symbol::Type)
- setAxisBinding(...)
- setAxisBinding( (DataRep)arg1, (str)arg2, (str)arg3) -> None :
setAxisBinding ( string, string ) -> None
Sets an axis binding. The first argument is the axis and the
second is a label of a column in the DataSource.
C++ signature :
void setAxisBinding(hippodraw::PyDataRep {lvalue},std::string,std::string)
- setAxisBindings(...)
- setAxisBindings( (DataRep)arg1, (object)arg2) -> None :
setAxisBindings ( string, sequence ) -> None
Sets all the axes bindings. The first argument is the axis and
the sequence contains labels of columns in the DataSource.
C++ signature :
void setAxisBindings(hippodraw::PyDataRep {lvalue},std::vector<std::string, std::allocator<std::string> >)
- setBinWidth(...)
- setBinWidth( (DataRep)arg1, (str)arg2, (float)arg3) -> None :
setBinWidth ( string, value ) -> None
Sets the width of the bins, if data representation is binned.
C++ signature :
void setBinWidth(hippodraw::PyDataRep {lvalue},std::string,double)
- setColor(...)
- setColor( (DataRep)arg1, (str)arg2) -> None :
setColor ( string ) -> None
Sets the color of the point representation.
See DataRep.colorNames() for list of available colors.
C++ signature :
void setColor(hippodraw::PyDataRep {lvalue},std::string)
- setCutRange(...)
- setCutRange( (DataRep)arg1, (float)arg2, (float)arg3) -> None :
setCutRange ( low, high ) -> None
Sets the low and high end of the region highlight
C++ signature :
void setCutRange(hippodraw::PyDataRep {lvalue},double,double)
- setErrorDisplay(...)
- setErrorDisplay( (DataRep)arg1, (str)arg2, (bool)arg3) -> None :
setErrorDisplay ( string, boolean ) -> None
Turns on or off display of error bars, if available, on
specified axis.
C++ signature :
void setErrorDisplay(hippodraw::PyDataRep {lvalue},std::string,bool)
- setLineStyle(...)
- setLineStyle( (DataRep)arg1, (str)arg2) -> None :
setLineStyle ( string ) -> None
Sets the line style.
This method is deprecated, use DataRep.set(Line) instead.
C++ signature :
void setLineStyle(hippodraw::PyDataRep {lvalue},std::string)
- setPointRep(...)
- setPointRep( (DataRep)arg1, (RepBase)arg2) -> None :
setPointRep ( RepBase ) -> None
Sets the point representation.
C++ signature :
void setPointRep(hippodraw::PyDataRep {lvalue},hippodraw::RepBase*)
- setSize(...)
- setSize( (DataRep)arg1, (float)arg2) -> None :
setSize ( value ) -> None
Sets the size of the point representation.
C++ signature :
void setSize(hippodraw::PyDataRep {lvalue},double)
- setSymbol(...)
- setSymbol( (DataRep)arg1, (str)arg2, (float)arg3) -> None :
setSymbol ( string, value ) -> None
Sets the point symbol and size. This method is deprecated, use
DataRep.set(Symbol) and DataRep.setSize() instead.
C++ signature :
void setSymbol(hippodraw::PyDataRep {lvalue},std::string,float)
- setWeight(...)
- setWeight( (DataRep)arg1, (str)arg2) -> None :
setWeight ( string ) -> None
Sets the weight option if DataRep is a type of histogram.
The string is a label of a column in the DataSource.
C++ signature :
void setWeight(hippodraw::PyDataRep {lvalue},std::string)
Static methods defined here:
- names(...)
- names() -> object :
names () -> tuple
Returns a tuple containing the names of the types of DataRep
that are available.
C++ signature :
std::vector<std::string, std::allocator<std::string> > names()
Data and other attributes defined here:
- __instance_size__ = 48
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class DataSource(Boost.Python.instance) |
|
This class is an abstract base class defining the data table,
called an ntuple. That is a table with some number of columns and a
perhaps large number of rows. It implements some of the
but the actual data storage is done in a derived class. |
|
- Method resolution order:
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- clear(...)
- clear( (DataSource)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::DataSource {lvalue})
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- replaceColumn(...)
- replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( label, list ) -> None
Replaces the column of data by abel.
C++ signature :
void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors defined here:
- columns
- rows
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Display(Boost.Python.instance) |
|
A wrapper for the HippoDraw PlotterBase C++ class.
See HippoDraw's QtDisplay documentation for more details. |
|
- Method resolution order:
- Display
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1, (str)arg2) -> None :
Display ( string ) -> Display
Display ( string, DataSource, tuple ) -> Display
Display ( string, DataArray, tuple ) - > Display
Display ( string, tuple, tuple ) -> Display
Display ( string, list, tuple ) -> Display
Display ( string, RootNTuple, tuple ) -> Display
Display ( string, RootNTuple, tuple, tuple ) -> Display
This method is used to create a Display object.
The first method is used for creating static version of
Histogram, etc., where the string is the type of DataRep.
The remaining methods are for dynamic versions.
The string argument is the type. The second argument
is the DataSource and the third argument is tuple of
string for the binding to the DataSource.
For the last method, the fourth argument is a tuple
of integers to access a RootNTuple array variable.
For the names of the types of DataRep classes available
call DataRep.names().
C++ signature :
void __init__(_object*,std::string)
__init__( (object)arg1, (Function)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyFunctionRep*)
__init__( (object)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
C++ signature :
void __init__(_object*,std::string,hippodraw::DataSource,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (str)arg2, (DataArray)arg3, (object)arg4) -> None :
C++ signature :
void __init__(_object*,std::string,hippodraw::PyDataSource,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (str)arg2, (tuple)arg3, (object)arg4) -> None :
C++ signature :
void __init__(_object*,std::string,boost::python::tuple,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (str)arg2, (list)arg3, (object)arg4) -> None :
C++ signature :
void __init__(_object*,std::string,boost::python::list,std::vector<std::string, std::allocator<std::string> >)
- __reduce__ = (...)
- addDataRep(...)
- addDataRep( (Display)arg1, (DataRep)arg2) -> None :
addDataRep ( DataRep ) -> Display
addDataRep ( Function ) -> Display
addDataRep ( string, DataSource, tuple ) -> Display
Adds a DataRep to the display sharing the same Y axis range
The first two methods adds existing DataRep or Function to the
Display. The third method creates and adds DataRep to the
Display. Arguments are same as Display constructor.
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyDataRep*)
addDataRep( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
addDataRep( (Display)arg1, (Function)arg2) -> None :
C++ signature :
void addDataRep(hippodraw::QtDisplay {lvalue},hippodraw::PyFunctionRep*)
- addDataRepStacked(...)
- addDataRepStacked( (Display)arg1, (str)arg2, (DataSource)arg3, (object)arg4) -> None :
addDataRepStacked ( string, DataSource, tuple ) -> Display
Creates and adds a DataRep with independent Y axis ranges.
The arguments are the same as Display constructor.
C++ signature :
void addDataRepStacked(hippodraw::QtDisplay {lvalue},std::string,hippodraw::DataSource const*,std::vector<std::string, std::allocator<std::string> >)
- addFunction(...)
- addFunction( (Display)arg1, (FunctionBase)arg2) -> None :
addFunction ( FunctionBase ) -> None
Adds a FunctionBase object to the display by appropriately
wrapping it with a Function.
C++ signature :
void addFunction(hippodraw::QtDisplay {lvalue},hippodraw::FunctionBase*)
- addObserver(...)
- addObserver( (Display)arg1, (Observer)arg2) -> None :
addObserver ( Observer ) -> None
Adds an Observer to the Display object.
C++ signature :
void addObserver(hippodraw::QtDisplay {lvalue},hippodraw::Observer*)
- addValues(...)
- addValues( (Display)arg1, (object)arg2) -> None :
addValue ( tuple ) -> None
For static histograms, adds a value to the accumulation.
For 1D histogram, the tuple should contain one or two values,
the second used as a weight. For 2D histogram, the tuple should
contain two or three elements, the third being the weight.
non static Displays do nothing.
C++ signature :
void addValues(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
- applyCut(...)
- applyCut( (Display)arg1, (Display)arg2) -> None :
applyCut ( Cut ) -> None
Apply a Cut to the Display
C++ signature :
void applyCut(hippodraw::QtDisplay {lvalue},hippodraw::QtDisplay*)
- applyCuts(...)
- applyCuts( (Display)arg1, (object)arg2) -> None :
applyCuts ( sequence ) -> None
Apply each Cut in the sequence to the Display
C++ signature :
void applyCuts(hippodraw::QtDisplay {lvalue},std::vector<hippodraw::QtDisplay*, std::allocator<hippodraw::QtDisplay*> >)
- createDataArray(...)
- createDataArray( (Display)arg1) -> DataArray :
createDataArray ( ) -> DataArray
Returns a DataArray representation of the Display's contents
(This method available if configured with numarray)
C++ signature :
hippodraw::PyDataSource* createDataArray(hippodraw::QtDisplay {lvalue})
- createNTuple(...)
- createNTuple( (Display)arg1) -> NTuple :
createNTuple ( ) -> NTuple
Returns a NTuple representation of the Display's contents.
C++ signature :
hippodraw::PyNTuple* createNTuple(hippodraw::QtDisplay {lvalue})
- currentView(...)
- currentView( (Display)arg1) -> int :
currentView ( ) -> int
Index of the current view.
C++ signature :
int currentView(hippodraw::QtDisplay {lvalue})
- deleteView(...)
- deleteView( (Display)arg1, (int)arg2) -> None :
deleteView ( int ) -> None
Delete a view by index.
C++ signature :
void deleteView(hippodraw::QtDisplay {lvalue},int)
- getBinWidth(...)
- getBinWidth( (Display)arg1, (str)arg2) -> float :
getBinWidth ( string ) -> value
Returns the bin width on axis specified as a string,
e.g., 'x'.
C++ signature :
double getBinWidth(hippodraw::QtDisplay {lvalue},std::string)
- getDataRep(...)
- getDataRep( (Display)arg1) -> DataRep :
getDataRep ( ) -> DataRep
Returns a reference to the active DataRep or if all DataRep objects are
active, returns a reference to the first one.
C++ signature :
hippodraw::PyDataRep* getDataRep(hippodraw::QtDisplay {lvalue})
- getDataReps(...)
- getDataReps( (Display)arg1) -> object :
getDataReps ( ) -> list
Returns a list of DataRep objects contained by the Display..
C++ signature :
std::vector<hippodraw::PyDataRep*, std::allocator<hippodraw::PyDataRep*> > getDataReps(hippodraw::QtDisplay {lvalue})
- getLabel(...)
- getLabel( (Display)arg1, (str)arg2) -> str :
getLabel ( string ) -> string
Returns the label of the axis specified as a string,
e.g., 'x'.
C++ signature :
std::string getLabel(hippodraw::QtDisplay {lvalue},std::string)
- getLog(...)
- getLog( (Display)arg1, (str)arg2) -> int :
getLog ( string ) -> value
Returns True if axis specified as a string, e.g. 'x', is being
displayed on a logarithmic scale.
C++ signature :
int getLog(hippodraw::QtDisplay {lvalue},std::string)
- getRange(...)
- getRange( (Display)arg1, (str)arg2) -> object :
getRange ( string ) -> tuple
Returns the tuple representing the range for the axis specified
as a string, e.g., 'x'.
C++ signature :
std::vector<double, std::allocator<double> > getRange(hippodraw::QtDisplay {lvalue},std::string)
- getTitle(...)
- getTitle( (Display)arg1) -> str :
getTitle () -> string
Returns the current title. The title will be the title of
the DataSource unless it has been explicitly changed.
C++ signature :
std::string getTitle(hippodraw::QtDisplay {lvalue})
- nextView(...)
- nextView( (Display)arg1, (bool)arg2) -> int :
nextView ( bool ) -> int
Cycle to the next view in the view buffer. Set the argument to True to cycle for wards, False to cycle back wards.
Returns the index of the new view.
C++ signature :
int nextView(hippodraw::QtDisplay {lvalue},bool)
- numViews(...)
- numViews( (Display)arg1) -> int :
numViews ( ) -> int
Return the number of stored views.
C++ signature :
int numViews(hippodraw::QtDisplay {lvalue})
- numberOfEntries(...)
- numberOfEntries( (Display)arg1) -> float :
numberOfEntries ( ) -> value
Returns the number of entries in the Display.
C++ signature :
double numberOfEntries(hippodraw::QtDisplay {lvalue})
- plotterId(...)
- plotterId( (Display)arg1) -> int :
plotterId () -> value
Returns a unique identifier for the Display.
C++ signature :
int plotterId(hippodraw::QtDisplay {lvalue})
- reset(...)
- reset( (Display)arg1) -> None :
reset () -> None
Resets the contents of all bins. Only applicable to static
histograms.
C++ signature :
void reset(hippodraw::QtDisplay {lvalue})
- resize(...)
- resize( (Display)arg1) -> None :
resize () -> None
Resizes the Display to its saved values.
C++ signature :
void resize(hippodraw::QtDisplay {lvalue})
- saveView(...)
- saveView( (Display)arg1) -> int :
saveView ( ) -> int
Saves the current set of x and y ranges and returns the index of the saved view.
C++ signature :
int saveView(hippodraw::QtDisplay {lvalue})
- setAspectRatio(...)
- setAspectRatio( (Display)arg1, (float)arg2) -> None :
setAspectRatio ( value ) -> None
Sets the required aspect ratio of the Display to value, the
ratio of the width to the height.
C++ signature :
void setAspectRatio(hippodraw::QtDisplay {lvalue},double)
- setAutoRanging(...)
- setAutoRanging( (Display)arg1, (str)arg2, (bool)arg3) -> None :
setAutoRanging ( string, Boolean ) -> None
Sets auto-ranging on axis specified as a string, e.g. 'x',non or off.
C++ signature :
void setAutoRanging(hippodraw::QtDisplay {lvalue},std::string,bool)
- setAutoTicks(...)
- setAutoTicks( (Display)arg1, (str)arg2, (bool)arg3) -> None :
setAutoTicks ( Boolean ) -> None
Set the ticks generation to be automatic (the default) or
manually.
C++ signature :
void setAutoTicks(hippodraw::QtDisplay {lvalue},std::string,bool)
- setBinWidth(...)
- setBinWidth( (Display)arg1, (str)arg2, (float)arg3, (bool)arg4) -> None :
Set the bin width, explicitly saving the value or not.
C++ signature :
void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double,bool)
setBinWidth( (Display)arg1, (str)arg2, (float)arg3) -> None :
setBinWidth ( string, value ) -> None
Set the bin width to value on axis specified as a string,
e.g., 'x'.
C++ signature :
void setBinWidth(hippodraw::QtDisplay {lvalue},std::string,double)
- setColorMap(...)
- setColorMap( (Display)arg1, (str)arg2) -> None :
setColorMap ( string ) -> None
Set the value-to-color map to one named by the argument.
C++ signature :
void setColorMap(hippodraw::QtDisplay {lvalue},std::string)
- setContourLevels(...)
- setContourLevels( (Display)arg1, (object)arg2) -> None :
setContourLevels ( sequence ) -> None
Sets the contour levels if the Display is using contour point
representation from the values in the sequence.
C++ signature :
void setContourLevels(hippodraw::QtDisplay {lvalue},std::vector<double, std::allocator<double> >)
- setLabel(...)
- setLabel( (Display)arg1, (str)arg2, (str)arg3) -> None :
setLabel ( string, string ) -> None
Sets the label for the axis specified by first argument to value
of the second argument.
C++ signature :
void setLabel(hippodraw::QtDisplay {lvalue},std::string,std::string)
- setLog(...)
- setLog( (Display)arg1, (str)arg2, (int)arg3) -> None :
setLog ( string, Boolean ) -> None
Sets the axis specified by the first argument on log scale.
C++ signature :
void setLog(hippodraw::QtDisplay {lvalue},std::string,int)
- setNumberOfBins(...)
- setNumberOfBins( (Display)arg1, (str)arg2, (int)arg3) -> None :
setNumberOfBins ( string, value ) -> None
Sets the number of bins on named axis, e.g. 'x' to the given
value.
C++ signature :
void setNumberOfBins(hippodraw::QtDisplay {lvalue},std::string,unsigned int)
- setOffset(...)
- setOffset( (Display)arg1, (str)arg2, (float)arg3) -> None :
setOffset ( string, value ) -> None
Sets the offset of the bins relative to their current width on
specified axis.
C++ signature :
void setOffset(hippodraw::QtDisplay {lvalue},std::string,double)
- setPointRep(...)
- setPointRep( (Display)arg1, (RepBase)arg2) -> None :
setPointRep ( RepBase ) -> None
Sets the point representation to be used.
C++ signature :
void setPointRep(hippodraw::QtDisplay {lvalue},hippodraw::RepBase*)
- setRange(...)
- setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
C++ signature :
void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double)
setRange( (Display)arg1, (str)arg2, (float)arg3, (float)arg4, (bool)arg5) -> None :
setRange ( string, value, value ) -> None
setRange ( string, value, value, Boolean ) -> None
Set the upper and lower bounds for the specified axis. For the
second form, also save them if the Boolean argument is true.
C++ signature :
void setRange(hippodraw::QtDisplay {lvalue},std::string,double,double,bool)
- setTicks(...)
- setTicks( (Display)arg1, (str)arg2, (object)arg3, (object)arg4) -> None :
setTicks ( string, sequence, sequence ) -> None
Sets the tick locations and labels. The first argument is the
axis, the second argument is a sequence containing the
locations, and the third argument is a sequence of tick labels.
C++ signature :
void setTicks(hippodraw::QtDisplay {lvalue},std::string,std::vector<double, std::allocator<double> >,std::vector<std::string, std::allocator<std::string> >)
- setTitle(...)
- setTitle( (Display)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the display.
C++ signature :
void setTitle(hippodraw::QtDisplay {lvalue},std::string)
- setTransform(...)
- setTransform( (Display)arg1, (str)arg2) -> None :
setTransform ( string ) -> None
Sets the transform object.
C++ signature :
void setTransform(hippodraw::QtDisplay {lvalue},std::string)
- setView(...)
- setView( (Display)arg1, (int)arg2) -> None :
setView ( int ) -> None
Set the view by its index.
C++ signature :
void setView(hippodraw::QtDisplay {lvalue},int)
- unlock(...)
- unlock( (Display)arg1) -> None :
unlock () -> None
Unlock the application thread.
C++ signature :
void unlock(hippodraw::QtDisplay {lvalue})
- update(...)
- update( (Display)arg1) -> None :
update () -> None
Updates the display.
C++ signature :
void update(hippodraw::QtDisplay {lvalue})
Data and other attributes defined here:
- __instance_size__ = 144
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FCNBase(Boost.Python.instance) |
|
The base class for the objective function used in fitting. |
|
- Method resolution order:
- FCNBase
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FactoryPointRep(Boost.Python.instance) |
|
A private base class for PointRepFactory. |
|
- Method resolution order:
- FactoryPointRep
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FitsController(Boost.Python.instance) |
|
A class for creation of DataSource objects from a FITS file. |
|
- Method resolution order:
- FitsController
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- createDataArray(...)
- createDataArray( (FitsController)arg1, (str)arg2, (str)arg3) -> DataArray :
createDataArray ( string, string ) -> DataArray
Creates DataArray from a file with key name
C++ signature :
hippodraw::PyDataSource* createDataArray(hippodraw::PyFitsController {lvalue},std::string,std::string)
- createNTuple(...)
- createNTuple( (FitsController)arg1, (str)arg2, (str)arg3) -> FitsNTuple :
createNTuple ( string, string ) -> FitsNTuple
Creates FitsNTuple from the named file with key name. Python
take possession of it.
C++ signature :
hippodraw::FitsNTuple* createNTuple(hippodraw::PyFitsController {lvalue},std::string,std::string)
- getNTupleNames(...)
- getNTupleNames( (FitsController)arg1, (str)arg2) -> object :
getNTupleNames ( string ) -> sequence
Returns the names of the HDU data source objects in the file.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getNTupleNames(hippodraw::PyFitsController {lvalue},std::string)
- writeToFile(...)
- writeToFile( (FitsController)arg1, (DataArray)arg2, (str)arg3) -> None :
writeToFile ( DataArray, filename ) -> None.
writeToFile ( DataSource, filename ) -> None,
writeToFile ( DataArray, filename, tuple, tuple ) -> None.
writeToFile ( DataSource, filename, tuple, tuple ) -> None,
Writes a DataSource or DataArray to FITS file as binary table.
In the latter two forms, the first tuple is list of Cuts and
and the second is tuple of column labels
C++ signature :
void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::PyDataSource const*,std::string)
writeToFile( (FitsController)arg1, (DataSource)arg2, (str)arg3) -> None :
C++ signature :
void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::DataSource const*,std::string)
writeToFile( (FitsController)arg1, (DataSource)arg2, (str)arg3, (object)arg4, (object)arg5) -> None :
C++ signature :
void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::DataSource const*,std::string,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,std::vector<std::string, std::allocator<std::string> >)
writeToFile( (FitsController)arg1, (DataArray)arg2, (str)arg3, (object)arg4, (object)arg5) -> None :
C++ signature :
void writeToFile(hippodraw::PyFitsController {lvalue},hippodraw::PyDataSource const*,std::string,std::vector<hippodraw::QtCut*, std::allocator<hippodraw::QtCut*> >,std::vector<std::string, std::allocator<std::string> >)
Static methods defined here:
- instance(...)
- instance() -> FitsController :
instance () -> FitsController
Returns the single instance of the controller.
C++ signature :
hippodraw::PyFitsController* instance()
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FitsNTuple(DataSource) |
|
a derived class of DataSource that references a table or image in a
FITS file. A FitNTuple object must be created by the FitsController.Changes made to this object will not be reflected in the FITS file. |
|
- Method resolution order:
- FitsNTuple
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- addColumn(...)
- addColumn( (FitsNTuple)arg1, (str)arg2, (object)arg3) -> int :
addColumn ( string, list or tuple ) -> value
Adds a column to the data source. The string argument is used
for the label of the new column. The length of the new column
must the same as existing columns. The value returns is the
index to the column.
C++ signature :
int addColumn(hippodraw::FitsNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
- replaceColumn(...)
- replaceColumn( (FitsNTuple)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( index, list ) -> None
replaceColumn ( label, list ) -> None
Replaces the column of data by index or label. Does not
modify the FITS file.
C++ signature :
void replaceColumn(hippodraw::FitsNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
replaceColumn( (FitsNTuple)arg1, (int)arg2, (object)arg3) -> None :
C++ signature :
void replaceColumn(hippodraw::FitsNTuple {lvalue},unsigned int,std::vector<double, std::allocator<double> >)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Methods inherited from DataSource:
- clear(...)
- clear( (DataSource)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::DataSource {lvalue})
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from DataSource:
- columns
- rows
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Fitter(Boost.Python.instance) |
|
Provides an interface to objective function minimizers. |
|
- Method resolution order:
- Fitter
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- getFCN(...)
- getFCN( (Fitter)arg1) -> StatedFCN :
getFCN () -> FCNBase
Returns the objective function.
C++ signature :
hippodraw::StatedFCN* getFCN(hippodraw::Fitter {lvalue})
- minimize(...)
- minimize( (Fitter)arg1) -> bool :
minimize () -> Boolean
Attempts to do a minimization, returns True if successful.
C++ signature :
bool minimize(hippodraw::Fitter {lvalue})
- name(...)
- name( (Fitter)arg1) -> str :
name () -> string
Returns the minimizer name.
C++ signature :
std::string name(hippodraw::Fitter {lvalue})
- setFixedFlags(...)
- setFixedFlags( (Fitter)arg1, (object)arg2) -> None :
setFixedFlags ( sequence ) -> None
Sets which parameters that should be fixed during a fit. A
`1' in the sequence indicates corresponding parameters is fixed.
C++ signature :
void setFixedFlags(hippodraw::Fitter {lvalue},std::vector<int, std::allocator<int> >)
- setLimits(...)
- setLimits( (Fitter)arg1, (int)arg2, (float)arg3, (float)arg4) -> None :
C++ signature :
void setLimits(hippodraw::Fitter {lvalue},unsigned int,double,double)
setLimits( (Fitter)arg1, (str)arg2, (float)arg3, (float)arg4) -> None :
setLimits ( name, low, high ) -> None
setLimits ( index, low, high ) -> None
Sets the limits on a model function parameter. Only minimizers
based on Minuit support this feature, others throw an exception.
C++ signature :
void setLimits(hippodraw::Fitter {lvalue},std::string,double,double)
- setStepSize(...)
- setStepSize( (Fitter)arg1, (int)arg2, (float)arg3) -> None :
C++ signature :
void setStepSize(hippodraw::Fitter {lvalue},unsigned int,double)
setStepSize( (Fitter)arg1, (str)arg2, (float)arg3) -> None :
setStepSize ( name, value ) -> None
setStepSize ( index, value ) -> None
Sets the step size for the model function parameter. Only
minimizers based on Minuit support this function, others
throw an exception.
C++ signature :
void setStepSize(hippodraw::Fitter {lvalue},std::string,double)
Data descriptors defined here:
- degreesOfFreedom
- objectiveValue
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FitterFactory(Boost.Python.instance) |
|
The factory for returning fitters preloaded with objective functions. |
|
- Method resolution order:
- FitterFactory
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- create(...)
- create( (FitterFactory)arg1, (str)arg2) -> Fitter :
create ( string ) -> Fitter
Returns the newly created fitter object.
C++ signature :
hippodraw::Fitter* create(hippodraw::FitterFactory {lvalue},std::string)
- names(...)
- names( (FitterFactory)arg1) -> object :
names () -> sequence
Returns the names of the available fitters.
C++ signature :
std::vector<std::string, std::allocator<std::string> > names(hippodraw::FitterFactory {lvalue})
- setDefault(...)
- setDefault( (FitterFactory)arg1, (str)arg2) -> None :
setDefault ( string ) -> None
Sets the default fitter object. Throws an exception if given
invalid name.
C++ signature :
void setDefault(hippodraw::FitterFactory {lvalue},std::string)
Static methods defined here:
- instance(...)
- instance() -> FitterFactory :
instance () -> FitterFactory
Returns the single instance of the FitterFactory
C++ signature :
hippodraw::FitterFactory* instance()
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Function(Boost.Python.instance) |
|
This class wraps a FunctionBase object with a DataRep. This allows
it to be drawn in a Display. It also provides interface to member
functions of FunctionBase, although the user could obtain a
reference to the FunctionBase itself to do so. |
|
- Method resolution order:
- Function
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1, (str)arg2, (DataRep)arg3) -> None :
Function ( string, DataRep ) -> Function
Function ( FunctionBase, DataRep ) -> Function
The first form creates a function using the string to find the
FunctionBase in the FunctionFactory. The second form creates a
using an existing FunctionBase object. Both forms use the DataRep
as target for fitting and drawing
C++ signature :
void __init__(_object*,std::string,hippodraw::PyDataRep*)
__init__( (object)arg1, (FunctionBase)arg2 [, (DataRep)arg3]) -> None :
C++ signature :
void __init__(_object*,hippodraw::FunctionBase* [,hippodraw::PyDataRep*])
- __reduce__ = (...)
- addTo(...)
- addTo( (Function)arg1, (Display)arg2) -> None :
addTo ( Display ) -> None
Adds the Function to a Display. taking the Display's selected
DataRep as its target.
C++ signature :
void addTo(hippodraw::PyFunctionRep {lvalue},hippodraw::QtDisplay*)
- chiSquared(...)
- chiSquared( (Function)arg1) -> float :
chiSquare ( None ) -> value
Returns the Chi-Squared.
C++ signature :
double chiSquared(hippodraw::PyFunctionRep {lvalue})
- createResidualsDisplay(...)
- createResidualsDisplay( (Function)arg1) -> Display :
createResidualsDisplay ( None ) -> Display
Returns residuals Display object. The residuals display is an
XY plot showing the difference between the function values and
the target DataRep values.
C++ signature :
hippodraw::QtDisplay* createResidualsDisplay(hippodraw::PyFunctionRep {lvalue})
- degreesOfFreedom(...)
- degreesOfFreedom( (Function)arg1) -> int :
degressOfFreedom ( None ) -> value
Returns the number of degrees of freedom a fitter would have.
C++ signature :
int degreesOfFreedom(hippodraw::PyFunctionRep {lvalue})
- errors(...)
- errors( (Function)arg1) -> object :
errors ( None ) - > list
Returns the errors on the parameters. The errors are calculated
by a fitter, thus the values returned are only valid after
having done a fit.
C++ signature :
std::vector<double, std::allocator<double> > errors(hippodraw::PyFunctionRep {lvalue})
- fit(...)
- fit( (Function)arg1) -> bool :
fit ( None ) -> boolean
Attempts to fit the the function to the target DataRep.
Uses the currently selected fitter, unless one was explicitly
set. Note the fit is always done to linear sum if more than one
function is on the data.
C++ signature :
bool fit(hippodraw::PyFunctionRep {lvalue})
- getFitterName(...)
- getFitterName( (Function)arg1) -> str :
getFitterName ( None ) -> string
Returns the current fitter name.
C++ signature :
std::string getFitterName(hippodraw::PyFunctionRep {lvalue})
- objectiveValue(...)
- objectiveValue( (Function)arg1) -> float :
objectiveValue ( None ) -> value
Returns the objective Value that the fitter minimizes.
Typically it is the Chi-Squared.
C++ signature :
double objectiveValue(hippodraw::PyFunctionRep {lvalue})
- parameters(...)
- parameters( (Function)arg1) -> object :
parameters ( None ) -> list
Returns a list of the function's parameter values.
C++ signature :
std::vector<double, std::allocator<double> > parameters(hippodraw::PyFunctionRep {lvalue})
- parmNames(...)
- parmNames( (Function)arg1) -> object :
parmNames ( None ) -> list
Returns a list of parameter names.
C++ signature :
std::vector<std::string, std::allocator<std::string> > parmNames(hippodraw::PyFunctionRep {lvalue})
- principleErrors(...)
- principleErrors( (Function)arg1) -> object :
principleErrors ( None ) -> list
Returns the errors on the parameters.
C++ signature :
std::vector<double, std::allocator<double> > principleErrors(hippodraw::PyFunctionRep {lvalue})
- setFitRange(...)
- setFitRange( (Function)arg1, (float)arg2, (float)arg3) -> None :
setFitRange ( low, high ) -> None
Sets the range of the coordinate axis that is used for fitting.
C++ signature :
void setFitRange(hippodraw::PyFunctionRep {lvalue},double,double)
- setFitRangeEnabled(...)
- setFitRangeEnabled( (Function)arg1, (bool)arg2) -> None :
setFitRange ( boolean ) -> None
Enabled use of the fit range
C++ signature :
void setFitRangeEnabled(hippodraw::PyFunctionRep {lvalue},bool)
- setFitter(...)
- setFitter( (Function)arg1, (str)arg2) -> None :
setFitter ( string ) -> None
Sets the fitter by name from fitter factory.
C++ signature :
void setFitter(hippodraw::PyFunctionRep {lvalue},std::string)
- setFixedFlags(...)
- setFixedFlags( (Function)arg1, (object)arg2) -> None :
setFixedFlags ( list ) -> None
Set which parameters should be held fixed during fitting.
C++ signature :
void setFixedFlags(hippodraw::PyFunctionRep {lvalue},std::vector<int, std::allocator<int> >)
- setParameters(...)
- setParameters( (Function)arg1, (object)arg2) -> None :
setParameters ( list ) -> None
Sets the function's parameter values.
C++ signature :
void setParameters(hippodraw::PyFunctionRep {lvalue},std::vector<double, std::allocator<double> >)
- valueAt(...)
- valueAt( (Function)arg1, (float)arg2) -> float :
valueAt ( x ) -> value
Returns the function's value at given coordinate.
C++ signature :
double valueAt(hippodraw::PyFunctionRep {lvalue},double)
Data and other attributes defined here:
- __instance_size__ = 32
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class FunctionBase(Boost.Python.instance) |
|
The base class for raw functions. FunctionBase objects need to
wrapped with Function objects to be displayed. FunctionBase
can be derived from and cloned so they can be added to the
FunctionFactory. |
|
- Method resolution order:
- FunctionBase
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1, (FunctionBase)arg2) -> None :
FunctionBase () -> FunctionBase
FunctionBase ( FunctionBase ) -> FunctionBase
Constructors of the FunctionBase object.
C++ signature :
void __init__(_object*,hippodraw::FunctionBase)
__init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (FunctionBase)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::FunctionWrap)
- __reduce__ = (...)
- getParameters(...)
- getParameters( (FunctionBase)arg1) -> object :
getParameters () -> sequence
Returns the current function parameter values.
C++ signature :
std::vector<double, std::allocator<double> > getParameters(hippodraw::FunctionBase {lvalue})
- initialize(...)
- initialize( (FunctionBase)arg1) -> None :
initialize () -> None
Initializes the function parameter values and the names.
The number of parameters is taken from the number of names.
C++ signature :
void initialize(hippodraw::FunctionWrap {lvalue})
- name(...)
- name( (FunctionBase)arg1) -> str :
name () -> string
Returns the name of the function.
C++ signature :
std::string name(hippodraw::FunctionBase {lvalue})
- parmNames(...)
- parmNames( (FunctionBase)arg1) -> object :
parmNames () -> sequence
Returns the names of the parameters
C++ signature :
std::vector<std::string, std::allocator<std::string> > parmNames(hippodraw::FunctionBase {lvalue})
- setName(...)
- setName( (FunctionBase)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the function.
C++ signature :
void setName(hippodraw::FunctionWrap {lvalue},std::string)
- setParameters(...)
- setParameters( (FunctionBase)arg1, (object)arg2) -> None :
setParameters ( sequence ) -> None
Sets the values of the parameters.
C++ signature :
void setParameters(hippodraw::FunctionBase {lvalue},std::vector<double, std::allocator<double> >)
- setParmNames(...)
- setParmNames( (FunctionBase)arg1, (object)arg2) -> None :
setParmNames ( sequence ) -> None
Sets the parameter names and re-sizes the parameters
C++ signature :
void setParmNames(hippodraw::FunctionWrap {lvalue},std::vector<std::string, std::allocator<std::string> >)
Data and other attributes defined here:
- __instance_size__ = 24
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class HDApp(Boost.Python.instance) |
|
The HippoDraw application class. |
|
- Method resolution order:
- HDApp
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (int)arg2) -> None :
HDApp () -> HDApp
HDApp ( value ) -> HDApp
Using the constructor with no arguments creates
a HippoDraw application that runs in a separate
thread.
Using the constructor with one argument creates
a HippoDraw application in same thread. Use
app.exec_loop() to start it.
C++ signature :
void __init__(_object*,int)
__init__( (object)arg1, (str)arg2) -> None :
HDapp ( string ) -> HDapp
C++ signature :
void __init__(_object*,char*)
- __reduce__ = (...)
- canvas(...)
- canvas( (HDApp)arg1) -> Canvas :
canvas () -> Canvas
Returns the current canvas window.
C++ signature :
hippodraw::PyCanvas* canvas(hippodraw::PyApp {lvalue})
- exec_loop(...)
- exec_loop( (HDApp)arg1) -> int :
exec_loop () -> value
Starts the application object. Returns the value returned
by the application object upon exiting.
C++ signature :
int exec_loop(hippodraw::PyApp {lvalue})
- hasTerminated(...)
- hasTerminated( (HDApp)arg1) -> bool :
hasTerminated () -> Boolean
Returns True if the application has terminated.
C++ signature :
bool hasTerminated(hippodraw::PyApp {lvalue})
- lock(...)
- lock() -> None :
lock () -> None
Lock the Qt library Mutex. Will not return until no
other thread has the lock.
C++ signature :
void lock()
- openDocument(...)
- openDocument( (HDApp)arg1, (str)arg2) -> None :
openDocument ( string ) -> None
Opens new canvas window from saved document file.
C++ signature :
void openDocument(hippodraw::PyApp {lvalue},std::string)
- quit(...)
- quit( (HDApp)arg1) -> None :
quit () -> None
Closes all Canvas windows and Terminates the application.
C++ signature :
void quit(hippodraw::PyApp {lvalue})
- quitOnLastWindowClose(...)
- quitOnLastWindowClose( (HDApp)arg1, (bool)arg2) -> None :
quitOnLastWindowClose ( Boolean ) -> None
If argument is True, allows application to quit when last
Canvas is closed.
C++ signature :
void quitOnLastWindowClose(hippodraw::PyApp {lvalue},bool)
- unlock(...)
- unlock() -> None :
unlock () -> None
Unlocks the application thread.
C++ signature :
void unlock()
Static methods defined here:
- instance(...)
- instance() -> HDApp :
instance () -> HDApp
Returns a singleton instance of the HippoDraw
application object
C++ signature :
hippodraw::PyApp* instance()
Data and other attributes defined here:
- __instance_size__ = 24
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Line(Boost.Python.enum) |
| |
- Method resolution order:
- Line
- Boost.Python.enum
- __builtin__.int
- __builtin__.object
Data and other attributes defined here:
- dash = hippo.Line.dash
- dashdot = hippo.Line.dashdot
- dashdotdot = hippo.Line.dashdotdot
- dot = hippo.Line.dot
- invisible = hippo.Line.invisible
- solid = hippo.Line.solid
- values = {0: hippo.Line.solid, 1: hippo.Line.dash, 2: hippo.Line.dot, 3: hippo.Line.dashdot, 4: hippo.Line.dashdotdot, 5: hippo.Line.invisible}
Methods inherited from Boost.Python.enum:
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data descriptors inherited from Boost.Python.enum:
- name
Methods inherited from __builtin__.int:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- __xor__(...)
- x.__xor__(y) <==> x^y
- conjugate(...)
- Returns self, the complex conjugate of any int.
Data descriptors inherited from __builtin__.int:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
Data and other attributes inherited from __builtin__.int:
- __new__ = <built-in method __new__ of type object at 0xfffff801002ca208>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class ListTuple(DataSource) |
|
A derived class from DataSource containing columns as references to
Python list objects. This allows the data to be used without making
a copy of it. However, access to the data is slower than for most
of the other classes derived from DataSource |
|
- Method resolution order:
- ListTuple
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
ListTuple ( None ) -> ListTuple
Creates an empty ListTuple
C++ signature :
void __init__(_object*)
- __reduce__ = (...)
- addColumn(...)
- addColumn( (ListTuple)arg1, (str)arg2, (list)arg3) -> int :
addColumn ( string, list ) -> value
Adds the array as a new column with label from the string.
Returns the index of the new column.
C++ signature :
int addColumn(hippodraw::ListTuple {lvalue},std::string,boost::python::list)
- getLabel(...)
- getLabel( (ListTuple)arg1, (int)arg2) -> str :
getLabel ( index ) -> string
Returns label of column.
C++ signature :
std::string getLabel(hippodraw::ListTuple {lvalue},unsigned int)
- notifyObservers(...)
- notifyObservers( (ListTuple)arg1) -> None :
notifyObservers ( None ) -> None
Sends update message to all observers. Use this member if the
contents of the reference Python list has changed and Display
objects bound to it require updating.
C++ signature :
void notifyObservers(hippodraw::ListTuple {lvalue})
- replaceColumn(...)
- replaceColumn( (ListTuple)arg1, (int)arg2, (list)arg3) -> None :
replaceColumn ( index, list ) -> None
Replaces existing column with list
C++ signature :
void replaceColumn(hippodraw::ListTuple {lvalue},unsigned int,boost::python::list)
replaceColumn( (ListTuple)arg1, (str)arg2, (list)arg3) -> None :
replaceColumn ( string, list ) -> None
Replaces existing column with new array
C++ signature :
void replaceColumn(hippodraw::ListTuple {lvalue},std::string,boost::python::list)
- setLabels(...)
- setLabels( (ListTuple)arg1, (object)arg2) -> None :
setLabels ( list or tuple ) -> None
Sets the labels of the columns from list of string objects.
For an empty ListTuple object, implicitly sets the number of
columns.
C++ signature :
void setLabels(hippodraw::ListTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)
Data and other attributes defined here:
- __instance_size__ = 208
Methods inherited from DataSource:
- clear(...)
- clear( (DataSource)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::DataSource {lvalue})
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from DataSource:
- columns
- rows
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class NTuple(NTupleInternal) |
|
A derived class of DataSource that stores its tabular data vectors of
double precision numbers in C++. An NTuple object can be created in
a number of ways including reading from a file using the
NTupleController |
|
- Method resolution order:
- NTuple
- NTupleInternal
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
NTuple ( None ) -> NTuple
NTuple ( value ) -> NTuple
NTuple ( sequence ) -> NTuple
NTuple ( NTuple ) -> NTuple
The form with no arguments creates an empty NTuple with no rows
or columns. The form with one value argument creates an empty
NTuple with `value' number of columns. The form with a sequence
argument creates an empty NTuple with the number of columns equal
to size of the sequence. The sequence should contain string which
are used as the column labels. The last form form creates an
NTuple
whose contents is a copy of an existing one.
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (int)arg2) -> None :
C++ signature :
void __init__(_object*,unsigned int)
__init__( (object)arg1, (object)arg2) -> None :
C++ signature :
void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (NTuple)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::PyNTuple)
- __reduce__ = (...)
- addColumn(...)
- addColumn( (NTuple)arg1, (str)arg2, (object)arg3) -> int :
addColumn ( label, sequence ) -> index
Adds a new column with label.
C++ signature :
int addColumn(hippodraw::PyNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
- addRow(...)
- addRow( (NTuple)arg1, (object)arg2) -> None :
addRow ( sequence ) -> None
Append a row at the end.
C++ signature :
void addRow(hippodraw::PyNTuple {lvalue},std::vector<double, std::allocator<double> >)
- append(...)
- append( (NTuple)arg1, (DataSource)arg2) -> None :
append ( DataSource ) -> None
Appends the contents of the DataSource to the NTuple.
C++ signature :
void append(hippodraw::PyNTuple {lvalue},hippodraw::DataSource const*)
- clear(...)
- clear( (NTuple)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::PyNTuple {lvalue})
- replaceColumn(...)
- replaceColumn( (NTuple)arg1, (int)arg2, (object)arg3) -> None :
replaceColumn ( index, sequence ) -> None
Replaces the indexed column.
C++ signature :
void replaceColumn(hippodraw::PyNTuple {lvalue},unsigned int,std::vector<double, std::allocator<double> >)
replaceColumn( (NTuple)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( label, sequence ) -> None
Replaces the labeled column.
C++ signature :
void replaceColumn(hippodraw::PyNTuple {lvalue},std::string,std::vector<double, std::allocator<double> >)
- setTitle(...)
- setTitle( (NTuple)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::PyNTuple {lvalue},std::string)
Data and other attributes defined here:
- __instance_size__ = 224
Methods inherited from NTupleInternal:
- getLabel(...)
- getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
getLabel ( index ) -> string
Returns the label at column index.
C++ signature :
std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
- getRow(...)
- getRow( (NTupleInternal)arg1, (int)arg2) -> object :
getRow ( index ) -> list
Returns the index row as list floats.
C++ signature :
std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
- setIntervalCount(...)
- setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
setIntervalCount ( count ) -> None
Sets the interval count between updates to the observers.
C++ signature :
void setIntervalCount(hippodraw::NTuple {lvalue},int)
- setIntervalEnabled(...)
- setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
setIntervalEnable ( Boolean ) -> None
Sets the interval counting on or off
C++ signature :
void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
- setLabels(...)
- setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
setLabels ( sequence ) -> None
Sets the labels of the columns from the list of strings. If the
NTuple is empty, then also sets the number of columns to be the
size of the list. If the number of columns has already been
set, the the size of the list should be the same, otherwise
a RuntimeError exception is thrown.
C++ signature :
void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)
Methods inherited from DataSource:
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from DataSource:
- columns
- rows
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class NTupleController(Boost.Python.instance) |
|
A singleton object to manage NTuple objects. |
|
- Method resolution order:
- NTupleController
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- changeName(...)
- changeName( (NTupleController)arg1, (DataSource)arg2, (str)arg3) -> None :
changeName ( DataSource, string ) -> None
Change the name of an NTuple.
This method is deprecated, there's not need to do this
C++ signature :
void changeName(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*,std::string)
- createCircularBuffer(...)
- createCircularBuffer( (NTupleController)arg1, (int)arg2) -> CircularBuffer :
createCircularBuffer ( value ) -> CircularBuffer
Creates and registers a CircularBuffer object with set number of
columns.
C++ signature :
hippodraw::CircularBuffer* createCircularBuffer(hippodraw::PyNTupleController {lvalue},unsigned int)
- createDataArray(...)
- createDataArray( (NTupleController)arg1, (str)arg2) -> DataArray :
createDataArray ( filename ) -> DataArray
Creates a DataArray from file.
C++ signature :
hippodraw::PyDataSource* createDataArray(hippodraw::PyNTupleController {lvalue},std::string)
- createNTuple(...)
- createNTuple( (NTupleController)arg1) -> NTupleInternal :
Creates an empty NTuple
C++ signature :
hippodraw::NTuple* createNTuple(hippodraw::PyNTupleController {lvalue})
createNTuple( (NTupleController)arg1, (str)arg2) -> DataSource :
createNTuple () -> NTuple
createNTuple ( string ) -> NTuple
Creates and registers an NTuple. The first method creates an
empty NTuple object. The second method creates one from a
file. Both methods return ownership of the created object to
Python.
C++ signature :
hippodraw::DataSource* createNTuple(hippodraw::PyNTupleController {lvalue},std::string)
- findNTuple(...)
- findNTuple( (NTupleController)arg1, (str)arg2) -> DataSource :
findNTuple ( string ) -> DataSource
Find an registered NTuple by its name and returns a reference to
it. If the DataSource can not be found, an exception is thrown.
Warning: if more than one DataSource has the same name,
the first one found is returned.
C++ signature :
hippodraw::DataSource* findNTuple(hippodraw::PyNTupleController {lvalue},std::string)
- registerNTuple(...)
- registerNTuple( (NTupleController)arg1, (DataSource)arg2) -> str :
Register an NTuple to make it visible to the application
C++ signature :
std::string registerNTuple(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*)
registerNTuple( (NTupleController)arg1, (str)arg2, (DataSource)arg3) -> None :
registerNTuple ( DataSource ) -> None
registerNTuple ( string, DataSource ) -> None
Register an NTuple to make it visible to the application. The
first form takes the name from the DataSource object, if it has
one, otherwise generates a unique name. The second form takes
string argument for the name.
C++ signature :
void registerNTuple(hippodraw::PyNTupleController {lvalue},std::string,hippodraw::DataSource*)
- writeToFile(...)
- writeToFile( (NTupleController)arg1, (DataSource)arg2, (str)arg3) -> int :
writeToFile ( DataSource, string ) -> value
Writes the NTuple to a file as ASCII text. Returns 0 if
successful.
C++ signature :
int writeToFile(hippodraw::PyNTupleController {lvalue},hippodraw::DataSource*,std::string)
Static methods defined here:
- instance(...)
- instance() -> NTupleController :
instance () -> NTupleController
Returns the single instance of the controller
C++ signature :
hippodraw::PyNTupleController* instance()
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class NTupleFCN(StatedFCN) |
|
A objective function class used in fitting that uses a DataSource to
access the data |
|
- Method resolution order:
- NTupleFCN
- StatedFCN
- FCNBase
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- setDataSource(...)
- setDataSource( (NTupleFCN)arg1, (DataSource)arg2) -> None :
C++ signature :
void setDataSource(hippodraw::NTupleFCN {lvalue},hippodraw::DataSource const*)
setDataSource( (NTupleFCN)arg1, (DataSource)arg2, (int)arg3, (object)arg4) -> None :
setDataSource ( DataSource ) -> None
setDataSource ( DataSource, value, sequence ) -> None
The first form sets the data source with default indexes. The
second form takes in addition the dimensionality of the
coordinate and a column indexes from the sequence.
C++ signature :
void setDataSource(hippodraw::NTupleFCN {lvalue},hippodraw::DataSource const*,int,std::vector<int, std::allocator<int> >)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Methods inherited from StatedFCN:
- degreesOfFreedom(...)
- degreesOfFreedom( (StatedFCN)arg1) -> int :
degreesOfFreedom () -> value
Returns the degrees of freedom as integer.
C++ signature :
int degreesOfFreedom(hippodraw::StatedFCN {lvalue})
- objectiveValue(...)
- objectiveValue( (StatedFCN)arg1) -> float :
objectiveValue () -> value
Returns the objective value. For example, the objective
might be the Chi-Squared when derived class returns it as
its objective value.
C++ signature :
double objectiveValue(hippodraw::StatedFCN {lvalue})
- setFunction(...)
- setFunction( (StatedFCN)arg1, (FunctionBase)arg2) -> None :
setFunction ( FunctionBase ) -> None
Sets the model function.
C++ signature :
void setFunction(hippodraw::StatedFCN {lvalue},hippodraw::FunctionBase*)
- setUseErrors(...)
- setUseErrors( (StatedFCN)arg1, (bool)arg2) -> bool :
setUseErrors ( Boolean ) -> None
Sets the FCN to use errors on the data source if they exist.
C++ signature :
bool setUseErrors(hippodraw::StatedFCN {lvalue},bool)
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class NTupleInternal(DataSource) |
|
A derived class of DataSource that stores its tabular data vectors of
double precision numbers in C++. An NTuple object can be created in
a number of ways including reading from a file using the
NTupleController |
|
- Method resolution order:
- NTupleInternal
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
NTuple ( None ) -> NTuple
NTuple ( value ) -> NTuple
NTuple ( sequence ) -> NTuple
NTuple ( NTuple ) -> NTuple
The form with no arguments creates an empty NTuple with no rows
or columns. The form with one value argument creates an empty
NTuple with `value' number of columns. The form with a sequence
argument creates an empty NTuple with the number of columns equal
to size of the sequence. The sequence should contain string which
are used as the column labels. The last form form creates an
NTuple
whose contents is a copy of an existing one.
C++ signature :
void __init__(_object*)
__init__( (object)arg1, (int)arg2) -> None :
C++ signature :
void __init__(_object*,unsigned int)
__init__( (object)arg1, (object)arg2) -> None :
C++ signature :
void __init__(_object*,std::vector<std::string, std::allocator<std::string> >)
__init__( (object)arg1, (NTupleInternal)arg2) -> None :
C++ signature :
void __init__(_object*,hippodraw::NTuple)
- __reduce__ = (...)
- getLabel(...)
- getLabel( (NTupleInternal)arg1, (int)arg2) -> str :
getLabel ( index ) -> string
Returns the label at column index.
C++ signature :
std::string getLabel(hippodraw::NTuple {lvalue},unsigned int)
- getRow(...)
- getRow( (NTupleInternal)arg1, (int)arg2) -> object :
getRow ( index ) -> list
Returns the index row as list floats.
C++ signature :
std::vector<double, std::allocator<double> > getRow(hippodraw::NTuple {lvalue},unsigned int)
- setIntervalCount(...)
- setIntervalCount( (NTupleInternal)arg1, (int)arg2) -> None :
setIntervalCount ( count ) -> None
Sets the interval count between updates to the observers.
C++ signature :
void setIntervalCount(hippodraw::NTuple {lvalue},int)
- setIntervalEnabled(...)
- setIntervalEnabled( (NTupleInternal)arg1, (bool)arg2) -> None :
setIntervalEnable ( Boolean ) -> None
Sets the interval counting on or off
C++ signature :
void setIntervalEnabled(hippodraw::NTuple {lvalue},bool)
- setLabels(...)
- setLabels( (NTupleInternal)arg1, (object)arg2) -> None :
setLabels ( sequence ) -> None
Sets the labels of the columns from the list of strings. If the
NTuple is empty, then also sets the number of columns to be the
size of the list. If the number of columns has already been
set, the the size of the list should be the same, otherwise
a RuntimeError exception is thrown.
C++ signature :
void setLabels(hippodraw::NTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)
Data and other attributes defined here:
- __instance_size__ = 224
Methods inherited from DataSource:
- clear(...)
- clear( (DataSource)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::DataSource {lvalue})
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- replaceColumn(...)
- replaceColumn( (DataSource)arg1, (str)arg2, (object)arg3) -> None :
replaceColumn ( label, list ) -> None
Replaces the column of data by abel.
C++ signature :
void replaceColumn(hippodraw::DataSource {lvalue},std::string,std::vector<double, std::allocator<double> >)
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from DataSource:
- columns
- rows
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class NumArrayTuple(DataSource) |
|
Interface to numarray Python extension module. |
|
- Method resolution order:
- NumArrayTuple
- DataSource
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
Creates an empty NumArrayTuple
C++ signature :
void __init__(_object*)
- __reduce__ = (...)
- addColumn(...)
- addColumn( (NumArrayTuple)arg1, (str)arg2, (object)arg3) -> int :
Adds the array as a new column with label
C++ signature :
int addColumn(hippodraw::NumArrayTuple {lvalue},std::string,boost::python::numeric::array)
- getLabel(...)
- getLabel( (NumArrayTuple)arg1, (int)arg2) -> str :
C++ signature :
std::string getLabel(hippodraw::NumArrayTuple {lvalue},unsigned int)
- notifyObservers(...)
- notifyObservers( (NumArrayTuple)arg1) -> None :
Sends update message to all observers.
C++ signature :
void notifyObservers(hippodraw::NumArrayTuple {lvalue})
- replaceColumn(...)
- replaceColumn( (NumArrayTuple)arg1, (int)arg2, (object)arg3) -> None :
Replaces existing column with new array
Args:
index
numarray
C++ signature :
void replaceColumn(hippodraw::NumArrayTuple {lvalue},unsigned int,boost::python::numeric::array)
replaceColumn( (NumArrayTuple)arg1, (str)arg2, (object)arg3) -> None :
Replaces existing column with new array
Args:
label
numarray
C++ signature :
void replaceColumn(hippodraw::NumArrayTuple {lvalue},std::string,boost::python::numeric::array)
- setLabels(...)
- setLabels( (NumArrayTuple)arg1, (object)[label, ...]) -> None :
Sets the labels of the columns.
C++ signature :
void setLabels(hippodraw::NumArrayTuple {lvalue},std::vector<std::string, std::allocator<std::string> >)
Data and other attributes defined here:
- __instance_size__ = 208
Methods inherited from DataSource:
- clear(...)
- clear( (DataSource)arg1) -> None :
clear () -> None
Clears the data elements of the DataSource. That is, remove
all the rows while keeping the column labels.
C++ signature :
void clear(hippodraw::DataSource {lvalue})
- getColumn(...)
- getColumn( (DataSource)arg1, (int)arg2) -> object :
getColumn ( label ) -> list
getColumn ( index ) -> list
Get a column by its label or index. Returns copy of the
contents.
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},unsigned int)
getColumn( (DataSource)arg1, (str)arg2) -> object :
C++ signature :
std::vector<double, std::allocator<double> > getColumn(hippodraw::DataSource {lvalue},std::string)
- getLabels(...)
- getLabels( (DataSource)arg1) -> object :
getLabels () -> list
Returns list of column labels.
C++ signature :
std::vector<std::string, std::allocator<std::string> > getLabels(hippodraw::DataSource {lvalue})
- getTitle(...)
- getTitle( (DataSource)arg1) -> str :
getTitle () -> string
Returns the title of the ntuple.
C++ signature :
std::string getTitle(hippodraw::DataSource {lvalue})
- setName(...)
- setName( (DataSource)arg1, (str)arg2) -> None :
setName ( string ) -> None
Sets the name of the ntuple. The name should be a unique
string withing a running application. It may appear in the
Inspector.
C++ signature :
void setName(hippodraw::DataSource {lvalue},std::string)
- setTitle(...)
- setTitle( (DataSource)arg1, (str)arg2) -> None :
setTitle ( string ) -> None
Sets the title of the ntuple. The title by default appears at
the top of a Display.
C++ signature :
void setTitle(hippodraw::DataSource {lvalue},std::string)
Data descriptors inherited from DataSource:
- columns
- rows
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Observable(Boost.Python.instance) |
|
The base class for classes that can be target of an Observer
object. |
|
- Method resolution order:
- Observable
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __init__(...)
- __init__( (object)arg1) -> None :
C++ signature :
void __init__(_object*)
- __reduce__ = (...)
Data and other attributes defined here:
- __instance_size__ = 40
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Observer(Boost.Python.instance) |
|
The base class for classes that can be targets of Observable
update messages. |
|
- Method resolution order:
- Observer
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class RepBase(Boost.Python.instance) |
|
The base class for point and text representations.
See PointRepFactory for creating objects of this type. |
|
- Method resolution order:
- RepBase
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class StatedFCN(FCNBase) |
|
This a base class for objective function used in fitting that
maintains the state of the function's parameters. |
|
- Method resolution order:
- StatedFCN
- FCNBase
- Boost.Python.instance
- __builtin__.object
Methods defined here:
- __reduce__ = (...)
- degreesOfFreedom(...)
- degreesOfFreedom( (StatedFCN)arg1) -> int :
degreesOfFreedom () -> value
Returns the degrees of freedom as integer.
C++ signature :
int degreesOfFreedom(hippodraw::StatedFCN {lvalue})
- objectiveValue(...)
- objectiveValue( (StatedFCN)arg1) -> float :
objectiveValue () -> value
Returns the objective value. For example, the objective
might be the Chi-Squared when derived class returns it as
its objective value.
C++ signature :
double objectiveValue(hippodraw::StatedFCN {lvalue})
- setDataSource(...)
- setDataSource( (StatedFCN)arg1, (DataSource)arg2) -> None :
C++ signature :
void setDataSource(hippodraw::StatedFCN {lvalue},hippodraw::DataSource const*)
setDataSource( (StatedFCN)arg1, (DataSource)arg2, (int)arg3, (object)arg4) -> None :
setDataSource ( DataSource ) -> None
setDataSource ( DataSource, value, sequence ) -> None
The first form sets the data source with default indexes. The
second form takes in addition the dimensionality of the
coordinate and a column indexes from the sequence.
C++ signature :
void setDataSource(hippodraw::StatedFCN {lvalue},hippodraw::DataSource const*,int,std::vector<int, std::allocator<int> >)
- setFunction(...)
- setFunction( (StatedFCN)arg1, (FunctionBase)arg2) -> None :
setFunction ( FunctionBase ) -> None
Sets the model function.
C++ signature :
void setFunction(hippodraw::StatedFCN {lvalue},hippodraw::FunctionBase*)
- setUseErrors(...)
- setUseErrors( (StatedFCN)arg1, (bool)arg2) -> bool :
setUseErrors ( Boolean ) -> None
Sets the FCN to use errors on the data source if they exist.
C++ signature :
bool setUseErrors(hippodraw::StatedFCN {lvalue},bool)
Data and other attributes defined here:
- __init__ = <built-in function __init__>
- Raises an exception
This class cannot be instantiated from Python
Data descriptors inherited from Boost.Python.instance:
- __dict__
- __weakref__
Data and other attributes inherited from Boost.Python.instance:
- __new__ = <built-in method __new__ of Boost.Python.class object at 0xfffff80102049140>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class Symbol(Boost.Python.enum) |
| |
- Method resolution order:
- Symbol
- Boost.Python.enum
- __builtin__.int
- __builtin__.object
Data and other attributes defined here:
- filledcircle = hippo.Symbol.filledcircle
- filledsquare = hippo.Symbol.filledsquare
- filledtriangle = hippo.Symbol.filledtriangle
- invisible = hippo.Symbol.invisible
- opencircle = hippo.Symbol.opencircle
- opensquare = hippo.Symbol.opensquare
- opentriangle = hippo.Symbol.opentriangle
- plus = hippo.Symbol.plus
- times = hippo.Symbol.times
- values = {0: hippo.Symbol.opensquare, 1: hippo.Symbol.filledsquare, 2: hippo.Symbol.plus, 3: hippo.Symbol.times, 4: hippo.Symbol.opentriangle, 5: hippo.Symbol.filledtriangle, 6: hippo.Symbol.opencircle, 7: hippo.Symbol.filledcircle, 8: hippo.Symbol.invisible}
Methods inherited from Boost.Python.enum:
- __repr__(...)
- x.__repr__() <==> repr(x)
- __str__(...)
- x.__str__() <==> str(x)
Data descriptors inherited from Boost.Python.enum:
- name
Methods inherited from __builtin__.int:
- __abs__(...)
- x.__abs__() <==> abs(x)
- __add__(...)
- x.__add__(y) <==> x+y
- __and__(...)
- x.__and__(y) <==> x&y
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __coerce__(...)
- x.__coerce__(y) <==> coerce(x, y)
- __div__(...)
- x.__div__(y) <==> x/y
- __divmod__(...)
- x.__divmod__(y) <==> divmod(x, y)
- __float__(...)
- x.__float__() <==> float(x)
- __floordiv__(...)
- x.__floordiv__(y) <==> x//y
- __format__(...)
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getnewargs__(...)
- __hash__(...)
- x.__hash__() <==> hash(x)
- __hex__(...)
- x.__hex__() <==> hex(x)
- __index__(...)
- x[y:z] <==> x[y.__index__():z.__index__()]
- __int__(...)
- x.__int__() <==> int(x)
- __invert__(...)
- x.__invert__() <==> ~x
- __long__(...)
- x.__long__() <==> long(x)
- __lshift__(...)
- x.__lshift__(y) <==> x<<y
- __mod__(...)
- x.__mod__(y) <==> x%y
- __mul__(...)
- x.__mul__(y) <==> x*y
- __neg__(...)
- x.__neg__() <==> -x
- __nonzero__(...)
- x.__nonzero__() <==> x != 0
- __oct__(...)
- x.__oct__() <==> oct(x)
- __or__(...)
- x.__or__(y) <==> x|y
- __pos__(...)
- x.__pos__() <==> +x
- __pow__(...)
- x.__pow__(y[, z]) <==> pow(x, y[, z])
- __radd__(...)
- x.__radd__(y) <==> y+x
- __rand__(...)
- x.__rand__(y) <==> y&x
- __rdiv__(...)
- x.__rdiv__(y) <==> y/x
- __rdivmod__(...)
- x.__rdivmod__(y) <==> divmod(y, x)
- __rfloordiv__(...)
- x.__rfloordiv__(y) <==> y//x
- __rlshift__(...)
- x.__rlshift__(y) <==> y<<x
- __rmod__(...)
- x.__rmod__(y) <==> y%x
- __rmul__(...)
- x.__rmul__(y) <==> y*x
- __ror__(...)
- x.__ror__(y) <==> y|x
- __rpow__(...)
- y.__rpow__(x[, z]) <==> pow(x, y[, z])
- __rrshift__(...)
- x.__rrshift__(y) <==> y>>x
- __rshift__(...)
- x.__rshift__(y) <==> x>>y
- __rsub__(...)
- x.__rsub__(y) <==> y-x
- __rtruediv__(...)
- x.__rtruediv__(y) <==> y/x
- __rxor__(...)
- x.__rxor__(y) <==> y^x
- __sub__(...)
- x.__sub__(y) <==> x-y
- __truediv__(...)
- x.__truediv__(y) <==> x/y
- __trunc__(...)
- Truncating an Integral returns itself.
- __xor__(...)
- x.__xor__(y) <==> x^y
- conjugate(...)
- Returns self, the complex conjugate of any int.
Data descriptors inherited from __builtin__.int:
- denominator
- the denominator of a rational number in lowest terms
- imag
- the imaginary part of a complex number
- numerator
- the numerator of a rational number in lowest terms
- real
- the real part of a complex number
Data and other attributes inherited from __builtin__.int:
- __new__ = <built-in method __new__ of type object at 0xfffff801002ca208>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
| |