Class to handle calculation of beam normalization. More...

#include <RootAnalysis.hxx>

Inheritance diagram for dragon::BeamNorm:

Collaboration diagram for dragon::BeamNorm:

[legend]

Classes
struct	RunData
	Summarizes relevant normalization data for a run. More...

Public Member Functions
	BeamNorm ()
	Default constructor.

	BeamNorm (const char name, const char rossumFile)
	Construct from rossum file.

void	ChangeRossumFile (const char *name)
	Switch to a new rossum file.

RossumData *	GetRossumFile () const
	Get a pointer to the rossum file.

void	BatchCalculate (TChain chain, Int_t chargeBeam, Double_t pkLow0, Double_t pkHigh0, Double_t pkLow1, Double_t pkHigh1, const char recoilGate=0, Double_t time=120, Double_t skipBegin=10, Double_t skipEnd=5)
	Batch calculate over a chain of files.

void	BatchCalculate (TChain *chain, Int_t chargeBeam, Double_t pkLow0, Double_t pkHigh0, Double_t pkLow1, Double_t pkHigh1, const TCut &recoilGate, Double_t time=120, Double_t skipBegin=10, Double_t skipEnd=5)
	BatchCalculate overloaded with non-null recoil gate.

void	CalculateRecoils (TFile datafile, const char tree, const char *gate)
	Calculate the number of recoils per run.

Int_t	ReadSbCounts (TFile *datafile, Double_t pkLow0, Double_t pkHigh0, Double_t pkLow1, Double_t pkHigh1, Double_t time=120.)

void	ReadFC4 (Int_t runnum, Double_t skipBegin=10, Double_t skipEnd=5)
	Read rossum FC4 current.

void	CalculateNorm (Int_t run, Int_t chargeState)
	Calculate R and total beam particles.

RunData *	GetRunData (Int_t runnum)
	Return stored values of run data.

std::vector< Int_t > &	GetRuns () const
	Return a vector of run numbers used in the calculation.

TGraphAsymmErrors *	Plot (const char *param, Marker_t marker=20, Color_t markerColor=kBlack)

TGraphErrors *	PlotVal (const TString &valstr, int which=0, Marker_t marker=20, Color_t markerColor=kBlack, Option_t *option="")

TGraphErrors *	PlotNbeam (double sbnorm, int which=0, Marker_t marker=21, Color_t markerColor=kBlack)
	Plot number of beam particles with manual sbnorm specification.

Long64_t	Draw (const char varexp, const char selection, Option_t *option="", Long64_t nentries=1000000000, Long64_t firstentry=0)
	Draw run data information.

void	Draw (Option_t *option)

UDouble_t	GetEfficiency (const char *name) const

void	SetEfficiency (const char *name, UDouble_t value)

void	SetEfficiency (const char *name, Double_t value)

void	CorrectTransmission (Int_t reference)

UDouble_t	CalculateEfficiency (Bool_t print=kTRUE)

UDouble_t	CalculateYield (Int_t whichSb, Int_t type=kHiSingles, Bool_t print=kTRUE)

Public Attributes
TTree	fRunDataTree

Private Member Functions
RunData *	GetOrCreateRunData (Int_t runnum)
	Private GetRunData(), creates new if it's not made.

Bool_t	HaveRossumFile ()

UInt_t	GetParams (const char param, std::vector< Double_t > runnum, std::vector< UDouble_t > *parval)

	BeamNorm (const BeamNorm &)

BeamNorm &	operator= (const BeamNorm &)

	ClassDef (BeamNorm, 2)

Private Attributes
RunData *	fRunDataBranchAddr

std::map< Int_t, RunData >	fRunData

dragon::utils::AutoPtr< RossumData >	fRossum

std::map< std::string, UDouble_t >	fEfficiencies

Detailed Description

Class to handle calculation of beam normalization.

Definition at line 295 of file RootAnalysis.hxx.

Member Function Documentation

◆ CorrectTransmission()

void dragon::BeamNorm::CorrectTransmission ( Int_t reference )

Correct for FC4->FC1 transmission changes relative to a single "good" run

Corrects the yield and nbeam values for each run such that the transmission matches the reference run.

Parameters

reference Run number of the reference run.

Todo:: Change nbeam to nbeam_fc4 and nbeam_fc1 or something like that becuse now it's confusing to change both yield and nbeam and not explicit enough what's going on.

Definition at line 1394 of file RootAnalysis.cxx.

References dragon::BeamNorm::RunData::fc1, dragon::BeamNorm::RunData::fc4, dragon::BeamNorm::RunData::nbeam, dragon::BeamNorm::RunData::trans_corr, and dragon::BeamNorm::RunData::yield.

 {
   RunData* refData = GetRunData(reference);
   if(!refData) {
     std::cerr << "Cound not find run data for reference run " << reference << "\n";
     return;
   }
   UDouble_t transRef = refData->fc1 / UDouble_t::Mean(3, refData->fc4);
 
   for(std::map<Int_t, RunData>::iterator it = fRunData.begin(); it != fRunData.end(); ++it) {
     RunData& thisData = it->second;
     UDouble_t transThis = thisData.fc1 / UDouble_t::Mean(3, thisData.fc4);
     if(it->first != reference)
       thisData.trans_corr = (transThis / transRef);
     else
       thisData.trans_corr = UDouble_t(1, 0);
 
     for(int i=0; i< NSB; ++i) {
       thisData.yield[i] /= thisData.trans_corr;
       thisData.nbeam[i] /= thisData.trans_corr;
     }
   }
 }

◆ Plot()

TGraphAsymmErrors * dragon::BeamNorm::Plot	(	const char *	param,
		Marker_t	marker = `20`,
		Color_t	markerColor = `kBlack`
	)

Plot some parameter as a function of run number

Parameters

param	String specifying the parameter to plot, should be a member of dragon::BeamNorm::RunData
marker	Marker symbol
markerColor	Marker color

Returns: TGraph pointer containing param vs. run number, responsibility is on the user to delete this. In case of error, returns 0.

Also draws the returned TGraph in its own window.

Definition at line 1135 of file RootAnalysis.cxx.

 {
   TGraphAsymmErrors* gr = 0;
   std::vector<Double_t>  runnum;
   std::vector<UDouble_t> parval;
   UInt_t npar = GetParams(param, &runnum, &parval);
   if(npar) {
     gr = PlotUncertainties(runnum.size(), &runnum[0], &parval[0]);
     gr->SetMarkerStyle(marker);
     gr->SetMarkerColor(markerColor);
     gr->Draw("AP");
   }
   return gr;
 }

◆ PlotVal()

TGraphErrors * dragon::BeamNorm::PlotVal	(	const TString &	valstr,
		int	which = `0`,
		Marker_t	marker = `20`,
		Color_t	markerColor = `kBlack`,
		Option_t *	option = `""`
	)

Plot some parameter as a function of run number (alt. implementation)

Parameters

valstr	String specifying the parameter to plot, should be a member of dragon::BeamNorm::RunData
which	Specifies which array index to plot, ignored if valstr is not an array
marker	Marker symbol
markerColor	Marker color

Returns: TGraphErrors pointer containing param vs. run number, responsibility is on the user to delete this. In case of error, returns 0.

Also draws the returned TGraph in its own window.

Definition at line 1161 of file RootAnalysis.cxx.

 {
   std::vector<double> rn, val, err;
   for(size_t i=0; i< GetRuns().size(); ++i) {
     const dragon::BeamNorm::RunData* rd = GetRunData(GetRuns()[i]);
     rn.push_back(rd->runnum);
     if(0) {
     }
     else if(valstr == "sb_counts") {
       val.push_back(rd->sb_counts[which].GetNominal());
       err.push_back(rd->sb_counts[which].GetErrLow());
     }
     else if(valstr == "sb_counts_full") {
       val.push_back(rd->sb_counts_full[which].GetNominal());
       err.push_back(rd->sb_counts_full[which].GetErrLow());
     }
     else if(valstr == "live_time") {
       val.push_back(rd->live_time.GetNominal());
       err.push_back(rd->live_time.GetErrLow());
     }
     else if(valstr == "live_time_tail") {
       val.push_back(rd->live_time_tail.GetNominal());
       err.push_back(rd->live_time_tail.GetErrLow());
     }
     else if(valstr == "live_time_head") {
       val.push_back(rd->live_time_head.GetNominal());
       err.push_back(rd->live_time_head.GetErrLow());
     }
     else if(valstr == "live_time_coinc") {
       val.push_back(rd->live_time_coinc.GetNominal());
       err.push_back(rd->live_time_coinc.GetErrLow());
     }
     else if(valstr == "pressure") {
       val.push_back(rd->pressure.GetNominal());
       err.push_back(rd->pressure.GetErrLow());
     }
     else if(valstr == "pressure_full") {
       val.push_back(rd->pressure_full.GetNominal());
       err.push_back(rd->pressure_full.GetErrLow());
     }
     else if(valstr == "fc4") {
       val.push_back(rd->fc4[which].GetNominal());
       err.push_back(rd->fc4[which].GetErrLow());
     }
     else if(valstr == "fc1") {
       val.push_back(rd->fc1.GetNominal());
       err.push_back(rd->fc1.GetErrLow());
     }
     else if(valstr == "trans_corr") {
       val.push_back(rd->trans_corr.GetNominal());
       err.push_back(rd->trans_corr.GetErrLow());
     }
     else if(valstr == "sbnorm") {
       val.push_back(rd->sbnorm[which].GetNominal());
       err.push_back(rd->sbnorm[which].GetErrLow());
     }
     else if(valstr == "nbeam") {
       val.push_back(rd->nbeam[which].GetNominal());
       err.push_back(rd->nbeam[which].GetErrLow());
     }
     else if(valstr == "nrecoil") {
       val.push_back(rd->nrecoil.GetNominal());
       err.push_back(rd->nrecoil.GetErrLow());
     }
     else if(valstr == "yield") {
       val.push_back(rd->yield[which].GetNominal());
       err.push_back(rd->yield[which].GetErrLow());
     }
     else {
       std::cerr << "Invalid parameter << \"" << valstr.Data() << "\"\n";
       break;
     }
   }
   TGraphErrors* gr = 0;
   if(val.size()) {
     gr = new TGraphErrors(rn.size(), &rn[0], &val[0], 0, &err[0]);
     gr->SetMarkerStyle(marker);
     gr->SetMarkerColor(markerColor);
     gr->SetLineColor(markerColor);
     gr->Draw(option);
   }
   return gr;
 }

◆ ReadSbCounts()

Int_t dragon::BeamNorm::ReadSbCounts	(	TFile *	datafile,
		Double_t	pkLow0,
		Double_t	pkHigh0,
		Double_t	pkLow1,
		Double_t	pkHigh1,
		Double_t	time = `120.`
	)

Integrate the surface barrier counts at the beginning and end of a run

Calculates the "R-value" to normalize SB readings to Faraday cup data. Stores the result in fRunData, they can be accessed by using GetRunData()

Parameters

datafile	Pointer to the run's ROOT file
pkLow0	Low end of the SB0 good peak
pkHigh0	High end of the SB0 good peak
pkLow1	Low end of the SB1 good peak
pkHigh1	High end of the SB1 good peak
time	Number of seconds at the beginning of the run to use for calculating the normalization

Returns: The run number of the specified file.

Definition at line 859 of file RootAnalysis.cxx.

 {
   if(!HaveRossumFile()) {
     std::cout << "\n";
     dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "no rossum file loaded.";
     return 0;
   }
   if(!datafile || datafile->IsZombie()) {
     std::cout << "\n";
     dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "Invalid datafile: " << datafile;
     return 0;
   }
 
   Bool_t haveRunnum = kFALSE;
   Int_t runnum = 0;
   midas::Database* db = static_cast<midas::Database*>(datafile->Get("odbstop"));
 
   if (db) haveRunnum = db->ReadValue("/Runinfo/Run number", runnum);
   else {
     std::cout << "\n";
     dutils::Warning("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "MIDAS database at run stop time missing from file " << datafile->GetName() << "\n";
     midas::Database* dbstart = static_cast<midas::Database*>(datafile->Get("odbstart"));
     if (dbstart) haveRunnum = dbstart->ReadValue("/Runinfo/Run number", runnum);
     else {
       std::cout << "\n";
       dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
         << "MIDAS database at run start time missing from file " << datafile->GetName() << "\n";
       return 0;
     }
   }
   if(!haveRunnum) {
     std::cout << "\n";
     dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "could not read run number from file " << datafile->GetName();
     return 0;
   }
 
   TTree* t3 = static_cast<TTree*>(datafile->Get("t3"));
   if(t3 == 0 || t3->GetListOfBranches()->At(0) == 0) {
     std::cout << "\n";
     dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "no heavy-ion data tree in file" << datafile->GetName();
     return 0;
   }
 
   TTree* t20 = static_cast<TTree*>(datafile->Get("t20"));
   if(t20 == 0 || t20->GetListOfBranches()->At(0) == 0) {
     dutils::Error("BeamNorm::ReadSbCounts", __FILE__, __LINE__)
       << "no EPICS tree in file" << datafile->GetName();
     return 0;
   }
 
   dragon::Tail tail;
   dragon::Tail *pTail = &tail;
   t3->SetBranchAddress(t3->GetListOfBranches()->At(0)->GetName(), &pTail);
 
   dragon::Epics epics;
   dragon::Epics* pEpics = &epics;
   t20->SetBranchAddress(t20->GetListOfBranches()->At(0)->GetName(), &pEpics);
 
   AutoResetBranchAddresses Rst3_(t3);
   AutoResetBranchAddresses Rst20_(t20);
 
   Long64_t ncounts[NSB];
   Long64_t ncounts_full[NSB];
   for(int i=0; i< NSB; ++i) {
     ncounts[i] = 0;
     ncounts_full[i] = 0;
   }
 
   t3->GetEntry(0);
   Double_t tstart = pTail->header.fTimeStamp;
   Double_t low[NSB] =  { pkLow0,  pkLow1  };
   Double_t high[NSB] = { pkHigh0, pkHigh1 };
 
   for(int i=0; i< NSB; ++i) {
     std::stringstream cut;
     cut.precision(20);
     cut << "sb.ecal[" << i << "] > " << low[i] << " && sb.ecal[" << i << "] < " << high[i];
     ncounts_full[i] = t3->GetPlayer()->GetEntries(cut.str().c_str());
 
     cut << " && header.fTimeStamp - " << tstart << " < " << time;
     ncounts[i] = t3->GetPlayer()->GetEntries(cut.str().c_str());
   }
 
   UDouble_t live, live_full[3]; // [3]: head,tail,coinc
   {
     dragon::LiveTimeCalculator ltc;
     ltc.SetFile(datafile);
     ltc.CalculateSub(0, time);
     live = ltc.GetLivetime("tail");
     ltc.Calculate();
     live_full[0] = ltc.GetLivetime("head");
     live_full[1] = ltc.GetLivetime("tail");
     live_full[2] = ltc.GetLivetime("coinc");
   }
 
   t20->GetEntry(0);
   Double_t tstart20 = pTail->header.fTimeStamp;
   Int_t t1 = 0;
   std::vector<double> pressure;
 
   for(Long64_t entry = 0; entry != t20->GetEntries(); ++entry) {
     t20->GetEntry(entry);
     if(pEpics->ch == 0) {
       pressure.push_back(pEpics->val);
       if(pEpics->header.fTimeStamp - tstart20 < time)
         ++t1;
     }
   }
 
   RunData* rundata = GetOrCreateRunData(runnum);
   rundata->time = time;
   for(int i=0; i< NSB; ++i) {
     rundata->sb_counts[i] = UDouble_t(ncounts[i]);
     rundata->sb_counts_full[i] = UDouble_t(ncounts_full[i]);
   }
   //
   // Pressure over SB norm time
   {
     const Double_t pressureMean = utils::calculate_mean(pressure.begin(), pressure.begin() + t1);
     const Double_t pressureSigma = utils::calculate_stddev(pressure.begin(),
                                                            pressure.begin() + t1, pressureMean);
     rundata->pressure = UDouble_t (pressureMean, pressureSigma);
   }
   //
   // Pressure over full run
   {
     const Double_t pressureMean = utils::calculate_mean(pressure.begin(), pressure.end());
     const Double_t pressureSigma = utils::calculate_stddev(pressure.begin(),
                                                            pressure.end(), pressureMean);
     rundata->pressure_full = UDouble_t (pressureMean, pressureSigma);
   }
   rundata->live_time = live;
   rundata->live_time_head  = live_full[0];
   rundata->live_time_tail  = live_full[1];
   rundata->live_time_coinc = live_full[2];
 
   return runnum;
 }

Here is the call graph for this function:

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

/Volumes/Data/Users/elzoido238/packages/dragon/analyzer/src/utils/RootAnalysis.hxx
/Volumes/Data/Users/elzoido238/packages/dragon/analyzer/src/utils/RootAnalysis.cxx

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Function Documentation

◆ CorrectTransmission()

◆ Plot()

◆ PlotVal()

◆ ReadSbCounts()