void TTSelector::Begin(TTree *){
TString option = GetOption();
TObjArray *strobj = option.Tokenize(" ");
gTrigger = ((TObjString*)strobj->At(0))->GetString().Atoi();
gMode = ((TObjString*)strobj->At(1))->GetString().Atoi();
CreateMap();
TString filedir=ginFile;
filedir.Remove(filedir.Last('.')-4);
fFile = new TFile(goutFile,"RECREATE");
fTree = new TTree("M","Tree for GSI Prt Analysis");
fEvent = new TPrtEvent();
fTree->Branch("TPrtEvent", "TPrtEvent", &fEvent, 64000, 2);
TFile f(gcFile);
TIter nextkey(f.GetListOfKeys());
TKey *key;
while ((key = (TKey*)nextkey())) {
TGraph *gr = (TGraph*)key->ReadObj();
TString name = gr->GetName();
Int_t channel = name.Atoi();
gGr[channel]= new TGraph(*gr);
}
f.Close();
if(gMode == 1){
TFile f2(gtFile);
TIter nextkey2(f2.GetListOfKeys());
TKey *key2;
while ((key2 = (TKey*)nextkey2())) {
TGraph *gr = (TGraph*)key2->ReadObj();
TString name = gr->GetName();
Int_t channel = name.Atoi();
gGrDiff[channel]= new TGraph(*gr);
}
f2.Close();
}
std::cout<<"Initialization successful"<<std::endl;
}
TGraph* ContourGraph( TH2F* hist,double xmin=16, double xmax=90) {
//temporary canvas
TCanvas* MOO = new TCanvas( TString::Format("dummy_canvas_%s", hist->GetName()), "A scan of m_{0} versus m_{12}", 0, 0, 650,640);
MOO->cd();
TGraph* gr0 = new TGraph();
TH2F* h = (TH2F*)hist->Clone();
TGraph* gr = (TGraph*)gr0->Clone(TString::Format("gr_%s", h->GetName()));
cout << "==> Will dumb histogram: " << h->GetName() << " into a graph" <<endl;
h->SetContour( 1 );
//h->GetXaxis()->SetRangeUser(250,1200);
h->GetXaxis()->SetRangeUser(xmin, xmax);
//h->GetYaxis()->SetRangeUser(2,50);
double pval = CombinationGlob::cl_percent[1];
std::cout << pval << std::endl;
double signif = TMath::NormQuantile(1-pval);
h->SetContourLevel( 0, signif );
h->Draw("CONT LIST");
h->SetDirectory(0);
gPad->Update();
TObjArray *contours = (TObjArray*) gROOT->GetListOfSpecials()->FindObject("contours");
Int_t ncontours = contours->GetSize();
cout << "Found " << ncontours << " contours " << endl;
TList *list = (TList*)contours->At(0);
contours->Print("v");
if(!list) return NULL;
gr = (TGraph*)list->First();
if(!gr) return NULL;
gr->SetName(TString::Format("gr_%s", hist->GetName()));
//gr->SetName(hist->GetName());
int N = gr->GetN();
double x0, y0;
for(int j=0; j<N; j++) {
gr->GetPoint(j,x0,y0);
cout << j << " : " << x0 << " : "<<y0 << endl;
}
// // gr->SetMarkerSize(2.0);
//gr->Draw("ALP");
delete MOO;
cout << "Generated graph " << gr << " with name " << gr->GetName() << endl;
return gr;
}
//______________________________________________________________________________
void CheckPulsers(const Char_t* loc)
{
// Some old pedestal checking method.
Char_t t[256];
// number of runs
Int_t nRuns = gFiles->GetSize();
// number of channels
Int_t nCh = gReadAR->GetNelements();
// create arrays
Double_t** pedPos = new Double_t*[nCh];
Double_t* runNumbersD = new Double_t[nRuns];
for (Int_t i = 0; i < nCh; i++) pedPos[i] = new Double_t[nRuns];
// open the output files
TFile* fROOTout = new TFile("/tmp/pulser.root", "RECREATE");
// create directories
for (Int_t i = 0; i < nCh; i++)
{
sprintf(t, "%03d_%s", i, gReadAR->GetElement(i)->GetTDC());
fROOTout->mkdir(t);
}
TF1* func = new TF1("gausfunc", "gaus", 0 , 200);
// loop over runs
for (Int_t i = 0; i < nRuns; i++)
{
// get the file
TFile* f = (TFile*) gFiles->At(i);
// extract run number
Int_t runNumber;
sprintf(t, "%s/ARHistograms_CB_%%d.root", loc);
sscanf(f->GetName(), t, &runNumber);
runNumbersD[i] = (Double_t)runNumber;
printf("Processing run %d (%d/%d)\n", runNumber, i+1, nRuns);
fROOTout->cd();
// loop over TDCs
for (Int_t j = 0; j < nCh; j++)
{
// load histogram
sprintf(t, "%03d_%s", j, gReadAR->GetElement(j)->GetTDC());
fROOTout->cd(t);
sprintf(t, "ADC%s", gReadAR->GetElement(j)->GetTDC());
TH1D* h = (TH1D*) f->Get(t);
// fit gaussian to pulser
Double_t maxPos = h->GetXaxis()->GetBinCenter(h->GetMaximumBin());
func->SetParameters(1, maxPos, 0.1);
func->SetRange(maxPos - 2, maxPos + 2);
h->Fit(func, "RBQ");
maxPos = func->GetParameter(1);
// save position in file and memory
pedPos[j][i] = maxPos;
sprintf(t, "Run_%d", runNumber);
TCanvas* c = new TCanvas(t, t);
h->Draw();
TLine* tline = new TLine(maxPos, 0, maxPos, 10000);
tline->SetLineColor(kRed);
tline->SetLineWidth(2);
tline->Draw();
c->Write(c->GetName(), TObject::kOverwrite);
delete h;
delete c;
delete tline;
}
}
// create pedestal evolution graphs
fROOTout->cd();
// loop over channels
for (Int_t j = 0; j < nCh; j++)
{
printf("Creating pedestal graph for channel %d\n", j);
TGraph* g = new TGraph(nRuns, runNumbersD, pedPos[j]);
sprintf(t, "Overview_%03d_%s", j, gReadAR->GetElement(j)->GetTDC());
g->SetName(t);
g->SetTitle(t);
//g->GetYaxis()->SetRangeUser(1200, 1300);
g->Write(g->GetName(), TObject::kOverwrite);
delete g;
}
printf("Saving output file\n");
delete fROOTout;
// cleanup
for (Int_t i = 0; i < nCh; i++) delete [] pedPos[i];
delete [] pedPos;
delete [] runNumbersD;
}
//______________________________________________________________________________
void CheckTime(const Char_t* loc)
{
// Check time.
Char_t t[256];
// number of runs
Int_t nRuns = gFiles->GetSize();
// create arrays
const Int_t nCh = 352;
Double_t** pedPos = new Double_t*[nCh];
Double_t* runNumbersD = new Double_t[nRuns];
for (Int_t i = 0; i < nCh; i++) pedPos[i] = new Double_t[nRuns];
// open the output files
TFile* fROOTout = new TFile("/tmp/tagger_time.root", "RECREATE");
// create directories
for (Int_t i = 0; i < nCh; i++)
{
sprintf(t, "%03d", i);
fROOTout->mkdir(t);
}
TF1* func = new TF1("func", "gaus(0)+pol1(3)", -1000 , 1000);
// loop over runs
for (Int_t i = 0; i < nRuns; i++)
{
// get the file
TFile* f = (TFile*) gFiles->At(i);
// extract run number
Int_t runNumber;
sprintf(t, "%s/ARHistograms_CB_%%d.root", loc);
sscanf(f->GetName(), t, &runNumber);
runNumbersD[i] = (Double_t)runNumber;
printf("Processing run %d (%d/%d)\n", runNumber, i+1, nRuns);
fROOTout->cd();
TH2* h2 = (TH2*) f->Get("CaLib_Tagger_Time");
// loop over channels
for (Int_t j = 0; j < nCh; j++)
{
// load histogram
sprintf(t, "%03d", j);
fROOTout->cd(t);
sprintf(t, "%d_%d", i, j);
TH1* h = h2->ProjectionX(t, j+1, j+1);
h->Rebin(2);
sprintf(t, "Run_%d", runNumber);
TCanvas* c = new TCanvas(t, t);
TLine* tline = 0;
// check entries
if (h->GetEntries())
{
// fit gaussian to peak
Double_t maxPos = h->GetXaxis()->GetBinCenter(h->GetMaximumBin());
func->SetParameters(1, maxPos, 0.5, 1, 0.1);
func->SetRange(maxPos - 2, maxPos + 2);
func->SetParLimits(0, 0, 1000);
for (Int_t k = 0; k < 10; k++)
if (!h->Fit(func, "RBQ")) break;
// save position in file and memory
maxPos = func->GetParameter(1);
pedPos[j][i] = maxPos;
h->GetXaxis()->SetRangeUser(maxPos - 10, maxPos + 10);
h->Draw();
tline = new TLine(maxPos, 0, maxPos, 10000);
tline->SetLineColor(kRed);
tline->SetLineWidth(2);
tline->Draw();
}
else
{
h->Draw();
}
c->Write(c->GetName(), TObject::kOverwrite);
delete h;
delete c;
if (tline) delete tline;
}
delete h2;
}
// create pedestal evolution graphs
fROOTout->cd();
// loop over channels
for (Int_t j = 0; j < nCh; j++)
{
printf("Creating time graph for channel %d\n", j);
TGraph* g = new TGraph(nRuns, runNumbersD, pedPos[j]);
sprintf(t, "Overview_%03d", j);
g->SetName(t);
g->SetTitle(t);
//g->GetYaxis()->SetRangeUser(1200, 1300);
g->Write(g->GetName(), TObject::kOverwrite);
delete g;
}
printf("Saving output file\n");
delete fROOTout;
// cleanup
for (Int_t i = 0; i < nCh; i++) delete [] pedPos[i];
delete [] pedPos;
delete [] runNumbersD;
}
void addcanvases(){
fSavePath = "data/perfLL";
const Int_t narr = 20;
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
TFile *f1 = TFile::Open("c_l3.root");
TIter next1(f1->GetListOfKeys());
TKey *key1;
Int_t it1 = 0;
TCanvas *carr1[narr];
while((key1 = (TKey*)next1())) {
TClass *cl = gROOT->GetClass(key1->GetClassName());
if (!cl->InheritsFrom("TCanvas")) continue;
carr1[it1] = (TCanvas*)key1->ReadObj();
it1++;
}
TFile *f2 = TFile::Open("c_l0.root");
TIter next2(f2->GetListOfKeys());
TKey *key2;
Int_t it2 = 0;
TCanvas *carr2[narr];
while ((key2 = (TKey*)next2())) {
TClass *cl = gROOT->GetClass(key2->GetClassName());
if (!cl->InheritsFrom("TCanvas")) continue;
carr2[it2] = (TCanvas*)key2->ReadObj();
it2++;
}
TLegend *leg = new TLegend(0.2,0.7,0.5,0.9);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
for(Int_t i=0; i<it2; i++){
carr1[i]->Draw();
//leg->AddEntry( carr1[i],"3x3 full coverage","l");
//leg->Draw();
canvasAdd(carr1[i]);
TIter next(carr2[i]->GetListOfPrimitives());
TObject *obj;
while((obj = next())){
// if(obj->InheritsFrom("TH1F")){
// TH1F *h = (TH1F*)obj;
// std::cout<<"name "<< h->GetName() <<std::endl;
// h->SetLineStyle(7);
// h->SetLineWidth(2);
// h->Draw("same");
// }
if(obj->InheritsFrom("TGraph")){
TGraph *h = (TGraph*)obj;
std::cout<<"name "<< h->GetName() <<std::endl;
h->SetLineColor(32);
h->SetMarkerColor(2);
// h->SetLineWidth(2);
h->Draw("same PL");
// leg->AddEntry(h,"6.5x6.5 MCP PMTs coverage","lp");
// leg->Draw();
}
}
}
std::cout<<"save all " <<std::endl;
canvasSave(0,1);
}
int main( int argc ,char *argv[] ){
DataObject areas;
areas.getDataFromFile("resources/static_resources/area_noise_CMSSW_IDS.txt",2);
map<string, double> areaMap;
for (int i=1; i<= areas.getLenght(); i++){
double area = atof(areas.getElementFromPropertyContainer(i,2).c_str());
string roll = areas.getElementFromPropertyContainer(i,1);
areaMap[roll] = area;
}
//Syntax:
//EndCap RE(WDN)_SECTOR_RID
//Barrel W(WDN)_RID_SECTOR
if (argc < 5) {
cout << "Usage: " << argv[0] << " Zone Wheel Sector RollID [OutFile]" << endl;
cout << endl;
cout << " Conventions:"<< endl;
cout << " Barrel: W(WDN)_RID_SECTOR" << endl;
cout << " EndCap: RE(WDN)_SECTOR_RID" << endl;
cout << endl;
return 0;
}
bool corrected = true;
/* string zone = "EndCapPlus";
string RollID = "10";
int Sector = 2;
int WheelDiskNo = 2;
*/
string zone = argv[1];
string RollID = argv[4];
int Sector = atoi(argv[3]);
int WheelDiskNo = atoi(argv[2]);
string optionalID = argv[5];
string ContainerName = "ContainerRun2011.root";
string jsonFile = "./jsonFilesMu/Cert_160404-180252_7TeV_PromptReco_Collisions11_JSON.txt";
//Create a new Acquisition Registry
TFile* contFile = TFile::Open( ContainerName.c_str() );
Acquisition Run2011(contFile);
/* ifstream json(jsonFile.c_str());
Run2011.LoadJSON(json);*/
DataObject filterRun;
filterRun.getDataFromFile("filters/moreThan100.csv",1);
Run2011.LoadSelectionByDO(&filterRun, 1);
TFile* f;
if (argc >= 6){
f = new TFile(argv[6], "RECREATE");
cout << "Writing results on: " << argv[6] << endl;
}
else{
f = new TFile("Outputs/OutputFile.root", "RECREATE");
cout << "Writing results on: Outputs/OutputFile.root" << endl;
}
TGraph* plot = new TGraph();
TGraph* plotRun = new TGraph();
plot->SetName("RateVsLumi");
plotRun->SetName("RateVsRun");
plot->SetMarkerStyle(21);
contFile->Close();
int k=0;
int emptyStrip = 0;
cout << "Analysis of: " << zone << " - Wheel/Disk No." << WheelDiskNo << " ; Sector: " << Sector << " ; ID:" << RollID << endl;
cout << "Correction activated: " << corrected<< endl;
cout << "Dataset: " << ContainerName << endl;
cout << "JSON File: " << jsonFile << endl;
// Run2011.PrintValidRuns();
cout << "Number of runs: " << Run2011.numberOfRuns() << endl;
while (Run2011.hasNext()){
double NormalizedRate = 0;
Run* currentRun = Run2011.next();
//run selection
// if ( currentRun->getID() > 163289 && currentRun->getID() < 163340 ) continue;
// if (currentRun->getID() < 170000) continue;
// if (currentRun->getLumiSection() < 100) continue;
// if (currentRun->getID() < 178420) continue;
if (!Run2011.isValid(currentRun, false)) continue;
//Filling
contFile = TFile::Open( ContainerName.c_str() );
currentRun->FillFromContainer(contFile, areaMap);
double TotRate = 0;
double TotArea = 0;
int totAmount = 0;
if (currentRun->isFilled() == false){
cout << "Not filled: " << currentRun->getID() << endl;
}
if (currentRun->isFilled() == true){
map<string,ExRoll* > barrelMap;
if (zone == "Barrel")
barrelMap = currentRun->GetBarrel();
else if (zone == "EndCapPlus")
barrelMap = currentRun->GetEndCapPlus();
else if (zone == "EndCapMinus")
barrelMap = currentRun->GetEndCapMinus();
for (map<string,ExRoll* >::const_iterator it = barrelMap.begin(); it != barrelMap.end(); it++){
if (RollID != "-9")
if (it->second->getRollID().c_str() != RollID) continue;
if (Sector != -9)
if (it->second->getSector() != Sector) continue;
if (WheelDiskNo != -9)
if (it->second->getWheel_Disk_Number() != WheelDiskNo) continue;
//When we will decide to plot partition by partition
if (optionalID != "-9"){
// cout << optionalID << endl;
// cout << it->second->getOptionalRollID() << endl;
if ( it->second->getOptionalRollID().compare(optionalID) ) continue;
}
emptyStrip += it->second->getEmptyStrip();
// if ( it->second->getOptionalRollID().compare("B") ) continue;
// cout << "SEC " << it->second->getSector() << endl;
/* cout << "OPT: " << it->second-> getOptionalRollID() << endl;
cout << "RAW: " << it->second->getRawIDofClone(1) << endl;*/
// cout << "PASS: "******"VALUE: " << nAnalyzer.HealCloneByClone(it->second) << endl;
double rollArea = it->second->getRollArea();
TotArea += rollArea;
}
//Free RAM
for (map<string,ExRoll* >::const_iterator it = barrelMap.begin(); it != barrelMap.end(); it++){
delete it->second;
}
double NormalizedRate = TotRate / TotArea;
// cout << NormalizedRate << endl;
string zone = argv[1];
string RollID = argv[4];
int Sector = atoi(argv[3]);
int WheelDiskNo = atoi(argv[2]);
if (TotRate != 0 && TotArea != 0 && currentRun->getDelivered() != 0 && currentRun->isFilled()){
// currentRun->PrintStatistics();
cout << currentRun->getID() <<
"\t" << currentRun->getLumiSection() << "\t" << currentRun->getDelivered()
<< "\t" << currentRun->getLumi() <<
"\t" << TotRate << "\t" << TotArea << "\t" << NormalizedRate/2 << endl;
// plot->SetBinContent(plot->FindBin(currentRun->getLumi()), NormalizedRate);
cout << "POINT: " << k << " " << currentRun->getLumi()<< " " << NormalizedRate / 2 << endl;;
plot->SetPoint(k , currentRun->getLumi(), NormalizedRate / 2);
plotRun->SetPoint(k, currentRun->getID(), NormalizedRate / 2);
k++;
}
}
delete currentRun;
contFile->Close();
contFile->Delete();
}
plot->SetDrawOption("P");
f->WriteObject(plotRun, plotRun->GetName());
f->WriteObject(plot, plot->GetName());
return 0;
}
