macros/StreamingProduction/Fun4All_Stream_Combiner.C

0001 #include <GlobalVariables.C>
0002
0003 #include <Trkr_TpcReadoutInit.C>
0004
0005 #include <ffarawmodules/InttCheck.h>
0006 #include <ffarawmodules/StreamingCheck.h>
0007 #include <ffarawmodules/TpcCheck.h>
0008
0009 #include <ffamodules/FlagHandler.h>
0010 #include <ffamodules/HeadReco.h>
0011 #include <ffamodules/SyncReco.h>
0012
0013 #include <fun4allraw/Fun4AllStreamingInputManager.h>
0014 #include <fun4allraw/InputManagerType.h>
0015 #include <fun4allraw/SingleGl1PoolInput.h>
0016 #include <fun4allraw/SingleInttEventInput.h>
0017 #include <fun4allraw/SingleInttPoolInput.h>
0018 #include <fun4allraw/SingleMicromegasPoolInput.h>
0019 #include <fun4allraw/SingleMvtxPoolInput.h>
0020 #include <fun4allraw/SingleTpcPoolInput.h>
0021
0022 #include <fun4all/Fun4AllDstOutputManager.h>
0023 #include <fun4all/Fun4AllInputManager.h>
0024 #include <fun4all/Fun4AllOutputManager.h>
0025 #include <fun4all/Fun4AllServer.h>
0026 #include <fun4all/Fun4AllUtils.h>
0027
0028 #include <phool/recoConsts.h>
0029
0030 #include <Rtypes.h>  // resolves R__LOAD_LIBRARY for clang-tidy
0031 #include <TSystem.h>
0032
0033 #include <fstream>
0034
0035 R__LOAD_LIBRARY(libfun4all.so)
0036 R__LOAD_LIBRARY(libffamodules.so)
0037 R__LOAD_LIBRARY(libfun4allraw.so)
0038 R__LOAD_LIBRARY(libffarawmodules.so)
0039 R__LOAD_LIBRARY(libintt.so)
0040
0041 bool isGood(const std::string &infile);
0042 int getrunnumber(const std::string &listfile);
0043
0044 void Fun4All_Stream_Combiner(int nEvents = 5,
0045                              const std::string &input_gl1file = "gl1daq.list",
0046                              const std::string &input_inttfile00 = "intt0.list",
0047                              const std::string &input_inttfile01 = "intt1.list",
0048                              const std::string &input_inttfile02 = "intt2.list",
0049                              const std::string &input_inttfile03 = "intt3.list",
0050                              const std::string &input_inttfile04 = "intt4.list",
0051                              const std::string &input_inttfile05 = "intt5.list",
0052                              const std::string &input_inttfile06 = "intt6.list",
0053                              const std::string &input_inttfile07 = "intt7.list",
0054                              const std::string &input_mvtxfile00 = "mvtx0.list",
0055                              const std::string &input_mvtxfile01 = "mvtx1.list",
0056                              const std::string &input_mvtxfile02 = "mvtx2.list",
0057                              const std::string &input_mvtxfile03 = "mvtx3.list",
0058                              const std::string &input_mvtxfile04 = "mvtx4.list",
0059                              const std::string &input_mvtxfile05 = "mvtx5.list",
0060                              const std::string &input_tpcfile00 = "tpc00.list",
0061                              const std::string &input_tpcfile01 = "tpc01.list",
0062                              const std::string &input_tpcfile02 = "tpc02.list",
0063                              const std::string &input_tpcfile03 = "tpc03.list",
0064                              const std::string &input_tpcfile04 = "tpc04.list",
0065                              const std::string &input_tpcfile05 = "tpc05.list",
0066                              const std::string &input_tpcfile06 = "tpc06.list",
0067                              const std::string &input_tpcfile07 = "tpc07.list",
0068                              const std::string &input_tpcfile08 = "tpc08.list",
0069                              const std::string &input_tpcfile09 = "tpc09.list",
0070                              const std::string &input_tpcfile10 = "tpc10.list",
0071                              const std::string &input_tpcfile11 = "tpc11.list",
0072                              const std::string &input_tpcfile12 = "tpc12.list",
0073                              const std::string &input_tpcfile13 = "tpc13.list",
0074                              const std::string &input_tpcfile14 = "tpc14.list",
0075                              const std::string &input_tpcfile15 = "tpc15.list",
0076                              const std::string &input_tpcfile16 = "tpc16.list",
0077                              const std::string &input_tpcfile17 = "tpc17.list",
0078                              const std::string &input_tpcfile18 = "tpc18.list",
0079                              const std::string &input_tpcfile19 = "tpc19.list",
0080                              const std::string &input_tpcfile20 = "tpc20.list",
0081                              const std::string &input_tpcfile21 = "tpc21.list",
0082                              const std::string &input_tpcfile22 = "tpc22.list",
0083                              const std::string &input_tpcfile23 = "tpc23.list",
0084                              const std::string &input_tpotfile = "tpot.list")
0085 {
0086   // GL1 which provides the beam clock reference (if we ran with GL1)
0087   std::vector<std::string> gl1_infile;
0088   gl1_infile.push_back(input_gl1file);
0089
0090   // MVTX
0091   std::vector<std::string> mvtx_infile;
0092   mvtx_infile.push_back(input_mvtxfile00);
0093   mvtx_infile.push_back(input_mvtxfile01);
0094   mvtx_infile.push_back(input_mvtxfile02);
0095   mvtx_infile.push_back(input_mvtxfile03);
0096   mvtx_infile.push_back(input_mvtxfile04);
0097   mvtx_infile.push_back(input_mvtxfile05);
0098
0099   // INTT
0100   std::vector<std::string> intt_infile;
0101   intt_infile.push_back(input_inttfile00);
0102   intt_infile.push_back(input_inttfile01);
0103   intt_infile.push_back(input_inttfile02);
0104   intt_infile.push_back(input_inttfile03);
0105   intt_infile.push_back(input_inttfile04);
0106   intt_infile.push_back(input_inttfile05);
0107   intt_infile.push_back(input_inttfile06);
0108   intt_infile.push_back(input_inttfile07);
0109
0110   std::vector<std::string> tpc_infile;
0111   tpc_infile.push_back(input_tpcfile00);
0112   tpc_infile.push_back(input_tpcfile01);
0113   tpc_infile.push_back(input_tpcfile02);
0114   tpc_infile.push_back(input_tpcfile03);
0115   tpc_infile.push_back(input_tpcfile04);
0116   tpc_infile.push_back(input_tpcfile05);
0117   tpc_infile.push_back(input_tpcfile06);
0118   tpc_infile.push_back(input_tpcfile07);
0119   tpc_infile.push_back(input_tpcfile08);
0120   tpc_infile.push_back(input_tpcfile09);
0121   tpc_infile.push_back(input_tpcfile10);
0122   tpc_infile.push_back(input_tpcfile11);
0123   tpc_infile.push_back(input_tpcfile12);
0124   tpc_infile.push_back(input_tpcfile13);
0125   tpc_infile.push_back(input_tpcfile14);
0126   tpc_infile.push_back(input_tpcfile15);
0127   tpc_infile.push_back(input_tpcfile16);
0128   tpc_infile.push_back(input_tpcfile17);
0129   tpc_infile.push_back(input_tpcfile18);
0130   tpc_infile.push_back(input_tpcfile19);
0131   tpc_infile.push_back(input_tpcfile20);
0132   tpc_infile.push_back(input_tpcfile21);
0133   tpc_infile.push_back(input_tpcfile22);
0134   tpc_infile.push_back(input_tpcfile23);
0135
0136   // TPOT
0137   std::vector<std::string> tpot_infile;
0138   tpot_infile.push_back(input_tpotfile);
0139
0140   int runnumber = -99999;
0141   if (!gl1_infile.empty())
0142   {
0143     runnumber = getrunnumber(gl1_infile[0]);
0144   }
0145   else if (!mvtx_infile.empty())
0146   {
0147     runnumber = getrunnumber(mvtx_infile[0]);
0148   }
0149   else if (!intt_infile.empty())
0150   {
0151     runnumber = getrunnumber(intt_infile[0]);
0152   }
0153   else if (!tpc_infile.empty())
0154   {
0155     runnumber = getrunnumber(tpc_infile[0]);
0156   }
0157   else if (!tpot_infile.empty())
0158   {
0159     runnumber = getrunnumber(tpot_infile[0]);
0160   }
0161   if (runnumber == -99999)
0162   {
0163     std::cout << "could not extract run number from input files (all lists empty?)"
0164               << std::endl;
0165     gSystem->Exit(1);
0166   }
0167
0168   TpcSampleInit(runnumber);
0169   std::cout << " run: " << runnumber
0170             << " samples: " << TRACKING::reco_tpc_maxtime_sample
0171             << " pre: " << TRACKING::reco_tpc_time_presample
0172             << std::endl;
0173
0174   Fun4AllServer *se = Fun4AllServer::instance();
0175   se->Verbosity(1);
0176
0177   Fun4AllStreamingInputManager *in = new Fun4AllStreamingInputManager("Comb");
0178   //  in->Verbosity(3);
0179
0180   // create and register input managers
0181   int NumInputs = 0;
0182   int i = 0;
0183
0184   for (const auto &iter : gl1_infile)
0185   {
0186     if (isGood(iter))
0187     {
0188       SingleGl1PoolInput *gl1_sngl = new SingleGl1PoolInput("GL1_" + std::to_string(i));
0189       //    gl1_sngl->Verbosity(3);
0190       gl1_sngl->AddListFile(iter);
0191       in->registerStreamingInput(gl1_sngl, InputManagerType::GL1);
0192       i++;
0193     }
0194   }
0195   NumInputs += i;
0196
0197   i = 0;
0198   for (const auto &iter : intt_infile)
0199   {
0200     if (isGood(iter))
0201     {
0202       std::cout << "opening file " << iter << std::endl;
0203       SingleInttPoolInput *intt_sngl = new SingleInttPoolInput("INTT_" + std::to_string(i));
0204       //    intt_sngl->Verbosity(3);
0205       intt_sngl->AddListFile(iter);
0206       in->registerStreamingInput(intt_sngl, InputManagerType::INTT);
0207       i++;
0208     }
0209   }
0210   NumInputs += i;
0211
0212   i = 0;
0213   for (const auto &iter : mvtx_infile)
0214   {
0215     if (isGood(iter))
0216     {
0217       SingleMvtxPoolInput *mvtx_sngl = new SingleMvtxPoolInput("MVTX_" + std::to_string(i));
0218       // mvtx_sngl->Verbosity(5);
0219       mvtx_sngl->AddListFile(iter);
0220       in->registerStreamingInput(mvtx_sngl, InputManagerType::MVTX);
0221       i++;
0222     }
0223   }
0224   NumInputs += i;
0225
0226   i = 0;
0227   for (const auto &iter : tpc_infile)
0228   {
0229     if (isGood(iter))
0230     {
0231       SingleTpcPoolInput *tpc_sngl = new SingleTpcPoolInput("TPC_" + std::to_string(i));
0232       //    tpc_sngl->Verbosity(2);
0233       //   tpc_sngl->DryRun();
0234       tpc_sngl->SetBcoRange(5);
0235       tpc_sngl->AddListFile(iter);
0236       //    tpc_sngl->SetMaxTpcTimeSamples(TRACKING::reco_tpc_maxtime_sample);
0237       tpc_sngl->SetMaxTpcTimeSamples(1024);
0238       in->registerStreamingInput(tpc_sngl, InputManagerType::TPC);
0239       i++;
0240     }
0241   }
0242   NumInputs += i;
0243
0244   i = 0;
0245   for (const auto &iter : tpot_infile)
0246   {
0247     if (isGood(iter))
0248     {
0249       SingleMicromegasPoolInput *mm_sngl = new SingleMicromegasPoolInput("MICROMEGAS_" + std::to_string(i));
0250       //   sngl->Verbosity(3);
0251       mm_sngl->SetBcoRange(10);
0252       mm_sngl->SetNegativeBco(2);
0253       mm_sngl->SetBcoPoolSize(50);
0254       mm_sngl->AddListFile(iter);
0255       in->registerStreamingInput(mm_sngl, InputManagerType::MICROMEGAS);
0256       i++;
0257     }
0258   }
0259   NumInputs += i;
0260
0261   // if there is no input manager this macro will still run - so just quit here
0262   if (NumInputs == 0)
0263   {
0264     std::cout << "no file lists no input manager registered, quitting" << std::endl;
0265     gSystem->Exit(1);
0266   }
0267   se->registerInputManager(in);
0268   // StreamingCheck *scheck = new StreamingCheck();
0269   // scheck->SetTpcBcoRange(130);
0270   // se->registerSubsystem(scheck);
0271   // TpcCheck *tpccheck = new TpcCheck();
0272   // tpccheck->Verbosity(3);
0273   // tpccheck->SetBcoRange(130);
0274   // se->registerSubsystem(tpccheck);
0275   SyncReco *sync = new SyncReco();
0276   se->registerSubsystem(sync);
0277
0278   HeadReco *head = new HeadReco();
0279   se->registerSubsystem(head);
0280
0281   FlagHandler *flag = new FlagHandler();
0282   se->registerSubsystem(flag);
0283   // std::string outdir = "/sphenix/user/pinkenbu";
0284   // std::string outfilename = "./gl1A.root";
0285   // int neventsper = 1;
0286   Fun4AllOutputManager *out = new Fun4AllDstOutputManager("out", "streaming.root");
0287
0288   // Fun4AllOutputManager *out = new Fun4AllDstOutputManager("out",outfilename);
0289   // out->UseFileRule();
0290   // out->SetNEvents(neventsper);                       // number of events per output file
0291   // out->SetClosingScript("stageout.sh");      // script to call on file close (not quite working yet...)
0292   // out->SetClosingScriptArgs(outdir);  // additional beyond the name of the file
0293   se->registerOutputManager(out);
0294
0295   if (nEvents < 0)
0296   {
0297     return;
0298   }
0299   se->run(nEvents);
0300
0301   se->End();
0302   delete se;
0303   std::cout << "all done" << std::endl;
0304   gSystem->Exit(0);
0305 }
0306
0307 bool isGood(const std::string &infile)
0308 {
0309   std::ifstream intest;
0310   intest.open(infile);
0311   bool goodfile = false;
0312   if (intest.is_open())
0313   {
0314     if (intest.peek() != std::ifstream::traits_type::eof())  // is it non zero?
0315     {
0316       goodfile = true;
0317     }
0318     intest.close();
0319   }
0320   return goodfile;
0321 }
0322
0323 int getrunnumber(const std::string &listfile)
0324 {
0325   if (!isGood(listfile))
0326   {
0327     std::cout << "listfile " << listfile << " is bad" << std::endl;
0328     gSystem->Exit(1);
0329   }
0330   std::ifstream ifs(listfile);
0331   std::string filepath;
0332   std::getline(ifs, filepath);
0333
0334   std::pair<int, int> runseg = Fun4AllUtils::GetRunSegment(filepath);
0335   int runnumber = runseg.first;
0336   //  int segment = abs(runseg.second);
0337   return runnumber;
0338 }