diff --git a/Tutorials/PWGLF/Strangeness/CMakeLists.txt b/Tutorials/PWGLF/Strangeness/CMakeLists.txt index 39734cb836a..6a9ca0389f0 100644 --- a/Tutorials/PWGLF/Strangeness/CMakeLists.txt +++ b/Tutorials/PWGLF/Strangeness/CMakeLists.txt @@ -9,6 +9,6 @@ # granted to it by virtue of its status as an Intergovernmental Organization # or submit itself to any jurisdiction. -add_subdirectory(pp) -add_subdirectory(PbPb) +add_subdirectory(Original) +add_subdirectory(Derived) diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/CMakeLists.txt b/Tutorials/PWGLF/Strangeness/Derived/Analysis/CMakeLists.txt new file mode 100644 index 00000000000..0e08d103af1 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/CMakeLists.txt @@ -0,0 +1,41 @@ +# Copyright 2019-2020 CERN and copyright holders of ALICE O2. +# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# All rights not expressly granted are reserved. +# +# This software is distributed under the terms of the GNU General Public +# License v3 (GPL Version 3), copied verbatim in the file "COPYING". +# +# In applying this license CERN does not waive the privileges and immunities +# granted to it by virtue of its status as an Intergovernmental Organization +# or submit itself to any jurisdiction. + +o2physics_add_dpl_workflow(strangeness-derived-skeleton + SOURCES strangeness_derived_skeleton.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + +o2physics_add_dpl_workflow(strangeness-derived-step0 + SOURCES strangeness_derived_step0.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + +o2physics_add_dpl_workflow(strangeness-derived-step1 + SOURCES strangeness_derived_step1.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + +o2physics_add_dpl_workflow(strangeness-derived-step2 + SOURCES strangeness_derived_step2.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + +o2physics_add_dpl_workflow(strangeness-derived-step3 + SOURCES strangeness_derived_step3.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + +o2physics_add_dpl_workflow(strangeness-derived-step4 + SOURCES strangeness_derived_step4.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME AnalysisTutorial) + diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_skeleton.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_skeleton.json new file mode 100644 index 00000000000..87d588b5e92 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_skeleton.json @@ -0,0 +1,20 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "internal-dpl-aod-spawner": "", + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step0.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step0.json new file mode 100644 index 00000000000..87d588b5e92 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step0.json @@ -0,0 +1,20 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "internal-dpl-aod-spawner": "", + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step1.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step1.json new file mode 100644 index 00000000000..77ae6a5bab8 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step1.json @@ -0,0 +1,31 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "cascadesetting_cospa": "0.998", + "cascadesetting_v0cospa": "0.97", + "cascadesetting_dcacascdau": "1", + "cascadesetting_dcav0dau": "1", + "cascadesetting_dcabachtopv": "0.06", + "cascadesetting_dcapostopv": "0.06", + "cascadesetting_dcanegtopv": "0.06", + "cascadesetting_mindcav0topv": "0.01", + "cascadesetting_cascradius": "0.5", + "cascadesetting_v0radius": "1.2", + "cascadesetting_v0masswindow": "0.008", + "cascadesetting_competingmassrej": "0.008" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step2.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step2.json new file mode 100644 index 00000000000..29e4354e5ae --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step2.json @@ -0,0 +1,34 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "cascadesetting_cospa": "0.998", + "cascadesetting_v0cospa": "0.96999999999999997", + "cascadesetting_dcacascdau": "1", + "cascadesetting_dcav0dau": "1", + "cascadesetting_dcabachtopv": "0.0599999987", + "cascadesetting_dcapostopv": "0.0599999987", + "cascadesetting_dcanegtopv": "0.0599999987", + "cascadesetting_mindcav0topv": "0.00999999978", + "cascadesetting_cascradius": "0.5", + "cascadesetting_v0radius": "1.20000005", + "cascadesetting_v0masswindow": "0.00800000038", + "cascadesetting_competingmassrej": "0.00800000038", + "NSigmaTPCPion": "3", + "NSigmaTPCKaon": "3", + "NSigmaTPCProton": "3" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step3.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step3.json new file mode 100644 index 00000000000..d9decaee05c --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step3.json @@ -0,0 +1,212 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "strangenesstofpid": { + "v0Calibration.qaMassWindow": "0.005", + "axisP": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "axisRatioMethods": { + "values": [ + 400, + 0.8999999761581421, + 1.899999976158142 + ] + }, + "v0Calibration.qaCosPA": "0.999", + "rejectUndefinedTof": "1", + "v0Calibration.qaDCADau": "0.5", + "axisDeltaTime": { + "values": [ + 2000, + -1000, + 1000 + ] + }, + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "v0Calibration.qaTPCNSigma": "5", + "ccdb.lutPath": "GLO/Param/MatLUT", + "axisDeltaTimeVsPrimaryCalculation": { + "values": [ + 500, + -500, + 500 + ] + }, + "axisEta": { + "values": [ + 20, + -1, + 1 + ] + }, + "axisTimeLong": { + "values": [ + 3000, + -1500000, + 1500000 + ] + }, + "calculationMethod": "0", + "calculateCascades": "-1", + "cascadeCalibration.qaV0DCADau": "0.5", + "axisNSigma": { + "values": [ + 200, + -10, + 10 + ] + }, + "axisSmallP": { + "values": [ + 250, + 0, + 2.5 + ] + }, + "manualRunNumber": "544122", + "calculateV0TOFPIDs": "-1", + "cascadeCalibration.qaCascCosPA": "0.995", + "processDerivedData": "1", + "calculateV0s": "-1", + "cascadeCalibration.qaCascDCADau": "0.5", + "cascadeCalibration.qaMassWindow": "0.005", + "axisBCshift": { + "values": [ + 130, + -3006569.541579235, + 237032.45348549983 + ] + }, + "doBCshift": "1", + "useCustomRunNumber": "1", + "axisPosition": { + "values": [ + 400, + -400, + 400 + ] + }, + "processStandardData": "0", + "axisTime": { + "values": [ + 400, + 10000, + 50000 + ] + }, + "calculateCascTOFPIDs": "-1", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "calculateV0TOFDebugs": "-1", + "axisSnp": { + "values": [ + 220, + -1.100000023841858, + 1.100000023841858 + ] + }, + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "ccdb.grpPath": "GLO/GRP/GRP", + "doNSigmas": "1", + "calculateV0TOFBetas": "-1", + "reassociateTracks": "1", + "ccdb.nSigmaPath": "Users/d/ddobrigk/stratof", + "doQA": "0", + "cascadeCalibration.qaV0CosPA": "0.995", + "cascadeCalibration.qaTPCNSigma": "5", + "d_bz": "-999", + "tofPosition": "377.934", + "doQANSigma": "0" + }, + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "cascadesetting_cospa": "0.998", + "cascadesetting_v0cospa": "0.96999999999999997", + "cascadesetting_dcacascdau": "1", + "cascadesetting_dcav0dau": "1", + "cascadesetting_dcabachtopv": "0.0599999987", + "cascadesetting_dcapostopv": "0.0599999987", + "cascadesetting_dcanegtopv": "0.0599999987", + "cascadesetting_mindcav0topv": "0.00999999978", + "cascadesetting_cascradius": "0.5", + "cascadesetting_v0radius": "1.20000005", + "cascadesetting_v0masswindow": "0.00800000038", + "cascadesetting_competingmassrej": "0.00800000038", + "NSigmaTPCPion": "3", + "NSigmaTPCKaon": "3", + "NSigmaTPCProton": "3", + "NSigmaTOFPion": "3", + "NSigmaTOFKaon": "3", + "NSigmaTOFProton": "3" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step4.json b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step4.json new file mode 100644 index 00000000000..d9decaee05c --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/configuration_step4.json @@ -0,0 +1,212 @@ +{ + "internal-dpl-clock": "", + "internal-dpl-aod-reader": { + "aod-file-private": "@input_data.txt", + "time-limit": "0", + "orbit-offset-enumeration": "0", + "orbit-multiplier-enumeration": "0", + "start-value-enumeration": "0", + "end-value-enumeration": "-1", + "step-value-enumeration": "1" + }, + "strangenesstofpid": { + "v0Calibration.qaMassWindow": "0.005", + "axisP": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "axisRatioMethods": { + "values": [ + 400, + 0.8999999761581421, + 1.899999976158142 + ] + }, + "v0Calibration.qaCosPA": "0.999", + "rejectUndefinedTof": "1", + "v0Calibration.qaDCADau": "0.5", + "axisDeltaTime": { + "values": [ + 2000, + -1000, + 1000 + ] + }, + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "v0Calibration.qaTPCNSigma": "5", + "ccdb.lutPath": "GLO/Param/MatLUT", + "axisDeltaTimeVsPrimaryCalculation": { + "values": [ + 500, + -500, + 500 + ] + }, + "axisEta": { + "values": [ + 20, + -1, + 1 + ] + }, + "axisTimeLong": { + "values": [ + 3000, + -1500000, + 1500000 + ] + }, + "calculationMethod": "0", + "calculateCascades": "-1", + "cascadeCalibration.qaV0DCADau": "0.5", + "axisNSigma": { + "values": [ + 200, + -10, + 10 + ] + }, + "axisSmallP": { + "values": [ + 250, + 0, + 2.5 + ] + }, + "manualRunNumber": "544122", + "calculateV0TOFPIDs": "-1", + "cascadeCalibration.qaCascCosPA": "0.995", + "processDerivedData": "1", + "calculateV0s": "-1", + "cascadeCalibration.qaCascDCADau": "0.5", + "cascadeCalibration.qaMassWindow": "0.005", + "axisBCshift": { + "values": [ + 130, + -3006569.541579235, + 237032.45348549983 + ] + }, + "doBCshift": "1", + "useCustomRunNumber": "1", + "axisPosition": { + "values": [ + 400, + -400, + 400 + ] + }, + "processStandardData": "0", + "axisTime": { + "values": [ + 400, + 10000, + 50000 + ] + }, + "calculateCascTOFPIDs": "-1", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "calculateV0TOFDebugs": "-1", + "axisSnp": { + "values": [ + 220, + -1.100000023841858, + 1.100000023841858 + ] + }, + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "ccdb.grpPath": "GLO/GRP/GRP", + "doNSigmas": "1", + "calculateV0TOFBetas": "-1", + "reassociateTracks": "1", + "ccdb.nSigmaPath": "Users/d/ddobrigk/stratof", + "doQA": "0", + "cascadeCalibration.qaV0CosPA": "0.995", + "cascadeCalibration.qaTPCNSigma": "5", + "d_bz": "-999", + "tofPosition": "377.934", + "doQANSigma": "0" + }, + "strangeness_derived_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "cascadesetting_cospa": "0.998", + "cascadesetting_v0cospa": "0.96999999999999997", + "cascadesetting_dcacascdau": "1", + "cascadesetting_dcav0dau": "1", + "cascadesetting_dcabachtopv": "0.0599999987", + "cascadesetting_dcapostopv": "0.0599999987", + "cascadesetting_dcanegtopv": "0.0599999987", + "cascadesetting_mindcav0topv": "0.00999999978", + "cascadesetting_cascradius": "0.5", + "cascadesetting_v0radius": "1.20000005", + "cascadesetting_v0masswindow": "0.00800000038", + "cascadesetting_competingmassrej": "0.00800000038", + "NSigmaTPCPion": "3", + "NSigmaTPCKaon": "3", + "NSigmaTPCProton": "3", + "NSigmaTOFPion": "3", + "NSigmaTOFKaon": "3", + "NSigmaTOFProton": "3" + }, + "internal-dpl-aod-writer": "", + "internal-dpl-aod-global-analysis-file-sink": "", + "internal-dpl-injected-dummy-sink": "" +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_skeleton.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_skeleton.sh new file mode 100644 index 00000000000..ed8c18dc09c --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_skeleton.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="skeleton" +LOGFILE="log-${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_skeleton.json" + +o2-analysistutorial-lf-strangeness-derived-skeleton ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/${STEP}/${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step0.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step0.sh new file mode 100644 index 00000000000..d916e41af6a --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step0.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="0" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step0.json" + +o2-analysistutorial-lf-strangeness-derived-step0 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step1.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step1.sh new file mode 100644 index 00000000000..f5f0b069d8b --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step1.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="1" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step1.json" + +o2-analysistutorial-lf-strangeness-derived-step1 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step2.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step2.sh new file mode 100644 index 00000000000..5729987a8c5 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step2.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="2" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step2.json" + +o2-analysistutorial-lf-strangeness-derived-step2 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step3.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step3.sh new file mode 100644 index 00000000000..e51731d18e4 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step3.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="3" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step3.json" + +o2-analysis-lf-strangenesstofpid ${OPTION} | o2-analysistutorial-lf-strangeness-derived-step3 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step4.sh b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step4.sh new file mode 100644 index 00000000000..7b258879a22 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/run_step4.sh @@ -0,0 +1,24 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="4" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step4.json" + +o2-analysis-lf-strangenesstofpid ${OPTION} | o2-analysistutorial-lf-strangeness-derived-step4 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_skeleton.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_skeleton.cxx new file mode 100644 index 00000000000..13b030a6b02 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_skeleton.cxx @@ -0,0 +1,65 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + void init(InitContext const&) + { + // Axes + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + + void process(soa::Filtered>::iterator const& collision) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step0.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step0.cxx new file mode 100644 index 00000000000..fa3b71c7b35 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step0.cxx @@ -0,0 +1,84 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +// STEP 0 +// Starting point: loop over all cascades and fill invariant mass histogram + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rXi{"xi", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rOmega{"omega", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + void init(InitContext const&) + { + // Axes + AxisSpec XiMassAxis = {100, 1.28f, 1.36f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec OmegaMassAxis = {100, 1.63f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + + // Xi/Omega reconstruction + rXi.add("hMassXi", "hMassXi", {HistType::kTH1F, {XiMassAxis}}); + + rOmega.add("hMassOmega", "hMassOmega", {HistType::kTH1F, {OmegaMassAxis}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + + void process(soa::Filtered>::iterator const& collision, + aod::CascCores const& Cascades) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + + // Cascades + for (const auto& casc : Cascades) { + rXi.fill(HIST("hMassXi"), casc.mXi()); + rOmega.fill(HIST("hMassOmega"), casc.mOmega()); + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step1.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step1.cxx new file mode 100644 index 00000000000..f9211528626 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step1.cxx @@ -0,0 +1,144 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +// STEP 0 +// Starting point: loop over all cascades and fill invariant mass histogram +// STEP 1 +// Apply selections on topological variables of Cascades + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rXi{"xi", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rOmega{"omega", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + // Configurable parameters for cascade selection + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.98, "Casc CosPA"}; + Configurable cascadesetting_v0cospa{"cascadesetting_v0cospa", 0.97, "V0 CosPA"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "DCA cascade daughters"}; + Configurable cascadesetting_dcav0dau{"cascadesetting_dcav0dau", 1.0, "DCA v0 daughters"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.06, "DCA bachelor to PV"}; + Configurable cascadesetting_dcapostopv{"cascadesetting_dcapostopv", 0.06, "DCA positive to PV"}; + Configurable cascadesetting_dcanegtopv{"cascadesetting_dcanegtopv", 0.06, "DCA negative to PV"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "minimum V0 DCA to PV"}; + Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascradius"}; + Configurable cascadesetting_v0radius{"cascadesetting_v0radius", 1.2, "v0radius"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "v0 mass window"}; + Configurable cascadesetting_competingmassrej{"cascadesetting_competingmassrej", 0.008, "Competing mass rejection"}; + + void init(InitContext const&) + { + // Axes + AxisSpec XiMassAxis = {100, 1.28f, 1.36f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec OmegaMassAxis = {100, 1.63f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + + // Xi/Omega reconstruction + rXi.add("hMassXi", "hMassXi", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelected", "hMassXiSelected", {HistType::kTH1F, {XiMassAxis}}); + + rOmega.add("hMassOmega", "hMassOmega", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelected", "hMassOmegaSelected", {HistType::kTH1F, {OmegaMassAxis}}); + + // Xi/Omega topological cuts + rXi.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rXi.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + + rOmega.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rOmega.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + + // Filters on Cascades + // Cannot filter on dynamic columns + Filter preFilterCascades = (aod::cascdata::dcaV0daughters < cascadesetting_dcav0dau && + nabs(aod::cascdata::dcapostopv) > cascadesetting_dcapostopv && + nabs(aod::cascdata::dcanegtopv) > cascadesetting_dcanegtopv && + nabs(aod::cascdata::dcabachtopv) > cascadesetting_dcabachtopv && + aod::cascdata::dcacascdaughters < cascadesetting_dcacascdau); + + void process(soa::Filtered>::iterator const& collision, + soa::Filtered> const& Cascades) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + + // Cascades + for (const auto& casc : Cascades) { + rXi.fill(HIST("hMassXi"), casc.mXi()); + rOmega.fill(HIST("hMassOmega"), casc.mOmega()); + + // Cut on dynamic columns + if (casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_cospa) + continue; + if (casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_v0cospa) + continue; + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda) > cascadesetting_v0masswindow) + continue; + if (casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_mindcav0topv) + continue; + if (casc.cascradius() < cascadesetting_cascradius) + continue; + if (casc.v0radius() < cascadesetting_v0radius) + continue; + + // Fill histograms! (if possible) + rXi.fill(HIST("hMassXiSelected"), casc.mXi()); + + rXi.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rXi.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadesetting_competingmassrej) { // competing mass rejection, only in case of Omega + rOmega.fill(HIST("hMassOmegaSelected"), casc.mOmega()); + + rOmega.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rOmega.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step2.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step2.cxx new file mode 100644 index 00000000000..a52df4fc576 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step2.cxx @@ -0,0 +1,180 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +// STEP 0 +// Starting point: loop over all cascades and fill invariant mass histogram +// STEP 1 +// Apply selections on topological variables of Cascades +// STEP 2 +// Apply TPC PID selections on cascade daughter tracks + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rXi{"xi", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rOmega{"omega", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + // Configurable parameters for cascade selection + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.98, "Casc CosPA"}; + Configurable cascadesetting_v0cospa{"cascadesetting_v0cospa", 0.97, "V0 CosPA"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "DCA cascade daughters"}; + Configurable cascadesetting_dcav0dau{"cascadesetting_dcav0dau", 1.0, "DCA v0 daughters"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.06, "DCA bachelor to PV"}; + Configurable cascadesetting_dcapostopv{"cascadesetting_dcapostopv", 0.06, "DCA positive to PV"}; + Configurable cascadesetting_dcanegtopv{"cascadesetting_dcanegtopv", 0.06, "DCA negative to PV"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "minimum V0 DCA to PV"}; + Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascradius"}; + Configurable cascadesetting_v0radius{"cascadesetting_v0radius", 1.2, "v0radius"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "v0 mass window"}; + Configurable cascadesetting_competingmassrej{"cascadesetting_competingmassrej", 0.008, "Competing mass rejection"}; + + // Configurable parameters for PID selection + Configurable NSigmaTPCPion{"NSigmaTPCPion", 4, "NSigmaTPCPion"}; + Configurable NSigmaTPCKaon{"NSigmaTPCKaon", 4, "NSigmaTPCKaon"}; + Configurable NSigmaTPCProton{"NSigmaTPCProton", 4, "NSigmaTPCProton"}; + + void init(InitContext const&) + { + // Axes + AxisSpec XiMassAxis = {100, 1.28f, 1.36f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec OmegaMassAxis = {100, 1.63f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + + // Xi/Omega reconstruction + rXi.add("hMassXi", "hMassXi", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelected", "hMassXiSelected", {HistType::kTH1F, {XiMassAxis}}); + + rOmega.add("hMassOmega", "hMassOmega", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelected", "hMassOmegaSelected", {HistType::kTH1F, {OmegaMassAxis}}); + + // Xi/Omega topological cuts + rXi.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rXi.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + + rOmega.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rOmega.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + + // Filters on Cascades + // Cannot filter on dynamic columns + Filter preFilterCascades = (aod::cascdata::dcaV0daughters < cascadesetting_dcav0dau && + nabs(aod::cascdata::dcapostopv) > cascadesetting_dcapostopv && + nabs(aod::cascdata::dcanegtopv) > cascadesetting_dcanegtopv && + nabs(aod::cascdata::dcabachtopv) > cascadesetting_dcabachtopv && + aod::cascdata::dcacascdaughters < cascadesetting_dcacascdau); + + // Defining the type of the daughter tracks + using dauTracks = soa::Join; + + void process(soa::Filtered>::iterator const& collision, + soa::Filtered> const& Cascades, + dauTracks const&) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + + // Cascades + for (const auto& casc : Cascades) { + const auto& bachDaughterTrackCasc = casc.bachTrackExtra_as(); + const auto& posDaughterTrackCasc = casc.posTrackExtra_as(); + const auto& negDaughterTrackCasc = casc.negTrackExtra_as(); + + rXi.fill(HIST("hMassXi"), casc.mXi()); + rOmega.fill(HIST("hMassOmega"), casc.mOmega()); + + // Cut on dynamic columns + if (casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_cospa) + continue; + if (casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_v0cospa) + continue; + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda) > cascadesetting_v0masswindow) + continue; + if (casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_mindcav0topv) + continue; + if (casc.cascradius() < cascadesetting_cascradius) + continue; + if (casc.v0radius() < cascadesetting_v0radius) + continue; + + // PID selection + if (casc.sign() < 0) { + if (std::abs(posDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(negDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } else { + if (std::abs(negDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(posDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } + + // Fill histograms! (if possible) + if (std::abs(bachDaughterTrackCasc.tpcNSigmaPi()) < NSigmaTPCPion) { // Xi case + rXi.fill(HIST("hMassXiSelected"), casc.mXi()); + + rXi.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rXi.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + if (std::abs(bachDaughterTrackCasc.tpcNSigmaKa()) < NSigmaTPCKaon) { // Omega case + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadesetting_competingmassrej) { // competing mass rejection, only in case of Omega + rOmega.fill(HIST("hMassOmegaSelected"), casc.mOmega()); + + rOmega.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rOmega.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step3.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step3.cxx new file mode 100644 index 00000000000..1894aa39146 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step3.cxx @@ -0,0 +1,242 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +// STEP 0 +// Starting point: loop over all cascades and fill invariant mass histogram +// STEP 1 +// Apply selections on topological variables of Cascades +// STEP 2 +// Apply TPC PID selections on cascade daughter tracks +// STEP 3 +// Apply TOF PID selections on cascade daugther tracks (if info is available) + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rXi{"xi", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rOmega{"omega", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + // Configurable parameters for cascade selection + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.98, "Casc CosPA"}; + Configurable cascadesetting_v0cospa{"cascadesetting_v0cospa", 0.97, "V0 CosPA"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "DCA cascade daughters"}; + Configurable cascadesetting_dcav0dau{"cascadesetting_dcav0dau", 1.0, "DCA v0 daughters"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.06, "DCA bachelor to PV"}; + Configurable cascadesetting_dcapostopv{"cascadesetting_dcapostopv", 0.06, "DCA positive to PV"}; + Configurable cascadesetting_dcanegtopv{"cascadesetting_dcanegtopv", 0.06, "DCA negative to PV"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "minimum V0 DCA to PV"}; + Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascradius"}; + Configurable cascadesetting_v0radius{"cascadesetting_v0radius", 1.2, "v0radius"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "v0 mass window"}; + Configurable cascadesetting_competingmassrej{"cascadesetting_competingmassrej", 0.008, "Competing mass rejection"}; + + // Configurable parameters for PID selection + Configurable NSigmaTPCPion{"NSigmaTPCPion", 4, "NSigmaTPCPion"}; + Configurable NSigmaTPCKaon{"NSigmaTPCKaon", 4, "NSigmaTPCKaon"}; + Configurable NSigmaTPCProton{"NSigmaTPCProton", 4, "NSigmaTPCProton"}; + + // Configurable parameters for TOF PID selection + Configurable NSigmaTOFPion{"NSigmaTOFPion", 3, "NSigmaTOFPion"}; + Configurable NSigmaTOFKaon{"NSigmaTOFKaon", 3, "NSigmaTOFKaon"}; + Configurable NSigmaTOFProton{"NSigmaTOFProton", 3, "NSigmaTOFProton"}; + + void init(InitContext const&) + { + // Axes + AxisSpec XiMassAxis = {100, 1.28f, 1.36f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec OmegaMassAxis = {100, 1.63f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + + // Xi/Omega reconstruction + rXi.add("hMassXi", "hMassXi", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelected", "hMassXiSelected", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelectedWithTOF", "hMassXiSelectedWithTOF", {HistType::kTH1F, {XiMassAxis}}); + + rOmega.add("hMassOmega", "hMassOmega", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelected", "hMassOmegaSelected", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelectedWithTOF", "hMassOmegaSelectedWithTOF", {HistType::kTH1F, {OmegaMassAxis}}); + + // Xi/Omega topological cuts + rXi.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rXi.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + + rOmega.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rOmega.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + + // Filters on Cascades + // Cannot filter on dynamic columns + Filter preFilterCascades = (aod::cascdata::dcaV0daughters < cascadesetting_dcav0dau && + nabs(aod::cascdata::dcapostopv) > cascadesetting_dcapostopv && + nabs(aod::cascdata::dcanegtopv) > cascadesetting_dcanegtopv && + nabs(aod::cascdata::dcabachtopv) > cascadesetting_dcabachtopv && + aod::cascdata::dcacascdaughters < cascadesetting_dcacascdau); + + // Defining the type of the daughter tracks + using dauTracks = soa::Join; + + void process(soa::Filtered>::iterator const& collision, + soa::Filtered> const& Cascades, + dauTracks const&) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + + // Cascades + for (const auto& casc : Cascades) { + const auto& bachDaughterTrackCasc = casc.bachTrackExtra_as(); + const auto& posDaughterTrackCasc = casc.posTrackExtra_as(); + const auto& negDaughterTrackCasc = casc.negTrackExtra_as(); + + rXi.fill(HIST("hMassXi"), casc.mXi()); + rOmega.fill(HIST("hMassOmega"), casc.mOmega()); + + // Cut on dynamic columns + if (casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_cospa) + continue; + if (casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_v0cospa) + continue; + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda) > cascadesetting_v0masswindow) + continue; + if (casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_mindcav0topv) + continue; + if (casc.cascradius() < cascadesetting_cascradius) + continue; + if (casc.v0radius() < cascadesetting_v0radius) + continue; + + // PID selection + if (casc.sign() < 0) { + if (std::abs(posDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(negDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } else { + if (std::abs(negDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(posDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } + + // TOF PID check + bool xiPassTOFSelection = true; + bool omegaPassTOFSelection = true; + if (casc.sign() < 0) { + if (posDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPr()) > NSigmaTOFProton) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPr()) > NSigmaTOFProton) { + omegaPassTOFSelection &= false; + } + } + if (negDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPi()) > NSigmaTOFPion) { + omegaPassTOFSelection &= false; + } + } + } else { + if (posDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPi()) > NSigmaTOFPion) { + omegaPassTOFSelection &= false; + } + } + if (negDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPr()) > NSigmaTOFProton) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPr()) > NSigmaTOFProton) { + omegaPassTOFSelection &= false; + } + } + } + + if (bachDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmKa()) > NSigmaTOFKaon) { + omegaPassTOFSelection &= false; + } + } + + // Fill histograms! (if possible) + if (std::abs(bachDaughterTrackCasc.tpcNSigmaPi()) < NSigmaTPCPion) { // Xi case + rXi.fill(HIST("hMassXiSelected"), casc.mXi()); + if (xiPassTOFSelection) + rXi.fill(HIST("hMassXiSelectedWithTOF"), casc.mXi()); + + rXi.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rXi.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + if (std::abs(bachDaughterTrackCasc.tpcNSigmaKa()) < NSigmaTPCKaon) { // Omega case + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadesetting_competingmassrej) { // competing mass rejection, only in case of Omega + rOmega.fill(HIST("hMassOmegaSelected"), casc.mOmega()); + if (omegaPassTOFSelection) { + rOmega.fill(HIST("hMassOmegaSelectedWithTOF"), casc.mOmega()); + } + + rOmega.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rOmega.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step4.cxx b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step4.cxx new file mode 100644 index 00000000000..714f30f4c84 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/Analysis/strangeness_derived_step4.cxx @@ -0,0 +1,322 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Step4 of the Strangeness tutorial +/// \author Romain Schotter +/// based on the original codes from: +/// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) +/// \author Chiara De Martin (chiara.de.martin@cern.ch) + +#include "PWGLF/DataModel/LFStrangenessPIDTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +// STEP 0 +// Starting point: loop over all cascades and fill invariant mass histogram +// STEP 1 +// Apply selections on topological variables of Cascades +// STEP 2 +// Apply TPC PID selections on cascade daughter tracks +// STEP 3 +// Apply TOF PID selections on cascade daugther tracks (if info is available) +// STEP 4 +// Check the MC information of the cascades + +struct strangeness_derived_tutorial { + // Histograms are defined with HistogramRegistry + HistogramRegistry rEventSelection{"eventSelection", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rXi{"xi", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rOmega{"omega", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry rGenParticles{"genParticles", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + + // Configurable for histograms + Configurable nBins{"nBins", 100, "N bins in all histos"}; + + // Configurable for event selection + Configurable cutzvertex{"cutzvertex", 10.0f, "Accepted z-vertex range (cm)"}; + + // Configurable parameters for cascade selection + Configurable cascadesetting_cospa{"cascadesetting_cospa", 0.98, "Casc CosPA"}; + Configurable cascadesetting_v0cospa{"cascadesetting_v0cospa", 0.97, "V0 CosPA"}; + Configurable cascadesetting_dcacascdau{"cascadesetting_dcacascdau", 1.0, "DCA cascade daughters"}; + Configurable cascadesetting_dcav0dau{"cascadesetting_dcav0dau", 1.0, "DCA v0 daughters"}; + Configurable cascadesetting_dcabachtopv{"cascadesetting_dcabachtopv", 0.06, "DCA bachelor to PV"}; + Configurable cascadesetting_dcapostopv{"cascadesetting_dcapostopv", 0.06, "DCA positive to PV"}; + Configurable cascadesetting_dcanegtopv{"cascadesetting_dcanegtopv", 0.06, "DCA negative to PV"}; + Configurable cascadesetting_mindcav0topv{"cascadesetting_mindcav0topv", 0.01, "minimum V0 DCA to PV"}; + Configurable cascadesetting_cascradius{"cascadesetting_cascradius", 0.5, "cascradius"}; + Configurable cascadesetting_v0radius{"cascadesetting_v0radius", 1.2, "v0radius"}; + Configurable cascadesetting_v0masswindow{"cascadesetting_v0masswindow", 0.01, "v0 mass window"}; + Configurable cascadesetting_competingmassrej{"cascadesetting_competingmassrej", 0.008, "Competing mass rejection"}; + + // Configurable parameters for PID selection + Configurable NSigmaTPCPion{"NSigmaTPCPion", 4, "NSigmaTPCPion"}; + Configurable NSigmaTPCKaon{"NSigmaTPCKaon", 4, "NSigmaTPCKaon"}; + Configurable NSigmaTPCProton{"NSigmaTPCProton", 4, "NSigmaTPCProton"}; + + // Configurable parameters for TOF PID selection + Configurable NSigmaTOFPion{"NSigmaTOFPion", 3, "NSigmaTOFPion"}; + Configurable NSigmaTOFKaon{"NSigmaTOFKaon", 3, "NSigmaTOFKaon"}; + Configurable NSigmaTOFProton{"NSigmaTOFProton", 3, "NSigmaTOFProton"}; + + void init(InitContext const&) + { + // Axes + AxisSpec XiMassAxis = {100, 1.28f, 1.36f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec OmegaMassAxis = {100, 1.63f, 1.7f, "#it{M}_{inv} [GeV/#it{c}^{2}]"}; + AxisSpec vertexZAxis = {nBins, -15., 15., "vrtx_{Z} [cm]"}; + AxisSpec ptAxis = {100, 0.0f, 10.0f, "#it{p}_{T} (GeV/#it{c})"}; + + // Histograms + // Event selection + rEventSelection.add("hVertexZRec", "hVertexZRec", {HistType::kTH1F, {vertexZAxis}}); + + // Xi/Omega reconstruction + rXi.add("hMassXi", "hMassXi", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelected", "hMassXiSelected", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiSelectedWithTOF", "hMassXiSelectedWithTOF", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hMassXiTrueRec", "hMassXiTrueRec", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hPtXiTrueRec", "hPtXiTrueRec", {HistType::kTH1F, {ptAxis}}); + rXi.add("hMassXiTrueRecWithTOF", "hMassXiTrueRecWithTOF", {HistType::kTH1F, {XiMassAxis}}); + rXi.add("hPtXiTrueRecWithTOF", "hPtXiTrueRecWithTOF", {HistType::kTH1F, {ptAxis}}); + + rOmega.add("hMassOmega", "hMassOmega", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelected", "hMassOmegaSelected", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaSelectedWithTOF", "hMassOmegaSelectedWithTOF", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hMassOmegaTrueRec", "hMassOmegaTrueRec", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hPtOmegaTrueRec", "hPtOmegaTrueRec", {HistType::kTH1F, {ptAxis}}); + rOmega.add("hMassOmegaTrueRecWithTOF", "hMassOmegaTrueRecWithTOF", {HistType::kTH1F, {OmegaMassAxis}}); + rOmega.add("hPtOmegaTrueRecWithTOF", "hPtOmegaTrueRecWithTOF", {HistType::kTH1F, {ptAxis}}); + + // Xi/Omega topological cuts + rXi.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rXi.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + + rOmega.add("hCascDCAV0Daughters", "hCascDCAV0Daughters", {HistType::kTH1F, {{55, 0.0f, 2.2f}}}); + rOmega.add("hCascCosPA", "hCascCosPA", {HistType::kTH1F, {{100, 0.95f, 1.f}}}); + + // Generated level histograms + rEventSelection.add("hVertexZGen", "hVertexZGen", {HistType::kTH1F, {vertexZAxis}}); + rGenParticles.add("hPtXiGen", "hPtXiGen", {HistType::kTH1F, {{ptAxis}}}); + rGenParticles.add("hPtOmegaGen", "hPtOmegaGen", {HistType::kTH1F, {{ptAxis}}}); + } + + // Defining filters for events (event selection) + // Processed events will be already fulfilling the event selection requirements + Filter eventFilter = (o2::aod::evsel::sel8 == true); + Filter posZFilter = (nabs(o2::aod::collision::posZ) < cutzvertex); + Filter posZFilterMC = (nabs(o2::aod::mccollision::posZ) < cutzvertex); + + // Filters on Cascades + // Cannot filter on dynamic columns + Filter preFilterCascades = (aod::cascdata::dcaV0daughters < cascadesetting_dcav0dau && + nabs(aod::cascdata::dcapostopv) > cascadesetting_dcapostopv && + nabs(aod::cascdata::dcanegtopv) > cascadesetting_dcanegtopv && + nabs(aod::cascdata::dcabachtopv) > cascadesetting_dcabachtopv && + aod::cascdata::dcacascdaughters < cascadesetting_dcacascdau); + + // Defining the type of the daughter tracks + using dauTracks = soa::Join; + + void processRecMC(soa::Filtered>::iterator const& collision, + soa::Filtered> const& Cascades, + dauTracks const&, + aod::CascMCCores const& /*cascmccores*/) + { + // Fill the event counter + rEventSelection.fill(HIST("hVertexZRec"), collision.posZ()); + + // Cascades + for (const auto& casc : Cascades) { + const auto& bachDaughterTrackCasc = casc.bachTrackExtra_as(); + const auto& posDaughterTrackCasc = casc.posTrackExtra_as(); + const auto& negDaughterTrackCasc = casc.negTrackExtra_as(); + + rXi.fill(HIST("hMassXi"), casc.mXi()); + rOmega.fill(HIST("hMassOmega"), casc.mOmega()); + + // Cut on dynamic columns + if (casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_cospa) + continue; + if (casc.v0cosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_v0cospa) + continue; + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda) > cascadesetting_v0masswindow) + continue; + if (casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_mindcav0topv) + continue; + if (casc.cascradius() < cascadesetting_cascradius) + continue; + if (casc.v0radius() < cascadesetting_v0radius) + continue; + + // PID selection + if (casc.sign() < 0) { + if (std::abs(posDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(negDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } else { + if (std::abs(negDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + continue; + } + if (std::abs(posDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + continue; + } + } + + // TOF PID check + bool xiPassTOFSelection = true; + bool omegaPassTOFSelection = true; + if (casc.sign() < 0) { + if (posDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPr()) > NSigmaTOFProton) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPr()) > NSigmaTOFProton) { + omegaPassTOFSelection &= false; + } + } + if (negDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPi()) > NSigmaTOFPion) { + omegaPassTOFSelection &= false; + } + } + } else { + if (posDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPi()) > NSigmaTOFPion) { + omegaPassTOFSelection &= false; + } + } + if (negDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiLaPr()) > NSigmaTOFProton) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmLaPr()) > NSigmaTOFProton) { + omegaPassTOFSelection &= false; + } + } + } + + if (bachDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmKa()) > NSigmaTOFKaon) { + omegaPassTOFSelection &= false; + } + } + + if (bachDaughterTrackCasc.hasTOF()) { + if (std::abs(casc.tofNSigmaXiPi()) > NSigmaTOFPion) { + xiPassTOFSelection &= false; + } + if (std::abs(casc.tofNSigmaOmKa()) > NSigmaTOFKaon) { + omegaPassTOFSelection &= false; + } + } + + // Fill histograms! (if possible) + if (std::abs(bachDaughterTrackCasc.tpcNSigmaPi()) < NSigmaTPCPion) { // Xi case + rXi.fill(HIST("hMassXiSelected"), casc.mXi()); + if (xiPassTOFSelection) { + rXi.fill(HIST("hMassXiSelectedWithTOF"), casc.mXi()); + } + + rXi.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rXi.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + if (std::abs(bachDaughterTrackCasc.tpcNSigmaKa()) < NSigmaTPCKaon) { // Omega case + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadesetting_competingmassrej) { // competing mass rejection, only in case of Omega + rOmega.fill(HIST("hMassOmegaSelected"), casc.mOmega()); + if (omegaPassTOFSelection) { + rOmega.fill(HIST("hMassOmegaSelectedWithTOF"), casc.mOmega()); + } + + rOmega.fill(HIST("hCascDCAV0Daughters"), casc.dcaV0daughters()); + rOmega.fill(HIST("hCascCosPA"), casc.casccosPA(collision.posX(), collision.posY(), collision.posZ())); + } + } + + // MC truth info + if (!casc.has_cascMCCore()) { + continue; + } + auto cascmccore = casc.cascMCCore_as(); + + // Checking that the cascade is a true Xi + if (std::abs(cascmccore.pdgCode()) == PDG_t::kXiMinus) { + if (std::abs(bachDaughterTrackCasc.tpcNSigmaPi()) < NSigmaTPCPion) { // Xi case + rXi.fill(HIST("hMassXiTrueRec"), casc.mXi()); + rXi.fill(HIST("hPtXiTrueRec"), casc.pt()); + if (xiPassTOFSelection) { + rXi.fill(HIST("hMassXiTrueRecWithTOF"), casc.mXi()); + rXi.fill(HIST("hPtXiTrueRecWithTOF"), casc.pt()); + } + } + } + if (std::abs(cascmccore.pdgCode()) == PDG_t::kOmegaMinus) { + if (std::abs(bachDaughterTrackCasc.tpcNSigmaKa()) < NSigmaTPCKaon) { // Omega case + if (std::abs(casc.mXi() - o2::constants::physics::MassXiMinus) > cascadesetting_competingmassrej) { // competing mass rejection, only in case of Omega + rOmega.fill(HIST("hMassOmegaTrueRec"), casc.mOmega()); + rOmega.fill(HIST("hPtOmegaTrueRec"), casc.pt()); + if (omegaPassTOFSelection) { + rOmega.fill(HIST("hMassOmegaTrueRecWithTOF"), casc.mOmega()); + rOmega.fill(HIST("hPtOmegaTrueRecWithTOF"), casc.pt()); + } + } + } + } + } + } + + void processGenMC(soa::Filtered::iterator const& mcCollision, + const soa::SmallGroups>& collisions, + const soa::SmallGroups>& cascMC) + { + if (collisions.size() < 1) // to process generated collisions that've been reconstructed at least once + return; + rEventSelection.fill(HIST("hVertexZGen"), mcCollision.posZ()); + + for (const auto& cascmc : cascMC) { + if (std::abs(cascmc.pdgCode()) == PDG_t::kXiMinus) { + rGenParticles.fill(HIST("hPtXiGen"), cascmc.ptMC()); + } + if (std::abs(cascmc.pdgCode()) == PDG_t::kOmegaMinus) { + rGenParticles.fill(HIST("hPtOmegaGen"), cascmc.ptMC()); + } + } + } + + PROCESS_SWITCH(strangeness_derived_tutorial, processRecMC, "Process Run 3 mc, reconstructed", true); + PROCESS_SWITCH(strangeness_derived_tutorial, processGenMC, "Process Run 3 mc, generated", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} diff --git a/Tutorials/PWGLF/Strangeness/Derived/CMakeLists.txt b/Tutorials/PWGLF/Strangeness/Derived/CMakeLists.txt new file mode 100644 index 00000000000..f593f821726 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/CMakeLists.txt @@ -0,0 +1,13 @@ +# Copyright 2019-2020 CERN and copyright holders of ALICE O2. +# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +# All rights not expressly granted are reserved. +# +# This software is distributed under the terms of the GNU General Public +# License v3 (GPL Version 3), copied verbatim in the file "COPYING". +# +# In applying this license CERN does not waive the privileges and immunities +# granted to it by virtue of its status as an Intergovernmental Organization +# or submit itself to any jurisdiction. + +add_subdirectory(Analysis) +# add_subdirectory(DerivedDataProduction) \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/Data/run.sh b/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/Data/run.sh new file mode 100644 index 00000000000..01daa27ed26 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/Data/run.sh @@ -0,0 +1,32 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="deriveddata" +LOGFILE="log-${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-pid-tof-merge ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysis-lf-strangederivedbuilder ${OPTION} --aod-file @input_data.txt --aod-writer-json OutputDirector.json >"$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/${STEP}/AnalysisResults.root" + mv AO2D.root "${DIR_THIS}/results/${STEP}/AO2D.root" + mv dpl-config.json "${DIR_THIS}/results/${STEP}/${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi diff --git a/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/MC/runMC.sh b/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/MC/runMC.sh new file mode 100644 index 00000000000..94b0950c05e --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Derived/DerivedDataProduction/MC/runMC.sh @@ -0,0 +1,33 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="deriveddata" +LOGFILE="log-${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configurationMC.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-mccollisionextra ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-pid-tof-merge ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysis-lf-strangederivedbuilder ${OPTION} --aod-file @input_dataMC.txt --aod-writer-json OutputDirectorMC.json >"$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/${STEP}/AnalysisResults.root" + mv AO2D.root "${DIR_THIS}/results/${STEP}/AO2D.root" + mv dpl-config.json "${DIR_THIS}/results/${STEP}/${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi diff --git a/Tutorials/PWGLF/Strangeness/pp/CMakeLists.txt b/Tutorials/PWGLF/Strangeness/Original/CMakeLists.txt similarity index 100% rename from Tutorials/PWGLF/Strangeness/pp/CMakeLists.txt rename to Tutorials/PWGLF/Strangeness/Original/CMakeLists.txt diff --git a/Tutorials/PWGLF/Strangeness/Original/configuration_step0.json b/Tutorials/PWGLF/Strangeness/Original/configuration_step0.json new file mode 100644 index 00000000000..f770087747e --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/configuration_step0.json @@ -0,0 +1,582 @@ +{ + "track-selection": { + "ptMax": "1e+10", + "produceTable": "-1", + "etaMin": "-1", + "isRun3": "1", + "itsMatching": "1", + "etaMax": "1", + "compatibilityIU": "0", + "dcaSetup": "0", + "ptMin": "0.1", + "produceFBextendedTable": "-1" + }, + "ft0-corrected-table": { + "ccdb-timestamp": "-1", + "resoFT0C": "20", + "ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "resoFT0A": "20", + "collisionSystem": "-2", + "addHistograms": "0", + "ccdb-url": "http://alice-ccdb.cern.ch", + "processWithBypassFT0timeInMC": "0", + "processStandard": "1" + }, + "mult-cent-table": { + "generatorName": "", + "processRun3WithGlobalCounters": "0", + "processMFT": "0", + "processRun3": "1", + "processCentralityRun2": "0", + "processRun2": "0", + "processMonteCarlo2Mults": "0", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "maxPtGlobalTrack": "1e+10", + "embedINELgtZEROselection": "0", + "minPtGlobalTrack": "0.15", + "autoConfigureProcess": "0", + "ccdbPathCentrality": "Centrality/Estimators", + "doVertexZeq": "1", + "ccdbPathVtxZ": "Centrality/Calibration", + "minNclsITSibGlobalTrack": "1", + "reconstructionPass": "", + "ccdburl": "http://alice-ccdb.cern.ch", + "processCentralityRun3": "1", + "minNclsITSGlobalTrack": "5", + "processMonteCarlo": "0" + }, + "eventselection-run3": { + "timestamp.fatalOnInvalidTimestamp": "0", + "evselOpts.NumberOfOrbitsPerTF": "-1", + "evselOpts.TimeRangeVetoOnCollNarrow": "0.25", + "evselOpts.VzDiffNsigma": "3", + "evselOpts.maxDiffZvtxFT0vsPV": "1", + "bcselOpts.checkRunDurationLimits": "0", + "evselOpts.amIneeded": "-1", + "evselOpts.EpsilonVzDiffVetoInROF": "0.3", + "evselOpts.isMC": "-1", + "bcselOpts.ITSROFrameStartBorderMargin": "-1", + "timestamp.isRun2MC": "-1", + "bcselOpts.TimeFrameStartBorderMargin": "-1", + "bcselOpts.triggerBcShift": "0", + "evselOpts.FT0CamplPerCollCutVetoOnCollInROF": "5000", + "timestamp.orbit-reset-path": "CTP/Calib/OrbitReset", + "evselOpts.TimeIntervalForOccupancyCalculationMin": "-40", + "evselOpts.TimeRangeVetoOnCollStrict": "10", + "timestamp.rct-path": "RCT/Info/RunInformation", + "bcselOpts.maxInactiveChipsPerLayer": { + "values": [ + 8, + 8, + 8, + 111, + 111, + 195, + 195 + ] + }, + "lumiOpts.amIneeded": "-1", + "evselOpts.confSigmaBCforHighPtTracks": "4", + "evselOpts.FT0CamplPerCollCutVetoOnCollInTimeRange": "8000", + "bcselOpts.ITSROFrameEndBorderMargin": "-1", + "evselOpts.VzDiffMargin": "0.2", + "bcselOpts.amIneeded": "-1", + "evselOpts.TimeIntervalForOccupancyCalculationMax": "100", + "ccdburl": "http://alice-ccdb.cern.ch", + "evselOpts.muonSelection": "0", + "evselOpts.UseWeightsForOccupancyEstimator": "1", + "timestamp.verbose": "0", + "bcselOpts.TimeFrameEndBorderMargin": "-1", + "bcselOpts.NumberOfOrbitsPerTF": "-1" + }, + "pid-tpc-service": { + "pidTPC.pid-tiny-mu": "-1", + "pidTPC.pid-tiny-el": "-1", + "pidTPC.ccdb-timestamp": "0", + "pidTPC.enableNetworkOptimizations": "1", + "pidTPC.pid-full-ka": "-1", + "pidTPC.skipTPCOnly": "-1", + "pidTPC.pid-tiny-al": "-1", + "pidTPC.networkPathCCDB": "Analysis/PID/TPC/ML", + "pidTPC.useNetworkAl": "0", + "pidTPC.autofetchNetworks": "1", + "pidTPC.useNetworkEl": "1", + "processTracksIU": "1", + "pidTPC.ccdbPath": "Analysis/PID/TPC/Response", + "pidTPC.useNetworkMu": "0", + "pidTPC.enableTuneOnDataTable": "-1", + "pidTPC.pid-full-mu": "-1", + "pidTPC.networkPathLocally": "network.onnx", + "processTracksIUWithTracksQA": "0", + "pidTPC.pid-full-el": "-1", + "pidTPC.pid-tiny-pi": "-1", + "pidTPC.ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "pidTPC.pid-tiny-tr": "-1", + "pidTPC.useNetworkDe": "0", + "pidTPC.pid-full-al": "-1", + "pidTPC.pid-tiny-he": "-1", + "pidTPC.useNetworkPr": "1", + "pidTPC.recoPass": "", + "pidTPC.pid-tiny-pr": "-1", + "pidTPC.useNetworkHe": "0", + "pidTPC.pid-tiny-de": "-1", + "pidTPC.useNetworkTr": "0", + "pidTPC.useNetworkPi": "1", + "pidTPC.pid-full-pi": "-1", + "pidTPC.useNetworkKa": "1", + "pidTPC.pid-full-he": "-1", + "pidTPC.pid-full-de": "-1", + "pidTPC.pid-full-tr": "-1", + "pidTPC.param-file": "", + "pidTPC.useCorrecteddEdx": "0", + "pidTPC.networkSetNumThreads": "0", + "pidTPC.pid-full-pr": "-1", + "pidTPC.pid-tiny-ka": "-1", + "pidTPC.networkBetaGammaCutoff": "0.45", + "pidTPC.devicesRequiringTPCOnlyPID": { + "values": [ + "photon-conversion-builder" + ] + }, + "pidTPC.useNetworkCorrection": "1", + "ccdburl": "http://alice-ccdb.cern.ch", + "pidTPC.savedEdxsCorrected": "-1", + "processTracksMCIU": "0" + }, + "propagation-service": { + "trackTuner.updateCurvature": "0", + "cascadeBuilderOpts.mc_findableDetachedCascade": "0", + "processMonteCarloWithPID": "0", + "cascadeBuilderOpts.minCrossedRows": "-1", + "preSelectOpts.preselectOnlyDesiredCascades": "1", + "v0BuilderOpts.mc_addGeneratedGammaMakeCollinear": "1", + "cascadeBuilderOpts.maxDaughterEta": "1.5", + "ccdb.lutPath": "GLO/Param/MatLUTInner", + "v0BuilderOpts.mc_addGeneratedK0Short": "0", + "cascadeBuilderOpts.dcabachtopv": "0.05", + "trackTuner.updateTrackCovMat": "0", + "cascadeBuilderOpts.useCascadeMomentumAtPrimVtx": "0", + "cascadeBuilderOpts.mc_addGeneratedOmegaPlus": "0", + "cascadeBuilderOpts.kfUseV0MassConstraint": "1", + "trackPropagation.fillTrackTunerTable": "0", + "v0BuilderOpts.v0radius": "0.9", + "cascadeBuilderOpts.kfConstructMethod": "2", + "v0BuilderOpts.dcanegtopv": "0.05", + "v0BuilderOpts.mc_addGeneratedLambda": "0", + "cascadeBuilderOpts.casccospa": "0.97", + "cascadeBuilderOpts.mc_addGeneratedOmegaMinus": "0", + "preSelectOpts.lifetimeCut": { + "values": [ + [ + 20, + 60, + 40, + 20 + ] + ] + }, + "trackPropagation.useTrackTuner": "0", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "preSelectOpts.maxTPCpidNsigma": "5", + "trackTuner.updateTrackDCAs": "0", + "cascadeBuilderOpts.kfTuneForOmega": "0", + "trackTuner.pathInputFile": "", + "preSelectOpts.preselectOnlyDesiredV0s": "1", + "preSelectOpts.massWindowSafetyMargin": "0.001", + "trackTuner.updateCurvatureIU": "0", + "cascadeBuilderOpts.mc_addGeneratedXiPlus": "0", + "preSelectOpts.massCutXi": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "trackPropagation.trackTunerParams": "debugInfo=0|updateTrackDCAs=1|updateTrackCovMat=1|updateCurvature=0|updateCurvatureIU=0|updatePulls=0|isInputFileFromCCDB=1|pathInputFile=Users/m/mfaggin/test/inputsTrackTuner/PbPb2022|nameInputFile=trackTuner_DataLHC22sPass5_McLHC22l1b2_run529397.root|pathFileQoverPt=Users/h/hsharma/qOverPtGraphs|nameFileQoverPt=D0sigma_Data_removal_itstps_MC_LHC22b1b.root|usePvRefitCorrections=0|qOverPtMC=-1.|qOverPtData=-1.", + "v0BuilderOpts.minCrossedRows": "-1", + "processRealDataWithPID": "1", + "trackPropagation.trackTunerConfigSource": "1", + "refitWithMaterialCorrection": "0", + "cascadeBuilderOpts.cascradius": "0.9", + "cascadeBuilderOpts.mc_treatPiToMuDecays": "1", + "processRealData": "0", + "v0BuilderOpts.mc_populateV0MCCoresSymmetric": "1", + "preSelectOpts.massWindownumberOfSigmas": "20", + "trackTuner.usePvRefitCorrections": "0", + "v0BuilderOpts.mc_addGeneratedGamma": "0", + "v0BuilderOpts.moveTPCOnlyTracks": "1", + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "v0BuilderOpts.dcav0dau": "1.5", + "v0BuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_rapidityWindow": "0.5", + "trackTuner.isInputFileFromCCDB": "0", + "trackTuner.nameInputFile": "", + "v0BuilderOpts.maxDaughterEta": "1.5", + "useV0BufferForCascades": "0", + "v0BuilderOpts.mc_addGeneratedAntiLambda": "0", + "v0BuilderOpts.v0cospa": "0.97", + "deduplicationAlgorithm": "1", + "cascadeBuilderOpts.lambdaMassWindow": "0.01", + "preSelectOpts.massCutOm": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "cascadeBuilderOpts.dcacascdau": "1.5", + "trackTuner.updatePulls": "0", + "processMonteCarlo": "0", + "v0BuilderOpts.mc_populateV0MCCoresAsymmetric": "0", + "preSelectOpts.massCutLambda": { + "values": [ + [ + 0.0011751799611374736, + 0.00012409899500198662, + 0.005479369778186083, + 0.30800899863243103 + ] + ] + }, + "trackTuner.nPhiBins": "0", + "cascadeBuilderOpts.mc_populateCascMCCoresSymmetric": "1", + "v0BuilderOpts.generatePhotonCandidates": "1", + "preSelectOpts.massCutK0": { + "values": [ + [ + 0.0028188200667500496, + 0.0011405700352042913, + 0.0017213800456374884, + 0.5002620220184326 + ] + ] + }, + "trackTuner.pathFileQoverPt": "", + "trackTuner.qOverPtMC": "-1", + "v0BuilderOpts.mc_rapidityWindow": "0.5", + "trackPropagation.axisPtQA": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "cascadeBuilderOpts.kfDoDCAFitterPreMinimCasc": "1", + "v0BuilderOpts.dcapostopv": "0.05", + "preSelectOpts.massCutPhoton": "0.3", + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "cascadeBuilderOpts.kfDoDCAFitterPreMinimV0": "1", + "cascadeBuilderOpts.mc_populateCascMCCoresAsymmetric": "0", + "v0BuilderOpts.mc_findableDetachedV0": "0", + "trackPropagation.useTrkPid": "0", + "trackTuner.nameFileQoverPt": "", + "cascadeBuilderOpts.kfUseCascadeMassConstraint": "0", + "trackTuner.qOverPtData": "-1", + "v0BuilderOpts.mc_treatPiToMuDecays": "1", + "trackTuner.debugInfo": "0", + "trackPropagation.minPropagationDistance": "5", + "ccdburl": "http://alice-ccdb.cern.ch", + "cascadeBuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_addGeneratedXiMinus": "0", + "mc_findableMode": "0" + }, + "strangeness_tutorial": { + "nBins": "100", + "cutzvertex": "10" + } +} diff --git a/Tutorials/PWGLF/Strangeness/Original/configuration_step1.json b/Tutorials/PWGLF/Strangeness/Original/configuration_step1.json new file mode 100644 index 00000000000..bca1d319025 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/configuration_step1.json @@ -0,0 +1,587 @@ +{ + "track-selection": { + "ptMax": "1e+10", + "produceTable": "-1", + "etaMin": "-1", + "isRun3": "1", + "itsMatching": "1", + "etaMax": "1", + "compatibilityIU": "0", + "dcaSetup": "0", + "ptMin": "0.1", + "produceFBextendedTable": "-1" + }, + "ft0-corrected-table": { + "ccdb-timestamp": "-1", + "resoFT0C": "20", + "ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "resoFT0A": "20", + "collisionSystem": "-2", + "addHistograms": "0", + "ccdb-url": "http://alice-ccdb.cern.ch", + "processWithBypassFT0timeInMC": "0", + "processStandard": "1" + }, + "mult-cent-table": { + "generatorName": "", + "processRun3WithGlobalCounters": "0", + "processMFT": "0", + "processRun3": "1", + "processCentralityRun2": "0", + "processRun2": "0", + "processMonteCarlo2Mults": "0", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "maxPtGlobalTrack": "1e+10", + "embedINELgtZEROselection": "0", + "minPtGlobalTrack": "0.15", + "autoConfigureProcess": "0", + "ccdbPathCentrality": "Centrality/Estimators", + "doVertexZeq": "1", + "ccdbPathVtxZ": "Centrality/Calibration", + "minNclsITSibGlobalTrack": "1", + "reconstructionPass": "", + "ccdburl": "http://alice-ccdb.cern.ch", + "processCentralityRun3": "1", + "minNclsITSGlobalTrack": "5", + "processMonteCarlo": "0" + }, + "eventselection-run3": { + "timestamp.fatalOnInvalidTimestamp": "0", + "evselOpts.NumberOfOrbitsPerTF": "-1", + "evselOpts.TimeRangeVetoOnCollNarrow": "0.25", + "evselOpts.VzDiffNsigma": "3", + "evselOpts.maxDiffZvtxFT0vsPV": "1", + "bcselOpts.checkRunDurationLimits": "0", + "evselOpts.amIneeded": "-1", + "evselOpts.EpsilonVzDiffVetoInROF": "0.3", + "evselOpts.isMC": "-1", + "bcselOpts.ITSROFrameStartBorderMargin": "-1", + "timestamp.isRun2MC": "-1", + "bcselOpts.TimeFrameStartBorderMargin": "-1", + "bcselOpts.triggerBcShift": "0", + "evselOpts.FT0CamplPerCollCutVetoOnCollInROF": "5000", + "timestamp.orbit-reset-path": "CTP/Calib/OrbitReset", + "evselOpts.TimeIntervalForOccupancyCalculationMin": "-40", + "evselOpts.TimeRangeVetoOnCollStrict": "10", + "timestamp.rct-path": "RCT/Info/RunInformation", + "bcselOpts.maxInactiveChipsPerLayer": { + "values": [ + 8, + 8, + 8, + 111, + 111, + 195, + 195 + ] + }, + "lumiOpts.amIneeded": "-1", + "evselOpts.confSigmaBCforHighPtTracks": "4", + "evselOpts.FT0CamplPerCollCutVetoOnCollInTimeRange": "8000", + "bcselOpts.ITSROFrameEndBorderMargin": "-1", + "evselOpts.VzDiffMargin": "0.2", + "bcselOpts.amIneeded": "-1", + "evselOpts.TimeIntervalForOccupancyCalculationMax": "100", + "ccdburl": "http://alice-ccdb.cern.ch", + "evselOpts.muonSelection": "0", + "evselOpts.UseWeightsForOccupancyEstimator": "1", + "timestamp.verbose": "0", + "bcselOpts.TimeFrameEndBorderMargin": "-1", + "bcselOpts.NumberOfOrbitsPerTF": "-1" + }, + "pid-tpc-service": { + "pidTPC.pid-tiny-mu": "-1", + "pidTPC.pid-tiny-el": "-1", + "pidTPC.ccdb-timestamp": "0", + "pidTPC.enableNetworkOptimizations": "1", + "pidTPC.pid-full-ka": "-1", + "pidTPC.skipTPCOnly": "-1", + "pidTPC.pid-tiny-al": "-1", + "pidTPC.networkPathCCDB": "Analysis/PID/TPC/ML", + "pidTPC.useNetworkAl": "0", + "pidTPC.autofetchNetworks": "1", + "pidTPC.useNetworkEl": "1", + "processTracksIU": "1", + "pidTPC.ccdbPath": "Analysis/PID/TPC/Response", + "pidTPC.useNetworkMu": "0", + "pidTPC.enableTuneOnDataTable": "-1", + "pidTPC.pid-full-mu": "-1", + "pidTPC.networkPathLocally": "network.onnx", + "processTracksIUWithTracksQA": "0", + "pidTPC.pid-full-el": "-1", + "pidTPC.pid-tiny-pi": "-1", + "pidTPC.ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "pidTPC.pid-tiny-tr": "-1", + "pidTPC.useNetworkDe": "0", + "pidTPC.pid-full-al": "-1", + "pidTPC.pid-tiny-he": "-1", + "pidTPC.useNetworkPr": "1", + "pidTPC.recoPass": "", + "pidTPC.pid-tiny-pr": "-1", + "pidTPC.useNetworkHe": "0", + "pidTPC.pid-tiny-de": "-1", + "pidTPC.useNetworkTr": "0", + "pidTPC.useNetworkPi": "1", + "pidTPC.pid-full-pi": "-1", + "pidTPC.useNetworkKa": "1", + "pidTPC.pid-full-he": "-1", + "pidTPC.pid-full-de": "-1", + "pidTPC.pid-full-tr": "-1", + "pidTPC.param-file": "", + "pidTPC.useCorrecteddEdx": "0", + "pidTPC.networkSetNumThreads": "0", + "pidTPC.pid-full-pr": "-1", + "pidTPC.pid-tiny-ka": "-1", + "pidTPC.networkBetaGammaCutoff": "0.45", + "pidTPC.devicesRequiringTPCOnlyPID": { + "values": [ + "photon-conversion-builder" + ] + }, + "pidTPC.useNetworkCorrection": "1", + "ccdburl": "http://alice-ccdb.cern.ch", + "pidTPC.savedEdxsCorrected": "-1", + "processTracksMCIU": "0" + }, + "propagation-service": { + "trackTuner.updateCurvature": "0", + "cascadeBuilderOpts.mc_findableDetachedCascade": "0", + "processMonteCarloWithPID": "0", + "cascadeBuilderOpts.minCrossedRows": "-1", + "preSelectOpts.preselectOnlyDesiredCascades": "1", + "v0BuilderOpts.mc_addGeneratedGammaMakeCollinear": "1", + "cascadeBuilderOpts.maxDaughterEta": "1.5", + "ccdb.lutPath": "GLO/Param/MatLUTInner", + "v0BuilderOpts.mc_addGeneratedK0Short": "0", + "cascadeBuilderOpts.dcabachtopv": "0.05", + "trackTuner.updateTrackCovMat": "0", + "cascadeBuilderOpts.useCascadeMomentumAtPrimVtx": "0", + "cascadeBuilderOpts.mc_addGeneratedOmegaPlus": "0", + "cascadeBuilderOpts.kfUseV0MassConstraint": "1", + "trackPropagation.fillTrackTunerTable": "0", + "v0BuilderOpts.v0radius": "0.9", + "cascadeBuilderOpts.kfConstructMethod": "2", + "v0BuilderOpts.dcanegtopv": "0.05", + "v0BuilderOpts.mc_addGeneratedLambda": "0", + "cascadeBuilderOpts.casccospa": "0.97", + "cascadeBuilderOpts.mc_addGeneratedOmegaMinus": "0", + "preSelectOpts.lifetimeCut": { + "values": [ + [ + 20, + 60, + 40, + 20 + ] + ] + }, + "trackPropagation.useTrackTuner": "0", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "preSelectOpts.maxTPCpidNsigma": "5", + "trackTuner.updateTrackDCAs": "0", + "cascadeBuilderOpts.kfTuneForOmega": "0", + "trackTuner.pathInputFile": "", + "preSelectOpts.preselectOnlyDesiredV0s": "1", + "preSelectOpts.massWindowSafetyMargin": "0.001", + "trackTuner.updateCurvatureIU": "0", + "cascadeBuilderOpts.mc_addGeneratedXiPlus": "0", + "preSelectOpts.massCutXi": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "trackPropagation.trackTunerParams": "debugInfo=0|updateTrackDCAs=1|updateTrackCovMat=1|updateCurvature=0|updateCurvatureIU=0|updatePulls=0|isInputFileFromCCDB=1|pathInputFile=Users/m/mfaggin/test/inputsTrackTuner/PbPb2022|nameInputFile=trackTuner_DataLHC22sPass5_McLHC22l1b2_run529397.root|pathFileQoverPt=Users/h/hsharma/qOverPtGraphs|nameFileQoverPt=D0sigma_Data_removal_itstps_MC_LHC22b1b.root|usePvRefitCorrections=0|qOverPtMC=-1.|qOverPtData=-1.", + "v0BuilderOpts.minCrossedRows": "-1", + "processRealDataWithPID": "1", + "trackPropagation.trackTunerConfigSource": "1", + "refitWithMaterialCorrection": "0", + "cascadeBuilderOpts.cascradius": "0.9", + "cascadeBuilderOpts.mc_treatPiToMuDecays": "1", + "processRealData": "0", + "v0BuilderOpts.mc_populateV0MCCoresSymmetric": "1", + "preSelectOpts.massWindownumberOfSigmas": "20", + "trackTuner.usePvRefitCorrections": "0", + "v0BuilderOpts.mc_addGeneratedGamma": "0", + "v0BuilderOpts.moveTPCOnlyTracks": "1", + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "v0BuilderOpts.dcav0dau": "1.5", + "v0BuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_rapidityWindow": "0.5", + "trackTuner.isInputFileFromCCDB": "0", + "trackTuner.nameInputFile": "", + "v0BuilderOpts.maxDaughterEta": "1.5", + "useV0BufferForCascades": "0", + "v0BuilderOpts.mc_addGeneratedAntiLambda": "0", + "v0BuilderOpts.v0cospa": "0.97", + "deduplicationAlgorithm": "1", + "cascadeBuilderOpts.lambdaMassWindow": "0.01", + "preSelectOpts.massCutOm": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "cascadeBuilderOpts.dcacascdau": "1.5", + "trackTuner.updatePulls": "0", + "processMonteCarlo": "0", + "v0BuilderOpts.mc_populateV0MCCoresAsymmetric": "0", + "preSelectOpts.massCutLambda": { + "values": [ + [ + 0.0011751799611374736, + 0.00012409899500198662, + 0.005479369778186083, + 0.30800899863243103 + ] + ] + }, + "trackTuner.nPhiBins": "0", + "cascadeBuilderOpts.mc_populateCascMCCoresSymmetric": "1", + "v0BuilderOpts.generatePhotonCandidates": "1", + "preSelectOpts.massCutK0": { + "values": [ + [ + 0.0028188200667500496, + 0.0011405700352042913, + 0.0017213800456374884, + 0.5002620220184326 + ] + ] + }, + "trackTuner.pathFileQoverPt": "", + "trackTuner.qOverPtMC": "-1", + "v0BuilderOpts.mc_rapidityWindow": "0.5", + "trackPropagation.axisPtQA": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "cascadeBuilderOpts.kfDoDCAFitterPreMinimCasc": "1", + "v0BuilderOpts.dcapostopv": "0.05", + "preSelectOpts.massCutPhoton": "0.3", + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "cascadeBuilderOpts.kfDoDCAFitterPreMinimV0": "1", + "cascadeBuilderOpts.mc_populateCascMCCoresAsymmetric": "0", + "v0BuilderOpts.mc_findableDetachedV0": "0", + "trackPropagation.useTrkPid": "0", + "trackTuner.nameFileQoverPt": "", + "cascadeBuilderOpts.kfUseCascadeMassConstraint": "0", + "trackTuner.qOverPtData": "-1", + "v0BuilderOpts.mc_treatPiToMuDecays": "1", + "trackTuner.debugInfo": "0", + "trackPropagation.minPropagationDistance": "5", + "ccdburl": "http://alice-ccdb.cern.ch", + "cascadeBuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_addGeneratedXiMinus": "0", + "mc_findableMode": "0" + }, + "strangeness_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "v0setting_dcav0dau": "1", + "v0setting_dcapostopv": "0.0599999987", + "v0setting_dcanegtopv": "0.0599999987", + "v0setting_cospa": "0.97999999999999998", + "v0setting_radius": "0.5" + } +} diff --git a/Tutorials/PWGLF/Strangeness/Original/configuration_step2.json b/Tutorials/PWGLF/Strangeness/Original/configuration_step2.json new file mode 100644 index 00000000000..598f51a3b96 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/configuration_step2.json @@ -0,0 +1,588 @@ +{ + "track-selection": { + "ptMax": "1e+10", + "produceTable": "-1", + "etaMin": "-1", + "isRun3": "1", + "itsMatching": "1", + "etaMax": "1", + "compatibilityIU": "0", + "dcaSetup": "0", + "ptMin": "0.1", + "produceFBextendedTable": "-1" + }, + "ft0-corrected-table": { + "ccdb-timestamp": "-1", + "resoFT0C": "20", + "ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "resoFT0A": "20", + "collisionSystem": "-2", + "addHistograms": "0", + "ccdb-url": "http://alice-ccdb.cern.ch", + "processWithBypassFT0timeInMC": "0", + "processStandard": "1" + }, + "mult-cent-table": { + "generatorName": "", + "processRun3WithGlobalCounters": "0", + "processMFT": "0", + "processRun3": "1", + "processCentralityRun2": "0", + "processRun2": "0", + "processMonteCarlo2Mults": "0", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "maxPtGlobalTrack": "1e+10", + "embedINELgtZEROselection": "0", + "minPtGlobalTrack": "0.15", + "autoConfigureProcess": "0", + "ccdbPathCentrality": "Centrality/Estimators", + "doVertexZeq": "1", + "ccdbPathVtxZ": "Centrality/Calibration", + "minNclsITSibGlobalTrack": "1", + "reconstructionPass": "", + "ccdburl": "http://alice-ccdb.cern.ch", + "processCentralityRun3": "1", + "minNclsITSGlobalTrack": "5", + "processMonteCarlo": "0" + }, + "eventselection-run3": { + "timestamp.fatalOnInvalidTimestamp": "0", + "evselOpts.NumberOfOrbitsPerTF": "-1", + "evselOpts.TimeRangeVetoOnCollNarrow": "0.25", + "evselOpts.VzDiffNsigma": "3", + "evselOpts.maxDiffZvtxFT0vsPV": "1", + "bcselOpts.checkRunDurationLimits": "0", + "evselOpts.amIneeded": "-1", + "evselOpts.EpsilonVzDiffVetoInROF": "0.3", + "evselOpts.isMC": "-1", + "bcselOpts.ITSROFrameStartBorderMargin": "-1", + "timestamp.isRun2MC": "-1", + "bcselOpts.TimeFrameStartBorderMargin": "-1", + "bcselOpts.triggerBcShift": "0", + "evselOpts.FT0CamplPerCollCutVetoOnCollInROF": "5000", + "timestamp.orbit-reset-path": "CTP/Calib/OrbitReset", + "evselOpts.TimeIntervalForOccupancyCalculationMin": "-40", + "evselOpts.TimeRangeVetoOnCollStrict": "10", + "timestamp.rct-path": "RCT/Info/RunInformation", + "bcselOpts.maxInactiveChipsPerLayer": { + "values": [ + 8, + 8, + 8, + 111, + 111, + 195, + 195 + ] + }, + "lumiOpts.amIneeded": "-1", + "evselOpts.confSigmaBCforHighPtTracks": "4", + "evselOpts.FT0CamplPerCollCutVetoOnCollInTimeRange": "8000", + "bcselOpts.ITSROFrameEndBorderMargin": "-1", + "evselOpts.VzDiffMargin": "0.2", + "bcselOpts.amIneeded": "-1", + "evselOpts.TimeIntervalForOccupancyCalculationMax": "100", + "ccdburl": "http://alice-ccdb.cern.ch", + "evselOpts.muonSelection": "0", + "evselOpts.UseWeightsForOccupancyEstimator": "1", + "timestamp.verbose": "0", + "bcselOpts.TimeFrameEndBorderMargin": "-1", + "bcselOpts.NumberOfOrbitsPerTF": "-1" + }, + "pid-tpc-service": { + "pidTPC.pid-tiny-mu": "-1", + "pidTPC.pid-tiny-el": "-1", + "pidTPC.ccdb-timestamp": "0", + "pidTPC.enableNetworkOptimizations": "1", + "pidTPC.pid-full-ka": "-1", + "pidTPC.skipTPCOnly": "-1", + "pidTPC.pid-tiny-al": "-1", + "pidTPC.networkPathCCDB": "Analysis/PID/TPC/ML", + "pidTPC.useNetworkAl": "0", + "pidTPC.autofetchNetworks": "1", + "pidTPC.useNetworkEl": "1", + "processTracksIU": "1", + "pidTPC.ccdbPath": "Analysis/PID/TPC/Response", + "pidTPC.useNetworkMu": "0", + "pidTPC.enableTuneOnDataTable": "-1", + "pidTPC.pid-full-mu": "-1", + "pidTPC.networkPathLocally": "network.onnx", + "processTracksIUWithTracksQA": "0", + "pidTPC.pid-full-el": "-1", + "pidTPC.pid-tiny-pi": "-1", + "pidTPC.ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "pidTPC.pid-tiny-tr": "-1", + "pidTPC.useNetworkDe": "0", + "pidTPC.pid-full-al": "-1", + "pidTPC.pid-tiny-he": "-1", + "pidTPC.useNetworkPr": "1", + "pidTPC.recoPass": "", + "pidTPC.pid-tiny-pr": "-1", + "pidTPC.useNetworkHe": "0", + "pidTPC.pid-tiny-de": "-1", + "pidTPC.useNetworkTr": "0", + "pidTPC.useNetworkPi": "1", + "pidTPC.pid-full-pi": "-1", + "pidTPC.useNetworkKa": "1", + "pidTPC.pid-full-he": "-1", + "pidTPC.pid-full-de": "-1", + "pidTPC.pid-full-tr": "-1", + "pidTPC.param-file": "", + "pidTPC.useCorrecteddEdx": "0", + "pidTPC.networkSetNumThreads": "0", + "pidTPC.pid-full-pr": "-1", + "pidTPC.pid-tiny-ka": "-1", + "pidTPC.networkBetaGammaCutoff": "0.45", + "pidTPC.devicesRequiringTPCOnlyPID": { + "values": [ + "photon-conversion-builder" + ] + }, + "pidTPC.useNetworkCorrection": "1", + "ccdburl": "http://alice-ccdb.cern.ch", + "pidTPC.savedEdxsCorrected": "-1", + "processTracksMCIU": "0" + }, + "propagation-service": { + "trackTuner.updateCurvature": "0", + "cascadeBuilderOpts.mc_findableDetachedCascade": "0", + "processMonteCarloWithPID": "0", + "cascadeBuilderOpts.minCrossedRows": "-1", + "preSelectOpts.preselectOnlyDesiredCascades": "1", + "v0BuilderOpts.mc_addGeneratedGammaMakeCollinear": "1", + "cascadeBuilderOpts.maxDaughterEta": "1.5", + "ccdb.lutPath": "GLO/Param/MatLUTInner", + "v0BuilderOpts.mc_addGeneratedK0Short": "0", + "cascadeBuilderOpts.dcabachtopv": "0.05", + "trackTuner.updateTrackCovMat": "0", + "cascadeBuilderOpts.useCascadeMomentumAtPrimVtx": "0", + "cascadeBuilderOpts.mc_addGeneratedOmegaPlus": "0", + "cascadeBuilderOpts.kfUseV0MassConstraint": "1", + "trackPropagation.fillTrackTunerTable": "0", + "v0BuilderOpts.v0radius": "0.9", + "cascadeBuilderOpts.kfConstructMethod": "2", + "v0BuilderOpts.dcanegtopv": "0.05", + "v0BuilderOpts.mc_addGeneratedLambda": "0", + "cascadeBuilderOpts.casccospa": "0.97", + "cascadeBuilderOpts.mc_addGeneratedOmegaMinus": "0", + "preSelectOpts.lifetimeCut": { + "values": [ + [ + 20, + 60, + 40, + 20 + ] + ] + }, + "trackPropagation.useTrackTuner": "0", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "preSelectOpts.maxTPCpidNsigma": "5", + "trackTuner.updateTrackDCAs": "0", + "cascadeBuilderOpts.kfTuneForOmega": "0", + "trackTuner.pathInputFile": "", + "preSelectOpts.preselectOnlyDesiredV0s": "1", + "preSelectOpts.massWindowSafetyMargin": "0.001", + "trackTuner.updateCurvatureIU": "0", + "cascadeBuilderOpts.mc_addGeneratedXiPlus": "0", + "preSelectOpts.massCutXi": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "trackPropagation.trackTunerParams": "debugInfo=0|updateTrackDCAs=1|updateTrackCovMat=1|updateCurvature=0|updateCurvatureIU=0|updatePulls=0|isInputFileFromCCDB=1|pathInputFile=Users/m/mfaggin/test/inputsTrackTuner/PbPb2022|nameInputFile=trackTuner_DataLHC22sPass5_McLHC22l1b2_run529397.root|pathFileQoverPt=Users/h/hsharma/qOverPtGraphs|nameFileQoverPt=D0sigma_Data_removal_itstps_MC_LHC22b1b.root|usePvRefitCorrections=0|qOverPtMC=-1.|qOverPtData=-1.", + "v0BuilderOpts.minCrossedRows": "-1", + "processRealDataWithPID": "1", + "trackPropagation.trackTunerConfigSource": "1", + "refitWithMaterialCorrection": "0", + "cascadeBuilderOpts.cascradius": "0.9", + "cascadeBuilderOpts.mc_treatPiToMuDecays": "1", + "processRealData": "0", + "v0BuilderOpts.mc_populateV0MCCoresSymmetric": "1", + "preSelectOpts.massWindownumberOfSigmas": "20", + "trackTuner.usePvRefitCorrections": "0", + "v0BuilderOpts.mc_addGeneratedGamma": "0", + "v0BuilderOpts.moveTPCOnlyTracks": "1", + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "v0BuilderOpts.dcav0dau": "1.5", + "v0BuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_rapidityWindow": "0.5", + "trackTuner.isInputFileFromCCDB": "0", + "trackTuner.nameInputFile": "", + "v0BuilderOpts.maxDaughterEta": "1.5", + "useV0BufferForCascades": "0", + "v0BuilderOpts.mc_addGeneratedAntiLambda": "0", + "v0BuilderOpts.v0cospa": "0.97", + "deduplicationAlgorithm": "1", + "cascadeBuilderOpts.lambdaMassWindow": "0.01", + "preSelectOpts.massCutOm": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "cascadeBuilderOpts.dcacascdau": "1.5", + "trackTuner.updatePulls": "0", + "processMonteCarlo": "0", + "v0BuilderOpts.mc_populateV0MCCoresAsymmetric": "0", + "preSelectOpts.massCutLambda": { + "values": [ + [ + 0.0011751799611374736, + 0.00012409899500198662, + 0.005479369778186083, + 0.30800899863243103 + ] + ] + }, + "trackTuner.nPhiBins": "0", + "cascadeBuilderOpts.mc_populateCascMCCoresSymmetric": "1", + "v0BuilderOpts.generatePhotonCandidates": "1", + "preSelectOpts.massCutK0": { + "values": [ + [ + 0.0028188200667500496, + 0.0011405700352042913, + 0.0017213800456374884, + 0.5002620220184326 + ] + ] + }, + "trackTuner.pathFileQoverPt": "", + "trackTuner.qOverPtMC": "-1", + "v0BuilderOpts.mc_rapidityWindow": "0.5", + "trackPropagation.axisPtQA": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "cascadeBuilderOpts.kfDoDCAFitterPreMinimCasc": "1", + "v0BuilderOpts.dcapostopv": "0.05", + "preSelectOpts.massCutPhoton": "0.3", + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "cascadeBuilderOpts.kfDoDCAFitterPreMinimV0": "1", + "cascadeBuilderOpts.mc_populateCascMCCoresAsymmetric": "0", + "v0BuilderOpts.mc_findableDetachedV0": "0", + "trackPropagation.useTrkPid": "0", + "trackTuner.nameFileQoverPt": "", + "cascadeBuilderOpts.kfUseCascadeMassConstraint": "0", + "trackTuner.qOverPtData": "-1", + "v0BuilderOpts.mc_treatPiToMuDecays": "1", + "trackTuner.debugInfo": "0", + "trackPropagation.minPropagationDistance": "5", + "ccdburl": "http://alice-ccdb.cern.ch", + "cascadeBuilderOpts.mc_keepOnlyPhysicalPrimary": "0", + "cascadeBuilderOpts.mc_addGeneratedXiMinus": "0", + "mc_findableMode": "0" + }, + "strangeness_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "v0setting_dcav0dau": "1", + "v0setting_dcapostopv": "0.0599999987", + "v0setting_dcanegtopv": "0.0599999987", + "v0setting_cospa": "0.97999999999999998", + "v0setting_radius": "0.5", + "NSigmaTPCPion": "4" + } +} diff --git a/Tutorials/PWGLF/Strangeness/Original/configuration_step3.json b/Tutorials/PWGLF/Strangeness/Original/configuration_step3.json new file mode 100644 index 00000000000..ba83d242dd1 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/configuration_step3.json @@ -0,0 +1,598 @@ +{ + "track-selection": { + "ptMax": "1e+10", + "produceTable": "-1", + "etaMin": "-1", + "isRun3": "1", + "itsMatching": "1", + "etaMax": "1", + "compatibilityIU": "0", + "dcaSetup": "0", + "ptMin": "0.1", + "produceFBextendedTable": "-1" + }, + "ft0-corrected-table": { + "ccdb-timestamp": "-1", + "resoFT0C": "20", + "ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "resoFT0A": "20", + "collisionSystem": "-2", + "addHistograms": "0", + "ccdb-url": "http://alice-ccdb.cern.ch", + "processWithBypassFT0timeInMC": "0", + "processStandard": "1" + }, + "mc-collision-extra": { + "poiEtaWindow": "0.8", + "processNoCentrality": "0", + "pdgCodeOfInterest": "3312", + "processWithCentrality": "1", + "processMcContexts": "0", + "pdgCodeAbsolute": "1" + }, + "mult-cent-table": { + "generatorName": "PYTHIA", + "processRun3WithGlobalCounters": "0", + "processMFT": "0", + "processRun3": "1", + "processCentralityRun2": "0", + "processRun2": "0", + "processMonteCarlo2Mults": "1", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "maxPtGlobalTrack": "1e+10", + "embedINELgtZEROselection": "0", + "minPtGlobalTrack": "0.15", + "autoConfigureProcess": "0", + "ccdbPathCentrality": "Centrality/Estimators", + "doVertexZeq": "1", + "ccdbPathVtxZ": "Centrality/Calibration", + "minNclsITSibGlobalTrack": "1", + "reconstructionPass": "", + "ccdburl": "http://alice-ccdb.cern.ch", + "processCentralityRun3": "1", + "minNclsITSGlobalTrack": "5", + "processMonteCarlo": "1" + }, + "eventselection-run3": { + "timestamp.fatalOnInvalidTimestamp": "0", + "evselOpts.NumberOfOrbitsPerTF": "-1", + "evselOpts.TimeRangeVetoOnCollNarrow": "0.25", + "evselOpts.VzDiffNsigma": "3", + "evselOpts.maxDiffZvtxFT0vsPV": "1", + "bcselOpts.checkRunDurationLimits": "0", + "evselOpts.amIneeded": "-1", + "evselOpts.EpsilonVzDiffVetoInROF": "0.3", + "evselOpts.isMC": "-1", + "bcselOpts.ITSROFrameStartBorderMargin": "-1", + "timestamp.isRun2MC": "-1", + "bcselOpts.TimeFrameStartBorderMargin": "-1", + "bcselOpts.triggerBcShift": "0", + "evselOpts.FT0CamplPerCollCutVetoOnCollInROF": "5000", + "timestamp.orbit-reset-path": "CTP/Calib/OrbitReset", + "evselOpts.TimeIntervalForOccupancyCalculationMin": "-40", + "evselOpts.TimeRangeVetoOnCollStrict": "10", + "timestamp.rct-path": "RCT/Info/RunInformation", + "bcselOpts.maxInactiveChipsPerLayer": { + "values": [ + 8, + 8, + 8, + 111, + 111, + 195, + 195 + ] + }, + "lumiOpts.amIneeded": "-1", + "evselOpts.confSigmaBCforHighPtTracks": "4", + "evselOpts.FT0CamplPerCollCutVetoOnCollInTimeRange": "8000", + "bcselOpts.ITSROFrameEndBorderMargin": "-1", + "evselOpts.VzDiffMargin": "0.2", + "bcselOpts.amIneeded": "-1", + "evselOpts.TimeIntervalForOccupancyCalculationMax": "100", + "ccdburl": "http://alice-ccdb.cern.ch", + "evselOpts.muonSelection": "0", + "evselOpts.UseWeightsForOccupancyEstimator": "1", + "timestamp.verbose": "0", + "bcselOpts.TimeFrameEndBorderMargin": "-1", + "bcselOpts.NumberOfOrbitsPerTF": "-1" + }, + "pid-tpc-service": { + "pidTPC.pid-tiny-mu": "-1", + "pidTPC.pid-tiny-el": "-1", + "pidTPC.ccdb-timestamp": "0", + "pidTPC.enableNetworkOptimizations": "1", + "pidTPC.pid-full-ka": "-1", + "pidTPC.skipTPCOnly": "-1", + "pidTPC.pid-tiny-al": "-1", + "pidTPC.networkPathCCDB": "Analysis/PID/TPC/ML", + "pidTPC.useNetworkAl": "0", + "pidTPC.autofetchNetworks": "1", + "pidTPC.useNetworkEl": "1", + "processTracksIU": "0", + "pidTPC.ccdbPath": "Analysis/PID/TPC/Response", + "pidTPC.useNetworkMu": "0", + "pidTPC.enableTuneOnDataTable": "-1", + "pidTPC.pid-full-mu": "-1", + "pidTPC.networkPathLocally": "network.onnx", + "processTracksIUWithTracksQA": "0", + "pidTPC.pid-full-el": "-1", + "pidTPC.pid-tiny-pi": "-1", + "pidTPC.ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "pidTPC.pid-tiny-tr": "-1", + "pidTPC.useNetworkDe": "0", + "pidTPC.pid-full-al": "-1", + "pidTPC.pid-tiny-he": "-1", + "pidTPC.useNetworkPr": "1", + "pidTPC.recoPass": "", + "pidTPC.pid-tiny-pr": "-1", + "pidTPC.useNetworkHe": "0", + "pidTPC.pid-tiny-de": "-1", + "pidTPC.useNetworkTr": "0", + "pidTPC.useNetworkPi": "1", + "pidTPC.pid-full-pi": "-1", + "pidTPC.useNetworkKa": "1", + "pidTPC.pid-full-he": "-1", + "pidTPC.pid-full-de": "-1", + "pidTPC.pid-full-tr": "-1", + "pidTPC.param-file": "", + "pidTPC.useCorrecteddEdx": "0", + "pidTPC.networkSetNumThreads": "0", + "pidTPC.pid-full-pr": "-1", + "pidTPC.pid-tiny-ka": "-1", + "pidTPC.networkBetaGammaCutoff": "0.45", + "pidTPC.devicesRequiringTPCOnlyPID": { + "values": [ + "photon-conversion-builder" + ] + }, + "pidTPC.useNetworkCorrection": "1", + "ccdburl": "http://alice-ccdb.cern.ch", + "pidTPC.savedEdxsCorrected": "-1", + "processTracksMCIU": "1" + }, + "propagation-service": { + "trackTuner.updateCurvature": "0", + "cascadeBuilderOpts.mc_findableDetachedCascade": "0", + "processMonteCarloWithPID": "0", + "cascadeBuilderOpts.minCrossedRows": "-1", + "preSelectOpts.preselectOnlyDesiredCascades": "0", + "v0BuilderOpts.mc_addGeneratedGammaMakeCollinear": "1", + "cascadeBuilderOpts.maxDaughterEta": "1.5", + "ccdb.lutPath": "GLO/Param/MatLUTInner", + "v0BuilderOpts.mc_addGeneratedK0Short": "1", + "cascadeBuilderOpts.dcabachtopv": "0.05", + "trackTuner.updateTrackCovMat": "0", + "cascadeBuilderOpts.useCascadeMomentumAtPrimVtx": "0", + "cascadeBuilderOpts.mc_addGeneratedOmegaPlus": "1", + "cascadeBuilderOpts.kfUseV0MassConstraint": "1", + "trackPropagation.fillTrackTunerTable": "0", + "v0BuilderOpts.v0radius": "0.9", + "cascadeBuilderOpts.kfConstructMethod": "2", + "v0BuilderOpts.dcanegtopv": "0.05", + "v0BuilderOpts.mc_addGeneratedLambda": "1", + "cascadeBuilderOpts.casccospa": "0.97", + "cascadeBuilderOpts.mc_addGeneratedOmegaMinus": "1", + "preSelectOpts.lifetimeCut": { + "values": [ + [ + 20, + 60, + 40, + 20 + ] + ] + }, + "trackPropagation.useTrackTuner": "0", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "preSelectOpts.maxTPCpidNsigma": "5", + "trackTuner.updateTrackDCAs": "0", + "cascadeBuilderOpts.kfTuneForOmega": "0", + "trackTuner.pathInputFile": "", + "preSelectOpts.preselectOnlyDesiredV0s": "0", + "preSelectOpts.massWindowSafetyMargin": "0.001", + "trackTuner.updateCurvatureIU": "0", + "cascadeBuilderOpts.mc_addGeneratedXiPlus": "1", + "preSelectOpts.massCutXi": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "trackPropagation.trackTunerParams": "debugInfo=0|updateTrackDCAs=1|updateTrackCovMat=1|updateCurvature=0|updateCurvatureIU=0|updatePulls=0|isInputFileFromCCDB=1|pathInputFile=Users/m/mfaggin/test/inputsTrackTuner/PbPb2022|nameInputFile=trackTuner_DataLHC22sPass5_McLHC22l1b2_run529397.root|pathFileQoverPt=Users/h/hsharma/qOverPtGraphs|nameFileQoverPt=D0sigma_Data_removal_itstps_MC_LHC22b1b.root|usePvRefitCorrections=0|qOverPtMC=-1.|qOverPtData=-1.", + "v0BuilderOpts.minCrossedRows": "-1", + "processRealDataWithPID": "0", + "trackPropagation.trackTunerConfigSource": "1", + "refitWithMaterialCorrection": "0", + "cascadeBuilderOpts.cascradius": "0.9", + "cascadeBuilderOpts.mc_treatPiToMuDecays": "1", + "processRealData": "0", + "v0BuilderOpts.mc_populateV0MCCoresSymmetric": "0", + "preSelectOpts.massWindownumberOfSigmas": "20", + "trackTuner.usePvRefitCorrections": "0", + "v0BuilderOpts.mc_addGeneratedGamma": "1", + "v0BuilderOpts.moveTPCOnlyTracks": "1", + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + 1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "v0BuilderOpts.dcav0dau": "1.5", + "v0BuilderOpts.mc_keepOnlyPhysicalPrimary": "1", + "cascadeBuilderOpts.mc_rapidityWindow": "0.5", + "trackTuner.isInputFileFromCCDB": "0", + "trackTuner.nameInputFile": "", + "v0BuilderOpts.maxDaughterEta": "1.5", + "useV0BufferForCascades": "0", + "v0BuilderOpts.mc_addGeneratedAntiLambda": "1", + "v0BuilderOpts.v0cospa": "0.97", + "deduplicationAlgorithm": "1", + "cascadeBuilderOpts.lambdaMassWindow": "0.01", + "preSelectOpts.massCutOm": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "cascadeBuilderOpts.dcacascdau": "1.5", + "trackTuner.updatePulls": "0", + "processMonteCarlo": "1", + "v0BuilderOpts.mc_populateV0MCCoresAsymmetric": "1", + "preSelectOpts.massCutLambda": { + "values": [ + [ + 0.0011751799611374736, + 0.00012409899500198662, + 0.005479369778186083, + 0.30800899863243103 + ] + ] + }, + "trackTuner.nPhiBins": "0", + "cascadeBuilderOpts.mc_populateCascMCCoresSymmetric": "0", + "v0BuilderOpts.generatePhotonCandidates": "1", + "preSelectOpts.massCutK0": { + "values": [ + [ + 0.0028188200667500496, + 0.0011405700352042913, + 0.0017213800456374884, + 0.5002620220184326 + ] + ] + }, + "trackTuner.pathFileQoverPt": "", + "trackTuner.qOverPtMC": "-1", + "v0BuilderOpts.mc_rapidityWindow": "0.5", + "trackPropagation.axisPtQA": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "cascadeBuilderOpts.kfDoDCAFitterPreMinimCasc": "1", + "v0BuilderOpts.dcapostopv": "0.05", + "preSelectOpts.massCutPhoton": "0.3", + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "cascadeBuilderOpts.kfDoDCAFitterPreMinimV0": "1", + "cascadeBuilderOpts.mc_populateCascMCCoresAsymmetric": "1", + "v0BuilderOpts.mc_findableDetachedV0": "0", + "trackPropagation.useTrkPid": "0", + "trackTuner.nameFileQoverPt": "", + "cascadeBuilderOpts.kfUseCascadeMassConstraint": "0", + "trackTuner.qOverPtData": "-1", + "v0BuilderOpts.mc_treatPiToMuDecays": "1", + "trackTuner.debugInfo": "0", + "trackPropagation.minPropagationDistance": "5", + "ccdburl": "http://alice-ccdb.cern.ch", + "cascadeBuilderOpts.mc_keepOnlyPhysicalPrimary": "1", + "cascadeBuilderOpts.mc_addGeneratedXiMinus": "1", + "mc_findableMode": "0" + }, + "strangeness_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "v0setting_dcav0dau": "1", + "v0setting_dcapostopv": "0.0599999987", + "v0setting_dcanegtopv": "0.0599999987", + "v0setting_cospa": "0.97999999999999998", + "v0setting_radius": "0.5", + "NSigmaTPCPion": "4", + "processRecMC": "true", + "processGenMC": "true" + } +} diff --git a/Tutorials/PWGLF/Strangeness/Original/configuration_step4.json b/Tutorials/PWGLF/Strangeness/Original/configuration_step4.json new file mode 100644 index 00000000000..ba83d242dd1 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/configuration_step4.json @@ -0,0 +1,598 @@ +{ + "track-selection": { + "ptMax": "1e+10", + "produceTable": "-1", + "etaMin": "-1", + "isRun3": "1", + "itsMatching": "1", + "etaMax": "1", + "compatibilityIU": "0", + "dcaSetup": "0", + "ptMin": "0.1", + "produceFBextendedTable": "-1" + }, + "ft0-corrected-table": { + "ccdb-timestamp": "-1", + "resoFT0C": "20", + "ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "resoFT0A": "20", + "collisionSystem": "-2", + "addHistograms": "0", + "ccdb-url": "http://alice-ccdb.cern.ch", + "processWithBypassFT0timeInMC": "0", + "processStandard": "1" + }, + "mc-collision-extra": { + "poiEtaWindow": "0.8", + "processNoCentrality": "0", + "pdgCodeOfInterest": "3312", + "processWithCentrality": "1", + "processMcContexts": "0", + "pdgCodeAbsolute": "1" + }, + "mult-cent-table": { + "generatorName": "PYTHIA", + "processRun3WithGlobalCounters": "0", + "processMFT": "0", + "processRun3": "1", + "processCentralityRun2": "0", + "processRun2": "0", + "processMonteCarlo2Mults": "1", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "maxPtGlobalTrack": "1e+10", + "embedINELgtZEROselection": "0", + "minPtGlobalTrack": "0.15", + "autoConfigureProcess": "0", + "ccdbPathCentrality": "Centrality/Estimators", + "doVertexZeq": "1", + "ccdbPathVtxZ": "Centrality/Calibration", + "minNclsITSibGlobalTrack": "1", + "reconstructionPass": "", + "ccdburl": "http://alice-ccdb.cern.ch", + "processCentralityRun3": "1", + "minNclsITSGlobalTrack": "5", + "processMonteCarlo": "1" + }, + "eventselection-run3": { + "timestamp.fatalOnInvalidTimestamp": "0", + "evselOpts.NumberOfOrbitsPerTF": "-1", + "evselOpts.TimeRangeVetoOnCollNarrow": "0.25", + "evselOpts.VzDiffNsigma": "3", + "evselOpts.maxDiffZvtxFT0vsPV": "1", + "bcselOpts.checkRunDurationLimits": "0", + "evselOpts.amIneeded": "-1", + "evselOpts.EpsilonVzDiffVetoInROF": "0.3", + "evselOpts.isMC": "-1", + "bcselOpts.ITSROFrameStartBorderMargin": "-1", + "timestamp.isRun2MC": "-1", + "bcselOpts.TimeFrameStartBorderMargin": "-1", + "bcselOpts.triggerBcShift": "0", + "evselOpts.FT0CamplPerCollCutVetoOnCollInROF": "5000", + "timestamp.orbit-reset-path": "CTP/Calib/OrbitReset", + "evselOpts.TimeIntervalForOccupancyCalculationMin": "-40", + "evselOpts.TimeRangeVetoOnCollStrict": "10", + "timestamp.rct-path": "RCT/Info/RunInformation", + "bcselOpts.maxInactiveChipsPerLayer": { + "values": [ + 8, + 8, + 8, + 111, + 111, + 195, + 195 + ] + }, + "lumiOpts.amIneeded": "-1", + "evselOpts.confSigmaBCforHighPtTracks": "4", + "evselOpts.FT0CamplPerCollCutVetoOnCollInTimeRange": "8000", + "bcselOpts.ITSROFrameEndBorderMargin": "-1", + "evselOpts.VzDiffMargin": "0.2", + "bcselOpts.amIneeded": "-1", + "evselOpts.TimeIntervalForOccupancyCalculationMax": "100", + "ccdburl": "http://alice-ccdb.cern.ch", + "evselOpts.muonSelection": "0", + "evselOpts.UseWeightsForOccupancyEstimator": "1", + "timestamp.verbose": "0", + "bcselOpts.TimeFrameEndBorderMargin": "-1", + "bcselOpts.NumberOfOrbitsPerTF": "-1" + }, + "pid-tpc-service": { + "pidTPC.pid-tiny-mu": "-1", + "pidTPC.pid-tiny-el": "-1", + "pidTPC.ccdb-timestamp": "0", + "pidTPC.enableNetworkOptimizations": "1", + "pidTPC.pid-full-ka": "-1", + "pidTPC.skipTPCOnly": "-1", + "pidTPC.pid-tiny-al": "-1", + "pidTPC.networkPathCCDB": "Analysis/PID/TPC/ML", + "pidTPC.useNetworkAl": "0", + "pidTPC.autofetchNetworks": "1", + "pidTPC.useNetworkEl": "1", + "processTracksIU": "0", + "pidTPC.ccdbPath": "Analysis/PID/TPC/Response", + "pidTPC.useNetworkMu": "0", + "pidTPC.enableTuneOnDataTable": "-1", + "pidTPC.pid-full-mu": "-1", + "pidTPC.networkPathLocally": "network.onnx", + "processTracksIUWithTracksQA": "0", + "pidTPC.pid-full-el": "-1", + "pidTPC.pid-tiny-pi": "-1", + "pidTPC.ccdb-path-grplhcif": "GLO/Config/GRPLHCIF", + "pidTPC.pid-tiny-tr": "-1", + "pidTPC.useNetworkDe": "0", + "pidTPC.pid-full-al": "-1", + "pidTPC.pid-tiny-he": "-1", + "pidTPC.useNetworkPr": "1", + "pidTPC.recoPass": "", + "pidTPC.pid-tiny-pr": "-1", + "pidTPC.useNetworkHe": "0", + "pidTPC.pid-tiny-de": "-1", + "pidTPC.useNetworkTr": "0", + "pidTPC.useNetworkPi": "1", + "pidTPC.pid-full-pi": "-1", + "pidTPC.useNetworkKa": "1", + "pidTPC.pid-full-he": "-1", + "pidTPC.pid-full-de": "-1", + "pidTPC.pid-full-tr": "-1", + "pidTPC.param-file": "", + "pidTPC.useCorrecteddEdx": "0", + "pidTPC.networkSetNumThreads": "0", + "pidTPC.pid-full-pr": "-1", + "pidTPC.pid-tiny-ka": "-1", + "pidTPC.networkBetaGammaCutoff": "0.45", + "pidTPC.devicesRequiringTPCOnlyPID": { + "values": [ + "photon-conversion-builder" + ] + }, + "pidTPC.useNetworkCorrection": "1", + "ccdburl": "http://alice-ccdb.cern.ch", + "pidTPC.savedEdxsCorrected": "-1", + "processTracksMCIU": "1" + }, + "propagation-service": { + "trackTuner.updateCurvature": "0", + "cascadeBuilderOpts.mc_findableDetachedCascade": "0", + "processMonteCarloWithPID": "0", + "cascadeBuilderOpts.minCrossedRows": "-1", + "preSelectOpts.preselectOnlyDesiredCascades": "0", + "v0BuilderOpts.mc_addGeneratedGammaMakeCollinear": "1", + "cascadeBuilderOpts.maxDaughterEta": "1.5", + "ccdb.lutPath": "GLO/Param/MatLUTInner", + "v0BuilderOpts.mc_addGeneratedK0Short": "1", + "cascadeBuilderOpts.dcabachtopv": "0.05", + "trackTuner.updateTrackCovMat": "0", + "cascadeBuilderOpts.useCascadeMomentumAtPrimVtx": "0", + "cascadeBuilderOpts.mc_addGeneratedOmegaPlus": "1", + "cascadeBuilderOpts.kfUseV0MassConstraint": "1", + "trackPropagation.fillTrackTunerTable": "0", + "v0BuilderOpts.v0radius": "0.9", + "cascadeBuilderOpts.kfConstructMethod": "2", + "v0BuilderOpts.dcanegtopv": "0.05", + "v0BuilderOpts.mc_addGeneratedLambda": "1", + "cascadeBuilderOpts.casccospa": "0.97", + "cascadeBuilderOpts.mc_addGeneratedOmegaMinus": "1", + "preSelectOpts.lifetimeCut": { + "values": [ + [ + 20, + 60, + 40, + 20 + ] + ] + }, + "trackPropagation.useTrackTuner": "0", + "ccdb.mVtxPath": "GLO/Calib/MeanVertex", + "preSelectOpts.maxTPCpidNsigma": "5", + "trackTuner.updateTrackDCAs": "0", + "cascadeBuilderOpts.kfTuneForOmega": "0", + "trackTuner.pathInputFile": "", + "preSelectOpts.preselectOnlyDesiredV0s": "0", + "preSelectOpts.massWindowSafetyMargin": "0.001", + "trackTuner.updateCurvatureIU": "0", + "cascadeBuilderOpts.mc_addGeneratedXiPlus": "1", + "preSelectOpts.massCutXi": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "trackPropagation.trackTunerParams": "debugInfo=0|updateTrackDCAs=1|updateTrackCovMat=1|updateCurvature=0|updateCurvatureIU=0|updatePulls=0|isInputFileFromCCDB=1|pathInputFile=Users/m/mfaggin/test/inputsTrackTuner/PbPb2022|nameInputFile=trackTuner_DataLHC22sPass5_McLHC22l1b2_run529397.root|pathFileQoverPt=Users/h/hsharma/qOverPtGraphs|nameFileQoverPt=D0sigma_Data_removal_itstps_MC_LHC22b1b.root|usePvRefitCorrections=0|qOverPtMC=-1.|qOverPtData=-1.", + "v0BuilderOpts.minCrossedRows": "-1", + "processRealDataWithPID": "0", + "trackPropagation.trackTunerConfigSource": "1", + "refitWithMaterialCorrection": "0", + "cascadeBuilderOpts.cascradius": "0.9", + "cascadeBuilderOpts.mc_treatPiToMuDecays": "1", + "processRealData": "0", + "v0BuilderOpts.mc_populateV0MCCoresSymmetric": "0", + "preSelectOpts.massWindownumberOfSigmas": "20", + "trackTuner.usePvRefitCorrections": "0", + "v0BuilderOpts.mc_addGeneratedGamma": "1", + "v0BuilderOpts.moveTPCOnlyTracks": "1", + "ccdb.ccdb-url": "http://alice-ccdb.cern.ch", + "enabledTables": { + "values": [ + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + 1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + 1 + ], + [ + 1 + ], + [ + 1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ], + [ + -1 + ] + ] + }, + "v0BuilderOpts.dcav0dau": "1.5", + "v0BuilderOpts.mc_keepOnlyPhysicalPrimary": "1", + "cascadeBuilderOpts.mc_rapidityWindow": "0.5", + "trackTuner.isInputFileFromCCDB": "0", + "trackTuner.nameInputFile": "", + "v0BuilderOpts.maxDaughterEta": "1.5", + "useV0BufferForCascades": "0", + "v0BuilderOpts.mc_addGeneratedAntiLambda": "1", + "v0BuilderOpts.v0cospa": "0.97", + "deduplicationAlgorithm": "1", + "cascadeBuilderOpts.lambdaMassWindow": "0.01", + "preSelectOpts.massCutOm": { + "values": [ + [ + 0.0014320999616757035, + 0.00020356099412310869, + 0.002431869972497225, + 0.79966801404953 + ] + ] + }, + "cascadeBuilderOpts.dcacascdau": "1.5", + "trackTuner.updatePulls": "0", + "processMonteCarlo": "1", + "v0BuilderOpts.mc_populateV0MCCoresAsymmetric": "1", + "preSelectOpts.massCutLambda": { + "values": [ + [ + 0.0011751799611374736, + 0.00012409899500198662, + 0.005479369778186083, + 0.30800899863243103 + ] + ] + }, + "trackTuner.nPhiBins": "0", + "cascadeBuilderOpts.mc_populateCascMCCoresSymmetric": "0", + "v0BuilderOpts.generatePhotonCandidates": "1", + "preSelectOpts.massCutK0": { + "values": [ + [ + 0.0028188200667500496, + 0.0011405700352042913, + 0.0017213800456374884, + 0.5002620220184326 + ] + ] + }, + "trackTuner.pathFileQoverPt": "", + "trackTuner.qOverPtMC": "-1", + "v0BuilderOpts.mc_rapidityWindow": "0.5", + "trackPropagation.axisPtQA": { + "values": [ + 0, + 0, + 0.10000000149011612, + 0.20000000298023224, + 0.30000001192092896, + 0.4000000059604645, + 0.5, + 0.6000000238418579, + 0.699999988079071, + 0.800000011920929, + 0.8999999761581421, + 1, + 1.100000023841858, + 1.2000000476837158, + 1.2999999523162842, + 1.399999976158142, + 1.5, + 1.600000023841858, + 1.7000000476837158, + 1.7999999523162842, + 1.899999976158142, + 2, + 2.200000047683716, + 2.4000000953674316, + 2.5999999046325684, + 2.799999952316284, + 3, + 3.200000047683716, + 3.4000000953674316, + 3.5999999046325684, + 3.799999952316284, + 4, + 4.400000095367432, + 4.800000190734863, + 5.199999809265137, + 5.599999904632568, + 6, + 6.5, + 7, + 7.5, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 17, + 19, + 21, + 23, + 25, + 30, + 35, + 40, + 50 + ] + }, + "cascadeBuilderOpts.kfDoDCAFitterPreMinimCasc": "1", + "v0BuilderOpts.dcapostopv": "0.05", + "preSelectOpts.massCutPhoton": "0.3", + "ccdb.grpmagPath": "GLO/Config/GRPMagField", + "cascadeBuilderOpts.kfDoDCAFitterPreMinimV0": "1", + "cascadeBuilderOpts.mc_populateCascMCCoresAsymmetric": "1", + "v0BuilderOpts.mc_findableDetachedV0": "0", + "trackPropagation.useTrkPid": "0", + "trackTuner.nameFileQoverPt": "", + "cascadeBuilderOpts.kfUseCascadeMassConstraint": "0", + "trackTuner.qOverPtData": "-1", + "v0BuilderOpts.mc_treatPiToMuDecays": "1", + "trackTuner.debugInfo": "0", + "trackPropagation.minPropagationDistance": "5", + "ccdburl": "http://alice-ccdb.cern.ch", + "cascadeBuilderOpts.mc_keepOnlyPhysicalPrimary": "1", + "cascadeBuilderOpts.mc_addGeneratedXiMinus": "1", + "mc_findableMode": "0" + }, + "strangeness_tutorial": { + "nBins": "100", + "cutzvertex": "10", + "v0setting_dcav0dau": "1", + "v0setting_dcapostopv": "0.0599999987", + "v0setting_dcanegtopv": "0.0599999987", + "v0setting_cospa": "0.97999999999999998", + "v0setting_radius": "0.5", + "NSigmaTPCPion": "4", + "processRecMC": "true", + "processGenMC": "true" + } +} diff --git a/Tutorials/PWGLF/Strangeness/Original/run_step0.sh b/Tutorials/PWGLF/Strangeness/Original/run_step0.sh new file mode 100644 index 00000000000..1e895de996f --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/run_step0.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="0" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step0.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysistutorial-lf-strangeness-step0 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Original/run_step1.sh b/Tutorials/PWGLF/Strangeness/Original/run_step1.sh new file mode 100644 index 00000000000..03a327fd307 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/run_step1.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="1" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step1.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysistutorial-lf-strangeness-step1 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Original/run_step2.sh b/Tutorials/PWGLF/Strangeness/Original/run_step2.sh new file mode 100644 index 00000000000..27c596d1694 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/run_step2.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="2" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step2.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysistutorial-lf-strangeness-step2 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Original/run_step3.sh b/Tutorials/PWGLF/Strangeness/Original/run_step3.sh new file mode 100644 index 00000000000..ffaeea614a7 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/run_step3.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="3" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step3.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-mccollisionextra ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysistutorial-lf-strangeness-step3 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/Original/run_step4.sh b/Tutorials/PWGLF/Strangeness/Original/run_step4.sh new file mode 100644 index 00000000000..fd98b1fa358 --- /dev/null +++ b/Tutorials/PWGLF/Strangeness/Original/run_step4.sh @@ -0,0 +1,31 @@ +#!/bin/bash +# log file where the terminal output will be saved +STEP="4" +LOGFILE="log-STEP${STEP}.txt" + +#directory of this script +DIR_THIS=$PWD + +OPTION="-b --configuration json://configuration_step4.json" + +o2-analysis-trackselection ${OPTION} | +o2-analysis-ft0-corrected-table ${OPTION} | +o2-analysis-mccollisionextra ${OPTION} | +o2-analysis-multcenttable ${OPTION} | +o2-analysis-event-selection-service ${OPTION} | +o2-analysis-pid-tpc-service ${OPTION} | +o2-analysis-propagationservice ${OPTION} | +o2-analysistutorial-lf-strangeness-step4 ${OPTION} --aod-file @input_data.txt > "$LOGFILE" 2>&1 + +# report status +rc=$? +if [ $rc -eq 0 ]; then + echo "No problems!" + mkdir -p "${DIR_THIS}/results/step${STEP}" + mv AnalysisResults.root "${DIR_THIS}/results/step${STEP}/AnalysisResults.root" + mv dpl-config.json "${DIR_THIS}/results/step${STEP}/step${STEP}.json" +else + echo "Error: Exit code ${rc}" + echo "Check the log file ${LOGFILE}" + exit ${rc} +fi \ No newline at end of file diff --git a/Tutorials/PWGLF/Strangeness/pp/strangeness_step0.cxx b/Tutorials/PWGLF/Strangeness/Original/strangeness_step0.cxx similarity index 99% rename from Tutorials/PWGLF/Strangeness/pp/strangeness_step0.cxx rename to Tutorials/PWGLF/Strangeness/Original/strangeness_step0.cxx index a14b0a5aa3f..4c2b6569e09 100644 --- a/Tutorials/PWGLF/Strangeness/pp/strangeness_step0.cxx +++ b/Tutorials/PWGLF/Strangeness/Original/strangeness_step0.cxx @@ -13,11 +13,13 @@ /// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) /// \author Chiara De Martin (chiara.de.martin@cern.ch) -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" #include "PWGLF/DataModel/LFStrangenessTables.h" +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; diff --git a/Tutorials/PWGLF/Strangeness/pp/strangeness_step1.cxx b/Tutorials/PWGLF/Strangeness/Original/strangeness_step1.cxx similarity index 99% rename from Tutorials/PWGLF/Strangeness/pp/strangeness_step1.cxx rename to Tutorials/PWGLF/Strangeness/Original/strangeness_step1.cxx index 70748658778..ca57646dc97 100644 --- a/Tutorials/PWGLF/Strangeness/pp/strangeness_step1.cxx +++ b/Tutorials/PWGLF/Strangeness/Original/strangeness_step1.cxx @@ -13,11 +13,13 @@ /// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) /// \author Chiara De Martin (chiara.de.martin@cern.ch) -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" #include "PWGLF/DataModel/LFStrangenessTables.h" +#include "Common/DataModel/EventSelection.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; diff --git a/Tutorials/PWGLF/Strangeness/pp/strangeness_step2.cxx b/Tutorials/PWGLF/Strangeness/Original/strangeness_step2.cxx similarity index 99% rename from Tutorials/PWGLF/Strangeness/pp/strangeness_step2.cxx rename to Tutorials/PWGLF/Strangeness/Original/strangeness_step2.cxx index 9701410db1b..fd863f5090a 100644 --- a/Tutorials/PWGLF/Strangeness/pp/strangeness_step2.cxx +++ b/Tutorials/PWGLF/Strangeness/Original/strangeness_step2.cxx @@ -13,12 +13,14 @@ /// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) /// \author Chiara De Martin (chiara.de.martin@cern.ch) -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" #include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" #include "Common/DataModel/PIDResponse.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; diff --git a/Tutorials/PWGLF/Strangeness/pp/strangeness_step3.cxx b/Tutorials/PWGLF/Strangeness/Original/strangeness_step3.cxx similarity index 96% rename from Tutorials/PWGLF/Strangeness/pp/strangeness_step3.cxx rename to Tutorials/PWGLF/Strangeness/Original/strangeness_step3.cxx index 6121831fadb..339747e458d 100644 --- a/Tutorials/PWGLF/Strangeness/pp/strangeness_step3.cxx +++ b/Tutorials/PWGLF/Strangeness/Original/strangeness_step3.cxx @@ -13,12 +13,14 @@ /// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) /// \author Chiara De Martin (chiara.de.martin@cern.ch) -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" #include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" #include "Common/DataModel/PIDResponse.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -144,7 +146,7 @@ struct strangeness_tutorial { if (posDaughterTrack.has_mcParticle() && negDaughterTrack.has_mcParticle()) { // Checking that the daughter tracks come from particles and are not fake auto posParticle = posDaughterTrack.mcParticle(); auto negParticle = negDaughterTrack.mcParticle(); - if (posParticle.pdgCode() == 211 && negParticle.pdgCode() == -211) { // Checking that the daughter tracks are true pions + if (posParticle.pdgCode() == PDG_t::kPiPlus && negParticle.pdgCode() == PDG_t::kPiMinus) { // Checking that the daughter tracks are true pions rKzeroShort.fill(HIST("hMassK0ShortSelectedTruePions"), v0.mK0Short()); } } @@ -152,7 +154,7 @@ struct strangeness_tutorial { // Checking that the V0 is a true K0s if (v0.has_mcParticle()) { auto v0mcParticle = v0.mcParticle(); - if (v0mcParticle.pdgCode() == 310) { + if (v0mcParticle.pdgCode() == PDG_t::kK0Short) { rKzeroShort.fill(HIST("hMassK0ShortTrueRec"), v0.mK0Short()); rKzeroShort.fill(HIST("hPtK0ShortTrueRec"), v0.pt()); // To mimic distribution after the signal extraction } @@ -168,7 +170,7 @@ struct strangeness_tutorial { return; rEventSelection.fill(HIST("hVertexZGen"), mcCollision.posZ()); for (const auto& mcParticle : mcParticles) { - if (mcParticle.pdgCode() == 310) { + if (mcParticle.pdgCode() == PDG_t::kK0Short) { rGenParticles.fill(HIST("hPtK0ShortGen"), mcParticle.pt()); } } diff --git a/Tutorials/PWGLF/Strangeness/pp/strangeness_step4.cxx b/Tutorials/PWGLF/Strangeness/Original/strangeness_step4.cxx similarity index 91% rename from Tutorials/PWGLF/Strangeness/pp/strangeness_step4.cxx rename to Tutorials/PWGLF/Strangeness/Original/strangeness_step4.cxx index 544d4283932..f5a53dd5089 100644 --- a/Tutorials/PWGLF/Strangeness/pp/strangeness_step4.cxx +++ b/Tutorials/PWGLF/Strangeness/Original/strangeness_step4.cxx @@ -13,12 +13,13 @@ /// \author Nepeivoda Roman (roman.nepeivoda@cern.ch) /// \author Chiara De Martin (chiara.de.martin@cern.ch) -#include "Framework/runDataProcessing.h" -#include "Framework/AnalysisTask.h" -#include "Common/DataModel/EventSelection.h" #include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/DataModel/EventSelection.h" #include "Common/DataModel/PIDResponse.h" -#include "Framework/O2DatabasePDGPlugin.h" + +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" using namespace o2; using namespace o2::framework; @@ -70,9 +71,6 @@ struct strangeness_tutorial { Configurable NSigmaTPCPion{"NSigmaTPCPion", 4, "NSigmaTPCPion"}; Configurable NSigmaTPCProton{"NSigmaTPCProton", 4, "NSigmaTPCProton"}; - // PDG data base - Service pdgDB; - void init(InitContext const&) { // Axes @@ -161,10 +159,10 @@ struct strangeness_tutorial { if (v0.v0radius() < v0setting_radius) continue; - if (TMath::Abs(posDaughterTrack.tpcNSigmaPi()) > NSigmaTPCPion) { + if (std::abs(posDaughterTrack.tpcNSigmaPi()) > NSigmaTPCPion) { continue; } - if (TMath::Abs(negDaughterTrack.tpcNSigmaPi()) > NSigmaTPCPion) { + if (std::abs(negDaughterTrack.tpcNSigmaPi()) > NSigmaTPCPion) { continue; } @@ -183,7 +181,7 @@ struct strangeness_tutorial { if (posDaughterTrack.has_mcParticle() && negDaughterTrack.has_mcParticle()) { // Checking that the daughter tracks come from particles and are not fake auto posParticle = posDaughterTrack.mcParticle(); auto negParticle = negDaughterTrack.mcParticle(); - if (posParticle.pdgCode() == 211 && negParticle.pdgCode() == -211) { // Checking that the daughter tracks are true pions + if (posParticle.pdgCode() == PDG_t::kPiPlus && negParticle.pdgCode() == PDG_t::kPiMinus) { // Checking that the daughter tracks are true pions rKzeroShort.fill(HIST("hMassK0ShortSelectedTruePions"), v0.mK0Short()); } } @@ -191,7 +189,7 @@ struct strangeness_tutorial { // Checking that the V0 is a true K0s if (v0.has_mcParticle()) { auto v0mcParticle = v0.mcParticle(); - if (v0mcParticle.pdgCode() == 310) { + if (v0mcParticle.pdgCode() == PDG_t::kK0Short) { rKzeroShort.fill(HIST("hMassK0ShortTrueRec"), v0.mK0Short()); rKzeroShort.fill(HIST("hPtK0ShortTrueRec"), v0.pt()); // To mimic distribution after the signal extraction } @@ -209,7 +207,7 @@ struct strangeness_tutorial { // Cut on dynamic columns if (casc.casccosPA(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_cospa) continue; - if (TMath::Abs(casc.mLambda() - pdgDB->Mass(3122)) > cascadesetting_v0masswindow) + if (std::abs(casc.mLambda() - o2::constants::physics::MassLambda) > cascadesetting_v0masswindow) continue; if (casc.dcav0topv(collision.posX(), collision.posY(), collision.posZ()) < cascadesetting_mindcav0topv) continue; @@ -217,21 +215,21 @@ struct strangeness_tutorial { continue; if (casc.sign() < 0) { - if (TMath::Abs(posDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + if (std::abs(posDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { continue; } - if (TMath::Abs(negDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + if (std::abs(negDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { continue; } } else { - if (TMath::Abs(negDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { + if (std::abs(negDaughterTrackCasc.tpcNSigmaPr()) > NSigmaTPCProton) { continue; } - if (TMath::Abs(posDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + if (std::abs(posDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { continue; } } - if (TMath::Abs(bachDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { + if (std::abs(bachDaughterTrackCasc.tpcNSigmaPi()) > NSigmaTPCPion) { continue; } @@ -242,7 +240,7 @@ struct strangeness_tutorial { // Checking that the cascade is a true Xi if (casc.has_mcParticle()) { const auto cascmcParticle = casc.mcParticle(); - if (TMath::Abs(cascmcParticle.pdgCode()) == 3312) { + if (std::abs(cascmcParticle.pdgCode()) == PDG_t::kXiMinus) { rXi.fill(HIST("hMassXiTrueRec"), casc.mXi()); } } @@ -257,10 +255,10 @@ struct strangeness_tutorial { return; rEventSelection.fill(HIST("hVertexZGen"), mcCollision.posZ()); for (const auto& mcParticle : mcParticles) { - if (mcParticle.pdgCode() == 310) { + if (mcParticle.pdgCode() == PDG_t::kK0Short) { rGenParticles.fill(HIST("hPtK0ShortGen"), mcParticle.pt()); } - if (TMath::Abs(mcParticle.pdgCode()) == 3312) { + if (std::abs(mcParticle.pdgCode()) == PDG_t::kXiMinus) { rGenParticles.fill(HIST("hPtXiGen"), mcParticle.pt()); } }