source: trunk/libIGCM/libIGCM_post/libIGCM_post.ksh @ 1031

Last change on this file since 1031 was 1031, checked in by sdipsl, 10 years ago

See #187 RebuildFromArchive is deprecated
  • 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_card/libIGCM_card.ksh
487    . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
488    IGCM_sys_MkdirWork ${POST_DIR}
489    IGCM_debug_Verif_Exit_Post
490    IGCM_sys_QsubPost ${script}
491    IGCM_debug_Verif_Exit
492EOF
493    #
494    script=pack_restart
495    #
496    Script_Post_Output=${script}.${PeriodDateEnd}
497    #
498      IGCM_sys_RshPost <<-EOF
499      export DEBUG_debug=${DEBUG_debug}
500      export MODIPSL=${MODIPSL}
501      export libIGCM_SX=${libIGCM}
502      export libIGCM=${libIGCM_POST}
503      export SUBMIT_DIR=${SUBMIT_DIR}
504      export POST_DIR=${POST_DIR}
505      export MASTER=${MASTER}
506      export DateBegin=${PackDateBegin}
507      export DateEnd=${PeriodDateEnd}
508      export PeriodPack=${config_Post_PackFrequency}
509      export StandAlone=false
510      export listVarEnv=${listVarEnv}
511      export Script_Post_Output=${Script_Post_Output}
512      . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
513      . ${libIGCM_POST}/libIGCM_card/libIGCM_card.ksh
514      . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
515      IGCM_sys_MkdirWork ${POST_DIR}
516      IGCM_debug_Verif_Exit_Post
517      IGCM_sys_QsubPost ${script}
518      IGCM_debug_Verif_Exit
519EOF
520    #
521    script=pack_output
522    #
523    Script_Post_Output=${script}.${PeriodDateEnd}
524    #
525    if ( [ ${RebuildFrequency} = true ] && [ -f ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh ] ) ; then
526#       if [ X${MASTER} = Xtitane ] ; then
527#         echo "IGCM_sys_RshPost <<-EOF"                     >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
528#       fi
529      echo "export DEBUG_debug=${DEBUG_debug}              " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
530      echo "export MODIPSL=${MODIPSL}                      " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
531      echo "export libIGCM_SX=${libIGCM}                   " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
532      echo "export libIGCM=${libIGCM_POST}                 " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
533      echo "export SUBMIT_DIR=${SUBMIT_DIR}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
534      echo "export POST_DIR=${POST_DIR}                    " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
535      echo "export MASTER=${MASTER}                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
536      echo "export DateBegin=${PackDateBegin}              " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
537      echo "export DateEnd=${PeriodDateEnd}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
538      echo "export PeriodPack=${config_Post_PackFrequency} " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
539      echo "export StandAlone=false                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
540      echo "export listVarEnv=${listVarEnv}                " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
541      echo "export Script_Post_Output=${Script_Post_Output}" >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
542      echo "export script=${script}                        " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
543#       if [ X${MASTER} = Xtitane ] ; then
544#         echo ". ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh" >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
545#         echo ". ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh"     >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
546#       fi
547      echo "IGCM_sys_MkdirWork ${POST_DIR}                 " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
548      echo "IGCM_debug_Verif_Exit_Post                     " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
549      echo "IGCM_sys_QsubPost ${script}                    " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
550#       if [ X${MASTER} = Xtitane ] ; then
551#         echo "EOF"                                         >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
552#       fi
553      echo "IGCM_debug_Verif_Exit                          " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
554    else
555      IGCM_sys_RshPost <<-EOF
556        export DEBUG_debug=${DEBUG_debug}
557        export MODIPSL=${MODIPSL}
558        export libIGCM_SX=${libIGCM}
559        export libIGCM=${libIGCM_POST}
560        export SUBMIT_DIR=${SUBMIT_DIR}
561        export POST_DIR=${POST_DIR}
562        export MASTER=${MASTER}
563        export DateBegin=${PackDateBegin}
564        export DateEnd=${PeriodDateEnd}
565        export PeriodPack=${config_Post_PackFrequency}
566        export StandAlone=false
567        export listVarEnv=${listVarEnv}
568        export Script_Post_Output=${Script_Post_Output}
569        . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
570        . ${libIGCM_POST}/libIGCM_card/libIGCM_card.ksh
571        . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
572        IGCM_sys_MkdirWork ${POST_DIR}
573        IGCM_debug_Verif_Exit_Post
574        IGCM_sys_QsubPost ${script}
575        IGCM_debug_Verif_Exit
576EOF
577      export DateBegin=${SavedDateBegin}
578      export DateEnd=${SavedDateEnd}
579    fi
580  fi
581
582  #============== REBUILD POST-PROCESSING =============#
583  if ( [ X${AsynchronousRebuild} = Xtrue ] && [ -f ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh ] ) ; then
584    # -----------------------------------------------------------------------------------
585    # Function IGCM_FlushRebuild define in rebuild.ksh has not been closed yet. Do it now
586    # -----------------------------------------------------------------------------------
587    if [ ${DRYRUN} -le 1 ] ; then
588      echo "IGCM_debug_PopStack \"IGCM_FlushRebuild\" " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
589      echo "}                                         " >> ${RUN_DIR}/REBUILD_${PeriodDateBegin}/rebuild.ksh
590    fi
591    IGCM_sys_Mv      REBUILD_${PeriodDateBegin} ${REBUILD_DIR}
592  fi
593  #
594  if [ ${RebuildFrequency} = true ] ; then
595    IGCM_debug_Print 1 "REBUILD POST-PROCESSING FROM WORKDIR"
596    echo
597    script=rebuild_fromWorkdir
598    #
599    Script_Post_Output=${script}.${PeriodDateEnd}
600    #
601    listVarEnv="DEBUG_debug,MODIPSL,libIGCM,libIGCM_SX,SUBMIT_DIR,REBUILD_DIR,POST_DIR,MASTER,DateBegin,PeriodDateBegin,PeriodDateEnd,NbRebuildDir,StandAlone,RESOL_ATM,RESOL_OCE,RESOL_ICE,RESOL_MBG,RESOL_SRF,RESOL_SBG"
602    IGCM_sys_RshPost <<-EOF
603      export DEBUG_debug=${DEBUG_debug}
604      export MODIPSL=${MODIPSL}
605      export libIGCM_SX=${libIGCM}
606      export libIGCM=${libIGCM_POST}
607      export SUBMIT_DIR=${SUBMIT_DIR}
608      export REBUILD_DIR=${REBUILD_DIR}
609      export POST_DIR=${POST_DIR}
610      export MASTER=${MASTER}
611      export DateBegin=${DateBegin}
612      export PeriodDateBegin=${PeriodDateBegin}
613      export PeriodDateEnd=${PeriodDateEnd}
614      export NbRebuildDir=${NbRebuildDir}
615      export StandAlone=false
616      export RESOL_ATM=${RESOL_ATM}
617      export RESOL_OCE=${RESOL_OCE}
618      export RESOL_ICE=${RESOL_ICE}
619      export RESOL_MBG=${RESOL_MBG}
620      export RESOL_SRF=${RESOL_SRF}
621      export RESOL_SBG=${RESOL_SBG}
622      export listVarEnv=${listVarEnv}
623      export Script_Post_Output=${Script_Post_Output}
624      . ${libIGCM_POST}/libIGCM_debug/libIGCM_debug.ksh
625      . ${libIGCM_POST}/libIGCM_card/libIGCM_card.ksh
626      . ${libIGCM_POST}/libIGCM_sys/libIGCM_sys.ksh
627      IGCM_sys_MkdirWork ${POST_DIR}
628      IGCM_debug_Verif_Exit_Post
629      IGCM_sys_QsubPost ${script}
630      IGCM_debug_Verif_Exit
631EOF
632  fi
633  IGCM_debug_PopStack "IGCM_post_Submit"
634}
635
636#===================================
637function IGCM_post_CheckModuloFrequency
638{
639  IGCM_debug_PushStack "IGCM_post_CheckModuloFrequency" $*
640
641  # Used by IGCM_config_Check
642  # from 2 libIGCM compatible frequency (*Y, *M, *D, *y, *m, *d)
643  # Issue an exit instruction IGCM_debug_Exit if there modulo is not zero
644  # Input parameter are the name of the variable, not the frequency value itself
645  # example
646  # IGCM_post_ModuloFrequency config_Post_RebuildFrequency config_UserChoices_PeriodLength
647
648  typeset MasterName SlaveName MasterFrequency SlaveFrequency PeriodMasterYear PeriodMasterMonth PeriodMasterDay PeriodSlaveYear PeriodSlaveMonth PeriodSlaveDay
649
650  # Get the name of the variable
651  MasterName=$1
652  SlaveName=$2
653  # Get the value the above name points to
654  MasterFrequency=$( eval echo \${${1}} )
655  SlaveFrequency=$( eval echo \${${2}} )
656
657  IGCM_debug_Print 2 "IGCM_post_CheckModuloFrequency : Master=${MasterFrequency} Slave=${SlaveFrequency}"
658
659  case ${MasterFrequency} in
660  *y|*Y)
661    PeriodMasterYear=$( echo ${MasterFrequency} | sed -e "s/[yY]//" )
662    case ${SlaveFrequency} in
663    *Y|*y)
664      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
665      if ( [ ${PeriodSlaveYear} -gt ${PeriodMasterYear} ] || \
666      [ $(( ${PeriodMasterYear} % ${PeriodSlaveYear} )) -ne 0 ] );  then
667        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
668        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
669        IGCM_debug_Exit "Check your frequency"
670      else
671        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterYear} / ${PeriodSlaveYear} ))
672      fi ;;
673    *M|*m)
674      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
675      if ( [ ${PeriodSlaveMonth} -gt $(( ${PeriodMasterYear} * 12 )) ] || \
676        [ $(( ( ${PeriodMasterYear} * 12 ) % ${PeriodSlaveMonth} )) -ne 0 ] ) ; then
677        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
678        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
679        IGCM_debug_Exit "Check your frequency"
680      else
681        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( 12 * ${PeriodMasterYear} ) / ${PeriodSlaveMonth} ))
682      fi ;;
683    *D|*d)
684      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
685      NbDays=$( IGCM_date_DaysInYear ${year} )
686      if [ ${config_UserChoices_CalendarType} = 360d ] || [ ${config_UserChoices_CalendarType} = noleap ] ; then
687        if ( [ ${PeriodSlaveDay} -gt $(( ${PeriodMasterYear} * ${NbDays} )) ] || \
688          [ $(( ( ${PeriodMasterYear} * ${NbDays} ) % ${PeriodSlaveDay} )) -ne 0 ] ; ) then
689          IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
690          IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
691          IGCM_debug_Exit "Check your frequency"
692        fi
693      else
694        IGCM_debug_Print 1 "For ${MasterName} with leap calendar:"
695        IGCM_debug_Print 1 "We have a daily ${SlaveName} frequency and ${MasterName}=${MasterFrequency}"
696        IGCM_debug_Print 1 "No post-treatment. Case not properly handle at this moment by libIGCM. Sorry"
697        IGCM_debug_Exit    "Check your frequency ${MasterName} and choose a daily frequency for this one too."
698      fi ;;
699    esac ;;
700  *M|*m)
701    PeriodMasterMonth=$( echo ${MasterFrequency} | sed -e "s/[mM]//" )
702    case ${SlaveFrequency} in
703    *Y|*y)
704      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
705      if ( [ ${PeriodMasterMonth} -gt $(( ${PeriodSlaveYear} * 12 )) ] || \
706        [ $(( ${PeriodMasterMonth} % ( ${PeriodSlaveYear} * 12 ) )) -ne 0 ] ) ; then
707        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
708        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
709        IGCM_debug_Exit "Check your frequency"
710      else
711        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ( 12 * ${PeriodSlaveYear} ) ))
712      fi ;;
713    *M|*m)
714      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
715      if ( [ ${PeriodSlaveMonth} -gt ${PeriodMasterMonth} ] || \
716        [ $(( ${PeriodMasterMonth} % ${PeriodSlaveMonth} )) -ne 0 ] ) ;  then         
717        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
718        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
719        IGCM_debug_Exit "Check your frequency"
720      else
721        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ${PeriodSlaveMonth} ))
722      fi ;;
723    *D|*d)
724      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
725      IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
726      IGCM_debug_Exit "Check your frequency" ;;
727    esac ;;
728  *D|*d)
729    PeriodMasterDay=$( echo ${MasterFrequency} | sed -e "s/[dD]//" )
730    case ${SlaveFrequency} in
731    *Y|*y)
732      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
733      IGCM_debug_Print 1 "${MasterName} frequency ${MasterFrequency}"
734      IGCM_debug_Exit "Check your frequency" ;;
735    *M|*m)
736      IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
737      IGCM_debug_Print 1 "${MasterName} frequency ${MasterFrequency}"
738      IGCM_debug_Exit "Check your frequency" ;;
739    *D|*d)
740      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
741      if ( [ ${PeriodSlaveDay} -gt ${PeriodMasterDay} ] || \
742        [ $(( ${PeriodMasterDay} % ${PeriodSlaveDay} )) -ne 0 ] ) ;  then
743        IGCM_debug_Print 1 "${SlaveName} frequency ${SlaveFrequency} not compatbile with"
744        IGCM_debug_Print 1 "${MasterName} frequency : ${MasterFrequency}"
745        IGCM_debug_Exit "Check your frequency"
746      else
747        [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterDay} / ${PeriodSlaveDay} ))
748      fi ;;
749    esac ;;
750  NONE|none)
751    ;;
752  *)
753    IGCM_debug_Print 1 "KeyWord ${MasterFrequency} not allowed for ${MasterName} in config.card"
754    IGCM_debug_Exit "Check your ${MasterName} in config.card" ;;
755  esac
756
757  IGCM_debug_PopStack "IGCM_post_CheckModuloFrequency"
758}
759
760#===================================
761function IGCM_post_ModuloRuntimeFrequency
762{
763  IGCM_debug_PushStack "IGCM_post_ModuloRuntimeFrequency" $*
764
765  # Used by IGCM_post_Configure
766  # - from libIGCM (config_UserChoices_PeriodLength frequency * CumulPeriod) and
767  # - post-processing compatible frequency (*Y, *M, *D, *y, *m, *d)
768  # --> turn on post-processing submission when their modulo is zero
769  # Input parameter are the name of the variable, not the frequency value itself
770  # example
771  # IGCM_post_ModuloRuntimeFrequency config_Post_SeasonalFrequency config_UserChoices_PeriodLength
772
773  typeset MasterName SlaveName MasterFrequency SlaveFrequency PeriodMasterYear PeriodMasterMonth PeriodMasterDay PeriodSlaveYear PeriodSlaveMonth PeriodSlaveDay
774
775  # Get the name of the variable
776  MasterName=$1
777  SlaveName=$2
778  # Get the value the above name points to
779  eval MasterFrequency=\${${1}}
780  eval SlaveFrequency=\${${2}}
781
782  echo
783  IGCM_debug_Print 2 "IGCM_post_ModuloRuntimeFrequency : Master=${MasterFrequency} Slave=${SlaveFrequency} CumulPeriod=${CumulPeriod}"
784
785  case ${MasterFrequency} in
786  *y|*Y)
787    PeriodMasterYear=$( echo ${MasterFrequency} | sed -e "s/[yY]//" )
788    case ${SlaveFrequency} in
789    *Y|*y)
790      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
791      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveYear} - ${PeriodOffset} ) % ${PeriodMasterYear} )) -eq 0 ] ;  then
792        if [ $(( ${CumulPeriod} * ${PeriodSlaveYear} - ${PeriodOffset} )) -ne 0 ] ; then
793          eval ${post_freq}=true ; POST=true
794          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterYear} / ${PeriodSlaveYear} ))
795        fi
796      fi;;
797    *M|*m)
798      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
799      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} * 12 ) % ( ${PeriodMasterYear} * 12 ) )) -eq 0 ] ; then
800        if [ $(( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} * 12 )) -ne 0 ] ; then
801          eval ${post_freq}=true ; POST=true
802          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( 12 * ${PeriodMasterYear} ) / ${PeriodSlaveMonth} ))
803        fi
804      fi;;
805    *D|*d)
806      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
807      NbDays=$( IGCM_date_DaysInYear ${year} )
808      if [ $(( ( ${CumulPeriod} - ( ${PeriodOffset} * ${NbDays} / ${PeriodSlaveDay} ) ) % ( ${NbDays} * ${PeriodMasterYear} / ${PeriodSlaveDay} ) )) -eq 0 ] ; then
809        if [ $(( ${CumulPeriod} - ( ${PeriodOffset} * ${NbDays} / ${PeriodSlaveDay} ) )) -ne 0 ] ; then
810          eval ${post_freq}=true ; POST=true
811          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ( ${NbDays} * ${PeriodMasterYear} ) / ${PeriodSlaveDay} ))
812        fi
813      fi;;
814    esac ;;
815  *M|*m)
816    PeriodMasterMonth=$( echo ${MasterFrequency} | sed -e "s/[mM]//" )
817    case ${SlaveFrequency} in
818    *Y|*y)
819      PeriodSlaveYear=$( echo ${SlaveFrequency} | sed -e "s/[yY]//" )
820      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveYear} * 12 - ${PeriodOffset} ) % ( ${PeriodMasterMonth} ) )) -eq 0 ] ; then
821        if [ $(( ${CumulPeriod} * ${PeriodSlaveYear} * 12 - ${PeriodOffset} )) -ne 0 ] ; then
822          eval ${post_freq}=true ; POST=true
823          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ( 12 * ${PeriodSlaveYear} ) ))
824        fi
825      fi;;
826    *M|*m)
827      PeriodSlaveMonth=$( echo ${SlaveFrequency} | sed -e "s/[mM]//" )
828      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveMonth} - ${PeriodOffset} ) % ${PeriodMasterMonth} )) -eq 0 ] ;  then
829        if [ $(( ${CumulPeriod} * ${PeriodSlaveMonth} -  ${PeriodOffset} )) -ne 0 ] ; then
830          eval ${post_freq}=true ; POST=true
831          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterMonth} / ${PeriodSlaveMonth} ))
832        fi
833      fi;;
834    *D|*d)
835      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
836      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
837    esac ;;
838  *D|*d)
839    PeriodMasterDay=$( echo ${MasterFrequency} | sed -e "s/[dD]//" )
840    case ${SlaveFrequency} in
841    *Y|*y)
842      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
843      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
844    *M|*m)
845      IGCM_debug_Print 1 "PeriodLength frequency ${SlaveFrequency} not compatbile with"
846      IGCM_debug_Print 1 "${flag_post} frequency : ${MasterFrequency} " ;;
847    *D|*d)
848      PeriodSlaveDay=$( echo ${SlaveFrequency} | sed -e "s/[dD]//" )
849      if [ $(( ( ${CumulPeriod} * ${PeriodSlaveDay} - ${PeriodOffset} ) % ${PeriodMasterDay} )) -eq 0 ] ;  then
850        if [ $(( ${CumulPeriod} * ${PeriodSlaveDay} - ${PeriodOffset} )) -ne 0 ] ; then
851          eval ${post_freq}=true ; POST=true
852          [ X${3} = XNbPeriodPerFrequency ] && NbPeriodPerFrequency=$(( ${PeriodMasterDay} / ${PeriodSlaveDay} ))
853        fi
854      fi;;
855    esac ;;
856  NONE|none)
857    ;;
858  *)
859    IGCM_debug_Print 1 "KeyWord not allowed for ${post_freq} in config.card"
860    ;;
861  esac
862
863  IGCM_debug_PopStack "IGCM_post_ModuloRuntimeFrequency"
864}
Note: See TracBrowser for help on using the repository browser.