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

Last change on this file since 786 was 786, checked in by labetoulle, 11 years ago

Cosmetics :

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