//to run in ROOT: .x runD3PDSelector.C
void runGangaTTreeCache() {
cout << "Grid run, TTreeCache Enabled" <<endl;
char *rpath = getenv( "PWD" );
std::string filename = "./input.txt";
if (!( rpath == 0 )) { // if ENV-var not set use default
std::string path(rpath);
filename = path+"/input.txt";
}
cout << "Reading input file "<<filename<<endl;
TChain *c = new TChain("susy");
// TFileCollection* fc = new TFileCollection("mylist", "mylist",filename);
// c->AddFileInfoList((TCollection*)fc->GetList());
std::string argStr;
char *filechar = filename.c_str();
std::ifstream ifs(filechar);
std::vector<std::string> fileList;
// split by '\n'
int nfiles = 0;
while (std::getline(ifs,argStr)) {
for (size_t i=0,n; i <= argStr.length(); i=n+1) {
n = argStr.find_first_of('\n',i);
if (n == std::string::npos)
n = argStr.length();
TString tmp = argStr.substr(i,n-i);//std::string
nfiles++;
cout << "Adding file "<<tmp<<" nb "<<nfiles<<endl;
c->Add(tmp);
}
}
int nentries = c->GetEntries();
std::cout << "Total number of entries in chain (after all the files) " << c->GetEntries() << std::endl;
// GD use TTreeCache (disabled by default in ROOT5.28)
//c->SetCacheSize(100000000);
// GD DO NOT use TTreeCache (enabled by default in ROOT5.26)
c->SetCacheSize(0);
//c->SetProof();
c->Process("D3PDSelector.C+O");
// Create AthSummary.txt for the pilot
ofstream outf("AthSummary.txt");
// outf << "Files read: " << fc->GetNFiles() << std::endl;
outf << "Files read: " << nfiles << std::endl;
outf << "Events Read: " << nentries << std::endl;
outf << "{ \"events\":{\"read\":" << nentries << "} " << "}" << std::endl;
outf.close();
system("cp AthSummary.txt ..");
c->Delete();
cout << "All done, quitting ROOT..."<<endl;
//quit root
gApplication->Terminate();
}
//*******MAIN*******************************************************************
int main (int argc, char** argv)
{
std::cout<<"--------DUMPER TEMPLATE FIT: READ RAW DATA AND PRODUCE RECO TREE--------"<<std::endl;
//-----this map tells how the MCPs will be order in the output tree. The names should match the cfg file----
Fill_MCPList(); //look into the MCPMap.h class
//--------Read Options--------------------------------
ifstream inputCfg (argv[1], ios::in);
std::string inputFolder = argv[2];
int nChannels = atoi (argv[3]);
std::string outputFile = argv[4];
std::string ProMedioFile = argv[5];
TProfile** wf_promed = new TProfile*[10];
TH1F** templateHisto = new TH1F*[10];
double pro_medio_CF[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
double pro_medio_Charge[10] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};
TFile* inF = TFile::Open(ProMedioFile.c_str(),"read");
for(int iCh=0; iCh<10; ++iCh) {
wf_promed[iCh] = (TProfile*)inF->Get(Form("wf_promed_%d",iCh));
wf_promed[iCh]->SetDirectory(0);
}
inF->Close();
inF->Delete();
for(int iCh=0; iCh<10; ++iCh) {
templateHisto[iCh] = new TH1F(Form("templateHisto_%d",iCh), "", 1024, 0., 1024.);
for(int iBins=1; iBins<=1024; ++iBins) {
if(iBins <= 100) templateHisto[iCh]->SetBinContent(iBins, wf_promed[iCh]->GetBinContent(iBins+150));
else if(iBins > 100 && iBins < 250) templateHisto[iCh]->SetBinContent(iBins, templateHisto[iCh]->GetBinContent(iBins-100));
else templateHisto[iCh]->SetBinContent(iBins, wf_promed[iCh]->GetBinContent(iBins));
}
double amp = 0.5;
TimeConstFrac_ProMedio(templateHisto[iCh], amp, pro_medio_CF[iCh]);
pro_medio_Charge[iCh] = templateHisto[iCh]->Integral(pro_medio_CF[iCh]-5, pro_medio_CF[iCh]+20);
wf_promed[iCh]->Delete();
// std::cout << " iCh = " << iCh << " pro_medio_CF[iCh] = " << pro_medio_CF[iCh] << " pro_medio_Charge[iCh] = " << pro_medio_Charge[iCh] << std::endl;
}
// for(int iCh=0; iCh<10; ++iCh) std::cout << " templateHisto[iCh]->GetEntries() = " << templateHisto[iCh]->GetEntries() << std::endl;
// return 500;
//---------output tree----------------
TFile* outROOT = TFile::Open(("ntuples/reco_"+outputFile+".root").c_str(),"recreate");
outROOT->cd();
TTree* outTree = new TTree("reco_tree", "reco_tree");
outTree->SetDirectory(0);
SetOutTree(outTree);
int run=0, chNumber=0, HVtemp=0, PC=0;
float X0temp=0.;
std::string name, trig1, trig2;
//---------definitions-----------
std::map<int, int> PCOn;
std::map<int, int> HVVal;
std::map<int, std::string> MCPName;
int start=0;
//-------start to read the cfg file--------
while(!inputCfg.eof())
{
PCOn.clear();
HVVal.clear();
MCPName.clear();
if (start==0) { //read trigger chambers
inputCfg >> trig1 >> trig2;
start=1;
}
//-----fill maps--------
for (int count=0; count<nChannels; count++) //read exactly nChannels lines of the cfg file -> be careful to give the right number in input!!!!
{
inputCfg >> run >> chNumber >> HVtemp >> X0temp >> PC >> name;
PCOn.insert(std::make_pair(chNumber,PC));
HVVal.insert(std::make_pair(chNumber,HVtemp));
MCPName.insert(std::make_pair(chNumber,name));
}
//-----Definitions
vector<float> digiCh[10];
float timeCF[10], timeCFcorr[10];
float timeOT[10];
float timeMax[10];
float intBase[10], intSignal[10], intSignalcorr[10], ampMax[10];
///int fibreX[8], hodoYchannels[8];
TH1F** wfHisto = new TH1F*[10];
TF1** f_templateFit = new TF1*[10];
//--reading wire chamber from other tree --
TChain* t1 = new TChain("outputTree");
InitTree2(t1);
//---Chain
TChain* chain = new TChain("H4tree");
InitTree(chain);
char command1[300];
sprintf(command1, "find %s/%d/*/dqmPlotstotal.root > listTemp_%s_%d.txt", (inputFolder).c_str(), run, outputFile.c_str(), run);
system(command1);
char command2[300];
sprintf(command2, "find %s/%d/[0-9]*.root > listTemp2_%s_%d.txt", (inputFolder).c_str(), run, outputFile.c_str(), run);
system(command2);
char list1[200];
char list2[200];
sprintf (list1, "listTemp_%s_%d.txt", outputFile.c_str(), run);
sprintf (list2, "listTemp2_%s_%d.txt", outputFile.c_str(), run);
ifstream rootList (list1);
ifstream rootList2 (list2);
while (!rootList.eof() && !rootList2.eof())
{
char iRun_tW[70];
rootList >> iRun_tW;
char iRun_str[70];
rootList2 >> iRun_str;
TChain* tTemp = new TChain("outputTree");
tTemp->Add(iRun_tW);
TChain* tTempH4 = new TChain("H4tree");
tTempH4->Add(iRun_str);
if (tTemp->GetEntries() == tTempH4->GetEntries())
{
t1->Add(iRun_tW);
chain->Add(iRun_str);
}
else
std::cout<<"Bad spill found.. Skipped"<<std::endl;
tTemp->Delete();
tTempH4->Delete();
}
char command3[300];
sprintf(command3, "rm listTemp_%s_%d.txt", outputFile.c_str(), run);
char command4[300];
sprintf(command4, "rm listTemp2_%s_%d.txt", outputFile.c_str(), run);
system(command3);
system(command4);
std::cout<<"start reading run: "<<run<<std::endl;
//-----Data loop--------------------------------------------------------
for(int iEntry=0; iEntry<chain->GetEntries(); iEntry++){
// for(int iEntry=7; iEntry<8; iEntry++){ //RA
if(iEntry % 1000 == 0) cout << "read entry: " << iEntry << endl;
//-----Unpack data--------------------------------------------------
for(int iCh=0; iCh<nChannels; iCh++)
{
digiCh[iCh].clear();
wfHisto[iCh] = new TH1F(Form("wfHisto_%d", iCh), "", 1024, 0., 1024.);
}
//---Read the entry
chain->GetEntry(iEntry);
unsigned int spill=spillNumber;
unsigned int event=evtNumber;
/* for(unsigned int iCh=0; iCh<nAdcChannels; iCh++)
{
if(adcBoard[iCh] == 1 && adcChannel[iCh] == 0)
sci_front_adc = adcData[iCh];
if(adcBoard[iCh] == 1 && adcChannel[iCh] >= HODOX_ADC_START_CHANNEL &&
adcChannel[iCh] <= HODOX_ADC_END_CHANNEL)
fibreX[(adcChannel[iCh]-HODOX_ADC_START_CHANNEL)] = adcData[iCh];
if(adcBoard[iCh] == 1 && adcChannel[iCh] >= HODOY_ADC_START_CHANNEL &&
adcChannel[iCh] <= HODOY_ADC_END_CHANNEL)
fibreY[(adcChannel[iCh]-HODOY_ADC_START_CHANNEL)] = adcData[iCh];
}
*/
int tStart[10] = {0,0,0,0,0,0,0,0,0,0};
int tStop[10] = {0,0,0,0,0,0,0,0,0,0};
int tMax[10] = {0,0,0,0,0,0,0,0,0,0};
float aMax[10] = {10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000., 10000.};
float bLine[10] = {0.,0.,0.,0.,0., 0.,0.,0.,0.,0.};
//---Read digitizer samples
for(unsigned int iSample=0; iSample<nDigiSamples; iSample++){
if(iSample > 1024*10 - 1) break;
if (digiGroup[iSample] == 1 && digiChannel[iSample] == 0){
digiCh[9].push_back(digiSampleValue[iSample]);
wfHisto[9]->SetBinContent((iSample%1024) + 1, digiSampleValue[iSample]);
int iBin = (iSample%1024) + 1;
float value = digiSampleValue[iSample];
if((iBin >= 10 && iBin < 30) || (iBin >= 500 && iBin < 1000)) bLine[9] += value/520;
// if(digiChannel[iSample] == 9) std::cout << " value = " << value << std::endl;
if(value < aMax[9]) { aMax[9] = value; tMax[9] = iBin; }
if(iBin > 50 && value < 500. && tStart[9] == 0) tStart[9] = iBin;
if(iBin > 50 && value > 500. && tStart[9] != 0 && tStop[9] == 0) tStop[9] = iBin;
}
else{
digiCh[digiChannel[iSample]].push_back(digiSampleValue[iSample]);
wfHisto[digiChannel[iSample]]->SetBinContent((iSample%1024) + 1, digiSampleValue[iSample]);
int iBin = (iSample%1024) + 1;
float value = digiSampleValue[iSample];
if((iBin >= 10 && iBin < 30) || (iBin >= 500 && iBin < 1000)) bLine[digiChannel[iSample]] += value/520;
if(digiChannel[iSample] == 9) std::cout << " value = " << value << std::endl;
if(value < aMax[digiChannel[iSample]]) { aMax[digiChannel[iSample]] = value; tMax[digiChannel[iSample]] = iBin;}
if(iBin > 50 && value < 500. && tStart[digiChannel[iSample]] == 0) tStart[digiChannel[iSample]] = iBin;
if(iBin > 50 && value > 500. && tStart[digiChannel[iSample]] != 0 &&
tStop[digiChannel[iSample]] == 0) tStop[digiChannel[iSample]] = iBin;
}
}
//---loop over MPC's channels
for(int iCh=0; iCh<nChannels; iCh++){
if(iCh < 4) continue;
if(iCh == 8) continue;
// std::cout << " loop over MCP iCh = " << iCh << std::endl;
// std::cout << " bLine[iCh] = " << bLine[iCh] << std::endl;
// std::cout << " aMax[iCh] = " << aMax[iCh] << std::endl;
// std::cout << " tMax[iCh] = " << tMax[iCh] << std::endl;
// std::cout << " tStart[iCh] = " << tStart[iCh] << std::endl;
// std::cout << " tStop[iCh] = " << tStop[iCh] << std::endl;
tMax[iCh] -= 300;
double scale = 0.;
double scaleErr = 0.;
double baseL = 0.;
double baseLErr = 0.;
double xTime = 0.;
double xTimeErr = 0.;
FindTemplateFit(scale, scaleErr, baseL, baseLErr, xTime, xTimeErr, tStart[iCh], tStop[iCh], tMax[iCh], aMax[iCh], bLine[iCh], templateHisto[iCh], wfHisto[iCh], &(f_templateFit[iCh]));
float par0 = f_templateFit[iCh]->GetParameter(0);
float par1 = f_templateFit[iCh]->GetParameter(1);
float par2 = f_templateFit[iCh]->GetParameter(2);
float par3 = f_templateFit[iCh]->GetParameter(3);
ampMax[iCh] = par0;
//tMax
timeMax[iCh] = (300. / par1) + par2;
timeCF[iCh] = (pro_medio_CF[iCh] / par1) + par2;
intSignal[iCh] = pro_medio_Charge[iCh] * par0/par1 + par3/par1 * 25;
intBase[iCh] = par3;
timeOT[iCh] = par2;
intSignalcorr[iCh] = par1;
timeCFcorr[iCh] = timeCF[iCh];
// std::cout << " >> timeMax[iCh] = " << timeMax[iCh] << std::endl;
// std::cout << " >> timeCF[iCh] = " << timeCF[iCh] << std::endl;
// std::cout << " >> f_templateFit[iCh]->GetParameter(0) = " << f_templateFit[iCh]->GetParameter(0) << std::endl;
/*
if(iCh == 4){
TCanvas* c1 = new TCanvas();
templateHisto[iCh]->Draw();
f_templateFit[iCh]->Draw("same");
c1->Print("pippo.png", "png");
TCanvas* c2 = new TCanvas();
wfHisto[iCh]->Draw();
f_templateFit[iCh]->Draw("same");
c2->Print("pippo2.png", "png");
TFile outFile_template("outFile_template.root", "recreate");
outFile_template.cd();
iCh = 4;
templateHisto[iCh]->Write(Form("promedio_%d", iCh));
wfHisto[iCh]->Write(Form("wfHisto_%d", iCh));
f_templateFit[iCh]->Write(Form("func_%d", iCh));
outFile_template.Close();
}
*/
}
/*
TFile outFile_template("outFile_template.root", "recreate");
outFile_template.cd();
for(int iCh=0; iCh<nChannels; iCh++){
if(iCh < 4) continue;
if(iCh == 8) continue;
templateHisto[iCh]->Write(Form("promedio_%d", iCh));
wfHisto[iCh]->Write(Form("wfHisto_%d", iCh));
f_templateFit[iCh]->Write(Form("func_%d", iCh));
}
outFile_template.Close();
return 100;
*/
//--------dump ntuple - impulses are negative, invert the sign
for (int iCh=0; iCh<nChannels; iCh++)
{
time_CF[MCPList.at(MCPName.at(iCh))] = timeCF[iCh];
time_CF_corr[MCPList.at(MCPName.at(iCh))] = timeCFcorr[iCh];
time_OT[MCPList.at(MCPName.at(iCh))] = timeOT[iCh];
time_Max[MCPList.at(MCPName.at(iCh))] = timeMax[iCh];
amp_max[MCPList.at(MCPName.at(iCh))] = ampMax[iCh];
amp_max_corr[MCPList.at(MCPName.at(iCh))] = ampMax[iCh];
charge[MCPList.at(MCPName.at(iCh))] = -intSignal[iCh];
charge_corr[MCPList.at(MCPName.at(iCh))] = -intSignalcorr[iCh];
baseline[MCPList.at(MCPName.at(iCh))] = intBase[iCh];
isPCOn[MCPList.at(MCPName.at(iCh))] = PCOn.at(iCh);
HV[MCPList.at(MCPName.at(iCh))] = HVVal.at(iCh);
if (strcmp((MCPName.at(iCh)).c_str(),trig1.c_str())==0) isTrigger[MCPList.at(MCPName.at(iCh))] = 1;
// else if (strcmp((MCPName.at(iCh)).c_str(),trig2.c_str())==0) isTrigger[MCPList.at(MCPName.at(iCh))] = 2;
else isTrigger[MCPList.at(MCPName.at(iCh))] = 0;
wfHisto[iCh]->Delete();
}
run_id = run;
X0 = X0temp;
t1->GetEntry(iEntry);
tdcX = (*TDCreco)[0];
tdcY = (*TDCreco)[1];
if (spill!=spillNumber || event!=evtNumber) {
std::cout<<"PROBLEM: non-coherent read"<<std::endl;
continue;
}
outTree->Fill();
}
//---Get ready for next run
chain->Delete();
t1->Delete();
}
int main(int argc, char* argv[])
{
if( argc<2 )
{
std::cout << argv[0] << " config_file " << std::endl;
return 0;
}
// open steering file names
config steer(argv[1]);
mode = steer.getInt("mode");
rootfile_in = steer.getString("rootfile_in");
rootfile_out = steer.getString("rootfile_out");
signalFraction = steer.getDouble("signalFraction");
method = steer.getInt("method");
gaus_reso = steer.getDouble("gaus_reso");
RegVersion = steer.getString("RegVersion");
debug = steer.getInt("debug");
doEvenOdd = steer.getInt("doEvenOdd");
// check
if (mode==73||mode==75||mode==77)
{
parfile_ref = steer.getString("parfile_ref");
if (parfile_ref=="")
{
std::cout << "Missing parameters reference file. Please run " << argv[0] << " to print usage information. " << std::endl;
return 1;
}
}
if (mode==782)
{
calibtable_filename = steer.getString("calibtable_filename");
// fitscale is a stupid control to tell FillAllEvent
// if you want it to store all hits information, false is to store.
fitscale = false;
}
std::cout << argv[0] << std::endl;
std::cout << " mode = " << mode << std::endl;
std::cout << " method = " << method << std::endl;
std::cout << " rootfile_in = " << rootfile_in << std::endl;
std::cout << " rootfile_out = " << rootfile_out << std::endl;
std::cout << " signalFraction = " << signalFraction << std::endl;
std::cout << " GaussianResolution = " << gaus_reso << std::endl;
std::cout << " RegVersion = " << RegVersion << std::endl;
std::cout << " doEvenOdd = " << doEvenOdd << std::endl;
if (mode==73||mode==75||mode==77) std::cout << " Parameter Reference File = " << parfile_ref << std::endl;
if (mode==782) std::cout << " calibtable_filename = " << calibtable_filename << std::endl;
std::cout << " Start program. " << std::endl;
// reading data
TChain* tree = new TChain("selected", "selected");
tree->Add(rootfile_in.c_str());
// Set the branches for the TChain/TTree
SetTreeBranch(tree);
// reading extra tree
TChain* extree = new TChain("extraCalibTree", "extraCalibTree");
extree->Add(rootfile_in.c_str());
// Set the branches for the extra TTree
SetExtraTreeBranch(extree);
// output root file
TFile* fout = TFile::Open(rootfile_out.c_str(), "recreate");
// all events
nEvents = tree->GetEntries();
nSignals = nEvents;
// Fill all events into vectors
FillAllEvents(tree, extree, 2, RegVersion, fitscale, doEvenOdd);
if (debug>0) std::cout << " Step 1: fill all events: " << nEvents << std::endl;
// delete the chain no more need it
tree->Delete();
extree->Delete();
// define the fitting function
BWGSLikelihoodFCN fcn;
fcn.setdebug(debug);
if (debug>0) std::cout << " Step 1: Initialize PDF overall " << std::endl;
// initialize PDF
fcn.initBWGSParameters(_FitWindowHigh, // windowHigh
_FitWindowLow, // windowLow
_Zmass, //voigtMass
gaus_reso, //voightResolution
2.4952, //voigtWidth
nSignals,
nEvents);
// define the energy scales as parameters
MnUserParameters scales;
// reference scales
std::vector<double> scalesref;
if (mode==73)
{
// read reference scales
std::ifstream reffile(parfile_ref.c_str());
if (reffile.is_open())
{
std::string line;
double s, e;
while (getline(reffile,line))
{
std::stringstream sline(line);
sline >> s >> e;
scalesref.push_back(s);
}
reffile.close();
}
int main (int argc, char** argv)
{
// get run number
std::string inputName = std::string(argv[1]);
char split_char = '/';
std::vector<std::string> tokens;
std::istringstream split(inputName);
for(std::string each; getline(split, each, split_char);
tokens.push_back(each));
split_char = '_';
std::vector<std::string> tokens_name;
std::istringstream split_name(tokens.at(1));
for(std::string each; getline(split_name, each, split_char);
tokens_name.push_back(each));
const int Ch_ref1 = atoi((tokens_name.at(1)).c_str());
const int Ch_ref2 = atoi((tokens_name.at(3)).c_str());
const int Ch_1 = atoi((tokens_name.at(5)).c_str());
const int Ch_2 = atoi((tokens_name.at(7)).c_str());
const int Ch_3 = atoi((tokens_name.at(9)).c_str());
std::vector<std::string> nameMCP;
nameMCP.push_back("MiB1");
nameMCP.push_back("MiB2");
nameMCP.push_back("ScB");
nameMCP.push_back("Planacon");
nameMCP.push_back("MiB3");
nameMCP.push_back("Roma2");
if(tokens_name.at(0) == "Scan3") nameMCP.at(1) = "Roma1";
std::vector<std::string> pcMCP;
for(unsigned int ii=0; ii<nameMCP.size(); ++ii) pcMCP.push_back("");
pcMCP.at(Ch_ref1) = tokens_name.at(2);
pcMCP.at(Ch_ref2) = tokens_name.at(4);
pcMCP.at(Ch_1) = tokens_name.at(6);
pcMCP.at(Ch_2) = tokens_name.at(8);
pcMCP.at(Ch_3) = tokens_name.at(10);
//---treshold setup Scan-dependent
init();
const int iScanTh = atoi(argv[2])-1;
float Ch_th[6]={0,0,0,0,0,0};
Ch_th[Ch_ref1] = _th[iScanTh][Ch_ref1];
Ch_th[Ch_ref2] = _th[iScanTh][Ch_ref2];
Ch_th[Ch_1] = _th[iScanTh][Ch_1];
Ch_th[Ch_2] = _th[iScanTh][Ch_2];
Ch_th[Ch_3] = _th[iScanTh][Ch_3];
TFile* out = TFile::Open((tokens_name.at(0)+"_outHistos.root").c_str(),"recreate");
out->cd();
//Output dat
std::ofstream data1(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_1)+"_pc_"+pcMCP.at(Ch_1)+".dat").data());
std::ofstream data2(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_2)+"_pc_"+pcMCP.at(Ch_2)+".dat").data());
std::ofstream data3(("analized_data/"+tokens_name.at(0)+"_"+nameMCP.at(Ch_3)+"_pc_"+pcMCP.at(Ch_3)+".dat").data());
int nFiles = 1, iRun = 0, goodEvt = 0;
int iScan = 0;
//---usefull histos
TH1F* chHistoBase_All[9];
TH1F* chHistoSignal_All[9];
TH1F* timeDiffHisto[9];
TH1F* timeDiffHisto_Double = new TH1F("timeDiffHisto_Double", "timeDiffHisto_Double",5000,-10,10);
//---histos initialization
for(int iCh=0; iCh<6; ++iCh)
{
char h1[30], h2[30], h3[30];
sprintf(h1, "histoBase_All_Ch%d", iCh);
sprintf(h2, "histoSignal_All_Ch%d", iCh);
sprintf(h3, "histoTime_Ch%d", iCh);
chHistoBase_All[iCh] = new TH1F(h1,h1,30000,-30000,1000);
chHistoSignal_All[iCh] = new TH1F(h2, h2,30000,-30000,1000);
timeDiffHisto[iCh] = new TH1F(h3, h3,1024,0,1024);
}
//---do runs loop
ifstream log (argv[1], ios::in);
while(log >> nFiles)
{
++iScan;
vector<float> digiCh[9];
float timeCF[9];
float baseline[9];
float intSignal[9], intBase[9];
int count[5]={0,0,0,0,0}, spare[5]={0,0,0,0,0}, spare2[5]={0,0,0,0,0};
int tot_tr1 = 0, tot_tr0 = 0, trig = 0;
int HV1=0, HV2=0, HV3=0;
TH1F* chHistoWF_Ch[9];
TH1F* chHistoBase_Ch[9];
TH1F* chHistoSignal_Ch[9];
TH1F* timeDiffHisto_Triple_Ch1 = new TH1F(Form("timeDiffHisto_Triple_Ch1_Scan%d",iScan), "", 5000,-100,100);
TH1F* timeDiffHisto_Triple_Ch2 = new TH1F(Form("timeDiffHisto_Triple_Ch2_Scan%d",iScan), "", 5000,-100,100);
TH1F* timeDiffHisto_Triple_Ch3 = new TH1F(Form("timeDiffHisto_Triple_Ch3_Scan%d",iScan), "", 5000,-100,100);
char ha[10];
for (int iiw=0;iiw<9;++iiw){
sprintf (ha,"histoWF_Ch%d_Scan_%d",iiw, iScan);
chHistoWF_Ch[iiw] = new TH1F( ha, "", 1024,0.,1024);
chHistoWF_Ch[iiw]->SetXTitle("Waveform");
sprintf (ha,"histoBase_Ch%d_Scan_%d",iiw, iScan);
chHistoBase_Ch[iiw] = new TH1F( ha, "", 30000,-30000,1000);
chHistoBase_Ch[iiw] -> SetXTitle ("Integral BaseLine Ch(ADC)");
sprintf (ha,"histoSignal_Ch%d_Scan_%d",iiw, iScan);
chHistoSignal_Ch[iiw] = new TH1F( ha, "", 30000,-30000,1000);
chHistoSignal_Ch[iiw] -> SetXTitle ("Integral Signal Ch(ADC)");
}
//---data chain
TChain* chain = new TChain("eventRawData");
InitTree(chain);
for(int iFiles=0; iFiles<nFiles; iFiles++){
log >> iRun;
char iRun_str[30];
sprintf(iRun_str, "../Analysis_TB/DATA/run_IMCP_%d_*.root", iRun);
chain->Add(iRun_str);
cout << "Reading: ../Analysis_TB/DATA/run_IMCP_" << iRun << endl;
}
log >> HV1 >> HV2 >> HV3;
for(int iEntry=0; iEntry<chain->GetEntries(); iEntry++) {
//---always clear the std::vector !!!
for(int iCh=0; iCh<9; iCh++) digiCh[iCh].clear();
//---Read the entry
chain->GetEntry(iEntry);
//---DAQ bug workaround
if(iRun < 145) goodEvt = 10;
else goodEvt = 1;
if(evtNumber % goodEvt == 0){
//---Read SciFront ADC value and set the e- multiplicity
//---(default = 1)
trig = 1;
for(int iCh=0; iCh<nAdcChannels; iCh++)
{
if(adcData[iCh] > 1500 && adcBoard[iCh] == 1 && adcChannel[iCh] == 0) trig=2;
if(adcData[iCh] < 500 && adcBoard[iCh] == 1 && adcChannel[iCh] == 0) trig=0;
}
if(trig > 1) continue;
//---Read digitizer samples
for(int iSample=0; iSample<nDigiSamples; iSample++){
if(digiChannel[iSample] == 3){
digiCh[digiChannel[iSample]].push_back(-digiSampleValue[iSample]);
chHistoWF_Ch[digiChannel[iSample]]->SetBinContent(digiSampleIndex[iSample]+1, -digiSampleValue[iSample]);
}
else{
digiCh[digiChannel[iSample]].push_back(digiSampleValue[iSample]);
chHistoWF_Ch[digiChannel[iSample]]->SetBinContent(digiSampleIndex[iSample]+1, digiSampleValue[iSample]);
}
}
for(int iCh=0; iCh<6; iCh++){
// baseline[iCh] = SubtractBaseline(5, 25, &digiCh[iCh]);
baseline[iCh] = SubtractBaseline(26, 46, &digiCh[iCh]);
intBase[iCh] = ComputeIntegral(26, 46, &digiCh[iCh]);
if(trig == 0) {
chHistoBase_All[iCh]->Fill(ComputeIntegral(26, 46, &digiCh[iCh]));
chHistoBase_Ch[iCh]->Fill(ComputeIntegral(26, 46, &digiCh[iCh]));
// chHistoBase_All[iCh]->Fill(ComputeIntegral(0, 150, &digiCh[iCh]));
// chHistoBase_Ch[iCh]->Fill(ComputeIntegral(0, 150, &digiCh[iCh]));
}
timeCF[iCh]=TimeConstFrac(30, 500, &digiCh[iCh], 0.5);
// timeDiffHisto[iCh]->Fill(timeCF[iCh]*0.2-timeCF[0]*0.2);
timeDiffHisto[iCh]->Fill(timeCF[iCh]);
int t1 = (int)(timeCF[iCh]/0.2) - 3;
int t2 = (int)(timeCF[iCh]/0.2) + 17;
//---Fill the signal integral histo only if the e- multiplicity is 1
if(t1 > 30 && t1 < 1024 && t2 > 30 && t2 < 1024 && trig == 1)
{
chHistoSignal_All[iCh]->Fill(ComputeIntegral(t1, t2, &digiCh[iCh]));
chHistoSignal_Ch[iCh]->Fill(ComputeIntegral(t1, t2, &digiCh[iCh]));
intSignal[iCh] = ComputeIntegral(t1, t2, &digiCh[iCh]);
}
else intSignal[iCh] = ComputeIntegral(50, 70, &digiCh[iCh]);
}// loop over Ch
//---Multiplicity == 1 --> compute efficency, fake rate and timing
if(intSignal[Ch_ref1] < Ch_th[Ch_ref1] && intSignal[Ch_ref2] < Ch_th[Ch_ref2] && trig == 1){
++tot_tr1;
float tDiff = (timeCF[Ch_ref1] - timeCF[Ch_ref2]);
float tMean = (timeCF[Ch_ref1] + timeCF[Ch_ref2])*0.5;
timeDiffHisto_Double->Fill(tDiff);
timeDiffHisto_Triple_Ch1->Fill(tMean - timeCF[Ch_1]);
timeDiffHisto_Triple_Ch2->Fill(tMean - timeCF[Ch_2]);
timeDiffHisto_Triple_Ch3->Fill(tMean - timeCF[Ch_3]);
if(intSignal[Ch_1] < Ch_th[Ch_1]) ++count[1];
if(intSignal[Ch_2] < Ch_th[Ch_2]) ++count[2];
if(intSignal[Ch_3] < Ch_th[Ch_3]) ++count[3];
if(intBase[Ch_1] < Ch_th[Ch_1]) ++spare[1];
if(intBase[Ch_2] < Ch_th[Ch_2]) ++spare[2];
if(intBase[Ch_3] < Ch_th[Ch_3]) ++spare[3];
}
}// good Event
}// loop over entries
std::cout << "HV1 = " << HV1 << " HV2 = " << HV2 << " HV3 = " << HV3 << std::endl;
double eff1 = ((double)count[1]-(double)spare[1])/(double)tot_tr1;
double eff2 = ((double)count[2]-(double)spare[2])/(double)tot_tr1;
double eff3 = ((double)count[3]-(double)spare[3])/(double)tot_tr1;
double eff1Err = TMath::Sqrt((eff1*(1-eff1))/tot_tr1);
double eff2Err = TMath::Sqrt((eff2*(1-eff2))/tot_tr1);
double eff3Err = TMath::Sqrt((eff3*(1-eff3))/tot_tr1);
std::cout << "Ch_1 eff = " << eff1 << " +/- " << eff1Err << std::endl;
std::cout << "Ch_2 eff = " << eff2 << " +/- " << eff2Err << std::endl;
std::cout << "Ch_3 eff = " << eff3 << " +/- " << eff3Err << std::endl;
/*
data1 << HV1 << " " << eff1 << " " << 0 << " " << eff1Err << std::endl;
data1 << HV2 << " " << eff2 << " " << 0 << " " << eff2Err << std::endl;
data1 << HV3 << " " << eff3 << " " << 0 << " " << eff3Err << std::endl;
*/
for(int iw=0; iw<6; ++iw){
if(iw == 2) continue;
chHistoBase_Ch[iw]->Write();
chHistoSignal_Ch[iw]->Write();
chHistoWF_Ch[iw]->Write();
}
timeDiffHisto_Triple_Ch1->Write();
timeDiffHisto_Triple_Ch2->Write();
timeDiffHisto_Triple_Ch3->Write();
chain->Delete();
}
for(int iw=0; iw<6; ++iw){
if(iw == 2) continue;
chHistoBase_All[iw]->Write();
chHistoSignal_All[iw]->Write();
timeDiffHisto[iw]->Write();
}
data1.close();
data2.close();
data3.close();
timeDiffHisto_Double->Write();
out->Close();
return 0;
}
//int data_MC_Pt_Comparison_entries(int EndCaps = 0, int r9sup = 1, int log = 0)
int main(int argc, char *argv[])
{
for(int iarg = 0 ; iarg < argc; iarg++)
{
cout << "argv[" << iarg << "]= " << argv[iarg] << endl;
}
if( argc == 1 )
{
cerr << "arguments should be passed : directoryName, eta, r9, xVariable, log" <<endl;
return 1;
}
string directoryName = "Data_MC_Mmumugamma_Comparison_ScaleAndSmearing/smearingFactors";
string eta = "Barrel_1";
string r9 = "all";
string ptCut = "25"; // "30" "35"
if( argc > 1 ) directoryName = argv[1];
if( argc > 2 ) eta = argv[2];
if( argc > 3 ) r9 = argv[3];
if( argc > 4 ) ptCut = argv[4];
int nBins = 50; //FIXME
double xMin, xMax;
xMin = 0.9; //FIXME
xMax = 1.1; //FIXME
string xVariableName, yVariableName;
gROOT->Reset();
TGaxis::SetMaxDigits(3);
setTDRStyle();
//setEgammaStyle();
string directoryName_2 = directoryName;
string fileName = directoryName;
cout<<endl<<"fileName = "<<fileName<<endl;
cout<<endl<<"directoryName = "<<directoryName<<endl;
directoryName += Form("/%s_%sR9/",eta.c_str(), r9.c_str());
TString cut = Form("(Photon_Et > %s && isJanLooseMMG == 1",ptCut.c_str());
if(r9 == "low" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && Photon_r9 < 0.94 && abs(Photon_SC_Eta) < 1";
if(r9 == "low" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && Photon_r9 < 0.94 && abs(Photon_SC_Eta) > 1";
if(r9 == "high" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && Photon_r9 > 0.94 && abs(Photon_SC_Eta) < 1";
if(r9 == "high" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && Photon_r9 > 0.94 && abs(Photon_SC_Eta) > 1";
if(r9 == "low" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && Photon_r9 < 0.95 && abs(Photon_SC_Eta) < 2";
if(r9 == "low" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && Photon_r9 < 0.95 && abs(Photon_SC_Eta) > 2";
if(r9 == "high" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && Photon_r9 > 0.95 && abs(Photon_SC_Eta) < 2";
if(r9 == "high" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && Photon_r9 > 0.95 && abs(Photon_SC_Eta) > 2";
if(r9 == "all" && eta == "Barrel_1") cut += " && Photon_isEB == 1 && abs(Photon_SC_Eta) < 1";
if(r9 == "all" && eta == "Barrel_2") cut += " && Photon_isEB == 1 && abs(Photon_SC_Eta) > 1";
if(r9 == "all" && eta == "Endcaps_1") cut += " && Photon_isEE == 1 && abs(Photon_SC_Eta) < 2";
if(r9 == "all" && eta == "Endcaps_2") cut += " && Photon_isEE == 1 && abs(Photon_SC_Eta) > 2";
if(r9 == "all" && eta == "all") cut += " && (Photon_isEE == 1 || Photon_isEB == 1)";
cut += ")*weight_pileUp";
cout<<endl<<"cut = "<<cut<<endl;
TChain * dYToMuMuFSRChainNew = new TChain("miniTree");
TChain * dYToMuMuNonFSRChainNew = new TChain("miniTree");
TChain * ttJetsChainNew = new TChain("miniTree");
TChain * wJetsChainNew = new TChain("miniTree");
dYToMuMuFSRChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_DYToMuMu_M-20_CT10_TuneZ2_7TeV-powheg-pythia_Fall11-PU_S6_START42_V14B-v1_September12_NewSelection_1_scaleAndsmearing_v4_partALL.root");
dYToMuMuNonFSRChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_DYToMuMu_M-20_CT10_TuneZ2_7TeV-powheg-pythia_Fall11-PU_S6_START42_V14B-v1_September12_NewSelection_2_scaleAndsmearing_v4_partALL.root");
ttJetsChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_TTJets_TuneZ2_7TeV-madgraph-tauola_NewSelection_3_scaleAndsmearing_v4_partALL.root");
wJetsChainNew->Add("/sps/cms/sgandurr/CMSSW_4_2_8_patch7/src/Zmumugamma_miniTrees_rereco_2011_lastTag/miniTree_WJetsToLNu_TuneZ2_7TeV-madgraph-tauola_NewSelection_3_scaleAndsmearing_v4_partALL.root");
TCanvas *c1 = new TCanvas("c1", "c1",0,0,600,600);
TH1D *dYToMuMuFSRNew = new TH1D("dYToMuMuFSRNew","dYToMuMuFSRNew", nBins, xMin, xMax);
TH1D *dYToMuMuNonFSRNew = new TH1D("dYToMuMuNonFSRNew","dYToMuMuNonFSRNew", nBins, xMin, xMax);
TH1D *ttJetsNew = new TH1D("ttJetsNew","ttJetsNew", nBins, xMin, xMax);
TH1D *wJetsNew = new TH1D("wJetsNew","wJetsNew", nBins, xMin, xMax);
dYToMuMuFSRChainNew->Draw("shervinSmearing>>dYToMuMuFSRNew",cut);
dYToMuMuNonFSRChainNew->Draw("shervinSmearing>>dYToMuMuNonFSRNew",cut);
ttJetsChainNew->Draw("shervinSmearing>>ttJetsNew",cut);
wJetsChainNew->Draw("shervinSmearing>>wJetsNew",cut);
// --- 2012 Lumi --- //
//double lumidata = 808.472 + 82.136 + 4429.0 + 495.003 + 134.242 + 6397.0 + 7274.0;
//double lumiDY = 48819386.0 / 1914.894;
//double lumiTtJets = 6736135.0 / 234.0;
//double lumiwJets = 57709905.0 / 37509.25;
// --- 2011 Lumi --- //
double lumidata = (0.706370 + 0.385819 + 2.741 + 1.099) * 1000;
double lumiDY = 29743564.0 / 1665.835;
double lumiTtJets = 3701947.0 / 165.0;
double lumiwJets = 81345381.0 / 31314.0;
// --- 2011 Lumi old --- //
//double lumiDY = 29743564.0 / 1626.0;
//double lumiTtJets = 3701947.0 / 94.76;
//double lumiwJets = 81345381.0 / 27770.0;
ttJetsNew->Scale(lumiDY / lumiTtJets);
wJetsNew->Scale(lumiDY / lumiwJets);
dYToMuMuFSRNew->Add(dYToMuMuNonFSRNew);
dYToMuMuFSRNew->Add(ttJetsNew);
dYToMuMuFSRNew->Add(wJetsNew);
dYToMuMuNonFSRNew->Add(ttJetsNew);
dYToMuMuNonFSRNew->Add(wJetsNew);
ttJetsNew->Add(wJetsNew);
c1->Clear();
dYToMuMuFSRNew->GetYaxis()->SetTitle("Events / 0.004"); //FIXME
dYToMuMuFSRNew->GetXaxis()->SetTitle("smearing factors");
/*
dYToMuMuFSR->GetXaxis()->SetLabelFont(42);
dYToMuMuFSR->GetXaxis()->SetTitleFont(42);
dYToMuMuFSR->GetYaxis()->SetLabelFont(42);
dYToMuMuFSR->GetYaxis()->SetTitleFont(42);
dYToMuMuFSR->GetYaxis()->SetTitleOffset(1.65);
*/
dYToMuMuFSRNew->SetFillColor(kGreen-7);
dYToMuMuNonFSRNew->SetFillColor(kAzure-5);
ttJetsNew->SetFillColor(kBlue-1);
wJetsNew->SetFillColor(kCyan+2);
dYToMuMuFSRNew->Draw("");
// --- Fit --- //
TF1 * f1 = new TF1("f1","gaus",xMin,xMax);
//TF1 * f1 = new TF1("f1","gaus",0.96,1.04);
//f1->FixParameter(1,1.0); //FIXME
//f1->FixParameter(2,1.0); //FIXME
dYToMuMuFSRNew->Fit(f1);
f1->SetLineColor(kBlue);
f1->SetLineWidth(2);
f1->Draw("SAMES");
c1->Clear();
dYToMuMuFSRNew->Draw("E");
f1->Draw("SAMES");
dYToMuMuFSRNew->SetMarkerStyle(20);
dYToMuMuFSRNew->SetMarkerSize(0.5);
TLatex latexLabel;
latexLabel.SetTextFont(42);
latexLabel.SetTextSize(0.028);
latexLabel.SetNDC();
//latexLabel.DrawLatex(0.25, 0.96, "CMS Preliminary 2011 #sqrt{s} = 7 TeV L = 4.93 fb^{-1}");
//double Ymin = 0;
//double Ymax = max(dYToMuMuFSR->GetMaximum(),data->GetMaximum()) + max(dYToMuMuFSR->GetMaximum(),data->GetMaximum()) * 0.1;
//cout << "Ymax = "<<Ymax<<endl;
//dYToMuMuFSRNew->GetYaxis()->SetRangeUser(Ymin,Ymax);
plotsRecording(directoryName, fileName, c1);
c1->Clear();
f1->Delete();
f1 = 0;
dYToMuMuFSRNew->Delete();
dYToMuMuFSRNew = 0;
dYToMuMuNonFSRNew->Delete();
dYToMuMuNonFSRNew = 0;
ttJetsNew->Delete();
ttJetsNew = 0;
wJetsNew->Delete();
wJetsNew = 0;
dYToMuMuFSRChainNew->Delete();
dYToMuMuFSRChainNew = 0;
dYToMuMuNonFSRChainNew->Delete();
dYToMuMuNonFSRChainNew = 0;
ttJetsChainNew->Delete();
ttJetsChainNew = 0;
wJetsChainNew->Delete();
wJetsChainNew = 0;
delete c1;
c1 = 0;
return 0;
}
int main(int argc, char** argv) {
gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
// load ntuple
TChain *chain = new TChain ("myanalysis/EcalAnalysisTree","EcalAnalysisTree") ;
chain->Add("/tmp/malberti/EcalTree_EG_Run2010A-WZEG-Nov4Skim_v1_RAW-RECO.root");
chain->Add("/tmp/malberti/EcalTree_Electron_Run2010B-WZEG-Nov4Skim_v1_RAW-RECO.root");
int nEntries = (int)chain->GetEntries() ;
cout << "FOUND " << nEntries << " ENTRIES\n" << endl;;
//ecalVariables variables
unsigned int runId;
unsigned int eventId;
unsigned int eventNaiveId;
int nEcalRecHits;
float ecalRecHitType[3300];
float ecalRecHitEnergy[3300];
float ecalRecHitIEta[3300];
float ecalRecHitIPhi[3300];
float ecalRecHitTime[3300];
float ecalRecHitChi2[3300];
int ecalRecHitRecoFlag[3300];
float ecalRecHitMatrixFlag[3300][5][5];
float ecalRecHitMatrix[3300][5][5];
float ecalRecHitS4oS1[3300];
int ecalDigis[3300][10];
int ecalGainId[3300][10];
// Set branch addresses.
chain -> SetBranchAddress("runId", &runId);
chain -> SetBranchAddress("eventId", &eventId);
chain -> SetBranchAddress("eventNaiveId", &eventNaiveId);
chain -> SetBranchAddress("nEcalRecHits", &nEcalRecHits);
chain -> SetBranchAddress("ecalRecHitType", ecalRecHitType);
chain -> SetBranchAddress("ecalRecHitEnergy", ecalRecHitEnergy);
chain -> SetBranchAddress("ecalRecHitIEta", ecalRecHitIEta);
chain -> SetBranchAddress("ecalRecHitIPhi", ecalRecHitIPhi);
chain -> SetBranchAddress("ecalRecHitTime", ecalRecHitTime);
chain -> SetBranchAddress("ecalRecHitChi2", ecalRecHitChi2);
chain -> SetBranchAddress("ecalRecHitRecoFlag", ecalRecHitRecoFlag);
chain -> SetBranchAddress("ecalRecHitMatrixFlag", ecalRecHitMatrixFlag);
chain -> SetBranchAddress("ecalRecHitMatrix", ecalRecHitMatrix);
chain -> SetBranchAddress("ecalRecHitS4oS1", ecalRecHitS4oS1);
chain -> SetBranchAddress("ecalDigis", ecalDigis);
chain -> SetBranchAddress("ecalGainId", ecalGainId);
// output file
char outfileName[100];
sprintf(outfileName,"HistosSlewRate.root");
cout << "Saving histograms on file " << outfileName <<endl;
TFile saving (outfileName,"recreate") ;
// histos
TH1F *hGainSwitch = new TH1F("hGainSwitch","hGainSwitch",10,-5,5);
hGainSwitch->GetXaxis()->SetTitle("Gain(max) - Gain(max-1)");
TH1F *hSlewRate = new TH1F("hSlewRate","hSlewRate", 5000, 0, 5000);
hSlewRate ->SetFillStyle(1);
hSlewRate ->SetFillColor(kRed);
hSlewRate ->GetXaxis()->SetTitle("Slew Rate (ADC/ns)");
TH2F *hAmplitude = new TH2F("hAmplitude","hAmplitude", 1000, 0, 10000, 500, 0, 5000);
hAmplitude -> SetMarkerColor(kRed);
hAmplitude -> SetMarkerStyle(20);
hAmplitude -> SetMarkerSize(0.35);
hAmplitude -> GetXaxis() -> SetTitle("Expected Amplitude (ADC)");
hAmplitude -> GetYaxis() -> SetTitle("Observed Amplitude (ADC)");
TH2F *hAmplitude2 = new TH2F("hAmplitude2","hAmplitude2", 1000, 0, 10000, 500, 0, 5000);
hAmplitude2 -> SetMarkerColor(kBlue);
hAmplitude2 -> SetMarkerStyle(20);
hAmplitude2 -> SetMarkerSize(0.35);
hAmplitude2 -> GetXaxis() -> SetTitle("Expected Amplitude (ADC)");
hAmplitude2 -> GetYaxis() -> SetTitle("Observed Amplitude (ADC)");
TH2F *hAmpl_vs_Time = new TH2F("hAmpl_vs_Time","hAmpl_vs_Time", 800, -100, 100, 1000, 0, 10000);
hAmpl_vs_Time -> SetMarkerColor(kRed);
hAmpl_vs_Time -> SetMarkerStyle(20);
hAmpl_vs_Time -> SetMarkerSize(0.3);
hAmpl_vs_Time -> GetXaxis() -> SetTitle("Time (ns)");
hAmpl_vs_Time -> GetYaxis() -> SetTitle("Expected Amplitude (ADC)");
TH2F *hRatio_vs_Time = new TH2F("hRatio_vs_Time","hRatio_vs_Time", 800, -100, 100, 200, 0, 2);
hRatio_vs_Time -> SetMarkerColor(kRed);
hRatio_vs_Time -> SetMarkerStyle(20);
hRatio_vs_Time -> SetMarkerSize(0.3);
hRatio_vs_Time -> GetXaxis() -> SetTitle("Time (ns)");
hRatio_vs_Time -> GetYaxis() -> SetTitle("Ratio");
TH1F *hr1 = new TH1F("hr1","hr1",200,0,2);
TH1F *hr2 = new TH1F("hr2","hr2",200,0,2);
TH1F *hTfit1 = new TH1F("hTfit1","hTfit1 (expected Amplitude < 3000 ADC)",400,-50,50);
hTfit1 -> SetFillStyle(3001);
hTfit1 -> SetFillColor(kRed+2);
hTfit1 -> GetXaxis() -> SetTitle("T_{fit} (ns)");
TH1F *hTfit2 = new TH1F("hTfit2","hTfit2 (expected Amplitude > 3000 ADC)",400,-50,50);
hTfit2 -> SetFillStyle(3001);
hTfit2 -> SetFillColor(kBlue+2);
hTfit2 -> GetXaxis() -> SetTitle("T_{fit} (ns)");
TH1F *hAmax1 = new TH1F("hAmax1","hTAmax1 (expected Amplitude < 3000 ADC)",1000,0,10000);
hAmax1 -> SetFillStyle(3001);
hAmax1 -> SetFillColor(kRed+2);
hAmax1 -> GetXaxis() -> SetTitle("A_{max} (ADC counts)");
TH1F *hAmax2 = new TH1F("hAmax2","hTAmax2 (expected Amplitude > 3000 ADC)",1000,0,10000);
hAmax2 -> SetFillStyle(3001);
hAmax2 -> SetFillColor(kBlue+2);
hAmax2 -> GetXaxis() -> SetTitle("A_{max} (ADC counts)");
TGraphErrors* gsample;
char gname[100];
char gtitle[100];
int ievt=0;
float A[3300][10];
float G[3] = {1.,2.,12.}; // gain ratios
//loop over the events
for (int entry = 0 ; entry < nEntries; ++entry) {
chain -> GetEntry(entry) ;
if (entry%10000==0) cout << " Analyzing entry " << entry << endl;
for (int ihit =0 ; ihit < nEcalRecHits; ihit++) {
// barrel only
if ( ecalRecHitType[ihit]!=0) continue;
float energy = ecalRecHitEnergy[ihit];
float eta = ecalRecHitIEta[ihit]*0.0175;
float theta = 2. * atan(exp(-eta));
float et = energy*sin(theta);
//if ( energy < 100. ) continue; // E>10 GeV
//cerco il sample max
float ped = (ecalDigis[ihit][0] + ecalDigis[ihit][1] + ecalDigis[ihit][2])/3;
int imax = 0;
int maxAmpl = 0;
for (int isample = 0; isample < 10 ; isample++)
{
if (ecalGainId[ihit][isample]!=0) A[ihit][isample] = (ecalDigis[ihit][isample] - ped) * G[ ecalGainId[ihit][isample] - 1];
if ( A[ihit][isample] >= maxAmpl)
{
imax = isample;
maxAmpl = A[ihit][isample] ;
}
} // end loop over 10 samples
// check gain switch
bool gainSwitch = false;
if (ecalGainId[ihit][imax-1]==1 && ecalGainId[ihit][imax] != ecalGainId[ihit][imax-1]) gainSwitch = true;
//Seleziono eventi con gain switch
if (!gainSwitch) continue;
hGainSwitch -> Fill( ecalGainId[ihit][imax]-ecalGainId[ihit][imax-1]);
//cout << "MAX sample = "<< imax << " MAX amplitude = "<< A[ihit][imax] << " MAX gain Id =" << ecalGainId[ihit][imax]<< endl;
//cout << "MAX-1 sample = "<< imax-1 << " MAX-1 amplitude = "<< A[ihit][imax-1] << " MAX-1 gain Id =" << ecalGainId[ihit][imax-1] << endl;
//cout << endl;
float slewRate = A[ihit][imax-1];
hSlewRate -> Fill(slewRate);
// graphs
gsample = new TGraphErrors();
sprintf(gtitle,"shape_Run%d_Evt%d",runId,eventId);
sprintf(gname,"shape_%d",ievt);
gsample->SetName(gname);
gsample->SetTitle(gtitle);
gsample->GetXaxis()->SetTitle("Time (ns)");
gsample->GetYaxis()->SetTitle("ADC counts");
for (int isample = 0; isample < 10 ; isample++)
{
gsample->SetPoint(isample, double(isample)*25., A[ihit][isample]);
gsample->SetPointError(isample,0.,0.9);
}
// fit function
TF1 *fpulseShape = new TF1("fpulseShape", pulseShape,0.,240.,3);
fpulseShape->SetLineColor(kBlue);
fpulseShape->SetParName(0,"Ped");
fpulseShape->SetParName(1,"A");
fpulseShape->SetParName(2,"T0");
fpulseShape->FixParameter(0,0); // ped
fpulseShape->SetParameter(1,A[ihit][imax]); // ampl
fpulseShape->SetParameter(2,imax*25.); // T0
gsample->RemovePoint(imax-1);
gsample->Fit("fpulseShape","QSR+") ;
//re-set dei punti, altrimenti root non li plotta!
for (int isample = 0; isample < 10 ; isample++)
{
gsample->SetPoint(isample, double(isample)*25., A[ihit][isample]);
gsample->SetPointError(isample,0.,0.9);
}
ievt++;
float measuredAmpl = A[ihit][imax-1] ;
float expectedAmpl = A[ihit][imax] * fpulseShape->Eval((imax-1)*25.)/fpulseShape->Eval(imax*25.);
hAmplitude -> Fill(expectedAmpl,measuredAmpl);
hAmplitude2 -> Fill( A[ihit][imax] * 0.774,measuredAmpl);
float t0 = fpulseShape->GetParameter(2);
hAmpl_vs_Time -> Fill(t0-125.,expectedAmpl);
hRatio_vs_Time -> Fill(t0-125., fpulseShape->Eval((imax-1)*25.)/fpulseShape->Eval(imax*25.));
if (expectedAmpl > 3000) {
hr2->Fill( fpulseShape->Eval((imax-1)*25.)/fpulseShape->Eval(imax*25.));
hTfit2->Fill(t0-125.);
hAmax2->Fill(A[ihit][imax]);
}
else {
hr1->Fill( fpulseShape->Eval((imax-1)*25.)/fpulseShape->Eval(imax*25.));
hTfit1->Fill(t0-125.);
hAmax1->Fill(A[ihit][imax]);
}
if ( expectedAmpl < 3000 )
//if (ievt<10)
gsample->Write();
} // end loop over recHits
}//end loop over events
chain->Delete();
saving.cd () ;
hGainSwitch ->Write();
hSlewRate -> Write();
hAmplitude ->Write();
hAmplitude2 ->Write();
hAmpl_vs_Time ->Write();
hRatio_vs_Time ->Write();
hTfit1->Write();
hTfit2->Write();
hAmax1->Write();
hAmax2->Write();
hr1->Write();
hr2->Write();
saving.Close () ;
return 0;
}