/[MITgcm]/MITgcm/verification/testreport
ViewVC logotype

Diff of /MITgcm/verification/testreport

Parent Directory Parent Directory | Revision Log Revision Log | View Revision Graph Revision Graph | View Patch Patch

revision 1.9.2.8 by edhill, Sat Oct 4 02:10:52 2003 UTC revision 1.93 by jmc, Wed Sep 5 16:09:31 2007 UTC
# Line 1  Line 1 
1  #!/bin/bash  #! /usr/bin/env bash
2  #  #
3  #  $Header$  #  $Header$
4    #  $Name$
5  #  #
6    
7  usage()  usage()
# Line 10  usage() Line 11  usage()
11      echo      echo
12      echo "where possible OPTIONS are:"      echo "where possible OPTIONS are:"
13      echo "  (-help|-h)               print usage"      echo "  (-help|-h)               print usage"
14      echo "  (-mpi)                   use MPI input files"      echo "  (-mth)                   run multi threaded (using eedata.mth)"
15      echo "  (-optfile=|-of=)STRING   list of optfiles to use"      echo "  (-mpi)                   compile and run using MPI"
16      echo "  (-a|-addr)STRING         list of email recipients"      echo "  (-ieee|-noieee)          if possible, use IEEE compiler flags"
17        echo "                             (DEF=\"-ieee\")"
18        echo "  (-of=|-optfile=)STRING   list of optfiles to use"
19        echo "  (-a|-addr) STRING        list of email recipients"
20      echo "                             (DEF=\"edhill@mitgcm.org\")"      echo "                             (DEF=\"edhill@mitgcm.org\")"
21      echo "  (-t|-tdir)STRING         list of test dirs to use"      echo "  (-t|-tdir) STRING        list of group and/or exp. dirs to test"
22      echo "                             (DEF=\"\" which builds all)"      echo "                             (recognized groups: basic, tutorials)"
23      echo "  (-b|-bash)STRING         location of \"bash\" executable"      echo "                             (DEF=\"\" which test all)"
24      echo "                             (DEF=\"\" for \"/bin/bash\")"      echo "  (-skd|-skipdir) STRING   list of exp. dirs to skip"
25      echo "  (-command)STRING         command to run"      echo "                             (DEF=\"\" which test all)"
26        echo "  (-b|-bash) STRING        preferred location of a \"bash\" or"
27        echo "                             Bourne-compatible \"sh\" shell"
28        echo "                             (DEF=\"\" for \"bash\")"
29        echo "  (-adm|-ad)               perform an adjoint run"
30        echo "  (-command) STRING        command to run"
31      echo "                             (DEF=\"make output.txt\")"      echo "                             (DEF=\"make output.txt\")"
32      echo "  (-m|-make)STRING         command to use for \"make\""      echo "  (-m|-make) STRING        command to use for \"make\""
33      echo "                             (DEF=\"make\")"      echo "                             (DEF=\"make\")"
34        echo "  (-odir) STRING           used to build output directory name"
35        echo "                             (DEF=\"hostname\")"
36        echo "  (-ptr|-ptracers) STRING  specify which ptracers to test"
37        echo "                             (DEF=\"1 2 3 4 5\")"
38        echo "  (-match) NUMBER          Matching Criteria (number of digits)"
39        echo "                             (DEF=\"12\")"
40        echo "  (-j) JOBS                use \"make -j JOBS\" for parallel builds"
41      echo "  (-clean)                 *ONLY* run \"make CLEAN\""      echo "  (-clean)                 *ONLY* run \"make CLEAN\""
42      echo "  (-quick|-q)              same as \"-nogenmake -noclean -nodepend\""      echo "  (-quick|-q)              same as \"-nogenmake -noclean -nodepend\""
43      echo "  (-nogenmake|-ng)         skip the genmake stage"      echo "  (-nogenmake|-ng)         skip the genmake stage"
44      echo "  (-noclean|-nc)           skip the \"make clean\" stage"      echo "  (-noclean|-nc)           skip the \"make clean\" stage"
45      echo "  (-nodepend|-nd)          skip the \"make depend\" stage"      echo "  (-nodepend|-nd)          skip the \"make depend\" stage"
46        echo "  (-deldir|-dd)            on success, delete the output directory"
47        echo "  (-ts)                    provide timing information per timestep"
48        echo "  (-papis)                 provide MFlop/s per timestep using PAPI"
49        echo "  (-pcls)                  provide MFlop/s per timestep using PCL"
50      echo      echo
51      echo "and where STRING follows a whitespace-delimited format"      echo "and where STRING can be a whitespace-delimited list"
52      echo "such as:"      echo "such as:"
53        echo
54      echo "  -t 'exp0 exp2 exp3' "      echo "  -t 'exp0 exp2 exp3' "
55      echo "  -addr='abc@123.com testing@home.org'"      echo "  -addr='abc@123.com testing@home.org'"
56      echo      echo
57        echo "provided that the expression is properly quoted within the current"
58        echo "shell (note the use of single quotes to protect white space)."
59        echo
60      exit 1      exit 1
61  }  }
62    
63  #  build the mpack utility  #  build the mpack utility
64  build_mpack()  build_mpack()
65  {  {
66      echo -n "building the mpack utility...  "      printf "building the mpack utility...  "
67      if test ! -x "$MPACKDIR/mpack" ; then      if test ! -x "$MPACKDIR/mpack" ; then
68          if test ! -d $MPACKDIR ; then          if test ! -d $MPACKDIR ; then
69                echo
70              echo "Error: can't find \"$MPACKDIR\""              echo "Error: can't find \"$MPACKDIR\""
71              echo "  are you sure this program is being run in the correct "              echo "  are you sure this program is being run in the correct "
72              echo "  (that is, \"MITGCM_ROOT\verification\") directory?"              echo "  (that is, \"MITGCM_ROOT\verification\") directory?"
73              exit 1              echo
74                HAVE_MPACK=f
75          fi          fi
76          echo -n "building mpack...  "          printf "building mpack...  "
77          ( cd $MPACKDIR && ./configure && $MAKE ) > build_mpack.out 2>&1          if test "x$CC" = x ; then
78                export CC=cc
79            fi
80            ( cd $MPACKDIR && ./configure && $MAKE ) > tr_build_mpack.out 2>&1
81          RETVAL=$?          RETVAL=$?
82          if test "x$RETVAL" != x0 ; then          if test "x$RETVAL" != x0 ; then
83              echo              echo
84              echo "Error building the mpack tools at: $MPACK_DIR"              echo "Error building the mpack tools at: $MPACK_DIR"
85              exit 1              echo
86                HAVE_MPACK=f
87            else
88                rm -f tr_build_mpack.out
89                HAVE_MPACK=t
90          fi          fi
91        else
92            HAVE_MPACK=t
93      fi      fi
94      echo "OK"      echo "OK"
95  }  }
96    
97  compare_lines()  testoutput_var()
 {  
     # use codelet to compare lines  
     if [ $verbose -gt 1 ]; then  
         cat tmp3.txt 1>&2  
     fi  
     return `./a.out < tmp3.txt`  
 }  
   
 testoutput_for_prop()  
98  {  {
99      # testoutput_for_prop dir s1 label subdir      # testoutput_var dir s1 label subdir extension
100      #      #
101      #  compares files in $dir/$subdir/output.txt and $dir/results/output.txt      #  compares 1 variable output selected from file $dir/$subdir/$OUTPUTFILE
102      #  using search strings s1 and text label      #     with same output from reference file $dir/results/output.$extension
103        #  using search strings s1 and text label
104    
105      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
106          echo testoutput_for_prop: grep "$2" $1/$4/output.txt 1>&2          echo testoutput_var: grep "$2" $1/$4/$OUTPUTFILE 1>&2
107      fi      fi
108      if [ -r $1/$4/output.txt ]; then      if [ -r $1/$4/$OUTPUTFILE ]; then
109          grep "$2" $1/$4/output.txt | sed 's/.*=//' | nl > tmp1.txt          grep "$2" $1/$4/$OUTPUTFILE | sed 's/.*=//' | cat -n > tmp1.txt
110          lncnt=`wc -l tmp1.txt | awk '{print $1}' `          lncntA=`wc -l tmp1.txt | awk '{print $1}' `
111          if [ $lncnt -lt 3 ]; then          if [ $lncntA -lt 3 ]; then
112              if [ $verbose -gt 0 ]; then              if [ $verbose -gt 0 ]; then
113                  echo Not enough lines of output when searching for "$2" 1>&2                  echo Not enough lines of output when searching for "$2" 1>&2
114              fi              fi
115              return 99              return 99
116          fi          fi
117      else      else
118          echo testoutput_for_prop: output.txt from model run was not readable 1>&2          echo testoutput_var: $OUTPUTFILE from model run was not readable 1>&2
119          return 99          return 99
120      fi      fi
121      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
122          echo testoutput_for_prop: grep "$2" $1/results/output.txt 1>&2          echo testoutput_var: grep "$2" $1/results/output.$5 1>&2
123      fi      fi
124      grep "$2" $1/results/output.txt | sed 's/.*=//' | nl > tmp2.txt      grep "$2" $1/results/output.$5 | sed 's/.*=//' | cat -n > tmp2.txt
125      lncnt=`wc -l tmp2.txt | awk '{print $1}' `      lncntB=`wc -l tmp2.txt | awk '{print $1}' `
126      if [ $lncnt -lt 3 ]; then      if [ $lncntB -lt 3 ]; then
127          if [ $verbose -gt 0 ]; then          if [ $verbose -gt 0 ]; then
128              echo Not enough lines of output when searching for "$2" 1>&2              echo Not enough lines of output when searching for "$2" 1>&2
129          fi          fi
130          return 99          return 99
131      fi      fi
132        if [ $lncntA -ne $lncntB ]; then
133            if [ $verbose -gt 0 ]; then
134                echo Not same Nb of lines when searching for "$2" ":" $lncntA $lncntB 1>&2
135            fi
136            return 99
137        fi
138        has_nan=`cat tmp1.txt | grep -i nan | wc -l`
139        if [ $has_nan -gt 0  ] ; then
140            echo testoutput_var: $OUTPUTFILE contains $has_nan NaN values  1>&2
141            return 99
142        fi
143        has_inf=`cat tmp1.txt | grep -i inf | wc -l`
144        if [ $has_inf -gt 0  ] ; then
145            echo testoutput_var: $OUTPUTFILE contains $has_inf Inf values  1>&2
146            return 99
147        fi
148      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
149          echo testoutput_for_prop: join tmp1.txt tmp2.txt 1>&2          echo testoutput_var: join tmp1.txt tmp2.txt 1>&2
150      fi      fi
151      join tmp1.txt tmp2.txt | awk '{print $1 " " $2 " " $3}' > tmp3.txt      join tmp1.txt tmp2.txt | awk '{print $1 " " $2 " " $3}' > tmp3.txt
152      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
153          echo testoutput_for_prop: compare_lines 1>&2          echo testoutput_var: compare_lines 1>&2
154        fi
155        if [ $verbose -gt 1 ]; then
156            cat tmp3.txt 1>&2
157      fi      fi
158      compare_lines      echo "-1" >> tmp3.txt
159      digits_of_similarity=$?      # On the SGI O3K (*not* the O2K), "cat -n" inserts a ":" after the line number
160        cat tmp3.txt | sed -e 's|:||g' > tmp4.txt
161        digits_of_similarity=`./tr_cmpnum < tmp4.txt`
162      if [ $digits_of_similarity -eq 99 ]; then      if [ $digits_of_similarity -eq 99 ]; then
163          if [ $verbose -gt 0 ]; then          if [ $verbose -gt 0 ]; then
164              echo testoutput_for_prop: No comparison was available for \"$2\" 1>&2              echo testoutput_var: No comparison was available for \"$2\" 1>&2
165          fi          fi
166          digits_of_similarity=99          digits_of_similarity=99
167      else      else
# Line 121  testoutput_for_prop() Line 169  testoutput_for_prop()
169              echo There were $digits_of_similarity decimal places of similarity for \"$2\" 1>&2              echo There were $digits_of_similarity decimal places of similarity for \"$2\" 1>&2
170          fi          fi
171      fi      fi
172      rm tmp1.txt tmp2.txt tmp3.txt      rm -f tmp1.txt tmp2.txt tmp3.txt tmp4.txt
173            
174      return $digits_of_similarity      return $digits_of_similarity
175  }  }
# Line 141  dashnum() Line 189  dashnum()
189      done      done
190  }  }
191    
192  testoutput()  testoutput_ad()
193  {  {
194      # testoutput diretory subdir      grep $3 $1/results_ad/output_adm.txt | awk '{print NR " " $5}' > t05.txt
195      #      grep $3 $1/$2/$OUTPUTFILE | awk '{print NR " " $5}' > t15.txt
196      #  test output in "directory"      grep $3 $1/results_ad/output_adm.txt | awk '{print NR " " $6}' > t06.txt
197        grep $3 $1/$2/$OUTPUTFILE | awk '{print NR " " $6}' > t16.txt
198        join t05.txt t15.txt > t5.txt
199        join t06.txt t16.txt > t6.txt
200        echo "-1" >> t5.txt
201        echo "-1" >> t6.txt
202        digits_5=`./tr_cmpnum < t5.txt`
203        digits_6=`./tr_cmpnum < t6.txt`
204        dashnum $digits_5 $digits_6
205        rm -f t[01][56].txt t[56].txt
206    }
207    
208      if [ $debug -gt 0 ]; then  check_for_add_mon_output()
209          echo testoutput: testoutput_for_prop $1 cg2d_init_res 1>&2  {
210        # Check for additional types of monitor output
211        if test "x$1" = x ; then
212            return
213      fi      fi
214      testoutput_for_prop $1 "cg2d_init_res" "cg2d init. residual" $2; cg2dres=$?  
215      if [ $debug -gt 0 ]; then      for ii in $PTRACERS_NUM ; do
216          echo testoutput: cg2dres=$cg2dres 1>&2          eval "HAVE_PTR0"$ii"=f"
217        done
218    
219        ptr_add="trcstat_ptracerXX_min trcstat_ptracerXX_max"
220        ptr_add="$ptr_add trcstat_ptracerXX_mean trcstat_ptracerXX_sd"
221        for ii in $PTRACERS_NUM ; do
222            for jj in $ptr_add ; do
223                name=`eval "echo $jj | sed -e 's|XX|0"$ii"|g'"`
224                tst=`grep $name $1 | wc -l | awk '{print $1}'`
225                if test ! "x$tst" = x0 ; then
226                    eval "HAVE_PTR0"$ii"=t"
227                fi
228            done
229            #  eval 'echo "HAVE_PTR0'$ii' = $HAVE_PTR0'$ii'"'
230        done
231    }
232    
233    testoutput_run()
234    {
235        # testoutput_run directory subdir extension
236        #
237        #  test output from 1 run in "directory"
238        if test "x$ADM" = x ; then
239            if [ $debug -gt 0 ]; then
240                echo testoutput_run: testoutput_var $1 cg2d_init_res 1>&2
241            fi
242            testoutput_var $1 "cg2d_init_res" "cg2d init. residual" $2 $3; cg2dres=$?
243            if [ $debug -gt 0 ]; then
244                echo testoutput_run: cg2dres=$cg2dres 1>&2
245            fi
246            testoutput_var $1 "dynstat_theta_min" "theta minimum" $2 $3; tmin=$?
247            testoutput_var $1 "dynstat_theta_max" "theta maximum" $2 $3; tmax=$?
248            testoutput_var $1 "dynstat_theta_mean" "theta mean" $2 $3; tmean=$?
249            testoutput_var $1 "dynstat_theta_sd" "theta s.d." $2 $3; tsd=$?
250            testoutput_var $1 "dynstat_salt_min" "salt minimum" $2 $3; smin=$?
251            testoutput_var $1 "dynstat_salt_max" "salt maximum" $2 $3; smax=$?
252            testoutput_var $1 "dynstat_salt_mean" "salt mean" $2 $3; smean=$?
253            testoutput_var $1 "dynstat_salt_sd" "salt s.d." $2 $3; ssd=$?
254            testoutput_var $1 "dynstat_uvel_min" "U minimum" $2 $3; umin=$?
255            testoutput_var $1 "dynstat_uvel_max" "U maximum" $2 $3; umax=$?
256            testoutput_var $1 "dynstat_uvel_mean" "U mean" $2 $3; umean=$?
257            testoutput_var $1 "dynstat_uvel_sd" "U s.d." $2 $3; usd=$?
258            testoutput_var $1 "dynstat_vvel_min" "V minimum" $2 $3; vmin=$?
259            testoutput_var $1 "dynstat_vvel_max" "V maximum" $2 $3; vmax=$?
260            testoutput_var $1 "dynstat_vvel_mean" "V mean" $2 $3; vmean=$?
261            testoutput_var $1 "dynstat_vvel_sd" "V s.d." $2 $3; vsd=$?
262    
263            #  This is for PTRACERS
264            for ii in $PTRACERS_NUM ; do
265                eval `echo "p0"$ii"_min=99"`
266                eval `echo "p0"$ii"_max=99"`
267                eval `echo "p0"$ii"_mean=99"`
268                eval `echo "p0"$ii"_sd=99"`
269                tst=`eval 'echo "$HAVE_PTR0'$ii'"'`
270                #echo 'tst = '$tst
271                if test "x$tst" = xt ; then
272                    a="trcstat_ptracer0"
273                    testoutput_var $1 "$a"$ii"_min"  "p0"$ii"_min"  $2 $3
274                    RETVAL=$? ; eval `echo "p0"$ii"_min="$RETVAL`
275                    testoutput_var $1 "$a"$ii"_max"  "p0"$ii"_max"  $2 $3
276                    RETVAL=$? ; eval `echo "p0"$ii"_max="$RETVAL`
277                    testoutput_var $1 "$a"$ii"_mean" "p0"$ii"_mean" $2 $3
278                    RETVAL=$? ; eval `echo "p0"$ii"_mean="$RETVAL`
279                    testoutput_var $1 "$a"$ii"_sd"   "p0"$ii"_sd"   $2 $3
280                    RETVAL=$? ; eval `echo "p0"$ii"_sd="$RETVAL`
281                fi
282            done
283    
284            allargs="$cg2dres $tmin $tmax $tmean $tsd $smin $smax $smean $ssd"
285            allargs="$allargs $umin $umax $umean $usd $vmin $vmax $vmean $vsd"
286            allargs="$allargs $p01_min $p01_max $p01_mean $p01_sd"
287            allargs="$allargs $p02_min $p02_max $p02_mean $p02_sd"
288            allargs="$allargs $p03_min $p03_max $p03_mean $p03_sd"
289            allargs="$allargs $p04_min $p04_max $p04_mean $p04_sd"
290            allargs="$allargs $p05_min $p05_max $p05_mean $p05_sd"
291    
292            eval "dashnum $allargs"
293    
294        else
295            testoutput_ad $1 $2 "precision_grdchk_result"
296      fi      fi
       
     testoutput_for_prop $1 "dynstat_theta_min" "theta minimum" $2; tmin=$?  
     testoutput_for_prop $1 "dynstat_theta_max" "theta maximum" $2; tmax=$?  
     testoutput_for_prop $1 "dynstat_theta_mean" "theta mean" $2; tmean=$?  
     testoutput_for_prop $1 "dynstat_theta_sd" "theta s.d." $2; tsd=$?  
     testoutput_for_prop $1 "dynstat_salt_min" "salt minimum" $2; smin=$?  
     testoutput_for_prop $1 "dynstat_salt_max" "salt maximum" $2; smax=$?  
     testoutput_for_prop $1 "dynstat_salt_mean" "salt mean" $2; smean=$?  
     testoutput_for_prop $1 "dynstat_salt_sd" "salt s.d." $2; ssd=$?  
     testoutput_for_prop $1 "dynstat_uvel_min" "U minimum" $2; umin=$?  
     testoutput_for_prop $1 "dynstat_uvel_max" "U maximum" $2; umax=$?  
     testoutput_for_prop $1 "dynstat_uvel_mean" "U mean" $2; umean=$?  
     testoutput_for_prop $1 "dynstat_uvel_sd" "U s.d." $2; usd=$?  
     testoutput_for_prop $1 "dynstat_vvel_min" "V minimum" $2; vmin=$?  
     testoutput_for_prop $1 "dynstat_vvel_max" "V maximum" $2; vmax=$?  
     testoutput_for_prop $1 "dynstat_vvel_mean" "V mean" $2; vmean=$?  
     testoutput_for_prop $1 "dynstat_vvel_sd" "V s.d." $2; vsd=$?  
       
     dashnum $cg2dres $tmin $tmax $tmean $tsd $smin $smax $smean $ssd \  
         $umin $umax $umean $usd $vmin $vmax $vmean $vsd  
297  }  }
298    
299  genmakemodel()  genmakemodel()
# Line 182  genmakemodel() Line 302  genmakemodel()
302      if test "x$NOGENMAKE" = xt ; then      if test "x$NOGENMAKE" = xt ; then
303          echo "genmake skipped!"          echo "genmake skipped!"
304      else      else
305          GENMAKE2="$BASH ../../../tools/genmake2"          if test "x$BASH" = x ; then
306                GENMAKE2="../../../tools/genmake2"
307            else
308                GENMAKE2="$BASH ../../../tools/genmake2 -bash $BASH"
309            fi
310          (          (
311              cd $1;              cd $1;
312              printf 'genmake ... ' 1>&2              command="$GENMAKE2  -ds -m $MAKE"
313              command="$GENMAKE2  -ds -m $MAKE --mods=../code"              if test "x$ADM" = x ; then
314                    command="$command --mods=../code"
315                else
316                    command="$command --mods=../code_ad"
317                fi
318              if test "x$OPTFILE" != xNONE ; then              if test "x$OPTFILE" != xNONE ; then
319                  command="$command --optfile=$OPTFILE"                  command="$command --optfile=$OPTFILE"
                 # echo "  command=\"$command\""  
320              fi              fi
321                if test "x$IEEE" != x ; then
322                    command="$command -ieee"
323                fi
324                if test "x$MPI" = xt ; then
325                    command="$command -mpi"
326                fi
327                if test "x$TS" = xt ; then
328                    command="$command -ts"
329                fi
330                if test "x$PAPIS" = xt ; then
331                    command="$command -papis"
332                else
333                if test "x$PCLS" = xt ; then
334                    command="$command -pcls"
335                fi
336                fi
337                printf 'genmake ... ' 1>&2
338              $command > make.log 2>&1              $command > make.log 2>&1
339              RETVAL=$?              RETVAL=$?
340              for i in genmake_state genmake_optfile genmake_local Makefile ; do              #  Reduce the size of the testing emails!
341                  if test -r $i ; then              head -100 Makefile > $CDIR/Makefile_head
                     cp $i $CDIR  
                 fi  
             done  
342              if test "x$RETVAL" != x0 ; then              if test "x$RETVAL" != x0 ; then
343                  tail make.log                  tail make.log
344                  echo "genmakemodel: genmake failed" 1>&2                  echo "genmakemodel: genmake failed" 1>&2
345                  cp make.log $CDIR                  cp genmake_* make.log $CDIR
346                  return 1                  return 1
347              else              else
348                  echo "succesful" 1>&2                  echo "successful" 1>&2
349              fi              fi
350          )          )
351      fi      fi
# Line 214  makeclean() Line 355  makeclean()
355  {  {
356      # makeclean directory      # makeclean directory
357      if test "x$NOCLEAN" = xt ; then      if test "x$NOCLEAN" = xt ; then
358          echo "make CLEAN skipped!"          echo "make Clean skipped!"
359      else      else
360          (          (
361              cd $1;              cd $1;
362              if test -e output.txt ; then              #if test -e $OUTPUTFILE ; then rm -f $OUTPUTFILE ; fi
                 rm -f output.txt  
             fi  
             printf 'make CLEAN ... ' 2>&1  
363              if test -r Makefile ; then              if test -r Makefile ; then
364                  $MAKE CLEAN >> make.log 2>&1                  printf 'clean build-dir: make Clean ... ' 2>&1
365                    $MAKE Clean >> make.log 2>&1
366                  RETVAL=$?                  RETVAL=$?
367                  if test "x$RETVAL" != x0 ; then                  if test "x$RETVAL" != x0 ; then
368                      tail make.log                      tail make.log
369                      echo "makeclean: \"make CLEAN\" failed" 1>&2                      echo "makeclean: \"make Clean\" failed" 1>&2
370                      cp make.log $CDIR"/make.log"                      cp make.log $CDIR"/make.log"
371                      return 1                      return 1
372                  fi                  fi
373              fi              fi
374              echo succesful 1>&2              echo successful 1>&2
375                exit 0
376            )
377        fi
378    }
379    
380    run_clean()
381    {
382        # run_clean directory
383        if test "x$NOCLEAN" = xt ; then
384            echo "run_clean skipped!"
385        else
386            (
387                cd $1;
388                printf 'clean run-dir ... ' 2>&1
389                # part of what is done after "make clean" when doing "make CLEAN"
390                find . -name "*.meta" -exec rm {} \;
391                find . -name "*.data" -exec rm {} \;
392                find . -name "fort.*" -exec rm {} \;
393                find . -type l -exec rm {} \;
394                rm -f $EXECUTABLE *.txt STD* *diagnostics.log datetime
395                rm -rf mnc_test_*
396                echo successful 1>&2
397              exit 0              exit 0
398          )          )
399      fi      fi
# Line 255  makedependmodel() Line 416  makedependmodel()
416                  cp make.log $CDIR"/make.log"                  cp make.log $CDIR"/make.log"
417                  return 1                  return 1
418              else              else
419                  echo succesful 1>&2                  echo successful 1>&2
420              fi              fi
421          )          )
422      fi      fi
# Line 268  makemodel() Line 429  makemodel()
429          cd $1;          cd $1;
430          if test -r Makefile ; then          if test -r Makefile ; then
431              printf 'make ... ' 1>&2              printf 'make ... ' 1>&2
432              $MAKE >> make.log 2>&1              if test "x$ADM" = x ; then
433                    if test "x$JOBS" = x ; then
434                        $MAKE >> make.log 2>&1
435                    else
436                        $MAKE -j $JOBS >> make.log 2>&1
437                    fi
438                else
439                    $MAKE adall >> make.log 2>&1
440                fi
441              RETVAL=$?              RETVAL=$?
442              if test "x$RETVAL" != x0 ; then              if test "x$RETVAL" != x0 ; then
443                  tail make.log                  tail make.log
# Line 276  makemodel() Line 445  makemodel()
445                  cp make.log $CDIR"/make.log"                  cp make.log $CDIR"/make.log"
446                  return 1                  return 1
447              else              else
448                  echo succesful 1>&2                  echo successful 1>&2
449              fi              fi
450          fi          fi
451      )      )
452  }  }
453    
454    symlink_mpifiles()
455    {
456        # Put special links so that MPI specific files are used
457        # This MUST be invoked between makeclean and makelinks because
458        # the Makefile will link to non-mpi files by default
459    
460        dir=$1
461        code_dir=$2
462        BUILD_DIR=$dir/$3
463        CODE_DIR=$dir/$code_dir
464        
465        # These are files that should replace their counter-part when using -mpi
466        MPI_FILES=`(cd $CODE_DIR; find . -name "*_mpi")`
467    
468        #  Is this an MPI run?
469        if test "x$MPI" = xt ; then
470            # YES: We symbolically link these files to the build
471            # dir so long as there is no real file in place
472            for ii in $MPI_FILES ; do
473                i=`echo $ii | sed 's:^\./::'`
474                name=`echo $i | sed 's:_mpi::' `
475                cmp $CODE_DIR/$i $BUILD_DIR/$name > /dev/null 2>&1
476                RETVAL=$?
477                if test "x$RETVAL" != x0 ; then
478                    if ! test -f $BUILD_DIR/$i ; then
479                        #echo Linking $name to $i
480                        (cd $BUILD_DIR; ln -sf ../$code_dir/$i $name)
481                    fi
482                fi
483            done
484        else
485            # NO: We undo any _mpi symbolically linked files
486            for ii in $MPI_FILES ; do
487                i=`echo $ii | sed 's:^\./::'`
488                name=`echo $i | sed 's:_mpi::' `
489                if test -L $BUILD_DIR/$name ; then
490                    cmp $BUILD_DIR/$name "../$code_dir/$name"_mpi > /dev/null 2>&1
491                    RETVAL=$?
492                    if test "x$RETVAL" = x0 ; then
493                        #echo Un-linking $name from $linktarg
494                        rm -f $BUILD_DIR/$name
495                    fi
496                fi
497            done
498        fi
499        
500    }
501    
502  linkdata()  linkdata()
503  {  {
504      # linkdata flag      # linkdata run_dir input_dir_1 input_dir_2 ...
505      #      #
506      # symbolically link data files to run directory      # symbolically link data files to run directory
507      if [ $1 -ne 0 ]; then      if test -d $1 ; then
508          ( cd $2 ;  ln -sf ../input/* . )          (
509                cd $1 ; shift
510                if test -r "../"$1"/eedata.mth" ; then
511                # found eedata.mth in 1rst input dir and it is readable
512                    if test "x$MULTI_THREAD" = "xt" ; then
513                    # multi-threaded test: remove symbolic link & link eedata.mth
514                        if test -h eedata ; then rm -f eedata ; fi
515                        if test ! -r eedata ; then
516                            ln -sf "../"$1"/eedata.mth" eedata ;
517                            printf 'eedata.mth ' 1>&2
518                        fi
519                    else
520                    # not multi-threaded test: remove eedata symbolic link
521                        if test -h eedata ; then rm -f eedata ; fi
522                    fi
523                fi
524                for ldir in $* ; do
525                    if test -d "../"$ldir ; then
526                        printf 'ldir='${ldir} 1>&2
527                        files=`( cd "../"$ldir ; ls -1 | grep -v CVS )`
528                        for i in $files ; do
529                            if test ! -d "../"$ldir/$i ; then
530                                if test ! -r $i  ; then
531                                    printf ' '$i 1>&2
532                                    ln -sf "../"$ldir"/"$i $i
533                                fi
534                            fi
535                        done
536                        if test -x "../"$ldir"/"prepare_run ; then
537                            "../"$ldir"/"prepare_run
538                        fi
539                        printf ' ; ' 1>&2
540                    fi
541                done
542            )
543      fi      fi
544  }  }
545    
# Line 296  runmodel() Line 547  runmodel()
547  {  {
548      # runmodel directory      # runmodel directory
549      #      #
550      #  runs "$COMMAND" in "directory"      #  runs "$COMMAND in "directory"
551      #  (where "$COMMAND" is relative to "directory")      #  (where "$COMMAND" is relative to "directory")
552      (      (
553          cd $1          cd $1
554          printf 'runmodel: ' 1>&2          printf 'runmodel in %s ...' $1 1>&2
555          # make output.txt          # make output.txt
556          $COMMAND          echo
557          RETVAL=$?          if test ! -x $EXECUTABLE -a -x "../"$builddir"/"$EXECUTABLE ; then
558          if test "x$RETVAL" = x0 ; then              echo " link" $EXECUTABLE "from dir ../"$builddir > run.log_00
559              cp output.txt $CDIR"/output.txt"              ln -sf "../"$builddir"/"$EXECUTABLE .
560            fi
561            if test ! -x $EXECUTABLE ; then
562                    rm -f run.log ; touch run.log
563                    if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
564                    echo " no executable:" $EXECUTABLE >> run.log
565                    RETVAL=8
566                    ENDVAL=-1
567            else
568                if test $OUTPUTFILE -ot $EXECUTABLE ; then
569                    rm -f run.log ; touch run.log
570                    if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
571                    ( eval $COMMAND ) >> run.log 2>&1
572                    RETVAL=$?
573                else
574                    RETVAL=0
575                    if test -f run.log ; then
576                        if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
577                        echo "---------->> $OUTPUTFILE is up to date " >> run.log 2>&1
578                    else
579                        touch run.log
580                        if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
581                        echo "---------->> $OUTPUTFILE is up to date " >> run.log 2>&1
582                        echo " no previous run.log: assume NORMAL END" >> run.log 2>&1
583                    fi
584                fi
585                ENDVAL=`cat run.log | grep -v 'ABNORMAL END' | grep -c 'NORMAL END'`
586            fi
587            rm -f run.log_00
588            #if test "x$RETVAL" = x0 ; then
589            if [ $RETVAL -eq 0 -a $ENDVAL -gt 0 ] ; then
590                tail run.log
591                echo successful 1>&2
592                # === Reduce the size of the testing emails!
593                #cp $OUTPUTFILE $CDIR"/"$OUTPUTFILE
594                if test -s STDERR.0000 ; then cp STDERR.0000 $CDIR"/STDERR.0000" ; fi
595              return 0              return 0
596          else          else
597                tail run.log
598                echo failed '(run:' $RETVAL ' end:' $ENDVAL ')' 1>&2
599                cp run.log $CDIR"/run.log"
600                if test -s STDERR.0000 ; then cp STDERR.0000 $CDIR"/STDERR.0000" ; fi
601              return 1              return 1
602          fi          fi
603      )      )
# Line 317  createcodelet() Line 607  createcodelet()
607  {  {
608      # create codelet for comparing model output      # create codelet for comparing model output
609    
610      echo -n "creating the comparison code...  "      printf "creating the comparison code...  "
611      cat > tmp_cmpnum.f <<EOFA      cat > tr_cmpnum.c <<EOF
612        program cmpnum  #include <stdio.h>
613        implicit none  #include <math.h>
614        real*8 a,b,diff  int main( int argc, char** argv )  {
615        integer linnum,best    int linnum,cmplin,best,lncnt;
616        best=-16    double a,b,abave,relerr;
617    99  read(*,*,end=70,err=60) linnum,a,b    best = -22;
618        diff=0.5*(abs(a)+abs(b))    lncnt = 0;
619  c     print *,a,b,diff,abs(a-b)/diff    while( 1 & (lncnt+=1) < 999 )  {
620        if (diff.gt.1.e-12) then      scanf("%d", &linnum);
621          diff=abs(a-b)/diff      if (linnum == -1)  break;
622          if (diff.gt.0.) then      scanf("%lf", &a);  scanf("%lf", &b);
623  c         print *,int(log10(diff)),diff      abave = 0.5*(fabs(a)+fabs(b));
624            linnum=int(log10(diff))      if ( abave == abave ) {
625            best=max(best,linnum)        if (abave > 0.0) {
626          endif          relerr=fabs(a-b)/abave;
627        else          if (relerr > 0.0) { cmplin = (int)rint(log10(relerr)); }
628          if (best.eq.-16.and.diff.ne.0.) best=-22          else { cmplin = -16 ; }
629        endif          best = (best > cmplin) ? best : cmplin; }
630        goto 99        else { cmplin = -22 ; }
631    60  stop 'cmpnum: An error occured reading a,b'     /* printf("%d ; %lf ; %lf\n",cmplin,a,b); */
632    70  print *,-best        }
633        end     else {
634  EOFA     /* printf("%lf ; %lf ; %lf\n",abave,a,b); */
635          break; }
636      }
637      if (lncnt == 999) best=-29;
638      if (linnum != -1) best=-99;
639      printf("%d\n", -best);
640      return 0;
641    }
642    EOF
643        $CC -o tr_cmpnum tr_cmpnum.c -lm
644    
645      f77 tmp_cmpnum.f      if [ -x ./tr_cmpnum ]; then
     if [ -x ./a.out ]; then  
646          echo "OK"          echo "OK"
647          return 0          return 0
648      else      else
649          echo          echo
650          echo "createcodelet: failed to compile codelet"          echo "ERROR: failed to compile comparison code -- please specify"
651            echo "  a C compiler using the CC environment variable."
652          exit 1          exit 1
653      fi      fi
654  }  }
# Line 366  formatresults() Line 665  formatresults()
665      if [ $1 = '--' ]; then      if [ $1 = '--' ]; then
666          printf ' N/O '          printf ' N/O '
667      else      else
668          if [ $1 -gt 12 ]; then          if [ $1 -ge $MATCH_CRIT ]; then
669              printf ' pass'              printf ' pass'
670          else          else
671              printf ' FAIL'              printf ' FAIL'
# Line 377  formatresults() Line 676  formatresults()
676            
677  }  }
678    
 show_help()  
 {  
     cat - << EOF  
 $0 [-help] [-quick] [-verbose] dir1 [dir2] [...]  
   
  -help|-h      Show this help message  
  -quiet     Reduce the amount of output  
  -verbose   Produce copious amounts of output  
  -debug     Produce even more output which will mean nothing to most  
  -force     Do "make CLEAN" before compiling. This forces a complete rebuild.  
  -clean     Do "make CLEAN" after compiling and testing.  
  -noieee    By default, $0 uses the -ieee option for genmake. This turns it off.  
  -cleanup   Aggresively removes all model output, executables and object files  
             and then exits. Use with care.  
   
 Normal usage:  
  $0 *       Configure, compile, run and analyze in all experiment directories  
 EOF  
 }  
   
679  scandirs()  scandirs()
680  {  {
681      if [ $# -eq 0 ]; then      if [ $# -eq 1 ]; then
682          for arg in * ; do          for arg in * ; do
683              test -d $arg/input && echo $arg              test -d $arg/$1 && echo $arg
684          done          done
685      else      else
686          echo $*          echo $*
687      fi      fi
688  }  }
689    
690    
691  ###############################################################################  ###############################################################################
 ###############################################################################  
 ###############################################################################  
692    
693    
694  #  Default properties  #  Default properties
# Line 421  clean=0 Line 698  clean=0
698  expts=''  expts=''
699  # ieee=1  # ieee=1
700    
701    IEEE=true
702    if test "x$MITGCM_IEEE" != x ; then
703        IEEE=$MITGCM_IEEE
704    fi
705    
706    
707  CLEANUP=f  CLEANUP=f
708  QUICK=f  QUICK=f
709  NOGENMAKE=f  NOGENMAKE=f
710  NOCLEAN=f  NOCLEAN=f
711  NODEPEND=f  NODEPEND=f
712    POSTCLEAN=f
713    
714  BASH=  BASH=
715  OPTFILE=NONE  OPTFILE=NONE
716  ADDRESSES=  ADDRESSES=
717  TESTDIRS=  TESTDIRS=
718    SKIPDIRS=
719  MPACKDIR="../tools/mpack-1.6"  MPACKDIR="../tools/mpack-1.6"
720    HAVE_MPACK=
721  MPACK="$MPACKDIR/mpack"  MPACK="$MPACKDIR/mpack"
722  COMMAND="make output.txt"  COMMAND=
723  MAKE=make  if test "x$MAKE" = x ; then
724        MAKE=make
725    fi
726    if test "x$CC" = x ; then
727        CC=cc
728    fi
729    JOBS=
730  MPI=f  MPI=f
731    MULTI_THREAD=f
732    OUTDIR=
733    DELDIR=
734    
735    ADM=
736    
737    # Additional monitor types
738    PTRACERS_NUM="1 2 3 4 5"
739    
740    MATCH_CRIT=13
741    
742  echo -n "parsing options...  "  printf "parsing options...  "
743    
744  ac_prev=  ac_prev=
745  for ac_option ; do  for ac_option ; do
# Line 471  for ac_option ; do Line 773  for ac_option ; do
773          -tdir=* | --tdir=*)          -tdir=* | --tdir=*)
774              TESTDIRS=$ac_optarg ;;              TESTDIRS=$ac_optarg ;;
775    
776            -skipdir | --skipdir | -skd | --skd)
777                ac_prev=SKIPDIRS ;;
778            -skipdir=* | --skipdir=*)
779                SKIPDIRS=$ac_optarg ;;
780    
781          -bash | --bash | -b | --b)          -bash | --bash | -b | --b)
782              ac_prev=BASH ;;              ac_prev=BASH ;;
783          -bash=* | --bash=*)          -bash=* | --bash=*)
# Line 486  for ac_option ; do Line 793  for ac_option ; do
793          -make=* | --make=*)          -make=* | --make=*)
794              MAKE=$ac_optarg ;;              MAKE=$ac_optarg ;;
795    
796            -odir | --odir)
797                ac_prev=OUTDIR ;;
798            -odir=* | --odir=*)
799                OUTDIR=$ac_optarg ;;
800    
801            -ptracers | --ptracers | -ptr | --ptr)
802                ac_prev=PTRACERS_NUM ;;
803            -ptracers=* | --ptracers=* | -ptr=* | --ptr=*)
804                PTRACERS_NUM=$ac_optarg ;;
805    
806            -match | --match ) ac_prev=MATCH_CRIT ;;
807            -match=* | --match=* ) MATCH_CRIT=$ac_optarg ;;
808    
809            -j) ac_prev=JOBS ;;
810            -j=*) JOBS=$ac_optarg ;;
811    
812          -clean | --clean)          -clean | --clean)
813              CLEANUP=t ;;              CLEANUP=t ; DELDIR=t ;;
814    
815          -quick | --quick | -q | --q)          -quick | --quick | -q | --q)
816              QUICK=t ;;              QUICK=t ;;
# Line 498  for ac_option ; do Line 821  for ac_option ; do
821          -nodepend | --nodepend | -nd | --nd)          -nodepend | --nodepend | -nd | --nd)
822              NODEPEND=t ;;              NODEPEND=t ;;
823    
824            -postclean | --postclean | -pc | --pc)
825                POSTCLEAN=t ;;
826    
827          -mpi) MPI=t ;;          -mpi) MPI=t ;;
828    
829            -mth) MULTI_THREAD=t ;;
830    
831            -adm | -ad) ADM=t ;;
832    
833            -ieee) IEEE=true ;;
834            -noieee) IEEE= ;;
835    
836          -verbose) verbose=2 ;;          -verbose) verbose=2 ;;
837          -debug) debug=1 ;;          -debug) debug=1 ;;
838          -quiet) verbose=0 ;;          -quiet) verbose=0 ;;
839    
840            -deldir | -dd) DELDIR=t ;;
841    
842            -ts) TS=t;;
843    
844            -papis) PAPIS=t;;
845    
846            -pcls) PCL=t;;
847    
848          -*)          -*)
849              echo "Error: unrecognized option: "$ac_option              echo "Error: unrecognized option: "$ac_option
850              usage              usage
# Line 524  if test "x$QUICK" = xt ; then Line 866  if test "x$QUICK" = xt ; then
866  fi  fi
867    
868  if test "x$TESTDIRS" = x ; then  if test "x$TESTDIRS" = x ; then
869      TESTDIRS=`scandirs`      if test "x$ADM" = xt ; then
870            LIST=`scandirs results_ad`
871        else
872            LIST=`scandirs results`
873        fi
874    else
875        #- expand group of experiments:
876        LIST=" "
877        for xx in $TESTDIRS
878        do
879          case $xx in
880            'basic') LIST=${LIST}" aim.5l_cs hs94.128x64x5 ideal_2D_oce"
881                     LIST=${LIST}" lab_sea tutorial_baroclinic_gyre"
882                     LIST=${LIST}" tutorial_global_oce_latlon tutorial_plume_on_slope"
883                    ;;
884            'tutorials')
885                     LIST=${LIST}" "`ls | grep 'tutorial_'` ;;
886            *)       LIST=${LIST}" "$xx ;;
887          esac
888        done
889  fi  fi
890    #echo 'LIST='${LIST}'<'
891    #- skip dirs, remove duplicate and non-directory:
892    TESTDIRS=" "
893    count=0
894    for xx in $LIST
895    do
896        yy=`echo $SKIPDIRS | grep -c $xx`
897        if test $yy = 0 ; then
898            if test -d $xx ; then
899                yy=`echo $TESTDIRS | grep -c $xx`
900                if test $yy = 0 ; then TESTDIRS=${TESTDIRS}" "$xx ; fi
901            else count=1 ;
902                echo ""; echo -n " -- skip \"$xx\" (not a directory !)"
903            fi
904        else
905            if test $count = 1 ; then echo -n ", \"$xx\""
906            else count=1 ; echo "" ;  echo -n " skip: \"$xx\""
907            fi
908        fi
909    done
910    if test $count = 1 ; then echo "" ; echo -n " ... " ; fi
911    #echo 'TESTDIRS='${TESTDIRS}'<'
912    
913  if test "x$OPTFILE" = xNONE -a "x$MITGCM_OF" != x ; then  if test "x$OPTFILE" = xNONE -a "x$MITGCM_OF" != x ; then
914      OPTFILE=$MITGCM_OF      OPTFILE=$MITGCM_OF
915  fi  fi
916    
917  echo "OK"  if test "x$ADM" = xt ; then
918        EXECUTABLE="mitgcmuv_ad"
919        OUTPUTFILE="output_adm.txt"
920    else
921        EXECUTABLE="mitgcmuv"
922        OUTPUTFILE="output.txt"
923    fi
924    
925    if test "x$COMMAND" = x ; then
926        COMMAND="./$EXECUTABLE > $OUTPUTFILE"
927    fi
928    if test "x$MPI" = xt ; then
929        OUTPUTFILE="STDOUT.0000"
930    fi
931    
932    #echo "OK"
933    echo "OK (COMMAND= $COMMAND )"
934    
935  #  create the FORTRAN comparison code  #  create the FORTRAN comparison code
936  createcodelet  createcodelet
937    
938  #  build the mpack utility  #  build the mpack utility
939  build_mpack  if test "x$ADDRESSES" = xNONE -o "x$ADDRESSES" = x ; then
940        echo "skipping mpack build"
941    else
942        build_mpack
943    fi
944    
945  #  Create a uniquely named directory to store results  #  Create a uniquely named directory to store results
946  MACH=`hostname`  MACH=`hostname`
947  UNAMEA=`uname -a`  UNAMEA=`uname -a`
948  DATE=`date +%Y%m%d`  DATE=`date +%Y%m%d`
949  BASE=$MACH"_"$DATE"_"  BASE="tr_"$MACH"_"$DATE"_"
950    if test "x$OUTDIR" != x ; then
951        BASE="tr_"$OUTDIR"_"$DATE"_"
952    fi
953  DNUM=0  DNUM=0
954  DRESULTS="$BASE$DNUM"  DRESULTS="$BASE$DNUM"
955  while test -e $DRESULTS ; do  while test -e $DRESULTS ; do
# Line 553  done Line 959  done
959  mkdir $DRESULTS  mkdir $DRESULTS
960  RETVAL=$?  RETVAL=$?
961  if test "x$RETVAL" != x0 ; then  if test "x$RETVAL" != x0 ; then
962      echo "Error: can't create results directory \"./$DRESULTS\""      echo "ERROR: Can't create results directory \"./$DRESULTS\""
963      exit 1      exit 1
964  fi  fi
965  SUMMARY="$DRESULTS/summary.txt"  SUMMARY="$DRESULTS/summary.txt"
966  date > $SUMMARY  printf "Start time:  " >> $SUMMARY
967  cat << EOF >> $SUMMARY  start_date=`date`
968                  T           S           U           V  echo $start_date > $SUMMARY
 G D M    c        m  s        m  s        m  s        m  s  
 E p a R  g  m  m  e  .  m  m  e  .  m  m  e  .  m  m  e  .  
 N n k u  2  i  a  a  d  i  a  a  d  i  a  a  d  i  a  a  d  
 2 d e n  d  n  x  n  .  n  x  n  .  n  x  n  .  n  x  n  .  
   
 EOF  
   
 NDIR=0  
969    
970    of_path=
971  if test "x$OPTFILE" != xNONE ; then  if test "x$OPTFILE" != xNONE ; then
972      if test -r $OPTFILE ; then      if test -r $OPTFILE ; then
973          OPTFILE=`pwd`"/$OPTFILE"          # get the path
974            path=${OPTFILE%/*}
975            if test "x$path" = x ; then
976                of_path=`pwd`
977            else
978                of_path=`( cd $path > /dev/null 2>&1 ; pwd )`
979            fi
980            file=${OPTFILE##*/}
981            OPTFILE=$of_path/$file
982            cp $OPTFILE $DRESULTS
983            echo >> $SUMMARY
984            echo "  OPTFILE=$OPTFILE" >> $SUMMARY
985        else
986            echo | tee $SUMMARY
987            echo "ERROR: can't read OPTFILE=\"$OPTFILE\"" | tee $SUMMARY
988            exit 1
989      fi      fi
990    else
991        echo >> $SUMMARY
992        echo "No \"OPTFILE\" was explicitly specified by testreport," >> $SUMMARY
993        echo "   so the genmake default will be used." >> $SUMMARY
994  fi  fi
995  echo  echo
 echo "OPTFILE=$OPTFILE" >> $SUMMARY  
996  echo >> $SUMMARY  echo >> $SUMMARY
997    if test "x$ADM" = x ; then
998        if [ $MATCH_CRIT -lt 10 ] ;
999        then line_0="      "$MATCH_CRIT ;
1000        else line_0="     "$MATCH_CRIT ; fi
1001        line_0="   $line_0  ----T-----  ----S-----  ----U-----  ----V-----"
1002    #   line_0="            ----T-----  ----S-----  ----U-----  ----V-----"
1003        line_1="G D M    c        m  s        m  s        m  s        m  s"
1004        line_2="E p a R  g  m  m  e  .  m  m  e  .  m  m  e  .  m  m  e  ."
1005        line_3="N n k u  2  i  a  a  d  i  a  a  d  i  a  a  d  i  a  a  d"
1006        line_4="2 d e n  d  n  x  n  .  n  x  n  .  n  x  n  .  n  x  n  ."
1007        for ii in $PTRACERS_NUM ; do
1008            #  tst=`eval 'echo $HAVE_PTR0'$ii`
1009            #  if test "x$tst" = xt ; then
1010            line_0="$line_0  --PTR 0"$ii"--"
1011            line_1="$line_1        m  s"
1012            line_2="$line_2  m  m  e  ."
1013            line_3="$line_3  i  a  a  d"
1014            line_4="$line_4  n  x  n  ."
1015            #  fi
1016        done
1017        echo "$line_0" | tee -a $SUMMARY
1018        echo "$line_1" | tee -a $SUMMARY
1019        echo "$line_2" | tee -a $SUMMARY
1020        echo "$line_3" | tee -a $SUMMARY
1021        echo "$line_4" | tee -a $SUMMARY
1022        echo " "       | tee -a $SUMMARY
1023    else
1024        echo "ADJOINT=true" >> $SUMMARY
1025        echo >> $SUMMARY
1026        cat << EOF | tee -a $SUMMARY
1027    G D M    C  G
1028    E p a R  o  r
1029    N n k u  s  a
1030    2 d e n  t  d
1031    
1032    EOF
1033    fi
1034    
1035  #  ...and each test directory...  #  ...and each test directory...
1036  for dir in $TESTDIRS ; do  for dir in $TESTDIRS ; do
# Line 584  for dir in $TESTDIRS ; do Line 1038  for dir in $TESTDIRS ; do
1038      #  Cleanup only!      #  Cleanup only!
1039      if test "x$CLEANUP" = xt ; then      if test "x$CLEANUP" = xt ; then
1040          if test -r $dir/build/Makefile ; then          if test -r $dir/build/Makefile ; then
1041                echo '  ------  clean dir:' $dir/build
1042              ( cd $dir/build ; make CLEAN )              ( cd $dir/build ; make CLEAN )
1043          fi          fi
1044          if test -r $dir/input/Makefile ; then          if test -d $dir/run/CVS ; then
1045              ( cd $dir/input ; make CLEAN )              echo '  ------  clean dir:' $dir/run
1046                run_clean $dir/run
1047          fi          fi
1048            (
1049                cd $dir
1050                rm -rf tr_run.*
1051            )
1052          continue          continue
1053      fi      fi
1054    
1055      #  Verify that the testdir exists and contains previous      #  Verify that the testdir exists and contains previous
1056      #  results in the correct location--or skip this directory!      #  results in the correct location--or skip this directory!
1057      if test ! -r $dir"/results/output.txt" ; then      fout=
1058          echo "can't read \"$dir/results/output.txt\" -- skipping $dir"      if test "x$ADM" = x ; then
1059            fout=$dir"/results/output.txt"
1060        else
1061            fout=$dir"/results_ad/output_adm.txt"
1062        fi
1063        if test ! -r $fout ; then
1064            echo "can't read \"$fout\" -- skipping $dir"
1065          continue          continue
1066      fi      fi
1067        if test "x$ADM" = x ; then
1068            check_for_add_mon_output  $fout
1069        fi
1070    
1071      echo "-------------------------------------------------------------------------------"      # Check for additional types of monitor output
     echo  
     echo "Experiment:  $dir"  
     echo  
     unset genmake makedepend make run  
     results='-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --'  
1072    
1073      if [ -r $dir/build ]; then      builddir="build"
1074          seperatebuilddir=1      if test ! -d $dir/$builddir ; then mkdir $dir/$builddir ; fi
1075          builddir=build      rundir="run"
1076          rundir=build     #rundir=$builddir
1077          ( cd $dir/build; ln -sf ../input/* . )      if test ! -d $dir/$rundir ; then
1078      else          rundir=$builddir
         seperatebuilddir=0  
         builddir=input  
         rundir=input  
1079      fi      fi
1080            
1081      CODE_DIR=$dir/code      if test "x$ADM" = x ; then
1082            code_dir=code
1083            CODE_DIR=$dir/code
1084            input_dirs='input'
1085        else
1086            code_dir=code_ad
1087            CODE_DIR=$dir/code_ad
1088            input_dirs='input_ad input'
1089        fi
1090      BUILD_DIR=$dir/$builddir      BUILD_DIR=$dir/$builddir
     MPI_FILES="CPP_EEOPTIONS.h_mpi SIZE.h_mpi"  
     NOMPI_FILES="CPP_EEOPTIONS.h_nompi SIZE.h_nompi"  
1091    
1092      #  Is this an MPI run?      if test ! -r $CODE_DIR"/SIZE.h_mpi" -a "x$MPI" = "xt" ; then
1093      if test "x$MPI" = xt ; then          echo "can't find \"$CODE_DIR/SIZE.h_mpi\" -- skipping $dir"
1094          FILES=$MPI_FILES          continue
     else  
         FILES=$NOMPI_FILES  
1095      fi      fi
1096            if test ! -r $dir"/input/eedata.mth" -a "x$MULTI_THREAD" = "xt" ; then
1097      #  Check to see that we have the files          echo "can't find \"$dir/input/eedata.mth\" -- skipping $dir"
     have_files=t  
     for i in $FILES ; do  
         if test ! -r $CODE_DIR/$i ; then  
             echo "Warning: can't read file $CODE_DIR/$i"  
             have_files=f  
         fi  
     done  
     if test "x$have_files" != xt -a "x$MPI" = xt ; then  
         echo "Skipping $dir due to lack of input files (see above warning)"  
1098          continue          continue
1099      fi      fi
1100        
1101      #  If we have the $FILES and they differ, copy the $FILES to $BUILD_DIR      #  Check whether there are "extra runs" for this testdir
1102      if test "x$have_files" = xt ; then      extra_runs=
1103          for i in $FILES ; do      if test "x$ADM" = x ; then
1104              cmp $CODE_DIR/$i $BUILD_DIR/$i > /dev/null 2>&1          ex_run_dirs=`( cd $dir ; echo input.* )`
1105              RETVAL=$?          #echo "ex_run_dirs='$ex_run_dirs'"
1106              if test "x$RETVAL" != x0 ; then          for exd in $ex_run_dirs ; do
1107                  cp $CODE_DIR/$i $BUILD_DIR/$i              name=`echo $exd | sed -e 's/input.//g'`
1108                outf="$dir/results/output.$name.txt"
1109                if test -f $outf -a -r $outf ; then
1110                    if test "x$MULTI_THREAD" = "xt" ; then
1111                        if test -r $dir"/"$exd"/eedata.mth" ; then
1112                            extra_runs="$extra_runs $name"
1113                        #else echo $dir"/"$exd"/eedata.mth: not found"
1114                        fi
1115                    else
1116                        extra_runs="$extra_runs $name"
1117                    fi
1118              fi              fi
1119          done          done
1120      fi      fi
1121        
1122        echo "-------------------------------------------------------------------------------"
1123        echo
1124        if test "x$extra_runs" = "x" ; then
1125           echo "Experiment:  $dir"
1126        else
1127           echo "Experiment:  $dir ; extra_runs=$extra_runs"
1128        fi
1129        echo
1130        unset genmake makedepend make run
1131        results='-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --'
1132    
1133      #  Create an output dir for each OPTFILE/tdir combination      #  Create an output dir for each OPTFILE/tdir combination
1134      CDIR=$DRESULTS"/"$DRESULTS"_"$NDIR      rel_CDIR=$DRESULTS"/"$dir
1135      mkdir $CDIR      mkdir $rel_CDIR
1136      CDIR=`pwd`"/$CDIR"      CDIR=`pwd`"/$rel_CDIR"
1137            
1138      if test "x$CLEANUP" = xt ; then      if test "x$CLEANUP" = xt ; then
1139          makeclean $dir/$builddir          echo '====>>> this is to check that we never go through this part <<< ==='
1140            makeclean $dir/$builddir \
1141                && run_clean $dir/$rundir
1142      else      else
1143          genmakemodel $dir/$builddir && genmake=Y \          genmakemodel $dir/$builddir && genmake=Y \
1144              && makeclean $dir/$builddir \              && makeclean $dir/$builddir \
1145                && run_clean $dir/$rundir \
1146                && symlink_mpifiles $dir $code_dir $builddir \
1147              && makedependmodel $dir/$builddir && makedepend=Y \              && makedependmodel $dir/$builddir && makedepend=Y \
1148              && makemodel $dir/$builddir && make=Y \              && makemodel $dir/$builddir && make=Y \
1149              && linkdata $seperatebuilddir $dir/$rundir \              && linkdata $dir/$rundir $input_dirs \
1150              && runmodel $dir/$builddir && run=Y \              && runmodel $dir/$rundir && run=Y \
1151              && results=`testoutput $dir $rundir`              && results=`testoutput_run $dir $rundir "txt"`
1152      fi      fi
1153            
1154      echo      echo
1155      formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \      if test "x$ADM" = x ; then
1156          ${run:-N} $results          fres=`formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N} $results`
1157      echo          echo
1158      formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \          echo "$fres" >> $SUMMARY
1159          ${run:-N} $results >> $SUMMARY          echo "fresults='$fres'" > $CDIR"/summary.txt"
1160      echo "fresults='" > $CDIR"/summary.txt"          echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1161      formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \          echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1162          ${run:-N} $results >> $CDIR"/summary.txt"          echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1163      echo "'" >> $CDIR"/summary.txt"          echo "tdir='$dir'" >> $CDIR"/summary.txt"
1164      echo "MACH='$MACH'" >> $CDIR"/summary.txt"  
1165      echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"          for ex in $extra_runs ; do
1166      echo "DATE='$DATE'" >> $CDIR"/summary.txt"              unset run
1167      echo "tdir='$dir'" >> $CDIR"/summary.txt"              results='-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --'
1168                #  Create an output dir for each OPTFILE/tdir.ex combination
1169                rel_CDIR=$DRESULTS"/"$dir"."$ex
1170                mkdir $rel_CDIR
1171                CDIR=`pwd`"/$rel_CDIR"
1172                test ! -e "$dir/tr_run.$ex" && mkdir "$dir/tr_run.$ex"
1173                run_clean $dir/tr_run.$ex
1174                linkdata $dir/tr_run.$ex input.$ex input
1175                runmodel $dir/tr_run.$ex && run=Y \
1176                    && results=`testoutput_run $dir tr_run.$ex ${ex}".txt"`
1177                fres=`printf '%s %s %s %s' ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N}`
1178                fres=`formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N} $results`
1179                fres="$fres.$ex"
1180                echo
1181                echo "$fres" >> $SUMMARY
1182                echo "fresults='$fres'" > $CDIR"/summary.txt"
1183                echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1184                echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1185                echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1186                echo "tdir='$dir.$ex'" >> $CDIR"/summary.txt"
1187                if test "x$POSTCLEAN" = xt ; then
1188                    run_clean $dir/tr_run.$ex
1189                fi
1190            done
1191        else
1192            fres=`printf '%s %s %s %s' ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N}`
1193            fres=$fres"$results   $dir"
1194            echo
1195            echo "$fres" >> $SUMMARY
1196            echo "fresults='$fres'" > $CDIR"/summary.txt"
1197            echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1198            echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1199            echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1200            echo "tdir='$dir'" >> $CDIR"/summary.txt"
1201            grep -A3 'Seconds in section "ALL' $dir/$rundir/$OUTPUTFILE \
1202                               >> $CDIR"/summary.txt"
1203        fi
1204    
1205        #postclean $dir/$builddir
1206        if test "x$POSTCLEAN" = xt ; then
1207            makeclean $dir/$builddir \
1208                && run_clean $dir/$rundir
1209        fi
1210            
1211      (      echo "-------------------------------------------------------------------------------"
         cd $DRESULTS  
         tar -cf $NDIR".tar" $DRESULTS"_"$NDIR > /dev/null 2>&1  
         gzip $NDIR".tar"  
     )  
1212            
1213      if test "x$ADDRESSES" = xNONE -o "x$ADDRESSES" = x ; then  done
1214          echo "No mail sent"  
1215      else  printf "Start time:  " >> $SUMMARY
1216          $MPACK -s MITgcm-test -m 1000000 $DRESULTS"/"$NDIR".tar.gz" $ADDRESSES  echo $start_date >> $SUMMARY
1217    printf "End time:    " >> $SUMMARY
1218    date >> $SUMMARY
1219    
1220    #  If addresses were supplied and mpack built successfully, then try
1221    #  to send email using mpack.
1222    if test "x$ADDRESSES" = xNONE -o "x$ADDRESSES" = x ; then
1223        echo "No results email was sent."
1224    else
1225        if test "x$HAVE_MPACK" = xt ; then
1226            tar -cf $DRESULTS".tar" $DRESULTS > /dev/null 2>&1 \
1227                && gzip $DRESULTS".tar" \
1228                && $MPACK -s MITgcm-test -m 3555000 $DRESULTS".tar.gz" $ADDRESSES
1229          RETVAL=$?          RETVAL=$?
1230          if test "x$RETVAL" != x0 ; then          if test "x$RETVAL" != x0 ; then
1231              echo "Warning: \"$MPACK\" failed -- please contact <edhill@mitgcm.org>"              echo
1232                echo "Warning: The tar, gzip, & mpack step failed.  Please send email"
1233                echo "  to <MITgcm-support@mitgcm.org> for help.  You may copy the "
1234                echo "  summary of results from the directory \"$DRESULTS\"."
1235                echo
1236          else          else
1237              rm -f $DRESULTS"/"$NDIR".tar*"              echo
1238                echo "An email containing results was sent to the following addresses:"
1239                echo "  \"$ADDRESSES\""
1240                echo
1241          fi          fi
1242            test -f $DRESULTS".tar"  &&  rm -f $DRESULTS".tar"
1243            test -f $DRESULTS".tar.gz"  &&  rm -f $DRESULTS".tar.gz"
1244      fi      fi
1245    fi
1246    
1247      echo "-------------------------------------------------------------------------------"  rm -f tr_cmpnum.c tr_cmpnum
       
     NDIR=$(( $NDIR + 1 ))  
       
 done  
1248    
1249  rm tmp_cmpnum.f a.out  if test "x$CLEANUP" != xt ; then
1250        cat $SUMMARY | sed 's/ -- -- -- --//g'
1251        if test -e tr_out.txt ; then
1252            mv tr_out.txt tr_out.txt.old
1253        fi
1254        cat $SUMMARY | sed 's/ -- -- -- --//g' > tr_out.txt
1255    fi
1256    
1257  cat $SUMMARY  if test "x$DELDIR" = xt ; then
1258        rm -rf $DRESULTS
1259    fi
1260    
Legend:
Removed from v.1.9.2.8  
changed lines
  Added in v.1.93
  ViewVC Help
Powered by ViewVC 1.1.22