├── .gitignore ├── LICENSE ├── README.md ├── fortran_origin ├── .DS_Store ├── .pom2k.f.swo ├── IC.dat ├── box.txt ├── diff.txt ├── fort.40 ├── fort.71 ├── grid ├── params ├── pom2k.c ├── pom2k.f ├── pom2k.n ├── runpom2k ├── seamount.txt └── tags ├── manual ├── A Manual for POM.pdf ├── A Manual for POM.tex ├── A Small Part of POM's RBF.pdf ├── A Small Part of POM's RBF.tex └── llncs.cls ├── matlab_new_operator ├── AXB.m ├── AXF.m ├── AYB.m ├── AYF.m ├── AZB.m ├── AZF.m ├── DXB.m ├── DXF.m ├── DYB.m ├── DYF.m ├── DZB.m ├── DZF.m ├── Field.m ├── Grid.m ├── create_field.m ├── create_grid.m ├── init_grid.m ├── main.m └── shift.m ├── matlab_operator ├── AXB.m ├── AXB1.m ├── AXB2.m ├── AXF.m ├── AXF1.m ├── AXF2.m ├── AYB.m ├── AYF.m ├── AZB.m ├── AZF.m ├── AZF1.m ├── DIVISION.m ├── DXB.m ├── DXC.m ├── DXF.m ├── DYB.m ├── DYC.m ├── DYF.m ├── DZB.m ├── DZC.m ├── DZF.m ├── IC.dat ├── Operator.m ├── Rk1.m ├── Rk2.m ├── SUM1.m ├── SUM2.m ├── SUMZ1.m ├── SUMZ2.m ├── advave.m ├── advct.m ├── advq.m ├── advt1.m ├── advt2.m ├── advu.m ├── advv.m ├── areas_masks.m ├── baropg.m ├── bcond.m ├── bk_bcond.m ├── bk_bcondorl.m ├── box.m ├── dens.m ├── depth.m ├── file2ic.m ├── findpsi.m ├── gen_operator.m ├── pom2k.m ├── printall.m ├── profq.m ├── proft.m ├── profu.m ├── profv.m ├── prxy.m ├── prxyz.m ├── prxz.m ├── pryz.m ├── seamount.m ├── slpmax.m ├── smol_adif.m ├── vertvl.m └── write_to_file.m └── matlab_origin ├── advave.m ├── advct.m ├── advq.m ├── advt1.m ├── advt2.m ├── advu.m ├── advv.m ├── areas_masks.m ├── baropg.m ├── bcond.m ├── bcondorl.m ├── bianliang.m ├── box.m ├── dens.m ├── depth.m ├── file2ic.m ├── findpsi.m ├── pom2k.m ├── printall.m ├── profq.m ├── proft.m ├── profu.m ├── profv.m ├── prxy.m ├── prxyz.m ├── prxz.m ├── pryz.m ├── seamount.m ├── slpmax.m ├── smol_adif.m ├── vertvl.m └── write_to_file.m /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | *.smod 19 | 20 | # Compiled Static libraries 21 | *.lai 22 | *.la 23 | *.a 24 | *.lib 25 | 26 | # Executables 27 | *.exe 28 | *.out 29 | *.app 30 | 31 | *.mat 32 | 33 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 hxmhuang 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # pom2k_matlab 2 | Matlab code for pom2k ocean model 3 | -------------------------------------------------------------------------------- /fortran_origin/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AI4EarthLab/pom2k_matlab/339cfec2faab1c9f2c9863f85f0a9500bb66fa93/fortran_origin/.DS_Store -------------------------------------------------------------------------------- /fortran_origin/.pom2k.f.swo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AI4EarthLab/pom2k_matlab/339cfec2faab1c9f2c9863f85f0a9500bb66fa93/fortran_origin/.pom2k.f.swo -------------------------------------------------------------------------------- /fortran_origin/diff.txt: -------------------------------------------------------------------------------- 1 | 1c1 2 | < subroutine seamount 3 | --- 4 | > subroutine box 5 | 4c4 6 | < C * FUNCTION : Sets up for seamount problem. * 7 | --- 8 | > C * FUNCTION : Sets up conservation box problem. * 9 | 5a6,22 10 | > C * This basin uses the same grid as the seamount * 11 | > C * problem, but it has a flat bottom, is surrounded by * 12 | > C * walls and is initialised with uniform salinity and * 13 | > C * temperature. It is forced by a surface input of * 14 | > C * water of the same temperature and salinity as the * 15 | > C * water in the basin. Therefore, the temperature and * 16 | > C * salinity in the basin should not change, and the * 17 | > C * free surface should fall at a rate vflux. It is also* 18 | > C * forced by a steady atmospheric pressure field which * 19 | > C * depresses the southwestern half of the model by 1 m * 20 | > C * and elevates the northeastern half of the model by * 21 | > C * 1 m. * 22 | > C * * 23 | > C * Since this problem defines its own fixed e_atmos, * 24 | > C * tatm, satm and e_atmos, comment out corresponding * 25 | > C * declarations after the do 9000 statement in main * 26 | > C * program. * 27 | 12c29 28 | < real delh,delx,elejmid,elwjmid,ra,vel 29 | --- 30 | > real depth,delx,tatm,satm 31 | 15c32 32 | < C Set delh > 1.0 for an island or delh < 1.0 for a seamount: 33 | --- 34 | > C Water depth: 35 | 17c34 36 | < delh=0.90 37 | --- 38 | > depth=4500.0 39 | 23,30d39 40 | < C Radius island or seamount: 41 | < C 42 | < ra=25000.0 43 | < C 44 | < C Current velocity: 45 | < C 46 | < vel=0.20 47 | < C 48 | 194,202c203 49 | < C 50 | < h(i,j)=4500.0*(1.0-delh 51 | < $ *exp(-((east_c(i,j) 52 | < $ -east_c((im+1)/2,j))**2 53 | < $ +(north_c(i,j) 54 | < $ -north_c(i,(jm+1)/2))**2) 55 | < $ /ra**2)) 56 | < if(h(i,j).lt.1.0) h(i,j)=1.0 57 | < C 58 | --- 59 | > h(i,j)=depth 60 | 206c207 61 | < C Close the north and south boundaries to form a channel: 62 | --- 63 | > C Close the north and south boundaries: 64 | 212a214,220 65 | > C Close the east and west boundaries: 66 | > C 67 | > do j=1,jm 68 | > h(1,j)=1.0 69 | > h(im,j)=1.0 70 | > end do 71 | > C 72 | 221a230,238 73 | > C Set tbias and sbias here for test (tbias and sbias would 74 | > C normally only be set in the main program): 75 | > C 76 | > tbias=10.0 77 | > sbias=20.0 78 | > write(6,1) tbias,sbias 79 | > 1 format(/' tbias and sbias changed in subroutine box to:'/ 80 | > $ 2f10.3//) 81 | > C 82 | 227c244 83 | < tb(i,j,k)=5.0+15.0*exp(zz(k)*h(i,j)/1000.0)-tbias 84 | --- 85 | > tb(i,j,k)=20.0-tbias 86 | 231d247 87 | < ub(i,j,k)=vel*dum(i,j) 88 | 242c258 89 | < uab(i,j)=vel*dum(i,j) 90 | --- 91 | > C No conditions necessary for this problem 92 | 255c271,288 93 | < C No conditions necessary for this problem 94 | --- 95 | > if(i+j-57.le.0) then 96 | > e_atmos(i,j)=1.0 97 | > else 98 | > e_atmos(i,j)=-1.0 99 | > endif 100 | > C 101 | > C Ensure atmospheric pressure cannot make water depth go negative: 102 | > C 103 | > e_atmos(i,j)=min(e_atmos(i,j),h(i,j)) 104 | > C 105 | > vfluxf(i,j)=-0.00010 106 | > C 107 | > C See main program, just after "Begin numerical integration", for 108 | > C an explanation of these terms: 109 | > C 110 | > tatm=20.0 111 | > satm=35.0 112 | > C 113 | 287,289c320,321 114 | < C (in the seamount problem, the east and west boundaries are open, 115 | < C while the south and north boundaries are closed through the 116 | < C specification of the masks fsm, dum and dvm): 117 | --- 118 | > C (in this problem, all lateral boundaries are closed through 119 | > C the specification of the masks fsm, dum and dvm): 120 | 296,315d327 121 | < do j=2,jmm1 122 | < uabw(j)=uab(2,j) 123 | < uabe(j)=uab(imm1,j) 124 | < C 125 | < C Set geostrophically conditioned elevations at the boundaries: 126 | < C 127 | < ele(j)=ele(j-1)-cor(imm1,j)*uab(imm1,j)/grav*dy(imm1,j-1) 128 | < elw(j)=elw(j-1)-cor(2,j)*uab(2,j)/grav*dy(2,j-1) 129 | < end do 130 | < C 131 | < C Adjust boundary elevations so that they are zero in the middle 132 | < C of the channel: 133 | < C 134 | < elejmid=ele(jmm1/2) 135 | < elwjmid=elw(jmm1/2) 136 | < do j=2,jmm1 137 | < ele(j)=(ele(j)-elejmid)*fsm(im,j) 138 | < elw(j)=(elw(j)-elwjmid)*fsm(2,j) 139 | < end do 140 | < C 141 | -------------------------------------------------------------------------------- /fortran_origin/fort.71: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AI4EarthLab/pom2k_matlab/339cfec2faab1c9f2c9863f85f0a9500bb66fa93/fortran_origin/fort.71 -------------------------------------------------------------------------------- /fortran_origin/grid: -------------------------------------------------------------------------------- 1 | parameter(im=41, jm=61, kb=16) 2 | -------------------------------------------------------------------------------- /fortran_origin/params: -------------------------------------------------------------------------------- 1 | iproblem= 3 2 | days= 0.50 3 | prtd1= 0.25 4 | dte= 12. 5 | -------------------------------------------------------------------------------- /fortran_origin/pom2k.c: -------------------------------------------------------------------------------- 1 | C*********************************************************************** 2 | C 3 | C Common blocks for pom2k.f 4 | C 5 | C*********************************************************************** 6 | C 7 | C source_c should agree with source in pom2k.f. 8 | C 9 | character*40 source_c 10 | parameter(source_c='pom2k 2006-05-03') 11 | C 12 | C*********************************************************************** 13 | C 14 | C Array sizes: 15 | C 16 | integer 17 | $ im ,imm1 ,imm2 ,jm , 18 | $ jmm1 ,jmm2 ,kb ,kbm1 , 19 | $ kbm2 20 | C 21 | C*********************************************************************** 22 | C 23 | C Set size of problem here: 24 | C 25 | c parameter 26 | c -- file2ic (iproblem=3) 27 | c $ (im=41 ,jm=61 ,kb=16) 28 | c -- seamount (iproblem=1) 29 | c $ (im=65 ,jm=49 ,kb=21) 30 | C ---- from parameter file generated by runpom2k ---- 31 | include 'grid' 32 | C 33 | C*********************************************************************** 34 | C 35 | parameter 36 | $ (imm1=im-1 ,imm2=im-2 ,jmm1=jm-1 ,jmm2=jm-2 , 37 | $ kbm1=kb-1 ,kbm2=kb-2 ) 38 | C 39 | C----------------------------------------------------------------------- 40 | C 41 | C Scalars: 42 | C 43 | real 44 | $ alpha ,dte ,dti ,dti2 , 45 | $ grav ,hmax ,kappa ,pi , 46 | $ ramp ,rfe ,rfn ,rfs , 47 | $ rfw ,rhoref ,sbias ,slmax , 48 | $ small ,tbias ,time ,tprni , 49 | $ umol ,vmaxl 50 | 51 | integer 52 | $ iint ,iprint ,iskp ,jskp , 53 | $ kl1 ,kl2 ,mode ,ntp 54 | C 55 | common/blkcon/ 56 | $ alpha ,dte ,dti ,dti2 , 57 | $ grav ,hmax ,kappa ,pi , 58 | $ ramp ,rfe ,rfn ,rfs , 59 | $ rfw ,rhoref ,sbias ,slmax , 60 | $ small ,tbias ,time ,tprni , 61 | $ umol ,vmaxl , 62 | $ iint ,iprint ,iskp ,jskp , 63 | $ kl1 ,kl2 ,mode ,ntp 64 | C 65 | C----------------------------------------------------------------------- 66 | C 67 | C 1-D arrays: 68 | C 69 | real 70 | $ dz ,dzz ,z ,zz 71 | C 72 | common/blk1d/ 73 | $ dz(kb) ,dzz(kb) ,z(kb) ,zz(kb) 74 | C 75 | C----------------------------------------------------------------------- 76 | C 77 | C 2-D arrays: 78 | C 79 | real 80 | $ aam2d ,advua ,advva ,adx2d , 81 | $ ady2d ,art ,aru ,arv , 82 | $ cbc ,cor ,d ,drx2d , 83 | $ dry2d ,dt ,dum ,dvm , 84 | $ dx ,dy ,east_c ,east_e , 85 | $ east_u ,east_v ,e_atmos ,egb , 86 | $ egf ,el ,elb ,elf , 87 | $ et ,etb ,etf ,fluxua , 88 | $ fluxva ,fsm ,h ,north_c , 89 | $ north_e ,north_u ,north_v ,psi , 90 | $ rot ,ssurf ,swrad ,vfluxb , 91 | $ tps ,tsurf ,ua ,vfluxf , 92 | $ uab ,uaf ,utb ,utf , 93 | $ va ,vab ,vaf , 94 | $ vtb ,vtf ,wssurf ,wtsurf , 95 | $ wubot ,wusurf ,wvbot ,wvsurf 96 | C 97 | common/blk2d/ 98 | $ aam2d(im,jm) ,advua(im,jm) ,advva(im,jm) ,adx2d(im,jm) , 99 | $ ady2d(im,jm) ,art(im,jm) ,aru(im,jm) ,arv(im,jm) , 100 | $ cbc(im,jm) ,cor(im,jm) ,d(im,jm) ,drx2d(im,jm) , 101 | $ dry2d(im,jm) ,dt(im,jm) ,dum(im,jm) ,dvm(im,jm) , 102 | $ dx(im,jm) ,dy(im,jm) ,east_c(im,jm) ,east_e(im,jm) , 103 | $ east_u(im,jm) ,east_v(im,jm) ,e_atmos(im,jm) ,egb(im,jm) , 104 | $ egf(im,jm) ,el(im,jm) ,elb(im,jm) ,elf(im,jm) , 105 | $ et(im,jm) ,etb(im,jm) ,etf(im,jm) ,fluxua(im,jm) , 106 | $ fluxva(im,jm) ,fsm(im,jm) ,h(im,jm) ,north_c(im,jm) , 107 | $ north_e(im,jm) ,north_u(im,jm) ,north_v(im,jm) ,psi(im,jm) , 108 | $ rot(im,jm) ,ssurf(im,jm) ,swrad(im,jm) ,vfluxb(im,jm) , 109 | $ tps(im,jm) ,tsurf(im,jm) ,ua(im,jm) ,vfluxf(im,jm) , 110 | $ uab(im,jm) ,uaf(im,jm) ,utb(im,jm) ,utf(im,jm) , 111 | $ va(im,jm) ,vab(im,jm) ,vaf(im,jm) , 112 | $ vtb(im,jm) ,vtf(im,jm) ,wssurf(im,jm) ,wtsurf(im,jm) , 113 | $ wubot(im,jm) ,wusurf(im,jm) ,wvbot(im,jm) ,wvsurf(im,jm) 114 | C 115 | C----------------------------------------------------------------------- 116 | C 117 | C 3-D arrays: 118 | C 119 | real 120 | $ aam ,advx ,advy ,a , 121 | $ c ,drhox ,drhoy ,dtef , 122 | $ ee ,gg ,kh ,km , 123 | $ kq ,l ,q2b ,q2 , 124 | $ q2lb ,q2l ,rho ,rmean , 125 | $ sb ,sclim ,s ,tb , 126 | $ tclim ,t ,ub ,uf , 127 | $ u ,vb ,vf ,v , 128 | $ w ,zflux 129 | C 130 | common/blk3d/ 131 | $ aam(im,jm,kb) ,advx(im,jm,kb) ,advy(im,jm,kb) ,a(im,jm,kb) , 132 | $ c(im,jm,kb) ,drhox(im,jm,kb),drhoy(im,jm,kb),dtef(im,jm,kb) , 133 | $ ee(im,jm,kb) ,gg(im,jm,kb) ,kh(im,jm,kb) ,km(im,jm,kb) , 134 | $ kq(im,jm,kb) ,l(im,jm,kb) ,q2b(im,jm,kb) ,q2(im,jm,kb) , 135 | $ q2lb(im,jm,kb) ,q2l(im,jm,kb) ,rho(im,jm,kb) ,rmean(im,jm,kb), 136 | $ sb(im,jm,kb) ,sclim(im,jm,kb),s(im,jm,kb) ,tb(im,jm,kb) , 137 | $ tclim(im,jm,kb),t(im,jm,kb) ,ub(im,jm,kb) ,uf(im,jm,kb) , 138 | $ u(im,jm,kb) ,vb(im,jm,kb) ,vf(im,jm,kb) ,v(im,jm,kb) , 139 | $ w(im,jm,kb) ,zflux(im,jm,kb) 140 | C 141 | C----------------------------------------------------------------------- 142 | C 143 | C 1 and 2-D boundary value arrays: 144 | C 145 | real 146 | $ ele ,eln ,els ,elw , 147 | $ sbe ,sbn ,sbs ,sbw , 148 | $ tbe ,tbn ,tbs ,tbw , 149 | $ uabe ,uabw ,ube ,ubw , 150 | $ vabn ,vabs ,vbn ,vbs 151 | C 152 | common/bdry/ 153 | $ ele(jm) ,eln(im) ,els(im) ,elw(jm) , 154 | $ sbe(jm,kb) ,sbn(im,kb) ,sbs(im,kb) ,sbw(jm,kb) , 155 | $ tbe(jm,kb) ,tbn(im,kb) ,tbs(im,kb) ,tbw(jm,kb) , 156 | $ uabe(jm) ,uabw(jm) ,ube(jm,kb) ,ubw(jm,kb) , 157 | $ vabn(im) ,vabs(im) ,vbn(im,kb) ,vbs(im,kb) 158 | C 159 | C----------------------------------------------------------------------- 160 | C 161 | C Character variables: 162 | C 163 | character*26 164 | $ time_start 165 | C 166 | character*40 167 | $ source,title 168 | C 169 | common/blkchar/ 170 | $ time_start ,source ,title 171 | C 172 | C----------------------------------------------------------------------- 173 | C 174 | C End of common blocks 175 | C 176 | C----------------------------------------------------------------------- 177 | C 178 | -------------------------------------------------------------------------------- /fortran_origin/runpom2k: -------------------------------------------------------------------------------- 1 | # 2 | # Runscript for pom2k with example of reading IC from file. 3 | # IC file generated by /GRID-DATA/GRID.f (T.E. Dec04) 4 | # 5 | # Note: if "grid" not created here you can put it in pom2k.c 6 | # "params" replaces default values set in pom2k.f 7 | # 8 | # 9 | # ------------------ PARAMETER FILES FOR EACH CASE ----------- 10 | # 11 | # -- SMALL TEST CASE (initial cond. calc. in pom2k.f) 12 | # 13 | # echo ' parameter(im=5, jm=5, kb=5)' > grid 14 | # echo ' iproblem= 2 ' > params 15 | # echo ' days= 0.025 ' >> params 16 | # echo ' prtd1= 0.0125 ' >> params 17 | # echo ' dte= 6. ' >> params 18 | # 19 | # 20 | # -- SEAMOUNT TEST CASE (initial cond. calc. in pom2k.f) 21 | # 22 | #echo ' parameter(im=65, jm=49, kb=21)' > grid 23 | #echo ' iproblem= 3 ' > params 24 | ##echo ' days= h0.025 ' >> params 25 | #echo ' days= 15.25 ' >> params 26 | #echo ' prtd1= 0.0125 ' >> params 27 | #echo ' dte= 6. ' >> params 28 | # 29 | # -- COAST TEST CASE (initial cond. from file) 30 | # 31 | echo ' parameter(im=41, jm=61, kb=16)' > grid 32 | echo ' iproblem= 3 ' > params 33 | echo ' days= 0.50 ' >> params 34 | echo ' prtd1= 0.25 ' >> params 35 | echo ' dte= 12. ' >> params 36 | cp IC.dat fort.40 # Initial Condition file 37 | # 38 | # ------------------ COMPILE & RUN ---------------------------- 39 | # 40 | # g77 -O3 pom2k.f /usr/local/lib/libnetcdf.a 41 | # ---- now netCDF output not used (see "CDF" in pom2k.f) 42 | # g77 -O3 pom2k.f 43 | gfortran -I/usr/local/include -L/usr/local/lib -lnetcdf -O2 -o pom2k.exe pom2k.f 44 | #gfortran -O3 pom2k.f 45 | #gfortran -g -O2 pom2k.f -o pom2k.exe 46 | #gfortran -g -O2 pom2k.f -o pom2k.exe 47 | # f90 -O3 pom2k.f # or any other compiler you wish to use 48 | # 49 | # ------------------ OUTPUT FILES ----------------------------- 50 | # 51 | #./pom2k.exe > pom2k.out # printout file 52 | ./pom2k.exe # printout file 53 | # 54 | # pom2k.nc # netCDF file for MATLAB plotting 55 | -------------------------------------------------------------------------------- /manual/A Manual for POM.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AI4EarthLab/pom2k_matlab/339cfec2faab1c9f2c9863f85f0a9500bb66fa93/manual/A Manual for POM.pdf -------------------------------------------------------------------------------- /manual/A Small Part of POM's RBF.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AI4EarthLab/pom2k_matlab/339cfec2faab1c9f2c9863f85f0a9500bb66fa93/manual/A Small Part of POM's RBF.pdf -------------------------------------------------------------------------------- /matlab_new_operator/AXB.m: -------------------------------------------------------------------------------- 1 | function r = AXB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 2:dim(1); 6 | A(idx,:,:) = 0.5*(A(idx-1,:,:) + A(idx,:,:)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.axb_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/AXF.m: -------------------------------------------------------------------------------- 1 | function r = AXF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 1:dim(1)-1; 6 | A(idx,:,:) = 0.5*(A(idx,:,:) + A(idx+1,:,:)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.axf_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/AYB.m: -------------------------------------------------------------------------------- 1 | function r = AYB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 2:dim(2); 6 | A(:,idx,:) = 0.5*(A(:,idx-1,:) + A(:,idx,:)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.ayb_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/AYF.m: -------------------------------------------------------------------------------- 1 | function r = AYF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 1:dim(2)-1; 6 | A(:,idx,:) = 0.5*(A(:,idx,:) + A(:,idx+1,:)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.ayf_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/AZB.m: -------------------------------------------------------------------------------- 1 | function r = AZB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 2:dim(3); 6 | A(:,:,idx) = 0.5*(A(:,:,idx-1) + A(:,:,idx)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.azb_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/AZF.m: -------------------------------------------------------------------------------- 1 | function r = AZF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 1:dim(3)-1; 6 | A(:,:,idx) = 0.5*(A(:,:,idx) + A(:,:,idx+1)); 7 | 8 | if(~isnumeric(obj_field)) 9 | r = Field(A, obj_field.grid, ... 10 | obj_field.grid.azf_map(obj_field.pos)); 11 | else 12 | r = A; 13 | end 14 | end -------------------------------------------------------------------------------- /matlab_new_operator/DXB.m: -------------------------------------------------------------------------------- 1 | function r = DXB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | A(2:dim(1),:,:) = A(2:dim(1),:,:) - A(1:dim(1)-1,:,:); 6 | A(1,:,:) = 0; 7 | 8 | if(~isnumeric(obj_field)) 9 | A = A ./ obj_field.dx_b(); 10 | 11 | r = Field(A, obj_field.grid, ... 12 | obj_field.grid.dxb_map(obj_field.pos)); 13 | else 14 | r = A; 15 | end 16 | end -------------------------------------------------------------------------------- /matlab_new_operator/DXF.m: -------------------------------------------------------------------------------- 1 | function r = DXF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | A(1:dim(1)-1,:,:) = A(2:dim(1),:,:) - A(1:dim(1)-1,:,:); 6 | A(dim(1),:,:) = 0; 7 | 8 | if(~isnumeric(obj_field)) 9 | A = A ./ obj_field.dx_f(); 10 | 11 | r = Field(A, obj_field.grid, ... 12 | obj_field.grid.dxf_map(obj_field.pos)); 13 | else 14 | r = A; 15 | end 16 | end -------------------------------------------------------------------------------- /matlab_new_operator/DYB.m: -------------------------------------------------------------------------------- 1 | function r = DYB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | A(:,2:dim(2),:) = A(:,2:dim(2),:) - A(:,1:dim(2)-1,:); 6 | A(:,1,:) = 0; 7 | 8 | if(~isnumeric(obj_field)) 9 | A = A ./ obj_field.dy_b(); 10 | 11 | r = Field(A, obj_field.grid, ... 12 | obj_field.grid.dyb_map(obj_field.pos)); 13 | else 14 | r = A; 15 | end 16 | end -------------------------------------------------------------------------------- /matlab_new_operator/DYF.m: -------------------------------------------------------------------------------- 1 | function r = DYF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | A(:,1:dim(2)-1,:) = A(:,2:dim(2),:) - A(:,1:dim(2)-1,:); 6 | A(:,dim(2),:) = 0; 7 | 8 | if(~isnumeric(obj_field)) 9 | A = A ./ obj_field.dy_f(); 10 | 11 | r = Field(A, obj_field.grid, ... 12 | obj_field.grid.dyf_map(obj_field.pos)); 13 | else 14 | r = A; 15 | end 16 | end -------------------------------------------------------------------------------- /matlab_new_operator/DZB.m: -------------------------------------------------------------------------------- 1 | function r = DZB(obj_field) 2 | A = double(obj_field); 3 | dim = size(A) 4 | 5 | idx = 2:dim(3); 6 | 7 | A(:,:,idx) = A(:,:,idx) - A(:,:,idx-1); 8 | A(:,:,1) = 0; 9 | 10 | if(~isnumeric(obj_field)) 11 | A = A ./ obj_field.dz_b(); 12 | 13 | r = Field(A, obj_field.grid, ... 14 | obj_field.grid.dzb_map(obj_field.pos)); 15 | else 16 | r = A; 17 | end 18 | end -------------------------------------------------------------------------------- /matlab_new_operator/DZF.m: -------------------------------------------------------------------------------- 1 | function r = DZF(obj_field) 2 | A = double(obj_field); 3 | dim = size(A); 4 | 5 | idx = 1:dim(3)-1; 6 | 7 | A(:,:,idx) = A(:,:,idx+1) - A(:,:,idx); 8 | A(:,:,dim(3)) = 0; 9 | 10 | if(~isnumeric(obj_field)) 11 | A = A ./ obj_field.dz_f(); 12 | 13 | r = Field(A, obj_field.grid, ... 14 | obj_field.grid.dzf_map(obj_field.pos)); 15 | else 16 | r = A; 17 | end 18 | end -------------------------------------------------------------------------------- /matlab_new_operator/Grid.m: -------------------------------------------------------------------------------- 1 | classdef Grid 2 | properties 3 | dim 4 | type 5 | 6 | dx_f_map 7 | dy_f_map 8 | dz_f_map 9 | 10 | dx_b_map 11 | dy_b_map 12 | dz_b_map 13 | 14 | axf_map 15 | axb_map 16 | ayf_map 17 | ayb_map 18 | azf_map 19 | azb_map 20 | 21 | dxf_map 22 | dxb_map 23 | dyf_map 24 | dyb_map 25 | dzf_map 26 | dzb_map 27 | 28 | has_initialized 29 | end 30 | methods 31 | function obj = Grid(dim_, type_) 32 | obj.dim = dim_; 33 | obj.type = type_; 34 | obj.has_initialized = false; 35 | end 36 | 37 | % function obj = jump(g1, gt) 38 | % t = mod(g1.type + gt, 2); 39 | % obj = Grid(g1.dim, t, g1.gridset); 40 | % end 41 | 42 | function r = dx_f(g1, pos) 43 | r = g1.dx_f_map(pos); 44 | end 45 | function r = dy_f(g1, pos) 46 | r = g1.dy_f_map(pos); 47 | end 48 | function r = dz_(g1, pos) 49 | r = g1.dz_f_map(pos); 50 | end 51 | 52 | function r = dx_b(g1, pos) 53 | r = g1.dx_b_map(pos); 54 | end 55 | function r = dy_b(g1, pos) 56 | r = g1.dy_b_map(pos); 57 | end 58 | function r = dz_b(g1, pos) 59 | r = g1.dz_b_map(pos); 60 | end 61 | 62 | end 63 | end 64 | 65 | -------------------------------------------------------------------------------- /matlab_new_operator/create_field.m: -------------------------------------------------------------------------------- 1 | function r = create_field(data, grid, pos) 2 | r = Field(data, grid, pos); 3 | end -------------------------------------------------------------------------------- /matlab_new_operator/create_grid.m: -------------------------------------------------------------------------------- 1 | function r = create_grid(m, n, k, type) 2 | r = Grid([m,n,k], type); 3 | end -------------------------------------------------------------------------------- /matlab_new_operator/init_grid.m: -------------------------------------------------------------------------------- 1 | function obj = init_grid(obj, dx, dy, dz) 2 | 3 | obj.dx_f_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 4 | obj.dy_f_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 5 | obj.dz_f_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 6 | 7 | obj.dx_b_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 8 | obj.dy_b_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 9 | obj.dz_b_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 10 | 11 | if(obj.type == 'C') 12 | 13 | % set dx, dy, dz for each point, i.e. point 0, 1, 2, 3, 7 14 | obj.dx_f_map(0) = AYB(AXB(dx)); 15 | obj.dy_f_map(0) = AYB(AXB(dy)); 16 | obj.dz_f_map(0) = AZF(dz); 17 | 18 | obj.dx_f_map(1) = AYB(dx); 19 | obj.dy_f_map(1) = AYB(dy); 20 | obj.dz_f_map(1) = AZF(dz); 21 | 22 | obj.dx_f_map(2) = AXB(dx); 23 | obj.dy_f_map(2) = AXB(dy); 24 | obj.dz_f_map(2) = AZF(dz); 25 | 26 | obj.dx_f_map(3) = dx; 27 | obj.dy_f_map(3) = dy; 28 | obj.dz_f_map(3) = AZF(dz); 29 | 30 | obj.dx_f_map(7) = dx; 31 | obj.dy_f_map(7) = dy; 32 | obj.dz_f_map(7) = dz; 33 | 34 | obj.dx_b_map(0) = shift(AYB(AXB(dx)), -1, 1); 35 | obj.dy_b_map(0) = shift(AYB(AXB(dy)), -1, 2); 36 | obj.dz_b_map(0) = shift(AZF(dz), -1, 3); 37 | 38 | obj.dx_b_map(1) = shift(AYB(dx), -1, 1); 39 | obj.dy_b_map(1) = shift(AYB(dy), -1, 2); 40 | obj.dz_b_map(1) = shift(AZF(dz), -1, 3); 41 | 42 | obj.dx_b_map(2) = shift(AXB(dx), -1, 1); 43 | obj.dy_b_map(2) = shift(AXB(dy), -1, 2); 44 | obj.dz_b_map(2) = shift(AZF(dz), -1, 3); 45 | 46 | obj.dx_b_map(3) = shift(dx, -1, 1); 47 | obj.dy_b_map(3) = shift(dy, -1, 2); 48 | obj.dz_b_map(3) = shift(AZF(dz), -1, 3); 49 | 50 | obj.dx_b_map(7) = shift(dx, -1, 1); 51 | obj.dy_b_map(7) = shift(dy, -1, 2); 52 | obj.dz_b_map(7) = shift(dz, -1, 3); 53 | 54 | % set point map relations 55 | dxf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 56 | dxb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 57 | dyf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 58 | dyb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 59 | dzf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 60 | dzb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 61 | 62 | axf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 63 | axb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 64 | ayf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 65 | ayb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 66 | azf_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 67 | azb_map = containers.Map('KeyType', 'int32', 'ValueType', 'any'); 68 | 69 | dxf_map(0) = 1; dyf_map(0) = 2; dzf_map(0) = 4; 70 | dxf_map(1) = 0; dyf_map(1) = 3; dzf_map(1) = 5; 71 | dxf_map(2) = 3; dyf_map(2) = 0; dzf_map(2) = 6; 72 | dxf_map(3) = 2; dyf_map(3) = 1; dzf_map(3) = 7; 73 | dxf_map(4) = 5; dyf_map(4) = 6; dzf_map(4) = 0; 74 | dxf_map(5) = 4; dyf_map(5) = 7; dzf_map(5) = 1; 75 | dxf_map(6) = 7; dyf_map(6) = 4; dzf_map(6) = 2; 76 | dxf_map(7) = 6; dyf_map(7) = 5; dzf_map(7) = 3; 77 | 78 | axf_map = dxf_map; ayf_map = dyf_map; azf_map = dzf_map; 79 | axb_map = dxf_map; ayb_map = dyf_map; azb_map = dzf_map; 80 | dxb_map = dxf_map; dyb_map = dyf_map; dzb_map = dzf_map; 81 | 82 | obj.axf_map = axf_map; obj.dxf_map = dxf_map; 83 | obj.axb_map = axb_map; obj.dxb_map = dxb_map; 84 | obj.ayf_map = ayf_map; obj.dyf_map = dyf_map; 85 | obj.ayb_map = ayb_map; obj.dyb_map = dyb_map; 86 | obj.azf_map = azf_map; obj.dzf_map = dzf_map; 87 | obj.azb_map = azb_map; obj.dzb_map = dzb_map; 88 | end 89 | 90 | obj.has_initialized = true; 91 | end -------------------------------------------------------------------------------- /matlab_new_operator/main.m: -------------------------------------------------------------------------------- 1 | m = 5; 2 | n = 5; 3 | k = 3; 4 | 5 | %*********************************** 6 | v1 = repmat(0.11, m, 1); 7 | v11 = ones(m, 1); 8 | 9 | v2 = repmat(0.12, n, 1); 10 | v21 = ones(n, 1); 11 | 12 | v3 = repmat(0.12, k, 1); 13 | v31 = ones(k, 1); 14 | 15 | dx = meshgrid(v1, v21, v31); % dx_3d 16 | dy = meshgrid(v1, v21, v31); % dy_3d 17 | dz = meshgrid(v1, v21, v31); % dz_3d 18 | 19 | %*********************************** 20 | DATA_U = rand(m, n, k); 21 | DATA_UB = rand(m, n, k); 22 | DATA_D = rand(m, n, k); 23 | DATA_V = rand(m, n, k); 24 | DATA_VB = rand(m, n, k); 25 | DATA_AAM = rand(m, n, k); 26 | 27 | gs = create_grid(m, n, k, 'C'); 28 | 29 | %matlab does not support modifying an input parameter inside call 30 | gs = init_grid(gs, dx, dy, dz); 31 | 32 | D = create_field(DATA_D, gs, 3); 33 | AAM = create_field(DATA_AAM, gs, 3); 34 | V = create_field(DATA_V, gs, 1); 35 | VB = create_field(DATA_VB, gs, 1); 36 | U = create_field(DATA_U, gs, 2); 37 | UB = create_field(DATA_UB, gs, 2); 38 | 39 | 40 | %examples 41 | xflux1 = DXB(AXF(AXB(D) .* U) .* AXF(U)) - DXB(D .* AAM .* 2.0 .* DXF(UB)); 42 | yflux1 = DYB(AYF(AYB(D) .* V) .* AYF(V)) - DYB(D .* AAM .* 2.0 .* DYF(VB)); 43 | 44 | -------------------------------------------------------------------------------- /matlab_new_operator/shift.m: -------------------------------------------------------------------------------- 1 | function r = shift(A, unit, dim) 2 | b = circshift(A, unit, dim); 3 | 4 | if(dim == 1) 5 | if(unit > 0) 6 | b(1:unit, :, :) = A(1:unit, :, :); 7 | elseif(unit < 0) 8 | b(end+unit:end,:,:) = A(end+unit:end,:,:); 9 | end 10 | end 11 | 12 | if(dim == 2) 13 | if(unit > 0) 14 | b(:, 1:unit, :) = A(:, 1:unit, :); 15 | elseif(unit < 0) 16 | b(:, end+unit:end,:) = A(:,end+unit:end,:); 17 | end 18 | end 19 | 20 | if(dim == 3) 21 | if(unit > 0) 22 | b(:, :, 1:unit) = A(:, :, 1:unit); 23 | elseif(unit < 0) 24 | b(:, :, end+unit:end) = A(:, :, end+unit:end); 25 | end 26 | end 27 | 28 | r = b; 29 | end -------------------------------------------------------------------------------- /matlab_operator/AXB.m: -------------------------------------------------------------------------------- 1 | function F=AXB(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | 7 | for k=1:kz 8 | F(:,:,k)=OP.OP_AXB*X(:,:,k); 9 | end 10 | 11 | end 12 | -------------------------------------------------------------------------------- /matlab_operator/AXB1.m: -------------------------------------------------------------------------------- 1 | function F=AXB1(X) 2 | global OP 3 | %load('operator.mat'); 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(ny,kz); 7 | for i=1:mx 8 | tmp(:,:)=X(i,:,:); 9 | F(i,:,:)=OP.OP_AXB1 * tmp; 10 | end 11 | 12 | end -------------------------------------------------------------------------------- /matlab_operator/AXB2.m: -------------------------------------------------------------------------------- 1 | function F=AXB2(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=OP.OP_AXB * tmp; 10 | end 11 | 12 | end -------------------------------------------------------------------------------- /matlab_operator/AXF.m: -------------------------------------------------------------------------------- 1 | function F=AXF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=OP.OP_AXF*X(:,:,k); 8 | end 9 | end 10 | -------------------------------------------------------------------------------- /matlab_operator/AXF1.m: -------------------------------------------------------------------------------- 1 | function F=AXF1(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(ny,kz); 7 | for i=1:mx 8 | tmp(:,:)=X(i,:,:); 9 | F(i,:,:)=OP.OP_AXF1 * tmp; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/AXF2.m: -------------------------------------------------------------------------------- 1 | function F=AXF2(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=OP.OP_AXF * tmp; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/AYB.m: -------------------------------------------------------------------------------- 1 | function F=AYB(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=X(:,:,k)*OP.OP_AYB; 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/AYF.m: -------------------------------------------------------------------------------- 1 | function F=AYF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=X(:,:,k)*OP.OP_AYF; 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/AZB.m: -------------------------------------------------------------------------------- 1 | function F=AZB(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_AZB; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/AZF.m: -------------------------------------------------------------------------------- 1 | function F=AZF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_AZF; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/AZF1.m: -------------------------------------------------------------------------------- 1 | function F=AZF1(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(ny,kz); 7 | for i=1:mx 8 | tmp(:,:)=X(i,:,:); 9 | F(i,:,:)=tmp*OP.OP_AZF; 10 | end 11 | 12 | end -------------------------------------------------------------------------------- /matlab_operator/DIVISION.m: -------------------------------------------------------------------------------- 1 | function f=DIVISION(A,B) 2 | f=A./B; 3 | f(isnan(f))=0; 4 | f(isinf(f))=0; 5 | -------------------------------------------------------------------------------- /matlab_operator/DXB.m: -------------------------------------------------------------------------------- 1 | function F=DXB(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=OP.OP_DXB*X(:,:,k); 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/DXC.m: -------------------------------------------------------------------------------- 1 | function F=DXC(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=OP.OP_DXB * OP.OP_AXF*X(:,:,k); 8 | end 9 | 10 | end -------------------------------------------------------------------------------- /matlab_operator/DXF.m: -------------------------------------------------------------------------------- 1 | function F=DXF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=OP.OP_DXF*X(:,:,k); 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/DYB.m: -------------------------------------------------------------------------------- 1 | function F=DYB2(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=X(:,:,k)*OP.OP_DYB; 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/DYC.m: -------------------------------------------------------------------------------- 1 | function F=DYC(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=X(:,:,k)*(OP.OP_AYF * OP.OP_DYB); 8 | end 9 | 10 | end -------------------------------------------------------------------------------- /matlab_operator/DYF.m: -------------------------------------------------------------------------------- 1 | function F=DYF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | for k=1:kz 7 | F(:,:,k)=X(:,:,k)*OP.OP_DYF; 8 | end 9 | 10 | end 11 | -------------------------------------------------------------------------------- /matlab_operator/DZB.m: -------------------------------------------------------------------------------- 1 | function F=DZB(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_DZB; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/DZC.m: -------------------------------------------------------------------------------- 1 | function F=DZC(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*(OP.OP_AZF * OP.OP_DZB); 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/DZF.m: -------------------------------------------------------------------------------- 1 | function F=DZF(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_DZF; 10 | end 11 | 12 | end 13 | -------------------------------------------------------------------------------- /matlab_operator/Operator.m: -------------------------------------------------------------------------------- 1 | classdef Operator 2 | %OPERATOR Summary of this class goes here 3 | % Detailed explanation goes here 4 | 5 | properties 6 | OP_AXF, 7 | OP_AXB, 8 | OP_AYF, 9 | OP_AYB, 10 | OP_AZF, 11 | OP_AZB, 12 | OP_DXF, 13 | OP_DXB, 14 | OP_DYF, 15 | OP_DYB, 16 | OP_DZF, 17 | OP_DZB, 18 | OP_L_XY, 19 | OP_L_XZ, 20 | OP_L_YZ, 21 | OP_R_XY, 22 | OP_R_XZ, 23 | OP_R_YZ, 24 | OP_SUMZ1, 25 | OP_SUMZ2, 26 | OP_AXB1, 27 | OP_AXF1, 28 | OP_Rk, 29 | end 30 | 31 | methods 32 | end 33 | 34 | end 35 | 36 | -------------------------------------------------------------------------------- /matlab_operator/Rk1.m: -------------------------------------------------------------------------------- 1 | function F=Rk1(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(ny,kz); 7 | for i=1:mx 8 | tmp(:,:)=X(i,:,:); 9 | F(i,:,:)=tmp*OP.OP_Rk; 10 | end 11 | 12 | end -------------------------------------------------------------------------------- /matlab_operator/Rk2.m: -------------------------------------------------------------------------------- 1 | function F=Rk2(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_Rk; 10 | end 11 | 12 | end -------------------------------------------------------------------------------- /matlab_operator/SUM1.m: -------------------------------------------------------------------------------- 1 | function F=SUM1(X) 2 | %load('operator.mat'); 3 | global OP 4 | [mx,ny,kz]=size(X); 5 | F=zeros(mx,ny,kz); 6 | tmp=zeros(mx,kz); 7 | for j=1:ny 8 | tmp(:,:)=X(:,j,:); 9 | F(:,j,:)=tmp*OP.OP_SUMZ1; 10 | end 11 | % for k=1:kz 12 | % F(:,:,k)=F(:,:,k); 13 | % end 14 | end 15 | -------------------------------------------------------------------------------- /matlab_operator/SUM2.m: -------------------------------------------------------------------------------- 1 | function F=SUM2(X) 2 | global OP 3 | [mx,ny,kz]=size(X); 4 | F=zeros(mx,ny,kz); 5 | tmp=zeros(mx,kz); 6 | for j=1:ny 7 | tmp(:,:)=X(:,j,:); 8 | F(:,j,:)=tmp*OP.OP_SUMZ2; 9 | end 10 | % for k=1:kz 11 | % F(:,:,k)=F(:,:,kz); 12 | % end 13 | end 14 | -------------------------------------------------------------------------------- /matlab_operator/SUMZ1.m: -------------------------------------------------------------------------------- 1 | function F=SUMZ1(Z) 2 | load('operator.mat'); 3 | F=Z*OP_SUMZ1; 4 | end 5 | -------------------------------------------------------------------------------- /matlab_operator/SUMZ2.m: -------------------------------------------------------------------------------- 1 | function F=SUMZ2_YZ(Z) 2 | load('operator.mat'); 3 | F=Z*OP_SUMZ2; 4 | end 5 | -------------------------------------------------------------------------------- /matlab_operator/advave.m: -------------------------------------------------------------------------------- 1 | function [curv2d,wubot,wvbot,advua,advva] = advave(curv2d,wubot,wvbot,mode,aam2d,uab,vab,ua,va,cbc,d) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Calculates horizontal advection and diffusion. * 5 | % * * 6 | % ********************************************************************** 7 | %load('grid.mat'); 8 | global im jm dx dy; 9 | 10 | advua = zeros(im,jm); 11 | advva = zeros(im,jm); 12 | tps = zeros(im,jm); 13 | 14 | tps = AYB(AXB(d)) .* AXB(AYB(aam2d)) ... 15 | .* ( DYB(uab) .*DIVISION( 1.0,AYB(AXB(dy)) ) + DXB(vab) .* DIVISION( 1.0,AYB(AXB(dx)) ) ); 16 | 17 | advua = DXB(( AXF(AXB(d).*ua) .* AXF(ua)-2.0*d .* aam2d .* DXF(uab)./dx ) .* dy ) ... 18 | +DYF( ( AXB(AYB(d).*va) .* AYB(ua)-tps ) .* AYB(AXB(dx)) ); 19 | advva = DXF( ( AYB(AXB(d).*ua) .* AXB(va)-tps ) .* AYB(AXB(dy)) )... 20 | +DYB( ( AYF(AYB(d).*va) .* AYF(va) - 2.0*d .* aam2d .* DYF(vab)./dy ) .* dx ); 21 | 22 | %%%%%%%%%%%%%%%%%%% 23 | %wubot = zeros(im,jm); 24 | %wvbot = zeros(im,jm); 25 | 26 | if(mode==2) 27 | wubot = -AXB(cbc) .* sqrt( uab.^2+AXB(AYF(vab)).^2 ) .* uab; 28 | wvbot = -AYB(cbc) .* sqrt( vab.^2+AYB(AXF(uab)).^2 ) .* vab; 29 | curv2d = (AYF(va) .* DXC(dy) - AXF(ua) .* DYC(dx))./(dx.*dy); 30 | advua = advua-aru .* AXB( curv2d .* d .* AYF(va) ); 31 | advva = advva+arv .* AYB( curv2d .* d .* AXF(ua) ); 32 | end 33 | 34 | return 35 | -------------------------------------------------------------------------------- /matlab_operator/advct.m: -------------------------------------------------------------------------------- 1 | function [advx,advy]=advct(u,v,dt_3d,aam,ub,vb) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Calculates the horizontal portions of momentum * 5 | % * advection well in advance of their use in advu and * 6 | % * advv so that their vertical integrals (created in * 7 | % * the main program) may be used in the external (2-D) * 8 | % * mode calculation. * 9 | % * * 10 | % ********************************************************************** 11 | 12 | %load('grid.mat'); 13 | global im jm kb dx_3d dy_3d aru_3d arv_3d; 14 | 15 | curv=zeros(im,jm,kb); advx=zeros(im,jm,kb); advy=zeros(im,jm,kb); 16 | xflux=zeros(im,jm,kb); yflux=zeros(im,jm,kb); 17 | 18 | curv= (AYF(v) .* DXB(AXF(dy_3d)) - AXF(u) .* DYB(AYF(dx_3d)) ) ./ (dx_3d .* dy_3d); 19 | % Calculate x-component of velocity advection: 20 | xflux = dy_3d .* (AXF( AXB(dt_3d) .* u ) .* AXF(u) - dt_3d.*aam*2.0.*DXF(ub)./dx_3d ); 21 | yflux = AYB(AXB(dx_3d)) .* ( ( AXB( AYB(dt_3d) .* v ) .* AYB(u) ) - AYB(AXB(dt_3d)) .* AYB(AXB(aam)) ... 22 | .*( DIVISION( DYB(ub), AYB(AXB(dy_3d)) ) + DIVISION( DXB(vb), AYB(AXB(dx_3d)) ) ) ) ; 23 | advx=DXB( xflux ) + DYF( yflux ) - aru_3d .* AXB( curv .* dt_3d .* AYF(v) ); 24 | % Calculate y-component of velocity advection: 25 | xflux = AYB(AXB(dy_3d)) .* ( ( AYB( AXB(dt_3d) .* u ) .* AXB(v) ) -AYB(AXB(dt_3d)) .* AYB(AXB(aam)) ... 26 | .* ( DIVISION( DYB(ub), AYB(AXB(dy_3d)) ) + DIVISION( DXB(vb), AYB(AXB(dx_3d)) ) ) ) ; 27 | yflux = dx_3d .* (AYF( AYB(dt_3d) .* v ) .* AYF(v) - dt_3d.*aam*2.0.*DYF(vb)./dy_3d ); 28 | advy=DXF( xflux ) + DYB( yflux ) + arv_3d .* AYB( curv .* dt_3d .* AXF(u) ); 29 | 30 | end 31 | -------------------------------------------------------------------------------- /matlab_operator/advq.m: -------------------------------------------------------------------------------- 1 | function [qf]=advq(qb,q,dt,u,v,w,aam,h,etb,etf,dti2) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : calculates horizontal advection and diffusion, and * 5 | % * vertical advection for turbulent quantities. * 6 | % * * 7 | % ********************************************************************** 8 | %load('grid.mat');load('operator.mat'); 9 | global im jm kb dy_3d dum_3d dvm_3d art_3d dx_3d dz_3d 10 | 11 | xflux = zeros(im,jm,kb); 12 | yflux = zeros(im,jm,kb); 13 | qf=zeros(im,jm,kb); 14 | 15 | dt_3d=repmat(dt,1,1,kb); 16 | h_3d =repmat(h,1,1,kb); 17 | 18 | % Do horizontal advection and diffusion: 19 | xflux=AXB(dy_3d) .* ( AXB(q) .* AXB(dt_3d) .* AZB(u) -AZB( AXB( aam ))... 20 | .*AXB(h_3d) .*DXB( qb ) .* dum_3d .* DIVISION( 1.0,AXB( dx_3d ) ) ); 21 | % do vertical advection: add flux terms, then step forward in time: 22 | yflux=AYB(dx_3d) .* ( AYB(q) .* AYB(dt_3d) .* AZB(v) -AZB( AYB( aam ) )... 23 | .*AYB(h_3d) .*DYB( qb ) .* dvm_3d .* DIVISION( 1.0,AYB( dy_3d ) ) ); 24 | 25 | qf= ( ( h_3d+repmat(etb,1,1,kb) ) .* art_3d .* qb... 26 | -dti2*( -DZC(w.*q) .* art_3d.*DIVISION( 1.0,AZB(dz_3d) ) + DXF(xflux)+DYF(yflux)) )... 27 | ./ ( ( h_3d+repmat(etf,1,1,kb) ) .* art_3d ) ; 28 | qf(1,:,:) =0; qf(im,:,:)=0; 29 | qf(:,1,:) =0; qf(:,jm,:)=0; 30 | qf(:,:,1) =0; qf(:,:,kb)=0; 31 | return 32 | -------------------------------------------------------------------------------- /matlab_operator/advt1.m: -------------------------------------------------------------------------------- 1 | function [ff]=advt1(fb,f,dt,u,v,aam,tprni,w,etb,etf,h) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Integrates conservative scalar equations. * 5 | % * * 6 | % * This is centred scheme, as originally provide in * 7 | % * POM (previously called advt). * 8 | % * * 9 | % ********************************************************************** 10 | %load('grid.mat');load('para.mat'); 11 | global im jm kb dum_3d dvm_3d dx_3d dy_3d dz_3d art_3d dti2; 12 | 13 | xflux=zeros(im,jm,kb); yflux=zeros(im,jm,kb); zflux=zeros(im,jm,kb); ff=zeros(im,jm,kb); 14 | dt_3d=repmat(dt,1,1,kb); 15 | h_3d=repmat(h,1,1,kb); 16 | % for advective fluxes and diffusive fluxes: 17 | xflux=(AXB(dt_3d).*AXB(f).*u-DIVISION(AXB(aam).*AXB(h_3d)*tprni.*DXB(fb).*dum_3d , AXB(dx_3d))).*AXB(dy_3d); 18 | yflux=(AYB(dt_3d).*AYB(f).*v-DIVISION(AYB(aam).*AYB(h_3d)*tprni.*DYB(fb).*dvm_3d , AYB(dy_3d))).*AYB(dx_3d); 19 | % for vertical advection: 20 | zflux=AZB(f).*w.*art_3d; 21 | xflux(:,:,kb)=0.0; yflux(:,:,kb)=0.0; zflux(:,:,kb)=0.0; 22 | 23 | % Add net horizontal fluxes and then step forward in time: 24 | ff= DIVISION((fb.*(h_3d+repmat(etb,1,1,kb)).* art_3d - dti2 .* (DXF(xflux)+ DYF(yflux)-DZF(zflux)./dz_3d) ) ... 25 | , ((h_3d+repmat(etf,1,1,kb)).* art_3d)) ; 26 | ff(1,:,:)=0;ff(im,:,:)=0; ff(:,1,:)=0;ff(:,jm,:)=0; ff(:,:,kb)=0; 27 | end -------------------------------------------------------------------------------- /matlab_operator/advt2.m: -------------------------------------------------------------------------------- 1 | function [fb,f,fclim,ff,xflux,yflux,nitera,sw,... 2 | zflux] = advt2(fb,f,fclim,ff,xflux,yflux,nitera,sw,... 3 | zflux,... 4 | im,jm,kb,imm1,jmm1,kbm1,dti2,... 5 | etb,etf,w,art,fsm,dt,aam,tprni,h,dum,dvm,dx,dy,u,v,aru,arv,dz,dzz) 6 | 7 | 8 | 9 | % ********************************************************************** 10 | % * * 11 | % * FUN%TION : Integrates conservative scalar equations. * 12 | % * * 13 | % * This is a first-order upstream scheme, which * 14 | % * reduces implicit diffusion using the Smolarkiewicz * 15 | % * iterative upstream scheme with an antidiffusive * 16 | % * velocity. * 17 | % * * 18 | % * It is based on the subroutines of Gianmaria Sannino * 19 | % * (Inter-university %omputing %onsortium, Rome, Italy)* 20 | % * and Vincenzo Artale (Italian National Agency for * 21 | % * New Technology and Environment, Rome, Italy), * 22 | % * forwnloaded from the POM FTP site on 1 Nov. 2001. * 23 | % * The calculations have been simplified by removing * 24 | % * the shock switch option. It should be noted that * 25 | % * this implementation fores not include cross-terms * 26 | % * which are in the original formulation. * 27 | % * * 28 | % * fb,f,fclim,ff . as used in subroutine advt1 * 29 | % * xflux,yflux ... working arrays used to save memory * 30 | % * nitera ........ number of iterations. This should * 31 | % * be in the range 1 - 4. 1 is * 32 | % * standard upstream differencing; * 33 | % * 3 adds 50% %PU time to POM. * 34 | % * sw ............ smoothing parameter. This should * 35 | % * preferably be 1, but 0 < sw < 1 * 36 | % * gives smoother solutions with less * 37 | % * overshoot when nitera > 1. * 38 | % * * 39 | % * Reference: * 40 | % * * 41 | % * Smolarkiewicz, P.K.; A fully multidimensional * 42 | % * positive definite advection transport algorithm * 43 | % * with small implicit diffusion, Journal of * 44 | % * %omputational Physics, 54, 325-362, 1984. * 45 | % * * 46 | % ********************************************************************** 47 | % 48 | % 49 | % 50 | % 51 | % calculate horizontal mass fluxes: 52 | % 53 | xmassflux=zeros(im,jm,kb); 54 | ymassflux=zeros(im,jm,kb); 55 | 56 | 57 | % 58 | for k=1:kbm1 59 | for j=2:jmm1 60 | for i=2:im 61 | xmassflux(i,j,k)=0.25e0*(dy(i-1,j)+dy(i,j)) ... 62 | *(dt(i-1,j)+dt(i,j))*u(i,j,k); 63 | end 64 | end 65 | % 66 | for j=2:jm 67 | for i=2:imm1 68 | ymassflux(i,j,k)=0.25e0*(dx(i,j-1)+dx(i,j)) ... 69 | *(dt(i,j-1)+dt(i,j))*v(i,j,k); 70 | end 71 | end 72 | end 73 | % 74 | for j=1:jm 75 | for i=1:im 76 | fb(i,j,kb)=fb(i,j,kbm1); 77 | end 78 | end 79 | % 80 | eta=etb; 81 | zwflux=w; 82 | fbmem=fb; 83 | % 84 | % Start Smolarkiewicz scheme: 85 | % 86 | for itera=1:nitera 87 | % 88 | % Upwind advection scheme: 89 | % 90 | for k=1:kbm1 91 | for j=2:jm 92 | for i=2:im 93 | xflux(i,j,k)=0.5e0 ... 94 | *((xmassflux(i,j,k)+abs(xmassflux(i,j,k))) ... 95 | *fbmem(i-1,j,k)+ ... 96 | (xmassflux(i,j,k)-abs(xmassflux(i,j,k))) ... 97 | *fbmem(i,j,k)); 98 | % 99 | yflux(i,j,k)=0.5e0 ... 100 | *((ymassflux(i,j,k)+abs(ymassflux(i,j,k))) ... 101 | *fbmem(i,j-1,k)+ ... 102 | (ymassflux(i,j,k)-abs(ymassflux(i,j,k))) ... 103 | *fbmem(i,j,k)); 104 | end 105 | end 106 | end 107 | % 108 | for j=2:jmm1 109 | for i=2:imm1 110 | zflux(i,j,1)=0.e0; 111 | if(itera==1) 112 | zflux(i,j,1)=w(i,j,1)*f(i,j,1)*art(i,j); 113 | end 114 | zflux(i,j,kb)=0.e0; 115 | end 116 | end 117 | % 118 | for k=2:kbm1 119 | for j=2:jmm1 120 | for i=2:imm1 121 | zflux(i,j,k)=0.5e0 ... 122 | *((zwflux(i,j,k)+abs(zwflux(i,j,k))) ... 123 | *fbmem(i,j,k)+ ... 124 | (zwflux(i,j,k)-abs(zwflux(i,j,k))) ... 125 | *fbmem(i,j,k-1)); 126 | zflux(i,j,k)=zflux(i,j,k)*art(i,j); 127 | end 128 | end 129 | end 130 | % 131 | % Add net advective fluxes and step forward in time: 132 | % 133 | for k=1:kbm1 134 | for j=2:jmm1 135 | for i=2:imm1 136 | ff(i,j,k)=xflux(i+1,j,k)-xflux(i,j,k) ... 137 | +yflux(i,j+1,k)-yflux(i,j,k) ... 138 | +(zflux(i,j,k)-zflux(i,j,k+1))/dz(k); 139 | ff(i,j,k)=(fbmem(i,j,k)*(h(i,j)+eta(i,j))*art(i,j) ... 140 | -dti2*ff(i,j,k))/((h(i,j)+etf(i,j))*art(i,j)); 141 | end 142 | end 143 | end 144 | % 145 | % %alculate antidiffusion velocity: 146 | % 147 | 148 | [xmassflux,ymassflux,zwflux,ff,sw] = smol_adif(xmassflux,ymassflux,zwflux,ff,sw,... 149 | im,jm,kb,imm1,jmm1,kbm1,dti2,fsm,aru,arv,dzz,dt); 150 | % 151 | eta=etf; 152 | fbmem=ff; 153 | % 154 | % End of Smolarkiewicz scheme 155 | % 156 | end 157 | % 158 | % Add horizontal diffusive fluxes: 159 | % 160 | 161 | fb=fb-fclim; 162 | % 163 | for k=1:kbm1 164 | for j=2:jm 165 | for i=2:im 166 | xmassflux(i,j,k)=0.5e0*(aam(i,j,k)+aam(i-1,j,k)); 167 | ymassflux(i,j,k)=0.5e0*(aam(i,j,k)+aam(i,j-1,k)); 168 | end 169 | end 170 | end 171 | % 172 | for k=1:kbm1 173 | for j=2:jm 174 | for i=2:im 175 | xflux(i,j,k)=-xmassflux(i,j,k)*(h(i,j)+h(i-1,j))*tprni ... 176 | *(fb(i,j,k)-fb(i-1,j,k))*dum(i,j) ... 177 | *(dy(i,j)+dy(i-1,j))*0.5e0/(dx(i,j)+dx(i-1,j)); 178 | yflux(i,j,k)=-ymassflux(i,j,k)*(h(i,j)+h(i,j-1))*tprni ... 179 | *(fb(i,j,k)-fb(i,j-1,k))*dvm(i,j) ... 180 | *(dx(i,j)+dx(i,j-1))*0.5e0/(dy(i,j)+dy(i,j-1)); 181 | end 182 | end 183 | end 184 | % 185 | 186 | fb=fb+fclim; 187 | % 188 | % Add net horizontal fluxes and step forward in time: 189 | % 190 | for k=1:kbm1 191 | for j=2:jmm1 192 | for i=2:imm1 193 | ff(i,j,k)=ff(i,j,k)-dti2*(xflux(i+1,j,k)-xflux(i,j,k) ... 194 | +yflux(i,j+1,k)-yflux(i,j,k)) ... 195 | /((h(i,j)+etf(i,j))*art(i,j)); 196 | end 197 | end 198 | end 199 | 200 | end 201 | 202 | % 203 | % ********************************************************************** 204 | % * * 205 | -------------------------------------------------------------------------------- /matlab_operator/advu.m: -------------------------------------------------------------------------------- 1 | function [uf] = advu(advx,cor,dt,e_atmos,drhox,h,ub,u,v,w,egf,egb,etf,etb) 2 | %load('grid.mat');load('para.mat');load('operator.mat'); 3 | 4 | global im jm kb aru_3d dti2 grav dy_3d dz_3d; 5 | 6 | h_3d = repmat(h,1,1,kb); 7 | dt_3d = repmat(dt,1,1,kb); 8 | etb_3d = repmat(etb,1,1,kb); 9 | cor_3d = repmat(cor,1,1,kb); 10 | egf_3d = repmat(egf,1,1,kb); 11 | egb_3d = repmat(egb,1,1,kb); 12 | e_atmos_3d = repmat(e_atmos,1,1,kb); 13 | etf_3d = repmat(etf,1,1,kb); 14 | 15 | uf=zeros(im,jm,kb); 16 | uf = AXB(w) .* AZB(u); 17 | bond = uf(im,:,:); 18 | uf=DIVISION( AXB(etb_3d+h_3d).*aru_3d.*ub... 19 | -dti2*( advx+drhox-aru_3d.*AXB( cor_3d.*dt_3d.*AYF(v) )... 20 | +grav*AXB(dt_3d).*( DXB(egf_3d+egb_3d)+DXB(e_atmos_3d)*2.0 ).*AXB(dy_3d)/2.e0... 21 | -DZF(uf).*aru_3d./dz_3d )... 22 | ,AXB(etf_3d+h_3d).*aru_3d ); 23 | uf(im,:,:) = bond; 24 | 25 | -------------------------------------------------------------------------------- /matlab_operator/advv.m: -------------------------------------------------------------------------------- 1 | function [vf] = advv(advy,cor,dt,e_atmos,drhoy,h,vb,u,v,w,egf,egb,etf,etb) 2 | %load('grid.mat');load('para.mat');load('operator.mat'); 3 | 4 | global im jm kb arv_3d dti2 grav dx_3d dz_3d 5 | 6 | h_3d = repmat(h,1,1,kb); 7 | dt_3d = repmat(dt,1,1,kb); 8 | etb_3d = repmat(etb,1,1,kb); 9 | cor_3d = repmat(cor,1,1,kb); 10 | egf_3d = repmat(egf,1,1,kb); 11 | egb_3d = repmat(egb,1,1,kb); 12 | etf_3d = repmat(etf,1,1,kb); 13 | e_atmos_3d = repmat(e_atmos,1,1,kb); 14 | 15 | 16 | vf=zeros(im,jm,kb); 17 | vf = AYB(w) .* AZB(v); 18 | vf = DIVISION( AYB(etb_3d+h_3d).*arv_3d.*vb... 19 | -dti2*( advy+drhoy+arv_3d.*AYB( cor_3d.*dt_3d.*AXF(u) )... 20 | +grav*AYB(dt_3d).*( DYB(egf_3d+egb_3d)+DYB(e_atmos_3d)*2.0 ).*AYB(dx_3d)/2.e0... 21 | -DZF(vf).*arv_3d./dz_3d )... 22 | ,AYB(etf_3d+h_3d).*arv_3d ); 23 | 24 | return 25 | -------------------------------------------------------------------------------- /matlab_operator/areas_masks.m: -------------------------------------------------------------------------------- 1 | function [art,aru,arv,fsm,dum,dvm]=areas_masks(dx,dy,h) 2 | %load('grid.mat'); 3 | 4 | global im jm; 5 | 6 | % Set to zero 7 | art=zeros(im,jm); aru=zeros(im,jm); arv=zeros(im,jm); 8 | fsm=zeros(im,jm); dum=zeros(im,jm); dvm=zeros(im,jm); 9 | 10 | % Calculate areas of "t" and "s" cells: 11 | art = dx .* dy; 12 | aru = AXB(dx) .* AXB(dy); 13 | arv = AYB(dx) .* AYB(dy); 14 | aru(1,:)=aru(2,:); 15 | aru(:,1)=aru(:,2); 16 | arv(1,:)=arv(2,:); 17 | arv(:,1)=arv(:,2); 18 | 19 | % Initialise and set up free surface mask: 20 | fsm(h>1.0)=1.0; 21 | 22 | dum(2:im,2:jm)=fsm(2:im,2:jm) .* fsm(1:im-1,2:jm); 23 | dvm(2:im,2:jm)=fsm(2:im,2:jm) .* fsm(2:im,1:jm-1); -------------------------------------------------------------------------------- /matlab_operator/baropg.m: -------------------------------------------------------------------------------- 1 | function [rho,drhox,drhoy] = baropg(rho, rmean, dt, ramp) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Calculates baroclinic pressure gradient. * 5 | % * * 6 | % ********************************************************************** 7 | 8 | %load('grid.mat'); load('para.mat'); 9 | global im jm kb zz_3d dx_3d dy_3d grav dum_3d dvm_3d; 10 | 11 | rho = rho - rmean; 12 | drhox=zeros(im,jm,kb); drhoy=zeros(im,jm,kb); 13 | 14 | dt_3d=repmat(dt,1,1,kb); 15 | % Calculate x-component of baroclinic pressure gradient: 16 | drhox(:,:,1)= -grav .* zz_3d(:,:,1) .* AXB(dt_3d(:,:,1)) .* DXB(rho(:,:,1)); 17 | drhox= SUM1(drhox-grav *DZB(zz_3d) .* AXB(dt_3d) .* DXB(AZB(rho)) + grav * AZB(zz_3d) .* DXB(dt_3d) .* DZB(AXB(rho))); 18 | drhox = ramp*drhox .* AXB(dt_3d) .* dum_3d .* AXB(dy_3d); 19 | 20 | % Calculate y-component of baroclinic pressure gradient: 21 | drhoy(:,:,1)= -grav .* zz_3d(:,:,1) .* AYB(dt_3d(:,:,1)) .* DYB(rho(:,:,1)); 22 | drhoy= SUM1(drhoy-grav * DZB(zz_3d) .* AYB(dt_3d) .* DYB(AZB(rho)) + grav * AZB(zz_3d) .* DYB(dt_3d) .* DZB(AYB(rho))); 23 | drhoy = ramp*drhoy .* AYB(dt_3d) .* dvm_3d .* AYB(dx_3d); 24 | 25 | rho = rho + rmean; -------------------------------------------------------------------------------- /matlab_operator/dens.m: -------------------------------------------------------------------------------- 1 | function [rhoo]=dens(si,ti,h_3d,fsm_3d) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Calculates (density-1000.)/rhoref. * 5 | % * * 6 | % * (see: Mellor, G.L., 1991, J. Atmos. Oceanic Tech., * 7 | % * 609-611.) * 8 | % * * 9 | % * ti is potential temperature * 10 | % * * 11 | % * If using 32 bit precision, it is recommended that * 12 | % * cr,p,rhor,sr,tr,tr2,tr3 and tr4 be made double * 13 | % * precision, and the "e"s in the constants be changed * 14 | % * to "d"s. * 15 | % * * 16 | % * NOTE: if pressure is not used in dens, buoyancy term (boygr) * 17 | % * in profq must be changed (see note in profq) * 18 | % * * 19 | % ********************************************************************** 20 | 21 | %load('grid.mat'); 22 | %load('para.mat'); 23 | global im jm kb tbias sbias rhor rhoref grav zz_3d 24 | 25 | rhoo=zeros(im,jm,kb); 26 | 27 | tr=ti+tbias; 28 | sr=si+sbias; 29 | tr2=tr.*tr; 30 | tr3=tr2.*tr; 31 | tr4=tr3.*tr; 32 | % Approximate pressure in units of bars: 33 | p=grav*rhoref*(-zz_3d .* h_3d)*1.e-5; 34 | rhor=-0.157406e0+6.793952e-2*tr-9.095290e-3*tr2+1.001685e-4*tr3... 35 | -1.120083e-6*tr4+6.536332e-9*tr4.*tr; 36 | 37 | rhor=rhor+(0.824493e0-4.0899e-3*tr+7.6438e-5*tr2-8.2467e-7*tr3... 38 | +5.3875e-9*tr4).*sr+(-5.72466e-3+1.0227e-4*tr... 39 | -1.6546e-6*tr2).*abs(sr).^1.5+4.8314e-4*sr.*sr; 40 | 41 | cr=1449.1e0+.0821e0*p+4.55e0*tr-.045e0*tr2+1.34e0*(sr-35.e0); 42 | rhor=rhor+1.e5*p./(cr.*cr).*(1.e0-2.e0*p./(cr.*cr)); 43 | 44 | rhoo=rhor./rhoref.*fsm_3d; 45 | 46 | 47 | -------------------------------------------------------------------------------- /matlab_operator/depth.m: -------------------------------------------------------------------------------- 1 | function [z,zz,dz,dzz,z_3d,zz_3d,dz_3d,dzz_3d]=depth(im, jm, kb, kl1, kl2) 2 | 3 | %load('grid.mat'); 4 | 5 | kdz=[1,1,2,4,8,16,32,64,128,256,512,1024]; 6 | 7 | z=zeros(1,kb); 8 | zz=zeros(1,kb); 9 | dz=zeros(1,kb); 10 | dzz=zeros(1,kb); 11 | 12 | for k=2:kl1 13 | z(k)=z(k-1)+kdz(k-1); 14 | end 15 | 16 | delz=z(kl1)-z(kl1-1); 17 | 18 | for k=kl1+1:kl2 19 | z(k)=z(k-1)+delz; 20 | end 21 | 22 | for k=kl2+1:kb 23 | dz(k)=kdz(kb-k+1)*delz/kdz(kb-kl2); 24 | z(k)=z(k-1)+dz(k); 25 | end 26 | 27 | for k=1:kb 28 | z(k)=-z(k)/z(kb); 29 | end 30 | 31 | for k=1:kb-1 32 | zz(k)=0.5e0*(z(k)+z(k+1)); 33 | end 34 | 35 | zz(kb)=2.e0*zz(kb-1)-zz(kb-2); 36 | 37 | for k=1:kb-1 38 | dz(k)=z(k)-z(k+1); 39 | dzz(k)=zz(k)-zz(k+1); 40 | end 41 | 42 | dz(kb)=0.e0; 43 | dzz(kb)=0.e0; 44 | 45 | z_3d=zeros(im,jm,kb); zz_3d=zeros(im,jm,kb); dz_3d=zeros(im,jm,kb); dzz_3d=zeros(im,jm,kb); 46 | for k=1:kb 47 | z_3d(:,:,k)=repmat(z(k),im,jm); 48 | zz_3d(:,:,k)=repmat(zz(k),im,jm); 49 | dz_3d(:,:,k)=repmat(dz(k),im,jm); 50 | dzz_3d(:,:,k)=repmat(dzz(k),im,jm); 51 | end 52 | return -------------------------------------------------------------------------------- /matlab_operator/file2ic.m: -------------------------------------------------------------------------------- 1 | function[dx,dy,cor,east_c,north_c,east_e,north_e,east_u,north_u,east_v,... 2 | north_v,h,art,aru,arv,fsm,dum,dvm,tb,sb,... 3 | tclim,sclim,ub,vb,elb,etb,dt,aam2d,rmean,rfe,rfw,... 4 | rfn,rfs,uabw,uabe,ele,elw,tbe,tbw,sbe,sbw,... 5 | tbn,tbs,sbn,sbs,rot,els,eln,vabs,vabn,ubw,... 6 | ube,vbs,vbn,ssurf,tsurf,dx_3d,dy_3d,cor_3d,h_3d,art_3d,... 7 | aru_3d,arv_3d,fsm_3d,dum_3d,dvm_3d,dt_3d,z,zz,dz,dzz,... 8 | z_3d,zz_3d,dz_3d,dzz_3d] = file2ic(aam); 9 | % ********************************************************************** 10 | % * * 11 | % * FUNCTION : Sets up my own problem. * 12 | % * * 13 | % * This example read IC from IC.dat file, generated by GRID.f in * 14 | % * GRID-DATA directory. Only minimal number of fields are read, * 15 | % * while others are calculated here. * 16 | % * * 17 | % ********************************************************************** 18 | % 19 | global im jm kb 20 | field = ''; 21 | name = ' '; 22 | rad=0.01745329; 23 | re=6371.E3; 24 | fprintf('(/,'' Read grid and initial conditions '',/) \n'); 25 | % 26 | %---start read-------------- 27 | %--- 1D --- 28 | fid = fopen('IC.dat','r'); 29 | %--------------1 D 30 | name=fscanf(fid,'%s',[1]); 31 | z=fscanf(fid,'%f',[1,kb]); 32 | 33 | name=fscanf(fid,'%s',[1]); 34 | zz=fscanf(fid,'%f',[1,kb]); 35 | 36 | name=fscanf(fid,'%s',[1]); 37 | dz=fscanf(fid,'%f',[1,kb]); 38 | 39 | name=fscanf(fid,'%s',[1]); 40 | dzz=fscanf(fid,'%f',[1,kb]); 41 | 42 | %---------------2 D 43 | name=fscanf(fid,'%s',[1]); 44 | east_e=fscanf(fid,'%f',[im,jm]); 45 | 46 | name=fscanf(fid,'%s',[1]); 47 | north_e=fscanf(fid,'%f',[im,jm]); 48 | 49 | name=fscanf(fid,'%s',[1]); 50 | h=fscanf(fid,'%f',[im,jm]); 51 | 52 | %---------------3 D 53 | name=fscanf(fid,'%s',[1]); 54 | for k=1:kb 55 | t(:,:,k)=fscanf(fid,'%f',[im,jm]); 56 | end 57 | 58 | name=fscanf(fid,'%s',[1]); 59 | for k=1:kb 60 | s(:,:,k)=fscanf(fid,'%f',[im,jm]); 61 | end 62 | 63 | name=fscanf(fid,'%s',[1]); 64 | for k=1:kb 65 | rmean(:,:,k)=fscanf(fid,'%f',[im,jm]); 66 | end 67 | 68 | %--- Constant wind stress read here 69 | % (for time dep. read in loop 9000 & interpolate in time) 70 | %---------------2 D 71 | name=fscanf(fid,'%s',[1]); 72 | wusurf(:,:)=fscanf(fid,'%f',[im,jm]); 73 | 74 | name=fscanf(fid,'%s',[1]); 75 | wvsurf(:,:)=fscanf(fid,'%f',[im,jm]); 76 | 77 | %-----------------read end------------------- 78 | % 79 | % --- calc. surface & lateral BC from climatology 80 | % 81 | for k=1:kb 82 | z_3d(:,:,k)=repmat(z(k),im,jm); 83 | zz_3d(:,:,k)=repmat(zz(k),im,jm); 84 | dz_3d(:,:,k)=repmat(dz(k),im,jm); 85 | dzz_3d(:,:,k)=repmat(dzz(k),im,jm); 86 | end 87 | 88 | for j=1:jm 89 | for i=1:im 90 | tsurf(i,j)=t(i,j,1); 91 | ssurf(i,j)=s(i,j,1); 92 | for k=1:kb 93 | tclim(i,j,k)=t(i,j,k); 94 | sclim(i,j,k)=s(i,j,k); 95 | end 96 | end 97 | end 98 | % 99 | % --- EAST & WEST BCs --- 100 | for j=1:jm 101 | ele(j)=0.; 102 | elw(j)=0.; 103 | % --- other vel. BCs (fixed in time) can be specified here 104 | uabe(j)=0.; 105 | uabw(j)=0.; 106 | for k=1:kb 107 | ubw(j,k)=0.; 108 | ube(j,k)=0.; 109 | tbw(j,k)=tclim(1,j,k); 110 | sbw(j,k)=sclim(1,j,k); 111 | tbe(j,k)=tclim(im,j,k); 112 | sbe(j,k)=sclim(im,j,k); 113 | end 114 | end 115 | % --- NORTH & SOUTH BCs --- 116 | for i=1:im 117 | els(i)=0.; 118 | eln(i)=0.; 119 | vabs(i)=0.; 120 | vabn(i)=0.; 121 | for k=1:kb 122 | vbs(i,k)=0.; 123 | vbn(i,k)=0.; 124 | tbs(i,k)=tclim(i,1,k); 125 | sbs(i,k)=sclim(i,1,k); 126 | tbn(i,k)=tclim(i,jm,k); 127 | sbn(i,k)=sclim(i,jm,k); 128 | end 129 | end 130 | % 131 | % Set initial conditions: 132 | % 133 | tb = t; 134 | sb = s; 135 | ub = zeros(im,jm,kb); 136 | vb=zeros(im,jm,kb); 137 | h_3d=repmat(h,1,1,kb); 138 | 139 | %[rho]=dens(sb,tb,h_3d,fsm_3d); 140 | % 141 | % --- calc. Curiolis Parameter 142 | % 143 | for j=1:jm 144 | for i=1:im 145 | cor(i,j)=2.*7.29E-5*sin(north_e(i,j)*rad); 146 | aam2d(i,j)=aam(i,j,1); 147 | elb(i,j)=0.; 148 | etb(i,j)=0.; 149 | dt(i,j)=h(i,j); 150 | end 151 | end 152 | % 153 | for j=1:jm 154 | for i=2:im-1 155 | dx(i,j)=0.5*rad*re*sqrt(((east_e(i+1,j)-east_e(i-1,j))... 156 | *cos(north_e(i,j)*rad))^2+(north_e(i+1,j)-north_e(i-1,j))^2); 157 | end 158 | dx(1,j)=dx(2,j); 159 | dx(im,j)=dx(im-1,j); 160 | end 161 | % 162 | for i=1:im 163 | for j=2:jm-1 164 | dy(i,j)=0.5*rad*re*sqrt(((east_e(i,j+1)-east_e(i,j-1))... 165 | *cos(north_e(i,j)*rad))^2+(north_e(i,j+1)-north_e(i,j-1))^2); 166 | end 167 | dy(i,1)=dy(i,2); 168 | dy(i,jm)=dy(i,jm-1); 169 | end 170 | % 171 | % Calculate areas and masks: 172 | % 173 | [art,aru,arv,fsm,dum,dvm]=areas_masks(dx,dy,h); 174 | fsm_3d=repmat(fsm,1,1,kb); 175 | % 176 | % 177 | % --- the following grids are needed only for netcdf plotting 178 | % 179 | % Corner of cell points: 180 | % 181 | for j=2:jm 182 | for i=2:im 183 | east_c(i,j)=(east_e(i,j)+east_e(i-1,j)... 184 | +east_e(i,j-1)+east_e(i-1,j-1))/4.e0; 185 | north_c(i,j)=(north_e(i,j)+north_e(i-1,j)... 186 | +north_e(i,j-1)+north_e(i-1,j-1))/4.e0; 187 | end 188 | end 189 | % 190 | % 191 | % Extrapolate ends (approx.): 192 | % 193 | for i=2:im 194 | east_c(i,1)=2.*east_c(i,2)-east_c(i,3); 195 | north_c(i,1)=2.*north_c(i,2)-north_c(i,3); 196 | end 197 | east_c(1,1)=2.*east_c(2,1)-east_c(3,1); 198 | % 199 | for j=2:jm 200 | east_c(1,j)=2.*east_c(2,j)-east_c(3,j); 201 | north_c(1,j)=2.*north_c(2,j)-north_c(3,j); 202 | end 203 | north_c(1,1)=2.*north_c(1,2)-north_c(1,3); 204 | % 205 | % u-points: 206 | % 207 | for j=1:jm-1 208 | for i=1:im 209 | east_u(i,j)=(east_c(i,j)+east_c(i,j+1))/2.e0; 210 | north_u(i,j)=(north_c(i,j)+north_c(i,j+1))/2.e0; 211 | end 212 | end 213 | % 214 | % Extrapolate ends: 215 | % 216 | for i=1:im 217 | east_u(i,jm)=(east_c(i,jm)*3.e0-east_c(i,jm-1))/2.e0; 218 | north_u(i,jm)=(north_c(i,jm)*3.e0-north_c(i,jm-1))/2.e0; 219 | end 220 | % 221 | % v-points: 222 | % 223 | for j=1:jm 224 | for i=1:im-1 225 | east_v(i,j)=(east_c(i,j)+east_c(i+1,j))/2.e0; 226 | north_v(i,j)=(north_c(i,j)+north_c(i+1,j))/2.e0; 227 | end 228 | end 229 | % 230 | % Extrapolate ends: 231 | % 232 | for j=1:jm 233 | east_v(im,j)=(east_c(im,j)*3.e0-east_c(im-1,j))/2.e0; 234 | north_v(im,j)=(north_c(im,j)*3.e0-north_c(im-1,j))/2.e0; 235 | end 236 | % 237 | % rot is the angle (radians, anticlockwise) of the i-axis relative 238 | % to east, averaged to a cell centre: (only needed for CDF plotting) 239 | % 240 | for j=1:jm 241 | for i=1:im-1 242 | rot(i,j)=0.; 243 | dlat=north_e(i+1,j)-north_e(i,j); 244 | dlon= east_e(i+1,j)- east_e(i,j); 245 | if(dlon~=0.) 246 | rot(i,j)=atan(dlat/dlon); 247 | end 248 | end 249 | rot(im,j)=rot(im-1,j); 250 | end 251 | % 252 | % Set lateral boundary conditions, for use in subroutine bcond 253 | % set all=0 for closed BCs. 254 | % Values=0 for vel BC only, =1 is combination of vel+elev. 255 | rfe=0.e0; 256 | rfw=0.e0; 257 | rfn=0.e0; 258 | rfs=0.e0; 259 | 260 | dx_3d=repmat(dx,1,1,kb); dy_3d=repmat(dy,1,1,kb); 261 | cor_3d=repmat(cor,1,1,kb); art_3d=repmat(art,1,1,kb); 262 | aru_3d=repmat(aru,1,1,kb); arv_3d=repmat(arv,1,1,kb); 263 | dum_3d=repmat(dum,1,1,kb); dvm_3d=repmat(dvm,1,1,kb); 264 | dt_3d=repmat(dt,1,1,kb); 265 | % 266 | return 267 | end 268 | -------------------------------------------------------------------------------- /matlab_operator/findpsi.m: -------------------------------------------------------------------------------- 1 | function findpsi(im,jm,imm1,jmm1,time,iskp,jskp,uab,vab,d,dx,dy) 2 | % ********************************************************************** 3 | % * * 4 | % * ROUTINE NAME: findpsi * 5 | % * * 6 | % * FUN%TION : %alculates the stream function, first assuming * 7 | % * zero on the southern boundary and then, using the * 8 | % * values on the western boundary, the stream function * 9 | % * is calculated again. If the elevation field is near * 10 | % * steady state, the two calculations should agree; * 11 | % * otherwise not. * 12 | % * * 13 | % ********************************************************************** 14 | % 15 | % 16 | 17 | psi = zeros(im,jm); 18 | % 19 | % Sweep northward: 20 | % 21 | for j=2:jmm1 22 | for i=2:im 23 | psi(i,j+1)=psi(i,j) ... 24 | +.25e0*uab(i,j)*(d(i,j)+d(i-1,j)) ... 25 | *(dy(i,j)+dy(i-1,j)) 26 | end 27 | end 28 | % 29 | prxy('Streamfunction, psi from u ',time,psi,im,iskp,jm,jskp,0.e0); 30 | % 31 | % Sweep eastward: 32 | % 33 | for j=2:jm 34 | for i=2:imm1 35 | psi(i+1,j)=psi(i,j) ... 36 | -.25e0*vab(i,j)*(d(i,j)+d(i,j-1)) ... 37 | *(dx(i,j)+dx(i,j-1)) 38 | end 39 | end 40 | % 41 | prxy('Streamfunction, psi from v ',time,psi,im,iskp,jm,jskp,0.e0); 42 | end 43 | 44 | % 45 | -------------------------------------------------------------------------------- /matlab_operator/printall.m: -------------------------------------------------------------------------------- 1 | function printall(im,jm,imm1,jmm1,iskp,jskp,uab,vab,elb,d,dx,dy,time,u,v,w,t,s,rho,aam,km,kb,mode,dt,zz,z) 2 | % ********************************************************************** 3 | % * * 4 | % * POM2K SOURCE CODE * 5 | % * * 6 | % * ROUTINE NAME: printall * 7 | % * * 8 | % * FUNCTION : Prints a set of outputs to device 6 * 9 | % * * 10 | % * Edit as approriate. * 11 | % * * 12 | % ********************************************************************** 13 | % 14 | % 15 | % 2-D horizontal fields: 16 | % 17 | prxy('Depth-averaged u, uab ',time,uab,im,iskp,jm,jskp,0.e0); 18 | % 19 | prxy('Depth-averaged v, vab ',time,vab,im,iskp,jm,jskp,0.e0); 20 | % 21 | prxy('Surface elevation, elb ',time,elb,im,iskp,jm,jskp,0.e0); 22 | % 23 | % 24 | % Calculate and print streamfunction: 25 | % 26 | findpsi(im,jm,imm1,jmm1,time,iskp,jskp,uab,vab,d,dx,dy); 27 | % 28 | if(mode~=2) 29 | % 30 | % 2-D horizontal sections of 3-D fields: 31 | % 32 | % Set levels for output: 33 | % 34 | ko(1)=1; 35 | ko(2)=floor(kb/2); 36 | ko(3)=kb-1; 37 | % 38 | prxyz('x-velocity, u ',time,u,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 39 | % 40 | prxyz('y-velocity, v ',time,v,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 41 | % 42 | ko(1)=2; 43 | prxyz('z-velocity, w ',time,w,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 44 | ko(1)=1; 45 | % 46 | prxyz('Potential temperature, t ',time,t,im,iskp,jm,jskp,kb,ko,3,1.e-2); 47 | % 48 | prxyz('Salinity, s ',time,s,im,iskp,jm,jskp,kb,ko,3,1.e-2); 49 | % 50 | prxyz('(density-1000)/rhoref, rho ',time,rho,im,iskp,jm,jskp,kb,ko,3,1.e-5); 51 | % 52 | % 53 | prxyz('Horizontal kinematic viscosity, aam ',time,aam,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 54 | % 55 | prxyz('Vertical kinematic viscosity, km ',time,km,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 56 | % 57 | % 58 | % Set sections for output: 59 | % 60 | jo(1)=1; 61 | jo(2)=floor(jm/2); 62 | jo(3)=jm-1; 63 | 64 | prxz('x-velocity, u ',time,u,im,iskp,jm,kb,jo,3,0.e0 ,dt,zz); 65 | % 66 | prxz('y-velocity, v ',time,v,im,iskp,jm,kb,jo,3,0.e0 ,dt,zz); 67 | % 68 | prxz('z-velocity, w ',time,w,im,iskp,jm,kb,jo,3,0.e0 ,dt,z ); 69 | % 70 | prxz('Potential temperature, t ',time,t,im,iskp,jm,kb,jo,3,1.e-2,dt,zz); 71 | % 72 | prxz('Salinity, s ',time,s,im,iskp,jm,kb,jo,3,1.e-2,dt,zz); 73 | % 74 | prxz('(density-1000)/rhoref, rho ',time,rho,im,iskp,jm,kb,jo,3,1.e-5,dt,zz); 75 | % 76 | % 77 | % Set se%tions for output: 78 | % 79 | io(1)=1; 80 | io(2)=floor(im/2); 81 | io(3)=im-1; 82 | % 83 | pryz('x-velocity, u ', time,u,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 84 | % 85 | pryz('y-velocity, v ', time,v,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 86 | % 87 | pryz('z-velocity, w ', time,w,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 88 | % 89 | pryz('Potential temperature, t ', time,t,im,jm,jskp,kb,io,3,1.e-2,dt,zz); 90 | % 91 | end 92 | % 93 | -------------------------------------------------------------------------------- /matlab_operator/profq.m: -------------------------------------------------------------------------------- 1 | function [sm,sh,dh,cc,ee,gg,l,kq,km,kh,... 2 | uf,vf,q2b,q2lb,a,c]=profq(sm,sh,dh,cc,... 3 | ee,gg,l,kq,km,kh,uf,vf,q2,q2b,q2lb,a,c,... 4 | h,etf,dti2,umol,dzz,grav,rho,kappa,u,v,dt,small,fsm,im,jm,kb,imm1,jmm1,kbm1,tbias,sbias,dz,... 5 | wusurf,wubot,wvsurf,wvbot,t,s,rhoref,zz,z) 6 | % ********************************************************************** 7 | % * Updated: Sep. 24, 2003 * 8 | % * FUNCTION : Solves for q2 (twice the turbulent kinetic energy), * 9 | % * q2l (q2 x turbulent length scale), km (vertical * 10 | % * kinematic viscosity) and kh (vertical kinematic * 11 | % * diffusivity), using a simplified version of the * 12 | % * level 2 1/2 model of Mellor and Yamada (1982). * 13 | % * In this version, the Craig-Banner sub-model whereby breaking wave * 14 | % * tke is injected into the surface is included. However, we use an * 15 | % * analytical solution to the near surface tke equation to solve for * 16 | % * q2 at the surface giving the same result as C-B diffusion. The new * 17 | % * scheme is simpler and more robust than the latter scheme. * 18 | % * * 19 | % * References * 20 | % * Craig, P. D. and M. L. Banner, Modeling wave-enhanced turbulence * 21 | % * in the ocean surface layer. J. Phys. Oceanogr., 24, 2546-2559, * 22 | % * 1994. * 23 | % * Ezer, T., On the seasonal mixed-layer simulated by a basin-scale * 24 | % * ocean model and the Mellor-Yamada turbulence scheme, * 25 | % * J. Geophys. Res., 105(C7), 16,843-16,855, 2000. * 26 | % * Mellor, G.L. and T. Yamada, Development of a turbulence * 27 | % * closure model for geophysical fluid fluid problems, * 28 | % * Rev. Geophys. Space Phys., 20, 851-875, 1982. * 29 | % * Mellor, G. L., One-dimensional, ocean surface layer modeling, * 30 | % * a problem and a solution. J. Phys. Oceanogr., 31(3), 790-809, * 31 | % * 2001. * 32 | % * Mellor, G.L. and A. Blumberg, Wave breaking and ocean surface * 33 | % * thermal response, J. Phys. Oceanogr., 2003. * 34 | % * Stacey, M. W., Simulations of the wind-forced near-surface * 35 | % * circulation in Knight Inlet: a parameterization of the * 36 | % * roughness length. J. Phys. Oceanogr., 29, 1363-1367, 1999. * 37 | % * * 38 | % ********************************************************************** 39 | %load('grid.mat');load('operator.mat');load('para.mat'); 40 | global dzz_3d kbm2 dz_3d zz_3d z_3d; 41 | 42 | a1=0.92; b1=16.6 ; a2=0.74 ; b2=10.1 ; c1=0.08; 43 | e1=1.8 ; e2=1.33 ; sef=1.0 ; cbcnst=100.; surfl=2.e5 ; shiw=0.0; 44 | 45 | l0=zeros(im,jm); 46 | kn = zeros(im,jm,kb); 47 | boygr=zeros(im,jm,kb); 48 | gh=zeros(im,jm,kb); 49 | stf=zeros(im,jm,kb); 50 | la=zeros(kb); 51 | 52 | dh = h + etf; 53 | dh_3d=repmat(dh,1,1,kb); 54 | 55 | a = zeros(im,jm,kb); 56 | c = zeros(im,jm,kb); 57 | d = zeros(im,jm,kb); 58 | 59 | a(:,:,2:kbm1)=dzz_3d(:,:,1:kbm2).*dz_3d(:,:,2:kbm1); 60 | c(:,:,2:kbm1)=dzz_3d(:,:,1:kbm2).*dz_3d(:,:,1:kbm2); 61 | 62 | a= DIVISION(-dti2 .* (AZF(kq)+umol) , (a .* dh_3d .* dh_3d)); 63 | c= DIVISION(-dti2 .* (AZB(kq)+umol) , (c .* dh_3d .* dh_3d)); 64 | a(:,:,1)=0.e0; c(:,:,1)=0.e0; 65 | a(:,:,kb)=0.e0; c(:,:,kb)=0.e0; 66 | %----------------------------------------------------------------------- 67 | % The following section solves the equation: 68 | % 69 | % dti2*(kq*q2')' - q2*(2.*dti2*dtef+1.) = -q2b 70 | % 71 | % Surface and bottom boundary conditions: 72 | % 73 | const1=(16.6e0^(2.e0/3.e0))*sef; 74 | 75 | % initialize fields that are not calculated on all boundaries 76 | % but are later used there 77 | l0(:,jm) =0; l0(im,:)=0; 78 | kn(:,:,:)=0; 79 | 80 | utau2 = sqrt( AXF(wusurf).^2 +AYF(wvsurf).^2 ); 81 | % Wave breaking energy- a variant of Craig & Banner (1994), see Mellor and Blumberg, 2003. 82 | % Surface length scale following Stacey (1999). 83 | l0 = surfl*utau2/grav; 84 | uf(:,:,kb) = sqrt( AXF(wubot).^2 +AYF(wvbot).^2 ) .* const1; 85 | 86 | % Calculate speed of sound squared: 87 | h_3d=repmat(h,1,1,kb); 88 | p=grav*rhoref*(-zz_3d .* h_3d)*1.e-4; % Calculate pressure in units of decibars: 89 | cc=1449.10+.00821*p+4.55*(t+tbias) -.045e0*(t+tbias).^2 +1.34*(s+sbias-35.0e0); 90 | cc=cc./sqrt((1.0-.01642.*p./cc) .*(1.0-0.40.*p./cc.^2)); 91 | cc(:,:,kb)=0; 92 | 93 | % Calculate buoyancy gradient: 94 | q2b =abs(q2b); 95 | q2lb=abs(q2lb); 96 | tmp = zeros(im,jm,kb); 97 | for k=2:kbm1 98 | tmp(:,:,k)=dzz(k-1); 99 | end 100 | boygr=DIVISION(-grav* DZB(rho) , tmp .* h_3d ) + DIVISION(grav^2 , AZB(cc.^2)); 101 | boygr(:,:,1)=0.e0; boygr(:,:,kb)=0.e0; 102 | l=q2lb ./ q2b; 103 | %l=max(l, repmat(kappa*l0,1,1,kb)); 104 | l=(z_3d>-0.5) .* max(l, repmat(kappa*l0,1,1,kb))+(z_3d<=-0.5) .* l; 105 | gh=l.^2 .* boygr ./q2b; 106 | gh=min(gh, 0.028); 107 | 108 | l(:,:,1)=kappa*l0; l(:,:,kb)=0; 109 | gh(:,:,1)=0 ; gh(:,:,kb)=0; 110 | 111 | % Calculate production of turbulent kinetic energy: 112 | kn= DIVISION(km.*sef.*(AXF(DZB(u)).^2 + AYF(DZB(v)).^2) , (tmp.*dh_3d).^2) -shiw.*km.*boygr + kh.*boygr; 113 | % 114 | % NOTE: Richardson # dep. dissipation correction (Mellor: 2001; Ezer, 2000), 115 | % depends on ghc the critical number (empirical -6 to -2) to increase mixing. 116 | ghc=-6.0e0; 117 | stf=ones(im,jm,kb); 118 | % It is unclear yet if diss. corr. is needed when surf. waves are included. 119 | % if(gh(i,j,k).lt.0.e0) 120 | % ... stf(i,j,k)=1.0e0-0.9e0*(gh(i,j,k)/ghc)**1.5e0 121 | % if(gh(i,j,k).lt.ghc) stf(i,j,k)=0.1e0 122 | dtef=sqrt(q2b).*stf./(b1.*l+small); 123 | dtef(:,:,1)=0.e0;dtef(:,:,kb)=0.e0; 124 | 125 | d=-uf-2.e0*dti2*kn; 126 | d(:,:,1)=-(15.8*cbcnst)^(2./3.).*utau2; 127 | d(:,jm,1)=0; d(im,:,1)=0; d(:,:,kb)=-uf(:,:,kb); 128 | temp1=a(:,:,1:kbm1); temp2=c(:,:,2:kb); 129 | 130 | for j=2:jm 131 | for i=2:im 132 | la=diag(reshape(a(i,j,:)+c(i,j,:)-1-2.e0*dti2.*dtef(i,j,:),kb,1),0) ... 133 | - diag(reshape(temp1(i,j,:),kbm1,1),1) ... 134 | - diag(reshape(temp2(i,j,:),kbm1,1),-1); 135 | uf(i,j,:)=la\reshape(d(i,j,:),kb,1); 136 | end 137 | end 138 | 139 | %----------------------------------------------------------------------- 140 | % The following section solves the equation: 141 | % 142 | % dti2(kq*q2l')' - q2l*(dti2*dtef+1.) = -q2lb 143 | 144 | vf(:,:,kb)=0.e0; 145 | 146 | for k=2:kbm1 147 | dtef(:,:,k)=dtef(:,:,k).*(1.e0+e2.*((1.e0/abs(z(k)-z(1))+1.e0./abs(z(k)-z(kb))) ... 148 | .*l(:,:,k)./(dh(:,:)*kappa)).^2); 149 | end 150 | 151 | d=-vf-dti2*kn.*l.*e1; 152 | d(:,:,1)=-(15.8*cbcnst)^(2./3.).*utau2; 153 | d(:,jm,1)=0.e0; d(im,:,1)=0.e0; d(:,:,kb)=0.e0; 154 | temp=vf(:,:,1); 155 | 156 | for j=2:jm 157 | for i=2:im 158 | la=diag(reshape(a(i,j,:)+c(i,j,:)-1-dti2.*dtef(i,j,:),kb,1),0) ... 159 | - diag(reshape(temp1(i,j,:),kbm1,1),1) ... 160 | - diag(reshape(temp2(i,j,:),kbm1,1),-1); 161 | vf(i,j,:)=la\reshape(d(i,j,:),kb,1); 162 | end 163 | end 164 | vf(:,:,1)=temp; 165 | 166 | dt_3d=repmat(dt,1,1,kb); 167 | 168 | filter = (uf<=small | vf<=small); 169 | filter(:,:,1) = false; 170 | filter(:,:,kb) = false; 171 | uf(filter) = small; 172 | vf(filter) = 0.1 * dt_3d(filter) * small; 173 | 174 | %----------------------------------------------------------------------- 175 | % The following section solves for km and kh: 176 | coef4=18.e0*a1*a1+9.e0*a1*a2; 177 | coef5=9.e0*a1*a2; 178 | % Note that sm and sh limit to infinity when gh approaches 0.0288: 179 | coef1=a2*(1.e0-6.e0*a1/b1*stf); 180 | coef2=3.e0*a2*b2/stf+18.e0*a1*a2; 181 | coef3=a1*(1.e0-3.e0*c1-6.e0*a1/b1*stf); 182 | sh=coef1./(1.e0-coef2.*gh); 183 | sm=coef3+sh.*coef4.*gh; 184 | sm=sm./(1.0-coef5.*gh); 185 | 186 | kn=l.*sqrt(abs(q2)); 187 | kq=(kn.*.41e0.*sh+kq)*.5e0; 188 | km=(kn.*sm+km)*.5e0; 189 | kh=(kn.*sh+kh)*.5e0; 190 | 191 | fsm_3d = repmat(fsm, 1, 1, kb); 192 | km(:,jm,:)=km(:,jmm1,:).*fsm_3d(:,jm,:); 193 | kh(:,jm,:)=km(:,jmm1,:).*fsm_3d(:,jm,:); 194 | km(:,1,:)=km(:,2,:).*fsm_3d(:,1,:); 195 | kh(:,1,:)=kh(:,2,:).*fsm_3d(:,1,:); 196 | 197 | km(im,:,:)=km(imm1,:,:).*fsm_3d(im,:,:); 198 | kh(im,:,:)=kh(imm1,:,:).*fsm_3d(im,:,:); 199 | km(1,:,:)=km(2,:,:).*fsm_3d(1,:,:); 200 | kh(1,:,:)=kh(2,:,:).*fsm_3d(1,:,:); 201 | 202 | end 203 | 204 | -------------------------------------------------------------------------------- /matlab_operator/proft.m: -------------------------------------------------------------------------------- 1 | function [f1] = proft(f,wfsurf,fsurf,nbc,h,etf,swrad,kh) 2 | %----------------------------------------------------------------------- 3 | % Irradiance parameters after Paulson and Simpson: 4 | % ntp 1 2 3 4 5 5 | % Jerlov type i ia ib ii iii 6 | r=[0.58,0.62,0.67,0.77,0.78]; 7 | ad1=[0.35,0.60,1.0,1.5,1.4]; 8 | ad2=[0.23,20.0,17.0,14.0,7.90]; 9 | % solves the equation:dti2*(kh*f')'-f=-fb 10 | global im jm kb dz_3d dzz_3d kbm1 dti2 umol kbm2 dz 11 | 12 | rad=zeros(im,jm,kb); 13 | a = zeros(im,jm,kb);c = zeros(im,jm,kb); d=zeros(im,jm,kb); 14 | dh = h+etf; 15 | dh_3d=repmat(dh,1,1,kb);swrad_3d=repmat(swrad,1,1,kb); 16 | la=zeros(kb); f1=zeros(im,jm,kb); 17 | 18 | if(nbc==2||nbc==4) 19 | rad=swrad_3d.*(r(ntp)*exp(z_3d.*dh_3d/ad1(ntp))+(1.e0-r(ntp))*exp(z_3d.*dh_3d/ad2(ntp))); 20 | rad(:,:,kb)=0.0; 21 | end 22 | 23 | a(:,:,1:kbm2)=-dti2*(kh(:,:,2:kbm1)+umol); 24 | a=DIVISION(a,dz_3d.*dzz_3d.*dh_3d.*dh_3d); 25 | 26 | c(:,:,2:kbm1)=dzz_3d(:,:,1:kbm2); 27 | c=DIVISION(-dti2*(kh+umol),dz_3d.*c.*dh_3d.*dh_3d); 28 | 29 | d=-f - DIVISION(dti2 .* DZF(rad),(dh_3d .* dz_3d)); 30 | d(:,:,1)= -f(:,:,1) + dti2 .* wfsurf(:,:) ./ (dh(:,:) .* dz(1)); 31 | d(:,:,kb)=-f(:,:,kb); 32 | 33 | if(nbc==2) 34 | d(:,:,1)=-f(:,:,1) + dti2*(wfsurf+rad(:,:,1)-rad(:,:,2))./(dz(1)*dh); 35 | elseif(nbc==3 || nbc==4) 36 | a(:,:,1)=0.e0; 37 | d(:,:,1)=-fsurf; 38 | end 39 | 40 | % calculate penetrative radiation. At the bottom any unattenuated 41 | % radiation is deposited in the bottom layer: 42 | temp1=a(:,:,1:kbm1); temp2=c(:,:,2:kb); 43 | 44 | for j=2:jm 45 | for i=2:im 46 | la=diag(reshape(a(i,j,:)+c(i,j,:)-1,kb,1),0) ... 47 | - diag(reshape(temp1(i,j,:),kbm1,1),1) ... 48 | - diag(reshape(temp2(i,j,:),kbm1,1),-1); 49 | f1(i,j,:)=la\reshape(d(i,j,:),kb,1); 50 | end 51 | end 52 | return 53 | -------------------------------------------------------------------------------- /matlab_operator/profu.m: -------------------------------------------------------------------------------- 1 | function [uf,wubot] = profu(uf,etf,h,km,wusurf,cbc,ub,vb) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : Solves for vertical diffusion of x-momentum using * 6 | % * method described by Richmeyer and Morton. * 7 | % * * 8 | % * See: * 9 | % * * 10 | % * Richtmeyer R.D., and K.W. Morton, 1967. Difference * 11 | % * Methods for Initial-Value Problems, 2nd edition, * 12 | % * Interscience, New York, 198-201. * 13 | % * * 14 | % * NOTE that wusurf has the opposite sign to the wind * 15 | % * speed. * 16 | % * * 17 | % ********************************************************************** 18 | %load('grid.mat');load('operator.mat');load('para.mat'); 19 | global im jm kb dz_3d dzz_3d kbm1 dti2 umol kbm2 dz dum 20 | 21 | dh = AXB(h+etf);dh(1,:)=1.e0;dh(:,1)=1.e0; 22 | dh_3d=repmat(dh,1,1,kb); 23 | a=zeros(im,jm,kb); 24 | c = AXB(km); c(1,:,:)=0.e0; c(:,1,:)=0.e0; 25 | la=zeros(kbm1);d=zeros(im,jm,kb); 26 | 27 | a(:,:,1:kbm2)=-dti2*(c(:,:,2:kbm1)+umol); 28 | a=DIVISION(a,dz_3d.*dzz_3d.*dh_3d.*dh_3d); 29 | 30 | d(:,:,2:kbm1)=dzz_3d(:,:,1:kbm2); 31 | c=DIVISION(-dti2*(c+umol),dz_3d.*d.*dh_3d.*dh_3d); 32 | 33 | tps = AXB(cbc) .* sqrt( ub(:,:,kbm1).^2 + AXB( AYF( vb(:,:,kbm1) ) ).^2 ); 34 | a(:,:,kbm1)=-tps(:,:) * dti2./(dz(kbm1) .* dh(:,:)); 35 | 36 | d=-uf; 37 | d(:,:,1)= -uf(:,:,1) + dti2 .* wusurf(:,:) ./ (dh(:,:) .* dz(1)); 38 | temp1=a(:,:,1:kbm1); temp1(:,:,kbm1)=0.e0; 39 | temp2=c(:,:,2:kb); 40 | 41 | for j=2:jm 42 | for i=2:im 43 | la=diag(reshape(a(i,j,:)+c(i,j,:)-1,kb,1),0) ... 44 | - diag(reshape(temp1(i,j,:),kbm1,1),1) ... 45 | - diag(reshape(temp2(i,j,:),kbm1,1),-1); 46 | uf(i,j,:)=la\reshape(d(i,j,:),kb,1); 47 | end 48 | end 49 | uf=uf.*repmat(dum,1,1,kb); 50 | wubot=-tps.*uf(:,:,kbm1); 51 | 52 | return 53 | 54 | -------------------------------------------------------------------------------- /matlab_operator/profv.m: -------------------------------------------------------------------------------- 1 | function [vf,wvbot] = profv(vf,etf,h,km,wvsurf,cbc,ub,vb) 2 | % ********************************************************************** 3 | % * 4 | % * FUNCTION : Solves for vertical diffusion of y-momentum using * 5 | % * method described by Richmeyer and Morton. * 6 | % * * 7 | % * See: * 8 | % * * 9 | % * Richtmeyer R.D., and K.W. Morton, 1967. Difference * 10 | % * Methods for Initial-Value Problems, 2nd edition, * 11 | % * Interscience, New York, 198-201. * 12 | % * * 13 | % * NOTE that wvsurf has the opposite sign to the wind * 14 | % * speed. * 15 | % * * 16 | % ********************************************************************** 17 | global im jm kb dz_3d dzz_3d kbm1 dti2 umol kbm2 dz dvm 18 | 19 | a=zeros(im,jm,kb); 20 | dh = AYB(h+etf); dh(1,:)=1.e0; dh(:,1)=1.e0; 21 | dh_3d=repmat(dh,1,1,kb); 22 | c = AYB(km); c(1,:,:)=0.e0;c(:,1,:)=0.e0; 23 | la=zeros(kbm1);d=zeros(im,jm,kb); 24 | 25 | a(:,:,1:kbm2)=-dti2*(c(:,:,2:kbm1)+umol); 26 | a=DIVISION(a,dz_3d.*dzz_3d.*dh_3d.*dh_3d); 27 | 28 | d(:,:,2:kbm1)=dzz_3d(:,:,1:kbm2); 29 | c=DIVISION(-dti2*(c+umol),dz_3d.*d.*dh_3d.*dh_3d); 30 | 31 | tps = AYB(cbc) .* sqrt( AYB( AXF( ub(:,:,kbm1) ) ).^2 + vb(:,:,kbm1).^2 ); 32 | a(:,:,kbm1)=-tps(:,:) * dti2./(dz(kbm1) .* dh(:,:)); 33 | 34 | d=-vf; 35 | d(:,:,1)= -vf(:,:,1) + dti2 .* wvsurf(:,:) ./ (dh(:,:) .* dz(1)); 36 | temp1=a(:,:,1:kbm1); temp1(:,:,kbm1)=0.e0; 37 | temp2=c(:,:,2:kb); 38 | 39 | for j=2:jm 40 | for i=2:im 41 | la=diag(reshape(a(i,j,:)+c(i,j,:)-1,kb,1),0) ... 42 | - diag(reshape(temp1(i,j,:),kbm1,1),1) ... 43 | - diag(reshape(temp2(i,j,:),kbm1,1),-1); 44 | vf(i,j,:)=la\reshape(d(i,j,:),kb,1); 45 | end 46 | end 47 | 48 | vf=vf.*repmat(dvm,1,1,kb); 49 | wvbot=-tps .* vf(:,:,kbm1); 50 | 51 | return 52 | -------------------------------------------------------------------------------- /matlab_operator/prxy.m: -------------------------------------------------------------------------------- 1 | function prxy(label,time,a,im,iskp,jm,jskp,scala) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : Writes a horizontal 2-D field. * 6 | % * * 7 | % * label ....... label for output * 8 | % * time ........ time (days) * 9 | % * a(im,jm,kb).. array to be printed * 10 | % * iskp ........ skipping interval for i * 11 | % * jskp ........ skipping interval for j * 12 | % * scala ....... < 0 for floating point numbers output * 13 | % * 0 for integer output, divisor for a * 14 | % * based on magnitudes of |a| values * 15 | % * > 0 for integer output, divisor for a * 16 | % * given by scala * 17 | % * * 18 | % ********************************************************************** 19 | % 20 | 21 | if(scala>=0.e0) 22 | cols=24; 23 | else 24 | cols=12; 25 | end 26 | % 27 | if (scala<0.e0) 28 | scale = 1.e0; 29 | end 30 | if (scala==0.e0) 31 | amx=1.e-12; 32 | for j=1:jskp:jm 33 | for i=1:iskp:im 34 | amx=max(abs(a(i,j)),amx); 35 | end 36 | end 37 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 38 | end 39 | if(scala>0.e0) 40 | scale=scala; 41 | end 42 | % 43 | % 44 | fprintf('%s\n',label); 45 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 46 | for ib=1:cols*iskp:im 47 | % 48 | ie=ib+(cols-1)*iskp; 49 | if(ie>im) 50 | ie=im; 51 | end 52 | % 53 | for j=1:jskp:jm 54 | jwr=jm+1-j; 55 | if(scala>=0.e0) 56 | 57 | fprintf('%d , %d \n',jwr,floor(a(ib,jwr)/scale+0.5)); 58 | fprintf('%d , %d \n',jwr,floor(a(ie,jwr)/scale+0.5)); 59 | fprintf('%d , %d \n',jwr,floor(a(iskp,jwr)/scale+0.5)); 60 | else 61 | fprintf('%d , %d \n',jwr,a(ib,jwr)); 62 | fprintf('%d , %d \n',jwr,a(ie,jwr)); 63 | fprintf('%d , %d \n',jwr,a(iskip,jwr)); 64 | 65 | end 66 | end 67 | % 68 | % 69 | end 70 | return 71 | end 72 | % 73 | -------------------------------------------------------------------------------- /matlab_operator/prxyz.m: -------------------------------------------------------------------------------- 1 | function prxyz(label,time,a,im,iskp,jm,jskp,kb,ko,nko,scala) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUNCTION : Writes horizontal layers of a 3-D field with * 6 | % * integers or floating point numbers. * 7 | % * * 8 | % * label ....... label for output * 9 | % * time ........ time (days) * 10 | % * a(im,jm,kb).. array to be printed * 11 | % * iskp ........ skipping interval for i * 12 | % * jskp ........ skipping interval for j * 13 | % * ko .......... 1-D array of k-indices for output * 14 | % * nko ......... number of elements in ko * 15 | % * scala ....... < 0 for floating point numbers output * 16 | % * 0 for integer output, divisor for a * 17 | % * based on magnitudes of |a| values * 18 | % * > 0 for integer output, divisor for a * 19 | % * given by scala * 20 | % * * 21 | % * (NOTE that this combines functions of old prxyz and * 22 | % * eprxyz) * 23 | % * * 24 | % ********************************************************************** 25 | % 26 | 27 | % 28 | if(scala>=0.e0) 29 | cols=24; 30 | else 31 | cols=12; 32 | end 33 | % 34 | if (scala<0.e0) scale = 1.e0; 35 | end 36 | if (scala==0.e0) 37 | amx=1.e-12; 38 | for iko=1:nko 39 | k=ko(iko); 40 | for j=1:jskp:jm 41 | for i=1:iskp:im 42 | amx=max(abs(a(i,j,k)),amx); 43 | end 44 | end 45 | end 46 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 47 | end 48 | if(scala>0.e0) scale=scala; 49 | end 50 | % 51 | fprintf('%s\n',label); 52 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 53 | 54 | for iko=1:nko 55 | % 56 | k=ko(iko); 57 | fprintf('Layer k = %d \n',k); 58 | % 59 | for ib=1:cols*iskp:im 60 | % 61 | ie=ib+(cols-1)*iskp; 62 | if(ie>im) ie=im; 63 | % 64 | if(scala>=0.e0) 65 | fprintf('%d %d %d\n',ib,ie,iskp); 66 | else 67 | fprintf('%d %d %d\n',ib,ie,iskp); 68 | end 69 | % 70 | for j=1:jskp:jm 71 | jwr=jm+1-j; 72 | if(scala>=0.e0) 73 | fprintf('%d , %d \n',jwr,floor(a(ib,jwr,k)/scale+0.5)); 74 | fprintf('%d , %d \n',jwr,floor(a(ie,jwr,k)/scale+0.5)); 75 | fprintf('%d , %d \n',jwr,floor(a(iskp,jwr,k)/scale+0.5)); 76 | else 77 | fprintf('%d , %d \n',jwr,a(ib,jwr,k)); 78 | fprintf('%d , %d \n',jwr,a(ie,jwr,k)); 79 | fprintf('%d , %d \n',jwr,a(iskp,jwr,k)); 80 | end 81 | end 82 | % 83 | fprintf('//'); 84 | % 85 | end 86 | % 87 | end 88 | % 89 | return 90 | % 91 | end 92 | % 93 | -------------------------------------------------------------------------------- /matlab_operator/prxz.m: -------------------------------------------------------------------------------- 1 | function prxz(label,time,a,im,iskp,jm,kb,jo,njo,scala,dt,zz) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Writes vertical section of a 3-D field, in the * 5 | % * x- or i-direction . * 6 | % * * 7 | % * label ....... label for output * 8 | % * time ........ time (days) * 9 | % * a(im,jm,kb).. array to be printed * 10 | % * iskp ........ skipping interval for i * 11 | % * jo .......... 1-D array of j-indices for output * 12 | % * njo ......... number of elements in jo * 13 | % * scala ....... < 0 for floating point numbers output * 14 | % * 0 for integer output, divisor for a * 15 | % * based on magnitudes of |a| values * 16 | % * > 0 for integer output, divisor for a * 17 | % * given by scala * 18 | % * dt(im,jm) ... total depth * 19 | % * zz(kb) ...... sigma coordinate * 20 | % * * 21 | % ********************************************************************** 22 | % 23 | if(scala>=0.e0) 24 | cols=24; 25 | else 26 | cols=12; 27 | end 28 | % 29 | if (scala<0.e0) 30 | scale = 1.e0; 31 | end 32 | if (scala==0.e0) 33 | amx=1.e-12; 34 | for k=1:kb 35 | for ijo=1:njo 36 | j=jo(ijo); 37 | for i=1:iskp:im 38 | amx=max(abs(a(i,j,k)),amx); 39 | end 40 | end 41 | end 42 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 43 | end 44 | if(scala>0.e0) 45 | scale=scala; 46 | end 47 | % 48 | fprintf('%s\n',label); 49 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 50 | 51 | for ijo=1:njo 52 | j=jo(ijo); 53 | fprintf('Section j = %d \n',j); 54 | for ib=1:cols*iskp:im 55 | ie=ib+(cols-1)*iskp; 56 | if(ie>im) ie=im; 57 | end 58 | 59 | fprintf('i = %d , d= %d , z or zz',ib,floor(dt(ib,j)+0.5)); 60 | fprintf('i = %d , d= %d , z or zz',ie,floor(dt(ie,j)+0.5)); 61 | fprintf('i = %d , d= %d , z or zz',iskp,floor(dt(iskp,j)+0.5)); 62 | 63 | for k=1:kb 64 | if(scala>=0.e0) 65 | fprintf('%d , %f %d\n',k,zz(k),floor(a(ib,j,k)/scale+0.5)); 66 | fprintf('%d , %f %d\n',k,zz(k),floor(a(ie,j,k)/scale+0.5)); 67 | fprintf('%d , %f %d\n',k,zz(k),floor(a(iskp,j,k)/scale+0.5)); 68 | else 69 | fprintf('%d , %f %f\n',k,zz(k),a(ib,j,k)); 70 | fprintf('%d , %f %f\n',k,zz(k),a(ie,j,k)); 71 | fprintf('%d , %f %f\n',k,zz(k),a(ik,j,k)); 72 | end 73 | end 74 | % 75 | end 76 | % 77 | end 78 | % 79 | return 80 | % 81 | end 82 | % 83 | -------------------------------------------------------------------------------- /matlab_operator/pryz.m: -------------------------------------------------------------------------------- 1 | function pryz(label,time,a,im,jm,jskp,kb,io,nio,scala,dt,zz) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUNCTION : Writes vertical section of a 3-D field, in the * 6 | % * y- or j-direction. * 7 | % * * 8 | % * label ....... label for output * 9 | % * time ........ time (days) * 10 | % * a(im,jm,kb).. array to be printed * 11 | % * jskp ........ skipping interval for j * 12 | % * io .......... 1-D array of i-indices for output * 13 | % * nio ......... number of elements in io * 14 | % * scala ....... < 0 for floating point numbers output * 15 | % * 0 for integer output, divisor for a * 16 | % * based on magnitudes of |a| values * 17 | % * > 0 for integer output, divisor for a * 18 | % * given by scala * 19 | % * dt(im,jm) ... total depth * 20 | % * zz(kb) ...... sigma coordinate * 21 | % * * 22 | % ********************************************************************** 23 | % 24 | % 25 | if(scala>=0.e0) 26 | cols=24; 27 | else 28 | cols=12; 29 | end 30 | % 31 | if (scala<0.e0) 32 | scale = 1.e0; 33 | end 34 | if (scala==0.e0) 35 | amx=1.e-12 36 | for k=1:kb 37 | for j=1:jskp:jm 38 | for iio=1:nio 39 | i=io(iio); 40 | amx=max(abs(a(i,j,k)),amx); 41 | end 42 | end 43 | end 44 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 45 | end 46 | if(scala>0.e0) 47 | scale=scala; 48 | end 49 | % 50 | 51 | fprintf('%s\n',label); 52 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 53 | % 54 | for iio=1:nio 55 | % 56 | i=io(iio); 57 | % 58 | fprintf('Section i = %d \n',i); 59 | for jb=1:cols*jskp:jm 60 | % 61 | je=jb+(cols-1)*jskp; 62 | if(je>jm) 63 | je=jm; 64 | end 65 | % 66 | if(scala>=0.e0) 67 | fprintf('%20d%20d%20d',jb,je,jskp); 68 | else 69 | fprintf('%10d%10d%10d',jb,je,jskp); 70 | end 71 | 72 | fprintf('%10d \n',floor(dt(i,jb)/scale+0.5)); 73 | fprintf('%10d \n',floor(dt(i,je)/scale+0.5)); 74 | fprintf('%10d \n',floor(dt(i,jskp)/scale+0.5)); 75 | 76 | for k=1:kb 77 | if(scala>=0.e0) 78 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,jb,k)/scale+0.5)); 79 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,je,k)/scale+0.5)); 80 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,jskp,k)/scale+0.5)); 81 | 82 | else 83 | fprintf('%d %d %d \n',k,zz(k),a(i,jb,k)); 84 | fprintf('%d %d %d \n',k,zz(k),a(i,je,k)); 85 | fprintf('%d %d %d \n',k,zz(k),a(i,jb,jskp)); 86 | end 87 | end 88 | % 89 | fprintf('//'); 90 | % 91 | end 92 | % 93 | end 94 | % 95 | return 96 | % 97 | end 98 | % 99 | -------------------------------------------------------------------------------- /matlab_operator/slpmax.m: -------------------------------------------------------------------------------- 1 | function [h] = slpmax(h,im,jm,fsm,slmax) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Limits the maximum of: * 5 | % * * 6 | % * / * 7 | % * * 8 | % * for two adjacent cells. The maximum possible value * 9 | % * is unity. * 10 | % * * 11 | % ********************************************************************** 12 | 13 | for loop=1:10 14 | % Sweep right: 15 | for j=2:jm-1 16 | for i=2:im-1 17 | if(fsm(i,j) ~= 0.e0 && fsm(i+1,j) ~=0.e0) 18 | if(abs(h(i+1,j)-h(i,j))/(h(i,j)+h(i+1,j)) >= slmax) 19 | mean=(h(i+1,j)+h(i,j))/2.e0; 20 | %del=sign(slmax,h(i+1,j)-h(i,j)); 21 | if(h(i+1,j)-h(i,j)>=0.e0) 22 | del = abs(slmax); 23 | else del = -abs(slmax); 24 | end 25 | h(i+1,j)=mean*(1.e0+del); 26 | h(i,j)=mean*(1.e0-del); 27 | end 28 | end 29 | end 30 | 31 | % Sweep left: 32 | for i=im-1:-1:2 33 | if(fsm(i,j) ~= 0.0 && fsm(i+1,j) ~= 0.0) 34 | if(abs(h(i+1,j)-h(i,j))/(h(i,j)+h(i+1,j)) >= slmax) 35 | mean=(h(i+1,j)+h(i,j))/2.e0; 36 | %del=sign(slmax,h(i+1,j)-h(i,j)); 37 | if(h(i+1,j)-h(i,j)>=0.e0) 38 | del = abs(slmax); 39 | else del = -abs(slmax); 40 | end 41 | h(i+1,j)=mean*(1.e0+del); 42 | h(i,j)=mean*(1.e0-del); 43 | end 44 | end 45 | end 46 | end 47 | 48 | % Sweep up: 49 | for i=2:im-1 50 | for j=2:jm-1 51 | if(fsm(i,j) ~= 0.0 && fsm(i,j+1) ~= 0.0) 52 | if(abs(h(i,j+1)-h(i,j))/(h(i,j)+h(i,j+1)) >= slmax) 53 | mean=(h(i,j+1)+h(i,j))/2.e0; 54 | if(h(i,j+1)-h(i,j)>=0.e0) 55 | del=abs(slmax); 56 | else del=-abs(slmax); 57 | end 58 | %del=sign(slmax,h(i,j+1)-h(i,j)); 59 | h(i,j+1)=mean*(1.0+del); 60 | h(i,j)=mean*(1.0-del); 61 | end 62 | end 63 | end 64 | 65 | % Sweep down: 66 | for j=jm-1:-1:2 67 | if(fsm(i,j) ~= 0.0 && fsm(i,j+1) ~= 0.0) 68 | if(abs(h(i,j+1)-h(i,j))/(h(i,j)+h(i,j+1)) >= slmax) 69 | mean=(h(i,j+1)+h(i,j))/2.e0; 70 | if(h(i,j+1)-h(i,j)>=0.e0) 71 | del=abs(slmax); 72 | else del=-abs(slmax); 73 | end 74 | %del=sign(slmax,h(i,j+1)-h(i,j)); 75 | h(i,j+1)=mean*(1.e0+del); 76 | h(i,j)=mean*(1.e0-del); 77 | end 78 | end 79 | end 80 | end 81 | end 82 | -------------------------------------------------------------------------------- /matlab_operator/smol_adif.m: -------------------------------------------------------------------------------- 1 | function[xmassflux,ymassflux,zwflux,ff,sw] = smol_adif(xmassflux,ymassflux,zwflux,ff,sw,... 2 | im,jm,kb,imm1,jmm1,kbm1,dti2,fsm,aru,arv,dzz,dt) 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : %alculates the antidiffusive velocity used to * 6 | % * reduce the numerical diffusion associated with the * 7 | % * upstream differencing scheme. * 8 | % * * 9 | % * This is based on a subroutine of Gianmaria Sannino * 10 | % * (Inter-university %omputing %onsortium, Rome, Italy)* 11 | % * and Vincenzo Artale (Italian National Agency for * 12 | % * New Technology and Environment, Rome, Italy), * 13 | % * forwnloaded from the POM FTP site on 1 Nov. 2001. * 14 | % * The calculations have been simplified by removing * 15 | % * the shock switch option. * 16 | % * * 17 | % ********************************************************************** 18 | % 19 | % 20 | % 21 | % 22 | value_min=1.0e-9; 23 | epsilon=1.0e-14; 24 | % 25 | % Apply temperature and salinity mask: 26 | % 27 | for k=1:kb 28 | for i=1:im 29 | for j=1:jm 30 | ff(i,j,k)=ff(i,j,k)*fsm(i,j); 31 | end 32 | end 33 | end 34 | % 35 | % Recalculate mass fluxes with antidiffusion velocity: 36 | % 37 | for k=1:kbm1 38 | for j=2:jmm1 39 | for i=2:im 40 | if(ff(i,j,k) 1. * 38 | % * * 39 | % * Reference: * 40 | % * * 41 | % * Smolarkiewicz, P.K.; A fully multidimensional * 42 | % * positive definite advection transport algorithm * 43 | % * with small implicit diffusion, Journal of * 44 | % * %omputational Physics, 54, 325-362, 1984. * 45 | % * * 46 | % ********************************************************************** 47 | % 48 | % 49 | % 50 | % 51 | % calculate horizontal mass fluxes: 52 | % 53 | xmassflux=zeros(im,jm,kb); 54 | ymassflux=zeros(im,jm,kb); 55 | 56 | 57 | % 58 | for k=1:kbm1 59 | for j=2:jmm1 60 | for i=2:im 61 | xmassflux(i,j,k)=0.25e0*(dy(i-1,j)+dy(i,j)) ... 62 | *(dt(i-1,j)+dt(i,j))*u(i,j,k); 63 | end 64 | end 65 | % 66 | for j=2:jm 67 | for i=2:imm1 68 | ymassflux(i,j,k)=0.25e0*(dx(i,j-1)+dx(i,j)) ... 69 | *(dt(i,j-1)+dt(i,j))*v(i,j,k); 70 | end 71 | end 72 | end 73 | % 74 | for j=1:jm 75 | for i=1:im 76 | fb(i,j,kb)=fb(i,j,kbm1); 77 | end 78 | end 79 | % 80 | eta=etb; 81 | zwflux=w; 82 | fbmem=fb; 83 | % 84 | % Start Smolarkiewicz scheme: 85 | % 86 | for itera=1:nitera 87 | % 88 | % Upwind advection scheme: 89 | % 90 | for k=1:kbm1 91 | for j=2:jm 92 | for i=2:im 93 | xflux(i,j,k)=0.5e0 ... 94 | *((xmassflux(i,j,k)+abs(xmassflux(i,j,k))) ... 95 | *fbmem(i-1,j,k)+ ... 96 | (xmassflux(i,j,k)-abs(xmassflux(i,j,k))) ... 97 | *fbmem(i,j,k)); 98 | % 99 | yflux(i,j,k)=0.5e0 ... 100 | *((ymassflux(i,j,k)+abs(ymassflux(i,j,k))) ... 101 | *fbmem(i,j-1,k)+ ... 102 | (ymassflux(i,j,k)-abs(ymassflux(i,j,k))) ... 103 | *fbmem(i,j,k)); 104 | end 105 | end 106 | end 107 | % 108 | for j=2:jmm1 109 | for i=2:imm1 110 | zflux(i,j,1)=0.e0; 111 | if(itera==1) 112 | zflux(i,j,1)=w(i,j,1)*f(i,j,1)*art(i,j); 113 | end 114 | zflux(i,j,kb)=0.e0; 115 | end 116 | end 117 | % 118 | for k=2:kbm1 119 | for j=2:jmm1 120 | for i=2:imm1 121 | zflux(i,j,k)=0.5e0 ... 122 | *((zwflux(i,j,k)+abs(zwflux(i,j,k))) ... 123 | *fbmem(i,j,k)+ ... 124 | (zwflux(i,j,k)-abs(zwflux(i,j,k))) ... 125 | *fbmem(i,j,k-1)); 126 | zflux(i,j,k)=zflux(i,j,k)*art(i,j); 127 | end 128 | end 129 | end 130 | % 131 | % Add net advective fluxes and step forward in time: 132 | % 133 | for k=1:kbm1 134 | for j=2:jmm1 135 | for i=2:imm1 136 | ff(i,j,k)=xflux(i+1,j,k)-xflux(i,j,k) ... 137 | +yflux(i,j+1,k)-yflux(i,j,k) ... 138 | +(zflux(i,j,k)-zflux(i,j,k+1))/dz(k); 139 | ff(i,j,k)=(fbmem(i,j,k)*(h(i,j)+eta(i,j))*art(i,j) ... 140 | -dti2*ff(i,j,k))/((h(i,j)+etf(i,j))*art(i,j)); 141 | end 142 | end 143 | end 144 | % 145 | % %alculate antidiffusion velocity: 146 | % 147 | 148 | [xmassflux,ymassflux,zwflux,ff,sw] = smol_adif(xmassflux,ymassflux,zwflux,ff,sw,... 149 | im,jm,kb,imm1,jmm1,kbm1,dti2,fsm,aru,arv,dzz,dt); 150 | % 151 | eta=etf; 152 | fbmem=ff; 153 | % 154 | % End of Smolarkiewicz scheme 155 | % 156 | end 157 | % 158 | % Add horizontal diffusive fluxes: 159 | % 160 | 161 | fb=fb-fclim; 162 | % 163 | for k=1:kbm1 164 | for j=2:jm 165 | for i=2:im 166 | xmassflux(i,j,k)=0.5e0*(aam(i,j,k)+aam(i-1,j,k)); 167 | ymassflux(i,j,k)=0.5e0*(aam(i,j,k)+aam(i,j-1,k)); 168 | end 169 | end 170 | end 171 | % 172 | for k=1:kbm1 173 | for j=2:jm 174 | for i=2:im 175 | xflux(i,j,k)=-xmassflux(i,j,k)*(h(i,j)+h(i-1,j))*tprni ... 176 | *(fb(i,j,k)-fb(i-1,j,k))*dum(i,j) ... 177 | *(dy(i,j)+dy(i-1,j))*0.5e0/(dx(i,j)+dx(i-1,j)); 178 | yflux(i,j,k)=-ymassflux(i,j,k)*(h(i,j)+h(i,j-1))*tprni ... 179 | *(fb(i,j,k)-fb(i,j-1,k))*dvm(i,j) ... 180 | *(dx(i,j)+dx(i,j-1))*0.5e0/(dy(i,j)+dy(i,j-1)); 181 | end 182 | end 183 | end 184 | % 185 | 186 | fb=fb+fclim; 187 | % 188 | % Add net horizontal fluxes and step forward in time: 189 | % 190 | for k=1:kbm1 191 | for j=2:jmm1 192 | for i=2:imm1 193 | ff(i,j,k)=ff(i,j,k)-dti2*(xflux(i+1,j,k)-xflux(i,j,k) ... 194 | +yflux(i,j+1,k)-yflux(i,j,k)) ... 195 | /((h(i,j)+etf(i,j))*art(i,j)); 196 | end 197 | end 198 | end 199 | 200 | end 201 | 202 | % 203 | % ********************************************************************** 204 | % * * 205 | -------------------------------------------------------------------------------- /matlab_origin/advu.m: -------------------------------------------------------------------------------- 1 | function [uf] = advu(advx,aru,dz,cor,dt,e_atmos,dy,drhox,h,dti2,ub,uf,u,v,w,im,jm,kb,imm1,jmm1,kbm1,grav,egf,egb,etf,etb) 2 | % ********************************************************************** 3 | % * * 4 | % * ROUTINE NAME: advu * 5 | % * * 6 | % * FUN%TION : fores horizontal and vertical advection of * 7 | % * u-momentum, and includes coriolis, surface slope * 8 | % * and baroclinic terms. * 9 | % * * 10 | % ********************************************************************** 11 | % 12 | % 13 | % for vertical advection: 14 | % 15 | 16 | 17 | uf=zeros(im,jm,kb); 18 | % 19 | for k=2:kbm1 20 | for j=1:jm 21 | for i=2:im 22 | uf(i,j,k)=.25e0*(w(i,j,k)+w(i-1,j,k)) ... 23 | *(u(i,j,k)+u(i,j,k-1)); 24 | end 25 | end 26 | end 27 | % 28 | % %ombine horizontal and vertical advection with coriolis, surface 29 | % slope and baroclinic terms: 30 | % 31 | for k=1:kbm1 32 | for j=2:jmm1 33 | for i=2:imm1 34 | uf(i,j,k)=advx(i,j,k) ... 35 | +(uf(i,j,k)-uf(i,j,k+1))*aru(i,j)/dz(k) ... 36 | -aru(i,j)*.25e0 ... 37 | *(cor(i,j)*dt(i,j) ... 38 | *(v(i,j+1,k)+v(i,j,k)) ... 39 | +cor(i-1,j)*dt(i-1,j) ... 40 | *(v(i-1,j+1,k)+v(i-1,j,k))) ... 41 | +grav*.125e0*(dt(i,j)+dt(i-1,j)) ... 42 | *(egf(i,j)-egf(i-1,j)+egb(i,j)-egb(i-1,j) ... 43 | +(e_atmos(i,j)-e_atmos(i-1,j))*2.e0) ... 44 | *(dy(i,j)+dy(i-1,j)) ... 45 | +drhox(i,j,k); 46 | end 47 | end 48 | end 49 | % 50 | % Step forward in time: 51 | % 52 | for k=1:kbm1 53 | for j=2:jmm1 54 | for i=2:imm1 55 | uf(i,j,k)=((h(i,j)+etb(i,j)+h(i-1,j)+etb(i-1,j)) ... 56 | *aru(i,j)*ub(i,j,k) ... 57 | -2.e0*dti2*uf(i,j,k)) ... 58 | /((h(i,j)+etf(i,j)+h(i-1,j)+etf(i-1,j)) ... 59 | *aru(i,j)); 60 | end 61 | end 62 | end 63 | 64 | return 65 | end 66 | % 67 | 68 | 69 | -------------------------------------------------------------------------------- /matlab_origin/advv.m: -------------------------------------------------------------------------------- 1 | function [vf] = advv(advy,arv,dz,cor,dt,e_atmos,dx,drhoy,h,dti2,vb,vf,u,v,w,im,jm,kb,imm1,jmm1,kbm1,grav,egf,egb,etf,etb) 2 | % ********************************************************************** 3 | % * * 4 | % * FUN%TION : fores horizontal and vertical advection of * 5 | % * v-momentum, and includes coriolis, surface slope * 6 | % * and baroclinic terms. * 7 | % * * 8 | % ********************************************************************** 9 | % 10 | % 11 | % for vertical advection: 12 | % 13 | 14 | 15 | vf=zeros(im,jm,kb); 16 | 17 | for k=2:kbm1 18 | for j=2:jm 19 | for i=1:im 20 | vf(i,j,k)=.25e0*(w(i,j,k)+w(i,j-1,k)) ... 21 | *(v(i,j,k)+v(i,j,k-1)); 22 | end 23 | end 24 | end 25 | % 26 | % %ombine horizontal and vertical advection with coriolis: surface 27 | % slope and baroclinic terms: 28 | % 29 | for k=1:kbm1 30 | for j=2:jmm1 31 | for i=2:imm1 32 | vf(i,j,k)=advy(i,j,k) ... 33 | +(vf(i,j,k)-vf(i,j,k+1))*arv(i,j)/dz(k) ... 34 | +arv(i,j)*.25e0 ... 35 | *(cor(i,j)*dt(i,j) ... 36 | *(u(i+1,j,k)+u(i,j,k)) ... 37 | +cor(i,j-1)*dt(i,j-1) ... 38 | *(u(i+1,j-1,k)+u(i,j-1,k))) ... 39 | +grav*.125e0*(dt(i,j)+dt(i,j-1)) ... 40 | *(egf(i,j)-egf(i,j-1)+egb(i,j)-egb(i,j-1) ... 41 | +(e_atmos(i,j)-e_atmos(i,j-1))*2.e0) ... 42 | *(dx(i,j)+dx(i,j-1)) ... 43 | +drhoy(i,j,k); 44 | end 45 | end 46 | end 47 | % 48 | % Step forward in time: 49 | % 50 | for k=1:kbm1 51 | for j=2:jmm1 52 | for i=2:imm1 53 | vf(i,j,k)=((h(i,j)+etb(i,j)+h(i,j-1)+etb(i,j-1)) ... 54 | *arv(i,j)*vb(i,j,k) ... 55 | -2.e0*dti2*vf(i,j,k)) ... 56 | /((h(i,j)+etf(i,j)+h(i,j-1)+etf(i,j-1)) ... 57 | *arv(i,j)); 58 | end 59 | end 60 | end 61 | % 62 | return 63 | % 64 | 65 | end 66 | % 67 | 68 | -------------------------------------------------------------------------------- /matlab_origin/areas_masks.m: -------------------------------------------------------------------------------- 1 | function [art,aru,arv,fsm,dum,dvm]=areas_masks(art,aru,arv,fsm,dum,dvm,... 2 | im,jm,dx,dy,h) 3 | 4 | 5 | % Calculate areas of "t" and "s" cells: 6 | art=dx.*dy; 7 | % Calculate areas of "u" and "v" cells: 8 | 9 | 10 | for j=2:jm 11 | for i=2:im 12 | aru(i,j)=.25e0*(dx(i,j)+dx(i-1,j))*(dy(i,j)+dy(i-1,j)); 13 | arv(i,j)=.25e0*(dx(i,j)+dx(i,j-1))*(dy(i,j)+dy(i,j-1)); 14 | end 15 | end 16 | 17 | for j=1:jm 18 | aru(1,j)=aru(2,j); 19 | arv(1,j)=arv(2,j); 20 | end 21 | 22 | for i=1:im 23 | aru(i,1)=aru(i,2); 24 | arv(i,1)=arv(i,2); 25 | end 26 | 27 | 28 | % Initialise and set up free surface mask: 29 | fsm=zeros(im,jm); 30 | dum=zeros(im,jm); 31 | dvm=zeros(im,jm); 32 | fsm(h>1.e0)=1.e0; 33 | 34 | % Set up velocity masks: 35 | for j=2:jm 36 | for i=2:im 37 | dum(i,j)=fsm(i,j)*fsm(i-1,j); 38 | dvm(i,j)=fsm(i,j)*fsm(i,j-1); 39 | end 40 | end 41 | 42 | return 43 | end 44 | 45 | -------------------------------------------------------------------------------- /matlab_origin/baropg.m: -------------------------------------------------------------------------------- 1 | function [rho,drhox,drhoy] = baropg(rho,drhox,drhoy,... 2 | im,jm,imm1,jmm1,kb,kbm1,grav,... 3 | zz,dt,dum,dvm,ramp,rmean,dx,dy) 4 | 5 | % ********************************************************************** 6 | % * * 7 | % * FUNCTION : Calculates baroclinic pressure gradient. * 8 | % * * 9 | % ********************************************************************** 10 | % 11 | rho = rho - rmean; 12 | % 13 | % Calculate x-component of baroclinic pressure gradient: 14 | % 15 | for j=2:jmm1 16 | for i=2:imm1 17 | drhox(i,j,1)=.5e0*grav*(-zz(1))*(dt(i,j)+dt(i-1,j)) ... 18 | *(rho(i,j,1)-rho(i-1,j,1)); 19 | end 20 | end 21 | % 22 | for k=2:kbm1 23 | for j=2:jmm1 24 | for i=2:imm1 25 | drhox(i,j,k)=drhox(i,j,k-1) ... 26 | +grav*.25e0*(zz(k-1)-zz(k)) ... 27 | *(dt(i,j)+dt(i-1,j)) ... 28 | *(rho(i,j,k)-rho(i-1,j,k) ... 29 | +rho(i,j,k-1)-rho(i-1,j,k-1)) ... 30 | +grav*.25e0*(zz(k-1)+zz(k)) ... 31 | *(dt(i,j)-dt(i-1,j)) ... 32 | *(rho(i,j,k)+rho(i-1,j,k) ... 33 | -rho(i,j,k-1)-rho(i-1,j,k-1)); 34 | end 35 | end 36 | end 37 | % 38 | for k=1:kbm1 39 | for j=2:jmm1 40 | for i=2:imm1 41 | drhox(i,j,k)=.25e0*(dt(i,j)+dt(i-1,j)) ... 42 | *drhox(i,j,k)*dum(i,j) ... 43 | *(dy(i,j)+dy(i-1,j)); 44 | end 45 | end 46 | end 47 | % 48 | % Calculate y-component of baroclinic pressure gradient: 49 | % 50 | for j=2:jmm1 51 | for i=2:imm1 52 | drhoy(i,j,1)=.5e0*grav*(-zz(1))*(dt(i,j)+dt(i,j-1)) ... 53 | *(rho(i,j,1)-rho(i,j-1,1)); 54 | end 55 | end 56 | % 57 | for k=2:kbm1 58 | for j=2:jmm1 59 | for i=2:imm1 60 | drhoy(i,j,k)=drhoy(i,j,k-1) ... 61 | +grav*.25e0*(zz(k-1)-zz(k)) ... 62 | *(dt(i,j)+dt(i,j-1)) ... 63 | *(rho(i,j,k)-rho(i,j-1,k) ... 64 | +rho(i,j,k-1)-rho(i,j-1,k-1)) ... 65 | +grav*.25e0*(zz(k-1)+zz(k)) ... 66 | *(dt(i,j)-dt(i,j-1)) ... 67 | *(rho(i,j,k)+rho(i,j-1,k) ... 68 | -rho(i,j,k-1)-rho(i,j-1,k-1)); 69 | end 70 | end 71 | end 72 | % 73 | for k=1:kbm1 74 | for j=2:jmm1 75 | for i=2:imm1 76 | drhoy(i,j,k)=.25e0*(dt(i,j)+dt(i,j-1)) ... 77 | *drhoy(i,j,k)*dvm(i,j) ... 78 | *(dx(i,j)+dx(i,j-1)); 79 | end 80 | end 81 | end 82 | % 83 | for k=1:kb 84 | for j=2:jmm1 85 | for i=2:imm1 86 | drhox(i,j,k)=ramp*drhox(i,j,k); 87 | drhoy(i,j,k)=ramp*drhoy(i,j,k); 88 | end 89 | end 90 | end 91 | % 92 | for k=1:kb 93 | for j=1:jm 94 | for i=1:im 95 | rho(i,j,k)=rho(i,j,k)+rmean(i,j,k); 96 | end 97 | end 98 | end 99 | return 100 | end -------------------------------------------------------------------------------- /matlab_origin/bcondorl.m: -------------------------------------------------------------------------------- 1 | function [elf,uaf,vaf,uf,vf,w,ube,ubw] = bcondorl(idx,elf,uaf,vaf,uf,vf,w,ube,ubw,... 2 | im,jm,kb,imm1,jmm1,kbm1,... 3 | fsm,grav,ramp,rfe,h,uabe,ele,el,uabw,rfw,elw,rfn,eln,vabs,rfs,els,... 4 | dum,dvm,hmax,u,v,t,s,tbn,sbn,dti,tbs,sbs,q2,q2l,small,vabn,dx,dy,dt,tbe,sbe,tbw,sbw,zz) 5 | % ********************************************************************** 6 | % * * 7 | % * FUNCTION : This is an optional subroutine replacing bcond and * 8 | % * using Orlanski's scheme (J. Comp. Phys. 21, 251-269,* 9 | % * 1976), specialized for the seamount problem. To * 10 | % * make it work for the seamount problem, I (G.M.) * 11 | % * have had to add an extra condition on an "if" * 12 | % * statement in the t and s open boundary conditions, * 13 | % * which involves the sign of the normal velocity. * 14 | % * Thus: * 15 | % * * 16 | % * if(cl==0.e0.and.ubw(j,k).ge.0.e0) uf(1,j,k)=tbw(j,k), * 17 | % * * 18 | % * plus 3 others of the same kind. * 19 | % * * 20 | % ********************************************************************** 21 | % 22 | if(idx==1) 23 | % 24 | %----------------------------------------------------------------------- 25 | % 26 | % External (2-D) boundary conditions: 27 | % 28 | % In this example the governing boundary conditions are a radiation 29 | % condition on uaf(im,j) in the east and an inflow uaf(2,j) in the 30 | % west. The tangential velocities are set to zero on both 31 | % boundaries. These are only one set of possibilities and may not 32 | % represent a choice which yields the most physically realistic 33 | % result. 34 | % 35 | % Elevation (in this application, elevation is not a primary 36 | % boundary condition): 37 | % 38 | for j=1:jm 39 | elf(1,j)=elf(2,j); 40 | elf(im,j)=elf(imm1,j); 41 | end 42 | % 43 | for j=1:jm 44 | for i=1:im 45 | elf(i,j)=elf(i,j)*fsm(i,j); 46 | end 47 | end 48 | % 49 | return 50 | % 51 | elseif(idx==2) 52 | % 53 | % External (2-D) velocity: 54 | % 55 | for j=2:jmm1 56 | % 57 | % West: 58 | % 59 | uaf(2,j)=ramp*uabw(j)-sqrt(grav/h(2,j))*(el(2,j)-elw(j)); 60 | uaf(1,j)=uaf(2,j); 61 | vaf(1,j)=0.e0; 62 | % 63 | % East: 64 | % 65 | uaf(im,j)=ramp*uabe(j) ... 66 | +sqrt(grav/h(imm1,j))*(el(imm1,j)-ele(j)); 67 | vaf(im,j)=0.e0; 68 | % 69 | end 70 | % 71 | for j=1:jm 72 | for i=1:im 73 | uaf(i,j)=uaf(i,j)*dum(i,j); 74 | vaf(i,j)=vaf(i,j)*dvm(i,j); 75 | end 76 | end 77 | % 78 | return 79 | % 80 | elseif(idx==3) 81 | % 82 | %----------------------------------------------------------------------- 83 | % 84 | % Internal (3-D) boundary conditions: 85 | % 86 | % Eastern and western radiation boundary conditions according to 87 | % Orlanski's explicit scheme: 88 | % 89 | for k=1:kbm1 90 | for j=2:jmm1 91 | % 92 | % West: 93 | % 94 | denom=(uf(3,j,k)+ub(3,j,k)-2.e0*u(4,j,k)); 95 | if(denom==0.e0) 96 | denom=0.01e0; 97 | end 98 | cl=(ub(3,j,k)-uf(3,j,k))/denom; 99 | if(cl>1.e0) 100 | cl=1.e0; 101 | end 102 | if(cl<0.e0) 103 | cl=0.e0; 104 | end 105 | uf(2,j,k)=(ub(2,j,k)*(1.e0-cl)+2.e0*cl*u(3,j,k)) ... 106 | /(1.e0+cl); 107 | uf(1,j,k)=uf(2,j,k); 108 | vf(1,j,k)=0.e0; 109 | % 110 | % East: 111 | % 112 | denom=(uf(im-1,j,k)+ub(im-1,j,k)-2.e0*u(im-2,j,k)); 113 | if(denom==0.e0) 114 | denom=0.01e0; 115 | end 116 | cl=(ub(im-1,j,k)-uf(im-1,j,k))/denom; 117 | if(cl>1.e0) 118 | cl=1.e0; 119 | end 120 | if(cl<0.e0) 121 | cl=0.e0; 122 | end 123 | uf(im,j,k)=(ub(im,j,k)*(1.e0-cl)+2.e0*cl*u(im-1,j,k)) ... 124 | /(1.e0+cl); 125 | vf(im,j,k)=0.e0; 126 | end 127 | end 128 | % 129 | for k=1:kbm1 130 | for j=1:jm 131 | for i=1:im 132 | uf(i,j,k)=uf(i,j,k)*dum(i,j); 133 | vf(i,j,k)=vf(i,j,k)*dvm(i,j); 134 | end 135 | end 136 | end 137 | % 138 | return 139 | % 140 | elseif(idx==4) 141 | % 142 | % Temperature and salinity boundary conditions (using uf and vf: 143 | % respectively): 144 | % 145 | for k=1:kbm1 146 | for j=1:jm 147 | % 148 | % West: 149 | % 150 | ubw(j,k)=ub(2,j,k); 151 | denom=(uf(2,j,k)+tb(2,j,k)-2.e0*t(3,j,k)); 152 | if(denom==0.e0) 153 | denom=0.01e0; 154 | end 155 | cl=(tb(2,j,k)-uf(2,j,k))/denom; 156 | if(cl>1.e0) 157 | cl=1.e0; 158 | end 159 | if(cl<0.e0) 160 | cl=0.e0; 161 | end 162 | uf(1,j,k)=(tb(1,j,k)*(1.e0-cl)+2.e0*cl*t(2,j,k))/(1.e0+cl); 163 | if(cl==0.e0 && ubw(j,k)>=0.e0) 164 | uf(1,j,k)=tbw(j,k); 165 | end 166 | % 167 | denom=(vf(2,j,k)+sb(2,j,k)-2.e0*s(3,j,k)); 168 | if(denom==0.e0) 169 | denom=0.01e0; 170 | end 171 | cl=(sb(2,j,k)-vf(2,j,k))/denom; 172 | if(cl>1.e0) 173 | cl=1.e0; 174 | end 175 | if(cl<0.e0) 176 | cl=0.e0; 177 | end 178 | vf(1,j,k)=(sb(1,j,k)*(1.e0-cl)+2.e0*cl*s(2,j,k))/(1.e0+cl); 179 | if(cl==0.e0 && ubw(j,k) >= 0.e0) 180 | vf(1,j,k)=sbw(j,k); 181 | end 182 | % 183 | % East: 184 | % 185 | ube(j,k)=ub(im,j,k); 186 | denom=(uf(im-1,j,k)+tb(im-1,j,k)-2.e0*t(im-2,j,k)); 187 | if(denom==0.e0) denom=0.01e0; 188 | end 189 | cl=(tb(im-1,j,k)-uf(im-1,j,k))/denom; 190 | if(cl>1.e0) cl=1.e0; 191 | end 192 | if(cl<0.e0) cl=0.e0; 193 | end 194 | uf(im,j,k)=(tb(im,j,k)*(1.e0-cl)+2.e0*cl*t(im-1,j,k)) ... 195 | /(1.e0+cl); 196 | if(cl==0.e0 && ube(j,k)<=0.e0) uf(im,j,k)=tbe(j,k); 197 | end 198 | % 199 | denom=(vf(im-1,j,k)+sb(im-1,j,k)-2.e0*s(im-2,j,k)); 200 | if(denom==0.e0) denom=0.01e0; 201 | end 202 | cl=(sb(im-1,j,k)-vf(im-1,j,k))/denom; 203 | if(cl>1.e0) 204 | cl=1.e0; 205 | end 206 | if(cl<0.e0) 207 | cl=0.e0; 208 | end 209 | vf(im,j,k)=(sb(im,j,k)*(1.e0-cl)+2.e0*cl*s(im-1,j,k)) ... 210 | /(1.e0+cl); 211 | if(cl==0.e0 && ube(j,k)<=0.e0) 212 | vf(im,j,k)=sbe(j,k); 213 | end 214 | % 215 | end 216 | end 217 | % 218 | for k=1:kbm1 219 | for j=1:jm 220 | for i=1:im 221 | uf(i,j,k)=uf(i,j,k)*fsm(i,j); 222 | vf(i,j,k)=vf(i,j,k)*fsm(i,j); 223 | end 224 | end 225 | end 226 | 227 | % 228 | elseif(idx==5) 229 | % 230 | % Vertical velocity boundary conditions: 231 | % 232 | for k=1:kbm1 233 | for j=1:jm 234 | for i=1:im 235 | w(i,j,k)=w(i,j,k)*fsm(i,j); 236 | end 237 | end 238 | end 239 | % 240 | 241 | % 242 | elseif(idx==6) 243 | % 244 | % q2 and q2l boundary conditions: 245 | % 246 | for k=1:kb 247 | % 248 | for j=1:jm 249 | uf(im,j,k)=1.e-10; 250 | vf(im,j,k)=1.e-10; 251 | uf(1,j,k)=1.e-10; 252 | vf(1,j,k)=1.e-10; 253 | end 254 | % 255 | for j=1:jm 256 | for i=1:im 257 | uf(i,j,k)=uf(i,j,k)*fsm(i,j); 258 | vf(i,j,k)=vf(i,j,k)*fsm(i,j); 259 | end 260 | end 261 | end 262 | % 263 | 264 | % 265 | end 266 | % 267 | end 268 | % 269 | -------------------------------------------------------------------------------- /matlab_origin/dens.m: -------------------------------------------------------------------------------- 1 | function [si,ti,rhoo]=dens(si,ti,rhoo,... 2 | im,jm,kbm1,tbias,sbias,grav,rhoref,zz,h,fsm) 3 | % ********************************************************************** 4 | % * * 5 | % * FUNCTION : Calculates (density-1000.)/rhoref. * 6 | % * * 7 | % * (see: Mellor, G.L., 1991, J. Atmos. Oceanic Tech., * 8 | % * 609-611.) * 9 | % * * 10 | % * ti is potential temperature * 11 | % * * 12 | % * If using 32 bit precision, it is recommended that * 13 | % * cr,p,rhor,sr,tr,tr2,tr3 and tr4 be made double * 14 | % * precision, and the "e"s in the constants be changed * 15 | % * to "d"s. * 16 | % * * 17 | % * NOTE: if pressure is not used in dens, buoyancy term (boygr) * 18 | % * in profq must be changed (see note in profq) * 19 | % * * 20 | % ********************************************************************** 21 | 22 | 23 | for k=1:kbm1 24 | for j=1:jm 25 | for i=1:im 26 | tr=ti(i,j,k)+tbias; 27 | sr=si(i,j,k)+sbias; 28 | tr2=tr*tr; 29 | tr3=tr2*tr; 30 | tr4=tr3*tr; 31 | % Approximate pressure in units of bars: 32 | p=grav*rhoref*(-zz(k)* h(i,j))*1.e-5; 33 | rhor=-0.157406e0+6.793952e-2*tr-9.095290e-3*tr2+1.001685e-4*tr3... 34 | -1.120083e-6*tr4+6.536332e-9*tr4*tr; 35 | 36 | rhor=rhor+(0.824493e0-4.0899e-3*tr+7.6438e-5*tr2-8.2467e-7*tr3... 37 | +5.3875e-9*tr4)*sr+(-5.72466e-3+1.0227e-4*tr... 38 | -1.6546e-6*tr2)*abs(sr)^1.5+4.8314e-4*sr*sr; 39 | 40 | cr=1449.1e0+.0821e0*p+4.55e0*tr-.045e0*tr2+1.34e0*(sr-35.e0); 41 | rhor=rhor+1.e5*p/(cr*cr)*(1.e0-2.e0*p/(cr*cr)); 42 | 43 | rhoo(i,j,k)=rhor/rhoref*fsm(i,j); 44 | end 45 | end 46 | end 47 | 48 | -------------------------------------------------------------------------------- /matlab_origin/depth.m: -------------------------------------------------------------------------------- 1 | function [kdz,z,zz,dz,dzz]=depth(z,zz,dz,dzz,kb,kl1,kl2) 2 | 3 | 4 | kdz=[1,1,2,4,8,16,32,64,128,256,512,1024]; 5 | 6 | z=zeros(1,kb); 7 | zz=zeros(1,kb); 8 | dz=zeros(1,kb); 9 | dzz=zeros(1,kb); 10 | 11 | for k=2:kl1 12 | z(k)=z(k-1)+kdz(k-1); 13 | end 14 | 15 | delz=z(kl1)-z(kl1-1); 16 | 17 | for k=kl1+1:kl2 18 | z(k)=z(k-1)+delz; 19 | end 20 | 21 | for k=kl2+1:kb 22 | dz(k)=kdz(kb-k+1)*delz/kdz(kb-kl2); 23 | z(k)=z(k-1)+dz(k); 24 | end 25 | 26 | for k=1:kb 27 | z(k)=-z(k)/z(kb); 28 | end 29 | 30 | for k=1:kb-1 31 | zz(k)=0.5e0*(z(k)+z(k+1)); 32 | end 33 | 34 | zz(kb)=2.e0*zz(kb-1)-zz(kb-2); 35 | 36 | for k=1:kb-1 37 | dz(k)=z(k)-z(k+1); 38 | dzz(k)=zz(k)-zz(k+1); 39 | end 40 | 41 | dz(kb)=0.e0; 42 | dzz(kb)=0.e0; 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /matlab_origin/file2ic.m: -------------------------------------------------------------------------------- 1 | function[dx,dy,cor,... 2 | east_c,north_c,east_e,north_e,east_u,north_u,east_v,north_v,... 3 | h,art,aru,arv,fsm,dum,dvm,... 4 | tb,sb,tclim,sclim,ub,uab,elb,etb,dt,... 5 | aam2d,rho,rmean,rfe,rfw,rfn,rfs,... 6 | uabw,uabe,ele,elw,tbe,tbw,sbe,sbw,tbn,tbs,sbn,sbs,rot,els,eln,vabs,vabn,ubw,ube,vbs,vbn] = file2ic(dx,dy,cor,... 7 | east_c,north_c,east_e,north_e,east_u,north_u,east_v,north_v,... 8 | h,art,aru,arv,fsm,dum,dvm,... 9 | tb,sb,tclim,sclim,ub,uab,elb,etb,dt,... 10 | aam2d,rho,rmean,rfe,rfw,rfn,rfs,... 11 | uabw,uabe,ele,elw,tbe,tbw,sbe,sbw,tbn,tbs,sbn,sbs,... 12 | e_atmos,aam,im,jm,kb,imm1,jmm1,kbm1,slmax,zz,tbias,sbias,grav,rhoref,rot,els,eln,vabs,vabn,ubw,ube,vbs,vbn) 13 | % ********************************************************************** 14 | % * * 15 | % * FUNCTION : Sets up my own problem. * 16 | % * * 17 | % * This example read IC from IC.dat file, generated by GRID.f in * 18 | % * GRID-DATA directory. Only minimal number of fields are read, * 19 | % * while others are calculated here. * 20 | % * * 21 | % ********************************************************************** 22 | % 23 | field = ''; 24 | rad=0.01745329; 25 | re=6371.E3; 26 | fprintf('(/,'' Read grid and initial conditions '',/'); 27 | % 28 | %--- 1D --- 29 | fid = fopen('data.in','r'); 30 | fscanf(fid,'%s',field); 31 | fprintf('%s',filed); 32 | for k=1:kb 33 | fscanf('%f',z(k)); 34 | end 35 | 36 | fscanf(fid,'%s',field); 37 | fprintf('%s',filed); 38 | for k=1:kb 39 | fscanf(fid,'%f',zz(k)); 40 | end 41 | 42 | fscanf(fid,'%s',field); 43 | fprintf('%s',filed); 44 | for k=1:kb 45 | fscanf(fid,'%f',dz(k)); 46 | end 47 | 48 | fscanf(fid,'%s',field); 49 | fprintf('%s',filed); 50 | for k=1:kb 51 | fscanf(fid,'%f',dzz(k)); 52 | end 53 | 54 | 55 | %--- 2D --- 56 | fscanf(fid,'%s',field); 57 | fprintf('%s',filed); 58 | for i=1:im 59 | for j=1:jm 60 | fscanf(fid,'%f',east_e(i,j)); 61 | end 62 | end 63 | 64 | fscanf(fid,'%s',field); 65 | fprintf('%s',filed); 66 | for i=1:im 67 | for j=1:jm 68 | fscanf(fid,'%f',north_e(i,j)); 69 | end 70 | end 71 | 72 | 73 | fscanf(fid,'%s',field); 74 | fprintf('%s',filed); 75 | for i=1:im 76 | for j=1:jm 77 | fscanf(fid,'%f',h(i,j)); 78 | end 79 | end 80 | 81 | fscanf(fid,'%s',field); 82 | fprintf('%s',filed); 83 | for i=1:im 84 | for j=1:jm 85 | fscanf(fid,'%f',h(i,j)); 86 | end 87 | end 88 | 89 | %--- 3D --- 90 | 91 | fscanf(fid,'%s',field); 92 | fprintf('%s',filed); 93 | for i=1:im 94 | for j=1:jm 95 | for k=1:kb 96 | fscanf(fid,'%f',t(i,j,k)); 97 | end 98 | end 99 | end 100 | 101 | fscanf(fid,'%s',field); 102 | fprintf('%s',filed); 103 | for i=1:im 104 | for j=1:jm 105 | for k=1:kb 106 | fscanf(fid,'%f',s(i,j,k)); 107 | end 108 | end 109 | end 110 | 111 | fscanf(fid,'%s',field); 112 | fprintf('%s',filed); 113 | for i=1:im 114 | for j=1:jm 115 | for k=1:kb 116 | fscanf(fid,'%f',rmean(i,j,k)); 117 | end 118 | end 119 | end 120 | 121 | 122 | 123 | %--- Constant wind stress read here 124 | % (for time dep. read in loop 9000 & interpolate in time) 125 | 126 | fscanf(fid,'%s',field); 127 | fprintf('%s',filed); 128 | for i=1:im 129 | for j=1:jm 130 | scanf(fid,'%f',wusurf(i,j)); 131 | end 132 | end 133 | 134 | 135 | fscanf(fid,'%s',field); 136 | fprintf('%s',filed); 137 | for i=1:im 138 | for j=1:jm 139 | scanf(fid,'%f',wvsurf(i,j)); 140 | end 141 | end 142 | 143 | % 144 | % --- calc. surface & lateral BC from climatology 145 | % 146 | for j=1:jm 147 | for i=1:im 148 | tsurf(i,j)=t(i,j,1); 149 | ssurf(i,j)=s(i,j,1); 150 | for k=1:kb 151 | tclim(i,j,k)=t(i,j,k); 152 | sclim(i,j,k)=s(i,j,k); 153 | end 154 | end 155 | end 156 | % 157 | % --- EAST & WEST BCs --- 158 | for j=1:jm 159 | ele(j)=0.; 160 | elw(j)=0.; 161 | % --- other vel. BCs (fixed in time) can be specified here 162 | uabe(j)=0.; 163 | uabw(j)=0.; 164 | for k=1:kb 165 | ubw(j,k)=0.; 166 | ube(j,k)=0.; 167 | tbw(j,k)=tclim(1,j,k); 168 | sbw(j,k)=sclim(1,j,k); 169 | tbe(j,k)=tclim(im,j,k); 170 | sbe(j,k)=sclim(im,j,k); 171 | end 172 | end 173 | % --- NORTH & SOUTH BCs --- 174 | for i=1:im 175 | els(i)=0.; 176 | eln(i)=0.; 177 | vabs(i)=0.; 178 | vabn(i)=0.; 179 | for k=1:kb 180 | vbs(i,k)=0.; 181 | vbn(i,k)=0.; 182 | tbs(i,k)=tclim(i,1,k); 183 | sbs(i,k)=sclim(i,1,k); 184 | tbn(i,k)=tclim(i,jm,k); 185 | sbn(i,k)=sclim(i,jm,k); 186 | end 187 | end 188 | % 189 | % Set initial conditions: 190 | % 191 | tb = t; 192 | sb = s; 193 | ub = zeros(im,jm,kb); 194 | vb=zeros(im,jm,kb); 195 | % 196 | 197 | [sb,tb,rho]=dens(si,ti,rhoo,... 198 | im,jm,kbm1,tbias,sbias,grav,rhoref,zz,h,fsm); 199 | % 200 | % --- calc. Curiolis Parameter 201 | % 202 | for j=1:jm 203 | for i=1:im 204 | cor(i,j)=2.*7.29E-5*sin(north_e(i,j)*rad); 205 | aam2d(i,j)=aam(i,j,1); 206 | elb(i,j)=0.; 207 | etb(i,j)=0.; 208 | dt(i,j)=h(i,j); 209 | end 210 | end 211 | % 212 | for j=1:jm 213 | for i=2:im-1 214 | dx(i,j)=0.5*rad*re*sqrt(((east_e(i+1,j)-east_e(i-1,j))... 215 | *cos(north_e(i,j)*rad))^2+(north_e(i+1,j)-north_e(i-1,j))^2); 216 | end 217 | dx(1,j)=dx(2,j); 218 | dx(im,j)=dx(im-1,j); 219 | end 220 | % 221 | for i=1:im 222 | for j=2:jm-1 223 | dy(i,j)=0.5*rad*re*sqrt(((east_e(i,j+1)-east_e(i,j-1))... 224 | *cos(north_e(i,j)*rad))^2+(north_e(i,j+1)-north_e(i,j-1))^2); 225 | end 226 | dy(i,1)=dy(i,2); 227 | dy(i,jm)=dy(i,jm-1); 228 | end 229 | % 230 | % Calculate areas and masks: 231 | % 232 | [art,aru,arv,fsm,dum,dvm]=areas_masks(art,aru,arv,fsm,dum,dvm,... 233 | im,jm,dx,dy,h); 234 | % 235 | % 236 | % --- the following grids are needed only for netcdf plotting 237 | % 238 | % Corner of cell points: 239 | % 240 | for j=2:jm 241 | for i=2:im 242 | east_c(i,j)=(east_e(i,j)+east_e(i-1,j)... 243 | +east_e(i,j-1)+east_e(i-1,j-1))/4.e0; 244 | north_c(i,j)=(north_e(i,j)+north_e(i-1,j)... 245 | +north_e(i,j-1)+north_e(i-1,j-1))/4.e0; 246 | end 247 | end 248 | % 249 | % 250 | % Extrapolate ends (approx.): 251 | % 252 | for i=2:im 253 | east_c(i,1)=2.*east_c(i,2)-east_c(i,3); 254 | north_c(i,1)=2.*north_c(i,2)-north_c(i,3); 255 | end 256 | east_c(1,1)=2.*east_c(2,1)-east_c(3,1); 257 | % 258 | for j=2:jm 259 | east_c(1,j)=2.*east_c(2,j)-east_c(3,j); 260 | north_c(1,j)=2.*north_c(2,j)-north_c(3,j); 261 | end 262 | north_c(1,1)=2.*north_c(1,2)-north_c(1,3); 263 | % 264 | % u-points: 265 | % 266 | for j=1:jm-1 267 | for i=1:im 268 | east_u(i,j)=(east_c(i,j)+east_c(i,j+1))/2.e0; 269 | north_u(i,j)=(north_c(i,j)+north_c(i,j+1))/2.e0; 270 | end 271 | end 272 | % 273 | % Extrapolate ends: 274 | % 275 | for i=1:im 276 | east_u(i,jm)=(east_c(i,jm)*3.e0-east_c(i,jm-1))/2.e0; 277 | north_u(i,jm)=(north_c(i,jm)*3.e0-north_c(i,jm-1))/2.e0; 278 | end 279 | % 280 | % v-points: 281 | % 282 | for j=1:jm 283 | for i=1:im-1 284 | east_v(i,j)=(east_c(i,j)+east_c(i+1,j))/2.e0; 285 | north_v(i,j)=(north_c(i,j)+north_c(i+1,j))/2.e0; 286 | end 287 | end 288 | % 289 | % Extrapolate ends: 290 | % 291 | for j=1:jm 292 | east_v(im,j)=(east_c(im,j)*3.e0-east_c(im-1,j))/2.e0; 293 | north_v(im,j)=(north_c(im,j)*3.e0-north_c(im-1,j))/2.e0; 294 | end 295 | % 296 | % rot is the angle (radians, anticlockwise) of the i-axis relative 297 | % to east, averaged to a cell centre: (only needed for CDF plotting) 298 | % 299 | for j=1:jm 300 | for i=1:im-1 301 | rot(i,j)=0.; 302 | dlat=north_e(i+1,j)-north_e(i,j); 303 | dlon= east_e(i+1,j)- east_e(i,j); 304 | if(dlon~=0.) 305 | rot(i,j)=atan(dlat/dlon); 306 | end 307 | end 308 | rot(im,j)=rot(im-1,j); 309 | end 310 | % 311 | % Set lateral boundary conditions, for use in subroutine bcond 312 | % set all=0 for closed BCs. 313 | % Values=0 for vel BC only, =1 is combination of vel+elev. 314 | rfe=0.e0; 315 | rfw=0.e0; 316 | rfn=0.e0; 317 | rfs=0.e0; 318 | % 319 | return 320 | end 321 | -------------------------------------------------------------------------------- /matlab_origin/findpsi.m: -------------------------------------------------------------------------------- 1 | function findpsi(im,jm,imm1,jmm1,time,iskp,jskp,uab,vab,d,dx,dy) 2 | % ********************************************************************** 3 | % * * 4 | % * ROUTINE NAME: findpsi * 5 | % * * 6 | % * FUN%TION : %alculates the stream function, first assuming * 7 | % * zero on the southern boundary and then, using the * 8 | % * values on the western boundary, the stream function * 9 | % * is calculated again. If the elevation field is near * 10 | % * steady state, the two calculations should agree; * 11 | % * otherwise not. * 12 | % * * 13 | % ********************************************************************** 14 | % 15 | % 16 | 17 | psi = zeros(im,jm); 18 | % 19 | % Sweep northward: 20 | % 21 | for j=2:jmm1 22 | for i=2:im 23 | psi(i,j+1)=psi(i,j) ... 24 | +.25e0*uab(i,j)*(d(i,j)+d(i-1,j)) ... 25 | *(dy(i,j)+dy(i-1,j)) 26 | end 27 | end 28 | % 29 | prxy('Streamfunction, psi from u ',time,psi,im,iskp,jm,jskp,0.e0); 30 | % 31 | % Sweep eastward: 32 | % 33 | for j=2:jm 34 | for i=2:imm1 35 | psi(i+1,j)=psi(i,j) ... 36 | -.25e0*vab(i,j)*(d(i,j)+d(i,j-1)) ... 37 | *(dx(i,j)+dx(i,j-1)) 38 | end 39 | end 40 | % 41 | prxy('Streamfunction, psi from v ',time,psi,im,iskp,jm,jskp,0.e0); 42 | end 43 | 44 | % 45 | -------------------------------------------------------------------------------- /matlab_origin/printall.m: -------------------------------------------------------------------------------- 1 | function printall(im,jm,imm1,jmm1,iskp,jskp,uab,vab,elb,d,dx,dy,time,u,v,w,t,s,rho,aam,km,kb,mode,dt,zz,z) 2 | % ********************************************************************** 3 | % * * 4 | % * POM2K SOURCE CODE * 5 | % * * 6 | % * ROUTINE NAME: printall * 7 | % * * 8 | % * FUNCTION : Prints a set of outputs to device 6 * 9 | % * * 10 | % * Edit as approriate. * 11 | % * * 12 | % ********************************************************************** 13 | % 14 | % 15 | % 2-D horizontal fields: 16 | % 17 | prxy('Depth-averaged u, uab ',time,uab,im,iskp,jm,jskp,0.e0); 18 | % 19 | prxy('Depth-averaged v, vab ',time,vab,im,iskp,jm,jskp,0.e0); 20 | % 21 | prxy('Surface elevation, elb ',time,elb,im,iskp,jm,jskp,0.e0); 22 | % 23 | % 24 | % Calculate and print streamfunction: 25 | % 26 | findpsi(im,jm,imm1,jmm1,time,iskp,jskp,uab,vab,d,dx,dy); 27 | % 28 | if(mode~=2) 29 | % 30 | % 2-D horizontal sections of 3-D fields: 31 | % 32 | % Set levels for output: 33 | % 34 | ko(1)=1; 35 | ko(2)=floor(kb/2); 36 | ko(3)=kb-1; 37 | % 38 | prxyz('x-velocity, u ',time,u,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 39 | % 40 | prxyz('y-velocity, v ',time,v,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 41 | % 42 | ko(1)=2; 43 | prxyz('z-velocity, w ',time,w,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 44 | ko(1)=1; 45 | % 46 | prxyz('Potential temperature, t ',time,t,im,iskp,jm,jskp,kb,ko,3,1.e-2); 47 | % 48 | prxyz('Salinity, s ',time,s,im,iskp,jm,jskp,kb,ko,3,1.e-2); 49 | % 50 | prxyz('(density-1000)/rhoref, rho ',time,rho,im,iskp,jm,jskp,kb,ko,3,1.e-5); 51 | % 52 | % 53 | prxyz('Horizontal kinematic viscosity, aam ',time,aam,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 54 | % 55 | prxyz('Vertical kinematic viscosity, km ',time,km,im,iskp,jm,jskp,kb,ko,3,0.e0 ); 56 | % 57 | % 58 | % Set sections for output: 59 | % 60 | jo(1)=1; 61 | jo(2)=floor(jm/2); 62 | jo(3)=jm-1; 63 | 64 | prxz('x-velocity, u ',time,u,im,iskp,jm,kb,jo,3,0.e0 ,dt,zz); 65 | % 66 | prxz('y-velocity, v ',time,v,im,iskp,jm,kb,jo,3,0.e0 ,dt,zz); 67 | % 68 | prxz('z-velocity, w ',time,w,im,iskp,jm,kb,jo,3,0.e0 ,dt,z ); 69 | % 70 | prxz('Potential temperature, t ',time,t,im,iskp,jm,kb,jo,3,1.e-2,dt,zz); 71 | % 72 | prxz('Salinity, s ',time,s,im,iskp,jm,kb,jo,3,1.e-2,dt,zz); 73 | % 74 | prxz('(density-1000)/rhoref, rho ',time,rho,im,iskp,jm,kb,jo,3,1.e-5,dt,zz); 75 | % 76 | % 77 | % Set se%tions for output: 78 | % 79 | io(1)=1; 80 | io(2)=floor(im/2); 81 | io(3)=im-1; 82 | % 83 | pryz('x-velocity, u ', time,u,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 84 | % 85 | pryz('y-velocity, v ', time,v,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 86 | % 87 | pryz('z-velocity, w ', time,w,im,jm,jskp,kb,io,3,0.e0 ,dt,zz); 88 | % 89 | pryz('Potential temperature, t ', time,t,im,jm,jskp,kb,io,3,1.e-2,dt,zz); 90 | % 91 | end 92 | % 93 | -------------------------------------------------------------------------------- /matlab_origin/proft.m: -------------------------------------------------------------------------------- 1 | function [f,wfsurf,fsurf,nbc,dh,... 2 | a,c,ee,gg] = proft(f,wfsurf,fsurf,nbc,dh,... 3 | a,c,ee,gg,... 4 | h,etf,dti2,dz,dzz,swrad,ntp,im,jm,kb,kbm1,kbm2,kh,umol) 5 | 6 | % ********************************************************************** 7 | % * * 8 | % * FUN%TION : Solves for vertical diffusion of temperature and * 9 | % * salinity using method described by Richmeyer and * 10 | % * Morton. * 11 | % * * 12 | % * Irradiance parameters are from Paulson and Simpson. * 13 | % * * 14 | % * See: * 15 | % * * 16 | % * Richtmeyer R.D., and K.W. Morton, 1967. Difference * 17 | % * Methods for Initial-Value Problems, 2nd edition, * 18 | % * Interscience, New York, 198-201. * 19 | % * * 20 | % * Paulson, %. A., and J. Simpson, 1977: Irradiance * 21 | % * measurements in the upper ocean, J. Phys. * 22 | % * Oceanogr., 7, 952-956. * 23 | % * * 24 | % * NOTES: * 25 | % * * 26 | % * (1) wfsurf and swrad are negative values when water * 27 | % * column is warming or salt is being added. * 28 | % * * 29 | % * (2) nbc may only be 1 and 3 for salinity. * 30 | % * * 31 | % ********************************************************************** 32 | % 33 | % 34 | 35 | % 36 | %----------------------------------------------------------------------- 37 | % 38 | % Irradiance parameters after Paulson and Simpson: 39 | % 40 | % ntp 1 2 3 4 5 41 | % Jerlov type i ia ib ii iii 42 | % 43 | r=[0.58,0.62,0.67,0.77,0.78]; 44 | ad1=[0.35,0.60,1.0,1.5,1.4]; 45 | ad2=[0.23,20.0,17.0,14.0,7.90]; 46 | % 47 | %----------------------------------------------------------------------- 48 | % 49 | % Surface boundary condition: 50 | % 51 | % nbc prescribed prescribed short wave 52 | % temperature flux penetration 53 | % or salinity (temperature 54 | % only) 55 | % 56 | % 1 no yes no 57 | % 2 no yes yes 58 | % 3 yes no no 59 | % 4 yes no yes 60 | % 61 | % NOTE that only 1 and 3 are allowed for salinity. 62 | % 63 | %----------------------------------------------------------------------- 64 | % 65 | % The following section solves the equation: 66 | % 67 | % dti2*(kh*f')'-f=-fb 68 | % 69 | 70 | dh = h+etf; 71 | rad=zeros(im,jm,kb); 72 | % 73 | 74 | for k=2:kbm1 75 | for j=1:jm 76 | for i=1:im 77 | a(i,j,k-1)=-dti2*(kh(i,j,k)+umol) ... 78 | /(dz(k-1)*dzz(k-1)*dh(i,j)*dh(i,j)); 79 | c(i,j,k)=-dti2*(kh(i,j,k)+umol) ... 80 | /(dz(k)*dzz(k-1)*dh(i,j)*dh(i,j)); 81 | end 82 | end 83 | end 84 | % 85 | % %alculate penetrative radiation. At the bottom any unattenuated 86 | % radiation is deposited in the bottom layer: 87 | % 88 | % 89 | if(nbc==2||nbc==4) 90 | % 91 | for k=1:kbm1 92 | for j=1:jm 93 | for i=1:im 94 | rad(i,j,k)=swrad(i,j) ... 95 | *(r(ntp)*exp(z(k)*dh(i,j)/ad1(ntp)) ... 96 | +(1.e0-r(ntp))*exp(z(k)*dh(i,j)/ad2(ntp))); 97 | end 98 | end 99 | end 100 | % 101 | end 102 | % 103 | if(nbc==1) 104 | % 105 | for j=1:jm 106 | for i=1:im 107 | ee(i,j,1)=a(i,j,1)/(a(i,j,1)-1.e0); 108 | gg(i,j,1)=-dti2*wfsurf(i,j)/(-dz(1)*dh(i,j))-f(i,j,1); 109 | gg(i,j,1)=gg(i,j,1)/(a(i,j,1)-1.e0); 110 | end 111 | end 112 | % 113 | elseif(nbc==2) 114 | % 115 | for j=1:jm 116 | for i=1:im 117 | ee(i,j,1)=a(i,j,1)/(a(i,j,1)-1.e0); 118 | gg(i,j,1)=dti2*(wfsurf(i,j)+rad(i,j,1)-rad(i,j,2)) ... 119 | /(dz(1)*dh(i,j)) ... 120 | -f(i,j,1); 121 | gg(i,j,1)=gg(i,j,1)/(a(i,j,1)-1.e0); 122 | end 123 | end 124 | % 125 | elseif(nbc==3 || nbc==4) 126 | % 127 | for j=1:jm 128 | for i=1:im 129 | ee(i,j,1)=0.e0; 130 | gg(i,j,1)=fsurf(i,j); 131 | end 132 | end 133 | % 134 | end 135 | % 136 | for k=2:kbm2 137 | for j=1:jm 138 | for i=1:im 139 | gg(i,j,k)=1.e0/(a(i,j,k)+c(i,j,k)*(1.e0-ee(i,j,k-1))-1.e0); 140 | ee(i,j,k)=a(i,j,k)*gg(i,j,k); 141 | gg(i,j,k)=(c(i,j,k)*gg(i,j,k-1)-f(i,j,k) ... 142 | +dti2*(rad(i,j,k)-rad(i,j,k+1)) ... 143 | /(dh(i,j)*dz(k))) ... 144 | *gg(i,j,k); 145 | end 146 | end 147 | end 148 | % 149 | % Bottom adiabatic boundary condition: 150 | % 151 | for j=1:jm 152 | for i=1:im 153 | f(i,j,kbm1)=(c(i,j,kbm1)*gg(i,j,kbm2)-f(i,j,kbm1) ... 154 | +dti2*(rad(i,j,kbm1)-rad(i,j,kb)) ... 155 | /(dh(i,j)*dz(kbm1))) ... 156 | /(c(i,j,kbm1)*(1.e0-ee(i,j,kbm2))-1.e0); 157 | end 158 | end 159 | % 160 | for k=2:kbm1 161 | ki=kb-k; 162 | for j=1:jm 163 | for i=1:im 164 | f(i,j,ki)=(ee(i,j,ki)*f(i,j,ki+1)+gg(i,j,ki)); 165 | end 166 | end 167 | end 168 | 169 | % 170 | -------------------------------------------------------------------------------- /matlab_origin/profu.m: -------------------------------------------------------------------------------- 1 | function [a,c,ee,gg,tps,uf,wubot] = profu(a,c,ee,gg,tps,uf,wubot,... 2 | etf,h,km,dti2,umol,dz,dzz,wusurf,cbc,dum,im,jm,kb,imm1,jmm1,kbm1,kbm2,ub,vb) 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : Solves for vertical diffusion of x-momentum using * 6 | % * method described by Richmeyer and Morton. * 7 | % * * 8 | % * See: * 9 | % * * 10 | % * Richtmeyer R.D., and K.W. Morton, 1967. Difference * 11 | % * Methods for Initial-Value Problems, 2nd edition, * 12 | % * Interscience, New York, 198-201. * 13 | % * * 14 | % * NOTE that wusurf has the opposite sign to the wind * 15 | % * speed. * 16 | % * * 17 | % ********************************************************************** 18 | % 19 | dh=ones(im,jm); 20 | % 21 | % The following section solves the equation: 22 | % 23 | % dti2*(km*u')'-u=-ub 24 | % 25 | % 26 | for j=2:jm 27 | for i=2:im 28 | dh(i,j)=(h(i,j)+etf(i,j)+h(i-1,j)+etf(i-1,j))*.5e0; 29 | end 30 | end 31 | % 32 | for k=1:kb 33 | for j=2:jm 34 | for i=2:im 35 | c(i,j,k)=(km(i,j,k)+km(i-1,j,k))*.5e0; 36 | end 37 | end 38 | end 39 | % 40 | for k=2:kbm1 41 | for j=1:jm 42 | for i=1:im 43 | a(i,j,k-1)=-dti2*(c(i,j,k)+umol) ... 44 | /(dz(k-1)*dzz(k-1)*dh(i,j)*dh(i,j)); 45 | c(i,j,k)=-dti2*(c(i,j,k)+umol) ... 46 | /(dz(k)*dzz(k-1)*dh(i,j)*dh(i,j)); 47 | end 48 | end 49 | end 50 | % 51 | for j=1:jm 52 | for i=1:im 53 | ee(i,j,1)=a(i,j,1)/(a(i,j,1)-1.e0); 54 | gg(i,j,1)=(-dti2*wusurf(i,j)/(-dz(1)*dh(i,j)) ... 55 | -uf(i,j,1)) ... 56 | /(a(i,j,1)-1.e0); 57 | end 58 | end 59 | % 60 | for k=2:kbm2 61 | for j=1:jm 62 | for i=1:im 63 | gg(i,j,k)=1.e0/(a(i,j,k)+c(i,j,k)*(1.e0-ee(i,j,k-1))-1.e0); 64 | ee(i,j,k)=a(i,j,k)*gg(i,j,k); 65 | gg(i,j,k)=(c(i,j,k)*gg(i,j,k-1)-uf(i,j,k))*gg(i,j,k); 66 | end 67 | end 68 | end 69 | % 70 | for j=2:jmm1 71 | for i=2:imm1 72 | tps(i,j)=0.5e0*(cbc(i,j)+cbc(i-1,j)) ... 73 | *sqrt(ub(i,j,kbm1)^2 ... 74 | +(.25e0*(vb(i,j,kbm1)+vb(i,j+1,kbm1) ... 75 | +vb(i-1,j,kbm1)+vb(i-1,j+1,kbm1)))^2); 76 | uf(i,j,kbm1)=(c(i,j,kbm1)*gg(i,j,kbm2)-uf(i,j,kbm1)) ... 77 | /(tps(i,j)*dti2/(-dz(kbm1)*dh(i,j))-1.e0 ... 78 | -(ee(i,j,kbm2)-1.e0)*c(i,j,kbm1)); 79 | uf(i,j,kbm1)=uf(i,j,kbm1)*dum(i,j); 80 | end 81 | end 82 | % 83 | 84 | for k=2:kbm1 85 | ki=kb-k; 86 | for j=2:jmm1 87 | for i=2:imm1 88 | uf(i,j,ki)=(ee(i,j,ki)*uf(i,j,ki+1)+gg(i,j,ki))*dum(i,j); 89 | end 90 | end 91 | end 92 | % 93 | for j=2:jmm1 94 | for i=2:imm1 95 | wubot(i,j)=-tps(i,j)*uf(i,j,kbm1); 96 | end 97 | end 98 | 99 | return 100 | end 101 | 102 | % 103 | -------------------------------------------------------------------------------- /matlab_origin/profv.m: -------------------------------------------------------------------------------- 1 | 2 | function [a,c,ee,gg,tps,vf,wvbot] = profv(a,c,ee,gg,tps,vf,wvbot,... 3 | dvm,dz,dzz,im,jm,kb,imm1,jmm1,kbm1,kbm2,... 4 | km,cbc,ub,vb,umol,wvsurf,h,etf,dti2) 5 | 6 | % ********************************************************************** 7 | % * 8 | % * FUNCTION : Solves for vertical diffusion of y-momentum using * 9 | % * method described by Richmeyer and Morton. * 10 | % * * 11 | % * See: * 12 | % * * 13 | % * Richtmeyer R.D., and K.W. Morton, 1967. Difference * 14 | % * Methods for Initial-Value Problems, 2nd edition, * 15 | % * Interscience, New York, 198-201. * 16 | % * * 17 | % * NOTE that wvsurf has the opposite sign to the wind * 18 | % * speed. * 19 | % * * 20 | % ********************************************************************** 21 | % 22 | % 23 | dh=ones(im,jm); 24 | % The following section solves the equation: 25 | % 26 | % dti2*(km*u')'-u=-ub 27 | % 28 | % 29 | for j=2:jm 30 | for i=2:im 31 | dh(i,j)=.5e0*(h(i,j)+etf(i,j)+h(i,j-1)+etf(i,j-1)); 32 | end 33 | end 34 | % 35 | for k=1:kb 36 | for j=2:jm 37 | for i=2:im 38 | c(i,j,k)=(km(i,j,k)+km(i,j-1,k))*.5e0; 39 | end 40 | end 41 | end 42 | % 43 | for k=2:kbm1 44 | for j=1:jm 45 | for i=1:im 46 | a(i,j,k-1)=-dti2*(c(i,j,k)+umol) ... 47 | /(dz(k-1)*dzz(k-1)*dh(i,j)*dh(i,j)); 48 | c(i,j,k)=-dti2*(c(i,j,k)+umol) ... 49 | /(dz(k)*dzz(k-1)*dh(i,j)*dh(i,j)); 50 | end 51 | end 52 | end 53 | % 54 | for j=1:jm 55 | for i=1:im 56 | ee(i,j,1)=a(i,j,1)/(a(i,j,1)-1.e0); 57 | gg(i,j,1)=(-dti2*wvsurf(i,j)/(-dz(1)*dh(i,j))-vf(i,j,1)) ... 58 | /(a(i,j,1)-1.e0); 59 | end 60 | end 61 | % 62 | for k=2:kbm2 63 | for j=1:jm 64 | for i=1:im 65 | gg(i,j,k)=1.e0/(a(i,j,k)+c(i,j,k)*(1.e0-ee(i,j,k-1))-1.e0); 66 | ee(i,j,k)=a(i,j,k)*gg(i,j,k); 67 | gg(i,j,k)=(c(i,j,k)*gg(i,j,k-1)-vf(i,j,k))*gg(i,j,k); 68 | end 69 | end 70 | end 71 | % 72 | for j=2:jmm1 73 | for i=2:imm1 74 | tps(i,j)=0.5e0*(cbc(i,j)+cbc(i,j-1)) ... 75 | *sqrt((.25e0*(ub(i,j,kbm1)+ub(i+1,j,kbm1) ... 76 | +ub(i,j-1,kbm1)+ub(i+1,j-1,kbm1)))^2 ... 77 | +vb(i,j,kbm1)^2); 78 | 79 | vf(i,j,kbm1)=(c(i,j,kbm1)*gg(i,j,kbm2)-vf(i,j,kbm1)) ... 80 | /(tps(i,j)*dti2/(-dz(kbm1)*dh(i,j))-1.e0 ... 81 | -(ee(i,j,kbm2)-1.e0)*c(i,j,kbm1)); 82 | vf(i,j,kbm1)=vf(i,j,kbm1)*dvm(i,j); 83 | end 84 | end 85 | % 86 | for k=2:kbm1 87 | ki=kb-k; 88 | for j=2:jmm1 89 | for i=2:imm1 90 | vf(i,j,ki)=(ee(i,j,ki)*vf(i,j,ki+1)+gg(i,j,ki))*dvm(i,j); 91 | end 92 | end 93 | end 94 | % 95 | for j=2:jmm1 96 | for i=2:imm1 97 | wvbot(i,j)=-tps(i,j)*vf(i,j,kbm1); 98 | end 99 | end 100 | % 101 | return 102 | % 103 | end 104 | % 105 | -------------------------------------------------------------------------------- /matlab_origin/prxy.m: -------------------------------------------------------------------------------- 1 | function prxy(label,time,a,im,iskp,jm,jskp,scala) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : Writes a horizontal 2-D field. * 6 | % * * 7 | % * label ....... label for output * 8 | % * time ........ time (days) * 9 | % * a(im,jm,kb).. array to be printed * 10 | % * iskp ........ skipping interval for i * 11 | % * jskp ........ skipping interval for j * 12 | % * scala ....... < 0 for floating point numbers output * 13 | % * 0 for integer output, divisor for a * 14 | % * based on magnitudes of |a| values * 15 | % * > 0 for integer output, divisor for a * 16 | % * given by scala * 17 | % * * 18 | % ********************************************************************** 19 | % 20 | 21 | if(scala>=0.e0) 22 | cols=24; 23 | else 24 | cols=12; 25 | end 26 | % 27 | if (scala<0.e0) 28 | scale = 1.e0; 29 | end 30 | if (scala==0.e0) 31 | amx=1.e-12; 32 | for j=1:jskp:jm 33 | for i=1:iskp:im 34 | amx=max(abs(a(i,j)),amx); 35 | end 36 | end 37 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 38 | end 39 | if(scala>0.e0) 40 | scale=scala; 41 | end 42 | % 43 | % 44 | fprintf('%s\n',label); 45 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 46 | for ib=1:cols*iskp:im 47 | % 48 | ie=ib+(cols-1)*iskp; 49 | if(ie>im) 50 | ie=im; 51 | end 52 | % 53 | for j=1:jskp:jm 54 | jwr=jm+1-j; 55 | if(scala>=0.e0) 56 | 57 | fprintf('%d , %d \n',jwr,floor(a(ib,jwr)/scale+0.5)); 58 | fprintf('%d , %d \n',jwr,floor(a(ie,jwr)/scale+0.5)); 59 | fprintf('%d , %d \n',jwr,floor(a(iskp,jwr)/scale+0.5)); 60 | else 61 | fprintf('%d , %d \n',jwr,a(ib,jwr)); 62 | fprintf('%d , %d \n',jwr,a(ie,jwr)); 63 | fprintf('%d , %d \n',jwr,a(iskip,jwr)); 64 | 65 | end 66 | end 67 | % 68 | % 69 | end 70 | return 71 | end 72 | % 73 | -------------------------------------------------------------------------------- /matlab_origin/prxyz.m: -------------------------------------------------------------------------------- 1 | function prxyz(label,time,a,im,iskp,jm,jskp,kb,ko,nko,scala) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUNCTION : Writes horizontal layers of a 3-D field with * 6 | % * integers or floating point numbers. * 7 | % * * 8 | % * label ....... label for output * 9 | % * time ........ time (days) * 10 | % * a(im,jm,kb).. array to be printed * 11 | % * iskp ........ skipping interval for i * 12 | % * jskp ........ skipping interval for j * 13 | % * ko .......... 1-D array of k-indices for output * 14 | % * nko ......... number of elements in ko * 15 | % * scala ....... < 0 for floating point numbers output * 16 | % * 0 for integer output, divisor for a * 17 | % * based on magnitudes of |a| values * 18 | % * > 0 for integer output, divisor for a * 19 | % * given by scala * 20 | % * * 21 | % * (NOTE that this combines functions of old prxyz and * 22 | % * eprxyz) * 23 | % * * 24 | % ********************************************************************** 25 | % 26 | 27 | % 28 | if(scala>=0.e0) 29 | cols=24; 30 | else 31 | cols=12; 32 | end 33 | % 34 | if (scala<0.e0) scale = 1.e0; 35 | end 36 | if (scala==0.e0) 37 | amx=1.e-12; 38 | for iko=1:nko 39 | k=ko(iko); 40 | for j=1:jskp:jm 41 | for i=1:iskp:im 42 | amx=max(abs(a(i,j,k)),amx); 43 | end 44 | end 45 | end 46 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 47 | end 48 | if(scala>0.e0) scale=scala; 49 | end 50 | % 51 | fprintf('%s\n',label); 52 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 53 | 54 | for iko=1:nko 55 | % 56 | k=ko(iko); 57 | fprintf('Layer k = %d \n',k); 58 | % 59 | for ib=1:cols*iskp:im 60 | % 61 | ie=ib+(cols-1)*iskp; 62 | if(ie>im) ie=im; 63 | % 64 | if(scala>=0.e0) 65 | fprintf('%d %d %d\n',ib,ie,iskp); 66 | else 67 | fprintf('%d %d %d\n',ib,ie,iskp); 68 | end 69 | % 70 | for j=1:jskp:jm 71 | jwr=jm+1-j; 72 | if(scala>=0.e0) 73 | fprintf('%d , %d \n',jwr,floor(a(ib,jwr,k)/scale+0.5)); 74 | fprintf('%d , %d \n',jwr,floor(a(ie,jwr,k)/scale+0.5)); 75 | fprintf('%d , %d \n',jwr,floor(a(iskp,jwr,k)/scale+0.5)); 76 | else 77 | fprintf('%d , %d \n',jwr,a(ib,jwr,k)); 78 | fprintf('%d , %d \n',jwr,a(ie,jwr,k)); 79 | fprintf('%d , %d \n',jwr,a(iskp,jwr,k)); 80 | end 81 | end 82 | % 83 | fprintf('//'); 84 | % 85 | end 86 | % 87 | end 88 | % 89 | return 90 | % 91 | end 92 | % 93 | -------------------------------------------------------------------------------- /matlab_origin/prxz.m: -------------------------------------------------------------------------------- 1 | function prxz(label,time,a,im,iskp,jm,kb,jo,njo,scala,dt,zz) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Writes vertical section of a 3-D field, in the * 5 | % * x- or i-direction . * 6 | % * * 7 | % * label ....... label for output * 8 | % * time ........ time (days) * 9 | % * a(im,jm,kb).. array to be printed * 10 | % * iskp ........ skipping interval for i * 11 | % * jo .......... 1-D array of j-indices for output * 12 | % * njo ......... number of elements in jo * 13 | % * scala ....... < 0 for floating point numbers output * 14 | % * 0 for integer output, divisor for a * 15 | % * based on magnitudes of |a| values * 16 | % * > 0 for integer output, divisor for a * 17 | % * given by scala * 18 | % * dt(im,jm) ... total depth * 19 | % * zz(kb) ...... sigma coordinate * 20 | % * * 21 | % ********************************************************************** 22 | % 23 | if(scala>=0.e0) 24 | cols=24; 25 | else 26 | cols=12; 27 | end 28 | % 29 | if (scala<0.e0) 30 | scale = 1.e0; 31 | end 32 | if (scala==0.e0) 33 | amx=1.e-12; 34 | for k=1:kb 35 | for ijo=1:njo 36 | j=jo(ijo); 37 | for i=1:iskp:im 38 | amx=max(abs(a(i,j,k)),amx); 39 | end 40 | end 41 | end 42 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 43 | end 44 | if(scala>0.e0) 45 | scale=scala; 46 | end 47 | % 48 | fprintf('%s\n',label); 49 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 50 | 51 | for ijo=1:njo 52 | j=jo(ijo); 53 | fprintf('Section j = %d \n',j); 54 | for ib=1:cols*iskp:im 55 | ie=ib+(cols-1)*iskp; 56 | if(ie>im) ie=im; 57 | end 58 | 59 | fprintf('i = %d , d= %d , z or zz',ib,floor(dt(ib,j)+0.5)); 60 | fprintf('i = %d , d= %d , z or zz',ie,floor(dt(ie,j)+0.5)); 61 | fprintf('i = %d , d= %d , z or zz',iskp,floor(dt(iskp,j)+0.5)); 62 | 63 | for k=1:kb 64 | if(scala>=0.e0) 65 | fprintf('%d , %f %d\n',k,zz(k),floor(a(ib,j,k)/scale+0.5)); 66 | fprintf('%d , %f %d\n',k,zz(k),floor(a(ie,j,k)/scale+0.5)); 67 | fprintf('%d , %f %d\n',k,zz(k),floor(a(iskp,j,k)/scale+0.5)); 68 | else 69 | fprintf('%d , %f %f\n',k,zz(k),a(ib,j,k)); 70 | fprintf('%d , %f %f\n',k,zz(k),a(ie,j,k)); 71 | fprintf('%d , %f %f\n',k,zz(k),a(ik,j,k)); 72 | end 73 | end 74 | % 75 | end 76 | % 77 | end 78 | % 79 | return 80 | % 81 | end 82 | % 83 | -------------------------------------------------------------------------------- /matlab_origin/pryz.m: -------------------------------------------------------------------------------- 1 | function pryz(label,time,a,im,jm,jskp,kb,io,nio,scala,dt,zz) 2 | 3 | % ********************************************************************** 4 | % * * 5 | % * FUNCTION : Writes vertical section of a 3-D field, in the * 6 | % * y- or j-direction. * 7 | % * * 8 | % * label ....... label for output * 9 | % * time ........ time (days) * 10 | % * a(im,jm,kb).. array to be printed * 11 | % * jskp ........ skipping interval for j * 12 | % * io .......... 1-D array of i-indices for output * 13 | % * nio ......... number of elements in io * 14 | % * scala ....... < 0 for floating point numbers output * 15 | % * 0 for integer output, divisor for a * 16 | % * based on magnitudes of |a| values * 17 | % * > 0 for integer output, divisor for a * 18 | % * given by scala * 19 | % * dt(im,jm) ... total depth * 20 | % * zz(kb) ...... sigma coordinate * 21 | % * * 22 | % ********************************************************************** 23 | % 24 | % 25 | if(scala>=0.e0) 26 | cols=24; 27 | else 28 | cols=12; 29 | end 30 | % 31 | if (scala<0.e0) 32 | scale = 1.e0; 33 | end 34 | if (scala==0.e0) 35 | amx=1.e-12 36 | for k=1:kb 37 | for j=1:jskp:jm 38 | for iio=1:nio 39 | i=io(iio); 40 | amx=max(abs(a(i,j,k)),amx); 41 | end 42 | end 43 | end 44 | scale=10.e0^(floor(log10(amx)+100.e0)-103); 45 | end 46 | if(scala>0.e0) 47 | scale=scala; 48 | end 49 | % 50 | 51 | fprintf('%s\n',label); 52 | fprintf('Time= %f, multiply all values by %f\n', time,scale); 53 | % 54 | for iio=1:nio 55 | % 56 | i=io(iio); 57 | % 58 | fprintf('Section i = %d \n',i); 59 | for jb=1:cols*jskp:jm 60 | % 61 | je=jb+(cols-1)*jskp; 62 | if(je>jm) 63 | je=jm; 64 | end 65 | % 66 | if(scala>=0.e0) 67 | fprintf('%20d%20d%20d',jb,je,jskp); 68 | else 69 | fprintf('%10d%10d%10d',jb,je,jskp); 70 | end 71 | 72 | fprintf('%10d \n',floor(dt(i,jb)/scale+0.5)); 73 | fprintf('%10d \n',floor(dt(i,je)/scale+0.5)); 74 | fprintf('%10d \n',floor(dt(i,jskp)/scale+0.5)); 75 | 76 | for k=1:kb 77 | if(scala>=0.e0) 78 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,jb,k)/scale+0.5)); 79 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,je,k)/scale+0.5)); 80 | fprintf('%d %d %d \n',k,zz(k),floor(a(i,jskp,k)/scale+0.5)); 81 | 82 | else 83 | fprintf('%d %d %d \n',k,zz(k),a(i,jb,k)); 84 | fprintf('%d %d %d \n',k,zz(k),a(i,je,k)); 85 | fprintf('%d %d %d \n',k,zz(k),a(i,jb,jskp)); 86 | end 87 | end 88 | % 89 | fprintf('//'); 90 | % 91 | end 92 | % 93 | end 94 | % 95 | return 96 | % 97 | end 98 | % 99 | -------------------------------------------------------------------------------- /matlab_origin/slpmax.m: -------------------------------------------------------------------------------- 1 | function [h] = slpmax(h,im,jm,fsm,slmax) 2 | % ********************************************************************** 3 | % * * 4 | % * FUNCTION : Limits the maximum of: * 5 | % * * 6 | % * / * 7 | % * * 8 | % * for two adjacent cells. The maximum possible value * 9 | % * is unity. * 10 | % * * 11 | % ********************************************************************** 12 | 13 | for loop=1:10 14 | % Sweep right: 15 | for j=2:jm-1 16 | for i=2:im-1 17 | if(fsm(i,j) ~= 0.e0 && fsm(i+1,j) ~=0.e0) 18 | if(abs(h(i+1,j)-h(i,j))/(h(i,j)+h(i+1,j)) >= slmax) 19 | mean=(h(i+1,j)+h(i,j))/2.e0; 20 | %del=sign(slmax,h(i+1,j)-h(i,j)); 21 | if(h(i+1,j)-h(i,j)>=0.e0) 22 | del = abs(slmax); 23 | else del = -abs(slmax); 24 | end 25 | h(i+1,j)=mean*(1.e0+del); 26 | h(i,j)=mean*(1.e0-del); 27 | end 28 | end 29 | end 30 | 31 | % Sweep left: 32 | for i=im-1:-1:2 33 | if(fsm(i,j) ~= 0.0 && fsm(i+1,j) ~= 0.0) 34 | if(abs(h(i+1,j)-h(i,j))/(h(i,j)+h(i+1,j)) >= slmax) 35 | mean=(h(i+1,j)+h(i,j))/2.e0; 36 | %del=sign(slmax,h(i+1,j)-h(i,j)); 37 | if(h(i+1,j)-h(i,j)>=0.e0) 38 | del = abs(slmax); 39 | else del = -abs(slmax); 40 | end 41 | h(i+1,j)=mean*(1.e0+del); 42 | h(i,j)=mean*(1.e0-del); 43 | end 44 | end 45 | end 46 | end 47 | 48 | % Sweep up: 49 | for i=2:im-1 50 | for j=2:jm-1 51 | if(fsm(i,j) ~= 0.0 && fsm(i,j+1) ~= 0.0) 52 | if(abs(h(i,j+1)-h(i,j))/(h(i,j)+h(i,j+1)) >= slmax) 53 | mean=(h(i,j+1)+h(i,j))/2.e0; 54 | if(h(i,j+1)-h(i,j)>=0.e0) 55 | del=abs(slmax); 56 | else del=-abs(slmax); 57 | end 58 | %del=sign(slmax,h(i,j+1)-h(i,j)); 59 | h(i,j+1)=mean*(1.0+del); 60 | h(i,j)=mean*(1.0-del); 61 | end 62 | end 63 | end 64 | 65 | % Sweep down: 66 | for j=jm-1:-1:2 67 | if(fsm(i,j) ~= 0.0 && fsm(i,j+1) ~= 0.0) 68 | if(abs(h(i,j+1)-h(i,j))/(h(i,j)+h(i,j+1)) >= slmax) 69 | mean=(h(i,j+1)+h(i,j))/2.e0; 70 | if(h(i,j+1)-h(i,j)>=0.e0) 71 | del=abs(slmax); 72 | else del=-abs(slmax); 73 | end 74 | %del=sign(slmax,h(i,j+1)-h(i,j)); 75 | h(i,j+1)=mean*(1.e0+del); 76 | h(i,j)=mean*(1.e0-del); 77 | end 78 | end 79 | end 80 | end 81 | end 82 | -------------------------------------------------------------------------------- /matlab_origin/smol_adif.m: -------------------------------------------------------------------------------- 1 | function[xmassflux,ymassflux,zwflux,ff,sw] = smol_adif(xmassflux,ymassflux,zwflux,ff,sw,... 2 | im,jm,kb,imm1,jmm1,kbm1,dti2,fsm,aru,arv,dzz,dt) 3 | % ********************************************************************** 4 | % * * 5 | % * FUN%TION : %alculates the antidiffusive velocity used to * 6 | % * reduce the numerical diffusion associated with the * 7 | % * upstream differencing scheme. * 8 | % * * 9 | % * This is based on a subroutine of Gianmaria Sannino * 10 | % * (Inter-university %omputing %onsortium, Rome, Italy)* 11 | % * and Vincenzo Artale (Italian National Agency for * 12 | % * New Technology and Environment, Rome, Italy), * 13 | % * forwnloaded from the POM FTP site on 1 Nov. 2001. * 14 | % * The calculations have been simplified by removing * 15 | % * the shock switch option. * 16 | % * * 17 | % ********************************************************************** 18 | % 19 | % 20 | % 21 | % 22 | value_min=1.0e-9; 23 | epsilon=1.0e-14; 24 | % 25 | % Apply temperature and salinity mask: 26 | % 27 | for k=1:kb 28 | for i=1:im 29 | for j=1:jm 30 | ff(i,j,k)=ff(i,j,k)*fsm(i,j); 31 | end 32 | end 33 | end 34 | % 35 | % Recalculate mass fluxes with antidiffusion velocity: 36 | % 37 | for k=1:kbm1 38 | for j=2:jmm1 39 | for i=2:im 40 | if(ff(i,j,k)