DedxCalibRunByRun Class Reference

#include <DedxCalibRunByRun.h>

Inheritance diagram for DedxCalibRunByRun:

Public Member Functions
	DedxCalibRunByRun (const std::string &name, ISvcLocator *pSvcLocator)
	~DedxCalibRunByRun ()
void	initializing ()
void	BookHists ()
void	genNtuple ()
void	FillHists ()
void	AnalyseHists ()
void	WriteHists ()
Public Member Functions inherited from DedxCalib
	DedxCalib (const std::string &name, ISvcLocator *pSvcLocator)
	~DedxCalib ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()

Additional Inherited Members
Protected Member Functions inherited from DedxCalib
double	cal_dedx_bitrunc (float truncate, std::vector< double > phlist)
double	cal_dedx (float truncate, std::vector< double > phlist)
void	getCurvePar ()
void	set_dEdx (int landau, float dEdx, int trkalg, int runflag, int dedxhit_use, float ptrk, float theta, float pl_rp, int vflag[3], double t0)
void	ReadRecFileList ()
Protected Attributes inherited from DedxCalib
IMdcGeomSvc *	geosvc
IDedxCorrecSvc *	exsvc
float	truncate
vector< double >	Curve_Para
vector< double >	Sigma_Para
int	vFlag [3]
double	m_dedx_exp [5]
double	m_ex_sigma [5]
double	m_pid_prob [5]
double	m_chi_ex [5]
vector< string >	m_recFileVector
int	ParticleFlag
int	m_calibflag
int	m_phShapeFlag
std::string	m_eventType
std::string	m_recFileList
std::string	m_rootfile
std::string	m_curvefile

Detailed Description

Definition at line 9 of file DedxCalibRunByRun.h.

Constructor & Destructor Documentation

DedxCalibRunByRun()

DedxCalibRunByRun::DedxCalibRunByRun	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 16 of file DedxCalibRunByRun.cxx.

    : DedxCalib( name, pSvcLocator ) {}

~DedxCalibRunByRun()

DedxCalibRunByRun::~DedxCalibRunByRun ( )

inline

Definition at line 12 of file DedxCalibRunByRun.h.

{};

Member Function Documentation

AnalyseHists()

void DedxCalibRunByRun::AnalyseHists ( )

virtual

Implements DedxCalib.

Definition at line 127 of file DedxCalibRunByRun.cxx.

                                     {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "DedxCalibRunByRun::AnalyseHists()" << endmsg;
 
  m_hist->Fit( "gaus", "Q" );
  for ( int i = 0; i < runNo; i++ )
  {
    for ( int j = 0; j < NumEvtBlocksInRun; j++ )
    { m_rungain[i * NumEvtBlocksInRun + j]->Fit( "gaus", "Q" ); }
  }
}

BookHists()

void DedxCalibRunByRun::BookHists ( )

virtual

Implements DedxCalib.

Definition at line 19 of file DedxCalibRunByRun.cxx.

                                  {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "DedxCalibRunByRun::BookHists()" << endmsg;
 
  ReadRecFileList();
  runNo = m_recFileVector.size();
 
  m_hist = new TH1F( "dEdx_allRun", "dEdx_allRun", NumHistBins, MinHistValue1, MaxHistValue1 );
  m_hist->GetXaxis()->SetTitle( "dE/dx" );
  m_hist->GetYaxis()->SetTitle( "entries" );
  m_rungain = new TH1F*[runNo * NumEvtBlocksInRun];
  stringstream hlabel;
  for ( int i = 0; i < runNo; i++ )
  {
    for ( int j = 0; j < NumEvtBlocksInRun; j++ )
    {
      hlabel.str( "" );
      hlabel << "dEdx_Run_" << i << "_sub_" << j;
      m_rungain[i * NumEvtBlocksInRun + j] =
          new TH1F( hlabel.str().c_str(), hlabel.str().c_str(), NumHistBins, MinHistValue1,
                    MaxHistValue1 );
    }
  }
}

FillHists()

void DedxCalibRunByRun::FillHists ( )

virtual

Implements DedxCalib.

Definition at line 44 of file DedxCalibRunByRun.cxx.

                                  {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "DedxCalibRunByRun::FillHists()" << endmsg;
 
  TFile* f;
  TTree* n103;
  string runlist;
 
  int    ndedxhit  = 0;
  double dEdx[100] = { 0 }, pathlength[100] = { 0 }, wid[100] = { 0 }, layid[100] = { 0 },
         dd_in[100] = { 0 }, eangle[100] = { 0 }, zhit[100] = { 0 };
  double         dedx  = 0;
  float          runNO = 0, evtNO = 0, runFlag = 0, costheta = 0, tes = 0;
  vector<double> phlist;
  for ( int i = 0; i < runNo; i++ )
  {
    runlist = m_recFileVector[i];
    f       = new TFile( runlist.c_str() );
    n103    = (TTree*)f->Get( "n103" );
    n103->SetBranchAddress( "ndedxhit", &ndedxhit );
    n103->SetBranchAddress( "dEdx_hit", dEdx );
    n103->SetBranchAddress( "pathlength_hit", pathlength );
    n103->SetBranchAddress( "wid_hit", wid );
    n103->SetBranchAddress( "layid_hit", layid );
    n103->SetBranchAddress( "dd_in_hit", dd_in );
    n103->SetBranchAddress( "eangle_hit", eangle );
    n103->SetBranchAddress( "zhit_hit", zhit );
    n103->SetBranchAddress( "runNO", &runNO );
    n103->SetBranchAddress( "evtNO", &evtNO );
    n103->SetBranchAddress( "runFlag", &runFlag );
    n103->SetBranchAddress( "costheta", &costheta );
    n103->SetBranchAddress( "t0", &tes );
    int           m( 0 ); // count for events in a block
    int           index( 0 );
    float         evtfrom( 0 );
    struct runevt m_runevt;
    for ( int j = 0; j < n103->GetEntries(); j++ )
    {
      phlist.clear();
      n103->GetEntry( j );
      for ( int k = 0; k < ndedxhit; k++ )
      {
        dEdx[k] = exsvc->StandardHitCorrec( 0, runFlag, 2, runNO, evtNO, pathlength[k], wid[k],
                                            layid[k], dEdx[k], dd_in[k], eangle[k], costheta );
        phlist.push_back( dEdx[k] );
      }
      dedx = cal_dedx_bitrunc( truncate, phlist );
      dedx = exsvc->StandardTrackCorrec( 0, runFlag, 2, runNO, evtNO, dedx, costheta, tes );
      m_rungain[i * NumEvtBlocksInRun + index]->Fill( dedx );
      m_hist->Fill( dedx );
      m++;
      if ( m == NumEvtInBlocks )
      {
        m_runevt.runno        = runNO;
        m_runevt.evtfrom      = evtfrom;
        m_runevt.evtto        = evtNO;
        m_runevt.global_index = i * NumEvtBlocksInRun + index;
        m_runevt.local_index  = index;
        m_evtNOVector.push_back( m_runevt );
        evtfrom = evtNO + 1;
        index++;
        m = 0;
      }
      if ( index == NumEvtBlocksInRun )
      {
        log << MSG::FATAL << "DedxCalibRunByRun: Too many events in a run!!!" << endmsg;
        break;
      }
    }
    if ( index ) m_evtNOVector.pop_back();
    else
    {
      m_runevt.runno        = runNO;
      m_runevt.evtfrom      = 0;
      m_runevt.global_index = i * NumEvtBlocksInRun;
      m_runevt.local_index  = 0;
    }
    m_runevt.evtto = MaxNumEvt;
    m_evtNOVector.push_back( m_runevt );
    cout << "runNO = " << m_runevt.runno << endl;
  }
}

genNtuple()

void DedxCalibRunByRun::genNtuple ( )

inlinevirtual

Implements DedxCalib.

Definition at line 15 of file DedxCalibRunByRun.h.

{}

initializing()

void DedxCalibRunByRun::initializing ( )

inlinevirtual

Implements DedxCalib.

Definition at line 13 of file DedxCalibRunByRun.h.

{}

WriteHists()

void DedxCalibRunByRun::WriteHists ( )

virtual

Implements DedxCalib.

Definition at line 139 of file DedxCalibRunByRun.cxx.

                                   {
  MsgStream log( msgSvc(), name() );
  log << MSG::INFO << "DedxCalibRunByRun::WriteHists()" << endmsg;
 
  TFile* f = new TFile( m_rootfile.c_str(), "recreate" );
 
  Double_t gainpar = 0, resolpar = 0;
  gainpar  = m_hist->GetFunction( "gaus" )->GetParameter( 1 );
  resolpar = m_hist->GetFunction( "gaus" )->GetParameter( 2 );
 
  TTree* gain = new TTree( "gaincalib", "gaincalib" );
  gain->Branch( "gain", &gainpar, "gain[1]/D" );
  gain->Fill();
  TTree* resol = new TTree( "resolcalib", "resolcalib" );
  resol->Branch( "resol", &resolpar, "resol[1]/D" );
  resol->Fill();
 
  Int_t    runno( 0 ), evtfrom( 0 ), evtto( 0 ), index( 0 ), global_index( 0 );
  Double_t runmean = 0, rungain = 0, runresol = 0;
  TTree*   runbyrun = new TTree( "runcalib", "runcalib" );
  runbyrun->Branch( "runno", &runno, "runno/I" );
  runbyrun->Branch( "index", &index, "index/I" );
  runbyrun->Branch( "evtfrom", &evtfrom, "evtfrom/I" );
  runbyrun->Branch( "evtto", &evtto, "evtto/I" );
  runbyrun->Branch( "runmean", &runmean, "runmean/D" );
  runbyrun->Branch( "rungain", &rungain, "rungain/D" );
  runbyrun->Branch( "runresol", &runresol, "runresol/D" );
  vector<struct runevt>::iterator p;
  p = m_evtNOVector.begin();
  while ( p != m_evtNOVector.end() )
  {
    runno        = ( *p ).runno;
    evtfrom      = ( *p ).evtfrom;
    evtto        = ( *p ).evtto;
    index        = ( *p ).local_index;
    global_index = ( *p ).global_index;
    runmean      = m_rungain[global_index]->GetFunction( "gaus" )->GetParameter( 1 );
    runresol     = m_rungain[global_index]->GetFunction( "gaus" )->GetParameter( 2 );
    rungain      = runmean / NormalMean;
    cout << "   runno = " << runno << "   @  evtfrom = " << evtfrom << "  @ evtto " << evtto
         << "  @ index " << index << "  @  runmean = " << runmean
         << "  @  rungain = " << rungain << "  @  runresol =  " << runresol << endl;
    runbyrun->Fill();
    m_rungain[global_index]->Write();
    p++;
  }
 
  m_hist->Write();
  gain->Write();
  resol->Write();
  runbyrun->Write();
 
  delete m_hist;
  for ( int i = 0; i < runNo; i++ )
  {
    for ( int j = 0; j < NumEvtBlocksInRun; j++ ) delete m_rungain[i * NumEvtBlocksInRun + j];
  }
  delete gain;
  delete resol;
  delete runbyrun;
  f->Close();
}

---

The documentation for this class was generated from the following files:

• DedxCalibRunByRun.h
• DedxCalibRunByRun.cxx