//------------------------------------------------------------------------------
// getTreeFromFile
//------------------------------------------------------------------------------
TTree* getTreeFromFile(const char* infname, Bool_t loadFromDir = kTRUE)
{
bool verbose = false;
if (verbose) {
cout << "--- Open file " << infname << endl;
}
TFile* inf = new TFile(infname,"read");
assert(inf);
TTree* t = 0;
if (loadFromDir) {
TDirectory *dir = (TDirectory*)inf->FindObjectAny("ElectronValidationMod");
assert(dir);
t = (TTree*)dir->Get("ElectronIDOptimizationTree");
assert(t);
} else {
t = (TTree*)inf->Get("ElectronIDOptimizationTree");
}
if (verbose) {
cout << "---\tRecovered tree " << t->GetName()
<< " with "<< t->GetEntries() << " entries" << endl;
}
return t;
}
//------------------------------------------------------------------------------
// getTreeFromFile
//------------------------------------------------------------------------------
TTree* getTreeFromFile(const char* infname, int nsel)
{
bool verbose = false;
if (verbose) {
cout << "--- Open file " << infname << endl;
}
TFile* inf = new TFile(infname,"read");
assert(inf);
//TDirectory *dir = (TDirectory*)inf->FindObjectAny("HwwMakeNtupleMod");
//assert(dir);
TTree* t;
if (nsel==0) t = (TTree*) gROOT->FindObject("HwwTree0");
else if(nsel==1) t = (TTree*) gROOT->FindObject("HwwTree1");
else if(nsel==2) t = (TTree*) gROOT->FindObject("HwwTree2");
else if(nsel==3) t = (TTree*) gROOT->FindObject("HwwTree3");
else if(nsel==4) t = (TTree*) gROOT->FindObject("HwwTree4");
else assert(1);
t->SetName("tree");
assert(t);
if (verbose) {
cout << "---\tRecovered tree " << t->GetName()
<< " with "<< t->GetEntries() << " entries" << endl;
}
return t;
}
//------------------------------------------------------------------------------
// getTreeFromFile
//------------------------------------------------------------------------------
TTree* getTreeFromFile(const char* infname, const char* tname)
{
bool verbose = false;
if (verbose) {
cout << "--- Open file " << infname << endl;
}
TFile* inf = new TFile(infname,"read");
assert(inf);
TTree* t = (TTree*)inf->Get(tname);
if (!t) {
TDirectory *dir = (TDirectory*)inf->FindObjectAny("eleIDdir");
if (!dir) {
cout << "Cannot get Directory HwwNtuplerMod from file " << infname << endl;
assert(dir);
}
t = (TTree*)dir->Get(tname);
}
if (!t) {
cout << "Cannot get Tree with name " << tname << " from file " << infname << endl;
}
assert(t);
if (verbose) {
cout << "---\tRecovered tree " << t->GetName()
<< " with "<< t->GetEntries() << " entries" << endl;
}
return t;
}
//------------------------------------------------------------------------------
// getTreeFromFile
//------------------------------------------------------------------------------
TTree* getTreeFromFile(const char* infname)
{
bool verbose = true;
if (verbose) {
cout << "--- Open file " << infname << endl;
}
TFile* inf = new TFile(infname,"read");
assert(inf);
//TDirectory *dir = (TDirectory*)inf->FindObjectAny("HwwMakeNtupleMod");
//assert(dir);
TTree* t;
t = (TTree*) inf->Get("HwwTree0");
if(!t) t = (TTree*) inf->Get("HwwTree1");
if(!t) t = (TTree*) inf->Get("HwwTree2");
if(!t) t = (TTree*) inf->Get("tree");
assert(t);
t->SetName("tree");
if (verbose) {
cout << "---\tRecovered tree " << t->GetName()
<< " with "<< t->GetEntries() << " entries" << endl;
}
return t;
}
TTree *skim(std::string var, TTree *fullTree, std::string newname, std::string cutstr, bool isWeighted , bool reweighted){
std::cout << newname.c_str() << " " << cutstr.c_str() << std::endl;
fullTree->Draw(">>cutlist",cutstr.c_str());
TEventList *keep_points = (TEventList*)gDirectory->Get("cutlist");
int nEntries = fullTree->GetEntries();
float x;
float weight, weight_in, weight_in_pu;
float catvar1,catvar2,catvar3,catvar4;
float tau1,tau2;
float genpt;
TLorentzVector *jet;
TTree *newTree = new TTree(newname.c_str(),newname.c_str());
newTree->Branch(var.c_str(),&x,Form("%s/Float_t",var.c_str()));
newTree->Branch("weight",&weight,"weight/Float_t");
newTree->Branch("jet1mprune",&catvar1,"jet1mprume/Float_t");
newTree->Branch("jet1mtrim",&catvar2,"jet1mtrim/Float_t");
newTree->Branch("jet1tau2o1",&catvar3,"jet1tau12o1/Float_t");
newTree->Branch("jet1pt",&catvar4,"jet1pt/Float_t");
fullTree->SetBranchAddress(var.c_str(),&x);
fullTree->SetBranchAddress("scale1fb",&weight_in);
fullTree->SetBranchAddress("puweight",&weight_in_pu);
fullTree->SetBranchAddress("jet1mprune",&catvar1);
fullTree->SetBranchAddress("jet1mtrim" ,&catvar2);
fullTree->SetBranchAddress("jet1tau2" ,&tau2);
fullTree->SetBranchAddress("jet1tau1" ,&tau1);
fullTree->SetBranchAddress("jet1" ,&jet);
if ( reweighted){
std::cout << "Reweighting For generated PT " << std::endl;
fullTree->SetBranchAddress("genvpt" ,&genpt);
}
std::cout << " Filling Skim tree " << newTree->GetName() << std::endl;
for (int evt=0;evt<nEntries;evt++){
fullTree->GetEntry(evt);
if ( !(keep_points->Contains(evt)) ) continue;
if (isWeighted) weight = weight_in*weight_in_pu*luminosity;
else weight = 1.;
if (reweighted) {
if (genpt<reweightgenpt->GetXaxis()->GetXmax() && genpt>reweightgenpt->GetXaxis()->GetXmin()) {
weight*=reweightgenpt->GetBinContent(reweightgenpt->FindBin(genpt));
}
//std::cout << "genpt = " << genpt << ", weight = " << reweightgenpt->GetBinContent(reweightgenpt->FindBin(genpt)) <<std::endl;
}
catvar3 = tau2/tau1; // make the sub-structure variable
catvar4 = jet->Pt();
//std::cout << jet->Pt() << std::endl;
newTree->Fill();
}
return newTree;
}
//------------------------------------------------------------------------------
// getTreeFromFile
//------------------------------------------------------------------------------
TTree* getTreeFromFile(const char* infname, const char* tname)
{
bool verbose = false;
if (verbose) {
cout << "--- Open file " << infname << endl;
}
TFile* inf = new TFile(infname,"read");
assert(inf);
TTree* t = (TTree*)inf->Get(tname);
assert(t);
if (verbose) {
cout << "---\tRecovered tree " << t->GetName()
<< " with "<< t->GetEntries() << " entries" << endl;
}
return t;
}
void rewritetrees(){
TString trees[] = {"iso2j1t" , "noniso2j1t" , "iso2j0t" , "noniso2j0t" , "iso3j2t" , "noniso3j2t" , "iso3j1t" , "noniso3j1t" };
struct{
float weight;
float mtw;
float met;
bool data;
bool qcd;
} info;
TFile* fout = TFile::Open("out.root" , "RECREATE");
for( int i=0 ; i < 8 ; i++){
cout << trees[i] << endl;
TTree* tree = (TTree*)( _file0->Get("Trees/" + trees[i] ) );
tree->SetBranchAddress( "info" , &info );
tree->Print();
TTree* tout = new TTree( tree->GetName() , tree->GetTitle() );
tout->SetAutoSave( 10000 );
tout->Branch( "weight" , &info.weight );
tout->Branch( "mtw" , &info.mtw);
tout->Branch( "met" , &info.met );
tout->Branch( "data" , &info.data );
tout->Branch( "qcd" , &info.qcd );
for(int j = 0 ; j < tree->GetEntries() ; j++){
tree->GetEntry(j);
tout->Fill();
//cout << i ;
}
}
fout->Write();
fout->Close();
}
//get the RooDataSet, multiply each roorealvar by the event_weight
void get_roodset_from_ttree(TDirectoryFile *f, TString treename, RooDataSet* &roodset){
cout << "Creating roodset from file: " << f->GetName() << " with tree: " << treename.Data() << endl;
TTree *t = NULL;
assert(roodset==NULL);
f->GetObject(treename.Data(),t);
if (!t) {cout << "Impossible to find TTree " << treename.Data() << endl; return;}
TObjArray *objs = t->GetListOfBranches();
//disables all branches
t->SetBranchStatus("*",0);
float v_rooisopv1;
float v_rooisopv2;
float v_rooisowv1;
float v_rooisowv2;
float v_roovar1;
float v_roovar2;
float v_roopt1;
float v_roosieie1;
float v_rooeta1;
float v_roopt2;
float v_roosieie2;
float v_rooeta2;
float v_roodiphopt;
float v_roodiphomass;
float v_roorho;
float v_roosigma;
float v_roonvtx;
float v_rooweight;
TBranch *b_roovar1;
TBranch *b_roovar2;
TBranch *b_rooisopv1;
TBranch *b_rooisopv2;
TBranch *b_rooisowv1;
TBranch *b_rooisowv2;
TBranch *b_roopt1;
TBranch *b_roosieie1;
TBranch *b_rooeta1;
TBranch *b_roopt2;
TBranch *b_roosieie2;
TBranch *b_rooeta2;
TBranch *b_roodiphopt;
TBranch *b_roodiphomass;
TBranch *b_roorho;
TBranch *b_roosigma;
TBranch *b_roonvtx;
TBranch *b_rooweight;
const int nvars = 18;
float* ptrs[nvars]={&v_roovar1,&v_roovar2,&v_rooisopv1,&v_rooisopv2,&v_rooisowv1,&v_rooisowv2,&v_roopt1,&v_roosieie1,&v_rooeta1,&v_roopt2,&v_roosieie2,&v_rooeta2,&v_roodiphopt,&v_roodiphomass,&v_roorho,&v_roosigma,&v_roonvtx,&v_rooweight};
TBranch** branches[nvars]={&b_roovar1,&b_roovar2,&b_rooisopv1,&b_rooisopv2,&b_rooisowv1,&b_rooisowv2,&b_roopt1,&b_roosieie1,&b_rooeta1,&b_roopt2,&b_roosieie2,&b_rooeta2,&b_roodiphopt,&b_roodiphomass,&b_roorho,&b_roosigma,&b_roonvtx,&b_rooweight};
RooRealVar* rooptrs[nvars]={roovar1,roovar2,rooisopv1,rooisopv2,rooisowv1,rooisowv2,roopt1,roosieie1,rooeta1,roopt2,roosieie2,rooeta2,roodiphopt,roodiphomass,roorho,roosigma,roonvtx,rooweight};
bool status[nvars];
RooArgSet args;
for (int i=0; i<nvars; i++){
status[i]=0;
TString name = rooptrs[i]->GetName();
TObject *obj = objs->FindObject(name.Data());
if (!obj) continue;
t->SetBranchStatus(name.Data(),1);
status[i]=1;
t->SetBranchAddress(name.Data(),ptrs[i],branches[i]);
args.add(*(rooptrs[i]));
}
TString newname = Form("roo_%s",t->GetName());
roodset = new RooDataSet(newname.Data(),newname.Data(),args,WeightVar(*rooweight) );
for (int j=0; j<t->GetEntries(); j++){
t->GetEntry(j);
for (int i=0; i<nvars; i++){
if (!status[i]) continue;
rooptrs[i]->setVal(*(ptrs[i]));
}
roodset->add(args,v_rooweight);
}
cout << "Imported roodset " << newname.Data() << " from TTree " << t->GetName() << endl;
roodset->Print();
}
void CheckESD(const char* fileNameE="AliESDsTmp.root",const char* fileNameR="alien:///alice/data/2010/LHC10h/000137549/ESDs/pass1_4plus/10000137549001.100/AliESDs.root") {
Int_t nev = 10;
Int_t nskip = 0;
const char* fileNameM = "AliESDs.root";
const char *trgname;
if (gSystem->Getenv("DC_ESDFILE")) {
fileNameR = gSystem->Getenv("DC_ESDFILE");
}
if (gSystem->Getenv("DC_NEVENTS")) {
nev = atoi(gSystem->Getenv("DC_NEVENTS"));
}
if (gSystem->Getenv("DC_TRGNAME")) {
trgname = gSystem->Getenv("DC_TRGNAME");
}
if (gSystem->Getenv("DC_EEVENT")) {
nskip = atoi(gSystem->Getenv("DC_EEVENT"));
}
if (!gGrid) TGrid::Connect("alien://");
TFile *_fileE = TFile::Open(fileNameE);
TFile *_fileR = TFile::Open(fileNameR);
AliESDEvent* esdE = new AliESDEvent();
AliESDEvent* esdR = new AliESDEvent();
AliESDRun* runM = 0x0;
AliESDHeader* headM = 0x0;
AliESDZDC* zdcM = 0x0;
AliESDVZERO* vzeroM = 0x0;
AliMultiplicity *multM = 0x0;
TTree* treeESDE;
TTree* treeESDR;
_fileE->GetObject("esdTree", treeESDE);
_fileR->GetObject("esdTree", treeESDR);
esdE->ReadFromTree(treeESDE);
esdR->ReadFromTree(treeESDR);
// Output ESDs
TFile *_fileM = TFile::Open(fileNameM, "RECREATE");
TTree *treeESDM = new TTree("esdTree", "Tree with ESD objects");
AliESDEvent *esdM = new AliESDEvent();
esdM->CreateStdContent();
esdM->WriteToTree(treeESDM);
Int_t nEventsE = treeESDE->GetEntries();
Int_t nEventsR = treeESDR->GetEntries();
Int_t nEvents = TMath::Min(nEventsE,nEventsR);
nEvents = TMath::Min(nEvents,nev);
Int_t lastSelectedEvent = -1;
if (nskip>0) {
printf("We will skip %d events\n",nskip);
lastSelectedEvent = nskip-1;
}
for (Int_t iEv=0; iEv<nEvents; iEv++) {
printf("Event %i\n",iEv);
treeESDE->GetEvent(iEv);
if (trgname) {
for (Int_t jEv=lastSelectedEvent+1; jEv<nEventsR; jEv++) {
treeESDR->GetEvent(jEv);
TString firedTrigClasses = esdR->GetFiredTriggerClasses();
if (firedTrigClasses.Contains(trgname)) {
lastSelectedEvent = jEv;
break;
}
}
} else {
treeESDR->GetEvent(iEv);
lastSelectedEvent = iEv;
}
printf("and Event %i\n",lastSelectedEvent);
// Copy the esd event from the Merged (Signal) reconstrcution
*esdM = *esdE;
// Replace some branches with those from original esd event
runM = dynamic_cast<AliESDRun *>(esdM->FindListObject("AliESDRun"));
*runM = *(dynamic_cast<AliESDRun *>(esdR->FindListObject("AliESDRun")));
headM = dynamic_cast<AliESDHeader *>(esdM->FindListObject("AliESDHeader"));
*headM = *(dynamic_cast<AliESDHeader *>(esdR->FindListObject("AliESDHeader")));
zdcM = dynamic_cast<AliESDZDC *>(esdM->FindListObject("AliESDZDC"));
*zdcM = *(dynamic_cast<AliESDZDC *>(esdR->FindListObject("AliESDZDC")));
vzeroM = dynamic_cast<AliESDVZERO *>(esdM->FindListObject("AliESDVZERO"));
*vzeroM = *(dynamic_cast<AliESDVZERO *>(esdR->FindListObject("AliESDVZERO")));
multM = dynamic_cast<AliMultiplicity *>(esdM->FindListObject("AliMultiplicity"));
*multM = *(dynamic_cast<AliMultiplicity *>(esdR->FindListObject("AliMultiplicity")));
treeESDM->Fill();
}
_fileM->cd();
treeESDM->Write(treeESDM->GetName(),TObject::kOverwrite);
_fileM->Close();
}
void striptree(TString fileName="", Int_t nAPVs=4)
{
//===========================================================================
// Change the inputs
//===========================================================================
//TString fileName = "Raw_Data_July1_Ped_300V";
//TString fileName = "Raw_Data_July1_Source_300V";
//TString fileName = "Raw_Data_July1_Ped_200V";
//TString fileName = "Raw_Data_Pedestal_300V";
// TString fileName = "Raw_Data_Source_300V";
// TString fileName = "Raw_Data_Sept_3_1";
// TString fileName = "Raw_Data_test_3_7";
// TString fileName = "Raw_Data_Albox_2011_03_31_1";
//-- TString fileName = "Raw_Data_04_01_AL_center_1";
// TString fileName = "Raw_Data_04_01_AL_7820_1";
//-- TString fileName = "Raw_Data_7817_04_01_1";
// TString fileName = "Raw_Data_7817_04_01_bkg_1";
//int nAPVs = 4;
//TString fileName = "Raw_Data_July1_Source_200V";
//int nAPVs = 1;
int nEvents = -1; // -1 means all
TString dat = fileName;
TString eps = fileName + "-events.eps";
TString root = fileName + "-events.root";
TFile* file = new TFile(root, "RECREATE");
//===========================================================================
// Read the data and make a 2D scatter plot
//===========================================================================
ifstream in(dat);
if (!in) {
cout<< "File " << dat << " not found" <<endl;
return;
}
TString comments = "vertical --> APV0, APV1, ... of event 1, ...";
TString s;
while (1) {
s.ReadLine(in);
if (s.BeginsWith(comments))
break;
}
gStyle->SetOptStat(10);
TString title = fileName+" ADC Counts vs Channel";
TString title32 = fileName+" ADC Counts vs Channel for 32 ch";
TH2D *h2d = new TH2D("h2d", title.Data(), nAPVs*128, 0, nAPVs*128, 200, 0, 200);
TH2D *h2d32 = new TH2D("h2d32", title.Data(), 16, 0, 16, 200, 0, 200);
TProfile *profile = new TProfile("profile", title32.Data(), nAPVs*128, 0, nAPVs*128);
int event, apv, channel, adc;
// TTree* tree = new TTree("tree", "tree");
// tree->Branch("event", &event, "event/I");
// tree->Branch("apv", &apv, "apv/I");
// tree->Branch("channel", &channel, "channel/I");
// tree->Branch("adc", &adc, "adc/I");
Int_t raw[512];
TTree* etree = new TTree("etree", "etree");
etree->Branch("raw", &raw, "raw[512]/I"); // etree->Draw("raw:Iteration$","Entry$==0")
etree->SetMarkerStyle(6);
etree->SetMarkerColor(2);
int n = 0;
while (1) {
in >> s;
if (!in.good())
break;
if (s.BeginsWith("]DATA]")) // last line
break;
n++;
if ((nEvents != -1) && (n > nEvents))
break;
event = atoi(s.Data());
if (event%100 == 0)
cout << "Processing event " << event << endl;
for (int i=0; i<2; i++)
in >> s; // time
Int_t ichannel = 0;
for (apv=1; apv<=nAPVs; apv++) {
in >> s; // header + analog APV data + one tick mark
int sequenceNumber = 0;
TString subString = "";
int length = s.Length();
for (int j=0; j<length; j++) {
char c = s[j];
if (c != ',') {
subString += c;
} else {
if (sequenceNumber >= 12) {
channel = sequenceNumber - 12;
adc = atoi(subString.Data());
h2d->Fill((apv - 1) * 128 + channel + 0.5, adc);
h2d32->Fill(((apv - 1) * 128 + channel)/32 + 0.5, adc);
profile->Fill((apv - 1) * 128 + channel + 0.5, adc);
//tree->Fill();
raw[ichannel] = adc;
++ichannel;
}
subString = "";
sequenceNumber++;
}
}
}
etree->Fill();
}
in.close();
TCanvas *canvas = new TCanvas;
canvas->Divide(1,2);
canvas->cd();
canvas->cd(1); h2d->Draw();
canvas->cd(2); profile->Draw();
canvas->SaveAs(eps);
// //-- TFile file(root, "RECREATE");
// h2d->Write();
// profile->Write();
// tree->Write();
// //file.Close();
cout<< "\nWrite " << etree->GetEntries() << " of tree " << etree->GetName() << " into file " << file->GetName() <<endl;
cout<< "To plot strip content use e.g. etree->Draw(\"raw:Iteration$\",\"Entry$==0\")" <<endl;
file->Write();
}
int main(int argc, char **argv)
{
TString analysis = "Lb2Lmumu";
bool MC = false;
TString base = "/afs/cern.ch/work/p/pluca/weighted/Lmumu/";
if(argc > 1)
{
string arg = argv[1];
if(arg == "MC") MC = true;
}
vector< string > novar;
novar.push_back("Lb_MassCons");
novar.push_back("Lb_MassConsLambda");
novar.push_back("Lb_MassConsJpsiLambda");
novar.push_back("cosTheta");
novar.push_back("cosThetaL");
novar.push_back("cosThetaB");
novar.push_back("phiL");
novar.push_back("phiB");
novar.push_back("dphi");
novar.push_back("cosTheta_TRUE");
novar.push_back("cosThetaL_TRUE");
novar.push_back("cosThetaB_TRUE");
novar.push_back("phiL_TRUE");
novar.push_back("phiB_TRUE");
novar.push_back("dphi_TRUE");
TCut cutJpsi = CutsDef::cutJpsi;
TCut cutMuMu = CutsDef::cutMuMu_veto;
TreeReader* treeReader = new TreeReader("tree");
TString namefile = base + "candLb";
if(MC) namefile += "_MC";
namefile += ".root";
TFile * candFile = new TFile(namefile,"recreate");
if(!MC) treeReader->AddFile(base+analysis+"_CL_NBweighted.root");
else treeReader->AddFile(base+analysis+"_MC_Pythia8_NBweighted.root");
treeReader->Initialize(novar,"except");
Analysis * anaLbMuMu = new Analysis("Lb2Lmumu","Lb",treeReader,&cutMuMu);
candFile->cd();
TTree * candLbMuMu = anaLbMuMu->applyCuts(&addVariables);
candLbMuMu->Write();
string tnameMuMu = candLbMuMu->GetName();
candFile->Close();
candFile = TFile::Open(namefile,"update");
TTree * singleCand_LbMuMu = anaLbMuMu->checkMultiple("weight",namefile,tnameMuMu,&randomKill);
singleCand_LbMuMu->Write();
if(MC)
{
treeReader = new TreeReader("tree");
treeReader->AddFile(base+"Lb2JpsiL_MC_Pythia8_NBweighted.root");
treeReader->Initialize(novar,"except");
}
Analysis * anaLbJpsi = new Analysis("Lb2JpsiL","Lb",treeReader,&cutJpsi);
candFile->cd();
TTree * candLbJpsi = anaLbJpsi->applyCuts(&addVariables);
candLbJpsi->Write();
string tnameJpsi = candLbJpsi->GetName();
candFile->Close();
candFile = TFile::Open(namefile,"update");
TTree * singleCand_LbJpsi = anaLbJpsi->checkMultiple("weight",namefile,tnameJpsi,&randomKill);
singleCand_LbJpsi->Write();
candFile->cd();
TTree * candLbJpsi_reduced = anaLbJpsi->applyCuts(&addVariables,300);
candLbJpsi_reduced->SetName("candLb2JpsiL_reduced");
candLbJpsi_reduced->Write();
if(MC)
{
candFile->cd();
TCut jpsiSwap = cutJpsi + CutsDef::jpsiSwapID;
TCut mumuSwap = cutMuMu + CutsDef::mumuSwapID;
TTree * mumuSwapTree = anaLbMuMu->applyCuts(&mumuSwap, false,&addVariables);
mumuSwapTree->SetName("candLmumuSwap");
mumuSwapTree->Write();
TTree * jpsiSwapTree = anaLbJpsi->applyCuts(&jpsiSwap, false, &addVariables);
jpsiSwapTree->SetName("candJpsiLSwap");
jpsiSwapTree->Write();
TreeReader * KSReader = new TreeReader("tree");
KSReader->AddFile(base+"Bd2JpsiKS_MC12_NBweighted.root");
KSReader->Initialize(novar,"except");
TCut cutBdLL = cutJpsi + CutsDef::LLcut;
TCut cutBdDD = cutJpsi + CutsDef::DDcut;
Analysis * KSAnalysis_LL = new Analysis("BdJpsiKS_LL","B0",KSReader,&cutBdLL);
TTree *KSTree_LL = KSAnalysis_LL->applyCuts(&addVariables);
KSTree_LL->Write();
Analysis * KSAnalysis_DD = new Analysis("BdJpsiKS_DD","B0",KSReader,&cutBdDD);
TTree *KSTree_DD = KSAnalysis_DD->applyCuts(&addVariables);
KSTree_DD->Write();
Analysis * KSAnalysis_all = new Analysis("BdJpsiKS","B0",KSReader,&cutJpsi);
TTree *KSTree = KSAnalysis_all->applyCuts(&addVariables);
KSTree->Write();
candFile->cd();
TreeReader * KstmumuReader = new TreeReader("tree");
KstmumuReader->AddFile(base+"Bu2Kstmumu_MC12_NBweighted.root");
KstmumuReader->Initialize(novar,"except");
Analysis * KstmumuAnalysis = new Analysis("BuKstmumu","B0",KstmumuReader,&cutMuMu);
TTree *KstmumuTree = KstmumuAnalysis->applyCuts(&addVariables);
KstmumuTree->Write();
candFile->cd();
TreeReader * KSmumuReader = new TreeReader("tree");
KSmumuReader->AddFile(base+"Bd2KSmumu_MC12_NBweighted.root");
KSmumuReader->Initialize(novar,"except");
Analysis * KSmumuAnalysis = new Analysis("BdKSmumu","B0",KSmumuReader,&cutMuMu);
TTree *KSmumuTree = KSmumuAnalysis->applyCuts(&addVariables);
KSmumuTree->Write();
candFile->cd();
TreeReader * JpsiGenReader = new TreeReader("tree");
JpsiGenReader->AddFile("/afs/cern.ch/work/k/kreps/public/LbLMuMuAna/generatorLevel/LbJpsiLGenOnlyDaughInAccForRadiativeTail.root");
JpsiGenReader->Initialize();
TCut JpsiTailCut = "TMath::Power(J_psi_1S_MASS/1000,2) < 8 && Lb_MASS > 5300 && Lambda0_MASS > 1105 && Lambda0_MASS < 1125";
Analysis * JpsiTailAnalysis = new Analysis("JpsiTail","Lb",JpsiGenReader,&JpsiTailCut);
TTree *JpsiTailTree = JpsiTailAnalysis->applyCuts(&RenameMass, 0.1);
JpsiTailTree->Write();
}
candFile->Close();
delete candFile;
return 0;
}
void FlagClones(string fileName = "BsphiKK_data_duplicates.root")
{
// get the input
TTree* tree = GetTree(fileName.c_str());
// clone the tree..
int num_entries = tree->GetEntries();
vector<int> flag_clones; flag_clones.resize(num_entries);
for (int i = 0; i < num_entries; ++i)
{
flag_clones[i] = 1;
}
double sort_var;
//tree->SetBranchAddress("B_s0_ENDVERTEX_CHI2",&sort_var);
UInt_t run;tree->SetBranchAddress("runNumber",&run);
ULong64_t event; tree->SetBranchAddress("eventNumber",&event);
int key1; tree->SetBranchAddress("Kminus_TRACK_Key",&key1);
int key2; tree->SetBranchAddress("Kminus0_TRACK_Key",&key2);
int key3; tree->SetBranchAddress("Kplus_TRACK_Key",&key3);
int key4; tree->SetBranchAddress("Kplus0_TRACK_Key",&key4);
int i = 0;
TRandom generator(9875);
cout << "Finding duplicate candidates in a sample containing " << num_entries << " events" << endl;
while(i < num_entries)
{
tree->GetEntry(i);
sort_var = generator.Rndm();
int run_i = run;
int event_i = event;
vector<CloneInfo> clones;
CloneTagger tagger(clones);
tagger.addToClones({key1,key2,key3,key4},i,sort_var);
int j = i+1;
for (j=i+1;j<num_entries; j++)
{
tree->GetEntry(j);
sort_var = generator.Rndm();
int run_j = run;
int event_j = event;
if(run_j!=run_i || event_j!=event_i)
{
break;
}
else
{
tagger.addToClones({key1,key2,key3,key4},j,sort_var);
}
}
tagger.sortClones();
tagger.tagClones();
if(clones.size() > 1)
{
for(auto clone : clones)
{
flag_clones[clone.i()] = clone.isAlive();
}
}
i=j;
}
// make the output
string outputName = fileName.substr(0,fileName.size() - 5);
outputName += "_Clone.root";
TFile* outFile = TFile::Open(outputName.c_str(),"RECREATE");
cout << "Reading: " << tree->GetName() << " from " << fileName << " to " << outputName << endl;
TTree* newtree = tree->CloneTree(-1);
int isAlive;
TBranch *branch_bestVtxChi2 = newtree->Branch("isDup",&isAlive, "isDup/I");
num_entries = newtree->GetEntries();
// loop again and write the branch
for (i=0;i<num_entries; i++)
{
newtree->GetEntry(i);
isAlive = flag_clones[i];
branch_bestVtxChi2->Fill();
}
newtree->Write();
outFile->Close();
return;
}
//std::mutex mtx;
void ProcessFilePar(TString fileIn, TString fileOut, TString treename, vector<TString> friends, vector<TString> branches, vector<TString> newbranches, unsigned jobid = 0, unsigned NPAR = 1)
{
//mtx.lock(); //for threads
TFile *fin = new TFile(fileIn);
TTree *tjet = (TTree*)fin->Get(treename);
//mtx.unlock();
vector<TTree *> friendTrees;
vector<bool> sameFileFriend;
for (auto f:friends) {
auto fr = tokenize(f,":");
if (fr.size()==1) {tjet->AddFriend(fr[0]); sameFileFriend.push_back(true);}
else if (fr.size()==2) {tjet->AddFriend(fr[1],fr[0]); sameFileFriend.push_back(false);}
TTree *tfriend = (TTree*)fin->Get(f);
friendTrees.push_back(tfriend);
}
AddBranchesByCounter(tjet, branches);
for (unsigned i=0;i<friendTrees.size();i++) AddBranchesByCounter(friendTrees[i],branches);
//sort branches into categories
for (auto bName:branches) {
TBranch *b=tjet->GetBranch(bName);
if (b==0) cout <<"Branch "<<bName<<" doesn't exist!"<<endl;
//parse in case there is a tree name in the branch
auto branchtoken = tokenize(bName,".");
auto leafname = branchtoken[branchtoken.size()-1];
TObjArray *bl = b->GetListOfLeaves();
if (bl->GetEntries()>1)
cout <<" Branch "<<b->GetTitle()<<" has more than 1 leave. Taking first..."<<endl;
if (bl->GetEntries()==0) {
cout <<" Branch "<<b->GetTitle()<<" has no leaves! Skipping..."<<endl;
continue;
}
TLeaf * l = (TLeaf *)(*bl)[0];
//what's the type?
TString type = l->GetTypeName();
if (VERBOSE) cout<<l->GetTitle()<<endl;
//array?
bool array = l->GetLeafCount()!=0;
TString counter;
if (array) counter = l->GetLeafCount()->GetBranch()->GetName();
if (type=="Float_t")
{ if (array) {brVFloat.push_back(bName); brVFloatCounter.push_back(counter); }else brFloat.push_back(bName);}
else if (type=="Int_t")
{ if (array) {brVInt.push_back(bName); brVIntCounter.push_back(counter); }else brInt.push_back(bName);}
else cout << "Unsupported branch type "<<type<<" for branch "<<bName<<". Skipping..."<<endl;
}
//treat counters as ints only
AppendToListUniquely(brVIntCounter, brInt);
AppendToListUniquely(brVFloatCounter, brInt);
//too keep track of old branches, which cannot be read (todo: just check it...)
int noldbrInt = brInt.size(), noldbrFloat = brFloat.size(), noldbrVInt = brVInt.size(), noldbrVIntCounter = brVIntCounter.size(), noldbrVFloat = brVFloat.size(), noldbrVFloatCounter = brVFloatCounter.size();
//add new branches
ParseNewBranches(newbranches, brInt, brFloat, brVInt, brVIntCounter, brVFloat, brVFloatCounter);
//print for debugging
if (VERBOSE) {
cout<<"int : "; for (auto s:brInt) cout <<s<<", "; cout<<endl;
cout<<"float : "; for (auto s:brFloat) cout <<s<<", "; cout<<endl;
cout<<"Vint : "; for (auto s:brVInt) cout <<s<<", "; cout<<endl;
cout<<"Vfloat : "; for (auto s:brVFloat) cout <<s<<", "; cout<<endl;
cout<<"Vintcnt : "; for (auto s:brVIntCounter) cout <<s<<", "; cout<<endl;
cout<<"Vfloatcnt : "; for (auto s:brVFloatCounter) cout <<s<<", "; cout<<endl;
}
tjet->SetBranchStatus("*",1);
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,0);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) {unsigned f=0; tjet->SetBranchStatus(b,0,&f); if (VERBOSE) cout<<"turning off "<<b<<", found = "<<f<<endl;}
TFile *fout = new TFile(fileOut,"recreate");
TTree *tjetout;
//in case of one-to-many event - do not copy branches automatically!
if (useOneToOne) tjetout = tjet->CloneTree(0);
else tjetout = new TTree(tjet->GetName(),tjet->GetTitle());
//think about memory tree
// tjetout->SetDirectory(0);
tjetout->SetName(tjet->GetName());
//TTree *tjetout = new TTree("t","t");
//to see what is copied...
//tjetout->Print();
for (auto b:brVFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brFloat) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brVInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
for (auto b:brInt) if (tjet->GetBranch(b)!=0) tjet->SetBranchStatus(b,1);
vector<int> valIntIn(brInt.size()), valIntOut(brInt.size());
vector<float> valFloatIn(brFloat.size()), valFloatOut(brFloat.size());
vector<vector<int> >valVIntIn (brVInt.size()); vector<vector<int> >valVIntOut (brVInt.size());
vector<vector<float> >valVFloatIn (brVFloat.size()); vector<vector<float> >valVFloatOut (brVFloat.size());
for (unsigned i=0;i<brInt.size();i++) {
if (tjet->GetBranch(brInt[i])!=0)
tjet->SetBranchAddress(brInt[i],&valIntIn[i]);
if (tjetout->GetBranch(brInt[i])!=0) {//why would it?
tjetout->SetBranchAddress(brInt[i],&valIntOut[i]);
cout<<"branch "<<brInt[i]<<" already exist for some reason..."<<endl;
}
else //logical...
if (NonFriendBranch(tjet, brInt[i]))
tjetout->Branch(brInt[i],&valIntOut[i],Form("%s/I",brInt[i].Data()));
}
for (unsigned i=0;i<brFloat.size();i++) {
if (tjet->GetBranch(brFloat[i])!=0)
tjet->SetBranchAddress(brFloat[i],&valFloatIn[i]);
if (NonFriendBranch(tjet, brFloat[i]))
tjetout->Branch(brFloat[i],&valFloatOut[i],Form("%s/F",brFloat[i].Data()));
}
for (unsigned i=0;i<brVFloat.size();i++) {
if (tjet->GetBranch(brVFloat[i])!=0) {
valVFloatIn[i] = vector<float>(NMAX);
tjet->SetBranchAddress(brVFloat[i],&valVFloatIn[i][0]);
}
valVFloatOut[i] = vector<float>(NMAX);
if (NonFriendBranch(tjet, brVFloat[i]))
tjetout->Branch(brVFloat[i],&valVFloatOut[i][0],Form("%s[%s]/F",brVFloat[i].Data(),brVFloatCounter[i].Data()));
}
for (unsigned i=0;i<brVInt.size();i++) {
if (tjet->GetBranch(brVInt[i])) {
valVIntIn[i] = vector<int>(NMAX);
tjet->SetBranchAddress(brVInt[i],&valVIntIn[i][0]);
}
valVIntOut[i] = vector<int>(NMAX);
if (NonFriendBranch(tjet, brVInt[i]))
tjetout->Branch(brVInt[i],&valVIntOut[i][0],Form("%s[%s]/I",brVInt[i].Data(),brVIntCounter[i].Data()));
}
Long64_t nentries = tjet->GetEntries();
int nentries1 = nentries/NPAR*jobid;
int nentries2 = nentries/NPAR*(jobid+1);
nentries = nentries2-nentries1;
int oneperc = nentries/100; if (oneperc==0) oneperc = 1;
cout<<"Start processing..."<<endl;
TStopwatch s;
s.Start();
TTimeStamp t0;
double readTime = 0, processingTime = 0, copyToTime = 0, cloneTime=0, copyFromTime=0, fillTime = 0;
for (Long64_t i=0; i<nentries;i++) {
if (jobid==0 && i % oneperc == 0 && i>0) {
std::cout << std::fixed;
TTimeStamp t1; cout<<" \r"<<i/oneperc<<"% "<<" est. time "<<setprecision(2) <<(t1-t0)*nentries/(i+.1)<<" s ";
cout<<";Processing:"<<setprecision(2)<<processingTime/(t1-t0)*100<<" %";
cout<<";Copy1:"<<setprecision(2) <<copyToTime/(t1-t0)*100<<" %";
cout<<";Clone:"<<setprecision(2) <<cloneTime/(t1-t0)*100<<" %";
cout<<";Copy2:"<<setprecision(2) <<copyFromTime/(t1-t0)*100<<" %";
cout<<";Fill:"<<setprecision(2) <<fillTime/(t1-t0)*100<<" %";
cout<<";Read:"<<setprecision(2) <<readTime/(t1-t0)*100<<" %";
cout<<flush;
}
TTimeStamp tsRead0;
tjet->GetEntry(i+nentries1);
TTimeStamp tsRead1;
readTime+=tsRead1-tsRead0;
Everything ev;
TTimeStamp tsCpTo0;
for (unsigned j=0;j<brInt.size();j++) ev.PutInt(brInt[j],valIntIn[j]);
for (unsigned j=0;j<brFloat.size();j++) ev.PutFloat(brFloat[j],valFloatIn[j]);
for (unsigned j=0;j<brVFloat.size();j++) ev.PutVFloat(brVFloat[j],brVFloatCounter[j],valVFloatIn[j]);
for (unsigned j=0;j<brVInt.size();j++) ev.PutVInt(brVInt[j],brVIntCounter[j],valVIntIn[j]);
TTimeStamp tsCpTo1;
copyToTime+=tsCpTo1-tsCpTo0;
TTimeStamp tsCl0;
//think about: copy object (timing 10% ->3%)
//but it copies vectors, so push_back will add in the end...
// Everything evout = ev;
//or even reference(in place?) (->0.2%)
//Everything &evout = ev;
Everything evout = ev.CloneStructure();
TTimeStamp tsCl1;
cloneTime+=tsCl1-tsCl0;
bool exitEvent = false;
int counter = 0;
while (!exitEvent) {
TTimeStamp tsPr0;
if (useOneToOne) {
fProcessOneToOne(ev, evout);
evout.UpdateCounters();
exitEvent = true;
} else {
exitEvent = fProcessOneToMany(ev, evout, counter);
// if (!exitEvent) cout<<"event to write "<<counter<<endl;
counter++;
}
TTimeStamp tsPr1;
processingTime+=tsPr1-tsPr0;
//Everything evout = ev;
TTimeStamp tsCpFrom0;
for (unsigned j=0;j<brInt.size();j++) valIntOut[j] = evout.GetInt(brInt[j]);
for (unsigned j=0;j<brFloat.size();j++) {valFloatOut[j] = evout.GetFloat(brFloat[j]);
// cout<<brFloat[j]<<" "<<evout.GetFloat(brFloat[j])<<endl;
}
for (unsigned j=0;j<brVFloat.size();j++) valVFloatOut[j] = evout[brVFloat[j]];
for (unsigned j=0;j<brVInt.size();j++) valVIntOut[j] = evout.GetVInt(brVInt[j]);
TTimeStamp tsCpFrom1;
copyFromTime+=tsCpFrom1-tsCpFrom0;
TTimeStamp tsFill0;
tjetout->Fill();
TTimeStamp tsFill1;
fillTime+=tsFill1-tsFill0;
}
}
cout<<endl;
s.Stop();
cout<<"Done in ";s.Print();
tjetout->FlushBaskets();
tjetout->Write();
cout<<"Copying other trees..."<<endl;
for (unsigned i=0;i<friendTrees.size();i++) {
TTree *t = friendTrees[i];
if (sameFileFriend[i]) {
//TTree *triendout = t->CloneTree(-1,"fast");
TTree *triendout = t->CopyTree("","",nentries,nentries1);
triendout->Write();
}
}
fout->Close();
friendTrees.clear();
}
//**********MAIN**************************************************************************
int main(int argc, char* argv[])
{
if(argc < 2)
{
cout << argv[0] << " cfg file " << "[run]" << endl;
return -1;
}
//---memory consumption tracking---
float cpu[2]{0}, mem[2]={0}, vsz[2]={0}, rss[2]={0};
//---load options---
CfgManager opts;
opts.ParseConfigFile(argv[1]);
//-----input setup-----
if(argc > 2)
{
vector<string> run(1, argv[2]);
opts.SetOpt("h4reco.run", run);
}
string outSuffix = opts.GetOpt<string>("h4reco.outNameSuffix");
string run = opts.GetOpt<string>("h4reco.run");
TChain* inTree = new TChain("H4tree");
ReadInputFiles(opts, inTree);
H4Tree h4Tree(inTree);
//-----output setup-----
uint64 index=stoul(run)*1e9;
TFile* outROOT = new TFile("ntuples/"+outSuffix+TString(run)+".root", "RECREATE");
outROOT->cd();
RecoTree mainTree(&index);
//---Get plugin sequence---
PluginLoader<PluginBase>* loader;
vector<PluginLoader<PluginBase>* > pluginLoaders;
map<string, PluginBase*> pluginMap;
vector<PluginBase*> pluginSequence;
vector<string> pluginList = opts.GetOpt<vector<string> >("h4reco.pluginList");
//---plugin creation
pluginLoaders.reserve(pluginList.size());
for(auto& plugin : pluginList)
{
cout << ">>> Loading plugin <" << plugin << ">" << endl;
//---create loader
loader = new PluginLoader<PluginBase>(opts.GetOpt<string>(plugin+".pluginType"));
pluginLoaders.push_back(loader);
pluginLoaders.back()->Create();
//---get instance and put it in the plugin sequence
PluginBase* newPlugin = pluginLoaders.back()->CreateInstance();
if(newPlugin)
{
pluginSequence.push_back(newPlugin);
pluginSequence.back()->SetInstanceName(plugin);
pluginMap[plugin] = pluginSequence.back();
}
else
{
cout << ">>> ERROR: plugin type " << opts.GetOpt<string>(plugin+".pluginType") << " is not defined." << endl;
return 0;
}
}
//---begin
for(auto& plugin : pluginSequence)
{
plugin->Begin(opts, &index);
for(auto& shared : plugin->GetSharedData("", "TTree", true))
{
TTree* tree = (TTree*)shared.obj;
tree->SetMaxVirtualSize(10000);
tree->SetDirectory(outROOT);
}
}
//---events loop
int maxEvents=opts.GetOpt<int>("h4reco.maxEvents");
cout << ">>> Processing H4DAQ run #" << run << " <<<" << endl;
while(h4Tree.NextEntry() && (index-stoul(run)*1e9<maxEvents || maxEvents==-1))
{
if(index % 1000 == 0)
{
cout << ">>>Processed events: " << index-stoul(run)*1e9 << "/"
<< (maxEvents<0 ? h4Tree.GetEntries() : min((int)h4Tree.GetEntries(), maxEvents))
<< endl;
TrackProcess(cpu, mem, vsz, rss);
}
//---call ProcessEvent for each plugin
for(auto& plugin : pluginSequence)
plugin->ProcessEvent(h4Tree, pluginMap, opts);
//---fill the main tree with info variables and increase event counter
mainTree.time_stamp = h4Tree.evtTimeStart;
mainTree.run = h4Tree.runNumber;
mainTree.spill = h4Tree.spillNumber;
mainTree.event = h4Tree.evtNumber;
mainTree.Fill();
++index;
}
//---end
for(auto& plugin : pluginSequence)
{
//---call endjob for each plugin
plugin->End(opts);
//---get permanent data from each plugin and store them in the out file
for(auto& shared : plugin->GetSharedData())
{
if(shared.obj->IsA()->GetName() == string("TTree"))
{
TTree* currentTree = (TTree*)shared.obj;
outROOT->cd();
currentTree->BuildIndex("index");
currentTree->Write(currentTree->GetName(), TObject::kOverwrite);
mainTree.AddFriend(currentTree->GetName());
}
else
{
outROOT->cd();
shared.obj->Write(shared.tag.c_str(), TObject::kOverwrite);
}
}
}
//---close
mainTree.Write();
opts.Write("cfg");
outROOT->Close();
for(auto& loader : pluginLoaders)
loader->Destroy();
//---info
TrackProcess(cpu, mem, vsz, rss);
exit(0);
}
void ZeeGammaMassFitSystematicStudy(string workspaceFile, const Int_t seed = 1234,
Int_t Option = 0, Int_t NToys = 1) {
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
TRandom3 *randomnumber = new TRandom3(seed);
// RooRealVar m("m","mass",60,130);
RooCategory sample("sample","");
sample.defineType("Pass",1);
sample.defineType("Fail",2);
//--------------------------------------------------------------------------------------------------------------
//Load Workspace
//==============================================================================================================
TFile *f = new TFile (workspaceFile.c_str(), "READ");
RooWorkspace *w = (RooWorkspace*)f->Get("MassFitWorkspace");
//--------------------------------------------------------------------------------------------------------------
//Setup output tree
//==============================================================================================================
TFile *outputfile = new TFile (Form("EffToyResults_Option%d_Seed%d.root",Option, seed), "RECREATE");
float varEff = 0;
float varEffErrL = 0;
float varEffErrH = 0;
TTree *outTree = new TTree("eff","eff");
outTree->Branch("eff",&varEff, "eff/F");
outTree->Branch("efferrl",&varEffErrL, "efferrl/F");
outTree->Branch("efferrh",&varEffErrH, "efferrh/F");
//--------------------------------------------------------------------------------------------------------------
//Load Model
//==============================================================================================================
RooSimultaneous *totalPdf = (RooSimultaneous*)w->pdf("totalPdf");
RooRealVar *m_default = (RooRealVar*)w->var("m");
m_default->setRange("signalRange",85, 95);
//get default models
RooAddPdf *modelPass_default = (RooAddPdf*)w->pdf("modelPass");
RooAddPdf *modelFail_default = (RooAddPdf*)w->pdf("modelFail");
//get variables
RooRealVar *Nsig = (RooRealVar*)w->var("Nsig");
RooRealVar *eff = (RooRealVar*)w->var("eff");
RooRealVar *NbkgFail = (RooRealVar*)w->var("NbkgFail");
RooFormulaVar NsigPass("NsigPass","eff*Nsig",RooArgList(*eff,*Nsig));
RooFormulaVar NsigFail("NsigFail","(1.0-eff)*Nsig",RooArgList(*eff,*Nsig));
//get number of expected events
Double_t npass = 100;
Double_t nfail = 169;
//*************************************************************************************
//make alternative model
//*************************************************************************************
RooRealVar *tFail_default = (RooRealVar*)w->var("tFail");
RooRealVar *fracFail_default = (RooRealVar*)w->var("fracFail");
RooRealVar *meanFail_default = (RooRealVar*)w->var("meanFail");
RooRealVar *sigmaFail_default = (RooRealVar*)w->var("sigmaFail");
RooHistPdf *bkgFailTemplate_default = (RooHistPdf*)w->pdf("bkgHistPdfFail");
RooFFTConvPdf *sigFail_default = (RooFFTConvPdf*)w->pdf("signalFail");
RooFFTConvPdf *bkgFail_default = (RooFFTConvPdf*)w->pdf("bkgConvPdfFail");
RooExtendPdf *esignalFail_default = (RooExtendPdf *)w->pdf("esignalFail");
RooExtendPdf *ebackgroundFail_default = (RooExtendPdf *)w->pdf("ebackgroundFail");
RooExponential *bkgexpFail_default = (RooExponential*)w->pdf("bkgexpFail");
RooAddPdf *backgroundFail_default = (RooAddPdf*)w->pdf("backgroundFail");
RooGaussian *bkggausFail_default = (RooGaussian*)w->pdf("bkggausFail");
//shifted mean
RooRealVar *meanFail_shifted = new RooRealVar("meanFail_shifted","meanFail_shifted", 0, -5, 5);
meanFail_shifted->setVal(meanFail_default->getVal());
if (Option == 1) meanFail_shifted->setVal(meanFail_default->getVal()-1.0);
else if (Option == 2) meanFail_shifted->setVal(meanFail_default->getVal()+1.0);
else if (Option == 11) meanFail_shifted->setVal(meanFail_default->getVal()-2.0);
else if (Option == 12) meanFail_shifted->setVal(meanFail_default->getVal()+2.0);
RooRealVar *sigmaFail_shifted = new RooRealVar("sigmaFail_shifted","sigmaFail_shifted", 0, -5, 5);
sigmaFail_shifted->setVal(sigmaFail_default->getVal());
if (Option == 3) sigmaFail_shifted->setVal(sigmaFail_default->getVal()*1.2);
else if (Option == 4) sigmaFail_shifted->setVal(sigmaFail_default->getVal()*0.8);
CMCBkgTemplateConvGaussianPlusExp *bkgFailModel = new CMCBkgTemplateConvGaussianPlusExp(*m_default,bkgFailTemplate_default,false,meanFail_shifted,sigmaFail_shifted, "shifted");
bkgFailModel->t->setVal(tFail_default->getVal());
bkgFailModel->frac->setVal(fracFail_default->getVal());
cout << "mean : " << meanFail_default->getVal() << " - " << meanFail_shifted->getVal() << endl;
cout << "sigma : " << sigmaFail_default->getVal() << " - " << sigmaFail_shifted->getVal() << endl;
cout << "t: " << tFail_default->getVal() << " - " << bkgFailModel->t->getVal() << endl;
cout << "frac: " << fracFail_default->getVal() << " - " << bkgFailModel->frac->getVal() << endl;
cout << "eff: " << eff->getVal() << " : " << NsigPass.getVal() << " / " << (NsigPass.getVal() + NsigFail.getVal()) << endl;
cout << "NbkgFail: " << NbkgFail->getVal() << endl;
//make alternative fail model
RooAddPdf *modelFail=0;
RooExtendPdf *esignalFail=0, *ebackgroundFail=0;
ebackgroundFail = new RooExtendPdf("ebackgroundFail_shifted","ebackgroundFail_shifted",*(bkgFailModel->model),*NbkgFail,"signalRange");
modelFail = new RooAddPdf("modelFail","Model for FAIL sample", RooArgList(*esignalFail_default,*ebackgroundFail));
cout << "*************************************\n";
ebackgroundFail->Print();
cout << "*************************************\n";
ebackgroundFail_default->Print();
cout << "*************************************\n";
modelFail->Print();
cout << "*************************************\n";
modelFail_default->Print();
cout << "*************************************\n";
TCanvas *cv = new TCanvas("cv","cv",800,600);
RooPlot *mframeFail_default = m_default->frame(Bins(Int_t(130-60)/2));
modelFail_default->plotOn(mframeFail_default);
modelFail_default->plotOn(mframeFail_default,Components("ebackgroundFail"),LineStyle(kDashed),LineColor(kRed));
modelFail_default->plotOn(mframeFail_default,Components("bkgexpFail"),LineStyle(kDashed),LineColor(kGreen+2));
mframeFail_default->GetYaxis()->SetTitle("");
mframeFail_default->GetYaxis()->SetTitleOffset(1.2);
mframeFail_default->GetXaxis()->SetTitle("m_{ee#gamma} [GeV/c^{2}]");
mframeFail_default->GetXaxis()->SetTitleOffset(1.05);
mframeFail_default->SetTitle("");
mframeFail_default->Draw();
cv->SaveAs("DefaultModel.gif");
RooPlot *mframeFail = m_default->frame(Bins(Int_t(130-60)/2));
modelFail->plotOn(mframeFail);
modelFail->plotOn(mframeFail,Components("ebackgroundFail_shifted"),LineStyle(kDashed),LineColor(kRed));
modelFail->plotOn(mframeFail,Components("bkgexpFail_shifted"),LineStyle(kDashed),LineColor(kGreen+2));
mframeFail->GetYaxis()->SetTitle("");
mframeFail->GetYaxis()->SetTitleOffset(1.2);
mframeFail->GetXaxis()->SetTitle("m_{ee#gamma} [GeV/c^{2}]");
mframeFail->GetXaxis()->SetTitleOffset(1.05);
mframeFail->SetTitle("");
mframeFail->Draw();
cv->SaveAs(Form("ShiftedModel_%d.gif",Option));
//*************************************************************************************
//Do Toys
//*************************************************************************************
for(uint t=0; t < NToys; ++t) {
RooDataSet *pseudoData_pass = modelPass_default->generate(*m_default, randomnumber->Poisson(npass));
RooDataSet *pseudoData_fail = 0;
pseudoData_fail = modelFail->generate(*m_default, randomnumber->Poisson(nfail));
RooDataSet *pseudoDataCombined = new RooDataSet("pseudoDataCombined","pseudoDataCombined",RooArgList(*m_default),
RooFit::Index(sample),
RooFit::Import("Pass",*pseudoData_pass),
RooFit::Import("Fail",*pseudoData_fail));
pseudoDataCombined->write(Form("toy%d.txt",t));
RooFitResult *fitResult=0;
fitResult = totalPdf->fitTo(*pseudoDataCombined,
RooFit::Extended(),
RooFit::Strategy(2),
//RooFit::Minos(RooArgSet(eff)),
RooFit::Save());
cout << "\n\n";
cout << "Eff Fit: " << eff->getVal() << " -" << fabs(eff->getErrorLo()) << " +" << eff->getErrorHi() << endl;
//Fill Tree
varEff = eff->getVal();
varEffErrL = fabs(eff->getErrorLo());
varEffErrH = eff->getErrorHi();
outTree->Fill();
// //*************************************************************************************
// //Plot Toys
// //*************************************************************************************
// TCanvas *cv = new TCanvas("cv","cv",800,600);
// char pname[50];
// char binlabelx[100];
// char binlabely[100];
// char yield[50];
// char effstr[100];
// char nsigstr[100];
// char nbkgstr[100];
// char chi2str[100];
// //
// // Plot passing probes
// //
// RooPlot *mframeFail_default = m.frame(Bins(Int_t(130-60)/2));
// modelFail_default->plotOn(mframeFail_default);
// modelFail_default->plotOn(mframeFail_default,Components("ebackgroundFail"),LineStyle(kDashed),LineColor(kRed));
// modelFail_default->plotOn(mframeFail_default,Components("bkgexpFail"),LineStyle(kDashed),LineColor(kGreen+2));
// mframeFail_default->Draw();
// cv->SaveAs("DefaultModel.gif");
// RooPlot *mframeFail = m.frame(Bins(Int_t(130-60)/2));
// modelFail->plotOn(mframeFail);
// modelFail->plotOn(mframeFail,Components("ebackgroundFail_shifted"),LineStyle(kDashed),LineColor(kRed));
// modelFail->plotOn(mframeFail,Components("bkgexpFail_shifted"),LineStyle(kDashed),LineColor(kGreen+2));
// sprintf(yield,"%u Events",(Int_t)passTree->GetEntries());
// sprintf(nsigstr,"N_{sig} = %.1f #pm %.1f",NsigPass.getVal(),NsigPass.getPropagatedError(*fitResult));
// plotPass.AddTextBox(yield,0.21,0.76,0.51,0.80,0,kBlack,-1);
// plotPass.AddTextBox(effstr,0.70,0.85,0.94,0.90,0,kBlack,-1);
// plotPass.AddTextBox(0.70,0.73,0.94,0.83,0,kBlack,-1,1,nsigstr);//,chi2str);
// mframeFail->Draw();
// cv->SaveAs(Form("ShiftedModel_%d.gif",Option));
// //
// // Plot failing probes
// //
// sprintf(pname,"fail%s_%i",name.Data(),ibin);
// sprintf(yield,"%u Events",(Int_t)failTree->GetEntries());
// sprintf(nsigstr,"N_{sig} = %.1f #pm %.1f",NsigFail.getVal(),NsigFail.getPropagatedError(*fitResult));
// sprintf(nbkgstr,"N_{bkg} = %.1f #pm %.1f",NbkgFail.getVal(),NbkgFail.getPropagatedError(*fitResult));
// sprintf(chi2str,"#chi^{2}/DOF = %.3f",mframePass->chiSquare(nflfail));
// CPlot plotFail(pname,mframeFail,"Failing probes","tag-probe mass [GeV/c^{2}]","Events / 2.0 GeV/c^{2}");
// plotFail.AddTextBox(binlabelx,0.21,0.85,0.51,0.90,0,kBlack,-1);
// if((name.CompareTo("etapt")==0) || (name.CompareTo("etaphi")==0)) {
// plotFail.AddTextBox(binlabely,0.21,0.80,0.51,0.85,0,kBlack,-1);
// plotFail.AddTextBox(yield,0.21,0.76,0.51,0.80,0,kBlack,-1);
// } else {
// plotFail.AddTextBox(yield,0.21,0.81,0.51,0.85,0,kBlack,-1);
// }
// plotFail.AddTextBox(effstr,0.70,0.85,0.94,0.90,0,kBlack,-1);
// plotFail.AddTextBox(0.70,0.68,0.94,0.83,0,kBlack,-1,2,nsigstr,nbkgstr);//,chi2str);
// plotFail.Draw(cfail,kTRUE,format);
} //for loop over all toys
//*************************************************************************************
//Save To File
//*************************************************************************************
outputfile->WriteTObject(outTree, outTree->GetName(), "WriteDelete");
}
void SkimClassification(TString process="ZnnH125")
{
gROOT->LoadMacro("HelperFunctions.h" ); // make functions visible to TTreeFormula
gROOT->SetBatch(1);
//TChain * chain = new TChain("tree");
//TString fname = "";
//TString dijet = "DiJetPt_";
//TString dirMC = "dcache:/pnfs/cms/WAX/resilient/jiafu/ZnunuHbb/" + tagMC + "/";
//TString dirData = "dcache:/pnfs/cms/WAX/resilient/jiafu/ZnunuHbb/" + tagData + "/";
TString indir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Spring15_PU20bx25/skimV12_v2/step3/";
TString outdir = "/afs/cern.ch/work/d/degrutto/public/MiniAOD/ZnnHbb_Spring15_PU20bx25/skimV12_v2/step3/skim_ZnnH_classification/";
TString prefix = "Step3_";
TString suffix = ".root";
TFile *input = TFile::Open(indir + prefix + process + suffix);
if (!input) {
std::cout << "ERROR: Could not open input file." << std::endl;
exit(1);
}
TTree *tree = (TTree *) input->Get("tree");
Long64_t entries = tree->GetEntriesFast();
// Make output directory if it doesn't exist
if (gSystem->AccessPathName(outdir))
gSystem->mkdir(outdir);
TString outname = outdir + prefix + Form("%s.root", process.Data());
TFile* output = TFile::Open(outname, "RECREATE");
// Get selections
const std::vector < std::string > & selExpressions = GetSelExpressions("ZnunuHighPt") ;
// const UInt_t nsels = 3; // ZnunuHighPt, ZnunuLowPt, ZnunuLowCSV
const UInt_t nsels = 1; // just one now... ZnunuHighPt, ZnunuLowPt, ZnunuLowCSV
// assert(nsels == selExpressions.size()); <-- fixME
// even-number events for training, odd-number events for testing
TCut evenselection = "evt %2 == 0";
TCut oddselection = "evt %2 == 1";
TTreeFormula *ttf = 0;
std::vector < TTreeFormula * >::const_iterator formIt, formItEnd;
// Loop over selections
std::vector<Long64_t> ventries;
for (unsigned int i = 0; i < nsels; i++) {
TString selname = "ZnunuHighPt";
if (i == 1) {
selname = "ZnunuMedPt";
// selExpressions = GetSelExpressions("ZnunuMedPt") ;
} else if (i == 2) {
selname = "ZnunuLowPt";
// selExpressions = GetSelExpressions("ZnunuLowPt") ;
}
TTree *t1 = (TTree*) tree->CloneTree(0);
TTree *t2 = (TTree*) tree->CloneTree(0);
t1->SetName(TString::Format("%s_%s_train", tree->GetName(), selname.Data()));
t2->SetName(TString::Format("%s_%s", tree->GetName(), selname.Data()));
// The clones should not delete any shared i/o buffers.
ResetDeleteBranches(t1);
ResetDeleteBranches(t2);
ttf = new TTreeFormula(Form("ttfsel%i", i), selExpressions.at(i).c_str(), tree);
ttf->SetQuickLoad(1);
TTreeFormula *ttf1 = new TTreeFormula(Form("ttfeven%i", i), evenselection, tree);
ttf1->SetQuickLoad(1);
TTreeFormula *ttf2 = new TTreeFormula(Form("ttfodd%i", i), oddselection, tree);
ttf2->SetQuickLoad(1);
if (!ttf || !ttf->GetNdim()) {
std::cerr << "ERROR: Failed to find any TTree variable from the selection: " << selExpressions.at(i) << std::endl;
return;
}
/// Loop over events
Int_t curTree = tree->GetTreeNumber();
const Long64_t nentries = tree->GetEntries();
for (Long64_t ievt = 0; ievt < nentries; ievt++) {
Long64_t entryNumber = tree->GetEntryNumber(ievt);
if (entryNumber < 0) break;
Long64_t localEntry = tree->LoadTree(entryNumber);
if (localEntry < 0) break;
if (tree->GetTreeNumber() != curTree) {
curTree = tree->GetTreeNumber();
ttf ->UpdateFormulaLeaves(); // if using TChain
ttf1->UpdateFormulaLeaves(); // if using TChain
ttf2->UpdateFormulaLeaves(); // if using TChain
}
const Int_t ndata = ttf->GetNdata();
Bool_t keep = kFALSE;
for(Int_t current = 0; current<ndata && !keep; current++) {
keep |= (bool(ttf->EvalInstance(current)) != 0);
}
if (!keep) continue;
bool even = (bool) ttf1->EvalInstance();
bool odd = (bool) ttf2->EvalInstance();
if (even && odd) {
std::cerr << "ERROR: An event cannot be even and odd at the same time." << std::cout;
return;
}
tree->GetEntry(entryNumber, 1); // get all branches
if (even) {
t1->Fill();
} else {
t2->Fill();
}
} // end loop over events
t1->Write();
t2->Write();
ventries.push_back(t1->GetEntriesFast() + t2->GetEntriesFast());
delete ttf;
delete ttf1;
delete ttf2;
}
std::clog << process << ": skimmed from " << entries << " to " << ventries[0] << " (ZnunuHighPt), " << ventries[1] << " (ZnunuLowPt), " << ventries[2] << " (ZnunuLowCSV) " << " entries." << std::endl;
output->Close();
input->Close();
delete output;
delete input;
return;
}
void fullPedestalAnalysis(string inputDIR, string outputDIR, string inputCablingMap, string outputFileName){
gROOT->ProcessLine("gErrorIgnoreLevel = 1");
// open the file and prepare the cluster tree, adding the other trees as frined --> memory consuming
std::cout<<"##################################"<<std::endl;
std::cout<<"###### fullPedestalAnalysis ######"<<std::endl;
std::cout<<"##################################"<<std::endl;
clock_t tStart = clock();
// prepare style and load macros
setTDRStyle();
gROOT->SetBatch(kTRUE);
system(("mkdir -p "+outputDIR).c_str());
ifstream file;
std::cout<<"### Make input file list"<<std::endl;
system(("find "+inputDIR+" -name \"*.root\" > file.temp").c_str());
std::ifstream infile;
string line;
vector<string> fileList;
infile.open("file.temp",ifstream::in);
if(infile.is_open()){
while(!infile.eof()){
getline(infile,line);
if(line != "" and TString(line).Contains(".root") and line !="\n"){
fileList.push_back(line);
}
}
}
system("rm file.temp");
std::sort(fileList.begin(),fileList.end());
TFile* cablingFile = TFile::Open(inputCablingMap.c_str(),"READ");
cablingFile->cd();
TTree* readoutMap = (TTree*) cablingFile->FindObjectAny("readoutMap");
TTreeReader reader(readoutMap);
TTreeReaderValue<uint32_t> detid (reader,"detid");
TTreeReaderValue<uint16_t> fecCrate (reader,"fecCrate");
TTreeReaderValue<uint16_t> fecSlot (reader,"fecSlot");
TTreeReaderValue<uint16_t> fecRing (reader,"fecRing");
TTreeReaderValue<uint16_t> ccuAdd (reader,"ccuAdd");
TTreeReaderValue<uint16_t> ccuChan (reader,"ccuChan");
TTreeReaderValue<uint16_t> lldChannel (reader,"lldChannel");
TTreeReaderValue<uint16_t> fedId (reader,"fedId");
TTreeReaderValue<uint16_t> fedCh (reader,"fedCh");
// output tree
TFile* ouputTreeFile = new TFile((outputDIR+"/"+outputFileName).c_str(),"RECREATE");
ouputTreeFile->cd();
ouputTreeFile->SetCompressionLevel(0);
TTree* outputTree = new TTree("pedestalFullNoise","pedestalFullNoise");
// branches
uint32_t detid_,fedKey_;
uint16_t fecCrate_,fecSlot_, fecRing_, ccuAdd_, ccuChan_, lldChannel_, fedId_, fedCh_, apvId_, stripId_;
float noiseMean_,noiseRMS_, noiseSkewness_, noiseKurtosis_;
float fitChi2_, fitChi2Probab_, fitStatus_;
float fitGausMean_, fitGausSigma_, fitGausNormalization_;
float fitGausMeanError_, fitGausSigmaError_, fitGausNormalizationError_;
float noiseIntegral3Sigma_, noiseIntegral3SigmaFromFit_;
float noiseIntegral4Sigma_, noiseIntegral4SigmaFromFit_;
float noiseIntegral5Sigma_, noiseIntegral5SigmaFromFit_;
float kSValue_, kSProbab_, jBValue_, jBProbab_, aDValue_, aDProbab_;
vector<float> noiseDistribution_, noiseDistributionError_;
float xMin_, xMax_, nBin_ ;
outputTree->Branch("detid",&detid_,"detid/i");
outputTree->Branch("fedKey",&fedKey_,"fedKey/i");
outputTree->Branch("fecCrate",&fecCrate_,"fecCrate/s");
outputTree->Branch("fecSlot",&fecSlot_,"fecSlot/s");
outputTree->Branch("fecRing",&fecRing_,"fecRing/s");
outputTree->Branch("ccuAdd",&ccuAdd_,"ccuAdd/s");
outputTree->Branch("ccuChan",&ccuChan_,"ccuChan/s");
outputTree->Branch("lldChannel",&lldChannel_,"lldChannel/s");
outputTree->Branch("fedId",&fedId_,"fedId/s");
outputTree->Branch("fedCh",&fedCh_,"fedCh/s");
outputTree->Branch("apvId",&apvId_,"apvId/s");
outputTree->Branch("stripId",&stripId_,"stripId/s");
outputTree->Branch("noiseMean",&noiseMean_,"noiseMean/F");
outputTree->Branch("noiseRMS",&noiseRMS_,"noiseRMS/F");
outputTree->Branch("noiseSkewness",&noiseSkewness_,"noiseSkewness/F");
outputTree->Branch("noiseKurtosis",&noiseKurtosis_,"noiseKurtosis/F");
outputTree->Branch("fitGausNormalization",&fitGausNormalization_,"fitGausNormalization/F");
outputTree->Branch("fitGausMean",&fitGausMean_,"fitGausMean/F");
outputTree->Branch("fitGausSigma",&fitGausSigma_,"fitGausSigma/F");
outputTree->Branch("fitGausNormalizationError",&fitGausNormalizationError_,"fitGausNormalizationError/F");
outputTree->Branch("fitGausMeanError",&fitGausMeanError_,"fitGausMeanError/F");
outputTree->Branch("fitGausSigmaError",&fitGausSigmaError_,"fitGausSigmaError/F");
outputTree->Branch("fitChi2",&fitChi2_,"fitChi2/F");
outputTree->Branch("fitChi2Probab",&fitChi2Probab_,"fitChi2Probab/F");
outputTree->Branch("fitStatus",&fitStatus_,"fitStatus_F");
outputTree->Branch("noiseIntegral3Sigma",&noiseIntegral3Sigma_,"noiseIntegral3Sigma/F");
outputTree->Branch("noiseIntegral3SigmaFromFit",&noiseIntegral3SigmaFromFit_,"noiseIntegral3SigmaFromFit/F");
outputTree->Branch("noiseIntegral4Sigma",&noiseIntegral4Sigma_,"noiseIntegral4Sigma/F");
outputTree->Branch("noiseIntegral4SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral4SigmaFromFit/F");
outputTree->Branch("noiseIntegral5Sigma",&noiseIntegral4Sigma_,"noiseIntegral5Sigma/F");
outputTree->Branch("noiseIntegral5SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral5SigmaFromFit/F");
outputTree->Branch("kSValue",&kSValue_,"kSValue/F");
outputTree->Branch("jBValue",&jBValue_,"jBValue/F");
outputTree->Branch("aDValue",&aDValue_,"aDValue/F");
outputTree->Branch("kSProbab",&kSProbab_,"kSProbab/F");
outputTree->Branch("jBProbab",&jBProbab_,"jBProbab/F");
outputTree->Branch("aDProbab",&aDProbab_,"aDProbab/F");
outputTree->Branch("xMin",&xMin_,"xMin/F");
outputTree->Branch("xMax",&xMax_,"xMax/F");
outputTree->Branch("nBin",&nBin_,"nBin/F");
bool histoBranches = false;
// Loop on the file list to extract each histogram 2D DQM histo with full noise distribution
TH1F* histoNoiseStrip = NULL;
TF1* fitFunc = NULL;
TH1F* randomHisto = NULL;
TFitResultPtr result;
for(auto file : fileList){
cout<<"input file: "<<file<<endl;
TFile* inputFile = TFile::Open(file.c_str(),"READ");
inputFile->cd();
// take into account that the DQM file structure for strips is always the same --> use cabling map to browse the histograms
reader.SetEntry(0);
TH2* histoNoise = NULL;
long int iChannel = 0;
int noFitResult = 0;
while(reader.Next()){
cout.flush();
if(iChannel %10 == 0) cout<<"\r"<<"iChannel "<<100*double(iChannel)/(readoutMap->GetEntries()/reductionFactor)<<" % ";
if(iChannel > double(readoutMap->GetEntries())/reductionFactor) break;
iChannel++;
TString objName;
uint32_t fedKey = SiStripFedKey(*fedId,SiStripFedKey::feUnit(*fedCh),SiStripFedKey::feChan(*fedCh)).key();
std::stringstream stream;
stream << std::hex << fedKey;
string fedKeyStr = stream.str();
if(fedKeyStr.size() == 4)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x0000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else if(fedKeyStr.size() == 5)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else
cerr<<"hex number to short "<<fedKeyStr<<" --> please check "<<endl;
inputFile->GetObject(objName.Data(),histoNoise);
// extract single strip noise histogram --> loop on the y-axis
uint16_t apvID = 0;
uint16_t stripID = 0;
if(histoNoiseStrip == 0 or histoNoiseStrip == NULL){
histoNoiseStrip = new TH1F ("histoNoiseStrip","",histoNoise->GetNbinsX(),histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
histoNoiseStrip->Sumw2();
}
for(int iBinY = 0; iBinY < histoNoise->GetNbinsY(); iBinY++){
histoNoiseStrip->Reset();
histoNoiseStrip->SetDirectory(0);
// two multiplexed APV per line
if(iBinY < histoNoise->GetNbinsY()/2) apvID = 1;
else apvID = 2;
// strip id
stripID++;
if(stripID > 128) stripID = 1;
// loop on x-axis bin
for(int iBinX = 0; iBinX < histoNoise->GetNbinsX(); iBinX++){
histoNoiseStrip->SetBinContent(iBinX+1,histoNoise->GetBinContent(iBinX+1,iBinY+1));
histoNoiseStrip->SetBinError(iBinX+1,histoNoise->GetBinError(iBinX+1,iBinY+1));
}
// to initialize branches
detid_ = 0; fedKey_ = 0; fecCrate_ = 0; fecSlot_ = 0; fecRing_ = 0; ccuAdd_ = 0; ccuChan_ = 0; lldChannel_ = 0; fedId_ = 0; fedCh_ = 0; apvId_ = 0; stripId_ = 0;
noiseMean_ = 0.; noiseRMS_ = 0.; noiseSkewness_ = 0.; noiseKurtosis_ = 0.;
fitGausMean_ = 0.; fitGausSigma_ = 0.;fitGausNormalization_ = 0.;
fitGausMeanError_ = 0.; fitGausSigmaError_ = 0.;fitGausNormalizationError_ = 0.;
fitChi2_ = 0.; fitChi2Probab_ = 0.; fitStatus_ = -1.;
noiseIntegral3Sigma_ = 0.; noiseIntegral3SigmaFromFit_ = 0.;
noiseIntegral4Sigma_ = 0.; noiseIntegral4SigmaFromFit_ = 0.;
noiseIntegral5Sigma_ = 0.; noiseIntegral5SigmaFromFit_ = 0.;
kSProbab_ = 0.; jBProbab_ = 0.;
kSValue_ = 0.; jBValue_ = 0.;
aDValue_= 0.; aDProbab_ = 0.;
nBin_ = 0.; xMin_ = 0.; xMax_ = 0.;
// basic info
detid_ = *detid;
fedKey_ = fedKey;
fecCrate_ = *fecCrate;
fecSlot_ = *fecSlot;
fecRing_ = *fecRing;
ccuAdd_ = *ccuAdd;
ccuChan_ = *ccuChan;
lldChannel_ = *lldChannel;
fedId_ = *fedId;
fedCh_ = *fedCh;
apvId_ = apvID;
stripId_ = stripID;
// basic info of nioise distribution
noiseMean_ = histoNoiseStrip->GetMean();
noiseRMS_ = histoNoiseStrip->GetRMS();
noiseSkewness_ = histoNoiseStrip->GetSkewness();
noiseKurtosis_ = histoNoiseStrip->GetKurtosis();
float integral = histoNoiseStrip->Integral();
noiseIntegral3Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*3)))/integral;
noiseIntegral4Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*4)))/integral;
noiseIntegral5Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*5)))/integral;
// make a gaussian fit
if(fitFunc == NULL or fitFunc == 0){
fitFunc = new TF1 ("fitFunc","gaus(0)",histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
}
fitFunc->SetRange(histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
fitFunc->SetParameters(histoNoiseStrip->Integral(),noiseMean_,noiseRMS_);
result = histoNoiseStrip->Fit(fitFunc,"QSR");
if(result.Get()){
fitStatus_ = result->Status();
fitGausNormalization_ = fitFunc->GetParameter(0);
fitGausMean_ = fitFunc->GetParameter(1);
fitGausSigma_ = fitFunc->GetParameter(2);
fitGausNormalizationError_ = fitFunc->GetParError(0);
fitGausMeanError_ = fitFunc->GetParError(1);
fitGausSigmaError_ = fitFunc->GetParError(2);
fitChi2_ = result->Chi2();
fitChi2Probab_ = result->Prob();
noiseIntegral3SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*3)))/histoNoiseStrip->Integral();
noiseIntegral4SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*4)))/histoNoiseStrip->Integral();
noiseIntegral5SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*5)))/histoNoiseStrip->Integral();
jBValue_ = (histoNoiseStrip->Integral()/6)*(noiseSkewness_*noiseSkewness_+(noiseKurtosis_*noiseKurtosis_)/4);
jBProbab_ = ROOT::Math::chisquared_cdf_c(jBValue_,2);
if(randomHisto == 0 or randomHisto == NULL)
randomHisto = (TH1F*) histoNoiseStrip->Clone("randomHisto");
randomHisto->Reset();
randomHisto->SetDirectory(0);
if(integral != 0){
if(generateRandomDistribution){
randomHisto->FillRandom("fitFunc",histoNoiseStrip->Integral());
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
aDValue_ = histoNoiseStrip->AndersonDarlingTest(randomHisto,"T");
aDProbab_ = histoNoiseStrip->AndersonDarlingTest(randomHisto);
}
else{
randomHisto->Add(fitFunc);
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
// AD test
ROOT::Fit::BinData data1;
ROOT::Fit::BinData data2;
ROOT::Fit::FillData(data1,histoNoiseStrip,0);
data2.Initialize(randomHisto->GetNbinsX()+1,1);
for(int ibin = 0; ibin < randomHisto->GetNbinsX(); ibin++){
if(histoNoiseStrip->GetBinContent(ibin+1) != 0 or randomHisto->GetBinContent(ibin+1) >= 1)
data2.Add(randomHisto->GetBinCenter(ibin+1),randomHisto->GetBinContent(ibin+1),randomHisto->GetBinError(ibin+1));
}
double probab;
double value;
ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2,probab,value);
aDValue_ = value;
aDProbab_ = probab;
}
}
}
else
noFitResult++;
if(not histoBranches){
noiseDistribution_.clear();
noiseDistributionError_.clear();
outputTree->Branch("noiseDistribution","vector<float>",&noiseDistribution_);
outputTree->Branch("noiseDistributionError","vector<float>",&noiseDistributionError_);
histoBranches = true;
}
// set histogram
noiseDistribution_.clear();
noiseDistributionError_.clear();
for(int iBin = 0; iBin < histoNoiseStrip->GetNbinsX(); iBin++){
noiseDistribution_.push_back(histoNoiseStrip->GetBinContent(iBin+1));
noiseDistributionError_.push_back(histoNoiseStrip->GetBinError(iBin+1));
}
nBin_ = histoNoiseStrip->GetNbinsX();
xMin_ = histoNoise->GetXaxis()->GetBinLowEdge(1);
xMax_ = histoNoise->GetXaxis()->GetBinLowEdge(histoNoise->GetNbinsX()+1);
// fill all branches for each strip
ouputTreeFile->cd();
outputTree->Fill();
}
}
inputFile->Close();
std::cout<<std::endl;
cout<<"No fit results found for "<<100*double(noFitResult)/iChannel<<endl;
}
outputTree->BuildIndex("detid");
outputTree->Write(outputTree->GetName(),TObject::kOverwrite);
ouputTreeFile->Close();
cablingFile->Close();
/* Do your stuff here */
cout<<"Time taken: "<<(double)(clock() - tStart)/CLOCKS_PER_SEC<<endl;
}
//________________________________________________________________________________
void MergeComplexHistogramFile( const Char_t *TargetName=0, const Char_t *inputFilesPattern=0)
{
if (TargetName && TargetName[0] && inputFilesPattern && inputFilesPattern[0] ) {
printf(" An experimental version of macro.\n");
TStopwatch time;
Int_t fileCounter = 0;
Int_t dirCounter = 0;
Int_t treeCounter = 0;
Int_t histogramCounter = 0;
// Create the output file
TFile *outFile = TFile::Open(TargetName,"RECREATE");
TDirectory *outDir = outFile;
TDirIter listOfFiles(inputFilesPattern);
const char *fileName = 0;
while ( (fileName = listOfFiles.NextFile() ) ) {
Int_t currentDirDepth = 0;
printf(".");
fileCounter++;
StFileIter file(fileName);
TObject *obj = 0;
while ( (obj = *file) ) {
Int_t depth = file.GetDepth();
while (depth < currentDirDepth) {
outDir = outDir->GetMotherDir();
currentDirDepth--;
}
if ( obj->IsA()->InheritsFrom(TH1::Class()) ) {
// descendant of TH1 -> merge it
// printf("Merging histogram: %s\n",obj->GetName() );
// std::cout << "Merging histogram " << obj->GetName() << std::endl;
TH1 *h1 = (TH1*)obj;
TH1 *dstHistogram = 0;
// Check whether we found the new histogram
if ( (dstHistogram = (TH1 *)outDir->FindObject(h1->GetName()))) {
// Accumulate the histogram
dstHistogram->Add(h1);
delete h1; // Optional, to reduce the memory consumption
printf("h");
} else {
// First time - move the histogram
h1->SetDirectory(outDir);
printf(" The new Histogram found: %s \n", h1->GetName() );
histogramCounter++;
}
} else if ( obj->IsA()->InheritsFrom(TTree::Class()) ) {
// descendant of TTree -> merge it
// printf("Merging Tree %p:%s\n",obj, obj->GetName() );
TTree *tree = (TTree*)obj;
TTree *dstTree = 0;
// Check whether we found the new histogram
if ( (dstTree = (TTree *)outDir->FindObject(tree->GetName()))) {
// printf("Merging %p:%s with the existing Tree %p:%s\n"
// ,tree,tree->GetName(),dstTree, dstTree->GetName() );
// Merge the tree
TList *nextTree = new TList(); nextTree->Add(tree);
dstTree->Merge(nextTree);
delete tree; // Optional, to reduce the memory consumption
delete nextTree;
printf("t");
} else {
// First time - move the TTree
TDirectory *saveDir = 0;
if (outDir != gDirectory) {
saveDir = gDirectory;
outDir->cd();
}
TList *nextTree = new TList(); nextTree->Add(tree);
dstTree = TTree::MergeTrees(nextTree);
if (saveDir) saveDir->cd();
// printf(" The new TTree found: %p:%s \n",tree, tree->GetName() );
// printf(" Create the destination Tree %p:%s\n\n",dstTree, dstTree->GetName() );
delete tree; // Optional, to reduce the memory consumption
delete nextTree;
treeCounter++;
}
} else if ( obj->IsA()->InheritsFrom(TDirectory::Class()) ) {
printf("The input sub-TDirectory object: %s depth=%d\n",obj->GetName(), depth);
TDirectory *d = (TDirectory *)outDir->FindObject(obj->GetName());
if (!d) {
d = outDir->mkdir(obj->GetName());
dirCounter++;
printf("The new TDirectory object: %s depth=%d\n",d->GetPathStatic(), depth);
}
if (d) {
outDir = d;
printf("The output sub-TDirectory object: %s depth=%d\n",outDir->GetPathStatic(), depth);
}
} else {
printf("I have no idea how to merge the %s objects of the %s class. Skipping .... \n",obj->GetName(), obj->ClassName() );
}
++file;
}
}
printf("\n Finishing . . . \n");
outFile->Write(); // this creates a second copy of the TTree ???
outFile->Close();
delete outFile;
if (fileCounter) printf(" Total files merged: %d \n", fileCounter);
if (dirCounter) printf(" Total TDirectory objects merged: %d \n", dirCounter);
if (histogramCounter) printf(" Total histograms merged: %d \n", histogramCounter);
if (treeCounter) printf(" Total TTree\'s merged: %d \n",treeCounter);
if (dirCounter || treeCounter) printf(" You have used the experimental version of the program. Please check the output file\n");
time.Print("Merge");
} else {
printf("\nUsage: root MergeHistogramFile.C(\"DestinationFileName\",\"InputFilesPattern\")\n");
printf("------ where InputFilesPattern ::= <regexp_pattern_for_the_input_files>|@indirect_file_list\n");
printf(" indirect_file_list ::= a text file with the list of the files\n");
printf(" indirect_file_list can be create by the shell command:\n");
printf(" ls -1 *.root>indirect_file_list \n\n");
}
}
void KVSimDir::AnalyseFile(const Char_t* filename)
{
// Analyse ROOT file given as argument.
// If there is a TTree in the file, then we look at all of its branches until we find one
// containing objects which derive from KVEvent:
//
// -- if they inherit from KVSimEvent, we add the file to the list of simulated data:
// * a KVSimFile is created. The title of the TTree where data were found will
// be used as 'Information' on the nature of the simulation.
// -- if they inherit from KVReconstructedEvent, we add the file to the list of filtered data.
// * a KVSimFile is created. Informations on the filtered data are extracted from
// TNamed objects in the file with names 'Dataset', 'System', 'Run', 'Geometry'
// (type of geometry used, 'ROOT' or 'KV'), 'Origin' (i.e. the name of the simulation
// file which was filtered), 'Filter' (type of filter: Geo, GeoThresh or Full).
// These objects are automatically created when data is filtered using KVEventFiltering.
//
// Analysis of the file stops after the first TTree with a branch satisfying one of the
// two criteria is found (it is assumed that in each file there is only one TTree containing
// either simulated or filtered data).
Info("AnalyseFile", "Analysing file %s...", filename);
TString fullpath;
AssignAndDelete(fullpath, gSystem->ConcatFileName(GetDirectory(), filename));
TFile* file = TFile::Open(fullpath);
if (!file || file->IsZombie()) return;
// look for TTrees in file
TIter next(file->GetListOfKeys());
TKey* key;
while ((key = (TKey*)next())) {
TString cn = key->GetClassName();
if (cn == "TTree") {
// look for branch with KVEvent objects
TTree* tree = (TTree*)file->Get(key->GetName());
TSeqCollection* branches = tree->GetListOfBranches();
TIter nextB(branches);
TBranchElement* branch;
while ((branch = (TBranchElement*)nextB())) {
TString branch_classname = branch->GetClassName();
TClass* branch_class = TClass::GetClass(branch_classname, kFALSE, kTRUE);
if (branch_class && branch_class->InheritsFrom("KVEvent")) {
if (branch_class->InheritsFrom("KVSimEvent")) {
fSimData.Add(new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName()));
delete file;
return;
} else if (branch_class->InheritsFrom("KVReconstructedEvent")) {
// filtered data. there must be TNamed called 'Dataset', 'System', & 'Run' in the file.
TNamed* ds = (TNamed*)file->Get("Dataset");
TNamed* orig = (TNamed*)file->Get("Origin");
TNamed* sys = (TNamed*)file->Get("System");
TNamed* r = (TNamed*)file->Get("Run");
TNamed* g = (TNamed*)file->Get("Geometry");
TNamed* f = (TNamed*)file->Get("Filter");
TString dataset;
if (ds) dataset = ds->GetTitle();
TString system;
if (sys) system = sys->GetTitle();
TString run;
if (r) run = r->GetTitle();
TString origin;
if (orig) origin = orig->GetTitle();
TString geometry;
if (g) geometry = g->GetTitle();
TString filter;
if (f) filter = f->GetTitle();
Int_t run_number = run.Atoi();
fFiltData.Add(new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName(),
dataset, system, run_number, geometry, origin, filter));
delete file;
delete ds;
delete sys;
delete r;
delete f;
return;
}
}
}
}
}
}
void calculateEff(int nArguments) {
string configSysName = Form("share/file.txt");
ifstream configSystematic(configSysName.c_str());
vector<string> fileNames;
vector<string> treeNames;
string fileName, treeName;
while (!configSystematic.eof()) {
configSystematic >> fileName >> treeName;
if ((fileName.compare(0, 1, "#") == 0))
continue;
if (!configSystematic.good())
break;
fileNames.push_back(fileName);
treeNames.push_back(treeName);
}
ofstream fout;
fout.open("share/table.txt");
fout << left << setw(60) << "#Systematics" << "\t\t" << setw(25) << "purity(corr,rec)(B/A+B)" << "\t\t" << setw(25) << "accept(corr,fid)(B/B'+C)" << "\t\t" << setw(25) << "eff_{fid}=a/p"
<< setw(25) << "N_{fid}" << setw(25) << "N_{gen}" << endl;
for (int iSys = 0; iSys < fileNames.size(); ++iSys) {
bool c_debug(false);
if (nArguments > 2) {
cerr << "\n\t[INFO]\t" << "* * * main applyFiducialCut starts * * *" << endl;
applyFiducialCut(fileNames.at(iSys).c_str());
cerr << "\n\t[INFO]\t" << "* * * main applyFiducialCut finishes * * *" << endl;
} else {
cerr << "\n\t[INFO]\t" << "* * * main SKIP applyFiducialCut * * *" << endl;
}
/* nominal Trees */
TFile* nominalFile = new TFile("../data/2016-04-05/reprocess/reprocess_1j1b_v11_20160405.root");
TTree *nominalTree = (TTree*) nominalFile->Get(treeNames.at(iSys).c_str());
cerr << "\t[INFO]\t" << "Reco Tree " << nominalTree->GetName() << " " << nominalTree->GetEntries() << endl;
TFile* particleFile = new TFile(Form("root/fiducialRegion_%s.root", fileNames.at(iSys).c_str()));
TTree* particleTree = (TTree*) particleFile->Get("particleLevel");
cerr << "\t[INFO]\t" << "Truth Tree " << particleTree->GetName() << " " << particleTree->GetEntries() << endl;
Int_t runRecNominal;
Int_t eventRecNominal;
Float_t EventWeight, EventWeight_noPU, weight_leptonSF, weight_bTagSF_77, mc_weight;
nominalTree->SetBranchAddress("mcChannelNumber", &runRecNominal);
nominalTree->SetBranchAddress("EventNumber", &eventRecNominal);
nominalTree->SetBranchAddress("EventWeight_noPU", &EventWeight_noPU);
nominalTree->SetBranchAddress("EventWeight", &EventWeight);
nominalTree->SetBranchAddress("weight_leptonSF", &weight_leptonSF);
nominalTree->SetBranchAddress("weight_bTagSF_77", &weight_bTagSF_77);
nominalTree->SetBranchAddress("weight_mc", &mc_weight);
UInt_t runParticle;
ULong64_t eventParticle;
Float_t weight_mc;
particleTree->SetBranchAddress("mcChannelNumber", &runParticle);
particleTree->SetBranchAddress("eventNumber", &eventParticle);
particleTree->SetBranchAddress("weight_mc", &weight_mc);
/************/
/* counting */
/************/
/* build particleTree index */
particleTree->BuildIndex("mcChannelNumber", "eventNumber");
nominalTree->BuildIndex("mcChannelNumber", "EventNumber");
double totalEventWeight(0.), totalOverlapEventWeight(0.), totalOverlapweight_mc(0.), totalweight_mc(0.), totalOverlapmc_weight(0.);
double ExperimentalWeight(0.);
ofstream bugstr;
if (c_debug)
bugstr.open("share/bug.log");
bool useWeight(true);
for (Long64_t ievt = 0; ievt < (c_debug ? 10 : nominalTree->GetEntries()); ievt++) {
nominalTree->GetEntry(ievt);
ExperimentalWeight = (EventWeight_noPU == 0) ? 0 : (EventWeight / EventWeight_noPU) * weight_leptonSF * weight_bTagSF_77 * mc_weight;
totalEventWeight += useWeight ? ExperimentalWeight : 1; // A+B
if (particleTree->GetEntryWithIndex(runRecNominal, eventRecNominal) > 0) {
totalOverlapEventWeight += useWeight ? ExperimentalWeight : 1; // B
totalOverlapmc_weight += useWeight ? mc_weight : 1;
if (c_debug)
bugstr << "recon matched " << runRecNominal << " " << eventRecNominal << " totalOverlapmc_weight=" << totalOverlapmc_weight << endl;
} else {
if (c_debug)
bugstr << "recon notmatc " << runRecNominal << " " << eventRecNominal << " totalOverlapmc_weight=" << totalOverlapmc_weight << endl;
}
}
int dupl(0);
vector<int> duplevts;
ifstream ifile(Form("share/%s.overlap.dupEvt", fileNames.at(iSys).c_str()));
if (ifile) {
int evt;
while (!ifile.eof()) {
ifile >> evt;
if (!ifile.good())
break;
duplevts.push_back(evt);
}
}
for (Long64_t ievt = 0; ievt < (c_debug ? 10 : particleTree->GetEntries()); ievt++) {
particleTree->GetEntry(ievt);
totalweight_mc += useWeight ? weight_mc : 1; // B'+C
if (nominalTree->GetEntryWithIndex(runParticle, eventParticle) > 0) {
for (int id = 0; id < duplevts.size(); ++id) {
if (eventParticle == duplevts.at(id)) {
dupl++;
cerr << "\t[WARNING]\t" << "duplicated evt No. " << eventParticle << ". But still counted." << endl;
duplevts.erase(duplevts.begin() + id);
}
}
totalOverlapweight_mc += useWeight ? weight_mc : 1; // B'
if (c_debug)
bugstr << "truth matched " << runParticle << " " << eventParticle << " totalOverlapweight_mc=" << totalOverlapweight_mc << endl;
} else {
if (c_debug)
bugstr << "truth notmatc " << runParticle << " " << eventParticle << " totalOverlapweight_mc=" << totalOverlapweight_mc << endl;
}
}
/* Make sure overlap events are the same */
assert(fabs(totalOverlapmc_weight - totalOverlapweight_mc) < dupl + 0.001);
double purity = totalOverlapEventWeight / totalEventWeight;
double accept = totalOverlapEventWeight / totalweight_mc;
cerr << "\n\t[INFO]\t" << "* * * * * * * * * * * * * * * * * * * * * * * * ";
cerr << "\n\t[INFO]\t" << "* * * prime(') stands for weight_mc * * * * * * ";
cerr << "\n\t[INFO]\t" << "* * * reconstructed events (A + B) " << totalEventWeight << " * * *";
cerr << "\n\t[INFO]\t" << "* * * fiducial events (B'+ C) " << totalweight_mc << " * * *";
cerr << "\n\t[INFO]\t" << "* * * overlapped events (B) " << totalOverlapEventWeight << " * * *";
cerr << "\n\t[INFO]\t" << "* * * overlapped events (B') " << totalOverlapweight_mc << " * * *";
cerr << "\n\t[INFO]\t" << "* * * purity (corr, rec) (B / A+B ) " << purity << " * * *";
cerr << "\n\t[INFO]\t" << "* * * accept (corr, fid) (B / B'+C) " << accept << " * * *";
cerr << "\n\t[INFO]\t" << "* * * eff_{fid} " << accept / purity << " * * *";
cerr << "\n\t[INFO]\t" << "* * * * * * * * * * * * * * * * * * * * * * * * \n";
cerr << "\033[1;31m\n\t[INFO]\t" << iSys << "/" << treeNames.size() << ")\t" << treeNames.at(iSys) << "\t\t" << purity << "\t\t" << accept << "\t\t" << purity / accept << "\t\t"
<< totalweight_mc << "\033[0m" << endl;
fout << left << setw(60) << treeNames.at(iSys) << "\t\t" << setw(25) << purity << "\t\t" << setw(25) << accept << "\t\t" << setw(25) << accept / purity << setw(25) << totalweight_mc << endl;
}
return;
}
