#!/bin/bash

#TalysWorkDir="/home/axiotis/Data/Talys_script/test"
NumberOfThreads=`nproc`
declare -i NumberOfWorkingThreads=NumberOfThreads-2
CurWorkDir=`pwd`

qstat >/dev/null 2>&1
if [ "$?" == "0" ] ; then
   pc_type="cluster"
   find_dir="${HOME}/.talys"
else
   pc_type="pc"
   [ -d "${HOME}/Software/talys" ] && find_dir="${HOME}/Software/talys" || find_dir="/usr/share"
fi

####################################################
#NumberOfWorkingThreads=55
#CPUOccupation=80

function GoodToGo {
   RuningTalysPids=( $(jobs -p 2>/dev/null) )
#   if [[ "${#RuningTalysPids[@]}" -ge "${NumberOfWorkingThreads}" ]] ; then
#      echo "wait"
#   else
#      echo "go"
#   fi

#   if (( $(echo "${kkener}>0" | bc -l) ))
#   if (( $(echo "$(top -bn1 | grep Cpu | sed 's|[ \t]\+| |' | cut -f2 -d' ')>${CPUOccupation}" | bc -l) )) || [[ "${#RuningTalysPids[@]}" -ge "${NumberOfWorkingThreads}" ]]
   if (( $(echo "$(top -bn1 | grep Cpu | sed 's|[ \t]\+| |' | cut -f2 -d' ')>${CPUOccupation}" | bc -l) ))
   then
      echo "wait"
   else
      echo "go"
   fi

}

declare -a RuningTalysPids
function RunTalys {
   if [ "${pc_type}" == "cluster" ] ; then
      echo "talys-${talys_version} < input > output ; rm ${LogDir}/${qsubLogFileName}.o*" | qsub -cwd -V -j y -o ${LogDir} -N ${qsubLogFileName}
      CalculateRatios
   else
      while [[ "`ps -au ${USER}  | grep talys | wc -l`" -ge "${NumberOfWorkingThreads}" ]] ; do sleep 1 ; done
#      RuningTalysPids=( $(jobs -p 2>/dev/null) )
#      if [[ "${#RuningTalysPids[@]}" -ge "${NumberOfWorkingThreads}" ]] ; then
#         wait -n ${RuningTalysPids[*]}
#      fi
#            echo "Outside222 $(GoodToGo) $(jobs -p 2>/dev/null)"
#sleep "$(( ${RANDOM} % 2 + 1 ))"
      (
#            echo "Outside $(GoodToGo) $(jobs -p 2>/dev/null)"
#         GTG="wait"
#         echo "outside ${GTG}"
#         while [[ "$(GoodToGo)" == "wait" ]] ; do
#            sleep "$(( ${RANDOM} % 2 + 1 ))"
#            GTG=$(GoodToGo)
#         echo "inside $(GoodToGo)"
#         done
        echo "Running talys in folder ${TalysCalcDir}" >> ${LogFileName}
#        top -bn1 | grep Cpu | sed 's|[ \t]\+| |' | cut -f2 -d' '
         talys-${talys_version} < input > output
         echo "Finished running talys in folder ${TalysCalcDir}" >> ${LogFileName}
         CalculateRatios
      ) &
   fi
}

function RunCalculateChi {
   if [ "${pc_type}" == "cluster" ] ; then
      echo "chi_calc ${csfile} ${TalysWorkDir}/data/${mass}${element}/${expfile} ${mtar} ${beam} >> ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/chi2/${reaction}-${expfile} ; rm -f ${LogDir}/chi2-${expfile}*" | qsub -cwd -V -j y -o ${LogDir} -N chi2-${expfile}
   else
      chi_calc ${csfile} ${TalysWorkDir}/data/${mass}${element}/${expfile} ${mtar} ${beam} >> ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/chi2/${reaction}-${expfile}
   fi
}

function RunCalculateRatios {
   if [ "${pc_type}" == "cluster" ] ; then
      echo "ratio "${enum}" "${denom}" >> ${RatioCalcDir}/ratioOut ; rm -f ${LogDir}/ratio-${qsubLogFileName}.o*" | qsub -cwd -V -j y -o ${LogDir} -hold_jid ${qsubLogFileName} -N ratio-${qsubLogFileName}
   else
      echo "Calculating ratios for folder ${TalysCalcDir}" >> ${LogFileName}
      ratio "${enum}" "${denom}" >> ${RatioCalcDir}/ratioOut
      echo "Finished calculating ratios for folder ${TalysCalcDir}" >> ${LogFileName}
   fi
}

function RunCalculateRanges {
   rangeFolder=$1
   rangeFile=$2
   initialFiles=$3
   while read line ; do
      ener=$(echo ${line} | cut -f1 -d' ')
      min=$(echo ${line} | cut -f2 -d' ')
      max=$(echo ${line} | cut -f3 -d' ')
      if [[ "${min}" == "${max}" ]] ; then continue ; fi
      minfiles=$(grep "${ener}.*${min}" ${projectile}-*/${initialFiles} | sed "s/\(.*\)\/\(.*\)/\1/" | tr '\n' ' ' ) #"
      maxfiles=$(grep "${ener}.*${max}" ${projectile}-*/${initialFiles} | sed "s/\(.*\)\/\(.*\)/\1/" | tr '\n' ' ' ) #"
      sed -i "/^\ *${line}/c\ ${line} MINIMUM IN ${minfiles} MAXIMUM IN ${maxfiles}" ${rangeFolder}/${rangeFile}
   done < ${rangeFolder}/${rangeFile} &
   unset initialFiles
   unset rangeFile
   unset rangeFolder
}

function Define_Dir {
   unset rr
   unset rrgs
   if [ "${ast}" == "y" ] ; then rr="-rr" ; fi
   if [ "${astgs}" == "y" ] ; then rrgs="gs" ; fi
   TalysCalcDir=${InputWorkDir}/Talys-${talys_version}/${mass}${element}/${projectile}-${alpha_omp}${jlm_omp}${ld_model}${strength}
   qsubLogFileName="talys-${talys_version}_${mass}${element}_${projectile}-${alpha_omp}${jlm_omp}${ld_model}${strength}"
   if [ ${add_keywords} ] ; then
      for (( i=0; i<${#add_keywords[@]}; i++ )) ; do
         TalysCalcDir=${TalysCalcDir}-$(eval echo "\${${add_keywords[$i]}_line}" | sed "s/<.*>/${keywords_values[$i]}/" | sed "s/\ /_/g" | sed "s/adjust//g" | sed "s/_${projectile}//g")
         qsubLogFileName="${qsubLogFileName}-$(eval echo "\${${add_keywords[$i]}_line}" | sed "s/<.*>/${keywords_values[$i]}/" | sed "s/\ /_/g" | sed "s/adjust//g" | sed "s/_${projectile}//g")"
      done
   fi
   TalysCalcDir=${TalysCalcDir}${rr}${rrgs}
   qsubLogFileName="${qsubLogFileName}${rr}${rrgs}"
}

function MakeInput {
   echo "projectile ${projectile}" > input
   echo "element ${element}" >> input
   echo "mass ${mass}" >> input
   echo "energy energies" >> input
   echo "alphaomp ${alpha_omp}" >> input
   echo "jlmomp ${jlm_omp}" >> input
   echo "ldmodel ${ld_model}" >> input
   echo "strength ${strength}" >> input
   if [ ${cbreak_p} ] ; then echo "Cbreak p ${cbreak_p}" >> input ; fi
   if [ ${cbreak_n} ] ; then echo "Cbreak n ${cbreak_n}" >> input ; fi
   if [ ${transeps} ] ; then echo "transeps ${transeps}" >> input ; fi
   if [ ${popeps} ] ; then echo "popeps ${popeps}" >> input ; fi
   if [ ${xseps} ] ; then echo "xseps ${xseps}" >> input ; fi
   if [ ${isomer} ] ; then echo "isomer ${isomer}" >> input ; fi
   echo "astro ${ast}" >> input
   echo "astrogs ${astgs}" >> input
   if [ ${distflag} ] ; then echo "fileelastic ${distflag}" >> input ; echo "outangle ${distflag}" >> input ; fi
   echo "relativistic n" >> input
   echo "filechannels y" >> input
   echo "channels y" >> input
   if [ ${add_keywords} ] ; then
      for (( i=0; i<${#add_keywords[@]}; i++ )) ; do
         eval echo "\${${add_keywords[$i]}_line}" | sed "s/<.*>/${keywords_values[$i]}/" >> input
      done
   fi
}

function CalculateRanges {
   if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element} ] ; then
      echo "Calculating ranges for nucleus ${mass}${element} run with talys version ${talys_version}" >> ${LogFileName}
      if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/Ranges ] ; then
         rm -rf ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/Ranges/${projectile}-ranges-*
      else
         mkdir -p ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/Ranges
      fi
      rrgsFiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/${projectile}-*rrgs/astrorate.* 2>/dev/null)
      if [ ${rrgsFiles} ] ; then for rrgsFile in ${rrgsFiles[@]} ; do mv rrgsFile rrgsFile_gs ; done ; fi
      unset rrgsFiles
      cd ${InputWorkDir}/Talys-${talys_version}/${mass}${element}
#      rpfiles=$(ls ${projectile}-*/rp*.* ${projectile}-*/astrorate.* 2>/dev/null | sort -k2 -u -t/ | sed "s/.*\/\(.*\)/\1/g") #"
      rpfiles=$(find ./ -iwholename \*${projectile}-\*/rp\*.\* -or -iwholename \*${projectile}-\*/astrorate.\* 2>/dev/null | sed "s/.*\/\(.*\)/\1/g" | sort -u -t/ ) #"
      for rpfile in ${rpfiles[@]} ; do
         sort -g -k2 ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > Ranges/min-ranges-${rpfile}
         sort -g -k2 -r ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > Ranges/max-ranges-${rpfile}
         paste -d' ' Ranges/min-ranges-${rpfile} - <<< $(cut -f3 -d' ' Ranges/max-ranges-${rpfile}) > Ranges/${projectile}-ranges-${rpfile}
         rm -f Ranges/min-ranges-${rpfile} Ranges/max-ranges-${rpfile}
         RunCalculateRanges Ranges "${projectile}-ranges-${rpfile}" "${rpfile}"
      done
      wait
      unset rpfiles
   fi
}

function CalculateRatiosRanges {
   if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element} ] ; then
      echo "Calculating ranges of ratios for nucleus ${mass}${element} run with talys version ${talys_version}" >> ${LogFileName}
      for ratioDir in ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/ratio_* ; do
         if [ -d ${ratioDir}/Ranges ] ; then
            rm -rf ${ratioDir}/Ranges/*
         else
            mkdir -p ${ratioDir}/Ranges
         fi
         cd ${ratioDir}
         rpfiles=$(ls ${projectile}-*/ratioOut 2>/dev/null | sort -k2 -u -t/ | sed "s/.*\/\(.*\)/\1/g") #"
         for rpfile in ${rpfiles[@]} ; do
            sort -g -k2 ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > Ranges/min-ranges-${rpfile}
            sort -g -k2 -r ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > Ranges/max-ranges-${rpfile}
            paste -d' ' Ranges/min-ranges-${rpfile} - <<< $(cut -f3 -d' ' Ranges/max-ranges-${rpfile}) > Ranges/${projectile}-ranges-${rpfile}
            rm -f Ranges/min-ranges-${rpfile} Ranges/max-ranges-${rpfile}
            RunCalculateRanges Ranges "${projectile}-ranges-${rpfile}" "${rpfile}"
         done
         unset rpfiles
      done
      wait
   fi
}

function CalculatePartialRanges {
   if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element} ] ; then
      echo "Calculating partial ranges for nucleus ${mass}${element} run with talys version ${talys_version}" >> ${LogFileName}
      myparRanges=$(echo ${partial_ranges[@]} | sed "s/\ /\_/g")
      if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/PartialRanges_${myparRanges} ] ; then
         rm -rf ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/PartialRanges_${myparRanges}/${projectile}-ranges-*
      else
         mkdir -p ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/PartialRanges_${myparRanges}
      fi
      for parv in ${partial_ranges[@]} ; do
         string=${string}"${projectile}-${parv}/rp*.* ${projectile}-${parv}-rr/astrorate.* "
      done
      cd ${InputWorkDir}/Talys-${talys_version}/${mass}${element}
      rpfiles=$(ls $(echo ${string} | sed "s/\+/\*/g") 2>/dev/null | sort -k2 -u -t/ | sed "s/.*\/\(.*\)/\1/g") #"
      kkrpfiles=$(ls $(echo ${string} | sed "s/\+/\*/g") 2>/dev/null | sort -u )
echo "|`pwd`|${string}|${rpfiles[@]}|${kkrpfiles[@]}|"
      for rpfile in ${rpfiles[@]} ; do
         sort -g -k2 ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > PartialRanges_${myparRanges}/min-ranges-${rpfile}
         sort -g -k2 -r ${projectile}-*/${rpfile} | sed "/#/d" | cut -f1-3 -d' ' | sort -g -u > PartialRanges_${myparRanges}/max-ranges-${rpfile}
         paste -d' ' PartialRanges_${myparRanges}/min-ranges-${rpfile} - <<< $(cut -f3 -d' ' PartialRanges_${myparRanges}/max-ranges-${rpfile}) > PartialRanges_${myparRanges}/${projectile}-ranges-${rpfile}
         rm -f PartialRanges_${myparRanges}/min-ranges-${rpfile} PartialRanges_${myparRanges}/max-ranges-${rpfile}
         RunCalculateRanges "PartialRanges_${myparRanges}" "${projectile}-ranges-${rpfile}" "${rpfile}"
      done
      wait
      unset rpfiles
      unset string
   fi
}

function CalculateChi {
   if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element} ] ; then
      echo "Calculating chi2 for nucleus ${mass}${element} run with talys version ${talys_version}" >> ${LogFileName}
      if [ -d ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/chi2 ] ; then
         rm -rf ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/chi2/*
      else
         mkdir -p ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/chi2
      fi
      expfiles=$(ls ${TalysWorkDir}/data/${mass}${element}/* 2>/dev/null | sed "s/.*\/.*${element}\/\(.*\)/\1/g") #"
      ztar=$(grep ${mass}${element} ${massesDir}/* | sed "s/\ \+/\ /g" | cut -f2 -d' ')
      if [ ! ${ztar} ] ; then ztar=$(grep ${element}.*${mass} ${massesDir}/* | sed "s/\ \+/\ /g" | cut -f2 -d' ') ; fi
      mtar=$(grep ${mass}${element} ${massesDir}/* | sed "s/\ \+/\ /g" | cut -f4 -d' ')
      if [ ! ${mtar} ] ; then mtar=$(grep ${element}.*${mass} ${massesDir}/* | sed "s/\ \+/\ /g" | cut -f4 -d' ') ; fi
      for expfile in ${expfiles[@]} ; do
         reaction=$(echo ${expfile} | sed "s/.*\_\([pan][gnpa]\)\_.*/\1/g") #"
	 expfilestate=$(echo ${expfile} | grep -oh [Lt][o0-9][t0-9])
         case ${reaction} in
            pg ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+1))*$(($mass+1))*.${expfilestate} 2>/dev/null) ; beam=p ;;
            pn ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+1))*$(($mass+0))*.${expfilestate} 2>/dev/null) ; beam=p ;;
            pp ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+0))*$(($mass+0))*.${expfilestate} 2>/dev/null) ; beam=p ;;
            pa ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar-1))*$(($mass-3))*.${expfilestate} 2>/dev/null) ; beam=p ;;
            ag ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+2))*$(($mass+4))*.${expfilestate} 2>/dev/null) ; beam=a ;;
            an ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+2))*$(($mass+3))*.${expfilestate} 2>/dev/null) ; beam=a ;;
            ap ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+1))*$(($mass+3))*.${expfilestate} 2>/dev/null) ; beam=a ;;
            aa ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+0))*$(($mass+0))*.${expfilestate} 2>/dev/null) ; beam=a ;;
            ng ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+0))*$(($mass+1))*.${expfilestate} 2>/dev/null) ; beam=n ;;
            nn ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar+0))*$(($mass+0))*.${expfilestate} 2>/dev/null) ; beam=n ;;
            np ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar-1))*$(($mass+0))*.${expfilestate} 2>/dev/null) ; beam=n ;;
            na ) csfiles=$(ls ${InputWorkDir}/Talys-${talys_version}/${mass}${element}/*/rp*$(($ztar-2))*$(($mass-3))*.${expfilestate} 2>/dev/null) ; beam=n ;;
         esac
         for csfile in ${csfiles[@]} ; do
            RunCalculateChi
         done
         unset csfiles
         unset beam
      done
      unset expfiles
   fi
}

function CalculateRatios {
      if [ ${ratio} ] && [ -d ${TalysCalcDir} ] ; then
         for enum in ${ratio_values[0]} ; do
            if [ ! -e ${enum} ] ; then continue ; fi
            for denom in ${ratio_values[1]} ; do
               if [ ! -e ${denom} ] ; then continue ; fi
               RatioCalcDir=$(echo ${TalysCalcDir} | sed "s/${mass}${element}\/${projectile}/${mass}${element}\/ratio_${enum}_over_${denom}\/${projectile}/")
               if [ -d ${RatioCalcDir} ] ; then rm -rf ${RatioCalcDir} ; fi
               mkdir -p ${RatioCalcDir}
               RunCalculateRatios
            done
         done
      fi
}

function iterate_on_additional_keywords {
   local index="$2"
   if [ "${index}" == "${#add_keywords[@]}" ] ; then
      Define_Dir
      if [ "${talys_flag}" == "y" ] ; then
         if [ ! -d ${TalysCalcDir} ] ; then mkdir -p ${TalysCalcDir} ; fi
         calc_ener=0
         if [ -e ${TalysCalcDir}/total.tot ] ; then calc_ener=$(( $(wc -l ${TalysCalcDir}/total.tot | cut -f1 -d' ') - $(grep "^#" ${TalysCalcDir}/total.tot | wc -l)  )) ; fi
         diff ${InputWorkDir}/energies.$$ ${TalysCalcDir}/energies >/dev/null 2>&1
         if [ "$?" -gt "0" -o "$(wc -l ${InputWorkDir}/energies.$$ | cut -f1 -d' ')" -ne "${calc_ener}" ] ; then
            if [ ${TalysCalcDir} ] && [ -d ${TalysCalcDir} ] ; then
               rm -rf ${TalysCalcDir}/*
               cp ${InputWorkDir}/energies.$$ ${TalysCalcDir}/energies
               cd ${TalysCalcDir}
               MakeInput
               RunTalys
            fi
         fi
      fi
   else
      for dumelement in $(eval echo "\${${add_keywords[${index}]}_values[@]}") ; do
         keywords_values["${index}"]="${dumelement}"
         local it=$((index+1))
         iterate_on_additional_keywords keywords_values[@] "$it"
      done
   fi
}

if [ ! ${TalysWorkDir} ] ; then
   echo "TalysWorkDir is not defined."
   read -p "Give folder for Talys calculations and data " TalysWorkDir
   if [ ! ${TalysWorkDir} ] ; then echo -e "You haven't given any input!!!\nExiting!!!\nRun Again the Program!!!" ; exit 10 ; fi
   echo "Setting ${TalysWorkDir} as TalysWorkDir in bashrc"
   echo "export TalysWorkDir=${TalysWorkDir}" >> ~/.bashrc
fi

if [ ! -d ${TalysWorkDir} ] ; then mkdir -p ${TalysWorkDir} ; fi
if [ ! -d ${TalysWorkDir}/data ] ; then mkdir -p ${TalysWorkDir}/data ; fi
if [ ! -d ${TalysWorkDir}/inputs ] ; then mkdir -p ${TalysWorkDir}/inputs ; fi
if [ ! -d ${TalysWorkDir} ] ; then echo -e "Directory ${TalysWorkDir} doesn't exist and could not be created!!!\nExiting!!!" ; exit 11 ; fi

if [ ! $1 ] ; then
   echo "Making SampleInput in folder ${TalysWorkDir}/inputs"
   cat > ${TalysWorkDir}/inputs/SampleInput <<_EOF_
################################################################################
#####  Configuration section                                               #####
################################################################################
Give Talys Versions (can be more than one, default 1.95) : 1.95
Run Talys y/n : n
Calculate Ranges y/n : n
Calculate Chi y/n : n
Calculate Partial Ranges (optional) : 1n++ +y+4
Calculate ratio (numerators / denominators) (both can be more than one): rp035080.L00 / rp035080.tot
Calculate elastic angular distributions (y/n, ONLY ONE) (optional, default n) : 

################################################################################
#####  Basic configuration of input file                                   #####
################################################################################
Give Nuclei (In either form 78Se Se78) (can be more than one) : Se78
Give projectile (can be more than one of n p d t h a g) : p
Give alphaomps (1-8) (can be more than one, default 1) : 1 2
jlmomp y/n (can be more than one, default n) : y n
Give ldmodels (1-6) (can be more than one, default 1) : 1
Give strengths (1-8) (can be more than one, default 2) : 1
Give energy range and step (in MeV, it has to be <Min> <Max> <step>) : 0 11 .05
Give Cbreak p (optional, ONLY ONE) : 
Give Cbreak n (optional, ONLY ONE) : 
Give transeps (optional, ONLY ONE) : 
Give popeps (optional, ONLY ONE) : 
Give xseps (optional, ONLY ONE) : 
Give isomer (optional, ONLY ONE) : 
astro y/n (can be more than one) (optional, default n) : n
astrogs y/n (can be more than one) (optional, default n) : n

################################################################################
#####  Additional keywords to be added to the input file                   #####
#####  The following three formats are recognized                          #####
#####  1. keyword p1 p2 ...                                                #####
#####  2. keyword p1 <p2_value1 p2_value2 p2_value3 ...> p3 p4 ...         #####
#####  3. keyword p1 p2 <range p3Min p3Max p3step> p4 ...                  #####
#####  where pi is the ith parameter needed for the additional keyword     #####
################################################################################
##### Beginning of additional keywords

##### End of additional keywords
_EOF_
   chmod 444 ${TalysWorkDir}/inputs/SampleInput
else
   if [ ! -s ${CurWorkDir}/$1 ] ; then echo "File $1 does not exist or is empty." ; echo "Please check the filename provided and run again" ; exit 12 ; fi
   InputFileName=`basename "$1"`
   InputWorkDir=${TalysWorkDir}/${InputFileName}
   if [ ! -d ${InputWorkDir} ] ; then mkdir -p ${InputWorkDir} ; fi
   if [ ! -d ${InputWorkDir} ] ; then echo -e "Directory ${InputWorkDir} doesn't exist and could not be created!!!\nExiting!!!" ; exit 13 ; fi
   cp -f ${CurWorkDir}/$1 ${InputWorkDir}/
   LogDir=${InputWorkDir}/logs
   if [ ! -d ${LogDir} ] ; then mkdir -p ${LogDir} ; fi
   if [ ! -d ${LogDir} ] ; then echo -e "Directory ${LogDir} doesn't exist and could not be created!!!\nExiting!!!" ; exit 14 ; fi
   LogFileName=${LogDir}/${InputFileName}.log
   echo -e "\n################################################################################" >> ${LogFileName}
   echo "Running Talys-script for input ${InputFileName}" >> ${LogFileName}

   echo "Reading input file ${InputWorkDir}/${InputFileName}." >> ${LogFileName}
   IFS=' ' read -a talys_versions  <<< $(grep -i "Give.*Talys.*Versions"           ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a talys_flag      <<< $(grep -i "Run.*Talys.*y\/n"                ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a ranges_flag     <<< $(grep -i "Calculate.*Ranges.*y\/n"         ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a chi_flag        <<< $(grep -i "Calculate.*chi.*y\/n"            ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a partial_ranges  <<< $(grep -i "Calculate.*Partial.*Ranges"      ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a ratio           <<< $(grep -i "Calculate.*ratio"                ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS='/' read -a ratio_values    <<< ${ratio[@]}
   IFS=' ' read -a distflag        <<< $(grep -i "Calculate.*elastic.*angula"      ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"

   IFS=' ' read -a nuclei          <<< $(grep -i "Give.*Nuclei"                    ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a projectiles     <<< $(grep -i "Give.*projectile"                ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a alpha_omps      <<< $(grep -i "Give.*alphaomps"                 ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a jlm_omps        <<< $(grep -i "jlmomp.*y\/n"                    ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a ld_models       <<< $(grep -i "Give.*ldmodels"                  ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a strengths       <<< $(grep -i "Give.*strengths"                 ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a energy_range    <<< $(grep -i "Give.*energy.*range.*and.*step"  ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
#   IFS=' ' read -a energy          <<< $(grep -i "Give.*energy.*Limits"            ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
#   IFS=' ' read -a energystp       <<< $(grep -i "Give.*energy.*step"              ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a cbreak_p        <<< $(grep -i "Give.*Cbreak.*p"                 ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a cbreak_n        <<< $(grep -i "Give.*Cbreak.*n"                 ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a transeps        <<< $(grep -i "Give.*transeps"                  ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a popeps          <<< $(grep -i "Give.*popeps"                    ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a xseps           <<< $(grep -i "Give.*xseps"                     ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a isomer          <<< $(grep -i "Give.*isomer"                    ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a astro           <<< $(grep -i "astro[^g].*y\/n"                 ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"
   IFS=' ' read -a astrogs         <<< $(grep -i "astrogs.*y\/n"                   ${InputWorkDir}/${InputFileName} | sed "s/.*:\(.*\)/\1/") #"

   add_keywords=($(sed -n "/#.*Beginning/,/#.*End/p" ${InputWorkDir}/${InputFileName} | sed "/^#/d" | cut -f1 -d' '))

   if [ ! ${talys_versions} ] ; then talys_versions=1.96 ; fi
   if [ ${ratio} ] && [ ! ${#ratio_values[@]} -eq 2 ] ; then 
      echo "warning: The ratio values in the input file are not correct and will be discarded!!!"
      echo "warning: The ratio values in the input file are not correct and will be discarded!!!" >> ${LogFileName}
      unset ratio_values
      unset ratio
   fi
   if [ ! ${distflag} ] ; then distflag=n ; fi

   if [ ! ${nuclei} ] ; then echo "error: Please input at least one nucleus" ; echo "error: Please input at least one nucleus" >> ${LogFileName} ; exit 15 ; fi
   if [ ! ${projectiles} ] ; then echo "error: Please input at least one projectile" ; echo "error: Please input at least one projectile" >> ${LogFileName} ; exit 16 ; fi
   if [ ! ${alpha_omps} ] ; then alpha_omps=1 ; fi
   if [ ! ${jlm_omps} ] ; then jlm_omps=n ; fi
   if [ ! ${ld_models} ] ; then ld_models=1 ; fi
   if [ ! ${strengths} ] ; then strengths=2 ; fi
   if [ "${talys_flag}" == "y" ] ; then
      if [ -e ${InputWorkDir}/energies.$$ ] ; then rm -f ${InputWorkDir}/energies.$$ ; fi
      if [ ${energy_range} ] || [ ${energy} ] ; then
         if [ ${energy_range} ] ; then kkenermin=${energy_range[0]} ; else kkenermin=${energy[0]} ; fi
         if [ ${energy_range} ] ; then kkenermax=${energy_range[1]} ; else kkenermax=${energy[1]} ; fi
         if [ ${energy_range} ] ; then kkenerstp=${energy_range[2]} ; else kkenerstp=${energystp} ; fi
         kkener=${kkenermin}
         while (( $(echo "${kkener}<=${kkenermax}" | bc -l) )) ; do
            if (( $(echo "${kkener}>0" | bc -l) )) ; then echo ${kkener} >> ${InputWorkDir}/energies.$$ ; fi
            kkener=$(echo "${kkener}+${kkenerstp}" | bc -l)
         done
         unset kkenermin
         unset kkenermax
         unset kkenerstp
         unset kkener
      else
         echo "error: You asked to run Talys but you have not given the energy range for the calculation!!!"
         echo "error: You asked to run Talys but you have not given the energy range for the calculation!!!" >> ${LogFileName}
         exit 17
      fi
   fi
   if [ ! ${astro} ] ; then astro=n ; fi
   if [ ! ${astrogs} ] ; then astrogs=n ; fi

   for keyword in ${add_keywords[@]} ; do
      eval "${keyword}_line=\"`grep ${keyword} ${InputWorkDir}/${InputFileName} 2>/dev/null`\""
      if ((eval echo "\${${keyword}_line}") | grep "<" 2>/dev/null) ; then
         declare -a "${keyword}_values"
         eval "${keyword}_values"="($(eval echo "\${${keyword}_line}" | sed "s/.*<\(.*\)>.*/\1/"))"
         if [ "$(eval echo "\${${keyword}_values[0]}")" == "range" ] ; then
            eval kkmin=\${${keyword}_values[1]}
            eval kkmax=\${${keyword}_values[2]}
            eval kkstp=\${${keyword}_values[3]}
            unset ${keyword}_values
            declare -a "${keyword}_values"
            eval "${keyword}_values"+="($(echo ${kkmin}))"
            while (( $(echo "${kkmin}<${kkmax}" | bc -l) )) ; do
               eval "${keyword}_values"+="($(echo "${kkmin}+${kkstp}" | bc -l))"
               kkmin=$(echo "${kkmin}+${kkstp}" | bc -l)
            done
            unset kkmin
            unset kkmax
            unset kkstp
         fi
      else
         eval "${keyword}_values"="("kk")"
      fi
   done
   
   for talys_version in ${talys_versions[@]} ; do
      massesDir=$(find ${find_dir} -name "audi" -or -name "ame2*" 2>/dev/null | sort -V | tail -1)
      for nucleus in ${nuclei[@]} ; do
         mass=${nucleus//[[:alpha:]]}
         element=${nucleus//[[:digit:]]}
         for projectile in ${projectiles[@]} ; do
            for alpha_omp in ${alpha_omps[@]} ; do
               for jlm_omp in ${jlm_omps[@]} ; do
                  for ld_model in ${ld_models[@]} ; do
                     for strength in ${strengths[@]} ; do
                        for ast in ${astro[@]} ; do
                           for astgs in ${astrogs[@]} ; do
                              if [ ! "${ast}" == "y" ] && [ "${astgs}" == "y" ] ; then break ; fi
                              declare -a keywords_values
                              iterate_on_additional_keywords "" 0
                              unset keywords_values
#   Finishing do on astrogs
                           done
#   Finishing do on astro
                        done
#   Finishing do on strengths
                     done
#   Finishing do on ld_models
                  done
#   Finishing do on jlm_omps
               done
#   Finishing do on alpha_omps
            done
            qsubPrefix="talys-${talys_version}_${mass}${element}_${projectile}"
            if [ "${pc_type}" == "cluster" ] ; then
               while true ; do
                  if qstat -j "${qsubPrefix}*" 2> /dev/null | grep ${qsubPrefix} &> /dev/null ; then
                     sleep 10s
                  else
                     if [ "${ranges_flag}" == "y" ] ; then
                        CalculateRanges
                        if [ ${ratio} ] ; then CalculateRatiosRanges ; fi
                     fi
                     if [ ${partial_ranges} ] ; then CalculatePartialRanges ; fi
                     if [ "${chi_flag}" == "y" ] ; then CalculateChi ; fi
                     break
                  fi
               done &
            else
               wait
               if [ "${ranges_flag}" == "y" ] ; then
                  CalculateRanges
                  if [ ${ratio} ] ; then CalculateRatiosRanges ; fi
               fi
               if [ ${partial_ranges} ] ; then CalculatePartialRanges ; fi
               if [ "${chi_flag}" == "y" ] ; then CalculateChi ; fi
               wait
            fi
#   Finishing do on projectiles
         done
#   Finishing do on nuclei
      done
#   Finishing do on talys_versions
   done

   if [ "${talys_flag}" == "y" ] && [ -e ${InputWorkDir}/energies.$$ ] ; then rm -f ${InputWorkDir}/energies.$$ ; fi
fi

wait

exit 0
