Merge b784736 into sapling-pr-archive-ehellbar

Author: ehellbar

DATA/production/configurations/asyncReco/async_pass.sh

@@ -412,67 +412,46 @@ fi
 echo "SETTING_ROOT_OUTPUT = $SETTING_ROOT_OUTPUT"
 
 # Enabling GPUs
-if [[ -n "$ALIEN_JDL_USEGPUS" && $ALIEN_JDL_USEGPUS != 0 ]] ; then
-  echo "Enabling GPUS"
-  [[ -z ${GPUTYPE:-} ]] && export GPUTYPE="HIP"
-  [[ -z ${GPUMEMSIZE:-} ]] && export GPUMEMSIZE=$((25 << 30))
-  if [[ "0$ASYNC_PASS_NO_OPTIMIZED_DEFAULTS" != "01" ]]; then
+if [[ $ASYNC_PASS_NO_OPTIMIZED_DEFAULTS != 1 ]]; then
+  export OPTIMIZED_PARALLEL_ASYNC_AUTO_SHM_LIMIT=1
+  if [[ $ALIEN_JDL_USEGPUS == 1 ]] ; then
+    echo "Enabling GPUS"
+    if [[ -z $ALIEN_JDL_SITEARCH ]]; then echo "ERROR: Must set ALIEN_JDL_SITEARCH to define GPU architecture!"; exit 1; fi
+    if [[ $ALIEN_JDL_SITEARCH == "NERSC" ]]; then # Disable mlock / ulimit / gpu memory registration - has performance impact, but doesn't work at NERSC for now
+      export SETENV_NO_ULIMIT=1
+      export CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow+="GPU_proc.noGPUMemoryRegistration=1;"
+    fi
+    ALIEN_JDL_SITEARCH_TMP=$ALIEN_JDL_SITEARCH
+    if [[ $ALIEN_JDL_SITEARCH == "EPN_MI100" ]]; then
+      ALIEN_JDL_SITEARCH_TMP=EPN
+      export EPN_NODE_MI100=1
+    elif [[ $ALIEN_JDL_SITEARCH == "EPN_MI50" ]]; then
+      ALIEN_JDL_SITEARCH_TMP=EPN
+    fi
     if [[ "ALIEN_JDL_USEFULLNUMADOMAIN" == 0 ]]; then
       if [[ $keep -eq 0 ]]; then
         if [[ $ALIEN_JDL_UNOPTIMIZEDGPUSETTINGS != 1 ]]; then
-          export OPTIMIZED_PARALLEL_ASYNC=pp_1gpu  # sets the multiplicities to optimized defaults for this configuration (1 job with 1 gpu on EPNs)
-          export OPTIMIZED_PARALLEL_ASYNC_AUTO_SHM_LIMIT=1
+          export OPTIMIZED_PARALLEL_ASYNC=pp_1gpu_${ALIEN_JDL_SITEARCH_TMP} # (16 cores, 1 gpu per job, pp)
         else
-          # forcing multiplicities to be 1
-          export MULTIPLICITY_PROCESS_tof_matcher=1
-          export MULTIPLICITY_PROCESS_mch_cluster_finder=1
-          export MULTIPLICITY_PROCESS_tpc_entropy_decoder=1
-          export MULTIPLICITY_PROCESS_itstpc_track_matcher=1
-          export MULTIPLICITY_PROCESS_its_tracker=1
-          export OMP_NUM_THREADS=4
-          export TIMEFRAME_RATE_LIMIT=8
-          export SHMSIZE=30000000000
+          export OPTIMIZED_PARALLEL_ASYNC=pp_1gpu_${ALIEN_JDL_SITEARCH_TMP}_unoptimized # (16 cores, 1 gpu per job, pp, low CPU multiplicities)
         fi
       else
-        export TIMEFRAME_RATE_LIMIT=4
-        export SHMSIZE=30000000000
+        export OPTIMIZED_PARALLEL_ASYNC=keep_root
       fi
     else
       if [[ $BEAMTYPE == "pp" ]]; then
-        export OPTIMIZED_PARALLEL_ASYNC=pp_4gpu # sets the multiplicities to optimized defaults for this configuration (1 Numa, pp)
-        export OPTIMIZED_PARALLEL_ASYNC_AUTO_SHM_LIMIT=1
+        export OPTIMIZED_PARALLEL_ASYNC=pp_4gpu_${ALIEN_JDL_SITEARCH_TMP} # (64 cores, 1 NUMA, 4 gpu per job, pp)
       else  # PbPb
-        export OPTIMIZED_PARALLEL_ASYNC=PbPb_4gpu # sets the multiplicities to optimized defaults for this configuration (1 Numa, PbPb)
-        export OPTIMIZED_PARALLEL_ASYNC_AUTO_SHM_LIMIT=1
+        export OPTIMIZED_PARALLEL_ASYNC=PbPb_4gpu_${ALIEN_JDL_SITEARCH_TMP} # (64 cores, 1 NUMA 4 gpu per job, PbPb)
       fi
     fi
-  fi
-else
-  # David, Oct 13th
-  # the optimized settings for the 8 core GRID queue without GPU are
-  # (overwriting the values above)
-  #
-  if [[ "0$ASYNC_PASS_NO_OPTIMIZED_DEFAULTS" != "01" ]]; then
-    if [[ "$ALIEN_JDL_EPNFULLNUMACPUONLY" != 1 ]]; then
-      if [[ $BEAMTYPE == "pp" ]]; then
-        if (( $(echo "$RUN_IR > 800000" | bc -l) )); then
-          export TIMEFRAME_RATE_LIMIT=1
-        elif (( $(echo "$RUN_IR < 50000" | bc -l) )); then
-          export TIMEFRAME_RATE_LIMIT=6
-        else
-          export TIMEFRAME_RATE_LIMIT=3
-        fi
-        export OPTIMIZED_PARALLEL_ASYNC=pp_8cpu # sets the multiplicities to optimized defaults for this configuration (grid)
-        export SHMSIZE=16000000000
-      else # PbPb
-        export TIMEFRAME_RATE_LIMIT=2
-        export OPTIMIZED_PARALLEL_ASYNC=pp_8cpu
-        export SHMSIZE=16000000000
-        export SVERTEX_THREADS=5
-      fi
+  else
+    export SETENV_NO_ULIMIT=1
+    export DPL_DEFAULT_PIPELINE_LENGTH=16 # to avoid memory issues - affects performance, so don't do with GPUs
+    if [[ $ALIEN_JDL_EPNFULLNUMACPUONLY != 1 ]]; then
+      export OPTIMIZED_PARALLEL_ASYNC=8cpu # (8 cores per job, grid)
     else
-      export OPTIMIZED_PARALLEL_ASYNC=pp_64cpu # to use EPNs with full NUMA domain but without GPUs
-      export OPTIMIZED_PARALLEL_ASYNC_AUTO_SHM_LIMIT=1
+      export OPTIMIZED_PARALLEL_ASYNC=pp_64cpu # (64 cores per job, 1 NUMA, EPN)
     fi
   fi
 fi

DATA/production/configurations/asyncReco/setenv_extra.sh

@@ -3,15 +3,6 @@
 
 # process flags passed to the script
 
-if [[ -z "$ALIEN_JDL_USEGPUS" || $ALIEN_JDL_USEGPUS != 1 ]]; then
-  export SETENV_NO_ULIMIT=1
-fi
-
-# to avoid memory issues - we don't do this on the EPNs, since it can affect the performance
-if [[ $ALIEN_JDL_USEGPUS != 1 ]]; then
-  export DPL_DEFAULT_PIPELINE_LENGTH=16
-fi
-
 # check if this is a production on skimmed data
 if grep -q /skimmed/ wn.xml ; then
   export ON_SKIMMED_DATA=1;

DATA/production/workflow-multiplicities.sh

@@ -53,11 +53,23 @@ if [[ ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]]; then
     [[ ! -z ${TIMEFRAME_RATE_LIMIT:-} ]] && unset TIMEFRAME_RATE_LIMIT
     [[ ! -z ${SHMSIZE:-} ]] && unset SHMSIZE
   fi
-  if [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_8cpu" ]]; then
+  if [[ $OPTIMIZED_PARALLEL_ASYNC == "8cpu" ]]; then
     [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && TIMEFRAME_RATE_LIMIT=3
     [[ -z ${SHMSIZE:-} ]] && SHMSIZE=16000000000
     NGPURECOTHREADS=5
-  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_16cpu" ]]; then
+    if [[ $BEAMTYPE == "pp" ]]; then
+      if (( $(echo "$RUN_IR > 800000" | bc -l) )); then
+        TIMEFRAME_RATE_LIMIT=1
+      elif (( $(echo "$RUN_IR < 50000" | bc -l) )); then
+        TIMEFRAME_RATE_LIMIT=6
+      else
+        TIMEFRAME_RATE_LIMIT=3
+      fi
+    else # PbPb
+      TIMEFRAME_RATE_LIMIT=2
+      SVERTEX_THREADS=5
+    fi
+  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "16cpu" ]]; then
     [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && TIMEFRAME_RATE_LIMIT=8
     [[ -z ${SHMSIZE:-} ]] && SHMSIZE=22000000000
     NGPURECOTHREADS=9
@@ -78,20 +90,28 @@ if [[ ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]]; then
     N_MCHCL=3
     N_TOFMATCH=2
     N_TPCENTDEC=3
-  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_1gpu" ]]; then
+  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_1gpu_EPN" || $OPTIMIZED_PARALLEL_ASYNC == "pp_1gpu_EPN_unoptimized" ]]; then
     [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && TIMEFRAME_RATE_LIMIT=8
     [[ -z ${SHMSIZE:-} ]] && SHMSIZE=30000000000
-    N_TOFMATCH=2
-    N_MCHCL=3
-    N_TPCENTDEC=2
-    N_TPCITS=3
+    NGPUS=1
+    GPUTYPE=HIP
+    GPUMEMSIZE=$((25 << 30))
     N_MCHTRK=2
-    N_ITSTRK=3
-    NGPURECOTHREADS=8
+    N_TPCTRK=$NGPUS
+    if [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_1gpu_EPN" ]]; then
+      N_TOFMATCH=2
+      N_MCHCL=3
+      N_TPCENTDEC=2
+      N_TPCITS=3
+      N_ITSTRK=3
+      NGPURECOTHREADS=8
+    else
+      NGPURECOTHREADS=4
+    fi
     NTRDTRKTHREADS=3
     ITSTRK_THREADS=2
     ITSTPC_THREADS=2
-  elif [[ $OPTIMIZED_PARALLEL_ASYNC =~ ^pp_4gpu(_|$) ]]; then
+  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_gpu_NERSC" || $OPTIMIZED_PARALLEL_ASYNC == "pp_4gpu_EPN" ]]; then
     if [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]]; then
       if [[ ! -z ${ALIEN_JDL_LPMANCHORYEAR} && ${ALIEN_JDL_LPMANCHORYEAR} -lt 2023 ]]; then
         TIMEFRAME_RATE_LIMIT=45
@@ -100,19 +120,21 @@ if [[ ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]]; then
       fi
     fi
     [[ -z ${SHMSIZE:-} ]] && SHMSIZE=100000000000
-    if [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_4gpu_NERSC" ]]; then
+    if [[ $OPTIMIZED_PARALLEL_ASYNC == "pp_gpu_NERSC" ]]; then
       NGPUS=1
       GPUTYPE=CUDA
     else
       NGPUS=4
+      GPUTYPE=HIP
     fi
+    GPUMEMSIZE=$((25 << 30))
     NGPURECOTHREADS=8
     NTRDTRKTHREADS=2
     ITSTRK_THREADS=2
     ITSTPC_THREADS=2
     SVERTEX_THREADS=4
     TPCTIMESERIES_THREADS=2
-    N_TPCTRK=4
+    N_TPCTRK=$NGPUS
     N_FWDMATCH=2
     N_PRIMVTXMATCH=1
     N_PRIMVTX=1
@@ -128,16 +150,18 @@ if [[ ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]]; then
     N_ITSTRK=12
     N_ITSCL=2
     export DPL_SMOOTH_RATE_LIMITING=1
-  elif [[ $OPTIMIZED_PARALLEL_ASYNC =~ ^PbPb_4gpu(_|$) ]]; then
+  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "PbPb_gpu_NERSC" || $OPTIMIZED_PARALLEL_ASYNC == "PbPb_4gpu_EPN" ]]; then
     [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && TIMEFRAME_RATE_LIMIT=35
     [[ -z ${SHMSIZE:-} ]] && SHMSIZE=100000000000 # SHM_LIMIT 3/4
     [[ -z ${TIMEFRAME_SHM_LIMIT:-} ]] && TIMEFRAME_SHM_LIMIT=$(($SHMSIZE / 3))
-    if [[ $OPTIMIZED_PARALLEL_ASYNC == "PbPb_4gpu_NERSC" ]]; then
+    if [[ $OPTIMIZED_PARALLEL_ASYNC == "PbPb_gpu_NERSC" ]]; then
       NGPUS=1
       GPUTYPE=CUDA
     else
       NGPUS=4
+      GPUTYPE=HIP
     fi
+    GPUMEMSIZE=$((25 << 30))
     NGPURECOTHREADS=8
     NTRDTRKTHREADS=8
     ITSTRK_THREADS=5
@@ -172,6 +196,9 @@ if [[ ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]]; then
     N_MCHTRK=1
     N_TOFMATCH=9
     N_TPCTRK=6
+  elif [[ $OPTIMIZED_PARALLEL_ASYNC == "keep_root" ]]; then
+    TIMEFRAME_RATE_LIMIT=4
+    SHMSIZE=30000000000
   else
     echo "Invalid optimized setting '$OPTIMIZED_PARALLEL_ASYNC'" 1>&2
     exit 1

DATA/tools/epn/gen_topo_o2dpg.sh

@@ -94,7 +94,7 @@ while true; do
     done
     git checkout $GEN_TOPO_SOURCE &> /dev/null
     if [[ $? != 0 ]]; then
-      git fetch --tags origin 1>&2 || { echo Repository update failed 1>&2; exit 1; }
+      git fetch -f --tags origin 1>&2 || { echo Repository update failed 1>&2; exit 1; }
       git checkout $GEN_TOPO_SOURCE &> /dev/null || { echo commit does not exist 1>&2; exit 1; }
     fi
     # At a tag, or a detached non-dirty commit, but not on a branch

MC/bin/o2dpg_sim_workflow.py

@@ -1322,6 +1322,7 @@ def getDigiTaskName(det):
    #<--------- TOF-TPC(-ITS) global track matcher workflow
    toftpcmatchneeds = [TOFRECOtask['name'], TPCRECOtask['name'], ITSTPCMATCHtask['name'], TRDTRACKINGtask2['name']]
    toftracksrcdefault = dpl_option_from_config(anchorConfig, 'o2-tof-matcher-workflow', 'track-sources', default_value='TPC,ITS-TPC,TPC-TRD,ITS-TPC-TRD')
+   tofusefit = option_if_available('o2-tof-matcher-workflow', '--use-fit', envfile=async_envfile)
    TOFTPCMATCHERtask = createTask(name='toftpcmatch_'+str(tf), needs=toftpcmatchneeds, tf=tf, cwd=timeframeworkdir, lab=["RECO"], mem='1000')
    tofmatcher_cmd_parts = [
      '${O2_ROOT}/bin/o2-tof-matcher-workflow',
@@ -1332,9 +1333,11 @@ def getDigiTaskName(det):
                       'ITSCATrackerParam',
                       'MFTClustererParam',
                       'GPU_rec_tpc',
+                      'ft0tag',
                       'trackTuneParams'], tpcLocalCFreco),
      ' --track-sources ' + toftracksrcdefault,
      (' --combine-devices','')[args.no_combine_dpl_devices],
+     tofusefit,
      tpc_corr_scaling_options,
      tpc_corr_options_mc
    ]
@@ -1951,11 +1954,11 @@ def remove_json_prefix(path):
    AOD_merge_task['cmd'] = ' set -e ; [ -f aodmerge_input.txt ] && rm aodmerge_input.txt; '
    AOD_merge_task['cmd'] += ' for i in `seq 1 ' + str(NTIMEFRAMES) + '`; do echo "tf${i}/AO2D.root" >> aodmerge_input.txt; done; '
    AOD_merge_task['cmd'] += ' o2-aod-merger --input aodmerge_input.txt --output AO2D_pre.root'
-   # produce MonaLisa event stat file
-   AOD_merge_task['cmd'] += ' ; ${O2DPG_ROOT}/MC/bin/o2dpg_determine_eventstat.py'
    # reindex the BC + connected tables because it there could be duplicate BC entries due to the orbit-early treatment
    # see https://its.cern.ch/jira/browse/O2-6227
    AOD_merge_task['cmd'] += ' ; root -q -b -l "${O2DPG_ROOT}/MC/utils/AODBcRewriter.C(\\\"AO2D_pre.root\\\",\\\"AO2D.root\\\")"'
+   # produce MonaLisa event stat file
+   AOD_merge_task['cmd'] += ' ; ${O2DPG_ROOT}/MC/bin/o2dpg_determine_eventstat.py'
    AOD_merge_task['alternative_alienv_package'] = "None" # we want latest software for this step
    workflow['stages'].append(AOD_merge_task)
 

MC/bin/o2dpg_sim_workflow_anchored.py

@@ -23,7 +23,7 @@
   raise EnvironmentError("O2DPG_ROOT is not set in the environment.")
 mc_prodinfo_path = os.path.abspath(os.path.join(o2dpg_root, "MC", "prodinfo"))
 sys.path.append(mc_prodinfo_path)
-from mcprodinfo_ccdb_upload import MCProdInfo, upload_mcprodinfo_meta, query_mcprodinfo
+from mcprodinfo_ccdb_upload import MCProdInfo, publish_MCProdInfo
 import dataclasses
 
 # Creates a time anchored MC workflow; positioned within a given run-number (as function of production size etc)
@@ -450,14 +450,6 @@ def parse_file(filename):
     print(f"This run as globally {total_excluded_fraction} of it's data marked to be exluded")
     return excluded
 
-def publish_MCProdInfo(mc_prod_info, ccdb_url = "https://alice-ccdb.cern.ch", username = "aliprod", include_meta_into_aod=False):
-   print("Publishing MCProdInfo")
-
-   # see if this already has meta-data uploaded, otherwise do nothing
-   mc_prod_info_q = query_mcprodinfo(ccdb_url, username, mc_prod_info.RunNumber, mc_prod_info.LPMProductionTag)
-   if mc_prod_info_q == None:
-    # could make this depend on hash values in future
-    upload_mcprodinfo_meta(ccdb_url, username, mc_prod_info.RunNumber, mc_prod_info.LPMProductionTag, dataclasses.asdict(mc_prod_info))
 
 
 def main():

MC/config/PWGDQ/ini/Generator_InjectedPromptCharmoniaFwdy_TriggerGap_OO5TeV.ini

@@ -0,0 +1,7 @@
+### The external generator derives from GeneratorPythia8.
+[GeneratorExternal]
+fileName=${O2DPG_MC_CONFIG_ROOT}/MC/config/PWGDQ/external/generator/generator_pythia8_withInjectedPromptSignals_gaptriggered_dq.C
+funcName=GeneratorPythia8InjectedPromptCharmoniaGapTriggered(5,11)
+
+[GeneratorPythia8]
+config=${O2DPG_MC_CONFIG_ROOT}/MC/config/PWGDQ/pythia8/generator/pythia8_inel_triggerGap_OO5TeV.cfg

MC/config/PWGDQ/ini/tests/Generator_InjectedPromptCharmoniaFwdy_TriggerGap_OO5TeV.C

@@ -0,0 +1,85 @@
+int External()
+{
+    int checkPdgSignal[] = {443,100443};
+    int checkPdgDecay = 13;
+    double rapiditymin = -4.3; double rapiditymax = -2.3;
+    std::string path{"o2sim_Kine.root"};
+    std::cout << "Check for\nsignal PDG " << checkPdgSignal << "\ndecay PDG " << checkPdgDecay << "\n";
+    TFile file(path.c_str(), "READ");
+    if (file.IsZombie()) {
+        std::cerr << "Cannot open ROOT file " << path << "\n";
+        return 1;
+    }
+
+    auto tree = (TTree*)file.Get("o2sim");
+    std::vector<o2::MCTrack>* tracks{};
+    tree->SetBranchAddress("MCTrack", &tracks);
+
+    int nLeptons{};
+    int nAntileptons{};
+    int nLeptonPairs{};
+    int nLeptonPairsToBeDone{};
+    int nSignalJpsi{};
+    int nSignalPsi2S{};
+    int nSignalJpsiWithinAcc{};
+    int nSignalPsi2SWithinAcc{};
+    auto nEvents = tree->GetEntries();
+    o2::steer::MCKinematicsReader mcreader("o2sim", o2::steer::MCKinematicsReader::Mode::kMCKine);
+    Bool_t isInjected = kFALSE;
+
+    for (int i = 0; i < nEvents; i++) {
+        tree->GetEntry(i);
+        for (auto& track : *tracks) {
+            auto pdg = track.GetPdgCode();
+	        auto rapidity =  track.GetRapidity();
+	        auto idMoth = track.getMotherTrackId();
+            if (pdg == checkPdgDecay) {
+                // count leptons
+                nLeptons++;
+            } else if(pdg == -checkPdgDecay) {
+                // count anti-leptons
+                nAntileptons++;
+            } else if (pdg == checkPdgSignal[0] || pdg == checkPdgSignal[1]) {
+                if(idMoth < 0) {
+		            // count signal PDG 
+		            pdg == checkPdgSignal[0] ? nSignalJpsi++ : nSignalPsi2S++;
+                    // count signal PDG within acceptance 
+		            if(rapidity > rapiditymin && rapidity < rapiditymax) { pdg == checkPdgSignal[0] ? nSignalJpsiWithinAcc++ : nSignalPsi2SWithinAcc++;}
+		        }
+		        auto child0 = o2::mcutils::MCTrackNavigator::getDaughter0(track, *tracks);
+                auto child1 = o2::mcutils::MCTrackNavigator::getDaughter1(track, *tracks);
+                if (child0 != nullptr && child1 != nullptr) {
+                    // check for parent-child relations
+                    auto pdg0 = child0->GetPdgCode();
+                    auto pdg1 = child1->GetPdgCode();
+                    std::cout << "First and last children of parent " << checkPdgSignal << " are PDG0: " << pdg0 << " PDG1: " << pdg1 << "\n";
+                    if (std::abs(pdg0) == checkPdgDecay && std::abs(pdg1) == checkPdgDecay && pdg0 == -pdg1) {
+                        nLeptonPairs++;
+                        if (child0->getToBeDone() && child1->getToBeDone()) {
+                            nLeptonPairsToBeDone++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    std::cout << "#events: " << nEvents << "\n"
+              << "#leptons: " << nLeptons << "\n"
+              << "#antileptons: " << nAntileptons << "\n"
+              << "#signal (prompt Jpsi): " << nSignalJpsi << "; within acceptance " << rapiditymin << " < y < " << rapiditymax << " : " << nSignalJpsiWithinAcc << "\n"
+              << "#signal (prompt Psi(2S)): " << nSignalPsi2S << "; within acceptance " << rapiditymin << " < y < " << rapiditymax << " : " << nSignalPsi2SWithinAcc << "\n"
+              << "#lepton pairs: " << nLeptonPairs << "\n"
+              << "#lepton pairs to be done: " << nLeptonPairs << "\n";
+
+
+    if (nLeptonPairs == 0 || nLeptons == 0 || nAntileptons == 0) {
+        std::cerr << "Number of leptons, number of anti-leptons as well as number of lepton pairs should all be greater than 1.\n";
+        return 1;
+    }
+    if (nLeptonPairs != nLeptonPairsToBeDone) {
+        std::cerr << "The number of lepton pairs should be the same as the number of lepton pairs which should be transported.\n";
+        return 1;
+    }
+
+    return 0;
+}