Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-11-22 00:47:31

0001 #include "RecoTracker/MkFitCore/src/Matriplex/MatriplexCommon.h"
0002 
0003 // CCCC #include "fittestMPlex.h"
0004 #include "RecoTracker/MkFitCMS/standalone/buildtestMPlex.h"
0005 
0006 #include "RecoTracker/MkFitCore/interface/HitStructures.h"
0007 #include "RecoTracker/MkFitCore/interface/MkBuilder.h"
0008 #include "RecoTracker/MkFitCore/src/MkFitter.h"
0009 #include "RecoTracker/MkFitCMS/interface/MkStdSeqs.h"
0010 #include "RecoTracker/MkFitCMS/standalone/MkStandaloneSeqs.h"
0011 
0012 #include "RecoTracker/MkFitCore/interface/Config.h"
0013 #include "RecoTracker/MkFitCore/standalone/ConfigStandalone.h"
0014 
0015 #include "RecoTracker/MkFitCore/standalone/Event.h"
0016 
0017 #include "RecoTracker/MkFitCore/src/MaterialEffects.h"
0018 
0019 #ifndef NO_ROOT
0020 #include "RecoTracker/MkFitCore/standalone/Validation.h"
0021 #endif
0022 
0023 //#define DEBUG
0024 #include "RecoTracker/MkFitCore/src/Debug.h"
0025 
0026 #include "oneapi/tbb/task_arena.h"
0027 #include "oneapi/tbb/parallel_for.h"
0028 
0029 #if defined(USE_VTUNE_PAUSE)
0030 #include "ittnotify.h"
0031 #endif
0032 
0033 #include <cstdlib>
0034 #include <limits>
0035 #include <list>
0036 #include <sstream>
0037 #include <memory>
0038 
0039 using namespace mkfit;
0040 
0041 //==============================================================================
0042 
0043 void initGeom() {
0044   std::cout << "Constructing geometry '" << Config::geomPlugin << "'\n";
0045 
0046   // NB: we currently assume that each node is a layer, and that layers
0047   // are added starting from the center
0048   // NB: z is just a dummy variable, VUSolid is actually infinite in size.  *** Therefore, set it to the eta of simulation ***
0049 
0050   /*
0051   // Test CMSSW loading
0052   IterationsInfo ii;
0053   unsigned int algorithms[]={ 4,22,23,5,24,7,8,9,10,6 }; // 10 iterations
0054   ii.resize(10);
0055   for (int i = 0; i < 10; ++i) {
0056       ii[i].m_track_algorithm = algorithms[i];
0057   }
0058   auto xx = configJson_Load_File(ii, "mkfit-phase1-initialStep.json");
0059   printf("%d\n", xx->m_iteration_index);
0060   */
0061 
0062   mkfit::execTrackerInfoCreatorPlugin(Config::geomPlugin, Config::TrkInfo, Config::ItrInfo);
0063 
0064   ConfigJson cj(Config::json_verbose);
0065 
0066   if (Config::json_dump_before)
0067     cj.dump(Config::ItrInfo);
0068 
0069   if (!Config::json_load_filenames.empty()) {
0070     ConfigJsonPatcher::PatchReport report;
0071 
0072     for (auto& fn : Config::json_load_filenames) {
0073       // This is for testing only ... we drop the loaded IterationConfig
0074       // as further code will always use IterationsInfo[ iter_index ].
0075       cj.patchLoad_File(Config::ItrInfo, fn, &report);
0076     }
0077 
0078     printf(
0079         "mkFit.cc/%s--JSON-Load read %d JSON entities from %d files, replaced %d parameters.\n"
0080         "   NOTE that these changes were NOT APPLIED to actual configuration that is going to be used.\n",
0081         __func__,
0082         report.n_json_entities,
0083         report.n_files,
0084         report.n_replacements);
0085   }
0086 
0087   if (!Config::json_patch_filenames.empty()) {
0088     ConfigJsonPatcher::PatchReport report;
0089 
0090     cj.patch_Files(Config::ItrInfo, Config::json_patch_filenames, &report);
0091 
0092     printf("mkFit.cc/%s--JOSN-Patch read %d JSON entities from %d files, replaced %d parameters.\n",
0093            __func__,
0094            report.n_json_entities,
0095            report.n_files,
0096            report.n_replacements);
0097   }
0098 
0099   if (Config::json_dump_after)
0100     cj.dump(Config::ItrInfo);
0101 
0102   if (!Config::json_save_iters_fname_fmt.empty()) {
0103     cj.save_Iterations(
0104         Config::ItrInfo, Config::json_save_iters_fname_fmt, Config::json_save_iters_include_iter_info_preamble);
0105   }
0106 
0107   Config::ItrInfo.setupStandardFunctionsFromNames();
0108 
0109   // Test functions for ConfigJsonPatcher
0110   // cj.test_Direct (Config::ItrInfo[0]);
0111   // cj.test_Patcher(Config::ItrInfo[0]);
0112 }
0113 
0114 namespace {
0115   int g_start_event = 1;
0116 
0117   bool g_run_fit_std = false;
0118 
0119   bool g_run_build_all = true;
0120   bool g_run_build_cmssw = false;
0121   bool g_run_build_bh = false;
0122   bool g_run_build_std = false;
0123   bool g_run_build_ce = false;
0124   bool g_run_build_mimi = false;
0125 
0126   std::string g_operation = "simulate_and_process";
0127   ;
0128   std::string g_input_file = "";
0129   std::string g_output_file = "";
0130 
0131   seedOptsMap g_seed_opts;
0132   void init_seed_opts() {
0133     g_seed_opts["sim"] = {simSeeds, "Use simtracks for seeds"};
0134     g_seed_opts["cmssw"] = {cmsswSeeds, "Use external CMSSW seeds"};
0135     g_seed_opts["find"] = {findSeeds, "Use mplex seed finder for seeds"};
0136   }
0137 
0138   cleanOptsMap g_clean_opts;
0139   void init_clean_opts() {
0140     g_clean_opts["none"] = {noCleaning, "No cleaning applied to external CMSSW seeds"};
0141     g_clean_opts["n2"] = {cleanSeedsN2, "Apply N^2 cleaning by Mario to external CMSSW seeds"};
0142     g_clean_opts["pure"] = {
0143         cleanSeedsPure,
0144         "Only use external CMSSW seeds that have produced a CMSSW track \n    must enable: --read-cmssw-tracks"};
0145     g_clean_opts["badlabel"] = {cleanSeedsBadLabel, "Remove seeds with label()<0 in external CMSSW seeds"};
0146   }
0147 
0148   matchOptsMap g_match_opts;
0149   void init_match_opts() {
0150     g_match_opts["trkparam"] = {trkParamBased,
0151                                 "Use track parameter-based matching for validating against CMSSW tracks"};
0152     g_match_opts["hits"] = {hitBased, "Use hit-based matching for validating against CMSSW tracks"};
0153     g_match_opts["label"] = {labelBased, "Only allowed with pure seeds: stricter hit-based matching"};
0154   }
0155 
0156   const char* b2a(bool b) { return b ? "true" : "false"; }
0157 
0158   std::vector<DeadVec> deadvectors;
0159 
0160   void init_deadvectors() {
0161     deadvectors.resize(Config::TrkInfo.n_layers());
0162 #include "RecoTracker/MkFitCMS/standalone/deadmodules.h"
0163   }
0164 
0165 }  // namespace
0166 
0167 //==============================================================================
0168 
0169 // Getters and setters of enum configs (from command line using anon. namespace above)
0170 
0171 template <typename T, typename U>
0172 std::string getOpt(const T& c_opt, const U& g_opt_map) {
0173   static const std::string empty("");
0174 
0175   for (const auto& g_opt_pair : g_opt_map) {
0176     if (g_opt_pair.second.first == c_opt)
0177       return g_opt_pair.first;
0178   }
0179   std::cerr << "No match for option " << c_opt << std::endl;
0180   return empty;
0181 }
0182 
0183 template <typename T, typename U>
0184 void setOpt(const std::string& cmd_ln_str, T& c_opt, const U& g_opt_map, const std::string& ex_txt) {
0185   if (g_opt_map.count(cmd_ln_str))
0186     c_opt = g_opt_map.at(cmd_ln_str).first;
0187   else {
0188     std::cerr << cmd_ln_str << " is not a valid " << ex_txt << " option!! Exiting..." << std::endl;
0189     exit(1);
0190   }
0191 }
0192 
0193 template <typename U>
0194 void listOpts(const U& g_opt_map) {
0195   for (const auto& g_opt_pair : g_opt_map) {
0196     std::cout << "  " << g_opt_pair.first.c_str() << " : " << g_opt_pair.second.second.c_str() << std::endl;
0197   }
0198 }
0199 
0200 //==============================================================================
0201 
0202 void test_standard() {
0203   printf("Running test_standard(), operation=\"%s\"\n", g_operation.c_str());
0204   printf("  vusize=%d, num_th_sim=%d, num_th_finder=%d\n",
0205          MPT_SIZE,
0206          Config::numThreadsSimulation,
0207          Config::numThreadsFinder);
0208   printf(
0209       "  sizeof(Track)=%zu, sizeof(Hit)=%zu, sizeof(SVector3)=%zu, sizeof(SMatrixSym33)=%zu, sizeof(MCHitInfo)=%zu\n",
0210       sizeof(Track),
0211       sizeof(Hit),
0212       sizeof(SVector3),
0213       sizeof(SMatrixSym33),
0214       sizeof(MCHitInfo));
0215 
0216   if (Config::seedInput == cmsswSeeds)
0217     printf("- reading seeds from file\n");
0218 
0219   initGeom();
0220   if (Config::useDeadModules) {
0221     init_deadvectors();
0222   }
0223 
0224   if (Config::nEvents <= 0) {
0225     return;
0226   }
0227 
0228   DataFile data_file;
0229   if (g_operation == "read") {
0230     int evs_in_file = data_file.openRead(g_input_file, Config::TrkInfo.n_layers());
0231     int evs_available = evs_in_file - g_start_event + 1;
0232     if (Config::nEvents == -1) {
0233       Config::nEvents = evs_available;
0234     } else if (Config::nEvents > evs_available and not Config::loopOverFile) {
0235       printf("Requested number of events %d, only %d available.\n", Config::nEvents, evs_available);
0236       Config::nEvents = evs_available;
0237     }
0238 
0239     if (g_start_event > 1) {
0240       data_file.skipNEvents(g_start_event - 1);
0241     }
0242   }
0243 
0244   constexpr int NT = 5;
0245   double t_sum[NT] = {0};
0246   double t_skip[NT] = {0};
0247   std::vector<double> t_sum_iter(Config::nItersCMSSW, 0.0);
0248   std::vector<double> t_skip_iter(Config::nItersCMSSW, 0.0);
0249   double time = dtime();
0250 
0251   std::atomic<int> nevt{g_start_event};
0252   std::atomic<int> seedstot{0}, simtrackstot{0}, candstot{0};
0253   std::atomic<int> maxHits_all{0}, maxLayer_all{0};
0254 
0255   MkBuilder::populate();
0256 
0257   std::vector<std::unique_ptr<Event>> evs(Config::numThreadsEvents);
0258   std::vector<std::unique_ptr<Validation>> vals(Config::numThreadsEvents);
0259   std::vector<std::unique_ptr<MkBuilder>> mkbs(Config::numThreadsEvents);
0260   std::vector<std::shared_ptr<EventOfHits>> eohs(Config::numThreadsEvents);
0261   std::vector<std::shared_ptr<FILE>> fps;
0262   fps.reserve(Config::numThreadsEvents);
0263 
0264   const std::string valfile("valtree");
0265 
0266   for (int i = 0; i < Config::numThreadsEvents; ++i) {
0267     std::ostringstream serial;
0268     if (Config::numThreadsEvents > 1) {
0269       serial << "_" << i;
0270     }
0271     vals[i].reset(Validation::make_validation(valfile + serial.str() + ".root", &Config::TrkInfo));
0272     mkbs[i] = MkBuilder::make_builder(Config::silent);
0273     eohs[i].reset(new EventOfHits(Config::TrkInfo));
0274     evs[i].reset(new Event(*vals[i], 0, Config::TrkInfo.n_layers()));
0275     if (g_operation == "read") {
0276       fps.emplace_back(fopen(g_input_file.c_str(), "r"), [](FILE* fp) {
0277         if (fp)
0278           fclose(fp);
0279       });
0280     }
0281   }
0282 
0283   tbb::task_arena arena(Config::numThreadsFinder);
0284 
0285   dprint("parallel_for step size " << (Config::nEvents + Config::numThreadsEvents - 1) / Config::numThreadsEvents);
0286 
0287   time = dtime();
0288 
0289   int events_per_thread = (Config::nEvents + Config::numThreadsEvents - 1) / Config::numThreadsEvents;
0290 
0291   arena.execute([&]() {
0292     tbb::parallel_for(
0293         tbb::blocked_range<int>(0, Config::numThreadsEvents, 1),
0294         [&](const tbb::blocked_range<int>& threads) {
0295           int thisthread = threads.begin();
0296 
0297           assert(threads.begin() == threads.end() - 1 && thisthread < Config::numThreadsEvents);
0298 
0299           // std::vector<Track> plex_tracks;
0300           auto& ev = *evs[thisthread].get();
0301           auto& mkb = *mkbs[thisthread].get();
0302           auto& eoh = *eohs[thisthread].get();
0303           auto fp = fps[thisthread].get();
0304 
0305           int evstart = thisthread * events_per_thread;
0306           int evend = std::min(Config::nEvents, evstart + events_per_thread);
0307 
0308           dprint("thisthread " << thisthread << " events " << Config::nEvents << " events/thread " << events_per_thread
0309                                << " range " << evstart << ":" << evend);
0310 
0311           for (int evt = evstart; evt < evend; ++evt) {
0312             ev.reset(nevt++);
0313 
0314             if (!Config::silent) {
0315               std::lock_guard<std::mutex> printlock(Event::printmutex);
0316               printf("\n");
0317               printf("Processing event %d\n", ev.evtID());
0318             }
0319 
0320             ev.read_in(data_file, fp);
0321 
0322             // skip events with zero seed tracks!
0323             if (ev.seedTracks_.empty())
0324               continue;
0325 
0326             // plex_tracks.resize(ev.simTracks_.size());
0327 
0328             StdSeq::loadHitsAndBeamSpot(ev, eoh);
0329 
0330             if (Config::useDeadModules) {
0331               StdSeq::loadDeads(eoh, deadvectors);
0332             }
0333 
0334             double t_best[NT] = {0}, t_cur[NT] = {0};
0335             std::vector<double> t_cur_iter;
0336             simtrackstot += ev.simTracks_.size();
0337             seedstot += ev.seedTracks_.size();
0338 
0339             int ncands_thisthread = 0;
0340             int maxHits_thisthread = 0;
0341             int maxLayer_thisthread = 0;
0342             for (int b = 0; b < Config::finderReportBestOutOfN; ++b) {
0343               t_cur[0] = 0;  // t_cur[0] = (g_run_fit_std) ? runFittingTestPlex(ev, plex_tracks) : 0;
0344               t_cur[1] = (g_run_build_all || g_run_build_bh) ? runBuildingTestPlexBestHit(ev, eoh, mkb) : 0;
0345               t_cur[3] = (g_run_build_all || g_run_build_ce) ? runBuildingTestPlexCloneEngine(ev, eoh, mkb) : 0;
0346               if (g_run_build_all || g_run_build_mimi)
0347                 t_cur_iter = runBtpCe_MultiIter(ev, eoh, mkb, Config::nItersCMSSW);
0348               t_cur[4] = (g_run_build_all || g_run_build_mimi) ? t_cur_iter[Config::nItersCMSSW] : 0;
0349               if (g_run_build_all || g_run_build_cmssw)
0350                 runBuildingTestPlexDumbCMSSW(ev, eoh, mkb);
0351               t_cur[2] = (g_run_build_all || g_run_build_std) ? runBuildingTestPlexStandard(ev, eoh, mkb) : 0;
0352               if (g_run_build_ce || g_run_build_mimi) {
0353                 ncands_thisthread = mkb.total_cands();
0354                 auto const& ln = mkb.max_hits_layer(eoh);
0355                 maxHits_thisthread = ln.first;
0356                 maxLayer_thisthread = ln.second;
0357               }
0358               for (int i = 0; i < NT; ++i)
0359                 t_best[i] = (b == 0) ? t_cur[i] : std::min(t_cur[i], t_best[i]);
0360 
0361               if (!Config::silent) {
0362                 std::lock_guard<std::mutex> printlock(Event::printmutex);
0363                 if (Config::finderReportBestOutOfN > 1) {
0364                   printf("----------------------------------------------------------------\n");
0365                   printf("Best-of-times:");
0366                   for (int i = 0; i < NT; ++i)
0367                     printf("  %.5f/%.5f", t_cur[i], t_best[i]);
0368                   printf("\n");
0369                 }
0370                 printf("----------------------------------------------------------------\n");
0371               }
0372             }
0373 
0374             candstot += ncands_thisthread;
0375             if (maxHits_thisthread > maxHits_all) {
0376               maxHits_all = maxHits_thisthread;
0377               maxLayer_all = maxLayer_thisthread;
0378             }
0379             if (!Config::silent) {
0380               std::lock_guard<std::mutex> printlock(Event::printmutex);
0381               printf("Matriplex fit = %.5f  --- Build  BHMX = %.5f  STDMX = %.5f  CEMX = %.5f  MIMI = %.5f\n",
0382                      t_best[0],
0383                      t_best[1],
0384                      t_best[2],
0385                      t_best[3],
0386                      t_best[4]);
0387             }
0388 
0389             {
0390               static std::mutex sum_up_lock;
0391               std::lock_guard<std::mutex> locker(sum_up_lock);
0392 
0393               for (int i = 0; i < NT; ++i)
0394                 t_sum[i] += t_best[i];
0395               if (evt > 0)
0396                 for (int i = 0; i < NT; ++i)
0397                   t_skip[i] += t_best[i];
0398               if (g_run_build_all || g_run_build_mimi) {
0399                 for (int i = 0; i < Config::nItersCMSSW; ++i)
0400                   t_sum_iter[i] += t_cur_iter[i];
0401                 if (evt > 0)
0402                   for (int i = 0; i < Config::nItersCMSSW; ++i)
0403                     t_skip_iter[i] += t_cur_iter[i];
0404               }
0405             }
0406           }
0407         },
0408         tbb::simple_partitioner());
0409   });
0410 
0411   time = dtime() - time;
0412 
0413   printf("\n");
0414   printf("================================================================\n");
0415   printf("=== TOTAL for %d events\n", Config::nEvents);
0416   printf("================================================================\n");
0417 
0418   printf("Total Matriplex fit = %.5f  --- Build  BHMX = %.5f  STDMX = %.5f  CEMX = %.5f  MIMI = %.5f\n",
0419          t_sum[0],
0420          t_sum[1],
0421          t_sum[2],
0422          t_sum[3],
0423          t_sum[4]);
0424   printf("Total event > 1 fit = %.5f  --- Build  BHMX = %.5f  STDMX = %.5f  CEMX = %.5f  MIMI = %.5f\n",
0425          t_skip[0],
0426          t_skip[1],
0427          t_skip[2],
0428          t_skip[3],
0429          t_skip[4]);
0430   printf("Total event loop time %.5f simtracks %d seedtracks %d builtcands %d maxhits %d on lay %d\n",
0431          time,
0432          simtrackstot.load(),
0433          seedstot.load(),
0434          candstot.load(),
0435          maxHits_all.load(),
0436          maxLayer_all.load());
0437   //fflush(stdout);
0438   if (g_run_build_all || g_run_build_mimi) {
0439     printf("================================================================\n");
0440     for (int i = 0; i < Config::nItersCMSSW; ++i)
0441       std::cout << " Iteration " << i << " build time = " << t_sum_iter[i] << " \n";
0442     printf("================================================================\n");
0443     for (int i = 0; i < Config::nItersCMSSW; ++i)
0444       std::cout << " Iteration " << i << " build time (event > 1) = " << t_skip_iter[i] << " \n";
0445     printf("================================================================\n");
0446   }
0447   if (g_operation == "read") {
0448     data_file.close();
0449   }
0450 
0451   for (auto& val : vals) {
0452     val->fillConfigTree();
0453     val->saveTTrees();
0454   }
0455 }
0456 
0457 //==============================================================================
0458 // Command line argument parsing
0459 //==============================================================================
0460 
0461 typedef std::list<std::string> lStr_t;
0462 typedef lStr_t::iterator lStr_i;
0463 
0464 bool has_suffix(const std::string& str, const std::string& suffix) {
0465   return str.size() >= suffix.size() && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
0466 }
0467 
0468 void next_arg_or_die(lStr_t& args, lStr_i& i, bool allow_single_minus = false) {
0469   lStr_i j = i;
0470   if (++j == args.end() || has_suffix(*j, ".C") || ((*j)[0] == '-' && !(*j == "-" && allow_single_minus))) {
0471     std::cerr << "Error: option " << *i << " requires an argument.\n";
0472     exit(1);
0473   }
0474   i = j;
0475 }
0476 
0477 //==============================================================================
0478 // main
0479 //==============================================================================
0480 
0481 #include <fenv.h>
0482 
0483 int main(int argc, const char* argv[]) {
0484 #ifdef _GNU_SOURCE
0485   if (Const::nan_etc_sigs_enable) {
0486     feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);  //FE_ALL_EXCEPT);
0487   }
0488 #endif
0489 
0490 #ifdef USE_VTUNE_PAUSE
0491   __itt_pause();
0492 #endif
0493 
0494   assert(sizeof(Track::Status) == 4 &&
0495          "To make sure this is true for icc and gcc<6 when mixing bools/ints in bitfields.");
0496 
0497   // init enum maps
0498   init_seed_opts();
0499   init_clean_opts();
0500   init_match_opts();
0501 
0502   lStr_t mArgs;
0503   for (int i = 1; i < argc; ++i) {
0504     mArgs.push_back(argv[i]);
0505   }
0506 
0507   lStr_i i = mArgs.begin();
0508   while (i != mArgs.end()) {
0509     lStr_i start = i;
0510 
0511     if (*i == "-h" || *i == "-help" || *i == "--help") {
0512       printf(
0513           "\n"
0514           "Usage: %s [options]\n"
0515           "Options: defaults defined as (def: DEFAULT VALUE)\n"
0516           "\n----------------------------------------------------------------------------------------------------------"
0517           "\n\n"
0518           "Generic options\n\n"
0519           "  --geom           <str>   geometry plugin to use (def: %s)\n"
0520           "  --silent                 suppress printouts inside event loop (def: %s)\n"
0521           "  --best-out-of    <int>   run test num times, report best time (def: %d)\n"
0522           "  --input-file             file name for reading (def: %s)\n"
0523           "  --output-file            file name for writitng (def: %s)\n"
0524           "  --read-cmssw-tracks      read external cmssw reco tracks if available (def: %s)\n"
0525           "  --read-simtrack-states   read in simTrackStates for pulls in validation (def: %s)\n"
0526           "  --num-events     <int>   number of events to run over or simulate (def: %d)\n"
0527           "                             if using --input-file, must be enabled AFTER on command line\n"
0528           "  --start-event    <int>   event number to start at when reading from a file (def: %d)\n"
0529           "  --loop-over-file         after reaching the end of the file, start over from the beginning until "
0530           "<num-events> events have been processed\n"
0531           "\n"
0532           "If no --input-file is specified, will trigger simulation\n"
0533           "  --num-tracks     <int>   number of tracks to generate for each event (def: %d)\n"
0534           "\n----------------------------------------------------------------------------------------------------------"
0535           "\n\n"
0536           "Threading related options\n\n"
0537           "  --num-thr-sim    <int>   number of threads for simulation (def: %d)\n"
0538           "  --num-thr        <int>   number of threads for track finding (def: %d)\n"
0539           "  --num-thr-ev     <int>   number of threads to run the event loop (def: %d)\n"
0540           "  --seeds-per-task <int>   number of seeds to process in a tbb task (def: %d)\n"
0541           "  --hits-per-task  <int>   number of layer1 hits per task when using find seeds (def: %d)\n"
0542           "\n----------------------------------------------------------------------------------------------------------"
0543           "\n\n"
0544           "FittingTestMPlex options\n\n"
0545           "  --fit-std                run standard fitting test (def: %s)\n"
0546           "  --fit-std-only           run only standard fitting test (def: %s)\n"
0547           "  --cf-fitting             enable conformal fit before fitting tracks to get initial estimate of track "
0548           "parameters and errors (def: %s)\n"
0549           "  --fit-val                enable ROOT based validation for fittingMPlex  (def: %s)\n"
0550           "\n----------------------------------------------------------------------------------------------------------"
0551           "\n\n"
0552           "BuildingTestMPlex options\n\n"
0553           " **Specify which building routine you would like to run\n"
0554           "  --build-cmssw            run dummy validation of CMSSW tracks with MkBuilder stuff (def: %s)\n"
0555           "  --build-bh               run best-hit building test (def: %s)\n"
0556           "  --build-std              run standard combinatorial building test (def: %s)\n"
0557           "  --build-ce               run clone engine combinatorial building test (def: %s)\n"
0558           "  --build-mimi             run clone engine on multiple-iteration test (def: %s)\n"
0559           "  --num-iters-cmssw <int>  number of mimi iterations to run (def: set to 3 when --build-mimi is in effect, "
0560           "0 otherwise)\n"
0561           "\n"
0562           " **Seeding options\n"
0563           "  --seed-input     <str>   which seed collecion used for building (def: %s)\n"
0564           "  --seed-cleaning  <str>   which seed cleaning to apply if using cmssw seeds (def: %s)\n"
0565           "  --cf-seeding             enable conformal fit over seeds (def: %s)\n"
0566           "\n"
0567           " **Duplicate removal options\n"
0568           "  --remove-dup            run duplicate removal after building, using both hit and kinematic criteria (def: "
0569           "%s)\n"
0570           "  --remove-dup-no-hit     run duplicate removal after building, using kinematic criteria only (def: %s)\n"
0571           "\n"
0572           " **Dead module (strip) option\n"
0573           "  --use-dead-modules          run duplicate removal after building, using both hit and kinematic criteria "
0574           "(def: %s)\n"
0575           "\n"
0576           " **Additional options for building\n"
0577           "  --use-phiq-arr           use phi-Q arrays in select hit indices (def: %s)\n"
0578           "  --kludge-cms-hit-errors  make sure err(xy) > 15 mum, err(z) > 30 mum (def: %s)\n"
0579           "  --backward-fit           perform backward fit during building (def: %s)\n"
0580           "  --no-backward-search     do not do backward search after backward fit\n"
0581           "                           (def: do search if backward-fit is enabled and available in given iteration)\n"
0582           "  --include-pca            do the backward fit to point of closest approach, does not imply "
0583           "'--backward-fit' (def: %s)\n"
0584           "\n----------------------------------------------------------------------------------------------------------"
0585           "\n\n"
0586           "Validation options\n\n"
0587           " **Text file based options\n"
0588           "  --quality-val            enable printout validation for MkBuilder (def: %s)\n"
0589           "                             must enable: --dump-for-plots\n"
0590           "  --dump-for-plots         make shell printouts for plots (def: %s)\n"
0591           "  --mtv-like-val           configure validation to emulate CMSSW MultiTrackValidator (MTV) (def: %s)\n"
0592           "  --mtv-require-seeds      configure validation to emulate MTV but require sim tracks to be matched to "
0593           "seeds (def: %s)\n"
0594           "\n"
0595           " **ROOT based options\n"
0596           "  --sim-val-for-cmssw      enable ROOT based validation for CMSSW tracks with simtracks as reference [eff, "
0597           "FR, DR] (def: %s)\n"
0598           "  --sim-val                enable ROOT based validation for seeding, building, and fitting with simtracks "
0599           "as reference [eff, FR, DR] (def: %s)\n"
0600           "  --cmssw-val              enable ROOT based validation for building and fitting with CMSSW tracks as "
0601           "reference [eff, FR, DR] (def: %s)\n"
0602           "                             must enable: --geom CMS-phase1 --read-cmssw-tracks\n"
0603           "  --cmssw-match-fw  <str>  which cmssw track matching routine to use if validating against CMSSW tracks, "
0604           "forward built tracks only (def: %s)\n"
0605           "                             must enable: --geom CMS-phase1 --cmssw-val --read-cmssw-tracks\n"
0606           "  --cmssw-match-bk  <str>  which cmssw track matching routine to use if validating against CMSSW tracks, "
0607           "backward fit tracks only (def: %s)\n"
0608           "                             must enable: --geom CMS-phase1 --cmssw-val --read-cmssw-tracks --backward-fit "
0609           "--backward-fit-pca\n"
0610           "  --inc-shorts             include short reco tracks into FR (def: %s)\n"
0611           "  --keep-hit-info          keep vectors of hit idxs and branches in trees (def: %s)\n"
0612           "  --try-to-save-sim-info   two options for this flag [related to validation with simtracks as reference "
0613           "collection] (def: %s)\n"
0614           "                              a) IF (--read-simtrack-states is enabled)\n"
0615           "                                    If a sim track is associated to a reco track, but it does not contain "
0616           "the last found on the reco track\n"
0617           "                                    still save sim track kinematic info from generator position\n"
0618           "                              b) ELSE (--read-simtrack-states is NOT enabled)\n"
0619           "                                    Save sim track kinematic info from generator position if matched to "
0620           "reco track\n"
0621           "\n----------------------------------------------------------------------------------------------------------"
0622           "\n\n"
0623           "Combo spaghetti, that's with cole slaw:\n\n"
0624           " **Building and fitting combo options\n"
0625           "  --backward-fit-pca       perform backward fit to point of closest approach during building\n"
0626           "                             == --backward-fit --include-pca\n"
0627           " **Seed combo options\n"
0628           "  --cmssw-simseeds         use CMS geom with simtracks for seeds\n"
0629           "                             == --geom CMS-phase1 --seed-input %s\n"
0630           "  --cmssw-stdseeds         use CMS geom with CMSSW seeds uncleaned\n"
0631           "                             == --geom CMS-phase1 --seed-input %s --seed-cleaning %s\n"
0632           "  --cmssw-n2seeds          use CMS geom with CMSSW seeds cleaned with N^2 routine\n"
0633           "                             == --geom CMS-phase1 --seed-input %s --seed-cleaning %s\n"
0634           "  --cmssw-pureseeds        use CMS geom with pure CMSSW seeds (seeds which produced CMSSW reco tracks), "
0635           "enable read of CMSSW tracks\n"
0636           "                             == --geom CMS-phase1 --seed-input %s --seed-cleaning %s --read-cmssw-tracks\n"
0637           "  --cmssw-goodlabelseeds   use CMS geom with CMSSW seeds with label() >= 0\n"
0638           "                             == --geom CMS-phase1 --seed-input %s --seed-cleaning %s\n"
0639           "\n"
0640           " **CMSSW validation combo options\n"
0641           "  --cmssw-val-fhit-bhit    use CMSSW validation with hit based matching (50 percent after seed) for forward "
0642           "built tracks\n"
0643           "                           use CMSSW validation with hit based matching (50 percent after seed) for "
0644           "backward fit tracks\n"
0645           "                             == --cmssw-val --read-cmssw-tracks --cmssw-match-fw %s --cmssw-match-bk %s\n"
0646           "                             must enable: --backward-fit-pca\n"
0647           "  --cmssw-val-fhit-bprm    use CMSSW validation with hit based matching (50 percent after seed) for forward "
0648           "built tracks\n"
0649           "                           use CMSSW validation with track parameter based matching for backward fit "
0650           "tracks\n"
0651           "                             == --cmssw-val --read-cmssw-tracks --cmssw-match-fw %s --cmssw-match-bk %s\n"
0652           "                             must enable: --backward-fit-pca\n"
0653           "  --cmssw-val-fprm-bhit    use CMSSW validation with track parameter based matching for forward built "
0654           "tracks\n"
0655           "                           use CMSSW validation with hit based matching (50 percent after seed) for "
0656           "backward fit tracks\n"
0657           "                             == --cmssw-val --read-cmssw-tracks --cmssw-match-fw %s --cmssw-match-bk %s\n"
0658           "                             must enable: --backward-fit-pca\n"
0659           "  --cmssw-val-fprm-bprm    use CMSSW validation with track parameter based matching for forward built "
0660           "tracks\n"
0661           "                           use CMSSW validation with track parameter based matching for backward fit "
0662           "tracks\n"
0663           "                             == --cmssw-val --read-cmssw-tracks --cmssw-match-fw %s --cmssw-match-bk %s\n"
0664           "                             must enable: --backward-fit-pca\n"
0665           "  --cmssw-val-label        use CMSSW validation with stricter hit based matching for both forward built and "
0666           "backward fit tracks, enable read of CMSSW tracks\n"
0667           "                             == --cmssw-val --read-cmssw-tracks --cmssw-match-fw %s --cmssw-match-bk %s\n"
0668           "                             must enable: --cmssw-pureseeds --backward-fit-pca\n"
0669           "\n----------------------------------------------------------------------------------------------------------"
0670           "\n\n"
0671           "JSON config patcher options:\n\n"
0672           "  --json-load  <filename>  load single IterationConfig from given JSON file (def: do not load)\n"
0673           "                           can be specified multiple times for several files\n"
0674           "  --json-patch <filename>  patch IterationsInfo from given JSON file (def: do not patch)\n"
0675           "                           can be specified multiple times for several files\n"
0676           "  --json-save-iterations <fname-fmt> save per iteration json files\n"
0677           "                           %%d in fname-fmt gets replaced with iteration index\n"
0678           "                           %%s in fname-fmt gets replaced with iteration algorithm name\n"
0679           "                           exactly one of %%d and %%s must be specified\n"
0680           "  --json-save-iterations-include-iter-info-preamble (def: %s)\n"
0681           "  --json-verbose     print each patch assignment as it is being made (def: %s)\n"
0682           "  --json-dump-before print iteration config before patching (def: %s)\n"
0683           "  --json-dump-after  print iteration config after  patching (def: %s)\n"
0684           "\n----------------------------------------------------------------------------------------------------------"
0685           "\n\n",
0686           argv[0],
0687 
0688           Config::geomPlugin.c_str(),
0689           b2a(Config::silent),
0690           Config::finderReportBestOutOfN,
0691           g_input_file.c_str(),
0692           g_output_file.c_str(),
0693           b2a(Config::readCmsswTracks),
0694           b2a(Config::readSimTrackStates),
0695           Config::nEvents,
0696           g_start_event,
0697           Config::nTracks,
0698 
0699           Config::numThreadsSimulation,
0700           Config::numThreadsFinder,
0701           Config::numThreadsEvents,
0702           Config::numSeedsPerTask,
0703           Config::numHitsPerTask,
0704 
0705           b2a(g_run_fit_std),
0706           b2a(g_run_fit_std &&
0707               !(g_run_build_all || g_run_build_cmssw || g_run_build_bh || g_run_build_std || g_run_build_ce)),
0708           b2a(Config::cf_fitting),
0709           b2a(Config::fit_val),
0710 
0711           b2a(g_run_build_all || g_run_build_cmssw),
0712           b2a(g_run_build_all || g_run_build_bh),
0713           b2a(g_run_build_all || g_run_build_std),
0714           b2a(g_run_build_all || g_run_build_ce),
0715           b2a(g_run_build_all || g_run_build_mimi),
0716 
0717           getOpt(Config::seedInput, g_seed_opts).c_str(),
0718           getOpt(Config::seedCleaning, g_clean_opts).c_str(),
0719           b2a(Config::cf_seeding),
0720 
0721           b2a(Config::removeDuplicates && Config::useHitsForDuplicates),
0722           b2a(Config::removeDuplicates && !Config::useHitsForDuplicates),
0723 
0724           b2a(Config::useDeadModules),
0725 
0726           b2a(Config::usePhiQArrays),
0727           b2a(Config::kludgeCmsHitErrors),
0728           b2a(Config::backwardFit),
0729           b2a(Config::includePCA),
0730 
0731           b2a(Config::quality_val),
0732           b2a(Config::dumpForPlots),
0733           b2a(Config::mtvLikeValidation),
0734           b2a(Config::mtvRequireSeeds),
0735 
0736           b2a(Config::sim_val_for_cmssw),
0737           b2a(Config::sim_val),
0738           b2a(Config::cmssw_val),
0739           getOpt(Config::cmsswMatchingFW, g_match_opts).c_str(),
0740           getOpt(Config::cmsswMatchingBK, g_match_opts).c_str(),
0741           b2a(Config::inclusiveShorts),
0742           b2a(Config::keepHitInfo),
0743           b2a(Config::tryToSaveSimInfo),
0744 
0745           getOpt(simSeeds, g_seed_opts).c_str(),
0746           getOpt(cmsswSeeds, g_seed_opts).c_str(),
0747           getOpt(noCleaning, g_clean_opts).c_str(),
0748           getOpt(cmsswSeeds, g_seed_opts).c_str(),
0749           getOpt(cleanSeedsN2, g_clean_opts).c_str(),
0750           getOpt(cmsswSeeds, g_seed_opts).c_str(),
0751           getOpt(cleanSeedsPure, g_clean_opts).c_str(),
0752           getOpt(cmsswSeeds, g_seed_opts).c_str(),
0753           getOpt(cleanSeedsBadLabel, g_clean_opts).c_str(),
0754 
0755           getOpt(hitBased, g_match_opts).c_str(),
0756           getOpt(hitBased, g_match_opts).c_str(),
0757           getOpt(hitBased, g_match_opts).c_str(),
0758           getOpt(trkParamBased, g_match_opts).c_str(),
0759           getOpt(trkParamBased, g_match_opts).c_str(),
0760           getOpt(hitBased, g_match_opts).c_str(),
0761           getOpt(trkParamBased, g_match_opts).c_str(),
0762           getOpt(trkParamBased, g_match_opts).c_str(),
0763           getOpt(labelBased, g_match_opts).c_str(),
0764           getOpt(labelBased, g_match_opts).c_str(),
0765 
0766           b2a(Config::json_verbose),
0767           b2a(Config::json_save_iters_include_iter_info_preamble),
0768           b2a(Config::json_dump_before),
0769           b2a(Config::json_dump_after));
0770 
0771       printf("List of options for string based inputs \n");
0772       printf(
0773           "--geom \n"
0774           "  CMS-phase1 \n"
0775           "  CMS-phase2 \n"
0776           "  CylCowWLids \n"
0777           "\n");
0778 
0779       printf("--seed-input \n");
0780       listOpts(g_seed_opts);
0781       printf("\n");
0782 
0783       printf("--seed-cleaning \n");
0784       listOpts(g_clean_opts);
0785       printf("\n");
0786 
0787       printf("--cmssw-matching \n");
0788       listOpts(g_match_opts);
0789       printf("\n");
0790 
0791       exit(0);
0792     }  // end of "help" block
0793 
0794     else if (*i == "--geom") {
0795       next_arg_or_die(mArgs, i);
0796       Config::geomPlugin = *i;
0797     } else if (*i == "--silent") {
0798       Config::silent = true;
0799     } else if (*i == "--best-out-of") {
0800       next_arg_or_die(mArgs, i);
0801       Config::finderReportBestOutOfN = atoi(i->c_str());
0802     } else if (*i == "--input-file") {
0803       next_arg_or_die(mArgs, i);
0804       g_input_file = *i;
0805       g_operation = "read";
0806       Config::nEvents = -1;
0807     } else if (*i == "--output-file") {
0808       next_arg_or_die(mArgs, i);
0809       g_output_file = *i;
0810       g_operation = "write";
0811     } else if (*i == "--read-cmssw-tracks") {
0812       Config::readCmsswTracks = true;
0813     } else if (*i == "--read-simtrack-states") {
0814       Config::readSimTrackStates = true;
0815     } else if (*i == "--num-events") {
0816       next_arg_or_die(mArgs, i);
0817       Config::nEvents = atoi(i->c_str());
0818     } else if (*i == "--start-event") {
0819       next_arg_or_die(mArgs, i);
0820       g_start_event = atoi(i->c_str());
0821     } else if (*i == "--loop-over-file") {
0822       Config::loopOverFile = true;
0823     } else if (*i == "--num-tracks") {
0824       next_arg_or_die(mArgs, i);
0825       Config::nTracks = atoi(i->c_str());
0826     } else if (*i == "--num-thr-sim") {
0827       next_arg_or_die(mArgs, i);
0828       Config::numThreadsSimulation = atoi(i->c_str());
0829     } else if (*i == "--num-thr") {
0830       next_arg_or_die(mArgs, i);
0831       Config::numThreadsFinder = atoi(i->c_str());
0832     } else if (*i == "--num-thr-ev") {
0833       next_arg_or_die(mArgs, i);
0834       Config::numThreadsEvents = atoi(i->c_str());
0835     } else if (*i == "--seeds-per-task") {
0836       next_arg_or_die(mArgs, i);
0837       Config::numSeedsPerTask = atoi(i->c_str());
0838     } else if (*i == "--hits-per-task") {
0839       next_arg_or_die(mArgs, i);
0840       Config::numHitsPerTask = atoi(i->c_str());
0841     } else if (*i == "--fit-std") {
0842       g_run_fit_std = true;
0843     } else if (*i == "--fit-std-only") {
0844       g_run_fit_std = true;
0845       g_run_build_all = false;
0846       g_run_build_bh = false;
0847       g_run_build_std = false;
0848       g_run_build_ce = false;
0849     } else if (*i == "--cf-fitting") {
0850       Config::cf_fitting = true;
0851     } else if (*i == "--fit-val") {
0852       Config::fit_val = true;
0853     } else if (*i == "--build-cmssw") {
0854       g_run_build_all = false;
0855       g_run_build_cmssw = true;
0856       g_run_build_bh = false;
0857       g_run_build_std = false;
0858       g_run_build_ce = false;
0859     } else if (*i == "--build-bh") {
0860       g_run_build_all = false;
0861       g_run_build_cmssw = false;
0862       g_run_build_bh = true;
0863       g_run_build_std = false;
0864       g_run_build_ce = false;
0865     } else if (*i == "--build-std") {
0866       g_run_build_all = false;
0867       g_run_build_cmssw = false;
0868       g_run_build_bh = false;
0869       g_run_build_std = true;
0870       g_run_build_ce = false;
0871     } else if (*i == "--build-ce") {
0872       g_run_build_all = false;
0873       g_run_build_cmssw = false;
0874       g_run_build_bh = false;
0875       g_run_build_std = false;
0876       g_run_build_ce = true;
0877     } else if (*i == "--build-mimi") {
0878       g_run_build_all = false;
0879       g_run_build_cmssw = false;
0880       g_run_build_bh = false;
0881       g_run_build_std = false;
0882       g_run_build_ce = false;
0883       g_run_build_mimi = true;
0884       if (Config::nItersCMSSW == 0)
0885         Config::nItersCMSSW = 3;
0886     } else if (*i == "--num-iters-cmssw") {
0887       next_arg_or_die(mArgs, i);
0888       Config::nItersCMSSW = atoi(i->c_str());
0889     } else if (*i == "--seed-input") {
0890       next_arg_or_die(mArgs, i);
0891       setOpt(*i, Config::seedInput, g_seed_opts, "seed input collection");
0892     } else if (*i == "--seed-cleaning") {
0893       next_arg_or_die(mArgs, i);
0894       setOpt(*i, Config::seedCleaning, g_clean_opts, "seed cleaning");
0895     } else if (*i == "--cf-seeding") {
0896       Config::cf_seeding = true;
0897     } else if (*i == "--use-phiq-arr") {
0898 #ifdef CONFIG_PhiQArrays
0899       Config::usePhiQArrays = true;
0900 #else
0901       printf("--use-phiq-arr has no effect: recompile with CONFIG_PhiQArrays\n");
0902 #endif
0903     } else if (*i == "--remove-dup") {
0904       Config::removeDuplicates = true;
0905       Config::useHitsForDuplicates = true;
0906     } else if (*i == "--remove-dup-no-hit") {
0907       Config::removeDuplicates = true;
0908       Config::useHitsForDuplicates = false;
0909     } else if (*i == "--use-dead-modules") {
0910       Config::useDeadModules = true;
0911     } else if (*i == "--kludge-cms-hit-errors") {
0912       Config::kludgeCmsHitErrors = true;
0913     } else if (*i == "--backward-fit") {
0914       Config::backwardFit = true;
0915     } else if (*i == "--no-backward-search") {
0916       Config::backwardSearch = false;
0917     } else if (*i == "--include-pca") {
0918       Config::includePCA = true;
0919     } else if (*i == "--quality-val") {
0920       Config::quality_val = true;
0921     } else if (*i == "--dump-for-plots") {
0922       Config::dumpForPlots = true;
0923     } else if (*i == "--mtv-like-val") {
0924       Config::mtvLikeValidation = true;
0925       Config::cmsSelMinLayers = 0;
0926       Config::nMinFoundHits = 0;
0927     } else if (*i == "--mtv-require-seeds") {
0928       Config::mtvLikeValidation = true;
0929       Config::cmsSelMinLayers = 0;
0930       Config::nMinFoundHits = 0;
0931       Config::mtvRequireSeeds = true;
0932     } else if (*i == "--sim-val-for-cmssw") {
0933       Config::sim_val_for_cmssw = true;
0934     } else if (*i == "--sim-val") {
0935       Config::sim_val = true;
0936     } else if (*i == "--cmssw-val") {
0937       Config::cmssw_val = true;
0938     } else if (*i == "--cmssw-match-fw") {
0939       next_arg_or_die(mArgs, i);
0940       setOpt(*i, Config::cmsswMatchingFW, g_match_opts, "CMSSW validation track matching for forward built tracks");
0941     } else if (*i == "--cmssw-match-bk") {
0942       next_arg_or_die(mArgs, i);
0943       setOpt(*i, Config::cmsswMatchingBK, g_match_opts, "CMSSW validation track matching for backward fit tracks");
0944     } else if (*i == "--inc-shorts") {
0945       Config::inclusiveShorts = true;
0946     } else if (*i == "--keep-hit-info") {
0947       Config::keepHitInfo = true;
0948     } else if (*i == "--try-to-save-sim-info") {
0949       Config::tryToSaveSimInfo = true;
0950     } else if (*i == "--backward-fit-pca") {
0951       Config::backwardFit = true;
0952       Config::includePCA = true;
0953     } else if (*i == "--cmssw-simseeds") {
0954       Config::geomPlugin = "CMS-phase1";
0955       Config::seedInput = simSeeds;
0956     } else if (*i == "--cmssw-stdseeds") {
0957       Config::geomPlugin = "CMS-phase1";
0958       Config::seedInput = cmsswSeeds;
0959       Config::seedCleaning = noCleaning;
0960     } else if (*i == "--cmssw-n2seeds") {
0961       Config::geomPlugin = "CMS-phase1";
0962       Config::seedInput = cmsswSeeds;
0963       Config::seedCleaning = cleanSeedsN2;
0964     } else if (*i == "--cmssw-pureseeds") {
0965       Config::geomPlugin = "CMS-phase1";
0966       Config::seedInput = cmsswSeeds;
0967       Config::seedCleaning = cleanSeedsPure;
0968       Config::readCmsswTracks = true;
0969     } else if (*i == "--cmssw-goodlabelseeds") {
0970       Config::geomPlugin = "CMS-phase1";
0971       Config::seedInput = cmsswSeeds;
0972       Config::seedCleaning = cleanSeedsBadLabel;
0973     } else if (*i == "--cmssw-val-fhit-bhit") {
0974       Config::cmssw_val = true;
0975       Config::readCmsswTracks = true;
0976       Config::cmsswMatchingFW = hitBased;
0977       Config::cmsswMatchingBK = hitBased;
0978     } else if (*i == "--cmssw-val-fhit-bprm") {
0979       Config::cmssw_val = true;
0980       Config::readCmsswTracks = true;
0981       Config::cmsswMatchingFW = hitBased;
0982       Config::cmsswMatchingBK = trkParamBased;
0983     } else if (*i == "--cmssw-val-fprm-bhit") {
0984       Config::cmssw_val = true;
0985       Config::readCmsswTracks = true;
0986       Config::cmsswMatchingFW = trkParamBased;
0987       Config::cmsswMatchingBK = hitBased;
0988     } else if (*i == "--cmssw-val-fprm-bprm") {
0989       Config::cmssw_val = true;
0990       Config::readCmsswTracks = true;
0991       Config::cmsswMatchingFW = trkParamBased;
0992       Config::cmsswMatchingBK = trkParamBased;
0993     } else if (*i == "--cmssw-val-label") {
0994       Config::cmssw_val = true;
0995       Config::readCmsswTracks = true;
0996       Config::cmsswMatchingFW = labelBased;
0997       Config::cmsswMatchingBK = labelBased;
0998     } else if (*i == "--json-load") {
0999       next_arg_or_die(mArgs, i);
1000       Config::json_load_filenames.push_back(*i);
1001     } else if (*i == "--json-patch") {
1002       next_arg_or_die(mArgs, i);
1003       Config::json_patch_filenames.push_back(*i);
1004     } else if (*i == "--json-save-iterations") {
1005       next_arg_or_die(mArgs, i);
1006       Config::json_save_iters_fname_fmt = *i;
1007     } else if (*i == "--json-save-iterations-include-iter-info-preamble") {
1008       Config::json_save_iters_include_iter_info_preamble = true;
1009     } else if (*i == "--json-verbose") {
1010       Config::json_verbose = true;
1011     } else if (*i == "--json-dump-before") {
1012       Config::json_dump_before = true;
1013     } else if (*i == "--json-dump-after") {
1014       Config::json_dump_after = true;
1015     } else {
1016       fprintf(stderr, "Error: Unknown option/argument '%s'.\n", i->c_str());
1017       exit(1);
1018     }
1019 
1020     mArgs.erase(start, ++i);
1021   }
1022 
1023   // Do some checking of options before going...
1024   if (Config::seedCleaning != cleanSeedsPure &&
1025       (Config::cmsswMatchingFW == labelBased || Config::cmsswMatchingBK == labelBased)) {
1026     std::cerr << "What have you done?!? Can't mix cmssw label matching without pure seeds! Exiting..." << std::endl;
1027     exit(1);
1028   } else if (Config::mtvLikeValidation && Config::inclusiveShorts) {
1029     std::cerr
1030         << "What have you done?!? Short reco tracks are already accounted for in the MTV-Like Validation! Inclusive "
1031            "shorts is only an option for the standard simval, and will break the MTV-Like simval! Exiting..."
1032         << std::endl;
1033     exit(1);
1034   }
1035 
1036   Config::recalculateDependentConstants();
1037 
1038   printf("Running with n_threads=%d, best_out_of=%d\n", Config::numThreadsFinder, Config::finderReportBestOutOfN);
1039 
1040   test_standard();
1041 
1042   return 0;
1043 }