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

calib_endcap_sigma Class Reference

#include <calib_endcap_sigma.h>

Inheritance diagram for calib_endcap_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_endcap_sigma (const unsigned int nrbin)
 calib_endcap_sigma (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_sigma ()
 ~calib_endcap_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 fillRecord (const Record *r, unsigned int icounter)
void fillRecord (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)

Private Attributes

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_sigma::calib_endcap_sigma (  const unsigned int  nrbin  ) 
  

00004                                                                 :TofCalibFit( false, nEndcapSigma ) {
00005 
00006   nKind          = 1;    // 0:tleft
00007   nBinPerCounter = nrbin;
00008 
00009   nHistPerCounter   = nKind*nBinPerCounter;
00010   nCanvasPerCounter = 2;
00011   CanvasPerCounterName.push_back( static_cast<string>("Offset") );  
00012   CanvasPerCounterName.push_back( static_cast<string>("Sigma") );  
00013 
00014   nGraphPerCanvasPerCounter.push_back(1);
00015   nGraphPerCanvasPerCounter.push_back(1);
00016 
00017   nHistogram      = 0;
00018   nCanvas         = 0;
00019 
00020   int numGraphs = 0;
00021   std::vector<unsigned int>::iterator iter = nGraphPerCanvasPerCounter.begin();
00022   for( ; iter!=nGraphPerCanvasPerCounter.end(); iter++ ) {
00023     numGraphs = numGraphs + (*iter);
00024   }
00025   if( numGraphs != nGraphEcSigma ) {
00026     cout << "tofcalgsec::calib_endcap_sigma: the number of Graphs is NOT reasonable!!!" << endl;
00027     exit(0);
00028   }
00029 
00030   m_name = string("calib_endcap_sigma");
00031 
00032   const int tbin   = 150;
00033   const double tbegin = -1.5;
00034   const double tend   =  1.5;
00035 
00036   // histograms per counter
00037   char hname[256];
00038   for( unsigned int i=0; i<NEndcap; i++ ) {
00039     m_result.push_back( HepVector(nEndcapSigma,0) );
00040     for( unsigned int j=0; j<nKind; j++ ) {
00041       for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00042         sprintf( hname, "tleft-tofid%i-r%i",  i, k);
00043         m_histograms.push_back( new TH1F( hname, hname, tbin, tbegin, tend ) );
00044 
00045         m_fitresult.push_back( HepVector(nParEcSigma,0) );
00046       }
00047     }
00048   }
00049 
00050   rpos.resize( nBinPerCounter );
00051   rposerr.resize( nBinPerCounter );
00052   rstep = ( rend - rbegin )/nBinPerCounter;
00053   for( unsigned int i=0; i<nBinPerCounter; i++ ) {
00054     rpos[i] = rbegin + ( i+0.5 )*rstep;
00055     rposerr[i] = 0.5*rstep;
00056   }
00057 
00058 }

calib_endcap_sigma::~calib_endcap_sigma (   ) 
  

00061                                         {
00062   m_fitresult.clear();
00063   rpos.clear();
00064   rposerr.clear();
00065 }

calib_endcap_sigma::calib_endcap_sigma (  const unsigned int  nrbin  ) 
 

calib_endcap_sigma::~calib_endcap_sigma (   ) 
 

Member Function Documentation

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

Implements TofCalibFit.

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

Implements TofCalibFit.

00068                                                                             {
00069 
00070   std::cout << setiosflags(ios::left) << setw(10) << icounter << setw(8) << data->size() << setw(30) << name() << std::endl;
00071 
00072   if( data->size() > 0 ) {
00073     std::vector<Record*>::iterator iter = data->begin();
00074     for( ; iter!=data->end(); iter++ ) {
00075       fillRecord( (*iter), icounter );
00076     }
00077   }
00078   fitHistogram( icounter );
00079   fillGraph( icounter );
00080   fitGraph( icounter );
00081 
00082   return;
00083 }

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

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

00124                                                           {
00125 
00126   char gname1[256], gname2[256];
00127 
00128   // fill graphs per counter
00129   // 4 canvas per counter,
00130   //   1. offset of tleft vs z 
00131   //   2. sigma  of tleft vs z
00132   std::vector<double> toffset, toffseterr;
00133   std::vector<double> tsigma, tsigmaerr;
00134   toffset.resize( nBinPerCounter );
00135   toffseterr.resize( nBinPerCounter );
00136   tsigma.resize( nBinPerCounter );
00137   tsigmaerr.resize( nBinPerCounter );
00138 
00139   std::vector<HepVector>::iterator iter = m_fitresult.begin() + icounter*nKind*nBinPerCounter;
00140   for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00141     toffset[k]    = (*(iter+k))[0];
00142     toffseterr[k] = (*(iter+k))[1];
00143     tsigma[k]     = (*(iter+k))[2];
00144     tsigmaerr[k]  = (*(iter+k))[3];
00145   }
00146 
00147   sprintf( gname1, "offset-tofid-%i", icounter );
00148   m_graphs.push_back( new TGraphErrors( nBinPerCounter, &rpos[0], &toffset[0], &rposerr[0], &toffseterr[0]) );
00149   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.end() - 1;
00150   (*itgraph)->SetTitle(gname1);
00151   (*itgraph)->SetMarkerSize(1.5);
00152   (*itgraph)->SetMarkerStyle(20);
00153   (*itgraph)->SetMarkerColor(2);
00154 
00155   sprintf( gname2, "sigma-tofid-%i", icounter );
00156   m_graphs.push_back( new TGraphErrors( nBinPerCounter, &rpos[0], &tsigma[0], &rposerr[0], &tsigmaerr[0]) );
00157   itgraph = m_graphs.end() - 1;
00158   (*itgraph)->SetTitle(gname2);
00159   (*itgraph)->SetMarkerSize(1.5);
00160   (*itgraph)->SetMarkerStyle(21);
00161   (*itgraph)->SetMarkerColor(4);
00162 
00163   return;
00164 }

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

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

00086                                                                             {
00087 
00088   double rhit = r->zrhit();
00089   if( rhit<rbegin || rhit>rend ) return;
00090   int rbin = static_cast<int>((rhit-rbegin)/rstep);
00091   if( rbin<0 ) { rbin = 0; }
00092   else if( rbin>static_cast<int>(nBinPerCounter-1) ) {
00093     cout << "tofcalgsec::calib_endcap_sigma:fillRecord: rhit is out of range, rhit=" << rhit << " rbin=" << rbin << endl;
00094     return;
00095   }
00096 
00097   std::vector<TH1F*>::iterator iter = m_histograms.begin() + icounter*nKind*nBinPerCounter + rbin;
00098   (*iter)->Fill( r->tleft() );
00099 
00100   return;
00101 }

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

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

00167                                                          {
00168 
00169   TF1* p2 = new TF1("p2", "pol2", rbegin, rend );
00170 
00171   std::vector<unsigned int>::iterator itnumber = nGraphPerCanvasPerCounter.begin();
00172   std::vector<TGraphErrors*>::iterator itgraph = m_graphs.begin() + icounter*nGraphEcSigma + 1;
00173 
00174   (*itgraph)->Fit( "p2", "Q" );
00175   X = HepVector( m_npar, 0 );
00176   X[0] = p2->GetParameter(0);
00177   X[1] = p2->GetParameter(1);
00178   X[2] = p2->GetParameter(2);
00179 
00180   std::vector<HepVector>::iterator iter = m_result.begin() + icounter;
00181   (*iter) = X;
00182 
00183   return;
00184 }

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

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

00104                                                              {
00105   TF1* g = new TF1("g", "gaus");
00106   g->SetLineColor(2);
00107   g->SetLineWidth(1);
00108 
00109   std::vector<TH1F*>::iterator     iter1 = m_histograms.begin() + icounter*nKind*nBinPerCounter;
00110   std::vector<HepVector>::iterator iter2 = m_fitresult.begin() + icounter*nKind*nBinPerCounter;
00111   for( unsigned int j=0; j<nBinPerCounter; j++, iter1++, iter2++ ) {
00112     (*iter1)->Fit( g, "Q");
00113     (*iter2)[0] = g->GetParameter(1);
00114     (*iter2)[1] = g->GetParError(1);
00115     (*iter2)[2] = g->GetParameter(2);
00116     (*iter2)[3] = g->GetParError(2);
00117   }
00118 
00119   return;
00120 
00121 }

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;            }

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_endcap_sigma::m_fitresult [private]
 

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

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

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

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

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

double calib_endcap_sigma::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:43 2011 for BOSS6.5.5 by  doxygen 1.3.9.1