MITgcm_contrib/quarter_degree_global/size.m

% determine possible combinations of tile sizes
clear all, close all, Nx=2880; Ny=2176; px=[]; py=[];
for i=2:sqrt(Nx)
  if mod(Nx,i)==0, px=[px i]; end
end
for i=2:sqrt(Ny)
  if mod(Ny,i)==0, py=[py i]; end
end
n=0;
for i=1:length(px)
  for j=1:length(py)
    n=n+1;
    pnx(n)=px(i);
    snx(n)=Nx/pnx(n);
    pny(n)=py(j);
    sny(n)=Ny/pny(n);
    pnxpny(n)=pnx(n)*pny(n);
  end
end
[pnxpny i]=sort(pnxpny);
pnx=pnx(i); pny=pny(i);
snx=snx(i); sny=sny(i);
[pnxpny' pnx' pny' snx' sny']


     npx*npy         npx         npy         snx         sny
         480          15          32         192          68
         480          30          16          96         136
         510          15          34         192          64
         510          30          17          96         128
         512          16          32         180          68
         512          32          16          90         136
         544          16          34         180          64
         544          32          17          90         128
         576          18          32         160          68
         576          36          16          80         136
         612          18          34         160          64
         612          36          17          80         128
         640          20          32         144          68
         640          40          16          72         136
         680          20          34         144          64
         680          40          17          72         128
         720          45          16          64         136
         765          45          17          64         128
         768          24          32         120          68
         768          48          16          60         136
         816          24          34         120          64
         816          48          17          60         128
         960          30          32          96          68
        1020          30          34          96          64
        1024          32          32          90          68
1	dimitri	1.1	% determine possible combinations of tile sizes
2			clear all, close all, Nx=2880; Ny=2176; px=[]; py=[];
3			for i=2:sqrt(Nx)
4			if mod(Nx,i)==0, px=[px i]; end
5			end
6			for i=2:sqrt(Ny)
7			if mod(Ny,i)==0, py=[py i]; end
8			end
9			n=0;
10			for i=1:length(px)
11			for j=1:length(py)
12			n=n+1;
13			pnx(n)=px(i);
14			snx(n)=Nx/pnx(n);
15			pny(n)=py(j);
16			sny(n)=Ny/pny(n);
17			pnxpny(n)=pnx(n)*pny(n);
18			end
19			end
20			[pnxpny i]=sort(pnxpny);
21			pnx=pnx(i); pny=pny(i);
22			snx=snx(i); sny=sny(i);
23			[pnxpny' pnx' pny' snx' sny']
24
25
26			npx*npy npx npy snx sny
27			480 15 32 192 68
28			480 30 16 96 136
29			510 15 34 192 64
30			510 30 17 96 128
31			512 16 32 180 68
32			512 32 16 90 136
33			544 16 34 180 64
34			544 32 17 90 128
35			576 18 32 160 68
36			576 36 16 80 136
37			612 18 34 160 64
38			612 36 17 80 128
39			640 20 32 144 68
40			640 40 16 72 136
41			680 20 34 144 64
42			680 40 17 72 128
43			720 45 16 64 136
44			765 45 17 64 128
45			768 24 32 120 68
46			768 48 16 60 136
47			816 24 34 120 64
48			816 48 17 60 128
49			960 30 32 96 68
50			1020 30 34 96 64
51			1024 32 32 90 68