#include "TObjArray.h"
#include "TROOT.h"
#include <cstring>
#include <string>
#include <vector>
#include "MdcCalibConst.h"

Functions
double	xtFun (double t, double xtpar[])
void	fcnXT (Int_t &npar, Double_t gin, Double_t &f, Double_t par, Int_t iflag)
void	fcnXtEdge (Int_t &npar, Double_t gin, Double_t &f, Double_t par, Int_t iflag)
Double_t	xtFitFun (Double_t *x, Double_t par[])
Double_t	xtFitEdge (Double_t *x, Double_t par[])
void	writeConst (MdcCalibConst calconst, TObjArray newXtList, TObjArray *r2tList)
std::vector< std::string >	getHistList ()
std::vector< std::string >	getHistList (std::string path)

Variables
const int	NLAYER = 43
const int	NWIRE = 6796
const int	NLR = 3
const int	NXTBIN = 50
const int	NXTPAR = 8
const int	NENTRXT = 18
const int	NENTRSD = 6
const int	NSDBIN = 24
const int	gfixXtC0 = 1
const double	gTbinw = 10.0
std::vector< double >	XMEAS
std::vector< double >	TBINCEN
std::vector< double >	ERR
double	Tmax
double	Dmax
std::vector< double >	XMEASED
std::vector< double >	TBINCENED
std::vector< double >	ERRED
int	gNEntr [43]
double	gTimeShift
double	gTesMin
double	gTesMax
int	gFgIniCalConst
bool	gPreT0SetTm
double	gInitT0
double	gT0Shift
double	gTminFitChindf
double	gTmaxFitChindf
int	gResiType
int	gCalSigma
int	gFixXtC0
int	gFgCalib [NLAYER]
double	gTminFitRange [NLAYER][2]
double	gTmaxFitRange [NLAYER][2]
double	gInitTm [NLAYER]
double	gQmin [NLAYER]
double	gQmax [NLAYER]

Function Documentation

◆ fcnXT()

void fcnXT	(	Int_t &	npar,
		Double_t *	gin,
		Double_t &	f,
		Double_t *	par,
		Int_t	iflag )

Definition at line 65 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                                                                  {
  unsigned int i;
  int          ord;
  Double_t     deta;
  Double_t     chisq = 0.0;
  Double_t     dfit;
 
  for ( i = 0; i < TBINCEN.size(); i++ )
  {
    dfit = 0;
    for ( ord = 0; ord <= 5; ord++ ) { dfit += par[ord] * pow( TBINCEN[i], ord ); }
    deta = ( dfit - XMEAS[i] ) / ERR[i];
    chisq += deta * deta;
  }
 
  f = chisq;
}

Referenced by XtCalib::calib().

◆ fcnXtEdge()

void fcnXtEdge	(	Int_t &	npar,
		Double_t *	gin,
		Double_t &	f,
		Double_t *	par,
		Int_t	iflag )

Definition at line 83 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                                                                      {
  unsigned int i;
  Double_t     deta;
  Double_t     chisq = 0.0;
  Double_t     dfit;
 
  for ( i = 0; i < TBINCENED.size(); i++ )
  {
    dfit = par[0] * ( TBINCENED[i] - Tmax ) + Dmax;
    deta = ( dfit - XMEASED[i] ) / ERRED[i];
    chisq += deta * deta;
  }
 
  f = chisq;
}

Referenced by XtCalib::calib().

◆ getHistList() [1/2]

std::vector< std::string > getHistList ( )

Definition at line 14 of file MdcAlignAlg/share/distAlign/src/fun.cpp.

                             {
  vector<string> fnames;
 
  string command( "JobOutputDir=`/bin/ls -dt1 joboutput-* 2>/dev/null | head -1`\n"
                  "if [ -d \"${JobOutputDir}\" ]; then\n"
                  "  find ${JobOutputDir} -name hist.root\n"
                  "fi\n" );
 
  stringstream fnstream;
 
  char* fnbuf   = new char[1024];
  FILE* fstream = popen( command.c_str(), "r" );
 
  while ( fgets( fnbuf, 1024, fstream ) != NULL ) { fnstream << fnbuf; }
 
  string fname;
  while ( !( fnstream >> fname ).eof() ) { fnames.push_back( fname ); }
 
  pclose( fstream );
  delete[] fnbuf;
 
  if ( fnames.empty() )
  {
    cout << "WARNING: Failed to retrieve hist files in the current directory!" << endl;
    //       exit(1);
  }
  return fnames;
}

Referenced by main().

◆ getHistList() [2/2]

std::vector< std::string > getHistList ( std::string path )

◆ writeConst()

void writeConst	(	MdcCalibConst *	calconst,
		TObjArray *	newXtList,
		TObjArray *	r2tList )

Definition at line 110 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                                                                     {
  TFile fout( "MdcCalibConst_new.root", "recreate" );
 
  int    key;
  double xtpar;
  TTree* xttree = new TTree( "XtTree", "XtTree" );
  xttree->Branch( "xtkey", &key, "key/I" );
  xttree->Branch( "xtpar", &xtpar, "xtpar/D" );
  for ( int lay = 0; lay < 43; lay++ )
  {
    for ( int entr = 0; entr < 18; entr++ )
    {
      for ( int lr = 0; lr < 3; lr++ )
      {
        for ( int ord = 0; ord < 8; ord++ )
        {
          key   = calconst->getXtKey( lay, entr, lr, ord );
          xtpar = calconst->getXtpar( lay, entr, lr, ord );
          xttree->Fill();
        }
      }
    }
  }
 
  double t0;
  double delt0;
  TTree* t0tree = new TTree( "T0Tree", "T0Tree" );
  t0tree->Branch( "t0", &t0, "t0/D" );
  t0tree->Branch( "delt0", &delt0, "delt0/D" );
  for ( int wid = 0; wid < 6796; wid++ )
  {
    t0    = calconst->getT0( wid );
    delt0 = calconst->getDelT0( wid );
    t0tree->Fill();
  }
 
  double qtval[2];
  TTree* qttree = new TTree( "QtTree", "QtTree" );
  qttree->Branch( "qtpar0", &( qtval[0] ), "qtpar0/D" );
  qttree->Branch( "qtpar1", &( qtval[1] ), "qtpar1/D" );
  for ( int lay = 0; lay < 43; lay++ )
  {
    qtval[0] = calconst->getQtpar0( lay );
    qtval[1] = calconst->getQtpar1( lay );
    qttree->Fill();
  }
 
  double sdpar;
  TTree* sdtree = new TTree( "SdTree", "SdTree" );
  sdtree->Branch( "sdkey", &key, "key/I" );
  sdtree->Branch( "sdpar", &sdpar, "sdpar/D" );
  for ( int lay = 0; lay < 43; lay++ )
  {
    for ( int entr = 0; entr < 6; entr++ )
    {
      for ( int lr = 0; lr < 2; lr++ )
      {
        for ( int bin = 0; bin < 24; bin++ )
        {
          key   = calconst->getSdKey( lay, entr, lr, bin );
          sdpar = calconst->getSdpar( lay, entr, lr, bin );
          sdtree->Fill();
        }
      }
    }
  }
 
  fout.cd();
  xttree->Write();
  t0tree->Write();
  qttree->Write();
  sdtree->Write();
  if ( ( newXtList->GetEntries() ) > 0 ) newXtList->Write();
  if ( ( r2tList->GetEntries() ) > 0 ) r2tList->Write();
  fout.Close();
}

Referenced by main().

◆ xtFitEdge()

Double_t xtFitEdge	(	Double_t *	x,
		Double_t	par[] )

Definition at line 105 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                                  {
  double val = Dmax + ( x[0] - Tmax ) * par[0];
  return val;
}

Referenced by GrXtCalib::calib().

◆ xtFitFun()

Double_t xtFitFun	(	Double_t *	x,
		Double_t	par[] )

Definition at line 99 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                                 {
  Double_t val = 0.0;
  for ( Int_t ord = 0; ord < 6; ord++ ) { val += par[ord] * pow( x[0], ord ); }
  return val;
}

Referenced by GrXtCalib::calib().

◆ xtFun()

double xtFun	(	double	t,
		double	xtpar[] )

Definition at line 47 of file MdcCalibAlg/share/distcalib/src/fun.cpp.

                                         {
  int    ord;
  double dist = 0.0;
  double tm   = xtpar[6];
 
  if ( t < tm )
  {
    for ( ord = 0; ord <= 5; ord++ ) { dist += xtpar[ord] * pow( t, ord ); }
  }
  else
  {
    for ( ord = 0; ord <= 5; ord++ ) { dist += xtpar[ord] * pow( tm, ord ); }
    dist += xtpar[7] * ( t - tm );
  }
 
  return dist;
}