source: tags/libIGCM_v2.1.1/libIGCM_post/libIGCM_post.ksh @ 1435

Last change on this file since 1435 was 927, checked in by sdipsl, 11 years ago

remove AA_rebuild_fromArchive. AA_rebuild_fromWorkdir can do both
  • 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: 40.9 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
14#=======================================================================
15
16function IGCM_post_Configure
17{
18  IGCM_debug_PushStack "IGCM_post_Configure"
19
20  # Debug Print :
21  echo
22  IGCM_debug_Print 1 "IGCM_post_Configure"
23  #
24  # Initialize
25  #
26  POST=false
27  RebuildFrequency=false
28  PackFrequency=false
29  TimeSeriesFrequency=false
30  SeasonalFrequency=false
31  unset list_post
32  #
33  # ONLY IF SOMETHING NEEDS TO BE DONE (EATHER TIME SERIES OR SEASONAL) COMPUTE THE MODULOS
34  #
35  if [ X${AsynchronousRebuild} = Xtrue ] ; then
36    list_post="RebuildFrequency"
37  fi
38  #
39  if [ X${Pack} = Xtrue ] ; then
40    list_post="${list_post} PackFrequency"
41  fi
42  #
43  if ( [ X${TimeSeries} = Xtrue ] || [ X${TimeSeries2D} = Xtrue ] || [ X${TimeSeries3D} = Xtrue ] || [ X${TimeSeriesChunck2D} = Xtrue ] || [ X${TimeSeriesChunck3D} = Xtrue ] ) ; then
44    list_post="${list_post} TimeSeriesFrequency"
45  fi
46  #
47  if [ X${Seasonal} = Xtrue ] ; then
48    list_post="${list_post} SeasonalFrequency"
49  fi
50
51  # Overrule special cases
52  if ( [ ! X${config_Post_TimeSeriesFrequency} = X${NULL_STR} ] && \
53    [ ! X${config_Post_TimeSeriesFrequency} = XNONE ]           && \
54    [ ${SimulationLengthInDays} -ge ${ExperienceLengthInDays} ] ) ; then
55    TimeSeriesFrequency=true
56    POST=true
57  fi
58  #
59  if ( [ X${AsynchronousRebuild} = Xtrue ] && [ ${SimulationLengthInDays} -ge ${ExperienceLengthInDays} ] ) ; then
60    RebuildFrequency=true
61    POST=true
62  fi
63
64  # READ REBUILD OR TIME SERIES OR SEASONAL FREQUENCY
65  # AND TURN ON THE SUBMISSION FLAG WHEN MODULO IS ZERO
66  for post_freq in ${list_post} ; do
67    # Extract frequency from previously defined variable
68    config_Post_post_freq=$( eval echo \${config_Post_${post_freq}} )
69    # Offset for Seasonal Average starting period
70    if [ ${post_freq} = SeasonalFrequency ] ; then
71      if ( [ X${config_Post_SeasonalFrequencyOffset} = X${NULL_STR} ] || [ X${config_Post_SeasonalFrequencyOffset} = XNONE ] || [ X${config_Post_SeasonalFrequencyOffset} = X ] ) ; then
72        PeriodOffset=0
73      else
74        PeriodOffset=${config_Post_SeasonalFrequencyOffset}
75      fi
76    else
77      PeriodOffset=0
78    fi
79    # Compute Modulo between frequencys (/!\second argument will be multiplied by CumuPeriod/!\)
80    # RebuildFrequency needs additionnal information
81    if [ ${post_freq} = RebuildFrequency ] ; then
82      IGCM_post_ModuloRuntimeFrequency config_Post_post_freq config_UserChoices_PeriodLength NbPeriodPerFrequency
83      NbRebuildDir=${NbPeriodPerFrequency}
84    else
85      IGCM_post_ModuloRuntimeFrequency config_Post_post_freq config_UserChoices_PeriodLength
86    fi
87    #
88    eval IGCM_debug_Print 1 \" "${post_freq} flag value : \${${post_freq}}" \"
89  done
90  #
91  IGCM_debug_Print 2 "POST-TREATEMENT flag value : ${POST}"
92  #
93  # Prepare headers for the shell dedicated to post-processing
94  if ( [ ${PackFrequency} = true ] && ( [ ${TimeSeriesFrequency} = true ] || [ ${SeasonalFrequency} = true ] ) ) ; then
95    if [ $DRYRUN -le 1 ]; then
96      echo "#!/bin/ksh                                     " >  ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
97      echo "function IGCM_FlushPost                        " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
98      echo "{                                              " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
99      echo "IGCM_debug_PushStack \"IGCM_FlushPost\"        " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
100      echo "echo                                           " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
101      echo "IGCM_debug_Print 1 \"IGCM_FlushPost\"          " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
102      echo "echo                                           " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
103    fi
104  fi
105  IGCM_debug_PopStack "IGCM_post_Configure"
106}
107
108function IGCM_post_Submit
109{
110  IGCM_debug_PushStack "IGCM_post_Submit"
111
112  typeset listVarEnv DaysTemp
113
114  POST_DIR=${R_BUF_KSH}
115
116  if [ ${POST} = true ]; then
117    echo
118    IGCM_debug_Print 1 "IGCM_post_Submit"
119    echo
120    IGCM_debug_Print 2 "POST_DIR = ${POST_DIR}"
121  fi
122
123  #============ TIME SERIES POST-PROCESSING ===========#
124  if [ ${TimeSeriesFrequency} = true ] ; then
125
126    IGCM_debug_Print 1 "TIME SERIES POST-PROCESSING ACTIVATED"
127    echo
128
129
130
131    # Get information from last execution
132    IGCM_card_DefineVariableFromOption ${SUBMIT_DIR}/run.card PostProcessing TimeSeriesCompleted
133    CompletedFlag=${run_PostProcessing_TimeSeriesCompleted}
134    #
135
136
137
138    listVarEnv="DEBUG_debug,MODIPSL,libIGCM,libIGCM_SX,SUBMIT_DIR,POST_DIR,MASTER,RebuildFrequency,DateBegin,PeriodDateEnd,StandAlone,CompletedFlag,TsTask,CompToRead,FlagToRead,RESOL_ATM,RESOL_OCE,RESOL_ICE,RESOL_MBG,RESOL_SRF,RESOL_SBG"
139    #
140    jLoop=${#ListDimension[*]}
141    j=0
142    until [ $j -ge ${jLoop} ]; do
143      Dimension=${ListDimension[${j}]}
144      #
145      if [ X$( eval echo \${TimeSeries${Dimension}} ) = Xtrue ] ; then
146      #
147        IGCM_debug_Print 1 "TIME SERIES POST-PROCESSING ${Dimension} ACTIVATED"
148        echo
149        #
150        if [ X${Dimension} = X ] ; then
151          TsTask="empty"
152          Script_Post_Output=create_ts.${PeriodDateEnd}
153        else
154          TsTask=${Dimension}
155          Script_Post_Output=create_ts.${PeriodDateEnd}.${TsTask}
156        fi
157        #
158        if [ ${RebuildFrequency} = true ] ; then
159          #
160          if [ ${PackFrequency} = true ] ; then
161            FunctionPath=${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
162          else
163            FunctionPath=${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
164          fi
165          #
166          if [ -f ${FunctionPath} ] ; then
167#           if [ X${MASTER} = Xtitane ] ; then
168#             echo "IGCM_sys_RshPost <<-EOF"                       >> ${FunctionPath}
169#           fi
170            echo "export DEBUG_debug=${DEBUG_debug}              " >> ${FunctionPath}
171            echo "export MODIPSL=${MODIPSL}                      " >> ${FunctionPath}
172            echo "export libIGCM_SX=${libIGCM}                   " >> ${FunctionPath}
173            echo "export libIGCM=${libIGCM_POST}                 " >> ${FunctionPath}
174            echo "export SUBMIT_DIR=${SUBMIT_DIR}                " >> ${FunctionPath}
175            echo "export POST_DIR=${POST_DIR}                    " >> ${FunctionPath}
176            echo "export MASTER=${MASTER}                        " >> ${FunctionPath}
177            echo "export RebuildFrequency=${RebuildFrequency}    " >> ${FunctionPath}
178            echo "export DateBegin=${DateBegin}                  " >> ${FunctionPath}
179            echo "export PeriodDateEnd=${PeriodDateEnd}          " >> ${FunctionPath}
180            echo "export StandAlone=false                        " >> ${FunctionPath}
181            echo "export CompletedFlag=${CompletedFlag}          " >> ${FunctionPath}
182            echo "export TsTask=${TsTask}                        " >> ${FunctionPath}
183            echo "unset  CompToRead                              " >> ${FunctionPath}
184            echo "unset  FlagToRead                              " >> ${FunctionPath}
185            echo "export RESOL_ATM=${RESOL_ATM}                  " >> ${FunctionPath}
186            echo "export RESOL_OCE=${RESOL_OCE}                  " >> ${FunctionPath}
187            echo "export RESOL_ICE=${RESOL_ICE}                  " >> ${FunctionPath}
188            echo "export RESOL_MBG=${RESOL_MBG}                  " >> ${FunctionPath}
189            echo "export RESOL_SRF=${RESOL_SRF}                  " >> ${FunctionPath}
190            echo "export RESOL_SBG=${RESOL_SBG}                  " >> ${FunctionPath}
191            echo "export listVarEnv=${listVarEnv}                " >> ${FunctionPath}
192            echo "export Script_Post_Output=${Script_Post_Output}" >> ${FunctionPath}
193#           if [ X${MASTER} = Xtitane ] ; then
194#             echo ". ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh" >> ${FunctionPath}
195#             echo ". ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh"     >> ${FunctionPath}
196#           fi
197            echo "IGCM_sys_MkdirWork ${POST_DIR}                 " >> ${FunctionPath}
198            echo "IGCM_debug_Verif_Exit_Post                     " >> ${FunctionPath}
199            echo "IGCM_sys_QsubPost create_ts                    " >> ${FunctionPath}
200#           if [ X${MASTER} = Xtitane ] ; then
201#             echo "EOF"                                           >> ${FunctionPath}
202#           fi
203          fi
204        else
205          IGCM_sys_RshPost <<-EOF
206                    export DEBUG_debug=${DEBUG_debug}
207                    export MODIPSL=${MODIPSL}
208                    export libIGCM_SX=${libIGCM}
209                    export libIGCM=${libIGCM_POST}
210                    export SUBMIT_DIR=${SUBMIT_DIR}
211                    export POST_DIR=${POST_DIR}
212                    export MASTER=${MASTER}
213                    export RebuildFrequency=${RebuildFrequency}
214                    export DateBegin=${DateBegin}
215                    export PeriodDateEnd=${PeriodDateEnd}
216                    export StandAlone=false
217                    export CompletedFlag=${CompletedFlag}
218                    export TsTask=${TsTask}
219                    unset  CompToRead
220                    unset  FlagToRead
221                    export RESOL_ATM=${RESOL_ATM}
222                    export RESOL_OCE=${RESOL_OCE}
223                    export RESOL_ICE=${RESOL_ICE}
224                    export RESOL_MBG=${RESOL_MBG}
225                    export RESOL_SRF=${RESOL_SRF}
226                    export RESOL_SBG=${RESOL_SBG}
227                    export listVarEnv=${listVarEnv}
228                    export Script_Post_Output=${Script_Post_Output}
229                    . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
230                    . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
231                    IGCM_sys_MkdirWork ${POST_DIR}
232                    IGCM_debug_Verif_Exit_Post
233                    IGCM_sys_QsubPost create_ts
234EOF
235        fi
236      fi
237      #
238      if [ X$( eval echo \${TimeSeriesChunck${Dimension}} ) = Xtrue ] ; then
239        #
240        IGCM_debug_Print 1 "TIME SERIES POST-PROCESSING ${Dimension} WITH CHUNCK ACTIVATED"
241        echo
242        # Need to Remember This One
243        SavedDateBegin=${DateBegin}
244        # Kind of task create_ts will perform
245        TsTask=Chunck${Dimension}
246        # Number of chunck jobs to configure and submit
247        eval NbJob=\${#CHUNCK${Dimension}_COMP[@]}
248        typeset i
249        i=0
250        until [ $i -ge $NbJob ]; do
251          CompToRead=$( eval echo \${CHUNCK${Dimension}_COMP[\${i}]} )
252          FlagToRead=$( eval echo \${CHUNCK${Dimension}_FLAG[\${i}]} )
253          NameToRead=$( eval echo \${CHUNCK${Dimension}_NAME[\${i}]} )
254          ChunckSize=$( eval echo \${CHUNCK${Dimension}_SIZE[\${i}]} )
255          # Chunck Length (mandatory in Year)
256          YearsChunckLength=$( echo ${ChunckSize} | sed -e "s/[yY]//" )
257          #
258          IGCM_date_GetYearMonth ${DateBegin}     YearBegin MonthBegin
259          #
260          IGCM_date_GetYearMonth ${PeriodDateEnd} YearEnd   MonthEnd
261          # How many chunck in total since simulation began
262          NbYearsChunckLoop=$(( ( ${YearEnd} - ${YearBegin} + 1 ) / ${YearsChunckLength} ))
263          #  Tweak special case
264          [ $(( ( ${YearEnd} - ${YearBegin} + 1 ) % ${YearsChunckLength} )) = 0 ] && NbYearsChunckLoop=$(( ${NbYearsChunckLoop} - 1 ))
265          # Starting Year of the current chunck
266          ChunckTsYearBegin=$(( ${NbYearsChunckLoop} * ${YearsChunckLength} + ${YearBegin} ))
267          # Starting date of the current chunck
268          ChunckTsDateBegin=${ChunckTsYearBegin}${MonthBegin}01
269          #
270          Script_Post_Output=create_ts.${PeriodDateEnd}.${TsTask}.${CompToRead}.${NameToRead}
271          #
272          if [ ${RebuildFrequency} = true ] ; then
273            #
274            if [ ${PackFrequency} = true ] ; then
275              FunctionPath=${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
276            else
277              FunctionPath=${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
278            fi
279            #
280            if [ -f ${FunctionPath} ] ; then
281#             if [ X${MASTER} = Xtitane ] ; then
282#               echo "IGCM_sys_RshPost <<-EOF"                       >> ${FunctionPath}
283#             fi
284              echo "export DEBUG_debug=${DEBUG_debug}              " >> ${FunctionPath}
285              echo "export MODIPSL=${MODIPSL}                      " >> ${FunctionPath}
286              echo "export libIGCM_SX=${libIGCM}                   " >> ${FunctionPath}
287              echo "export libIGCM=${libIGCM_POST}                 " >> ${FunctionPath}
288              echo "export SUBMIT_DIR=${SUBMIT_DIR}                " >> ${FunctionPath}
289              echo "export POST_DIR=${POST_DIR}                    " >> ${FunctionPath}
290              echo "export MASTER=${MASTER}                        " >> ${FunctionPath}
291              echo "export RebuildFrequency=${RebuildFrequency}    " >> ${FunctionPath}
292              echo "export DateBegin=${ChunckTsDateBegin}          " >> ${FunctionPath}
293              echo "export PeriodDateEnd=${PeriodDateEnd}          " >> ${FunctionPath}
294              echo "export StandAlone=false                        " >> ${FunctionPath}
295              echo "export CompletedFlag=${CompletedFlag}          " >> ${FunctionPath}
296              echo "export TsTask=${TsTask}                        " >> ${FunctionPath}
297              echo "export CompToRead=${CompToRead}                " >> ${FunctionPath}
298              echo "export FlagToRead=${FlagToRead}                " >> ${FunctionPath}
299              echo "export RESOL_ATM=${RESOL_ATM}                  " >> ${FunctionPath}
300              echo "export RESOL_OCE=${RESOL_OCE}                  " >> ${FunctionPath}
301              echo "export RESOL_ICE=${RESOL_ICE}                  " >> ${FunctionPath}
302              echo "export RESOL_MBG=${RESOL_MBG}                  " >> ${FunctionPath}
303              echo "export RESOL_SRF=${RESOL_SRF}                  " >> ${FunctionPath}
304              echo "export RESOL_SBG=${RESOL_SBG}                  " >> ${FunctionPath}
305              echo "export listVarEnv=${listVarEnv}                " >> ${FunctionPath}
306              echo "export Script_Post_Output=${Script_Post_Output}" >> ${FunctionPath}
307#             if [ X${MASTER} = Xtitane ] ; then
308#               echo ". ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh" >> ${FunctionPath}
309#               echo ". ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh"     >> ${FunctionPath}
310#             fi
311              echo "IGCM_sys_MkdirWork ${POST_DIR}                 " >> ${FunctionPath}
312              echo "IGCM_debug_Verif_Exit_Post                     " >> ${FunctionPath}
313              echo "IGCM_sys_QsubPost create_ts                    " >> ${FunctionPath}
314#             if [ X${MASTER} = Xtitane ] ; then
315#               echo "EOF"                                           >> ${FunctionPath}
316#             fi
317            fi
318          else
319            IGCM_sys_RshPost <<-EOF
320                        export DEBUG_debug=${DEBUG_debug}
321                        export MODIPSL=${MODIPSL}
322                        export libIGCM_SX=${libIGCM}
323                        export libIGCM=${libIGCM_POST}
324                        export SUBMIT_DIR=${SUBMIT_DIR}
325                        export POST_DIR=${POST_DIR}
326                        export MASTER=${MASTER}
327                        export RebuildFrequency=${RebuildFrequency}
328                        export DateBegin=${ChunckTsDateBegin}
329                        export PeriodDateEnd=${PeriodDateEnd}
330                        export StandAlone=false
331                        export CompletedFlag=${CompletedFlag}
332                        export TsTask=${TsTask}
333                        export CompToRead=${CompToRead}
334                        export FlagToRead=${FlagToRead}
335                        export RESOL_ATM=${RESOL_ATM}
336                        export RESOL_OCE=${RESOL_OCE}
337                        export RESOL_ICE=${RESOL_ICE}
338                        export RESOL_MBG=${RESOL_MBG}
339                        export RESOL_SRF=${RESOL_SRF}
340                        export RESOL_SBG=${RESOL_SBG}
341                        export listVarEnv=${listVarEnv}
342                        export Script_Post_Output=${Script_Post_Output}
343                        . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
344                        . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
345                        IGCM_sys_MkdirWork ${POST_DIR}
346                        IGCM_debug_Verif_Exit_Post
347                        IGCM_sys_QsubPost create_ts
348EOF
349            #
350          fi
351          #
352          export DateBegin=${SavedDateBegin}
353          #
354          (( i=i+1 ))
355          #
356        done
357      fi
358      (( j=j+1 ))
359    done
360  fi
361
362  #=============  SEASONAL POST-PROCESSING ============#
363  if [ ${SeasonalFrequency} = true ] ; then
364    #
365    IGCM_debug_Print 1 "SEASONNAL POST-PROCESSING"
366    echo
367    #
368    Script_Post_Output=create_se.${PeriodDateEnd}
369    #
370    listVarEnv="DEBUG_debug,MODIPSL,libIGCM,libIGCM_SX,SUBMIT_DIR,POST_DIR,MASTER,RebuildFrequency,DateBegin,PeriodDateEnd,StandAlone,RESOL_ATM,RESOL_OCE,RESOL_ICE,RESOL_MBG,RESOL_SRF,RESOL_SBG"
371
372    if [ ${RebuildFrequency} = true ] ; then
373      #
374      if [ ${PackFrequency} = true ] ; then
375        FunctionPath=${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
376      else
377        FunctionPath=${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
378      fi
379      #
380      if [ -f ${FunctionPath} ] ; then
381      #
382#     if [ X${MASTER} = Xtitane ] ; then
383#       echo "IGCM_sys_RshPost <<-EOF"                     >> ${FunctionPath}
384#     fi
385      echo "export DEBUG_debug=${DEBUG_debug}              " >> ${FunctionPath}
386      echo "export MODIPSL=${MODIPSL}                      " >> ${FunctionPath}
387      echo "export libIGCM_SX=${libIGCM}                   " >> ${FunctionPath}
388      echo "export libIGCM=${libIGCM_POST}                 " >> ${FunctionPath}
389      echo "export SUBMIT_DIR=${SUBMIT_DIR}                " >> ${FunctionPath}
390      echo "export POST_DIR=${POST_DIR}                    " >> ${FunctionPath}
391      echo "export MASTER=${MASTER}                        " >> ${FunctionPath}
392      echo "export RebuildFrequency=${RebuildFrequency}    " >> ${FunctionPath}
393      echo "export DateBegin=${DateBegin}                  " >> ${FunctionPath}
394      echo "export PeriodDateEnd=${PeriodDateEnd}          " >> ${FunctionPath}
395      echo "export StandAlone=false                        " >> ${FunctionPath}
396      echo "export RESOL_ATM=${RESOL_ATM}                  " >> ${FunctionPath}
397      echo "export RESOL_OCE=${RESOL_OCE}                  " >> ${FunctionPath}
398      echo "export RESOL_ICE=${RESOL_ICE}                  " >> ${FunctionPath}
399      echo "export RESOL_MBG=${RESOL_MBG}                  " >> ${FunctionPath}
400      echo "export RESOL_SRF=${RESOL_SRF}                  " >> ${FunctionPath}
401      echo "export RESOL_SBG=${RESOL_SBG}                  " >> ${FunctionPath}
402      echo "export listVarEnv=${listVarEnv}                " >> ${FunctionPath}
403      echo "export Script_Post_Output=${Script_Post_Output}" >> ${FunctionPath}
404#     if [ X${MASTER} = Xtitane ] ; then
405#       echo ". ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh" >> ${FunctionPath}
406#       echo ". ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh"     >> ${FunctionPath}
407#     fi
408      echo "IGCM_sys_MkdirWork ${POST_DIR}                 " >> ${FunctionPath}
409      echo "IGCM_debug_Verif_Exit_Post                     " >> ${FunctionPath}
410      echo "IGCM_sys_QsubPost create_se                    " >> ${FunctionPath}
411#     if [ X${MASTER} = Xtitane ] ; then
412#       echo "EOF"                                         >> ${FunctionPath}
413#     fi
414      fi
415    else
416      IGCM_sys_RshPost <<-EOF
417            export DEBUG_debug=${DEBUG_debug}
418            export MODIPSL=${MODIPSL}
419          export libIGCM_SX=${libIGCM}
420            export libIGCM=${libIGCM_POST}
421            export SUBMIT_DIR=${SUBMIT_DIR}
422            export POST_DIR=${POST_DIR}
423            export MASTER=${MASTER}
424            export RebuildFrequency=${RebuildFrequency}
425            export DateBegin=${DateBegin}
426            export PeriodDateEnd=${PeriodDateEnd}
427            export StandAlone=false
428            export RESOL_ATM=${RESOL_ATM}
429            export RESOL_OCE=${RESOL_OCE}
430            export RESOL_ICE=${RESOL_ICE}
431            export RESOL_MBG=${RESOL_MBG}
432            export RESOL_SRF=${RESOL_SRF}
433            export RESOL_SBG=${RESOL_SBG}
434            export listVarEnv=${listVarEnv}
435            export Script_Post_Output=${Script_Post_Output}
436            . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
437            . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
438            IGCM_sys_MkdirWork ${POST_DIR}
439            IGCM_debug_Verif_Exit_Post
440            IGCM_sys_QsubPost create_se
441EOF
442    fi
443  fi
444
445  #============== PACK PROCESSING FOR RESTART, DEBUG AND OUTPUT FILES =============#
446  if [ ${PackFrequency} = true ] ; then
447    IGCM_debug_Print 1 "PACK POST-PROCESSING"
448    # -----------------------------------------------------------------------------------
449    # Function IGCM_FlushPost called by pack_output.job has not been closed yet. Do it now
450    # Will submit Time Series OR Seasonal Average if needed
451    # -----------------------------------------------------------------------------------
452    if [ -f ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh ] ; then
453      echo "IGCM_debug_PopStack \"IGCM_FlushPost\" " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
454      echo "}                                      " >> ${R_BUFR}/FlushPost_${PeriodDateEnd}.ksh
455    fi
456    echo
457    ## Need to Remember This One
458    SavedDateBegin=${DateBegin}
459    ## Need to Remember This One
460    SavedDateEnd=${DateEnd}
461    #
462    DaysTemp=$(( $( IGCM_date_DaysInPreviousPeriod ${PeriodDateEnd} ${config_Post_PackFrequency} end ) - 1 ))
463    #
464    PackDateBegin=$( IGCM_date_AddDaysToGregorianDate ${PeriodDateEnd} -${DaysTemp} )
465    #
466    script=pack_debug
467    #
468    Script_Post_Output=${script}.${PeriodDateEnd}
469    #
470    listVarEnv="DEBUG_debug,MODIPSL,libIGCM,libIGCM_SX,SUBMIT_DIR,POST_DIR,MASTER,DateBegin,DateEnd,PeriodPack,StandAlone"
471    IGCM_sys_RshPost <<-EOF
472    export DEBUG_debug=${DEBUG_debug}
473    export MODIPSL=${MODIPSL}
474    export libIGCM_SX=${libIGCM}
475    export libIGCM=${libIGCM_POST}
476    export SUBMIT_DIR=${SUBMIT_DIR}
477    export POST_DIR=${POST_DIR}
478    export MASTER=${MASTER}
479    export DateBegin=${PackDateBegin}
480    export DateEnd=${PeriodDateEnd}
481    export PeriodPack=${config_Post_PackFrequency}
482    export StandAlone=false
483    export listVarEnv=${listVarEnv}
484    export Script_Post_Output=${Script_Post_Output}
485    . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
486    . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
487    IGCM_sys_MkdirWork ${POST_DIR}
488    IGCM_debug_Verif_Exit_Post
489    IGCM_sys_QsubPost ${script}
490EOF
491    #
492    script=pack_restart
493    #
494    Script_Post_Output=${script}.${PeriodDateEnd}
495    #
496      IGCM_sys_RshPost <<-EOF
497      export DEBUG_debug=${DEBUG_debug}
498      export MODIPSL=${MODIPSL}
499      export libIGCM_SX=${libIGCM}
500      export libIGCM=${libIGCM_POST}
501      export SUBMIT_DIR=${SUBMIT_DIR}
502      export POST_DIR=${POST_DIR}
503      export MASTER=${MASTER}
504      export DateBegin=${PackDateBegin}
505      export DateEnd=${PeriodDateEnd}
506      export PeriodPack=${config_Post_PackFrequency}
507      export StandAlone=false
508      export listVarEnv=${listVarEnv}
509      export Script_Post_Output=${Script_Post_Output}
510      . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
511      . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
512      IGCM_sys_MkdirWork ${POST_DIR}
513      IGCM_debug_Verif_Exit_Post
514      IGCM_sys_QsubPost ${script}
515EOF
516    #
517    script=pack_output
518    #
519    Script_Post_Output=${script}.${PeriodDateEnd}
520    #
521    if ( [ ${RebuildFrequency} = true ] && [ -f ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh ] ) ; then
522#       if [ X${MASTER} = Xtitane ] ; then
523#         echo "IGCM_sys_RshPost <<-EOF"                     >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
524#       fi
525      echo "export DEBUG_debug=${DEBUG_debug}              " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
526      echo "export MODIPSL=${MODIPSL}                      " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
527      echo "export libIGCM_SX=${libIGCM}                   " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
528      echo "export libIGCM=${libIGCM_POST}                 " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
529      echo "export SUBMIT_DIR=${SUBMIT_DIR}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
530      echo "export POST_DIR=${POST_DIR}                    " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
531      echo "export MASTER=${MASTER}                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
532      echo "export DateBegin=${PackDateBegin}              " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
533      echo "export DateEnd=${PeriodDateEnd}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
534      echo "export PeriodPack=${config_Post_PackFrequency} " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
535      echo "export StandAlone=false                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
536      echo "export listVarEnv=${listVarEnv}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
537      echo "export Script_Post_Output=${Script_Post_Output}" >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
538      echo "export script=${script}                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
539#       if [ X${MASTER} = Xtitane ] ; then
540#         echo ". ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh" >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
541#         echo ". ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh"     >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
542#       fi
543      echo "IGCM_sys_MkdirWork ${POST_DIR}                 " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
544      echo "IGCM_debug_Verif_Exit_Post                     " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
545      echo "IGCM_sys_QsubPost ${script}                    " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
546#       if [ X${MASTER} = Xtitane ] ; then
547#         echo "EOF"                                         >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
548#       fi
549    else
550      IGCM_sys_RshPost <<-EOF
551        export DEBUG_debug=${DEBUG_debug}
552        export MODIPSL=${MODIPSL}
553        export libIGCM_SX=${libIGCM}
554        export libIGCM=${libIGCM_POST}
555        export SUBMIT_DIR=${SUBMIT_DIR}
556        export POST_DIR=${POST_DIR}
557        export MASTER=${MASTER}
558        export DateBegin=${PackDateBegin}
559        export DateEnd=${PeriodDateEnd}
560        export PeriodPack=${config_Post_PackFrequency}
561        export StandAlone=false
562        export listVarEnv=${listVarEnv}
563        export Script_Post_Output=${Script_Post_Output}
564        . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
565        . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
566        IGCM_sys_MkdirWork ${POST_DIR}
567        IGCM_debug_Verif_Exit_Post
568        IGCM_sys_QsubPost ${script}
569EOF
570      export DateBegin=${SavedDateBegin}
571      export DateEnd=${SavedDateEnd}
572    fi
573  fi
574
575  #============== REBUILD POST-PROCESSING =============#
576  if ( [ X${AsynchronousRebuild} = Xtrue ] && [ -f ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh ] ) ; then
577    # -----------------------------------------------------------------------------------
578    # Function IGCM_FlushRebuild define in rebuild.ksh has not been closed yet. Do it now
579    # -----------------------------------------------------------------------------------
580    if [ ${DRYRUN} -le 1 ] ; then
581      echo "IGCM_debug_PopStack \"IGCM_FlushRebuild\" " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
582      echo "}                                         " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
583    fi
584    if [ X${config_Post_RebuildFromArchive} = Xtrue ] ; then
585      IGCM_sys_Put_Dir REBUILD_${PeriodDateBegin} ${REBUILD_DIR}
586    else
587      IGCM_sys_Mv      REBUILD_${PeriodDateBegin} ${REBUILD_DIR}
588    fi
589  fi
590  #
591  if [ ${RebuildFrequency} = true ] ; then
592    if ( [ X${config_Post_RebuildFromArchive} = Xtrue ] ) ; then
593      IGCM_debug_Print 1 "REBUILD POST-PROCESSING FROM ARCHIVE"
594      echo
595    else
596      IGCM_debug_Print 1 "REBUILD POST-PROCESSING FROM WORKDIR"
597      echo
598    fi
599    script=rebuild_fromWorkdir
600    #
601    Script_Post_Output=${script}.${PeriodDateEnd}
602    #
603    listVarEnv="DEBUG_debug,MODIPSL,libIGCM,libIGCM_SX,SUBMIT_DIR,REBUILD_DIR,POST_DIR,MASTER,RebuildFromArchive,DateBegin,PeriodDateBegin,PeriodDateEnd,NbRebuildDir,StandAlone,RESOL_ATM,RESOL_OCE,RESOL_ICE,RESOL_MBG,RESOL_SRF,RESOL_SBG"
604    IGCM_sys_RshPost <<-EOF
605      export DEBUG_debug=${DEBUG_debug}
606      export MODIPSL=${MODIPSL}
607      export libIGCM_SX=${libIGCM}
608      export libIGCM=${libIGCM_POST}
609      export SUBMIT_DIR=${SUBMIT_DIR}
610      export REBUILD_DIR=${REBUILD_DIR}
611      export POST_DIR=${POST_DIR}
612      export MASTER=${MASTER}
613      export RebuildFromArchive=${config_Post_RebuildFromArchive}
614      export DateBegin=${DateBegin}
615      export PeriodDateBegin=${PeriodDateBegin}
616      export PeriodDateEnd=${PeriodDateEnd}
617      export NbRebuildDir=${NbRebuildDir}
618      export StandAlone=false
619      export RESOL_ATM=${RESOL_ATM}
620      export RESOL_OCE=${RESOL_OCE}
621      export RESOL_ICE=${RESOL_ICE}
622      export RESOL_MBG=${RESOL_MBG}
623      export RESOL_SRF=${RESOL_SRF}
624      export RESOL_SBG=${RESOL_SBG}
625      export listVarEnv=${listVarEnv}
626      export Script_Post_Output=${Script_Post_Output}
627      . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
628      . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
629      IGCM_sys_MkdirWork ${POST_DIR}
630      IGCM_debug_Verif_Exit_Post
631      IGCM_sys_QsubPost ${script}
632EOF
633  fi
634  IGCM_debug_PopStack "IGCM_post_Submit"
635}
636
637#===================================
638function IGCM_post_CheckModuloFrequency
639{
640  IGCM_debug_PushStack "IGCM_post_CheckModuloFrequency" $*
641
642  # Used by IGCM_config_Check
643  # from 2 libIGCM compatible frequency (*Y, *M, *D, *y, *m, *d)
644  # Issue an exit instruction IGCM_debug_Exit if there modulo is not zero
645  # Input parameter are the name of the variable, not the frequency value itself
646  # example
647  # IGCM_post_ModuloFrequency config_Post_RebuildFrequency config_UserChoices_PeriodLength
648
649  typeset MasterName SlaveName MasterFrequency SlaveFrequency PeriodMasterYear PeriodMasterMonth PeriodMasterDay PeriodSlaveYear PeriodSlaveMonth PeriodSlaveDay
650
651  # Get the name of the variable
652  MasterName=$1
653  SlaveName=$2
654  # Get the value the above name points to
655  MasterFrequency=$( eval echo \${${1}} )
656  SlaveFrequency=$( eval echo \${${2}} )
657
658  IGCM_debug_Print 2 "IGCM_post_CheckModuloFrequency : Master=${MasterFrequency} Slave=${SlaveFrequency}"
659
660  case ${MasterFrequency} in
661  *y|*Y)
662    PeriodMasterYear=$( echo ${MasterFrequency} | sed -e "s/[yY]//" )
663    case ${SlaveFrequency} in
664    *Y|*y)
665      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
666      if ( [ ${PeriodSlaveYear} -gt ${PeriodMasterYear} ] || \
667      [ $(( ${PeriodMasterYear} % ${PeriodSlaveYear} )) -ne 0 ] );  then
668        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
669        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
670        IGCM_debug_Exit "Check your frequency"
671      else
672        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterYear} / ${PeriodSlaveYear} ))
673      fi ;;
674    *M|*m)
675      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
676      if ( [ ${PeriodSlaveMonth} -gt $(( ${PeriodMasterYear} * 12 )) ] || \
677        [ $(( ( ${PeriodMasterYear} * 12 ) % ${PeriodSlaveMonth} )) -ne 0 ] ) ; then
678        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
679        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
680        IGCM_debug_Exit "Check your frequency"
681      else
682        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( 12 * ${PeriodMasterYear} ) / ${PeriodSlaveMonth} ))
683      fi ;;
684    *D|*d)
685      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
686      NbDays=$( IGCM_date_DaysInYear ${year} )
687      if [ ${config_UserChoices_CalendarType} = 360d ] || [ ${config_UserChoices_CalendarType} = noleap ] ; then
688        if ( [ ${PeriodSlaveDay} -gt $(( ${PeriodMasterYear} * ${NbDays} )) ] || \
689          [ $(( ( ${PeriodMasterYear} * ${NbDays} ) % ${PeriodSlaveDay} )) -ne 0 ] ; ) then
690          IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
691          IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
692          IGCM_debug_Exit "Check your frequency"
693        fi
694      else
695        IGCM_debug_Print 1 "For ${MasterName} with leap calendar:"
696        IGCM_debug_Print 1 "We have a daily ${SlaveName} frequency and ${MasterName}=${MasterFrequency}"
697        IGCM_debug_Print 1 "No post-treatment. Case not properly handle at this moment by libIGCM. Sorry"
698        IGCM_debug_Exit    "Check your frequency ${MasterName} and choose a daily frequency for this one too."
699      fi ;;
700    esac ;;
701  *M|*m)
702    PeriodMasterMonth=$( echo ${MasterFrequency} | sed -e "s/[mM]//" )
703    case ${SlaveFrequency} in
704    *Y|*y)
705      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
706      if ( [ ${PeriodMasterMonth} -gt $(( ${PeriodSlaveYear} * 12 )) ] || \
707        [ $(( ${PeriodMasterMonth} % ( ${PeriodSlaveYear} * 12 ) )) -ne 0 ] ) ; then
708        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
709        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
710        IGCM_debug_Exit "Check your frequency"
711      else
712        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ( 12 * ${PeriodSlaveYear} ) ))
713      fi ;;
714    *M|*m)
715      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
716      if ( [ ${PeriodSlaveMonth} -gt ${PeriodMasterMonth} ] || \
717        [ $(( ${PeriodMasterMonth} % ${PeriodSlaveMonth} )) -ne 0 ] ) ;  then         
718        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
719        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
720        IGCM_debug_Exit "Check your frequency"
721      else
722        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ${PeriodSlaveMonth} ))
723      fi ;;
724    *D|*d)
725      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
726      IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
727      IGCM_debug_Exit "Check your frequency" ;;
728    esac ;;
729  *D|*d)
730    PeriodMasterDay=$( echo ${MasterFrequency} | sed -e "s/[dD]//" )
731    case ${SlaveFrequency} in
732    *Y|*y)
733      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
734      IGCM_debug_Print 1 "${MasterName} frequency ${MasterFrequency}"
735      IGCM_debug_Exit "Check your frequency" ;;
736    *M|*m)
737      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
738      IGCM_debug_Print 1 "${MasterName} frequency ${MasterFrequency}"
739      IGCM_debug_Exit "Check your frequency" ;;
740    *D|*d)
741      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
742      if ( [ ${PeriodSlaveDay} -gt ${PeriodMasterDay} ] || \
743        [ $(( ${PeriodMasterDay} % ${PeriodSlaveDay} )) -ne 0 ] ) ;  then
744        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
745        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
746        IGCM_debug_Exit "Check your frequency"
747      else
748        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterDay} / ${PeriodSlaveDay} ))
749      fi ;;
750    esac ;;
751  NONE|none)
752    ;;
753  *)
754    IGCM_debug_Print 1 "KeyWord ${MasterFrequency} not allowed for ${MasterName} in config.card"
755    IGCM_debug_Exit "Check your ${MasterName} in config.card" ;;
756  esac
757
758  IGCM_debug_PopStack "IGCM_post_CheckModuloFrequency"
759}
760
761#===================================
762function IGCM_post_ModuloRuntimeFrequency
763{
764  IGCM_debug_PushStack "IGCM_post_ModuloRuntimeFrequency" $*
765
766  # Used by IGCM_post_Configure
767  # - from libIGCM (config_UserChoices_PeriodLength frequency * CumulPeriod) and
768  # - post-processing compatible frequency (*Y, *M, *D, *y, *m, *d)
769  # --> turn on post-processing submission when their modulo is zero
770  # Input parameter are the name of the variable, not the frequency value itself
771  # example
772  # IGCM_post_ModuloRuntimeFrequency config_Post_SeasonalFrequency config_UserChoices_PeriodLength
773
774  typeset MasterName SlaveName MasterFrequency SlaveFrequency PeriodMasterYear PeriodMasterMonth PeriodMasterDay PeriodSlaveYear PeriodSlaveMonth PeriodSlaveDay
775
776  # Get the name of the variable
777  MasterName=$1
778  SlaveName=$2
779  # Get the value the above name points to
780  eval MasterFrequency=\${${1}}
781  eval SlaveFrequency=\${${2}}
782
783  echo
784  IGCM_debug_Print 2 "IGCM_post_ModuloRuntimeFrequency : Master=${MasterFrequency} Slave=${SlaveFrequency} CumulPeriod=${CumulPeriod}"
785
786  case ${MasterFrequency} in
787  *y|*Y)
788    PeriodMasterYear=$( echo ${MasterFrequency} | sed -e "s/[yY]//" )
789    case ${SlaveFrequency} in
790    *Y|*y)
791      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
792      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveYear} - ${PeriodOffset} ) % ${PeriodMasterYear} )) -eq 0 ] ;  then
793        if [ $(( ${CumulPeriod} * ${PeriodSlaveYear} - ${PeriodOffset} )) -ne 0 ] ; then
794          eval ${post_freq}=true ; POST=true
795          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterYear} / ${PeriodSlaveYear} ))
796        fi
797      fi;;
798    *M|*m)
799      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
800      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} * 12 ) % ( ${PeriodMasterYear} * 12 ) )) -eq 0 ] ; then
801        if [ $(( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} * 12 )) -ne 0 ] ; then
802          eval ${post_freq}=true ; POST=true
803          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( 12 * ${PeriodMasterYear} ) / ${PeriodSlaveMonth} ))
804        fi
805      fi;;
806    *D|*d)
807      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
808      NbDays=$( IGCM_date_DaysInYear ${year} )
809      if [ $(( ( ${CumulPeriod} - ( ${PeriodOffset} * ${NbDays} / ${PeriodSlaveDay} ) ) % ( ${NbDays} * ${PeriodMasterYear} / ${PeriodSlaveDay} ) )) -eq 0 ] ; then
810        if [ $(( ${CumulPeriod} - ( ${PeriodOffset} * ${NbDays} / ${PeriodSlaveDay} ) )) -ne 0 ] ; then
811          eval ${post_freq}=true ; POST=true
812          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( ${NbDays} * ${PeriodMasterYear} ) / ${PeriodSlaveDay} ))
813        fi
814      fi;;
815    esac ;;
816  *M|*m)
817    PeriodMasterMonth=$( echo ${MasterFrequency} | sed -e "s/[mM]//" )
818    case ${SlaveFrequency} in
819    *Y|*y)
820      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
821      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveYear} * 12 - ${PeriodOffset} ) % ( ${PeriodMasterMonth} ) )) -eq 0 ] ; then
822        if [ $(( ${CumulPeriod} * ${PeriodSlaveYear} * 12 - ${PeriodOffset} )) -ne 0 ] ; then
823          eval ${post_freq}=true ; POST=true
824          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ( 12 * ${PeriodSlaveYear} ) ))
825        fi
826      fi;;
827    *M|*m)
828      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
829      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} ) % ${PeriodMasterMonth} )) -eq 0 ] ;  then
830        if [ $(( ${CumulPeriod} * ${PeriodSlaveMonth} -  ${PeriodOffset} )) -ne 0 ] ; then
831          eval ${post_freq}=true ; POST=true
832          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ${PeriodSlaveMonth} ))
833        fi
834      fi;;
835    *D|*d)
836      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
837      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
838    esac ;;
839  *D|*d)
840    PeriodMasterDay=$( echo ${MasterFrequency} | sed -e "s/[dD]//" )
841    case ${SlaveFrequency} in
842    *Y|*y)
843      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
844      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
845    *M|*m)
846      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
847      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
848    *D|*d)
849      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
850      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveDay} - ${PeriodOffset} ) % ${PeriodMasterDay} )) -eq 0 ] ;  then
851        if [ $(( ${CumulPeriod} * ${PeriodSlaveDay} - ${PeriodOffset} )) -ne 0 ] ; then
852          eval ${post_freq}=true ; POST=true
853          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterDay} / ${PeriodSlaveDay} ))
854        fi
855      fi;;
856    esac ;;
857  NONE|none)
858    ;;
859  *)
860    IGCM_debug_Print 1 "KeyWord not allowed for ${post_freq} in config.card"
861    ;;
862  esac
863
864  IGCM_debug_PopStack "IGCM_post_ModuloRuntimeFrequency"
865}
Note: See TracBrowser for help on using the repository browser.