source: CONFIG_DEVT/IPSLCM6.5_work_ENSEMBLES/libIGCM/libIGCM_post/libIGCM_post.ksh @ 6122

Last change on this file since 6122 was 6122, checked in by aclsce, 2 years ago

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