Beispiel #1
0
void histoTrbyTr(string decay, int saveFig= 0 , int onlyFirstCandidate= 0){
  gROOT->Reset();
  gROOT->SetStyle("Plain");
  gStyle->SetOptStat(1);
  gStyle->SetHistLineWidth(2);
  //  gStyle->SetOptStat(111110);
  //gStyle->SetOptFit(111);

  gROOT->ForceStyle();
 //  double pigreco = 3.141592;

   stringstream file;
  file.str("");
  file << "rfdir:///castor/cern.ch/cms/store/caf/user/taroni/TkAlData2011-20110721/variables"<<decay<<".root";


  cout << __LINE__ << " Opening file: " << file.str().c_str() << endl;
  
  TFile * f = new TFile();
  
  f = TFile::Open(file.str().c_str());
  if (!f){
    cout << "FILE NOT FOUND" << endl;
    return;
  }
   cout << __LINE__ << " file " << file.str().c_str() <<  " opened" << endl;
   stringstream outstring;
   outstring.str("");
   outstring << "triggerFile" << decay << ".root";

   TFile* outfile = new TFile(outstring.str().c_str(),"RECREATE");

   outfile -> cd();

//    double etaMu1;
//    double phiMu1;
//    double ptMu1;
//    double etaMu2;
//    double phiMu2;
//    double ptMu2;
   
  double nbins = 0;
  double  firstbin = 0;
  double  lastbin  = 0;

  double maxMass =0, minMass=0;

  string str3;
  size_t pos;
  pos = decay.find("MuMu");    // position of "live" in str
  str3 = decay.substr (0, pos);   // get from "live" to the end
  cout << str3 << endl;

//   if (decay == "ZMuMu" || decay == "ZMuMuMC" ) {
  if (str3 == "Z" ) {
    nbins = 140;
    firstbin = 50;
    lastbin  = 120;
    maxMass = 115;
    minMass = 65;
  }  else if (str3 == "Jpsi") {
    nbins = 80;
    firstbin = 2;
    lastbin  = 4;
    maxMass = 3.4;
    minMass = 2.7;
  }  else if (str3 == "Upsilon") {
    nbins = 80;
    firstbin = 8.5;
    lastbin  = 10.5;
    maxMass = 9.9;
    minMass = 8.9;
  }

  if (DEBUG)    cout<< __LINE__ << endl;

  TH1D * hTrigger = new TH1D("trigger","trigger",100,0.,100.); 
  
 //   TH1D *hMass= new TH1D("hMass","Invariant Mass",nbins,firstbin,lastbin);
//   TH1D *hPtMother= new TH1D("hPtMother","MotherTransverse Momentum",200,0.,200.);
//   TH1D *hEtaMother= new TH1D("hEtaMother","Mother Eta",100,-5.,5.);
//   TH1D *hPhiMother= new TH1D("hPhiMother","Mother Phi",100,-4.,4.);


  TH1D *hPt= new TH1D("hPt","Transverse Momentum",200,0.,200.);
  TH1D *hEta= new TH1D("hEta","Eta",100,-4.,4.);
  TH1D *hPhi= new TH1D("hPhi","Phi",100,-4.,4.);

//   TH1D *hDeltaPhi= new TH1D("hDeltaPhi","DeltaPhi",100,-10.,10.);
//   TH1D *hDeltaEta= new TH1D("hDeltaEta","DeltaEta",100,-10.,10.);
//   TH1D *hDeltaR  = new TH1D("R"  ,"R"  ,100,-1.,10.);

  TH1I *hMultCand = new TH1I("hMultCand","MultipleCandidate",50,-.5,49.5);

//   TH2D * hEta1vsDeltaPhi = new TH2D ("hEta1vsDeltaPhi", "EtaMu1vsDeltaPhi", 100, -2., 2. , 100, -4., 4.) ;
//   TH2D * hEta2vsDeltaPhi = new TH2D ("hEta2vsDeltaPhi", "EtaMu2vsDeltaPhi", 100, -2., 2. , 100, -4., 4.) ;

  if (DEBUG)  cout<< __LINE__ << endl;


  map <string,  vector <TH1D *> > hTrMap;
  f->cd();

    TTree *t2 = (TTree*)f->Get("myanalysis/AnalysisTree");
    if (DEBUG) cout<< __LINE__ << endl;

//     TBranch *EtaMother= t2->GetBranch("EtaMother");
//     TBranch *PhiMother= t2->GetBranch("PhiMother");
//     TBranch *PtMother= t2->GetBranch("PtMother");
   
    TBranch *chi2 = t2->GetBranch("Chi");
//     TBranch *Ntk  = t2->GetBranch("mol");
    TBranch *M= t2->GetBranch("invMass");
    TBranch *P= t2->GetBranch("P");
    TBranch *Pt= t2->GetBranch("Pt");
    TBranch *Px= t2->GetBranch("Px");
    TBranch *Py= t2->GetBranch("Py");
    TBranch *Pz= t2->GetBranch("Pz");
    TBranch *Eta= t2->GetBranch("Eta");
    TBranch *Phi= t2->GetBranch("Phi");

    TBranch *trigger= t2->GetBranch("triggerInfo");

      if (DEBUG)cout<< __LINE__ << endl;



    vector <double> *chi2pt=0;

    vector <double> *Ppt=0, *Ptpt=0, *Pxpt=0, *Pypt=0, *Pzpt=0, *Etapt=0, *Phipt=0;
//     vector<double> *mass=0, *PtMotherpt=0,*EtaMotherpt=0,*PhiMotherpt=0;

    vector <pair <string, bool> > *triggerInfo =0;

//     M->SetAddress(&mass);
//     PtMother->SetAddress(&PtMotherpt);
//     EtaMother->SetAddress(&EtaMotherpt);
//     PhiMother->SetAddress(&PhiMotherpt);

    P->SetAddress(&Ppt);
    Pt->SetAddress(&Ptpt);
    Px->SetAddress(&Pxpt);
    Py->SetAddress(&Pypt);
    Pz->SetAddress(&Pzpt);
    Eta->SetAddress(&Etapt);
    Phi->SetAddress(&Phipt);

    trigger->SetAddress(&triggerInfo);

    Int_t nentries = (Int_t)t2->GetEntries();
//     nentries = 100;
    cout << __LINE__ << " Entries " << nentries << endl;
    vector < string > triggerNames;

//     nentries = 100 ;
    outfile->cd();
   
   for ( int i=0;i<nentries;i++) {
      t2->GetEntry(i);
      hTrigger->Fill(triggerInfo->size());

      for (unsigned int itr = 0; itr < triggerInfo->size(); itr++){
	if (triggerInfo->at(itr).second== 1) {
	  string triggerName= (triggerInfo->at(itr)).first ;
	  bool checkName = false;
	  for( unsigned int iname =0; iname<triggerNames.size(); iname++){

	    if (triggerNames.at(iname).compare(triggerName)==0){
 	      checkName = true;
	    }
	  }
	  if (checkName == false ) {
	    triggerNames.push_back(triggerName);

	  }
	}
      }
  
   }
    cout << "triggersize" << " " << triggerNames.size()<< endl;

   for (unsigned int itr=0; itr<triggerNames.size(); itr++){
      
      vector < TH1D *> hTrVector; 
      stringstream histoEtaName, histoPhiName, histoPtName, histoEtaMotherName, histoPhiMotherName;
      histoEtaName.str("");
      histoPhiName.str("");
      histoPtName.str("");
      histoEtaName << triggerNames.at(itr) << "TrackEta";
      histoPhiName << triggerNames.at(itr) << "TrackPhi";
      histoPtName  << triggerNames.at(itr) << "TrackPt";
      if (DEBUG)cout<< __LINE__ << endl;
      if (DEBUG) cout<< __LINE__ << endl;
      hTrMap[triggerNames.at(itr)].push_back(new TH1D (histoEtaName.str().c_str(),histoEtaName.str().c_str(),500,-5,5));
      hTrMap[triggerNames.at(itr)].push_back( new TH1D (histoPhiName.str().c_str(),histoPhiName.str().c_str(),640,-3.2,3.2));
      hTrMap[triggerNames.at(itr)].push_back( new TH1D (histoPtName.str().c_str(),histoPtName.str().c_str(),200,0.,0.));
      
      hTrVector.clear();
   }

      if (DEBUG)cout<< __LINE__ << endl;
    f->cd();
    t2->ResetBranchAddresses();

//     M->SetAddress(&mass);

//     PtMother->SetAddress(&PtMotherpt);
//     EtaMother->SetAddress(&EtaMotherpt);
//     PhiMother->SetAddress(&PhiMotherpt);

    P->SetAddress(&Ppt);
    Pt->SetAddress(&Ptpt);
    Px->SetAddress(&Pxpt);
    Py->SetAddress(&Pypt);
    Pz->SetAddress(&Pzpt);
    Eta->SetAddress(&Etapt);
    Phi->SetAddress(&Phipt);

    trigger->SetAddress(&triggerInfo);
    outfile->cd();
    for ( int i=0;i<nentries;i++) {

      t2->GetEntry(i); 

      unsigned int muonSize = Ptpt->size();
      if (DEBUG)cout<< __LINE__ << endl;
      for (unsigned int ivec=0; ivec< muonSize;ivec++){
	hPt->Fill(Ptpt->at(ivec));
	if (DEBUG) cout<< __LINE__ << endl;
 
	hEta->Fill(Etapt->at(ivec));
	hPhi->Fill(Phipt->at(ivec));

 	for (unsigned int itr = 0; itr < triggerInfo->size(); itr++){
//	for (unsigned int itr = 0; itr < 100; itr++){   
	string name = triggerInfo->at(itr).first;
// 	  cout << __LINE__ << " trigger "  << triggerInfo->at(itr).first << " " << triggerInfo->at(itr).second << endl;
	  if (triggerInfo->at(itr).second== 1) {
// 	     if (DEBUG) cout<< __LINE__ << endl;
	    (hTrMap[name][0])->Fill(Etapt->at(ivec));
// 	     if (DEBUG) cout<< __LINE__ << endl;
	    hTrMap[name][1]->Fill(Phipt->at(ivec));
// 	     if (DEBUG) cout<< __LINE__ << endl;
	    hTrMap[name][2]->Fill(Ptpt->at(ivec));
	  }
	}
      
        // cout<< __LINE__ << endl;
    
    
//     for (unsigned int ivec=0; ivec< MassSize;ivec++){
// 	for (unsigned int itr = 0; itr < triggerInfo->size(); itr++){
// 	  string name = triggerInfo->at(itr).first;
// 	  hTrMap[name][2]->Fill(EtaMotherpt->at(ivec));
// 	  hTrMap[name][3]->Fill(PhiMotherpt->at(ivec));
// 	}
	//     }
      }

	if (DEBUG) cout<< __LINE__ << endl;
      //   }//if

    }//entries
    if (DEBUG) cout<< __LINE__ << endl;
      
   outfile->cd();

 /////////////////////////////////////////////////////////////////////////////
   TCanvas *canv1= new TCanvas("canv1","firstAnalysis",1000,700);
//    TCanvas *canv3= new TCanvas("canv3","DeltaPhiDeltaEtaR",1000,700);
//    TCanvas *canv4= new TCanvas("canv4","EtaMuVsDeltaPhi",600,800);
   TCanvas *canv7= new TCanvas("canv7","trigger",600,400);
//    TCanvas *canv2= new TCanvas("canv2","MotherAnalysis",1000,700);

   if (DEBUG) cout<< __LINE__ << endl;
   map <string , TCanvas *> canvasMap;
   for (map < string , vector <TH1D*> >::const_iterator it=hTrMap.begin(); it!=hTrMap.end(); it++){
   if (DEBUG) cout<< __LINE__ << endl;
     if (it->second.size()<1) continue ;
   if (DEBUG) cout<< __LINE__ << endl;
     if (it->second.at(1)->GetEntries() < 2*nentries/10) continue;
   if (DEBUG) cout<< __LINE__ << endl;
     string name = it->first;
     if (DEBUG) cout << __LINE__ << ", entries  "<<   it->second.at(1)->GetEntries() << endl;
   if (DEBUG) cout<< __LINE__ << endl;
     stringstream canvasName; 
     canvasName << "c_"<< decay<< "_" << name;
     canvasMap[name] = new TCanvas (canvasName.str().c_str(),canvasName.str().c_str(),1000,700);
   if (DEBUG) cout<< __LINE__ << endl;
     canvasMap[name]->Divide(2,2);
     canvasMap[name]->cd(1); 
     it->second[0]->Draw(); 
     canvasMap[name]->cd(2); 
     it->second[1]->Draw(); 
   if (DEBUG) cout<< __LINE__ << endl;
     canvasMap[name]->cd(3); 
     canvasMap[name]->GetPad(3)->SetLogy();
     it->second[2]->Draw(); 
     it->second[2]->GetXaxis()->SetTitle("GeV/c"); 
//      canvasMap[name]->cd(4); 
//      it->second[3]->Draw(); 
   if (DEBUG) cout<< __LINE__ << endl;
     stringstream canvasFileName;
     canvasFileName << "plots/"<< canvasName.str().c_str()<< ".png" ; 
   if (DEBUG) cout<< __LINE__ << endl;
     if (saveFig ==1){
       if (it->second.at(1)->GetEntries() < 2*nentries/10) continue;
       if (DEBUG) cout<< __LINE__ << endl;
       canvasMap[name]->SaveAs(canvasFileName.str().c_str());
     }
   }
   if (DEBUG) cout<< __LINE__ << endl;
   for (map < string , vector <TH1D*> >::const_iterator it=hTrMap.begin(); it!=hTrMap.end(); it++){
     if (it->second.size()<1) continue ;
     if (it->second.at(1)->GetEntries() < 2*nentries/10) continue;
     string name = it->first;
     canvasMap[name]->Write();
   }
   if (DEBUG) cout<< __LINE__ << endl;

   vector <TCanvas*> cVector;
   cVector.push_back(canv1);
//    cVector.push_back(canv2);
//    cVector.push_back(canv3);
//    cVector.push_back(canv4);
   cVector.push_back(canv7);

   canv1->Draw();
   canv1->Divide(2,2);
      
   canv1->cd(1);
   if (DEBUG) cout<< __LINE__ << endl;
	
   hPt->SetFillStyle(3033);
   hPt->SetFillColor(99);
   hPt->GetXaxis()->SetTitle("P_{T} (GeV/c)");
   int maxBin = 0;
   for (int ibin = 1 ; ibin <= hPt->GetNbinsX() ; ibin++){
     if (hPt->GetBinContent(ibin) != 0) {
       maxBin = ibin;
     }
   }
   double maxX = (int )(hPt->GetBinCenter(maxBin)/10)*10  + 11  ;
   hPt->GetXaxis()->SetRangeUser(0,maxX);
   canv1->GetPad(1)->SetLogy();
   hPt->Draw();
   if (DEBUG) cout<< __LINE__ << endl;
	
   canv1->cd(2);
//    hMass->SetFillStyle(3020);
//    hMass->SetFillColor(3);
//    hMass->GetXaxis()->SetTitle("Mass (GeV/c^{2})");
//    hMass->Draw();
   
   canv1->cd(3);
   hPhi->SetFillStyle(3009);
   hPhi->SetFillColor(2);
   hPhi->GetXaxis()->SetTitle("#phi (rad)");
   hPhi->Draw();
   
   canv1->cd(4);
   hEta->SetFillStyle(3020);
   hEta->SetFillColor(4);
   hEta->GetXaxis()->SetTitle("#eta");
   hEta->Draw();
   canv1->Update();
   if (DEBUG) cout<< __LINE__ << endl;

     
//    canv2->Draw();
//    canv2->Divide(2,2);
//    canv2->cd(1);
//    hMass->Draw();
//    canv2->cd(2);
//    hPhiMother->Draw();
//    hPhiMother->GetXaxis()->SetTitle("#phi (rad)");
//    canv2->cd(3);
//    hEtaMother->Draw();
//    hEtaMother->GetXaxis()->SetTitle("#eta");
//    canv2->cd(4);
//    hPtMother->Draw();
//    hPtMother->GetXaxis()->SetTitle("p_{T} (GeV/c)");
//    canv2->Update();
 
//    canv3->Divide(2,2);
   
//    canv3->cd(1);
//    hDeltaPhi->SetFillStyle(3009);
//    hDeltaPhi->SetFillColor(1);
//    hDeltaPhi->GetXaxis()->SetTitle("#phi");
//    hDeltaPhi->Draw();
   
//    canv3->cd(2);
//    hDeltaEta->SetFillStyle(3020);
//    hDeltaEta->SetFillColor(3);
//    hDeltaEta->GetXaxis()->SetTitle("#eta");
//    hDeltaEta->Draw();
   
//    canv3->cd(3);
//    hDeltaR->SetFillStyle(3009);
//    hDeltaR->SetFillColor(2);
//    hDeltaR->GetXaxis()->SetTitle("R");
//    hDeltaR->Draw();

//    canv3->Update();
   
   canv7->Draw();
   canv7->cd();
   hTrigger->Draw();
   canv7->Update();
   
//    canv4->Draw();
//    canv4->Divide(1,2);
//    canv4->cd(1);
//    hEta1vsDeltaPhi->Draw();
//    canv4->cd(2);
//    hEta2vsDeltaPhi->Draw();
//    canv4->Update();
   if (DEBUG) cout<< __LINE__ << endl;



   if (saveFig == 1 ) {
     for (unsigned icanv = 0 ; icanv < cVector.size(); icanv++){
       stringstream imageName;
     // imageName.str("");
     // imageName <<decay<< cVector[icanv]->GetTitle()<<".jpg";
     // cVector[icanv]->SaveAs(imageName.str().c_str());
     // imageName.str("");
     // imageName <<decay<< cVector[icanv]->GetTitle()<<".gif";
     // cVector[icanv]->SaveAs(imageName.str().c_str());
       imageName.str("");
       imageName << "plots/"<<decay<< cVector[icanv]->GetTitle()<<".png";
       cVector[icanv]->SaveAs(imageName.str().c_str());
       imageName.str("");
       imageName <<"plots/"<<decay<< cVector[icanv]->GetTitle()<<".eps";
       cVector[icanv]->SaveAs(imageName.str().c_str());
     }
   }


   for (unsigned icanv = 0 ; icanv < cVector.size(); icanv++){
     cVector[icanv]->Write();
   }

//    hTriggCount -> Write();
   if (DEBUG) cout<< __LINE__ << endl;

//    hEta1vsDeltaPhi->Write();
//    hEta2vsDeltaPhi->Write();
//    if (DEBUG) cout<< __LINE__ << endl;
	
//    hMass->Write();
//    hPtMother->Write();
//    hEtaMother->Write();
//    hPhiMother->Write();
   hPt->Write();
   hEta->Write();
   hPhi->Write();

//    hDeltaPhi->Write();
//    hDeltaEta->Write();
//    hDeltaR  ->Write();

   hMultCand->Write();
   hTrigger ->Write();
   // cout<< __LINE__ << endl;

   for (map < string , vector <TH1D*> >::const_iterator it=hTrMap.begin(); it!=hTrMap.end(); it++){
     if (it->second.size()<1) continue ;
     if ((it->second).at(1)->GetEntries() < 2*nentries/10) continue;
     (it->second).at(0)->Write();
     (it->second).at(1)->Write();
     (it->second).at(2)->Write();
//      (it->second).at(3)->Write();
     
   }
   if (DEBUG) cout<< __LINE__ << endl;

   // cout<< __LINE__ << endl;


   for (unsigned icanv = 0 ; icanv < cVector.size(); icanv++){
     cVector[icanv]->~TCanvas();
   }


   if (DEBUG) cout<< __LINE__ << endl;

//    hMass->~TH1D();
   hPt->~TH1D();
   hEta->~TH1D();
   hPhi->~TH1D();

//    hDeltaPhi->~TH1D();
//    hDeltaEta->~TH1D();
//    hDeltaR  ->~TH1D();

   hTrigger ->~TH1D();

   hMultCand->~TH1I();
//    for (map<string, vector <TH1D*> >::iterator it=hTrMap.begin(); it!=hTrMap.end(); it++){
//      (it->second).at(0)->~TH1D();
//      (it->second).at(1)->~TH1D();
//      (it->second).at(2)->~TH1D();
//      (it->second).at(3)->~TH1D();
//    }

   outfile->Close();

   f->Close();
   cout << __LINE__ << " file " << file.str().c_str() <<  " closed" << endl;


}
void NewCosmicstest(){
	//gROOT->Reset();	
	
	TStopwatch *clock0 = new TStopwatch();
	TFile *fout = new TFile("Cosmictest.root","RECREATE");
	bool high = 1;
	
	//Float_t z0 = 1400;
	Float_t z0 = 0;
	Float_t yTop = 600;
	Float_t xTop = 300;
	Float_t zTop = 3650;
	
	Float_t xdist = 3000;
	Float_t zdist = 9000;
	
	TH2D *StartXZ = new TH2D("xz","xz;x[cm];z[cm]",30,-(xdist/2),xdist/2,90,z0 - 4500,z0 + 4500);
	TH1D *StartTheta = new TH1D("#theta","#theta; #theta_Zenith",100,0,2);
	TH1D *StartPhi = new TH1D("#phi","#phi; #phi",50,0,7);
	TH1D *StartPHigh = new TH1D("PHigh","P; P[GeV]",100,-1,3);
	TH1D *StartP = new TH1D("P","P;P[GeV]",100,-1,3);
	TH1D *StartPLow = new TH1D("PLow","P;P[GeV]",100,-1,3);
	//TH1D *StartP = new TH1D("P","P;P[GeV]",100,0.1,1000);
	BinLogX(StartP);
	BinLogX(StartPHigh);
	BinLogX(StartPLow);
	
	TH2D *StartPTheta = new TH2D("P,Theta","P-Theta;P[GeV];#theta",150,-1,3,50,0,2);
	BinLogX(StartPTheta);
	
	TH2D *MCXZ = new TH2D("MCxz","xz;x[cm];z[cm]",30,-(xdist/2),xdist/2,90,z0 - 4500,z0 + 4500);
	TH1D *MCTheta = new TH1D("MC#theta","#theta; #theta",100,0,2);
	TH1D *MCPhi = new TH1D("MC#phi","#phi, #phi",50,0,7);
	
	TH1I *MCnTry = new TH1I("nTry","nTry",100,4.6,5);
	
	Double_t totalweightsum=0;
	Double_t px,py,pz,x,y,z,w, weighttest, weight;
	Int_t nTry,nInside,nEvent,nTest;	
	Co3Rng *fRandomEngine = new Co3Rng();
	
	int EVENTS = 400000;
	Int_t kmax = 40000;
	float weight1,weight1Low,weight1High;
	weight1Low = 123*xdist*zdist/EVENTS/10000; // expected #muons per spill/ #simulated events per spill 174*30*90/500000
	cout<<weight1Low<<endl;
	
	double I = fRandomEngine->fSpectrumH->Integral(100,1000);
	weight1High = 2*TMath::Pi()/3*I*xdist*zdist/EVENTS/10000;
		//weight2 = 900/I; // 1/(mean momentum weight), P_max-P_min/(3*0.3044/2pi)
	
	cout<< weight1High<<endl;
	Float_t weight3 = 4.833931503; // MC average of nTry/nEvents 4.833949997 +- 0.000010494			
	weight1 = 1;								
	weight = weight1 / weight3;
	
	nInside = 0; nEvent = 0; nTest = 0; weighttest = 0;
	y = 1900; //20m over beam axis

	w = weight/kmax;
	clock0->Start();
	for(Int_t k = 0;k<kmax;k++){
		cout<<k<<endl;
		nTry =0;
		for(Int_t i=0;i<EVENTS;i++){
		   Bool_t hit = 0;   
		   do{
				// shower characteristics
			   double phi = fRandomEngine->Uniform(0,2*TMath::Pi());
			   double theta = fRandomEngine->fTheta->GetRandom();
			  				  			    		 
	   	   //momentum components
				px = TMath::Sin(phi)*TMath::Sin(theta); 
				pz = TMath::Cos(phi)*TMath::Sin(theta);
				py = -TMath::Cos(theta);
				
				// start position, area 1120m^2
				x = fRandomEngine->Uniform(-xdist/2,xdist/2);
				z = fRandomEngine->Uniform(z0 - zdist/2, z0 + zdist/2);
				
				// claim for flight close to the actual detector
				if((abs(x-(y+yTop)*px/py) < xTop && abs(z-z0-(y+yTop)*pz/py) < zTop) || (abs(x-(y-yTop)*px/py) < xTop && abs(z-z0-(y-yTop)*pz/py) <  zTop)|| abs(y-(x+xTop)*py/px)<yTop && abs(z-z0-(x+xTop)*pz/px)<zTop || abs(y-(x-xTop)*py/px)<yTop && abs(z-z0-(x-xTop)*pz/px)<zTop){
					
					// muon momentum
					double P;
					//if (!high) {P = fRandomEngine->NEWstest(theta);}
					//else {P = fRandomEngine->fSpectrumH->GetRandom();}
					// high
					P = fRandomEngine->fSpectrumH->GetRandom();
					w = weight1High/weight3/kmax;
					StartP->Fill(P,w);
					StartPHigh->Fill(P,w);
					StartPTheta->Fill(P,theta,w);
					// low
					P = fRandomEngine->NEWstest(theta);
					w = weight1Low/weight3/kmax;
					StartP->Fill(P,w);
					StartPLow->Fill(P,w);
					StartPTheta->Fill(P,theta,w);
					
					
					px = px*P;
					py = py*P;
					pz = pz*P;
					
					//muon or anti-muon
					hit = 1; nInside++; 
					// StartP->Fill(P,w);
					
					w = weight1Low/weight3/kmax + weight1High/weight3/kmax;
					
					StartTheta->Fill(theta,w); // kein Weight!
					StartPhi->Fill(phi,w);	// kein Weight!	
					StartXZ->Fill(x,z,w); // kein Weight!	
					StartPTheta->Fill(P,theta,w);	
			   }
			   nTry++;
				weighttest += w;
				MCTheta->Fill(theta,w); // kein Weight!
				MCPhi->Fill(phi,w);
				MCXZ->Fill(x,z,w);
				nTest++;
			}while(!hit);
			nEvent++;
		}
		MCnTry->Fill(1.0*nTry/EVENTS);
	}
	clock0->Stop();
	
	delete fRandomEngine;
	cout<<nEvent<<" events have been generated."<<endl;
	cout<<"There is a total of "<<nInside<<"/"<<nTest<<" muons that passed close enough to the detector."<<endl;
	cout<<"Including the given weight this corresponds to ";
	cout<<kmax*weighttest/xdist/zdist*10000/123.3044<<" spills (1 spill = "<<xdist*zdist*123.3044/10000;
	cout<<" real cosmic muons = "<<EVENTS<<" simulated events)."<<endl;
   
   cout<<weighttest<<endl;
   clock0->Print();
   
   Double_t meanflux = 0;
   Int_t binsum = 0;
   for (Int_t ix = 2; ix<29;ix++){
	   for (Int_t iz = 2; iz<89;iz++){
		 	binsum++;
		   meanflux += MCXZ->GetBinContent(ix,iz);
		}
	}
	cout<< "meanflux: "<<meanflux/binsum<<"  "<< meanflux<<endl<<endl;
   printf("MCnTry: %.9f +- %.9f",MCnTry->GetMean(),MCnTry->GetMeanError());
   cout<<endl<<endl;
     
    TCanvas *c1 = new TCanvas("c1","c1",400,400);
	 c1->Divide(1,1);
	 c1->cd(1);
	 MCnTry->DrawCopy();
	
	 TCanvas *c4 = new TCanvas("c4","c4",400,400);
	 c4->Divide(1,1);
	 c4->cd(1);
	 StartPTheta->DrawCopy("SURF2");
	 gPad->SetLogx();
	
	 //TCanvas *c2 = new TCanvas("c2","c2",400,400);
	 //c2->Divide(1,1);
	 //c2->cd(1);
	 //gPad->SetLogy();
	 //wei->DrawCopy();
	
    TCanvas *c3 = new TCanvas("c3","c3",1600,800);
	 c3->Divide(4,2);
	 c3->cd(1);
	 StartXZ->DrawCopy("COLZ");
	 c3->cd(2);
	 //MCP->SetLineColor(kGreen);
	// MCP->DrawCopy();
	 //StartP->DrawCopy();
	 //TF1 *fs = new TF1("fs",NEWs,1,100,2);
	 //fs->FixParameter(0, 0);
	 //fs->FixParameter(1, 500);
	 //StartP->Add(fs,-1);
	 StartP->DrawCopy();
	 //StartP->Fit(fs,"I");
	 
	 
	// 
	 //fs->DrawCopy("SAME");
	 
	 //gPad->SetLogy();
	 gPad->SetLogx();
	 c3->cd(3);
	 MCTheta->SetLineColor(kGreen);
	 MCTheta->DrawCopy();
	 StartTheta->DrawCopy("SAME");
	 //TF1 *f1 = new TF1("f1","[0]*cos(x)*cos(x)",1.57,3.14);
	 //StartTheta->Fit(f1,"","",1.57,3.14);	
	 gPad->SetLogy(0);
	 gPad->SetLogx(0);
	 c3->cd(4);
	 MCPhi->SetLineColor(kGreen);
	 MCPhi->DrawCopy();
	 StartPhi->DrawCopy("SAME");
	//TF1 *f1 = new TF1("f1","[0]*cos(x)*cos(x)",1.57,3.14);
	//StartTheta->Fit(f1,"","",1.57,3.14);	
	 gPad->SetLogy(0);
	 gPad->SetLogx(0);
	 c3->cd(5);
	 MCXZ->DrawCopy("COLZ");
	 c3->cd(6);
	 //MCP->Divide(StartP);
	// MCP->DrawCopy();
	 gPad->SetLogy(0);
	 gPad->SetLogx(0);
	 c3->cd(7);
	 //MCTheta->Divide(StartTheta);
	 MCTheta->DrawCopy();
	 gPad->SetLogy();
	 gPad->SetLogx(0);
	 c3->cd(8);
	 //MCPhi->Divide(StartPhi);
	 MCPhi->DrawCopy();
	 gPad->SetLogy(0);
	 gPad->SetLogx(0);
	 c3->Update();
	 c3->SaveAs("Start.png");
	 
	 
	 
	 
	 StartXZ->Write();
	 StartTheta->Write();
	 StartPhi->Write();
	 StartP->Write();
	 StartPLow->Write();
	 StartPHigh->Write();
	
    StartPTheta->Write();
		
	 MCXZ->Write();
	 MCTheta->Write();
	 MCPhi->Write();
	
	 MCnTry->Write();
	 fout ->Close();
	 
	 
  
}
void processWaveforms(TTree* treeToSort, vector<Plots>& targetPlots, TFile* outFile, string mode)
{
    TH1D* fittedTimeHisto = new TH1D("raw fitted times", "raw fitted times", TOF_BINS,TOF_LOWER_BOUND,TOF_RANGE);

    TH2D* deltaTVsPulseHeight = new TH2D("delta T vs. pulse height","delta T vs. pulse height", 200, -10, 10, 1580, 0, 15800);

    TH2D* deltaTVsPulseIntegral0 = new TH2D("delta T vs. pulse integral, target 0","delta T vs. pulse integral, target 0",100, -10, 10, pow(2,15), 0, pow(2,15));
    TH2D* deltaTVsPulseIntegral1 = new TH2D("delta T vs. pulse integral, target 1","delta T vs. pulse integral, target 1",100, -10, 10, pow(2,15), 0, pow(2,15));
    TH2D* deltaTVsPulseIntegral2 = new TH2D("delta T vs. pulse integral, target 2","delta T vs. pulse integral, target 2",100, -10, 10, pow(2,15), 0, pow(2,15));
    TH2D* deltaTVsPulseIntegral3 = new TH2D("delta T vs. pulse integral, target 3","delta T vs. pulse integral, target 3",100, -10, 10, pow(2,15), 0, pow(2,15));
    TH2D* deltaTVsPulseIntegral4 = new TH2D("delta T vs. pulse integral, target 4","delta T vs. pulse integral, target 4",100, -10, 10, pow(2,15), 0, pow(2,15));
    TH2D* deltaTVsPulseIntegral5 = new TH2D("delta T vs. pulse integral, target 5","delta T vs. pulse integral, target 5",100, -10, 10, pow(2,15), 0, pow(2,15));

    TH1D* triggerAmplitudeHisto = new TH1D("triggerAmplitudeHisto","triggerAmplitudeHisto",pow(2,14),0,pow(2,14));
    TH1D* relativeTriggerTimeHisto = new TH1D("relativeTriggerTimeHisto","relative trigger time, from start of fitted wavelet",200,-5,5);
    TH2D* relativeTriggerTimeVsAmplitude = new TH2D("relativeTriggerTimeVSAmplitude","relative trigger time vs amplitude", 200, -5, 5, pow(2,14), 0, pow(2,14));

    TH1D* gammaToGammaTimeH = new TH1D("gammaToGammaTimeH","time between consecutive gammas", 1000, -5, 5);

    if(mode=="DPP")
    {
        setBranchesHistos(treeToSort);

        int totalEntries = treeToSort->GetEntries();
        cout << "Total waveforms = " << totalEntries << endl;

        vector<double> triggerList;

        waveformWrap = new TMultiGraph("DPP waveforms", "DPP waveforms");
        vector<TGraph*> waveletGraphs;
        vector<TGraph*> triggerGraphs;

        int gammaGate[2] = {80,90};

        double prevGammaTime = 0;

        for(int j=1; j<totalEntries; j++)
        {
            if(j%1000==0)
            {
                cout << "Processing triggers on waveform " << j << "\r";
                fflush(stdout);
            }

            /*if(j>500)
            {
                break;
            }*/

            triggerList.clear();
            triggerValues.clear();

            // pull individual waveform event
            treeToSort->GetEntry(j);

            // calculate the baseline for this waveform
            BASELINE = calculateBaseline(*procEvent.waveform);

            // Loop through all points in the waveform and fit peaks
            for(int k=DPP_PEAKFIT_START; (size_t)k<procEvent.waveform->size(); k++)
            {
                // Check to see if this point creates a new trigger
                if(isTrigger(k, *procEvent.waveform))
                {
                    // trigger found - plot/fit/extract time

                    double timeDiff = procEvent.completeTime-procEvent.macroTime;
                    double microTime = fmod(timeDiff,MICRO_LENGTH);

                    if(microTime > gammaGate[0] && microTime < gammaGate[1])
                    {
                        processTrigger(j, k, triggerList, *procEvent.waveform);

                        double fullTime = procEvent.completeTime-procEvent.macroTime+data.trigger1Time+DPP_PEAKFIT_OFFSET;
                        gammaToGammaTimeH->Fill(fmod(fullTime,MICRO_LENGTH)-prevGammaTime);
                        prevGammaTime=fmod(fullTime,MICRO_LENGTH);

                        fillTriggerHistos(fullTime, targetPlots);
                        fittedTimeHisto->Fill(data.trigger1Time);
                    }

                    //processTrigger(j, k, triggerList, *procEvent.waveform);

                    break;
                }
            }

            //produceTriggerOverlay(j, triggerList, *procEvent.waveform);

            TH2D* deltaTVsPulseIntegralHisto;

            switch(procEvent.targetPos-1)
            {
                case 0:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral0;
                    break;

                case 1:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral1;
                    break;

                case 2:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral2;
                    break;

                case 3:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral3;
                    break;

                case 4:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral4;
                    break;

                case 5:
                    deltaTVsPulseIntegralHisto = deltaTVsPulseIntegral5;
                    break;
            }

            triggerAmplitudeHisto->Fill(data.peak1Amplitude);
            relativeTriggerTimeHisto->Fill(data.trigger1Time+DPP_PEAKFIT_OFFSET);
            relativeTriggerTimeVsAmplitude->Fill(data.trigger1Time+DPP_PEAKFIT_OFFSET,data.peak1Amplitude);

            deltaTVsPulseIntegralHisto->Fill(data.trigger1Time+DPP_PEAKFIT_OFFSET, procEvent.lgQ);
            deltaTVsPulseHeight->Fill(data.trigger1Time+DPP_PEAKFIT_OFFSET, data.peak1Amplitude);

            // Create a new graph for each wavelet
            //waveletGraphs.push_back(new TGraph());

            // Fill each micropulse graph with waveform samples
            /*for (int l=0; l<procEvent.waveform->size(); l++)
              {
              waveletGraphs.back()->SetPoint(l,l*SAMPLE_PERIOD,procEvent.waveform->at(l));
              }*/

            // Create a new graph for each wavelet
            //triggerGraphs.push_back(new TGraph());

            // Fill each micropulse graph with waveform samples
            //triggerGraphs.back()->SetPoint(0,triggerList[0],triggerValues[0]);

            fill(procEvent.waveform->begin(),procEvent.waveform->end(),BASELINE);
        }

        TGraph* exponentialFit = new TGraph();
        exponentialFit->SetPoint(0,-0.78,140);
        exponentialFit->SetPoint(1,0.16,206);
        exponentialFit->SetPoint(2,1.79,305);
        exponentialFit->SetPoint(3,2.82,417);
        exponentialFit->SetPoint(4,3.59,566);
        exponentialFit->SetPoint(5,4.4,929);
        exponentialFit->SetPoint(6,5.2,1482);
        exponentialFit->SetPoint(7,5.7,2149);
        exponentialFit->SetPoint(8,6.9,5319);
        exponentialFit->SetPoint(9,7.3,7808);
        exponentialFit->SetPoint(10,7.7,11395);
        exponentialFit->SetPoint(11,8.0,16200);
        exponentialFit->Write();

        // Add each wavelet graph to the MultiGraph
        for (int m=0; m<waveletGraphs.size(); m++)
        {
            //cout << "adding graph " << m << " to multigraph" << endl;
            waveletGraphs[m]->Draw();
            waveformWrap->Add(waveletGraphs[m],"l");
        }

        // Add each trigger graph to the MultiGraph
        for (int m=0; m<triggerGraphs.size(); m++)
        {
            //cout << "adding graph " << m << " to multigraph" << endl;
            triggerGraphs[m]->SetMarkerSize(2);
            triggerGraphs[m]->SetMarkerColor(2);
            triggerGraphs[m]->Draw();
            waveformWrap->Add(triggerGraphs[m],"*");
        }

        waveformWrap->Write();

        for(Plots p : targetPlots)
        {
            p.getTOFHisto()->Write();
            p.getEnergyHisto()->Write();
        }

        fittedTimeHisto->Write();

        deltaTVsPulseIntegral0->Write();
        deltaTVsPulseIntegral1->Write();
        deltaTVsPulseIntegral2->Write();
        deltaTVsPulseIntegral3->Write();
        deltaTVsPulseIntegral4->Write();
        deltaTVsPulseIntegral5->Write();

        deltaTVsPulseHeight->Write();

        relativeTriggerTimeHisto->Write();
        triggerAmplitudeHisto->Write();
        relativeTriggerTimeVsAmplitude->Write();

        gammaToGammaTimeH->Write();
    }

    else if(mode=="waveform")
    {
        setBranchesHistosW(treeToSort);

        triggerWalk = new TH2I("triggerWalk","trigger time vs. waveform chunk #",200,0,200,1000,0,1000);

        TH1I* monitorHisto = new TH1I("targetPosH", "targetPos", 7, 0, 7);
        monitorHisto->GetXaxis()->SetTitle("target position of each waveform");

        long triggersWithGamma = 0;
        vector<int> fullWaveform(MACRO_LENGTH/2, BASELINE);
        vector<double> triggerList;

        int prevTargetPos = 0;
        double firstTimetagInSeries = 0;

        int totalEntries = treeToSort->GetEntries();
        cout << "Total waveforms = " << totalEntries << endl;

        /*TCanvas *mycan = (TCanvas*)gROOT->FindObject("mycan");

          if(!mycan)
          {
          mycan = new TCanvas("mycan","mycan");
          }*/

        // EVENT LOOP for sorting through channel-specific waveforms
        for(int j=1; j<totalEntries; j++)
        {
            cout << "Processing triggers on waveform " << j << "\r";
            fflush(stdout);

            if(j>30)
            {
                break;
            }

            triggerList.clear();
            triggerValues.clear();

            prevTargetPos = procEvent.targetPos;

            // pull individual waveform event
            treeToSort->GetEntry(j);

            if(procEvent.evtNo==1)
            {
                // new macropulse; process the previous macropulse's waveform

                // calculate the baseline for this waveform
                BASELINE = calculateBaseline(fullWaveform);

                // Loop through all points in the waveform and fit peaks
                for(int k=PEAKFIT_WINDOW; (size_t)k<fullWaveform.size(); k++)
                {
                    // Check to see if this point creates a new trigger
                    if(isTrigger(k, fullWaveform))
                    {
                        // trigger found - plot/fit/extract time
                        processTrigger(j, k, triggerList, fullWaveform);

                        // shift waveform index past the end of this fitting window
                        // so that we don't refit the same data
                        k += PEAKFIT_WINDOW;
                    }
                    /*if(triggerList.size()>10)
                      {
                      for(int m=0; m<triggerList.size(); m++)
                      {
                      cout << "triggerList[" << m << "] = " << triggerList[m] << endl;
                      }
                      break;
                      }*/
                }

                // Use the gamma peaks to find the time offset for this waveform, and
                // adjust the microTime with this offset

                double gammaOffset = calculateGammaOffset(triggerList);

                /*for(int m=0; (size_t)m<triggerList.size(); m++)
                  {
                  fillTriggerHistos(triggerList[m]-gammaOffset, targetPlots);
                  }*/

                if(gammaOffset!=0)
                {
                    for(int m=0; (size_t)m<triggerList.size(); m++)
                    {
                        //fillTriggerHistos(triggerList[m]-gammaOffset+WAVEFORM_OFFSET, targetPlots);
                    }

                    triggersWithGamma++;
                }

                /*if(j<30)
                  {
                  produceTriggerOverlay(j, triggerList, fullWaveform);
                  }*/

                /*temp.str("");
                  temp << "waveformWrap" << j;

                  waveformWrap = new TMultiGraph(temp.str().c_str(), temp.str().c_str());

                  vector<TGraph*> microGraphs;

                // Create a new graph for each micropulse period to be plotted
                for (int m = 0; m<floor(2*procEvent.waveform->size()/MICRO_LENGTH); m++)
                {
                microGraphs.push_back(new TGraph());
                }

                // Fill each micropulse graph with waveform samples
                for (int l = 0; l<procEvent.waveform->size(); l++)
                {
                microGraphs[(int)floor(l/(double)MICRO_LENGTH)]->SetPoint(microGraphs[(int)floor(l/(double)MICRO_LENGTH)]->GetN(),fmod(2*l+WAVEFORM_OFFSET,MICRO_LENGTH),procEvent.waveform->at(l));
                //cout << "Adding value " << procEvent.waveform->at(l) << " to position " << fmod(l,MICRO_LENGTH) << " in microGraph " << floor(l/(double)MICRO_LENGTH) << endl;
                }

                // Add each graph to the MultiGraph
                for (int m = 0; m<microGraphs.size(); m++)
                {
                //cout << "adding graph " << m << " to multigraph" << endl;
                microGraphs[m]->Draw();
                waveformWrap->Add(microGraphs[m],"l");
                }

                waveformWrap->Write();
                */

                //gPad->Modified();
                //mycan->Update();

                // Fill trigger histogram
                /*for (int l = 0; l<triggerList.size(); l++)
                  {
                  cout << "trigger " << l << " = " << triggerList[l] << ", " << triggerValues[l] << endl;
                  }*/

                //triggerH->Write();
                //cout << "Finished processing waveform " << j << endl << endl;

                /*if(j==10)
                  {
                  break;
                  }*/

                monitorHisto->Fill(prevTargetPos);

                fill(fullWaveform.begin(),fullWaveform.end(),BASELINE);

                firstTimetagInSeries = procEvent.completeTime;
            }

            if (procEvent.targetPos == 0)
            {
                continue;
            }

            double timeOffset = procEvent.completeTime-firstTimetagInSeries;

            if(timeOffset<MACRO_LENGTH-2*procEvent.waveform->size())
            {
                for(int k=0; k<procEvent.waveform->size(); k++)
                {
                    fullWaveform[timeOffset/SAMPLE_PERIOD+k] = procEvent.waveform->at(k);
                }
            }
        }

        cout << "Triggers with gamma in wavelet: " << triggersWithGamma << endl;

        monitorHisto->Write();

        for(Plots p : targetPlots)
        {
            p.getTOFHisto()->Write();
            p.getEnergyHisto()->Write();
        }

        cout << "Number of good fits: " << numberGoodFits << endl;
        cout << "onePeak = " << numberOnePeakFits << endl; 
        cout << "onePeakExpBack = " << numberOnePeakExpBackFits << endl; 
        cout << "twoPeaks = " << numberTwoPeakFits << endl << endl; 
        cout << "Number of bad fits: " << numberBadFits << endl;
    }

    else
    {
        cerr << "Error: digitizer mode was " << mode << "; only possible options are 'DPP' or 'waveform'. Exiting..." << endl;
        exit(1);
    }
}