calib_endcap_atten Class Reference

#include <calib_endcap_atten.h>

Inheritance diagram for calib_endcap_atten:

TofCalibFit List of all members.

Public Member Functions

 calib_endcap_atten (const unsigned int nrbin)
 ~calib_endcap_atten ()
void calculate (RecordSet *&data, unsigned int icounter)
const stringname () const
void fillTxt (const char *file)
void fillRoot (const char *file)
HepVector tcorrelation ()
void setTCorrelation (HepVector tc)

Protected Attributes

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

Private Member Functions

void fillRecord (const Record *r, unsigned int icounter)
void fitHistogram (unsigned int icounter)
void fillGraph (unsigned int icounter)
void fitGraph (unsigned int icounter)
void updateData (Record *r, unsigned int icounter)
void fillRecordQ0 (const Record *r, unsigned int icounter)
void fitHistogramQ0 (unsigned int icounter)
void fillGraphQ0 ()

Private Attributes

std::vector< double > rpos
std::vector< double > rposerr
double rstep
std::vector< double > itofid
std::vector< double > itofiderr
double itofidstep
std::vector< HepVector > m_fitresult

Detailed Description

Definition at line 10 of file calib_endcap_atten.h.


Constructor & Destructor Documentation

calib_endcap_atten::calib_endcap_atten ( const unsigned int  nrbin  ) 

Definition at line 13 of file calib_endcap_atten.cxx.

References TofCalibFit::CanvasName, TofCalibFit::CanvasPerCounterName, genRecEmupikp::i, iter(), itofid, itofiderr, itofidstep, m_fitresult, TofCalibFit::m_histograms, TofCalibFit::m_name, TofCalibFit::m_result, TofCalibFit::nBinPerCounter, TofCalibFit::nCanvas, TofCalibFit::nCanvasPerCounter, NEndcap, nEndcapAtten, nGraphEcAtten, TofCalibFit::nGraphPerCanvas, TofCalibFit::nGraphPerCanvasPerCounter, TofCalibFit::nHistogram, TofCalibFit::nHistPerCounter, TofCalibFit::nKind, nParEcAtten, rbegin, rend, rpos, rposerr, rstep, and deljobs::string.

00013                                                                 :TofCalibFit( false, nEndcapAtten ) {
00014 
00015   nKind          = 1;    // pulse height
00016   nBinPerCounter = nrbin + 1;
00017 
00018   nHistPerCounter   = nKind*nBinPerCounter;
00019   nCanvasPerCounter = 2;
00020   CanvasPerCounterName.push_back( static_cast<string>("Pulse Height Most Probable Value") );  
00021   CanvasPerCounterName.push_back( static_cast<string>("Pulse Height Sigma") );  
00022   nGraphPerCanvasPerCounter.push_back(1);
00023   nGraphPerCanvasPerCounter.push_back(1);
00024 
00025   nHistogram      = 0;
00026   nCanvas         = 2;
00027   CanvasName.push_back( static_cast<string>("Pulse Height Most Probable Value vs TOF Counter Number") );  
00028   CanvasName.push_back( static_cast<string>("Pulse Height Sigma vs TOF Counter Number") );  
00029   nGraphPerCanvas.push_back(1);
00030   nGraphPerCanvas.push_back(1);
00031 
00032   int numGraphs1 = 0;
00033   std::vector<unsigned int>::iterator iter = nGraphPerCanvasPerCounter.begin();
00034   for( ; iter!=nGraphPerCanvasPerCounter.end(); iter++ ) {
00035     numGraphs1 = numGraphs1 + (*iter);
00036   }
00037   if( numGraphs1 != nGraphEcAtten ) {
00038     cout << "tofcalgsec::calib_endcap_atten: the number of Graphs is NOT reasonable!!!" << endl;
00039     exit(0);
00040   }
00041   int numGraphs2 = 0;
00042   iter = nGraphPerCanvas.begin();
00043   for( ; iter!=nGraphPerCanvas.end(); iter++ ) {
00044     numGraphs2 = numGraphs2 + (*iter);
00045   }
00046   if( numGraphs2 != nGraphEcAtten ) {
00047     cout << "tofcalgsec::calib_endcap_atten: the number of Graphs is NOT reasonable!!!" << endl;
00048     exit(0);
00049   }
00050 
00051   m_name = string("calib_endcap_atten");
00052 
00053   const int qbin      = 100;
00054   const double qbegin = 0.0;
00055   const double qend   = 5000.0;
00056 
00057   // histograms per counter
00058   char hname[256];
00059   for( unsigned int i=0; i<NEndcap; i++ ) {
00060     m_result.push_back( HepVector(nEndcapAtten,0) );
00061     for( unsigned int k=0; k<nrbin; k++ ) {
00062       sprintf( hname, "Q-id%i-r%i", i, k);
00063       m_histograms.push_back( new TH1F( hname, hname, qbin, qbegin, qend ) );
00064       m_fitresult.push_back( HepVector(nParEcAtten,0) );
00065     }
00066     sprintf( hname, "Q0-id%i", i );
00067     m_histograms.push_back( new TH1F( hname, hname, qbin, qbegin, qend ) );
00068     m_fitresult.push_back( HepVector(nParEcAtten,0) );
00069   }
00070 
00071   rpos.resize( nrbin );
00072   rposerr.resize( nrbin );
00073   rstep = ( rend - rbegin )/nrbin;
00074   for( unsigned int i=0; i<nrbin; i++ ) {
00075     rpos[i] = rbegin + ( i+0.5 )*rstep;
00076     rposerr[i] = 0.5*rstep;
00077   }
00078   itofid.resize( NEndcap );
00079   itofiderr.resize( NEndcap );
00080   itofidstep = 1.0;
00081   for( unsigned int i=0; i<NEndcap; i++ ) {
00082     itofid[i] = i*1.0;
00083     itofiderr[i] = 0.5;
00084   }
00085 
00086 }

calib_endcap_atten::~calib_endcap_atten (  ) 

Definition at line 89 of file calib_endcap_atten.cxx.

References itofid, itofiderr, m_fitresult, rpos, and rposerr.

00089                                         {
00090   m_fitresult.clear();
00091   rpos.clear();
00092   rposerr.clear();
00093   itofid.clear();
00094   itofiderr.clear();
00095 }


Member Function Documentation

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

Implements TofCalibFit.

Definition at line 98 of file calib_endcap_atten.cxx.

References fillGraph(), fillGraphQ0(), fillRecord(), fillRecordQ0(), fitGraph(), fitHistogram(), fitHistogramQ0(), iter(), TofCalibFit::name(), NEndcap, and updateData().

00098                                                                             {
00099 
00100   std::cout << setiosflags(ios::left) << setw(10) << icounter << setw(8) << data->size() << setw(30) << name() << std::endl;
00101 
00102   if( data->size() > 0 ) {
00103     std::vector<Record*>::iterator iter = data->begin();
00104     for( ; iter!=data->end(); iter++ ) {
00105       fillRecord( (*iter), icounter );
00106     }
00107     fitHistogram( icounter );
00108     fillGraph( icounter );
00109     fitGraph( icounter );
00110   }
00111   else {
00112     fillGraph( icounter );  // keep the m_graphs is not empty()
00113   }
00114 
00115   if( data->size() > 0 ) {
00116     std::vector<Record*>::iterator iter = data->begin();
00117     for( ; iter!=data->end(); iter++ ) {
00118       updateData( (*iter), icounter );
00119       fillRecordQ0( (*iter), icounter );
00120     }
00121     fitHistogramQ0( icounter );
00122   }
00123 
00124   if( icounter==(NEndcap-1) ) {
00125     fillGraphQ0();
00126   }
00127 
00128   return;
00129 }

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

Definition at line 170 of file calib_endcap_atten.cxx.

References iter(), m_fitresult, TofCalibFit::m_graphs, TofCalibFit::nBinPerCounter, TofCalibFit::nKind, rbegin, and rend.

Referenced by calculate().

00170                                                           {
00171 
00172   char gname1[256], gname2[256];
00173 
00174   // fill graphs
00175   // 2 canvas per counter,
00176   //   1. Q MPV vs z 
00177   //   2. Q sigma vs z
00178   std::vector<double> toffset, toffseterr;
00179   std::vector<double> tsigma, tsigmaerr;
00180   toffset.resize( nBinPerCounter-1 );
00181   toffseterr.resize( nBinPerCounter-1 );
00182   tsigma.resize( nBinPerCounter-1 );
00183   tsigmaerr.resize( nBinPerCounter-1 );
00184 
00185   std::vector<HepVector>::iterator iter = m_fitresult.begin() + icounter*nKind*nBinPerCounter;
00186   for( unsigned int k=0; k<nBinPerCounter-1; k++ ) {
00187     toffset[k]    = log((*(iter+k))[0]);
00188     toffseterr[k] = log((*(iter+k))[0])*((*(iter+k))[1])/((*(iter+k))[0]);
00189     tsigma[k]     = (*(iter+k))[2];
00190     tsigmaerr[k]  = (*(iter+k))[3];
00191   }
00192 
00193   sprintf( gname1, "Q MPV-tofid-%i", icounter );
00194   m_graphs.push_back( new TH1F( gname1, gname1, nBinPerCounter-1, rbegin, rend ) );
00195   std::vector<TH1F*>::iterator itgraph = m_graphs.end() - 1;
00196   (*itgraph)->SetMarkerSize(1.5);
00197   (*itgraph)->SetMarkerStyle(20);
00198   (*itgraph)->SetMarkerColor(2);
00199   for( unsigned int k=0; k<nBinPerCounter-1; k++ ) {
00200     (*itgraph)->SetBinContent( k+1, toffset[k]    );
00201     (*itgraph)->SetBinError(   k+1, toffseterr[k] );
00202   }
00203 
00204   sprintf( gname2, "Q sigma-tofid-%i", icounter );
00205   m_graphs.push_back( new TH1F( gname2, gname2, nBinPerCounter-1, rbegin, rend ) );
00206   itgraph = m_graphs.end() - 1;
00207   (*itgraph)->SetMarkerSize(1.5);
00208   (*itgraph)->SetMarkerStyle(21);
00209   (*itgraph)->SetMarkerColor(4);
00210   for( unsigned int k=0; k<nBinPerCounter-1; k++ ) {
00211     (*itgraph)->SetBinContent( k+1, tsigma[k]    );
00212     (*itgraph)->SetBinError(   k+1, tsigmaerr[k] );
00213   }
00214 
00215   return;
00216 }

void calib_endcap_atten::fillGraphQ0 (  )  [private]

Definition at line 288 of file calib_endcap_atten.cxx.

References genRecEmupikp::i, m_fitresult, TofCalibFit::m_graphs, TofCalibFit::m_result, TofCalibFit::nBinPerCounter, and NEndcap.

Referenced by calculate().

00288                                      {
00289   char gname1[256], gname2[256];
00290 
00291   // fill graphs
00292   // 2 canvas per counter,
00293   //   1. Q0 MPV vs z 
00294   //   2. Q0 sigma vs z
00295   std::vector<double> toffset, toffseterr;
00296   std::vector<double> tsigma, tsigmaerr;
00297   toffset.resize( NEndcap );
00298   toffseterr.resize( NEndcap );
00299   tsigma.resize( NEndcap );
00300   tsigmaerr.resize( NEndcap );
00301 
00302   unsigned int number = 0;
00303   std::vector<HepVector>::iterator iter1 = m_fitresult.begin() + nBinPerCounter - 1;
00304   std::vector<HepVector>::iterator iter2 = m_result.begin();
00305   for( unsigned int i=0; i<NEndcap; i++ ) {
00306     number = i*nBinPerCounter;
00307     toffset[i]    = (*(iter1+number))[0];
00308     toffseterr[i] = (*(iter1+number))[1];
00309     tsigma[i]     = (*(iter1+number))[2];
00310     tsigmaerr[i]  = (*(iter1+number))[3];
00311 
00312 
00313     (*(iter2+i))[3] = toffset[i]/toffset[0];
00314     (*(iter2+i))[4] = toffset[i];
00315   }
00316 
00317   sprintf( gname1, "Q0 MPV vs TOF Counter Number" );
00318   m_graphs.push_back( new TH1F( gname1, gname1, NEndcap, -0.5, NEndcap-0.5 ) );
00319   std::vector<TH1F*>::iterator itgraph = m_graphs.end() - 1;
00320   (*itgraph)->SetMarkerSize(1.5);
00321   (*itgraph)->SetMarkerStyle(20);
00322   (*itgraph)->SetMarkerColor(2);
00323   for( unsigned int k=0; k<nBinPerCounter-1; k++ ) {
00324     (*itgraph)->SetBinContent( k+1, tsigma[k]    );
00325     (*itgraph)->SetBinError(   k+1, tsigmaerr[k] );
00326   }
00327   for( unsigned int i=0; i<NEndcap; i++ ) {
00328     (*itgraph)->SetBinContent( i+1, toffset[i]    );
00329     (*itgraph)->SetBinError(   i+1, toffseterr[i] );
00330   }
00331 
00332   sprintf( gname2, "Q0 Sigma vs TOF Counter Number" );
00333   m_graphs.push_back( new TH1F( gname2, gname2, NEndcap, -0.5, NEndcap-0.5 ) );
00334   itgraph = m_graphs.end() - 1;
00335   (*itgraph)->SetTitle(gname2);
00336   (*itgraph)->SetMarkerSize(1.5);
00337   (*itgraph)->SetMarkerStyle(21);
00338   (*itgraph)->SetMarkerColor(4);
00339   for( unsigned int i=0; i<NEndcap; i++ ) {
00340     (*itgraph)->SetBinContent( i+1, tsigma[i]    );
00341     (*itgraph)->SetBinError(   i+1, tsigmaerr[i] );
00342   }
00343 
00344   return;
00345 }

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

Definition at line 132 of file calib_endcap_atten.cxx.

References abs, iter(), TofCalibFit::m_histograms, TofCalibFit::nBinPerCounter, TofCalibFit::nKind, Record::qleft(), rbegin, rend, rstep, Record::theta(), and Record::zrhit().

Referenced by calculate().

00132                                                                             {
00133 
00134   double rhit = r->zrhit();
00135   if( rhit<rbegin || rhit>rend ) return;
00136   int rbin = static_cast<int>((rhit-rbegin)/rstep);
00137   if( rbin<0 ) { rbin = 0; }
00138   else if( rbin>static_cast<int>(nBinPerCounter-1-1) ) {
00139     cout << "tofcalgsec::calib_endcap_atten:fillRecord: rhit is out of range, rhit=" << rhit << " rbin=" << rbin << endl;
00140     return;
00141   }
00142 
00143   std::vector<TH1F*>::iterator iter = m_histograms.begin() + icounter*nKind*nBinPerCounter + rbin;
00144   (*iter)->Fill( r->qleft()*abs(r->theta()) );
00145 
00146   return;
00147 }

void calib_endcap_atten::fillRecordQ0 ( const Record r,
unsigned int  icounter 
) [private]

Definition at line 263 of file calib_endcap_atten.cxx.

References iter(), TofCalibFit::m_histograms, TofCalibFit::nBinPerCounter, TofCalibFit::nKind, and Record::q0().

Referenced by calculate().

00263                                                                               {
00264   std::vector<TH1F*>::iterator iter = m_histograms.begin() + icounter*nKind*nBinPerCounter + nBinPerCounter - 1;
00265   (*iter)->Fill( r->q0() );
00266  
00267   return;
00268 }

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

Definition at line 80 of file TofCalibFit.cxx.

References TofCalibFit::CanvasName, TofCalibFit::CanvasPerCounterName, delete_small_size::dirname, genRecEmupikp::i, iter(), ganga-rec::j, TofCalibFit::m_graphs, TofCalibFit::m_histograms, TofCalibFit::m_name, TofCalibFit::nCanvas, TofCalibFit::nCanvasPerCounter, TofCalibFit::nCounter, TofCalibFit::nGraphPerCanvas, TofCalibFit::nGraphPerCanvasPerCounter, TofCalibFit::nHistogram, and TofCalibFit::nHistPerCounter.

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<TH1F*>::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("E");
00139           }
00140           else {
00141             (*(iter2+k))->Draw("Esame");
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<TH1F*>::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("E");
00170         }
00171         else {
00172           (*(iter2+k))->Draw("Esame");
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]

Definition at line 52 of file TofCalibFit.cxx.

References genRecEmupikp::i, TofCalibFit::m_result, and TofCalibFit::name().

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_endcap_atten::fitGraph ( unsigned int  icounter  )  [private]

Definition at line 219 of file calib_endcap_atten.cxx.

References endcapQFunc(), iter(), TofCalibFit::m_graphs, TofCalibFit::m_npar, TofCalibFit::m_result, nGraphEcAtten, rbegin, rend, and TofCalibFit::X.

Referenced by calculate().

00219                                                          {
00220 
00221   TF1 *fsingleq = new TF1( "fsingleq", endcapQFunc, rbegin, rend, 3 );
00222   fsingleq->SetLineColor(1);
00223   fsingleq->SetLineWidth(1);
00224   fsingleq->SetParameters( 6.5, 0.0, 0.0 );
00225 
00226   std::vector<TH1F*>::iterator itgraph = m_graphs.begin() + icounter*nGraphEcAtten;
00227 
00228   (*itgraph)->Fit( "fsingleq", "Q", "", rbegin, rend );
00229   X = HepVector( m_npar, 0 );
00230   X[0] = fsingleq->GetParameter(0);
00231   X[1] = fsingleq->GetParameter(1);
00232   X[2] = fsingleq->GetParameter(2);
00233   X[3] = 0.;
00234   X[4] = 0.;
00235   X[5] = 0.;
00236 
00237   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00238   (*iter) = X;
00239 
00240   return;
00241 }

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

Definition at line 150 of file calib_endcap_atten.cxx.

References ganga-rec::j, m_fitresult, TofCalibFit::m_histograms, TofCalibFit::nBinPerCounter, and TofCalibFit::nKind.

Referenced by calculate().

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

void calib_endcap_atten::fitHistogramQ0 ( unsigned int  icounter  )  [private]

Definition at line 271 of file calib_endcap_atten.cxx.

References m_fitresult, TofCalibFit::m_histograms, TofCalibFit::nBinPerCounter, and TofCalibFit::nKind.

Referenced by calculate().

00271                                                                {
00272   TF1* ld = new TF1("ld", "landau");
00273   ld->SetLineColor(2);
00274   ld->SetLineWidth(1);
00275 
00276   std::vector<TH1F*>::iterator     iter1 = m_histograms.begin() + icounter*nKind*nBinPerCounter + nBinPerCounter - 1;
00277   std::vector<HepVector>::iterator iter2 = m_fitresult.begin() + icounter*nKind*nBinPerCounter + nBinPerCounter - 1;
00278   (*iter1)->Fit( ld, "Q");
00279   (*iter2)[0] = ld->GetParameter(1);
00280   (*iter2)[1] = ld->GetParError(1);
00281   (*iter2)[2] = ld->GetParameter(2);
00282   (*iter2)[3] = ld->GetParError(2);
00283 
00284   return;
00285 }

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

Definition at line 27 of file TofCalibFit.h.

References TofCalibFit::m_name.

Referenced by TofCalibManager::addCalib(), calib_etf_bunch::calculate(), calib_endcap_sigma::calculate(), calculate(), calib_barrel_sigma::calculate(), calib_barrel_q0::calculate(), calib_barrel_common::calculate(), and TofCalibFit::fillTxt().

00027 { return m_name; }

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

Definition at line 35 of file TofCalibFit.h.

References TofCalibFit::m_tcorrelation.

00035 { m_tcorrelation = tc; }

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

Definition at line 34 of file TofCalibFit.h.

References TofCalibFit::X.

00034 { return X;            }

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

Definition at line 244 of file calib_endcap_atten.cxx.

References abs, endcapQFunc(), exp(), genRecEmupikp::i, iter(), TofCalibFit::m_result, q, Record::qleft(), Record::setQ0(), Record::theta(), and Record::zrhit().

Referenced by calculate().

00244                                                                       {
00245   double rhit     = r->zrhit();
00246   double q        = r->qleft();
00247   double costheta = abs(r->theta());
00248 
00249   double par[3];
00250   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00251   for( unsigned int i=0; i<3; i++ ) {
00252     par[i] = (*iter)[i];
00253   }
00254 
00255   par[0] = 0.;
00256   double q0 = q*costheta/exp(endcapQFunc(&rhit,par));
00257   r->setQ0( q0 );
00258 
00259   return;
00260 }


Member Data Documentation

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

Definition at line 58 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_endcap_atten(), calib_etf_bunch::calib_etf_bunch(), calib_barrel_q0::fillGraph(), and TofCalibFit::fillRoot().

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

Definition at line 57 of file TofCalibFit.h.

Referenced by calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), and TofCalibFit::fillRoot().

std::vector<double> calib_endcap_atten::itofid [private]

Definition at line 32 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), and ~calib_endcap_atten().

std::vector<double> calib_endcap_atten::itofiderr [private]

Definition at line 33 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), and ~calib_endcap_atten().

double calib_endcap_atten::itofidstep [private]

Definition at line 34 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten().

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

Definition at line 36 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), fillGraph(), fillGraphQ0(), fitHistogram(), fitHistogramQ0(), and ~calib_endcap_atten().

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

Definition at line 54 of file TofCalibFit.h.

Referenced by calib_etf_bunch::fillGraph(), calib_endcap_sigma::fillGraph(), fillGraph(), calib_barrel_sigma::fillGraph(), calib_barrel_q0::fillGraph(), calib_barrel_common::fillGraph(), fillGraphQ0(), calib_barrel_sigma::fillGraphT0(), TofCalibFit::fillRoot(), calib_etf_bunch::fitGraph(), calib_endcap_sigma::fitGraph(), fitGraph(), calib_barrel_sigma::fitGraph(), calib_barrel_common::fitGraph(), calib_barrel_sigma::fitGraphT0(), and TofCalibFit::~TofCalibFit().

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

Definition at line 53 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), calib_etf_bunch::fillRecord(), calib_endcap_sigma::fillRecord(), fillRecord(), calib_barrel_sigma::fillRecord(), calib_barrel_q0::fillRecord(), calib_barrel_common::fillRecord(), fillRecordQ0(), calib_barrel_sigma::fillRecordT0(), TofCalibFit::fillRoot(), calib_etf_bunch::fitHistogram(), calib_endcap_sigma::fitHistogram(), fitHistogram(), calib_barrel_sigma::fitHistogram(), calib_barrel_q0::fitHistogram(), calib_barrel_common::fitHistogram(), fitHistogramQ0(), calib_barrel_sigma::fitHistogramT0(), and TofCalibFit::~TofCalibFit().

string TofCalibFit::m_name [protected, inherited]

Definition at line 50 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), TofCalibFit::fillRoot(), TofCalibFit::name(), and TofCalibFit::TofCalibFit().

int TofCalibFit::m_npar [protected, inherited]

Definition at line 38 of file TofCalibFit.h.

Referenced by calib_endcap_sigma::fitGraph(), fitGraph(), calib_barrel_sigma::fitGraph(), and TofCalibFit::TofCalibFit().

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

Definition at line 55 of file TofCalibFit.h.

Referenced by calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), fillGraphQ0(), TofCalibFit::fillTxt(), calib_etf_bunch::fitGraph(), calib_endcap_sigma::fitGraph(), fitGraph(), calib_barrel_sigma::fitGraph(), calib_barrel_q0::fitGraph(), calib_barrel_common::fitGraph(), calib_barrel_sigma::fitGraphT0(), updateData(), calib_barrel_sigma::updateData(), and TofCalibFit::~TofCalibFit().

HepVector TofCalibFit::m_tcorrelation [protected, inherited]

Definition at line 60 of file TofCalibFit.h.

Referenced by TofCalibFit::setTCorrelation(), TofCalibFit::TofCalibFit(), and calib_barrel_sigma::updateData().

unsigned int TofCalibFit::nBinPerCounter [protected, inherited]

Definition at line 41 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), calib_etf_bunch::fillGraph(), calib_endcap_sigma::fillGraph(), fillGraph(), calib_barrel_sigma::fillGraph(), calib_barrel_common::fillGraph(), fillGraphQ0(), calib_barrel_sigma::fillGraphT0(), calib_etf_bunch::fillRecord(), calib_endcap_sigma::fillRecord(), fillRecord(), calib_barrel_sigma::fillRecord(), calib_barrel_common::fillRecord(), fillRecordQ0(), calib_barrel_sigma::fillRecordT0(), calib_endcap_sigma::fitHistogram(), fitHistogram(), calib_barrel_sigma::fitHistogram(), fitHistogramQ0(), calib_barrel_sigma::fitHistogramT0(), and TofCalibFit::TofCalibFit().

unsigned int TofCalibFit::nCanvas [protected, inherited]

Definition at line 47 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), TofCalibFit::fillRoot(), and TofCalibFit::TofCalibFit().

unsigned int TofCalibFit::nCanvasPerCounter [protected, inherited]

Definition at line 44 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), TofCalibFit::fillRoot(), and TofCalibFit::TofCalibFit().

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

Definition at line 48 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_endcap_atten(), calib_etf_bunch::calib_etf_bunch(), and TofCalibFit::fillRoot().

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

Definition at line 45 of file TofCalibFit.h.

Referenced by calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), TofCalibFit::fillRoot(), calib_barrel_sigma::fitGraph(), and calib_barrel_sigma::fitGraphT0().

unsigned int TofCalibFit::nHistogram [protected, inherited]

Definition at line 46 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), TofCalibFit::fillRoot(), and TofCalibFit::TofCalibFit().

unsigned int TofCalibFit::nHistPerCounter [protected, inherited]

Definition at line 43 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), TofCalibFit::fillRoot(), and TofCalibFit::TofCalibFit().

unsigned int TofCalibFit::nKind [protected, inherited]

Definition at line 40 of file TofCalibFit.h.

Referenced by calib_barrel_common::calib_barrel_common(), calib_barrel_q0::calib_barrel_q0(), calib_barrel_sigma::calib_barrel_sigma(), calib_endcap_atten(), calib_endcap_sigma::calib_endcap_sigma(), calib_etf_bunch::calib_etf_bunch(), calib_etf_bunch::fillGraph(), calib_endcap_sigma::fillGraph(), fillGraph(), calib_barrel_sigma::fillGraph(), calib_barrel_common::fillGraph(), calib_barrel_sigma::fillGraphT0(), calib_endcap_sigma::fillRecord(), fillRecord(), calib_barrel_sigma::fillRecord(), calib_barrel_common::fillRecord(), fillRecordQ0(), calib_barrel_sigma::fillRecordT0(), calib_endcap_sigma::fitHistogram(), fitHistogram(), calib_barrel_sigma::fitHistogram(), fitHistogramQ0(), calib_barrel_sigma::fitHistogramT0(), and TofCalibFit::TofCalibFit().

std::vector<double> calib_endcap_atten::rpos [private]

Definition at line 29 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), and ~calib_endcap_atten().

std::vector<double> calib_endcap_atten::rposerr [private]

Definition at line 30 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), and ~calib_endcap_atten().

double calib_endcap_atten::rstep [private]

Definition at line 31 of file calib_endcap_atten.h.

Referenced by calib_endcap_atten(), and fillRecord().

HepVector TofCalibFit::X [protected, inherited]

Definition at line 51 of file TofCalibFit.h.

Referenced by calib_etf_bunch::fitGraph(), calib_endcap_sigma::fitGraph(), fitGraph(), calib_barrel_sigma::fitGraph(), calib_barrel_common::fitGraph(), calib_barrel_common::fitHistogram(), TofCalibFit::tcorrelation(), and TofCalibFit::TofCalibFit().


Generated on Tue Nov 29 23:17:59 2016 for BOSS_7.0.2 by  doxygen 1.4.7