Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-05 08:15:28 

0001 
0002 #include <uspin/SpinDBInput.h>
0003 #include <uspin/SpinDBOutput.h>
0004 #include "sPhenixStyle.C"
0005 R__LOAD_LIBRARY(libuspin.so)
0006 
0007 float ZDC1CUT = 100;  // keep above (nominal 65)
0008 float ZDC2CUT = 15;   // keep above (nominal 25)
0009 float VETOCUT = 150;  // keep below (nominal 150)
0010 bool ismerged = true;
0011 bool isflipON = true;
0012 void drawBunchBunch(const std::string infile = "store34485/store34485-2.root", int storenumber = 34485, int runnumber = 42797)
0013 {
0014   SetsPhenixStyle();
0015   TFile *f = new TFile(infile.c_str());
0016   //========================== Hists/Graphs ==============================//
0017 
0018   TH1D *n_smd_L = new TH1D("n_smd_L", "n_smd_L", 128, 0, 128);
0019   TH1D *n_smd_R = new TH1D("n_smd_R", "n_smd_R", 128, 0, 128);
0020   TH1D *s_smd_L = new TH1D("s_smd_L", "s_smd_L", 128, 0, 128);
0021   TH1D *s_smd_R = new TH1D("s_smd_R", "s_smd_R", 128, 0, 128);
0022 
0023   TH1D *n_smd_U = new TH1D("n_smd_U", "n_smd_U", 128, 0, 128);
0024   TH1D *n_smd_D = new TH1D("n_smd_D", "n_smd_D", 128, 0, 128);
0025   TH1D *s_smd_U = new TH1D("s_smd_U", "s_smd_U", 128, 0, 128);
0026   TH1D *s_smd_D = new TH1D("s_smd_D", "s_smd_D", 128, 0, 128);
0027 
0028   //======================================================================//
0029 
0030   //========================== SMD Hit Tree ==============================//
0031   TTree *smdHits = (TTree *) f->Get("smdHits");
0032   int bunchnumber, showerCutN, showerCutS;
0033   float n_x, n_y, s_x, s_y;
0034   float zdcN1_adc, zdcN2_adc, veto_NF, veto_NB;
0035   float zdcS1_adc, zdcS2_adc, veto_SF, veto_SB;
0036   float smdS1_adc, smdS2_adc, smdS6_adc, smdS7_adc;
0037   float smdN1_adc, smdN2_adc, smdN6_adc, smdN7_adc;
0038   float smdS1_v_adc, smdS2_v_adc, smdS7_v_adc, smdS8_v_adc;
0039   float smdN1_v_adc, smdN2_v_adc, smdN7_v_adc, smdN8_v_adc;
0040   smdHits->SetBranchAddress("bunchnumber", &bunchnumber);
0041   smdHits->SetBranchAddress("showerCutN", &showerCutN);
0042   smdHits->SetBranchAddress("showerCutS", &showerCutS);
0043   smdHits->SetBranchAddress("n_x", &n_x);
0044   smdHits->SetBranchAddress("n_y", &n_y);
0045   smdHits->SetBranchAddress("s_x", &s_x);
0046   smdHits->SetBranchAddress("s_y", &s_y);
0047   smdHits->SetBranchAddress("zdcN1_adc", &zdcN1_adc);
0048   smdHits->SetBranchAddress("zdcN2_adc", &zdcN2_adc);
0049   smdHits->SetBranchAddress("zdcS1_adc", &zdcS1_adc);
0050   smdHits->SetBranchAddress("zdcS2_adc", &zdcS2_adc);
0051   smdHits->SetBranchAddress("veto_NF", &veto_NF);
0052   smdHits->SetBranchAddress("veto_NB", &veto_NB);
0053   smdHits->SetBranchAddress("veto_SF", &veto_SF);
0054   smdHits->SetBranchAddress("veto_SB", &veto_SB);
0055   // smdHits->SetBranchStatus("n_x",0);
0056   // smdHits->SetBranchStatus("s_y",0);
0057   
0058   smdHits -> SetBranchAddress ("smdN1_adc",       &smdN1_adc);
0059   smdHits -> SetBranchAddress ("smdN2_adc",       &smdN2_adc);
0060   smdHits -> SetBranchAddress ("smdN6_adc",       &smdN6_adc);
0061   smdHits -> SetBranchAddress ("smdN7_adc",       &smdN7_adc);
0062   smdHits -> SetBranchAddress ("smdS1_adc",       &smdS1_adc);
0063   smdHits -> SetBranchAddress ("smdS2_adc",       &smdS2_adc);
0064   smdHits -> SetBranchAddress ("smdS6_adc",       &smdS6_adc);
0065   smdHits -> SetBranchAddress ("smdS7_adc",       &smdS7_adc);
0066   smdHits -> SetBranchAddress ("smdN1_v_adc",       &smdN1_v_adc);
0067   smdHits -> SetBranchAddress ("smdN2_v_adc",       &smdN2_v_adc);
0068   smdHits -> SetBranchAddress ("smdN7_v_adc",       &smdN7_v_adc);
0069   smdHits -> SetBranchAddress ("smdN8_v_adc",       &smdN8_v_adc);
0070   smdHits -> SetBranchAddress ("smdS1_v_adc",       &smdS1_v_adc);
0071   smdHits -> SetBranchAddress ("smdS2_v_adc",       &smdS2_v_adc);
0072   smdHits -> SetBranchAddress ("smdS7_v_adc",       &smdS7_v_adc);
0073   smdHits -> SetBranchAddress ("smdS8_v_adc",       &smdS8_v_adc);
0074 
0075 
0076 
0077 
0078   smdHits->SetBranchStatus("zdcN3_adc",0);
0079   smdHits->SetBranchStatus("zdcS3_adc",0);
0080   int nentries = smdHits->GetEntries();
0081   //======================================================================//
0082 
0083   //============================= Option A: Spin DB ================================//
0084   unsigned int qa_level = 0xffff;
0085   SpinDBOutput spin_out("phnxrc");
0086   SpinDBContent spin_cont;
0087   spin_out.StoreDBContent(runnumber, runnumber, qa_level);
0088   spin_out.GetDBContentStore(spin_cont, runnumber);
0089 
0090   int crossingshift = spin_cont.GetCrossingShift();
0091   // crossingshift = 0;
0092   // crossingshift = ixs;
0093   // if (ixs < 0){crossingshift = 120+ixs;}
0094   std::cout << crossingshift << std::endl;
0095 
0096   int bspinpat[120] = {0};
0097   int yspinpat[120] = {0};
0098   for (int i = 0; i < 120; i++)
0099   {
0100     bspinpat[i] = spin_cont.GetSpinPatternBlue(i);
0101     yspinpat[i] = spin_cont.GetSpinPatternYellow(i);
0102     if(isflipON)
0103     {
0104       bspinpat[i]*=-1;
0105       yspinpat[i]*=-1;
0106     }
0107   }
0108   //======================================================================//
0109 
0110   //============================= Option B: Get spin pattern manually ================================//
0111   int bpat[120] = {0};
0112   int ypat[120] = {0};
0113   std::string preset_pattern_blue[8];
0114   std::string preset_pattern_yellow[8];
0115   preset_pattern_blue[0] = "+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+*********";
0116   preset_pattern_blue[1] = "-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-*********";
0117   preset_pattern_blue[2] = "+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+*********";
0118   preset_pattern_blue[3] = "-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-*********";
0119   preset_pattern_blue[4] = "++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++-*********";
0120   preset_pattern_blue[5] = "--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--+*********";
0121   preset_pattern_blue[6] = "++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++-*********";
0122   preset_pattern_blue[7] = "--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--+*********";
0123 
0124   preset_pattern_yellow[0] = "++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++-*********";
0125   preset_pattern_yellow[1] = "++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++-*********";
0126   preset_pattern_yellow[2] = "--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--+*********";
0127   preset_pattern_yellow[3] = "--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--++--+*********";
0128   preset_pattern_yellow[4] = "+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+*********";
0129   preset_pattern_yellow[5] = "+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+--+-++-+-+-+--+-+-+-++-+*********";
0130   preset_pattern_yellow[6] = "-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-*********";
0131   preset_pattern_yellow[7] = "-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-++-+--+-+-+-++-+-+-+--+-*********";
0132 
0133   int spinpatternNo = 3;
0134   if (storenumber == 34485)
0135   {
0136     spinpatternNo = 3;
0137   }  // pattern names start at '111x111_P1' so index 3  means '111x111_P4' and so on
0138 
0139   for (int i = 0; i < 120; i++)
0140   {
0141     if (preset_pattern_blue[spinpatternNo].at(i) == '+')
0142     {
0143       bpat[i] = 1;
0144     }
0145     else if (preset_pattern_blue[spinpatternNo].at(i) == '-')
0146     {
0147       bpat[i] = -1;
0148     }
0149     else if (preset_pattern_blue[spinpatternNo].at(i) == '*')
0150     {
0151       bpat[i] = 10;
0152     }
0153 
0154     if (preset_pattern_yellow[spinpatternNo].at(i) == '+')
0155     {
0156       ypat[i] = 1;
0157     }
0158     else if (preset_pattern_yellow[spinpatternNo].at(i) == '-')
0159     {
0160       ypat[i] = -1;
0161     }
0162     else if (preset_pattern_yellow[spinpatternNo].at(i) == '*')
0163     {
0164       ypat[i] = 10;
0165     }
0166   }
0167   //=====================================================================================//
0168 
0169   //======================= process event ==================================//
0170   std::cout << nentries << std::endl;
0171 
0172   int clockOffset = 1;  // this is the offset between GL1 and ZDC events
0173 
0174 //for (int i = 0; i <1000000; i++)
0175   for (int i = 0; i < nentries - clockOffset; i++)
0176   {
0177     if (i % 1000000 == 0)
0178     {
0179       std::cout << "Entry: " << i << std::endl;
0180     }
0181     smdHits->GetEntry(i + clockOffset);
0182 
0183     int sphenix_cross = (bunchnumber + crossingshift) % 120;
0184 
0185     smdHits->GetEntry(i);
0186 
0187     int bspin = bspinpat[sphenix_cross];  // option A: spinDB
0188     int yspin = yspinpat[sphenix_cross];  // option A: spinDB
0189     // int bspin = bpat[sphenix_cross]; //option B: preset patterns
0190     // int yspin = ypat[sphenix_cross]; //option B: preset patterns
0191 
0192     if (zdcN1_adc > ZDC1CUT && zdcN2_adc > ZDC2CUT && veto_NF < VETOCUT && veto_NB < VETOCUT && showerCutN == 1)
0193     {
0194       if (smdN1_adc > 100. && smdN2_adc > 100.)
0195       {
0196         n_smd_L->Fill(sphenix_cross);
0197       }
0198       if (smdN6_adc > 100. && smdN7_adc > 100.)
0199         n_smd_R->Fill(sphenix_cross);
0200       if (smdN1_v_adc > 100. && smdN2_v_adc > 100.)
0201       {
0202         n_smd_D->Fill(sphenix_cross);
0203       }
0204       if (smdN7_v_adc > 100. && smdN8_v_adc > 100.)
0205       {
0206         n_smd_U->Fill(sphenix_cross);
0207       }
0208       //////////// OLD //////////////////
0209       // if (n_x < -3)
0210       // {
0211       //   n_smd_L->Fill(sphenix_cross);
0212       // }
0213       // else if (n_x > 3)
0214       //   n_smd_R->Fill(sphenix_cross);
0215 
0216       // if (n_y > 3)
0217       // {
0218       //   n_smd_U->Fill(sphenix_cross);
0219       // }
0220       // else if (n_y < -3)
0221       // {
0222       //   n_smd_D->Fill(sphenix_cross);
0223       // }
0224       //////////// OLD ////////////////
0225     }
0226 
0227     if (zdcS1_adc > ZDC1CUT && zdcS2_adc > ZDC2CUT && veto_SF < VETOCUT && veto_SB < VETOCUT && showerCutS == 1)
0228     {
0229       if (smdS1_adc > 100. && smdS2_adc > 100.)
0230       {
0231         s_smd_L->Fill(sphenix_cross);
0232       }
0233       if (smdS6_adc > 100. && smdS7_adc > 100.)
0234         s_smd_R->Fill(sphenix_cross);
0235       if (smdS1_v_adc > 100. && smdS2_v_adc > 100.)
0236       {
0237         s_smd_D->Fill(sphenix_cross);
0238       }
0239       if (smdS7_v_adc > 100. && smdS8_v_adc > 100.)
0240       {
0241         s_smd_U->Fill(sphenix_cross);
0242       }
0243 
0244       /////////////// OLD ///////////////
0245       // if (s_x < -3)
0246       // {
0247       //   s_smd_L->Fill(sphenix_cross);
0248       // }
0249       // else if (s_x > 3)
0250       //   s_smd_R->Fill(sphenix_cross);
0251       // if (s_y > 3)
0252       // {
0253       //   s_smd_U->Fill(sphenix_cross);
0254       // }
0255       // else if (s_y < -3)
0256       // {
0257       //   s_smd_D->Fill(sphenix_cross);
0258       // }
0259       ///////////// OLD //////////////////
0260     }
0261   }
0262   //=====================================================================================//
0263 
0264   std::vector<double> x_spinup_blueUD, y_spinup_blueUD, ex_spinup_blueUD, ey_spinup_blueUD;
0265   std::vector<double> x_spindown_blueUD, y_spindown_blueUD, ex_spindown_blueUD, ey_spindown_blueUD;
0266   std::vector<double> x_spinup_yellowUD, y_spinup_yellowUD, ex_spinup_yellowUD, ey_spinup_yellowUD;
0267   std::vector<double> x_spindown_yellowUD, y_spindown_yellowUD, ex_spindown_yellowUD, ey_spindown_yellowUD;
0268 
0269   for (int i = 1; i <= 115; ++i)
0270   {
0271     double A = n_smd_U->GetBinContent(i);
0272     double B = n_smd_D->GetBinContent(i);
0273     double A_y = s_smd_U->GetBinContent(i);
0274     double B_y = s_smd_D->GetBinContent(i);
0275     std::cout << "A : " << A << " //// B : " << B << std::endl;
0276     int nbunch = i - 1;
0277     int b_spin = bspinpat[nbunch];
0278     int y_spin = yspinpat[nbunch];
0279     if (b_spin != 1 && b_spin != -1)
0280       continue;
0281     if (A != 0 || B != 0)
0282     {
0283       double aym = (A - B) / (A + B);
0284       double error = TMath::Sqrt(4 * (A * B) / ((A + B) * (A + B) * (A + B)));
0285       if (b_spin == 1)
0286       {  // spinup_blueUD bin
0287         x_spinup_blueUD.push_back(nbunch);
0288         y_spinup_blueUD.push_back(aym);
0289         ex_spinup_blueUD.push_back(0);  // No error on x
0290         ey_spinup_blueUD.push_back(error);
0291       }
0292       else if (b_spin == -1)
0293       {  // spindown_blueUD bin
0294         x_spindown_blueUD.push_back(nbunch);
0295         y_spindown_blueUD.push_back(aym);
0296         ex_spindown_blueUD.push_back(0);  // No error on x
0297         ey_spindown_blueUD.push_back(error);
0298       }
0299     }
0300     if (A_y != 0 || B_y != 0)
0301     {
0302       double aym = (A_y - B_y) / (A_y + B_y);
0303       double error = TMath::Sqrt(4 * (A_y * B_y) / ((A_y + B_y) * (A_y + B_y) * (A_y + B_y)));
0304       if (y_spin == 1)
0305       {  // spinup_blueUD bin
0306         x_spinup_yellowUD.push_back(nbunch);
0307         y_spinup_yellowUD.push_back(aym);
0308         ex_spinup_yellowUD.push_back(0);  // No error on x
0309         ey_spinup_yellowUD.push_back(error);
0310       }
0311       else if (y_spin == -1)
0312       {  // spindown_yellowUD bin
0313         x_spindown_yellowUD.push_back(nbunch);
0314         y_spindown_yellowUD.push_back(aym);
0315         ex_spindown_yellowUD.push_back(0);  // No error on x
0316         ey_spindown_yellowUD.push_back(error);
0317       }
0318     }
0319   }
0320 
0321   std::vector<double> x_spinup_blue, y_spinup_blue, ex_spinup_blue, ey_spinup_blue;
0322   std::vector<double> x_spindown_blue, y_spindown_blue, ex_spindown_blue, ey_spindown_blue;
0323   std::vector<double> x_spinup_yellow, y_spinup_yellow, ex_spinup_yellow, ey_spinup_yellow;
0324   std::vector<double> x_spindown_yellow, y_spindown_yellow, ex_spindown_yellow, ey_spindown_yellow;
0325 
0326   int nBins = n_smd_L->GetNbinsX();
0327   for (int i = 1; i <= 115; ++i)
0328   {
0329     double A = n_smd_L->GetBinContent(i);
0330     double B = n_smd_R->GetBinContent(i);
0331     double A_y = s_smd_L->GetBinContent(i);
0332     double B_y = s_smd_R->GetBinContent(i);
0333     std::cout << "A : " << A << " //// B : " << B << std::endl;
0334     int nbunch = i - 1;
0335     int b_spin = bspinpat[nbunch];
0336     int y_spin = yspinpat[nbunch];
0337     if (b_spin != 1 && b_spin != -1)
0338       continue;
0339     if (A != 0 || B != 0)
0340     {
0341       double aym = (A - B) / (A + B);
0342       double error = TMath::Sqrt(4 * (A * B) / ((A + B) * (A + B) * (A + B)));
0343       if (b_spin == 1)
0344       {  // spinup_blue bin
0345         x_spinup_blue.push_back(nbunch);
0346         y_spinup_blue.push_back(aym);
0347         ex_spinup_blue.push_back(0);  // No error on x
0348         ey_spinup_blue.push_back(error);
0349       }
0350       else if (b_spin == -1)
0351       {  // spindown_blue bin
0352         x_spindown_blue.push_back(nbunch);
0353         y_spindown_blue.push_back(aym);
0354         ex_spindown_blue.push_back(0);  // No error on x
0355         ey_spindown_blue.push_back(error);
0356       }
0357     }
0358     if (A_y != 0 || B_y != 0)
0359     {
0360       double aym = (A_y - B_y) / (A_y + B_y);
0361       double error = TMath::Sqrt(4 * (A_y * B_y) / ((A_y + B_y) * (A_y + B_y) * (A_y + B_y)));
0362       if (y_spin == 1)
0363       {  // spinup_blue bin
0364         x_spinup_yellow.push_back(nbunch);
0365         y_spinup_yellow.push_back(aym);
0366         ex_spinup_yellow.push_back(0);  // No error on x
0367         ey_spinup_yellow.push_back(error);
0368       }
0369       else if (y_spin == -1)
0370       {  // spindown_yellow bin
0371         x_spindown_yellow.push_back(nbunch);
0372         y_spindown_yellow.push_back(aym);
0373         ex_spindown_yellow.push_back(0);  // No error on x
0374         ey_spindown_yellow.push_back(error);
0375       }
0376     }
0377   }
0378 
0379   // Create the TGraphErrors for spinup_blueUD bins
0380   TGraphErrors *graph_spinup_blueUD = new TGraphErrors(x_spinup_blueUD.size(), x_spinup_blueUD.data(), y_spinup_blueUD.data(), ex_spinup_blueUD.data(), ey_spinup_blueUD.data());
0381   graph_spinup_blueUD->SetMarkerStyle(21);
0382   graph_spinup_blueUD->SetTitle("SMD North Up Down asymmetry");
0383   graph_spinup_blueUD->SetMarkerColor(kRed);
0384   graph_spinup_blueUD->SetLineColor(kRed);
0385 
0386   // Create the TGraphErrors for spindown_blueUD bins
0387   TGraphErrors *graph_spindown_blueUD = new TGraphErrors(x_spindown_blueUD.size(), x_spindown_blueUD.data(), y_spindown_blueUD.data(), ex_spindown_blueUD.data(), ey_spindown_blueUD.data());
0388   graph_spindown_blueUD->SetMarkerStyle(21);
0389   graph_spindown_blueUD->SetTitle("SMD North Up Down asymmetry");
0390   graph_spindown_blueUD->SetMarkerColor(kBlue);
0391   graph_spindown_blueUD->SetLineColor(kBlue);
0392 
0393   // Create the TGraphErrors for spinup_yellowUD bins
0394   TGraphErrors *graph_spinup_yellowUD = new TGraphErrors(x_spinup_yellowUD.size(), x_spinup_yellowUD.data(), y_spinup_yellowUD.data(), ex_spinup_yellowUD.data(), ey_spinup_yellowUD.data());
0395   graph_spinup_yellowUD->SetMarkerStyle(21);
0396   graph_spinup_yellowUD->SetTitle("SMD South Up Down asymmetry");
0397   graph_spinup_yellowUD->SetMarkerColor(kRed);
0398   graph_spinup_yellowUD->SetLineColor(kRed);
0399 
0400   // Create the TGraphErrors for spindown_yellowUD bins
0401   TGraphErrors *graph_spindown_yellowUD = new TGraphErrors(x_spindown_yellowUD.size(), x_spindown_yellowUD.data(), y_spindown_yellowUD.data(), ex_spindown_yellowUD.data(), ey_spindown_yellowUD.data());
0402   graph_spindown_yellowUD->SetMarkerStyle(21);
0403   graph_spindown_yellowUD->SetTitle("SMD South Up Down asymmetry ");
0404   graph_spindown_yellowUD->SetMarkerColor(kBlue);
0405   graph_spindown_yellowUD->SetLineColor(kBlue);
0406 
0407   // Create the TGraphErrors for spinup_blue bins
0408   TGraphErrors *graph_spinup_blue = new TGraphErrors(x_spinup_blue.size(), x_spinup_blue.data(), y_spinup_blue.data(), ex_spinup_blue.data(), ey_spinup_blue.data());
0409   graph_spinup_blue->SetMarkerStyle(21);
0410   graph_spinup_blue->SetTitle("SMD North Left Right asymmetry");
0411   graph_spinup_blue->SetMarkerColor(kRed);
0412   graph_spinup_blue->SetLineColor(kRed);
0413 
0414   // Create the TGraphErrors for spindown_blue bins
0415   TGraphErrors *graph_spindown_blue = new TGraphErrors(x_spindown_blue.size(), x_spindown_blue.data(), y_spindown_blue.data(), ex_spindown_blue.data(), ey_spindown_blue.data());
0416   graph_spindown_blue->SetMarkerStyle(21);
0417   graph_spindown_blue->SetTitle("SMD North Left Right asymmetry");
0418   graph_spindown_blue->SetMarkerColor(kBlue);
0419   graph_spindown_blue->SetLineColor(kBlue);
0420 
0421   // Create the TGraphErrors for spinup_yellow bins
0422   TGraphErrors *graph_spinup_yellow = new TGraphErrors(x_spinup_yellow.size(), x_spinup_yellow.data(), y_spinup_yellow.data(), ex_spinup_yellow.data(), ey_spinup_yellow.data());
0423   graph_spinup_yellow->SetMarkerStyle(21);
0424   graph_spinup_yellow->SetTitle("SMD South Left Right asymmetry");
0425   graph_spinup_yellow->SetMarkerColor(kRed);
0426   graph_spinup_yellow->SetLineColor(kRed);
0427 
0428   // Create the TGraphErrors for spindown_yellow bins
0429   TGraphErrors *graph_spindown_yellow = new TGraphErrors(x_spindown_yellow.size(), x_spindown_yellow.data(), y_spindown_yellow.data(), ex_spindown_yellow.data(), ey_spindown_yellow.data());
0430   graph_spindown_yellow->SetMarkerStyle(21);
0431   graph_spindown_yellow->SetTitle("SMD South Left Right asymmetry ");
0432   graph_spindown_yellow->SetMarkerColor(kBlue);
0433   graph_spindown_yellow->SetLineColor(kBlue);
0434 
0435   TLatex *latex = new TLatex();
0436   latex->SetNDC();
0437   latex->SetTextSize(0.045);
0438   latex->SetTextAlign(31);
0439   TCanvas *canvas = new TCanvas("canvas_blue", "North SMD", 950, 800);
0440   graph_spinup_blue->GetXaxis()->SetLimits(0, 111);
0441   graph_spinup_blue->GetYaxis()->SetTitle("(L-R)/(L+R)");
0442   graph_spinup_blue->GetXaxis()->SetTitle("Bunch number");
0443   graph_spinup_blue->SetMinimum(-0.08);
0444   graph_spinup_blue->SetMaximum(0.02);
0445   canvas->cd();
0446   graph_spinup_blue->Draw("AP");
0447   graph_spindown_blue->Draw("P SAME");
0448   TFitResultPtr fit_spinup_blue = graph_spinup_blue->Fit("pol0", "S");
0449   TFitResultPtr fit_spindown_blue = graph_spindown_blue->Fit("pol0", "S");
0450   // Add legend
0451   TLegend leg1(.20, .70, .60, .90);
0452   leg1.AddEntry((TObject *) 0, Form("SMD North / Run 42796+42797"), "");
0453   leg1.AddEntry(graph_spinup_blue, Form("blue #uparrow :  %.5f #pm %.5f", fit_spinup_blue->Parameter(0), fit_spinup_blue->ParError(0)), "LP");
0454   leg1.AddEntry(graph_spindown_blue, Form("blue #downarrow : %.5f #pm %.5f", fit_spindown_blue->Parameter(0), fit_spindown_blue->ParError(0)), "LP");
0455   leg1.SetTextSize(0.03);
0456   leg1.Draw();
0457   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0458 
0459   TCanvas *canvas2 = new TCanvas("canvas_blueUD", "North SMD UD", 950, 800);
0460   graph_spinup_blueUD->GetXaxis()->SetLimits(0, 111);
0461   graph_spinup_blueUD->GetYaxis()->SetTitle("(U-D)/(U+D)");
0462   graph_spinup_blueUD->GetXaxis()->SetTitle("Bunch number");
0463   graph_spinup_blueUD->SetMinimum(0.18);
0464   graph_spinup_blueUD->SetMaximum(0.18+0.1);
0465   canvas2->cd();
0466   graph_spinup_blueUD->Draw("AP");
0467   graph_spindown_blueUD->Draw("P SAME");
0468   // Add legend
0469   TFitResultPtr fit_spinup_blueUD = graph_spinup_blueUD->Fit("pol0", "S");
0470   TFitResultPtr fit_spindown_blueUD = graph_spindown_blueUD->Fit("pol0", "S");
0471   TLegend leg2(.20, .70, .60, .90);
0472   leg2.AddEntry((TObject *) 0, Form("SMD North / Run 42796+42797"), "");
0473   leg2.AddEntry(graph_spinup_blueUD, Form("blue #uparrow :  %.5f #pm %.5f", fit_spinup_blueUD->Parameter(0), fit_spinup_blueUD->ParError(0)), "LP");
0474   leg2.AddEntry(graph_spindown_blueUD, Form("blue #downarrow : %.5f #pm %.5f", fit_spindown_blueUD->Parameter(0), fit_spindown_blueUD->ParError(0)), "LP");
0475   leg2.SetTextSize(0.03);
0476   leg2.Draw();
0477   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0478 
0479   TCanvas *canvas3 = new TCanvas("canvas_yellow", "South SMD", 950, 800);
0480   graph_spinup_yellow->GetXaxis()->SetLimits(0, 111);
0481   graph_spinup_yellow->GetYaxis()->SetTitle("(L-R)/(L+R)");
0482   graph_spinup_yellow->GetXaxis()->SetTitle("Bunch number");
0483   graph_spinup_yellow->SetMaximum(0.07);
0484   graph_spinup_yellow->SetMinimum(-0.03);
0485   canvas3->cd();
0486   graph_spinup_yellow->Draw("AP");
0487   graph_spindown_yellow->Draw("P SAME");
0488   // Add legend
0489   TFitResultPtr fit_spinup_yellow = graph_spinup_yellow->Fit("pol0", "S");
0490   TFitResultPtr fit_spindown_yellow = graph_spindown_yellow->Fit("pol0", "S");
0491   TLegend leg3(.20, .70, .60, .90);
0492   leg3.AddEntry((TObject *) 0, Form("SMD South / Run 42796+42797"), "");
0493   leg3.AddEntry(graph_spinup_yellow, Form("yellow #uparrow :  %.5f #pm %.5f", fit_spinup_yellow->Parameter(0), fit_spinup_yellow->ParError(0)), "LP");
0494   leg3.AddEntry(graph_spindown_yellow, Form("yellow #downarrow : %.5f #pm %.5f", fit_spindown_yellow->Parameter(0), fit_spindown_yellow->ParError(0)), "LP");
0495   leg3.SetTextSize(0.03);
0496   leg3.Draw();
0497   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0498 
0499   TCanvas *canvas4 = new TCanvas("canvas_yellow_UD", "South SMD", 950, 800);
0500   graph_spinup_yellowUD->GetXaxis()->SetLimits(0, 111);
0501   graph_spinup_yellowUD->GetYaxis()->SetTitle("(U-D)/(U+D)");
0502   graph_spinup_yellowUD->GetXaxis()->SetTitle("Bunch number");
0503   graph_spinup_yellowUD->SetMaximum(-0.04 + 0.1);
0504   graph_spinup_yellowUD->SetMinimum(-0.04);
0505   canvas4->cd();
0506   graph_spinup_yellowUD->Draw("AP");
0507   graph_spindown_yellowUD->Draw("P SAME");
0508   // Add legend
0509   // TLegend *legend4 = new TLegend(0.7, 0.9, 0.8, 0.95);
0510   // legend4->AddEntry(graph_spinup_yellowUD, "yellow spin up Bunches", "p");
0511   // legend4->AddEntry(graph_spindown_yellowUD, "yellow spin down Bunches", "p");
0512   // legend4->Draw();
0513   // latex->DrawLatexNDC(0.65, 0.8, "#bf{sPHENIX} internal");
0514   // if (!ismerged)
0515   //   latex->DrawLatexNDC(0.65, 0.75, Form("Run %d", runnumber));
0516   // else
0517   //   latex->DrawLatexNDC(0.65, 0.75, Form("Store %d", storenumber));
0518   TFitResultPtr fit_spinup_yellowUD = graph_spinup_yellowUD->Fit("pol0", "S");
0519   TFitResultPtr fit_spindown_yellowUD = graph_spindown_yellowUD->Fit("pol0", "S");
0520   TLegend leg4(.20, .70, .60, .90);
0521   leg4.AddEntry((TObject *) 0, Form("SMD South / Run 42796+42797"), "");
0522   leg4.AddEntry(graph_spinup_yellowUD, Form("yellow #uparrow :  %.5f #pm %.5f", fit_spinup_yellowUD->Parameter(0), fit_spinup_yellowUD->ParError(0)), "LP");
0523   leg4.AddEntry(graph_spindown_yellowUD, Form("yellow #downarrow : %.5f #pm %.5f", fit_spindown_yellowUD->Parameter(0), fit_spindown_yellowUD->ParError(0)), "LP");
0524   leg4.SetTextSize(0.03);
0525   leg4.Draw();
0526   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0527 
0528   TCanvas *canvas5 = new TCanvas("canvas5", "canvas5", 950, 800);
0529   canvas5->cd();
0530   canvas5->SetLogy();
0531   // n_smd_L->SetLineWidth(1.5);
0532   n_smd_L->SetXTitle("bunch number");
0533   // n_smd_L->SetMarkerStyle(kFullCircle);
0534   n_smd_L->Draw("E");
0535   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0536 
0537   canvas5->SaveAs("north_smd1.pdf");
0538   TCanvas *canvas6 = new TCanvas("canvas6", "canvas6", 950, 800);
0539   canvas6->cd();
0540   canvas6->SetLogy();
0541   // n_smd_L->SetLineWidth(1.5);
0542   n_smd_R->SetXTitle("bunch number");
0543   // n_smd_R->SetMarkerStyle(kFullCircle);
0544   n_smd_R->Draw("E");
0545   latex->DrawLatex(1 - gPad->GetRightMargin(), 1 - gPad->GetTopMargin() + 0.01, Form("#it{p+p}, 200 GeV #it{#bf{sPHENIX}} internal"));
0546   canvas6->SaveAs("north_smd2.pdf");
0547 
0548   TFile *sfile = new TFile("sfile.root", "RECREATE");
0549   TString pdfName;
0550   TString fileName;
0551   sfile->cd();
0552   canvas->Write();
0553   pdfName = canvas->GetName();
0554   fileName = pdfName + ".pdf";
0555   canvas->SaveAs(fileName);
0556   canvas->Update();
0557   canvas2->Write();
0558   pdfName = canvas2->GetName();
0559   fileName = pdfName + ".pdf";
0560   canvas2->SaveAs(fileName);
0561   canvas2->Update();
0562   canvas3->Write();
0563   pdfName = canvas3->GetName();
0564   fileName = pdfName + ".pdf";
0565   canvas3->SaveAs(fileName);
0566   canvas3->Update();
0567   canvas4->Write();
0568   pdfName = canvas4->GetName();
0569   fileName = pdfName + ".pdf";
0570   canvas4->SaveAs(fileName);
0571   canvas4->Update();
0572 
0573   n_smd_L->Write();
0574   n_smd_R->Write();
0575   s_smd_L->Write();
0576   s_smd_R->Write();
0577   sfile->Close();
0578 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!