Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

calib_barrel_sigma Class Reference

#include <calib_barrel_sigma.h>

Inheritance diagram for calib_barrel_sigma:

TofCalibFit TofCalibFit List of all members.

Public Member Functions

void calculate (RecordSet *&data, unsigned int icounter)
void calculate (RecordSet *&data, unsigned int icounter)
 calib_barrel_sigma (const unsigned int nzbin)
 calib_barrel_sigma (const unsigned int nzbin)
void fillRoot (const char *file)
void fillRoot (const char *file)
void fillTxt (const char *file)
void fillTxt (const char *file)
const string & name () const
const string & name () const
void setTCorrelation (HepVector tc)
void setTCorrelation (HepVector tc)
HepVector tcorrelation ()
HepVector tcorrelation ()
 ~calib_barrel_sigma ()
 ~calib_barrel_sigma ()

Protected Attributes

std::vector< string > CanvasName
std::vector< string > CanvasName
std::vector< string > CanvasPerCounterName
std::vector< string > CanvasPerCounterName
std::vector< TGraphErrors * > m_graphs
std::vector< TGraphErrors * > m_graphs
std::vector< TH1F * > m_histograms
std::vector< TH1F * > m_histograms
string m_name
int m_npar
std::vector< HepVector > m_result
std::vector< HepVector > m_result
HepVector m_tcorrelation
unsigned int nBinPerCounter
unsigned int nCanvas
unsigned int nCanvasPerCounter
std::vector< unsigned int > nGraphPerCanvas
std::vector< unsigned int > nGraphPerCanvas
std::vector< unsigned int > nGraphPerCanvasPerCounter
std::vector< unsigned int > nGraphPerCanvasPerCounter
unsigned int nHistogram
unsigned int nHistPerCounter
unsigned int nKind
HepVector X

Private Member Functions

void fillGraph (unsigned int icounter)
void fillGraph (unsigned int icounter)
void fillGraphT0 (unsigned int icounter)
void fillGraphT0 (unsigned int icounter)
void fillRecord (const Record *r, unsigned int icounter)
void fillRecord (const Record *r, unsigned int icounter)
void fillRecordT0 (const Record *r, unsigned int icounter)
void fillRecordT0 (const Record *r, unsigned int icounter)
void fitGraph (unsigned int icounter)
void fitGraph (unsigned int icounter)
void fitGraphT0 (unsigned int icounter)
void fitGraphT0 (unsigned int icounter)
void fitHistogram (unsigned int icounter)
void fitHistogram (unsigned int icounter)
void fitHistogramT0 (unsigned int icounter)
void fitHistogramT0 (unsigned int icounter)
void updateData (Record *r, unsigned int icounter)
void updateData (Record *r, unsigned int icounter)

Private Attributes

std::vector< HepVector > m_fitresult
std::vector< HepVector > m_fitresult
std::vector< double > zpos
std::vector< double > zpos
std::vector< double > zposerr
std::vector< double > zposerr
double zstep

Constructor & Destructor Documentation

calib_barrel_sigma::calib_barrel_sigma (  const unsigned int  nzbin  ) 
  

00021                                                                 :TofCalibFit( true, nBarrelSigma ) {
00022 
00023   nKind          = 5;    // 0:tleft, 1:tright, 2:t0, 3:tplus, 4:tminus
00024   nBinPerCounter = nzbin;
00025 
00026   nHistPerCounter   = nKind*nBinPerCounter;
00027   nCanvasPerCounter = 4;
00028   CanvasPerCounterName.push_back( static_cast<string>("Offset") );  
00029   CanvasPerCounterName.push_back( static_cast<string>("Offset-TimeCorrelation") );  
00030   CanvasPerCounterName.push_back( static_cast<string>("Sigma") );  
00031   CanvasPerCounterName.push_back( static_cast<string>("Sigma-TimeCorrelation") );  
00032   nGraphPerCanvasPerCounter.push_back(3);
00033   nGraphPerCanvasPerCounter.push_back(2);
00034   nGraphPerCanvasPerCounter.push_back(3);
00035   nGraphPerCanvasPerCounter.push_back(3);
00036 
00037   nHistogram      = 0;
00038   nCanvas         = 0;
00039 
00040   int numGraphs = 0;
00041   std::vector<unsigned int>::iterator iter = nGraphPerCanvasPerCounter.begin();
00042   for( ; iter!=nGraphPerCanvasPerCounter.end(); iter++ ) {
00043     numGraphs = numGraphs + (*iter);
00044   }
00045   if( numGraphs != nGraphTotalSigma ) {
00046     cout << "tofcalgsec::calib_barrel_sigma: the number of Graphs is NOT reasonable!!!" << endl;
00047     exit(0);
00048   }
00049 
00050   m_name = string("calib_barrel_sigma");
00051 
00052   const int tbin   = 150;
00053   const double tbegin = -1.5;
00054   const double tend   =  1.5;
00055 
00056   // histograms per counter
00057   char hname[256];
00058   for( unsigned int i=0; i<NBarrel; i++ ) {
00059     m_result.push_back( HepVector(nBarrelSigma,0) );
00060     for( unsigned int j=0; j<nKind; j++ ) {
00061       for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00062         if( j==0 )      { sprintf( hname, "tleft-id%i-z%i",  i, k); }
00063         else if( j==1 ) { sprintf( hname, "tright-id%i-z%i", i, k); }
00064         else if( j==2 ) { sprintf( hname, "t0-id%i-z%i",     i, k); }
00065         else if( j==3 ) { sprintf( hname, "tplus-id%i-z%i",  i, k); }
00066         else if( j==4 ) { sprintf( hname, "tminus-id%i-z%i", i, k); }
00067         m_histograms.push_back( new TH1F( hname, hname, tbin, tbegin, tend ) );
00068 
00069         m_fitresult.push_back( HepVector(nParSigma,0) );
00070       }
00071     }
00072   }
00073 
00074   zpos.resize( nBinPerCounter );
00075   zposerr.resize( nBinPerCounter );
00076   zstep = ( zend - zbegin )/nBinPerCounter;
00077   for( unsigned int i=0; i<nBinPerCounter; i++ ) {
00078     zpos[i] = zbegin + ( i+0.5 )*zstep;
00079     zposerr[i] = 0.5*zstep;
00080   }
00081 
00082 }

calib_barrel_sigma::~calib_barrel_sigma (   ) 
  

00085                                         {
00086   m_fitresult.clear();
00087   zpos.clear();
00088   zposerr.clear();
00089 }

calib_barrel_sigma::calib_barrel_sigma (  const unsigned int  nzbin  ) 
 

calib_barrel_sigma::~calib_barrel_sigma (   ) 
 

Member Function Documentation

void calib_barrel_sigma::calculate (  RecordSet *&  data,
unsigned int  icounter
)  [virtual]
 

Implements TofCalibFit.

void calib_barrel_sigma::calculate (  RecordSet *&  data,
unsigned int  icounter
)  [virtual]
 

Implements TofCalibFit.

00092                                                                             {
00093 
00094   std::cout << setiosflags(ios::left) << setw(10) << icounter << setw(8) << data->size() << setw(30) << name() << std::endl;
00095 
00096   if( data->size() > 0 ) {
00097     std::vector<Record*>::iterator iter = data->begin();
00098     for( ; iter!=data->end(); iter++ ) {
00099       fillRecord( (*iter), icounter );
00100     }
00101   }
00102   fitHistogram( icounter );
00103   fillGraph( icounter );
00104   fitGraph( icounter );
00105 
00106   if( data->size() > 0 ) {
00107     std::vector<Record*>::iterator iter = data->begin();
00108     for( ; iter!=data->end(); iter++ ) {
00109       updateData( (*iter), icounter );
00110       fillRecordT0( (*iter), icounter );
00111     }
00112   }
00113   fitHistogramT0( icounter );
00114   fillGraphT0( icounter );
00115   fitGraphT0( icounter );
00116 
00117   return;
00118 }

void calib_barrel_sigma::fillGraph (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fillGraph (  unsigned int  icounter  )  [private]
  

00169                                                           {
00170 
00171   char gname1[256], gname2[256];
00172 
00173   // fill graphs
00174   // 4 canvas per counter,
00175   //   1. offset of tleft, tright and t0 vs z 
00176   //   2. sigma of tleft, tright and t0 vs z
00177   //   3. offset of tplus and tminus vs z
00178   //   4. sigma of tplus, tminus and T_Correlation vs z
00179   std::vector<double> toffset, toffseterr;
00180   std::vector<double> tsigma, tsigmaerr;
00181   toffset.resize( nBinPerCounter );
00182   toffseterr.resize( nBinPerCounter );
00183   tsigma.resize( nBinPerCounter );
00184   tsigmaerr.resize( nBinPerCounter );
00185 
00186   unsigned int number = 0;
00187   std::vector<HepVector>::iterator iter = m_fitresult.begin() + icounter*nKind*nBinPerCounter;
00188   for( unsigned int j=0; j<nKind; j++ ) {
00189     for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00190       number = j*nBinPerCounter + k;
00191       toffset[k]    = (*(iter+number))[0];
00192       toffseterr[k] = (*(iter+number))[1];
00193     }
00194 
00195     sprintf( gname1, "offset-tofid-%i", icounter );
00196     if( j!=2 ) {
00197       m_graphs.push_back( new TGraphErrors( nBinPerCounter, &zpos[0], &toffset[0], &zposerr[0], &toffseterr[0]) );
00198     }
00199     else {
00200       m_graphs.push_back( new TGraphErrors( nBinPerCounter ) );
00201     }
00202     std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00203     (*itgraph)->SetTitle(gname1);
00204     (*itgraph)->SetMarkerSize(1.5);
00205     if( j==0 || j==3) {
00206       (*itgraph)->SetMarkerStyle(20);
00207       (*itgraph)->SetMarkerColor(2);
00208       (*itgraph)->SetMaximum( 0.15 );
00209       (*itgraph)->SetMinimum(-0.15 );
00210     }
00211     else if( j==1 || j==4 ) {
00212       (*itgraph)->SetMarkerStyle(21);
00213       (*itgraph)->SetMarkerColor(4);
00214     }
00215     else if( j==2 ) {
00216       (*itgraph)->SetMarkerStyle(4);
00217       (*itgraph)->SetMarkerColor(2);
00218     }
00219   }
00220 
00221   for( unsigned int j=0; j<nKind; j++ ) {
00222     for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00223       number = j*nBinPerCounter + k;
00224       tsigma[k]     = (*(iter+number))[2];
00225       tsigmaerr[k]  = (*(iter+number))[3];
00226     }
00227 
00228     sprintf( gname2, "sigma-tofid-%i", icounter );
00229     if( j!=2 ) {
00230       m_graphs.push_back( new TGraphErrors( nBinPerCounter, &zpos[0], &tsigma[0], &zposerr[0], &tsigmaerr[0]) );
00231     }
00232     else {
00233       m_graphs.push_back( new TGraphErrors( nBinPerCounter ) ); 
00234     }
00235     std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00236     (*itgraph)->SetTitle(gname2);
00237     (*itgraph)->SetMarkerSize(1.5);
00238     if( j==0 || j==3 ) {
00239       (*itgraph)->SetMarkerStyle(20);
00240       (*itgraph)->SetMarkerColor(2);
00241       (*itgraph)->SetMaximum( 0.3 );
00242       (*itgraph)->SetMinimum( 0.0 );
00243     }
00244     else if( j==1 || j==4 ) {
00245       (*itgraph)->SetMarkerStyle(21);
00246       (*itgraph)->SetMarkerColor(4);
00247     }
00248     else if( j==2 ) {
00249       (*itgraph)->SetMarkerStyle(4);
00250       (*itgraph)->SetMarkerColor(2);
00251     }
00252   }
00253 
00254   for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00255     number = (nKind-1)*nBinPerCounter + k;
00256     double sigPlus  = (*(iter+number-nBinPerCounter))[2];
00257     double sigMinus = (*(iter+number))[2];
00258     double sigErrPlus  = (*(iter+number-nBinPerCounter))[3];
00259     double sigErrMinus = (*(iter+number))[3];
00260     tsigma[k]     = sqrt( sigPlus*sigPlus - sigMinus*sigMinus );
00261     tsigmaerr[k]  = sqrt( sigErrPlus*sigErrPlus + sigErrMinus*sigErrMinus );
00262   }
00263   sprintf( gname2, "sigma-tofid-%i", icounter );
00264   m_graphs.push_back( new TGraphErrors( nBinPerCounter, &zpos[0], &tsigma[0], &zposerr[0], &tsigmaerr[0]) );
00265   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00266   (*itgraph)->SetTitle(gname2);
00267   (*itgraph)->SetMarkerSize(1.5);
00268   (*itgraph)->SetMarkerStyle(4);
00269   (*itgraph)->SetMarkerColor(2);
00270 
00271   return;
00272 }

void calib_barrel_sigma::fillGraphT0 (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fillGraphT0 (  unsigned int  icounter  )  [private]
  

00364                                                             {
00365   char gname1[256], gname2[256];
00366 
00367   // fill graphs
00368   // 4 canvas per counter,
00369   //   1. offset of tleft, tright and t0 vs z 
00370   //   2. sigma of tleft, tright and t0 vs z
00371   //   3. offset of tplus and tminus vs z
00372   //   4. sigma of tplus, tminus and T_Correlation vs z
00373   std::vector<double> toffset, toffseterr;
00374   std::vector<double> tsigma, tsigmaerr;
00375   toffset.resize( nBinPerCounter );
00376   toffseterr.resize( nBinPerCounter );
00377   tsigma.resize( nBinPerCounter );
00378   tsigmaerr.resize( nBinPerCounter );
00379 
00380   std::vector<HepVector>::iterator iter = m_fitresult.begin() + icounter*nKind*nBinPerCounter + 2*nBinPerCounter;
00381   for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00382     toffset[k]    = (*(iter+k))[0];
00383     toffseterr[k] = (*(iter+k))[1];
00384     tsigma[k]     = (*(iter+k))[2];
00385     tsigmaerr[k]  = (*(iter+k))[3];
00386   }
00387 
00388   sprintf( gname1, "offset-tofid-%i", icounter );
00389   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.begin() + icounter*nGraphTotalSigma + 2;
00390   for( unsigned int i=0; i<nBinPerCounter; i++ ) {
00391     (*itgraph)->SetPoint( i, zpos[i], toffset[i] );
00392     (*itgraph)->SetPointError( i, zposerr[i], toffseterr[i] );
00393   }
00394 
00395   sprintf( gname2, "sigma-tofid-%i", icounter );
00396   itgraph = m_graphs.begin() + icounter*nGraphTotalSigma + 7;
00397   for( unsigned int i=0; i<nBinPerCounter; i++ ) {
00398     (*itgraph)->SetPoint( i, zpos[i], tsigma[i] );
00399     (*itgraph)->SetPointError( i, zposerr[i], tsigmaerr[i] );
00400   }
00401 
00402   return;
00403 }

void calib_barrel_sigma::fillRecord (  const Record *  r,
unsigned int  icounter
)  [private]
 

void calib_barrel_sigma::fillRecord (  const Record *  r,
unsigned int  icounter
)  [private]
  

00121                                                                             {
00122 
00123   double zhit = r->zrhit();
00124   if( zhit<zbegin || zhit>zend ) return;
00125   int zbin = static_cast<int>((zhit-zbegin)/zstep);
00126   if( zbin<0 ) { zbin = 0; }
00127   else if( zbin>static_cast<int>(nBinPerCounter-1) ) {
00128     cout << "tofcalgsec::calib_barrel_sigma:fillRecord: zhit is out of range, zhit=" << zhit << " zbin=" << zbin << endl;
00129     return;
00130   }
00131 
00132   std::vector<TH1F*>::iterator iter = m_histograms.begin();
00133   unsigned int number = icounter*nKind*nBinPerCounter + zbin;
00134   (*(iter+number))->Fill( r->tleft() );
00135   (*(iter+nBinPerCounter+number))->Fill( r->tright() );
00136   (*(iter+3*nBinPerCounter+number))->Fill( (r->tleft()+r->tright())/2.0 );
00137   (*(iter+4*nBinPerCounter+number))->Fill( (r->tleft()-r->tright())/2.0 );
00138 
00139   return;
00140 }

void calib_barrel_sigma::fillRecordT0 (  const Record *  r,
unsigned int  icounter
)  [private]
 

void calib_barrel_sigma::fillRecordT0 (  const Record *  r,
unsigned int  icounter
)  [private]
  

00327                                                                               {
00328   double zhit = r->zrhit();
00329   if( zhit<zbegin || zhit>zend ) return;
00330   int zbin = static_cast<int>((zhit-zbegin)/zstep);
00331   if( zbin<0 ) { zbin = 0; }
00332   else if( zbin>static_cast<int>(nBinPerCounter-1) ) {
00333     cout << "tofcalgsec::calib_barrel_sigma:fillRecordT0: zhit is out of range, zhit=" << zhit << " zbin=" << zbin << endl;
00334     return;
00335   }
00336 
00337   std::vector<TH1F*>::iterator iter = m_histograms.begin();
00338   unsigned int number = icounter*nKind*nBinPerCounter + 2*nBinPerCounter + zbin;
00339   (*(iter+number))->Fill( r->t0() );
00340  
00341   return;
00342 }

void TofCalibFit::fillRoot (  const char *  file  )  [inherited]
 

void TofCalibFit::fillRoot (  const char *  file  )  [inherited]
  

00080                                              {
00081 
00082   unsigned int nhist = m_histograms.size();
00083   if( nhist != (nCounter*nHistPerCounter + nHistogram) ) {
00084     std::cout<<" tofcalgsec::TofCalibFit:" << m_name << ": the number of histograms is NOT same as the number of histograms saved!" << " nhist=" << nhist << " calculated=" << (nCounter*nHistPerCounter + nHistogram) << " nCounter=" << nCounter << " nHistPerCounter=" << nHistPerCounter << " nHistogram=" << nHistogram << std::endl;
00085     exit(0);
00086   }
00087 
00088   unsigned int numgraph1 = 0;
00089   unsigned int numgraph2 = 0;
00090   if( nCanvasPerCounter!=0 ) {
00091     std::vector<unsigned int>::iterator iter = nGraphPerCanvasPerCounter.begin();
00092     for( ; iter!=nGraphPerCanvasPerCounter.end(); iter++ ) {
00093       numgraph1 = numgraph1 + (*iter);
00094     }
00095   }
00096   if( nCanvas!=0 ) {
00097     std::vector<unsigned int>::iterator iter = nGraphPerCanvas.begin();
00098     for( ; iter!=nGraphPerCanvas.end(); iter++ ) {
00099       numgraph2 = numgraph2 + (*iter);
00100     }
00101   }
00102   unsigned int ngraph = m_graphs.size();
00103   if( ngraph != ( nCounter*numgraph1+numgraph2) ) {
00104     std::cout<<" tofcalgsec::TofCalibFit:"<< m_name << ": the number of graphs is NOT same as the number of graphs saved!"<<std::endl;
00105     exit(0);
00106   }
00107 
00108   TFile f(file,"RECREATE");
00109 
00110   gStyle->SetOptStat(2211);
00111   gStyle->SetOptFit(1111);
00112   gStyle->SetLabelSize(0.03,"x");
00113   gStyle->SetLabelSize(0.03,"y");
00114 
00115   char dirname[256];
00116   char canvasname[256];
00117   if( nHistPerCounter>0 || nCanvasPerCounter>0 ) {
00118     std::vector<TH1F*>::iterator   iter1 = m_histograms.begin();
00119     std::vector<TGraphErrors*>::iterator iter2 = m_graphs.begin();
00120     for( unsigned int i=0; i<nCounter; i++ ) {
00121       sprintf( dirname, "tofid%i", i );
00122       TDirectory* cdresult = f.mkdir( dirname );
00123       cdresult->cd();
00124       
00125       for( unsigned int j=0; j<nHistPerCounter; j++ ) {
00126         (*(iter1+j))->Write();
00127       }
00128       iter1 = iter1 + nHistPerCounter;
00129 
00130       for( unsigned int j=0; j<nCanvasPerCounter; j++ ) {
00131         std::vector<string>::iterator it1 = CanvasPerCounterName.begin() + j;
00132         std::vector<unsigned int>::iterator it2 = nGraphPerCanvasPerCounter.begin() + j;
00133         sprintf( canvasname, "%s-tofid-%i", (*it1).c_str(), i );
00134         TCanvas* c1 = new TCanvas( canvasname, canvasname, 1);
00135         c1->SetFillColor(10);
00136         for( unsigned int k=0; k<(*it2); k++ ) {
00137           if( k==0 ) {
00138             (*(iter2+k))->Draw("AP");
00139           }
00140           else {
00141             (*(iter2+k))->Draw("P");
00142           }
00143         }
00144         iter2 = iter2 + (*it2);
00145         c1->Write();
00146       }
00147     }
00148   }
00149 
00150   if( nHistogram>0 || nCanvas>0 ) {
00151     sprintf( dirname, "summary" );
00152     TDirectory* cdresult = f.mkdir( dirname );
00153     cdresult->cd();
00154 
00155     std::vector<TH1F*>::iterator iter1 = m_histograms.begin() + nCounter*nHistPerCounter;
00156     std::vector<TGraphErrors*>::iterator iter2 = m_graphs.begin() + nCounter*numgraph1;
00157     for( ; iter1 != m_histograms.end(); iter1++ ) {
00158       (*iter1)->Write();
00159     }
00160 
00161     for( unsigned int j=0; j<nCanvas; j++ ) {
00162       std::vector<string>::iterator it1 = CanvasName.begin() + j;
00163       std::vector<unsigned int>::iterator it2 = nGraphPerCanvas.begin() + j;
00164       sprintf( canvasname, (*it1).c_str() );
00165       TCanvas* c1 = new TCanvas( canvasname, canvasname, 1);
00166       c1->SetFillColor(10);
00167       for( unsigned int k=0; k<(*it2); k++ ) {
00168         if( k==0 ) {
00169           (*(iter2+k))->Draw("AP");
00170         }
00171         else {
00172           (*(iter2+k))->Draw("P");
00173         }
00174       }
00175       iter2 = iter2 + (*it2);
00176       c1->Write();
00177     }
00178 
00179   }
00180 
00181   f.Close();
00182 
00183   return;
00184 }

void TofCalibFit::fillTxt (  const char *  file  )  [inherited]
 

void TofCalibFit::fillTxt (  const char *  file  )  [inherited]
  

00052                                             {
00053   std::ofstream out(file,ios::out);
00054   if( out ) {
00055     std::vector<HepVector>::iterator it;
00056     for( it=m_result.begin(); it!=m_result.end(); it++ ) {
00057       for( int i=0; i<(*it).num_row(); i++ ) {
00058         out << (*it)[i] << " ";
00059       }
00060       out << std::endl;
00061     }
00062     out.close();
00063   }
00064   else{
00065     cerr << "error when open file " << file << " for write in " << name() << "::fillTxt()" << std::endl;
00066     cout << "print all parameters to srceen: in total " << m_result.size() << " items" << std::endl;
00067     std::vector<HepVector>::iterator it;
00068     for( it=m_result.begin(); it!=m_result.end(); it++ ) {
00069       for( int i=0; i<(*it).num_row(); i++ ) {
00070         cout << (*it)[i] << " ";
00071       }
00072       cout << std::endl;
00073     }
00074   }
00075 
00076   return;
00077 }

void calib_barrel_sigma::fitGraph (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fitGraph (  unsigned int  icounter  )  [private]
  

00275                                                          {
00276 
00277   TF1* fsingle = new TF1("fsingle", "pol4");
00278   fsingle->SetLineColor(1);
00279   fsingle->SetLineWidth(1);
00280 
00281   std::vector<unsigned int>::iterator itnumber = nGraphPerCanvasPerCounter.begin();
00282   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.begin() + icounter*nGraphTotalSigma + (*itnumber) + (*(itnumber+1));
00283 
00284   (*itgraph)->Fit( "fsingle", "Q", "", zbegin, zend );
00285   X = HepVector( m_npar, 0 );
00286   for( unsigned int i=0; i<5; i++ ) {
00287     X[i] = fsingle->GetParameter(i);
00288   }
00289   (*(itgraph+1))->Fit( "fsingle", "Q", "", zbegin, zend );
00290   for( unsigned int i=0; i<5; i++ ) {
00291     X[i+5] = fsingle->GetParameter(i);
00292   }
00293 
00294   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00295   (*iter) = X;
00296 
00297   return;
00298 }

void calib_barrel_sigma::fitGraphT0 (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fitGraphT0 (  unsigned int  icounter  )  [private]
  

00406                                                            {
00407 
00408   //  TF1 *fdouble = new TF1( "fdouble", doubleEndFunc, zbegin, zend, 3 );
00409   TF1 *fdouble = new TF1( "fdouble", "pol4", zbegin, zend );
00410   fdouble->SetLineColor(1);
00411   fdouble->SetLineWidth(1);
00412 
00413   std::vector<unsigned int>::iterator itnumber = nGraphPerCanvasPerCounter.begin();
00414   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.begin() + icounter*nGraphTotalSigma + (*itnumber) + (*(itnumber+1)) + 2;
00415   (*itgraph)->Fit( "fdouble", "Q", "", zbegin, zend );
00416 
00417   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00418   (*iter)[10] = fdouble->GetParameter(0);
00419   (*iter)[11] = fdouble->GetParameter(1);
00420   (*iter)[12] = fdouble->GetParameter(2);
00421   (*iter)[13] = fdouble->GetParameter(3);
00422   (*iter)[14] = fdouble->GetParameter(4);
00423 
00424   return;
00425 }

void calib_barrel_sigma::fitHistogram (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fitHistogram (  unsigned int  icounter  )  [private]
  

00143                                                              {
00144   TF1* g = new TF1("g", "gaus");
00145   g->SetLineColor(2);
00146   g->SetLineWidth(1);
00147 
00148   std::vector<TH1F*>::iterator     iter1 = m_histograms.begin() + icounter*nKind*nBinPerCounter;
00149   std::vector<HepVector>::iterator iter2 = m_fitresult.begin() + icounter*nKind*nBinPerCounter;
00150   for( unsigned int i=0; i<nKind; i++ ) {
00151     for( unsigned int j=0; j<nBinPerCounter; j++ ) {
00152       if( i!=2 ) {
00153         (*iter1)->Fit( g, "Q");
00154         (*iter2)[0] = g->GetParameter(1);
00155         (*iter2)[1] = g->GetParError(1);
00156         (*iter2)[2] = g->GetParameter(2);
00157         (*iter2)[3] = g->GetParError(2);
00158       }
00159       iter1++;
00160       iter2++;
00161     }
00162   }
00163 
00164   return;
00165 
00166 }

void calib_barrel_sigma::fitHistogramT0 (  unsigned int  icounter  )  [private]
 

void calib_barrel_sigma::fitHistogramT0 (  unsigned int  icounter  )  [private]
  

00345                                                                {
00346   TF1* g = new TF1("g", "gaus");
00347   g->SetLineColor(2);
00348   g->SetLineWidth(1);
00349 
00350   std::vector<TH1F*>::iterator     iter1 = m_histograms.begin() + icounter*nKind*nBinPerCounter + 2*nBinPerCounter;
00351   std::vector<HepVector>::iterator iter2 = m_fitresult.begin() + icounter*nKind*nBinPerCounter + 2*nBinPerCounter;
00352   for( unsigned int j=0; j<nBinPerCounter; j++, iter1++, iter2++ ) {
00353     (*iter1)->Fit( g, "Q");
00354     (*iter2)[0] = g->GetParameter(1);
00355     (*iter2)[1] = g->GetParError(1);
00356     (*iter2)[2] = g->GetParameter(2);
00357     (*iter2)[3] = g->GetParError(2);
00358   }
00359 
00360   return;
00361 }

const string& TofCalibFit::name (  void   )  const [inline, inherited]
  

00029 { return m_name; }

const string& TofCalibFit::name (   )  const [inline, inherited]
  

00029 { return m_name; }

void TofCalibFit::setTCorrelation (  HepVector  tc  )  [inline, inherited]
  

00037 { m_tcorrelation = tc; }

void TofCalibFit::setTCorrelation (  HepVector  tc  )  [inline, inherited]
  

00037 { m_tcorrelation = tc; }

HepVector TofCalibFit::tcorrelation (   )  [inline, inherited]
  

00036 { return X;            }

HepVector TofCalibFit::tcorrelation (   )  [inline, inherited]
  

00036 { return X;            }

void calib_barrel_sigma::updateData (  Record *  r,
unsigned int  icounter
)  [private]
 

void calib_barrel_sigma::updateData (  Record *  r,
unsigned int  icounter
)  [private]
  

00301                                                                       {
00302   double zhit = r->zrhit();
00303   double t1 = r->tleft();
00304   double t2 = r->tright();
00305 
00306   double par1[5], par2[5];
00307   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00308   for( unsigned int i=0; i<5; i++ ) {
00309     par1[i] = (*iter)[i];
00310     par2[i] = (*iter)[i+5];
00311   }
00312 
00313   double tsigma1 = par1[0]+par1[1]*zhit+par1[2]*pow(zhit,2)+par1[3]*pow(zhit,3) + par1[4]*pow(zhit,4);
00314   double tsigma2 = par2[0]+par2[1]*zhit+par2[2]*pow(zhit,2)+par2[3]*pow(zhit,3) + par2[4]*pow(zhit,4);
00315   double tc      = m_tcorrelation[0];
00316 
00317   double weight1 = (tsigma2*tsigma2-tc*tc)/(tsigma1*tsigma1+tsigma2*tsigma2-2.0*tc*tc);
00318   double weight2 = (tsigma1*tsigma1-tc*tc)/(tsigma1*tsigma1+tsigma2*tsigma2-2.0*tc*tc);
00319   double t0 = weight1*t1 + weight2*t2;
00320 
00321   r->setT0( t0 );
00322   
00323   return;
00324 }

Member Data Documentation

std::vector<string> TofCalibFit::CanvasName [protected, inherited]
 

std::vector<string> TofCalibFit::CanvasName [protected, inherited]
 

std::vector<string> TofCalibFit::CanvasPerCounterName [protected, inherited]
 

std::vector<string> TofCalibFit::CanvasPerCounterName [protected, inherited]
 

std::vector<HepVector> calib_barrel_sigma::m_fitresult [private]
 

std::vector<HepVector> calib_barrel_sigma::m_fitresult [private]
 

std::vector<TGraphErrors*> TofCalibFit::m_graphs [protected, inherited]
 

std::vector<TGraphErrors*> TofCalibFit::m_graphs [protected, inherited]
 

std::vector<TH1F*> TofCalibFit::m_histograms [protected, inherited]
 

std::vector<TH1F*> TofCalibFit::m_histograms [protected, inherited]
 

string TofCalibFit::m_name [protected, inherited]
 

int TofCalibFit::m_npar [protected, inherited]
 

std::vector<HepVector> TofCalibFit::m_result [protected, inherited]
 

std::vector<HepVector> TofCalibFit::m_result [protected, inherited]
 

HepVector TofCalibFit::m_tcorrelation [protected, inherited]
 

unsigned int TofCalibFit::nBinPerCounter [protected, inherited]
 

unsigned int TofCalibFit::nCanvas [protected, inherited]
 

unsigned int TofCalibFit::nCanvasPerCounter [protected, inherited]
 

std::vector<unsigned int> TofCalibFit::nGraphPerCanvas [protected, inherited]
 

std::vector<unsigned int> TofCalibFit::nGraphPerCanvas [protected, inherited]
 

std::vector<unsigned int> TofCalibFit::nGraphPerCanvasPerCounter [protected, inherited]
 

std::vector<unsigned int> TofCalibFit::nGraphPerCanvasPerCounter [protected, inherited]
 

unsigned int TofCalibFit::nHistogram [protected, inherited]
 

unsigned int TofCalibFit::nHistPerCounter [protected, inherited]
 

unsigned int TofCalibFit::nKind [protected, inherited]
 

HepVector TofCalibFit::X [protected, inherited]
 

std::vector<double> calib_barrel_sigma::zpos [private]
 

std::vector<double> calib_barrel_sigma::zpos [private]
 

std::vector<double> calib_barrel_sigma::zposerr [private]
 

std::vector<double> calib_barrel_sigma::zposerr [private]
 

double calib_barrel_sigma::zstep [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 15:55:40 2011 for BOSS6.5.5 by  doxygen 1.3.9.1