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

calib_endcap_atten Class Reference

#include <calib_endcap_atten.h>

Inheritance diagram for calib_endcap_atten:

TofCalibFit TofCalibFit List of all members.

Public Member Functions

void calculate (RecordSet *&data, unsigned int icounter)
void calculate (RecordSet *&data, unsigned int icounter)
 calib_endcap_atten (const unsigned int nrbin)
 calib_endcap_atten (const unsigned int nrbin)
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_endcap_atten ()
 ~calib_endcap_atten ()

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 fillGraphQ0 ()
void fillGraphQ0 ()
void fillRecord (const Record *r, unsigned int icounter)
void fillRecord (const Record *r, unsigned int icounter)
void fillRecordQ0 (const Record *r, unsigned int icounter)
void fillRecordQ0 (const Record *r, unsigned int icounter)
void fitGraph (unsigned int icounter)
void fitGraph (unsigned int icounter)
void fitHistogram (unsigned int icounter)
void fitHistogram (unsigned int icounter)
void fitHistogramQ0 (unsigned int icounter)
void fitHistogramQ0 (unsigned int icounter)
void updateData (Record *r, unsigned int icounter)
void updateData (Record *r, unsigned int icounter)

Private Attributes

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

Constructor & Destructor Documentation

calib_endcap_atten::calib_endcap_atten (  const unsigned int  nrbin  ) 
  

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 (   ) 
  

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

calib_endcap_atten::calib_endcap_atten (  const unsigned int  nrbin  ) 
 

calib_endcap_atten::~calib_endcap_atten (   ) 
 

Member Function Documentation

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

Implements TofCalibFit.

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

Implements TofCalibFit.

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]
 

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

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 TGraphErrors( nBinPerCounter-1, &rpos[0], &toffset[0], &rposerr[0], &toffseterr[0]) );
00195   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00196   (*itgraph)->SetTitle(gname1);
00197   (*itgraph)->SetMarkerSize(1.5);
00198   (*itgraph)->SetMarkerStyle(20);
00199   (*itgraph)->SetMarkerColor(2);
00200 
00201   sprintf( gname2, "Q sigma-tofid-%i", icounter );
00202   m_graphs.push_back( new TGraphErrors( nBinPerCounter-1, &rpos[0], &tsigma[0], &rposerr[0], &tsigmaerr[0]) );
00203   itgraph = m_graphs.end() - 1;
00204   (*itgraph)->SetTitle(gname2);
00205   (*itgraph)->SetMarkerSize(1.5);
00206   (*itgraph)->SetMarkerStyle(21);
00207   (*itgraph)->SetMarkerColor(4);
00208 
00209   return;
00210 }

void calib_endcap_atten::fillGraphQ0 (   )  [private]
 

void calib_endcap_atten::fillGraphQ0 (   )  [private]
  

00282                                      {
00283   char gname1[256], gname2[256];
00284 
00285   // fill graphs
00286   // 2 canvas per counter,
00287   //   1. Q0 MPV vs z 
00288   //   2. Q0 sigma vs z
00289   std::vector<double> toffset, toffseterr;
00290   std::vector<double> tsigma, tsigmaerr;
00291   toffset.resize( NEndcap );
00292   toffseterr.resize( NEndcap );
00293   tsigma.resize( NEndcap );
00294   tsigmaerr.resize( NEndcap );
00295 
00296   unsigned int number = 0;
00297   std::vector<HepVector>::iterator iter1 = m_fitresult.begin() + nBinPerCounter - 1;
00298   std::vector<HepVector>::iterator iter2 = m_result.begin();
00299   for( unsigned int i=0; i<NEndcap; i++ ) {
00300     number = i*nBinPerCounter;
00301     toffset[i]    = (*(iter1+number))[0];
00302     toffseterr[i] = (*(iter1+number))[1];
00303     tsigma[i]     = (*(iter1+number))[2];
00304     tsigmaerr[i]  = (*(iter1+number))[3];
00305 
00306 
00307     (*(iter2+i))[3] = toffset[i]/toffset[0];
00308     (*(iter2+i))[4] = toffset[i];
00309   }
00310 
00311   sprintf( gname1, "Q0 MPV vs TOF Counter Number" );
00312   m_graphs.push_back( new TGraphErrors( NEndcap, &itofid[0], &toffset[0], &itofiderr[0], &toffseterr[0]) );
00313   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00314   (*itgraph)->SetTitle(gname1);
00315   (*itgraph)->SetMarkerSize(1.5);
00316   (*itgraph)->SetMarkerStyle(20);
00317   (*itgraph)->SetMarkerColor(2);
00318 
00319   sprintf( gname2, "Q0 Sigma vs TOF Counter Number" );
00320   m_graphs.push_back( new TGraphErrors( NEndcap, &itofid[0], &tsigma[0], &itofiderr[0], &tsigmaerr[0]) );
00321   itgraph = m_graphs.end() - 1;
00322   (*itgraph)->SetTitle(gname2);
00323   (*itgraph)->SetMarkerSize(1.5);
00324   (*itgraph)->SetMarkerStyle(21);
00325   (*itgraph)->SetMarkerColor(4);
00326 
00327   return;
00328 }

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

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

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]
 

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

00257                                                                               {
00258   std::vector<TH1F*>::iterator iter = m_histograms.begin() + icounter*nKind*nBinPerCounter + nBinPerCounter - 1;
00259   (*iter)->Fill( r->q0() );
00260  
00261   return;
00262 }

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

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

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

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

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

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]
 

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

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

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_endcap_atten::updateData (  Record *  r,
unsigned int  icounter
)  [private]
 

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

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

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<double> calib_endcap_atten::itofid [private]
 

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

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

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

double calib_endcap_atten::itofidstep [private]
 

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

std::vector<HepVector> calib_endcap_atten::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]
 

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

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

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

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

double calib_endcap_atten::rstep [private]
 

HepVector TofCalibFit::X [protected, inherited]
 

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