Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:16:33 

0001 #include "ZdcSmdCount.h"
0002 
0003 #include <fun4all/Fun4AllReturnCodes.h>
0004 #include <fun4all/PHTFileServer.h>
0005 
0006 #include <calobase/TowerInfoContainer.h>
0007 #include <calobase/TowerInfo.h>
0008 
0009 
0010 #include <phool/PHCompositeNode.h>
0011 #include <phool/PHIODataNode.h>    // for PHIODataNode
0012 #include <phool/PHNode.h>          // for PHNode
0013 #include <phool/PHNodeIterator.h>  // for PHNodeIterator
0014 #include <phool/PHObject.h>        // for PHObject
0015 #include <phool/getClass.h>
0016 
0017 #include <ffarawobjects/Gl1Packetv1.h>
0018 #include <ffarawobjects/CaloPacketContainerv1.h>
0019 #include <ffarawobjects/CaloPacketv1.h>
0020 //spin database stuff
0021 #include <uspin/SpinDBContent.h>
0022 #include <uspin/SpinDBOutput.h>
0023 
0024 #include <fstream>
0025 #include <iostream>
0026 #include <sstream>
0027 
0028 #include <TFile.h>
0029 #include <TH2.h>
0030 #include <TH1.h>
0031 #include <TGraphErrors.h>
0032 
0033 //____________________________________________________________________________..
0034 ZdcSmdCount::ZdcSmdCount(const std::string &name,const int runnumber,float cutvalue,int roller):
0035  SubsysReco(name)
0036 {
0037   runnumber_ = runnumber;
0038   cut_value_ =  cutvalue;
0039   char outfile_c[200];
0040   sprintf(outfile_c,"result_count_%08d-%d-%d.root",runnumber_,static_cast<int>(cut_value_),roller);
0041   outfile_name_.assign(outfile_c);
0042   event_counter_ = 0;
0043   std::cout << "ZdcSmdCount::ZdcSmdCount(const std::string &name) Calling ctor" << std::endl;
0044   std::cout << "SImpleZdcSmdAna::Output file : " << outfile_name_ << std::endl;
0045 }
0046 
0047 //____________________________________________________________________________..
0048 ZdcSmdCount::~ZdcSmdCount()
0049 {
0050   std::cout << "ZdcSmdCount::~ZdcSmdCount() Calling dtor" << std::endl;
0051 }
0052 
0053 //____________________________________________________________________________..
0054 int ZdcSmdCount::Init(PHCompositeNode *topNode)
0055 {
0056   std::cout << "ZdcSmdCount::Init(PHCompositeNode *topNode) Initializing" << std::endl;
0057   outfile_ = new TFile(outfile_name_.c_str(),"RECREATE");
0058   outfile_ -> cd();
0059 
0060   InitHist();
0061   const char *zdccalib = "/sphenix/u/jaein213";
0062     if (!zdccalib)
0063   {
0064     std::cout << "ZDCCALIB environment variable not set" << std::endl;
0065     exit(1);
0066   }
0067   std::string mappingfilename = std::string(zdccalib) + "/" + "ChannelMapping.dat";
0068   std::ifstream mapping(mappingfilename);
0069 
0070   if (!mapping)
0071   {
0072   std::cout<< " could not be opened."<<std::endl;
0073     exit(1);
0074   }
0075   int adc, array;
0076   std::string ChannelName;
0077   for (int i = 0; i < 128; i++)
0078   {
0079     mapping >> adc >> array >> ChannelName;
0080     Chmapping[adc] = array;
0081     std::cout << adc << " \t" << array << std::endl;
0082   }
0083 
0084   GetSpinPatterns();
0085   return Fun4AllReturnCodes::EVENT_OK;
0086 }
0087 
0088 //____________________________________________________________________________..
0089 int ZdcSmdCount::InitRun(PHCompositeNode *topNode)
0090 {
0091 //  std::cout << "ZdcSmdCount::InitRun(PHCompositeNode *topNode) Initializing for Run XXX" << std::endl;
0092   return Fun4AllReturnCodes::EVENT_OK;
0093 }
0094 
0095 int ZdcSmdCount::process_event(PHCompositeNode *topNode)
0096 {
0097   if (event_counter_ % 1000 == 0)
0098     std::cout << "event : " << event_counter_ << " started" << std::endl;
0099   CaloPacketContainer *zdc_cont = findNode::getClass<CaloPacketContainerv1>(topNode, "ZDCPackets");
0100   CaloPacket *p = zdc_cont->getPacket(0);
0101   Gl1Packetv1 *gl1 = findNode::getClass<Gl1Packetv1>(topNode, "GL1Packet");
0102   if (gl1)
0103   {
0104     bunchNum_ = gl1->getBunchNumber();
0105   }
0106   if (zdc_cont->get_npackets() != 1)
0107   {
0108     std::cout << "No packet! skip this event : " << event_counter_ << std::endl;
0109     return Fun4AllReturnCodes::EVENT_OK;
0110   }
0111   float south_zdc[3] = {0.};
0112   float north_zdc[3] = {0.};
0113   float south_smd[16] = {0.};
0114   float north_smd[16] = {0.};
0115   float south_veto[2] = {0.};
0116   float north_veto[2] = {0.};
0117   if (false)
0118   {
0119 
0120     std::cout << south_zdc[0]
0121               << north_zdc[0]
0122               << south_smd[0]
0123               << north_smd[0]
0124               << south_veto[0]
0125               << north_veto[0]
0126               << std::endl;
0127   }
0128   // unsigned int north_smd_h_count = 0; // horizontal smd
0129   // unsigned int north_smd_v_count = 0; // vertical smd
0130   // unsigned int south_smd_h_count = 0; // horizontal smd
0131   // unsigned int south_smd_v_count = 0; // vertical smd
0132   for (std::map<int, int>::iterator it = Chmapping.begin(); it != Chmapping.end(); ++it) // new mapping for ZDC/SMD/Veto with 2 ADC boards//May 13th 2024
0133   {
0134     if (it->second < 0)
0135       continue;
0136     if (it->second > 51)
0137       continue;
0138     int j = it->second;
0139     // std::cout<<j<<std::endl;
0140     double baseline = 0.;
0141     double baseline_low = 0.;
0142     double baseline_high = 0.;
0143     for (int s = 0; s < 3; s++)
0144     {
0145       baseline_low += p->iValue(s, it->first);
0146     }
0147 
0148     baseline_low /= 3.;
0149 
0150     for (int s = p->iValue(0, "SAMPLES") - 3; s < p->iValue(0, "SAMPLES"); s++)
0151     {
0152       baseline_high += p->iValue(s, it->first);
0153     }
0154 
0155     baseline_high /= 3.;
0156     baseline = baseline_low;
0157 
0158     if (baseline_high < baseline_low)
0159       baseline = baseline_high;
0160 
0161     if (baseline_high < baseline_low)
0162       baseline = baseline_high;
0163 
0164     for (int s = 0; s < p->iValue(0, "SAMPLES"); s++)
0165     {
0166       // h_waveformAll->Fill(s, p->iValue(s, it->first) - baseline);
0167       if (j < 8)
0168       {
0169         h2_SouthZDC_->Fill(s, p->iValue(s, it->first) - baseline);
0170       }
0171       else if (j < 16) //-->[0,15]
0172       {
0173         h2_NorthZDC_->Fill(s, p->iValue(s, it->first) - baseline);
0174       }
0175 
0176       else if (j < 32) //-->[16,31]
0177       {
0178         h2_NorthSMD_->Fill(s, p->iValue(s, it->first) - baseline);
0179       }
0180 
0181       else if (j < 48) //-->[32,47]
0182       {
0183         h2_SouthSMD_->Fill(s, p->iValue(s, it->first) - baseline);
0184       }
0185 
0186       else if (j < 50) //-->[48,49]
0187       {
0188         h2_NorthVeto_->Fill(s, p->iValue(s, it->first) - baseline);
0189       }
0190 
0191       else if (j < 52) //-->[50,51]
0192       {
0193         h2_SouthVeto_->Fill(s, p->iValue(s, it->first) - baseline);
0194       }
0195     }
0196 
0197     ////////////////////////////////////////////////////////
0198 
0199     if (j == 0 || j == 2 || j == 4) // ZDC South High Gain
0200     {
0201       float max_adc = -99999;
0202       float max_t = -1;
0203       int time_min = 6;
0204       int time_max = 9;
0205       for (int s = time_min; s < time_max + 1; s++)
0206       {
0207         float temp = p->iValue(s, it->first);
0208         if (max_adc < temp)
0209         {
0210           max_adc = temp;
0211           max_t = s;
0212         }
0213       }
0214       south_zdc[j / 2] = max_adc - baseline;
0215       h2_SouthZDC_cut_->Fill(max_t, south_zdc[j / 2]);
0216       h1_SouthZDC_adc_->Fill(south_zdc[j / 2]);
0217       h1_SouthZDC_adc_origin_->Fill(max_adc);
0218       h1_SouthZDC_adc_ped_->Fill(baseline);
0219     }
0220     if (j == 8 || j == 10 || j == 12) // ZDC North High Gain
0221     {
0222       float max_adc = -99999;
0223       float max_t = -1;
0224       int time_min = 6;
0225       int time_max = 9;
0226       for (int s = time_min; s < time_max + 1; s++)
0227       {
0228         float temp = p->iValue(s, it->first);
0229         if (max_adc < temp)
0230         {
0231           max_adc = temp;
0232           max_t = s;
0233         }
0234       }
0235       north_zdc[(j - 8) / 2] = max_adc - baseline;
0236       h2_NorthZDC_cut_->Fill(max_t, north_zdc[(j - 8) / 2]);
0237       h1_NorthZDC_adc_->Fill(north_zdc[(j - 8) / 2]);
0238       h1_NorthZDC_adc_origin_->Fill(max_adc);
0239       h1_NorthZDC_adc_ped_->Fill(baseline);
0240     }
0241 
0242     if (j > 15 && j < 31) // j == 31 : N SMD ADC SUM
0243     {
0244       float max_adc = -99999;
0245       float max_t = -1;
0246       int time_min = 10;
0247       int time_max = 13;
0248       for (int s = time_min; s < time_max + 1; s++)
0249       {
0250         float temp = p->iValue(s, it->first);
0251         if (max_adc < temp)
0252         {
0253           max_adc = temp;
0254           max_t = s;
0255         }
0256       }
0257       //smd[0] = h1 smd[7] = h8, smd[8] = v1 smd[14] = v7
0258       north_smd[j - 16] = max_adc - baseline;
0259       h2_NorthSMD_cut_->Fill(max_t, north_smd[j - 16]);
0260       h1_NorthSMD_adc_->Fill(north_smd[j - 16]);
0261       h1_NorthSMD_adc_origin_->Fill(max_adc);
0262       h1_NorthSMD_adc_ped_->Fill(baseline);
0263     }
0264     if (j > 31 && j < 47) // j == 47 : S SMD ADC SUM
0265     {
0266       float max_adc = -99999;
0267       float max_t = -1;
0268       int time_min = 7;
0269       int time_max = 12;
0270       for (int s = time_min; s < time_max + 1; s++)
0271       {
0272         float temp = p->iValue(s, it->first);
0273         if (max_adc < temp)
0274         {
0275           max_adc = temp;
0276           max_t = s;
0277         }
0278       }
0279       //smd[0] = h1 smd[7] = h8, smd[8] = v1 smd[14] = v7
0280       south_smd[j - 32] = max_adc - baseline;
0281       h2_SouthSMD_cut_->Fill(max_t, south_smd[j - 32]);
0282       h1_SouthSMD_adc_->Fill(south_smd[j - 32]);
0283       h1_SouthSMD_adc_origin_->Fill(max_adc);
0284       h1_SouthSMD_adc_ped_->Fill(baseline);
0285     }
0286     if (j > 47 && j < 50)
0287     {
0288       float max_adc = -99999;
0289       float max_t = -1;
0290       int time_min = 7;
0291       int time_max = 12;
0292       for (int s = time_min; s < time_max + 1; s++)
0293       {
0294         float temp = p->iValue(s, it->first);
0295         if (max_adc < temp)
0296         {
0297           max_adc = temp;
0298           max_t = s;
0299         }
0300       }
0301       north_veto[j - 48] = max_adc - baseline;
0302       h2_NorthVeto_cut_->Fill(max_t, max_adc - baseline);
0303       h1_NorthVeto_adc_->Fill(max_adc-baseline);
0304       h1_NorthVeto_adc_origin_->Fill(max_adc);
0305       h1_NorthVeto_adc_ped_->Fill(baseline);
0306     }
0307     if (j > 49 && j < 52)
0308     {
0309       float max_adc = -99999;
0310       float max_t = -1;
0311       int time_min = 6;
0312       int time_max = 8;
0313       for (int s = time_min; s < time_max + 1; s++)
0314       {
0315         float temp = p->iValue(s, it->first);
0316         if (max_adc < temp)
0317         {
0318           max_adc = temp;
0319           max_t = s;
0320         }
0321       }
0322 
0323       south_veto[j - 50] = max_adc - baseline;
0324       h2_SouthVeto_cut_->Fill(max_t, max_adc - baseline);
0325       h1_SouthVeto_adc_->Fill(max_adc - baseline);
0326       h1_SouthVeto_adc_origin_->Fill(max_adc);
0327       h1_SouthVeto_adc_ped_->Fill(baseline);
0328     }
0329   }
0330   // North side
0331   h1_NorthZDC1_adc_->Fill(north_zdc[0]);
0332   h1_NorthZDC2_adc_->Fill(north_zdc[1]);
0333   h1_NorthZDC3_adc_->Fill(north_zdc[2]);
0334   if (north_zdc[0] > 100 && north_zdc[1] > 15 && north_veto[0]<150 && north_veto[1] < 150)
0335  // if (north_zdc[0] > 100 && north_zdc[1] > 75)
0336   {
0337     if (north_smd[8] > cut_value_ && north_smd[9] > cut_value_) // v1 v2 Left
0338     {
0339       h1_NorthSMD_Vertical_12_->Fill(bunchNum_);
0340     }
0341     if (north_smd[13] > cut_value_ && north_smd[14] > cut_value_) // v6 v7 Right
0342     {
0343       h1_NorthSMD_Vertical_67_->Fill(bunchNum_);
0344     }
0345     if (north_smd[0] > cut_value_ && north_smd[1] > cut_value_) // h1 h2 bottom
0346     {
0347       h1_NorthSMD_Horizontal_12_->Fill(bunchNum_);
0348     }
0349     if (north_smd[6] > cut_value_ && north_smd[7] > cut_value_) // h7 h8 top
0350     {
0351       h1_NorthSMD_Horizontal_78_->Fill(bunchNum_);
0352     }
0353   }
0354   
0355   h1_SouthZDC1_adc_->Fill(south_zdc[0]);
0356   h1_SouthZDC2_adc_->Fill(south_zdc[1]);
0357   h1_SouthZDC3_adc_->Fill(south_zdc[2]);
0358   if (south_zdc[0] > 100 && south_zdc[1] > 15 && south_veto[0]<150 && south_veto[1]<150)
0359   //if (south_zdc[0] > 100 && south_zdc[1] > 75)
0360   {
0361     if (south_smd[8] > cut_value_ && south_smd[9] > cut_value_) // v1 v2 Left
0362     {
0363       h1_SouthSMD_Vertical_12_->Fill(bunchNum_);
0364     }
0365     if (south_smd[13] > cut_value_ && south_smd[14] > cut_value_) // v6 v7 Right
0366     {
0367       h1_SouthSMD_Vertical_67_->Fill(bunchNum_);
0368     }
0369     if (south_smd[0] > cut_value_ && south_smd[1] > cut_value_) // h1 h2 Bottom
0370     {
0371       h1_SouthSMD_Horizontal_12_->Fill(bunchNum_);
0372     }
0373     if (south_smd[6] > cut_value_ && south_smd[7] > cut_value_) // h7 h8 Top
0374     {
0375       h1_SouthSMD_Horizontal_78_->Fill(bunchNum_);
0376     }
0377   }
0378   event_counter_++;
0379   return Fun4AllReturnCodes::EVENT_OK;
0380 }
0381 
0382 //____________________________________________________________________________..
0383 int ZdcSmdCount::ResetEvent(PHCompositeNode *topNode)
0384 {
0385   if (Verbosity() > 5)
0386   {
0387     std::cout << "ZdcSmdCount::ResetEvent(PHCompositeNode *topNode) Resetting internal structures, prepare for next event" << std::endl;
0388   }
0389   return Fun4AllReturnCodes::EVENT_OK;
0390 }
0391 
0392 //____________________________________________________________________________..
0393 int ZdcSmdCount::EndRun(const int runnumber)
0394 {
0395   std::cout << "ZdcSmdCount::EndRun(const int runnumber) Ending Run for Run " << runnumber << std::endl;
0396   return Fun4AllReturnCodes::EVENT_OK;
0397 }
0398 
0399 //____________________________________________________________________________..
0400 int ZdcSmdCount::End(PHCompositeNode *topNode)
0401 {
0402 
0403   std::cout << "ZdcSmdCount::End(PHCompositeNode *topNode) This is the End..." << std::endl;
0404   outfile_->Write(); 
0405   outfile_->Close(); 
0406   return Fun4AllReturnCodes::EVENT_OK;
0407 }
0408 
0409 //____________________________________________________________________________..
0410 int ZdcSmdCount::Reset(PHCompositeNode *topNode)
0411 {
0412  std::cout << "ZdcSmdCount::Reset(PHCompositeNode *topNode) being Reset" << std::endl;
0413   return Fun4AllReturnCodes::EVENT_OK;
0414 }
0415 
0416 //____________________________________________________________________________..
0417 void ZdcSmdCount::Print(const std::string &what) const
0418 {
0419   if (Verbosity() > 5)
0420   {
0421     std::cout << "ZdcSmdCount::Print(const std::string &what) const Printing info for " << what << std::endl;
0422   }
0423 }
0424 void ZdcSmdCount::SetZDCAdcCut(unsigned int side, unsigned int module, float value)
0425 {
0426   //not used 
0427   if (side < kSide_num_ && module < kZdc_num_)
0428     zdc_adc_cut_[side][module] = value;
0429   else
0430   {
0431     std::cout << "ZdcSmdCount::setZdcAdcCut : side value is unsuitable! Use default value.. " << std::endl;
0432   }
0433 }
0434 
0435 void ZdcSmdCount::GetSpinPatterns()
0436 {
0437   // Get the spin patterns from the spin DB
0438 
0439   //  0xffff is the qa_level from XingShiftCal //////
0440   unsigned int qa_level = 0xffff;
0441   SpinDBContent spin_cont;
0442   SpinDBOutput spin_out("phnxrc");
0443   runNum = runnumber_;
0444   spin_out.StoreDBContent(runNum, runNum, qa_level);
0445   spin_out.GetDBContentStore(spin_cont, runNum);
0446 
0447   // Get crossing shift
0448   crossingShift = spin_cont.GetCrossingShift();
0449   std::cout << "Crossing shift: " << crossingShift << std::endl;
0450 
0451   std::cout << "Blue spin pattern: [";
0452   for (int i = 0; i < 120; i++)
0453   {
0454     spinPatternBlue[i] = spin_cont.GetSpinPatternBlue(i);
0455     std::cout << spinPatternBlue[i];
0456     if (i < 119)
0457       std::cout << ", ";
0458   }
0459   std::cout << "]" << std::endl;
0460 
0461   std::cout << "Yellow spin pattern: [";
0462   for (int i = 0; i < 120; i++)
0463   {
0464     spinPatternYellow[i] = spin_cont.GetSpinPatternYellow(i);
0465     std::cout << spinPatternYellow[i];
0466     if (i < 119)
0467       std::cout << ", ";
0468   }
0469   std::cout << "]" << std::endl;
0470 
0471   if (false)
0472   {
0473     // for testing -- if we couldn't find the spin pattern, fill it with a dummy pattern
0474     // +-+-+-+- ...
0475     std::cout << "Could not find spin pattern packet for blue beam! Using dummy pattern" << std::endl;
0476     for (int i = 0; i < NBUNCHES; i++)
0477     {
0478       int mod = i % 2;
0479       if (mod == 0)
0480         spinPatternBlue[i] = 1;
0481       else
0482         spinPatternBlue[i] = -1;
0483     }
0484     // for testing -- if we couldn't find the spin pattern, fill it with a dummy pattern
0485     // ++--++-- ,,,
0486     std::cout << "Could not find spin pattern packet for yellow beam! Using dummy pattern" << std::endl;
0487     for (int i = 0; i < NBUNCHES; i++)
0488     {
0489       int mod = i % 4;
0490       if (mod == 0 || mod == 1)
0491         spinPatternYellow[i] = 1;
0492       else
0493         spinPatternYellow[i] = -1;
0494     }
0495   }
0496 }
0497 
0498 void ZdcSmdCount::InitHist()
0499 {
0500   h1_NorthSMD_Vertical_12_ = new TH1I("h1_NSMD_v_12", "h1_NSMD_v_12", 128, 0, 128);
0501   h1_NorthSMD_Vertical_67_ = new TH1I("h1_NSMD_v_67", "h1_NSMD_v_67", 128, 0, 128);
0502   h1_NorthSMD_Horizontal_12_ = new TH1I("h1_NSMD_h_12", "h1_NSMD_h_12", 128, 0, 128);
0503   h1_NorthSMD_Horizontal_78_ = new TH1I("h1_NSMD_h_78", "h1_NSMD_h_78", 128, 0, 128);
0504 
0505   h1_SouthSMD_Vertical_12_ = new TH1I("h1_SSMD_v_12", "h1_SSMD_v_12", 128, 0, 128);
0506   h1_SouthSMD_Vertical_67_ = new TH1I("h1_SSMD_v_67", "h1_SSMD_v_67", 128, 0, 128);
0507   h1_SouthSMD_Horizontal_12_ = new TH1I("h1_SSMD_h_12", "h1_SSMD_h_12", 128, 0, 128);
0508   h1_SouthSMD_Horizontal_78_ = new TH1I("h1_SSMD_h_78", "h1_SSMD_h_78", 128, 0, 128);
0509 
0510   h1_NorthZDC_adc_ = new TH1D("h1_NZDC_adc", "h1_NZDC_adc", 200, 0, 500);
0511   h1_SouthZDC_adc_ = new TH1D("h1_SZDC_adc", "h1_SZDC_adc", 200, 0, 500);
0512   h1_NorthZDC_adc_origin_ = new TH1D("h1_NZDC_adc_or", "h1_NZDC_adc_or", 2000, 0, 5000);
0513   h1_SouthZDC_adc_origin_ = new TH1D("h1_SZDC_adc_or", "h1_SZDC_adc_or", 2000, 0, 5000);
0514   h1_NorthZDC_adc_ped_ = new TH1D("h1_NZDC_adc_ped", "h1_NZDC_adc_ped", 2000, 0, 5000);
0515   h1_SouthZDC_adc_ped_ = new TH1D("h1_SZDC_adc_ped", "h1_SZDC_adc_ped", 2000, 0, 5000);
0516   h1_NorthZDC1_adc_ = new TH1D("h1_NZDC1_adc", "h1_NZDC1_adc", 200, 0, 500);
0517   h1_SouthZDC1_adc_ = new TH1D("h1_SZDC1_adc", "h1_SZDC1_adc", 200, 0, 500);
0518   h1_NorthZDC2_adc_ = new TH1D("h1_NZDC2_adc", "h1_NZDC2_adc", 200, 0, 500);
0519   h1_SouthZDC2_adc_ = new TH1D("h1_SZDC2_adc", "h1_SZDC2_adc", 200, 0, 500);
0520   h1_NorthZDC3_adc_ = new TH1D("h1_NZDC3_adc", "h1_NZDC3_adc", 200, 0, 500);
0521   h1_SouthZDC3_adc_ = new TH1D("h1_SZDC3_adc", "h1_SZDC3_adc", 200, 0, 500);
0522   
0523   
0524   h1_NorthSMD_adc_ = new TH1D("h1_NSMD_adc", "h1_NSMD_adc", 200, 0, 500);
0525   h1_SouthSMD_adc_ = new TH1D("h1_SSMD_adc", "h1_SSMD_adc", 200, 0, 500);
0526   h1_NorthSMD_adc_origin_ = new TH1D("h1_NSMD_adc_or", "h1_NSMD_adc_or", 2000, 0, 5000);
0527   h1_SouthSMD_adc_origin_ = new TH1D("h1_SSMD_adc_or", "h1_SSMD_adc_or", 2000, 0, 5000);
0528   h1_NorthSMD_adc_ped_ = new TH1D("h1_NSMD_adc_ped", "h1_NSMD_adc_ped", 2000, 0, 5000);
0529   h1_SouthSMD_adc_ped_ = new TH1D("h1_SSMD_adc_ped", "h1_SSMD_adc_ped", 2000, 0, 5000);
0530   h2_SouthZDC_ = new TH2F("h2_SouthZDC", "h2_SouthZDC", 19, -0.5, 18.5, 512, -500, 16000);
0531   h2_NorthZDC_ = new TH2F("h2_NorthZDC", "h2_NorthZDC", 19, -0.5, 18.5, 512, -500, 16000);
0532   h2_SouthSMD_ = new TH2F("h2_SouthSMD", "h2_SouthSMD", 19, -0.5, 18.5, 512, -500, 16000);
0533   h2_NorthSMD_ = new TH2F("h2_NorthSMD", "h2_NorthSMD", 19, -0.5, 18.5, 512, -500, 16000);
0534   h2_SouthVeto_ = new TH2F("h2_SouthVeto", "h2_SouthVeto", 19, -0.5, 18.5, 512, -500, 16000);
0535   h2_NorthVeto_ = new TH2F("h2_NorthVeto", "h2_NorthVeto", 19, -0.5, 18.5, 512, -500, 16000);
0536   h1_SouthVeto_adc_ = new TH1D("h1_SouthVeto_adc", "h1_SouthVeto_adc", 512, -500, 16000);
0537   h1_NorthVeto_adc_ = new TH1D("h1_NorthVeto_adc", "h1_NorthVeto_adc", 512, -500, 16000);
0538   h1_SouthVeto_adc_origin_ = new TH1D("h1_SouthVeto_adc_or", "h1_SouthVeto_or", 512, -500, 16000);
0539   h1_NorthVeto_adc_origin_ = new TH1D("h1_NorthVeto_adc_or", "h1_NorthVeto_or", 512, -500, 16000);
0540   h1_SouthVeto_adc_ped_ = new TH1D("h1_SouthVeto_adc_ped", "h1_SouthVeto_ped", 512, -500, 16000);
0541   h1_NorthVeto_adc_ped_ = new TH1D("h1_NorthVeto_adc_ped", "h1_NorthVeto_ped", 512, -500, 16000);
0542   h2_SouthZDC_cut_ = new TH2F("h2_SouthZDC_cut", "h2_SouthZDC_cut", 19, -0.5, 18.5, 512, -500, 16000);
0543   h2_NorthZDC_cut_ = new TH2F("h2_NorthZDC_cut", "h2_NorthZDC_cut", 19, -0.5, 18.5, 512, -500, 16000);
0544   h2_SouthSMD_cut_ = new TH2F("h2_SouthSMD_cut", "h2_SouthSMD_cut", 19, -0.5, 18.5, 512, -500, 16000);
0545   h2_NorthSMD_cut_ = new TH2F("h2_NorthSMD_cut", "h2_NorthSMD_cut", 19, -0.5, 18.5, 512, -500, 16000);
0546   h2_SouthVeto_cut_ = new TH2F("h2_SouthVeto_cut", "h2_SouthVeto_cut", 19, -0.5, 18.5, 512, -500, 16000);
0547   h2_NorthVeto_cut_ = new TH2F("h2_NorthVeto_cut", "h2_NorthVeto_cut", 19, -0.5, 18.5, 512, -500, 16000);
0548 }
[ 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!