source: branches/libIGCM_CESMEP/AA_TimeSeries_Checker @ 1553

Last change on this file since 1553 was 1525, checked in by cetlod, 4 years ago

Update Scripts for Post-processing on Irene-Rome
  • Property licence set to
    The following licence information concerns ONLY the libIGCM tools
    ==================================================================

    Copyright © Centre National de la Recherche Scientifique CNRS
    Commissariat à l'Énergie Atomique CEA

    libIGCM : Library for Portable Models Computation of IGCM Group.

    IGCM Group is the french IPSL Global Climate Model Group.

    This library is a set of shell scripts and functions whose purpose is
    the management of the initialization, the launch, the transfer of
    output files, the post-processing and the monitoring of datas produce
    by any numerical program on any plateforme.

    This software is governed by the CeCILL license under French law and
    abiding by the rules of distribution of free software. You can use,
    modify and/ or redistribute the software under the terms of the CeCILL
    license as circulated by CEA, CNRS and INRIA at the following URL
    "http://www.cecill.info".

    As a counterpart to the access to the source code and rights to copy,
    modify and redistribute granted by the license, users are provided only
    with a limited warranty and the software's author, the holder of the
    economic rights, and the successive licensors have only limited
    liability.

    In this respect, the user's attention is drawn to the risks associated
    with loading, using, modifying and/or developing or reproducing the
    software by the user in light of its specific status of free software,
    that may mean that it is complicated to manipulate, and that also
    therefore means that it is reserved for developers and experienced
    professionals having in-depth computer knowledge. Users are therefore
    encouraged to load and test the software's suitability as regards their
    requirements in conditions enabling the security of their systems and/or
    data to be ensured and, more generally, to use and operate it in the
    same conditions as regards security.

    The fact that you are presently reading this means that you have had
    knowledge of the CeCILL license and that you accept its terms.
  • Property svn:keywords set to Revision Author Date
File size: 21.7 KB
Line 
1#!/bin/ksh
2
3#**************************************************************
4# Author: Sebastien Denvil
5# Contact: Sebastien.Denvil__at__ipsl.jussieu.fr
6# $Revision::                                          $ Revision of last commit
7# $Author::                                            $ Author of last commit
8# $Date::                                              $ Date of last commit
9# IPSL (2006)
10#  This software is governed by the CeCILL licence see libIGCM/libIGCM_CeCILL.LIC
11#
12#**************************************************************
13# ID of your genci project. Curie only : post-processing jobs need it to run properly
14#-Q- curie export BRIDGE_MSUB_PROJECT=::default_project::
15#-Q- irene export BRIDGE_MSUB_PROJECT=::default_project::
16#-Q- irene-amd export BRIDGE_MSUB_PROJECT=::default_project::
17
18#D- Task type DO NOT CHANGE (computing, post-processing or checking)
19TaskType=checking
20
21#D- Low level debug : to perform lib test checks, stack construction and IO functions instrumentation
22DEBUG_debug=false
23
24#D- Messaging : all activities and call stacks will be sent to ipsl servers
25BigBrother=false
26
27# Check that everything went well during time series production
28# Display a short report
29# Launch what's missing
30# For use during a run (not on the end : PeriodState=Completed), it will complete
31# all TS to last PeriodDateEnd value, give by run.card->Configuration->(PeriodDateBegin - 1).
32
33#D- Path to libIGCM
34#D- Default : value from AA_job if any
35libIGCM=${libIGCM:=::modipsl::/libIGCM}
36
37# répertoire courrant
38CURRENT_DIR=$( pwd )
39
40# Emplacement des cartes
41CARD_DIR=${CARD_DIR:=${CURRENT_DIR}}
42
43# répertoire de stockage des sorties des create_ts
44POST_DIR=${POST_DIR:=${CARD_DIR}/OutScript}
45
46if [ ! -d ${CARD_DIR} ]; then
47  echo "No ${CARD_DIR}, we stop here"
48  exit
49fi
50
51########################################################################
52
53. ${libIGCM}/libIGCM_debug/libIGCM_debug.ksh
54. ${libIGCM}/libIGCM_card/libIGCM_card.ksh
55. ${libIGCM}/libIGCM_date/libIGCM_date.ksh
56#-------
57. ${libIGCM}/libIGCM_sys/libIGCM_sys.ksh
58. ${libIGCM}/libIGCM_config/libIGCM_config.ksh
59#-------
60( ${DEBUG_debug} ) && IGCM_debug_Check
61( ${DEBUG_debug} ) && IGCM_card_Check
62( ${DEBUG_debug} ) && IGCM_date_Check
63
64########################################################################
65
66#set -vx
67
68echo "Hi I'm here to help you complete the time series production you planned according to your *.card."
69echo "This action can potentially submit numbers of jobs (up to 50)"
70echo "This action can potentially remove unnecessary files but I will ALWAYS ask permission to do so"
71echo -e "\033[1;31mDo you want me to run in dryrun mode just telling what I would submit?\033[m"
72echo -e "\033[1;31mOr do you want me to submit job for real? Answer yes in this case.\033[m"
73echo -n " Run for real (y/n) :"
74read ActionAnswer
75
76case ${ActionAnswer} in
77oui|OUI|o|y|yes|YES)
78  echo "OK. I will submit jobs but ask permissions before removing files"
79  action=true
80  ;;
81non|NON|n|no|NO)
82  echo "OK. I won't submit jobs and only print out files I could remove"
83  action=false
84  ;;
85*)
86  echo "I did not recognize your answer. I will stop here."
87  echo "Please respond: oui|OUI|o|y|yes|YES"
88  echo "Or please respond: non|NON|n|no|NO"
89  exit
90  ;;
91esac
92
93#==================================
94# First of all
95#
96# Read libIGCM compatibility version in config.card
97# Read UserChoices section
98# Read Ensemble section
99# Read Post section
100# Define all netcdf output directories
101#==================================
102IGCM_config_CommonConfiguration ${CARD_DIR}/config.card
103
104#==================================
105# Read ListOfComponents section:
106IGCM_card_DefineArrayFromSection ${CARD_DIR}/config.card ListOfComponents
107
108if [ -f ${CARD_DIR}/run.card ] ; then
109  IGCM_card_DefineVariableFromOption ${CARD_DIR}/run.card Configuration PeriodState
110  IGCM_card_DefineVariableFromOption ${CARD_DIR}/run.card Configuration PeriodDateBegin
111  IGCM_card_DefineVariableFromOption ${CARD_DIR}/run.card PostProcessing TimeSeriesCompleted
112  IGCM_debug_Print 1 "DefineVariableFromOption  : run_Configuration"
113  IGCM_debug_PrintVariables 3 run_Configuration_PeriodState
114  IGCM_debug_Print 1 "DefineVariableFromOption  : run_PostProcessing"
115  IGCM_debug_PrintVariables 3 run_PostProcessing_TimeSeriesCompleted
116  if [ X${run_Configuration_PeriodState} != X"Completed" ] ; then
117    DateEnd=$( IGCM_date_AddDaysToGregorianDate $( IGCM_date_ConvertFormatToGregorian ${run_Configuration_PeriodDateBegin} ) -1 )
118  else
119    DateEnd=$( IGCM_date_ConvertFormatToGregorian ${config_UserChoices_DateEnd} )
120  fi
121  CompletedFlag=${run_PostProcessing_TimeSeriesCompleted}
122else
123  DateEnd=$( IGCM_date_ConvertFormatToGregorian ${config_UserChoices_DateEnd} )
124  CompletedFlag=""
125fi
126SavedCompletedFlag=${CompletedFlag}
127DateBegin=$( IGCM_date_ConvertFormatToGregorian ${config_UserChoices_DateBegin} )
128
129IGCM_date_GetYearMonth ${DateBegin} YearBegin MonthBegin
130IGCM_date_GetYearMonth ${DateEnd}   YearEnd   MonthEnd
131
132echo
133IGCM_debug_Print 1 "DateBegin for TimeSeries_Checker : "${DateBegin}
134IGCM_debug_Print 1 "DateEnd   for TimeSeries_Checker : "${DateEnd}
135IGCM_debug_Print 1 "CompletedFlag = "${CompletedFlag}
136echo
137
138for comp in ${config_ListOfComponents[*]} ; do
139  # Debug Print
140  IGCM_debug_Print 1 ${comp}
141  # Define component
142  IGCM_card_DefineArrayFromOption ${CARD_DIR}/config.card ListOfComponents ${comp}
143  eval compname=\${config_ListOfComponents_${comp}[0]} > /dev/null 2>&1
144  eval comptagname=\${config_ListOfComponents_${comp}[1]} > /dev/null 2>&1
145
146  # Read libIGCM compatibility version in ${compname}.card
147  card=${CARD_DIR}/COMP/${compname}.card
148
149  # Read and Build Output File stuff
150  #IGCM_debug_Print 1 "DefineArrayFromOption  : ${compname}_OutputFiles ${card}"
151  IGCM_card_DefineArrayFromOption ${card} OutputFiles List
152  ListFilesName=${compname}_OutputFiles_List
153  eval FileName0=\${${ListFilesName}[0]} > /dev/null 2>&1
154  #
155  if [ X${FileName0} != X${NULL_STR} ] ; then
156    #
157    #IGCM_debug_Print 1 "Component      : ${compname}"
158    #
159    # INITIALISATION
160    #
161    eval NbFiles=\${#${ListFilesName}[@]} > /dev/null 2>&1
162    i=2
163    #
164    until [ $i -ge $NbFiles ]; do
165      #
166      eval flag_post=\${${ListFilesName}[$i]} > /dev/null 2>&1
167      #
168      if [ X${flag_post} != XNONE ] ; then
169        #
170        # First of all
171        #
172        IGCM_card_DefineArrayFromSection ${card} ${flag_post}
173        #
174        IGCM_card_DefineArrayFromOption ${card} ${flag_post} TimeSeriesVars
175        IGCM_card_DefineArrayFromOption ${card} ${flag_post} Patches
176        if [ X"$( eval echo \${${compname}_${flag_post}_TimeSeriesVars[*]} )" = X"Option not" ] ; then
177          # New TimeSeriesVar description, with 2D, 3D and associate ChunckJob.
178          unset ListDimension
179          ListDimension[0]=2D
180          ListDimension[1]=3D
181          TimeSeries=false
182          TimeSeries2D=false
183          TimeSeries3D=false
184          chunck=false
185          iLoop=${#ListDimension[*]}
186          j=0
187          until [ $j -ge ${iLoop} ]; do
188            Dimension=${ListDimension[${j}]}
189            IGCM_card_DefineArrayFromOption ${card} ${flag_post} TimeSeriesVars${Dimension}
190            IGCM_card_DefineVariableFromOption ${card} ${flag_post} ChunckJob${Dimension}
191            #
192            # Time series WITHOUT chunk
193            #
194            if [ ! $( eval echo \${${compname}_${flag_post}_TimeSeriesVars${Dimension}} ) = ${NULL_STR} ] ; then
195              if [ $( eval echo \${${compname}_${flag_post}_ChunckJob${Dimension}} ) = NONE ] ; then
196                IGCM_debug_Print 2 "${Dimension} time series activated for ${flag_post}"
197                eval TimeSeries${Dimension}=true
198                chunck=false
199              fi
200            fi
201            #
202            # Time series WITH chunk
203            #
204            if [ ! $( eval echo \${${compname}_${flag_post}_TimeSeriesVars${Dimension}} ) = ${NULL_STR} ] ; then
205              chunck_size=$( eval echo \${${compname}_${flag_post}_ChunckJob${Dimension}} )
206              if [ ! ${chunck_size} = NONE ] &&  [ ! ${chunck_size} = OFF ] ; then
207                IGCM_debug_Print 2 "${Dimension} time series activated with ${chunck_size} chunck for ${flag_post}"
208                eval TimeSeriesChunck${Dimension}=true
209                chunck=true
210              fi
211            fi
212            (( j=j+1 ))
213            #
214            # If TimeSeriesVars list is empty or OFF we skip
215            #
216            if ( [ $( eval echo \${${compname}_${flag_post}_TimeSeriesVars${Dimension}} ) = ${NULL_STR} ] || \
217              [ ${chunck_size} = OFF ] ) ; then
218              #IGCM_debug_Print 2 "Empty TS : ${compname}_Post_${FILE}_TimeSeriesVars${Dimension}"
219              #(( i=i+3 ))
220              continue
221            fi
222            #
223            #  ICI ON TESTE QUE LES FICHIERS TS SONT LA!
224            #
225            FILE=$( echo ${flag_post} | awk "-FPost_" '{print $2}' )
226            IGCM_card_DefineArrayFromOption ${card}    Post_${FILE} TimeSeriesVars${Dimension}
227            IGCM_card_DefineVariableFromOption ${card} Post_${FILE} ChunckJob${Dimension}
228            #
229            FlagDir=$( echo ${FILE} | awk -F "_" '{print $1}' )
230            case ${FlagDir} in
231            *Y)  TS_Dir=TS_YE  ;;
232            *M)  TS_Dir=TS_MO  ;;
233            *D)  TS_Dir=TS_DA  ;;
234            3H|HF)  TS_Dir=TS_HF  ;;
235            INS) TS_Dir=TS_INS ;;
236            esac
237            #
238            # We need LIST of variables not allready produced (useful for standalone mode)
239            #
240            DateBegin=$( IGCM_date_ConvertFormatToGregorian ${config_UserChoices_DateBegin} )
241            IGCM_date_GetYearMonth ${DateBegin} YearBegin MonthBegin
242
243            # Si on n'a pas de chunck, dans ce cas chunck_size=la durée de la simulation en années
244            YearsChunckLength=$( echo ${chunck_size} | sed -e "s/[yY]//" )
245            [ ${chunck} = false ] && YearsChunckLength=$(( YearEnd - YearBegin + 1 ))
246
247            NbYearsChunckLoop=$(( ( YearEnd - YearBegin + 1 ) / YearsChunckLength ))
248            Reste=$(( ( YearEnd - YearBegin + 1 ) % YearsChunckLength ))
249
250            if [ ${Reste} -ne 0 ] ; then
251              NbYearsChunckLoop=$(( NbYearsChunckLoop + 1 ))
252            fi
253
254            if [ ${NbYearsChunckLoop} -eq 1 ] ; then
255              PeriodDateEnd=${DateEnd}
256            else
257              Length=$( IGCM_date_DaysInCurrentPeriod ${DateBegin} ${YearsChunckLength}Y )
258              PeriodDateEnd=$( IGCM_date_AddDaysToGregorianDate ${DateBegin} ${Length}-1 )
259            fi
260            #
261            DIRECTORY=${R_SAVE}/${comp}/Analyse/${TS_Dir}
262            YearsChunckLoop=1
263            ChunckDebut=${DateBegin}
264            ChunckFin=${PeriodDateEnd}
265            while [ ${YearsChunckLoop} -le ${NbYearsChunckLoop} ] ; do
266              countTotal=0
267              countGood=0
268              countBad=0
269              unset RemoveList
270              unset PotentialCompletedFlag
271              for var in $( eval echo \${${compname}_Post_${FILE}_TimeSeriesVars${Dimension}[*]} ) ; do
272                TestedFile=${config_UserChoices_JobName}_${ChunckDebut}_${ChunckFin}_${FlagDir}_${var}.nc
273                #
274                DEBUG_sys=false IGCM_sys_TestDirArchive ${DIRECTORY}
275                if [ $? = 0 ] ; then
276                  Candidat=$( find ${DIRECTORY} -name "${config_UserChoices_JobName}_${ChunckDebut}_*_${FlagDir}_${var}.nc" )
277                else
278                  Candidat=""
279                fi
280                #
281                BestCandidat=${ChunckDebut}
282                #
283                FoundCandidat=false
284                if [ ! "X${Candidat}" = "X" ] ; then
285                  for candid in ${Candidat} ; do
286                    #IGCM_debug_Print 1 -e "\033[1;32m[CompletedFlag CANDIDAT MATCH FOUND]\033[m $( basename ${candid} )"
287                    CandidatEnd=$( echo ${candid}   | awk -F${config_UserChoices_JobName} '{print $3}' | awk -F_ '{print $3}' )
288                    if [ ${CandidatEnd} -gt ${ChunckFin} ] ; then
289                      #IGCM_debug_Print 3 -e "File $( basename ${candid} ) should be suppress"
290                      set +A RemoveList ${RemoveList[*]} ${candid}
291                    elif [ ${CandidatEnd} -lt ${ChunckFin} ] ; then
292                      #IGCM_debug_Print 3 -e "File $( basename ${candid} ) should be suppress or used as a CompletedFlag baseline"
293                      # We keep the best candidat and remove the others
294                      if [ ${BestCandidat} -lt ${CandidatEnd} ] ; then
295                        if [ ${FoundCandidat} = true ] ; then
296                          set +A RemoveList ${RemoveList[*]} ${DIRECTORY}/${config_UserChoices_JobName}_${ChunckDebut}_${BestCandidat}_${FlagDir}_${var}.nc
297                        else
298                          FoundCandidat=true
299                        fi
300                        BestCandidat=${CandidatEnd}
301                      else
302                        set +A RemoveList ${RemoveList[*]} ${candid}
303                      fi
304                    fi
305                  done
306                else
307                  # No CompletedFlag candidat found
308                  CandidatCompletedFlag=""
309                fi
310                #
311                if [ ! -f ${DIRECTORY}/${TestedFile} ] ; then
312                  (( countBad = countBad + 1 ))
313                  [ ${countBad} = 1 ] && IGCM_debug_Print 3 "Missing time series from ${FILE} in ${DIRECTORY} :"
314                  IGCM_debug_Print 3 ${TestedFile}
315                  # Then we keep a track of the Best Candidat
316                  if [ ${FoundCandidat} = true ] ; then
317                    if [ ${chunck} = true ] ; then
318                      set +A PotentialCompletedFlag ${PotentialCompletedFlag[*]} ${BestCandidat}
319                    else
320                      eval set +A PotentialCompletedFlag${Dimension} \${PotentialCompletedFlag${Dimension}[*]} \${BestCandidat}
321                    fi
322                  fi
323                else
324                  (( countGood = countGood + 1 ))
325                  # Then we do not need the best candidat if any
326                  [ ${FoundCandidat} = true ] && set +A RemoveList ${RemoveList[*]} ${DIRECTORY}/${config_UserChoices_JobName}_${ChunckDebut}_${BestCandidat}_${FlagDir}_${var}.nc
327                fi
328                (( countTotal = countTotal + 1 ))
329              done
330
331              SuccessRate=$(( countGood * 100 / countTotal ))
332              if [ ${SuccessRate} -ne 100 ] ; then
333                IGCM_debug_Print 2 -e "\033[1;31m${SuccessRate}% files OK.\033[m for period ${ChunckDebut}-${ChunckFin}"
334              else
335                IGCM_debug_Print 2 -e "\033[1;32m${SuccessRate}% files OK.\033[m for period ${ChunckDebut}-${ChunckFin}"
336              fi
337              echo
338
339              # Remove what's in the RemoveList
340              if [ ${RemoveList} ] ; then
341                IGCM_debug_Print 2 "File(s) that will be removed ${RemoveList[*]}"
342                if [ ${action} = true ] ; then
343                  echo -e "\033[1;32mDo you want to remove them?\033[m"
344                  echo -n " Your answer (y/n) : "
345                  read RemoveAnswer
346                  case ${RemoveAnswer} in
347                  oui|OUI|o|y|yes|YES)
348                    echo "OK. I will erase them"
349                    IGCM_sys_Rm -f ${RemoveList[*]}
350                    ;;
351                  non|NON|n|no|NO)
352                    echo "OK. I won't erase them"
353                    ;;
354                  *)
355                    echo "I did not recognize your answer."
356                    echo "Please respond: oui|OUI|o|y|yes|YES"
357                    echo "Or please respond: non|NON|n|no|NO"
358                    exit
359                    ;;
360                  esac
361                fi
362              fi
363              #[ ${FoundCandidat} = true ] && IGCM_debug_Print 2 "Potentials CompletedFlag: ${PotentialCompletedFlag[*]}"
364              #
365              # TO REWRITE BEGIN
366              #
367              if ( [ ${chunck} = true ] && [ ${SuccessRate} -ne 100 ] ) ; then
368                NbCandidats=${#PotentialCompletedFlag[@]}
369                countCandid=1
370                if [ ${NbCandidats} -eq 0 ] ; then
371                  ChunckCompletedFlag=""
372                  IGCM_debug_Print 2 -e "\033[1;31mNO CompletedFlag\033[m"
373                elif [ ${NbCandidats} -eq 1 ] ; then
374                  ChunckCompletedFlag=${PotentialCompletedFlag[0]}
375                  IGCM_debug_Print 2 -e "\033[1;32mCompletedFlag=${ChunckCompletedFlag}\033[m"
376                elif [ ${NbCandidats} -gt 1 ] ; then
377                  k=1
378                  until [ $k -ge ${NbCandidats} ]; do
379                    ((k_m1=k-1))
380                    if [ ${PotentialCompletedFlag[${k_m1}]} = ${PotentialCompletedFlag[${k}]} ] ; then
381                      ((countCandid=countCandid+1))
382                    fi
383                    ((k=k+1))
384                  done
385                  if [ ${NbCandidats} -eq ${countCandid} ] ; then
386                    ChunckCompletedFlag=${PotentialCompletedFlag[0]}
387                    IGCM_debug_Print 2 -e "\033[1;32mCompletedFlag=${ChunckCompletedFlag}\033[m"
388                  else
389                    ChunckCompletedFlag=${PotentialCompletedFlag[0]}
390                    IGCM_debug_Print 2 -e "\033[1;31mToo Many Potential CompletedFlag\033[m Let start with first CompletedPeriod"
391                    IGCM_debug_Print 2 -e "\033[1;31mYou will have to redo TimeSeries_Checker\033[m for other period."
392                  fi
393                fi
394                #
395                # TO REWRITE END
396                #
397                if [ ${action} = true ] ; then
398                  IGCM_debug_Print 2 -e "\033[1;31mSubmit ${FILE} chunck ${Dimension}\033[m period ${ChunckDebut}-${ChunckFin} and CompletedFlag=${ChunckCompletedFlag}"
399                  listVarEnv="DEBUG_debug,BigBrother,libIGCM,SUBMIT_DIR,POST_DIR,Script_Post_Output,DateBegin,PeriodDateEnd,CompletedFlag,TsTask,CompToRead,FlagToRead"
400                  export DEBUG_debug=${DEBUG_debug}
401                  export BigBrother=${BigBrother}
402                  export libIGCM=${libIGCM}
403                  export SUBMIT_DIR=${CARD_DIR}
404                  export POST_DIR=${POST_DIR}
405                  export DateBegin=${ChunckDebut}
406                  export PeriodDateEnd=${ChunckFin}
407                  export CompletedFlag=${ChunckCompletedFlag}
408                  export TsTask=Chunck${Dimension}
409                  export CompToRead=${comp}
410                  export FlagToRead=${i}
411                  export NameToRead=${flag_post}
412                  export listVarEnv=${listVarEnv}
413                  export Script_Post_Output=create_ts.${PeriodDateEnd}.${TsTask}.${CompToRead}.${NameToRead}
414                  IGCM_sys_MkdirWork ${POST_DIR}
415                  IGCM_debug_Verif_Exit
416                  IGCM_sys_QsubPost create_ts
417                  echo
418                else
419                  IGCM_debug_Print 2 -e "\033[1;31mI should NOW submit ${FILE} chunck ${Dimension}\033[m period ${ChunckDebut}-${ChunckFin} and CompletedFlag=${ChunckCompletedFlag}"
420                fi
421              fi
422
423              if ( [ ${chunck} = false ] && [ ${SuccessRate} -ne 100 ] ) ; then
424                eval Launch${Dimension}=true
425              fi
426
427              # Date update
428              ChunckDebut=$( IGCM_date_AddDaysToGregorianDate ${ChunckFin} 1 )
429
430              (( YearsChunckLoop = YearsChunckLoop + 1 ))
431
432              if [ ${YearsChunckLoop} -eq ${NbYearsChunckLoop} ] ; then
433                ChunckFin=${DateEnd}
434              else
435                Length=$( IGCM_date_DaysInCurrentPeriod ${ChunckDebut} ${YearsChunckLength}Y )
436                ChunckFin=$( IGCM_date_AddDaysToGregorianDate ${ChunckDebut} ${Length}-1 )
437              fi
438            done
439          done
440        else
441          ListDimension[0]=""
442          TimeSeries=true
443          TimeSeries2D=false
444          TimeSeries3D=false
445          TimeSeriesChunck2D=false
446          TimeSeriesChunck3D=false
447        fi
448      fi
449      (( i=i+3 ))
450    done
451  fi
452done # comp loop
453
454echo
455
456DateBegin=$( IGCM_date_ConvertFormatToGregorian ${config_UserChoices_DateBegin} )
457IGCM_date_GetYearMonth ${DateBegin} YearBegin MonthBegin
458CompletedFlag=${SavedCompletedFlag}
459
460unset CompToRead
461unset FlagToRead
462
463if [ X${Launch2D} = Xtrue ] ; then
464  if [ ${action} = true ] ; then
465    #IGCM_debug_Print 2 "Potentials CompletedFlag: ${PotentialCompletedFlag2D[*]}"
466    IGCM_debug_Print 2 -e "\033[1;31mSubmit 2D\033[m without chunck period ${DateBegin}-${DateEnd}"
467    listVarEnv="DEBUG_debug,BigBrother,libIGCM,SUBMIT_DIR,POST_DIR,Script_Post_Output,DateBegin,PeriodDateEnd,CompletedFlag,TsTask"
468    export DEBUG_debug=${DEBUG_debug}
469    export BigBrother=${BigBrother}
470    export libIGCM=${libIGCM}
471    export SUBMIT_DIR=${CARD_DIR}
472    export POST_DIR=${POST_DIR}
473    export DateBegin=${DateBegin}
474    export PeriodDateEnd=${DateEnd}
475    export CompletedFlag=${CompletedFlag}
476    export TsTask=2D
477    export listVarEnv=${listVarEnv}
478    export Script_Post_Output=create_ts.${PeriodDateEnd}.${TsTask}
479    IGCM_sys_MkdirWork ${POST_DIR}
480    IGCM_debug_Verif_Exit
481    IGCM_sys_QsubPost create_ts
482    echo
483  else
484    IGCM_debug_Print 2 -e "\033[1;31mI should NOW submit 2D without chunck\033[m period ${DateBegin}-${DateEnd}"
485  fi
486fi
487
488if [ X${Launch3D} = Xtrue ] ; then
489  if [ ${action} = true ] ; then
490    #IGCM_debug_Print 2 "Potentials CompletedFlag: ${PotentialCompletedFlag3D[*]}"
491    IGCM_debug_Print 2 -e "\033[1;31mSubmit 3D\033[m without chunck period ${DateBegin}-${DateEnd}"
492    listVarEnv="DEBUG_debug,BigBrother,libIGCM,SUBMIT_DIR,POST_DIR,Script_Post_Output,DateBegin,PeriodDateEnd,CompletedFlag,TsTask"
493    export DEBUG_debug=${DEBUG_debug}
494    export BigBrother=${BigBrother}
495    export libIGCM=${libIGCM}
496    export SUBMIT_DIR=${CARD_DIR}
497    export POST_DIR=${POST_DIR}
498    export DateBegin=${DateBegin}
499    export PeriodDateEnd=${DateEnd}
500    export CompletedFlag=${CompletedFlag}
501    export TsTask=3D
502    export listVarEnv=${listVarEnv}
503    export Script_Post_Output=create_ts.${PeriodDateEnd}.${TsTask}
504    IGCM_sys_MkdirWork ${POST_DIR}
505    IGCM_debug_Verif_Exit
506    IGCM_sys_QsubPost create_ts
507    echo
508  else
509    IGCM_debug_Print 2 -e "\033[1;31mI should NOW submit 3D without chunck\033[m  period ${DateBegin}-${DateEnd}"
510  fi
511fi
Note: See TracBrowser for help on using the repository browser.