void DrawDmDiff_HIM(TString path="/home/karavdin/datastorage/BOXoutputJune2014_NewGeo5/"){
  //  double dP[11]={-1e-1,-1e-2,-1e-3,-1e-4,-1e-5,0,1e-5,1e-4,1e-3,1e-2,1e-1};
  //TString dPstr[11]={"-1e-1", "-1e-2", "-1e-3", "-1e-4", "-1e-5", "0", "1e-5", "1e-4", "1e-3", "1e-2", "1e-1"};
  //  const int Nsteps=11;
//   const int Nsteps=3;
// TString dPstr[Nsteps]={"-1e-3", "-1e-4", "0"};
  const int Nsteps=4;
  TString dPstr[Nsteps]={"0","-1e-3","-1e-2","-1e-1"};

 TH1D *hresPhi_phi_mean[Nsteps];   TH1D *hresPhi_phi_sigma[Nsteps];
 TH1D *hresTheta_phi_mean[Nsteps];   TH1D *hresTheta_phi_sigma[Nsteps];
 TH1D *hresPhi_theta_mean[Nsteps];   TH1D *hresPhi_theta_sigma[Nsteps];
 TH1D *hresTheta_theta_mean[Nsteps];   TH1D *hresTheta_theta_sigma[Nsteps];

 TH1D *hresLMDPhi_phi_mean[Nsteps];   TH1D *hresLMDPhi_phi_sigma[Nsteps];
 TH1D *hresLMDTheta_phi_mean[Nsteps];   TH1D *hresLMDTheta_phi_sigma[Nsteps];
 TH1D *hresLMDPhi_theta_mean[Nsteps];   TH1D *hresLMDPhi_theta_sigma[Nsteps];
 TH1D *hresLMDTheta_theta_mean[Nsteps];   TH1D *hresLMDTheta_theta_sigma[Nsteps];

 // TH2D *hthphLMD[Nsteps]; TH2D *hthphIP[Nsteps]; 
  TCanvas c1;
  //  TString name_out = path+"/PlotsSummary_Cuts_PrecIsPbeam_small.pdf";
  TString name_out = path+"/PlotsSummary_Cuts_PrecIsPbeam.pdf";
  name_out_o = name_out+"(";
  name_out_c = name_out+")";
  TLegend *leg = new TLegend(0.75,0.6,0.98,0.99);
  leg->SetHeader("P_{sim}=P_{beam}+dP, P_{rec}=P_{beam}");
  for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresPhi_phi = (TH2D*)f_in->Get("hresPhiPhi");
    if(hresPhi_phi==0) continue;
    // hthphLMD[i] = new TH2D();     hthphIP[i] = new TH2D();
    //  hthphLMD[i] = (TH2D*)f_in->Get("hphthLMD");
    TString nameAcc = "dP =";
    nameAcc+=dPstr[i];
    // hthphLMD[i]->SetTitle(nameAcc.Data());
    // hthphIP[i] =  (TH2D*)f_in->Get("hphthIP");
    // hthphIP[i]->SetTitle(nameAcc.Data());

    TString name_phiphi = "hresPhiPhi_";
    name_phiphi +=i;
    hresPhi_phi->SetName(name_phiphi.Data());
    hresPhi_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    // cout<<name_phiphi_mean<<endl;
    hresPhi_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresPhi_phi_mean[i]->SetMarkerStyle(21);
    hresPhi_phi_mean[i]->SetMarkerSize(2.1);
    hresPhi_phi_mean[i]->SetMarkerColor(35+3*i);
    
    hresPhi_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(#phi^{IP}_{MC}-#phi^{IP}_{REC}), rad");
 
    // hresPhi_phi_mean[i]->SetMaximum(0.02);
    // hresPhi_phi_mean[i]->SetMinimum(-0.02);
    hresPhi_phi_mean[i]->SetTitle("");
    hresPhi_phi_mean[i]->SetMaximum(0.03);
    hresPhi_phi_mean[i]->SetMinimum(-0.03);
    if(i==0){
      hresPhi_phi_mean[i]->SetMarkerStyle(20);
      hresPhi_phi_mean[i]->SetMarkerColor(kBlack);
      hresPhi_phi_mean[i]->Draw();
    }
    else{
      hresPhi_phi_mean[i]->Add(hresPhi_phi_mean[0],-1);
      hresPhi_phi_mean[i]->Draw("same");
    }
    TString Pleg = "dP = ";
    Pleg+=dPstr[i];
    leg->AddEntry(hresPhi_phi_mean[i],Pleg.Data(),"ep");
    // f_in->Close();
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresPhi_phi = (TH2D*)f_in->Get("hresPhiPhi");
    if(hresPhi_phi==0) continue;
    TString name_phiphi = "hresPhiPhi_";
    name_phiphi +=i;
    hresPhi_phi->SetName(name_phiphi.Data());
    hresPhi_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresPhi_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresPhi_phi_sigma[i]->SetMarkerStyle(21);
    hresPhi_phi_sigma[i]->SetMarkerSize(2.1);
    hresPhi_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresPhi_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#phi^{IP}_{MC}-#phi^{IP}_{REC}), rad");
    hresPhi_phi_sigma[i]->SetTitle("");
   
    // hresPhi_phi_sigma[i]->SetMaximum(0.2);
    // hresPhi_phi_sigma[i]->SetMinimum(0.05);
    hresPhi_phi_sigma[i]->SetMaximum(0.03);
    hresPhi_phi_sigma[i]->SetMinimum(-0.03);
    if(i==0){
      hresPhi_phi_sigma[i]->SetMarkerStyle(20);
      hresPhi_phi_sigma[i]->SetMarkerColor(kBlack);
      hresPhi_phi_sigma[i]->Draw();
    }
    else{
      hresPhi_phi_sigma[i]->Add(hresPhi_phi_sigma[0],-1);
      hresPhi_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresTheta_phi = (TH2D*)f_in->Get("hresThetaPhi");
    if(hresTheta_phi==0) continue;
    TString name_phiphi = "hresThetaPhi_";
    name_phiphi +=i;
    hresTheta_phi->SetName(name_phiphi.Data());
    hresTheta_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    //    cout<<name_phiphi_mean<<endl;
    hresTheta_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresTheta_phi_mean[i]->SetMarkerStyle(21);
    hresTheta_phi_mean[i]->SetMarkerSize(2.1);
    hresTheta_phi_mean[i]->SetMarkerColor(35+3*i);
    hresTheta_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(#theta^{IP}_{MC}-#theta^{IP}_{REC}), mrad");
    hresTheta_phi_mean[i]->SetTitle("");
    // hresTheta_phi_mean[i]->SetMaximum(0.05);
  //   hresTheta_phi_mean[i]->SetMinimum(-0.2);
    
    hresTheta_phi_mean[i]->SetMaximum(0.1);
    hresTheta_phi_mean[i]->SetMinimum(-0.1);
    if(i==0){
      hresTheta_phi_mean[i]->SetMarkerStyle(20);
      hresTheta_phi_mean[i]->SetMarkerColor(kBlack);
      hresTheta_phi_mean[i]->Draw();
    }
    else{
      hresTheta_phi_mean[i]->Add(hresTheta_phi_mean[0],-1);
      hresTheta_phi_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresTheta_phi = (TH2D*)f_in->Get("hresThetaPhi");
    if(hresTheta_phi==0) continue;
    TString name_phiphi = "hresThetaPhi_";
    name_phiphi +=i;
    hresTheta_phi->SetName(name_phiphi.Data());
    hresTheta_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresTheta_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresTheta_phi_sigma[i]->SetMarkerStyle(21);
    hresTheta_phi_sigma[i]->SetMarkerSize(2.1);
    hresTheta_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresTheta_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#theta^{IP}_{MC}-#theta^{IP}_{REC}), mrad");
    hresTheta_phi_sigma[i]->SetTitle("");
    // hresTheta_phi_sigma[i]->SetMaximum(3.);
    // hresTheta_phi_sigma[i]->SetMinimum(0);
  
    hresTheta_phi_sigma[i]->SetMaximum(0.1);
    hresTheta_phi_sigma[i]->SetMinimum(-0.1);
    if(i==0){
      hresTheta_phi_sigma[i]->SetMarkerStyle(20);
      hresTheta_phi_sigma[i]->SetMarkerColor(kBlack);
      hresTheta_phi_sigma[i]->Draw();
    }
    else{
      hresTheta_phi_sigma[i]->Add(hresTheta_phi_sigma[0],-1);
      hresTheta_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
 //  //////////////////////////// theta
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresPhi_theta = (TH2D*)f_in->Get("hresPhiTheta");
    if(hresPhi_theta==0) continue;
    TString name_thetaphi = "hresPhiTheta_";
    name_thetaphi +=i;
    hresPhi_theta->SetName(name_thetaphi.Data());
    hresPhi_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresPhi_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresPhi_theta_mean[i]->SetMarkerStyle(21);
    hresPhi_theta_mean[i]->SetMarkerSize(2.1);
    hresPhi_theta_mean[i]->SetMarkerColor(35+3*i);
    hresPhi_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(#phi^{IP}_{MC}-#phi^{IP}_{REC}), rad");
    hresPhi_theta_mean[i]->SetTitle("");
    // hresPhi_theta_mean[i]->SetMaximum(0.02);
    // hresPhi_theta_mean[i]->SetMinimum(0.);
    
    hresPhi_theta_mean[i]->SetMaximum(0.03);
    hresPhi_theta_mean[i]->SetMinimum(-0.03);
    if(i==0){
      hresPhi_theta_mean[i]->SetMarkerStyle(20);
      hresPhi_theta_mean[i]->SetMarkerColor(kBlack);
      hresPhi_theta_mean[i]->Draw();
    }
    else{
      hresPhi_theta_mean[i]->Add(hresPhi_theta_mean[0],-1);
      hresPhi_theta_mean[i]->Draw("same");
    }
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresPhi_theta = (TH2D*)f_in->Get("hresPhiTheta");
    if(hresPhi_theta==0) continue;
    TString name_thetaphi = "hresPhiTheta_";
    name_thetaphi +=i;
    hresPhi_theta->SetName(name_thetaphi.Data());
    hresPhi_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresPhi_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresPhi_theta_sigma[i]->SetMarkerStyle(21);
    hresPhi_theta_sigma[i]->SetMarkerSize(2.1);
    hresPhi_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresPhi_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#phi^{IP}_{MC}-#phi^{IP}_{REC}), rad");
    hresPhi_theta_sigma[i]->SetTitle("");
  
    // hresPhi_theta_sigma[i]->SetMaximum(0.12);
    // hresPhi_theta_sigma[i]->SetMinimum(0.05);
    
    hresPhi_theta_sigma[i]->SetMaximum(0.03);
    hresPhi_theta_sigma[i]->SetMinimum(-0.03);
    if(i==0){
      hresPhi_theta_sigma[i]->SetMarkerStyle(20);
      hresPhi_theta_sigma[i]->SetMarkerColor(kBlack);
      hresPhi_theta_sigma[i]->Draw();
    }
    else{
      hresPhi_theta_sigma[i]->Add(hresPhi_theta_sigma[0],-1);
      hresPhi_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresTheta_theta = (TH2D*)f_in->Get("hresThetaTheta");
    if(hresTheta_theta==0) continue;
    TString name_thetaphi = "hresThetaTheta_";
    name_thetaphi +=i;
    hresTheta_theta->SetName(name_thetaphi.Data());
    hresTheta_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresTheta_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresTheta_theta_mean[i]->SetMarkerStyle(21);
    hresTheta_theta_mean[i]->SetMarkerSize(2.1);
    hresTheta_theta_mean[i]->SetMarkerColor(35+3*i);
    hresTheta_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(#theta^{IP}_{MC}-#theta^{IP}_{REC}), mrad");
    hresTheta_theta_mean[i]->SetTitle("");
    // hresTheta_theta_mean[i]->SetMaximum(-0.02);
    // hresTheta_theta_mean[i]->SetMinimum(-0.16);

    hresTheta_theta_mean[i]->SetMaximum(0.1);
    hresTheta_theta_mean[i]->SetMinimum(-0.1);
    if(i==0){
      hresTheta_theta_mean[i]->SetMarkerStyle(20);
      hresTheta_theta_mean[i]->SetMarkerColor(kBlack);
      hresTheta_theta_mean[i]->Draw();
    }
    else{
      hresTheta_theta_mean[i]->Add(hresTheta_theta_mean[0],-1);
      hresTheta_theta_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresTheta_theta = (TH2D*)f_in->Get("hresThetaTheta");
    if(hresTheta_theta==0) continue;
    TString name_thetaphi = "hresThetaTheta_";
    name_thetaphi +=i;
    hresTheta_theta->SetName(name_thetaphi.Data());
    hresTheta_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresTheta_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresTheta_theta_sigma[i]->SetMarkerStyle(21);
    hresTheta_theta_sigma[i]->SetMarkerSize(2.1);
    hresTheta_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresTheta_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#theta^{IP}_{MC}-#theta^{IP}_{REC}), mrad");
    hresTheta_theta_sigma[i]->SetTitle("");
    
    // hresTheta_theta_sigma[i]->SetMaximum(0.8);
    // hresTheta_theta_sigma[i]->SetMinimum(0.65);

    hresTheta_theta_sigma[i]->SetMaximum(0.1);
    hresTheta_theta_sigma[i]->SetMinimum(-0.1);
    if(i==0){
      hresTheta_theta_sigma[i]->SetMarkerStyle(20);
      hresTheta_theta_sigma[i]->SetMarkerColor(kBlack);
      hresTheta_theta_sigma[i]->Draw();
    }
    else{
      hresTheta_theta_sigma[i]->Add(hresTheta_theta_sigma[0],-1);
      hresTheta_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 
 //////////////////// LMD
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDPhi_phi = (TH2D*)f_in->Get("hresLMDPhiPhi");
    if(hresLMDPhi_phi==0) continue;
    // hthphLMD[i] = new TH2D();     hthphIP[i] = new TH2D();
    //   hthphLMD[i] = (TH2D*)f_in->Get("hphthLMD");
    TString nameAcc = "dP =";
    nameAcc+=dPstr[i];
   
    TString name_phiphi = "hresLMDPhiPhi_";
    name_phiphi +=i;
    hresLMDPhi_phi->SetName(name_phiphi.Data());
    hresLMDPhi_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    // cout<<name_phiphi_mean<<endl;
    hresLMDPhi_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresLMDPhi_phi_mean[i]->SetMarkerStyle(21);
    hresLMDPhi_phi_mean[i]->SetMarkerSize(2.1);
    hresLMDPhi_phi_mean[i]->SetMarkerColor(35+3*i);
    
    hresLMDPhi_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(#phi^{LMD}_{MC}-#phi^{LMD}_{REC}), mrad");
    // hresLMDPhi_phi_mean[i]->SetMaximum(2.);
    // hresLMDPhi_phi_mean[i]->SetMinimum(-2.);
    hresLMDPhi_phi_mean[i]->SetMaximum(3.);
    hresLMDPhi_phi_mean[i]->SetMinimum(-3.);
    hresLMDPhi_phi_mean[i]->SetTitle("");

    if(i==0){
      hresLMDPhi_phi_mean[i]->SetMarkerStyle(20);
      hresLMDPhi_phi_mean[i]->SetMarkerColor(kBlack);
      hresLMDPhi_phi_mean[i]->Draw();
    }
    else{
      hresLMDPhi_phi_mean[i]->Add(hresLMDPhi_phi_mean[0],-1);
      hresLMDPhi_phi_mean[i]->Draw("same");
    }
    // TString Pleg = "dP = ";
    // Pleg+=dPstr[i];
    //   leg->AddEntry(hresLMDPhi_phi_mean[i],Pleg.Data(),"ep");
    // f_in->Close();
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDPhi_phi = (TH2D*)f_in->Get("hresLMDPhiPhi");
    if(hresLMDPhi_phi==0) continue;
    TString name_phiphi = "hresLMDPhiPhi_";
    name_phiphi +=i;
    hresLMDPhi_phi->SetName(name_phiphi.Data());
    hresLMDPhi_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresLMDPhi_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresLMDPhi_phi_sigma[i]->SetMarkerStyle(21);
    hresLMDPhi_phi_sigma[i]->SetMarkerSize(2.1);
    hresLMDPhi_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDPhi_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#phi^{LMD}_{MC}-#phi^{LMD}_{REC}), mrad");
    hresLMDPhi_phi_sigma[i]->SetTitle("");
    // hresLMDPhi_phi_sigma[i]->SetMaximum(1.);
    // hresLMDPhi_phi_sigma[i]->SetMinimum(0);
    hresLMDPhi_phi_sigma[i]->SetMaximum(3.);
    hresLMDPhi_phi_sigma[i]->SetMinimum(-3.);

    if(i==0){
      hresLMDPhi_phi_sigma[i]->SetMarkerStyle(20);
      hresLMDPhi_phi_sigma[i]->SetMarkerColor(kBlack);
      hresLMDPhi_phi_sigma[i]->Draw();
    }
    else{
      hresLMDPhi_phi_sigma[i]->Add(hresLMDPhi_phi_sigma[0],-1);
      hresLMDPhi_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDTheta_phi = (TH2D*)f_in->Get("hresLMDThetaPhi");
    if(hresLMDTheta_phi==0) continue;
    TString name_phiphi = "hresLMDThetaPhi_";
    name_phiphi +=i;
    hresLMDTheta_phi->SetName(name_phiphi.Data());
    hresLMDTheta_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    //    cout<<name_phiphi_mean<<endl;
    hresLMDTheta_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresLMDTheta_phi_mean[i]->SetMarkerStyle(21);
    hresLMDTheta_phi_mean[i]->SetMarkerSize(2.1);
    hresLMDTheta_phi_mean[i]->SetMarkerColor(35+3*i);
    hresLMDTheta_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(#theta^{LMD}_{MC}-#theta^{LMD}_{REC}), mrad");
    hresLMDTheta_phi_mean[i]->SetTitle("");
    // hresLMDTheta_phi_mean[i]->SetMaximum(5.);
    // hresLMDTheta_phi_mean[i]->SetMinimum(-5.);
    hresLMDTheta_phi_mean[i]->SetMaximum(0.2);
    hresLMDTheta_phi_mean[i]->SetMinimum(-0.2);

    if(i==0){
      hresLMDTheta_phi_mean[i]->SetMarkerStyle(20);
      hresLMDTheta_phi_mean[i]->SetMarkerColor(kBlack);
      hresLMDTheta_phi_mean[i]->Draw();
    }
    else{
      hresLMDTheta_phi_mean[i]->Add(hresLMDTheta_phi_mean[0],-1);
      hresLMDTheta_phi_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDTheta_phi = (TH2D*)f_in->Get("hresLMDThetaPhi");
    if(hresLMDTheta_phi==0) continue;
    TString name_phiphi = "hresLMDThetaPhi_";
    name_phiphi +=i;
    hresLMDTheta_phi->SetName(name_phiphi.Data());
    hresLMDTheta_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresLMDTheta_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresLMDTheta_phi_sigma[i]->SetMarkerStyle(21);
    hresLMDTheta_phi_sigma[i]->SetMarkerSize(2.1);
    hresLMDTheta_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDTheta_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#theta^{LMD}_{MC}-#theta^{LMD}_{REC}), mrad");
    hresLMDTheta_phi_sigma[i]->SetTitle("");
    // hresLMDTheta_phi_sigma[i]->SetMaximum(3.);
    // hresLMDTheta_phi_sigma[i]->SetMinimum(0);
    hresLMDTheta_phi_sigma[i]->SetMaximum(0.2);
    hresLMDTheta_phi_sigma[i]->SetMinimum(-0.2);
    if(i==0){
      hresLMDTheta_phi_sigma[i]->SetMarkerStyle(20);
      hresLMDTheta_phi_sigma[i]->SetMarkerColor(kBlack);
      hresLMDTheta_phi_sigma[i]->Draw();
    }
    else{
      hresLMDTheta_phi_sigma[i]->Add(hresLMDTheta_phi_sigma[0],-1);
      hresLMDTheta_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
 //  //////////////////////////// theta
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDPhi_theta = (TH2D*)f_in->Get("hresLMDPhiTheta");
    if(hresLMDPhi_theta==0) continue;
    TString name_thetaphi = "hresLMDPhiTheta_";
    name_thetaphi +=i;
    hresLMDPhi_theta->SetName(name_thetaphi.Data());
    hresLMDPhi_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresLMDPhi_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresLMDPhi_theta_mean[i]->SetMarkerStyle(21);
    hresLMDPhi_theta_mean[i]->SetMarkerSize(2.1);
    hresLMDPhi_theta_mean[i]->SetMarkerColor(35+3*i);
    hresLMDPhi_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(#phi^{LMD}_{MC}-#phi^{LMD}_{REC}), rad");
    hresLMDPhi_theta_mean[i]->SetTitle("");
    hresLMDPhi_theta_mean[i]->SetMaximum(3.);
    hresLMDPhi_theta_mean[i]->SetMinimum(-3.);
    // hresLMDPhi_theta_mean[i]->SetMaximum(0.8);
    // hresLMDPhi_theta_mean[i]->SetMinimum(-0.1);
    if(i==0){
      hresLMDPhi_theta_mean[i]->SetMarkerStyle(20);
      hresLMDPhi_theta_mean[i]->SetMarkerColor(kBlack);
      hresLMDPhi_theta_mean[i]->Draw();
    }
    else{
      hresLMDPhi_theta_mean[i]->Add(hresLMDPhi_theta_mean[0],-1);
      hresLMDPhi_theta_mean[i]->Draw("same");
    }
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDPhi_theta = (TH2D*)f_in->Get("hresLMDPhiTheta");
    if(hresLMDPhi_theta==0) continue;
    TString name_thetaphi = "hresLMDPhiTheta_";
    name_thetaphi +=i;
    hresLMDPhi_theta->SetName(name_thetaphi.Data());
    hresLMDPhi_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresLMDPhi_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresLMDPhi_theta_sigma[i]->SetMarkerStyle(21);
    hresLMDPhi_theta_sigma[i]->SetMarkerSize(2.1);
    hresLMDPhi_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDPhi_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#phi^{LMD}_{MC}-#phi^{LMD}_{REC}), rad");
    hresLMDPhi_theta_sigma[i]->SetTitle("");
    hresLMDPhi_theta_sigma[i]->SetMaximum(3.);
    hresLMDPhi_theta_sigma[i]->SetMinimum(-3.);
    // hresLMDPhi_theta_sigma[i]->SetMaximum(9.);
    // hresLMDPhi_theta_sigma[i]->SetMinimum(7.);
    if(i==0){
      hresLMDPhi_theta_sigma[i]->SetMarkerStyle(20);
      hresLMDPhi_theta_sigma[i]->SetMarkerColor(kBlack);
      hresLMDPhi_theta_sigma[i]->Draw();
    }
    else{
      hresLMDPhi_theta_sigma[i]->Add(hresLMDPhi_theta_sigma[0],-1);
      hresLMDPhi_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDTheta_theta = (TH2D*)f_in->Get("hresLMDThetaTheta");
    if(hresLMDTheta_theta==0) continue;
    TString name_thetaphi = "hresLMDThetaTheta_";
    name_thetaphi +=i;
    hresLMDTheta_theta->SetName(name_thetaphi.Data());
    hresLMDTheta_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresLMDTheta_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresLMDTheta_theta_mean[i]->SetMarkerStyle(21);
    hresLMDTheta_theta_mean[i]->SetMarkerSize(2.1);
    hresLMDTheta_theta_mean[i]->SetMarkerColor(35+3*i);
    hresLMDTheta_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(#theta^{LMD}_{MC}-#theta^{LMD}_{REC}), mrad");
    hresLMDTheta_theta_mean[i]->SetTitle("");
    hresLMDTheta_theta_mean[i]->SetMaximum(0.2);
    hresLMDTheta_theta_mean[i]->SetMinimum(-0.2);
    // hresLMDTheta_theta_mean[i]->SetMaximum(0.08);
    // hresLMDTheta_theta_mean[i]->SetMinimum(-0.06);
    if(i==0){
      hresLMDTheta_theta_mean[i]->SetMarkerStyle(20);
      hresLMDTheta_theta_mean[i]->SetMarkerColor(kBlack);
      hresLMDTheta_theta_mean[i]->Draw();
    }
    else{
      hresLMDTheta_theta_mean[i]->Add(hresLMDTheta_theta_mean[0],-1);
      hresLMDTheta_theta_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDTheta_theta = (TH2D*)f_in->Get("hresLMDThetaTheta");
    if(hresLMDTheta_theta==0) continue;
    TString name_thetaphi = "hresLMDThetaTheta_";
    name_thetaphi +=i;
    hresLMDTheta_theta->SetName(name_thetaphi.Data());
    hresLMDTheta_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresLMDTheta_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresLMDTheta_theta_sigma[i]->SetMarkerStyle(21);
    hresLMDTheta_theta_sigma[i]->SetMarkerSize(2.1);
    hresLMDTheta_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDTheta_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(#theta^{LMD}_{MC}-#theta^{LMD}_{REC}), mrad");
    hresLMDTheta_theta_sigma[i]->SetTitle("");
    hresLMDTheta_theta_sigma[i]->SetMaximum(0.2);
    hresLMDTheta_theta_sigma[i]->SetMinimum(-0.2);
    // hresLMDTheta_theta_sigma[i]->SetMaximum(0.4);
    // hresLMDTheta_theta_sigma[i]->SetMinimum(0.3);
    
    if(i==0){
      hresLMDTheta_theta_sigma[i]->SetMarkerStyle(20);
      hresLMDTheta_theta_sigma[i]->SetMarkerColor(kBlack);
      hresLMDTheta_theta_sigma[i]->Draw();
    }
    else{
      hresLMDTheta_theta_sigma[i]->Add(hresLMDTheta_theta_sigma[0],-1);
      hresLMDTheta_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 ////////////////////END LMD

 //////////////////////////////////////////////// X&Y
TH1D *hresX_phi_mean[Nsteps];   TH1D *hresX_phi_sigma[Nsteps];
 TH1D *hresY_phi_mean[Nsteps];   TH1D *hresY_phi_sigma[Nsteps];
 TH1D *hresX_theta_mean[Nsteps];   TH1D *hresX_theta_sigma[Nsteps];
 TH1D *hresY_theta_mean[Nsteps];   TH1D *hresY_theta_sigma[Nsteps];
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresX_phi = (TH2D*)f_in->Get("hresXPhi");
    if(hresX_phi==0) continue;
    // hthphLMD[i] = new TH2D();     hthphIP[i] = new TH2D();
    //   hthphLMD[i] = (TH2D*)f_in->Get("hphthLMD");
    TString nameAcc = "dP =";
    nameAcc+=dPstr[i];
   
    TString name_phiphi = "hresXPhi_";
    name_phiphi +=i;
    hresX_phi->SetName(name_phiphi.Data());
    hresX_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    // cout<<name_phiphi_mean<<endl;
    hresX_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresX_phi_mean[i]->SetMarkerStyle(21);
    hresX_phi_mean[i]->SetMarkerSize(2.1);
    hresX_phi_mean[i]->SetMarkerColor(35+3*i);
    
    hresX_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(X^{IP}_{MC}-X^{IP}_{REC}), cm");
    hresX_phi_mean[i]->SetMaximum(0.2);
    hresX_phi_mean[i]->SetMinimum(-0.2);
    hresX_phi_mean[i]->SetTitle("");
    
    if(i==0){
      hresX_phi_mean[i]->SetMarkerStyle(20);
      hresX_phi_mean[i]->SetMarkerColor(kBlack);
      hresX_phi_mean[i]->Draw();
    }
    else{
      hresX_phi_mean[i]->Add(hresX_phi_mean[0],-1);
      hresX_phi_mean[i]->Draw("same");
    }
    // TString Pleg = "dP = ";
    // Pleg+=dPstr[i];
    //   leg->AddEntry(hresX_phi_mean[i],Pleg.Data(),"ep");
    // f_in->Close();
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresX_phi = (TH2D*)f_in->Get("hresXPhi");
    if(hresX_phi==0) continue;
    TString name_phiphi = "hresXPhi_";
    name_phiphi +=i;
    hresX_phi->SetName(name_phiphi.Data());
    hresX_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresX_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresX_phi_sigma[i]->SetMarkerStyle(21);
    hresX_phi_sigma[i]->SetMarkerSize(2.1);
    hresX_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresX_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(X^{IP}_{MC}-X^{IP}_{REC}), cm");
    hresX_phi_sigma[i]->SetTitle("");
    hresX_phi_sigma[i]->SetMaximum(0.2);
    hresX_phi_sigma[i]->SetMinimum(-0.2);
    if(i==0){
      hresX_phi_sigma[i]->SetMarkerStyle(20);
      hresX_phi_sigma[i]->SetMarkerColor(kBlack);
      hresX_phi_sigma[i]->Draw();
    }
    else{
      hresX_phi_sigma[i]->Add(hresX_phi_sigma[0],-1);
      hresX_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresY_phi = (TH2D*)f_in->Get("hresYPhi");
    if(hresY_phi==0) continue;
    TString name_phiphi = "hresYPhi_";
    name_phiphi +=i;
    hresY_phi->SetName(name_phiphi.Data());
    hresY_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    //    cout<<name_phiphi_mean<<endl;
    hresY_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresY_phi_mean[i]->SetMarkerStyle(21);
    hresY_phi_mean[i]->SetMarkerSize(2.1);
    hresY_phi_mean[i]->SetMarkerColor(35+3*i);
    hresY_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(Y^{IP}_{MC}-Y^{IP}_{REC}), cm");
    hresY_phi_mean[i]->SetTitle("");
    hresY_phi_mean[i]->SetMaximum(0.2);
    hresY_phi_mean[i]->SetMinimum(-0.2);
    if(i==0){
      hresY_phi_mean[i]->SetMarkerStyle(20);
      hresY_phi_mean[i]->SetMarkerColor(kBlack);
      hresY_phi_mean[i]->Draw();
    }
    else{
      hresY_phi_mean[i]->Add(hresY_phi_mean[0],-1);
      hresY_phi_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresY_phi = (TH2D*)f_in->Get("hresYPhi");
    if(hresY_phi==0) continue;
    TString name_phiphi = "hresYPhi_";
    name_phiphi +=i;
    hresY_phi->SetName(name_phiphi.Data());
    hresY_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresY_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresY_phi_sigma[i]->SetMarkerStyle(21);
    hresY_phi_sigma[i]->SetMarkerSize(2.1);
    hresY_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresY_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(Y^{IP}_{MC}-Y^{IP}_{REC}), cm");
    hresY_phi_sigma[i]->SetTitle("");
    hresY_phi_sigma[i]->SetMaximum(0.2);
    hresY_phi_sigma[i]->SetMinimum(-0.2);
    if(i==0){
      hresY_phi_sigma[i]->SetMarkerStyle(20);
      hresY_phi_sigma[i]->SetMarkerColor(kBlack);
      hresY_phi_sigma[i]->Draw();
    }
    else{
      hresY_phi_sigma[i]->Add(hresY_phi_sigma[0],-1);
      hresY_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
 //  //////////////////////////// theta
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresX_theta = (TH2D*)f_in->Get("hresXTheta");
    if(hresX_theta==0) continue;
    TString name_thetaphi = "hresXTheta_";
    name_thetaphi +=i;
    hresX_theta->SetName(name_thetaphi.Data());
    hresX_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresX_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresX_theta_mean[i]->SetMarkerStyle(21);
    hresX_theta_mean[i]->SetMarkerSize(2.1);
    hresX_theta_mean[i]->SetMarkerColor(35+3*i);
    hresX_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(X^{IP}_{MC}-X^{IP}_{REC}), cm");
    hresX_theta_mean[i]->SetTitle("");
    hresX_theta_mean[i]->SetMaximum(0.2);
    hresX_theta_mean[i]->SetMinimum(-0.2);
    if(i==0){
      hresX_theta_mean[i]->SetMarkerStyle(20);
      hresX_theta_mean[i]->SetMarkerColor(kBlack);
      hresX_theta_mean[i]->Draw();
    }
    else{ 
      hresX_theta_mean[i]->Add(hresX_theta_mean[0],-1);
      hresX_theta_mean[i]->Draw("same");
    }
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresX_theta = (TH2D*)f_in->Get("hresXTheta");
    if(hresX_theta==0) continue;
    TString name_thetaphi = "hresXTheta_";
    name_thetaphi +=i;
    hresX_theta->SetName(name_thetaphi.Data());
    hresX_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresX_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresX_theta_sigma[i]->SetMarkerStyle(21);
    hresX_theta_sigma[i]->SetMarkerSize(2.1);
    hresX_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresX_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(X^{IP}_{MC}-X^{IP}_{REC}), cm");
    hresX_theta_sigma[i]->SetTitle("");
    hresX_theta_sigma[i]->SetMaximum(0.2);
    hresX_theta_sigma[i]->SetMinimum(-0.2);
    if(i==0){
      hresX_theta_sigma[i]->SetMarkerStyle(20);
      hresX_theta_sigma[i]->SetMarkerColor(kBlack);
      hresX_theta_sigma[i]->Draw();
    }
    else{
      hresX_theta_sigma[i]->Add(hresX_theta_sigma[0],-1);
      hresX_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresY_theta = (TH2D*)f_in->Get("hresYTheta");
    if(hresY_theta==0) continue;
    TString name_thetaphi = "hresYTheta_";
    name_thetaphi +=i;
    hresY_theta->SetName(name_thetaphi.Data());
    hresY_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresY_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresY_theta_mean[i]->SetMarkerStyle(21);
    hresY_theta_mean[i]->SetMarkerSize(2.1);
    hresY_theta_mean[i]->SetMarkerColor(35+3*i);
    hresY_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(Y^{IP}_{MC}-Y^{IP}_{REC}), cm");
    hresY_theta_mean[i]->SetTitle("");
    
    hresY_theta_mean[i]->SetMaximum(0.2);
    hresY_theta_mean[i]->SetMinimum(-0.2);
    if(i==0){
      hresY_theta_mean[i]->SetMarkerStyle(20);
      hresY_theta_mean[i]->SetMarkerColor(kBlack);
      hresY_theta_mean[i]->Draw();
    }
    else{
      hresY_theta_mean[i]->Add(hresY_theta_mean[0],-1);
      hresY_theta_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresY_theta = (TH2D*)f_in->Get("hresYTheta");
    if(hresY_theta==0) continue;
    TString name_thetaphi = "hresYTheta_";
    name_thetaphi +=i;
    hresY_theta->SetName(name_thetaphi.Data());
    hresY_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresY_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresY_theta_sigma[i]->SetMarkerStyle(21);
    hresY_theta_sigma[i]->SetMarkerSize(2.1);
    hresY_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresY_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(Y^{IP}_{MC}-Y^{IP}_{REC}), cm");
    hresY_theta_sigma[i]->SetTitle("");
   
    
    hresY_theta_sigma[i]->SetMaximum(0.2);
    hresY_theta_sigma[i]->SetMinimum(-0.2);
    if(i==0){
      hresY_theta_sigma[i]->SetMarkerStyle(20);
      hresY_theta_sigma[i]->SetMarkerColor(kBlack);
      hresY_theta_sigma[i]->Draw();
    }
    else{
      hresY_theta_sigma[i]->Add(hresY_theta_sigma[0],-1);
      hresY_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 //////////////////////////////////////////////// END X&Y


 ////////////////// LMD X&Y 
TH1D *hresLMDX_phi_mean[Nsteps];   TH1D *hresLMDX_phi_sigma[Nsteps];
 TH1D *hresLMDY_phi_mean[Nsteps];   TH1D *hresLMDY_phi_sigma[Nsteps];
 TH1D *hresLMDX_theta_mean[Nsteps];   TH1D *hresLMDX_theta_sigma[Nsteps];
 TH1D *hresLMDY_theta_mean[Nsteps];   TH1D *hresLMDY_theta_sigma[Nsteps];
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDX_phi = (TH2D*)f_in->Get("hresLMDXPhi");
    if(hresLMDX_phi==0) continue;
    // hthphLMD[i] = new TH2D();     hthphIP[i] = new TH2D();
    //   hthphLMD[i] = (TH2D*)f_in->Get("hphthLMD");
    TString nameAcc = "dP =";
    nameAcc+=dPstr[i];
   
    TString name_phiphi = "hresLMDXPhi_";
    name_phiphi +=i;
    hresLMDX_phi->SetName(name_phiphi.Data());
    hresLMDX_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    // cout<<name_phiphi_mean<<endl;
    hresLMDX_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresLMDX_phi_mean[i]->SetMarkerStyle(21);
    hresLMDX_phi_mean[i]->SetMarkerSize(2.1);
    hresLMDX_phi_mean[i]->SetMarkerColor(35+3*i);
    
    hresLMDX_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(X^{LMD}_{MC}-X^{LMD}_{REC}), cm");
    hresLMDX_phi_mean[i]->SetMaximum(1.7e-3);
    hresLMDX_phi_mean[i]->SetMinimum(-1.7e-3);
    hresLMDX_phi_mean[i]->SetTitle("");
    
    if(i==0){
      hresLMDX_phi_mean[i]->SetMarkerStyle(20);
      hresLMDX_phi_mean[i]->SetMarkerColor(kBlack);
      hresLMDX_phi_mean[i]->Draw();
    }
    else{
      hresLMDX_phi_mean[i]->Add(hresLMDX_phi_mean[0],-1);
      hresLMDX_phi_mean[i]->Draw("same");
    }
    // TString Pleg = "dP = ";
    // Pleg+=dPstr[i];
    //   leg->AddEntry(hresLMDX_phi_mean[i],Pleg.Data(),"ep");
    // f_in->Close();
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDX_phi = (TH2D*)f_in->Get("hresLMDXPhi");
    if(hresLMDX_phi==0) continue;
    TString name_phiphi = "hresLMDXPhi_";
    name_phiphi +=i;
    hresLMDX_phi->SetName(name_phiphi.Data());
    hresLMDX_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresLMDX_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresLMDX_phi_sigma[i]->SetMarkerStyle(21);
    hresLMDX_phi_sigma[i]->SetMarkerSize(2.1);
    hresLMDX_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDX_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(X^{LMD}_{MC}-X^{LMD}_{REC}), cm");
    hresLMDX_phi_sigma[i]->SetTitle("");
    hresLMDX_phi_sigma[i]->SetMaximum(1.7e-3);
    hresLMDX_phi_sigma[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDX_phi_sigma[i]->SetMarkerStyle(20);
      hresLMDX_phi_sigma[i]->SetMarkerColor(kBlack);
      hresLMDX_phi_sigma[i]->Draw();
    }
    else{
      hresLMDX_phi_sigma[i]->Add(hresLMDX_phi_sigma[0],-1);
      hresLMDX_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDY_phi = (TH2D*)f_in->Get("hresLMDYPhi");
    if(hresLMDY_phi==0) continue;
    TString name_phiphi = "hresLMDYPhi_";
    name_phiphi +=i;
    hresLMDY_phi->SetName(name_phiphi.Data());
    hresLMDY_phi->FitSlicesY();
    TString name_phiphi_mean = name_phiphi;
    name_phiphi_mean += "_1";
    //    cout<<name_phiphi_mean<<endl;
    hresLMDY_phi_mean[i] = (TH1D*)gDirectory->Get(name_phiphi_mean);
    hresLMDY_phi_mean[i]->SetMarkerStyle(21);
    hresLMDY_phi_mean[i]->SetMarkerSize(2.1);
    hresLMDY_phi_mean[i]->SetMarkerColor(35+3*i);
    hresLMDY_phi_mean[i]->GetYaxis()->SetTitle("#deltaMean(Y^{LMD}_{MC}-Y^{LMD}_{REC}), cm");
    hresLMDY_phi_mean[i]->SetTitle("");
    hresLMDY_phi_mean[i]->SetMaximum(1.7e-3);
    hresLMDY_phi_mean[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDY_phi_mean[i]->SetMarkerStyle(20);
      hresLMDY_phi_mean[i]->SetMarkerColor(kBlack);
      hresLMDY_phi_mean[i]->Draw();
    }
    else{
      hresLMDY_phi_mean[i]->Add(hresLMDY_phi_mean[0],-1);
      hresLMDY_phi_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDY_phi = (TH2D*)f_in->Get("hresLMDYPhi");
    if(hresLMDY_phi==0) continue;
    TString name_phiphi = "hresLMDYPhi_";
    name_phiphi +=i;
    hresLMDY_phi->SetName(name_phiphi.Data());
    hresLMDY_phi->FitSlicesY();
    TString name_phiphi_sigma = name_phiphi;
    name_phiphi_sigma += "_2";
    //    cout<<name_phiphi_sigma<<endl;
    hresLMDY_phi_sigma[i] = (TH1D*)gDirectory->Get(name_phiphi_sigma);
    hresLMDY_phi_sigma[i]->SetMarkerStyle(21);
    hresLMDY_phi_sigma[i]->SetMarkerSize(2.1);
    hresLMDY_phi_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDY_phi_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(Y^{LMD}_{MC}-Y^{LMD}_{REC}), cm");
    hresLMDY_phi_sigma[i]->SetTitle("");
    hresLMDY_phi_sigma[i]->SetMaximum(1.7e-3);
    hresLMDY_phi_sigma[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDY_phi_sigma[i]->SetMarkerStyle(20);
      hresLMDY_phi_sigma[i]->SetMarkerColor(kBlack);
      hresLMDY_phi_sigma[i]->Draw();
    }
    else{
      hresLMDY_phi_sigma[i]->Add(hresLMDY_phi_sigma[0],-1);
      hresLMDY_phi_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
 //  //////////////////////////// theta
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDX_theta = (TH2D*)f_in->Get("hresLMDXTheta");
    if(hresLMDX_theta==0) continue;
    TString name_thetaphi = "hresLMDXTheta_";
    name_thetaphi +=i;
    hresLMDX_theta->SetName(name_thetaphi.Data());
    hresLMDX_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresLMDX_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresLMDX_theta_mean[i]->SetMarkerStyle(21);
    hresLMDX_theta_mean[i]->SetMarkerSize(2.1);
    hresLMDX_theta_mean[i]->SetMarkerColor(35+3*i);
    hresLMDX_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(X^{LMD}_{MC}-X^{LMD}_{REC}), cm");
    hresLMDX_theta_mean[i]->SetTitle("");
    hresLMDX_theta_mean[i]->SetMaximum(1.7e-3);
    hresLMDX_theta_mean[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDX_theta_mean[i]->SetMarkerStyle(20);
      hresLMDX_theta_mean[i]->SetMarkerColor(kBlack);
      hresLMDX_theta_mean[i]->Draw();
    }
    else{ 
      hresLMDX_theta_mean[i]->Add(hresLMDX_theta_mean[0],-1);
      hresLMDX_theta_mean[i]->Draw("same");
    }
  }
  leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDX_theta = (TH2D*)f_in->Get("hresLMDXTheta");
    if(hresLMDX_theta==0) continue;
    TString name_thetaphi = "hresLMDXTheta_";
    name_thetaphi +=i;
    hresLMDX_theta->SetName(name_thetaphi.Data());
    hresLMDX_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresLMDX_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresLMDX_theta_sigma[i]->SetMarkerStyle(21);
    hresLMDX_theta_sigma[i]->SetMarkerSize(2.1);
    hresLMDX_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDX_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(X^{LMD}_{MC}-X^{LMD}_{REC}), cm");
    hresLMDX_theta_sigma[i]->SetTitle("");
    hresLMDX_theta_sigma[i]->SetMaximum(1.7e-3);
    hresLMDX_theta_sigma[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDX_theta_sigma[i]->SetMarkerStyle(20);
      hresLMDX_theta_sigma[i]->SetMarkerColor(kBlack);
      hresLMDX_theta_sigma[i]->Draw();
    }
    else{
      hresLMDX_theta_sigma[i]->Add(hresLMDX_theta_sigma[0],-1);
      hresLMDX_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);
 for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDY_theta = (TH2D*)f_in->Get("hresLMDYTheta");
    if(hresLMDY_theta==0) continue;
    TString name_thetaphi = "hresLMDYTheta_";
    name_thetaphi +=i;
    hresLMDY_theta->SetName(name_thetaphi.Data());
    hresLMDY_theta->FitSlicesY();
    TString name_thetaphi_mean = name_thetaphi;
    name_thetaphi_mean += "_1";
    //    cout<<name_thetaphi_mean<<endl;
    hresLMDY_theta_mean[i] = (TH1D*)gDirectory->Get(name_thetaphi_mean);
    hresLMDY_theta_mean[i]->SetMarkerStyle(21);
    hresLMDY_theta_mean[i]->SetMarkerSize(2.1);
    hresLMDY_theta_mean[i]->SetMarkerColor(35+3*i);
    hresLMDY_theta_mean[i]->GetYaxis()->SetTitle("#deltaMean(Y^{LMD}_{MC}-Y^{LMD}_{REC}), cm");
    hresLMDY_theta_mean[i]->SetTitle("");
    
    hresLMDY_theta_mean[i]->SetMaximum(1.7e-3);
    hresLMDY_theta_mean[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDY_theta_mean[i]->SetMarkerStyle(20);
      hresLMDY_theta_mean[i]->SetMarkerColor(kBlack);
      hresLMDY_theta_mean[i]->Draw();
    }
    else{
      hresLMDY_theta_mean[i]->Add(hresLMDY_theta_mean[0],-1);
      hresLMDY_theta_mean[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
  c1.Print(name_out_o);
for(int i=0;i<Nsteps;i++){
    TString path_loc = path+"/all_15_dM_";
    path_loc+=dPstr[i];
    TString file_in = path_loc+"/PrecIsPbeam_allCutsON/TOT_Lumi_EffTrk.root";
    //    cout<<file_in<<endl;
    TFile *f_in = new TFile(file_in.Data(),"READ");
    if(f_in==0) continue;
    TH2 *hresLMDY_theta = (TH2D*)f_in->Get("hresLMDYTheta");
    if(hresLMDY_theta==0) continue;
    TString name_thetaphi = "hresLMDYTheta_";
    name_thetaphi +=i;
    hresLMDY_theta->SetName(name_thetaphi.Data());
    hresLMDY_theta->FitSlicesY();
    TString name_thetaphi_sigma = name_thetaphi;
    name_thetaphi_sigma += "_2";
    //    cout<<name_thetaphi_sigma<<endl;
    hresLMDY_theta_sigma[i] = (TH1D*)gDirectory->Get(name_thetaphi_sigma);
    hresLMDY_theta_sigma[i]->SetMarkerStyle(21);
    hresLMDY_theta_sigma[i]->SetMarkerSize(2.1);
    hresLMDY_theta_sigma[i]->SetMarkerColor(35+3*i);
    hresLMDY_theta_sigma[i]->GetYaxis()->SetTitle("#deltaSigma(Y^{LMD}_{MC}-Y^{LMD}_{REC}), cm");
    hresLMDY_theta_sigma[i]->SetTitle("");
   
    
    hresLMDY_theta_sigma[i]->SetMaximum(1.7e-3);
    hresLMDY_theta_sigma[i]->SetMinimum(-1.7e-3);
    if(i==0){
      hresLMDY_theta_sigma[i]->SetMarkerStyle(20);
      hresLMDY_theta_sigma[i]->SetMarkerColor(kBlack);
      hresLMDY_theta_sigma[i]->Draw();
    }
    else{
      hresLMDY_theta_sigma[i]->Add(hresLMDY_theta_sigma[0],-1);
      hresLMDY_theta_sigma[i]->Draw("same");
    }
    // f_in->Close();
  }
 leg->Draw();
 c1.Print(name_out_o);

 ////////////////// END LMD X&Y 

 c1.Clear();
 c1.Print(name_out_c);




}