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

calib_barrel_common Class Reference

#include <calib_barrel_common.h>

Inheritance diagram for calib_barrel_common:

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_common (const unsigned int nzbin)
 calib_barrel_common (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_common ()
 ~calib_barrel_common ()

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 ()
void fillGraph ()
void fillRecord (const Record *r)
void fillRecord (const Record *r)
void fitGraph ()
void fitGraph ()
void fitHistogram ()
void fitHistogram ()

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_common::calib_barrel_common (  const unsigned int  nzbin  ) 
  

00004                                                                   :TofCalibFit( true, nBarrelCommon ) {
00005 
00006   nKind          = 4;
00007   nBinPerCounter = nzbin;
00008 
00009   nHistPerCounter   = 0;
00010   nCanvasPerCounter = 0;
00011   nHistogram      = nKind*nBinPerCounter+1;
00012   nCanvas         = 4;
00013   CanvasName.push_back( static_cast<string>("Offset") );
00014   CanvasName.push_back( static_cast<string>("Offset-PlusMinus") );  
00015   CanvasName.push_back( static_cast<string>("Sigma") );  
00016   CanvasName.push_back( static_cast<string>("Sigma-TCorrelation") );  
00017   nGraphPerCanvas.push_back(2);
00018   nGraphPerCanvas.push_back(2);
00019   nGraphPerCanvas.push_back(2);
00020   nGraphPerCanvas.push_back(3);
00021 
00022   int numGraphs = 0;
00023   std::vector<unsigned int>::iterator iter = nGraphPerCanvas.begin();
00024   for( ; iter!=nGraphPerCanvas.end(); iter++ ) {
00025     numGraphs = numGraphs + (*iter);
00026   }
00027   if( numGraphs != nGraphTotalCommon ) {
00028     cout << "tofcalgsec::calib_barrel_common: the number of Graphs is NOT reasonable!!!" << endl;
00029     exit(0);
00030   }
00031 
00032   m_name = string("calib_barrel_common");
00033 
00034   const int tbin   = 150;
00035   const double tbegin = -1.5;
00036   const double tend   =  1.5;
00037 
00038   char hname[256];
00039   // histograms
00040   for( unsigned int j=0; j<nKind; j++ ) {
00041     for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00042       if( j==0 )      { sprintf( hname, "tleft-z%i",  k); }
00043       else if( j==1 ) { sprintf( hname, "tright-z%i", k); }
00044       else if( j==2 ) { sprintf( hname, "tplus-z%i",  k); }
00045       else if( j==3 ) { sprintf( hname, "tminus-z%i", k); }
00046       m_fitresult.push_back( HepVector( nParCommon,0 ) );
00047       m_histograms.push_back( new TH1F( hname, hname, tbin, tbegin, tend ) );
00048     }
00049   }
00050   sprintf( hname, "deltaT" );
00051   m_fitresult.push_back( HepVector( nParCommon,0 ) );
00052   m_histograms.push_back( new TH1F( hname, hname, tbin, tbegin, tend ) );
00053 
00054   zpos.resize( nBinPerCounter );
00055   zposerr.resize( nBinPerCounter );
00056   zstep = ( zend - zbegin )/nBinPerCounter;
00057   for( unsigned int i=0; i<nBinPerCounter; i++ ) {
00058     zpos[i] = zbegin + ( i+0.5 )*zstep;
00059     zposerr[i] = 0.5*zstep;
00060   }
00061 
00062 }

calib_barrel_common::~calib_barrel_common (   ) 
  

00065                                           {
00066   m_fitresult.clear();
00067   zpos.clear();
00068   zposerr.clear();
00069 }

calib_barrel_common::calib_barrel_common (  const unsigned int  nzbin  ) 
 

calib_barrel_common::~calib_barrel_common (   ) 
 

Member Function Documentation

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

Implements TofCalibFit.

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

Implements TofCalibFit.

00072                                                                              {
00073 
00074   std::cout << setiosflags(ios::left) << setw(10) << icounter << setw(8) << data->size() << setw(30) << name() << std::endl;
00075 
00076   if( data->size() > 0 ) {
00077     std::vector<Record*>::iterator iter = data->begin();
00078     for( ; iter!=data->end(); iter++ ) {
00079       fillRecord( (*iter) );
00080     }
00081   }
00082 
00083   if( icounter==(NBarrel-1) ) {
00084     fitHistogram();
00085     fillGraph();
00086     fitGraph();
00087   }
00088 
00089   return;
00090 }

void calib_barrel_common::fillGraph (   )  [private]
 

void calib_barrel_common::fillGraph (   )  [private]
  

00139                                     {
00140 
00141   char gname1[256], gname2[256];
00142   TGraphErrors *gra[nGraphTotalCommon];
00143 
00144   // 4 canvas all counter,
00145   //   1. offset of tleft and tright vs z --- gra[0] and gra[1]
00146   //   2. common of tleft and tright vs z  --- gra[2] and gra[3]
00147   //   3. offset of tplus and tminus vs z --- gra[4] and gra[5]
00148   //   4. common of tplus, tminus and T_Correlation vs z
00149   //                                      --- gra[6], gra[7] and gra[8]
00150 
00151   std::vector<double> toffset, toffseterr;
00152   std::vector<double> tsigma, tsigmaerr;
00153   toffset.resize( nBinPerCounter );
00154   toffseterr.resize( nBinPerCounter );
00155   tsigma.resize( nBinPerCounter );
00156   tsigmaerr.resize( nBinPerCounter );
00157 
00158   unsigned int number = 0;
00159   std::vector<HepVector>::iterator iter = m_fitresult.begin();
00160   for( unsigned int j=0; j<nKind; j++ ) {
00161     for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00162       number = j*nBinPerCounter + k;
00163       toffset[k]    = (*(iter+number))[0];
00164       toffseterr[k] = (*(iter+number))[1];
00165       tsigma[k]     = (*(iter+number))[2];
00166       tsigmaerr[k]  = (*(iter+number))[3];
00167     }
00168 
00169     sprintf( gname1, "Offset" );
00170     gra[j] = new TGraphErrors( nBinPerCounter, &zpos[0], &toffset[0], &zposerr[0], &toffseterr[0]);
00171     gra[j]->SetTitle(gname1);
00172 
00173     sprintf( gname2, "Sigma" );
00174     gra[j+4] = new TGraphErrors( nBinPerCounter, &zpos[0], &tsigma[0], &zposerr[0], &tsigmaerr[0]);
00175     gra[j+4]->SetTitle(gname2);
00176   }
00177 
00178   for( unsigned int k=0; k<nBinPerCounter; k++ ) {
00179     number = (nKind-1)*nBinPerCounter + k;
00180     double sigPlus  = (*(iter+number-nBinPerCounter))[2];
00181     double sigMinus = (*(iter+number))[2];
00182     double sigErrPlus  = (*(iter+number-nBinPerCounter))[3];
00183     double sigErrMinus = (*(iter+number))[3];
00184     if( sigPlus>sigMinus ) {
00185       tsigma[k]    = sqrt( sigPlus*sigPlus - sigMinus*sigMinus );
00186     }
00187     else {
00188       tsigma[k]    = 0.0 - sqrt( sigMinus*sigMinus - sigPlus*sigPlus );
00189     }
00190     tsigmaerr[k] = sqrt( sigErrPlus*sigErrPlus + sigErrMinus*sigErrMinus );
00191   }
00192   gra[nGraphTotalCommon-1] = new TGraphErrors( nBinPerCounter, &zpos[0], &tsigma[0], &zposerr[0], &tsigmaerr[0]);
00193 
00194   for( int j=0; j<nGraphTotalCommon; j++, j++ ) {
00195     gra[j]->SetMarkerSize(1.5);
00196     gra[j]->SetMarkerStyle(20);
00197     gra[j]->SetMarkerColor(2);
00198     if( j==4 ) {
00199       gra[j]->SetMaximum( 0.22 );
00200       gra[j]->SetMinimum( 0.07 );
00201     }
00202     else if( j==6 ) {
00203       gra[j]->SetMaximum(  0.20 );
00204       gra[j]->SetMinimum( -0.02 );
00205     }
00206   }
00207   for( int j=1; j<nGraphTotalCommon; j++, j++ ) {
00208     gra[j]->SetMarkerSize(1.5);
00209     gra[j]->SetMarkerStyle(21);
00210     gra[j]->SetMarkerColor(4);
00211   }
00212   gra[nGraphTotalCommon-1]->SetMarkerStyle(4);
00213   gra[nGraphTotalCommon-1]->SetMarkerColor(6);
00214 
00215   for( int j=0; j<nGraphTotalCommon; j++ ) {
00216     m_graphs.push_back( gra[j] );
00217   }
00218 
00219   return;
00220 }

void calib_barrel_common::fillRecord (  const Record *  r  )  [private]
 

void calib_barrel_common::fillRecord (  const Record *  r  )  [private]
  

00094                                                       {
00095   double zhit = r->zrhit();
00096   if( zhit<zbegin || zhit>zend ) return;
00097   int zbin = static_cast<int>((zhit-zbegin)/zstep);
00098   if( ( zbin<0 ) || ( zbin>static_cast<int>(nBinPerCounter-1) ) ) {
00099     cout << "tofcalgsec::calib_barrel_common: zhit is out of range, zhit=" << zhit << " zbin=" << zbin << endl;
00100     return;
00101   }
00102 
00103   std::vector<TH1F*>::iterator iter = m_histograms.begin();
00104   (*(iter+zbin))->Fill( r->tleft() );
00105   (*(iter+nBinPerCounter+zbin))->Fill( r->tright() );
00106   (*(iter+2*nBinPerCounter+zbin))->Fill( (r->tleft()+r->tright())/2.0 );
00107   (*(iter+3*nBinPerCounter+zbin))->Fill( (r->tleft()-r->tright())/2.0 );
00108   (*(iter+nKind*nBinPerCounter))->Fill( r->tleft() );
00109   (*(iter+nKind*nBinPerCounter))->Fill( r->tright() );
00110 
00111   return;
00112 }

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_common::fitGraph (   )  [private]
 

void calib_barrel_common::fitGraph (   )  [private]
  

00223                                    {
00224   TF1* p0 = new TF1("p0", "pol0");
00225   p0->SetLineColor(1);
00226   p0->SetLineWidth(1);
00227 
00228   std::vector<TGraphErrors*>::iterator iter=m_graphs.end()-1;
00229   (*iter)->Fit( "p0", "Q" );
00230   X[0] = p0->GetParameter(0);
00231   X[1] = p0->GetParError(0);
00232 
00233   m_result.push_back( X );
00234   return;
00235 }

void calib_barrel_common::fitHistogram (   )  [private]
 

void calib_barrel_common::fitHistogram (   )  [private]
  

00115                                        {
00116   TF1* g = new TF1("g", "gaus");
00117   g->SetLineColor(2);
00118   g->SetLineWidth(1);
00119 
00120   std::vector<TH1F*>::iterator     iter1 = m_histograms.begin();
00121   std::vector<HepVector>::iterator iter2 = m_fitresult.begin();
00122   for( ; iter1!=m_histograms.end(); iter1++, iter2++ ) {
00123     (*iter1)->Fit( g, "Q");
00124     (*iter2)[0] = g->GetParameter(1);
00125     (*iter2)[1] = g->GetParError(1);
00126     (*iter2)[2] = g->GetParameter(2);
00127     (*iter2)[3] = g->GetParError(2);
00128   }
00129 
00130   iter2 = m_fitresult.end() - 1;
00131   X[2] = (*iter2)[0];
00132   X[3] = (*iter2)[1];
00133 
00134   return;
00135 
00136 }

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

std::vector<HepVector> calib_barrel_common::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_common::zpos [private]
 

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

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

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

double calib_barrel_common::zstep [private]
 

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