//#include "mktreeraw.hxx" #include "mktreedstchain_sct_fitABC.h" //------------------------------------------------------------------------------ ClassImp(ASYFadcPeak) ASYFadcPeak::ASYFadcPeak(){ mod=-1; pds0=pds1=pds2=pdr0=pdr1=pdr2=tls0=tls1=tls2=tlo0=tlo1=tlo2=tm0=tm1=tm2=am0=am1=am2=at0=at1=at2=0; sam0=sam1=sam2=sat0=sat1=sat2=0; s01=s02=s03=s04=s05=s06=s07=s08=s09=s09f=0; s11=s12=s13=s14=s15=s16=s17=s18=s19=s19f=0; s21=s22=s23=s24=s25=s26=s27=s28=s29=s29f=0; sf00=sf01=sf02=sf03=sf04=sf05=sf06=sf07=sf08=sf09=0; sf10=sf11=sf12=sf13=sf14=sf15=sf16=sf17=sf18=sf19=0; sf20=sf21=sf22=sf23=sf24=sf25=sf26=sf27=sf28=sf29=0; m00=m01=m02=m03=m04=m05=m06=m07=m08=m09=mx0=my0=mz0=ma0=mb0=mc0=0; m10=m11=m12=m13=m14=m15=m16=m17=m18=m19=mx1=my1=mz1=ma1=mb1=mc1=0; m20=m21=m22=m23=m24=m25=m26=m27=m28=m29=mx2=my2=mz2=ma2=mb2=mc2=0; p00=p04=p05=p09=0; p10=p12=p13=p14=p15=p17=p18=p19=p110=0; p20=p22=p23=p24=p25=p27=p28=p29=p210=0; rc0=rc1=rc2=0; chi20=chi21=chi22=0; } void ASYFadcPeak::Clear(Option_t *) {} //______________________________________________________________________________ ClassImp(ASYEvent) ASYEvent::ASYEvent() : run(0), evt(0), npeak(0), tms(0) { peak = new TClonesArray("ASYFadcPeak",1000); } ASYEvent::~ASYEvent() { Clear(); delete peak; peak = 0; } void ASYEvent::Clear(Option_t* option) { evt = 0; run = 0; npeak = 0; tms = 0; // Clear or Delete ?? TODO: Expalin what //if(peak) peak->Clear("C"); if(peak) peak->Delete(); } //______________________________________________________________________________ ASYEvent& ASYEvent::operator=(const ASYEvent& tc) { if (this == &tc) return *this; //if (fClass != tc.fClass) { // Error("operator=", "cannot copy ASYEvent's when classes are different"); // return *this; //} run = tc.run; evt = tc.evt; npeak = tc.npeak; tms = tc.tms; *peak = TClonesArray(*tc.peak); /* for (i = 0; i < fSize; i++) if (fKeep->fCont[i]) { if (TObject::GetObjectStat() && gObjectTable) gObjectTable->RemoveQuietly(fKeep->fCont[i]); ::operator delete(fKeep->fCont[i]); fKeep->fCont[i] = 0; fCont[i] = 0; } BypassStreamer(kTRUE); for (i = 0; i < tc.fSize; i++) { if (tc.fCont[i]) fKeep->fCont[i] = tc.fCont[i]->Clone(); fCont[i] = fKeep->fCont[i]; } fLast = tc.fLast; Changed(); */ return *this; } //______________________________________________________________________ std::ostream& operator<<(std::ostream& output, const ASYFadcPeak& p) { output << "[ASYFadcPeak: mod="<< p.mod; output << ", sam0=" << p.sam0 << ", sat0="<< p.sat0; output << ", sam1=" << p.sam1 << ", sat0="<< p.sat1; output << ", sam2=" << p.sam2 << ", sat0="<< p.sat2; output << ", p10=" << p.p10 << ", p12="<< p.p12 << ", p13="<< p.p13; output << ", p20=" << p.p20 << ", p22="<< p.p22 << ", p23="<< p.p23; output << "]"; return output; } //______________________________________________________________________ std::ostream& operator<<(std::ostream& output, const ASYEvent& ae) { output << "[ASYEvent: Run="<< ae.run << ", Event=" << ae.evt << ", Timestamp="<< ae.tms << ", NPeaks=" << ae.npeak << endl; ASYFadcPeak* pp = NULL; for (Int_t pi = 0; pi < ae.npeak; pi++ ) { cout << " -" << pi+1 << ": "; //pp = *((ASYFadcPeak*) (*ae.peak)[pi]); //cout << *pp << endl; cout << *((ASYFadcPeak*) (*ae.peak)[pi]) << endl; } output << "]"; return output; } //______________________________________________________________________ Double_t Det2(Double_t A[2][2]){ Double_t det=0.; det=A[0][0]*A[1][1]-A[1][0]*A[0][1]; return det; } //___________________________________________________________________ Double_t Det3(Double_t A[3][3]){ Double_t det=0.; det=A[0][0]*A[1][1]*A[2][2]+A[1][0]*A[2][1]*A[0][2]+A[0][1]*A[1][2]*A[2][0]- A[2][0]*A[1][1]*A[0][2]-A[1][0]*A[0][1]*A[2][2]-A[2][1]*A[1][2]*A[0][0]; return det; } // //___________________________________________________________________ //___________________________________________________________________ Double_t Det4(Double_t A[4][4]){ Double_t det=0.; det= A[0][3]*A[1][2]*A[2][1]*A[3][0] - A[0][2]*A[1][3]*A[2][1]*A[3][0] - A[0][3]*A[1][1]*A[2][2]*A[3][0] + A[0][1]*A[1][3]*A[2][2]*A[3][0] + A[0][2]*A[1][1]*A[2][3]*A[3][0] - A[0][1]*A[1][2]*A[2][3]*A[3][0] - A[0][3]*A[1][2]*A[2][0]*A[3][1] + A[0][2]*A[1][3]*A[2][0]*A[3][1] + A[0][3]*A[1][0]*A[2][2]*A[3][1] - A[0][0]*A[1][3]*A[2][2]*A[3][1] - A[0][2]*A[1][0]*A[2][3]*A[3][1] + A[0][0]*A[1][2]*A[2][3]*A[3][1] + A[0][3]*A[1][1]*A[2][0]*A[3][2] - A[0][1]*A[1][3]*A[2][0]*A[3][2] - A[0][3]*A[1][0]*A[2][1]*A[3][2] + A[0][0]*A[1][3]*A[2][1]*A[3][2] + A[0][1]*A[1][0]*A[2][3]*A[3][2] - A[0][0]*A[1][1]*A[2][3]*A[3][2] - A[0][2]*A[1][1]*A[2][0]*A[3][3] + A[0][1]*A[1][2]*A[2][0]*A[3][3] + A[0][2]*A[1][0]*A[2][1]*A[3][3] - A[0][0]*A[1][2]*A[2][1]*A[3][3] - A[0][1]*A[1][0]*A[2][2]*A[3][3] + A[0][0]*A[1][1]*A[2][2]*A[3][3]; return det; } //___________________________________________________________________ // Double_t Det(const int n, Double_t **A){ Double_t Det(const int n, Double_t A[9][9]){ Double_t det=0.; switch (n){ case 1 : det=A[0][0]; break; case 2 : det=A[0][0]*A[1][1]-A[1][0]*A[0][1]; break; case 3 : det=A[0][0]*A[1][1]*A[2][2]+A[1][0]*A[2][1]*A[0][2]+A[0][1]*A[1][2]*A[2][0]- A[2][0]*A[1][1]*A[0][2]-A[1][0]*A[0][1]*A[2][2]-A[2][1]*A[1][2]*A[0][0]; break; default : int i, j, k; det = 1; static double matrix[9][9]; // double **matrix; // matrix = new double *[n]; // // for ( i = 0; i < n; i++ ) // matrix[i] = new double[n]; for ( i = 0; i < n; i++ ) { for ( j = 0; j < n; j++ ) matrix[i][j] = A[i][j]; } for ( k = 0; k < n; k++ ) { if ( matrix[k][k] == 0 ) { bool ok = false; for ( j = k; j < n; j++ ) { if ( matrix[j][k] != 0 ) ok = true; } if ( !ok ) return 0; for ( i = k; i < n; i++ ) std::swap ( matrix[i][j], matrix[i][k] ); det = -det; } det *= matrix[k][k]; if ( k + 1 < n ) { for ( i = k + 1; i < n; i++ ) { for ( j = k + 1; j < n; j++ ) matrix[i][j] = matrix[i][j] - matrix[i][k] * matrix[k][j] / matrix[k][k]; } } } // for ( i = 0; i < n; i++ ) // delete [] matrix[i]; // // delete [] matrix; } //printf("Det: %f\n",det); return det; } // //___________________________________________________________________ // /////////////////////////////////////////////////////////////////////////////// // // double RCGAM8PRIM(Double_t *xx, Double_t *par){ // // // double x=xx[0];// // double p=xx[1];// // // double Q0 = par[0]; // // double Q1 = par[1]; // // double Q2 = par[2]; // double x0 = par[3]; // // double t0 = par[4]; // // double t1 = par[5]; // // double t2 = par[6]; // // double rc = par[7]; // // // // !!!! Q0 is in fact Q0/C // // here n=1 compared to RC11 // // double fun = 0.; // // double exp_rc = exp(-(x-x0)/rc); // // if(x<=x0) fun=0-p; // else fun = // Q0*rc*(-exp_rc*t0+exp(-(x-x0)/t0)*(t0-x+x0+rc*(x-x0)/t0))/(t0*pow(rc-t0,2))+ // Q1*rc*(-exp_rc*t1+exp(-(x-x0)/t1)*(t1-x+x0+rc*(x-x0)/t1))/(t1*pow(rc-t1,2))+ // Q2*rc*(-exp_rc*t2+exp(-(x-x0)/t2)*(t2-x+x0+rc*(x-x0)/t2))/(t2*pow(rc-t2,2))-p; // return fun; // } // // //___________________________________________________________________ /////////////////////////////////////////////////////////////////////////////// //____________________________________________________________________________________ ///This function returns interpolation result for given arrays and polynomial 2-nd order interpolation Double_t getInterpolatedValue(Double_t x, Double_t * ArrayX, Double_t * ArrayY, Int_t ArraySize, Double_t &A_p0, Double_t &A_p1 , Double_t &A_p2 ) { Int_t verboseLevel = 0; ///Allowed values:1,2,3,... ///1. Validate input data: if(ArraySize <= 0) { return 0.0; } ///2. Get the smallest and highest x value Int_t Xmin = ArrayX[0]; Int_t Xmax = ArrayX[0]; for(int i = 0; i < ArraySize; i++) { if(Xmin > ArrayX[i]){Xmin =ArrayX[i]; } if(Xmax < ArrayX[i]){Xmax =ArrayX[i]; } } // ///3. Creating histogram to get access to fit procedure // TGraph histo(ArraySize,ArrayX, ArrayY); // // ///4. Fit polynomial of order 2. // histo.Fit("pol2","W"); ///WNSFM, Q-quiet ,"SFNWQ" // // ///5. Getting results // Double_t p0 = histo.GetFunction("pol2")->GetParameter(0); // Double_t p1 = histo.GetFunction("pol2")->GetParameter(1); // Double_t p2 = histo.GetFunction("pol2")->GetParameter(2); // // printf("(1) %f %f %f\n",p0,p1,p2); double A,B,C,D,E,F,G,H; double XI,YI,X0,X1,X2,X3,X4; double W,Wa,Wb,Wc,a,b,c; A=B=C=D=E=F=G=H=0; for(int i=0;i 0 ) cout << "Parameters: p0="<< p0 << ", p1="<< p1 << ",p2=" << p2 << endl; Double_t y = A_p2*x*x + A_p1*x + A_p0; //fitResults->Print("V"); // print full information of fit including covariance matrix //if(verboseLevel >0) cout << "Result: ("<< x << "," << y << ")"<Draw(); ///6. Cleaning //delete histo; ///7. Returning result return y; } //____________________________________________________________________________________ vector getPercents ( TH1D * A_hist, Double_t t0, Double_t xmax, Double_t yMax) { vector points; //points.push_back(1); Int_t xMax = Int_t(xmax+1); //Double_t level[5] = {10., 30., 50., 70., 90.}; Double_t level[9] = {10., 20.,30., 40.,50., 60.,70.,80., 90.}; //Double_t den[5] = {50., 28., 21., 14., 7.}; Double_t den[9] = {50.,40., 28.,25., 21.,18., 14.,10., 7.}; Double_t height = yMax; Int_t curX; Double_t curY; Int_t x0= Int_t(t0+1); Double_t searchedX; Double_t searchedY; Int_t pm = 5; //printf("%f %f %f\n",t0,xmax,yMax); for ( int lvl = 0; lvl < 9; lvl++) { searchedX = 0.; searchedY = height * ( level [lvl] /100.); for ( int i = 0; i < xMax; i++) { curX = x0 + i; curY = A_hist -> GetBinContent( curX ); ///cout << " Point " << curX << ", "<< curY << endl; //printf("%d %d %f\n",i,curX,curY); if ( curY >= searchedY) { //cout << "Znaleziono przyblizone dla "<<(level[lvl] ) << " % x=" << curX << ": y=" << curY << endl; // if(lvl==0) pm=5; // if(lvl==4) pm=int((xmax-t0)/7.); pm=int((xmax-t0)/den[lvl]); if(pm<3) pm=3; Int_t ArraySize = 2*pm+1; Double_t *tabX = new Double_t[ArraySize]; Double_t *tabY = new Double_t[ArraySize]; for(int ti = 0; ti < ArraySize; ti++) { int bin = curX - pm + ti; tabX[ti] = A_hist -> GetBinCenter(bin); tabY[ti] = A_hist -> GetBinContent(bin); //printf("%d %d %f\n",ti,tabX[ti],tabY[ti]); } Double_t a,b,c; getInterpolatedValue( curX, tabX,tabY, ArraySize, c, b, a ); delete tabX; delete tabY; ///Jezeli wierzcholek jest na dole to prawy punkt Double_t x1; Double_t x2; Double_t delta = b*b - 4* (a * (c - searchedY)); if (a != 0 && delta>= 0){ x1 = (-b - TMath:: Sqrt( delta ) ) /(2 * a); x2 = (-b + TMath:: Sqrt( delta ) ) /(2 * a); //printf("delta>= 0\n"); } else{ //printf("delta= 0\n"); x1 = x2 = curX; } // printf(">>>> %f\n",y/ ///Jezeli wierzcholek jest do gory to lewy punkt ///lub wybrac wierzcholek blizej binu //cout << " -odleglosci od curX: dla x1=" << x1 <<" : " << TMath::Abs(curX - x1) << " i dla x2=" << x2 << " : " << TMath::Abs(curX - x2) << endl; if ( TMath::Abs(curX - x1) < TMath::Abs(curX - x2)) { searchedX = x1; } else { searchedX = x2; } //cout << " -Wybrany: " << searchedX << " dla " << searchedY << endl; break; } } points.push_back( searchedX ); points.push_back( searchedY ); } searchedX = 0.; searchedY = height * ( 90. /100.); for ( int i = xMax; i < A_hist->GetNbinsX(); i++) { curX = i; curY = A_hist -> GetBinContent( curX ); if ( curY <= searchedY) { pm = 50; if (curX + pm > A_hist->GetNbinsX()) pm = (A_hist->GetNbinsX() - curX) - 1; Int_t ArraySize = 2*pm+1; //printf("ArraySize %d\n",ArraySize); Double_t *tabX = new Double_t[ArraySize]; Double_t *tabY = new Double_t[ArraySize]; for(int ti = 0; ti < ArraySize; ti++) { int bin = curX - pm + ti; tabX[ti] = A_hist -> GetBinCenter(bin); tabY[ti] = A_hist -> GetBinContent(bin); //printf("%d %d %f %f\n",ti,bin,tabX[ti],tabY[ti]); } Double_t a,b,c; getInterpolatedValue( curX, tabX,tabY, ArraySize, c, b, a ); delete tabX; delete tabY; Double_t x1; Double_t x2; Double_t delta = b*b - 4* (a * (c - searchedY)); if (a != 0 && delta>= 0){ x1 = (-b - TMath:: Sqrt( delta ) ) /(2 * a); x2 = (-b + TMath:: Sqrt( delta ) ) /(2 * a); //printf("delta>= 0\n"); } else{ //printf("delta= 0\n"); x1 = x2 = curX; } if ( TMath::Abs(curX - x1) < TMath::Abs(curX - x2)) { searchedX = x1; } else { searchedX = x2; } //cout << " -Wybrany: " << searchedX << " dla " << searchedY << endl; //printf("Znalazlem 90%% na zboczu opadajacym! %f %f \n", searchedX, searchedY); break; } } points.push_back( searchedX ); points.push_back( searchedY ); return points; } //____________________________________________________________________________________ // Functions proobes the falling slope of the pulse. // The distance between maximum and end of pulse is divided to 10 in X axis // The points: (x and pulse value) are returned in a vector // Autor: Sebastian.Kupny@uj.edu.pl 2013-01 // Debug levels: // 0 - no printouts // 1 - info only about bad events // 2 - details about event // 3 - details about intervals of the falling edge // 4 and more - all outputs (with all selected points to fits) // vector GetSamplesFromTheFallingEdge ( TH1D * A_hist, Double_t t0, Double_t xMax, Double_t yMax, Int_t A_debugLevel ) { Int_t debugLvl = A_debugLevel; vector points; /// Container with results ///Parameters: Int_t numberOfIntervals = 10; /// 10 <==> Probing over 10% Int_t minimalStepLimit = 6; Int_t pm; ///Dlugosc przedzialu w okol probki w ktorym interpolujemy Double_t searchedX; Double_t searchedY; Int_t curX; ///Wybrany bin najblizszy wartosci x, dla ktorej chcemy miec wartosc funkcji do fitu. //Double_t curY; if (debugLvl > 2 ) printf("[GetSamplesFromTheFallingEdge:] Zaczynam te funckje \n"); if (debugLvl > 1 ) printf("[GetSamplesFromTheFallingEdge:] Parametry wejsciowe: t0=%f, \txMax=%f,\tyMax=%f\n", t0, xMax, yMax ); //Double_t fallingEdgeLength = A_hist->GetNbinsX() - xMax; /// Modul nie jest potrzebny, ale dla bezpieczenstwa.. // 2013-01 Poprawka Pana Jurka: Double_t fallingEdgeLength = A_hist->GetBinCenter(A_hist->GetNbinsX()) - xMax; /// Modul nie jest potrzebny, ale dla bezpieczenstwa.. Double_t step = fallingEdgeLength/((Double_t) numberOfIntervals); if (fallingEdgeLength <= 0 ){ if (debugLvl > 0 ) printf("[GetSamplesFromTheFallingEdge:] BAD EVENT: Maksimum znajduje sie poza zakresem/na granicy histogramu (xMax=%f). Nie probkuje poza histogramem.\n", xMax); searchedX = xMax ; for ( int i = 0; i < numberOfIntervals; i++ ) { searchedX += step; searchedY = 0; points.push_back( searchedX ); points.push_back( searchedY ); } return points; } if (debugLvl > 1 ) printf("[GetSamplesFromTheFallingEdge:] Step =%f \n", step); if (debugLvl > 1 ) printf("[GetSamplesFromTheFallingEdge:] FallingEdgeLength =%f \n", fallingEdgeLength); /// 0. Filtering bad pulse (with no tail, or with very short (smaller than minimalStepLimit*numberOfIntervals) ) if ( step < minimalStepLimit){ if (debugLvl > 0 ) printf("[GetSamplesFromTheFallingEdge:] BAD EVENT: Warunki minimalne nie sa spelnione (step=%f, step_min=%d),bym mogl otrzymac wartosci probek ze zbocza opadajacego\n", step, minimalStepLimit ); searchedX = xMax ; for ( int i = 0; i < numberOfIntervals; i++ ) { searchedX += step; searchedY = 0; curX = (searchedX-((Int_t)searchedX)<0.5)?((Int_t)searchedX):((Int_t)searchedX)+1; int bin = (Int_t)(searchedX+1); if(bin>A_hist->GetNbinsX()) bin = A_hist->GetNbinsX(); points.push_back( A_hist -> GetBinCenter(bin) ); points.push_back( A_hist -> GetBinContent(bin) ); } return points; } /// 1. Loop over number of samples (0..numberOfIntervals) the first is in max, the last is in end of the pulse (bin 512 or 1024) searchedX = xMax ; if (debugLvl > 1 ) printf( "[GetSamplesFromTheFallingEdge:] Przed petla, searchedX = %f \n", searchedX); for ( int i = 0; i < numberOfIntervals; i++ ) { if (debugLvl > 2 ) printf( "[GetSamplesFromTheFallingEdge:] Jestem w petli, i=%d \n", i); searchedX += step; curX = (searchedX-((Int_t)searchedX)<0.5)?((Int_t)searchedX):((Int_t)searchedX)+1; if (debugLvl > 2 ) printf("[GetSamplesFromTheFallingEdge:] curX = %d \n", curX ); if (debugLvl > 2 ) printf("[GetSamplesFromTheFallingEdge:] searchedX= %f \n", searchedX ); pm = step/2.; /// Bierzemy polowe dlugosci przedzialu miezdy probkami woklow miejsca w ktorym chcemy probkowac Int_t ArraySize = 2*pm+1; /// Przedzial do interpolacji - rowny z dwoch stron plus wartosc w srodku /// Jezeli wychodzimy z probka poza zakres: if (curX + pm > A_hist->GetNbinsX()) ArraySize = pm + (A_hist->GetNbinsX() - curX) + 1 ; /// Poprawka w przypadku konca histogramu. Bierzemy ostatnie biny. if (debugLvl > 2 ) printf("[GetSamplesFromTheFallingEdge:] ArraySize %d, in between (%d, %d ) \n", ArraySize, curX - pm, curX - pm + ArraySize - 1); Double_t *tabX = new Double_t[ArraySize]; Double_t *tabY = new Double_t[ArraySize]; for(int ti = 0; ti < ArraySize; ti++) { int bin = curX - pm + ti; tabX[ti] = A_hist -> GetBinCenter(bin); tabY[ti] = A_hist -> GetBinContent(bin); if (debugLvl > 3 ) printf("[GetSamplesFromTheFallingEdge:] ti = %d tabX[ti] = %f, tabY[ti] = %f\n",ti,tabX[ti],tabY[ti]); } Double_t a,b,c; /// Parametry paraboli, ktora bedziemy fitowac searchedY = getInterpolatedValue( curX, tabX,tabY, ArraySize, c, b, a ); delete tabX; delete tabY; /// Zapisujemy wyniki w wektorze wynikowym points.push_back( searchedX ); points.push_back( searchedY ); if (debugLvl > 1 ) printf("[GetSamplesFromTheFallingEdge:] Wyznaczylem probke %d:\t(%f, %f) \n",i, searchedX, searchedY); } if (debugLvl > 1 ) printf("[GetSamplesFromTheFallingEdge:] Wyznaczylem %d probek \n", numberOfIntervals); if (debugLvl > 2 ) printf("[GetSamplesFromTheFallingEdge:] Koncze te funckje\n"); return points; } //______________________________________________________________________ void PeakData::Clear(Option_t *option ) { mod=-1; n_sample[0]=n_sample[1]=n_sample[2]=0; evt[0]=evt[1]=evt[2]=0; pds[0]=pds[1]=pds[2]=0; pdr[0]=pdr[1]=pdr[2]=0; tls[0]=tls[1]=tls[2]=0; tlo[0]=tlo[1]=tlo[2]=0; tm[0]=tm[1]=tm[2]=0; am[0]=am[1]=am[2]=0; at[0]=at[1]=at[2]=0; sam[0]=sam[1]=sam[2]=0; sat[0]=sat[1]=sat[2]=0; s1[0]=s1[1]=s1[2]=0; s2[0]=s2[1]=s2[2]=0; s3[0]=s3[1]=s3[2]=0; s4[0]=s4[1]=s4[2]=0; s5[0]=s5[1]=s5[2]=0; s6[0]=s6[1]=s6[2]=0; s7[0]=s7[1]=s7[2]=0; s8[0]=s8[1]=s8[2]=0; s9[0]=s9[1]=s9[2]=0; s9f[0]=s9f[1]=s9f[2]=0; sf0[0]=sf0[1]=sf0[2]=0; sf1[0]=sf1[1]=sf1[2]=0; sf2[0]=sf2[1]=sf2[2]=0; sf3[0]=sf3[1]=sf3[2]=0; sf4[0]=sf4[1]=sf4[2]=0; sf5[0]=sf5[1]=sf5[2]=0; sf6[0]=sf6[1]=sf6[2]=0; sf7[0]=sf7[1]=sf7[2]=0; sf8[0]=sf8[1]=sf8[2]=0; sf9[0]=sf9[1]=sf9[2]=0; m0[0]=m0[1]=m0[2]=0; m1[0]=m1[1]=m1[2]=0; m2[0]=m2[1]=m2[2]=0; m3[0]=m3[1]=m3[2]=0; m4[0]=m4[1]=m4[2]=0; m5[0]=m5[1]=m5[2]=0; m6[0]=m6[1]=m6[2]=0; m7[0]=m7[1]=m7[2]=0; m8[0]=m8[1]=m8[2]=0; m9[0]=m9[1]=m9[2]=0; mx[0]=mx[1]=mx[2]=0; my[0]=my[1]=my[2]=0; mz[0]=mz[1]=mz[2]=0; ma[0]=ma[1]=ma[2]=0; mb[0]=mb[1]=mb[2]=0; mc[0]=mc[1]=mc[2]=0; p0[0]=p0[1]=p0[2]=0; p1[0]=p1[1]=p1[2]=0; p2[0]=p2[1]=p2[2]=0; p3[0]=p3[1]=p3[2]=0; p4[0]=p4[1]=p4[2]=0; p5[0]=p5[1]=p5[2]=0; p6[0]=p6[1]=p6[2]=0; p7[0]=p7[1]=p7[2]=0; p8[0]=p8[1]=p8[2]=0; p9[0]=p9[1]=p9[2]=0; p10[0]=p10[1]=p10[2]=0; rc[0]=rc[1]=rc[2]=0; chi2[0]=chi2[1]=chi2[2]=0; } //______________________________________________________________________ //______________________________________________________________________________ ASYFadcPeak& ASYFadcPeak::operator=(const ASYFadcPeak& tc) { if (this == &tc) return *this; //if (fClass != tc.fClass) { // Error("operator=", "cannot copy ASYEvent's when classes are different"); // return *this; //} mod = tc.mod; pds0 = tc.pds0; pdr0 = tc.pdr0; tls0 = tc.tls0; tlo0 = tc.tlo0; tm0 = tc.tm0; am0 = tc.am0; at0 = tc.at0; pds1 = tc.pds1; pdr1 = tc.pdr1; tls1 = tc.tls1; tlo1 = tc.tlo1; tm1 = tc.tm1; am1 = tc.am1; at1 = tc.at1; pds2 = tc.pds2; pdr2 = tc.pdr2; tls2 = tc.tls2; tlo2 = tc.tlo2; tm2 = tc.tm2; am2 = tc.am2; at2 = tc.at2; sam0 = tc.sam0; sat0 = tc.sat0; s01 = tc.s01; s02 = tc.s02; s03 = tc.s03; s04 = tc.s04; s05 = tc.s05; s06 = tc.s06; s07 = tc.s07; s08 = tc.s08; s09 = tc.s09; s09f = tc.s09f; sam1 = tc.sam1; sat1 = tc.sat1; s11 = tc.s11; s12 = tc.s12; s13 = tc.s13; s14 = tc.s14; s15 = tc.s15; s16 = tc.s16; s17 = tc.s17; s18 = tc.s18; s19 = tc.s19; s19f = tc.s19f; sam2 = tc.sam2; sat2 = tc.sat2; s21 = tc.s21; s22 = tc.s22; s23 = tc.s23; s24 = tc.s24; s25 = tc.s25; s26 = tc.s26; s27 = tc.s27; s28 = tc.s28; s29 = tc.s29; s29f = tc.s29f; sf00 = tc.sf00; sf01 = tc.sf01; sf02 = tc.sf02; sf03 = tc.sf03; sf04 = tc.sf04; sf05 = tc.sf05; sf06 = tc.sf06; sf07 = tc.sf07; sf08 = tc.sf08; sf09 = tc.sf09; sf10 = tc.sf10; sf11 = tc.sf11; sf12 = tc.sf12; sf13 = tc.sf13; sf14 = tc.sf14; sf15 = tc.sf15; sf16 = tc.sf16; sf17 = tc.sf17; sf18 = tc.sf18; sf19 = tc.sf19; sf20 = tc.sf20; sf21 = tc.sf21; sf22 = tc.sf22; sf23 = tc.sf23; sf24 = tc.sf24; sf25 = tc.sf25; sf26 = tc.sf26; sf27 = tc.sf27; sf28 = tc.sf28; sf29 = tc.sf29; m00 = tc.m00; m01 = tc.m01; m02 = tc.m02; m03 = tc.m03; m04 = tc.m04; m05 = tc.m05; m06 = tc.m06; m07 = tc.m07; m08 = tc.m08; m09 = tc.m09; mx0 = tc.mx0; my0 = tc.my0; mz0 = tc.mz0; ma0 = tc.ma0; mb0 = tc.mb0; mc0 = tc.mc0; m10 = tc.m10; m11 = tc.m11; m12 = tc.m12; m13 = tc.m13; m14 = tc.m14; m15 = tc.m15; m16 = tc.m16; m17 = tc.m17; m18 = tc.m18; m19 = tc.m19; mx1 = tc.mx1; my1 = tc.my1; mz1 = tc.mz1; ma1 = tc.ma1; mb1 = tc.mb1; mc1 = tc.mc1; m20 = tc.m20; m21 = tc.m21; m22 = tc.m22; m23 = tc.m23; m24 = tc.m24; m25 = tc.m25; m26 = tc.m26; m27 = tc.m27; m28 = tc.m28; m29 = tc.m29; mx2 = tc.mx2; my2 = tc.my2; mz2 = tc.mz2; ma2 = tc.ma2; mb2 = tc.mb2; mc2 = tc.mc2; p00 = tc.p00; p04 = tc.p04; p05 = tc.p05; p09 = tc.p09; rc0 = tc.rc0; p10 = tc.p10; p12 = tc.p12; p13 = tc.p13; p14 = tc.p14; p15 = tc.p15; p17 = tc.p17; p18 = tc.p18; p19 = tc.p19; p110 = tc.p110; rc1 = tc.rc1; p20 = tc.p20; p22 = tc.p22; p23 = tc.p23; p24 = tc.p24; p25 = tc.p25; p27 = tc.p27; p28 = tc.p28; p29 = tc.p29; p210 = tc.p210; rc2 = tc.rc2; chi20 = tc.chi20; chi21 = tc.chi21; chi22 = tc.chi22; return *this; }