[u/mrichter/AliRoot.git] / ITS / AliITSstatistics2.cxx

//////////////////////////////////////////////////////////////////////////
//  Alice ITS class to help keep statistical information                //
//                                                                      //
// version: 0.0.0 Draft.                                                //
// Date: April 18 1999                                                  //
// By: Bjorn S. Nilsen                                                  //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
#include "TMath.h"
#include "AliITSstatistics2.h"

ClassImp(AliITSstatistics2)

//
AliITSstatistics2::AliITSstatistics2() : TObject(){
//
// default constructor
//
    fX  = 0;
    fY  = 0;
    fYx = 0;
    fW  = 0;
    fN  = 0;
    fOrder = 0;
    return;
}


AliITSstatistics2::AliITSstatistics2(Int_t order) : TObject(){
//
// constructor to maximum moment/order order
//
    fOrder = order;
    fX     = new Double_t[order];
    fY     = new Double_t[order];
    fYx    = new Double_t[order];
    fW     = new Double_t[order];
    for(Int_t i=0;i<order;i++) {fX[i] = 0.0;fY[i] = 0.0;
                                fYx[i] = 0.0; fW[i] = 0.0;}
    fN = 0;
    return;
}

AliITSstatistics2::~AliITSstatistics2(){
//
// destructor
//
    if(fX!=0)  delete[] fX;
    if(fY!=0)  delete[] fY;
    if(fYx!=0) delete[] fYx;
    if(fW!=0)  delete[] fW;
    fX  = 0;
    fY  = 0;
    fYx = 0;
    fW  = 0;
    fN  = 0;
    fOrder = 0;
}

//_______________________________________________________________
AliITSstatistics2& AliITSstatistics2::operator=(AliITSstatistics2 &source){
// operator =

     if(this==&source) return *this;
	  if(source.fOrder!=0){
	       this->fOrder = source.fOrder;
			 this->fN = source.fN;
			 this->fX = new Double_t[this->fOrder];
			 this->fW = new Double_t[this->fOrder];
			 for(Int_t i=0;i<source.fOrder;i++){
			      this->fX[i] = source.fX[i];
					this->fW[i] = source.fW[i];
			 } // end for i
	  }else{
	       this->fX = 0;
			 this->fW = 0;
			 this->fN = 0;
			 this->fOrder = 0;
	  }// end if source.fOrder!=0
	  return *this;
}
//_______________________________________________________________
AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source):
    TObject(source){
// Copy constructor

     if(this==&source) return;
	  if(source.fOrder!=0){
	       this->fOrder = source.fOrder;
			 this->fN = source.fN;
			 this->fX = new Double_t[this->fOrder];
			 this->fW = new Double_t[this->fOrder];
			 for(Int_t i=0;i<source.fOrder;i++){
			      this->fX[i] = source.fX[i];
					this->fW[i] = source.fW[i];
			 } // end for i
	  }else{
	       this->fX = 0;
			 this->fW = 0;
			 this->fN = 0;
			 this->fOrder = 0;
	  }// end if source.fOrder!=0
}

void AliITSstatistics2::Reset(){
//
// Reset/zero statistics
//
    for(Int_t i=0;i<fOrder;i++) {fX[i] = 0.0;fY[i] = 0.0;
                                fYx[i] = 0.0; fW[i] = 0.0;}
    fN = 0;
    return;
}

void AliITSstatistics2::AddValue(Double_t y,Double_t x,Double_t w=1.0){
//
// add next x,y pair to statistics
//
    Double_t xs=1.0,ys=1.0,yxs=1.0,ws=1.0;
    Int_t i;

    const Double_t kBig=1.0e+38;

    if(y>kBig || x>kBig || w>kBig) return;


    fN++;
    for(i=0;i<fOrder;i++){
	xs  *= x;
	ys  *= y;
	yxs *= x*y;
	ws  *= w;
	fX[i]  += xs*w;
	fY[i]  += ys*w;
	fYx[i] += yxs*w;
	fW[i]  += ws;
    } // end for i
}

Double_t AliITSstatistics2::GetXNth(Int_t order){
//
// This give the unbiased estimator for the RMS.
//

    Double_t s;

    if(fW[0]!=0.0&&order<=fOrder) s = fX[order-1]/fW[0];
    else {
	s = 0.0;
	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
	       fOrder,fN,fW[0]);
    } // end else
    return s;
}
Double_t AliITSstatistics2::GetYNth(Int_t order){
//
// This give the unbiased estimator for the RMS.
//
    Double_t s;

    if(fW[0]!=0.0&&order<=fOrder) s = fY[order-1]/fW[0];
    else {
	s = 0.0;
	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
	       fOrder,fN,fW[0]);
    } // end else
    return s;
}
Double_t AliITSstatistics2::GetYXNth(Int_t order){
// This give the unbiased estimator for the RMS.
    Double_t s;

    if(fW[0]!=0.0&&order<=fOrder) s = fYx[order-1]/fW[0];
    else {
	s = 0.0;
	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
	       fOrder,fN,fW[0]);
    } // end else
    return s;
}
Double_t AliITSstatistics2::GetRMSX(){
// This give the unbiased estimator for the RMS.
    Double_t x,x2,w,ww,s;

    x  = GetMeanX(); // first order
    x2 = GetXNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.

    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetRMSY(){
// This give the unbiased estimator for the RMS.
    Double_t x,x2,w,ww,s;

    x  = GetMeanY(); // first order
    x2 = GetYNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.

    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetRMSYX(){
// This give the unbiased estimator for the RMS.
    Double_t x,x2,w,ww,s;

    x  = GetMeanYX(); // first order
    x2 = GetYXNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.

    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetErrorMeanY(){
//This is the error in the mean or the square root of the variance of the mean.
    Double_t rms,w,ww,s;

    rms = GetRMSY();
    w   = fW[0];
    ww  = fW[1];
    s   = rms*rms*ww/(w*w);
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetErrorMeanX(){
//This is the error in the mean or the square root of the variance of the mean.
    Double_t rms,w,ww,s;

    rms = GetRMSX();
    w   = fW[0];
    ww  = fW[1];
    s   = rms*rms*ww/(w*w);
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetErrorMeanYX(){
//This is the error in the mean or the square root of the variance of the mean.
    Double_t rms,w,ww,s;

    rms = GetRMSYX();
    w   = fW[0];
    ww  = fW[1];
    s   = rms*rms*ww/(w*w);
    return TMath::Sqrt(s);
}


Double_t AliITSstatistics2::GetErrorRMSY(){
//This is the error in the mean or the square root of the variance of the mean.
// at this moment this routine is only defined for weights=1.
    Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;

    if(fW[0]!=(Double_t)fN||GetN()<4) return (-1.);
    x  = GetMeanY(); // first order
    x2 = GetYNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.
    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);

    m2  = s;
    n   = (Double_t) GetN();
    x3  = GetYNth(3);
    x4  = GetYNth(4);
// This equation assumes that all of the weights are equal to 1.
    m4  = (n/(n-1.))*(x4-3.*x*x3+6.*x*x*x2-2.*x*x*x*x);
    s   = (m4-(n-3.)*m2*m2/(n-1.))/n;
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetErrorRMSX(){
//This is the error in the mean or the square root of the variance of the mean.
// at this moment this routine is only defined for weights=1.
    Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;

    if(fW[0]!=(Double_t)fN||GetN()<4) return (-1.);
    x  = GetMeanX(); // first order
    x2 = GetXNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.
    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);

    m2  = s;
    n   = (Double_t) GetN();
    x3  = GetXNth(3);
    x4  = GetXNth(4);
// This equation assumes that all of the weights are equal to 1.
    m4  = (n/(n-1.))*(x4-3.*x*x3+6.*x*x*x2-2.*x*x*x*x);
    s   = (m4-(n-3.)*m2*m2/(n-1.))/n;
    return TMath::Sqrt(s);
}
Double_t AliITSstatistics2::GetErrorRMSYX(){
//This is the error in the mean or the square root of the variance of the mean.
// at this moment this routine is only defined for weights=1.
    Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;

    if(fW[0]!=(Double_t)fN||GetN()<4) return (-1.);
    x  = GetMeanYX(); // first order
    x2 = GetYXNth(2); // second order
    w  = fW[0];     // first order - 1.
    ww = fW[1];     // second order - 1.
    if(w*w==ww) return (-1.0);
    s = (x2-x*x)*w*w/(w*w-ww);

    m2  = s;
    n   = (Double_t) GetN();
    x3  = GetYXNth(3);
    x4  = GetYXNth(4);
// This equation assumes that all of the weights are equal to 1.
    m4  = (n/(n-1.))*(x4-3.*x*x3+6.*x*x*x2-2.*x*x*x*x);
    s   = (m4-(n-3.)*m2*m2/(n-1.))/n;
    return TMath::Sqrt(s);
}
//_______________________________________________________________________
Double_t AliITSstatistics2::FitToLine(Double_t &a,Double_t &b){
// fit to y = a+bx returns Chi squared or -1.0 if an error
    Double_t c,d,e,f,g,h;

    a = b = 0.0;
    if(fOrder<2 || fN<3) return -1.0;
    c = GetWN(1);
    d = GetYN(1);
    e = GetXN(1);
    f = GetYXN(1);
    g = GetXN(2);
    h = c*g-e*e;
    a = d*g-f*e;
    b = c*f-d*e;
    if(h!=0.0){
	a = a/h;
	b = b/h;
    }else{
	printf("AliITSstatistics2: Error in FitToLine vertical line\n");
	return -1.0;
    } // end if h
    h = GetYN(2)+a*a*c+b*b*g-2.0*a*d-2.0*b*f+2.0*a*b*e;
    h /= (Double_t)fN - 2.0;
    return h;
}
Commit	Line	Data
b0f5e3fc	1	//////////////////////////////////////////////////////////////////////////
	2	// Alice ITS class to help keep statistical information //
	3	// //
	4	// version: 0.0.0 Draft. //
	5	// Date: April 18 1999 //
	6	// By: Bjorn S. Nilsen //
	7	// //
	8	//////////////////////////////////////////////////////////////////////////
	9	#include <stdio.h>
	10	#include <math.h>
	11	#include "TMath.h"
	12	#include "AliITSstatistics2.h"
	13
	14	ClassImp(AliITSstatistics2)
	15
	16	//
	17	AliITSstatistics2::AliITSstatistics2() : TObject(){
	18	//
	19	// default constructor
	20	//
07025d6d	21	fX = 0;
	22	fY = 0;
	23	fYx = 0;
	24	fW = 0;
b0f5e3fc	25	fN = 0;
	26	fOrder = 0;
	27	return;
	28	}
	29
	30
	31	AliITSstatistics2::AliITSstatistics2(Int_t order) : TObject(){
	32	//
	33	// constructor to maximum moment/order order
	34	//
b0f5e3fc	35	fOrder = order;
07025d6d	36	fX = new Double_t[order];
	37	fY = new Double_t[order];
	38	fYx = new Double_t[order];
	39	fW = new Double_t[order];
	40	for(Int_t i=0;i<order;i++) {fX[i] = 0.0;fY[i] = 0.0;
	41	fYx[i] = 0.0; fW[i] = 0.0;}
b0f5e3fc	42	fN = 0;
	43	return;
	44	}
	45
	46	AliITSstatistics2::~AliITSstatistics2(){
	47	//
	48	// destructor
	49	//
07025d6d	50	if(fX!=0) delete[] fX;
	51	if(fY!=0) delete[] fY;
	52	if(fYx!=0) delete[] fYx;
	53	if(fW!=0) delete[] fW;
	54	fX = 0;
	55	fY = 0;
	56	fYx = 0;
	57	fW = 0;
b0f5e3fc	58	fN = 0;
	59	fOrder = 0;
	60	}
	61
	62	//_______________________________________________________________
	63	AliITSstatistics2& AliITSstatistics2::operator=(AliITSstatistics2 &source){
	64	// operator =
	65
e8189707	66	if(this==&source) return *this;
	67	if(source.fOrder!=0){
	68	this->fOrder = source.fOrder;
	69	this->fN = source.fN;
07025d6d	70	this->fX = new Double_t[this->fOrder];
07025d6d	71	this->fW = new Double_t[this->fOrder];
e8189707	72	for(Int_t i=0;i<source.fOrder;i++){
07025d6d	73	this->fX[i] = source.fX[i];
07025d6d	74	this->fW[i] = source.fW[i];
e8189707	75	} // end for i
e8189707	76	}else{
07025d6d	77	this->fX = 0;
07025d6d	78	this->fW = 0;
e8189707	79	this->fN = 0;
	80	this->fOrder = 0;
	81	}// end if source.fOrder!=0
	82	return *this;
b0f5e3fc	83	}
b0f5e3fc	84	//_______________________________________________________________
ac74f489	85	AliITSstatistics2::AliITSstatistics2(AliITSstatistics2 &source):
ac74f489	86	TObject(source){
b0f5e3fc	87	// Copy constructor
b0f5e3fc	88
e8189707	89	if(this==&source) return;
	90	if(source.fOrder!=0){
	91	this->fOrder = source.fOrder;
	92	this->fN = source.fN;
07025d6d	93	this->fX = new Double_t[this->fOrder];
07025d6d	94	this->fW = new Double_t[this->fOrder];
e8189707	95	for(Int_t i=0;i<source.fOrder;i++){
07025d6d	96	this->fX[i] = source.fX[i];
07025d6d	97	this->fW[i] = source.fW[i];
e8189707	98	} // end for i
e8189707	99	}else{
07025d6d	100	this->fX = 0;
07025d6d	101	this->fW = 0;
e8189707	102	this->fN = 0;
	103	this->fOrder = 0;
	104	}// end if source.fOrder!=0
b0f5e3fc	105	}
	106
	107	void AliITSstatistics2::Reset(){
	108	//
	109	// Reset/zero statistics
	110	//
07025d6d	111	for(Int_t i=0;i<fOrder;i++) {fX[i] = 0.0;fY[i] = 0.0;
07025d6d	112	fYx[i] = 0.0; fW[i] = 0.0;}
b0f5e3fc	113	fN = 0;
	114	return;
	115	}
	116
	117	void AliITSstatistics2::AddValue(Double_t y,Double_t x,Double_t w=1.0){
	118	//
	119	// add next x,y pair to statistics
	120	//
	121	Double_t xs=1.0,ys=1.0,yxs=1.0,ws=1.0;
	122	Int_t i;
	123
e8189707	124	const Double_t kBig=1.0e+38;
	125
	126	if(y>kBig \|\| x>kBig \|\| w>kBig) return;
	127
	128
b0f5e3fc	129	fN++;
	130	for(i=0;i<fOrder;i++){
	131	xs *= x;
	132	ys *= y;
	133	yxs = xy;
	134	ws *= w;
07025d6d	135	fX[i] += xs*w;
	136	fY[i] += ys*w;
	137	fYx[i] += yxs*w;
	138	fW[i] += ws;
b0f5e3fc	139	} // end for i
	140	}
	141
	142	Double_t AliITSstatistics2::GetXNth(Int_t order){
	143	//
	144	// This give the unbiased estimator for the RMS.
	145	//
	146
	147	Double_t s;
	148
07025d6d	149	if(fW[0]!=0.0&&order<=fOrder) s = fX[order-1]/fW[0];
b0f5e3fc	150	else {
b0f5e3fc	151	s = 0.0;
07025d6d	152	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
07025d6d	153	fOrder,fN,fW[0]);
b0f5e3fc	154	} // end else
	155	return s;
	156	}
	157	Double_t AliITSstatistics2::GetYNth(Int_t order){
	158	//
	159	// This give the unbiased estimator for the RMS.
	160	//
	161	Double_t s;
	162
07025d6d	163	if(fW[0]!=0.0&&order<=fOrder) s = fY[order-1]/fW[0];
b0f5e3fc	164	else {
b0f5e3fc	165	s = 0.0;
07025d6d	166	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
07025d6d	167	fOrder,fN,fW[0]);
b0f5e3fc	168	} // end else
	169	return s;
	170	}
	171	Double_t AliITSstatistics2::GetYXNth(Int_t order){
	172	// This give the unbiased estimator for the RMS.
	173	Double_t s;
	174
07025d6d	175	if(fW[0]!=0.0&&order<=fOrder) s = fYx[order-1]/fW[0];
b0f5e3fc	176	else {
b0f5e3fc	177	s = 0.0;
07025d6d	178	printf("AliITSstatistics2: error in GetNth: fOrder=%d fN=%d fW[0]=%f\n",
07025d6d	179	fOrder,fN,fW[0]);
b0f5e3fc	180	} // end else
	181	return s;
	182	}
	183	Double_t AliITSstatistics2::GetRMSX(){
	184	// This give the unbiased estimator for the RMS.
	185	Double_t x,x2,w,ww,s;
	186
	187	x = GetMeanX(); // first order
	188	x2 = GetXNth(2); // second order
07025d6d	189	w = fW[0]; // first order - 1.
07025d6d	190	ww = fW[1]; // second order - 1.
b0f5e3fc	191
	192	if(w*w==ww) return (-1.0);
	193	s = (x2-xx)ww/(ww-ww);
	194	return TMath::Sqrt(s);
	195	}
	196	Double_t AliITSstatistics2::GetRMSY(){
	197	// This give the unbiased estimator for the RMS.
	198	Double_t x,x2,w,ww,s;
	199
	200	x = GetMeanY(); // first order
	201	x2 = GetYNth(2); // second order
07025d6d	202	w = fW[0]; // first order - 1.
07025d6d	203	ww = fW[1]; // second order - 1.
b0f5e3fc	204
	205	if(w*w==ww) return (-1.0);
	206	s = (x2-xx)ww/(ww-ww);
	207	return TMath::Sqrt(s);
	208	}
	209	Double_t AliITSstatistics2::GetRMSYX(){
	210	// This give the unbiased estimator for the RMS.
	211	Double_t x,x2,w,ww,s;
	212
	213	x = GetMeanYX(); // first order
	214	x2 = GetYXNth(2); // second order
07025d6d	215	w = fW[0]; // first order - 1.
07025d6d	216	ww = fW[1]; // second order - 1.
b0f5e3fc	217
	218	if(w*w==ww) return (-1.0);
	219	s = (x2-xx)ww/(ww-ww);
	220	return TMath::Sqrt(s);
	221	}
	222	Double_t AliITSstatistics2::GetErrorMeanY(){
	223	//This is the error in the mean or the square root of the variance of the mean.
	224	Double_t rms,w,ww,s;
	225
	226	rms = GetRMSY();
07025d6d	227	w = fW[0];
07025d6d	228	ww = fW[1];
b0f5e3fc	229	s = rmsrmsww/(w*w);
	230	return TMath::Sqrt(s);
	231	}
	232	Double_t AliITSstatistics2::GetErrorMeanX(){
	233	//This is the error in the mean or the square root of the variance of the mean.
	234	Double_t rms,w,ww,s;
	235
	236	rms = GetRMSX();
07025d6d	237	w = fW[0];
07025d6d	238	ww = fW[1];
b0f5e3fc	239	s = rmsrmsww/(w*w);
	240	return TMath::Sqrt(s);
	241	}
	242	Double_t AliITSstatistics2::GetErrorMeanYX(){
	243	//This is the error in the mean or the square root of the variance of the mean.
	244	Double_t rms,w,ww,s;
	245
	246	rms = GetRMSYX();
07025d6d	247	w = fW[0];
07025d6d	248	ww = fW[1];
b0f5e3fc	249	s = rmsrmsww/(w*w);
	250	return TMath::Sqrt(s);
	251	}
	252
	253
	254	Double_t AliITSstatistics2::GetErrorRMSY(){
	255	//This is the error in the mean or the square root of the variance of the mean.
	256	// at this moment this routine is only defined for weights=1.
	257	Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;
	258
07025d6d	259	if(fW[0]!=(Double_t)fN\|\|GetN()<4) return (-1.);
b0f5e3fc	260	x = GetMeanY(); // first order
b0f5e3fc	261	x2 = GetYNth(2); // second order
07025d6d	262	w = fW[0]; // first order - 1.
07025d6d	263	ww = fW[1]; // second order - 1.
b0f5e3fc	264	if(w*w==ww) return (-1.0);
	265	s = (x2-xx)ww/(ww-ww);
	266
	267	m2 = s;
	268	n = (Double_t) GetN();
	269	x3 = GetYNth(3);
	270	x4 = GetYNth(4);
	271	// This equation assumes that all of the weights are equal to 1.
	272	m4 = (n/(n-1.))(x4-3.xx3+6.xxx2-2.xxxx);
	273	s = (m4-(n-3.)m2m2/(n-1.))/n;
	274	return TMath::Sqrt(s);
	275	}
	276	Double_t AliITSstatistics2::GetErrorRMSX(){
	277	//This is the error in the mean or the square root of the variance of the mean.
	278	// at this moment this routine is only defined for weights=1.
	279	Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;
	280
07025d6d	281	if(fW[0]!=(Double_t)fN\|\|GetN()<4) return (-1.);
b0f5e3fc	282	x = GetMeanX(); // first order
b0f5e3fc	283	x2 = GetXNth(2); // second order
07025d6d	284	w = fW[0]; // first order - 1.
07025d6d	285	ww = fW[1]; // second order - 1.
b0f5e3fc	286	if(w*w==ww) return (-1.0);
	287	s = (x2-xx)ww/(ww-ww);
	288
	289	m2 = s;
	290	n = (Double_t) GetN();
	291	x3 = GetXNth(3);
	292	x4 = GetXNth(4);
	293	// This equation assumes that all of the weights are equal to 1.
	294	m4 = (n/(n-1.))(x4-3.xx3+6.xxx2-2.xxxx);
	295	s = (m4-(n-3.)m2m2/(n-1.))/n;
	296	return TMath::Sqrt(s);
	297	}
	298	Double_t AliITSstatistics2::GetErrorRMSYX(){
	299	//This is the error in the mean or the square root of the variance of the mean.
	300	// at this moment this routine is only defined for weights=1.
	301	Double_t x,x2,x3,x4,w,ww,m2,m4,n,s;
	302
07025d6d	303	if(fW[0]!=(Double_t)fN\|\|GetN()<4) return (-1.);
b0f5e3fc	304	x = GetMeanYX(); // first order
b0f5e3fc	305	x2 = GetYXNth(2); // second order
07025d6d	306	w = fW[0]; // first order - 1.
07025d6d	307	ww = fW[1]; // second order - 1.
b0f5e3fc	308	if(w*w==ww) return (-1.0);
	309	s = (x2-xx)ww/(ww-ww);
	310
	311	m2 = s;
	312	n = (Double_t) GetN();
	313	x3 = GetYXNth(3);
	314	x4 = GetYXNth(4);
	315	// This equation assumes that all of the weights are equal to 1.
	316	m4 = (n/(n-1.))(x4-3.xx3+6.xxx2-2.xxxx);
	317	s = (m4-(n-3.)m2m2/(n-1.))/n;
	318	return TMath::Sqrt(s);
	319	}
	320	//_______________________________________________________________________
	321	Double_t AliITSstatistics2::FitToLine(Double_t &a,Double_t &b){
	322	// fit to y = a+bx returns Chi squared or -1.0 if an error
	323	Double_t c,d,e,f,g,h;
	324
	325	a = b = 0.0;
	326	if(fOrder<2 \|\| fN<3) return -1.0;
	327	c = GetWN(1);
	328	d = GetYN(1);
	329	e = GetXN(1);
	330	f = GetYXN(1);
	331	g = GetXN(2);
	332	h = cg-ee;
	333	a = dg-fe;
	334	b = cf-de;
	335	if(h!=0.0){
	336	a = a/h;
	337	b = b/h;
	338	}else{
	339	printf("AliITSstatistics2: Error in FitToLine vertical line\n");
	340	return -1.0;
	341	} // end if h
	342	h = GetYN(2)+aac+bbg-2.0ad-2.0bf+2.0ab*e;
	343	h /= (Double_t)fN - 2.0;
	344	return h;
	345	}