/[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.4 by edhill, Wed Sep 3 20:02:47 2003 UTC revision 1.117 by jmc, Tue Aug 19 18:29:12 2008 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 "  (-b|-bash)STRING         location of \"bash\" executable"      echo "                             (DEF=\"-ieee\")"
18        echo "  (-gsl)                   compile with \"-gsl\" flag"
19        echo "  (-of=|-optfile=)STRING   list of optfiles to use"
20        echo "  (-a|-addr) STRING        list of email recipients"
21        echo "                             (DEF=\"\" no email is sent)"
22        echo "  (-mpd|-mpackdir) DIR     location of the mpack utility"
23        echo "                             (DEF=\"../tools/mpack-1.6\")"
24        echo "  (-t|-tdir) STRING        list of group and/or exp. dirs to test"
25        echo "                             (recognized groups: basic, tutorials)"
26        echo "                             (DEF=\"\" which test all)"
27        echo "  (-skd|-skipdir) STRING   list of exp. dirs to skip"
28        echo "                             (DEF=\"\" which test all)"
29        echo "  (-b|-bash) STRING        preferred location of a \"bash\" or"
30        echo "                             Bourne-compatible \"sh\" shell"
31        echo "                             (DEF=\"\" for \"bash\")"
32        echo "  (-adm|-ad)               perform an adjoint run"
33        echo "  (-command) STRING        command to run"
34        echo "                             (DEF=\"make output.txt\")"
35        echo "  (-m|-make) STRING        command to use for \"make\""
36        echo "                             (DEF=\"make\")"
37        echo "  (-odir) STRING           used to build output directory name"
38        echo "                             (DEF=\"hostname\")"
39        echo "  (-ptr|-ptracers) STRING  specify which ptracers to test"
40        echo "                             (DEF=\"1 2 3 4 5\")"
41        echo "  (-match) NUMBER          Matching Criteria (number of digits)"
42        echo "                             (DEF=\"12\")"
43        echo "  (-j) JOBS                use \"make -j JOBS\" for parallel builds"
44        echo "  (-clean)                 *ONLY* run \"make CLEAN\""
45        echo "  (-quick|-q)              same as \"-nogenmake -noclean -nodepend\""
46        echo "  (-nogenmake|-ng)         skip the genmake stage"
47        echo "  (-noclean|-nc)           skip the \"make clean\" stage"
48        echo "  (-nodepend|-nd)          skip the \"make depend\" stage"
49        echo "  (-deldir|-dd)            on success, delete the output directory"
50        echo "  (-ts)                    provide timing information per timestep"
51        echo "  (-papis)                 provide MFlop/s per timestep using PAPI"
52        echo "  (-pcls)                  provide MFlop/s per timestep using PCL"
53        echo
54        echo "and where STRING can be a whitespace-delimited list"
55        echo "such as:"
56        echo
57        echo "  -t 'exp0 exp2 exp3' "
58        echo "  -addr='abc@123.com testing@home.org'"
59        echo
60        echo "provided that the expression is properly quoted within the current"
61        echo "shell (note the use of single quotes to protect white space)."
62      echo      echo
63      exit 1      exit 1
64  }  }
# Line 21  usage() Line 66  usage()
66  #  build the mpack utility  #  build the mpack utility
67  build_mpack()  build_mpack()
68  {  {
69      echo -n "building the mpack utility...  "      printf "building the mpack utility...  "
70      if test ! -x "$MPACKDIR/mpack" ; then      MPACK="$MPACKDIR/mpack"
71        if test ! -x $MPACK ; then
72          if test ! -d $MPACKDIR ; then          if test ! -d $MPACKDIR ; then
73                echo
74              echo "Error: can't find \"$MPACKDIR\""              echo "Error: can't find \"$MPACKDIR\""
75              echo "  are you sure this program is being run in the correct "              echo "  are you sure this program is being run in the correct "
76              echo "  (that is, \"MITGCM_ROOT\verification\") directory?"              echo "  (that is, \"MITGCM_ROOT\verification\") directory?"
77              exit 1              echo
78                HAVE_MPACK=f
79            fi
80            if test "x$CC" = x ; then
81                export CC=cc
82          fi          fi
83          echo -n "building mpack...  "          printf "building mpack (using CC=$CC)...  "
84          ( cd $MPACKDIR && ./configure && make ) > build_mpack.out 2>&1          ( cd $MPACKDIR && ./configure && $MAKE ) > tr_build_mpack.out 2>&1
85          RETVAL=$?          RETVAL=$?
86          if test "x$RETVAL" != x0 ; then          if test "x$RETVAL" != x0 ; then
87              echo              echo
88              echo "Error building the mpack tools at: $MPACK_DIR"              echo "Error building the mpack tools at: $MPACK_DIR"
89              exit 1              echo
90                HAVE_MPACK=f
91            else
92                rm -f tr_build_mpack.out
93                HAVE_MPACK=t
94                echo "done"
95          fi          fi
96        else
97            HAVE_MPACK=t
98            echo "already exist"
99      fi      fi
     echo "OK"  
 }  
   
 compare_lines()  
 {  
     # use codelet to compare lines  
     if [ $verbose -gt 1 ]; then  
         cat tmp3.txt 1>&2  
     fi  
     return `./a.out < tmp3.txt`  
100  }  }
101    
102  testoutput_for_prop()  testoutput_var()
103  {  {
104      # testoutput_for_prop dir s1 label subdir      # testoutput_var dir s1 label subdir reference_output
105      #      #
106      #  compares files in $dir/$subdir/output.txt and $dir/results/output.txt      #  compares 1 variable output selected from file $dir/$subdir/$OUTPUTFILE
107      #  using search strings s1 and text label      #     with same output from reference file $dir/results/$reference_output
108        #  using search strings s1 and text label
109    
110      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
111          echo testoutput_for_prop: grep "$2" $1/$4/output.txt 1>&2          echo testoutput_var: grep "$2" $1/$4/$OUTPUTFILE 1>&2
112      fi      fi
113      if [ -r $1/$4/output.txt ]; then      if [ -r $1/$4/$OUTPUTFILE ]; then
114          grep "$2" $1/$4/output.txt | sed 's/.*=//' | nl > tmp1.txt          grep "$2" $1/$4/$OUTPUTFILE | sed 's/.*=//' | cat -n > tmp1.txt
115          lncnt=`wc -l tmp1.txt | awk '{print $1}' `          lncntA=`wc -l tmp1.txt | awk '{print $1}' `
116          if [ $lncnt -lt 3 ]; then          if [ $lncntA -lt 2 ]; then
117              if [ $verbose -gt 0 ]; then              if [ $verbose -gt 0 ]; then
118                  echo Not enough lines of output when searching for "$2" 1>&2                  echo Not enough lines of output when searching for "$2" 1>&2
119              fi              fi
120              return 99              return 99
121          fi          fi
122      else      else
123          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
124          return 99          return 99
125      fi      fi
126      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
127          echo testoutput_for_prop: grep "$2" $1/results/output.txt 1>&2          echo testoutput_var: grep "$2" $1/results/$5 1>&2
128      fi      fi
129      grep "$2" $1/results/output.txt | sed 's/.*=//' | nl > tmp2.txt      grep "$2" $1/results/$5 | sed 's/.*=//' | cat -n > tmp2.txt
130      lncnt=`wc -l tmp2.txt | awk '{print $1}' `      lncntB=`wc -l tmp2.txt | awk '{print $1}' `
131      if [ $lncnt -lt 3 ]; then      if [ $lncntB -lt 2 ]; then
132          if [ $verbose -gt 0 ]; then          if [ $verbose -gt 0 ]; then
133              echo Not enough lines of output when searching for "$2" 1>&2              echo Not enough lines of output when searching for "$2" 1>&2
134          fi          fi
135          return 99          return 99
136      fi      fi
137        if [ $lncntA -ne $lncntB ]; then
138            if [ $verbose -gt 0 ]; then
139                echo Not same Nb of lines when searching for "$2" ":" $lncntA $lncntB 1>&2
140            fi
141            return 99
142        fi
143        has_nan=`cat tmp1.txt | grep -i nan | wc -l`
144        if [ $has_nan -gt 0  ] ; then
145            echo testoutput_var: $OUTPUTFILE contains $has_nan NaN values  1>&2
146            return 99
147        fi
148        has_inf=`cat tmp1.txt | grep -i inf | wc -l`
149        if [ $has_inf -gt 0  ] ; then
150            echo testoutput_var: $OUTPUTFILE contains $has_inf Inf values  1>&2
151            return 99
152        fi
153      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
154          echo testoutput_for_prop: join tmp1.txt tmp2.txt 1>&2          echo testoutput_var: join tmp1.txt tmp2.txt 1>&2
155      fi      fi
156      join tmp1.txt tmp2.txt | awk '{print $1 " " $2 " " $3}' > tmp3.txt      join tmp1.txt tmp2.txt | awk '{print $1 " " $2 " " $3}' > tmp3.txt
157      if [ $debug -gt 0 ]; then      if [ $debug -gt 0 ]; then
158          echo testoutput_for_prop: compare_lines 1>&2          echo testoutput_var: compare_lines 1>&2
159      fi      fi
160      compare_lines      if [ $verbose -gt 1 ]; then
161      digits_of_similarity=$?          cat tmp3.txt 1>&2
162        fi
163        echo "-1" >> tmp3.txt
164        # On the SGI O3K (*not* the O2K), "cat -n" inserts a ":" after the line number
165        cat tmp3.txt | sed -e 's|:||g' > tmp4.txt
166        digits_of_similarity=`./tr_cmpnum < tmp4.txt`
167      if [ $digits_of_similarity -eq 99 ]; then      if [ $digits_of_similarity -eq 99 ]; then
168          if [ $verbose -gt 0 ]; then          if [ $verbose -gt 0 ]; then
169              echo testoutput_for_prop: No comparison was available for \"$2\" 1>&2              echo testoutput_var: No comparison was available for \"$3\" 1>&2
170          fi          fi
171          digits_of_similarity=99          digits_of_similarity=99
172      else      else
173          if [ $verbose -gt 0 ]; then          if [ $verbose -gt 0 ]; then
174              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 \"$3\" 1>&2
175          fi          fi
176      fi      fi
177      rm tmp1.txt tmp2.txt tmp3.txt      rm -f tmp1.txt tmp2.txt tmp3.txt tmp4.txt
178            
179      return $digits_of_similarity      return $digits_of_similarity
180  }  }
181    
182  dashnum()  testoutput_run()
183  {  {
184      # dashnum n1 n2 n3 ...      # testoutput_run directory subdir reference_output
185      #      #
186      #  print numbers using %3i format or "--" if number = 99      #  test output from 1 run in "directory"
187    # --> same processing for adjoint & forward test
188            # default list of output variables to be checked:
189            #  1rst : main variable used to decide if it pass or FAIL
190            #  others : number of matching digits to be printed in summary.txt
191            listChk=$DEF_CHECK_LIST
192            #  load experiment-specific list from file "tr_checklist" (if it exist)
193            if test -r $1/$2/tr_checklist ; then listChk=`cat $1/$2/tr_checklist` ; fi
194            sVar=`echo $listChk | awk '{print $1}'`
195            # remove 1rst var and expand the list: + => min max mean s.d
196            listVar=`echo $listChk | sed 's/ [a-zA-Z0-9]*+/&mn &mx &av &sd/g' \
197                                   | sed 's/+//g' | sed "s/^$sVar//"`
198            if [ $debug -gt 0 ]; then echo "testoutput_run: listVar(I)='$listVar'" 1>&2 ; fi
199            # check for ptracer output in reference_output file :
200            outpref=$1/results/$3
201            ptr_mon="trcstat_ptracerXX_min trcstat_ptracerXX_max"
202            ptr_mon="$ptr_mon trcstat_ptracerXX_mean trcstat_ptracerXX_sd"
203            for ii in $PTRACERS_NUM ; do
204                ptrfound=0
205                for jj in $ptr_mon ; do
206                    name=`eval "echo $jj | sed -e 's|XX|0"$ii"|g'"`
207                    tst=`grep $name $outpref | wc -l | awk '{print $1}'`
208                    if test ! "x$tst" = x0 ; then ptrfound=1 ; fi
209                done
210                if test $ptrfound = '1' ; then
211                    eval "HAVE_PTR0"$ii"=t"
212                else
213                    eval "HAVE_PTR0"$ii"=f"
214                  if test "x$ADM" = x ; then
215                  # remove this ptr from the list of output variable to check
216                  # echo "-- ptr test=" $tst "number of var=" `echo $listVar | awk '{print NF}'` 1>&2
217                    listVar=`echo "$listVar" | sed "s/ pt$ii..//g"`
218                  fi
219                fi
220            #   eval 'echo "HAVE_PTR0'$ii' = $HAVE_PTR0'$ii'"' 1>&2
221            done
222            tst=`echo $sVar $listVar | awk '{ for(i=2;i<=NF;i++){if($i==$1)t+=1}; print t }'`
223            if test $tst != 1 ; then
224              if test $tst = 0 ; then echo "==> WARNING: selected var >$sVar< not found" 1>&2
225                     else echo "==> WARNING: found selected var >$sVar< $tst times" 1>&2 ; fi
226              echo "==> WARNING: in checked list:" $listVar 1>&2
227            #- put it back once:
228              listVar=" $sVar "`echo "$listVar " | sed "s/ $sVar / /g"`
229            fi
230            if [ $debug -gt 0 ]; then echo "testoutput_run: listVar(M)='$listVar'" 1>&2 ; fi
231            echo "listVar='$listVar'" > $CDIR"/summary.txt"
232            allargs=""
233            for xx in $listVar
234            do
235              case $xx in
236               'PS')  if [ $debug -gt 0 ]
237                      then echo testoutput_run: testoutput_var $1 cg2d_init_res 1>&2 ; fi
238                      testoutput_var $1 "cg2d_init_res" "Press. Solver (cg2d)" $2 $3; yy=$?
239                      if [ $debug -gt 0 ] ; then echo testoutput_run: cg2dres=$yy 1>&2 ; fi ;;
240              'Cost') testoutput_var $1 "ADM  precision_derivative_cost" "ADM Cost" $2 $3; yy=$? ;;
241              'Grad') testoutput_var $1 "ADM  precision_derivative_grad" "ADM Grad" $2 $3; yy=$? ;;
242               'Tmn') testoutput_var $1 "dynstat_theta_min"  "Theta minimum"  $2 $3; yy=$? ;;
243               'Tmx') testoutput_var $1 "dynstat_theta_max"  "Theta maximum"  $2 $3; yy=$? ;;
244               'Tav') testoutput_var $1 "dynstat_theta_mean" "Theta mean"     $2 $3; yy=$? ;;
245               'Tsd') testoutput_var $1 "dynstat_theta_sd"   "Theta Std.Dev"  $2 $3; yy=$? ;;
246               'Smn') testoutput_var $1 "dynstat_salt_min"  "Salt minimum"    $2 $3; yy=$? ;;
247               'Smx') testoutput_var $1 "dynstat_salt_max"  "Salt maximum"    $2 $3; yy=$? ;;
248               'Sav') testoutput_var $1 "dynstat_salt_mean" "Salt mean"       $2 $3; yy=$? ;;
249               'Ssd') testoutput_var $1 "dynstat_salt_sd"   "Salt Std.Dev"    $2 $3; yy=$? ;;
250               'Umn') testoutput_var $1 "dynstat_uvel_min"  "U minimum"       $2 $3; yy=$? ;;
251               'Umx') testoutput_var $1 "dynstat_uvel_max"  "U maximum"       $2 $3; yy=$? ;;
252               'Uav') testoutput_var $1 "dynstat_uvel_mean" "U mean"          $2 $3; yy=$? ;;
253               'Usd') testoutput_var $1 "dynstat_uvel_sd"   "U Std.Dev"       $2 $3; yy=$? ;;
254               'Vmn') testoutput_var $1 "dynstat_vvel_min"  "V minimum"       $2 $3; yy=$? ;;
255               'Vmx') testoutput_var $1 "dynstat_vvel_max"  "V maximum"       $2 $3; yy=$? ;;
256               'Vav') testoutput_var $1 "dynstat_vvel_mean" "V mean"          $2 $3; yy=$? ;;
257               'Vsd') testoutput_var $1 "dynstat_vvel_sd"   "V Std.Dev"       $2 $3; yy=$? ;;
258            'pt1mn'|'pt2mn'|'pt3mn'|'pt4mn'|'pt5mn') ii=`echo $xx | sed 's/pt//' | sed 's/..$//'`
259               testoutput_var $1 "trcstat_ptracer0"$ii"_min"  "p0"$ii"_min"   $2 $3; yy=$? ;;
260            'pt1mx'|'pt2mx'|'pt3mx'|'pt4mx'|'pt5mx') ii=`echo $xx | sed 's/pt//' | sed 's/..$//'`
261               testoutput_var $1 "trcstat_ptracer0"$ii"_max"  "p0"$ii"_max"   $2 $3; yy=$? ;;
262            'pt1av'|'pt2av'|'pt3av'|'pt4av'|'pt5av') ii=`echo $xx | sed 's/pt//' | sed 's/..$//'`
263               testoutput_var $1 "trcstat_ptracer0"$ii"_mean" "p0"$ii"_mean" $2 $3; yy=$? ;;
264            'pt1sd'|'pt2sd'|'pt3sd'|'pt4sd'|'pt5sd') ii=`echo $xx | sed 's/pt//' | sed 's/..$//'`
265               testoutput_var $1 "trcstat_ptracer0"$ii"_sd"   "p0"$ii"_StDv"  $2 $3; yy=$? ;;
266             'Qntmn') testoutput_var $1 "extforcing_qnet_min" "Qnet minimum"  $2 $3; yy=$? ;;
267             'Qntmx') testoutput_var $1 "extforcing_qnet_max" "Qnet maximum"  $2 $3; yy=$? ;;
268             'Qntav') testoutput_var $1 "extforcing_qnet_mean" "Qnet mean"    $2 $3; yy=$? ;;
269             'Qntsd') testoutput_var $1 "extforcing_qnet_sd"  "Qnet Std.Dev"  $2 $3; yy=$? ;;
270             'aSImn') testoutput_var $1 "seaice_area_min"   "SIce Area min"   $2 $3; yy=$? ;;
271             'aSImx') testoutput_var $1 "seaice_area_max"   "SIce Area max"   $2 $3; yy=$? ;;
272             'aSIav') testoutput_var $1 "seaice_area_mean"  "SIce Area mean"  $2 $3; yy=$? ;;
273             'aSIsd') testoutput_var $1 "seaice_area_sd"    "SIce Area StDv"  $2 $3; yy=$? ;;
274             'hSImn') testoutput_var $1 "seaice_heff_min"   "SIce Heff min"   $2 $3; yy=$? ;;
275             'hSImx') testoutput_var $1 "seaice_heff_max"   "SIce Hell max"   $2 $3; yy=$? ;;
276             'hSIav') testoutput_var $1 "seaice_heff_mean"  "SIce Hell mean"  $2 $3; yy=$? ;;
277             'hSIsd') testoutput_var $1 "seaice_heff_sd"    "SIce Hell StDv"  $2 $3; yy=$? ;;
278            'AthSiG') testoutput_var $1 "thSI_Ice_Area_G" "thSIc Area Global" $2 $3; yy=$? ;;
279            'AthSiS') testoutput_var $1 "thSI_Ice_Area_S" "thSIc Area South"  $2 $3; yy=$? ;;
280            'AthSiN') testoutput_var $1 "thSI_Ice_Area_N" "thSIc Area North"  $2 $3; yy=$? ;;
281            'HthSiG') testoutput_var $1 "thSI_IceH_ave_G" "thSIc H Global"    $2 $3; yy=$? ;;
282            'HthSiS') testoutput_var $1 "thSI_IceH_ave_S" "thSIc H South"     $2 $3; yy=$? ;;
283            'HthSiN') testoutput_var $1 "thSI_IceH_ave_N" "thSIc H North"     $2 $3; yy=$? ;;
284                  *) yy=99; echo "WARNING: asking for var=$xx : not recognized !" 1>&2 ;;
285              esac
286              if test $xx = $sVar
287              then allargs="$allargs > $yy <"
288              else allargs="$allargs $yy"
289              fi
290            done
291    
292            nbVar=`echo $listVar | awk '{print NF}'`
293            if [ $nbVar -lt $LEN_CHECK_LIST ] ; then
294            #-- fill line (up to standard length) with dot:
295              adNul=`expr $LEN_CHECK_LIST - $nbVar | awk '{for(i=1;i<=$1;i++){print "."}}'`
296              echo $allargs $adNul
297            else
298              echo $allargs
299            fi
300    # <-- same processing for adjoint & forward test
301    }
302    
303      for num in $@ ; do  genmakemodel()
304          if [ $num = 99 ]; then  {
305              printf ' --'      # genmakemodel directory
306        if test "x$NOGENMAKE" = xt ; then
307            echo "genmake skipped!"
308        else
309            if test "x$BASH" = x ; then
310                GENMAKE2="../../../tools/genmake2"
311          else          else
312              printf '%3i' $num              GENMAKE2="$BASH ../../../tools/genmake2 -bash $BASH"
313          fi          fi
314      done          (
315                cd $1;
316                command="$GENMAKE2  -ds -m $MAKE"
317                if test "x$ADM" = x ; then
318                    command="$command --mods=../code"
319                else
320                    command="$command --mods=../code_ad"
321                fi
322                if test "x$OPTFILE" != xNONE ; then
323                    command="$command --optfile=$OPTFILE"
324                fi
325                if test "x$IEEE" != x ; then
326                    command="$command -ieee"
327                fi
328                if test "x$GSL" = xt ; then
329                    command="$command -gsl"
330                fi
331                if test "x$MPI" = xt ; then
332                    command="$command -mpi"
333                fi
334                if test "x$TS" = xt ; then
335                    command="$command -ts"
336                fi
337                if test "x$PAPIS" = xt ; then
338                    command="$command -papis"
339                else
340                if test "x$PCLS" = xt ; then
341                    command="$command -pcls"
342                fi
343                fi
344                printf 'genmake ... ' 1>&2
345                $command > make.log 2>&1
346                RETVAL=$?
347                #  Reduce the size of the testing emails!
348                head -100 Makefile > $CDIR/Makefile_head
349                if test "x$RETVAL" != x0 ; then
350                    tail make.log
351                    echo "genmakemodel: genmake failed" 1>&2
352                    cp genmake_* make.log $CDIR
353                    return 1
354                else
355                    echo "successful" 1>&2
356                fi
357            )
358        fi
359  }  }
360    
361  testoutput()  makeclean()
362  {  {
363      # testoutput diretory subdir      # makeclean directory
364      #      if test "x$NOCLEAN" = xt ; then
365      #  test output in "directory"          echo "make Clean skipped!"
366        else
367      if [ $debug -gt 0 ]; then          (
368          echo testoutput: testoutput_for_prop $1 cg2d_init_res 1>&2              cd $1;
369      fi              #if test -e $OUTPUTFILE ; then rm -f $OUTPUTFILE ; fi
370      testoutput_for_prop $1 "cg2d_init_res" "cg2d init. residual" $2; cg2dres=$?              if test -r Makefile ; then
371      if [ $debug -gt 0 ]; then                  printf 'clean build-dir: make Clean ... ' 2>&1
372          echo testoutput: cg2dres=$cg2dres 1>&2                  $MAKE Clean >> make.log 2>&1
373                    RETVAL=$?
374                    if test "x$RETVAL" != x0 ; then
375                        tail make.log
376                        echo "makeclean: \"make Clean\" failed" 1>&2
377                        cp make.log $CDIR"/make.log"
378                        return 1
379                    fi
380                fi
381                echo successful 1>&2
382                exit 0
383            )
384      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  
385  }  }
386    
387  genmakemodel()  run_clean()
388  {  {
389      # genmakemodel directory      # run_clean directory
390      GENMAKE2="$BASH ../../../tools/genmake2"      if test "x$NOCLEAN" = xt ; then
391      (          echo "run_clean skipped!"
392          cd $1;      else
393          printf 'genmake ... ' 1>&2          (
394          # ../../../tools/genmake -ieee -mods=../code > make.log 2>&1              cd $1;
395          $GENMAKE2  -ds --mods=../code "--optfile="$OPTFILE > make.log 2>&1              printf 'clean run-dir ... ' 2>&1
396          RETVAL=$?              # part of what is done after "make clean" when doing "make CLEAN"
397          for i in gm_state gm_optfile gm_local Makefile ; do              find . -name "*.meta" -exec rm {} \;
398              if test -r $i ; then              find . -name "*.data" -exec rm {} \;
399                  cp $i $CDIR              find . -name "fort.*" -exec rm {} \;
400              fi              find . -type l -exec rm {} \;
401          done              rm -f $EXECUTABLE *.txt STD* *diagnostics.log datetime
402          if test "x$RETVAL" != x0 ; then              rm -rf mnc_test_*
403              tail make.log              rm -f *_MIT_CE_000.opt0000 costfunction*0000
404              echo "genmakemodel: genmake failed" 1>&2              echo successful 1>&2
405              cp make.log $CDIR              exit 0
406              return 1          )
407          else      fi
             echo "succesful" 1>&2  
         fi  
     )  
408  }  }
409    
410  makeclean()  makedependmodel()
411  {  {
412      # makeclean directory      # makedependmodel directory
413      (      if test "x$NODEPEND" = xt ; then
414          cd $1;          echo "make depend skipped!"
415          rm -f output.txt      else
416          printf 'make CLEAN ... ' 2>&1          (
417          if test -r Makefile ; then              cd $1;
418              make CLEAN >> make.log 2>&1              printf 'make depend ... ' 1>&2
419                $MAKE depend >> make.log 2>&1
420              RETVAL=$?              RETVAL=$?
421              if test "x$RETVAL" != x0 ; then              if test "x$RETVAL" != x0 ; then
422                  tail make.log                  tail make.log
423                  echo "makeclean: \"make CLEAN\" failed" 1>&2                  echo "makedependmodel: make depend failed" 1>&2
424                  cp make.log $CDIR"/make.log"                  cp make.log $CDIR"/make.log"
425                  return 1                  return 1
426                else
427                    echo successful 1>&2
428              fi              fi
429          fi          )
430          echo succesful 1>&2      fi
         exit 0  
     )  
 }  
   
 makedependmodel()  
 {  
     # makedependmodel directory  
     (  
         cd $1;  
         printf 'make depend ... ' 1>&2  
         make depend >> make.log 2>&1  
         RETVAL=$?  
         if test "x$RETVAL" != x0 ; then  
             tail make.log  
             echo "makedependmodel: make depend failed" 1>&2  
             cp make.log $CDIR"/make.log"  
             return 1  
         else  
             echo succesful 1>&2  
         fi  
     )  
431  }  }
432    
433  makemodel()  makemodel()
# Line 232  makemodel() Line 437  makemodel()
437          cd $1;          cd $1;
438          if test -r Makefile ; then          if test -r Makefile ; then
439              printf 'make ... ' 1>&2              printf 'make ... ' 1>&2
440              make >> make.log 2>&1              if test "x$ADM" = x ; then
441                    if test "x$JOBS" = x ; then
442                        $MAKE >> make.log 2>&1
443                    else
444                        $MAKE -j $JOBS >> make.log 2>&1
445                    fi
446                else
447                    $MAKE adall >> make.log 2>&1
448                fi
449              RETVAL=$?              RETVAL=$?
450              if test "x$RETVAL" != x0 ; then              if test "x$RETVAL" != x0 ; then
451                  tail make.log                  tail make.log
# Line 240  makemodel() Line 453  makemodel()
453                  cp make.log $CDIR"/make.log"                  cp make.log $CDIR"/make.log"
454                  return 1                  return 1
455              else              else
456                  echo succesful 1>&2                  echo successful 1>&2
457              fi              fi
458          fi          fi
459      )      )
460  }  }
461    
462    symlink_mpifiles()
463    {
464        # Put special links so that MPI specific files are used
465        # This MUST be invoked between makeclean and makelinks because
466        # the Makefile will link to non-mpi files by default
467    
468        dir=$1
469        code_dir=$2
470        BUILD_DIR=$dir/$3
471        CODE_DIR=$dir/$code_dir
472        
473        # These are files that should replace their counter-part when using -mpi
474        MPI_FILES=`(cd $CODE_DIR; find . -name "*_mpi" -print)`
475    
476        #  Is this an MPI run?
477        if test "x$MPI" = xt ; then
478            # YES: We symbolically link these files to the build
479            # dir so long as there is no real file in place
480            for ii in $MPI_FILES ; do
481                i=`echo $ii | sed 's:^\./::'`
482                name=`echo $i | sed 's:_mpi::' `
483                cmp $CODE_DIR/$i $BUILD_DIR/$name > /dev/null 2>&1
484                RETVAL=$?
485                if test "x$RETVAL" != x0 ; then
486                    if ! test -f $BUILD_DIR/$i ; then
487                        #echo Linking $name to $i
488                        (cd $BUILD_DIR; ln -sf ../$code_dir/$i $name)
489                    fi
490                fi
491            done
492        else
493            # NO: We undo any _mpi symbolically linked files
494            for ii in $MPI_FILES ; do
495                i=`echo $ii | sed 's:^\./::'`
496                name=`echo $i | sed 's:_mpi::' `
497                if test -L $BUILD_DIR/$name ; then
498                    cmp $BUILD_DIR/$name "../$code_dir/$name"_mpi > /dev/null 2>&1
499                    RETVAL=$?
500                    if test "x$RETVAL" = x0 ; then
501                        #echo Un-linking $name from $linktarg
502                        rm -f $BUILD_DIR/$name
503                    fi
504                fi
505            done
506        fi
507        
508    }
509    
510  linkdata()  linkdata()
511  {  {
512      # linkdata flag      # linkdata run_dir input_dir_1 input_dir_2 ...
513      #      #
514      # symbolically link data files to run directory      # symbolically link data files to run directory
515      if [ $1 -ne 0 ]; then      if test -d $1 ; then
516          ( cd $2 ;  ln -sf ../input/* . )          (
517                cd $1 ; shift
518                if test -r "../"$1"/eedata.mth" ; then
519                # found eedata.mth in 1rst input dir and it is readable
520                    if test "x$MULTI_THREAD" = "xt" ; then
521                    # multi-threaded test: remove symbolic link & link eedata.mth
522                        if test -h eedata ; then rm -f eedata ; fi
523                        if test ! -r eedata ; then
524                            ln -sf "../"$1"/eedata.mth" eedata ;
525                            printf 'eedata.mth ' 1>&2
526                        fi
527                    else
528                    # not multi-threaded test: remove eedata symbolic link
529                        if test -h eedata ; then rm -f eedata ; fi
530                    fi
531                fi
532                prevDir='NONE'
533                for ldir in $* ; do
534                    if test -d "../"$ldir -a $ldir != $prevDir ; then
535                        printf 'ldir='${ldir} 1>&2
536                        files=`( cd "../"$ldir ; ls -1 | grep -v CVS )`
537                        for i in $files ; do
538                            if test ! -d "../"$ldir/$i ; then
539                                if test ! -r $i  ; then
540                                    printf ' '$i 1>&2
541                                    ln -sf "../"$ldir"/"$i $i
542                                fi
543                            fi
544                        done
545                        if test -x "../"$ldir"/"prepare_run ; then
546                            "../"$ldir"/"prepare_run
547                        fi
548                        printf ' ; ' 1>&2
549                    fi
550                    prevDir=$ldir
551                done
552            )
553      fi      fi
554  }  }
555    
556  runmodel()  runmodel()
557  {  {
558      # runmodel directory exe      # runmodel directory
559      #      #
560      #  runs the model "exe" in "directory" (exe is relative to directory)      #  runs "$COMMAND in "directory"
561        #  (where "$COMMAND" is relative to "directory")
562      (      (
563          cd $1          cd $1
564          if [ -x $2 ]; then          printf 'runmodel in %s ...' $1 1>&2
565              if [ $quick -eq 0 ]; then          # make output.txt
566                  rm -f output.txt          echo
567              fi          if test -L $EXECUTABLE -a -x "../"$builddir"/"$EXECUTABLE ; then
568              printf 'runmodel: ' 1>&2              diff -q $EXECUTABLE "../"$builddir"/"$EXECUTABLE > /dev/null 2>&1
569              make output.txt              outD=$? ; if test $outD != 0 ; then rm -f $EXECUTABLE ; rm -f run.log ; fi
570              RETVAL=$?          fi
571              if test "x$RETVAL" = x0 ; then          if test ! -x $EXECUTABLE -a -x "../"$builddir"/"$EXECUTABLE ; then
572                  cp output.txt $CDIR"/output.txt"              echo " link" $EXECUTABLE "from dir ../"$builddir > run.log_00
573                  return 0              ln -sf "../"$builddir"/"$EXECUTABLE .
574            fi
575            if test ! -x $EXECUTABLE ; then
576                    rm -f run.log ; touch run.log
577                    if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
578                    echo " no executable:" $EXECUTABLE >> run.log
579                    RETVAL=8
580                    ENDVAL=-1
581            else
582                if test ! -f $OUTPUTFILE -o $OUTPUTFILE -ot $EXECUTABLE ; then
583                  # output do not exist or is older than executable:
584                    rm -f run.log ; touch run.log
585                    if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
586                    ( eval $COMMAND ) >> run.log 2>&1
587                    RETVAL=$?
588              else              else
589                  return 1                  RETVAL=0
590                    if test -f run.log ; then
591                        if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
592                        echo "---------->> $OUTPUTFILE is up to date " >> run.log 2>&1
593                    else
594                        touch run.log
595                        if test -f run.log_00 ; then cat run.log_00 >> run.log ; fi
596                        echo "---------->> $OUTPUTFILE is up to date " >> run.log 2>&1
597                        echo " no previous run.log: assume NORMAL END" >> run.log 2>&1
598                    fi
599              fi              fi
600                ENDVAL=`cat run.log | grep -v 'ABNORMAL END' | grep -c 'NORMAL END'`
601            fi
602            rm -f run.log_00
603            #if test "x$RETVAL" = x0 ; then
604            if [ $RETVAL -eq 0 -a $ENDVAL -gt 0 ] ; then
605                tail run.log
606                echo successful 1>&2
607                # === Reduce the size of the testing emails!
608                #cp $OUTPUTFILE $CDIR"/"$OUTPUTFILE
609                if test -s STDERR.0000 ; then cp STDERR.0000 $CDIR"/STDERR.0000" ; fi
610                return 0
611            else
612                tail run.log
613                echo failed '(run:' $RETVAL ' end:' $ENDVAL ')' 1>&2
614                cp run.log $CDIR"/run.log"
615                if test -s STDERR.0000 ; then cp STDERR.0000 $CDIR"/STDERR.0000" ; fi
616                return 1
617          fi          fi
618      )      )
619  }  }
# Line 284  createcodelet() Line 622  createcodelet()
622  {  {
623      # create codelet for comparing model output      # create codelet for comparing model output
624    
625      echo -n "creating the comparison code...  "      printf "creating the comparison code (using CC=$CC)...  "
626      cat > tmp_cmpnum.f <<EOFA      cat > tr_cmpnum.c <<EOF
627        program cmpnum  #include <stdio.h>
628        implicit none  #include <math.h>
629        real*8 a,b,diff  int main( int argc, char** argv )  {
630        integer linnum,best    int linnum,cmplin,best,lncnt;
631        best=-16    double a,b,abave,relerr;
632    99  read(*,*,end=70,err=60) linnum,a,b    best = -22;
633        diff=0.5*(abs(a)+abs(b))    lncnt = 0;
634  c     print *,a,b,diff,abs(a-b)/diff    while( 1 & ( (lncnt+=1) < 999 ) )  {
635        if (diff.gt.1.e-12) then      scanf("%d", &linnum);
636          diff=abs(a-b)/diff      if (linnum == -1)  break;
637          if (diff.gt.0.) then      scanf("%lf", &a);  scanf("%lf", &b);
638  c         print *,int(log10(diff)),diff      abave = 0.5*(fabs(a)+fabs(b));
639            linnum=int(log10(diff))      if ( abave == abave ) {
640            best=max(best,linnum)        if (abave > 0.0) {
641          endif          relerr=fabs(a-b)/abave;
642        else          if (relerr > 0.0) { cmplin = (int)rint(log10(relerr)); }
643          if (best.eq.-16.and.diff.ne.0.) best=-22          else { cmplin = -16 ; }
644        endif          best = (best > cmplin) ? best : cmplin; }
645        goto 99        else { cmplin = -22 ; }
646    60  stop 'cmpnum: An error occured reading a,b'     /* printf("%d ; %lf ; %lf\n",cmplin,a,b); */
647    70  print *,-best        }
648        end     else {
649  EOFA     /* printf("%lf ; %lf ; %lf\n",abave,a,b); */
650          break; }
651      }
652      if (lncnt == 999) best=-29;
653      if (linnum != -1) best=-99;
654      printf("%d\n", -best);
655      return 0;
656    }
657    EOF
658        $CC -o tr_cmpnum tr_cmpnum.c -lm
659    
660      f77 tmp_cmpnum.f      if [ -x ./tr_cmpnum ]; then
     if [ -x ./a.out ]; then  
661          echo "OK"          echo "OK"
662          return 0          return 0
663      else      else
664          echo          echo
665          echo "createcodelet: failed to compile codelet"          echo "ERROR: failed to compile comparison code -- please specify"
666            echo "  a C compiler using the CC environment variable."
667          exit 1          exit 1
668      fi      fi
669  }  }
# Line 328  formatresults() Line 675  formatresults()
675      nm=$1      nm=$1
676      printf '%s %s %s %s' $2 $3 $4 $5      printf '%s %s %s %s' $2 $3 $4 $5
677      shift; shift; shift; shift; shift;      shift; shift; shift; shift; shift;
678      printf '%3s' $@      listPrt=$@
679        listRes=`echo $listPrt | sed 's/>//' | sed 's/<//'`
680        xx=`echo $listPrt | sed 's/.*>//' | sed 's/<.*//' | awk '{print $1}'`
681        printf '%3s' $listPrt
682    #   line below does not work on hp-ux_ia64 : do those substitutions later on
683    #   printf '%3s' $listPrt | sed 's/ 99/ --/g' | sed 's/  > />/' | sed 's/  < /</'
684            
685      if [ $1 = '--' ]; then      if [ $xx = '..' ]; then
686            printf ' N/O '
687        elif [ $xx = '--' ]; then
688            printf ' N/O '
689        elif [ $xx = 99 ]; then
690          printf ' N/O '          printf ' N/O '
691      else      else
692          if [ $1 -gt 12 ]; then          if [ $xx -ge $MATCH_CRIT ]; then
693              printf ' pass'              printf ' pass'
694          else          else
695              printf ' FAIL'              printf ' FAIL'
# Line 344  formatresults() Line 700  formatresults()
700            
701  }  }
702    
 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  
 }  
   
703  scandirs()  scandirs()
704  {  {
705      if [ $# -eq 0 ]; then      if [ $# -eq 1 ]; then
706          for arg in * ; do          for arg in * ; do
707              test -d $arg/input && echo $arg              test -f $arg/$1 && echo $arg
708          done          done
709      else      else
710          echo $*          echo $*
711      fi      fi
712  }  }
713    
714    
715  ###############################################################################  ###############################################################################
 ###############################################################################  
 ###############################################################################  
716    
717    
718  #  Default properties  #  Default properties
719  debug=0  debug=0
720  verbose=1  verbose=1
 quick=0  
721  clean=0  clean=0
722  ieee=1  
723  expts=''  IEEE=true
724    if test "x$MITGCM_IEEE" != x ; then
725        IEEE=$MITGCM_IEEE
726    fi
727    GSL=f
728    
729    CLEANUP=f
730    QUICK=f
731    NOGENMAKE=f
732    NOCLEAN=f
733    NODEPEND=f
734    POSTCLEAN=f
735    
736  BASH=  BASH=
737  OPTFILES=  OPTFILE=NONE
738  ADDRESSES=edhill@mitgcm.org  ADDRESSES=
739  TESTDIRS=  TESTDIRS=
740    SKIPDIRS=
741  MPACKDIR="../tools/mpack-1.6"  MPACKDIR="../tools/mpack-1.6"
742  MPACK="$MPACKDIR/mpack"  HAVE_MPACK=
743    MPACK=
744    COMMAND=
745    if test "x$MAKE" = x ; then
746        MAKE=make
747    fi
748    if test "x$CC" = x ; then
749        CC=cc
750    fi
751    JOBS=
752    MPI=f
753    MULTI_THREAD=f
754    OUTDIR=
755    DELDIR=
756    
757    ADM=
758    
759    # list of pTracers to check for monitor output
760    PTRACERS_NUM="1 2 3 4 5"
761    
762  echo -n "parsing options...  "  MATCH_CRIT=13
763    
764    printf "parsing options...  "
765    
766  ac_prev=  ac_prev=
767  for ac_option ; do  for ac_option ; do
# Line 416  for ac_option ; do Line 781  for ac_option ; do
781              usage ;;              usage ;;
782                    
783          -optfile | --optfile | -of | --of)          -optfile | --optfile | -of | --of)
784              ac_prev=OPTFILES ;;              ac_prev=OPTFILE ;;
785          -optfile=* | --optfile=* | -of=* | --of=*)          -optfile=* | --optfile=* | -of=* | --of=*)
786              OPTFILES=$ac_optarg ;;              OPTFILE=$ac_optarg ;;
787                    
788          -addr | --addr | -a | --a)          -addr | --addr | -a | --a)
789              ac_prev=ADDRESSES ;;              ac_prev=ADDRESSES ;;
790          -addr=* | --addr=*)          -addr=* | --addr=*)
791              ADDRESSES=$ac_optarg ;;              ADDRESSES=$ac_optarg ;;
792            -mpackdir | --mpackdir | -mpd | --mpd)
793                ac_prev=MPACKDIR ;;
794            -mpackdir=* | --mpackdir=* | -mpd=* | --mpd=*)
795                MPACKDIR=$ac_optarg ;;
796    
797          -tdir | --tdir | -t | --t)          -tdir | --tdir | -t | --t)
798              ac_prev=TESTDIRS ;;              ac_prev=TESTDIRS ;;
799          -tdir=* | --tdir=*)          -tdir=* | --tdir=*)
800              TESTDIRS=$ac_optarg ;;              TESTDIRS=$ac_optarg ;;
801    
802            -skipdir | --skipdir | -skd | --skd)
803                ac_prev=SKIPDIRS ;;
804            -skipdir=* | --skipdir=*)
805                SKIPDIRS=$ac_optarg ;;
806    
807          -bash | --bash | -b | --b)          -bash | --bash | -b | --b)
808              ac_prev=BASH ;;              ac_prev=BASH ;;
809          -bash=* | --bash=*)          -bash=* | --bash=*)
810              BASH=$ac_optarg ;;              BASH=$ac_optarg ;;
811    
812          -quick) quick=1 ;;          -command | --command | -c | --c)
813                ac_prev=COMMAND ;;
814            -command=* | --command=*)
815                COMMAND=$ac_optarg ;;
816    
817            -make | --make | -m | --m)
818                ac_prev=MAKE ;;
819            -make=* | --make=*)
820                MAKE=$ac_optarg ;;
821    
822            -odir | --odir)
823                ac_prev=OUTDIR ;;
824            -odir=* | --odir=*)
825                OUTDIR=$ac_optarg ;;
826    
827            -ptracers | --ptracers | -ptr | --ptr)
828                ac_prev=PTRACERS_NUM ;;
829            -ptracers=* | --ptracers=* | -ptr=* | --ptr=*)
830                PTRACERS_NUM=$ac_optarg ;;
831    
832            -match | --match ) ac_prev=MATCH_CRIT ;;
833            -match=* | --match=* ) MATCH_CRIT=$ac_optarg ;;
834    
835            -j) ac_prev=JOBS ;;
836            -j=*) JOBS=$ac_optarg ;;
837    
838            -clean | --clean)
839                CLEANUP=t ; DELDIR=t ;;
840    
841            -quick | --quick | -q | --q)
842                QUICK=t ;;
843            -nogenmake | --nogenmake | -ng | --ng)
844                NOGENMAKE=t ;;
845            -noclean | --noclean | -nc | --nc)
846                NOCLEAN=t ;;
847            -nodepend | --nodepend | -nd | --nd)
848                NODEPEND=t ;;
849    
850            -postclean | --postclean | -pc | --pc)
851                POSTCLEAN=t ;;
852    
853            -mpi) MPI=t ;;
854    
855            -mth) MULTI_THREAD=t ;;
856    
857            -adm | -ad) ADM=t ;;
858    
859            -ieee) IEEE=true ;;
860            -noieee) IEEE= ;;
861            -gsl) GSL=t ;;
862    
863          -verbose) verbose=2 ;;          -verbose) verbose=2 ;;
864          -debug) debug=1 ;;          -debug) debug=1 ;;
         -clean) clean=1 ;;  
         -noieee) ieee=0 ;;  
865          -quiet) verbose=0 ;;          -quiet) verbose=0 ;;
866    
867            -deldir | -dd) DELDIR=t ;;
868    
869            -ts) TS=t;;
870    
871            -papis) PAPIS=t;;
872    
873            -pcls) PCL=t;;
874    
875          -*)          -*)
876              echo "Error: unrecognized option: "$ac_option              echo "Error: unrecognized option: "$ac_option
877              usage              usage
# Line 456  for ac_option ; do Line 886  for ac_option ; do
886            
887  done  done
888    
889    if test "x$QUICK" = xt ; then
890        NOGENMAKE=t
891        NOCLEAN=t
892        NODEPEND=t
893    fi
894    
895    #- setting for forward or ADM testing
896    if test "x$ADM" = xt ; then
897        code_dir=code_ad
898        inputdir=input_ad
899        ref_outp="output_adm.txt"
900        EXECUTABLE="mitgcmuv_ad"
901    else
902        code_dir=code
903        inputdir=input
904        ref_outp="output.txt"
905        EXECUTABLE="mitgcmuv"
906    fi
907    
908  if test "x$TESTDIRS" = x ; then  if test "x$TESTDIRS" = x ; then
909      TESTDIRS=`scandirs`      LIST=`scandirs results/$ref_outp`
910    else
911        #- expand group of experiments:
912        LIST=" "
913        for xx in $TESTDIRS
914        do
915          case $xx in
916            'basic') LIST=${LIST}" aim.5l_cs hs94.128x64x5 ideal_2D_oce"
917                     LIST=${LIST}" lab_sea tutorial_baroclinic_gyre"
918                     LIST=${LIST}" tutorial_global_oce_latlon tutorial_plume_on_slope"
919                    ;;
920            'tutorials')
921                     LIST=${LIST}" "`ls | grep 'tutorial_'` ;;
922            *)       LIST=${LIST}" "$xx ;;
923          esac
924        done
925    fi
926    #echo 'LIST='${LIST}'<'
927    #- skip dirs, remove duplicate and non-directory:
928    TESTDIRS=" "
929    count=0
930    for xx in $LIST
931    do
932        yy=`echo $SKIPDIRS | grep -c $xx`
933        if test $yy = 0 ; then
934            if test -d $xx ; then
935                yy=`echo $TESTDIRS | grep -c $xx`
936                if test $yy = 0 ; then TESTDIRS=${TESTDIRS}" "$xx ; fi
937            else count=1 ;
938                echo ""; echo -n " -- skip \"$xx\" (not a directory !)"
939            fi
940        else
941            if test $count = 1 ; then echo -n ", \"$xx\""
942            else count=1 ; echo "" ;  echo -n " skip: \"$xx\""
943            fi
944        fi
945    done
946    if test $count = 1 ; then echo "" ; echo -n " ... " ; fi
947    #echo 'TESTDIRS='${TESTDIRS}'<'
948    
949    if test "x$OPTFILE" = xNONE -a "x$MITGCM_OF" != x ; then
950        OPTFILE=$MITGCM_OF
951    fi
952    
953    OUTPUTFILE=$ref_outp
954    if test "x$COMMAND" = x ; then
955        COMMAND="./$EXECUTABLE > $OUTPUTFILE"
956  fi  fi
957    if test "x$MPI" = xt ; then
958        OUTPUTFILE="STDOUT.0000"
959    fi
960    
961    echo "OK (COMMAND= $COMMAND )"
962    
963  echo "OK"  # set the Default List of output variables to be checked:
964    #  (use default or load experiment-specific list from file "tr_checklist")
965    # content : 1rst = main variable used to decide if it pass or FAIL
966    #         others = number of matching digits to be printed in summary.txt
967    if test "x$ADM" = x ; then
968        DEF_CHECK_LIST='PS PS T+ S+ U+ V+ pt1+ pt2+ pt3+ pt4+ pt5+'
969        EMPTY_RESULTS='.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..'
970        LEN_CHECK_LIST=`echo $DEF_CHECK_LIST | sed 's/ [a-zA-Z0-9]*+/&mn &mx &av &sd/g' | awk '{print NF-1}'`
971        ii=`echo $EMPTY_RESULTS | awk '{print NF}'`
972        EMPTY_RESULTS=$EMPTY_RESULTS`expr $LEN_CHECK_LIST - $ii | awk 'BEGIN{FS=":"}{for(i=1;i<=$1;i++){printf "  ."}}'`
973    else
974        DEF_CHECK_LIST='Grad Cost Grad'
975        EMPTY_RESULTS='.. ..'
976        LEN_CHECK_LIST=`echo $DEF_CHECK_LIST | sed 's/ [a-zA-Z0-9]*+/&mn &mx &av &sd/g' | awk '{print NF-1}'`
977    fi
978    
979  #  create the FORTRAN comparison code  #  create the FORTRAN comparison code
980  createcodelet  createcodelet
981    
982  #  build the mpack utility  #  build the mpack utility (if ADDRESSES = NONE, do it to test the build)
983  build_mpack  if test "x$ADDRESSES" = x ; then
984        echo "skipping mpack build"
985    else
986        build_mpack
987    fi
988    
989  #  Create a uniquely named directory to store results  #  Create a uniquely named directory to store results
990    CMDLINE=$0
991    for xx in "$@" ; do CMDLINE="$CMDLINE '$xx'" ; done
992  MACH=`hostname`  MACH=`hostname`
993  UNAMEA=`uname -a`  UNAMEA=`uname -a`
994  DATE=`date +%Y%m%d`  DATE=`date +%Y%m%d`
995  BASE=$MACH"_"$DATE"_"  BASE="tr_"$MACH"_"$DATE"_"
996    if test "x$OUTDIR" != x ; then
997        BASE="tr_"$OUTDIR"_"$DATE"_"
998    fi
999  DNUM=0  DNUM=0
1000  DRESULTS="$BASE$DNUM"  DRESULTS="$BASE$DNUM"
1001  while test -e $DRESULTS ; do  while test -e $DRESULTS ; do
# Line 482  done Line 1005  done
1005  mkdir $DRESULTS  mkdir $DRESULTS
1006  RETVAL=$?  RETVAL=$?
1007  if test "x$RETVAL" != x0 ; then  if test "x$RETVAL" != x0 ; then
1008      echo "Error: can't create results directory \"./$DRESULTS\""      echo "ERROR: Can't create results directory \"./$DRESULTS\""
1009      exit 1      exit 1
1010  fi  fi
1011  SUMMARY="$DRESULTS/summary.txt"  SUMMARY="$DRESULTS/summary.txt"
1012  date > $SUMMARY  start_date=`date`
1013  cat << EOF >> $SUMMARY  echo $start_date > $SUMMARY
1014                  T           S           U           V  echo 'run:' $CMDLINE >> $SUMMARY
1015  G D M    c        m  s        m  s        m  s        m  s  echo 'on :' $UNAMEA  >> $SUMMARY
1016  E p a R  g  m  m  e  .  m  m  e  .  m  m  e  .  m  m  e  .  
1017  N n k u  2  i  a  a  d  i  a  a  d  i  a  a  d  i  a  a  d  of_path=
1018  2 d e n  d  n  x  n  .  n  x  n  .  n  x  n  .  n  x  n  .  if test "x$OPTFILE" != xNONE ; then
1019        if test -r $OPTFILE ; then
1020            # get the path
1021            path=${OPTFILE%/*}
1022            if test "x$path" = x ; then
1023                of_path=`pwd`
1024            else
1025                of_path=`( cd $path > /dev/null 2>&1 ; pwd )`
1026            fi
1027            file=${OPTFILE##*/}
1028            OPTFILE=$of_path/$file
1029            cp $OPTFILE $DRESULTS
1030            echo >> $SUMMARY
1031            echo "  OPTFILE=$OPTFILE" >> $SUMMARY
1032        else
1033            echo | tee $SUMMARY
1034            echo "ERROR: can't read OPTFILE=\"$OPTFILE\"" | tee $SUMMARY
1035            exit 1
1036        fi
1037    else
1038        echo >> $SUMMARY
1039        echo "No \"OPTFILE\" was explicitly specified by testreport," >> $SUMMARY
1040        echo "   so the genmake default will be used." >> $SUMMARY
1041    fi
1042    echo
1043    echo >> $SUMMARY
1044    if test "x$ADM" = x ; then
1045        if [ $MATCH_CRIT -lt 10 ] ;
1046        then line_0="default  "$MATCH_CRIT ;
1047        else line_0="default "$MATCH_CRIT ; fi
1048           line_0="$line_0  ----T-----  ----S-----  ----U-----  ----V-----"
1049    #   line_0="            ----T-----  ----S-----  ----U-----  ----V-----"
1050        line_1="G D M    c        m  s        m  s        m  s        m  s"
1051        line_2="E p a R  g  m  m  e  .  m  m  e  .  m  m  e  .  m  m  e  ."
1052        line_3="N n k u  2  i  a  a  d  i  a  a  d  i  a  a  d  i  a  a  d"
1053        line_4="2 d e n  d  n  x  n  .  n  x  n  .  n  x  n  .  n  x  n  ."
1054        for ii in $PTRACERS_NUM ; do
1055            line_0="$line_0  --PTR 0"$ii"--"
1056            line_1="$line_1        m  s"
1057            line_2="$line_2  m  m  e  ."
1058            line_3="$line_3  i  a  a  d"
1059            line_4="$line_4  n  x  n  ."
1060        done
1061        echo "$line_0" | tee -a $SUMMARY
1062        echo "$line_1" | tee -a $SUMMARY
1063        echo "$line_2" | tee -a $SUMMARY
1064        echo "$line_3" | tee -a $SUMMARY
1065        echo "$line_4" | tee -a $SUMMARY
1066        echo " "       | tee -a $SUMMARY
1067    else
1068        echo "ADJOINT=true" >> $SUMMARY
1069        echo >> $SUMMARY
1070        if [ $MATCH_CRIT -lt 10 ] ;
1071        then line_0="default     "$MATCH_CRIT ;
1072        else line_0="default    "$MATCH_CRIT ; fi
1073        echo "$line_0" | tee -a $SUMMARY
1074        cat << EOF | tee -a $SUMMARY
1075    G D M    C  G
1076    E p a R  o  r
1077    N n k u  s  a
1078    2 d e n  t  d
1079    
1080  EOF  EOF
1081    fi
1082    
1083  NDIR=0  #  ...and each test directory...
1084    for dir in $TESTDIRS ; do
1085        
1086        # set builddir & rundir:
1087        builddir="build"
1088        if test ! -d $dir/$builddir ; then mkdir $dir/$builddir ; fi
1089        rundir="run"
1090        if test ! -d $dir/$rundir ; then
1091            rundir=$builddir
1092        fi
1093        CODE_DIR=$dir/$code_dir
1094        BUILD_DIR=$dir/$builddir
1095    
1096  #  For each optfile...      #  Cleanup only!
1097  for OPTFILE in $OPTFILES ; do      if test "x$CLEANUP" = xt ; then
1098            if test -r $BUILD_DIR/Makefile ; then
1099                echo '  ------  clean dir:' $dir/$builddir
1100                ( cd $BUILD_DIR ; make CLEAN )
1101            fi
1102            if test -d $dir/$rundir/CVS ; then
1103                echo '  ------  clean dir:' $dir/$rundir
1104                run_clean $dir/$rundir
1105            fi
1106            (
1107                cd $dir
1108                rm -rf tr_run.*
1109            )
1110            continue
1111        fi
1112    
1113      OPTFILE=`pwd`"/$OPTFILE"      #  Verify that the testdir exists and contains previous
1114      if test ! -r $OPTFILE ; then      #  results in the correct location--or skip this directory!
1115          echo "Error: can't read optfile \"$OPTFILE\""      fout=$dir"/results/"$ref_outp
1116          exit 1      if test ! -r $fout ; then
1117            echo "can't read \"$fout\" -- skipping $dir"
1118            continue
1119      fi      fi
     echo  
     echo "OPTFILE=$OPTFILE" >> $SUMMARY  
     echo >> $SUMMARY  
       
     #  ...and each test directory...  
     for dir in $TESTDIRS ; do  
1120    
1121          #  Verify that the testdir exists and contains previous      # Check for specific files for particular type of run
         #  results in the correct location--or skip this directory!  
         if test ! -r $dir"/results/output.txt" ; then  
             echo | tee -a $SUMMARY  
             echo "can't read \"$dir/results/output.txt\" -- skipping $dir" \  
                 | tee -a $SUMMARY  
             continue  
         fi  
           
         #  Create an output dir for each OPTFILE/tdir combination  
         CDIR=$DRESULTS"/"$DRESULTS"_"$NDIR  
         mkdir $CDIR  
         CDIR=`pwd`"/$CDIR"  
1122    
1123          #  ...configue, make, run, and compare the output.      if test ! -r $CODE_DIR"/SIZE.h_mpi" -a "x$MPI" = "xt" ; then
1124          echo "-------------------------------------------------------------------------------"          echo "can't find \"$CODE_DIR/SIZE.h_mpi\" -- skipping $dir"
1125          echo          continue
1126          echo "Experiment:  $dir"      fi
1127          echo      if test ! -r $dir"/input/eedata.mth" -a "x$MULTI_THREAD" = "xt" ; then
1128          unset genmake makedepend make run          echo "can't find \"$dir/input/eedata.mth\" -- skipping $dir"
1129          results='-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --'          continue
1130          ( cd $dir/input; rm -f *.{o,f,c,F} *.[f,F]90 work* output.txt Make* make.log; )      fi
1131          if [ -r $dir/build ]; then  
1132              seperatebuilddir=1      #  Check whether there are "extra runs" for this testdir
1133              builddir=build      extra_runs=
1134              rundir=build      ex_run_dirs=`( cd $dir ; echo $inputdir.* )`
1135              ( cd $dir/build; ln -sf ../input/* . )      #echo "ex_run_dirs='$ex_run_dirs'"
1136          else      for exd in $ex_run_dirs ; do
1137              seperatebuilddir=0          name=`echo $exd | sed -e "s/$inputdir\.//"`
1138              builddir=input          refExOut=`echo $ref_outp | sed "s/\./.${name}./"`
1139              rundir=input          outf="$dir/results/$refExOut"
1140            if test -f $outf -a -r $outf ; then
1141                if test "x$MULTI_THREAD" = "xt" ; then
1142                    if test -r $dir"/"$exd"/eedata.mth" ; then
1143                        extra_runs="$extra_runs $name"
1144                    #else echo $dir"/"$exd"/eedata.mth: not found"
1145                    fi
1146                else
1147                    extra_runs="$extra_runs $name"
1148                fi
1149          fi          fi
1150        done
1151    
1152        echo "-------------------------------------------------------------------------------"
1153        echo
1154        if test "x$extra_runs" = "x" ; then
1155           echo "Experiment:  $dir"
1156        else
1157           echo "Experiment:  $dir ; extra_runs=$extra_runs"
1158        fi
1159        echo
1160        unset genmake makedepend make run
1161        results=$EMPTY_RESULTS
1162    
1163        #  Create an output dir for each OPTFILE/tdir combination
1164        rel_CDIR=$DRESULTS"/"$dir
1165        mkdir $rel_CDIR
1166        CDIR=`pwd`"/$rel_CDIR"
1167        
1168        if test "x$CLEANUP" = xt ; then
1169            echo '====>>> this is to check that we never go through this part <<< ==='
1170            makeclean $dir/$builddir \
1171                && run_clean $dir/$rundir
1172        else
1173          genmakemodel $dir/$builddir && genmake=Y \          genmakemodel $dir/$builddir && genmake=Y \
1174              && makeclean $dir/$builddir \              && makeclean $dir/$builddir \
1175                && run_clean $dir/$rundir \
1176                && symlink_mpifiles $dir $code_dir $builddir \
1177              && makedependmodel $dir/$builddir && makedepend=Y \              && makedependmodel $dir/$builddir && makedepend=Y \
1178              && makemodel $dir/$builddir && make=Y \              && makemodel $dir/$builddir && make=Y \
1179              && linkdata $seperatebuilddir $dir/$rundir \              && linkdata $dir/$rundir $inputdir input \
1180              && runmodel $dir/$builddir mitgcmuv && run=Y \              && runmodel $dir/$rundir && run=Y \
1181              && results=`testoutput $dir $rundir`              && results=`testoutput_run $dir $rundir $ref_outp`
1182          echo      fi
1183          formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \      
1184              ${run:-N} $results      echo
1185            fres=`formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N} $results`
1186          echo          echo
1187          formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \          echo "$fres" | sed 's/ 99/ --/g' | sed 's/  > />/' | sed 's/  < /</' >> $SUMMARY
1188              ${run:-N} $results >> $SUMMARY          touch $CDIR"/summary.txt"
1189          echo "fresults='" > $CDIR"/summary.txt"          echo "fresults='$fres'" | sed 's/ 99/ --/g' >> $CDIR"/summary.txt"
         formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} \  
             ${run:-N} $results >> $CDIR"/summary.txt"  
         echo "'" >> $CDIR"/summary.txt"  
1190          echo "MACH='$MACH'" >> $CDIR"/summary.txt"          echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1191          echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"          echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1192          echo "DATE='$DATE'" >> $CDIR"/summary.txt"          echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1193          echo "tdir='$dir'" >> $CDIR"/summary.txt"          echo "tdir='$dir'" >> $CDIR"/summary.txt"
1194            if test "x$ADM" = xt ; then
1195                head -1 $dir/$builddir/taf_ad.log >> $CDIR"/summary.txt"
1196                grep -A3 'Seconds in section "ALL' $dir/$rundir/$OUTPUTFILE \
1197                                    >> $CDIR"/summary.txt"
1198            fi
1199    
1200          (          for ex in $extra_runs ; do
1201              cd $DRESULTS              unset run
1202              tar -cf $NDIR".tar" $DRESULTS"_"$NDIR > /dev/null 2>&1              results=$EMPTY_RESULTS
1203              gzip $NDIR".tar"              #  reference output file
1204          )              refExOut=`echo $ref_outp | sed "s/\./.${ex}./g"`
1205                #  Create an output dir for each OPTFILE/tdir.ex combination
1206                rel_CDIR=$DRESULTS"/"$dir"."$ex
1207                mkdir $rel_CDIR
1208                CDIR=`pwd`"/$rel_CDIR"
1209                test ! -e "$dir/tr_run.$ex" && mkdir "$dir/tr_run.$ex"
1210                run_clean $dir/tr_run.$ex
1211                linkdata $dir/tr_run.$ex $inputdir.$ex $inputdir input
1212                runmodel $dir/tr_run.$ex && run=Y \
1213                && results=`testoutput_run $dir tr_run.$ex $refExOut`
1214                fres=`formatresults $dir ${genmake:-N} ${makedepend:-N} ${make:-N} ${run:-N} $results`
1215                fres="$fres.$ex"
1216                echo
1217                echo "$fres" | sed 's/ 99/ --/g' | sed 's/  > />/' | sed 's/  < /</' >> $SUMMARY
1218                touch $CDIR"/summary.txt"
1219                echo "fresults='$fres'" | sed 's/ 99/ --/g' >> $CDIR"/summary.txt"
1220                echo "MACH='$MACH'" >> $CDIR"/summary.txt"
1221                echo "UNAMEA='$UNAMEA'" >> $CDIR"/summary.txt"
1222                echo "DATE='$DATE'" >> $CDIR"/summary.txt"
1223                echo "tdir='$dir.$ex'" >> $CDIR"/summary.txt"
1224                if test "x$ADM" = xt ; then
1225                    head -1 $dir/$builddir/taf_ad.log >> $CDIR"/summary.txt"
1226                    grep -A3 'Seconds in section "ALL' $dir/tr_run.$ex/$OUTPUTFILE \
1227                                       >> $CDIR"/summary.txt"
1228                fi
1229                if test "x$POSTCLEAN" = xt ; then
1230                    run_clean $dir/tr_run.$ex
1231                fi
1232            done
1233    
1234        #postclean $dir/$builddir
1235        if test "x$POSTCLEAN" = xt ; then
1236            makeclean $dir/$builddir \
1237                && run_clean $dir/$rundir
1238        fi
1239        
1240        echo "-------------------------------------------------------------------------------"
1241        
1242    done
1243    
1244          $MPACK -s MITgcm-test -m 1000000 $DRESULTS"/"$NDIR".tar.gz" $ADDRESSES  printf "Start time:  " >> $SUMMARY
1245    echo "$start_date" >> $SUMMARY
1246    printf "End time:    " >> $SUMMARY
1247    date >> $SUMMARY
1248    
1249    #  If addresses were supplied and mpack built successfully, then try
1250    #  to send email using mpack.
1251    if test "x$ADDRESSES" = xNONE -o "x$ADDRESSES" = x ; then
1252        echo "No results email was sent."
1253    else
1254        if test "x$HAVE_MPACK" = xt ; then
1255            tar -cf $DRESULTS".tar" $DRESULTS > /dev/null 2>&1 \
1256                && gzip $DRESULTS".tar" \
1257                && $MPACK -s MITgcm-test -m 3555000 $DRESULTS".tar.gz" $ADDRESSES
1258          RETVAL=$?          RETVAL=$?
1259          if test "x$RETVAL" != x0 ; then          if test "x$RETVAL" != x0 ; then
1260              echo "Warning: \"$MPACK\" failed -- please contact <edhill@mitgcm.org>"              echo
1261                echo "Warning: The tar, gzip, & mpack step failed.  Please send email"
1262                echo "  to <MITgcm-support@mitgcm.org> for help.  You may copy the "
1263                echo "  summary of results from the directory \"$DRESULTS\"."
1264                echo
1265          else          else
1266              rm -f $DRESULTS"/"$NDIR".tar*"              echo
1267                echo "An email containing results was sent to the following addresses:"
1268                echo "  \"$ADDRESSES\""
1269                echo
1270          fi          fi
1271            test -f $DRESULTS".tar"  &&  rm -f $DRESULTS".tar"
1272            test -f $DRESULTS".tar.gz"  &&  rm -f $DRESULTS".tar.gz"
1273        fi
1274    fi
1275    
1276          NDIR=$(( $NDIR + 1 ))  rm -f tr_cmpnum.c tr_cmpnum
           
     done  
 done  
1277    
1278  rm tmp_cmpnum.f a.out  if test "x$CLEANUP" != xt ; then
1279        cat $SUMMARY | sed 's/ \.  \.  \.  \.  \.  \.  \.  \.  \.  \.  \.  \. //'
1280        if test -e tr_out.txt ; then
1281            mv tr_out.txt tr_out.txt.old
1282        fi
1283        cat $SUMMARY | sed '/^[YN] [YN] [YN] [YN]/ s/ \. //g' > tr_out.txt
1284    fi
1285    
1286  cat $SUMMARY  if test "x$DELDIR" = xt ; then
1287        rm -rf $DRESULTS
1288    fi
1289    

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.117

  ViewVC Help
Powered by ViewVC 1.1.22