| 1 |
function []=grid_load(dirGrid,nFaces,fileFormat,memoryLimit,omitNativeGrid); |
| 2 |
%object: load grid information, convert it to gcmfaces format |
| 3 |
% and encapsulate it in the global mygrid structure. |
| 4 |
%inputs: dirGrid is the directory where the grid files (gcm output) can be found. |
| 5 |
% nFaces is the number of faces in this gcm set-up of current interest. |
| 6 |
% fileFormat is the file format ('straight','cube','compact') |
| 7 |
%optional: memoryLimit is a flag that allows the user to omit secondary |
| 8 |
% grid fields in case memory/storage become an issue. It |
| 9 |
% takes 3 values : (0; the default) includes everything |
| 10 |
% (1) omits all 3D fields but hFacC (2) only loads XC & YC. |
| 11 |
% omitNativeGrid is a flag (0 by default) to bypass (when flag 1) |
| 12 |
% grid_load_native and grid_load_native_RAZ calls (that can |
| 13 |
% complement mygrid based upon e.g. tile*.mitgrid files) |
| 14 |
|
| 15 |
if isempty(whos('memoryLimit')); memoryLimit=0; end; |
| 16 |
if isempty(whos('omitNativeGrid')); omitNativeGrid=0; end; |
| 17 |
|
| 18 |
gcmfaces_global; mygrid=[]; |
| 19 |
|
| 20 |
if nargin==0;%assume that LLC90 grid is used |
| 21 |
if ~isempty(dir('nctiles_grid')); |
| 22 |
mygrid.dirGrid=['nctiles_grid' filesep]; |
| 23 |
mygrid.fileFormat='nctiles'; |
| 24 |
elseif ~isempty(dir('GRID')); |
| 25 |
mygrid.dirGrid=['GRID' filesep]; |
| 26 |
mygrid.fileFormat='compact'; |
| 27 |
elseif ~isempty(dir(['./XC.meta'])); |
| 28 |
mygrid.dirGrid=['.' filesep]; |
| 29 |
mygrid.fileFormat='compact'; |
| 30 |
else; |
| 31 |
fprintf('\n please indicate the grid directory (e.g., ''./'' or ''nctiles_grid/'') \n\n'); |
| 32 |
fprintf(' The ECCO v4 grid can be obtained as follows: \n'); |
| 33 |
fprintf([' wget --recursive ftp://mit.ecco-group.org/ecco_for_las/' ... |
| 34 |
'version_4/release1/nctiles_grid \n']); |
| 35 |
fprintf(' mv mit.ecco-group.org/ecco_for_las/version_4/release1/nctiles_grid . \n\n'); |
| 36 |
dirGrid=input(''); |
| 37 |
mygrid.dirGrid=[dirGrid filesep]; |
| 38 |
if ~isempty(dir([mygrid.dirGrid 'GRID.0001.nc'])); |
| 39 |
mygrid.fileFormat='nctiles'; |
| 40 |
elseif ~isempty(dir([mygrid.dirGrid 'XC.meta'])); |
| 41 |
mygrid.fileFormat='compact'; |
| 42 |
else; |
| 43 |
error(['could not find grid files in ' mygrid.dirGrid]); |
| 44 |
end; |
| 45 |
end; |
| 46 |
mygrid.nFaces=5; |
| 47 |
mygrid.gcm2facesFast=false; |
| 48 |
mygrid.memoryLimit=0; |
| 49 |
omitNativeGrid=isempty(dir([mygrid.dirGrid 'tile001.mitgrid'])); |
| 50 |
else;%user specified settings |
| 51 |
mygrid.dirGrid=dirGrid; |
| 52 |
mygrid.nFaces=nFaces; |
| 53 |
mygrid.fileFormat=fileFormat; |
| 54 |
mygrid.gcm2facesFast=false; |
| 55 |
mygrid.memoryLimit=memoryLimit; |
| 56 |
end; |
| 57 |
|
| 58 |
if mygrid.memoryLimit>0; |
| 59 |
gcmfaces_msg(['* Warning from grid_load : memoryLimit>0 ' ... |
| 60 |
'may precludes advanced gmcfaces functions.'],''); |
| 61 |
end; |
| 62 |
if mygrid.memoryLimit>1; |
| 63 |
gcmfaces_msg(['* Warning from grid_load : memoryLimit>1 ' ... |
| 64 |
'may only allow for basic fields displays.'],''); |
| 65 |
end; |
| 66 |
|
| 67 |
if strcmp(mygrid.fileFormat,'nctiles'); |
| 68 |
i2=ncread([mygrid.dirGrid 'GRID.0001.nc'],'i2'); |
| 69 |
nn=length(i2); |
| 70 |
mygrid.ioSize=[nn nn*13]; |
| 71 |
mygrid.facesSize=[[nn nn*3];[nn nn*3];[nn nn];[nn*3 nn];[nn*3 nn];[nn nn]]; |
| 72 |
mygrid.facesExpand=[]; |
| 73 |
elseif ~isempty(dir([mygrid.dirGrid 'grid.specs.mat'])); |
| 74 |
specs=open([mygrid.dirGrid 'grid.specs.mat']); |
| 75 |
mygrid.ioSize=specs.ioSize; |
| 76 |
mygrid.facesSize=specs.facesSize; |
| 77 |
mygrid.facesExpand=specs.facesExpand; |
| 78 |
%example for creating grid.specs.mat, to put in dirGrid : |
| 79 |
%ioSize=[364500 1]; |
| 80 |
%facesSize=[[270 450];[0 0];[270 270];[180 270];[450 270]]; |
| 81 |
%facesExpand=[270 450]; |
| 82 |
%save grid.specs.mat ioSize facesSize facesExpand; |
| 83 |
elseif strcmp(mygrid.fileFormat,'compact'); |
| 84 |
v0=rdmds([mygrid.dirGrid 'XC']); |
| 85 |
mygrid.ioSize=size(v0); |
| 86 |
nn=size(v0,1); pp=size(v0,2)/nn; |
| 87 |
mm=(pp+4-mygrid.nFaces)/4*nn; |
| 88 |
mygrid.facesSize=[[nn mm];[nn mm];[nn nn];[mm nn];[mm nn];[nn nn]]; |
| 89 |
mygrid.facesExpand=[]; |
| 90 |
elseif strcmp(mygrid.fileFormat,'cube'); |
| 91 |
v0=rdmds([mygrid.dirGrid 'XC']); |
| 92 |
mygrid.ioSize=size(v0); |
| 93 |
nn=size(v0,2); |
| 94 |
mygrid.facesSize=[[nn nn];[nn nn];[nn nn];[nn nn];[nn nn];[nn nn]]; |
| 95 |
mygrid.facesExpand=[]; |
| 96 |
elseif strcmp(mygrid.fileFormat,'straight'); |
| 97 |
v0=rdmds([mygrid.dirGrid 'XC']); |
| 98 |
mygrid.ioSize=size(v0); |
| 99 |
mygrid.facesSize=mygrid.ioSize; |
| 100 |
mygrid.facesExpand=[]; |
| 101 |
end; |
| 102 |
|
| 103 |
mygrid.missVal=NaN;%will be set to 0 once the grid has been loaded. |
| 104 |
|
| 105 |
if ~(mygrid.nFaces==1&strcmp(mygrid.fileFormat,'straight'))&... |
| 106 |
~(mygrid.nFaces==6&strcmp(mygrid.fileFormat,'cube'))&... |
| 107 |
~(mygrid.nFaces==6&strcmp(mygrid.fileFormat,'compact'))&... |
| 108 |
~(mygrid.nFaces==5&strcmp(mygrid.fileFormat,'compact'))&... |
| 109 |
~(mygrid.nFaces==5&strcmp(mygrid.fileFormat,'nctiles')); |
| 110 |
error('non-supported grid topology'); |
| 111 |
end; |
| 112 |
|
| 113 |
if strcmp(mygrid.fileFormat,'nctiles'); |
| 114 |
%place holders (needed for read_nctiles) |
| 115 |
tmp1=NaN*zeros(nn,nn*3); |
| 116 |
tmp2=NaN*zeros(nn,nn); |
| 117 |
tmp3=NaN*zeros(nn*3,nn); |
| 118 |
mygrid.XC=gcmfaces({tmp1,tmp1,tmp2,tmp3,tmp3}); |
| 119 |
mygrid.YC=gcmfaces({tmp1,tmp1,tmp2,tmp3,tmp3}); |
| 120 |
mygrid.RC=NaN*zeros(50,1); |
| 121 |
clear tmp?; |
| 122 |
end; |
| 123 |
|
| 124 |
%the various grid fields: |
| 125 |
if mygrid.memoryLimit==0; |
| 126 |
list0={'XC','XG','YC','YG','RAC','RAZ','DXC','DXG','DYC','DYG','hFacC','hFacS','hFacW','Depth'}; |
| 127 |
elseif mygrid.memoryLimit==1; |
| 128 |
list0={'XC','XG','YC','YG','RAC','RAZ','DXC','DXG','DYC','DYG','hFacC','Depth'}; |
| 129 |
elseif mygrid.memoryLimit==2; |
| 130 |
list0={'XC','YC'}; |
| 131 |
end; |
| 132 |
|
| 133 |
for iFld=1:length(list0); |
| 134 |
if ~strcmp(mygrid.fileFormat,'nctiles'); |
| 135 |
eval(['mygrid.' list0{iFld} '=rdmds2gcmfaces([mygrid.dirGrid ''' list0{iFld} '*'']);']); |
| 136 |
else; |
| 137 |
eval(['mygrid.' list0{iFld} '=read_nctiles([mygrid.dirGrid ''GRID''],''' list0{iFld} ''');']); |
| 138 |
end; |
| 139 |
end; |
| 140 |
|
| 141 |
%the vertical grid |
| 142 |
list0={'RC','RF','DRC','DRF'}; |
| 143 |
for iFld=1:length(list0); |
| 144 |
if ~strcmp(mygrid.fileFormat,'nctiles'); |
| 145 |
eval(['mygrid.' list0{iFld} '=squeeze(rdmds([mygrid.dirGrid ''' list0{iFld} '*'']));']); |
| 146 |
else; |
| 147 |
eval(['ncload ' mygrid.dirGrid 'GRID.0001.nc ' list0{iFld} ';']); |
| 148 |
eval(['mygrid.' list0{iFld} '=' list0{iFld} ''';']); |
| 149 |
if strcmp(list0{iFld},'RF'); mygrid.RF=[mygrid.RF;NaN]; end; |
| 150 |
end; |
| 151 |
end; |
| 152 |
|
| 153 |
%grid orientation |
| 154 |
if mygrid.memoryLimit<2; |
| 155 |
list0={'AngleCS','AngleSN'}; |
| 156 |
test0=~isempty(dir([mygrid.dirGrid 'AngleCS*'])); |
| 157 |
if strcmp(mygrid.fileFormat,'nctiles'); |
| 158 |
for iFld=1:length(list0); |
| 159 |
eval(['mygrid.' list0{iFld} '=read_nctiles([mygrid.dirGrid ''GRID''],''' list0{iFld} ''');']); |
| 160 |
end; |
| 161 |
elseif test0; |
| 162 |
for iFld=1:length(list0); |
| 163 |
eval(['mygrid.' list0{iFld} '=rdmds2gcmfaces([mygrid.dirGrid ''' list0{iFld} '*'']);']); |
| 164 |
end; |
| 165 |
else; |
| 166 |
warning('\n AngleCS/AngleSN not found; set to 1/0 assuming lat/lon grid.\n'); |
| 167 |
mygrid.AngleCS=mygrid.XC; mygrid.AngleCS(:)=1; |
| 168 |
mygrid.AngleSN=mygrid.XC; mygrid.AngleSN(:)=0; |
| 169 |
end; |
| 170 |
end; |
| 171 |
|
| 172 |
%if the native grid is found then re-load (to benefit from double precision & avoid blank tile issues) |
| 173 |
files=dir([mygrid.dirGrid 'grid_cs32*bin']); |
| 174 |
if isempty(files); files=dir([mygrid.dirGrid 'tile*.mitgrid']); end; |
| 175 |
%logic above needs fixing since I think blank tiles show 0 rather than NaN on some machines |
| 176 |
if (length(files)==mygrid.nFaces)&~omitNativeGrid; |
| 177 |
grid_load_native; |
| 178 |
%replace NaNs with 0s if needed (blank tile only issue) |
| 179 |
list0={'hFacC','hFacS','hFacW','Depth','AngleCS','AngleSN'}; |
| 180 |
for ii=1:length(list0); |
| 181 |
if isfield(mygrid,list0{ii}); |
| 182 |
eval(['tmp1=mygrid.' list0{ii} ';']); |
| 183 |
tmp1(isnan(tmp1))=0; |
| 184 |
eval(['mygrid.' list0{ii} '=tmp1;']); |
| 185 |
end; |
| 186 |
end; |
| 187 |
%reset angles if needed (blank tile only issue) |
| 188 |
tmp1=mygrid.AngleCS.^2+mygrid.AngleSN.^2; |
| 189 |
tmp1=1*(tmp1>0.999&tmp1<1.001); |
| 190 |
mygrid.AngleCS(tmp1==0)=1; |
| 191 |
mygrid.AngleSN(tmp1==0)=0; |
| 192 |
end; |
| 193 |
|
| 194 |
%get full RAZ (incl. 'extra line and column') needed for e.g. rotational computations |
| 195 |
if mygrid.memoryLimit<2&~omitNativeGrid; |
| 196 |
grid_load_native_RAZ; |
| 197 |
end; |
| 198 |
|
| 199 |
%grid masks |
| 200 |
if mygrid.memoryLimit<1; |
| 201 |
mygrid.hFacCsurf=mygrid.hFacC; |
| 202 |
for ff=1:mygrid.hFacC.nFaces; mygrid.hFacCsurf{ff}=mygrid.hFacC{ff}(:,:,1); end; |
| 203 |
|
| 204 |
mskC=mygrid.hFacC; mskC(mskC==0)=NaN; mskC(mskC>0)=1; mygrid.mskC=mskC; |
| 205 |
mskW=mygrid.hFacW; mskW(mskW==0)=NaN; mskW(mskW>0)=1; mygrid.mskW=mskW; |
| 206 |
mskS=mygrid.hFacS; mskS(mskS==0)=NaN; mskS(mskS>0)=1; mygrid.mskS=mskS; |
| 207 |
end; |
| 208 |
|
| 209 |
%zonal mean and sections needed for transport computations |
| 210 |
% if mygrid.memoryLimit<1; |
| 211 |
% if ~isfield(mygrid,'mygrid.LATS_MASKS'); |
| 212 |
% gcmfaces_lines_zonal; |
| 213 |
% mygrid.LATS=[mygrid.LATS_MASKS.lat]'; |
| 214 |
% end; |
| 215 |
% if ~isfield(mygrid,'LINES_MASKS'); |
| 216 |
% [lonPairs,latPairs,names]=gcmfaces_lines_pairs; |
| 217 |
% gcmfaces_lines_transp(lonPairs,latPairs,names); |
| 218 |
% end; |
| 219 |
% end; |
| 220 |
|
| 221 |
%to allow convert2gcmfaces/doFast: |
| 222 |
if isempty(mygrid.facesExpand)&mygrid.memoryLimit<2; |
| 223 |
tmp1=convert2gcmfaces(mygrid.XC); |
| 224 |
tmp1(:)=[1:length(tmp1(:))]; |
| 225 |
nn=length(tmp1(:)); |
| 226 |
mygrid.gcm2faces=convert2gcmfaces(tmp1); |
| 227 |
mygrid.faces2gcmSize=size(tmp1); |
| 228 |
mygrid.faces2gcm=convert2gcmfaces(tmp1); |
| 229 |
for iFace=1:mygrid.nFaces; |
| 230 |
n=length(mygrid.gcm2faces{iFace}(:)); |
| 231 |
mygrid.faces2gcm{iFace}=mygrid.gcm2faces{iFace}(:); |
| 232 |
mygrid.gcm2faces{iFace}=sparse([1:n],mygrid.gcm2faces{iFace}(:),ones(1,n),n,nn); |
| 233 |
end; |
| 234 |
mygrid.gcm2facesFast=true; |
| 235 |
end; |
| 236 |
|
| 237 |
%reset missVal parameter to 0. |
| 238 |
%Note : this is only used by convert2widefaces, for runs with cropped grids. |
| 239 |
%Note : 0 should not be used as a fill for the grid itself (NaN was used). |
| 240 |
mygrid.missVal=0; |
| 241 |
|
Parent Directory
| 
Revision Log
| 
Revision Graph