void testMergeCont()
{
// Macro to test merging of containers.
gROOT->LoadMacro("$ROOTSYS/tutorials/hsimple.C");
TList *list = (TList *)GetCollection();
TList *inputs = new TList();
for (Int_t i=0; i<10; i++) {
inputs->AddAt(GetCollection(),0);
list->Merge(inputs);
inputs->Delete();
f->Close();
}
delete inputs;
TH1F *hpx = (TH1F*)(((TList*)list->At(1))->At(0));
printf("============================================\n");
printf("Total hpx: %d entries\n", (int)hpx->GetEntries());
hpx->Draw();
list->Delete();
delete list;
}
void KVNameValueList::ClearSelection(TRegexp& sel)
{
// Remove from list all parameters whose name matches the regular expression
// Examples:
// remove all parameters starting with "toto": TRegexp sel("^toto")
// remove all parameters with "toto" in name: TRegexp sel("toto")
TList toBeRemoved;
Int_t np1 = GetNpar();
for (Int_t ii = 0; ii < np1; ii += 1) {
TString name = GetParameter(ii)->GetName();
if (name.Contains(sel)) toBeRemoved.Add(new TNamed(name.Data(), ""));
}
if (toBeRemoved.GetEntries()) {
TIter next(&toBeRemoved);
TNamed* tbr;
while ((tbr = (TNamed*)next())) RemoveParameter(tbr->GetName());
toBeRemoved.Delete();
}
}
void AnalyzeData(char *DataFile = "drs4_peds_5buffers.dat", Int_t nevt,
Int_t startEv = 1, char *PedFile, Int_t DrawExtraGraphs = 0) {
// Redefine DOMINO Depth in ADC counts
const Float_t DominoDepthADC = pow(2, DOMINO_DEPTH);
// open file
FILE *fdata = OpenDataFile(DataFile);
struct channel_struct *p;
struct channel_struct *dep;
// create histograms
// create list of histograms for channels and distribution
TList *DistChList = new TList();
TH1F *distch; // histo with distribution of cell-charge, for each channel
TList *DistChSubList = new TList();
TH1F *distchsub; // histo with distribution of cell-charge, pedestals subtracted, for each channel
TList *DistCh0SubList = new TList();
TH1F *distch0sub; // histo with distribution of cell-charge, pedestals subtracted,
// channel 0 subtracted for each channel
TList *grPedList = new TList();
TGraphErrors *grPed; // for each channel, pedestal value and RMS for each cell is plotted
TList *hCellList = new TList();
TH1F *hCell; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos)
TList *hCellSubList = new TList();
TH1F *hCellSub; // charge distribution for each cell (DOMINO_NCELL x DOMINO_NCH histos), pedestal subtracted
TList *hRMSList = new TList();
TH1F *hRMSdist; // histo with RMS distribution (statistical RMS of distribution)
TList *hRMSFitList = new TList();
TH1F *hRMSFitdist; // histo with RMS distribution (RMS of Gaussian fit)
TList *grDataList = new TList();
TGraphErrors *grData; // charge-cell and RMS for each cell is plotted
TList *grDataSubList = new TList();
TGraphErrors *grDataSub; // pedestal subtracted charge-cell and RMS for each cell is plotted
for (int h = 0; h < DOMINO_NCH; h++) {
//
TString title = "Data Dist channel";
title += h;
distch = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC);
DistChList->Add(distch);
//
TString title = "Data Dist Ped Sub channel";
title += h;
distchsub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2);
DistChSubList->Add(distchsub);
//
TString title = "Data Dist Ped Ch0 Sub channel";
title += h;
distch0sub = new TH1F(title, title, DominoDepthADC, -DominoDepthADC/2, DominoDepthADC/2);
DistCh0SubList->Add(distch0sub);
//
TString title = "Pedestal ch";
title += h;
grPed = new TGraphErrors(DOMINO_NCELL);
grPed->SetTitle(title);
grPedList->Add(grPed);
//
TString title = "Data ch";
title += h;
grData = new TGraphErrors(DOMINO_NCELL);
grData->SetTitle(title);
grDataList->Add(grData);
//
// Mean data and RMS for each channel and cell
TString title = "Data PedSubtracted ch";
title += h;
grDataSub = new TGraphErrors(DOMINO_NCELL);
grDataSub->SetTitle(title);
grDataSubList->Add(grDataSub);
//
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
// data distribution histos
TString title = "Data ch";
title += h;
title += " cell";
title += ch;
hCell = new TH1F(title, title, DominoDepthADC, 0., DominoDepthADC);
hCellList->Add(hCell);
// data (ped subtracted) distribution histos
TString title = "Data PedSub ch";
title += h;
title += " cell ";
title += ch;
hCellSub = new TH1F(title, title, 2 * DominoDepthADC, -1
* DominoDepthADC, DominoDepthADC);
hCellSubList->Add(hCellSub);
}
// Data-RMS distribution histos
TString title = "RMSDist channel";
title += h;
hRMSdist = new TH1F(title, title, 100, 0, 20.);
hRMSList->Add(hRMSdist);
// Data-RMS (calculated through a fit) distribution histos
TString title = "RMSFitDist channel";
title += h;
hRMSFitdist = new TH1F(title, title, 100, 0, 20.);
hRMSFitList->Add(hRMSFitdist);
}
//--------------
//
// calculate or read pedestals from file
grPedList = OpenPedestals(PedFile);
// return;
//
// ====== Read data file and subtract the pedestals
//
// Count number of events in data file
int nevtDataMax = 0;
while (!feof(fdata)) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
nevtDataMax++;
}
printf("nevtDataMax: %d\n", nevtDataMax);
if (nevt > (nevtDataMax - startEv) || nevt == 0)
nevt = nevtDataMax - startEv;
cout << endl << "==>> Processing " << nevt << " events from file "
<< DataFile << endl;
rewind(fdata);
Int_t ievt = 1;
// go to first event (startEv)
while (ievt < startEv) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
if (feof(fdata))
break;
ievt++;
}
// filling
ievt = 1;
Int_t flagEnd = 0;
Double_t chtmp;
Double_t PedVal, itmp, Ch0Val;
// loop on events
cout << endl << " --- read DATA file:" << fdata << endl;
while (ievt <= nevt && !flagEnd) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
if (feof(fdata))
flagEnd = 1;
if (ievt % (nevt / 10 + 1) == 0)
cout << "*" << endl;
p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data
dep = (struct channel_struct *) &event_data.ch[1]; // read bunch of data
TGraphErrors *grCh0 = new TGraphErrors(DOMINO_NCELL);
// loop on channels
for (int h = 0; h < DOMINO_NCH; h++) {
// loop on cells
distch = (TH1F *) DistChList->At(h);
distchsub = (TH1F *) DistChSubList->At(h);
grPed = (TGraphErrors *) grPedList->At(h);
distch0sub = (TH1F *) DistCh0SubList->At(h);
if(h==0) {
for(i = 0; i < DOMINO_NCELL;i++) {
grPed->GetPoint(i, itmp, PedVal);
chtmp = (Double_t)(p->data[i]);
chtmp = chtmp - PedVal;
grCh0->SetPoint(i,itmp, chtmp);
}
}
for (int i = 0; i < DOMINO_NCELL; i++) {
// Read pedestal value for this cell
grPed->GetPoint(i, itmp, PedVal);
grCh0->GetPoint(i, itmp, Ch0Val);
// cout << itmp << ", " << PedVal << endl;
// Read calibration correction for this cell
// CalFact =
//charge distribution for each cell, pedestal subtracted
chtmp = (Double_t)(p->data[i]); // data value
// cout << "tcell, tcell, depth: " << chtmp << "," << p->data[i] << "," << deptmp << endl;
distch->Fill(chtmp);
// Check data value: must be within DOMINO Depth
// if(chtmp > DominoDepthADC)
// cout << " === WARNING!!! Channel " << h << " Cell " << i << " has value " << chtmp << endl;
// cout << "Charge: " << p->data[i] << endl;
((TH1 *) hCellList->At(h * DOMINO_NCELL + i))->Fill(chtmp);
// Now the pedestal is subtracted
chtmp = chtmp - PedVal;
distchsub->Fill(chtmp);
((TH1 *) hCellSubList->At(h * DOMINO_NCELL + i))->Fill(chtmp);
chtmp = chtmp - Ch0Val;
distch0sub->Fill(chtmp);
}
p++; // next channel
}
ievt++; // next event
}
cout << endl;
// now mean and RMS for each cell are computed and save in histos and graphs
cout << " --- filling data histos and grphs " << endl;
TF1 *fgauss = new TF1("fgauss", Gauss, -10., 10., 3);
fgauss->SetParLimits(0, 0.1, 10000.);
fgauss->SetParLimits(1, 0., 4096.);
fgauss->SetParLimits(2, 0.1, 20.);
Float_t mean, rms, meansub, rmssub;
for (int h = 0; h < DOMINO_NCH; h++) {
// for (int h=5; h<6; h++){
cout << " Channel:" << h << endl;
hRMSdist = (TH1F *) hRMSList->At(h);
hRMSFitdist = (TH1F *) hRMSFitList->At(h);
grData = (TGraphErrors *) grDataList->At(h);
grDataSub = (TGraphErrors *) grDataSubList->At(h);
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
// data distribution histos
// cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<<hCell->GetMean()<< "," << hCell->GetRMS()<<endl;
hCell = (TH1F *) hCellList->At(h * DOMINO_NCELL + ch);
mean = hCell->GetMean();
rms = hCell->GetRMS();
hCellSub = (TH1F *) hCellSubList->At(h * DOMINO_NCELL + ch);
meansub = hCellSub->GetMean();
rmssub = hCellSub->GetRMS();
fgauss->SetParameter(0, (Double_t) nevt / 4.);
fgauss->SetParameter(1, mean);
fgauss->SetParameter(2, rms);
// hCell->Fit("fgauss","QN0");
grData->SetPoint(ch, ch, mean);
grData->SetPointError(ch, 0, rms);
grDataSub->SetPoint(ch, ch, meansub);
// grDataSub->SetPointError(ch,0.5,rmssub);
grDataSub->SetPointError(ch, 0.5, 2.1);
hRMSdist->Fill(rms);
hRMSFitdist->Fill(fgauss->GetParameter(2));
// cout << "cell:" << ch << " index:" << h*DOMINO_NCELL+ch << " Mean,RMS:"<< mean << "," << rms<<endl;
}
}
Double_t x, y, chtmp, x1, x2, y1, y2;
/*TList *grCellCalibList = OpenCalibFile("CalibrationData1000events.root");
TGraphErrors *grCellCalib;
TGraphErrors *grDataSubCalib = new TGraphErrors(DOMINO_NCELL);
grDataSubCalib->SetTitle("Data after calibration correction");
grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel);
for(ch = 0; ch < DOMINO_NCELL; ch++) {
grCellCalib = ((TGraphErrors *) grCellCalibList->At(ch));
grCellCalib->Fit("pol3", "Q");
TF1 *pol3fit = ((TF1 *) grCellCalib->GetFunction("pol3"));
grDataSub->GetPoint(ch, x, y);
chtmp = y - (Double_t)(pol3fit->Eval(y/3.25));
grDataSubCalib->SetPoint(ch, x, chtmp);
}
TCanvas *cGrTest = new TCanvas("grTest", "test per vedere i dati", 1000,1000);
grDataSubCalib->Draw("APEL");*/
TString Title = "Charge Distribution per channel";
gStyle->SetOptFit(111);
TCanvas *cdistch = new TCanvas("cdistch", Title, 1000, 1000);
cdistch->Divide(3, 3);
for (int i = 0; i < DOMINO_NCH; i++) {
cdistch->cd(i + 1);
TH1 *dhist = (TH1 *) DistChList->At(i);
dhist->DrawCopy();
dhist->SetLineWidth(1);
dhist->Fit("gaus", "Q");
dhist->GetFunction("gaus")->SetLineColor(4);
dhist->GetFunction("gaus")->SetLineWidth(2);
}
TString Title = "Charge Distribution Pedestals Subtracted per channel";
TCanvas *cdistchsub = new TCanvas("cdistchsub", Title, 1000, 1000);
cdistchsub->Divide(3, 3);
for (int i = 0; i < DOMINO_NCH; i++) {
cdistchsub->cd(i + 1);
TH1 *dsubhist = (TH1 *) DistChSubList->At(i);
dsubhist->DrawCopy();
dsubhist->SetLineWidth(1);
dsubhist->Fit("gaus", "Q");
dsubhist->GetFunction("gaus")->SetLineColor(4);
dsubhist->GetFunction("gaus")->SetLineWidth(2);
}
TString Title = "Charge Distribution Pedestals and Ch0 Subtracted per channel";
TCanvas *cdistch0sub = new TCanvas("cdistch0sub", Title, 1000, 1000);
cdistch0sub->Divide(3, 3);
for (int i = 0; i < DOMINO_NCH; i++) {
cdistch0sub->cd(i + 1);
TH1 *dch0subhist = (TH1 *) DistCh0SubList->At(i);
dch0subhist->DrawCopy();
dch0subhist->SetLineWidth(1);
dch0subhist->Fit("gaus", "Q");
dch0subhist->GetFunction("gaus")->SetLineColor(4);
dch0subhist->GetFunction("gaus")->SetLineWidth(2);
}
TCanvas *cDataSubTest = new TCanvas("cDataSubTest", "Data after pedestal subtraction", 1000, 1000);
cDataSubTest->Divide(1,8);
for (h = 0; h< DOMINO_NCH; h++) {
grDataSub = (TGraphErrors *) grDataSubList->At(h);
cDataSubTest->cd(h+1);
grDataSub->GetYaxis()->SetLabelSize(0.06);
grDataSub->GetXaxis()->SetLabelSize(0.06);
grDataSub->Draw("APE");
}
TCanvas *cDataSubTestCh5 = new TCanvas("cDataSubTestCh5", "Data after pedestal subtraction Ch5", 1200, 800);
grDataSub = (TGraphErrors *) grDataSubList->At(anaChannel);
grDataSub->GetYaxis()->SetLabelSize(0.06);
grDataSub->GetYaxis()->SetTitle("ADC Counts");
grDataSub->GetXaxis()->SetTitle("Cell");
grDataSub->GetXaxis()->SetLabelSize(0.06);
TLine *refval = new TLine(0,350,1024,350);
refval->SetLineWidth(3);
refval->SetLineStyle(2);
refval->SetLineColor(2);
TLine *i1 = new TLine(121,-50,121,800);
i1->SetLineStyle(2);
TLine *i2 = new TLine(291,-50,291,800);
i2->SetLineStyle(2);
TLine *i3 = new TLine(461,-50,461,800);
i3->SetLineStyle(2);
TLine *i4 = new TLine(632,-50,632,800);
i4->SetLineStyle(2);
TLine *i5 = new TLine(803,-50,803,800);
i5->SetLineStyle(2);
TLine *i6 = new TLine(975,-50,975,800);
i6->SetLineStyle(2);
TLine *ireal1 = new TLine(121+20,600,121+20,800);
ireal1->SetLineWidth(3);
ireal1->SetLineColor(4);
TLine *ireal2 = new TLine(291-20,600,291-20,800);
ireal2->SetLineWidth(3);
ireal2->SetLineColor(4);
TLine *ireal3 = new TLine(461+20,600,461+20,800);
ireal3->SetLineWidth(3);
ireal3->SetLineColor(4);
TLine *ireal4 = new TLine(632-20,600,632-20,800);
ireal4->SetLineWidth(3);
ireal4->SetLineColor(4);
TLine *ireal5 = new TLine(803+20,600,803+20,800);
ireal5->SetLineWidth(3);
ireal5->SetLineColor(4);
TLine *ireal6 = new TLine(975-20,600,975-20,800);
ireal6->SetLineWidth(3);
ireal6->SetLineColor(4);
grDataSub->Draw("APE");
refval->Draw("SAME");
i1->Draw("SAME");
i2->Draw("SAME");
i3->Draw("SAME");
i4->Draw("SAME");
i5->Draw("SAME");
i6->Draw("SAME");
ireal1->Draw("SAME");
ireal2->Draw("SAME");
ireal3->Draw("SAME");
ireal4->Draw("SAME");
ireal5->Draw("SAME");
ireal6->Draw("SAME");
TCanvas *cDataTest = new TCanvas("cDataTest", "Raw Data", 1000,1000);
cDataTest->Divide(1,8);
for(h = 0; h < DOMINO_NCH; h++) {
cDataTest->cd(h+1);
grData = (TGraphErrors *) grDataList->At(h);
grData->SetMarkerStyle(20);
grData->SetMarkerSize(0.5);
grData->Draw("APE");
}
// save root file with graph containing channel 5 data after pedestals subtraction.
/*
cout << "test" << endl;
TString OutFile = DataSubFile;
TFile *f = new TFile(OutFile,"RECREATE");
int h = anaChannel;
TString key="DataSubGraph";
key += h;
((TGraphErrors*)grDataSubList->At(h))->Write(key);
f->Close();
cout << " ---- Write data on file " << endl;
*/
// =======================================================//
// =====================Matteo's Code=====================//
// =======================================================//
/*
Int_t cht, incCht, decCht, xflag, nPeriods, iMax, iMin;
Double_t xdiff, incDiff, decDiff, incDiffTemp, decDiffTemp, incXDiff, decXDiff;
Double_t fitMax, fitMin, fitPeriod, chisquare;
Double_t DominoXval[DOMINO_NCELL];
Double_t DominoYval[DOMINO_NCELL];
Double_t FitXval[DOMINO_NCELL];
Double_t FitYval[DOMINO_NCELL];
// opens grDataSub.root
TString FileName = DataSubFile;
TGraphErrors *grDataSub;
int h = anaChannel;
TFile *f = new TFile(FileName);
TString key = "DataSubGraph";
key += h;
grDataSub = (TGraphErrors *) f->Get(key);
f->Close();
// Create a new graph with channel 5 data
TGraphErrors *grDataSubAnaCh;
int h = anaChannel;
grDataSubAnaCh = (TGraphErrors *) grDataSubList->At(h);
TGraphErrors *grDataSubFix = grDataSubAnaCh->Clone();
TGraphErrors *grRes = new TGraphErrors(DOMINO_NCELL);
TList *grResPeriodList = new TList();
Double_t xtemp, ytemp, DominoMax, DominoMin;
for (int ch = 0; ch < DOMINO_NCELL; ch++){
// get domino-output point and save in array
grDataSubAnaCh->GetPoint(ch, DominoXval[ch], DominoYval[ch]);
}
// find the domino point with max y-value
iMax = 0;
for(int ch = 0; ch < DOMINO_NCELL; ch++) {
if(DominoYval[ch] > DominoYval[iMax]) {
DominoMax = DominoYval[ch];
iMax = ch;
}
}
cout << "DominoMax e': " << DominoMax << endl;
// find the domino point with min y-value
iMin = 0;
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
if(DominoYval[ch] < DominoYval[iMin]) {
DominoMin = DominoYval[ch];
iMin = ch;
}
}
cout << "DominoMin e': " << DominoMin << endl;
// remove points from the graph that will be used for fit
for (int ch = 0; ch < DOMINO_NCELL; ch++){
grDataSubFix->GetPoint(ch, xtemp, ytemp);
if(ytemp > 0.8*DominoMax || ytemp < 0.2*DominoMin)
grDataSubFix->RemovePoint(ch);
}
TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4);
fsin->SetParameters(600., DOMINO_NCELL / 4., 150., 150.);
fsin->SetParNames("amplitude", "Period", "Phase", "DC-Offset");
grDataSubFix->Fit("fsin");
TF1 *fsinFit = grDataSubFix->GetFunction("fsin");
fsinFit->SetParNames("amplitude", "Period", "Phase", "DC-Offset");
chisquare = grDataSub->Chisquare(fsinFit);
cout << "il chi quadro della funzione di fit e' : " << chisquare << endl;
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
// get Fit-value and save in array
FitXval[ch] = DominoXval[ch];
FitYval[ch] = fsinFit->Eval(FitXval[ch]);
}
fitPeriod = fsinFit->GetParameter("Period");
cout << "il periodo della funzione e': " << fitPeriod << endl;
nPeriods = (Int_t) (DOMINO_NCELL/fitPeriod);
cout << "il numero di periodi della funzione e': " << nPeriods << endl;
fitMax = fsinFit->GetMaximum();
cout << "il massimo della funzione e': " << fitMax << endl;
fitMin = fsinFit->GetMinimum();
cout << "il minimo della funzione e': " << fitMin << endl;
// computes the y difference between the ch-domino point and the i-fit point
// and stops when the difference changes sign
//
// first and last points are not included in the cicle
//
// if the fit point y-value is bigger or smaller than the fit function max*0.8 or min*0.2
// the point is removed
for (int ch = 1; ch < DOMINO_NCELL - 1; ch++) {
if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) {
grRes->RemovePoint(ch);
continue;
}
incDiff = DominoYval[ch] - FitYval[ch];
incDiffTemp = DominoYval[ch] - FitYval[ch + 1];
decDiff = DominoYval[ch] - FitYval[ch];
decDiffTemp = DominoYval[ch] - FitYval[ch - 1];
if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) {
for (int i = ch; i < DOMINO_NCELL; i++, incDiff = incDiffTemp) {
incDiffTemp = DominoYval[ch] - FitYval[i];
if (sign(incDiff) != sign(incDiffTemp)) {
if(abs(incDiffTemp) < abs(incDiff))
incCht = i;
else
incCht = i - 1;
break;
}
}
xflag = 1;
}
else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) {
for (int j = ch; j >= 0 ; j--, decDiff = decDiffTemp) {
decDiffTemp = DominoYval[ch] - FitYval[j];
if (sign(decDiff) != sign(decDiffTemp)) {
if(abs(decDiffTemp) < abs(decDiff))
decCht = j;
else
decCht = j + 1;
break;
}
}
xflag = -1;
}
if(xflag == 1)
xdiff = FitXval[incCht] - DominoXval[ch];
else
xdiff = FitXval[decCht] - DominoXval[ch];
grRes->SetPoint(ch, (Double_t) ch, xdiff);
}
cout << "Draw Time Residuals" << endl;
TString Title = "Time Residuals";
TCanvas *timeres = new TCanvas("timeres", Title, 1200, 780);
grRes->SetMarkerStyle(20);
grRes->SetMarkerSize(0.3);
grRes->GetYaxis()->SetLabelSize(0.12);
grRes->GetXaxis()->SetLabelSize(0.12);
grRes->Draw("APE");
// The previous graph is now split in N graphs, where N is the number of fit periods
// this will be needed to set the function phase
//
// iMax = 0;
//
// for(ch = 0; ch < fitPeriod - 1; ch++) {
// if(FitYval[ch] > FitYval[iMax]) iMax = ch;
// }
cout << "il primo massimo ha l'indice : " << iMax << endl;
for (i = 0; i < nPeriods; i++) {
TGraphErrors *grResPeriod = new TGraphErrors((Int_t) fitPeriod);
grResPeriodList->Add(grResPeriod);
for(ch = i*fitPeriod + 1; ch < fitPeriod + (i*fitPeriod); ch++) {
if(FitYval[ch] > 0.8*fitMax || FitYval[ch] < 0.2*fitMin) {
grResPeriod->RemovePoint(ch);
continue;
}
incDiff = DominoYval[ch] - FitYval[ch];
incDiffTemp = DominoYval[ch] - FitYval[ch + 1];
decDiff = DominoYval[ch] - FitYval[ch];
decDiffTemp = DominoYval[ch] - FitYval[ch - 1];
if(abs(incDiffTemp) < abs(incDiff) || (sign(incDiff) != sign(incDiffTemp) && abs(decDiffTemp) > abs(decDiff))) {
for (int k = ch; k < k*fitPeriod + fitPeriod; k++, incDiff = incDiffTemp) {
incDiffTemp = DominoYval[ch] - FitYval[k];
if (sign(incDiff) != sign(incDiffTemp)) {
if(abs(incDiffTemp) < abs(incDiff))
incCht = k;
else
incCht = k - 1;
break;
}
}
xflag = 1;
}
else if(abs(decDiffTemp) < abs(decDiff) || (sign(decDiff) != sign(decDiffTemp) && abs(incDiffTemp) > abs(incDiff))) {
for (int j = ch; j > i*fitPeriod; j--, decDiff = decDiffTemp) {
decDiffTemp = DominoYval[ch] - FitYval[j];
if (sign(decDiff) != sign(decDiffTemp)) {
if(abs(decDiffTemp) < abs(decDiff))
decCht = j;
else
decCht = j + 1;
break;
}
}
xflag = -1;
}
if(xflag == 1)
xdiff = FitXval[incCht] - DominoXval[ch];
else
xdiff = FitXval[decCht] - DominoXval[ch];
grResPeriod->SetPoint(ch - i*fitPeriod, (Double_t) (ch - i*fitPeriod), xdiff);
}
}
TCanvas *timeresperiod = new TCanvas("timeresperiod", "Time Residuals Period", 1200, 780);
for(i = 0; i < nPeriods; i++) {
grResPeriod = ((TGraphErrors *) grResPeriodList->At(i));
grResPeriod->SetMarkerStyle(20);
grResPeriod->SetMarkerSize(0.3);
grResPeriod->GetYaxis()->SetLabelSize(0.12);
grResPeriod->GetXaxis()->SetLabelSize(0.12);
grResPeriod->Draw("APEsame");
}
cout << "Draw Data - Pedestals Subtracted" << endl;
TString Title = "Average Charge - Pedestal subtracted";
TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780);
grDataSubAnaCh->SetMarkerStyle(20);
grDataSubAnaCh->SetMarkerSize(0.3);
grDataSubAnaCh->GetYaxis()->SetLabelSize(0.12);
grDataSubAnaCh->GetXaxis()->SetLabelSize(0.12);
grDataSubAnaCh->Draw("APE");
fsinFit->Draw("same");
*/
// draw extra graphs
if (DrawExtraGraphs == 1) {
cout << " ----- DRAW Results ------" << endl;
//================ DRAW Results ==================
TCanvas *c = new TCanvas("ctmp", "test", 800, 800);
c->Divide(3, 3);
for (int pad = 1; pad < 10; pad++) {
c->cd(pad);
((TH1 *) hCellList->At(pad * 512 + 219))->DrawCopy();
hCellSub = (TH1F *) hCellSubList->At(pad * 512 + 219);
hCellSub->SetLineColor(2);
hCellSub->DrawCopy("same");
}
cout << "Draw RMS distributions" << endl;
TString Title = "RMS distributions per channel";
TCanvas *c4 = new TCanvas("c4", Title, 700, 700);
c4->Divide(3, 3);
for (int i = 0; i < DOMINO_NCH; i++) {
c4->cd(i + 2);
hRMSdist = (TH1F *) hRMSList->At(i);
hRMSFitdist = (TH1F *) hRMSFitList->At(i);
hRMSFitdist->SetLineColor(2);
hRMSFitdist->DrawCopy();
hRMSdist->DrawCopy("same");
}
TList *grDataCh0SubList = new TList();
TGraphErrors *grDataCh0Sub;
for(h = 0; h< DOMINO_NCELL; h++) {
grDataCh0Sub = new TGraphErrors(DOMINO_NCELL);
grDataCh0SubList->Add(grDataCh0Sub);
}
TGraphErrors *grDataSubCh0 = (TGraphErrors *) grDataSubList->At(6);
for(h = 0; h < DOMINO_NCH; h++) {
grDataSub = (TGraphErrors *) grDataSubList->At(h);
grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h);
for(ch = 0; ch < DOMINO_NCELL; ch++) {
grDataSubCh0->GetPoint(ch, x1, y1);
grDataSub->GetPoint(ch, x2, y2);
grDataCh0Sub->SetPoint(ch, x1 , y2 - y1);
}
}
TCanvas *cDataCH0Sub = new TCanvas("cDataCH0Sub","cDataCH0Sub", 1000,1000);
cDataCH0Sub->Divide(1,8);
for(h = 0; h < DOMINO_NCH; h++) {
cDataCH0Sub->cd(h+1);
grDataCh0Sub = (TGraphErrors *) grDataCh0SubList->At(h);
grDataCh0Sub->GetYaxis()->SetLabelSize(0.12);
grDataCh0Sub->GetXaxis()->SetLabelSize(0.12);
grDataCh0Sub->Draw("APEL");
}
cout << "Draw Data - Pedestals Subtracted" << endl;
TString Title = "Average Charge - Pedestal subtracted";
TCanvas *csubdata = new TCanvas("csubdata", Title, 1000, 1000);
csubdata->Divide(3,3);
for(h = 0; h < DOMINO_NCH; h++) {
csubdata->cd(h+1);
TString title = "DataSub channel ";
title += h;
TH1F *hCellDataSub = new TH1F(title, title, 100, -20, 20);
grDataSub = (TGraphErrors *) grDataSubList->At(h);
for(ch = 0; ch < DOMINO_NCELL; ch++) {
grDataSub->GetPoint(ch, x, y);
hCellDataSub->Fill(y);
}
hCellDataSub->Fit("gaus", "Q");
hCellDataSub->GetXaxis()->SetTitle("ADC Counts");
hCellDataSub->GetFunction("gaus")->SetLineColor(4);
hCellDataSub->DrawCopy();
}
cout << "breakpoint" << endl;
TCanvas *csubdata2 = new TCanvas("csubdata2", "DataSub for every channel", 1000, 1000);
TString title = "DataSub every channel ";
TH1F *hCellChDataSubTot = new TH1F(title, title, 100, -20, 20);
for(h = 0; h < DOMINO_NCH; h++) {
grDataSub = (TGraphErrors *) grDataSubList->At(h);
for(ch = 0; ch < DOMINO_NCELL; ch++) {
grDataSub->GetPoint(ch, x, y);
hCellChDataSubTot->Fill(y);
}
hCellChDataSubTot->Fit("gaus", "Q");
hCellChDataSubTot->GetXaxis()->SetTitle("ADC Counts");
hCellChDataSubTot->GetFunction("gaus")->SetLineColor(4);
hCellChDataSubTot->Draw();
}
cout << "Draw Pedestals" << endl;
TString Title = "Pedestals";
TCanvas *c2 = new TCanvas("c2", Title, 1050, 780);
c2->SetBorderMode(0);
c2->SetBorderSize(0.);
c2->Divide(1, 8);
// gStyle->SetCanvasBorderMode(0.);
// gStyle->SetCanvasBorderSize(0.);
Double_t x, y;
for (int h = 0; h < DOMINO_NCH; h++) {
c2->cd(h + 1);
grPed = ((TGraphErrors *) grPedList->At(h));
grPed->SetMarkerStyle(20);
grPed->SetMarkerSize(0.5);
grPed->GetYaxis()->SetLabelSize(0.12);
grPed->GetXaxis()->SetLabelSize(0.12);
// cout << " err:" << grPed->GetErrorY(102) << " " ;
// cout << x << "--" << y << endl;
grPed->Draw("APE");
}
cout << "Draw Data - Average charge" << endl;
TString Title = "Average_Charge";
TCanvas *cdata = new TCanvas("cdata", Title, 1050, 780);
cdata->Divide(1, 8);
Double_t x, y;
for (int h = 0; h < DOMINO_NCH; h++) {
cdata->cd(h + 1);
grData = ((TGraphErrors *) grDataList->At(h));
grData->SetMarkerStyle(20);
grData->SetMarkerSize(0.3);
grData->GetYaxis()->SetLabelSize(0.12);
grData->GetXaxis()->SetLabelSize(0.12);
grData->GetPoint(10, x, y);
// cout << x << "-" << y << endl;
grData->Draw("APE");
}
cout << "Draw Data - Pedestals Subtracted" << endl;
TString Title = "Average Charge - Pedestal subtracted";
TCanvas *csubdata = new TCanvas("csubdata", Title, 1200, 780);
csubdata->Divide(1, 8);
TF1 *fsin = new TF1("fsin", sigSin, 0., 1024., 4);
TH1D *resDist = new TH1D("resDist", "Residuals Signal", 100, -100., 100.);
cout << "Draw Data - Pedestals Subtracted" << endl;
TString Title = "Residuals";
TCanvas *residuals = new TCanvas("residuals", Title, 1200, 780);
resDist->DrawCopy();
}
fclose(fdata);
hCellList->Delete();
hCellSubList->Delete();
hRMSList->Delete();
hRMSFitList->Delete();
}
void addhistoEmc(const char* list="list.txt", char *newname=0)
{
// Add histograms from a set of files listed in file list
// and write the result into a new file.
char SumName[20];
if (!newname) {
sprintf(SumName,"Sum_All_Emc.root");
newname=SumName;
printf("\n === Default output file name is %s ===\n",newname);
}
TFile *f=NULL;
TH1F* hst[5][64][56];
TH1F* hadd=NULL;
char hnam[80];
char htit[80];
TList* hlist = 0;
char fpath[80];
int ifscanf=0;
Int_t ifile=0;
for(Int_t iMod=0; iMod<5; iMod++) {
for(Int_t iX=0; iX<64; iX++) {
for(Int_t iZ=0; iZ<56; iZ++) {
sprintf(hnam,"%d_%d_%d",iMod,iX,iZ);
sprintf(htit,"Two-gamma inv. mass for mod %d, cell (%d,%d)",iMod,iX,iZ);
hst[iMod][iX][iZ] = new TH1F(hnam,htit,100,0.,300.);
}
}
}
TH1F* hmgg = new TH1F("hmgg","2-cluster invariant mass",100,0.,300.);
FILE* fd = fopen(list,"r");
while( ifscanf = fscanf(fd,"%s",fpath) != EOF) {
f=new TFile(fpath);
hlist = (TList*)f->Get("histos");
for(Int_t iList=0; iList<hlist->GetEntries(); iList++) {
hadd = (TH1F*)hlist->At(iList);
const char* str = hadd->GetName();
int md,X,Z;
if (sscanf(str,"%d_%d_%d",&md,&X,&Z)) {
hst[md][X][Z]->Add(hadd);
//printf("Added hst[%d][%d][%d]\n",md,X,Z);
}
else {
printf("Trying to add histogram %s to hmgg.\n",hadd->GetName());
hmgg->Add(hadd);
}
}
printf("Deleting list..\n");
hlist->Delete();
printf("OK!\n");
ifile++;
printf("File %s processed.\n",fpath);
if(f) delete f;
}
printf("%d processed.\n",ifile);
TFile outfile(newname,"recreate");
for(Int_t iMod=0; iMod<5; iMod++) {
for(Int_t iX=0; iX<64; iX++) {
for(Int_t iZ=0; iZ<56; iZ++) {
if(hst[iMod][iX][iZ]->GetEntries()) hst[iMod][iX][iZ]->Print();
hst[iMod][iX][iZ]->Write();
}
}
}
hmgg->Write();
outfile.Close();
}
int main(int argc, char *argv[])
{
if (argc != 3 && argc != 4 && argc != 7) {
cout << "Usage: quickDraw path drawstring [selection [nbins xmin xmax]]" << endl;
cout << " will create a file histogram.pdf from the given files" << endl
<< endl;
cout << "path points to a directory containing ROOT files" << endl;
cout << "drawstring is a string usable in TTree::Draw()" << endl;
cout << "selection e.g. (muo_n>0)&&(jet_n>0) or 1. if no selection" << endl;
cout << "nbins number of bins in histogram" << endl;
cout << "xmin low x edge of histogram" << endl;
cout << "xmax high x edge of histogram" << endl;
cout << endl;
cout << "Example: quickDraw ~/data \"muo_pt[0]\" \"(jet_n>2)\" 100 0 1000" << endl;
cout << " will draw muo_pt of the leading muon (index 0) for all events" << endl;
cout << " that contain at least three jets in a histogram with 100 bins," << endl;
cout << " ranging from 0 to 1000 GeV" << endl;
cout << endl;
cout << "Example: quickDraw ~/data vtx_n global_weight" << endl;
cout << " will draw vtx_n for all events in an automatically binned histogram " << endl;
cout << " The histogram weight will be taken from the leaf global_weight for each event" << endl;
exit (1);
}
// Loop over all files in directory <path> and fill
// root file names into list <filelist>
Text_t lpath[strlen(argv[1])+8];
sprintf(lpath, "%s", argv[1]);
Text_t * basepath = gSystem->ExpandPathName(lpath); // delete it later...
void * dirhandle = gSystem->OpenDirectory(basepath);
const Text_t * basename;
if (gLogLevel)
cout << "Reading file names from directory " << basepath << endl;
TList * filelist = new TList;
while ((basename = gSystem->GetDirEntry(dirhandle))) {
// Skip non-ROOT files
if (!strstr(basename, ".root"))
continue;
Text_t * fullname = new Text_t[strlen(basepath)+strlen(basename)+2];
strcpy(fullname, basepath);
strcat(fullname, "/");
strcat(fullname, basename);
filelist->Add(new TObjString(fullname));
delete fullname;
}
// check if we have read some files
if (filelist->GetSize() < 1) {
cerr << "ERR: No *.root files available in " << basepath << " Exiting. " << endl;
exit(EXIT_FAILURE);
}
// Add all root files to a TChain
if (gLogLevel)
cout << "Adding files to TChain" << endl;
TChain * chain = new TChain("ACSkimAnalysis/allData");
TIter next(filelist);
while (TObjString * obj = (TObjString *) next()) {
chain->Add(obj->GetString());
if (gLogLevel > 3)
cout << "FILE: " << obj->GetString() << " added to TChain" << endl;
}
// Delete all filelist elements and the list itself
// (They are not deleted automatically when the TList is deleted!!!)
filelist->Delete();
delete filelist;
delete basepath;
long int events_from_tree = chain->GetEntries();
cout << "Found a total of " << events_from_tree << " events in chain" << endl;
gROOT->SetBatch();
TCanvas * c1 = new TCanvas();
TFile * f = new TFile("histo.root", "RECREATE");
Int_t nbins = 200;
double xmin = 0;
double xmax = 1;
if (argc == 7) {
nbins = atoi(argv[4]);
xmin = atof(argv[5]);
xmax = atof(argv[6]);
}
TH1D * h1 = new TH1D("h1", argv[2], nbins, xmin, xmax);
if (argc < 5) {
h1->SetBit(TH1::kCanRebin);
}
const char * selection = "1.";
if (argc >= 4)
selection = argv[3];
chain->Draw(Form("%s>>h1", argv[2]), selection);
h1->Draw();
c1->Print("histo.pdf");
f->Write();
f->Close();
delete f;
return 0;
}
void scanDirectory(const char *dirname)
{
TDirectoryIter iter(dirname);
const char *filename = 0;
TString ent;
TString file;
TString html;
html.Form(gPreamble,dirname,dirname);
TList dirList;
TList fileList;
while( (filename=iter.Next()) )
{
if (filename[0]!='.') {
ent.Form("%s/%s", dirname, filename);
FileStat_t st;
gSystem->GetPathInfo(ent.Data(), st);
if (R_ISDIR(st.fMode)) {
//fprintf(stderr,"Seeing directory %s\n",ent.Data());
scanDirectory(ent.Data());
dirList.Add(new TObjString(filename));
} else {
size_t len = strlen(filename);
if (len > 8 && strncmp(filename,"pt_",3)==0 && strncmp(filename+len-5,".root",5)==0) {
//fprintf(stderr,"Seeing file %s\n",ent.Data());
file = filename;
file[len-5]='\0';
fileList.Add(new TObjString(file));
}
}
}
}
dirList.Sort();
fileList.Sort();
TIter next(&dirList);
TObjString *obj;
html += "<table width=\"500\">\n";
html += gLine;
html += gParentDir;
while ( (obj = (TObjString*)next()) ) {
html += TString::Format(gDirFmt,obj->GetName(),obj->GetName());
}
html += gLine;
if (!fileList.IsEmpty()) {
next = &fileList;
while ( (obj = (TObjString*)next()) ) {
html += "<tr>";
html += TString::Format(gFiles,obj->GetName(),obj->GetName(),obj->GetName(),obj->GetName());
obj = (TObjString*)next();
if (obj) {
html += TString::Format(gFiles,obj->GetName(),obj->GetName(),obj->GetName(),obj->GetName());
} else {
html += "<td></td></tr>";
break;
}
}
html += gLine;
}
html += "</table>\n";
dirList.Delete();
fileList.Delete();
html += "</body>\n";
html += "</html>\n";
ent.Form("%s/pt_index.html",dirname);
FILE *output = fopen(ent.Data(),"w");
fprintf(output,"%s",html.Data());
fclose(output);
}
void CalibrateData(Int_t nevt,Int_t startEv = 1, char *PedFile = "drs4_20100311_t_ped.root") {
// create progress bar
TGHProgressBar *gProgress = ProgressBar("Calibrazione dati");
// Redefine DOMINO Depth in ADC counts
const Float_t DominoDepthADC = pow(2, DOMINO_DEPTH);
// create list of histograms for pedestals
TList *grPedList = new TList();
TGraphErrors *grPed;
// create list of histograms for channels
TList *hCellCalibList = new TList();
TH1F *hCellCalib;
TList *grCellCalibList = new TList();
TGraphErrors *grCellCalib;
int mV[NCALIBFILES] = {-500,-400,-300,-200,-100,0,100,200,300,400,500};
/*for (int iFile = 0; iFile < NCALIBFILES; iFile++) {
mV[iFile] = mVStart;
mVStart += mVStep;
}*/
char *calibrationFile;
char *calibrationFileArray[NCALIBFILES];
calibrationFileArray[0] = "drs4_1000ev_dcm500mv.dat";
calibrationFileArray[1] = "drs4_1000ev_dcm400mv.dat";
calibrationFileArray[2] = "drs4_1000ev_dcm300mv.dat";
calibrationFileArray[3] = "drs4_1000ev_dcm200mv.dat";
calibrationFileArray[4] = "drs4_1000ev_dcm100mv.dat";
calibrationFileArray[5] = "drs4_1000ev_dc1mv.dat";
calibrationFileArray[6] = "drs4_1000ev_dc100mv.dat";
calibrationFileArray[7] = "drs4_1000ev_dc200mv.dat";
calibrationFileArray[8] = "drs4_1000ev_dc300mv.dat";
calibrationFileArray[9] = "drs4_1000ev_dc400mv.dat";
calibrationFileArray[10] = "drs4_1000ev_dc500mv.dat";
for (int iFile = 0; iFile < NCALIBFILES; iFile++) {
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
//
TString title = "Calibration signal file:";
title += iFile;
title += " ch:";
title += ch;
hCellCalib = new TH1F(title,title, DominoDepthADC, -DominoDepthADC, DominoDepthADC);
hCellCalibList->Add(hCellCalib);
}
}
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
grCellCalib = new TGraphErrors(NCALIBFILES);
grCellCalibList->Add(grCellCalib);
}
// calculate or read pedestals from file
grPedList = OpenPedestals(PedFile);
grPedData = (TGraphErrors *) grPedList->At(anaChannel);
grPedTrig = (TGraphErrors *) grPedList->At(trigChannel);
// create gauss function
TF1 *fgauss = new TF1("fgauss", "TMath::Gaus(x,[0],[1],0)", -DOMINO_NCELL, DOMINO_NCELL);
fgauss->SetParameter(0,0.);
fgauss->SetParameter(1,1.);
fgauss->SetParLimits(0, 0., DominoDepthADC);
fgauss->SetParLimits(1, 0.1, 20.);
TCanvas *ctest = new TCanvas("ChannelTest", "ChannelTest", 800, 600);
ctest->Divide(3, 4);
gProgress->Reset();
gProgress->SetMax(nevt*NCALIBFILES);
gSystem->ProcessEvents();
for (int iFile = 0; iFile < NCALIBFILES; iFile++) {
// open file
calibrationFile = calibrationFileArray[iFile];
FILE *fdata = OpenDataFile(calibrationFile);
struct channel_struct *p;
struct channel_struct *dep;
Double_t refval=0, reftmp = 0;
Double_t PedVal, itmp;
// Count number of events in data file
int nevtDataMax = 0;
while (!feof(fdata)) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
nevtDataMax++;
}
printf("nevtDataMax: %d\n", nevtDataMax);
if (nevt > (nevtDataMax - startEv) || nevt == 0)
nevt = nevtDataMax - startEv;
cout << endl << "==>> Processing " << nevt << " events from file "
<< calibrationFile << endl;
rewind(fdata);
for (int j = 0; j < 1; j++) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data
p += anaChannel;
for (ch = 0; ch < DOMINO_NCELL; ch++) {
grPedData->GetPoint(ch, itmp, PedVal);
reftmp = TMath::Abs((Double_t)(p->data[ch])-PedVal);
if (reftmp > 0.8* refval)
refval = 0.2*reftmp+0.8*refval;
// cout << ch << " " <<p->data[ch] << " " <<reftmp << " " << refval <<endl ;
}
}
cout << "refval="<< refval<<endl;
rewind(fdata);
Int_t ievt = 1;
// go to first event (startEv)
while (ievt < startEv) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
if (feof(fdata))
break;
ievt++;
}
ievt = 1;
Int_t iTrig = 0;
Int_t flagEnd = 0;
Double_t chtmp, chtrig;
Double_t ratio;
Double_t mean, rms;
// loop on events
while (ievt <= nevt && !flagEnd) {
fread((void *) &event_data, 1, sizeof(event_data), fdata);
if (feof(fdata))
flagEnd = 1;
p = (struct channel_struct *) &event_data.ch[0]; // read bunch of data
dep = (struct channel_struct *) &event_data.ch[1]; // read bunch of data
//now anaChannel analysis
p += anaChannel;
// read data, subtract pedestals values and fill hCellCalibList.
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
// Read pedestal value for this cell
grPedData->GetPoint(ch, itmp, PedVal);
chtmp = (Double_t)(p->data[ch]); // data value
chtmp = chtmp - PedVal;
//if (TMath::Abs(chtmp) > 0.9 * refval)
((TH1 *) hCellCalibList->At(iFile*DOMINO_NCELL+ch))->Fill(chtmp);
//cout << ch << " " << iFile << " " << chtmp << endl;
}
gProgress->Increment(1);
gSystem->DispatchOneEvent(kTRUE);
ievt++; // next event
}
TH1 *hCellTmp;
for(ch = 0; ch < DOMINO_NCELL;ch++) {
hCellTmp = ((TH1 *) hCellCalibList->At(iFile*DOMINO_NCELL+ch));
//hCellTmp->Fit("gaus", "Q");
//mean = (hCellTmp->GetFunction("gaus"))->GetParameter(1);
//rms = (hCellTmp->GetFunction("gaus"))->GetParameter(2);
mean = hCellTmp->GetMean();
rms = hCellTmp->GetRMS();
((TGraphErrors *) (grCellCalibList->At(ch)))->SetPoint(iFile, (Double_t) mV[iFile], mean);
((TGraphErrors *) (grCellCalibList->At(ch)))->SetPointError(iFile, 0., rms);
}
ctest->cd(iFile + 1);
hCellTmp = ((TH1 *) hCellCalibList->At(567 + iFile*DOMINO_NCELL));
hCellTmp->Fit("gaus","Q");
hCellTmp->DrawCopy();
}
TString OutFile = "CalibrationDataNew";
OutFile += nevt;
OutFile += "events.root";
TFile *f = new TFile(OutFile, "RECREATE");
for (int ch = 0; ch < DOMINO_NCELL; ch++) {
TString key = "CalibDataCell";
key += ch;
((TGraphErrors*) grCellCalibList->At(ch))->Write(key);
}
f->Close();
hCellCalibList->Delete();
((TGMainFrame *) gProgress->GetParent())->CloseWindow();
fclose(fdata);
}
