/[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.2 by edhill, Mon Sep 1 16:50:27 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 "  (-optfile=|-of=)STRING   list of genmake2 \"optfiles\""      echo "  (-mth)                   run multi threaded (using eedata.mth)"
15      echo "  (-a|-addr)STRING         list of email recipients"      echo "  (-mpi)                   compile and run using MPI"
16      echo "  (-t|-tdir)STRING         list of \"test\" dirs"      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\")"
21        echo "  (-t|-tdir) STRING        list of group and/or exp. dirs to test"
22        echo "                             (recognized groups: basic, tutorials)"
23        echo "                             (DEF=\"\" which test all)"
24        echo "  (-skd|-skipdir) STRING   list of exp. dirs to skip"
25        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\")"
32        echo "  (-m|-make) STRING        command to use for \"make\""
33        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\""
42        echo "  (-quick|-q)              same as \"-nogenmake -noclean -nodepend\""
43        echo "  (-nogenmake|-ng)         skip the genmake stage"
44        echo "  (-noclean|-nc)           skip the \"make clean\" stage"
45        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
51        echo "and where STRING can be a whitespace-delimited list"
52        echo "such as:"
53        echo
54        echo "  -t 'exp0 exp2 exp3' "
55        echo "  -addr='abc@123.com testing@home.org'"
56        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      echo
60      exit 1      exit 1
61  }  }
# Line 20  usage() Line 63  usage()
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()
98  {  {
99      # use codelet to compare lines      # testoutput_var dir s1 label subdir extension
     if [ $verbose -gt 1 ]; then  
         cat tmp3.txt 1>&2  
     fi  
     return `./a.out < tmp3.txt`  
 }  
   
 testoutput_for_prop()  
 {  
     # testoutput_for_prop dir s1 label subdir  
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 102  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 122  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()
300  {  {
301      # genmakemodel directory      # genmakemodel directory
302      GENMAKE2="../../../tools/genmake2"      if test "x$NOGENMAKE" = xt ; then
303      (          echo "genmake skipped!"
304          cd $1;      else
305          printf 'genmake ... ' 1>&2          if test "x$BASH" = x ; then
306          # ../../../tools/genmake -ieee -mods=../code > make.log 2>&1              GENMAKE2="../../../tools/genmake2"
         $GENMAKE2  -ds --mods=../code "--optfile="$OPTFILE > make.log 2>&1  
         RETVAL=$?  
         for i in gm_state gm_optfile gm_local Makefile ; do  
             if test -r $i ; then  
                 cp $i $CDIR  
             fi  
         done  
         if test "x$RETVAL" != x0 ; then  
             tail make.log  
             echo "genmakemodel: genmake failed" 1>&2  
             cp make.log $CDIR  
             return 1  
307          else          else
308              echo "succesful" 1>&2              GENMAKE2="$BASH ../../../tools/genmake2 -bash $BASH"
309          fi          fi
310      )          (
311                cd $1;
312                command="$GENMAKE2  -ds -m $MAKE"
313                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
319                    command="$command --optfile=$OPTFILE"
320                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
339                RETVAL=$?
340                #  Reduce the size of the testing emails!
341                head -100 Makefile > $CDIR/Makefile_head
342                if test "x$RETVAL" != x0 ; then
343                    tail make.log
344                    echo "genmakemodel: genmake failed" 1>&2
345                    cp genmake_* make.log $CDIR
346                    return 1
347                else
348                    echo "successful" 1>&2
349                fi
350            )
351        fi
352  }  }
353    
354  makeclean()  makeclean()
355  {  {
356      # makeclean directory      # makeclean directory
357      (      if test "x$NOCLEAN" = xt ; then
358          cd $1;          echo "make Clean skipped!"
359          rm -f output.txt      else
360          printf 'make CLEAN ... ' 2>&1          (
361          if test -r Makefile ; then              cd $1;
362              make CLEAN >> make.log 2>&1              #if test -e $OUTPUTFILE ; then rm -f $OUTPUTFILE ; fi
363              RETVAL=$?              if test -r Makefile ; then
364              if test "x$RETVAL" != x0 ; then                  printf 'clean build-dir: make Clean ... ' 2>&1
365                  tail make.log                  $MAKE Clean >> make.log 2>&1
366                  echo "makeclean: \"make CLEAN\" failed" 1>&2                  RETVAL=$?
367                  cp make.log $CDIR"/make.log"                  if test "x$RETVAL" != x0 ; then
368                  return 1                      tail make.log
369                        echo "makeclean: \"make Clean\" failed" 1>&2
370                        cp make.log $CDIR"/make.log"
371                        return 1
372                    fi
373              fi              fi
374          fi              echo successful 1>&2
375          echo succesful 1>&2              exit 0
376          exit 0          )
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
398            )
399        fi
400  }  }
401    
402  makedependmodel()  makedependmodel()
403  {  {
404      # makedependmodel directory      # makedependmodel directory
405      (      if test "x$NODEPEND" = xt ; then
406          cd $1;          echo "make depend skipped!"
407          printf 'make depend ... ' 1>&2      else
408          make depend >> make.log 2>&1          (
409          RETVAL=$?              cd $1;
410          if test "x$RETVAL" != x0 ; then              printf 'make depend ... ' 1>&2
411              tail make.log              $MAKE depend >> make.log 2>&1
412              echo "makedependmodel: make depend failed" 1>&2              RETVAL=$?
413              cp make.log $CDIR"/make.log"              if test "x$RETVAL" != x0 ; then
414              return 1                  tail make.log
415          else                  echo "makedependmodel: make depend failed" 1>&2
416              echo succesful 1>&2                  cp make.log $CDIR"/make.log"
417          fi                  return 1
418      )              else
419                    echo successful 1>&2
420                fi
421            )
422        fi
423  }  }
424    
425  makemodel()  makemodel()
# Line 231  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 239  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    
546  runmodel()  runmodel()
547  {  {
548      # runmodel directory exe      # runmodel directory
549      #      #
550      #  runs the model "exe" in "directory" (exe is relative to directory)      #  runs "$COMMAND in "directory"
551        #  (where "$COMMAND" is relative to "directory")
552      (      (
553          cd $1          cd $1
554          if [ -x $2 ]; then          printf 'runmodel in %s ...' $1 1>&2
555              if [ $quick -eq 0 ]; then          # make output.txt
556                  rm -f output.txt          echo
557              fi          if test ! -x $EXECUTABLE -a -x "../"$builddir"/"$EXECUTABLE ; then
558              printf 'runmodel: ' 1>&2              echo " link" $EXECUTABLE "from dir ../"$builddir > run.log_00
559              make output.txt              ln -sf "../"$builddir"/"$EXECUTABLE .
560              RETVAL=$?          fi
561              if test "x$RETVAL" = x0 ; then          if test ! -x $EXECUTABLE ; then
562                  cp output.txt $CDIR"/output.txt"                  rm -f run.log ; touch run.log
563                  return 0                  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              else
574                  return 1                  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              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
596            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
602          fi          fi
603      )      )
604  }  }
# Line 283  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" | tee          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 332  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 343  formatresults() Line 676  formatresults()
676            
677  }  }
678    
 show_help()  
 {  
     cat - << EOF  
 $0 [-help] [-quick] [-verbose] dir1 [dir2] [...]  
  -help      Show this help message  
  -quick     Skip "genmake" and "make depend" if the Makefile exists  
  -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
695  debug=0  debug=0
696  verbose=1  verbose=1
 quick=0  
697  clean=0  clean=0
 ieee=1  
698  expts=''  expts=''
699    # ieee=1
700    
701  OPTFILES=  IEEE=true
702  ADDRESSES=edhill@mitgcm.org  if test "x$MITGCM_IEEE" != x ; then
703        IEEE=$MITGCM_IEEE
704    fi
705    
706    
707    CLEANUP=f
708    QUICK=f
709    NOGENMAKE=f
710    NOCLEAN=f
711    NODEPEND=f
712    POSTCLEAN=f
713    
714    BASH=
715    OPTFILE=NONE
716    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=
723    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
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 414  for ac_option ; do Line 759  for ac_option ; do
759              usage ;;              usage ;;
760                    
761          -optfile | --optfile | -of | --of)          -optfile | --optfile | -of | --of)
762              ac_prev=OPTFILES ;;              ac_prev=OPTFILE ;;
763          -optfile=* | --optfile=* | -of=* | --of=*)          -optfile=* | --optfile=* | -of=* | --of=*)
764              OPTFILES=$ac_optarg ;;              OPTFILE=$ac_optarg ;;
765                    
766          -addr | --addr | -a | --a)          -addr | --addr | -a | --a)
767              ac_prev=ADDRESSES ;;              ac_prev=ADDRESSES ;;
# Line 428  for ac_option ; do Line 773  for ac_option ; do
773          -tdir=* | --tdir=*)          -tdir=* | --tdir=*)
774              TESTDIRS=$ac_optarg ;;              TESTDIRS=$ac_optarg ;;
775    
776          -quick) quick=1 ;;          -skipdir | --skipdir | -skd | --skd)
777                ac_prev=SKIPDIRS ;;
778            -skipdir=* | --skipdir=*)
779                SKIPDIRS=$ac_optarg ;;
780    
781            -bash | --bash | -b | --b)
782                ac_prev=BASH ;;
783            -bash=* | --bash=*)
784                BASH=$ac_optarg ;;
785    
786            -command | --command | -c | --c)
787                ac_prev=COMMAND ;;
788            -command=* | --command=*)
789                COMMAND=$ac_optarg ;;
790    
791            -make | --make | -m | --m)
792                ac_prev=MAKE ;;
793            -make=* | --make=*)
794                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)
813                CLEANUP=t ; DELDIR=t ;;
814    
815            -quick | --quick | -q | --q)
816                QUICK=t ;;
817            -nogenmake | --nogenmake | -ng | --ng)
818                NOGENMAKE=t ;;
819            -noclean | --noclean | -nc | --nc)
820                NOCLEAN=t ;;
821            -nodepend | --nodepend | -nd | --nd)
822                NODEPEND=t ;;
823    
824            -postclean | --postclean | -pc | --pc)
825                POSTCLEAN=t ;;
826    
827            -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 ;;
         -clean) clean=1 ;;  
         -noieee) ieee=0 ;;  
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 449  for ac_option ; do Line 859  for ac_option ; do
859            
860  done  done
861    
862    if test "x$QUICK" = xt ; then
863        NOGENMAKE=t
864        NOCLEAN=t
865        NODEPEND=t
866    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
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
914        OPTFILE=$MITGCM_OF
915    fi
916    
917    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  fi
931    
932  echo "OK"  #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 475  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
969  G D M    c        m  s        m  s        m  s        m  s  
970  E p a R  g  m  m  e  .  m  m  e  .  m  m  e  .  m  m  e  .  of_path=
971  N n k u  2  i  a  a  d  i  a  a  d  i  a  a  d  i  a  a  d  if test "x$OPTFILE" != xNONE ; then
972  2 d e n  d  n  x  n  .  n  x  n  .  n  x  n  .  n  x  n  .      if test -r $OPTFILE ; then
973            # 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
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
995    echo
996    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  EOF
1033    fi
1034    
1035  NDIR=0  #  ...and each test directory...
1036    for dir in $TESTDIRS ; do
1037        
1038        #  Cleanup only!
1039        if test "x$CLEANUP" = xt ; then
1040            if test -r $dir/build/Makefile ; then
1041                echo '  ------  clean dir:' $dir/build
1042                ( cd $dir/build ; make CLEAN )
1043            fi
1044            if test -d $dir/run/CVS ; then
1045                echo '  ------  clean dir:' $dir/run
1046                run_clean $dir/run
1047            fi
1048            (
1049                cd $dir
1050                rm -rf tr_run.*
1051            )
1052            continue
1053        fi
1054    
1055  #  For each optfile...      #  Verify that the testdir exists and contains previous
1056  for OPTFILE in $OPTFILES ; do      #  results in the correct location--or skip this directory!
1057        fout=
1058        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
1066        fi
1067        if test "x$ADM" = x ; then
1068            check_for_add_mon_output  $fout
1069        fi
1070    
1071      OPTFILE=`pwd`"/$OPTFILE"      # Check for additional types of monitor output
1072      if test ! -r $OPTFILE ; then  
1073          echo "Error: can't read optfile \"$OPTFILE\""      builddir="build"
1074          exit 1      if test ! -d $dir/$builddir ; then mkdir $dir/$builddir ; fi
1075        rundir="run"
1076       #rundir=$builddir
1077        if test ! -d $dir/$rundir ; then
1078            rundir=$builddir
1079      fi      fi
     echo  
     echo "OPTFILE=$OPTFILE" >> $SUMMARY  
     echo >> $SUMMARY  
1080            
1081      #  ...and each test directory...      if test "x$ADM" = x ; then
1082      for dir in $TESTDIRS ; do          code_dir=code
1083                    CODE_DIR=$dir/code
1084          #  Create an output dir for each OPTFILE/tdir combination          input_dirs='input'
1085          CDIR=$DRESULTS"/"$DRESULTS"_"$NDIR      else
1086          mkdir $CDIR          code_dir=code_ad
1087          CDIR=`pwd`"/$CDIR"          CODE_DIR=$dir/code_ad
1088            input_dirs='input_ad input'
1089        fi
1090        BUILD_DIR=$dir/$builddir
1091    
1092          #  ...configue, make, run, and compare the output.      if test ! -r $CODE_DIR"/SIZE.h_mpi" -a "x$MPI" = "xt" ; then
1093          echo "-------------------------------------------------------------------------------"          echo "can't find \"$CODE_DIR/SIZE.h_mpi\" -- skipping $dir"
1094          echo          continue
1095          echo "Experiment:  $dir"      fi
1096          echo      if test ! -r $dir"/input/eedata.mth" -a "x$MULTI_THREAD" = "xt" ; then
1097          unset genmake makedepend make run          echo "can't find \"$dir/input/eedata.mth\" -- skipping $dir"
1098          results='-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --'          continue
1099          ( cd $dir/input; rm -f *.{o,f,c,F} *.[f,F]90 work* output.txt Make* make.log; )      fi
         if [ -r $dir/build ]; then  
             seperatebuilddir=1  
             builddir=build  
             rundir=build  
             ( cd $dir/build; ln -sf ../input/* . )  
         else  
             seperatebuilddir=0  
             builddir=input  
             rundir=input  
         fi  
1100    
1101          #  Verify that the testdir exists and contains previous      #  Check whether there are "extra runs" for this testdir
1102          #  results in the correct location--or skip this directory!      extra_runs=
1103          if test ! -r $dir"/results/output.txt" ; then      if test "x$ADM" = x ; then
1104              echo | tee $SUMMARY          ex_run_dirs=`( cd $dir ; echo input.* )`
1105              echo "can't read \"$dir/results/output.txt\" -- skipping $dir" \          #echo "ex_run_dirs='$ex_run_dirs'"
1106                  | tee $SUMMARY          for exd in $ex_run_dirs ; do
1107              continue              name=`echo $exd | sed -e 's/input.//g'`
1108          fi              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
1119            done
1120        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
1134        rel_CDIR=$DRESULTS"/"$dir
1135        mkdir $rel_CDIR
1136        CDIR=`pwd`"/$rel_CDIR"
1137        
1138        if test "x$CLEANUP" = xt ; then
1139            echo '====>>> this is to check that we never go through this part <<< ==='
1140            makeclean $dir/$builddir \
1141                && run_clean $dir/$rundir
1142        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 mitgcmuv && run=Y \              && runmodel $dir/$rundir && run=Y \
1151              && results=`testoutput $dir $rundir`              && results=`testoutput_run $dir $rundir "txt"`
1152        fi
1153        
1154        echo
1155        if test "x$ADM" = x ; then
1156            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          echo "fresults='$fres'" > $CDIR"/summary.txt"
1160            echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1161            echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1162            echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1163            echo "tdir='$dir'" >> $CDIR"/summary.txt"
1164    
1165            for ex in $extra_runs ; do
1166                unset run
1167                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          echo
1195          formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \          echo "$fres" >> $SUMMARY
1196              ${run:-N} $results >> $SUMMARY          echo "fresults='$fres'" > $CDIR"/summary.txt"
         echo "fresults='" > $CDIR"/summary.txt"  
         formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \  
             ${run:-N} $results >> $CDIR"/summary.txt"  
         echo "'" >> $CDIR"/summary.txt"  
1197          echo "MACH='$MACH'" >> $CDIR"/summary.txt"          echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1198          echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"          echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1199          echo "DATE='$DATE'" >> $CDIR"/summary.txt"          echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1200          echo "tdir='$dir'" >> $CDIR"/summary.txt"          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              cd $DRESULTS      if test "x$POSTCLEAN" = xt ; then
1207              tar -cf $NDIR".tar" $DRESULTS"_"$NDIR > /dev/null 2>&1          makeclean $dir/$builddir \
1208              gzip $NDIR".tar"              && run_clean $dir/$rundir
1209          )      fi
1210        
1211        echo "-------------------------------------------------------------------------------"
1212        
1213    done
1214    
1215          $MPACK -s MITgcm-test -m 1000000 $DRESULTS"/"$NDIR".tar.gz" $ADDRESSES  printf "Start time:  " >> $SUMMARY
1216    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
1245    fi
1246    
1247          NDIR=$(( $NDIR + 1 ))  rm -f tr_cmpnum.c tr_cmpnum
           
     done  
 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.2  
changed lines
  Added in v.1.93

  ViewVC Help
Powered by ViewVC 1.1.22