sPhenix code displayed by LXR master/​analysis/​EMCal-position-dependent-calibration/​macro/​ana.357/​Fun4All_G4_sPHENIX.C	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-06 08:13:13

 #ifndef MACRO_FUN4ALLG4SPHENIX_C
 #define MACRO_FUN4ALLG4SPHENIX_C
 
 // c++ includes --
 #include <string>
 #include <iostream>
 #include <fstream>
 #include <math.h>
 #include <set>
 #include <map>
 
 using std::cout;
 using std::endl;
 using std::string;
 using std::to_string;
 using std::set;
 using std::istringstream;
 using std::max;
 using std::map;
 
 // root includes --
 #include <TSystem.h>
 #include <TROOT.h>
 
 #include <GlobalVariables.C>
 
 #include <DisplayOn.C>
 #include "G4Setup_sPHENIX.C"
 #include <G4_Bbc.C>
 #include <G4_CaloTrigger.C>
 #include <G4_Centrality.C>
 #include <G4_DSTReader.C>
 #include <G4_Global.C>
 #include <G4_HIJetReco.C>
 #include <G4_Input.C>
 #include <G4_Jets.C>
 #include <G4_KFParticle.C>
 #include <G4_ParticleFlow.C>
 #include <G4_Production.C>
 #include <G4_TopoClusterReco.C>
 
 #include <Trkr_RecoInit.C>
 #include <Trkr_Clustering.C>
 #include <Trkr_LaserClustering.C>
 #include <Trkr_Reco.C>
 #include <Trkr_Eval.C>
 #include <Trkr_QA.C>
 
 #include <Trkr_Diagnostics.C>
 #include <G4_User.C>
 #include <QA.C>
 
 #include <ffamodules/FlagHandler.h>
 #include <ffamodules/HeadReco.h>
 #include <ffamodules/SyncReco.h>
 #include <ffamodules/CDBInterface.h>
 
 #include <fun4all/Fun4AllDstOutputManager.h>
 #include <fun4all/Fun4AllOutputManager.h>
 #include <fun4all/Fun4AllServer.h>
 
 #include <phool/PHRandomSeed.h>
 #include <phool/recoConsts.h>
 
 R__LOAD_LIBRARY(libfun4all.so)
 R__LOAD_LIBRARY(libffamodules.so)
 
 // For HepMC Hijing
 // try inputFile = /sphenix/sim/sim01/sphnxpro/sHijing_HepMC/sHijing_0-12fm.dat
 
 int Fun4All_G4_sPHENIX(
     const int nEvents = 1,
     const int seed = 0,
     const string &outdir = ".",
     const string &tag = "0",
     const string &outputFile = "G4sPHENIX.root",
     const string &inputFile = "https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root",
     const string &embed_input_file = "https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root",
     const int skip = 0)
 {
   Fun4AllServer *se = Fun4AllServer::instance();
   se->Verbosity(1);
 
   //Opt to print all random seed used for debugging reproducibility. Comment out to reduce stdout prints.
   PHRandomSeed::Verbosity(1);
 
   // just if we set some flags somewhere in this macro
   recoConsts *rc = recoConsts::instance();
   // By default every random number generator uses
   // PHRandomSeed() which reads /dev/urandom to get its seed
   // if the RANDOMSEED flag is set its value is taken as seed
   // You can either set this to a random value using PHRandomSeed()
   // which will make all seeds identical (not sure what the point of
   // this would be:
   //  rc->set_IntFlag("RANDOMSEED",PHRandomSeed());
   // or set it to a fixed value so you can debug your code
   //  rc->set_IntFlag("RANDOMSEED", 12345);
 
   if(seed > 0) {
     rc->set_IntFlag("RANDOMSEED", seed);
   }
 
   //===============
   // Input options
   //===============
   // verbosity setting (applies to all input managers)
   Input::VERBOSITY = 0;
   // First enable the input generators
   // Either:
   // read previously generated g4-hits files, in this case it opens a DST and skips
   // the simulations step completely. The G4Setup macro is only loaded to get information
   // about the number of layers used for the cell reco code
   //  Input::READHITS = true;
   INPUTREADHITS::filename[0] = inputFile;
   // if you use a filelist
   // INPUTREADHITS::listfile[0] = inputFile;
   // Or:
   // Use particle generator
   // And
   // Further choose to embed newly simulated events to a previous simulation. Not compatible with `readhits = true`
   // In case embedding into a production output, please double check your G4Setup_sPHENIX.C and G4_*.C consistent with those in the production macro folder
   // E.g. /sphenix/sim//sim01/production/2016-07-21/single_particle/spacal2d/
   //  Input::EMBED = true;
   INPUTEMBED::filename[0] = embed_input_file;
   // if you use a filelist
   //INPUTEMBED::listfile[0] = embed_input_file;
 
   Input::SIMPLE = true;
   // Input::SIMPLE_NUMBER = 2; // if you need 2 of them
   // Input::SIMPLE_VERBOSITY = 1;
 
   // Enable this is emulating the nominal pp/pA/AA collision vertex distribution
   // Input::BEAM_CONFIGURATION = Input::AA_COLLISION; // Input::AA_COLLISION (default), Input::pA_COLLISION, Input::pp_COLLISION
 
   //  Input::PYTHIA6 = true;
 
   // Input::PYTHIA8 = true;
 
   //  Input::GUN = true;
   //  Input::GUN_NUMBER = 3; // if you need 3 of them
   // Input::GUN_VERBOSITY = 1;
 
   //D0 generator
   //Input::DZERO = false;
   //Input::DZERO_VERBOSITY = 0;
   //Lambda_c generator //Not ready yet
   //Input::LAMBDAC = false;
   //Input::LAMBDAC_VERBOSITY = 0;
   // Upsilon generator
   //Input::UPSILON = true;
   //Input::UPSILON_NUMBER = 3; // if you need 3 of them
   //Input::UPSILON_VERBOSITY = 0;
 
   //  Input::HEPMC = true;
   INPUTHEPMC::filename = inputFile;
 
   // Event pile up simulation with collision rate in Hz MB collisions.
   //Input::PILEUPRATE = 100e3;
 
   //-----------------
   // Initialize the selected Input/Event generation
   //-----------------
   // This creates the input generator(s)
   InputInit();
 
   //--------------
   // Set generator specific options
   //--------------
   // can only be set after InputInit() is called
 
   // Simple Input generator:
   // if you run more than one of these Input::SIMPLE_NUMBER > 1
   // add the settings for other with [1], next with [2]...
   if (Input::SIMPLE)
   {
     // particle id: https://pdg.lbl.gov/2020/reviews/rpp2020-rev-monte-carlo-numbering.pdf
     // photon id: 22
     INPUTGENERATOR::SimpleEventGenerator[0]->add_particles(22, 1);
     if (Input::HEPMC || Input::EMBED)
     {
       INPUTGENERATOR::SimpleEventGenerator[0]->set_reuse_existing_vertex(true);
       INPUTGENERATOR::SimpleEventGenerator[0]->set_existing_vertex_offset_vector(0.0, 0.0, 0.0);
     }
     else
     {
       INPUTGENERATOR::SimpleEventGenerator[0]->set_vertex_distribution_function(PHG4SimpleEventGenerator::Gaus,
                                                                                 PHG4SimpleEventGenerator::Gaus,
                                                                                 PHG4SimpleEventGenerator::Gaus);
       INPUTGENERATOR::SimpleEventGenerator[0]->set_vertex_distribution_mean(0., 0., 0.);
       INPUTGENERATOR::SimpleEventGenerator[0]->set_vertex_distribution_width(0.01, 0.01, 5.);
     }
     // generation in one sector
     INPUTGENERATOR::SimpleEventGenerator[0]->set_eta_range(0, 1.152);
     INPUTGENERATOR::SimpleEventGenerator[0]->set_phi_range(-M_PI/32.0 - 0.02, M_PI/32.0 + 0.02);
 
     // for testing use full range, all sectors
     // INPUTGENERATOR::SimpleEventGenerator[0]->set_eta_range(-1.152, 1.152);
     // INPUTGENERATOR::SimpleEventGenerator[0]->set_phi_range(-M_PI, M_PI);
 
     // Train
     // INPUTGENERATOR::SimpleEventGenerator[0]->set_pt_range(20, 21.);
 
     // Test
     INPUTGENERATOR::SimpleEventGenerator[0]->set_pt_range(1, 21.);
   }
   // Upsilons
   // if you run more than one of these Input::UPSILON_NUMBER > 1
   // add the settings for other with [1], next with [2]...
   if (Input::UPSILON)
   {
     INPUTGENERATOR::VectorMesonGenerator[0]->add_decay_particles("e", 0);
     INPUTGENERATOR::VectorMesonGenerator[0]->set_rapidity_range(-1, 1);
     INPUTGENERATOR::VectorMesonGenerator[0]->set_pt_range(0., 10.);
     // Y species - select only one, last one wins
     INPUTGENERATOR::VectorMesonGenerator[0]->set_upsilon_1s();
     if (Input::HEPMC || Input::EMBED)
     {
       INPUTGENERATOR::VectorMesonGenerator[0]->set_reuse_existing_vertex(true);
       INPUTGENERATOR::VectorMesonGenerator[0]->set_existing_vertex_offset_vector(0.0, 0.0, 0.0);
     }
   }
   // particle gun
   // if you run more than one of these Input::GUN_NUMBER > 1
   // add the settings for other with [1], next with [2]...
   if (Input::GUN)
   {
     INPUTGENERATOR::Gun[0]->AddParticle("pi-", 0, 1, 0);
     INPUTGENERATOR::Gun[0]->set_vtx(0, 0, 0);
   }
 
   // pythia6
   if (Input::PYTHIA6)
   {
     //! Nominal collision geometry is selected by Input::BEAM_CONFIGURATION
     Input::ApplysPHENIXBeamParameter(INPUTGENERATOR::Pythia6);
   }
   // pythia8
   if (Input::PYTHIA8)
   {
     //! Nominal collision geometry is selected by Input::BEAM_CONFIGURATION
     Input::ApplysPHENIXBeamParameter(INPUTGENERATOR::Pythia8);
   }
 
   //--------------
   // Set Input Manager specific options
   //--------------
   // can only be set after InputInit() is called
 
   if (Input::HEPMC)
   {
     //! Nominal collision geometry is selected by Input::BEAM_CONFIGURATION
     Input::ApplysPHENIXBeamParameter(INPUTMANAGER::HepMCInputManager);
 
     // optional overriding beam parameters
     //INPUTMANAGER::HepMCInputManager->set_vertex_distribution_width(100e-4, 100e-4, 8, 0);  //optional collision smear in space, time
     //    INPUTMANAGER::HepMCInputManager->set_vertex_distribution_mean(0,0,0,0);//optional collision central position shift in space, time
     // //optional choice of vertex distribution function in space, time
     //INPUTMANAGER::HepMCInputManager->set_vertex_distribution_function(PHHepMCGenHelper::Gaus, PHHepMCGenHelper::Gaus, PHHepMCGenHelper::Gaus, PHHepMCGenHelper::Gaus);
     //! embedding ID for the event
     //! positive ID is the embedded event of interest, e.g. jetty event from pythia
     //! negative IDs are backgrounds, .e.g out of time pile up collisions
     //! Usually, ID = 0 means the primary Au+Au collision background
     //INPUTMANAGER::HepMCInputManager->set_embedding_id(Input::EmbedID);
     if (Input::PILEUPRATE > 0)
     {
       // Copy vertex settings from foreground hepmc input
       INPUTMANAGER::HepMCPileupInputManager->CopyHelperSettings(INPUTMANAGER::HepMCInputManager);
       // and then modify the ones you want to be different
       // INPUTMANAGER::HepMCPileupInputManager->set_vertex_distribution_width(100e-4,100e-4,8,0);
     }
   }
   if (Input::PILEUPRATE > 0)
   {
     //! Nominal collision geometry is selected by Input::BEAM_CONFIGURATION
     Input::ApplysPHENIXBeamParameter(INPUTMANAGER::HepMCPileupInputManager);
   }
   // register all input generators with Fun4All
   InputRegister();
 
   if (! Input::READHITS)
   {
     rc->set_IntFlag("RUNNUMBER",1);
 
     SyncReco *sync = new SyncReco();
     se->registerSubsystem(sync);
 
     HeadReco *head = new HeadReco();
     se->registerSubsystem(head);
   }
 // Flag Handler is always needed to read flags from input (if used)
 // and update our rc flags with them. At the end it saves all flags
 // again on the DST in the Flags node under the RUN node
   FlagHandler *flag = new FlagHandler();
   se->registerSubsystem(flag);
 
   // set up production relatedstuff
   //   Enable::PRODUCTION = true;
 
   //======================
   // Write the DST
   //======================
 
   //Enable::DSTOUT = true;
   Enable::DSTOUT_COMPRESS = false;
   DstOut::OutputDir = outdir;
   DstOut::OutputFile = outputFile;
 
   //Option to convert DST to human command readable TTree for quick poke around the outputs
   //  Enable::DSTREADER = true;
 
   // turn the display on (default off)
    //Enable::DISPLAY = true;
 
   //======================
   // What to run
   //======================
 
   // QA, main switch
   Enable::QA = false;
 
   // Global options (enabled for all enables subsystems - if implemented)
   //  Enable::ABSORBER = true;
   //  Enable::OVERLAPCHECK = true;
   //  Enable::VERBOSITY = 1;
 
   // Enable::BBC = true;
   // Enable::BBC_SUPPORT = true; // save hist in bbc support structure
   // Enable::BBCRECO = Enable::BBC && true
   Enable::BBCFAKE = true;  // Smeared vtx and t0, use if you don't want real BBC in simulation
 
   Enable::PIPE = true;
   Enable::PIPE_ABSORBER = true;
 
   // central tracking
   Enable::MVTX = false;
   Enable::MVTX_CELL = Enable::MVTX && true;
   Enable::MVTX_CLUSTER = Enable::MVTX_CELL && true;
   Enable::MVTX_QA = Enable::MVTX_CLUSTER && Enable::QA && true;
 
   Enable::INTT = false;
 //  Enable::INTT_ABSORBER = true; // enables layerwise support structure readout
 //  Enable::INTT_SUPPORT = true; // enable global support structure readout
   Enable::INTT_CELL = Enable::INTT && true;
   Enable::INTT_CLUSTER = Enable::INTT_CELL && true;
   Enable::INTT_QA = Enable::INTT_CLUSTER && Enable::QA && true;
 
   Enable::TPC = false;
   Enable::TPC_ABSORBER = true;
   Enable::TPC_CELL = Enable::TPC && true;
   Enable::TPC_CLUSTER = Enable::TPC_CELL && true;
   Enable::TPC_QA = Enable::TPC_CLUSTER && Enable::QA && true;
 
   Enable::MICROMEGAS = false;
   Enable::MICROMEGAS_CELL = Enable::MICROMEGAS && true;
   Enable::MICROMEGAS_CLUSTER = Enable::MICROMEGAS_CELL && true;
   Enable::MICROMEGAS_QA = Enable::MICROMEGAS_CLUSTER && Enable::QA && true;
 
   Enable::TRACKING_TRACK = (Enable::MICROMEGAS_CLUSTER && Enable::TPC_CLUSTER && Enable::INTT_CLUSTER && Enable::MVTX_CLUSTER) && true;
   Enable::TRACKING_EVAL = Enable::TRACKING_TRACK && true;
   Enable::TRACKING_QA = Enable::TRACKING_TRACK && Enable::QA && true;
 
   //Additional tracking tools 
   //Enable::TRACKING_DIAGNOSTICS = Enable::TRACKING_TRACK && true;
   //G4TRACKING::filter_conversion_electrons = true;
 
 
   //  cemc electronics + thin layer of W-epoxy to get albedo from cemc
   //  into the tracking, cannot run together with CEMC
   //  Enable::CEMCALBEDO = true;
 
   Enable::CEMC = true;
   Enable::CEMC_ABSORBER = true;
   Enable::CEMC_CELL = Enable::CEMC && true;
   Enable::CEMC_TOWER = Enable::CEMC_CELL && true;
   Enable::CEMC_CLUSTER = Enable::CEMC_TOWER && true;
   Enable::CEMC_EVAL = Enable::CEMC_CLUSTER && true;
   Enable::CEMC_QA = Enable::CEMC_CLUSTER && Enable::QA && true;
 
   Enable::HCALIN = false;
   Enable::HCALIN_ABSORBER = true;
   Enable::HCALIN_CELL = Enable::HCALIN && true;
   Enable::HCALIN_TOWER = Enable::HCALIN_CELL && true;
   Enable::HCALIN_CLUSTER = Enable::HCALIN_TOWER && true;
   Enable::HCALIN_EVAL = Enable::HCALIN_CLUSTER && true;
   Enable::HCALIN_QA = Enable::HCALIN_CLUSTER && Enable::QA && true;
 
   Enable::MAGNET = true;
   Enable::MAGNET_ABSORBER = true;
 
   Enable::HCALOUT = false;
   Enable::HCALOUT_ABSORBER = true;
   Enable::HCALOUT_CELL = Enable::HCALOUT && true;
   Enable::HCALOUT_TOWER = Enable::HCALOUT_CELL && true;
   Enable::HCALOUT_CLUSTER = Enable::HCALOUT_TOWER && true;
   Enable::HCALOUT_EVAL = Enable::HCALOUT_CLUSTER && true;
   Enable::HCALOUT_QA = Enable::HCALOUT_CLUSTER && Enable::QA && true;
 
   Enable::EPD = false;
   Enable::EPD_TILE = Enable::EPD && true;
 
   Enable::BEAMLINE = true;
 //  Enable::BEAMLINE_ABSORBER = true;  // makes the beam line magnets sensitive volumes
 //  Enable::BEAMLINE_BLACKHOLE = true; // turns the beamline magnets into black holes
   Enable::ZDC = true;
 //  Enable::ZDC_ABSORBER = true;
 //  Enable::ZDC_SUPPORT = true;
   Enable::ZDC_TOWER = Enable::ZDC && true;
   Enable::ZDC_EVAL = Enable::ZDC_TOWER && true;
 
   //! forward flux return plug door. Out of acceptance and off by default.
   //Enable::PLUGDOOR = true;
   Enable::PLUGDOOR_ABSORBER = true;
 
   Enable::GLOBAL_RECO = (Enable::BBCFAKE || Enable::TRACKING_TRACK) && true;
   //Enable::GLOBAL_FASTSIM = true;
 
   //Enable::KFPARTICLE = true;
   //Enable::KFPARTICLE_VERBOSITY = 1;
   //Enable::KFPARTICLE_TRUTH_MATCH = true;
   //Enable::KFPARTICLE_SAVE_NTUPLE = true;
 
   Enable::CALOTRIGGER = Enable::CEMC_TOWER && Enable::HCALIN_TOWER && Enable::HCALOUT_TOWER && false;
 
   Enable::JETS = (Enable::GLOBAL_RECO || Enable::GLOBAL_FASTSIM) && false;
   Enable::JETS_EVAL = Enable::JETS && true;
   Enable::JETS_QA = Enable::JETS && Enable::QA && true;
 
   // HI Jet Reco for p+Au / Au+Au collisions (default is false for
   // single particle / p+p-only simulations, or for p+Au / Au+Au
   // simulations which don't particularly care about jets)
   Enable::HIJETS = Enable::JETS && Enable::CEMC_TOWER && Enable::HCALIN_TOWER && Enable::HCALOUT_TOWER && false;
 
   // 3-D topoCluster reconstruction, potentially in all calorimeter layers
   Enable::TOPOCLUSTER = Enable::CEMC_TOWER && Enable::HCALIN_TOWER && Enable::HCALOUT_TOWER && false;
   // particle flow jet reconstruction - needs topoClusters!
   Enable::PARTICLEFLOW = Enable::TOPOCLUSTER && true;
   // centrality reconstruction
   Enable::CENTRALITY = false;
 
   // new settings using Enable namespace in GlobalVariables.C
   Enable::BLACKHOLE = false;
   //Enable::BLACKHOLE_SAVEHITS = false; // turn off saving of bh hits
   //Enable::BLACKHOLE_FORWARD_SAVEHITS = false; // disable forward/backward hits
   //BlackHoleGeometry::visible = true;
 
   // run user provided code (from local G4_User.C)
   //Enable::USER = true;
 
   //===============
   // conditions DB flags
   //===============
   Enable::CDB = true;
   // global tag
   rc->set_StringFlag("CDB_GLOBALTAG",CDB::global_tag);
   // 64 bit timestamp
   rc->set_uint64Flag("TIMESTAMP",CDB::timestamp);
   //---------------
   // World Settings
   //---------------
   //  G4WORLD::PhysicsList = "FTFP_BERT"; //FTFP_BERT_HP best for calo
   //  G4WORLD::WorldMaterial = "G4_AIR"; // set to G4_GALACTIC for material scans
 
   //---------------
   // Magnet Settings
   //---------------
 
   //  G4MAGNET::magfield =  string(getenv("CALIBRATIONROOT"))+ string("/Field/Map/sphenix3dbigmapxyz.root");  // default map from the calibration database
   //  G4MAGNET::magfield = "1.5"; // alternatively to specify a constant magnetic field, give a float number, which will be translated to solenoidal field in T, if string use as fieldmap name (including path)
 //  G4MAGNET::magfield_rescale = 1.;  // make consistent with expected Babar field strength of 1.4T
 
   //---------------
   // Pythia Decayer
   //---------------
   // list of decay types in
   // $OFFLINE_MAIN/include/g4decayer/EDecayType.hh
   // default is All:
   // G4P6DECAYER::decayType = EDecayType::kAll;
 
   // Initialize the selected subsystems
   G4Init();
 
   //---------------------
   // GEANT4 Detector description
   //---------------------
   if (!Input::READHITS)
   {
     G4Setup();
   }
 
   //------------------
   // Detector Division
   //------------------
 
   if ((Enable::BBC && Enable::BBCRECO) || Enable::BBCFAKE) Bbc_Reco();
 
   if (Enable::MVTX_CELL) Mvtx_Cells();
   if (Enable::INTT_CELL) Intt_Cells();
   if (Enable::TPC_CELL) TPC_Cells();
   if (Enable::MICROMEGAS_CELL) Micromegas_Cells();
 
   if (Enable::CEMC_CELL) CEMC_Cells();
 
   if (Enable::HCALIN_CELL) HCALInner_Cells();
 
   if (Enable::HCALOUT_CELL) HCALOuter_Cells();
 
   //-----------------------------
   // CEMC towering and clustering
   //-----------------------------
 
   if (Enable::CEMC_TOWER) CEMC_Towers();
   if (Enable::CEMC_CLUSTER) CEMC_Clusters();
 
   //--------------
   // EPD tile reconstruction
   //--------------
 
   if (Enable::EPD_TILE) EPD_Tiles();
 
   //-----------------------------
   // HCAL towering and clustering
   //-----------------------------
 
   if (Enable::HCALIN_TOWER) HCALInner_Towers();
   if (Enable::HCALIN_CLUSTER) HCALInner_Clusters();
 
   if (Enable::HCALOUT_TOWER) HCALOuter_Towers();
   if (Enable::HCALOUT_CLUSTER) HCALOuter_Clusters();
 
   // if enabled, do topoClustering early, upstream of any possible jet reconstruction
   if (Enable::TOPOCLUSTER) TopoClusterReco();
 
   //--------------
   // SVTX tracking
   //--------------
   if(Enable::TRACKING_TRACK)
     {
       TrackingInit();
     }
   if (Enable::MVTX_CLUSTER) Mvtx_Clustering();
   if (Enable::INTT_CLUSTER) Intt_Clustering();
   if (Enable::TPC_CLUSTER)
     {
       if(G4TPC::ENABLE_DIRECT_LASER_HITS || G4TPC::ENABLE_CENTRAL_MEMBRANE_HITS)
     {
       TPC_LaserClustering();
     }
       else
     {
       TPC_Clustering();
     }
     }
   if (Enable::MICROMEGAS_CLUSTER) Micromegas_Clustering();
 
   if (Enable::TRACKING_TRACK)
   {
     Tracking_Reco();
   }
 
   if(Enable::TRACKING_DIAGNOSTICS)
     {
       const std::string kshortFile = "./kshort_" + outputFile;
       const std::string residualsFile = "./residuals_" + outputFile;
  
       G4KshortReconstruction(kshortFile);
       seedResiduals(residualsFile);
     }
 
   //-----------------
   // Global Vertexing
   //-----------------
 
   if (Enable::GLOBAL_RECO && Enable::GLOBAL_FASTSIM)
   {
     cout << "You can only enable Enable::GLOBAL_RECO or Enable::GLOBAL_FASTSIM, not both" << endl;
     gSystem->Exit(1);
   }
   if (Enable::GLOBAL_RECO)
   {
     Global_Reco();
   }
   else if (Enable::GLOBAL_FASTSIM)
   {
     Global_FastSim();
   }
 
   //-----------------
   // Centrality Determination
   //-----------------
 
   if (Enable::CENTRALITY)
   {
       Centrality();
   }
 
   //-----------------
   // Calo Trigger Simulation
   //-----------------
 
   if (Enable::CALOTRIGGER)
   {
     CaloTrigger_Sim();
   }
 
   //---------
   // Jet reco
   //---------
 
   if (Enable::JETS) Jet_Reco();
   if (Enable::HIJETS) HIJetReco();
 
   if (Enable::PARTICLEFLOW) ParticleFlow();
 
   //----------------------
   // Simulation evaluation
   //----------------------
   string outputroot = outdir + "/" + outputFile;
   string remove_this = ".root";
   size_t pos = outputroot.find(remove_this);
   if (pos != string::npos)
   {
     outputroot.erase(pos, remove_this.length());
   }
 
   if (Enable::TRACKING_EVAL) Tracking_Eval(outputroot + "_g4svtx_eval.root");
 
   if (Enable::CEMC_EVAL) CEMC_Eval(outputroot + "_g4cemc_eval-" + tag + ".root");
 
   if (Enable::HCALIN_EVAL) HCALInner_Eval(outputroot + "_g4hcalin_eval.root");
 
   if (Enable::HCALOUT_EVAL) HCALOuter_Eval(outputroot + "_g4hcalout_eval.root");
 
   if (Enable::JETS_EVAL) Jet_Eval(outputroot + "_g4jet_eval.root");
 
   if (Enable::DSTREADER) G4DSTreader(outputroot + "_DSTReader.root");
 
   if (Enable::USER) UserAnalysisInit();
 
   // Writes electrons from conversions to a new track map on the node tree
   // the ntuple file is for diagnostics, it is produced only if the flag is set in G4_Tracking.C
   if(G4TRACKING::filter_conversion_electrons) Filter_Conversion_Electrons(outputroot + "_secvert_ntuple.root");
 
   //======================
   // Run KFParticle on evt
   //======================
   if (Enable::KFPARTICLE && Input::UPSILON) KFParticle_Upsilon_Reco();
   if (Enable::KFPARTICLE && Input::DZERO) KFParticle_D0_Reco();
 
   //----------------------
   // Standard QAs
   //----------------------
 
   if (Enable::CEMC_QA) CEMC_QA();
   if (Enable::HCALIN_QA) HCALInner_QA();
   if (Enable::HCALOUT_QA) HCALOuter_QA();
 
   if (Enable::JETS_QA) Jet_QA();
 
   if (Enable::MVTX_QA) Mvtx_QA();
   if (Enable::INTT_QA) Intt_QA();
   if (Enable::TPC_QA) TPC_QA();
   if (Enable::MICROMEGAS_QA) Micromegas_QA();
   if (Enable::TRACKING_QA) Tracking_QA();
 
   if (Enable::TRACKING_QA && Enable::CEMC_QA && Enable::HCALIN_QA && Enable::HCALOUT_QA) QA_G4CaloTracking();
 
   //--------------
   // Set up Input Managers
   //--------------
 
   InputManagers();
 
   if (Enable::PRODUCTION)
   {
     Production_CreateOutputDir();
   }
 
   if (Enable::DSTOUT)
   {
     string FullOutFile = DstOut::OutputDir + "/" + DstOut::OutputFile;
     Fun4AllDstOutputManager *out = new Fun4AllDstOutputManager("DSTOUT", FullOutFile);
     if (Enable::DSTOUT_COMPRESS)
     {
       ShowerCompress();
       DstCompress(out);
     }
     se->registerOutputManager(out);
   }
   //-----------------
   // Event processing
   //-----------------
   if (Enable::DISPLAY)
   {
     DisplayOn();
 
     gROOT->ProcessLine("Fun4AllServer *se = Fun4AllServer::instance();");
     gROOT->ProcessLine("PHG4Reco *g4 = (PHG4Reco *) se->getSubsysReco(\"PHG4RECO\");");
 
     cout << "-------------------------------------------------" << endl;
     cout << "You are in event display mode. Run one event with" << endl;
     cout << "se->run(1)" << endl;
     cout << "Run Geant4 command with following examples" << endl;
     gROOT->ProcessLine("displaycmd()");
 
     return 0;
   }
 
   // if we use a negative number of events we go back to the command line here
   if (nEvents < 0)
   {
     return 0;
   }
   // if we run the particle generator and use 0 it'll run forever
   // for embedding it runs forever if the repeat flag is set
   if (nEvents == 0 && !Input::HEPMC && !Input::READHITS && INPUTEMBED::REPEAT)
   {
     cout << "using 0 for number of events is a bad idea when using particle generators" << endl;
     cout << "it will run forever, so I just return without running anything" << endl;
     return 0;
   }
 
   se->skip(skip);
   se->run(nEvents);
 
   //-----
   // QA output
   //-----
 
   if (Enable::QA) QA_Output(outputroot + "_qa.root");
 
   //-----
   // Exit
   //-----
 
 //  CDBInterface::instance()->Print(); // print used DB files
   se->End();
   std::cout << "All done" << std::endl;
   delete se;
   if (Enable::PRODUCTION)
   {
     Production_MoveOutput();
   }
 
   gSystem->Exit(0);
   return 0;
 }
 
 # ifndef __CINT__
 int main(int argc, char* argv[]) {
     if(argc < 1 || argc > 9){
         cout << "usage: ./bin/Fun4All_G4_sPHENIX nEvents seed outdir tag outputFile inputFile embed_input_file skip" << endl;
         cout << "nEvents: Number of events to generate. Default: 1." << endl;
         cout << "seed: random seed to use for reproducibility. Default: 0" << endl;
         cout << "outdir: Location of output directory. Default: ." << endl;
         cout << "tag: Give a tag to the outputfile. Default: 0" << endl;
         cout << "inputfile: Default: https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root" << endl;
         cout << "embed_input_file: Default: https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root" << endl;
         cout << "skip: Number of events to skip. Default 0." << endl;
         return 1;
     }
 
      int nEvents = 1;
      int seed = 0;
      string outdir = ".";
      string tag = "0";
      string outputFile = "G4sPHENIX.root";
      string inputFile = "https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root";
      string embed_input_file = "https://www.phenix.bnl.gov/WWW/publish/phnxbld/sPHENIX/files/sPHENIX_G4Hits_sHijing_9-11fm_00000_00010.root";
      int skip = 0;
 
     if(argc >= 2) {
         nEvents = atoi(argv[1]);
     }
     if(argc >= 3) {
         seed = atoi(argv[2]);
     }
     if(argc >= 4) {
         outdir = argv[3];
     }
     if(argc >= 5) {
         tag = argv[4];
     }
     if(argc >= 6) {
         outputFile = argv[5];
     }
     if(argc >= 7) {
         inputFile = argv[6];
     }
     if(argc >= 8) {
         embed_input_file = argv[7];
     }
     if(argc >= 9) {
         skip = atoi(argv[8]);
     }
 
     Fun4All_G4_sPHENIX(nEvents, seed, outdir, tag, outputFile, inputFile, embed_input_file, skip);
 
     cout << "done" << endl;
     return 0;
 }
 # endif
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team