jhplot
Class P1D

java.lang.Object
  extended by jhplot.DrawOptions
      extended by jhplot.P1D

public class P1D
extends DrawOptions

A container to hold data points with 1st and 2nd level errors. The first errors are usually statistical, the second error are systematic. P1D can be used for drawing, manipulation with data etc.


Constructor Summary
P1D(DataHolder dh, int i1, int i2)
          Create P1D data holder from multidimensional data holder.
P1D(DataHolder dh, java.lang.String title, int i1, int i2)
          Create P1D data holder from multidimensional data holder.
P1D(H1D histo)
          Create a P1D container from a histogram.
P1D(H1D histo, boolean binMean)
          Create a P1D container from a histogram.
P1D(H1D histo, boolean binMean, boolean fillXerrors)
          Create a P1D container from a histogram.
P1D(hep.aida.IDataPointSet pd)
          Create a P1D container from IDataPointSet.
P1D(java.lang.String title)
          Construct an empty container with a title
P1D(java.lang.String title, H1D histo)
          Create a P1D container from a histogram.
P1D(java.lang.String title, H1D histo, boolean binMean)
          Create a P1D container from a histogram.
P1D(java.lang.String title, H1D histo, boolean binMean, boolean fillXerrors)
          Create a P1D container from a histogram
P1D(java.lang.String title, int dimension)
          Construct an empty container with a title
P1D(java.lang.String title, java.lang.String sfile)
          Construct a P1D from a file.
 
Method Summary
 void add(double x, double y)
          Adds values of a plot-point pair (X,Y).
 void add(double x, double y, double err)
          Adds the values of a plot-point pair (X,Y).
 void add(double x, double y, double upper, double lower)
          Add values of a plot-point pair (X,Y).
 void add(double x, double y, double left, double right, double upper, double lower)
          Adds the values of a plot-point pair (X,Y).
 void add(double x, double y, double left, double right, double upper, double lower, double left_sys, double right_sys, double upper_sys, double lower_sys)
          Adds the values of a plot-point pair (x,y).
 P1D addAndAverage(P1D[] p1darray)
          Return P1D array with weighted average of several measurements.
 void clear()
          Clear the container
 P1D copy()
          Make a new data holder with the same title from the current one.
 P1D copy(java.lang.String newtitle)
          create an exact of the current holder
 int dimention()
          Returns the dimention of this P1D holder.
 void fill(double[] xa, double[] ya)
          Fill a P1D container from 2 arrays.
 void fill(double[] xa, double[] ya, double[] yerror)
          Fill a P1D container from 3 arrays (one represents symmetrical errors on Y).
 void fill(double[] xa, double[] ya, double[] yupper, double[] ylower)
          Fill a P1D container from 4 arrays (last represents asymmetrical upper and lower errors on Y).
 void fill(double[] x, double[] y, double[] left, double[] right, double[] upper, double[] lower, double[] left_sys, double[] right_sys, double[] upper_sys, double[] lower_sys)
          Fill the values of a X-Y plot-points with full errors.
 void fill(P0D xa, P0D ya)
          Fill a P1D container from 2 P0D arrays.
 void fill(P0D xa, P0D ya, P0D yerror)
          Fill a P1D container from P0D arrays (one represents symmetrical errors on Y).
 double[] getArrayX()
          Get array representing X-values
 double[] getArrayXleft()
          Get array representing X-left errors
 double[] getArrayXleftSys()
          Get array representing X-left 2nd level errors
 double[] getArrayXright()
          Get array representing X-right errors
 double[] getArrayXrightSys()
          Get array representing X-right 2nd level errors
 double[] getArrayY()
          Get array representing Y-values
 double[] getArrayYlower()
          Get array representing Y lower errors
 double[] getArrayYlowerSys()
          Get array representing Y lower 2nd level errors
 double[] getArrayYupper()
          Get array representing Y upper errors
 double[] getArrayYupperSys()
          Get array representing Y upper 2nd level errors
 jplot.DataArray getDataArray()
          Return a DataArray container from JPlot
 hep.aida.IDataPointSet getIDataPointSet()
          Get IDataPointSet.
 jplot.LinePars getLinePars()
          get LinePars class which holds graphical attributes
 double getMax(int axis)
          Returns the maximum value in the range.
 int getMaxIndex(int axis)
          Returns the index of maximum value in the range.
 double getMin(int axis)
          Returns the minimum value in the range.
 int getMinIndex(int axis)
          Returns the index of minimum value in the range.
 P1D getSys(P1D[] p1darray)
          Return P1D array which contains 2nd level errors (or systematic errors) evaluated from an array of P1D data holders.
 java.lang.String getTitle()
          Get a new title
 double getX(int i)
          Return a specific X-value.
 double getXleft(int i)
          Return a specific left error on X-value.
 double getXleftSys(int i)
          Return a specific left error on X-value (systematic error).
 double getXright(int i)
          Return a specific right error on X-value.
 double getXrightSys(int i)
          Return a specific right error on X-value (systematic error).
 double getY(int i)
          Return a specific Y-value.
 double getYlower(int i)
          Return a specific lower error on Y-value.
 double getYlowerSys(int i)
          Return a specific total lower error on Y-value.
 double getYupper(int i)
          Return a specific upper error on Y-value.
 double getYupperSys(int i)
          Return a specific systematical upper error on Y-value.
 double mean()
          Return the mean value
 P1D merge(P1D a)
          Merge two P1D containers.
 P1D move(java.lang.String what, java.lang.String how)
          Transform a P1D data holder to some function with error propagation (for both levels)
 P1D oper(P1D a, java.lang.String what)
          Operations on P1D container: add, subtract, multiply, divide.
 P1D oper(P1D a, java.lang.String title, java.lang.String what)
          Operations on P1D containers: add, subtract, multiply, divide.
 P1D oper(P1D a, java.lang.String title, java.lang.String what, java.lang.String how, P1D corr)
          Operations on P1D containers: add, subtract, multiply, divide.
 P1D operErrSys(java.lang.String title, int axis, P1D left, P1D right)
          Obtain a new P1D with 2nd-level errors on X or Y obtained from two P1D objects, one represents left on X (or lower on Y) error and the other represents the right on X (or upper on Y) error.
 P1D operScale(int axis, double scale)
          Scale P1D container
 P1D operScale(java.lang.String title, int axis, double scale)
          Scale X-values (axis=0) or Y values (axis=1) and their errors with a scale factor.
 P1D operScaleErr(java.lang.String title, int axis, double scale)
          Scale 1st level errors with a scale factor.
 P1D operScaleErrSys(java.lang.String title, int axis, double scale)
          Scale 2nd level errors with a scale factor.
 P1D operSmooth(int axis, boolean isWeighted, int k)
          Smooth P1D data points in either X or Y.
 P1D operSmoothGauss(int axis, double standardDeviation)
          Computes a Gaussian smoothed version of P1D.
 void print()
          Print a P1D container on the screen
 P1D range(int axis, double Min, double Max)
          Construct P1D in the range between Min and Max.
 P1D range(int IndexMin, int IndexMax)
          Construct P1D in the range between Min and Max indeces.
 void replace(int i, double x, double y, double left, double right, double upper, double lower, double left_sys, double right_sys, double upper_sys, double lower_sys)
          replaces the ith value of a plot-point pair (x,y).
 void set(int i, double x, double y)
          Sets the values of a plot-point pair (X,Y).
 void set(int i, double x, double y, double upper, double lower)
          Sets the values of a plot-point pair (x,y).
 void set(int i, double x, double y, double left, double right, double upper, double lower)
          Sets the values of a plot-point pair (x,y).
 void set(int i, double x, double y, double left, double right, double upper, double lower, double left_sys, double right_sys, double upper_sys, double lower_sys)
          Sets the values of a plot-point pair (x,y).
 void setDataArray(jplot.DataArray data)
          Set data in a form of DataArray
 void setDimension(int dimension)
          Set the dimension.
 P1D setErrAllToZero(java.lang.String title, int axis)
          Set all (1st and 2nd) level errors to zero.
 P1D setErrSqrt(java.lang.String title, int axis)
          Set 1st level error to sqrt of X or Y values.
 P1D setErrSysToZero(java.lang.String title, int axis)
          Set 2nd level errors to zero.
 P1D setErrToZero(java.lang.String title, int axis)
          Set 1st level errors to zero.
 void setLinePars(jplot.LinePars pnew)
          Sets LinePars class for graphical attributes
 void setTitle(java.lang.String title)
          Set a new title
 int size()
          Return the length of the data vector.
 void toFile(java.lang.String name)
          Write a P1D to an external file.
 void toFileAsLatex(java.lang.String name, java.text.DecimalFormat dx, java.text.DecimalFormat dy)
          Write a File in form of LaTeX table from values in the container P1D
 void toTable()
          Print the P1D container to a Table in a separate Frame.
 void toTable(boolean format)
          Print the P1D container to a Table in a separate Frame.
 void updateSummary()
          Update summary of the data.
 
Methods inherited from class jhplot.DrawOptions
copyLinePars, getBinWidth, getDrawOption, getDrawOptions, getLegend, getLineParm, getNameX, getNameY, getNameZ, getType, printDrawOptions, printDrawOptions, setBinWidth, setColor, setDrawLine, setDrawOption, setDrawSymbol, setErr, setErrAll, setErrColor, setErrColorX, setErrColorY, setErrFill, setErrFillColor, setErrFillColor, setErrSys, setErrSysFill, setErrSysFillColor, setErrSysFillColor, setErrSysX, setErrSysY, setErrTicSize, setErrX, setErrY, setFill, setFillColor, setFillColorTransparency, setGraphStyle, setLegend, setNameX, setNameY, setNameZ, setPenDash, setPenDash, setPenWidth, setPenWidthErr, setPenWidthErrSys, setStyle, setSymbol, setSymbolSize, setType
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

P1D

public P1D(java.lang.String title)
Construct an empty container with a title

Parameters:
title - New title

P1D

public P1D(java.lang.String title,
           int dimension)
Construct an empty container with a title

Parameters:
title - New title
dimension - dimension (2,4,6,10)

P1D

public P1D(DataHolder dh,
           java.lang.String title,
           int i1,
           int i2)
Create P1D data holder from multidimensional data holder. You should specify a slice which you want to export (X,Y) pair of P1D

Parameters:
dh - Input data container
title - New title
i1 - Index of the first column
i2 - Index of the second column

P1D

public P1D(DataHolder dh,
           int i1,
           int i2)
Create P1D data holder from multidimensional data holder. You should specify a slice which you want to export (X,Y) pair of P1D. The title is default

Parameters:
dh - Input data container
i1 - Index of the first column
i2 - Index of the second column

P1D

public P1D(java.lang.String title,
           java.lang.String sfile)
Construct a P1D from a file. The file should contain 2, or 4, or 6, or 10 columns: 1) x,y: data without any errors 2) x,y, y(upper), y(lower) - data with 1st level errors on Y 3) x,y, x(left), x(right), y(upper), y(lower) - data with 1st level errors on X and Y 4) x,y, x(left), x(right), y(upper), y(lower), x(leftSys), x(rightSys), y(upperSys), y(lowerSys) - data with X and Y and 1st and 2nd level errors

Parameters:
title - Title of the container
sfile - File name with input

P1D

public P1D(hep.aida.IDataPointSet pd)
Create a P1D container from IDataPointSet.

Parameters:
pd - Imported IDataPointSet.

P1D

public P1D(java.lang.String title,
           H1D histo,
           boolean binMean,
           boolean fillXerrors)
Create a P1D container from a histogram

Parameters:
title - New title
histo - Imported histogram
binMean - If true, Y values are put to the mean values in each bin. If false, is just a height in the histogram bin
fillXerrors - If true, errors are set to X values (half of the bin width) If false, errors on X are set to zero

P1D

public P1D(H1D histo,
           boolean binMean,
           boolean fillXerrors)
Create a P1D container from a histogram. The title is set to the histogram title.

Parameters:
histo - Imported histogram
binMean - If true, Y values are put to the mean values in each bin. If false, Y corresponds to height of the histogram bin
fillXerrors - If true, errors are set to X values (half of the bin width) If false, errors on X are set to zero

P1D

public P1D(java.lang.String title,
           H1D histo,
           boolean binMean)
Create a P1D container from a histogram. The title is set to the histogram title. Show errors on X as bin width x 0.5

Parameters:
title - New title
histo - Imported histogram
binMean - If true, Y values are put to the mean values in each bin. If false, Y is just a center of the histogram bin

P1D

public P1D(H1D histo,
           boolean binMean)
Create a P1D container from a histogram. The title is set to the histogram title. Show errors on X as bin width x 0.5

Parameters:
histo - Imported histogram
binMean - If true, Y values are put to the mean values in each bin. If false, Y is just a height of the histogram bin

P1D

public P1D(H1D histo)
Create a P1D container from a histogram. The title is set to the histogram title. Show errors on X as bin width x 0.5. The Y points are set to the mean values in each bin.

Parameters:
histo - Imported histogram

P1D

public P1D(java.lang.String title,
           H1D histo)
Create a P1D container from a histogram. The title is set to the histogram title. Show errors on X as bin width x 0.5 The Y points are set to the mean values in each bin.

Parameters:
title - New title
histo - Imported histogram
Method Detail

setDimension

public void setDimension(int dimension)
Set the dimension. Can be 2,4,6,10

Parameters:
dimension - dimension used.

setTitle

public void setTitle(java.lang.String title)
Set a new title

Overrides:
setTitle in class DrawOptions
Parameters:
title - New Title

getTitle

public java.lang.String getTitle()
Get a new title

Overrides:
getTitle in class DrawOptions
Returns:
Title

getLinePars

public jplot.LinePars getLinePars()
get LinePars class which holds graphical attributes

Returns:
Graphic attributes

setLinePars

public void setLinePars(jplot.LinePars pnew)
Sets LinePars class for graphical attributes

Parameters:
pnew - Graphic attributes

toFileAsLatex

public void toFileAsLatex(java.lang.String name,
                          java.text.DecimalFormat dx,
                          java.text.DecimalFormat dy)
Write a File in form of LaTeX table from values in the container P1D

Parameters:
name - Name of the file
dx - Format of x values
dy - Format of y values

toFile

public void toFile(java.lang.String name)
Write a P1D to an external file. If errors on data points are not given, they are set to 0

Parameters:
name - File name with output

print

public void print()
Print a P1D container on the screen


merge

public P1D merge(P1D a)
Merge two P1D containers.

Parameters:
a - Container to be added
Returns:
modified P1D container

setDataArray

public void setDataArray(jplot.DataArray data)
Set data in a form of DataArray

Parameters:
data - input data

operScale

public P1D operScale(int axis,
                     double scale)
Scale P1D container

Parameters:
scale - Scale factor
axis - if axis=0 applied for X, if axis=1 appied for Y
Returns:
New P1D container

operScale

public P1D operScale(java.lang.String title,
                     int axis,
                     double scale)
Scale X-values (axis=0) or Y values (axis=1) and their errors with a scale factor. The object to be returned is the same, only X or Y are scaled.

Parameters:
title - New Title
axis - axis for which scaling is applied. set to 0 for X and set to 1 for Y.
scale - Scale factor
Returns:
same P1D with scaled X or Y

setErrToZero

public P1D setErrToZero(java.lang.String title,
                        int axis)
Set 1st level errors to zero. All other errors are the same as before.

Parameters:
title - New Title
axis - axis = 0 for X, axis =1 for Y
Returns:
Output P1D container with zero first level errors

setErrAllToZero

public P1D setErrAllToZero(java.lang.String title,
                           int axis)
Set all (1st and 2nd) level errors to zero. if axis=0, for X values if axis=1, for Y values

Parameters:
title - New Title
axis - axis = 0 for X, axis =1 for Y
Returns:
Output P1D container with zero errors

setErrSysToZero

public P1D setErrSysToZero(java.lang.String title,
                           int axis)
Set 2nd level errors to zero.

Parameters:
title - New Title
axis - axis = 0 for X, axis =1 for Y
Returns:
Output P1D container with zero 2nd level errors

setErrSqrt

public P1D setErrSqrt(java.lang.String title,
                      int axis)
Set 1st level error to sqrt of X or Y values. If axis=0, left and right errors will be set on X as sqrt(X). If axis=1, upper and lower errors will be set on Y as sqrt(Y).

Parameters:
title - New Title
axis - axis (=0 for X, 1 for Y).
Returns:
Output P1D container

operScaleErrSys

public P1D operScaleErrSys(java.lang.String title,
                           int axis,
                           double scale)
Scale 2nd level errors with a scale factor. If axis=0, the scaling is applied to errors on X, if axis=1, the scale factor is applied for errors on Y.

Parameters:
title - New Title
axis - axis to a which a scale factor is applied (=0 for X, =1 for Y).
scale - Scale factor to be applied to 2nd level errors defined by axis
Returns:
Output P1D container with scaled 2nd-level errors

operScaleErr

public P1D operScaleErr(java.lang.String title,
                        int axis,
                        double scale)
Scale 1st level errors with a scale factor. If axis=0, the scaling is applied to errors on X, if axis=1, the scale factor to errors on Y.

Parameters:
title - New Title
axis - axis to which a scale factor is applied (=0 for X, 1 for Y).
scale - Scale factor to be applied to 1st level errors defined by axis
Returns:
Output P1D container with scaled 1st-level errors

operErrSys

public P1D operErrSys(java.lang.String title,
                      int axis,
                      P1D left,
                      P1D right)
Obtain a new P1D with 2nd-level errors on X or Y obtained from two P1D objects, one represents left on X (or lower on Y) error and the other represents the right on X (or upper on Y) error. To define X or Y axis, use "axis" variable. If axis=0, this method will be applied for X, if axis=1, this will be applied for Y. This means the central X,Y values are given by the original P1D, while 2nd level errors on X or Y of the original P1D are given by the differences: central-left and right-central for X or upper-central and central-lower for Y. The statistical errors (1st-level errors) are the same as for the original P1D. In case if it happen that the upper P1D is lower than the central value, it takes absolute value. This method is useful if you need to plot uncertainties associated with a measurement. Note: the method does create new object.

Parameters:
title - New Title
axis - axis=0, errors will be set to X (left and right). If axis=1, errors will be set as lower and upper error.
left - P1D used to build left errors on the central values (in X, when axis=0) or lower error on Y (when axis=1)
right - P1D used to build right errors on the central values (in X, when axis=0) or upper error on Y (when axis=1)
Returns:
Same P1D container with the 2nd-level errors on X or Y given by the differences between the original P1D and left (or right) P1Ds (if axis=0), or upper and lower P1Ds (if axis=1)

oper

public P1D oper(P1D a,
                java.lang.String what)
Operations on P1D container: add, subtract, multiply, divide. Keep the same graphical attributes and the title as for the original container. Note, no new object is created.

Parameters:
a - Input P1D container
what - what Output P1D container

oper

public P1D oper(P1D a,
                java.lang.String title,
                java.lang.String what)
Operations on P1D containers: add, subtract, multiply, divide. Keep the same graphical attributes

Parameters:
a - Input P1D container for operation
title - New title
what - String representing the operation: "+" add a P1D container to the original; "-" subtract a P1D from the original; "*" multiply; "/" divide by P1D
Returns:
P1D container after operation.

oper

public P1D oper(P1D a,
                java.lang.String title,
                java.lang.String what,
                java.lang.String how,
                P1D corr)
Operations on P1D containers: add, subtract, multiply, divide. Keep the same graphical attributes. Correlated errors are taken into account via additional P1D data holder which keeps correlation coefficients. The size of this P1D holder should be equal to the original size of P1D.

Parameters:
a - Input P1D container for the operation
title - New title
what - String representing the operation: "+" add a P1D to the original; "-" subtract a P1D from the original "*"; multiply "/" divide
how - how the operation should be performed: "X" - for X values; "Y" - do it for Y values; XY - do for X and Y values. Normally, however, you should do this for the Y option.
corr - P1D container which keeps correlation coefficients for each point. In most general case, this container should be filled as: add(0,0,x1,x2,x3,x4,y1,y2,y3,y4), where x1 (left), x2(right), x3(leftSys), x4(rightSys) - coefficients on X y1 (up), y2(down), y3(upSys), x4(downSys) - coefficients on Y. For example, in a simplest case when Y has 1st level (symmetrical statistical) errors and X does not have any, you need just define "corr" by filling it with: add(0,0,0,0,0,0,c,c,0,0), where c is a correlation coefficient. If "Y" values have both statistical and systematic errors, use the correlation P1D holder of the form add(0,0,0,0,0,0,c,c,c1,c2),
Returns:
Output P1D container

move

public P1D move(java.lang.String what,
                java.lang.String how)
Transform a P1D data holder to some function with error propagation (for both levels)

Parameters:
what - what operation should be performed: "inverse" - inverse to (1/a); "sqrt" - sqrt(a); "exp" - exp(a); "log" - log10(a); "cos" - cos(a) ;"sin" - sin(a); "tan" - tan(a); "acos" - acos(a); "asin" - asin(a); "atan" - atan(a); "cosh" - cosh(a); "sinh" - sinh(a); "tanh" - tanh(a); "square" - a**2
how - how the operation should be performed: "X" - for X values; "Y" - do it for Y values; XY - do for X and Y
Returns:
transformed P1D object

getDataArray

public jplot.DataArray getDataArray()
Return a DataArray container from JPlot

Returns:
Container of type DataArray

add

public void add(double x,
                double y)
Adds values of a plot-point pair (X,Y). All 1st and 2nd level errors on X and Y are assumed to be 0

Parameters:
x - X-value of the plot-point
y - Y-value of the plot-point

add

public void add(double x,
                double y,
                double err)
Adds the values of a plot-point pair (X,Y). It is assumed that Y-values have 1st level symmetrical errors (i.e. statistical errors). All other errors are set to 0 This point is added at the end of the array.

Parameters:
x - X-value of the plot-point
y - Y-value of the plot-point
err - an error on Y (assume symmetrical)

add

public void add(double x,
                double y,
                double upper,
                double lower)
Add values of a plot-point pair (X,Y). The points include upper and lower errors on Y. All other errors are set to 0. This point is added at the end of the array.

Parameters:
x - X-value of the plot-point
y - Y-value of the plot-point
upper - - upper error on Y
lower - - lower error on Y

add

public void add(double x,
                double y,
                double left,
                double right,
                double upper,
                double lower)
Adds the values of a plot-point pair (X,Y). It includes upper and lower errors on Y and left and right error on X. 2nd level errors are assumed to be 0 This point is added at the end of the array.

Parameters:
x - X-value of the plot-point
y - Y-value of the plot-point
left - - left error on X
right - - right error on X
upper - - upper error on Y
lower - - lower error on Y

add

public void add(double x,
                double y,
                double left,
                double right,
                double upper,
                double lower,
                double left_sys,
                double right_sys,
                double upper_sys,
                double lower_sys)
Adds the values of a plot-point pair (x,y). It includes upper and lower errors on X and Y, including 1st and 2nd level errors (i.e. statistical and systematic). This point is added at the end of the array.

Parameters:
x - x-value of the plot-point
y - y-value of the plot-point
left - - error on x (left)
right - - error on x (right)
upper - - error on y (upper)
lower - - error on y (lower)
left_sys - - error on x (left) - second level, used for systematics
right_sys - - error on x (right)
upper_sys - - error on y (upper)
lower_sys - - error on y (lower)

set

public void set(int i,
                double x,
                double y)
Sets the values of a plot-point pair (X,Y). All errors are assumed to be 0

Parameters:
i - index of the plot-point
x - x-value of the plot-point
y - y-value of the plot-point

set

public void set(int i,
                double x,
                double y,
                double upper,
                double lower)
Sets the values of a plot-point pair (x,y).

Parameters:
i - index of the plot-point
x - x-value of the plot-point
y - y-value of the plot-point
upper - upper error on y
lower - lower error on y

set

public void set(int i,
                double x,
                double y,
                double left,
                double right,
                double upper,
                double lower)
Sets the values of a plot-point pair (x,y).

Parameters:
i - index of the plot-point
x - x-value of the plot-point
y - y-value of the plot-point
left - - error on x (left)
right - - error on x (right)
upper - - error on y (upper)
lower - - error on y (lower)

set

public void set(int i,
                double x,
                double y,
                double left,
                double right,
                double upper,
                double lower,
                double left_sys,
                double right_sys,
                double upper_sys,
                double lower_sys)
Sets the values of a plot-point pair (x,y).

Parameters:
i - index of the plot-point
x - x-value of the plot-point
y - y-value of the plot-point
left - - error on x (left)
right - - error on x (right)
upper - - error on y (upper)
lower - - error on y (lower)
left_sys - - error on x (left) - second level, used for systematics
right_sys - - error on x (right)
upper_sys - - error on y (upper)
lower_sys - - error on y (lower)

updateSummary

public void updateSummary()
Update summary of the data. This is necessary after using "replace" method, since a single replacement of a data point does not trigger update of min and max for the data ranges. You do not need to do this if you use "add" or "set" methods.


replace

public void replace(int i,
                    double x,
                    double y,
                    double left,
                    double right,
                    double upper,
                    double lower,
                    double left_sys,
                    double right_sys,
                    double upper_sys,
                    double lower_sys)
replaces the ith value of a plot-point pair (x,y). After all replacements are done, call updateSummary method to get autorange axis values.

Parameters:
i - index of the plot-point
x - x-value of the plot-point
y - y-value of the plot-point
left - - error on x (left)
right - - error on x (right)
upper - - error on y (upper)
lower - - error on y (lower)
left_sys - - error on x (left) - second level, used for systematics
right_sys - - error on x (right)
upper_sys - - error on y (upper)
lower_sys - - error on y (lower)

size

public int size()
Return the length of the data vector.

Returns:
length of the PlotPoint vector

getArrayX

public double[] getArrayX()
Get array representing X-values

Returns:
array with X values

copy

public P1D copy(java.lang.String newtitle)
create an exact of the current holder

Parameters:
newtitle - new title

copy

public P1D copy()
Make a new data holder with the same title from the current one.

Returns:
new data holder

operSmooth

public P1D operSmooth(int axis,
                      boolean isWeighted,
                      int k)
Smooth P1D data points in either X or Y.

It is smoothed by averaging over a moving window of a size specified by the method parameter: if the value of the parameter is k then the width of the window is 2*k + 1. If the window runs off the end of the P1D only those values which intersect the histogram are taken into consideration. The smoothing may optionally be weighted to favor the central value using a "triangular" weighting. For example, for a value of k equal to 2 the central bin would have weight 1/3, the adjacent bins 2/9, and the next adjacent bins 1/9. Errors are kept the same as before.

Parameters:
axis - axis to which smoothing is applied (axis=0 for X, axis=1 for Y)
isWeighted - Whether values in X or Y will be weighted using a triangular weighting scheme favoring bins near the central bin.
k - The smoothing parameter which must be non-negative. If zero, the histogram object will be returned with no smoothing applied.
Returns:
A smoothed version of P1D.

operSmoothGauss

public P1D operSmoothGauss(int axis,
                           double standardDeviation)
Computes a Gaussian smoothed version of P1D. Smoothing can be done either to X or Y

Each band of the P1D is smoothed by discrete convolution with a kernel approximating a Gaussian impulse response with the specified standard deviation.

Parameters:
axis - axis to which smoothing is applied (axis=0 for X, axis=1 for Y)
standardDeviation - The standard deviation of the Gaussian smoothing kernel which must be non-negative or an IllegalArgumentException will be thrown. If zero, the P1D object will be returned with no smoothing applied.
Returns:
A Gaussian smoothed version of the histogram.

getSys

public P1D getSys(P1D[] p1darray)
Return P1D array which contains 2nd level errors (or systematic errors) evaluated from an array of P1D data holders. This means that this method returns a P1D , but now it has systematic errors evaluated from the input array. All systematic variations are treated independently and thus are added in quadrature. Use this method for evaluation of systematic uncertainties. This function implies only for Y values.

Parameters:
p1darray - Input P1D arrays
Returns:
output P1D arrays with the same values and systematic errors, but systematic errors are evaluated from the input set of P1D objects

addAndAverage

public P1D addAndAverage(P1D[] p1darray)
Return P1D array with weighted average of several measurements. This is a standard weighted least-squares procedure to combine experimental data with errors. Measurements represented by input P1Ds are assumed to be uncorrelated. Errors in X positions are not affected during averaging. Only 1st and 2nd level errors on Y are used. It is also assumed that upper and lower 1st-level errors on Y have the same size. In case if the are not the same, I average them (and print error!)

Parameters:
p1darray - Input P1D arrays. They will be added to the original P1D
Returns:
ouput P1D arrays with the same values and systematical errors, but systematical errors are evaluated from the input set of P1D objects

getArrayXleft

public double[] getArrayXleft()
Get array representing X-left errors

Returns:
array with X left errors

getArrayXright

public double[] getArrayXright()
Get array representing X-right errors

Returns:
array with X right errors

getArrayXrightSys

public double[] getArrayXrightSys()
Get array representing X-right 2nd level errors

Returns:
array with X right 2nd level errors

getArrayXleftSys

public double[] getArrayXleftSys()
Get array representing X-left 2nd level errors

Returns:
array with X left 2nd level values

getArrayY

public double[] getArrayY()
Get array representing Y-values

Returns:
array with Y values

getX

public double getX(int i)
Return a specific X-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of x at index i

getXleft

public double getXleft(int i)
Return a specific left error on X-value. if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of x at index i

getXright

public double getXright(int i)
Return a specific right error on X-value. if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of x at index i

getXleftSys

public double getXleftSys(int i)
Return a specific left error on X-value (systematic error). if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of x at index i

getXrightSys

public double getXrightSys(int i)
Return a specific right error on X-value (systematic error). if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of x at index i

getY

public double getY(int i)
Return a specific Y-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of y at index i

getYupper

public double getYupper(int i)
Return a specific upper error on Y-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of y at index i

getYlower

public double getYlower(int i)
Return a specific lower error on Y-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of y at index i

getArrayYlower

public double[] getArrayYlower()
Get array representing Y lower errors

Returns:
array with Y lower error

getArrayYlowerSys

public double[] getArrayYlowerSys()
Get array representing Y lower 2nd level errors

Returns:
array with Y lower 2nd level error

getYupperSys

public double getYupperSys(int i)
Return a specific systematical upper error on Y-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of y at index i

getArrayYupper

public double[] getArrayYupper()
Get array representing Y upper errors

Returns:
array with Y upper error

dimention

public int dimention()
Returns the dimention of this P1D holder. The convention is: 2: only x and y 3: x,y and symmetrical stat error on y 4: only x, y, y(up), y(down) 6: only x, y, x(up), x(down) y(up), y(down) > the rest

Returns:
dimention of the P1D

getYlowerSys

public double getYlowerSys(int i)
Return a specific total lower error on Y-value. This function returns POSINF (1e300) if index i falls beyond the valid range.

Parameters:
i - index of the array
Returns:
the value of y at index i

getArrayYupperSys

public double[] getArrayYupperSys()
Get array representing Y upper 2nd level errors

Returns:
array with Y upper 2nd level error

getIDataPointSet

public hep.aida.IDataPointSet getIDataPointSet()
Get IDataPointSet. If systematical errors included, they are added in quadrature with statistical errors.

Returns:
IDataPointSet made of P1D

getMax

public double getMax(int axis)
Returns the maximum value in the range.

Parameters:
axis - defines to which axis this function applies (0=X; 1=Y);
Returns:
the maximum value.

getMaxIndex

public int getMaxIndex(int axis)
Returns the index of maximum value in the range.

Parameters:
axis - defines to which axis this function applies (0=X; 1=Y);
Returns:
index of maximum value.

getMin

public double getMin(int axis)
Returns the minimum value in the range. Careful, no error checking on the value of axis, which should be less than N_AXES, defined in GraphSettings.

Parameters:
axis - defines to which axis this function applies (0=X; 1=Y);
Returns:
the minimum value.

getMinIndex

public int getMinIndex(int axis)
Returns the index of minimum value in the range.

Parameters:
axis - defines to which axis this function applies (0=X; 1=Y);
Returns:
index of maximum value.

range

public P1D range(int IndexMin,
                 int IndexMax)
Construct P1D in the range between Min and Max indeces. Min and Max are included. All errors will be coppied to a new P1D. For example, getRange(2,2) will return a P1D at index=2 (only one point with errors).

Parameters:
IndexMin - Min index
IndexMax - Max index
Returns:
transformed P1D object.

range

public P1D range(int axis,
                 double Min,
                 double Max)
Construct P1D in the range between Min and Max. Min and Max are included. All errors will be copied to a new P1D. if axis=, range between Min and Max in X was taken.

Parameters:
axis - if axis=0, applied for X, if axis=1, applied for Y.
Min - Min value
Max - Max value
Returns:
a new P1D

mean

public double mean()
Return the mean value

Returns:
Mean value

clear

public void clear()
Clear the container


toTable

public void toTable()
Print the P1D container to a Table in a separate Frame. The numbers are formatted to scientific format. One can sort and search the data in this table (but not modify)


toTable

public void toTable(boolean format)
Print the P1D container to a Table in a separate Frame. One can sort and search the data in this table (but not modify)

Parameters:
format - if false, numbers will not be formatted to the scientific format.

fill

public void fill(double[] xa,
                 double[] ya)
Fill a P1D container from 2 arrays. If it is not empty, add values will be appended. It is assumed that all errors are zero.

Parameters:
xa - array with X values
ya - array with Y values

fill

public void fill(P0D xa,
                 P0D ya)
Fill a P1D container from 2 P0D arrays. If it is not empty, add values will be appended. It is assumed that all errors are zero.

Parameters:
xa - P0D with X values
ya - P0D with Y values

fill

public void fill(double[] xa,
                 double[] ya,
                 double[] yerror)
Fill a P1D container from 3 arrays (one represents symmetrical errors on Y). If it is not empty, add values will be appended. It is assumed that all other errors are zero. Arrays must be of the same size.

Parameters:
xa - array with X values
ya - array with Y values
yerror - array with errors on Y values

fill

public void fill(P0D xa,
                 P0D ya,
                 P0D yerror)
Fill a P1D container from P0D arrays (one represents symmetrical errors on Y). If it is not empty, add values will be appended. It is assumed that all other errors are zero. Arrays must be of the same size.

Parameters:
xa - P0D array with X values
ya - P0D array with Y values
yerror - P0D array with errors on Y values

fill

public void fill(double[] xa,
                 double[] ya,
                 double[] yupper,
                 double[] ylower)
Fill a P1D container from 4 arrays (last represents asymmetrical upper and lower errors on Y). If it is not empty, add values will be appended. It is assumed that all other errors are zero. All arrays must be of the same size.

Parameters:
xa - array with X values
ya - array with Y values
yupper - array with upper errors on Y values
ylower - array with upper errors on Y values

fill

public void fill(double[] x,
                 double[] y,
                 double[] left,
                 double[] right,
                 double[] upper,
                 double[] lower,
                 double[] left_sys,
                 double[] right_sys,
                 double[] upper_sys,
                 double[] lower_sys)
Fill the values of a X-Y plot-points with full errors. It includes upper and lower errors on X and Y, including 1st and 2nd level errors (i.e. statistical and systematic). All arrays must be of the same size.

Parameters:
x - array of x-value of the plot-point
y - array of y-value of the plot-point
left - - array of error on x (left)
right - - array of error on x (right)
upper - - array of error on y (upper)
lower - - array of error on y (lower)
left_sys - - array of error on x (left) - second level, used for systematics
right_sys - - array of error on x (right)
upper_sys - - array of error on y (upper)
lower_sys - - array of error on y (lower)


jHepWork 1.1 (C) Chekanov