1 | #!/bin/bash |
---|
2 | ######################################################################## |
---|
3 | ######## Library of bash functions for the PEM launching script ######## |
---|
4 | ######################################################################## |
---|
5 | |
---|
6 | # To end the launching script |
---|
7 | endlaunch() { |
---|
8 | # Restore the previous value of LC_NUMERIC |
---|
9 | LC_NUMERIC=$OLD_LC_NUMERIC |
---|
10 | |
---|
11 | date |
---|
12 | echo "Successful end of the launching script for the PEM simulation." |
---|
13 | exit 0 |
---|
14 | } |
---|
15 | |
---|
16 | # To end the launching script with error |
---|
17 | errlaunch() { |
---|
18 | # Restore the previous value of LC_NUMERIC |
---|
19 | LC_NUMERIC=$OLD_LC_NUMERIC |
---|
20 | |
---|
21 | date |
---|
22 | echo "End with error of the launching script for the PEM." |
---|
23 | exit 1 |
---|
24 | } |
---|
25 | |
---|
26 | # To check what is the job scheduler |
---|
27 | function job_scheduler() { |
---|
28 | if command -v squeue &> /dev/null; then |
---|
29 | echo "SLURM is installed on $machine." |
---|
30 | name_job="#SBATCH --job-name=" |
---|
31 | kill_job="scancel" |
---|
32 | submit_job="sbatch --parsable" |
---|
33 | submit_dependjob="sbatch --parsable --dependency" |
---|
34 | elif command -v qstat &> /dev/null; then |
---|
35 | echo "PBS/TORQUE is installed on $machine." |
---|
36 | name_job="#PBS -N " |
---|
37 | kill_job="qdel" |
---|
38 | submit_job="qsub" |
---|
39 | submit_dependjob="qsub -W depend" |
---|
40 | else |
---|
41 | echo "Error: neither SLURM nor TORQUE/PBS is installed on $machine!" |
---|
42 | echo "You need to adapt the script to your job scheduler." |
---|
43 | errlaunch |
---|
44 | fi |
---|
45 | } |
---|
46 | |
---|
47 | # To check if everything necessary for the launching script is ok |
---|
48 | checklaunch() { |
---|
49 | # Save the current value of LC_NUMERIC and set it to a locale that uses a dot as the decimal separator |
---|
50 | OLD_LC_NUMERIC=$LC_NUMERIC |
---|
51 | LC_NUMERIC=en_US.UTF-8 |
---|
52 | |
---|
53 | if [ -v n_mars_years ] && [ ! -z "$n_mars_years" ]; then |
---|
54 | if [ $(echo "$n_mars_years < 0." | bc -l) -eq 1 ]; then |
---|
55 | echo "Error: the value of 'n_mars_years' must be >0!" |
---|
56 | errlaunch |
---|
57 | fi |
---|
58 | elif [ -v n_earth_years ] && [ ! -z "$n_earth_years" ]; then |
---|
59 | if [ $(echo "$n_earth_years < 0." | bc -l) -eq 1 ]; then |
---|
60 | echo "Error: the value of 'n_earth_years' must be >0!" |
---|
61 | errlaunch |
---|
62 | fi |
---|
63 | else |
---|
64 | echo "Error: no number of years to be simulated has been set!" |
---|
65 | errlaunch |
---|
66 | fi |
---|
67 | if [ $nPCM_ini -lt 2 ] || [ -z "$nPCM_ini" ]; then |
---|
68 | echo "Error: the value of 'nPCM_ini' must be >1!" |
---|
69 | errlaunch |
---|
70 | fi |
---|
71 | if [ $nPCM -lt 2 ] || [ -z "$nPCM" ]; then |
---|
72 | echo "Error: the value of 'nPCM' must be >1!" |
---|
73 | errlaunch |
---|
74 | fi |
---|
75 | if [ ! -f "PCMrun.job" ]; then |
---|
76 | echo "Error: file \"PCMrun.job\" does not exist in $dir!" |
---|
77 | errlaunch |
---|
78 | fi |
---|
79 | if [ ! -f "PEMrun.job" ]; then |
---|
80 | echo "Error: file \"PEMrun.job\" does not exist in $dir!" |
---|
81 | errlaunch |
---|
82 | fi |
---|
83 | if [ ! -f "run_PCM.def" ]; then |
---|
84 | echo "Error: file \"run_PCM.def\" does not exist in $dir!" |
---|
85 | errlaunch |
---|
86 | fi |
---|
87 | if [ ! -f "run_PEM.def" ]; then |
---|
88 | echo "Error: file \"run_PEM.def\" does not exist in $dir!" |
---|
89 | errlaunch |
---|
90 | fi |
---|
91 | if [ ! -f "context_lmdz_physics.xml" ]; then |
---|
92 | echo "Error: file \"context_lmdz_physics.xml\" does not exist in $dir!" |
---|
93 | errlaunch |
---|
94 | fi |
---|
95 | if [ ! -f "field_def_physics_mars.xml" ]; then |
---|
96 | echo "Error: file \"field_def_physics_mars.xml\" does not exist in $dir!" |
---|
97 | errlaunch |
---|
98 | fi |
---|
99 | if [ ! -f "file_def_physics_mars.xml" ]; then |
---|
100 | echo "Error: file \"file_def_physics_mars.xml\" does not exist in $dir!" |
---|
101 | errlaunch |
---|
102 | fi |
---|
103 | if [ ! -f "iodef.xml" ]; then |
---|
104 | echo "Error: file \"iodef.xml\" does not exist in $dir!" |
---|
105 | errlaunch |
---|
106 | fi |
---|
107 | if [ ! -d "out_PCM" ]; then |
---|
108 | mkdir out_PCM |
---|
109 | fi |
---|
110 | if [ ! -d "out_PEM" ]; then |
---|
111 | mkdir out_PEM |
---|
112 | fi |
---|
113 | if [ ! -d "starts" ]; then |
---|
114 | mkdir starts |
---|
115 | fi |
---|
116 | if [ ! -d "diags" ]; then |
---|
117 | mkdir diags |
---|
118 | fi |
---|
119 | if [ $mode -ne 0 ]; then |
---|
120 | job_scheduler |
---|
121 | fi |
---|
122 | } |
---|
123 | |
---|
124 | # To convert Earth years into Mars years |
---|
125 | convertyears() { |
---|
126 | myear=686.9725 # Number of Earth days in Martian year |
---|
127 | eyear=365.256363004 # Number of days in Earth year |
---|
128 | convert_years=$(echo "$myear/$eyear" | bc -l) |
---|
129 | convert_years=$(printf "%.4f" $convert_years) # Rounding to the 4th decimal to respect the precision of Martian year |
---|
130 | if [ -v n_mars_years ]; then |
---|
131 | n_myear=$n_mars_years |
---|
132 | echo "Number of years to be simulated: $n_myear Martian years." |
---|
133 | elif [ -v n_earth_years ]; then |
---|
134 | n_myear=$(echo "$n_earth_years/$convert_years" | bc -l) |
---|
135 | echo "Number of years to be simulated: $n_earth_years Earth years = $n_myear Martian years." |
---|
136 | fi |
---|
137 | } |
---|
138 | |
---|
139 | # To initialize the launching script |
---|
140 | initlaunch() { |
---|
141 | echo "This is a chained simulation for PEM and PCM runs in $dir on $machine by $user." |
---|
142 | convertyears |
---|
143 | i_myear=0. |
---|
144 | iPEM=1 |
---|
145 | iPCM=1 |
---|
146 | cp startfi.nc starts/ |
---|
147 | if [ -f "start.nc" ]; then |
---|
148 | cp start.nc starts/ |
---|
149 | elif [ -f "star1D.nc" ]; then |
---|
150 | cp star1D.txt starts/ |
---|
151 | fi |
---|
152 | if [ -f "startpem.nc" ]; then |
---|
153 | cp startpem.nc starts/ |
---|
154 | fi |
---|
155 | |
---|
156 | # Create a file to manage years of the chained simulation and store some info from the PEM runs |
---|
157 | echo $i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini > info_PEM.txt |
---|
158 | } |
---|
159 | |
---|
160 | # To submit the PCM runs |
---|
161 | # arg1: launching mode |
---|
162 | # arg2: number of PCM runs to launch |
---|
163 | # arg3: local number of the PCM run from which to start (optional) |
---|
164 | submitPCM() { |
---|
165 | find . -type f -name "PCMrun*.job" ! -name "PCMrun.job" -delete |
---|
166 | ii=1 |
---|
167 | if [ ! -z $3 ]; then |
---|
168 | ii=$3 |
---|
169 | fi |
---|
170 | if [ $(echo "$i_myear < $n_myear" | bc -l) -eq 1 ]; then |
---|
171 | echo "Run PCM $iPCM: call $ii/$2..." |
---|
172 | if [ $1 -eq 0 ]; then # Mode: processing scripts |
---|
173 | sed -i "s/^k=[0-9]\+$/k=$(echo "3 - $nPCM_ini" | bc)/" PCMrun.job |
---|
174 | ./PCMrun.job |
---|
175 | if [ $? -ne 0 ]; then |
---|
176 | errlaunch |
---|
177 | fi |
---|
178 | else # Mode: submitting jobs |
---|
179 | cp PCMrun.job PCMrun${iPCM}.job |
---|
180 | sed -i -E "s/($name_job[^0-9]*[0-9]*[^0-9]*)[0-9]+$/\1${iPCM}/" PCMrun${iPCM}.job |
---|
181 | sed -i "s/^k=[0-9]\+$/k=$(echo "3 - $nPCM_ini" | bc)/" PCMrun${iPCM}.job |
---|
182 | jobID=$(eval "$submit_job PCMrun${iPCM}.job") |
---|
183 | # Create a file to cancel the dependent jobs of the cycle |
---|
184 | echo "#!/bin/bash" > kill_launchPEM.sh |
---|
185 | chmod +x kill_launchPEM.sh |
---|
186 | echo $kill_job $jobID >> kill_launchPEM.sh |
---|
187 | fi |
---|
188 | ((iPCM++)) |
---|
189 | i_myear=$(echo "$i_myear + 1." | bc -l) |
---|
190 | ((ii++)) |
---|
191 | else |
---|
192 | endlaunch |
---|
193 | fi |
---|
194 | for ((i = $ii; i <= $2; i++)); do |
---|
195 | if [ $(echo "$i_myear < $n_myear" | bc -l) -eq 1 ]; then |
---|
196 | echo "Run PCM $iPCM: call $i/$2..." |
---|
197 | if [ $1 -eq 0 ]; then # Mode: processing scripts |
---|
198 | sed -i "s/^k=[0-9]\+$/k=$(echo "$i + 2 - $nPCM_ini" | bc)/" PCMrun.job |
---|
199 | ./PCMrun.job |
---|
200 | if [ $? -ne 0 ]; then |
---|
201 | errlaunch |
---|
202 | fi |
---|
203 | else # Mode: submitting jobs |
---|
204 | cp PCMrun.job PCMrun${iPCM}.job |
---|
205 | sed -i -E "s/($name_job[^0-9]*[0-9]*[^0-9]*)[0-9]+$/\1${iPCM}/" PCMrun${iPCM}.job |
---|
206 | sed -i "s/^k=[0-9]\+$/k=$(echo "$i + 2 - $nPCM_ini" | bc)/" PCMrun${iPCM}.job |
---|
207 | jobID=$(eval "$submit_dependjob=afterok:${jobID} PCMrun${iPCM}.job") |
---|
208 | echo $kill_job $jobID >> kill_launchPEM.sh |
---|
209 | fi |
---|
210 | ((iPCM++)) |
---|
211 | i_myear=$(echo "$i_myear + 1." | bc -l) |
---|
212 | else |
---|
213 | endlaunch |
---|
214 | fi |
---|
215 | done |
---|
216 | } |
---|
217 | |
---|
218 | # To submit the PEM run |
---|
219 | # arg1: launching mode |
---|
220 | submitPEM() { |
---|
221 | if [ $(echo "$i_myear < $n_myear" | bc -l) -eq 1 ]; then |
---|
222 | echo "Run PEM $iPEM" |
---|
223 | if [ $1 -eq 0 ]; then # Mode: processing scripts |
---|
224 | ./PEMrun.job |
---|
225 | if [ $? -ne 0 ]; then |
---|
226 | errlaunch |
---|
227 | fi |
---|
228 | else # Mode: submitting jobs |
---|
229 | sed -i -E "s/($name_job[^0-9]*[0-9]*[^0-9]*)[0-9]+$/\1${iPEM}/" PEMrun.job |
---|
230 | jobID=$(eval "$submit_job PEMrun.job") |
---|
231 | # Create a file to cancel the dependent jobs of the cycle |
---|
232 | echo "#!/bin/bash" > kill_launchPEM.sh |
---|
233 | chmod +x kill_launchPEM.sh |
---|
234 | echo $kill_job $jobID >> kill_launchPEM.sh |
---|
235 | fi |
---|
236 | else |
---|
237 | endlaunch |
---|
238 | fi |
---|
239 | } |
---|
240 | |
---|
241 | # To make one cycle of PCM and PEM runs |
---|
242 | # arg1: launching mode |
---|
243 | # arg2: number of PCM runs to launch |
---|
244 | # arg3: local number of the PCM run from which to start (optional) |
---|
245 | cyclelaunch() { |
---|
246 | # PCM runs |
---|
247 | submitPCM $1 $2 $3 |
---|
248 | |
---|
249 | # PEM run |
---|
250 | if [ $(echo "$i_myear < $n_myear" | bc -l) -eq 1 ]; then |
---|
251 | echo "Run PEM $iPEM" |
---|
252 | if [ $1 -eq 0 ]; then # Mode: processing scripts |
---|
253 | ./PEMrun.job |
---|
254 | if [ $? -ne 0 ]; then |
---|
255 | errlaunch |
---|
256 | fi |
---|
257 | else # Mode: submitting jobs |
---|
258 | sed -i -E "s/($name_job[^0-9]*[0-9]*[^0-9]*)[0-9]+$/\1${iPEM}/" PEMrun.job |
---|
259 | jobID=$(eval "$submit_dependjob=afterok:${jobID} PEMrun.job") |
---|
260 | echo $kill_job $jobID >> kill_launchPEM.sh |
---|
261 | fi |
---|
262 | else |
---|
263 | endlaunch |
---|
264 | fi |
---|
265 | } |
---|
266 | |
---|
267 | # To clean files after the starting run of the relaunch |
---|
268 | # arg1: file name prefix to clean |
---|
269 | # arg2: file name extension to clean |
---|
270 | # arg3: file number from which to clean |
---|
271 | cleanfiles() { |
---|
272 | prefix=$1 |
---|
273 | extension=$2 |
---|
274 | if [ -z "$extension" ]; then |
---|
275 | for file in ${prefix}*; do |
---|
276 | num=${file#$prefix} |
---|
277 | if [[ $num =~ ^[0-9]+$ ]] && [ $num -gt $3 ]; then |
---|
278 | rm $file |
---|
279 | fi |
---|
280 | done |
---|
281 | else |
---|
282 | for file in ${prefix}*${extension}; do |
---|
283 | num=${file#$prefix} |
---|
284 | num=${num%$extension} |
---|
285 | if [[ $num =~ ^[0-9]+$ ]] && [ $num -gt $3 ]; then |
---|
286 | rm $file |
---|
287 | fi |
---|
288 | done |
---|
289 | fi |
---|
290 | } |
---|
291 | |
---|
292 | # To relaunch from PCM run |
---|
293 | # arg1: launching mode |
---|
294 | relaunchPCM() { |
---|
295 | iPCM=$(($irelaunch + 1)) |
---|
296 | cleanfiles diags/diagfi .nc $irelaunch |
---|
297 | cleanfiles diags/diagsoil .nc $irelaunch |
---|
298 | cleanfiles diags/data2reshape .nc $irelaunch |
---|
299 | cleanfiles "out_PCM/run" "" $irelaunch |
---|
300 | cleanfiles starts/restart1D .txt $irelaunch |
---|
301 | cleanfiles starts/restart .nc $irelaunch |
---|
302 | cleanfiles starts/restartfi .nc $irelaunch |
---|
303 | cp starts/restartfi${irelaunch}.nc startfi.nc |
---|
304 | if [ -f "starts/restart${irelaunch}.nc" ]; then |
---|
305 | cp starts/restart${irelaunch}.nc start.nc |
---|
306 | elif [ -f "starts/restart1D${irelaunch}.txt" ]; then |
---|
307 | cp starts/restart1D${irelaunch}.txt start1D.txt |
---|
308 | fi |
---|
309 | if [ $irelaunch -le $nPCM_ini ]; then |
---|
310 | # PCM relaunch during the initialization cycle |
---|
311 | iPEM=1 |
---|
312 | cleanfiles diags/diagpem .nc $(($iPEM - 1)) |
---|
313 | cleanfiles diags/diagsoilpem .nc $(($iPEM - 1)) |
---|
314 | cleanfiles "out_PEM/run" "" $(($iPEM - 1)) |
---|
315 | cleanfiles starts/restart1D_postPEM .txt $(($iPEM - 1)) |
---|
316 | cleanfiles starts/restart_postPEM .nc $(($iPEM - 1)) |
---|
317 | cleanfiles starts/restartfi_postPEM .nc $(($iPEM - 1)) |
---|
318 | cleanfiles starts/restartpem .nc $(($iPEM - 1)) |
---|
319 | i_myear=$irelaunch |
---|
320 | sed -i "1s/.*/$i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini/" info_PEM.txt |
---|
321 | rm -f startpem.nc |
---|
322 | if [ $irelaunch -eq $(($nPCM_ini - 1)) ]; then |
---|
323 | cp diags/data2reshape${irelaunch}.nc data2reshape_Y1.nc |
---|
324 | cyclelaunch $1 $nPCM_ini $iPCM |
---|
325 | elif [ $irelaunch -eq $nPCM_ini ]; then |
---|
326 | cp diags/data2reshape$(($irelaunch - 1)).nc data2reshape_Y1.nc |
---|
327 | cp diags/data2reshape${irelaunch}.nc data2reshape_Y2.nc |
---|
328 | submitPEM $1 # The next job is a PEM run |
---|
329 | else |
---|
330 | cyclelaunch $1 $nPCM_ini $iPCM |
---|
331 | fi |
---|
332 | else |
---|
333 | # PCM relaunch during a cycle |
---|
334 | iPEM=$(echo "($iPCM - $nPCM_ini)/$nPCM + 1" | bc) |
---|
335 | il=$(echo "($irelaunch - $nPCM_ini + 1)%$nPCM + 1" | bc) |
---|
336 | cleanfiles diags/diagpem .nc $(($iPEM - 1)) |
---|
337 | cleanfiles diags/diagsoilpem .nc $(($iPEM - 1)) |
---|
338 | cleanfiles "out_PEM/run" "" $(($iPEM - 1)) |
---|
339 | cleanfiles starts/restart1D_postPEM .txt $(($iPEM - 1)) |
---|
340 | cleanfiles starts/restart_postPEM .nc $(($iPEM - 1)) |
---|
341 | cleanfiles starts/restartfi_postPEM .nc $(($iPEM - 1)) |
---|
342 | cleanfiles starts/restartpem .nc $(($iPEM - 1)) |
---|
343 | cp starts/restartpem$(($iPEM - 1)).nc startpem.nc |
---|
344 | if [ $il -eq $(($nPCM - 1)) ]; then # Second to last PCM run |
---|
345 | i_myear=$(($(awk "NR==$iPEM {print \$1}" "info_PEM.txt") + $il)) |
---|
346 | sed -i "1s/.*/$i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini/" info_PEM.txt |
---|
347 | cp diags/data2reshape${irelaunch}.nc data2reshape_Y1.nc |
---|
348 | cyclelaunch $1 $nPCM $il |
---|
349 | elif [ $il -eq $nPCM ]; then # Last PCM run so the next job is a PEM run |
---|
350 | i_myear=$(($(awk "NR==$iPEM {print \$1}" "info_PEM.txt") + $nPCM)) |
---|
351 | sed -i "1s/.*/$i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini/" info_PEM.txt |
---|
352 | cp diags/data2reshape$(($irelaunch - 1)).nc data2reshape_Y1.nc |
---|
353 | cp diags/data2reshape${irelaunch}.nc data2reshape_Y2.nc |
---|
354 | submitPEM $1 |
---|
355 | else |
---|
356 | i_myear=$(($(awk "NR==$iPEM {print \$1}" "info_PEM.txt") + $il)) |
---|
357 | sed -i "1s/.*/$i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini/" info_PEM.txt |
---|
358 | cyclelaunch $1 $nPCM $il |
---|
359 | fi |
---|
360 | fi |
---|
361 | } |
---|
362 | |
---|
363 | # To relaunch from PEM run |
---|
364 | # arg1: launching mode |
---|
365 | relaunchPEM() { |
---|
366 | iPEM=$(echo "$irelaunch + 1" | bc) |
---|
367 | iPCM=$(echo "$nPCM_ini + $nPCM*($irelaunch - 1) + 1" | bc) |
---|
368 | i_myear=$(awk "NR==$(($iPEM + 1)) {print \$1}" "info_PEM.txt") |
---|
369 | sed -i "1s/.*/$i_myear $n_myear $convert_years $iPCM $iPEM $nPCM $nPCM_ini/" info_PEM.txt |
---|
370 | cleanfiles diags/diagfi .nc $(($iPCM - 1)) |
---|
371 | cleanfiles diags/diagsoil .nc $(($iPCM - 1)) |
---|
372 | cleanfiles "out_PCM/run" "" $(($iPCM - 1)) |
---|
373 | cleanfiles starts/restart1D .txt $(($iPCM - 1)) |
---|
374 | cleanfiles starts/restart .nc $(($iPCM - 1)) |
---|
375 | cleanfiles starts/restartfi .nc $(($iPCM - 1)) |
---|
376 | cleanfiles diags/data2reshape .nc $(($iPCM - 1)) |
---|
377 | cleanfiles diags/diagpem .nc $irelaunch |
---|
378 | cleanfiles diags/diagsoilpem .nc $irelaunch |
---|
379 | cleanfiles "out_PEM/run" "" $irelaunch |
---|
380 | cleanfiles starts/restart1D_postPEM .txt $irelaunch |
---|
381 | cleanfiles starts/restart_postPEM .nc $irelaunch |
---|
382 | cleanfiles starts/restartfi_postPEM .nc $irelaunch |
---|
383 | cleanfiles starts/restartpem .nc $irelaunch |
---|
384 | cp starts/restartpem${irelaunch}.nc startpem.nc |
---|
385 | cp starts/restartfi_postPEM${irelaunch}.nc startfi.nc |
---|
386 | if [ -f "starts/restart_postPEM${irelaunch}.nc" ]; then |
---|
387 | cp starts/restart_postPEM${irelaunch}.nc start.nc |
---|
388 | elif [ -f "starts/restart1D_postPEM${irelaunch}.txt" ]; then |
---|
389 | cp starts/restart1D_postPEM${irelaunch}.txt start1D.txt |
---|
390 | fi |
---|
391 | cyclelaunch $1 $nPCM |
---|
392 | } |
---|