Example #1
0
void Parity_pi(int cen=1) {	//main_function

    struct StRefMultCorr refmultCorrUtil  = StRefMultCorr("refmult") ;

    delete gRandom;
    gRandom = new TRandom3(0);
    float Eweight = 1;
    const int Phibin = 80;
    char fname[200];
    float PsiShiftE1=0,PsiShiftE2=0,PsiShiftE3=0,PsiShiftE4=0;
    float PsiShiftW1=0,PsiShiftW2=0,PsiShiftW3=0,PsiShiftW4=0;
    float PsiShiftf1=0,PsiShiftf2=0,PsiShiftf3=0,PsiShiftf4=0;
    float PsiShiftb1=0,PsiShiftb2=0,PsiShiftb3=0,PsiShiftb4=0;
    float PsiShiftF1=0,PsiShiftF2=0,PsiShiftF3=0,PsiShiftF4=0;
    const int order = 1;
    float PhiMean[4*order]= {0,};
    float PhiWgtFF[Phibin][4],PhiWgtRF[Phibin][4];
    TProfile2D *TPCmean_FF, *TPCmean_RF;
    TH2D *TPCPhi_FF, *TPCPhi_RF;
    TProfile2D *Read_TPC_EP_full, *Read_TPC_EP_east, *Read_TPC_EP_west, *Read_TPC_EP_for, *Read_TPC_EP_bac;
    sprintf(fname,"cen%d.weight_pi_minbias5.root",cen);
    TFile *fWgt=new TFile(fname,"READ");
    if(!fWgt->IsOpen()) cout<<"no phi weight files!"<<endl;
    if(fWgt->IsOpen()) {
        TPCmean_FF = (TProfile2D*)fWgt->Get("TPCmeanPhi_FF");
        TPCmean_RF = (TProfile2D*)fWgt->Get("TPCmeanPhi_RF");
        TPCPhi_FF = (TH2D*)fWgt->Get("Hist_Phi_FF");
        TPCPhi_RF = (TH2D*)fWgt->Get("Hist_Phi_RF");
        Read_TPC_EP_full = (TProfile2D*)fWgt->Get("pTPC_EP_full");
        Read_TPC_EP_east = (TProfile2D*)fWgt->Get("pTPC_EP_east");
        Read_TPC_EP_west = (TProfile2D*)fWgt->Get("pTPC_EP_west");
        Read_TPC_EP_for = (TProfile2D*)fWgt->Get("pTPC_EP_for");
        Read_TPC_EP_bac = (TProfile2D*)fWgt->Get("pTPC_EP_bac");
        for(int j=0; j<4; j++) {
            float PhiMeanFF = TPCPhi_FF->ProjectionX("",j+1,j+1)->GetSum()/(float)Phibin;
            float PhiMeanRF = TPCPhi_RF->ProjectionX("",j+1,j+1)->GetSum()/(float)Phibin;
            for(int i=0; i<Phibin; i++) {
                PhiWgtFF[i][j] = (TPCPhi_FF->GetBinContent(i+1,j+1)>0)? PhiMeanFF/(TPCPhi_FF->GetBinContent(i+1,j+1)):1;
                PhiWgtRF[i][j] = (TPCPhi_RF->GetBinContent(i+1,j+1)>0)? PhiMeanRF/(TPCPhi_RF->GetBinContent(i+1,j+1)):1;
                //cout<<" PhiWgt= "<<PhiWgt[i][j];
            }
        }
    }  else {
        for(int j=0; j<4; j++) for(int i=0; i<Phibin; i++) {
                PhiWgtFF[i][j] = 1;
                PhiWgtRF[i][j] = 1;
            }

    }
    /*
    //prepare the files
      int nfile = 0;
      TChain* chain = new TChain("StrangenessDst");
      std::ifstream inlist(InputFileList);
      if(!inlist)cout<<" can't open file "<<endl;  //prepare the files
      char  *fileName=new char[200];
      while(!inlist.eof()) {
    	inlist.getline(fileName,200,'\n');
    	if(!inlist.eof()) nfile += chain->Add(fileName);
      }
    */
    TChain* chain = new TChain("StrangenessDst");
    int nfile = 0;
    nfile += chain->Add("/media/Disk_Chen/Data/200GeV_run11/data_minbias5_new/*.flow.nt.root");
    cout <<"Added "<<nfile<<" files"<<endl;
    cout<<"# entries in chain: "<<chain->GetEntries()<<endl;

    char fname_out[200];
    sprintf(fname_out,"cen%d.ntuple_result_Parity_pi_minbias5_eff.root",cen);
    TFile fout(fname_out,"RECREATE");
    //defining variables
    Float_t PVtxz, VPDvz, Bz, psi_E, psi_W, mod_E, mod_W, ZDCe, ZDCw, ZDCcoin, BBCco;			//run, event info
    Int_t   Run, Day, Day2, Day3, Event, Trigger, RefMult, TOFMult, Centrality, NPTracks;	//
    Float_t Charge, ndEdx, nSigma_p, nSigma_pi, DCAGlobal, Eta, Theta, Phi, Pt;		//track info

    //defining histograms
    TH1D* hEventTally = new TH1D("EventTally","Event Tally",10,0,1);
    hEventTally->SetBit(TH1::kCanRebin);
    hEventTally->SetStats(0);

    TProfile *Ref_Day3 = new TProfile("Ref_Day3","RefMult vs Run",100000,80000,180000,-0.5,999.5);
    TProfile *TOF_Day3 = new TProfile("TOF_Day3","TOFMult vs Run",100000,80000,180000,0,5000);
    TProfile *NPT_Day3 = new TProfile("NPT_Day3","NPTracks vs Run",100000,80000,180000,0,2000);
    TProfile *TPC_Day3_cos2 = new TProfile("TPC_Day3_cos2","cos(2*psi) vs Run", 100000,80000,180000,-1,1);
    TProfile *TPC_Day3_sin2 = new TProfile("TPC_Day3_sin2","sin(2*psi) vs Run", 100000,80000,180000,-1,1);
    TH1D *Hist_RefMult = new TH1D("Hist_RefMult","Hist_RefMult",1000,-0.5,999.5);
    TH1D *Hist_TOFMult = new TH1D("Hist_TOFMult","Hist_TOFMult",5000,-0.5,4999.5);
    TProfile *p_RefMult = new TProfile("p_RefMult","p_RefMult",50,0.5,1000.5, 0,1000, "");
    TProfile *p_TOFMult = new TProfile("p_TOFMult","p_TOFMult",50,0.5,5000.5, 0,5000, "");

    TH1D *hBz      = new TH1D("hBz","magnetic field",10, -10, 10);
    TH1D *hTrigger = new TH1D("hTrigger","hTrigger",400, 0.5, 400.5);
    TH1D *hCentrality = new TH1D("hCentrality","hCentrality",10,0,10);
    TH1D *hVertexZ = new TH1D("hVertexZ","hVertexZ",100,-100,100);
    TH2D *hMult_Vz = new TH2D("hMult_Vz","hMult_Vz",1000,-0.5,999.5,100,-100,100);
    TH2D *hMult_Vz_new = new TH2D("hMult_Vz_new","hMult_Vz_new",1000,-0.5,999.5,100,-100,100);
    TH1D *hBBC_coin = new TH1D("hBBC_coin","hBBC_coin",120,0,60000);
    TProfile2D *pTPCmeanPhi_FF = new TProfile2D("TPCmeanPhi_FF","TPCmeanPhi_FF",
            8*order,0.5,8*order+0.5,10000,8000,18000,-1,1,"");
    TProfile2D *pTPCmeanPhi_RF = new TProfile2D("TPCmeanPhi_RF","TPCmeanPhi_RF",
            8*order,0.5,8*order+0.5,10000,8000,18000,-1,1,"");

    TH1D* Hist_proton = new TH1D("Hist_proton","Hist_proton",50,-0.5,49.5);
    TH1D* Hist_pbar = new TH1D("Hist_pbar","Hist_pbar",50,-0.5,49.5);
    TH1D* Hist_netP = new TH1D("Hist_netP","Hist_netP",99,-49.5,49.5);
    TH2D *hEtaPtDist = new TH2D("EtaPtDist","EtaPtDist",26, -1.3, 1.3,300,0,15);
    TH2D* Hist_Phi = new TH2D("Hist_Phi","Hist_Phi",Phibin,-PI,PI,4,0.5,4.5);
    TH2D* Hist_TPC_EP_east = new TH2D("Hist_TPC_EP_east","Hist_TPC_EP_east",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_west = new TH2D("Hist_TPC_EP_west","Hist_TPC_EP_west",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_for = new TH2D("Hist_TPC_EP_for","Hist_TPC_EP_for",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_bac = new TH2D("Hist_TPC_EP_bac","Hist_TPC_EP_bac",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_full = new TH2D("Hist_TPC_EP_full","Hist_TPC_EP_full",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_east_flat = new TH2D("Hist_TPC_EP_east_flat","Hist_TPC_EP_east_flat",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_west_flat = new TH2D("Hist_TPC_EP_west_flat","Hist_TPC_EP_west_flat",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_for_flat = new TH2D("Hist_TPC_EP_for_flat","Hist_TPC_EP_for_flat",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_bac_flat = new TH2D("Hist_TPC_EP_bac_flat","Hist_TPC_EP_bac_flat",36,0,PI,100,80,180);
    TH2D* Hist_TPC_EP_full_flat = new TH2D("Hist_TPC_EP_full_flat","Hist_TPC_EP_full_flat",36,0,PI,100,80,180);
    TProfile2D* pTPC_EP_east = new TProfile2D("pTPC_EP_east","pTPC_EP_east",4,0.5,4.5,100,80,180,-1,1,"");
    TProfile2D* pTPC_EP_west = new TProfile2D("pTPC_EP_west","pTPC_EP_west",4,0.5,4.5,100,80,180,-1,1,"");
    TProfile2D* pTPC_EP_for = new TProfile2D("pTPC_EP_for","pTPC_EP_for",4,0.5,4.5,100,80,180,-1,1,"");
    TProfile2D* pTPC_EP_bac = new TProfile2D("pTPC_EP_bac","pTPC_EP_bac",4,0.5,4.5,100,80,180,-1,1,"");
    TProfile2D* pTPC_EP_full = new TProfile2D("pTPC_EP_full","pTPC_EP_full",4,0.5,4.5,100,80,180,-1,1,"");
    TH1F* Hist_dif_count = new TH1F("Hist_dif_count","Hist_dif_count",500,-250,250);
    TH1F* Hist_ful_count = new TH1F("Hist_ful_count","Hist_ful_count",1000,0,1000);


    TH1D* Hist_Pt = new TH1D("Hist_Pt","Hist_Pt",300,0,15);
    TH1D* Hist_Pt_TOF = new TH1D("Hist_Pt_TOF","Hist_Pt_TOF",300,0,15);
    TH1D* rc;
    TH2D* Hist_Phi_FF = new TH2D("Hist_Phi_FF","Hist_Phi_FF",Phibin,-PI,PI,4,0.5,4.5);
    TH2D* Hist_Phi_RF = new TH2D("Hist_Phi_RF","Hist_Phi_RF",Phibin,-PI,PI,4,0.5,4.5);
    TH2D* Hist_Phi_FF_new = new TH2D("Hist_Phi_FF_new","Hist_Phi_FF_new",Phibin,-PI,PI,4,0.5,4.5);
    TH2D* Hist_Phi_RF_new = new TH2D("Hist_Phi_RF_new","Hist_Phi_RF_new",Phibin,-PI,PI,4,0.5,4.5);
    TProfile *Hist_cos = new TProfile("Hist_cos","Hist_cos",2,0.5,2.5,-1,1,"");
    TProfile2D *Hist_cos_RefMult = new TProfile2D("Hist_cos_RefMult","Hist_cos_RefMult",2,0.5,2.5, 50,0.5,1000.5,-1,1,"");
    TProfile2D *Hist_cos_TOFMult = new TProfile2D("Hist_cos_TOFMult","Hist_cos_TOFMult",2,0.5,2.5, 50,0.5,5000.5,-1,1,"");
    TProfile2D *Hist_cos_ZDC = new TProfile2D("Hist_cos_ZDC","Hist_cos_ZDC",2,0.5,2.5, 50,0.5,20000.5,-1,1,"");
    TProfile2D *Hist_cos_BBC_RefMult = new TProfile2D("Hist_cos_BBC_RefMult","Hist_cos_BBC_RefMult",60,0,60000, 50,0.5,1000.5,-1,1,"");
    TH1D* hDpt   = new TH1D("hDpt","hDpt",200,0,2);
    TH1D* hQinv  = new TH1D("hQinv","hQinv",1000,0,10);
    TH1D* hQinv2 = new TH1D("hQinv2","hQinv2",1100,-1,10);

    TProfile *p_v2_RefMult_obs = new TProfile("p_v2_RefMult_obs","p_v2_RefMult_obs",50,0.5, 1000.5,-100,100,"");
    TProfile *p_v2_TOFMult_obs = new TProfile("p_v2_TOFMult_obs","p_v2_TOFMult_obs",50,0.5,5000.5,-100,100,"");
    TProfile *p_v2_ZDC_obs = new TProfile("p_v2_ZDC_obs","p_v2_ZDC_obs",50,0.5,20000.5,-100,100,"");
    TProfile2D *p_v2_BBC_RefMult_obs = new TProfile2D("p_v2_BBC_RefMult_obs","p_v2_BBC_RefMult_obs",60,0,60000,50,0.5, 1000.5,-100,100,"");
    TProfile *p_RefMult_ZDC_obs = new TProfile("p_RefMult_ZDC_obs","p_RefMult_ZDC_obs",50,0.5,20000.5,0,1000,"");
    TProfile *p_TOFMult_ZDC_obs = new TProfile("p_TOFMult_ZDC_obs","p_TOFMult_ZDC_obs",50,0.5,20000.5,0,5000,"");

    TProfile *pParity_int_obs1 = new TProfile("Parity_int_obs1","Parity_int_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_obs2 = new TProfile("Parity_int_obs2","Parity_int_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_obs3 = new TProfile("Parity_int_obs3","Parity_int_obs3",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_r_obs1 = new TProfile("Parity_int_r_obs1","Parity_int_r_obs1",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_r_obs2 = new TProfile("Parity_int_r_obs2","Parity_int_r_obs2",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_r_obs3 = new TProfile("Parity_int_r_obs3","Parity_int_r_obs3",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_rr_obs1 = new TProfile("Parity_int_rr_obs1","Parity_int_rr_obs1",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_rr_obs2 = new TProfile("Parity_int_rr_obs2","Parity_int_rr_obs2",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_rr_obs3 = new TProfile("Parity_int_rr_obs3","Parity_int_rr_obs3",4,0.5,4.5,-1600,1600,"");
    TProfile *pParity_int_s_obs1 = new TProfile("Parity_int_s_obs1","Parity_int_s_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_s_obs2 = new TProfile("Parity_int_s_obs2","Parity_int_s_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_s_obs3 = new TProfile("Parity_int_s_obs3","Parity_int_s_obs3",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ss_obs1 = new TProfile("Parity_int_ss_obs1","Parity_int_ss_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ss_obs2 = new TProfile("Parity_int_ss_obs2","Parity_int_ss_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ss_obs3 = new TProfile("Parity_int_ss_obs3","Parity_int_ss_obs3",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_w_obs1 = new TProfile("Parity_int_w_obs1","Parity_int_w_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_w_obs2 = new TProfile("Parity_int_w_obs2","Parity_int_w_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_w_obs3 = new TProfile("Parity_int_w_obs3","Parity_int_w_obs3",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ww_obs1 = new TProfile("Parity_int_ww_obs1","Parity_int_ww_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ww_obs2 = new TProfile("Parity_int_ww_obs2","Parity_int_ww_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ww_obs3 = new TProfile("Parity_int_ww_obs3","Parity_int_ww_obs3",4,0.5,4.5,-100,100,"");

    TProfile *pParity_int_same_run = new TProfile("Parity_int_same_run","Parity_int_same_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_rr_same_run = new TProfile("Parity_int_rr_same_run","Parity_int_rr_same_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_ss_same_run = new TProfile("Parity_int_ss_same_run","Parity_int_ss_same_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_ww_same_run = new TProfile("Parity_int_ww_same_run","Parity_int_ww_same_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_oppo_run = new TProfile("Parity_int_oppo_run","Parity_int_oppo_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_rr_oppo_run = new TProfile("Parity_int_rr_oppo_run","Parity_int_rr_oppo_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_ss_oppo_run = new TProfile("Parity_int_ss_oppo_run","Parity_int_ss_oppo_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_ww_oppo_run = new TProfile("Parity_int_ww_oppo_run","Parity_int_ww_oppo_run",10000,8000,18000,-100,100,"");
    TProfile *pParity_int_ss_ran_obs1 = new TProfile("Parity_int_ss_ran_obs1","Parity_int_ss_ran_obs1",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ss_ran_obs2 = new TProfile("Parity_int_ss_ran_obs2","Parity_int_ss_ran_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_int_ss_ran_obs3 = new TProfile("Parity_int_ss_ran_obs3","Parity_int_ss_ran_obs3",4,0.5,4.5,-100,100,"");

    TProfile2D *pParity_eta_ss_obs1 = new TProfile2D("Parity_eta_ss_obs1","Parity_eta_ss_obs1",12,0.5,12.5,20,-1,1,-100,100,"");
    TProfile2D *pParity_eta_ss_obs2 = new TProfile2D("Parity_eta_ss_obs2","Parity_eta_ss_obs2",12,0.5,12.5,20,-1,1,-100,100,"");
    TProfile2D *pParity_eta_ss_obs3 = new TProfile2D("Parity_eta_ss_obs3","Parity_eta_ss_obs3",12,0.5,12.5,20,-1,1,-100,100,"");

    TProfile2D *pParity_Deta_ss_obs1 = new TProfile2D("Parity_Deta_ss_obs1","Parity_Deta_ss_obs1",12,0.5,12.5,20,0,2,-100,100,"");
    TProfile2D *pParity_Deta_ss_obs2 = new TProfile2D("Parity_Deta_ss_obs2","Parity_Deta_ss_obs2",12,0.5,12.5,20,0,2,-100,100,"");
    TProfile2D *pParity_Deta_ss_obs3 = new TProfile2D("Parity_Deta_ss_obs3","Parity_Deta_ss_obs3",12,0.5,12.5,20,0,2,-100,100,"");
    TProfile2D *pParity_pt_ss_obs1  = new TProfile2D("Parity_pt_ss_obs1","Parity_pt_ss_obs1",12,0.5,12.5,20,0,2.0,-100,100,"");
    TProfile2D *pParity_pt_ss_obs2  = new TProfile2D("Parity_pt_ss_obs2","Parity_pt_ss_obs2",12,0.5,12.5,20,0,2.0,-100,100,"");
    TProfile2D *pParity_pt_ss_obs3  = new TProfile2D("Parity_pt_ss_obs3","Parity_pt_ss_obs3",12,0.5,12.5,20,0,2.0,-100,100,"");
    TProfile2D *pParity_Dpt_ss_obs1 = new TProfile2D("Parity_Dpt_ss_obs1","Parity_Dpt_ss_obs1",12,0.5,12.5,200,0,2.0,-100,100,"");
    TProfile2D *pParity_Dpt_ss_obs2 = new TProfile2D("Parity_Dpt_ss_obs2","Parity_Dpt_ss_obs2",12,0.5,12.5,200,0,2.0,-100,100,"");
    TProfile2D *pParity_Dpt_ss_obs3 = new TProfile2D("Parity_Dpt_ss_obs3","Parity_Dpt_ss_obs3",12,0.5,12.5,200,0,2.0,-100,100,"");
    TProfile2D *pParity_Q_ss_obs1   = new TProfile2D("Parity_Q_ss_obs1","Parity_Q_ss_obs1",4,0.5,4.5,500,0,5.0,-100,100,"");
    TProfile2D *pParity_Q_ss_obs2   = new TProfile2D("Parity_Q_ss_obs2","Parity_Q_ss_obs2",4,0.5,4.5,500,0,5.0,-100,100,"");
    TProfile2D *pParity_Q_ss_obs3   = new TProfile2D("Parity_Q_ss_obs3","Parity_Q_ss_obs3",4,0.5,4.5,500,0,5.0,-100,100,"");

    TProfile *pParity_noHBT_ss_obs2   = new TProfile("Parity_noHBT_ss_obs2","Parity_noHBT_ss_obs2",4,0.5,4.5,-100,100,"");
    TProfile *pParity_noHBT_ss_obs3   = new TProfile("Parity_noHBT_ss_obs3","Parity_noHBT_ss_obs3",4,0.5,4.5,-100,100,"");

    Int_t nentries = chain->GetEntries();
//	nentries = 50000;
    //loop through events
    for(int i = 0; i < nentries; i++) {

        if((i+1)%1000==0) cout<<"Processing entry == "<< i+1 <<" == out of "<<nentries<<".\n";
        chain->GetEntry(i);

        TLeaf* leaf_RunId   = chain->GetLeaf("mRunId");
        TLeaf* leaf_EventId = chain->GetLeaf("mEventId");
        TLeaf* leaf_Trigger = chain->GetLeaf("mTrigger");
        TLeaf* leaf_Bz	    = chain->GetLeaf("mBfield");
        TLeaf* leaf_PrimaryVertexZ = chain->GetLeaf("mPrimaryVertexPositionZ");
        TLeaf* leaf_VPDVz   = chain->GetLeaf("mVPDEWdiff");
        TLeaf* leaf_RefMult = chain->GetLeaf("mRefMult");
        TLeaf* leaf_TOFMult = chain->GetLeaf("mTOFmult");
        TLeaf* leaf_Centrality = chain->GetLeaf("mCentrality");
        TLeaf* leaf_ZDC_EP  = chain->GetLeaf("mZDC_EP");
        TLeaf* leaf_ZDC	    = chain->GetLeaf("mZDC");
        TLeaf* leaf_ZDCcoin = chain->GetLeaf("mZDCCoin");
        TLeaf* leaf_BBCco   = chain->GetLeaf("mBBCCoin");
        TLeaf* leaf_NoTracks = chain->GetLeaf("mNumberOfV0s");

        Run	= (int)leaf_RunId->GetValue(0);
        Event	= (int)leaf_EventId->GetValue(0);
        Trigger = (int)leaf_Trigger->GetValue(0);
        Bz	= leaf_Bz->GetValue(0);
        PVtxz	= leaf_PrimaryVertexZ->GetValue(0);
        VPDvz   = leaf_VPDVz->GetValue(0);
        RefMult = (int)leaf_RefMult->GetValue(0);
        TOFMult = (int)leaf_TOFMult->GetValue(0);
        NPTracks= (int)leaf_NoTracks->GetValue(0);
        ZDCw	= leaf_ZDC->GetValue(1) + leaf_ZDC->GetValue(2) + leaf_ZDC->GetValue(3);
        ZDCe	= leaf_ZDC->GetValue(5) + leaf_ZDC->GetValue(6) + leaf_ZDC->GetValue(7);
        ZDCcoin = leaf_ZDCcoin->GetValue(0);
        BBCco   = leaf_BBCco->GetValue(0);
        psi_E   = leaf_ZDC_EP->GetValue(0);
        psi_W	= leaf_ZDC_EP->GetValue(2);
        mod_E	= leaf_ZDC_EP->GetValue(1);
        mod_W   = leaf_ZDC_EP->GetValue(3);
        Centrality = leaf_Centrality->GetValue(0);
        Day 	= (int)((Run-12000000)/1000);
        Day2    = (int)((Run-12000000)/10);
        Day3    = (int)((Run-12000000)/1);

        int Bad =0;
        for(int jj=0; jj<12; jj++) if(Day2== bad_Ref_day2[jj]) {
                Bad = 1;
                break;
            }
        if(Day3<=138024) {
            for(int jj=0; jj<Nrun_MB1; jj++) if(Day3 == bad_Ref_day3_MB1[jj]) {
                    Bad = 1;
                    break;
                }
        }
        else if(Day3<=145020) {
            for(int jj=0; jj<Nrun_MB2; jj++) if(Day3 == bad_Ref_day3_MB2[jj]) {
                    Bad = 1;
                    break;
                }
        }
        else if(Day3<=154021) {}
        else if(Day3<=165031) {
            for(int jj=0; jj<Nrun_MB5; jj++) if(Day3 == bad_Ref_day3_MB5[jj]) {
                    Bad = 1;
                    break;
                }
        }
        else {
            for(int jj=0; jj<Nrun_MB6; jj++) if(Day3 == bad_Ref_day3_MB6[jj]) {
                    Bad = 1;
                    break;
                }
        }
        if(Bad) continue;  //bad run


        if(RefMult) {
            float gM = 0.9995 + 21.89/(4.191*RefMult-18.17) - 2.723e-5*(4.191*RefMult-18.17);
            Eweight = gM + 0.0009326*(gM-1)*PVtxz;
        }
        hBz->Fill(Bz);
        hTrigger->Fill(Trigger);
        if((Trigger%5)<2) continue;

        Centrality = 0;
        for(int j=0; j<9; j++) if(RefMult>cenDef[j]) Centrality = j+1;

        refmultCorrUtil.init(Run);
        if ( refmultCorrUtil.isBadRun(Run) ) continue;
        refmultCorrUtil.initEvent(RefMult, PVtxz, ZDCcoin) ;
        Int_t cent9  = 1 + refmultCorrUtil.getCentralityBin9() ;
        Eweight = refmultCorrUtil.getWeight();
        if((i+1)%1000==0) cout<<Centrality<<"   "<<Eweight<<endl;
        Centrality = cent9;

        hVertexZ->Fill(PVtxz);
        hEventTally->Fill("Total Event",1);

        if(TOFMult < -100+3.0*RefMult) continue;                   //remove pile-up
        if(TOFMult > 180 +5.2*RefMult) continue;
        if(TMath::Abs(PVtxz) > Vz_cut) continue;              //Z-vertex cut; track quality cut done in PkNtupleMaker
        if((PVtxz-VPDvz)>3 || (PVtxz-VPDvz)<-3) continue;

        Ref_Day3->Fill(Day3,RefMult);
        TOF_Day3->Fill(Day3,TOFMult);
        NPT_Day3->Fill(Day3,NPTracks);
        Hist_RefMult->Fill(RefMult);
        Hist_TOFMult->Fill(TOFMult);
        if(RefMult>10) {
            p_RefMult->Fill(RefMult,RefMult,Eweight);
            p_TOFMult->Fill(TOFMult,TOFMult,Eweight);
        }

        hCentrality->Fill(Centrality,Eweight);
        hMult_Vz->Fill(RefMult,PVtxz);
        hMult_Vz_new->Fill(RefMult,PVtxz,Eweight);
        if(cen && Centrality != cen) continue;

        hBBC_coin->Fill(BBCco);
        p_RefMult_ZDC_obs->Fill(ZDCe+ZDCw,RefMult,Eweight);
        p_TOFMult_ZDC_obs->Fill(ZDCe+ZDCw,TOFMult,Eweight);

        TLeaf* leaf_PtV0        = chain->GetLeaf("fV0s.mPtV0");
        TLeaf* leaf_EtaV0       = chain->GetLeaf("fV0s.mEtaV0");
        TLeaf* leaf_PhiV0       = chain->GetLeaf("fV0s.mPhiV0");
        TLeaf* leaf_ChargeV0    = chain->GetLeaf("fV0s.mChargeV0");
        TLeaf* leaf_DCAglobalV0 = chain->GetLeaf("fV0s.mDcaV0");
        TLeaf* leaf_ndEdxV0     = chain->GetLeaf("fV0s.mndEdxV0");
        TLeaf* leaf_TofFlagV0   = chain->GetLeaf("fV0s.mTofFlagV0");
        TLeaf* leaf_TofYLocalV0   = chain->GetLeaf("fV0s.mTofYLocalV0");
        TLeaf* leaf_TofM2V0   = chain->GetLeaf("fV0s.mTofM2V0");
        TLeaf* leaf_nSigmaPV0   = chain->GetLeaf("fV0s.mnSigma_pV0");
        TLeaf* leaf_nSigmaPiV0  = chain->GetLeaf("fV0s.mnSigma_piV0");
        TLeaf* leaf_nSigmaKV0   = chain->GetLeaf("fV0s.mnSigma_kV0");
        TLeaf* leaf_nSigmaEV0   = chain->GetLeaf("fV0s.mnSigma_eV0");

        int Np = 0, Npbar = 0;
        int Ntof = 0;
//TPC EP reconstruction
        TVector2 mQ, mQ1, mQ2, mQ3, mQ4;
        Double_t mQx=0., mQy=0., mQx1=0., mQy1=0., mQx2=0., mQy2=0., mQx3=0., mQy3=0., mQx4=0., mQy4=0.;
        int Fcount = 0, Ecount = 0, Wcount =0;
        for(int trk = 0; trk < NPTracks; trk++) {
            float EtaAsso   = leaf_EtaV0->GetValue(trk);
            float PtAsso    = leaf_PtV0->GetValue(trk);
            float PhiAsso   = leaf_PhiV0->GetValue(trk);
            float DCAglAsso = leaf_DCAglobalV0->GetValue(trk);
            float ChargeAsso= leaf_ChargeV0->GetValue(trk);
            nSigma_p  = leaf_nSigmaPV0->GetValue(trk);
            float nSigma_K  = leaf_nSigmaKV0->GetValue(trk);
            float nSigma_e  = leaf_nSigmaEV0->GetValue(trk);
            float TOFflag   = leaf_TofFlagV0->GetValue(trk);
            if(TOFflag>0) Ntof++;

            // also nSigma_e>1
            if(PtAsso>0.4 && PtAsso<1 && DCAglAsso<1 && EtaAsso>-1 && EtaAsso<1 && nSigma_p>-2 && nSigma_p<2 && nSigma_K>2 && nSigma_e >1 && ChargeAsso >0) Np++;
            if(PtAsso>0.4 && PtAsso<1 && DCAglAsso<1 && EtaAsso>-1 && EtaAsso<1 && nSigma_p>-2 && nSigma_p<2 && nSigma_K>2 && nSigma_e >1 && ChargeAsso <0) Npbar++;

            if(PtAsso > pt_asso_up || PtAsso < pt_asso_lo) continue;
            if(DCAglAsso > DcaCut) continue;
            if(EtaAsso>EtaCut || EtaAsso<-EtaCut) continue;
            if(opt_TOF ==1 && TOFflag<1) continue;

            Fcount++;
            int n = (int)((PhiAsso+PI)/2./PI*Phibin);
            int fl = (PVtxz > 0)? ((ChargeAsso > 0)? 1:2):((ChargeAsso > 0)? 3:4);
            Hist_Phi->Fill(PhiAsso,fl,PtAsso);
            float W_phi = (EtaAsso>0)? PhiWgtFF[n][fl-1]:PhiWgtRF[n][fl-1];
            mQx += W_phi*PtAsso * cos(PhiAsso * 2.);
            mQy += W_phi*PtAsso * sin(PhiAsso * 2.);

            if(EtaAsso>0 && PVtxz>0 && ChargeAsso > 0) Hist_Phi_FF->Fill(PhiAsso,1,Eweight);
            if(EtaAsso>0 && PVtxz>0 && ChargeAsso < 0) Hist_Phi_FF->Fill(PhiAsso,2,Eweight);
            if(EtaAsso<0 && PVtxz>0 && ChargeAsso > 0) Hist_Phi_RF->Fill(PhiAsso,1,Eweight);
            if(EtaAsso<0 && PVtxz>0 && ChargeAsso < 0) Hist_Phi_RF->Fill(PhiAsso,2,Eweight);
            if(EtaAsso>0 && PVtxz<0 && ChargeAsso > 0) Hist_Phi_FF->Fill(PhiAsso,1+2,Eweight);
            if(EtaAsso>0 && PVtxz<0 && ChargeAsso < 0) Hist_Phi_FF->Fill(PhiAsso,2+2,Eweight);
            if(EtaAsso<0 && PVtxz<0 && ChargeAsso > 0) Hist_Phi_RF->Fill(PhiAsso,1+2,Eweight);
            if(EtaAsso<0 && PVtxz<0 && ChargeAsso < 0) Hist_Phi_RF->Fill(PhiAsso,2+2,Eweight);
        }
        if(Ntof<2) continue;

        int net_Np = Np - Npbar;
        Hist_proton->Fill(Np);
        Hist_pbar->Fill(Npbar);
        Hist_netP->Fill(net_Np);
        int iTrack[Fcount], Scount = Fcount/2 -1;
        for(int q=0; q<Fcount; q++) iTrack[q] = q;
        random_shuffle(iTrack,iTrack+Fcount);
        Fcount = 0;
        for(int trk = 0; trk < NPTracks; trk++) {
            float EtaAsso   = leaf_EtaV0->GetValue(trk);
            float PtAsso    = leaf_PtV0->GetValue(trk);
            float PhiAsso   = leaf_PhiV0->GetValue(trk);
            float DCAglAsso = leaf_DCAglobalV0->GetValue(trk);
            float ChargeAsso= leaf_ChargeV0->GetValue(trk);
            float TOFflag   = leaf_TofFlagV0->GetValue(trk);
            if(PtAsso > pt_asso_up || PtAsso < pt_asso_lo) continue;
            if(DCAglAsso > DcaCut) continue;
            if(EtaAsso>EtaCut || EtaAsso<-EtaCut) continue;
            if(opt_TOF ==1 && TOFflag<1) continue;

            int n = (int)((PhiAsso+PI)/2./PI*Phibin);
            int fl = (PVtxz > 0)? ((ChargeAsso > 0)? 1:2):((ChargeAsso > 0)? 3:4);
            float W_phi = (EtaAsso>0)? PhiWgtFF[n][fl-1]:PhiWgtRF[n][fl-1];
            if(iTrack[Fcount] > Scount) {
                mQx1 +=W_phi*PtAsso*cos(PhiAsso*2.);
                mQy1 +=W_phi*PtAsso*sin(PhiAsso * 2.);
                Ecount++;
            }
            else {
                mQx2 += W_phi*PtAsso * cos(PhiAsso * 2.);
                mQy2 += W_phi*PtAsso * sin(PhiAsso * 2.);
                Wcount++;
            }
            if(EtaAsso> 0.1) {
                mQx3 +=W_phi*PtAsso*cos(PhiAsso*2.);
                mQy3 +=W_phi*PtAsso*sin(PhiAsso * 2.);
            }
            if(EtaAsso<-0.1) {
                mQx4 +=W_phi*PtAsso*cos(PhiAsso*2.);
                mQy4 +=W_phi*PtAsso*sin(PhiAsso * 2.);
            }
            Fcount++;
        }
        if(mQx1==0 || mQy1==0 || mQx2==0 || mQy2==0) continue;
        if(mQx3==0 || mQy3==0 || mQx4==0 || mQy4==0) continue;
        mQ.Set(mQx, mQy);
        mQ1.Set(mQx1, mQy1);
        mQ2.Set(mQx2, mQy2);
        mQ3.Set(mQx3, mQy3);
        mQ4.Set(mQx4, mQy4);
        float TPC_EP_full = 0.5*mQ.Phi();
        float TPC_EP_east = 0.5*mQ1.Phi();
        float TPC_EP_west = 0.5*mQ2.Phi();
        float TPC_EP_for  = 0.5*mQ3.Phi();
        float TPC_EP_bac  = 0.5*mQ4.Phi();
        Hist_TPC_EP_full->Fill(TPC_EP_full,Day);
        Hist_TPC_EP_east->Fill(TPC_EP_east,Day);
        Hist_TPC_EP_west->Fill(TPC_EP_west,Day);
        Hist_TPC_EP_for->Fill(TPC_EP_for,Day);
        Hist_TPC_EP_bac->Fill(TPC_EP_bac,Day);
        pTPC_EP_east->Fill(1,Day,cos(2*TPC_EP_east));
        pTPC_EP_east->Fill(2,Day,sin(2*TPC_EP_east));
        pTPC_EP_east->Fill(3,Day,cos(4*TPC_EP_east));
        pTPC_EP_east->Fill(4,Day,sin(4*TPC_EP_east));
        pTPC_EP_west->Fill(1,Day,cos(2*TPC_EP_west));
        pTPC_EP_west->Fill(2,Day,sin(2*TPC_EP_west));
        pTPC_EP_west->Fill(3,Day,cos(4*TPC_EP_west));
        pTPC_EP_west->Fill(4,Day,sin(4*TPC_EP_west));
        pTPC_EP_for->Fill(1,Day,cos(2*TPC_EP_for));
        pTPC_EP_for->Fill(2,Day,sin(2*TPC_EP_for));
        pTPC_EP_for->Fill(3,Day,cos(4*TPC_EP_for));
        pTPC_EP_for->Fill(4,Day,sin(4*TPC_EP_for));
        pTPC_EP_bac->Fill(1,Day,cos(2*TPC_EP_bac));
        pTPC_EP_bac->Fill(2,Day,sin(2*TPC_EP_bac));
        pTPC_EP_bac->Fill(3,Day,cos(4*TPC_EP_bac));
        pTPC_EP_bac->Fill(4,Day,sin(4*TPC_EP_bac));
        if(fWgt->IsOpen() && Read_TPC_EP_east->GetEntries()) {
            PsiShiftE1 = Read_TPC_EP_east->GetBinContent(1,Day-79);
            PsiShiftE2 = Read_TPC_EP_east->GetBinContent(2,Day-79);
            PsiShiftE3 = Read_TPC_EP_east->GetBinContent(3,Day-79);
            PsiShiftE4 = Read_TPC_EP_east->GetBinContent(4,Day-79);
        }
        if(fWgt->IsOpen() && Read_TPC_EP_west->GetEntries()) {
            PsiShiftW1 = Read_TPC_EP_west->GetBinContent(1,Day-79);
            PsiShiftW2 = Read_TPC_EP_west->GetBinContent(2,Day-79);
            PsiShiftW3 = Read_TPC_EP_west->GetBinContent(3,Day-79);
            PsiShiftW4 = Read_TPC_EP_west->GetBinContent(4,Day-79);
        }
        if(fWgt->IsOpen() && Read_TPC_EP_for->GetEntries()) {
            PsiShiftf1 = Read_TPC_EP_for->GetBinContent(1,Day-79);
            PsiShiftf2 = Read_TPC_EP_for->GetBinContent(2,Day-79);
            PsiShiftf3 = Read_TPC_EP_for->GetBinContent(3,Day-79);
            PsiShiftf4 = Read_TPC_EP_for->GetBinContent(4,Day-79);
        }
        if(fWgt->IsOpen() && Read_TPC_EP_bac->GetEntries()) {
            PsiShiftb1 = Read_TPC_EP_bac->GetBinContent(1,Day-79);
            PsiShiftb2 = Read_TPC_EP_bac->GetBinContent(2,Day-79);
            PsiShiftb3 = Read_TPC_EP_bac->GetBinContent(3,Day-79);
            PsiShiftb4 = Read_TPC_EP_bac->GetBinContent(4,Day-79);
        }
        float TPC_EP_east_new = TPC_EP_east, TPC_EP_west_new = TPC_EP_west;
        float TPC_EP_for_new = TPC_EP_for, TPC_EP_bac_new = TPC_EP_bac;
        TPC_EP_east_new += 2*(-PsiShiftE2*cos(2*TPC_EP_east)+PsiShiftE1*sin(2*TPC_EP_east))/(float)2 + 2*(-PsiShiftE4*cos(4*TPC_EP_east)+PsiShiftE3*sin(4*TPC_EP_east))/(float)4;
        TPC_EP_west_new += 2*(-PsiShiftW2*cos(2*TPC_EP_west)+PsiShiftW1*sin(2*TPC_EP_west))/(float)2 + 2*(-PsiShiftW4*cos(4*TPC_EP_west)+PsiShiftW3*sin(4*TPC_EP_west))/(float)4;
        TPC_EP_for_new += 2*(-PsiShiftf2*cos(2*TPC_EP_for)+PsiShiftf1*sin(2*TPC_EP_for))/(float)2 + 2*(-PsiShiftf4*cos(4*TPC_EP_for)+PsiShiftf3*sin(4*TPC_EP_for))/(float)4;
        TPC_EP_bac_new += 2*(-PsiShiftb2*cos(2*TPC_EP_bac)+PsiShiftb1*sin(2*TPC_EP_bac))/(float)2 + 2*(-PsiShiftb4*cos(4*TPC_EP_bac)+PsiShiftb3*sin(4*TPC_EP_bac))/(float)4;
        if(TPC_EP_east_new>PI) TPC_EP_east_new -= PI;
        if(TPC_EP_east_new< 0) TPC_EP_east_new += PI;
        if(TPC_EP_west_new>PI) TPC_EP_west_new -= PI;
        if(TPC_EP_west_new< 0) TPC_EP_west_new += PI;
        if(TPC_EP_for_new>PI) TPC_EP_for_new -= PI;
        if(TPC_EP_for_new< 0) TPC_EP_for_new += PI;
        if(TPC_EP_bac_new>PI) TPC_EP_bac_new -= PI;
        if(TPC_EP_bac_new< 0) TPC_EP_bac_new += PI;
        Hist_TPC_EP_east_flat->Fill(TPC_EP_east_new,Day);
        Hist_TPC_EP_west_flat->Fill(TPC_EP_west_new,Day);
        Hist_TPC_EP_for_flat->Fill(TPC_EP_for_new,Day);
        Hist_TPC_EP_bac_flat->Fill(TPC_EP_bac_new,Day);
        mQx = mQ1.Mod()*cos(2*TPC_EP_east_new) + mQ2.Mod()*cos(2*TPC_EP_west_new);
        mQy = mQ1.Mod()*sin(2*TPC_EP_east_new) + mQ2.Mod()*sin(2*TPC_EP_west_new);
        if(mQx==0 || mQy==0) continue;
        mQ.Set(mQx, mQy);
        TPC_EP_full = 0.5*mQ.Phi();
        pTPC_EP_full->Fill(1,Day,cos(2*TPC_EP_full));
        pTPC_EP_full->Fill(2,Day,sin(2*TPC_EP_full));
        pTPC_EP_full->Fill(3,Day,cos(4*TPC_EP_full));
        pTPC_EP_full->Fill(4,Day,sin(4*TPC_EP_full));
        if(fWgt->IsOpen() && Read_TPC_EP_full->GetEntries()) {
            PsiShiftF1 = Read_TPC_EP_full->GetBinContent(1,Day-79);
            PsiShiftF2 = Read_TPC_EP_full->GetBinContent(2,Day-79);
            PsiShiftF3 = Read_TPC_EP_full->GetBinContent(3,Day-79);
            PsiShiftF4 = Read_TPC_EP_full->GetBinContent(4,Day-79);
        }
        float TPC_EP_full_new = TPC_EP_full;
        TPC_EP_full_new += 2*(-PsiShiftF2*cos(2*TPC_EP_full)+PsiShiftF1*sin(2*TPC_EP_full))/(float)2 + 2*(-PsiShiftF4*cos(4*TPC_EP_full)+PsiShiftF3*sin(4*TPC_EP_full))/(float)4;
        if(TPC_EP_full_new>PI) TPC_EP_full_new -= PI;
        if(TPC_EP_full_new< 0) TPC_EP_full_new += PI;
        Hist_TPC_EP_full_flat->Fill(TPC_EP_full_new,Day);
        mQx = mQ.Mod()*cos(2*TPC_EP_full_new);
        mQy = mQ.Mod()*sin(2*TPC_EP_full_new);
        Hist_cos->Fill(1,cos(2.*TPC_EP_for_new-2.*TPC_EP_bac_new), Eweight);
        Hist_cos->Fill(2,cos(2.*TPC_EP_east_new-2.*TPC_EP_west_new), Eweight);
        Hist_cos_RefMult->Fill(1,RefMult,cos(2.*TPC_EP_for_new-2.*TPC_EP_bac_new), Eweight);
        Hist_cos_RefMult->Fill(2,RefMult,cos(2.*TPC_EP_east_new-2.*TPC_EP_west_new), Eweight);
        Hist_cos_TOFMult->Fill(1,TOFMult,cos(2.*TPC_EP_for_new-2.*TPC_EP_bac_new), Eweight);
        Hist_cos_TOFMult->Fill(2,TOFMult,cos(2.*TPC_EP_east_new-2.*TPC_EP_west_new), Eweight);
        Hist_cos_ZDC->Fill(1,ZDCe+ZDCw,cos(2.*TPC_EP_for_new-2.*TPC_EP_bac_new), Eweight);
        Hist_cos_ZDC->Fill(2,ZDCe+ZDCw,cos(2.*TPC_EP_east_new-2.*TPC_EP_west_new), Eweight);
        Hist_cos_BBC_RefMult->Fill(BBCco,RefMult,cos(2.*TPC_EP_for_new-2.*TPC_EP_bac_new), Eweight);
        Hist_dif_count->Fill(Ecount - Wcount);
        Hist_ful_count->Fill(Ecount + Wcount);
        TPC_Day3_cos2->Fill(Day3, cos(2*TPC_EP_full));
        TPC_Day3_sin2->Fill(Day3, sin(2*TPC_EP_full));
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //loop through matched primary tracks
        for(int trki = 0; trki < NPTracks; trki++) {
            Pt	  = leaf_PtV0->GetValue(trki);
            Eta	  = leaf_EtaV0->GetValue(trki);
            Theta     = 2.*atan(exp(-Eta));
            Charge	  = leaf_ChargeV0->GetValue(trki);
            Phi	  = leaf_PhiV0->GetValue(trki);
            ndEdx	  = leaf_ndEdxV0->GetValue(trki);
            DCAGlobal = leaf_DCAglobalV0->GetValue(trki);
            nSigma_p  = leaf_nSigmaPV0->GetValue(trki);
            nSigma_pi = leaf_nSigmaPiV0->GetValue(trki);
            float TOFflag   = leaf_TofFlagV0->GetValue(trki);
            float En  = sqrt(0.1396*0.1396+pow(Pt*cosh(Eta),2));
            float TofYLocal = leaf_TofYLocalV0->GetValue(trki);
            float TofM2     = leaf_TofM2V0->GetValue(trki);


            if(DCAGlobal > DcaCut) continue;
            if(Pt < pt_trig_lo || Pt > pt_trig_up) continue;
            if(Eta > EtaCut || Eta < -EtaCut) continue;

            Hist_Pt->Fill(Pt,Eweight);
            if(TOFflag>0) Hist_Pt_TOF->Fill(Pt,Eweight);

            if(ndEdx<15||nSigma_pi<-2 || nSigma_pi>2) continue;
            if(TOFflag<1||TofYLocal<-1.8||TofYLocal>1.8||TofM2<-0.01 || TofM2>0.1) continue;
            hEtaPtDist->Fill(Eta,Pt,Eweight);

//Corrections
            if(fWgt->IsOpen() && (TPCmean_FF->GetEntries() || TPCmean_RF->GetEntries())) {
                for(int k=1; k<5; k++) {
                    for(int kk=0; kk<order; kk++) {
                        if(Eta>0 && PVtxz>0) PhiMean[k-1+4*kk] = TPCmean_FF->GetBinContent(k+8*kk,Day2-7999);
                        if(Eta<0 && PVtxz>0) PhiMean[k-1+4*kk] = TPCmean_RF->GetBinContent(k+8*kk,Day2-7999);
                        if(Eta>0 && PVtxz<0) PhiMean[k-1+4*kk] = TPCmean_FF->GetBinContent(k+4+8*kk,Day2-7999);
                        if(Eta<0 && PVtxz<0) PhiMean[k-1+4*kk] = TPCmean_RF->GetBinContent(k+4+8*kk,Day2-7999);
                    }
                }
            }

            float cos1 =0, cos2=0, sin1=0, sin2=0, Phi_new = Phi;
            // Recentering parameters
            if(Eta>0 && PVtxz>0) {
                if(Charge > 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_FF->Fill(1+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_FF->Fill(2+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
                if(Charge < 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_FF->Fill(3+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_FF->Fill(4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
            }
            if(Eta<0 && PVtxz>0) {
                if(Charge > 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_RF->Fill(1+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_RF->Fill(2+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
                if(Charge < 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_RF->Fill(3+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_RF->Fill(4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
            }
            if(Eta>0 && PVtxz<0) {
                if(Charge > 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_FF->Fill(1+4+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_FF->Fill(2+4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
                if(Charge < 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_FF->Fill(3+4+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_FF->Fill(4+4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
            }
            if(Eta<0 && PVtxz<0) {
                if(Charge > 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_RF->Fill(1+4+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_RF->Fill(2+4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
                if(Charge < 0) {
                    for(int kk=0; kk<order; kk++) {
                        pTPCmeanPhi_RF->Fill(3+4+8*kk,Day2,cos(kk*Phi+Phi),Eweight);
                        pTPCmeanPhi_RF->Fill(4+4+8*kk,Day2,sin(kk*Phi+Phi),Eweight);
                    }
                }
            }

        }  //Track


    } // Event
    rc = (TH1D*)Hist_Pt_TOF->Clone();
    rc->SetName("rc");
    rc->Divide(Hist_Pt);


    fout.Write();
    char fname_new[200];
    sprintf(fname_new,"cen%d.weight_pi_minbias5_new.root",cen);
    TFile *fWgtNew = new TFile(fname_new,"RECREATE");
    pTPCmeanPhi_FF->Write();
    pTPCmeanPhi_RF->Write();
    Hist_Phi_FF->Write();
    Hist_Phi_RF->Write();
    pTPC_EP_east->Write();
    pTPC_EP_west->Write();
    pTPC_EP_for->Write();
    pTPC_EP_bac->Write();
    pTPC_EP_full->Write();
    rc->Write();
    fWgtNew->Close();
    return;
}
Example #2
0
void Calc_Eff_200(int cen) {
const float PI = TMath::Pi();
const float mean = 0.01166;
const float rms = 0.05312;
TFile *f1 = new TFile("cen6.ntuple_result_v2_11_subEP_dca1_pt015_eta1_noP_pionDca1_higherEP.root");
TH1* h_pt = (TH1*)f1->Get("Hist_Pt");

float real[9][7] = {{1.68441e+07,1.94857e+07,1.91433e+07,1.76339e+07,1.57031e+07,1.3709e+07,1.18246e+07},
			{3.87595e+07,4.43888e+07,4.34577e+07,4.00144e+07,3.57267e+07,3.13252e+07,2.71556e+07},
			{8.04378e+07,9.2009e+07,9.01896e+07,8.33911e+07,7.47927e+07,6.59201e+07,5.74707e+07},
			{1.28651e+08,1.47865e+08,1.45606e+08,1.3528e+08,1.2199e+08,1.08084e+08,9.47436e+07},
			{1.9998e+08,2.31542e+08,2.29316e+08,2.14124e+08,1.94076e+08,1.72786e+08,1.52079e+08},
			{2.91541e+08,3.40818e+08,3.39637e+08,3.1877e+08,2.90097e+08,2.59203e+08,2.29072e+08},
			{3.94517e+08,4.66796e+08,4.68155e+08,4.41467e+08,4.03254e+08,3.61425e+08,3.20203e+08},
			{2.3895e+08,2.85928e+08,2.88314e+08,2.72767e+08,2.49768e+08,2.24261e+08,1.98897e+08},
			{2.70925e+08,3.27361e+08,3.31383e+08,3.14285e+08,2.88208e+08,2.5899e+08,2.29898e+08}};
float emrc[9][7] = {{127.287,180.108,180.46,203.105,201.325,185.72,183.217},
			{111.057,137.61,163.772,151.6,161.841,157.728,178.696},
			{157.959,196.018,206.222,184.609,183.632,238.975,225.804},
			{294.14,355.613,355.514,396.844,397.958,385.601,425},
			{499,551,666,616,706,750,677},
			{715,916,988,992,1031,1047,1070},
			{1045,1247,1393,1414,1523,1589,1527},
			{653,853,898,928,1016,1073,996},
			{863,975,1199,1263,1262,1258,1314}};
const int cenDef[9] = {10, 22, 43, 76, 125, 193, 281, 396, 466};

float Eweight = 1;

        TChain* chain = new TChain("McV0PicoDst");
        int nfile = 0;
        nfile += chain->Add("output_p/*.root");
	nfile += chain->Add("output_pbar/*.root");
//	nfile += chain->Add("output_test/*.root");
//	nfile += chain->Add("output_km/*.root");
//        nfile += chain->Add("output_kp/*.root");
                cout <<"Added "<<nfile<<" files"<<endl;
                cout<<"# entries in chain: "<<chain->GetEntries()<<endl;

	char fname_out[200];
	sprintf(fname_out,"cen%d.eff_200_p.root",cen);
        TFile fout(fname_out,"RECREATE");

	TH1D* Hist_RefMult = new TH1D("Hist_RefMult","Hist_RefMult",500,-0.5,499.5);
	TH2D* Hist_mc_pt = new TH2D("Hist_mc_pt","Hist_mc_pt",28,0,560,200,0,10);
	TH1D* Hist_mc_pt_cen = new TH1D("Hist_mc_pt_cen","Hist_mc_pt_cen",200,0,10);
        TH1D* Hist_mc_pt_L = new TH1D("Hist_mc_pt_L","Hist_mc_pt_Lokesh",200,0,10);
	TH1D* Hist_mc_eta = new TH1D("Hist_mc_eta","Hist_mc_eta",200,-1,1);
	TH1D* Hist_rc_flag = new TH1D("Hist_rc_flag","Hist_rc_flag",3000,-1000+0.5,2000.5);
	TH2D* Hist_rc_pt = new TH2D("Hist_rc_pt","Hist_rc_pt",28,0,560,200,0,10);
	TH1D* Hist_rc_pt_cen = new TH1D("Hist_rc_pt_cen","Hist_rc_pt_cen",200,0,10);
	TH1D* Hist_rc_pt_scale = new TH1D("Hist_rc_pt_scale","Hist_rc_pt_scale",200,0,10);
	TH1D* Hist_rc_pt_L = new TH1D("Hist_rc_pt_L","Hist_rc_pt_Lokesh",200,0,10);
	TH1D* Hist_rc_eta = new TH1D("Hist_rc_eta","Hist_rc_eta",200,-1,1);
	TH1D* Hist_rc_dca = new TH1D("Hist_rc_dca","Hist_rc_dca",200,0,20);
	TH1D* Hist_rc_dca_scale = new TH1D("Hist_rc_dca_scale","Hist_rc_dca_scale",200,0,20);
	TH1D* Hist_rc_nfit = new TH1D("Hist_rc_nfit","Hist_rc_nfit",100,0,100);
	TH1D* Hist_rc_rat = new TH1D("Hist_rc_rat","Hist_rc_rat",100,0,2);
	TH1D* Hist_dphi = new TH1D("Hist_dphi","Hist_dphi",128,-3.2,3.2);
        TH1D* Hist_dphi1 = new TH1D("Hist_dphi1","Hist_dphi1",128,-3.2,3.2);
        TH1D* Hist_dphi2 = new TH1D("Hist_dphi2","Hist_dphi2",128,-3.2,3.2);
        TH1D* Hist_dphi3 = new TH1D("Hist_dphi3","Hist_dphi3",128,-3.2,3.2);
        TH1D* Hist_dphi4 = new TH1D("Hist_dphi4","Hist_dphi4",128,-3.2,3.2);
        TH1D* Hist_dphi_pion = new TH1D("Hist_dphi_pion","Hist_dphi_pion",128,-3.2,3.2);
        TH1D* Hist_ddphi = new TH1D("Hist_ddphi","Hist_ddphi",128,-3.2,3.2);
        TProfile* p_dphi = new TProfile("p_dphi","p_dphi",4,0.5,4.5,-100,100);
        TProfile* p_dphi_pt = new TProfile("p_dphi_pt","p_dphi_pt",200,0,10,-100,100);
        TProfile* p_dphi_L = new TProfile("p_dphi_L","p_dphi_L",4,0.5,4.5,-100,100);
        TProfile* p_dphi_LM= new TProfile("p_dphi_LM","p_dphi_LM",4,0.5,4.5,-100,100);
        TProfile* p_dphi_M = new TProfile("p_dphi_M","p_dphi_M",4,0.5,4.5,-100,100);
        TProfile* p_dphi_RM= new TProfile("p_dphi_RM","p_dphi_RM",4,0.5,4.5,-100,100);
        TProfile* p_dphi_R = new TProfile("p_dphi_R","p_dphi_R",4,0.5,4.5,-100,100);
	TProfile* p_ddphi = new TProfile("p_ddphi","p_ddphi",4,0.5,4.5,-100,100);
        TProfile* p_ddphi_L = new TProfile("p_ddphi_L","p_ddphi_L",4,0.5,4.5,-100,100);
        TProfile* p_ddphi_LM= new TProfile("p_ddphi_LM","p_ddphi_LM",4,0.5,4.5,-100,100);
        TProfile* p_ddphi_M = new TProfile("p_ddphi_M","p_ddphi_M",4,0.5,4.5,-100,100);
        TProfile* p_ddphi_RM= new TProfile("p_ddphi_RM","p_ddphi_RM",4,0.5,4.5,-100,100);
        TProfile* p_ddphi_R = new TProfile("p_ddphi_R","p_ddphi_R",4,0.5,4.5,-100,100);
        TH1D* Hist_asym = new TH1D("Hist_asym","Hist_asym",600,-1.5+0.0025,1.5+0.0025);
        TH1D* Hist_asym_L = new TH1D("Hist_asym_L","Hist_asym_L",600,-1.5+0.0025,1.5+0.0025);
        TH1D* Hist_asym_LM= new TH1D("Hist_asym_LM","Hist_asym_LM",600,-1.5+0.0025,1.5+0.0025);
        TH1D* Hist_asym_M = new TH1D("Hist_asym_M","Hist_asym_M",600,-1.5+0.0025,1.5+0.0025);
        TH1D* Hist_asym_RM= new TH1D("Hist_asym_RM","Hist_asym_RM",600,-1.5+0.0025,1.5+0.0025);
        TH1D* Hist_asym_R = new TH1D("Hist_asym_R","Hist_asym_R",600,-1.5+0.0025,1.5+0.0025);

	Int_t nentries = chain->GetEntries();
	for(int i = 0; i < nentries; i++){

                if((i+1)%1000==0) cout<<"Processing entry == "<< i+1 <<" == out of "<<nentries<<".\n";
                chain->GetEntry(i);

                TLeaf* leaf_RunId   = chain->GetLeaf("runnumber");
		TLeaf* leaf_RefMult = chain->GetLeaf("nrefmult");
		TLeaf* leaf_Px	    = chain->GetLeaf("primvertexX");
		TLeaf* leaf_Py      = chain->GetLeaf("primvertexY");
		TLeaf* leaf_Pz      = chain->GetLeaf("primvertexZ");
		TLeaf* leaf_ZDCrate = chain->GetLeaf("zdcrate");
		TLeaf* leaf_nmcv0   = chain->GetLeaf("nmcv0");
		TLeaf* leaf_nv0	    = chain->GetLeaf("nv0");
                TLeaf* leaf_Np      = chain->GetLeaf("numberP");
                TLeaf* leaf_Nn      = chain->GetLeaf("numberN");

		int Run 	    = leaf_RunId->GetValue(0);
		int RefMult	    = leaf_RefMult->GetValue(0);
		float PVtxz	    = leaf_Pz->GetValue(0);
		int NmcTracks	    = leaf_nmcv0->GetValue(0);
		int NrcTracks	    = leaf_nv0->GetValue(0);
                int Np              = leaf_Np->GetValue(0);
                int Nn              = leaf_Nn->GetValue(0);

		Hist_RefMult->Fill(RefMult);
                int Centrality  = 0;
                for(int j=0;j<9;j++) if(RefMult>cenDef[j]) Centrality = j+1;
                if(RefMult) {
                        float gM = 0.9995 + 21.89/(4.191*RefMult-18.17) - 2.723e-5*(4.191*RefMult-18.17);
                        Eweight = gM + 0.0009326*(gM-1)*PVtxz;
                }
                if(cen && Centrality != cen) continue;

                TLeaf* leaf_mc_Pt        = chain->GetLeaf("mcv0pt");
		TLeaf* leaf_mc_Pz        = chain->GetLeaf("mcv0pz");
		TLeaf* leaf_mc_Px        = chain->GetLeaf("mcv0px");
		TLeaf* leaf_mc_Py        = chain->GetLeaf("mcv0py");
		TLeaf* leaf_mc_id        = chain->GetLeaf("mcv0id");

		for(int trk = 0; trk < NmcTracks; trk++) {
			float mc_pt = leaf_mc_Pt->GetValue(trk);
			float mc_pz = leaf_mc_Pz->GetValue(trk);
			float mc_theta = atan2(mc_pt,mc_pz);
			float mc_eta = -log(tan(mc_theta/2));
			Hist_mc_eta->Fill(mc_eta, Eweight);
			if(mc_eta>-0.5 && mc_eta<0.5) {Hist_mc_pt->Fill(RefMult,mc_pt);}
			if(mc_eta>-1 && mc_eta<1) {Hist_mc_pt_cen->Fill(mc_pt);}
			if(mc_eta>-0.1 && mc_eta<0.1) Hist_mc_pt_L->Fill(mc_pt, Eweight);
		}

                TLeaf* leaf_rc_Pt        = chain->GetLeaf("v0pt");
		TLeaf* leaf_rc_Phi	 = chain->GetLeaf("v0phi");
		TLeaf* leaf_rc_Eta	 = chain->GetLeaf("v0eta");
                TLeaf* leaf_rc_Charge    = chain->GetLeaf("v0charge");
		TLeaf* leaf_rc_flag	 = chain->GetLeaf("v0flag");
		TLeaf* leaf_rc_dca	 = chain->GetLeaf("v0dca");
		TLeaf* leaf_rc_Nfithits  = chain->GetLeaf("v0nfithits");
		TLeaf* leaf_rc_Nmaxhits  = chain->GetLeaf("v0nmaxhits"); 
		TLeaf* leaf_rc_Ndedxhits = chain->GetLeaf("v0ndedxhits");
                TLeaf* leaf_rc_id        = chain->GetLeaf("v0mcid");

               for(int trk = 0; trk < NrcTracks; trk++) {
			int flag = leaf_rc_flag->GetValue(trk);
			Hist_rc_flag->Fill(flag,Eweight);
			if(flag<0 || flag>1000) continue;
			float dca = leaf_rc_dca->GetValue(trk);
			float rc_pt = leaf_rc_Pt->GetValue(trk);
			float eta = leaf_rc_Eta->GetValue(trk);
			int nFitHits = leaf_rc_Nfithits->GetValue(trk);
			int nMaxHits = leaf_rc_Nmaxhits->GetValue(trk);
			float ratio = float(nFitHits)/nMaxHits;
			int ndEdxHits = leaf_rc_Ndedxhits->GetValue(trk);
			Hist_rc_nfit->Fill(nFitHits, Eweight);
			Hist_rc_rat->Fill(ratio, Eweight);
			if(nFitHits<20 || nFitHits>50) continue;
			if(ratio<0.52 || ratio>1.05) continue;
				if(dca>2) continue;

				int ptbin = 0;
				if(rc_pt>0.2) ptbin = 1;
				if(rc_pt>0.25) ptbin = 2;
				if(rc_pt>0.3) ptbin = 3;
				if(rc_pt>0.35) ptbin = 4;
				if(rc_pt>0.4) ptbin = 5;
				if(rc_pt>0.45) ptbin = 6;
				float ptW = 0.001*real[cen-1][ptbin]/emrc[cen-1][ptbin];
//			if((i+1)%1000==0 && rc_pt<0.3 && rc_pt>0.25)  cout<<ptW<<endl;
			Hist_rc_eta->Fill(eta, Eweight);
			
			if(rc_pt>0.15 && rc_pt<0.5) {Hist_rc_dca->Fill(dca, Eweight);Hist_rc_dca_scale->Fill(dca, Eweight*ptW);}
                        if(eta>-0.5 && eta<0.5) {Hist_rc_pt->Fill(RefMult,rc_pt);}

                        if(dca<2 && ndEdxHits>14) {
                        if(eta>-1 && eta<1) Hist_rc_pt_cen->Fill(rc_pt);
			Hist_rc_pt_scale->Fill(rc_pt, Eweight*ptW);
}
			if(dca<3 && nFitHits>=25 &&ndEdxHits>15 && eta>-0.1 && eta<0.1) Hist_rc_pt_L->Fill(rc_pt, Eweight);
                }
///////ONLY ABOVE THIS LINE IS NEEDED FOR EFFICIENCY/////////////////////////////////////////////////// 	
		float Mpt[30], Mdca[30], MndEdxHits[30], Mdphi[30], Mweight[30];
		float integral = (float)h_pt->Integral(1,40);
                float bin_mean = integral/40.;
		int Mnmatch = 0;
		for(int trk = 0; trk < NrcTracks; trk++) {
                        int flag = leaf_rc_flag->GetValue(trk);
			if(flag<0 || flag>1000) continue;
                        float dca = leaf_rc_dca->GetValue(trk);
                        float rc_pt = leaf_rc_Pt->GetValue(trk);
			float rc_phi = leaf_rc_Phi->GetValue(trk);
			float rc_charge = leaf_rc_Charge->GetValue(trk);
                        float eta = leaf_rc_Eta->GetValue(trk);
			if(eta>1 || eta<-1) continue; 
                        int nFitHits = leaf_rc_Nfithits->GetValue(trk);
                        int nMaxHits = leaf_rc_Nmaxhits->GetValue(trk);
                        float ratio = float(nFitHits)/nMaxHits;
                        int ndEdxHits = leaf_rc_Ndedxhits->GetValue(trk);
                        if(nFitHits<20 || nFitHits>50) continue;
                        if(ratio<0.52 || ratio>1.05) continue;
			int rc_id = leaf_rc_id->GetValue(trk);
			int bin = h_pt->FindBin(rc_pt);
			float weight = h_pt->GetBinContent(bin)/bin_mean;

			for(int tr = 0; tr < NmcTracks; tr++) {
                        	float mc_px = leaf_mc_Px->GetValue(tr);
                        	float mc_py = leaf_mc_Py->GetValue(tr);
				float mc_phi = atan2(mc_py,mc_px);
				int mc_id = leaf_mc_id->GetValue(tr);
				if(mc_id==rc_id) {
					Mpt[Mnmatch] = rc_pt;
					Mdca[Mnmatch] = dca;
					MndEdxHits[Mnmatch] = ndEdxHits;
					float dphi = rc_phi - mc_phi;
					if(dphi > PI) dphi -= 2*PI;
					if(dphi <-PI) dphi += 2*PI;
					if(rc_pt>0.15 && rc_pt<2) Hist_dphi->Fill(dphi,weight);
					if(rc_pt>0.15 && rc_pt<0.5) Hist_dphi1->Fill(dphi,weight);
					else if(rc_pt<1) Hist_dphi2->Fill(dphi,weight);
                                        else if(rc_pt<1.5) Hist_dphi3->Fill(dphi,weight);
                                        else if(rc_pt<2) Hist_dphi4->Fill(dphi,weight);
					Mdphi[Mnmatch] = dphi;
					Mweight[Mnmatch] = weight;
					Mnmatch++;
                                        if(rc_charge>0) Np--;
                                        else Nn--;
				}
			}
		}
              float asym = (float(Np)-float(Nn))/(Np+Nn);
              Hist_asym->Fill(asym);
                if(asym<mean-rms) Hist_asym_L->Fill(asym);
                else if(asym<mean-0.3*rms) Hist_asym_LM->Fill(asym);
                else if(asym<mean+0.3*rms) Hist_asym_M->Fill(asym);
                else if(asym<mean+rms) Hist_asym_RM->Fill(asym);
                else Hist_asym_R->Fill(asym);
//cout<<"Nmatch = "<<Mnmatch<<endl;
		for(int ii=0;ii<Mnmatch;ii++) {
                                float dphi = Mdphi[ii];
                        if(Mdca[ii]>1) continue;
                        if(MndEdxHits[ii]<=10) continue;
                        p_dphi_pt->Fill(Mpt[ii],100*cos(2*dphi));
                        if(Mpt[ii]<0.15 || Mpt[ii]>0.5) continue;
                        Hist_dphi_pion->Fill(Mdphi[ii]);
                                p_dphi->Fill(1,100*cos(2*dphi));
                                p_dphi->Fill(2,100*sin(2*dphi));
                                if(asym<mean-rms) {p_dphi_L->Fill(3,100*cos(2*dphi));
                                                        p_dphi_L->Fill(1,100*cos(2*dphi), Mweight[ii]);
                                                        p_dphi_L->Fill(4,100*sin(2*dphi));
                                                        p_dphi_L->Fill(2,100*sin(2*dphi), Mweight[ii]);}
                                else if(asym<mean-0.3*rms) {p_dphi_LM->Fill(3,100*cos(2*dphi));
                                                        p_dphi_LM->Fill(1,100*cos(2*dphi), Mweight[ii]);
                                                        p_dphi_LM->Fill(4,100*sin(2*dphi));
                                                        p_dphi_LM->Fill(2,100*sin(2*dphi), Mweight[ii]);}
                                else if(asym<mean+0.3*rms) {p_dphi_M->Fill(3,100*cos(2*dphi));
                                                        p_dphi_M->Fill(1,100*cos(2*dphi), Mweight[ii]);
                                                        p_dphi_M->Fill(4,100*sin(2*dphi));
                                                        p_dphi_M->Fill(2,100*sin(2*dphi), Mweight[ii]);}
                                else if(asym<mean+rms) {p_dphi_RM->Fill(3,100*cos(2*dphi));
                                                        p_dphi_RM->Fill(1,100*cos(2*dphi), Mweight[ii]);
                                                        p_dphi_RM->Fill(4,100*sin(2*dphi));
                                                        p_dphi_RM->Fill(2,100*sin(2*dphi), Mweight[ii]);}
                                else {p_dphi_R->Fill(3,100*cos(2*dphi));
                                                        p_dphi_R->Fill(1,100*cos(2*dphi), Mweight[ii]);
                                                        p_dphi_R->Fill(4,100*sin(2*dphi));
                                                        p_dphi_R->Fill(2,100*sin(2*dphi), Mweight[ii]);}

			for(int jj=0;jj<Mnmatch;jj++) {
				if(ii==jj) continue;
				if(Mpt[jj]<0.15 || Mpt[jj]>2.0) continue;
				float ddphi = Mdphi[ii] - Mdphi[jj];
				Hist_ddphi->Fill(ddphi);
				p_ddphi->Fill(1,100*cos(2*ddphi));
				p_ddphi->Fill(2,100*sin(2*ddphi));
                                if(asym<mean-rms) {p_ddphi_L->Fill(3,100*cos(2*ddphi));
							p_ddphi_L->Fill(1,100*cos(2*ddphi), Mweight[ii]*Mweight[jj]);
							p_ddphi_L->Fill(4,100*sin(2*ddphi));
							p_ddphi_L->Fill(2,100*sin(2*ddphi), Mweight[ii]*Mweight[jj]);}
                                else if(asym<mean-0.3*rms) {p_ddphi_LM->Fill(3,100*cos(2*ddphi));
							p_ddphi_LM->Fill(1,100*cos(2*ddphi), Mweight[ii]*Mweight[jj]);
                                                        p_ddphi_LM->Fill(4,100*sin(2*ddphi));			
							p_ddphi_LM->Fill(2,100*sin(2*ddphi), Mweight[ii]*Mweight[jj]);}
                                else if(asym<mean+0.3*rms) {p_ddphi_M->Fill(3,100*cos(2*ddphi));
							p_ddphi_M->Fill(1,100*cos(2*ddphi), Mweight[ii]*Mweight[jj]);
                                                        p_ddphi_M->Fill(4,100*sin(2*ddphi));
							p_ddphi_M->Fill(2,100*sin(2*ddphi), Mweight[ii]*Mweight[jj]);}
                                else if(asym<mean+rms) {p_ddphi_RM->Fill(3,100*cos(2*ddphi));
							p_ddphi_RM->Fill(1,100*cos(2*ddphi), Mweight[ii]*Mweight[jj]);
                                                        p_ddphi_RM->Fill(4,100*sin(2*ddphi));
							p_ddphi_RM->Fill(2,100*sin(2*ddphi), Mweight[ii]*Mweight[jj]);}
                                else {p_ddphi_R->Fill(3,100*cos(2*ddphi));
							p_ddphi_R->Fill(1,100*cos(2*ddphi), Mweight[ii]*Mweight[jj]);
                                                        p_ddphi_R->Fill(4,100*sin(2*ddphi));
							p_ddphi_R->Fill(2,100*sin(2*ddphi), Mweight[ii]*Mweight[jj]);}
			}
		}
	}

        fout.Write();
	return;

}
Example #3
0
int main(int argc, char* argv[])
{
  vector<vector<double> >* voltages = new vector<vector<double> >;
  vector<vector<double> >* currents = new vector<vector<double> >;
  voltages->resize(52);
  currents->resize(52);
  TChain* chain = loadChain(argc, argv);
  int entries = chain->GetEntries();

  cout << entries/2 << " files\n";

  for(int i=0; i<entries; i++)
  {
    chain->GetEvent(i);
    for(int slot=0; slot<16; slot++)
    {
      TLeaf* vleaf = chain->GetLeaf(("VHS_"+target_card[slot]+".VM."+target_channel[slot]).c_str());
      voltages->at(slot).push_back(vleaf->GetValue(0));
      TLeaf* ileaf = chain->GetLeaf(("VHS_"+target_card[slot]+".IM."+target_channel[slot]).c_str());
      currents->at(slot).push_back(ileaf->GetValue(0));      
    }
    for(int slot=0; slot<36; slot++)
    {
      if(veto_card[slot]=="4_3")
      {
	voltages->at(slot+16).push_back(-1);
	currents->at(slot+16).push_back(-1);
      }
      else
      {
	TLeaf* vleaf = chain->GetLeaf(("VHS_"+veto_card[slot]+".VM."+veto_channel[slot]).c_str());
	voltages->at(slot+16).push_back(vleaf->GetValue(0));
	TLeaf* ileaf = chain->GetLeaf(("VHS_"+veto_card[slot]+".IM."+veto_channel[slot]).c_str());
	currents->at(slot+16).push_back(ileaf->GetValue(0));
      }
    }
  }
  
  const double allowed_dv = 100;
  const double allowed_di = 50e-06;

  vector<bool> pmt_flags_v;
  vector<bool> pmt_flags_i;
  pmt_flags_v.resize(52,0);
  pmt_flags_i.resize(52,0);


  for( auto pmt = voltages->begin();
       pmt!=voltages->end(); ++pmt )
  {
    double meanvalue = mean(*pmt);
    double deviation = std_dev(*pmt);
    //cout << "Mean: " << meanvalue << " Dev: " << deviation << endl;
    for(auto it2 = (*pmt).begin();
	it2!=(*pmt).end(); ++it2)
    {
      //cout << distance((*it).begin(), it2) << " ";
      if( abs(*it2-meanvalue) > allowed_dv )
	pmt_flags_v.at( distance(voltages->begin(), pmt) ) = true;
    }
  }

  for( auto pmt = currents->begin();
       pmt!=currents->end(); ++pmt )
  {
    double meanvalue = mean(*pmt);
    double deviation = std_dev(*pmt);
    for(auto it2 = (*pmt).begin();
	it2!=(*pmt).end(); ++it2)
      if( abs(*it2-meanvalue) > allowed_di )
	pmt_flags_i.at( distance(currents->begin(), pmt) ) = true;
  }

  bool error = false;
  // Now if we managed to pick up some flags lets say so
  for(auto it = pmt_flags_v.begin();
      it!=pmt_flags_v.end(); ++it)
    if(*it==true)
    {
      cout << "PMT: " << distance(pmt_flags_v.begin(), it) << " varied VOLTAGE more than "
	   << allowed_dv << " from its mean value" << endl;
      error = true;
    }

  for(auto it = pmt_flags_i.begin();
      it!=pmt_flags_i.end(); ++it)
    if(*it==true)
    {
      cout << "PMT: " << distance(pmt_flags_i.begin(), it) << " varied CURRENT more than "
	   << allowed_di << " from its mean value" << endl;
      error = true;
    }

  if(error == true)
  {
    cout << ">>> See error.txt for full report <<<" << endl;
    writeReport(voltages, pmt_flags_v, currents, pmt_flags_i);
  }

  delete currents;
  delete voltages;
  return 0;
}