[u/mrichter/AliRoot.git] / PWGPP / CalibMacros / CPass0 / mergeMakeOCDB.byComponent.sh

#!/bin/bash

# Script to merge objects coming out of the calibration train and export of the OCDB:
# Arguments for local use:
#    1 - directory on which to look for the files to be merged 
#    2 - runNumber
#    3 - OCDB output path
#    optional:
#    4 - input default OCDB, default="raw://"
#    5 - option: "alien_cp" will use alien_cp to copy files from alien
#                "tfilecp" will copy the files first using TFile::Cp()
#                "nocopy" will access files over the network directly TFile::Open()
#                default is tfilecp, use 0
#    6 - number of files to download per iteration, default 20
#
# example local use (files will be downloaded from alien)
#./mergeMakeOCDB.byComponent.sh /alice/data/2012/LHC12g/000188362/cpass0/ 188362 local://./OCDB local:///cvmfs/alice.gsi.de/alice/data/2011/OCDB/ 0 30
#
# on ALIEN just do:
# $1 = directory where to perform the find 
# $2 = runNumber
# $3 = OCDB path

if [[ $# -eq 0 ]]; then
  echo arguments:
  echo  "  1 - directory on which to look for the files to be merged or local file list"
  echo  "  2 - runNumber"
  echo  "  3 - OCDB output path"
  echo  "  optional:"
  echo  "  4 - input default OCDB, default=\"raw://\""
  echo  "  5 - option: \"alien_cp\" will use alien_cp to copy files from alien"
  echo  "              \"tfilecp\" will copy the files first using TFile::Cp()"
  echo  "              \"nocopy\" will access files over the network directly TFile::Open()"
  echo  "              default is tfilecp (use 0)"
  echo  "  6 - number of files to download/merge per iteration, default 20"
  echo
  echo "example:"
  echo  " ./mergeMakeOCDB.byComponent.sh /alice/data/2012/LHC12g/000188362/cpass1/ 188362 local://./OCDB raw:// alien_cp 10"
  echo

  exit 0
fi

# init
path=$1
run=$(echo "$2" | sed 's/^0*//')
ocdb=$3
defaultOCDB="raw://"
[[ -n $4 ]] && defaultOCDB=$4
fileAccessMethod=$5
[[ "$fileAccessMethod" != "alien_cp" && "$fileAccessMethod" != "tfilecp" && "$fileAccessMethod" != "nocopy" ]] && fileAccessMethod="tfilecp"
numberOfFilesInAbunch=50
[[ $6 =~ ^[0-9]+$ ]] && numberOfFilesInAbunch=$6

isLocal=0
[[ -f $path ]] && isLocal=1
cleanup=1
[[ $isLocal -eq 1 ]] && cleanup=0
[[ $isLocal -eq 1 ]] && fileAccessMethod="nocopy"

# setup components to be merged
components="TOF MeanVertex T0 SDD TRD TPCCalib TPCAlign TPCCluster"

#################################################################
echo
echo $0" $*"
echo
echo "***********************" | tee -a merge.log
echo mergeMakeOCDB.byComponent.sh started | tee -a merge.log
echo path = $path | tee -a merge.log
echo run  = $run | tee -a merge.log
echo ocdb = $ocdb | tee -a merge.log
echo defaultOCDB=$defaultOCDB | tee -a merge.log
echo isLocal = $isLocal | tee -a merge.log
echo cleanup = $cleanup | tee -a merge.log
echo fileAccessMethod=$fileAccessMethod | tee -a merge.log
echo numberOfFilesInAbunch = $numberOfFilesInAbunch | tee -a merge.log
echo "***********************" | tee -a merge.log

alienFileList="alien.list"
localFileList="local.list"
partialLocalFileListPrefix=${localFileList}_
partialAlienFileListPrefix=${alienFileList}_
runningMergeByComponentLockFile="runningMergeByComponent.lock"

mergeByComponent()
{
  # process by component
  # first argument is the file list to process

  #lock
  touch $runningMergeByComponentLockFile

  # run inside a dedicated running directory
  # whic means copy the file list to process and prefic each line with ../
  # since the file names have no absolute paths!
  runningDirectory="${runningMergeByComponentLockFile}.${1}.dir"
  fileList="$1"
  cleanup=$2
  
  #sanity checks
  [[ ! -f $fileList ]] && echo "$fileList does not exist" && return
  mkdir -p $runningDirectory
  [[ ! -d $runningDirectory ]] && echo "cannot create the running directory $runningDirectory" && return 1
  
  #add the results of previous iteration to the BEGINNING of the list of files to be merged
  if [[ -f CalibObjects.root ]]; then
    echo "../CalibObjects.root" > $runningDirectory/$fileList
  fi

  #move the to be merged files to the running directory and make a list of available files
  #handle the case of archives (x.zip#y.root) as well
  nFiles=0
  while read entry; do
    if [[ $entry =~ ^.*\.root$ ]]; then
      file=${entry%#*}
      fileContent=${entry##*#}
      [[ "${fileContent}" == "${file}" ]] && fileContent=""
      [[ -n ${fileContent} ]] && fileContent="#${fileContent}"
      if [[ -f ${file} ]]; then
        ((nFiles++))
        if [[ -f "./${file}" ]]; then
          echo "../${file}${fileContent}" >> "${runningDirectory}/$fileList"
        else
          echo "${file}${fileContent}" >> "${runningDirectory}/$fileList"
        fi
      fi
    fi
  done < $fileList
  [[ $nFiles -lt 1 ]] && echo "no new files in $fileList" && rm -rf $runningDirectory && return

  #copy the macro to the running directory
  [[ -f mergeByComponent.C ]] && cp mergeByComponent.C $runningDirectory

  cd $runningDirectory

  echo "processing following files from $fileList:"
  cat $fileList

  for det in $components; do
    # merge
    echo "***********************" 
    echo merging $det data
    echo "***********************"
    echo aliroot -b -q "mergeByComponent.C(\"$det\", \"$fileList\")"
    aliroot -b -q "mergeByComponent.C(\"$det\", \"$fileList\")" 2>&1 | tee -a merge_${det}.log
    if validateMerging ${det}; then
      echo "### merge OK: mv CalibObjects.root CalibObjects_$det.root"
      mv CalibObjects.root CalibObjects_$det.root
    else 
    echo "### merging not validated"
      rm -f CalibObjects.root
    fi
    mv syswatch.log syswatch_merge_$det.log
  done
  
  # global merge
  echo "***********************"
  echo merging ALL data
  echo "***********************"
  partialCalibObjectsList="objects.list.${1}"
  ls -1 CalibObjects_*.root > $partialCalibObjectsList
  echo aliroot -b -q "mergeByComponent.C(\"ALL\", \"$partialCalibObjectsList\")"
  aliroot -b -q "mergeByComponent.C(\"ALL\", \"$partialCalibObjectsList\")" 2>&1 | tee -a merge_ALL.log
  if validateMerging "ALL"; then
    #move the new CalibObjects to parent directory
    echo mv -f CalibObjects.root ..
    mv -f CalibObjects.root ..
  else 
    echo "### merging not validated"
    rm -f CalibObjects.root
  fi

  mv syswatch.log syswatch_ALL.log
  rm $partialCalibObjectsList
  
  #move stuff back to the parent dir and clean up
  #merge the syswatch logs
  for x in syswatch*log; do
    [[ ! -f $x ]] && continue
    if [[ -f ../$x ]]
    then 
      echo "sed '1d' $x  >> ../$x"
      sed '1d' $x >> ../$x
      rm -f $x
    else 
      echo mv -f $x ..
      mv -f $x ..
    fi
  done

  #merge the other logs
  for x in *.log; do
    [[ ! -f $x ]] && continue
    if [[ -f ../$x ]]
    then
      echo "cat $x >> ../$x"
      cat $x >> ../$x
    else
      echo "mv -f $x .."
      mv -f $x ..
    fi
  done
  
  #final cleanup.
  #go to parent dir first to use the original fileList
  #without ../CalibObjects.root
  cd ..
  if [[ $cleanup -eq 1 ]]; then
    echo "cleaning up merged files..."
    while read file; do
      echo rm -rf $file
      rm -rf $file
    done<$fileList
  fi
  rm -rf $runningDirectory

  #unlock
  rm -f $runningMergeByComponentLockFile
  [[ ! -f CalibObjects.root ]] && echo "WARNING: CalibObjects.root not available!"
  echo "***mergeByComponent() DONE"
  echo
  return 0
}

waitIfLocked()
{
  while [ 1 ]; do
    [[ ! -f $1 ]] && break
    sleep 1
  done
  return 0
}

validateMerging()
{
  det=$1
  retCode=0
  [[ ! -f CalibObjects.root ]] && ((retCode++)) && echo "### no CalibObjects.root..."
  [[ ! -f ${det}_merge_done ]] && ((retCode++)) && echo "### no ${det}_merge_done, job finished abnormally..."
  error=$(grep -e "was a crash" *.log)
  [[ -n $error ]] && ((retCode++)) && echo "### error: $error"
  
  return $retCode
}

copyScripts()
{
  [[ ! -f mergeByComponent.C ]] && \
    cp -f $ALICE_ROOT/PWGPP/CalibMacros/CPass0/mergeByComponent.C $PWD && \
    echo "taking the default scripts from $ALICE_ROOT"
  [[ ! -f makeOCDB.C ]] && \
    cp -f $ALICE_ROOT/PWGPP/CalibMacros/CPass0/makeOCDB.C $PWD && \
    echo "taking the default scripts from $ALICE_ROOT"
}

#first, make sure we have the scripts
copyScripts | tee -a copy.log
ls
#with alien files copy them first to local
echo "***********************" 2>&1 | tee -a copy.log
echo copying files for run $run 2>&1 | tee -a copy.log
echo from $path 2>&1 | tee -a copy.log
echo "***********************" 2>&1 | tee -a copy.log
if [[ $isLocal -eq 0 ]]; then
  if [[ "$fileAccessMethod" == "alien_cp" ]]; then
    echo "alien_find $path AliESDfriends_v1.root | egrep ^/ > $alienFileList" 2>&1 | tee -a copy.log
    alien_find $path "AliESDfriends_v1.root" | egrep "^/" >  $alienFileList
    echo "alien_find done"
    echo
  else 
    echo aliroot -b -q "mergeByComponent.C(\"MAKEALIENLIST\",\"$alienFileList\", \"$path\", \"AliESDfriends_v1.root\")" 2>&1 | tee -a copy.log
    aliroot -b -q "mergeByComponent.C(\"MAKEALIENLIST\",\"$alienFileList\", \"$path\", \"AliESDfriends_v1.root\")" 2>&1 | tee -a copy.log
    echo "MAKEALIENLIST done"
    echo
  fi
else
  cp $path $alienFileList
fi
echo split --numeric-suffixes --suffix-length=6 --lines=$numberOfFilesInAbunch ${alienFileList} ${partialAlienFileListPrefix} | tee -a copy.log
split --numeric-suffixes --suffix-length=6 --lines=$numberOfFilesInAbunch ${alienFileList} ${partialAlienFileListPrefix}
rm -f $runningMergeByComponentLockFile
for partialAlienFileList in ${partialAlienFileListPrefix}*
do
  partialAlienFileListPostfix=${partialAlienFileList#$partialAlienFileListPrefix}
  partialLocalFileList=${partialLocalFileListPrefix}${partialAlienFileListPostfix}

  #copy the files if appropriate and make a list of files to use
  rm -f $partialLocalFileList
  if [[ "$fileAccessMethod" == "alien_cp" ]]; then
    while read x; do
      [[ $x != /* ]] && continue
      localName=${x//"/"/_}
      echo "alien_cp "alien://$x" $localName" 2>&1 | tee -a copy.log
      alien_cp "alien://$x" $localName
      echo $localName>>$partialLocalFileList
    done<$partialAlienFileList
  elif [[ "$fileAccessMethod" == "tfilecp" ]]; then
    echo aliroot -b -q "mergeByComponent.C(\"COPY\",\"$partialAlienFileList\",\"noPath\",\"noPattern\",10,\"$partialLocalFileList\")" 2>&1 | tee -a copy.log
    aliroot -b -q "mergeByComponent.C(\"COPY\",\"$partialAlienFileList\",\"noPath\",\"noPattern\",10,\"$partialLocalFileList\")" 2>&1 | tee -a copy.log
  elif [[ "$fileAccessMethod" == "nocopy" ]]; then
    while read x; do
      [[ $isLocal -eq 0 ]] && echo "alien://$x" >> $partialLocalFileList
      [[ $isLocal -eq 1 ]] && echo "$x" >> $partialLocalFileList
    done<$partialAlienFileList
    cleanup=0
  fi

  #handle syswatch
  if [[ -f syswatch_copy.log ]]
  then
    sed '1d' syswatch.log >> syswatch_copy.log
    rm -f syswatch.log
  else 
    [[ -f syswatch.log ]] && mv syswatch.log syswatch_copy.log
  fi

  #merge in parallel, use a simple lockfile
  #echo "waitIfLocked $runningMergeByComponentLockFile" | tee -a merge.log
  waitIfLocked $runningMergeByComponentLockFile
  if [[ $isLocal -eq 1 ]]; then
    #locally we don't need to run in parallel since we dont download,
    #besides it causes problems on some filesystems (like lustre) with file sync
    mergeByComponent $partialLocalFileList $cleanup 2>&1 | tee -a merge.log
  else
    mergeByComponent $partialLocalFileList $cleanup 2>&1 | tee -a merge.log &
  fi
done

#cleanup
rm -f ${partialAlienFileListPrefix}*
rm -f ${partialLocalFileListPrefix}*
rm -f $alienFileList

# make OCDB
echo "***********************" 2>&1 | tee -a ocdb.log
echo making $det OCDB 2>&1 | tee -a ocdb.log
echo "***********************" 2>&1 | tee -a ocdb.log
echo aliroot -b -q "makeOCDB.C($run, \"$ocdb\", \"$defaultOCDB\")" 2>&1 | tee -a ocdb.log
aliroot -b -q "makeOCDB.C($run, \"$ocdb\", \"$defaultOCDB\")" 2>&1 | tee -a ocdb.log
mv syswatch.log syswatch_makeOCDB.log

# summary
echo "***********************" 2>&1 | tee -a ocdb.log
echo SUMMARY 2>&1 | tee -a ocdb.log
echo "***********************" 2>&1 | tee -a ocdb.log
ls -altr *CalibObjects.root *done 2>&1 | tee -a ocdb.log
Commit	Line	Data
e9129651	1	#!/bin/bash
27eb9bff	2
d157f353	3	# Script to merge objects coming out of the calibration train and export of the OCDB:
9e160db9	4	# Arguments for local use:
d157f353	5	# 1 - directory on which to look for the files to be merged
9e160db9	6	# 2 - runNumber
d157f353	7	# 3 - OCDB output path
e9129651	8	# optional:
	9	# 4 - input default OCDB, default="raw://"
	10	# 5 - option: "alien_cp" will use alien_cp to copy files from alien
	11	# "tfilecp" will copy the files first using TFile::Cp()
	12	# "nocopy" will access files over the network directly TFile::Open()
	13	# default is tfilecp, use 0
	14	# 6 - number of files to download per iteration, default 20
	15	#
	16	# example local use (files will be downloaded from alien)
	17	#./mergeMakeOCDB.byComponent.sh /alice/data/2012/LHC12g/000188362/cpass0/ 188362 local://./OCDB local:///cvmfs/alice.gsi.de/alice/data/2011/OCDB/ 0 30
	18	#
	19	# on ALIEN just do:
d157f353	20	# $1 = directory where to perform the find
9e160db9	21	# $2 = runNumber
d157f353	22	# $3 = OCDB path
d157f353	23
e9129651	24	if [[ $# -eq 0 ]]; then
	25	echo arguments:
	26	echo " 1 - directory on which to look for the files to be merged or local file list"
	27	echo " 2 - runNumber"
	28	echo " 3 - OCDB output path"
	29	echo " optional:"
	30	echo " 4 - input default OCDB, default=\"raw://\""
	31	echo " 5 - option: \"alien_cp\" will use alien_cp to copy files from alien"
	32	echo " \"tfilecp\" will copy the files first using TFile::Cp()"
	33	echo " \"nocopy\" will access files over the network directly TFile::Open()"
	34	echo " default is tfilecp (use 0)"
	35	echo " 6 - number of files to download/merge per iteration, default 20"
	36	echo
	37	echo "example:"
	38	echo " ./mergeMakeOCDB.byComponent.sh /alice/data/2012/LHC12g/000188362/cpass1/ 188362 local://./OCDB raw:// alien_cp 10"
	39	echo
	40
	41	exit 0
	42	fi
d157f353	43
27eb9bff	44	# init
27eb9bff	45	path=$1
d1c49c14	46	run=$(echo "$2" \| sed 's/^0*//')
27eb9bff	47	ocdb=$3
e9129651	48	defaultOCDB="raw://"
	49	[[ -n $4 ]] && defaultOCDB=$4
	50	fileAccessMethod=$5
	51	[[ "$fileAccessMethod" != "alien_cp" && "$fileAccessMethod" != "tfilecp" && "$fileAccessMethod" != "nocopy" ]] && fileAccessMethod="tfilecp"
	52	numberOfFilesInAbunch=50
	53	[[ $6 =~ ^[0-9]+$ ]] && numberOfFilesInAbunch=$6
	54
d157f353	55	isLocal=0
22019e94	56	[[ -f $path ]] && isLocal=1
e9129651	57	cleanup=1
	58	[[ $isLocal -eq 1 ]] && cleanup=0
	59	[[ $isLocal -eq 1 ]] && fileAccessMethod="nocopy"
d157f353	60
e9129651	61	# setup components to be merged
e9129651	62	components="TOF MeanVertex T0 SDD TRD TPCCalib TPCAlign TPCCluster"
27eb9bff	63
e9129651	64	#################################################################
	65	echo
	66	echo $0" $*"
	67	echo
	68	echo "***********************" \| tee -a merge.log
	69	echo mergeMakeOCDB.byComponent.sh started \| tee -a merge.log
	70	echo path = $path \| tee -a merge.log
	71	echo run = $run \| tee -a merge.log
	72	echo ocdb = $ocdb \| tee -a merge.log
	73	echo defaultOCDB=$defaultOCDB \| tee -a merge.log
	74	echo isLocal = $isLocal \| tee -a merge.log
	75	echo cleanup = $cleanup \| tee -a merge.log
	76	echo fileAccessMethod=$fileAccessMethod \| tee -a merge.log
	77	echo numberOfFilesInAbunch = $numberOfFilesInAbunch \| tee -a merge.log
	78	echo "***********************" \| tee -a merge.log
27eb9bff	79
9e160db9	80	alienFileList="alien.list"
	81	localFileList="local.list"
	82	partialLocalFileListPrefix=${localFileList}_
	83	partialAlienFileListPrefix=${alienFileList}_
	84	runningMergeByComponentLockFile="runningMergeByComponent.lock"
	85
	86	mergeByComponent()
	87	{
	88	# process by component
	89	# first argument is the file list to process
9e160db9	90
	91	#lock
	92	touch $runningMergeByComponentLockFile
27eb9bff	93
40f73007	94	# run inside a dedicated running directory
	95	# whic means copy the file list to process and prefic each line with ../
	96	# since the file names have no absolute paths!
	97	runningDirectory="${runningMergeByComponentLockFile}.${1}.dir"
e9129651	98	fileList="$1"
	99	cleanup=$2
	100
	101	#sanity checks
	102	[[ ! -f $fileList ]] && echo "$fileList does not exist" && return
40f73007	103	mkdir -p $runningDirectory
e9129651	104	[[ ! -d $runningDirectory ]] && echo "cannot create the running directory $runningDirectory" && return 1
	105
	106	#add the results of previous iteration to the BEGINNING of the list of files to be merged
	107	if [[ -f CalibObjects.root ]]; then
	108	echo "../CalibObjects.root" > $runningDirectory/$fileList
	109	fi
40f73007	110
e9129651	111	#move the to be merged files to the running directory and make a list of available files
	112	#handle the case of archives (x.zip#y.root) as well
	113	nFiles=0
	114	while read entry; do
	115	if [[ $entry =~ ^.*\.root$ ]]; then
	116	file=${entry%#*}
	117	fileContent=${entry##*#}
	118	[[ "${fileContent}" == "${file}" ]] && fileContent=""
	119	[[ -n ${fileContent} ]] && fileContent="#${fileContent}"
	120	if [[ -f ${file} ]]; then
	121	((nFiles++))
	122	if [[ -f "./${file}" ]]; then
	123	echo "../${file}${fileContent}" >> "${runningDirectory}/$fileList"
	124	else
	125	echo "${file}${fileContent}" >> "${runningDirectory}/$fileList"
	126	fi
	127	fi
	128	fi
	129	done < $fileList
	130	[[ $nFiles -lt 1 ]] && echo "no new files in $fileList" && rm -rf $runningDirectory && return
40f73007	131
e9129651	132	#copy the macro to the running directory
	133	[[ -f mergeByComponent.C ]] && cp mergeByComponent.C $runningDirectory
	134
	135	cd $runningDirectory
	136
	137	echo "processing following files from $fileList:"
	138	cat $fileList
27eb9bff	139
9e160db9	140	for det in $components; do
27eb9bff	141	# merge
40f73007	142	echo "***********************"
	143	echo merging $det data
	144	echo "***********************"
	145	echo aliroot -b -q "mergeByComponent.C(\"$det\", \"$fileList\")"
e9129651	146	aliroot -b -q "mergeByComponent.C(\"$det\", \"$fileList\")" 2>&1 \| tee -a merge_${det}.log
	147	if validateMerging ${det}; then
	148	echo "### merge OK: mv CalibObjects.root CalibObjects_$det.root"
	149	mv CalibObjects.root CalibObjects_$det.root
	150	else
	151	echo "### merging not validated"
	152	rm -f CalibObjects.root
	153	fi
9e160db9	154	mv syswatch.log syswatch_merge_$det.log
9e160db9	155	done
9e160db9	156
9e160db9	157	# global merge
40f73007	158	echo "***********************"
	159	echo merging ALL data
	160	echo "***********************"
9e160db9	161	partialCalibObjectsList="objects.list.${1}"
9e160db9	162	ls -1 CalibObjects_*.root > $partialCalibObjectsList
40f73007	163	echo aliroot -b -q "mergeByComponent.C(\"ALL\", \"$partialCalibObjectsList\")"
e9129651	164	aliroot -b -q "mergeByComponent.C(\"ALL\", \"$partialCalibObjectsList\")" 2>&1 \| tee -a merge_ALL.log
	165	if validateMerging "ALL"; then
	166	#move the new CalibObjects to parent directory
	167	echo mv -f CalibObjects.root ..
	168	mv -f CalibObjects.root ..
	169	else
	170	echo "### merging not validated"
	171	rm -f CalibObjects.root
	172	fi
	173
9e160db9	174	mv syswatch.log syswatch_ALL.log
40f73007	175	rm $partialCalibObjectsList
9e160db9	176
40f73007	177	#move stuff back to the parent dir and clean up
	178	#merge the syswatch logs
	179	for x in syswatch*log; do
e9129651	180	[[ ! -f $x ]] && continue
e9129651	181	if [[ -f ../$x ]]
40f73007	182	then
e9129651	183	echo "sed '1d' $x >> ../$x"
e9129651	184	sed '1d' $x >> ../$x
40f73007	185	rm -f $x
40f73007	186	else
e9129651	187	echo mv -f $x ..
e9129651	188	mv -f $x ..
40f73007	189	fi
40f73007	190	done
e9129651	191
40f73007	192	#merge the other logs
40f73007	193	for x in *.log; do
e9129651	194	[[ ! -f $x ]] && continue
e9129651	195	if [[ -f ../$x ]]
40f73007	196	then
e9129651	197	echo "cat $x >> ../$x"
e9129651	198	cat $x >> ../$x
40f73007	199	else
e9129651	200	echo "mv -f $x .."
e9129651	201	mv -f $x ..
40f73007	202	fi
40f73007	203	done
e9129651	204
	205	#final cleanup.
	206	#go to parent dir first to use the original fileList
	207	#without ../CalibObjects.root
	208	cd ..
	209	if [[ $cleanup -eq 1 ]]; then
	210	echo "cleaning up merged files..."
	211	while read file; do
	212	echo rm -rf $file
	213	rm -rf $file
	214	done<$fileList
	215	fi
40f73007	216	rm -rf $runningDirectory
40f73007	217
9e160db9	218	#unlock
9e160db9	219	rm -f $runningMergeByComponentLockFile
e9129651	220	[[ ! -f CalibObjects.root ]] && echo "WARNING: CalibObjects.root not available!"
40f73007	221	echo "***mergeByComponent() DONE"
e9129651	222	echo
e9129651	223	return 0
9e160db9	224	}
d157f353	225
9e160db9	226	waitIfLocked()
	227	{
	228	while [ 1 ]; do
	229	[[ ! -f $1 ]] && break
	230	sleep 1
	231	done
e9129651	232	return 0
	233	}
	234
	235	validateMerging()
	236	{
	237	det=$1
	238	retCode=0
	239	[[ ! -f CalibObjects.root ]] && ((retCode++)) && echo "### no CalibObjects.root..."
	240	[[ ! -f ${det}_merge_done ]] && ((retCode++)) && echo "### no ${det}_merge_done, job finished abnormally..."
	241	error=$(grep -e "was a crash" *.log)
	242	[[ -n $error ]] && ((retCode++)) && echo "### error: $error"
	243
	244	return $retCode
9e160db9	245	}
d157f353	246
40f73007	247	copyScripts()
40f73007	248	{
e9129651	249	[[ ! -f mergeByComponent.C ]] && \
	250	cp -f $ALICE_ROOT/PWGPP/CalibMacros/CPass0/mergeByComponent.C $PWD && \
	251	echo "taking the default scripts from $ALICE_ROOT"
	252	[[ ! -f makeOCDB.C ]] && \
	253	cp -f $ALICE_ROOT/PWGPP/CalibMacros/CPass0/makeOCDB.C $PWD && \
	254	echo "taking the default scripts from $ALICE_ROOT"
40f73007	255	}
40f73007	256
e9129651	257	#first, make sure we have the scripts
	258	copyScripts \| tee -a copy.log
	259	ls
	260	#with alien files copy them first to local
	261	echo "***********************" 2>&1 \| tee -a copy.log
	262	echo copying files for run $run 2>&1 \| tee -a copy.log
	263	echo from $path 2>&1 \| tee -a copy.log
	264	echo "***********************" 2>&1 \| tee -a copy.log
	265	if [[ $isLocal -eq 0 ]]; then
	266	if [[ "$fileAccessMethod" == "alien_cp" ]]; then
	267	echo "alien_find $path AliESDfriends_v1.root \| egrep ^/ > $alienFileList" 2>&1 \| tee -a copy.log
	268	alien_find $path "AliESDfriends_v1.root" \| egrep "^/" > $alienFileList
	269	echo "alien_find done"
	270	echo
	271	else
40f73007	272	echo aliroot -b -q "mergeByComponent.C(\"MAKEALIENLIST\",\"$alienFileList\", \"$path\", \"AliESDfriends_v1.root\")" 2>&1 \| tee -a copy.log
40f73007	273	aliroot -b -q "mergeByComponent.C(\"MAKEALIENLIST\",\"$alienFileList\", \"$path\", \"AliESDfriends_v1.root\")" 2>&1 \| tee -a copy.log
e9129651	274	echo "MAKEALIENLIST done"
	275	echo
	276	fi
9e160db9	277	else
e9129651	278	cp $path $alienFileList
	279	fi
	280	echo split --numeric-suffixes --suffix-length=6 --lines=$numberOfFilesInAbunch ${alienFileList} ${partialAlienFileListPrefix} \| tee -a copy.log
	281	split --numeric-suffixes --suffix-length=6 --lines=$numberOfFilesInAbunch ${alienFileList} ${partialAlienFileListPrefix}
	282	rm -f $runningMergeByComponentLockFile
	283	for partialAlienFileList in ${partialAlienFileListPrefix}*
	284	do
	285	partialAlienFileListPostfix=${partialAlienFileList#$partialAlienFileListPrefix}
	286	partialLocalFileList=${partialLocalFileListPrefix}${partialAlienFileListPostfix}
	287
	288	#copy the files if appropriate and make a list of files to use
	289	rm -f $partialLocalFileList
	290	if [[ "$fileAccessMethod" == "alien_cp" ]]; then
	291	while read x; do
	292	[[ $x != /* ]] && continue
	293	localName=${x//"/"/_}
	294	echo "alien_cp "alien://$x" $localName" 2>&1 \| tee -a copy.log
	295	alien_cp "alien://$x" $localName
	296	echo $localName>>$partialLocalFileList
	297	done<$partialAlienFileList
	298	elif [[ "$fileAccessMethod" == "tfilecp" ]]; then
	299	echo aliroot -b -q "mergeByComponent.C(\"COPY\",\"$partialAlienFileList\",\"noPath\",\"noPattern\",10,\"$partialLocalFileList\")" 2>&1 \| tee -a copy.log
	300	aliroot -b -q "mergeByComponent.C(\"COPY\",\"$partialAlienFileList\",\"noPath\",\"noPattern\",10,\"$partialLocalFileList\")" 2>&1 \| tee -a copy.log
	301	elif [[ "$fileAccessMethod" == "nocopy" ]]; then
	302	while read x; do
	303	[[ $isLocal -eq 0 ]] && echo "alien://$x" >> $partialLocalFileList
	304	[[ $isLocal -eq 1 ]] && echo "$x" >> $partialLocalFileList
	305	done<$partialAlienFileList
	306	cleanup=0
	307	fi
	308
	309	#handle syswatch
	310	if [[ -f syswatch_copy.log ]]
	311	then
	312	sed '1d' syswatch.log >> syswatch_copy.log
	313	rm -f syswatch.log
	314	else
	315	[[ -f syswatch.log ]] && mv syswatch.log syswatch_copy.log
	316	fi
	317
	318	#merge in parallel, use a simple lockfile
	319	#echo "waitIfLocked $runningMergeByComponentLockFile" \| tee -a merge.log
	320	waitIfLocked $runningMergeByComponentLockFile
	321	if [[ $isLocal -eq 1 ]]; then
	322	#locally we don't need to run in parallel since we dont download,
	323	#besides it causes problems on some filesystems (like lustre) with file sync
	324	mergeByComponent $partialLocalFileList $cleanup 2>&1 \| tee -a merge.log
	325	else
	326	mergeByComponent $partialLocalFileList $cleanup 2>&1 \| tee -a merge.log &
	327	fi
	328	done
9e160db9	329
9e160db9	330	#cleanup
9e160db9	331	rm -f ${partialAlienFileListPrefix}*
9e160db9	332	rm -f ${partialLocalFileListPrefix}*
e9129651	333	rm -f $alienFileList
d157f353	334
	335	# make OCDB
	336	echo "***********************" 2>&1 \| tee -a ocdb.log
	337	echo making $det OCDB 2>&1 \| tee -a ocdb.log
	338	echo "***********************" 2>&1 \| tee -a ocdb.log
40f73007	339	echo aliroot -b -q "makeOCDB.C($run, \"$ocdb\", \"$defaultOCDB\")" 2>&1 \| tee -a ocdb.log
40f73007	340	aliroot -b -q "makeOCDB.C($run, \"$ocdb\", \"$defaultOCDB\")" 2>&1 \| tee -a ocdb.log
9e160db9	341	mv syswatch.log syswatch_makeOCDB.log
27eb9bff	342
	343	# summary
	344	echo "***********************" 2>&1 \| tee -a ocdb.log
	345	echo SUMMARY 2>&1 \| tee -a ocdb.log
	346	echo "***********************" 2>&1 \| tee -a ocdb.log
9e160db9	347	ls -altr CalibObjects.root done 2>&1 \| tee -a ocdb.log