${runMode} "$@"
;;
esac
+ return 0
}
generateMC()
OCDBpath=${2}
nEventsim=${3}
if [[ -n ${pretend} ]]; then
+ sleep ${pretendDelay}
touch galice.root
else
if [[ -f sim.C && -f Config.C ]] ; then
}
goCPass0()
-{
+(
umask 0002
targetDirectory=${1}
shift 7
if ! parseConfig ${configFile} "$@"; then return 1; fi
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
+
#use the jobindex only if set and non-negative
if [[ -z ${jobindex} || ${jobindex} -lt 0 ]]; then
[[ -n "${LSB_JOBINDEX}" ]] && jobindex=${LSB_JOBINDEX}
[[ -n "${SGE_TASK_ID}" ]] && jobindex=${SGE_TASK_ID}
+ if [[ -z ${jobindex} ]]; then
+ echo "no jobindex!"
+ return 1
+ fi
fi
[[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
- doneFile="${commonOutputPath}/meta/cpass0.job${jobindex}.run${runNumber}.done"
+
+ # This file signals that/if everything went fine
+ doneFileBase="cpass0.job${jobindex}.run${runNumber}.done"
+ [[ -n ${useProfilingCommand} ]] && doneFileBase="profiling.cpass0.job${jobindex}.run${runNumber}.done"
+
+ # We will have two copies of the file
+ mkdir -p "${commonOutputPath}/meta" || return 1
+ doneFileTmp="${batchWorkingDirectory}/${doneFileBase}"
+ doneFile="${commonOutputPath}/meta/${doneFileBase}"
[[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
outputDir=${targetDirectory}/${jobindex}_${chunkName%.*}
mkdir -p ${outputDir}
- [[ ! -d ${outputDir} ]] && echo "cannot make ${outputDir}" && touch ${doneFile} && return 1
+ if [[ ! -d ${outputDir} ]]; then
+ touch ${doneFileTmp}
+ echo "cannot make ${outputDir}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
#runpath=${PWD}/rundir_cpass0_${runNumber}_${jobindex}
runpath=${outputDir}
- [[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
- [[ ${reconstructInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && runpath=$(mktemp -d)
+ #[[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
+ [[ ${reconstructInTemporaryDir} -eq 1 ]] && runpath=$(mktemp -d -t cpass0.XXXXXX)
mkdir -p ${runpath}
- [[ ! -d ${runpath} ]] && echo "cannot make runpath ${runpath}" && touch ${doneFile} && return 1
- cd ${runpath}
+ if [[ ! -d ${runpath} ]]; then
+ touch ${doneFileTmp}
+ echo "cannot make runpath ${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
+ if ! cd ${runpath}; then
+ touch ${doneFileTmp}
+ echo "PWD=$PWD is not the runpath=${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
#runCPassX/C expects the raw chunk to be linked in the run dir
#despite it being accessed by the full path
olddir=${PWD}
outputDirMC=${commonOutputPath}/000${runNumber}/sim/${jobindex}
simrunpath=${outputDirMC}
- [[ ${simulateInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && simrunpath=${TMPDIR}
- [[ ${simulateInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && simrunpath=$(mktemp -d)
+ #[[ ${simulateInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && simrunpath=${TMPDIR}
+ [[ ${simulateInTemporaryDir} -eq 1 ]] && simrunpath=$(mktemp -d -t cpass0MC.XXXXXX)
mkdir -p ${outputDirMC}
mkdir -p ${simrunpath}
- cd ${simrunpath}
-
- filesMC=(
- "${commonOutputPath}/sim.C"
- "${commonOutputPath}/rec.C"
- "${commonOutputPath}/Config.C"
- "${commonOutputPath}/OCDB_*.root"
- )
- for file in ${filesMC[*]}; do
- [[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
- done
+ if cd ${simrunpath}; then
- generateMC ${runNumber} ${ocdbPath} ${nEvents}
+ filesMC=(
+ "${batchWorkingDirectory}/sim.C"
+ "${batchWorkingDirectory}/rec.C"
+ "${batchWorkingDirectory}/Config.C"
+ "${batchWorkingDirectory}/OCDB_*.root"
+ )
+ for file in ${filesMC[*]}; do
+ [[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ done
- [[ ! "${simrunpath}" =~ "${outputDirMC}" ]] && mv * ${outputDirMC} #TODO check if it works
- cd ${olddir}
-
- ln -s ${outputDirMC}/* ${runpath}/
-
- inputList=${outputDirMC}/galice.root #TODO not valid outside shell !!!
- infile=""
+ generateMC ${runNumber} ${ocdbPath} ${nEvents}
+
+ [[ ! "${simrunpath}" =~ "${outputDirMC}" ]] && mv * ${outputDirMC} #TODO check if it works
+ cd ${olddir}
+
+ ln -s ${outputDirMC}/* ${runpath}/
+
+ inputList=${outputDirMC}/galice.root #TODO not valid outside shell !!!
+ infile=""
+ fi
fi
######
- [[ ! -f ${inputList} && -z ${pretend} ]] && echo "input file ${inputList} not found, exiting..." && touch ${doneFile} && return 1
+ if [[ ! -f ${inputList} && -z ${pretend} ]]; then
+ touch ${doneFileTmp}
+ echo "input file ${inputList} not found, exiting..." >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
logOutputDir=${runpath}
[[ -n ${logToFinalDestination} ]] && logOutputDir=${outputDir}
- [[ -z ${dontRedirectStdOutToLog} ]] && exec 1> ${logOutputDir}/stdout
- [[ -z ${dontRedirectStdOutToLog} ]] && exec 2> ${logOutputDir}/stderr
+ [[ -z ${dontRedirectStdOutToLog} ]] && exec &> ${logOutputDir}/stdout
+ #[[ -z ${dontRedirectStdOutToLog} ]] && exec 2> ${logOutputDir}/stderr
echo "${0} $*"
echo "#####################"
echo CPass0:
echo JOB setup
- echo nEvents ${nEvents}
- echo runNumber ${runNumber}
- echo ocdbPath ${ocdbPath}
- echo infile ${infile}
- echo chunkName ${chunkName}
- echo jobindex ${jobindex}
- echo recoTriggerOptions ${recoTriggerOptions}
- echo targetDirectory ${targetDirectory}
- echo commonOutputPath ${commonOutputPath}
- echo doneFile ${doneFile}
- echo runpath ${runpath}
- echo outputDir ${outputDir}
- echo ALICE_ROOT ${ALICE_ROOT}
- echo PWD ${PWD}
+ echo nEvents ${nEvents}
+ echo runNumber ${runNumber}
+ echo ocdbPath ${ocdbPath}
+ echo infile ${infile}
+ echo chunkName ${chunkName}
+ echo jobindex ${jobindex}
+ echo recoTriggerOptions ${recoTriggerOptions}
+ echo targetDirectory ${targetDirectory}
+ echo commonOutputPath ${commonOutputPath}
+ echo doneFile ${doneFile}
+ echo batchWorkingDirectory ${batchWorkingDirectory}
+ echo runpath ${runpath}
+ echo outputDir ${outputDir}
+ echo PWD ${PWD}
+ echo ALICE_ROOT ${ALICE_ROOT}
echo "########## ###########"
alirootInfo > ALICE_ROOT.log
filesCPass0=(
- "${commonOutputPath}/runCPass0.sh"
- "${commonOutputPath}/recCPass0.C"
- "${commonOutputPath}/runCalibTrain.C"
- "${commonOutputPath}/localOCDBaccessConfig.C"
- "${commonOutputPath}/OCDB.root"
+ "${batchWorkingDirectory}/runCPass0.sh"
+ "${batchWorkingDirectory}/recCPass0.C"
+ "${batchWorkingDirectory}/runCalibTrain.C"
+ "${batchWorkingDirectory}/localOCDBaccessConfig.C"
+ "${batchWorkingDirectory}/OCDB.root"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/runCPass0.sh"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/recCPass0.C"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/runCalibTrain.C"
for file in ${filesCPass0[*]}; do
[[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ [[ ${file##*/} =~ .*\.sh ]] && chmod +x ${file##*/}
done
echo "this directory (${PWD}) contents:"
#run CPass0
echo "${runpath}/runCPass0.sh ${infile} ${nEvents} ${runNumber} ${ocdbPath} ${recoTriggerOptions}"
if [[ -n ${pretend} ]]; then
+ sleep ${pretendDelay}
touch AliESDs.root
touch AliESDfriends.root
touch AliESDfriends_v1.root
/bin/ls
echo
+ # [dberzano] OK this is fine!
echo rm -f ./${chunkName}
rm -f ./${chunkName}
- echo "cp --recursive ${runpath}/* ${outputDir}"
- cp -p --recursive ${runpath}/* ${outputDir}
+ echo "cp -R ${runpath}/* ${outputDir}"
+ cp -p -R ${runpath}/* ${outputDir}
echo
#validate CPass0
cd ${outputDir}
- touch ${doneFile}
- echo "dir ${outputDir}" >> ${doneFile}
- if summarizeLogs >> ${doneFile}; then
- [[ -f ${outputDirMC}/galice.root ]] && echo "sim ${outputDirMC}/galice.root" >> ${doneFile}
- [[ -f AliESDfriends_v1.root ]] && echo "calibfile ${outputDir}/AliESDfriends_v1.root" >> ${doneFile}
- [[ -f AliESDs.root ]] && echo "esd ${outputDir}/AliESDs.root" >> ${doneFile}
+ touch ${doneFileTmp}
+ echo "dir ${outputDir}" >> ${doneFileTmp}
+ if summarizeLogs >> ${doneFileTmp}; then
+ [[ -f ${outputDirMC}/galice.root ]] && echo "sim ${outputDirMC}/galice.root" >> ${doneFileTmp}
+ [[ -f AliESDfriends_v1.root ]] && echo "calibfile ${outputDir}/AliESDfriends_v1.root" >> ${doneFileTmp}
+ [[ -f AliESDs.root ]] && echo "esd ${outputDir}/AliESDs.root" >> ${doneFileTmp}
fi
- [[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+ [[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath} && echo "removing ${runpath}"
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
return 0
-}
+)
goCPass1()
-{
+(
umask 0002
targetDirectory=${1}
extraOpts=("$@")
if ! parseConfig ${configFile} "$@"; then return 1; fi
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
+
#use the jobindex only if set and non-negative
if [[ -z ${jobindex} || ${jobindex} -lt 0 ]]; then
[[ -n "${LSB_JOBINDEX}" ]] && jobindex=${LSB_JOBINDEX}
[[ -n "${SGE_TASK_ID}" ]] && jobindex=${SGE_TASK_ID}
+ if [[ -z ${jobindex} ]]; then
+ echo "no jobindex!"
+ return 1
+ fi
fi
[[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
- doneFile="${commonOutputPath}/meta/cpass1.job${jobindex}.run${runNumber}.done"
+
+ # This file signals that/if everything went fine
+ doneFileBase="cpass1.job${jobindex}.run${runNumber}.done"
+ [[ -n ${useProfilingCommand} ]] && doneFileBase="profiling.cpass0.job${jobindex}.run${runNumber}.done"
+
+ # We will have two copies of the file
+ mkdir -p "${commonOutputPath}/meta" || return 1
+ doneFileTmp="${batchWorkingDirectory}/${doneFileBase}"
+ doneFile="${commonOutputPath}/meta/${doneFileBase}"
[[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
#Packages= ;OutputDir= ;LPMPass= ;TriggerAlias= ;LPMRunNumber= ;LPMProductionType= ;LPMInteractionType= ;LPMProductionTag= ;LPMAnchorRun= ;LPMAnchorProduction= ;LPMAnchorYear=
export PRODUCTION_METADATA="OutputDir=cpass1"
- [[ ! -f ${inputList} && -z ${pretend} ]] && echo "input file ${inputList} not found, exiting..." && touch ${doneFile} && return 1
+ if [[ ! -f ${inputList} && -z ${pretend} ]]; then
+ touch ${doneFileTmp}
+ echo "input file ${inputList} not found, exiting..." >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
if [[ "${inputList}" =~ \.root$ ]]; then
infile=${inputList}
else
outputDir=${targetDirectory}/${jobindex}_${chunkName%.*}
mkdir -p ${outputDir}
- [[ ! -d ${outputDir} ]] && echo "cannot make ${outputDir}" && touch ${doneFile} && return 1
+ if [[ ! -d ${outputDir} ]];then
+ touch ${doneFileTmp}
+ echo "cannot make ${outputDir}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
#runpath=${PWD}/rundir_cpass1_${runNumber}_${jobindex}
runpath=${outputDir}
- [[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
- [[ ${reconstructInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && runpath=$(mktemp -d)
+ #[[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
+ [[ ${reconstructInTemporaryDir} -eq 1 ]] && runpath=$(mktemp -d -t cpass1.XXXXXX)
#MC
if [[ "${infile}" =~ galice\.root ]]; then
#init the running path
mkdir -p ${runpath}
- [[ ! -d ${runpath} ]] && echo "cannot make runpath ${runpath}" && touch ${doneFile} && return 1
- cd ${runpath}
+ if [[ ! -d ${runpath} ]]; then
+ touch ${doneFileTmp}
+ echo "cannot make runpath ${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
+ if ! cd ${runpath}; then
+ touch ${doneFileTmp}
+ echo "PWD=$PWD is not the runpath=${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
#this is needed for runCPass1.sh
ln -s ${infile} ${runpath}/${chunkName}
logOutputDir=${runpath}
[[ -n ${logToFinalDestination} ]] && logOutputDir=${outputDir}
- [[ -z ${dontRedirectStdOutToLog} ]] && exec 1> ${logOutputDir}/stdout
- [[ -z ${dontRedirectStdOutToLog} ]] && exec 2> ${logOutputDir}/stderr
+ [[ -z ${dontRedirectStdOutToLog} ]] && exec &> ${logOutputDir}/stdout
+ #[[ -z ${dontRedirectStdOutToLog} ]] && exec 2> ${logOutputDir}/stderr
echo "${0} $*"
echo "#####################"
echo CPass1:
echo JOB setup
- echo nEvents ${nEvents}
- echo runNumber ${runNumber}
- echo ocdbPath ${ocdbPath}
- echo infile ${infile}
- echo chunkName ${chunkName}
- echo jobindex ${jobindex}
- echo recoTriggerOptions ${recoTriggerOptions}
- echo targetDirectory ${targetDirectory}
- echo commonOutputPath ${commonOutputPath}
- echo doneFile ${doneFile}
- echo runpath ${runpath}
- echo outputDir ${outputDir}
- echo ALICE_ROOT ${ALICE_ROOT}
- echo PWD ${PWD}
- echo "########## ###########"
+ echo nEvents ${nEvents}
+ echo runNumber ${runNumber}
+ echo ocdbPath ${ocdbPath}
+ echo infile ${infile}
+ echo chunkName ${chunkName}
+ echo jobindex ${jobindex}
+ echo recoTriggerOptions ${recoTriggerOptions}
+ echo targetDirectory ${targetDirectory}
+ echo commonOutputPath ${commonOutputPath}
+ echo doneFile ${doneFile}
+ echo runpath ${runpath}
+ echo outputDir ${outputDir}
+ echo batchWorkingDirectory ${batchWorkingDirectory}
+ echo ALICE_ROOT ${ALICE_ROOT}
+ echo PWD ${PWD}
+ echo "#####################"
alirootInfo > ALICE_ROOT.log
filesCPass1=(
- "${commonOutputPath}/runCPass1.sh"
- "${commonOutputPath}/recCPass1.C"
- "${commonOutputPath}/recCPass1_OuterDet.C"
- "${commonOutputPath}/runCalibTrain.C"
- "${commonOutputPath}/QAtrain_duo.C"
- "${commonOutputPath}/localOCDBaccessConfig.C"
+ "${batchWorkingDirectory}/runCPass1.sh"
+ "${batchWorkingDirectory}/recCPass1.C"
+ "${batchWorkingDirectory}/recCPass1_OuterDet.C"
+ "${batchWorkingDirectory}/runCalibTrain.C"
+ "${batchWorkingDirectory}/QAtrain_duo.C"
+ "${batchWorkingDirectory}/localOCDBaccessConfig.C"
+ "${batchWorkingDirectory}/${configFile}"
"${commonOutputPath}/meta/cpass0.localOCDB.${runNumber}.tgz"
- "${commonOutputPath}/OCDB.root"
+ "${batchWorkingDirectory}/OCDB.root"
"${trustedQAtrainMacro}"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass1/runCPass1.sh"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass1/recCPass1.C"
"${ALICE_ROOT}/ANALYSIS/macros/QAtrain_duo.C"
)
- for file in ${filesCPass1[*]}; do
+ for file in "${filesCPass1[@]}"; do
[[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ [[ ${file##*/} =~ .*\.sh ]] && echo "making ${file##*/} executable" && chmod +x ${file##*/}
done
echo "this directory (${PWD}) contents:"
/bin/ls
echo
+ #remove spaces around commas from calls to root
sed -i '/.*root .*\.C/ s|\s*,\s*|,|g' *.sh
if [[ -n ${postSetUpActionCPass1} ]]; then
fi
if [[ ! $(/bin/ls -1 OCDB/*/*/*/*.root 2>/dev/null) ]]; then
- echo "cpass0 produced no calibration! exiting..."
- touch ${doneFile}
+ touch ${doneFileTmp}
+ echo "cpass0 produced no calibration! exiting..." >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
return 1
fi
#create the Barrel and OuterDet directories for CPass1 and link the local OCDB directory
#there to make the localOCDBaccessConfig.C file work, since it may point to the OCDB
#entries using a relative path, e.g. local://./OCDB
+ echo "linking the OCDB/ for Barrel and OuterDet directories"
mkdir Barrel OuterDet
+ ls -l
ln -s ../OCDB Barrel/OCDB
ln -s ../OCDB OuterDet/OCDB
chmod u+x runCPass1.sh
echo "${runpath}/runCPass1.sh ${infile} ${nEvents} ${runNumber} ${ocdbPath} ${recoTriggerOptions}"
if [[ -n ${pretend} ]]; then
+ sleep ${pretendDelay}
touch AliESDs_Barrel.root
touch AliESDfriends_Barrel.root
touch AliESDfriends_v1.root
#make the filtered tree (if requested and not already produced by QA
[[ -f AliESDs_Barrel.root ]] && echo "AliESDs_Barrel.root" > filtered.list
- if [[ -n ${runESDfiltering} && ! -f FilterEvents_Trees.root ]]; then
- goMakeFilteredTrees ${PWD} ${runNumber} "filtered.list" ${filteringFactorHighPt} ${filteringFactorV0s} ${ocdbPath} 1000000 0 10000000 0 ${configFile} AliESDs_Barrel.root "${extraOpts[@]}"
+ if [[ -n ${runESDfiltering} && ! -f FilterEvents_Trees.root && -f filtered.list ]]; then
+ goMakeFilteredTrees ${PWD} ${runNumber} "${PWD}/filtered.list" ${filteringFactorHighPt} ${filteringFactorV0s} ${ocdbPath} 1000000 0 10000000 0 ${configFile} AliESDs_Barrel.root "${extraOpts[@]}" >filtering.log
+ else
+ echo ""
fi
fi
/bin/ls
echo rm -f ./${chunkName}
rm -f ./${chunkName}
- echo "cp --recursive ${runpath}/* ${outputDir}"
- cp -pf --recursive ${runpath}/* ${outputDir}
+ echo "cp -R ${runpath}/* ${outputDir}"
+ cp -pf -R ${runpath}/* ${outputDir}
echo
#validate CPass1
cd ${outputDir}
- touch ${doneFile}
- echo "dir ${outputDir}" >> ${doneFile}
- if summarizeLogs >> ${doneFile}; then
- [[ -f AliESDs_Barrel.root ]] && echo "esd ${outputDir}/AliESDs_Barrel.root" >> ${doneFile}
- [[ -f AliESDfriends_v1.root ]] && echo "calibfile ${outputDir}/AliESDfriends_v1.root" >> ${doneFile}
- [[ -f QAresults_Barrel.root ]] && echo "qafile ${outputDir}/QAresults_Barrel.root" >> ${doneFile}
- [[ -f QAresults_Outer.root ]] && echo "qafile ${outputDir}/QAresults_Outer.root" >> ${doneFile}
- [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFile}
+ touch ${doneFileTmp}
+ echo "dir ${outputDir}" >> ${doneFileTmp}
+ if summarizeLogs >> ${doneFileTmp}; then
+ [[ -f AliESDs_Barrel.root ]] && echo "esd ${outputDir}/AliESDs_Barrel.root" >> ${doneFileTmp}
+ [[ -f AliESDfriends_v1.root ]] && echo "calibfile ${outputDir}/AliESDfriends_v1.root" >> ${doneFileTmp}
+ [[ -f QAresults_Barrel.root ]] && echo "qafile ${outputDir}/QAresults_Barrel.root" >> ${doneFileTmp}
+ [[ -f QAresults_Outer.root ]] && echo "qafile ${outputDir}/QAresults_Outer.root" >> ${doneFileTmp}
+ [[ -f QAresults_barrel.root ]] && echo "qafile ${outputDir}/QAresults_barrel.root" >> ${doneFileTmp}
+ [[ -f QAresults_outer.root ]] && echo "qafile ${outputDir}/QAresults_outer.root" >> ${doneFileTmp}
+ [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFileTmp}
+ else
+ if grep "qa_outer.log.*OK" ${doneFileTmp} > /dev/null; then
+ [[ -f QAresults_Outer.root ]] && echo "qafile ${outputDir}/QAresults_Outer.root" >> ${doneFileTmp}
+ [[ -f QAresults_outer.root ]] && echo "qafile ${outputDir}/QAresults_outer.root" >> ${doneFileTmp}
+ fi
+ if grep "qa_barrel.log.*OK" ${doneFileTmp} > /dev/null; then
+ [[ -f QAresults_Barrel.root ]] && echo "qafile ${outputDir}/QAresults_Barrel.root" >> ${doneFileTmp}
+ [[ -f QAresults_barrel.root ]] && echo "qafile ${outputDir}/QAresults_barrel.root" >> ${doneFileTmp}
+ fi
+ if grep "filtering.log.*OK" ${doneFileTmp} > /dev/null; then
+ [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFileTmp}
+ fi
fi
[[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
return 0
-}
+)
goMergeCPass0()
-{
+(
#
# find the output files and merge them
#
shift 5
if ! parseConfig ${configFile} "$@"; then return 1; fi
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
+
[[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
- doneFile="${commonOutputPath}/meta/merge.cpass0.run${runNumber}.done"
+
+ # This file signals that everything went fine
+ doneFileBase="merge.cpass0.run${runNumber}.done"
+
+ # We will have two copies of the file
+ mkdir -p "${commonOutputPath}/meta" || return 1
+ doneFileTmp="${batchWorkingDirectory}/${doneFileBase}"
+ doneFile="${commonOutputPath}/meta/${doneFileBase}"
umask 0002
ulimit -c unlimited
#runpath=${PWD}/rundir_cpass0_Merge_${runNumber}
runpath=${outputDir}
- [[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
- [[ ${reconstructInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && runpath=$(mktemp -d)
+ #[[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
+ [[ ${reconstructInTemporaryDir} -eq 1 ]] && runpath=$(mktemp -d -t mergeCPass0.XXXXXX)
mkdir -p ${runpath}
- [[ ! -d ${runpath} ]] && echo "not able to make the runpath ${runpath}" && touch ${doneFile} && return 1
- cd ${runpath}
+ if [[ ! -d ${runpath} ]]; then
+ touch ${doneFileTmp}
+ echo "not able to make the runpath ${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
+ if ! cd ${runpath}; then
+ touch ${doneFileTmp}
+ echo "PWD=$PWD is not the runpath=${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
logOutputDir=${runpath}
[[ -n ${logToFinalDestination} ]] && logOutputDir=${outputDir}
- [[ -z ${dontRedirectStdOutToLog} ]] && exec &> ${logOutputDir}/mergeMakeOCDB.log
+ [[ -z ${dontRedirectStdOutToLog} ]] && exec &> ${logOutputDir}/stdout
echo "${0} $*"
mergingScript="mergeMakeOCDB.byComponent.sh"
# copy files in case they are not already there
filesMergeCPass0=(
- "${commonOutputPath}/${calibrationFilesToMerge}"
- "${commonOutputPath}/OCDB.root"
- "${commonOutputPath}/localOCDBaccessConfig.C"
+ "${batchWorkingDirectory}/${calibrationFilesToMerge}"
+ "${batchWorkingDirectory}/OCDB.root"
+ "${batchWorkingDirectory}/localOCDBaccessConfig.C"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/mergeMakeOCDB.byComponent.sh"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/mergeByComponent.C"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/makeOCDB.C"
)
for file in ${filesMergeCPass0[*]}; do
[[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ [[ ${file##*/} =~ .*\.sh ]] && chmod +x ${file##*/}
done
sed -i '/.*root .*\.C/ s|\s*,\s*|,|g' *.sh
echo "${mergingScript} ${calibrationFilesToMerge} ${runNumber} local://./OCDB ${ocdbStorage}"
if [[ -n ${pretend} ]]; then
+ sleep ${pretendDelay}
touch CalibObjects.root
touch ocdb.log
touch merge.log
+ touch dcsTime.root
mkdir -p ./OCDB/TPC/Calib/TimeGain/
mkdir -p ./OCDB/TPC/Calib/TimeDrift/
- touch ./OCDB/TPC/Calib/TimeGain/someCalibObject_0-999999_cpass0.root
- touch ./OCDB/TPC/Calib/TimeDrift/otherCalibObject_0-999999_cpass0.root
+ echo "some calibration" >> ./OCDB/TPC/Calib/TimeGain/someCalibObject_0-999999_cpass0.root
+ echo "some calibration" >> ./OCDB/TPC/Calib/TimeDrift/otherCalibObject_0-999999_cpass0.root
else
- ./${mergingScript} ${calibrationFilesToMerge} ${runNumber} "local://./OCDB" ${ocdbStorage}
- fi
+ ./${mergingScript} ${calibrationFilesToMerge} ${runNumber} "local://./OCDB" ${ocdbStorage} >> "mergeMakeOCDB.log"
+ #produce the calib trees for expert QA (dcsTime.root)
+ goMakeLocalOCDBaccessConfig ./OCDB
+ echo aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
+ aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
+ fi
+
### produce the output
#tar the produced OCDB for reuse
- tar czf ${commonOutputPath}/meta/cpass0.localOCDB.${runNumber}.tgz ./OCDB
+ #tar czf ${commonOutputPath}/meta/cpass0.localOCDB.${runNumber}.tgz ./OCDB
- #produce the calib trees for expert QA (dcsTime.root)
- goMakeLocalOCDBaccessConfig ./OCDB
- echo aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
- aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
+ # Create tarball with OCDB, store on the shared directory, create signal file on batch directory
+ mkdir -p ${commonOutputPath}/meta
+ baseTar="cpass0.localOCDB.${runNumber}.tgz"
+ tar czf ${batchWorkingDirectory}/${baseTar} ./OCDB && \
+ mv ${batchWorkingDirectory}/${baseTar} ${commonOutputPath}/meta/${baseTar} && \
+ touch ${batchWorkingDirectory}/${baseTar}.done
/bin/ls
#copy all to output dir
- cp -pf --recursive ${runpath}/* ${outputDir}
-
+ cp -pf -R ${runpath}/* ${outputDir}
+
if [[ -n ${generateMC} ]]; then
goPrintValues sim ${commonOutputPath}/meta/sim.run${runNumber}.list ${commonOutputPath}/meta/cpass0.job*.run${runNumber}.done
fi
#validate merging cpass0
cd ${outputDir}
- touch ${doneFile}
- echo "dir ${outputDir}" >> ${doneFile}
- if summarizeLogs >> ${doneFile}; then
- [[ -f CalibObjects.root ]] && echo "calibfile ${outputDir}/CalibObjects.root" >> ${doneFile}
- [[ -f dcsTime.root ]] && echo "dcsTree ${outputDir}/dcsTime.root" >> ${doneFile}
+ touch ${doneFileTmp}
+ echo "dir ${outputDir}" >> ${doneFileTmp}
+ if summarizeLogs >> ${doneFileTmp}; then
+ [[ -f CalibObjects.root ]] && echo "calibfile ${outputDir}/CalibObjects.root" >> ${doneFileTmp}
+ [[ -f dcsTime.root ]] && echo "dcsTree ${outputDir}/dcsTime.root" >> ${doneFileTmp}
fi
[[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
return 0
-}
+)
goMergeCPass1()
-{
+(
#
# find the output files and merge them
#
shift 7
if ! parseConfig ${configFile} "$@"; then return 1; fi
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
+
[[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
- doneFile="${commonOutputPath}/meta/merge.cpass1.run${runNumber}.done"
+
+ # This file signals that everything went fine
+ doneFileBase="merge.cpass1.run${runNumber}.done"
+
+ # We will have two copies of the file
+ mkdir -p "${commonOutputPath}/meta" || return 1
+ doneFileTmp="${batchWorkingDirectory}/${doneFileBase}"
+ doneFile="${commonOutputPath}/meta/${doneFileBase}"
umask 0002
ulimit -c unlimited
#runpath=${PWD}/rundir_cpass1_Merge_${runNumber}
runpath=${outputDir}
- [[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
- [[ ${reconstructInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && runpath=$(mktemp -d)
+ #[[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
+ [[ ${reconstructInTemporaryDir} -eq 1 ]] && runpath=$(mktemp -d -t mergeCPass1.XXXXXX)
mkdir -p ${runpath}
- [[ ! -d ${runpath} ]] && echo "not able to make the runpath ${runpath}" && touch ${doneFile} && return 1
- cd ${runpath}
+ if [[ ! -d ${runpath} ]]; then
+ touch ${doneFileTmp}
+ echo "not able to make the runpath ${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
+ if ! cd ${runpath}; then
+ touch ${doneFileTmp}
+ echo "PWD=$PWD is not the runpath=${runpath}" >> ${doneFileTmp}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+ return 1
+ fi
logOutputDir=${runpath}
[[ -n ${logToFinalDestination} ]] && logOutputDir=${outputDir}
# copy files in case they are not already there
filesMergeCPass1=(
- "${commonOutputPath}/${calibrationFilesToMerge}"
- "${commonOutputPath}/${qaFilesToMerge}"
- "${commonOutputPath}/OCDB.root"
- "${commonOutputPath}/localOCDBaccessConfig.C"
+ "${batchWorkingDirectory}/${calibrationFilesToMerge}"
+ "${batchWorkingDirectory}/${qaFilesToMerge}"
+ "${batchWorkingDirectory}/OCDB.root"
+ "${batchWorkingDirectory}/localOCDBaccessConfig.C"
"${commonOutputPath}/meta/cpass0.localOCDB.${runNumber}.tgz"
- "${commonOutputPath}/QAtrain_duo.C"
+ "${batchWorkingDirectory}/QAtrain_duo.C"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass1/mergeMakeOCDB.byComponent.sh"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass1/mergeByComponent.C"
"${ALICE_ROOT}/PWGPP/CalibMacros/CPass1/makeOCDB.C"
)
for file in ${filesMergeCPass1[*]}; do
[[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ [[ ${file##*/} =~ .*\.sh ]] && chmod +x ${file##*/}
done
sed -i '/.*root .*\.C/ s|\s*,\s*|,|g' *.sh
echo "${mergingScript} ${calibrationFilesToMerge} ${runNumber} local://./OCDB ${ocdbStorage}"
if [[ -n ${pretend} ]]; then
- touch CalibObjects.root
+ sleep ${pretendDelay}
touch ocdb.log
- touch merge.log
touch cpass1.localOCDB.${runNumber}.tgz
- else
- ./${mergingScript} ${calibrationFilesToMerge} ${runNumber} "local://./OCDB" ${ocdbStorage}
- fi
-
- tar czf ${commonOutputPath}/meta/cpass1.localOCDB.${runNumber}.tgz ./OCDB
-
- #merge QA (and filtered trees)
- [[ -n ${AliAnalysisTaskFilteredTree_fLowPtTrackDownscaligF} ]] && export AliAnalysisTaskFilteredTree_fLowPtTrackDownscaligF
- [[ -n ${AliAnalysisTaskFilteredTree_fLowPtV0DownscaligF} ]] && export AliAnalysisTaskFilteredTree_fLowPtV0DownscaligF
-
- #echo aliroot -l -b -q "merge.C(\"${qaFilesToMerge}\",\"\",kFALSE,\"${qaMergedOutputFileName}\")"
- echo aliroot -b -q "QAtrain_duo.C(\"_barrel\",${runNumber},\"${qaFilesToMerge}\",1,\"${ocdbStorage}\")"
- if [[ -n ${pretend} ]]; then
touch ${qaMergedOutputFileName}
touch merge.log
touch trending.root
touch CalibObjects.root
touch dcsTime.root
touch ${qaMergedOutputFileName}
+ mkdir -p OCDB
else
+ ./${mergingScript} ${calibrationFilesToMerge} ${runNumber} "local://./OCDB" ${ocdbStorage}
+
+ #merge QA (and filtered trees)
+ [[ -n ${AliAnalysisTaskFilteredTree_fLowPtTrackDownscaligF} ]] && export AliAnalysisTaskFilteredTree_fLowPtTrackDownscaligF
+ [[ -n ${AliAnalysisTaskFilteredTree_fLowPtV0DownscaligF} ]] && export AliAnalysisTaskFilteredTree_fLowPtV0DownscaligF
+
+ #echo aliroot -l -b -q "merge.C(\"${qaFilesToMerge}\",\"\",kFALSE,\"${qaMergedOutputFileName}\")"
+ echo aliroot -b -q "QAtrain_duo.C(\"_barrel\",${runNumber},\"${qaFilesToMerge}\",1,\"${ocdbStorage}\")"
#aliroot -l -b -q "merge.C(\"${qaFilesToMerge}\",\"\",kFALSE,\"${qaMergedOutputFileName}\")"
aliroot -b -q "QAtrain_duo.C(\"_barrel\",${runNumber},\"${qaFilesToMerge}\",1,\"${ocdbStorage}\")" > mergeQA.log
mv QAresults_barrel.root ${qaMergedOutputFileName}
#merge filtered trees
echo aliroot -l -b -q "merge.C(\"${qaFilesToMerge}\",\"\",kFALSE,\"${qaMergedOutputFileName}\")"
- aliroot -l -b -q "merge.C(\"${filteredFilesToMerge}\",\"\",kFALSE,\"FilterEvents_Trees.root\")"
+ aliroot -l -b -q "merge.C(\"${filteredFilesToMerge}\",\"\",kFALSE,\"FilterEvents_Trees.root\")" > mergeFilteredTrees.log
+
+ #produce the calib trees for expert QA
+ echo aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
+ aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")" > calibTree.log
fi
-
- #produce the calib trees for expert QA
- echo aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
- aliroot -b -q "${ALICE_ROOT}/PWGPP/TPC/macros/CalibSummary.C(${runNumber},\"${ocdbStorage}\")"
+
+ # Create tarball with OCDB, store on the shared directory, create signal file on batch directory
+ mkdir -p ${commonOutputPath}/meta
+ baseTar="cpass1.localOCDB.${runNumber}.tgz"
+ tar czf ${batchWorkingDirectory}/${baseTar} ./OCDB && \
+ mv ${batchWorkingDirectory}/${baseTar} ${commonOutputPath}/meta/${baseTar} && \
+ touch ${batchWorkingDirectory}/${baseTar}.done
/bin/ls
#copy all to output dir
- cp -pf --recursive ${runpath}/* ${outputDir}
+ cp -pf -R ${runpath}/* ${outputDir}
#validate merge cpass1
cd ${outputDir}
- touch ${doneFile}
- echo "dir ${outputDir}" >> ${doneFile}
- if summarizeLogs >> ${doneFile}; then
- [[ -f CalibObjects.root ]] && echo "calibfile ${outputDir}/CalibObjects.root" >> ${doneFile}
- [[ -f ${qaMergedOutputFileName} ]] && echo "qafile ${outputDir}/${qaMergedOutputFileName}" >> ${doneFile}
- [[ -f trending.root ]] && echo "trendingfile ${outputDir}/trending.root" >> ${doneFile}
- [[ -f dcsTime.root ]] && echo "dcsTree ${outputDir}/dcsTime.root" >> ${doneFile}
- [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFile}
+ touch ${doneFileTmp}
+ echo "dir ${outputDir}" >> ${doneFileTmp}
+ if summarizeLogs >> ${doneFileTmp}; then
+ [[ -f CalibObjects.root ]] && echo "calibfile ${outputDir}/CalibObjects.root" >> ${doneFileTmp}
+ [[ -f ${qaMergedOutputFileName} ]] && echo "qafile ${outputDir}/${qaMergedOutputFileName}" >> ${doneFileTmp}
+ [[ -f trending.root ]] && echo "trendingfile ${outputDir}/trending.root" >> ${doneFileTmp}
+ [[ -f dcsTime.root ]] && echo "dcsTree ${outputDir}/dcsTime.root" >> ${doneFileTmp}
+ [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFileTmp}
+ else
+ if grep "mergeQA.log.*OK" ${doneFileTmp} > /dev/null; then
+ [[ -f ${qaMergedOutputFileName} ]] && echo "qafile ${outputDir}/${qaMergedOutputFileName}" >> ${doneFileTmp}
+ fi
+ if grep "mergeFilteredTrees.log.*OK" ${doneFileTmp} > /dev/null; then
+ [[ -f FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFileTmp}
+ fi
fi
[[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
return 0
-}
+)
goMerge()
-{
+(
#generic root merge using CPass1 merge.C script
inputList=${1}
outputFile=${2}
- configFile=${3-"becnhmark.config"}
+ configFile=${3-"benchmark.config"}
shift 3
if ! parseConfig ${configFile} "$@"; then return 1; fi
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
[[ ! -f ${inputList} ]] && echo "inputList ${inputList} does not exist!" && return 1
[[ ! -f ${configFile} ]] && echo "configFile ${configFile} does not exist!" && return 1
rm -f ${outputFile}
aliroot -b -q "${ALICE_ROOT}/PWGPP/CalibMacros/CPass0/merge.C(\"${inputList}\",\"\",kFALSE,\"${outputFile}\")" > merge_${inputList}.log
return 0
-}
+)
goSubmitMakeflow()
{
shift 3
extraOpts=("$@")
if ! parseConfig ${configFile} "${extraOpts[@]}"; then return 1; fi
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
[[ -z ${configFile} ]] && configFile="benchmark.config"
[[ ! -f ${configFile} ]] && echo "no config file found (${configFile})" && return 1
- #create the directopry for the metadata
- mkdir meta
-
if [[ ! $(which makeflow &>/dev/null) && -n ${makeflowPath} ]]; then
echo "setting the makflow path from the config: "
echo " export PATH=${makeflowPath}:${PATH}"
export PATH=${makeflowPath}:${PATH}
fi
+ #create the common output dir and the meta dir
+ commonOutputPath=${baseOutputDirectory}/${productionID}
+ if [[ -d ${commonOutputPath} ]]; then
+ echo "output dir ${commonOutputPath} exists!"
+ #return 1
+ else
+ mkdir -p ${commonOutputPath}
+ fi
+ mkdir -p ${commonOutputPath}/meta
+
+ self=${0}
+ #if which greadlink; then self=$(greadlink -f "${0}"); fi
+
+ #for reference copy the setup to the output dir
+ cp ${self} ${commonOutputPath}
+ cp ${configFile} ${commonOutputPath}
+ cp ${inputFileList} ${commonOutputPath}
+
#submit - use makeflow if available, fall back to old stuff when makeflow not there
if which makeflow; then
-
- goGenerateMakeflow ${productionID} ${inputFileList} ${configFile} "${extraOpts[@]}" > benchmark.makeflow
-
+ goGenerateMakeflow ${productionID} ${inputFileList} ${configFile} "${extraOpts[@]}" commonOutputPath=${commonOutputPath} > benchmark.makeflow
+ cp benchmark.makeflow ${commonOutputPath}
makeflow ${makeflowOptions} benchmark.makeflow
- cd ../
else
echo "no makeflow!"
fi
}
goGenerateMakeflow()
-{
+(
#generate the makeflow file
[[ $# -lt 3 ]] && echo "args: id inputFileList configFile" && return 1
productionID=${1}
configFile=${3}
shift 3
extraOpts=("$@")
- if ! parseConfig ${configFile} "${extraOpts[@]}"; then return 1; fi
+
+ #batch systems/makeflow sometimes handle spaces in arguments poorly, so encode them
+ for (( i=0;i<${#extraOpts[@]};i++ )); do
+ extraOpts[i]=$(encSpaces "${extraOpts[i]}")
+ done
+ extraOpts+=("encodedSpaces=1")
+
+ if ! parseConfig ${configFile} "${extraOpts[@]}" &>/dev/null; then return 1; fi
+
+ #extra safety
+ if [[ -z ${commonOutputPath} ]]; then
+ commonOutputPath=${baseOutputDirectory}/${productionID}
+ extraOpts=( "${extraOpts[@]}" "commonOutputPath=${commonOutputPath}" )
+ fi
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
[[ -z ${configFile} ]] && configFile="benchmark.config"
[[ ! -f ${configFile} ]] && echo "no config file found (${configFile})" && return 1
- commonOutputPath=${baseOutputDirectory}/${productionID}
-
- self=$(readlink -f "${0}")
- echo "self: $self"
#these files will be made a dependency - will be copied to the working dir of the jobs
declare -a copyFiles
inputFiles=(
"runCalibTrain.C"
"runCPass0.sh"
"recCPass0.C"
+ "runQA.sh"
)
for file in ${inputFiles[*]}; do
[[ -f ${file} ]] && copyFiles+=("${file}")
declare -A arr_cpass0_profiled_outputs
declare -A listOfRuns
[[ -n ${runNumber} ]] && listOfRuns[${runNumber}]=1
- while read x; do listOfRuns[$(guessRunNumber ${x})]=1; done < ${inputFileList}
+ while read x; do tmpRun=$(guessRunNumber ${x}); [[ -n ${tmpRun} ]] && listOfRuns[${tmpRun}]=1; done < ${inputFileList}
for runNumber in "${!listOfRuns[@]}"; do
[[ -z ${runNumber} ]] && continue
[[ ! ${runNumber} =~ ^[0-9]*[0-9]$ ]] && continue
declare -a arr_cpass0_outputs
declare -a arr_cpass1_outputs
+ #Header
+ echo "### Automatically generated on $(LANG=C date) ###"
+ echo ; echo
+
jobindex=0
inputFile=""
while read inputFile; do
if [[ ${autoOCDB} -ne 0 ]]; then
currentDefaultOCDB=$(setYear ${inputFile} ${defaultOCDB})
fi
+ guessRunData ${inputFile}
+
+ #Set variables
+ echo "### Variables ###"
+ echo "OUTPATH=\"${commonOutputPath}/${year}/${period}\""
+ echo ; echo
#CPass0
- arr_cpass0_outputs[${jobindex}]="meta/cpass0.job${jobindex}.run${runNumber}.done"
- echo "${arr_cpass0_outputs[${jobindex}]} : benchmark.sh ${configFile} ${copyFiles[@]}"
- echo -n " ${alirootEnv} ./benchmark.sh CPass0 ${commonOutputPath}/000${runNumber}/cpass0 ${inputFile} ${nEvents} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex}"" "
- for extraOption in "${extraOpts[@]}"; do echo -n \"${extraOption}\"" "; done; echo
- echo
+ #arr_cpass0_outputs[${jobindex}]="${commonOutputPath}/meta/cpass0.job${jobindex}.run${runNumber}.done"
+ arr_cpass0_outputs[${jobindex}]="cpass0.job${jobindex}.run${runNumber}.done"
+ echo "### CPass0 ###"
+ echo "${arr_cpass0_outputs[${jobindex}]}: benchmark.sh ${configFile} ${copyFiles[@]}"
+ echo " ${alirootEnv} ./benchmark.sh CPass0 \$OUTPATH/000${runNumber}/cpass0 ${inputFile} ${nEvents} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex} ${extraOpts[@]}"" "
+ echo ; echo
#CPass1
- arr_cpass1_outputs[${jobindex}]="meta/cpass1.job${jobindex}.run${runNumber}.done"
- echo "${arr_cpass1_outputs[${jobindex}]} : benchmark.sh ${configFile} meta/cpass0.localOCDB.${runNumber}.tgz ${copyFiles[@]}"
- echo -n " ${alirootEnv} ./benchmark.sh CPass1 ${commonOutputPath}/000${runNumber}/cpass1 ${inputFile} ${nEvents} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex}"" "
- for extraOption in "${extraOpts[@]}"; do echo -n \"${extraOption}\"" "; done; echo
- echo
+ #arr_cpass1_outputs[${jobindex}]="${commonOutputPath}/meta/cpass1.job${jobindex}.run${runNumber}.done"
+ arr_cpass1_outputs[${jobindex}]="cpass1.job${jobindex}.run${runNumber}.done"
+ echo "### CPass1 ###"
+ echo "${arr_cpass1_outputs[${jobindex}]}: benchmark.sh ${configFile} cpass0.localOCDB.${runNumber}.tgz.done ${copyFiles[@]}"
+ echo " ${alirootEnv} ./benchmark.sh CPass1 \$OUTPATH/000${runNumber}/cpass1 ${inputFile} ${nEvents} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex} ${extraOpts[@]}"" "
+ echo ; echo
((jobindex++))
done< <(grep "/000${runNumber}/" ${inputFileList})
#CPass0 list of Calib files to merge
- arr_cpass0_calib_list[${runNumber}]="meta/cpass0.calib.run${runNumber}.list"
- echo "${arr_cpass0_calib_list[${runNumber}]} : benchmark.sh ${arr_cpass0_outputs[*]}"
- echo " ./benchmark.sh PrintValues calibfile ${arr_cpass0_calib_list[${runNumber}]} ${arr_cpass0_outputs[*]}"
- echo
+ #arr_cpass0_calib_list[${runNumber}]="${commonOutputPath}/meta/cpass0.calib.run${runNumber}.list"
+ arr_cpass0_calib_list[${runNumber}]="cpass0.calib.run${runNumber}.list"
+ echo "### Produces the list of CPass0 files to merge (executes locally) ###"
+ echo "${arr_cpass0_calib_list[${runNumber}]}: benchmark.sh ${arr_cpass0_outputs[*]}"
+ echo " LOCAL ./benchmark.sh PrintValues calibfile ${arr_cpass0_calib_list[${runNumber}]} ${arr_cpass0_outputs[*]} && mkdir -p \$OUTPATH/meta && cp ${arr_cpass0_calib_list[${runNumber}]} \$OUTPATH/meta/${arr_cpass0_calib_list[${runNumber}]}"
+ echo ; echo
#CPass0 merging
- arr_cpass0_merged[${runNumber}]="meta/merge.cpass0.run${runNumber}.done"
- echo "meta/cpass0.localOCDB.${runNumber}.tgz ${arr_cpass0_merged[${runNumber}]} : benchmark.sh ${configFile} ${arr_cpass0_calib_list[${runNumber}]} ${copyFiles[@]}"
- echo -n " ${alirootEnv} ./benchmark.sh MergeCPass0 ${commonOutputPath}/000${runNumber}/cpass0 ${currentDefaultOCDB} ${configFile} ${runNumber} ${arr_cpass0_calib_list[${runNumber}]}"" "
- for extraOption in "${extraOpts[@]}"; do echo -n \"${extraOption}\"" "; done; echo
- echo
+ echo "### Merges CPass0 files ###"
+ #arr_cpass0_merged[${runNumber}]="${commonOutputPath}/meta/merge.cpass0.run${runNumber}.done"
+ arr_cpass0_merged[${runNumber}]="merge.cpass0.run${runNumber}.done"
+ echo "cpass0.localOCDB.${runNumber}.tgz.done ${arr_cpass0_merged[${runNumber}]}: benchmark.sh ${configFile} ${arr_cpass0_calib_list[${runNumber}]} ${copyFiles[@]}"
+ echo " ${alirootEnv} ./benchmark.sh MergeCPass0 \$OUTPATH/000${runNumber}/cpass0 ${currentDefaultOCDB} ${configFile} ${runNumber} ${arr_cpass0_calib_list[${runNumber}]} ${extraOpts[@]}"" "
+ echo ; echo
#CPass1 list of Calib/QA/ESD/filtered files
# the trick with QA is to have the string "Stage.txt" in the file name of the list of directories with QA output to trigger
# the production of the QA trending tree (only then the task->Finish() will be called in QAtrain_duo.C, on the grid
# this corresponds to the last merging stage)
- arr_cpass1_QA_list[${runNumber}]="meta/cpass1.QA.run${runNumber}.lastMergingStage.txt.list"
+ #arr_cpass1_QA_list[${runNumber}]="${commonOutputPath}/meta/cpass1.QA.run${runNumber}.lastMergingStage.txt.list"
+ arr_cpass1_QA_list[${runNumber}]="cpass1.QA.run${runNumber}.lastMergingStage.txt.list"
+ echo "### Lists CPass1 QA ###"
echo "${arr_cpass1_QA_list[${runNumber}]}: benchmark.sh ${arr_cpass1_outputs[*]}"
- echo " ./benchmark.sh PrintValues dir ${arr_cpass1_QA_list[${runNumber}]} ${arr_cpass1_outputs[*]}"
- echo
- arr_cpass1_calib_list[${runNumber}]="meta/cpass1.calib.run${runNumber}.list"
- echo "${arr_cpass1_calib_list[${runNumber}]} : benchmark.sh ${arr_cpass1_outputs[*]}"
- echo " ./benchmark.sh PrintValues calibfile ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_outputs[*]};"
- echo
- arr_cpass1_ESD_list[${runNumber}]="meta/cpass1.ESD.run${runNumber}.list"
- echo "${arr_cpass1_ESD_list[${runNumber}]} : benchmark.sh ${arr_cpass1_outputs[*]}"
- echo " ./benchmark.sh PrintValues esd ${arr_cpass1_ESD_list[${runNumber}]} ${arr_cpass1_outputs[*]}"
- echo
- arr_cpass1_filtered_list[${runNumber}]="meta/cpass1.filtered.run${runNumber}.list"
- echo "${arr_cpass1_filtered_list[${runNumber}]} : benchmark.sh ${arr_cpass1_outputs[*]}"
- echo " ./benchmark.sh PrintValues filteredTree ${arr_cpass1_filtered_list[${runNumber}]} ${arr_cpass1_outputs[*]}"
- echo
+ echo " LOCAL ./benchmark.sh PrintValues dir ${arr_cpass1_QA_list[${runNumber}]} ${arr_cpass1_outputs[*]} && mkdir -p \$OUTPATH/meta && cp ${arr_cpass1_QA_list[${runNumber}]} \$OUTPATH/meta/${arr_cpass1_QA_list[${runNumber}]}"
+ echo ; echo
+
+ #arr_cpass1_calib_list[${runNumber}]="${commonOutputPath}/meta/cpass1.calib.run${runNumber}.list"
+ arr_cpass1_calib_list[${runNumber}]="cpass1.calib.run${runNumber}.list"
+ echo "### Lists CPass1 Calib ###"
+ echo "${arr_cpass1_calib_list[${runNumber}]}: benchmark.sh ${arr_cpass1_outputs[*]}"
+ echo " LOCAL ./benchmark.sh PrintValues calibfile ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_outputs[*]} && mkdir -p \$OUTPATH/meta && cp ${arr_cpass1_calib_list[${runNumber}]} \$OUTPATH/meta/${arr_cpass1_calib_list[${runNumber}]}"
+ echo ; echo
+
+ #arr_cpass1_ESD_list[${runNumber}]="${commonOutputPath}/meta/cpass1.ESD.run${runNumber}.list"
+ arr_cpass1_ESD_list[${runNumber}]="cpass1.ESD.run${runNumber}.list"
+ echo "### Lists CPass1 ESDs ###"
+ echo "${arr_cpass1_ESD_list[${runNumber}]}: benchmark.sh ${arr_cpass1_outputs[*]}"
+ echo " LOCAL ./benchmark.sh PrintValues esd ${arr_cpass1_ESD_list[${runNumber}]} ${arr_cpass1_outputs[*]} && mkdir -p \$OUTPATH/meta && cp ${arr_cpass1_ESD_list[${runNumber}]} \$OUTPATH/meta/${arr_cpass1_ESD_list[${runNumber}]}"
+ echo ; echo
+
+ #arr_cpass1_filtered_list[${runNumber}]="${commonOutputPath}/meta/cpass1.filtered.run${runNumber}.list"
+ arr_cpass1_filtered_list[${runNumber}]="cpass1.filtered.run${runNumber}.list"
+ echo "### Lists CPass1 filtered ###"
+ echo "${arr_cpass1_filtered_list[${runNumber}]}: benchmark.sh ${arr_cpass1_outputs[*]}"
+ echo " LOCAL ./benchmark.sh PrintValues filteredTree ${arr_cpass1_filtered_list[${runNumber}]} ${arr_cpass1_outputs[*]} && mkdir -p \$OUTPATH/meta && cp ${arr_cpass1_filtered_list[${runNumber}]} \$OUTPATH/meta/${arr_cpass1_filtered_list[${runNumber}]}"
+ echo ; echo
#CPass1 merging
- arr_cpass1_merged[${runNumber}]="meta/merge.cpass1.run${runNumber}.done"
- echo "meta/cpass1.localOCDB.${runNumber}.tgz ${arr_cpass1_merged[${runNumber}]} : benchmark.sh ${configFile} ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_QA_list[${runNumber}]} ${copyFiles[@]}"
- echo -n " ${alirootEnv} ./benchmark.sh MergeCPass1 ${commonOutputPath}/000${runNumber}/cpass1 ${currentDefaultOCDB} ${configFile} ${runNumber} ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_QA_list[${runNumber}]} ${arr_cpass1_filtered_list[${runNumber}]}"" "
- for extraOption in "${extraOpts[@]}"; do echo -n \"${extraOption}\"" "; done; echo
- echo
+ #arr_cpass1_merged[${runNumber}]="${commonOutputPath}/meta/merge.cpass1.run${runNumber}.done"
+ arr_cpass1_merged[${runNumber}]="merge.cpass1.run${runNumber}.done"
+ echo "### Merges CPass1 files ###"
+ echo "cpass1.localOCDB.${runNumber}.tgz.done ${arr_cpass1_merged[${runNumber}]}: benchmark.sh ${configFile} ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_QA_list[${runNumber}]} ${copyFiles[@]}"
+ echo " ${alirootEnv} ./benchmark.sh MergeCPass1 \$OUTPATH/000${runNumber}/cpass1 ${currentDefaultOCDB} ${configFile} ${runNumber} ${arr_cpass1_calib_list[${runNumber}]} ${arr_cpass1_QA_list[${runNumber}]} ${arr_cpass1_filtered_list[${runNumber}]} ${extraOpts[@]}"" "
+ echo ; echo
#CPass0 wrapped in a profiling tool (valgrind,....)
- if [[ -n profilingCommand ]]; then
- arr_cpass0_profiled_outputs[${runNumber}]="meta/cpass0.jobProfiled.run${runNumber}.done"
- echo "${arr_cpass0_profiled_outputs[${runNumber}]} : benchmark.sh ${configFile} ${copyFiles[@]}"
- echo -n " ${alirootEnv} ./benchmark.sh CPass0 ${commonOutputPath}/000${runNumber}/profiled ${inputFile} ${nEventsProfiling} ${currentDefaultOCDB} ${configFile} ${runNumber} profiling"" "
- for extraOption in "${extraOpts[@]}"; do echo -n \"${extraOption}\"" "; done;
- echo "\"useProfilingCommand=${profilingCommand}\""
- echo
+ if [[ -n ${profilingCommand} ]]; then
+ inputFile=$(grep -m1 "${runNumber}/" ${inputFileList})
+ [[ -z ${nEventsProfiling} ]] && nEventsProfiling=2
+ currentDefaultOCDB=$(setYear ${inputFile} ${defaultOCDB})
+ jobindex="profiling"
+
+ #arr_cpass0_profiled_outputs[${runNumber}]="${commonOutputPath}/meta/profiling.cpass0.job${jobindex}.run${runNumber}.done"
+ arr_cpass0_profiled_outputs[${runNumber}]="profiling.cpass0.job${jobindex}.run${runNumber}.done"
+ echo "### CPass0 in a profiler ###"
+ echo "${arr_cpass0_profiled_outputs[${runNumber}]}: benchmark.sh ${configFile} ${copyFiles[@]}"
+ profilingCommand=$(encSpaces "${profilingCommand}")
+ echo " ${alirootEnv} ./benchmark.sh CPass0 \$OUTPATH/000${runNumber}/${jobindex} ${inputFile} ${nEventsProfiling} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex} ${extraOpts[@]} useProfilingCommand=${profilingCommand}"
+ echo ; echo
fi
done #runs
#Summary
- echo "summary.log : benchmark.sh ${configFile} ${arr_cpass1_merged[*]}"
- echo " LOCAL ./benchmark.sh MakeSummary ${configFile}"
- echo
+ echo "### Summary ###"
+ echo "summary.log: benchmark.sh ${configFile} ${arr_cpass1_merged[*]}"
+ echo " ${alirootEnv} ./benchmark.sh MakeSummary ${configFile} ${extraOpts[@]}"
+ echo ; echo
return 0
-}
+)
goPrintValues()
-{
+(
#print the values given the key from any number of files (store in output file on second argument)
if [[ $# -lt 3 ]]; then
echo "goPrintValues key outputFile inputFiles"
- echo "if outputFile is \"-\" dont redirect to a file"
+ echo "if outputFile is \"-\" don't redirect to a file"
return
fi
key=${1}
shift 2 #remove 2 first arguments from arg list to only pass the input files to awk
awk -v key=${key} '$0 ~ key" " {print $2}' "$@" | tee ${outputFile}
return 0
-}
+)
goCreateQAplots()
-{
+(
umask 0002
mergedQAfileList=${1}
productionID=${2}
outputDir=${3}
configFile=${4}
shift 4
- if ! parseConfig ${configFile} ${@}; then return 1; fi
+ if ! parseConfig ${configFile} "$@"; then return 1; fi
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
+
[[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
[[ -z ${logOutputDir} ]] && logOutputDir=${PWD}
- [[ -z ${dontRedirectStdOutToLog} ]] && exec 2>&1 > ${logOutputDir}/makeQAplots.log
+ [[ -z ${dontRedirectStdOutToLog} ]] && exec &> ${logOutputDir}/makeQAplots.log
echo "${0} $*"
olddir=${PWD}
mkdir -p ${outputDir}
cd ${outputDir}
- [[ ! "${PWD}" = "${outputDir}" ]] && echo "cannot make ${outputDir}... exiting" && return 1
+ [[ ! "${PWD}" =~ "${outputDir}" ]] && echo "PWD is not equal to outputDir=${outputDir}" && cd ${olddir} && return 1
- echo ${ALICE_ROOT}/PWGPP/QA/scripts/runQA.sh inputList=${mergedQAfileList}
- ${ALICE_ROOT}/PWGPP/QA/scripts/runQA.sh inputList="${mergedQAfileList}" inputListHighPtTrees="${filteringList}"
+ inputFiles=(
+ "${batchWorkingDirectory}/runQA.sh"
+ "${ALICE_ROOT}/PWGPP/QA/scripts/runQA.sh"
+ )
+ for file in ${inputFiles[*]}; do
+ [[ ! -f ${file##*/} && -f ${file} ]] && echo "copying ${file}" && cp -f ${file} .
+ done
+ echo "running QA with command:"
+ echo ./runQA.sh inputList="${mergedQAfileList}" inputListHighPtTrees="${filteringList}" ocdbStorage="${defaultOCDB}"
+ ./runQA.sh inputList="${mergedQAfileList}" inputListHighPtTrees="${filteringList}" ocdbStorage="${defaultOCDB}"
cd ${olddir}
return 0
-}
+)
goTest()
-{
- umask 0002
- exec 2>&1
- exec > >(tee test.log)
- echo "$@"
- echo something
- return 0
-}
+(
+ echo AA
+)
alirootInfo()
-{
+(
umask 0002
# save aliroot repository info
[[ -z "${ALICE_ROOT}" ]] && return 1
echo "\${ROOTSYS}=${ROOTSYS}"
echo "\${PATH}=${PATH}"
echo "\${LD_LIBRARY_PATH}=${LD_LIBRARY_PATH}"
+ echo
pushd ${PWD}
cd ${ALICE_ROOT}
- echo
currentBranch=$(git rev-parse --abbrev-ref HEAD)
git status
git diff ${currentBranch}
popd
return 0
-}
+)
setYear()
-{
+(
#set the year
# ${1} - year to be set
# ${2} - where to set the year
[[ ${year1} -ne ${year2} && -n ${year2} && -n ${year1} ]] && path=${2/\/${year2}\//\/${year1}\/}
echo ${path}
return 0
-}
+)
guessPeriod()
-{
+(
#guess the period from the path, pick the rightmost one
local IFS="/"
declare -a path=( ${1} )
done
echo ${period}
return 0
-}
+)
guessYear()
-{
+(
#guess the year from the path, pick the rightmost one
local IFS="/"
declare -a path=( ${1} )
done
echo ${year}
return 0
-}
+)
guessRunNumber()
-{
+(
#guess the run number from the path, pick the rightmost one
#works for /path/foo/000123456/bar/...
#and /path/foo.run123456.bar
for ((x=${dirDepth}-1;x>=0;x--)); do
local field=${path[${x}]}
field=${field/run/000}
- [[ ${field} =~ ^000[0-9][0-9][0-9][0-9][0-9][0-9]$ ]] && runNumber=${field#000} && break
+ [[ ${field} =~ [0-9][0-9][0-9][0-9][0-9][0-9]$ ]] && runNumber=${field#000} && break
done
echo ${runNumber}
return 0
-}
+)
validateLog()
-{
+(
log=${1}
errorConditions=(
'There was a crash'
'AliFatal'
'core dumped'
'\.C.*error:.*\.h: No such file'
+ 'line.*Aborted'
)
warningConditions=(
fi
return 0
-}
+)
summarizeLogs()
-{
+(
#print a summary of logs
logFiles=(
"*.log"
if [[ ${validationStatus} -eq 0 ]]; then
#in pretend mode randomly report an error in rec.log some cases
if [[ -n ${pretend} && "${log}" == "rec.log" ]]; then
- [[ $(( ${RANDOM}%2 )) -ge 1 ]] && echo "${finallog} BAD random error" || echo "${finallog} OK"
+ #[[ $(( ${RANDOM}%2 )) -ge 1 ]] && echo "${finallog} BAD random error" || echo "${finallog} OK"
+ echo "${finallog} OK"
else
echo "${finallog} OK"
fi
done < <(/bin/ls ${PWD}/*/core 2>/dev/null; /bin/ls ${PWD}/core 2>/dev/null)
return ${logstatus}
-}
+)
spitOutLocalOCDBaccessConfig()
{
local tempLocalOCDB=""
if [[ -f localOCDBaccessConfig.C ]]; then
- tempLocalOCDB=$(mktemp)
+ tempLocalOCDB=$(mktemp -t tempLocalOCDB.XXXXXX)
echo "egrep "SetSpecificStorage" localOCDBaccessConfig.C > ${tempLocalOCDB}"
egrep "SetSpecificStorage" localOCDBaccessConfig.C > ${tempLocalOCDB}
fi
}
goMakeFilteredTrees()
-{
+(
outputDir=${1}
runNumber=${2}
#get path to input list
esdFileName=${12-"AliESDs_Barrel.root"}
shift 12
if ! parseConfig ${configFile} "$@"; then return 1; fi
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
- commonOutputPath=${PWD}
- doneFile=${commonOutputPath}/meta/filtering.cpass1.run${runNumber}.done
-
- runpath=${outputDir}
- [[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
- [[ ${reconstructInTemporaryDir} -eq 1 && -z ${TMPDIR} ]] && runpath=$(mktemp -d)
-
-
- [[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
-
- mkdir -p ${outputDir}
- mkdir -p ${runpath}
+ [[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
+ doneFileBase=filtering.cpass1.run${runNumber}.done
+ doneFileTmp=${batchWorkingDirectory}/${doneFileBase}
+ doneFile=${commonOutputPath}/meta/${doneFileBase}
- cd ${runpath}
-
cat > filtering.log << EOF
goMakeFilteredTrees config:
runpath=${runpath}
offsetEvent=$offsetEvent
configFile=$configFile
esdFileName=$esdFileName
+ inputListfiles=$inputListfiles
+ doneFile=$doneFile
EOF
+ #runpath=${outputDir}
+ #[[ ${reconstructInTemporaryDir} -eq 1 && -n ${TMPDIR} ]] && runpath=${TMPDIR}
+ #[[ ${reconstructInTemporaryDir} -eq 1 ]] && runpath=$(mktemp -d -t goMakeFilteredTrees.XXXXXX)
+ #mkdir -p ${outputDir}
+ #mkdir -p ${runpath}
+ #if ! cd ${runpath}; then
+ # echo "PWD=$PWD is not the runpath=${runpath}"
+ # touch ${doneFile}
+ # return 1
+ #fi
+
if [[ -z ${pretend} ]];then
aliroot -l -b -q "${ALICE_ROOT}/PWGPP/macros/runFilteringTask.C(\"${inputListfiles}\",${filterT},${filterV},\"${OCDBpath}\",${maxFiles},${offsetFile},${maxEvents},${offsetEvent},\"${esdFileName}\")" &>> filtering.log
else
+ sleep ${pretendDelay}
touch filtering.log FilterEvents_Trees.root
fi
pwd
/bin/ls
touch ${doneFile}
summarizeLogs >> ${doneFile}
- echo mv -f * ${outputDir}
- mv -f * ${outputDir}
- [[ -f ${outputDir}/FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFile}
- cd ${commonOutputPath}
- [[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+
+ #echo mv -f * ${outputDir}
+ #mv -f * ${outputDir}
+ #[[ -f ${outputDir}/FilterEvents_Trees.root ]] && echo "filteredTree ${outputDir}/FilterEvents_Trees.root" >> ${doneFile}
+ #cd ${commonOutputPath}
+ #[[ "${runpath}" != "${outputDir}" ]] && rm -rf ${runpath}
+
+ cp "$doneFileTmp" "$doneFile" || rm -f "$doneFileTmp" "$doneFile"
+ [[ -n ${removeTMPdoneFile} ]] && rm -f ${doneFileTmp}
+
return 0
-}
+)
submit()
{
waitForJOBID=${4}
command=${5}
shift 5
- commandArgs=("$@")
+ local commandArgs=("$@")
#add quote strings around the extra arguments
for ((i=0; i<${#commandArgs[@]}; i++)); do
productionID=${1}
inputList=${2}
configFile=${3:-"benchmark.config"}
- configFile=$(readlink -f ${configFile})
+ #if which greadlink; then configFile=$(greadlink -f ${configFile}); fi
shift 3
extraOpts=("$@")
if ! parseConfig ${configFile} "${extraOpts[@]}"; then return 1; fi
+
+ #batch systems/makeflow sometimes handle spaces in arguments poorly, so encode them
+ for (( i=0;i<${#extraOpts[@]};i++ )); do
+ extraOpts[i]=$(encSpaces "${extraOpts[i]}")
+ done
+ extraOpts+=("encodedSpaces=1")
+ #this removes the copy of the done file used by makeflow (in the running dir)
+ extraOpts+=("removeTMPdoneFile=1")
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
#redirect all output to submit.log
echo "redirecting all output to ${PWD}/submit_${productionID//"/"/_}.log"
[[ ! -f ${alirootEnv} ]] && echo "alirootEnv script ${alirootEnv} not found!..." && return 1
#move the script, config and some other stuff to ${commonOutputPath} first, then use them from there
- self=$(readlink -f "${0}")
+ self=${0}
+ #if which greadlink; then self=$(greadlink -f "${0}"); fi
configPath=$(dirname ${configFile})
export commonOutputPath=${baseOutputDirectory}/${productionID}
inputList=${commonOutputPath}/${inputList##*/}
#convert to absolut pathnames
- inputList=$(readlink -f "${inputList}")
+ #if which greadlink; then inputList=$(greadlink -f "${inputList}"); fi
#make list of runs
if [[ -z ${runNumber} ]]; then
listOfRuns=($(while read x; do guessRunNumber ${x}; done < ${inputList} | sort | uniq))
listOfRuns=${runNumber}
fi
- alirootSource=$(readlink -f "${alirootSource}")
+ #if which greadlink; then alirootSource=$(greadlink -f "${alirootSource}"); fi
echo ""
echo "### BEGIN CONFIGURATION ###"
JOBfilterESDcpass1="fp1_${JOBpostfix}"
LASTJOB="000"
- oneInputFile=$(egrep -m1 "${runNumber}\/" ${inputList})
+ oneInputFile=$(egrep -m1 "${runNumber}/" ${inputList})
currentDefaultOCDB=${defaultOCDB}
[[ -z ${autoOCDB} ]] && autoOCDB=1
if [[ ${autoOCDB} -ne 0 ]]; then
currentDefaultOCDB=$(setYear ${oneInputFile} ${defaultOCDB})
fi
+ period=$(guessPeriod ${oneInputFile})
+ year=$(guessYear ${oneInputFile})
echo "submitting run ${runNumber} with OCDB ${currentDefaultOCDB}"
if [[ -n ${profilingCommand} ]]; then
[[ -z ${nEventsProfiling} ]] && nEventsProfiling=2
[[ -z ${profilingCommand} ]] && profilingCommand="/usr/bin/valgrind --tool=callgrind --num-callers=40 -v --trace-children=yes"
- submit "valgrind" 1 1 000 "${alirootEnv} ${self}" CPass0 ${commonOutputPath}/000${runNumber}/valgrind ${oneInputFile} ${nEventsProfiling} ${currentDefaultOCDB} ${configFile} ${runNumber} valgrind useProfilingCommand=${profilingCommand} "${extraOpts[@]}"
+ submit "profile-${JOBpostfix}" 1 1 000 "${alirootEnv} ${self}" CPass0 ${commonOutputPath}/${year}/${period}/000${runNumber}/${jobindex} ${oneInputFile} ${nEventsProfiling} ${currentDefaultOCDB} ${configFile} ${runNumber} ${jobindex} useProfilingCommand=$(encSpaces "${profilingCommand}") "${extraOpts[@]}"
fi
################################################################################
echo
# create directory and copy all files that are needed
- targetDirectory="${commonOutputPath}/000${runNumber}/cpass0"
+ targetDirectory="${commonOutputPath}/${year}/${period}/000${runNumber}/cpass0"
mkdir -p ${targetDirectory}
filesCPass0=(
submit ${JOBID1} 1 ${nFiles} 000 "${alirootEnv} ${self}" CPass0 ${targetDirectory} ${localInputList} ${nEvents} ${currentDefaultOCDB} ${configFile} ${runNumber} -1 "${extraOpts[@]}"
## submit a monitoring job that will run until a certain number of jobs are done with reconstruction
- submit "${JOBID1wait}" 1 1 000 "${alirootEnv} ${self}" WaitForOutput ${commonOutputPath} "meta/cpass0.job*.run${runNumber}.done" ${nFilesToWaitFor} ${maxSecondsToWait} '-maxdepth 1'
+ submit "${JOBID1wait}" 1 1 000 "${alirootEnv} ${self}" WaitForOutput ${commonOutputPath} "meta/cpass0.job*.run${runNumber}.done" ${nFilesToWaitFor} ${maxSecondsToWait}
LASTJOB=${JOBID1wait}
fi #end running CPass0
echo "submit CPass0 merging for run ${runNumber}"
echo
- targetDirectory="${commonOutputPath}/000${runNumber}/cpass0"
+ targetDirectory="${commonOutputPath}/${year}/${period}/000${runNumber}/cpass0"
mkdir -p ${targetDirectory}
#copy the scripts
if [ ${runCPass1reco} -eq 1 ]; then
- targetDirectory="${commonOutputPath}/000${runNumber}/cpass1"
+ targetDirectory="${commonOutputPath}/${year}/${period}/000${runNumber}/cpass1"
rm -f ${commonOutputPath}/meta/cpass1.job*.run${runNumber}.done
# safety feature: if we are re-running for any reason we want to delete the previous output first.
################################################################################
## submit a monitoring job that will run until a certain number of jobs are done with reconstruction
- submit "${JOBID4wait}" 1 1 "${LASTJOB}" "${alirootEnv} ${self}" WaitForOutput ${commonOutputPath} "meta/cpass1.job*.run${runNumber}.done" ${nFilesToWaitFor} ${maxSecondsToWait} '-maxdepth 1'
+ submit "${JOBID4wait}" 1 1 "${LASTJOB}" "${alirootEnv} ${self}" WaitForOutput ${commonOutputPath} "meta/cpass1.job*.run${runNumber}.done" ${nFilesToWaitFor} ${maxSecondsToWait}
LASTJOB=${JOBID4wait}
################################################################################
echo "submit CPass1 merging for run ${runNumber}"
echo
- targetDirectory="${commonOutputPath}/000${runNumber}/cpass1"
+ targetDirectory="${commonOutputPath}/${year}/${period}/000${runNumber}/cpass1"
rm -f ${commonOutputPath}/meta/merge.cpass1.run${runNumber}.done
mkdir -p ${targetDirectory}
# echo submitting filtering for run ${runNumber}
# echo
# submit "${JOBmakeESDlistCPass1}" 1 1 "${LASTJOB}" "${self}" PrintValues esd ${commonOutputPath}/meta/cpass1.ESD.run${runNumber}.list ${commonOutputPath}/meta/cpass1.job*.run${runNumber}.done
- # submit "${JOBfilterESDcpass1}" 1 1 "${JOBmakeESDlistCPass1}" "${alirootEnv} ${self}" MakeFilteredTrees ${commonOutputPath}/000${runNumber}/cpass1 ${runNumber} ${commonOutputPath}/meta/cpass1.ESD.run${runNumber}.list ${filteringFactorHighPt} ${filteringFactorV0s} ${currentDefaultOCDB} 1000000 0 10000000 0 ${configFile} AliESDs_Barrel.root "${extraOpts[@]}"
+ # submit "${JOBfilterESDcpass1}" 1 1 "${JOBmakeESDlistCPass1}" "${alirootEnv} ${self}" MakeFilteredTrees ${commonOutputPath}/${year}/${period}/000${runNumber}/cpass1 ${runNumber} ${commonOutputPath}/meta/cpass1.ESD.run${runNumber}.list ${filteringFactorHighPt} ${filteringFactorV0s} ${currentDefaultOCDB} 1000000 0 10000000 0 ${configFile} AliESDs_Barrel.root "${extraOpts[@]}"
# LASTJOB=${JOBfilterESDcpass1}
#fi
}
goWaitForOutput()
-{
+(
umask 0002
[[ $# -lt 3 ]] && echo "goWaitForOutput() wrong number of arguments, exiting.." && return 1
echo searchPath=${1}
fileName=${2}
numberOfFiles=${3}
maxSecondsToWait=${4}
- extraFindOptions=${5}
- echo "command to be executed: /bin/ls -1 ${searchPath}/${fileName} ${extraFindOptions}"
+ echo "command to be executed: /bin/ls -1 ${searchPath}/${fileName}"
[[ -z "${maxSecondsToWait}" ]] && maxSecondsToWait=$(( 3600*12 ))
while true; do
- #n=$(find ${searchPath} ${extraFindOptions} -name "${fileName}" | wc -l)
n=$(/bin/ls -1 ${searchPath}/${fileName} 2>/dev/null | wc -l)
[[ ${n} -gt 0 ]] && echo "found ${n} X ${fileName}"
[[ ${n} -ge ${numberOfFiles} ]] && break
done
echo "DONE! exiting..."
return 0
-}
+)
mergeSysLogs()
-{
+(
outputFile=${1}
shift
inputFiles="$@"
(( i++ ))
done < <(ls -1 ${inputFiles}) > ${outputFile}
return 0
-}
+)
goMakeMergedSummaryTree()
-{
+(
# create list of calibration entries
# takes no arguments, just run it in the base output
# directory with the following files in the working directory
# summary_pass0.tree
# summary_pass1.tree
#
-
+
[[ ! -f cpass0.dcsTree.list ]] && echo "no cpass0.dcsTree.list" && return 1
[[ ! -f cpass1.dcsTree.list ]] && echo "no cpass1.dcsTree.list" && return 1
[[ ! -f trending.root ]] && echo "no trending.root" && return 1
//
// Calibration values dump
//
+ //Printf("MakeTreeFromList cpass0.dcsTree.list");
AliXRDPROOFtoolkit::MakeTreeFromList("Calib.TPC.CPass0.root", "dcs","dcs","cpass0.dcsTree.list",1);
+ //Printf("MakeTreeFromList cpass1.dcsTree.list");
AliXRDPROOFtoolkit::MakeTreeFromList("Calib.TPC.CPass1.root", "dcs","dcs","cpass1.dcsTree.list",1);
//
// Calibration status dump
//
TFile *fprod = TFile::Open("fproduction.root","recreate");
TTree tree0, tree1;
+ //Printf("reading summary_pass0.tree");
tree0.ReadFile("summary_pass0.tree");
+ //Printf("reading summary_pass1.tree");
tree1.ReadFile("summary_pass1.tree");
tree0.Write("CPass0");
tree1.Write("CPass1");
stringSetup+="1#CPass0#runnumber#CPass0#fproduction.root+"; //
stringSetup+="1#CPass1#runnumber#CPass1#fproduction.root+"; //
//
+ //Printf("stringSetup: %s", stringSetup.Data());
AliXRDPROOFtoolkit::JoinTreesIndex("outAll.root","joinAll","run",stringSetup.Data(), 1);
}
EOF
aliroot -b -q "mergeTree.C" > mergeTrees.log
return $?
-}
+)
+
+stackTraceTree()
+(
+ # make stacktrace processing in case of standard root crash log
+ # input is a (list of) text files with the stack trace (either gdb aoutput
+ # produced with e.g. gdb --batch --quiet -ex "bt" -ex "quit" aliroot core, or the root crash log), output is a TTree formatted table.
+# example usage:
+# benchmark.sh stackTraceTree /foo/*/rec.log
+ gawk '
+ BEGIN {
+ print "frame/I:method/C:line/C:cpass/I:aliroot/I";
+ RS="#[0-9]*";
+ aliroot=0;
+ read=1;
+ }
+ /There was a crash/ {read=1;}
+ /The lines below might hint at the cause of the crash/ {read=0;}
+ read==1 {
+ if ($3 ~ /Ali*/) aliroot=1; else aliroot=0;
+ gsub("#","",RT);
+ if ($NF!="" && RT!="" && $3!="") print RT" "$3" "$NF" "0" "aliroot
+ }
+ ' "$@" 2>/dev/null
+)
goMakeSummary()
-{
+(
#all the final stuff goes in here for ease of use:
# summary logs
# qa plot making
# final file lists
+ # runs in current dir - in makeflow mode it can run LOCAL, then the QA plots and summaries
+ # will appear in the submission dir.
#some defaults:
log="summary.log"
productionID="qa"
extraOpts=("$@")
if ! parseConfig ${configFile} "${extraOpts[@]}"; then return 1; fi
- [[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
+ #if which greadlink; then configFile=$(greadlink -f ${configFile}); fi
+
+ #record the working directory provided by the batch system
+ batchWorkingDirectory=${PWD}
- exec &> >(tee ${log})
+ logTmp=${batchWorkingDirectory}/${log}
+ logDest=${commonOutputPath}/${log}
+
+ [[ -f ${alirootSource} && -z ${ALICE_ROOT} ]] && source ${alirootSource}
[[ ! -f ${configFile} ]] && echo "no config file ${configFile}!" && return
[[ -z ${commonOutputPath} ]] && commonOutputPath=${PWD}
+ #copy some useful stuff
+ #and go to the commonOutputPath
+ cp ${configFile} ${commonOutputPath}
+
+ exec &> >(tee ${logTmp})
+
#summarize the global stuff
echo "env script: ${alirootSource} ${alirootEnv}"
echo "\$ALICE_ROOT=${ALICE_ROOT}"
echo "commonOutputPath=${commonOutputPath}"
#summarize the stacktraces
- awk '
- BEGIN {
- print "frame/I:method/C:line/C:cpass/I:aliroot/I";
- RS="#[0-9]*";
- aliroot=0;
- }
- {
- if ($3 ~ /Ali*/) aliroot=1; else aliroot=0;
- gsub("#","",RT);
- if ($NF!="" && RT!="" && $3!="") print RT" "$3" "$NF" "0" "aliroot
- }
- ' 000*/cpass0/*/stacktrace* 2>/dev/null > stacktrace.tree
- awk '
- BEGIN {
- RS="#[0-9]*";
- aliroot=0;
- }
- {
- if ($3 ~ /Ali*/) aliroot=1; else aliroot=0;
- gsub("#","",RT);
- if ($NF!="" && RT!="" && $3!="") print RT" "$3" "$NF" "1" "aliroot
- }
- ' 000*/cpass1/*/stacktrace* 2>/dev/null >> stacktrace.tree
+ stackTraceTree ${commonOutputPath}/*/*/000*/cpass0/*/stacktrace* > stacktrace_cpass0.tree
+ stackTraceTree ${commonOutputPath}/*/*/000*/cpass1/*/stacktrace* > stacktrace_cpass1.tree
echo total numbers for the production:
echo
awk 'BEGIN {nFiles=0;nCore=0;}
/^calibfile/ {nFiles++;}
/core dumped/ {nCore++i;}
- END {print "cpass0 produced "nFiles" calib files, "nCore" core files";}' meta/cpass0.job*done 2>/dev/null
+ END {print "cpass0 produced "nFiles" calib files, "nCore" core files";}' ${commonOutputPath}/meta/cpass0.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/\/rec.log OK/ {nOK++;}
/\/rec.log BAD/ {nBAD++;}
/stderr BAD/ {if ($0 ~ /rec.log/){nBAD++;}}
- END {print "cpass0 reco: OK: "nOK"\tBAD: "nBAD;}' meta/cpass0.job*done 2>/dev/null
+ END {print "cpass0 reco: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/cpass0.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/\/calib.log OK/ {nOK++;}
/\/calib.log BAD/ {nBAD++;}
- END {print "cpass0 calib: OK: "nOK"\tBAD: "nBAD;}' meta/cpass0.job*done 2>/dev/null
+ END {print "cpass0 calib: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/cpass0.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/merge.log OK/ {nOK++;}
/merge.log BAD/ {nBAD++;}
- END {print "cpass0 merge: OK: "nOK"\tBAD: "nBAD;}' meta/merge.cpass0*done 2>/dev/null
+ END {print "cpass0 merge: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/merge.cpass0*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/ocdb.log OK/ {nOK++;}
/ocdb.log BAD/ {nBAD++;}
- END {print "cpass0 OCDB: OK: "nOK"\tBAD: "nBAD;}' meta/merge.cpass0*done 2>/dev/null
+ END {print "cpass0 OCDB: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/merge.cpass0*done 2>/dev/null
echo
awk 'BEGIN {nFiles=0;nCore=0;}
/^calibfile/ {nFiles++;}
/core dumped/ {nCore++;}
- END {print "cpass1 produced "nFiles" calib files, "nCore" core files";}' meta/cpass1.job*done 2>/dev/null
+ END {print "cpass1 produced "nFiles" calib files, "nCore" core files";}' ${commonOutputPath}/meta/cpass1.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/\/rec.log OK/ {nOK++;}
/\/rec.log BAD/ {nBAD++;}
/stderr BAD/ {if ($0 ~ /rec.log/){nBAD++;}}
- END {print "cpass1 reco: OK: "nOK"\tBAD: "nBAD;}' meta/cpass1.job*done 2>/dev/null
+ END {print "cpass1 reco: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/cpass1.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/\/calib.log OK/ {nOK++;}
/\/calib.log BAD/ {nBAD++;}
- END {print "cpass1 calib: OK: "nOK"\tBAD: "nBAD;}' meta/cpass1.job*done 2>/dev/null
+ END {print "cpass1 calib: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/cpass1.job*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/merge.log OK/ {nOK++;}
/merge.log BAD/ {nBAD++;}
- END {print "cpass1 merge: OK: "nOK"\tBAD: "nBAD;}' meta/merge.cpass1*done 2>/dev/null
+ END {print "cpass1 merge: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/merge.cpass1*done 2>/dev/null
awk 'BEGIN {nOK=0; nBAD=0; }
/ocdb.log OK/ {nOK++;}
/ocdb.log BAD/ {nBAD++;}
- END {print "cpass1 OCDB: OK: "nOK"\tBAD: "nBAD;}' meta/merge.cpass1*done 2>/dev/null
+ END {print "cpass1 OCDB: OK: "nOK"\tBAD: "nBAD;}' ${commonOutputPath}/meta/merge.cpass1*done 2>/dev/null
echo
echo per run stats:
- /bin/ls -1 meta/merge.cpass0.run*.done | while read x
+ /bin/ls -1 ${commonOutputPath}/meta/merge.cpass0.run*.done | while read x
do
dir=$(goPrintValues calibfile - ${x})
runNumber=$(guessRunNumber ${dir})
[[ -z ${runNumber} ]] && continue
- if $(/bin/ls meta/cpass0.job*.run${runNumber}.done &> /dev/null); then
+ if $(/bin/ls ${commonOutputPath}/meta/cpass0.job*.run${runNumber}.done &> /dev/null); then
statusCPass0=( $(
awk 'BEGIN {nOKrec=0;nBADrec=0;nOKcalib=0;nBADcalib=0;nOKstderr=0;nBADstderr=0;}
/\/rec.log OK/ {nOKrec++;}
/stderr OK/ {nOKstderr++;}
/\/calib.log OK/ {nOKcalib++;}
/\/calib.log BAD/ {nBADcalib++}
- END {print ""nOKrec" "nBADrec" "nOKstderr" "nBADstderr" "nOKcalib" "nBADcalib;}' meta/cpass0.job*.run${runNumber}.done 2>/dev/null
+ END {print ""nOKrec" "nBADrec" "nOKstderr" "nBADstderr" "nOKcalib" "nBADcalib;}' ${commonOutputPath}/meta/cpass0.job*.run${runNumber}.done 2>/dev/null
) )
fi
- if $(/bin/ls meta/cpass1.job*.run${runNumber}.done &>/dev/null); then
+ if $(/bin/ls ${commonOutputPath}/meta/cpass1.job*.run${runNumber}.done &>/dev/null); then
statusCPass1=( $(
awk 'BEGIN {nOKrec=0;nBADrec=0;nOKcalib=0;nBADcalib=0;nOKstderr=0;nBADstderr=0;nQAbarrelOK=0;nQAbarrelBAD=0;nQAouterOK=0;nQAouterBAD=0;}
/\/rec.log OK/ {nOKrec++;}
/\/qa_barrel.log BAD/ {nQAbarrelBAD++;}
/\/qa_outer.log OK/ {nQAouterOK++;}
/\/qa_outer.log BAD/ {nQAouterBAD++;}
- END {print ""nOKrec" "nBADrec" "nOKstderr" "nBADstderr" "nOKcalib" "nBADcalib" "nQAbarrelOK" "nQAbarrelBAD" "nQAouterOK" "nQAouterBAD;}' meta/cpass1.job*.run${runNumber}.done 2>/dev/null
+ END {print ""nOKrec" "nBADrec" "nOKstderr" "nBADstderr" "nOKcalib" "nBADcalib" "nQAbarrelOK" "nQAbarrelBAD" "nQAouterOK" "nQAouterBAD;}' ${commonOutputPath}/meta/cpass1.job*.run${runNumber}.done 2>/dev/null
) )
fi
goPrintValues trendingfile trending.list ${commonOutputPath}/meta/merge.cpass1.run*.done &>/dev/null
rm -f filtering.list
goPrintValues filteredTree filtering.list ${commonOutputPath}/meta/merge.cpass1.run*.done &>/dev/null
- #/bin/ls ${commonOutputPath}/*/cpass0/dcs* > cpass0.dcsTree.list
rm -f cpass0.dcsTree.list
goPrintValues dcsTree cpass0.dcsTree.list ${commonOutputPath}/meta/merge.cpass0.run*.done &>/dev/null
- #/bin/ls ${commonOutputPath}/*/cpass1/dcs* > cpass1.dcsTree.list
rm -f cpass1.dcsTree.list
goPrintValues dcsTree cpass1.dcsTree.list ${commonOutputPath}/meta/merge.cpass1.run*.done &>/dev/null
goMakeSummaryTree ${commonOutputPath} 0
goMakeSummaryTree ${commonOutputPath} 1
- goCreateQAplots "qa.list" "${productionID}" "QAplots" "${configFile}" "${extraOpts[@]}" filteringList="filtering.list" &>createQAplots.log
+ goCreateQAplots "${PWD}/qa.list" "${productionID}" "QAplots" "${configFile}" "${extraOpts[@]}" filteringList="${PWD}/filtering.list" &>createQAplots.log
#make a merged summary tree out of the QA trending, dcs trees and log summary trees
goMakeMergedSummaryTree
#if set, email the summary
- [[ -n ${MAILTO} ]] && cat ${log} | mail -s "benchmark ${productionID} done" ${MAILTO}
+ [[ -n ${MAILTO} ]] && cat ${logTmp} | mail -s "benchmark ${productionID} done" ${MAILTO}
+
+ # Copy log to destination (delete all on failure to signal error)
+ cp "$logTmp" "$logDest" || rm -f "$logTmp" "$logDest"
+ cp -r QAplots ${commonOutputPath}
+ cp *.list ${commonOutputPath}
+ cp *.root ${commonOutputPath}
+ cp *.log ${commonOutputPath}
return 0
-}
+)
goMakeSummaryTree()
-{
+(
if [[ $# -lt 1 ]] ; then
return
fi
done
return 0
-}
+)
parseConfig()
{
shift
args=("$@")
+
#some defaults
#autoOCDB=0
defaultOCDB="raw://"
#makeflowOptions="-T wq -N alice -d all -C ali-copilot.cern.ch:9097"
#makeflowOptions="-T wq -N alice -C ali-copilot.cern.ch:9097"
makeflowOptions=""
- batchCommand="/usr/bin/qsub"
- batchFlags="-b y -cwd -l h_rt=24:0:0,h_rss=4G "
+ #batchCommand="/usr/bin/qsub"
+ batchFlags=""
baseOutputDirectory="$PWD/output"
#alirootEnv="/cvmfs/alice.cern.ch/bin/alienv setenv AliRoot/v5-04-34-AN -c"
#alirootEnv="/home/mkrzewic/alisoft/balice_master.sh"
#dontRedirectStdOutToLog=1
logToFinalDestination=1
ALIROOT_FORCE_COREDUMP=1
+ pretendDelay=0
#first, source the config file
if [ -f ${configFile} ]; then
source ${configFile}
else
- echo "config file ${configFile} not found!, skipping..."
+ echo "config file ${configFile} not found!"
+ return 1
fi
- #then, parse the options as theya override the optionf from file
- for ((i=0;i<${#args[@]};i++)) ;do
- local var="${args[i]%%=*}"
- local value="${args[i]#*=}"
- echo exporting ${var}="${value}"
+ unset encodedSpaces
+ for opt in "${args[@]}"; do
+ [[ "${opt}" =~ encodedSpaces=.* ]] && encodedSpaces=1 && echo "encodedSpaces!" && break
+ done
+
+ #then, parse the options as they override the options from file
+ for opt in "${args[@]}"; do
+ [[ -z ${opt} ]] && continue
+ [[ -n ${encodedSpaces} ]] && opt="$(decSpaces ${opt})"
+ [[ "${opt}" =~ ^[[:space:]]*$ ]] && continue
+ if [[ ! "${opt}" =~ .*=.* ]]; then
+ echo "badly formatted option \"${opt}\" should be: option=value, stopping..."
+ return 1
+ fi
+ local var="${opt%%=*}"
+ local value="${opt#*=}"
+ echo "${var}=${value}"
export ${var}="${value}"
- shift
done
#do some checking
aliroot()
{
- args="$@"
+ args=("$@")
if [[ -n ${useProfilingCommand} ]]; then
- valgrindLogFile="cpu.txt"
- [[ "${args}" =~ rec ]] && valgrindLogFile="cpu_rec.txt"
- [[ "${args}}" =~ Calib ]] && valgrindLogFile="cpu_calib.txt"
- [[ -n ${useProfilingCommand} ]] && useProfilingCommand="${useProfilingCommand} --log-file=${valgrindLogFile}"
- echo running ${useProfilingCommand} aliroot ${args}
- ${useProfilingCommand} aliroot ${args}
+ profilerLogFile="cpu.txt"
+ [[ "${args}" =~ rec ]] && profilerLogFile="cpu_rec.txt"
+ [[ "${args}}" =~ Calib ]] && profilerLogFile="cpu_calib.txt"
+ echo running "${useProfilingCommand} aliroot ${args} &> ${profilerLogFile}"
+ ${useProfilingCommand} aliroot "${args[@]}" &> ${profilerLogFile}
else
#to prevent an infinite recursion use "command aliroot" to disable
#aliases and functions
- echo running command aliroot ${args}
- command aliroot "$@"
+ echo running command aliroot "${args[@]}"
+ command aliroot "${args[@]}"
fi
return 0
}
return 0
}
+#these functions encode strings to and from a space-less form
+#use when spaces are not well handled (e.g. in arguments to
+#commands in makeflow files, etc.
+encSpaces()(echo "${1// /@@@@}")
+decSpaces()(echo "${1//@@@@/ }")
+
main "$@"
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff