void dump_required_lvl2(TTree *tree, TLeaf &leaf, CodedOutputStream &o, CodedOutputStream &o2) {
const int DL = 1; // definition level multiplier
const int RL = 4; // repetition level multiplier
std::cout << "Dump vector vector: " << leaf.GetName() << " " << leaf.GetTypeName() << std::endl;
auto * branch = leaf.GetBranch();
std::vector<std::vector<T> > * data = NULL;
tree->SetBranchAddress(leaf.GetBranch()->GetName(), &data);
int entries = tree->GetEntries();
for (int i = 0; i < entries; i++) {
branch->GetEntry(i);
if (data->size() == 0) {
write_out_32(o2, DL*0 + RL*0);
}
for (int j = 0; j < data->size(); j++) {
if (data->at(j).size() == 0) {
int dl = 1;
int rl = (j > 0 ? 1 : 0);
write_out_32(o2, dl*DL + rl*RL);
}
for (int k = 0; k < data->at(j).size(); k++) {
int dl = 2;
int rl = (k > 0 ? 2 : (j > 0 ? 1 : 0));
write_out_32(o2, dl*DL + rl*RL);
write_out_type(o, data->at(j).at(k));
}
}
}
}
void dump_required_lvl0(TTree *tree, TLeaf &leaf, CodedOutputStream &o) {
std::cout << "Dump " << leaf.GetName() << std::endl;
auto *branch = leaf.GetBranch();
T data;
tree->SetBranchAddress(leaf.GetBranch()->GetName(), &data);
int entries = tree->GetEntries();
for (int i = 0; i < entries; i++) {
branch->GetEntry(i);
write_out_type(o, data);
}
}
map<TString, vector<TString> >GetCounterBranchListMap(TTree *t)
{
map<TString, vector<TString> > m;
TObjArray *l = t->GetListOfLeaves(); //sometimes leave can be named wrong - rely on branches
int n = l->GetEntries();// cout<<t->GetName()<<" has "<<n<<" leaves"<<endl;
for (int i=0;i<n;i++) {
TLeaf * leaf = (TLeaf *)(*l)[i];
TLeaf *lc = leaf->GetLeafCount();
if (lc!=0) {
m[lc->GetBranch()->GetName()].push_back(leaf->GetBranch()->GetName()); //get leaf's branch name
if (VERBOSE) cout<<lc->GetBranch()->GetName()<<" _ "<<leaf->GetBranch()->GetName()<<endl;
}
}
return m;
}
void Example_tags(TString topDir = "/star/rcf/GC/daq/tags")
{
//////////////////////////////////////////////////////////////////////////
// //
// Example_tags.C //
// //
// shows how to use the STAR tags files //
// Input: top level directory //
// //
// what it does: //
// 1. creates TChain from all tags files down from the topDir //
// 2. loops over all events in the chain //
// //
// owner: Alexandre V. Vaniachine <*****@*****.**> //
//////////////////////////////////////////////////////////////////////////
gSystem->Load("libTable");
gSystem->Load("St_base");
// start benchmarks
gBenchmark = new TBenchmark();
gBenchmark->Start("total");
// set loop optimization level
gROOT->ProcessLine(".O4");
// gather all files from the same top directory into one chain
// topDir must end with "/"
topDir +='/';
St_FileSet dirs(topDir);
St_DataSetIter next(&dirs,0);
St_DataSet *set = 0;
TChain chain("Tag");
while ( (set = next()) ) {
if (strcmp(set->GetTitle(),"file") ||
!(strstr(set->GetName(),".tags.root"))) continue;
chain.Add(gSystem->ConcatFileName(topDir,set->Path()));
}
UInt_t nEvents = chain->GetEntries();
cout<<"chained "<<nEvents<<" events "<<endl;
TObjArray *files = chain.GetListOfFiles();
UInt_t nFiles = files->GetEntriesFast();
cout << "chained " << nFiles << " files from " << topDir << endl;
TObjArray *leaves = chain.GetListOfLeaves();
Int_t nleaves = leaves->GetEntriesFast();
TString tableName = " ";
TObjArray *tagTable = new TObjArray;
Int_t tableCount = 0;
Int_t *tableIndex = new Int_t[nleaves];
Int_t tagCount = 0;
// decode tag table names
for (Int_t l=0;l<nleaves;l++) {
TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
tagCount+=leaf->GetNdata();
TBranch *branch = leaf->GetBranch();
// new tag table name
if ( strstr(branch->GetName(), tableName.Data()) == 0 ) {
tableName = branch->GetName();
// the tableName is encoded in the branch Name before the "."
tableName.Resize(tableName->Last('.'));
tagTable->AddLast(new TObjString(tableName.Data()));
tableCount++;
}
tableIndex[l]=tableCount-1;
}
cout << " tot num tables, tags = " << tableCount << " "
<< tagCount << endl << endl;
//EXAMPLE 1: how to print out names of all tags and values for first event
for (l=0;l<nleaves;l++) {
leaf = (TLeaf*)leaves->UncheckedAt(l);
branch = leaf->GetBranch();
branch->GetEntry();
// tag comment is in the title
TString Title = leaf->GetTitle();
Int_t dim = leaf->GetNdata();
if (dim==1) {
Title.ReplaceAll('['," '");
Title.ReplaceAll(']',"'");
}
cout << "\n Table: ";
cout.width(10);
cout << ((TObjString*)tagTable->UncheckedAt(tableIndex[l]))->GetString()
<<" -- has tag: " << Title << endl;
for (Int_t i=0;i<dim;i++) {
cout <<" "<< leaf->GetName();
if (dim>1) cout << '['<<i<<']';
cout << " = " << leaf->GetValue(i) << endl;
}
}
// EXAMPLE 2: how to make a plot
c1 = new TCanvas("c1","Beam-Gas Rejection",600,1000);
gStyle->SetMarkerStyle(8);
chain->Draw("n_trk_tpc[0]:n_trk_tpc[1]");
// EXAMPLE 3: how to make a selection (write selected event numbers on the plot)
Int_t ncoll=0;
char aevent[10];
TText t(0,0,"a");
t.SetTextFont(52);
t.SetTextSize(0.02);
Float_t cut = 0.35;
cout <<"\n Events with ntrk>400 and |asim|<"<<cut<<endl;
//loop over all events: READ ONLY n_trk_tpc AND mEventNumber BRANCHES!
gBenchmark->Start("loop");
for (Int_t i=0;i<nFiles;i++) {
chain.LoadTree(*(chain.GetTreeOffset()+i));
TTree *T = chain.GetTree();
//must renew leaf pointer for each tree
TLeaf *ntrk = T->GetLeaf("n_trk_tpc");
TLeaf *run = T->GetLeaf("mRunNumber");
TLeaf *event = T->GetLeaf("mEventNumber");
for (Int_t j=0; j<T->GetEntries(); j++){
ntrk->GetBranch()->GetEntry(j);
event->GetBranch()->GetEntry(j);
run->GetBranch()->GetEntry(j);
Int_t Nm=ntrk->GetValue(0);
Int_t Np=ntrk->GetValue(1);
Int_t Ntrk = Np+Nm;
// avoid division by 0
Float_t asim = Np-Nm;
if (Ntrk>0) asim /= Ntrk;
if (-cut < asim&&asim < cut && Ntrk>400) {
cout<<" Run "<<(UInt_t)run->GetValue()
<<", Event "<<event->GetValue() <<endl;
ncoll++;
sprintf(aevent,"%d",event->GetValue());
t.DrawText(Np+10,Nm+10,aevent);
}
}
}
gBenchmark->Stop("loop");
t.SetTextSize(0.05);
t.DrawText(50,2550,"ntrk>400 and |(Np-Nm)/(Np+Nm)| < 0.35 ");
t.DrawText(500,-300,"Ntrk with tanl<0 ");
cout << " Selected " << ncoll << " collision candidates out of "
<< nEvents << " events" << endl;
// stop timer and print benchmarks
gBenchmark->Print("loop");
gBenchmark->Stop("total");
gBenchmark->Print("total");
}
bool execute(const std::string& skeleton, const std::string& config_file, std::string output_dir/* = ""*/) {
std::vector<Plot> plots;
// If an output directory is specified, use it, otherwise use the current directory
if (output_dir == "")
output_dir = ".";
std::map<std::string, std::string> unique_names;
get_plots(config_file, plots);
std::cout << "List of requested plots: ";
for (size_t i = 0; i < plots.size(); i++) {
std::cout << "'" << plots[i].name << "'";
if (i != plots.size() - 1)
std::cout << ", ";
}
std::cout << std::endl;
// Convert plots name to unique name to avoid collision between different runs
for (Plot& plot: plots) {
std::string uuid = get_uuid();
unique_names[uuid] = plot.name;
plot.name = uuid;
}
std::unique_ptr<TChain> t(new TChain("t"));
t->Add(skeleton.c_str());
std::vector<Branch> branches;
std::function<void(TTreeFormula*)> getBranches = [&branches, &getBranches](TTreeFormula* f) {
if (!f)
return;
for (size_t i = 0; i < f->GetNcodes(); i++) {
TLeaf* leaf = f->GetLeaf(i);
if (! leaf)
continue;
TBranch* p_branch = getTopBranch(leaf->GetBranch());
Branch branch;
branch.name = p_branch->GetName();
if (std::find_if(branches.begin(), branches.end(), [&branch](const Branch& b) { return b.name == branch.name; }) == branches.end()) {
branch.type = p_branch->GetClassName();
if (branch.type.empty())
branch.type = leaf->GetTypeName();
branches.push_back(branch);
}
for (size_t j = 0; j < f->fNdimensions[i]; j++) {
if (f->fVarIndexes[i][j])
getBranches(f->fVarIndexes[i][j]);
}
}
for (size_t i = 0; i < f->fAliases.GetEntriesFast(); i++) {
getBranches((TTreeFormula*) f->fAliases.UncheckedAt(i));
}
};
std::string hists_declaration;
std::string text_plots;
for (auto& p: plots) {
// Create formulas
std::shared_ptr<TTreeFormula> selector(new TTreeFormula("selector", p.plot_cut.c_str(), t.get()));
getBranches(selector.get());
std::vector<std::string> splitted_variables = split(p.variable, ":");
for (const std::string& variable: splitted_variables) {
std::shared_ptr<TTreeFormula> var(new TTreeFormula("var", variable.c_str(), t.get()));
getBranches(var.get());
}
std::string binning = p.binning;
binning.erase(std::remove_if(binning.begin(), binning.end(), [](char chr) { return chr == '(' || chr == ')'; }), binning.end());
// If a variable bin size is specified, declare array that will be passed as array to histogram constructor
if(binning.find("{") != std::string::npos){
std::string arrayString = buildArrayForVariableBinning(binning, splitted_variables.size(), p.name);
hists_declaration += arrayString;
}
std::string title = p.title + ";" + p.x_axis + ";" + p.y_axis + ";" + p.z_axis;
std::string histogram_type = getHistogramTypeForDimension(splitted_variables.size());
hists_declaration += " std::unique_ptr<" + histogram_type + "> " + p.name + "(new " + histogram_type + "(\"" + p.name + "\", \"" + title + "\", " + binning + ")); " + p.name + "->SetDirectory(nullptr);\n";
std::string variable_string;
for (size_t i = 0; i < splitted_variables.size(); i++) {
variable_string += splitted_variables[i];
if (i != splitted_variables.size() - 1)
variable_string += ", ";
}
ctemplate::TemplateDictionary plot("plot");
plot.SetValue("CUT", p.plot_cut);
plot.SetValue("VAR", variable_string);
plot.SetValue("HIST", p.name);
ctemplate::ExpandTemplate(getTemplate("Plot"), ctemplate::DO_NOT_STRIP, &plot, &text_plots);
}
// Sort alphabetically
std::sort(branches.begin(), branches.end(), [](const Branch& a, const Branch& b) {
return a.name < b.name;
});
std::string text_branches;
for (const auto& branch: branches) {
text_branches += "const " + branch.type + "& " + branch.name + " = tree[\"" + branch.name + "\"].read<" + branch.type + ">();\n ";
}
ctemplate::TemplateDictionary header("header");
header.SetValue("BRANCHES", text_branches);
std::string output;
ctemplate::ExpandTemplate(getTemplate("Plotter.h"), ctemplate::DO_NOT_STRIP, &header, &output);
std::ofstream out(output_dir + "/Plotter.h");
out << output;
out.close();
output.clear();
std::string text_save_plots;
for (auto& p: plots) {
ctemplate::TemplateDictionary save_plot("save_plot");
save_plot.SetValue("UNIQUE_NAME", p.name);
save_plot.SetValue("PLOT_NAME", unique_names[p.name]);
ctemplate::ExpandTemplate(getTemplate("SavePlot"), ctemplate::DO_NOT_STRIP, &save_plot, &text_save_plots);
}
ctemplate::TemplateDictionary source("source");
source.SetValue("HISTS_DECLARATION", hists_declaration);
source.SetValue("PLOTS", text_plots);
source.SetValue("SAVE_PLOTS", text_save_plots);
ctemplate::ExpandTemplate(getTemplate("Plotter.cc"), ctemplate::DO_NOT_STRIP, &source, &output);
out.open(output_dir + "/Plotter.cc");
out << output;
out.close();
return true;
}