cice.setup

#!/bin/csh -f

set ICE_SANDBOX = `pwd`
set ICE_SCRIPTS = "${ICE_SANDBOX}/configuration/scripts"
set initargv = ( $argv[*] ) 

set helpheader = 0
set dash = "-"
set spval = "UnDeFiNeD"
set machcomp = $spval
set machine = $spval
set compilers = intel
set case = $spval
set test = $spval
set grid = gx3
set pesx = 4x1
set sets = ""
set bdir = $spval
set testid = $spval
set testsuite = $spval
set acct = $spval
set baseCom = $spval  # Baseline compare
set baseGen = $spval  # Baseline generate
set bfbcomp = $spval  # BFB compare
set report  = 0       # test results reporting
set versno = `grep "release =" doc/source/conf.py | cut -d \' -f 2`

if ($#argv < 1) then
  set helpheader = 1
endif

set argv = ( $initargv[*] )
# check for --version
while (1)
  if ($#argv < 1) break;
  if ("$argv[1]" =~ "--version" ) then
    echo "This is CICE ${versno}"
    exit -1
  endif
  shift argv
end

set argv = ( $initargv[*] )
# check for -h
while (1)
  if ($#argv < 1) break;
  if ("$argv[1]" =~ "-h" || "$argv[1]" =~ "--help") then
    set helpheader = 2
    if ("$argv[1]" == "-h") then
      set helpheader = 1
    endif
  endif
  shift argv
end

#------------------------------------------------------------
# Help output

if ( $helpheader > 0) then
cat << EOF1

NAME   
  cice.setup

SYNOPSIS
    --case CASE -m MACH 
        [-e ENV][-p MxN][-g GRID][-s SET1,SET2][--acct ACCT]

    --test TEST -m MACH --testid ID 
        [-e ENV][-p MxN][-g GRID][-s SET1,SET2][--acct ACCT]
        [--diff TESTNAME][--bdir DIR][--bgen DIR][--bcmp DIR]

    --suite SUITE -m MACH --testid ID 
        [-e ENV1,ENV2][--acct ACCT][--bdir DIR][--bgen DIR]
        [--bcmp DIR][--report]

DESCRIPTION
    --help, -h : help
    --version  : generates cice version number
    --case, -c : case, case directory/name (not with --test or --suite)
    --mach, -m : machine, machine name (required)
    --env,  -e : compiler(s), comma separated (default = "intel")
    --pes,  -p : tasks x threads or "m"x"n" (default is 1x1)
    --acct     : account number for the batch submission
    --grid, -g : grid, grid (default = col)
    --set,  -s : case option setting(s), comma separated (default = " ")

    For testing

    --test     : test, test name (not with --case or --suite)
    --suite    : test suite, pre-defined set of tests (not with --case or --test)
    --bdir     : top baseline directory, default ICE_MACHINE_BASELINE
    --bgen     : baselines directory where output from current tests are copied
    --bcmp     : baselines directory where output from current tests are compared
    --testid   : test ID, user-defined id for testing (REQUIRED with --test or --suite)
    --diff     : generate comparison against another case
    --report   : automatically post results when tests are complete

EXAMPLES
    cice.setup -c caseB -m gordon -e cray -s diag1,debug
    cice.setup --case ~/caseA --mach cheyenne --env intel --set diag24
    cice.setup --test restart -m onyx -e gnu -s debug -testid myid
    cice.setup --suite base_suite -m conrad --env intel,cray --testid myv1 --bgen myv1
    cice.setup --suite quick_suite -m cheyenne --testid myv1 --bgen myv1
    cice.setup --suite quick_suite -m cheyenne --testid myv2 --bgen myv2 --bcmp myv1

SEE ALSO
    cice.setup --help or
    User Documentation at https://github.com/cice-consortium/cice/

EOF1

if ($helpheader > 1) then
cat << EOF1

      Available --mach and --env combinations are in configuration/scripts/machines and include:
EOF1
      set soptions1 = `ls -1 configuration/scripts/machines | grep Macros | sed 's/Macros.//g' `
      set soptions = `echo $soptions1 | fmt -1 | sort `
      foreach sopt ($soptions)
        echo "             $sopt"
      end
cat << EOF1

      Available --set options are in configuration/scripts/options and include:
EOF1
      set soptions1 = `ls -1 configuration/scripts/options | grep set_ | sed 's/set_nml.//g' | sed 's/set_env.//g' `
      set soptions = `echo $soptions1 | fmt -1 | sort `
      foreach sopt ($soptions)
        echo "             $sopt"
      end

cat << EOF1

      Available tests are in configuration/scripts/tests and include:
EOF1
      set soptions1 = `ls -1 configuration/scripts/tests | grep test_ | sed 's/test_//g' | sed 's/.script//g' `
      set soptions = `echo $soptions1 | fmt -1 | sort `
      foreach sopt ($soptions)
        echo "             $sopt"
      end

cat << EOF1

      Available sets of predefined suites are in configurations/scripts/tests and include:
EOF1
      set soptions1 = `ls -1 configuration/scripts/tests | grep "\.ts" | sed 's/\.ts//g' `
      set soptions = `echo $soptions1 | fmt -1 | sort `
      foreach sopt ($soptions)
        echo "             $sopt"
      end

endif
exit -1
endif

#------------------------------------------------------------
# Read in command line arguments

echo " "
echo "${0}:"

set argv = ( $initargv[*] )

while (1)
  if ( $#argv < 1 ) break;
  set option = $argv[1];

# arguments without settings
  if ("$option" == "--report") then
    set report = 1
    shift argv

# arguments with settings
  else
    shift argv
    if ( $#argv < 1 ) then
      echo "${0}: ERROR1 in $option"
      exit -1
    endif
    if ($argv[1] =~ $dash* ) then
      echo "${0}: ERROR2 in $option"
      exit -1
    endif

    if ("$option" == "--case" || "$option" == "-c") then
      set case = $argv[1]
    else if ("$option" =~ --mach* || "$option" == "-m") then
      set machine = $argv[1]
    else if ("$option" =~ --env* || "$option" == "-e") then
      set compilers = $argv[1]
    else if ("$option" == "--test") then
      set test = $argv[1]
    else if ("$option" == "--grid" || "$option" == "-g") then
      set grid = $argv[1]
    else if ("$option" == "--pes" || "$option" == "-p") then
      set pesx = $argv[1]
    else if ("$option" == "--acct") then
      set acct = $argv[1]
    else if ("$option" =~ --set*  || "$option" == "-s") then
      set sets = $argv[1]
    else if ("$option" == "--bdir") then
      set bdir = $argv[1]
    else if ("$option" == "--bcmp") then
      set baseCom = $argv[1]
    else if ("$option" == "--bgen") then
      set baseGen = $argv[1]
    else if ("$option" == "--diff") then
      set bfbcomp = $argv[1]
    else if ("$option" == "--suite") then
      set testsuite = $argv[1]
    else if ("$option" == "--testid") then
      set testid = $argv[1]
    else
      echo "${0}: ERROR unknown option $option, use -h for help"
      exit -1
    endif

  shift argv

  endif
end

if ($machine == $spval) then
  echo "${0}: ERROR in arguments, -m required"
  exit -1
endif

if ($case == $spval && $test == $spval && $testsuite == $spval) then
  echo "${0}: ERROR in arguments, -c, -t, or -ts required"
  exit -1
endif

if ($case != $spval && $test != $spval) then
  echo "${0}: ERROR in arguments, cannot use both -c and -t"
  exit -1
endif

if ($case != $spval && $testsuite != $spval) then
  echo "${0}: ERROR in arguments, cannot use both -c and -ts"
  exit -1
endif

if ($testsuite != $spval && $test != $spval) then
  echo "${0}: ERROR in arguments, cannot use both -ts and -t"
  exit -1
endif

if ($testsuite == $spval) then
  if ("$compilers" =~ "*,*") then
    echo "${0}: ERROR in arguments, cannot set multiple compilers without -ts"
    exit -1
  else
    set compiler = ${compilers}
    set machcomp = ${machine}_${compiler}
  endif
endif

# tcraig, lets find another way to validate argument
#if ($test != $spval && $test != 'smoke' && $test != '10day' && $test != 'annual' \
# && $test != 'restart') then
#  echo "${0}: ERROR in arguments.  $test is not a valid test"
#  exit -1
#endif

if (($testsuite != $spval || $test != $spval) && $testid == $spval) then
  echo "${0}: ERROR in arguments.  -testid must be passed if using -ts or -t"
  exit -1
endif

#Update version.txt
echo "CICE ${versno}"  >! cicecore/version.txt

# Check to see if this is a test-suite run.  If so, loop through the various
#   tests and create a separate folder for each
if ( $testsuite != $spval ) then
  set tsdir = "${testsuite}.${testid}"
  if (-e ${testsuite}) then
    set tsfile = "${testsuite}"
  else if (-e ${testsuite}.ts) then
    set tsfile = "${testsuite}.ts"
  else 
    if (-e ${ICE_SCRIPTS}/tests/${testsuite}.ts) then
      set tsfile = "${ICE_SCRIPTS}/tests/${testsuite}.ts"
    else
      echo "${0}: ERROR, cannot find testsuite file ${testsuite}, also checked ${ICE_SCRIPTS}/tests/${testsuite}.ts"
      exit -1
    endif
  endif

  mkdir ./${tsdir}
  cp -f ${ICE_SCRIPTS}/tests/report_results.csh ./${tsdir}
  cp -f ${ICE_SCRIPTS}/tests/timeseries.csh ./${tsdir}

  if ($report == 1) then
    cp -f ${ICE_SCRIPTS}/tests/poll_queue.csh ./${tsdir}
  endif

cat >! ./${tsdir}/suite.run << EOF0
#!/bin/csh -f
EOF0

  set remote = `git remote -v | grep -i origin | grep -i push | sed "s|.*\(https.*\)\s.*|\1|g"`
  set branch = `git status | grep -i "on branch" | sed 's|^.*ranch\s*\(\S*\)$|\1|g'`
  set hash     = `git log | grep -i commit | head -1 | cut -d " " -f 2-`
  set hashuser = `git log | grep -i author | head -1 | cut -d : -f 2-`
  set hashdate = `git log | grep -i date   | head -1 | cut -d : -f 2-`
  set cdate = `date -u "+%Y-%m-%d"`
  set ctime = `date -u "+%H:%M:%S"`
  set vers = "unknown"
  set shhash = `echo ${hash} | cut -c 1-10`
  if (-e cicecore/version.txt) then
    set vers = `head -1 cicecore/version.txt`
  endif

cat >! ./${tsdir}/results.csh << EOF0
#!/bin/csh -f
rm -f results.log
echo "#------- " >> results.log
echo "#repo = ${remote}" >> results.log
echo "#bran = ${branch}" >> results.log
echo "#hash = ${hash}" >> results.log
echo "#hshs = ${shhash}" >> results.log
echo "#hshu = ${hashuser}" >> results.log
echo "#hshd = ${hashdate}" >> results.log
echo "#date = ${cdate}" >> results.log
echo "#time = ${ctime}" >> results.log
echo "#mach = ${machine}" >> results.log
echo "#user = ${user}" >> results.log
echo "#vers = ${vers}" >> results.log
echo "#------- " >> results.log
EOF0

  chmod +x ./${tsdir}/suite.run
  chmod +x ./${tsdir}/results.csh

  set ncompilers = "`echo $compilers | sed -e 's/,/ /g'`"

  foreach compiler ( $ncompilers )
  set machcomp = ${machine}_${compiler}
  foreach line ( "`cat $tsfile`" )
    # Check if line is a comment line
    if ( $line:q =~ '#'* || $line:q =~ '$'* || $line:q =~ '!'* ) then
      echo "skipping line: $line"
      continue
    endif
    # Obtain the test name, sets, grid, and PE information from .ts file
    set test = `echo $line | cut -d' ' -f1`
    set grid = `echo $line | cut -d' ' -f2`
    set pesx = `echo $line | cut -d' ' -f3`
    set sets_tmp = `echo $line | cut -d' ' -f4`
    set bfbcomp_tmp = `echo $line | cut -d' ' -f5`
    # Create a new sets_base variable to store sets passed to cice.setup
    if (! $?sets_base ) then
      set sets_base = "$sets"
    endif
    # Append sets from .ts file to the $sets variable
    if ( $sets_tmp == "none" ) then
      set sets = "$sets_base"
    else
      if ( $sets_base == "" ) then
        set sets = "$sets_tmp"
      else
        set sets = "$sets_base,$sets_tmp"
        # Remove duplictes in the sets variable
        set sets = "`echo $sets | sed -e 's/\b\([a-z]\+\)[ ,\n]\1/\1/g'`"
      endif
    endif
    # Create a new bfbcomp_base variable to store bfbcomp passed to cice.setup
    if (! $?bfbcomp_base ) then
      set bfbcomp_base = "$bfbcomp"
    endif
    # Use bfbcomp_base or bfbcomp_tmp
    if ( $bfbcomp_tmp == "" ) then
      set bfbcomp = "$bfbcomp_base"
    else
      set bfbcomp = "$bfbcomp_tmp"
    endif
endif

if ($case =~ $spval) then
  if ($sets != "") then
    set sarray = `echo $sets | sed 's/,/ /g' | fmt -1 | sort -n`
    set soptions = "JustStartingNowOK"
    foreach field ($sarray)
      if (${soptions} =~ "JustStartingNowOK") then
        set soptions = ${field}
      else
        set soptions = ${soptions}"_"${field}
      endif
    end
    # Only include $testid in testname if this is not a baseline-generating run
    set testname_noid = "${machcomp}_${test}_${grid}_${pesx}_${soptions}"
    set testname_base = "${machcomp}_${test}_${grid}_${pesx}_${soptions}.${testid}"
  else
    set testname_noid = "${machcomp}_${test}_${grid}_${pesx}"
    set testname_base = "${machcomp}_${test}_${grid}_${pesx}.${testid}"
  endif
  if ($testsuite != $spval) then
    set testname = "${tsdir}/$testname_base"
  else
    set testname = "$testname_base"
  endif
  set case = ${testname}
endif

if (-d $case) then
  echo "${0}: ERROR, case $case already exists"
  exit -1
endif
mkdir -p $case
echo "`date`${0} $initargv[*]" >> $case/README.case

#------------------------------------------------------------
# Setup case directory, copy files to case directory

cd ${case}
set casedir = `pwd`
set casescr = "${casedir}/casescripts"
if !( -d ${casescr}) mkdir ${casescr}

# from basic script dir to case
foreach file (cice.build cice.settings Makefile ice_in makdep.c)
  if !(-e ${ICE_SCRIPTS}/$file) then
    echo "${0}: ERROR, ${ICE_SCRIPTS}/$file not found"
    exit -1
  endif
  cp -f -p ${ICE_SCRIPTS}/$file ${casedir}
end

# from machines dir to case
foreach file (env.${machcomp} Macros.${machcomp})
  if !(-e ${ICE_SCRIPTS}/machines/$file) then
    echo "${0}: ERROR, ${ICE_SCRIPTS}/machines/$file not found"
    exit -1
  endif
  cp -f -p ${ICE_SCRIPTS}/machines/$file ${casedir}
end

# from basic script dir to casescr
foreach file (parse_namelist.sh parse_settings.sh parse_namelist_from_settings.sh cice_decomp.csh cice.run.setup.csh cice.test.setup.csh)
  if !(-e ${ICE_SCRIPTS}/$file) then
    echo "${0}: ERROR, ${ICE_SCRIPTS}/$file not found"
    exit -1
  endif
  cp -f -p ${ICE_SCRIPTS}/$file ${casescr}
end

if ($case =~ */*) then
  set casename = $case:t
else
  set casename = $case
endif

cd ${casedir}
source ./env.${machcomp} || exit 2

echo ICE_SANDBOX  = ${ICE_SANDBOX}
echo ICE_CASENAME = ${casename}
echo ICE_CASEDIR  = ${casedir}
echo ICE_MACHINE  = ${machine}
echo ICE_COMPILER = ${compiler}

#------------------------------------------------------------
# Compute a default blocksize

set chck = `echo ${pesx} | sed  's/^[0-9][0-9]*x[0-9][0-9]*$/OK/'`
if (${chck} == OK) then
  set task = `echo ${pesx} | sed s/x.\*//`
  set thrd = `echo ${pesx} | sed s/.\*x//`
else
  echo "${0}: ERROR in -p argument, ${pesx}, must be mxn"
  exit -1
endif

setenv ICE_DECOMP_GRID  ${grid}
setenv ICE_DECOMP_NTASK ${task}
setenv ICE_DECOMP_NTHRD ${thrd}

source ${casescr}/cice_decomp.csh
if ($status != 0) then
  echo "${0}: ERROR, cice_decomp.csh aborted"
  exit -1
endif

#------------------------------------------------------------
# Copy in and update cice.settings and ice_in files

set fimods = ${casescr}/ice_in.mods
set fsmods = ${casescr}/cice.settings.mods

cp ice_in ${casescr}/ice_in.base
cp cice.settings ${casescr}/cice.settings.base
if (-e ${fimods}) rm ${fimods}
if (-e ${fsmods}) rm ${fsmods}

cat >! ${fimods} << EOF1
# cice.setup settings

nprocs = ${task}
distribution_type = '${ICE_DECOMP_DECOMP}'
processor_shape   = '${ICE_DECOMP_DSHAPE}'
EOF1

# If this is a baseline-compare test, modify ICE_RUNDIR
if ($bdir != $spval) then
  setenv basedir_tmp ${bdir}
else
  setenv basedir_tmp ${ICE_MACHINE_BASELINE}
endif
if ("$baseGen" =~ "default") then
  set d1 = `echo ${cdate} | cut -c 3- | sed 's/-//g'`
  set t1 = `echo ${ctime} | sed 's/://g'`
  set baseGen = cice.${shhash}.${d1}-${t1}
endif
if ("$baseCom" =~ "default") then
  set baseCom = `ls -t $basedir_tmp | head -1`
endif


cat >! ${fsmods} << EOF1
# cice.setup settings

setenv ICE_SANDBOX  ${ICE_SANDBOX}
setenv ICE_SCRIPTS  ${ICE_SCRIPTS}
setenv ICE_CASENAME ${casename}
setenv ICE_CASEDIR  ${casedir}
setenv ICE_MACHINE  ${machine}
setenv ICE_COMPILER ${compiler}
setenv ICE_MACHCOMP ${machcomp}
setenv ICE_RUNDIR   ${ICE_MACHINE_WKDIR}/${casename}
setenv ICE_GRID     ${grid}
setenv ICE_NXGLOB   ${ICE_DECOMP_NXGLOB}
setenv ICE_NYGLOB   ${ICE_DECOMP_NYGLOB}
setenv ICE_NTASKS   ${task}
setenv ICE_NTHRDS   ${thrd}
setenv ICE_DECOMP   ${ICE_DECOMP_DECOMP}
setenv ICE_DSHAPE   ${ICE_DECOMP_DSHAPE}
setenv ICE_MXBLCKS  ${ICE_DECOMP_MXBLCKS}
setenv ICE_BLCKX    ${ICE_DECOMP_BLCKX}
setenv ICE_BLCKY    ${ICE_DECOMP_BLCKY}
setenv ICE_BASELINE ${basedir_tmp}
setenv ICE_BASEGEN  ${baseGen}
setenv ICE_BASECOM  ${baseCom}
setenv ICE_SPVAL    ${spval}
EOF1

if ($?ICE_MACHINE_QUIETMODE) then
  echo "setenv ICE_QUIETMODE  ${ICE_MACHINE_QUIETMODE}" >> ${fsmods}
endif

if ($bfbcomp != $spval) then
  echo "setenv ICE_BFBCOMP  ${machcomp}_${bfbcomp}.${testid}" >> ${fsmods}
else
  echo "setenv ICE_BFBCOMP  ${spval}" >> ${fsmods}
endif

if ($test != $spval) then
  echo "setenv ICE_TEST     ${test}" >> ${fsmods}
  echo "setenv ICE_TESTNAME ${testname_noid}" >> ${fsmods}
else
  echo "setenv ICE_TEST     ${spval}" >> ${fsmods}
  echo "setenv ICE_TESTNAME ${spval}" >> ${fsmods}
endif

if ($acct != $spval) then
  echo "setenv ICE_ACCOUNT ${acct}" >> ${fsmods}
else
  if (-e ~/.cice_proj) then
    set account_name = `head -1 ~/.cice_proj`
    echo "setenv ICE_ACCOUNT ${account_name}" >> ${fsmods}
  else
    echo "setenv ICE_ACCOUNT ${ICE_MACHINE_ACCT}" >> ${fsmods}
  endif
endif

if ($sets != "") then
  set setsx = `echo $sets | sed 's/,/ /g'`
else
  set setsx = ""
endif
if ($test != $spval) then
  set testx = ${test}
  # from test options to casescr in case any test time changes are applied
  cp -f -p ${ICE_SCRIPTS}/options/test_nml.${test}* ${casescr} >& /dev/null
else
  set testx = ""
endif

foreach name ($testx $grid $setsx)
  set found = 0
  if (-e ${ICE_SCRIPTS}/options/set_nml.${name}) then
cat >> ${fimods} << EOF2

# set_nml.${name}

EOF2
    cat ${ICE_SCRIPTS}/options/set_nml.${name} >> ${fimods}
cat >> ${fimods} << EOF2

EOF2
    echo "adding namelist mods set_nml.${name}"
    echo "`date`${0} adding namelist modes set_nml.${name}" >> ${casedir}/README.case
    set found = 1
  endif
  if (-e ${ICE_SCRIPTS}/options/set_env.${name}) then
cat >> ${fsmods} << EOF2

# set_env.${name}

EOF2
    cat ${ICE_SCRIPTS}/options/set_env.${name} >> ${fsmods}
cat >> ${fimods} << EOF2

EOF2
    echo "adding env mods set_env.${name}"
    echo "`date`${0} adding namelist modes set_env.${name}" >> ${casedir}/README.case
    set found = 1
  endif
  if (${found} == 0) then
    echo "${0}: ERROR, ${ICE_SCRIPTS}/options/set_[nml,env].${name} not found"
    exit -1
  endif
end

${casescr}/parse_settings.sh cice.settings ${fsmods}
${casescr}/parse_namelist.sh ice_in ${fimods}
source ./cice.settings
source ./env.${machcomp} || exit 2
${casescr}/parse_namelist_from_settings.sh ice_in cice.settings

#------------------------------------------------------------
# Generate run script

source ./cice.settings
source ./env.${machcomp} || exit 2

${casescr}/cice.run.setup.csh
if ($status != 0) then
  echo "${0}: ERROR, cice.run.setup.csh aborted"
  exit -1
endif

#------------------------------------------------------------

if ($test != $spval) then
  # Print information to stdout
  echo "Creating scripts for $test test"

  # Generate test script
  ${casescr}/cice.test.setup.csh 
  if ($status != 0) then
    echo "${0}: ERROR, cice.test.setup.csh aborted"
    exit -1
  endif

  # Initial test_output file
  echo "#---" >! test_output
  echo "PEND ${testname_noid} " >> test_output

endif

if ( $testsuite != $spval ) then
  cd ${ICE_SANDBOX}
  # Write build and run commands to suite.run

cat >> ./${tsdir}/results.csh << EOF
cat $testname_base/test_output >> results.log
EOF

cat >> ./${tsdir}/suite.run << EOF
cd $testname_base
./cice.build
./cice.submit
cd ..
EOF
    
  # Reset case for the next test in suite
  set case = $spval

  echo "" 
  echo "---" 
  echo "" 

  # This is the foreach end for the testsuite
  end
  # This is the foreach end for the compilers
  end

  # Add code to results.csh to count the number of failures
cat >> ./${tsdir}/results.csh << EOF
cat ./results.log
set pends = \`cat ./results.log | grep PEND | wc -l\`
set failures = \`cat ./results.log | grep FAIL | wc -l\`
set success = \`cat ./results.log | grep PASS | wc -l\`
set comments = \`cat ./results.log | grep "#" | wc -l\`
set alltotal = \`cat ./results.log | wc -l\`
@ total = \$alltotal - \$comments

echo "#------- " >> results.log
echo " " >> results.log
echo "#totl = \$total" >> results.log
echo "#pass = \$success" >> results.log
echo "#fail = \$failures" >> results.log
echo "#pend = \$pends" >> results.log

echo ""
echo "\$success of \$total tests PASSED"
echo "\$failures of \$total tests FAILED"
echo "\$pends of \$total tests PENDING"
exit \$failures
EOF

  # build and submit tests
  cd ${tsdir}
  ./suite.run | tee suite.log
  if ($report == 1) then
    echo "Reporting results"
    ./poll_queue.csh
    ./results.csh
    ./report_results.csh
  endif
  cd ${ICE_SANDBOX}

endif

echo " "
echo "${0} done"
echo " "
exit 0