#include <string>
#include <cstring>
#include <vector>
#include "TROOT.h"
#include "TObjArray.h"
#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 66 of file MdcCalibAlg/MdcCalibAlg-01-00-00/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 85 of file MdcCalibAlg/MdcCalibAlg-01-00-00/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/MdcAlignAlg-00-02-00/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 113 of file MdcCalibAlg/MdcCalibAlg-01-00-00/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 108 of file MdcCalibAlg/MdcCalibAlg-01-00-00/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 100 of file MdcCalibAlg/MdcCalibAlg-01-00-00/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/MdcCalibAlg-01-00-00/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;
}