dqutils Namespace Reference

Classes
class	CoolMdt
class	CoolRpc
class	CoolTgc
class	HanOutputFile
class	HistogramDataCOOL
class	MonitoringFile
class	StatusFlagCommentCOOL
class	StatusFlagCOOL
class	StatusFlagCOOLBase

Typedefs
typedef std::map< std::string, std::vector< int > >	keycyclemap

Functions
void	populateKeyMapping (TDirectory *, keycyclemap &)
std::string	getInputDirectory (const std::string &outputDirName, TFile *input, bool has_multiple_runs, std::map< TFile *, std::string > *prefixes)
std::string	getOutputDirectory (const std::string &inputDirName, TFile *input, bool has_multiple_runs, std::map< TFile *, std::string > *prefixes)
std::string	getOutputDirectory (TKey *key, TFile *input, bool has_multiple_runs, std::map< TFile *, std::string > *prefixes)
void getImageBuffer	ATLAS_NOT_THREAD_SAFE (TImage **img, TCanvas *myC, char **x, int *y)
void	plotResolution (const TString &coordinate, const TString &versus)
void	plotEfficiency ()
double	error_func (float x, const Double_t *par)
double	scaleFactorFitFcn (double *x, double *par)
std::vector< float >	stableGaussianFit (TH1 *histo)
int	updateHists (const std::string &inFileName, const std::string &inStem, const std::string &outFileName="", const std::string &outStem="")
bool	makeDirectories (const std::string &dirName)
bool	makeDir (const std::string &dirName)
void	Copy (TFile *source, TFile *target, const std::string &inDir, const std::string &outDir, const std::string &inHist="", const std::string &outHist="")
void	CopyHist (TFile *source, TFile *target, const std::string &inDir, const std::string &outDir, const std::string &inHist, const std::string &outHist)

Variables
std::vector< int >	root_color_choices
std::atomic< int >	padding = 0

Typedef Documentation

keycyclemap

typedef std::map<std::string, std::vector<int> > dqutils::keycyclemap

Definition at line 51 of file MonitoringFile.h.

Function Documentation

ATLAS_NOT_THREAD_SAFE()

void getImageBuffer dqutils::ATLAS_NOT_THREAD_SAFE	(	TImage **	img,
		TCanvas *	myC,
		char **	x,
		int *	y
	)

Definition at line 1130 of file HanOutputFile.cxx.

                                                                                          {
    gVirtualPS->Open(myC->GetName(), 114);
    myC->Paint();
    auto pImgDump = dynamic_cast<TImageDump*>(gVirtualPS);
    if (pImgDump) {
      (*img) = pImgDump->GetImage();
      if (*img) {
        (*img)->GetImageBuffer(x, y, TImage::kPng);
      }
    }
  }

Copy()

void dqutils::Copy	(	TFile *	source,
		TFile *	target,
		const std::string &	inDir,
		const std::string &	outDir,
		const std::string &	inHist = "",
		const std::string &	outHist = ""
	)

Definition at line 253 of file MonitoringFile_MoveVertexMonitoring.cxx.

                                                               {
    padding += 3;
 
    if (!inHist.empty()) {
      CopyHist(source, target, inDir, outDir, inHist, outHist);
    } else {
      TDirectory* sourceDir = source->GetDirectory(inDir.c_str());
      TDirectory* targetDir = target->GetDirectory(outDir.c_str());
 
      TIter nextKey(sourceDir->GetListOfKeys());
 
      TKey* key;
      while ((key = (TKey*) nextKey())) {
        std::string keyName = key->GetName();
        std::string className(key->GetClassName());
 
        if (className == "TDirectoryFile") {
          std::string newInDir = inDir;
          newInDir += '/';
          newInDir += keyName;
 
          std::string newOutDir = outDir;
          newOutDir += '/';
          newOutDir += keyName;
 
          if (!targetDir->FindKey(keyName.c_str())) {
            /*
               std::cout << std::setw(padding) << " ";
               std::cout << "creating Dir " << newOutDir << std::endl;
             */
            targetDir->mkdir(keyName.c_str());
          }
          /*
             std::cout << std::setw(padding) << " ";
             std::cout << "moving to " << newInDir << ", a " << className << std::endl;
           */
          Copy(source, target, newInDir, newOutDir);
        } else {
          CopyHist(source, target, inDir, outDir, keyName, keyName);
        }
      }
    }
 
    padding -= 3;
  }

CopyHist()

void dqutils::CopyHist	(	TFile *	source,
		TFile *	target,
		const std::string &	inDir,
		const std::string &	outDir,
		const std::string &	inHist,
		const std::string &	outHist
	)

Definition at line 300 of file MonitoringFile_MoveVertexMonitoring.cxx.

                                                                   {
    TDirectory* sourceDir = source->GetDirectory(inDir.c_str());
    TDirectory* targetDir = target->GetDirectory(outDir.c_str());
 
    targetDir->cd();
    TKey* key = sourceDir->FindKey(inHist.c_str());
    TObject* object = key->ReadObj();
    bool permission = true;
 
    if (targetDir->FindKey(outHist.c_str())) permission = false;
    if (permission) object->Write(outHist.c_str(), TObject::kOverwrite);
  }

error_func()

double dqutils::error_func	(	float	x,
		const Double_t *	par
	)

Definition at line 451 of file MonitoringFile_IDEnhancedPrimaryVertex.cxx.

                                                  {
//calculating the square of the propagated error on the fit values
    return(TMath::Power(par[0], 2) + x * TMath::Power(par[1], 2) + TMath::Power(x * par[2], 2));
  }

getInputDirectory()

std::string dqutils::getInputDirectory	(	const std::string &	outputDirName,
		TFile *	input,
		bool	has_multiple_runs,
		std::map< TFile *, std::string > *	prefixes
	)

getOutputDirectory() [1/2]

std::string dqutils::getOutputDirectory	(	const std::string &	inputDirName,
		TFile *	input,
		bool	has_multiple_runs,
		std::map< TFile *, std::string > *	prefixes
	)

getOutputDirectory() [2/2]

std::string dqutils::getOutputDirectory	(	TKey *	key,
		TFile *	input,
		bool	has_multiple_runs,
		std::map< TFile *, std::string > *	prefixes
	)

makeDir()

bool dqutils::makeDir

(

const std::string &

dirName

)

Definition at line 239 of file MonitoringFile_MoveVertexMonitoring.cxx.

                                         {
    padding += 3;
    std::cout << std::setw(padding) << " ";
 
    if (!gDirectory->FindKey(dirName.c_str())) {
      gDirectory->mkdir(dirName.c_str());
//            std::cout << "makeDir=" << dirName << std::endl;
    } else
//            std::cout << "object " << dirName << " already exists in directory " << gDirectory->GetName() <<
// std::endl;
      padding -= 3;
    return gDirectory->cd(dirName.c_str());
  }

makeDirectories()

bool dqutils::makeDirectories

(

const std::string &

dirName

)

Definition at line 221 of file MonitoringFile_MoveVertexMonitoring.cxx.

                                                 {
    bool success = true;
 
    if (!dirName.empty()) {
      std::string::size_type firstSlash = dirName.find('/');
      if (firstSlash == std::string::npos) {
        success &= makeDir(dirName);
      } else {
        std::string subdir(dirName, 0, firstSlash);
        if (!subdir.empty()) success &= makeDir(subdir);
 
        std::string newSubdir(dirName, firstSlash + 1, dirName.size() - firstSlash);
        success &= makeDirectories(newSubdir);
      }
    }
    return success;
  }

plotEfficiency()

void dqutils::plotEfficiency

(

)

Definition at line 375 of file MonitoringFile_IDEnhancedPrimaryVertex.cxx.

                        {
//  cout << "Creating and writing histos for efficiency" << endl;
 
    // get histos but return if any histo is not there in input
    TH1F* h_Vrt_split_tag_ntrk = (TH1F*) gDirectory->Get("Vrt_split_tag_ntrk");
 
    if (h_Vrt_split_tag_ntrk == 0) return;
 
    TH1F* h_Vrt_split_probe_ntrk = (TH1F*) gDirectory->Get("Vrt_split_probe_ntrk");
    if (h_Vrt_split_probe_ntrk == 0) return;
 
    TH1F* h_Vrt_split_matched_tag_ntrk = (TH1F*) gDirectory->Get("Vrt_split_matched_tag_ntrk");
    if (h_Vrt_split_matched_tag_ntrk == 0) return;
 
    TH1F* h_Vrt_split_matched_probe_ntrk = (TH1F*) gDirectory->Get("Vrt_split_matched_probe_ntrk");
    if (h_Vrt_split_matched_probe_ntrk == 0) return;
 
    TH1F* h_Vrt_split_dist_tag = (TH1F*) gDirectory->Get("Vrt_split_dist_tag");
    if (h_Vrt_split_dist_tag == 0) return;
 
    TH1F* h_Vrt_split_dist_probe = (TH1F*) gDirectory->Get("Vrt_split_dist_probe");
    if (h_Vrt_split_dist_probe == 0) return;
 
    // Use BayesDivide routing of TGraphAsymmErrors
    TGraphAsymmErrors* g_Vrt_rec_eff_m1_split_vs_ntrk = new TGraphAsymmErrors();
 
    g_Vrt_rec_eff_m1_split_vs_ntrk->BayesDivide(h_Vrt_split_probe_ntrk, h_Vrt_split_tag_ntrk);
    g_Vrt_rec_eff_m1_split_vs_ntrk->SetName("g_RecEff_M1");
 
    TGraphAsymmErrors* g_Vrt_sel_eff_m1_split_vs_ntrk = new TGraphAsymmErrors();
    g_Vrt_sel_eff_m1_split_vs_ntrk->BayesDivide(h_Vrt_split_matched_probe_ntrk, h_Vrt_split_matched_tag_ntrk);
    g_Vrt_sel_eff_m1_split_vs_ntrk->SetName("g_SelEff_M1");
 
    // formatting and writing out
    g_Vrt_rec_eff_m1_split_vs_ntrk->GetHistogram()->GetXaxis()->SetTitle("Number of tracks");
    g_Vrt_rec_eff_m1_split_vs_ntrk->GetHistogram()->GetYaxis()->SetTitle("Reconstruction efficiency");
    g_Vrt_rec_eff_m1_split_vs_ntrk->SetMarkerStyle(20);
    g_Vrt_rec_eff_m1_split_vs_ntrk->Write("", TObject::kOverwrite);
    delete g_Vrt_rec_eff_m1_split_vs_ntrk;
 
    g_Vrt_sel_eff_m1_split_vs_ntrk->GetHistogram()->GetXaxis()->SetTitle("Number of tracks");
    g_Vrt_sel_eff_m1_split_vs_ntrk->GetHistogram()->GetYaxis()->SetTitle("Selection Efficiency");
    g_Vrt_sel_eff_m1_split_vs_ntrk->SetMarkerStyle(20);
    g_Vrt_sel_eff_m1_split_vs_ntrk->Write("", TObject::kOverwrite);
    delete g_Vrt_sel_eff_m1_split_vs_ntrk;
 
    return;
  }

plotResolution()

void dqutils::plotResolution	(	const TString &	coordinate = "Z",
		const TString &	versus = "Ntrk"
	)

Definition at line 107 of file MonitoringFile_IDEnhancedPrimaryVertex.cxx.

                                                                                  {
//  cout << "Creating and writing histos for resolution " << coordinate << " versus " << versus << endl;
 
    TH2F* h_Vrt_pullVsSomething_split(0);
    TH2F* h_Vrt_err_vs_Something(0);
//   TH2F* h_Vrt_Tag_err_vs_Something(0);
    TString xAxisLabel("");
 
    if (versus == "Ntrk") {
      h_Vrt_pullVsSomething_split = (TH2F*) gDirectory->Get("Vrt_" + coordinate + "pullVsNtrkAverage_split");
      h_Vrt_err_vs_Something = (TH2F*) gDirectory->Get("Vrt_" + coordinate + "err_vs_ntrk");
//     h_Vrt_Tag_err_vs_Something      = (TH2F*)gDirectory->Get("Vrt_Tag_"+coordinate+"err_vs_ntrk");
      xAxisLabel = "Number of fitted tracks";
    } else if (versus == "SumPt2") {
      h_Vrt_pullVsSomething_split = (TH2F*) gDirectory->Get("Vrt_" + coordinate + "pullVsPt2Average_split");
      h_Vrt_err_vs_Something = (TH2F*) gDirectory->Get("Vrt_" + coordinate + "err_vs_pt2");
//     h_Vrt_Tag_err_vs_Something      = (TH2F*)gDirectory->Get("Vrt_Tag_"+coordinate+"err_vs_pt2");
      xAxisLabel = "#sqrt{#sum p_{T}^{2}} [GeV]";
    } else return;
 
    //if (h_Vrt_pullVsSomething_split == 0) std::cout << "h_Vrt_pullVsSomething_split has zero pointer!" << std::endl;
    //if (h_Vrt_err_vs_Something == 0) std::cout << "h_Vrt_err_vs_Something has zero pointer!" << std::endl;
    if (h_Vrt_pullVsSomething_split == 0 or h_Vrt_err_vs_Something == 0) return;
 
    int n_bins = h_Vrt_pullVsSomething_split->GetNbinsX();
    std::vector<float> rms_z;
    std::vector<float> rms_z_er;
    std::vector<float> sigma_z;
    std::vector<float> sigma_z_er;
    std::vector<float> bins_z_nt;
    std::vector<float> bins_z_nt_er;
 
// root starts counting the bins at 1, i.e. bin 1 holds NTrk = 0. or sqrt(sumpt2) = 0. - 0.25. GeV
//   std::cout << "n bins: " << n_bins << "\tTotal entries: " << h_Vrt_pullVsSomething_split->GetEntries() << std::endl;
//   TH1D * nTrksPerVertex = h_Vrt_pullVsSomething_split->ProjectionX("projectionNTrks_"+coordinate+"_"+versus);
 
//   TH1D * profileZFull = h_Vrt_pullVsSomething_split->ProjectionY("projectionPullsFull_"+coordinate+"_"+versus);
 
    Int_t startBin = 0;
    TH1D* profileZ = 0;
    const Int_t minEntriesForKFactorBin = 1000;
    for (int bin_count = 1; bin_count < n_bins + 1; bin_count++) {
      //Fixed binning
//     TH1D *profileZ = h_Vrt_pullVsSomething_split->ProjectionY("projectionPulls", bin_count, bin_count,"e");
//     Double_t binCenter = h_Vrt_pullVsSomething_split->GetXaxis()->GetBinCenter(bin_count);
//     Double_t binWidth = h_Vrt_pullVsSomething_split->GetXaxis()->GetBinWidth(bin_count)/2.;
 
      //Variable binning
      TH1D* profileZTmp = h_Vrt_pullVsSomething_split->ProjectionY("projectionPulls", bin_count, bin_count, "e");
      //cout << "Bin: " << bin_count << ", Entries: " << profileZTmp->GetEntries() << endl;
      if (profileZ == 0) {
        startBin = bin_count;
        profileZ = (TH1D*) profileZTmp->Clone("projectionPulls_Integrated");
        //cout << "StartBin = " << startBin << endl;
      } else {
        profileZ->Add(profileZTmp);
      }
      delete profileZTmp;
      profileZTmp = 0;
      if ((profileZ->GetEntries() < minEntriesForKFactorBin) && (bin_count < n_bins)) //not enough entries, not last bin
        continue;
 
      Double_t lowEdge = h_Vrt_pullVsSomething_split->GetXaxis()->GetBinLowEdge(startBin);
      Double_t highEdge = h_Vrt_pullVsSomething_split->GetXaxis()->GetBinLowEdge(bin_count) +
                          h_Vrt_pullVsSomething_split->GetXaxis()->GetBinWidth(bin_count);
      Double_t binCenter = (lowEdge + highEdge) / 2;
      Double_t binWidth = (highEdge - lowEdge) / 2; //half of the bin width
      //cout << "Bin done: " << binCenter << " +/- " << binWidth << ", Entries: " << profileZ->GetEntries() << endl;
      // variable binning end
 
      bins_z_nt.push_back(binCenter);
      bins_z_nt_er.push_back(binWidth); // dummy error of binwidth for now
 
      rms_z.push_back(profileZ->GetRMS());
      rms_z_er.push_back(profileZ->GetRMSError());
 
      //making a gaussian fit if there is anough entries
      if (profileZ->GetEntries() > 100.) {
        std::vector<float> fit_res = stableGaussianFit(profileZ);
        sigma_z.push_back(fit_res[0]);
        sigma_z_er.push_back(fit_res[1]);
      } else {
        sigma_z.push_back(0.);
        sigma_z_er.push_back(0.);
      }//end of good number of bins selection
 
      delete profileZ; // must keep this to delete the projection from memory (next one has same name!)
      profileZ = 0;
    }//end of loop over all the ntrk bins
 
    TGraphErrors* krms_z_vs_ntrk = new TGraphErrors(
      bins_z_nt.size(), &(bins_z_nt[0]), &(rms_z[0]), &(bins_z_nt_er[0]), &(rms_z_er[0]));
    krms_z_vs_ntrk->GetYaxis()->SetTitle(coordinate + " scale factor from RMS");
    krms_z_vs_ntrk->GetXaxis()->SetTitle(xAxisLabel);
    krms_z_vs_ntrk->SetTitle("scaleFactor" + coordinate + "_RMS");
    krms_z_vs_ntrk->SetName("scaleFactor" + coordinate + "_" + versus + "_RMS");
 
    TGraphErrors* kgs_z_vs_ntrk = new TGraphErrors(
      bins_z_nt.size(), &(bins_z_nt[0]), &(sigma_z[0]), &(bins_z_nt_er[0]), &(sigma_z_er[0]));
    kgs_z_vs_ntrk->GetYaxis()->SetTitle(coordinate + " scale factor from gauss fit");
    kgs_z_vs_ntrk->GetXaxis()->SetTitle(xAxisLabel);
    kgs_z_vs_ntrk->SetTitle("scaleFactor" + coordinate + "_Fit");
    kgs_z_vs_ntrk->SetName("scaleFactor_" + coordinate + "_" + versus + "_Fit");
 
// approximating the graph with 2nd order polynomial.
    float maxFitRange(100.);
    float minFitRange(2.);
    if (versus == "SumPt2") {
      minFitRange = 0.5;
      maxFitRange = 20.;
    }
    TF1* kgs_z_ntrk_fit;
    const Double_t* kgs_z_ntrk_fit_er;
    int fitResKFactorMethod = 2; // set by hand for now
    if (fitResKFactorMethod == 1) {
      //Fit with a pol2
      kgs_z_vs_ntrk->Fit("pol2", "Q", "", minFitRange, maxFitRange);
      kgs_z_vs_ntrk->GetFunction("pol2")->SetLineColor(kRed);
      kgs_z_ntrk_fit = kgs_z_vs_ntrk->GetFunction("pol2");
      kgs_z_ntrk_fit_er = kgs_z_ntrk_fit->GetParErrors();
    } else if (fitResKFactorMethod == 2) {
      //Fit with a pol1
      kgs_z_vs_ntrk->Fit("pol1", "Q", "", minFitRange, maxFitRange);
      kgs_z_vs_ntrk->GetFunction("pol1")->SetLineColor(kRed);
      kgs_z_ntrk_fit = kgs_z_vs_ntrk->GetFunction("pol1");
      kgs_z_ntrk_fit_er = kgs_z_ntrk_fit->GetParErrors();
    } else if (fitResKFactorMethod == 3) {
      TF1* kgsFitFcn = new TF1("kgsFitFcn", scaleFactorFitFcn, minFitRange, maxFitRange, 3);
      kgsFitFcn->SetParameter(0, minFitRange);
      kgsFitFcn->SetParameter(1, 1.0);
      kgsFitFcn->SetParameter(2, 1.0);
      for (int ifit = 0; ifit < 1; ifit++) //initial estimation of best parameters
        kgs_z_vs_ntrk->Fit(kgsFitFcn, "Q");
      kgs_z_vs_ntrk->Fit(kgsFitFcn, "Q"); //perform actual fit
      kgs_z_ntrk_fit = kgsFitFcn;
      kgs_z_ntrk_fit_er = kgsFitFcn->GetParErrors();
/*    cout << "ScaleFactor fit for " << coordinate << " vs " << versus << " (method " << fitResKFactorMethod << ")= "
        << kgsFitFcn->GetParameter(0) << " +/- " << kgsFitFcn->GetParError(0) << " "
        << kgsFitFcn->GetParameter(1) << " +/- " << kgsFitFcn->GetParError(1) << " "
        << kgsFitFcn->GetParameter(2) << " +/- " << kgsFitFcn->GetParError(2) << endl; */
    } else if (fitResKFactorMethod == 4) {
      //constant fit
      kgs_z_vs_ntrk->Fit("pol0", "Q", "", minFitRange, maxFitRange);
      kgs_z_vs_ntrk->GetFunction("pol0")->SetLineColor(kRed);
      kgs_z_ntrk_fit = kgs_z_vs_ntrk->GetFunction("pol0");
      kgs_z_ntrk_fit_er = kgs_z_ntrk_fit->GetParErrors();
/*    cout << "ScaleFactor fit for " << coordinate << " vs " << versus << " (method " << fitResKFactorMethod << ")= "
      << kgs_z_ntrk_fit->GetParameter(0) << " +/- " << kgs_z_ntrk_fit->GetParError(0) << endl; */
    }
 
// plotting the fit error of the unconstrained primary vertex and correcting them
    int nbins_z_err_ntrk = h_Vrt_err_vs_Something->GetNbinsX();
 
    std::vector<float> av_err_z;
    std::vector<float> av_err_z_er;
//   std::vector<float> av_err_tag_z;
//   std::vector<float> av_err_tag_z_er;
    std::vector<float> err_bins_z_nt;
    std::vector<float> err_bins_z_nt_er;
    std::vector<float> res_z;
    std::vector<float> res_z_er;
//   std::vector<float> res_tag_z;
//   std::vector<float> res_tag_z_er;
 
    for (int bin_count = 1; bin_count <= nbins_z_err_ntrk; ++bin_count) {
      err_bins_z_nt.push_back(h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count));
      err_bins_z_nt_er.push_back(h_Vrt_err_vs_Something->GetXaxis()->GetBinWidth(bin_count) / 2.);
 
      TH1D* profileY = h_Vrt_err_vs_Something->ProjectionY("projectionErrors", bin_count, bin_count, "e");
//     TH1D * profileYTag(0);
//     if (h_Vrt_Tag_err_vs_Something)
//       profileYTag = h_Vrt_Tag_err_vs_Something->ProjectionY("projectionErrorsTag",bin_count,bin_count,"e");
 
      float mean = profileY->GetMean();
      float mean_error = profileY->GetMeanError();
//     float meanTag(0);
//     float mean_errorTag(0);
//     if (profileYTag) {
//       meanTag = profileYTag->GetMean();
//       mean_errorTag = profileYTag->GetMeanError();
//     }
      delete profileY;
//     delete profileYTag;
 
      av_err_z.push_back(mean);
      av_err_z_er.push_back(mean_error);
//     av_err_tag_z.push_back(meanTag);
//     av_err_tag_z_er.push_back(mean_errorTag);
 
      //estimating the approximate k-factor and the error value
      double pr_er = 0.0;
      float val(0.);
      if (fitResKFactorMethod == 1) {
        pr_er = error_func(bin_count, kgs_z_ntrk_fit_er);
      } else if (fitResKFactorMethod == 2) {
        val = h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count);
        pr_er = TMath::Power(kgs_z_ntrk_fit_er[1] * val, 2) + TMath::Power(kgs_z_ntrk_fit_er[0], 2);
        pr_er = TMath::Sqrt(pr_er);
//       cout << "val = " << val << ", pr_er = " << pr_er << ", p0er = " << kgs_z_ntrk_fit_er[0] << ", p1er = "<<
// kgs_z_ntrk_fit_er[1] << endl;
      } else if (fitResKFactorMethod == 3) {
        val = h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count);
        //approximately the error on the plateau
        pr_er = kgs_z_ntrk_fit_er[2];
      } else if (fitResKFactorMethod == 4) {
        pr_er = kgs_z_ntrk_fit_er[0];
      }
 
      res_z.push_back(mean * kgs_z_ntrk_fit->Eval(h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count)));
      res_z_er.push_back(TMath::Sqrt(TMath::Power(mean_error *
                                                  kgs_z_ntrk_fit->Eval(h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(
                                                                         bin_count)),
                                                  2) + TMath::Power(pr_er * mean, 2)));
//     res_tag_z.push_back(meanTag * kgs_z_ntrk_fit->Eval(h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count)));
//     res_tag_z_er.push_back(TMath::Sqrt(TMath::Power(mean_errorTag *
// kgs_z_ntrk_fit->Eval(h_Vrt_err_vs_Something->GetXaxis()->GetBinCenter(bin_count)),2) + TMath::Power( pr_er * mean
// ,2)));
    }
    TGraphErrors* res_z_vs_ntrk =
      new TGraphErrors(err_bins_z_nt.size(), &(err_bins_z_nt[0]), &(res_z[0]), &(err_bins_z_nt_er[0]), &(res_z_er[0]));
    res_z_vs_ntrk->GetYaxis()->SetTitle(coordinate + " Vertex Resolution [mm]");
    res_z_vs_ntrk->GetXaxis()->SetTitle(xAxisLabel);
    res_z_vs_ntrk->SetTitle(coordinate + " Vertex Resolution");
    res_z_vs_ntrk->SetName("resolution_" + coordinate + "_" + versus);
 
//   TGraphErrors * res_tag_z_vs_ntrk = new TGraphErrors(err_bins_z_nt.size(),
// &(err_bins_z_nt[0]),&(res_tag_z[0]),&(err_bins_z_nt_er[0]), &(res_tag_z_er[0]) );
//   res_tag_z_vs_ntrk->GetYaxis()->SetTitle(coordinate+" Tagged Vertex Resolution [mm]");
//   res_tag_z_vs_ntrk->GetXaxis()->SetTitle(xAxisLabel);
//   res_tag_z_vs_ntrk->SetTitle(coordinate+" Tagged Vertex Resolution");
//   res_tag_z_vs_ntrk->SetName("resolution_tag_"+coordinate+"_"+versus);
 
//   TGraphErrors * mean_err_z_vs_ntrk = new TGraphErrors(err_bins_z_nt.size(),
// &(err_bins_z_nt[0]),&(av_err_z[0]),&(err_bins_z_nt_er[0]), &(av_err_z_er[0]) );
//   mean_err_z_vs_ntrk->GetYaxis()->SetTitle(coordinate+" mean vertex error [mm]");
//   mean_err_z_vs_ntrk->GetXaxis()->SetTitle(xAxisLabel);
//   mean_err_z_vs_ntrk->SetTitle(coordinate+" Mean Vertex Error");
//   mean_err_z_vs_ntrk->SetName("resolution_"+coordinate+"_"+versus+"_Uncorrected"); //not corrected with k-factor
 
    // Writing out
    if (versus == "Ntrk") res_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 100.);
    else res_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 20.);
    res_z_vs_ntrk->GetYaxis()->SetRangeUser(0.0025, 1.);
    res_z_vs_ntrk->Write("", TObject::kOverwrite);
    delete res_z_vs_ntrk;
 
    if (versus == "Ntrk") krms_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 100.);
    else krms_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 20.);
    krms_z_vs_ntrk->GetYaxis()->SetRangeUser(0.5, 1.3);
    krms_z_vs_ntrk->Write("", TObject::kOverwrite);
    delete krms_z_vs_ntrk;
 
    if (versus == "Ntrk") kgs_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 100.);
    else kgs_z_vs_ntrk->GetXaxis()->SetRangeUser(0., 20.);
    kgs_z_vs_ntrk->GetYaxis()->SetRangeUser(0.5, 1.3);
    kgs_z_vs_ntrk->Write("", TObject::kOverwrite);
    delete kgs_z_vs_ntrk;
 
//   nTrksPerVertex->GetYaxis()->SetTitle("Entries");
//   nTrksPerVertex->Draw();
//   nTrksPerVertex->Write("", TObject::kOverwrite);
 
    return;
  }

populateKeyMapping()

void dqutils::populateKeyMapping	(	TDirectory *	,
		keycyclemap &
	)

scaleFactorFitFcn()

double dqutils::scaleFactorFitFcn	(	double *	x,
		double *	par
	)

Definition at line 456 of file MonitoringFile_IDEnhancedPrimaryVertex.cxx.

                                                   {
    // Truncated gaus-smeared step function
    // par 0: mean of turn-on (and truncation point)
    // par 1: slope of turn-on
    // par 2: plateau
    return (x[0] >= par[0]) * TMath::Erf(par[1] * x[0] - par[0]) * par[2];
  }

stableGaussianFit()

std::vector< float > dqutils::stableGaussianFit

(

TH1 *

histo

)

Definition at line 424 of file MonitoringFile_IDEnhancedPrimaryVertex.cxx.

                                                 {
    std::vector<float> results;
    if (histo) {
      double sigmas = 2.;
 
      histo->Fit("gaus", "Q0", "", -2, 2);
      TF1* func = histo->GetFunction("gaus");
      double actualSigma = func->GetParameter(2);
      double actualSigmaErr = func->GetParError(2);
 
      for (int u = 0; u < 10; u++) {
        histo->Fit("gaus", "Q0", "", -sigmas * actualSigma, sigmas * actualSigma);
        func = histo->GetFunction("gaus");
        actualSigma = func->GetParameter(2);
        actualSigmaErr = func->GetParError(2);
      }//end of the fitting loop
 
      results.push_back(actualSigma);
      results.push_back(actualSigmaErr);
    } else {
      results.push_back(0.);
      results.push_back(0.);
    }//end of protection against an empty histogram
 
    return results;
  }//end of stableGaussian Fit function

updateHists()

int dqutils::updateHists	(	const std::string &	inFileName,
		const std::string &	inStem,
		const std::string &	outFileName = "",
		const std::string &	outStem = ""
	)

Definition at line 149 of file MonitoringFile_MoveVertexMonitoring.cxx.

                                         {
    std::string outFileName = fileName;
    std::string outStem = stem;
    //open original file
    TFile* source = TFile::Open(inFileName.c_str());
    if (!source) {
      //std::cout << "Couldn't open input file, " << inFileName << std::endl;
      return 1;
    }//else std::cout << "opening input file, " << inFileName << std::endl;
 
    //find out whether inStem is a histogram or a directory
    bool isDir = true;
    std::string path = inStem;
    std::string hist;
 
    if (inStem[inStem.size() - 1] != '/') {
      std::string::size_type lastSlash = inStem.find_last_of('/');
      hist = inStem.substr(lastSlash + 1, inStem.size() - lastSlash - 1);
      path = inStem.substr(0, lastSlash + 1);
      isDir = (source->FindObjectAny(hist.c_str()))->InheritsFrom("TDirectory");
      if (isDir) {
        path = inStem;
        hist.clear();
      }
    }
 
    if (path[path.size() - 1] == '/') path.resize(path.size() - 1);
    if (!source->GetDirectory(path.c_str())) {
      //std::cout << "path " << path << " directory doesn't exist in input file" << std::endl;
      return 1;
    }
 
    //open target file
    std::cout.fill(' ');
    if (outFileName.empty()) {
      outFileName = std::string(inFileName, 0, inFileName.find(".root"));
      outFileName += "_trimmed.root";
    }
 
    TFile* target = TFile::Open(outFileName.c_str(), "update");
    if (!target) {
      //std::cout << "coundn't open output file " << outFileName << std::endl;
      return 1;
    }//else std::cout << "opening output file " << outFileName << std::endl;
 
    if (outStem.empty()) outStem = inStem;
    std::string targetPath = outStem;
    std::string targetHist;
    if (!isDir) {
      std::string::size_type lastSlash = outStem.find_last_of('/');
      targetPath = outStem.substr(0, lastSlash + 1);
      targetHist = outStem.substr(lastSlash + 1, outStem.size() - lastSlash - 1);
    }
 
    if (targetPath[targetPath.size() - 1] == '/') targetPath.resize(targetPath.size() - 1);
 
    target->cd();
    if (!makeDirectories(targetPath)) {
      //std::cout << "couldn't create outStem directories in output" << std::endl;
      return 1;
    }
    //copy relevant objects
    if (!target->IsWritable()) return 1;
 
    Copy(source, target, path, targetPath, hist, targetHist);
 
    delete target;
    delete source;
    return 0;
  }

Variable Documentation

padding

std::atomic<int> dqutils::padding = 0

Definition at line 20 of file MonitoringFile_MoveVertexMonitoring.cxx.

root_color_choices

std::vector<int> dqutils::root_color_choices

Initial value:

= {
    kBlue, kRed, kGray, kOrange, kViolet, kGreen + 1
  }

Definition at line 86 of file HanOutputFile.cxx.