matlab_class/gcmfaces_IO/grid_load.m

function []=grid_load(dirGrid,nFaces,fileFormat,memoryLimit,omitNativeGrid);
%object:    load grid information, convert it to gcmfaces format
%           and encapsulate it in the global mygrid structure.
%inputs:    dirGrid is the directory where the grid files (gcm output) can be found.
%           nFaces is the number of faces in this gcm set-up of current interest.
%           fileFormat is the file format ('straight','cube','compact')
%optional:  memoryLimit is a flag that allows the user to omit secondary
%               grid fields in case memory/storage become an issue. It
%               takes 3 values : (0; the default) includes everything
%               (1) omits all 3D fields but hFacC (2) only loads XC & YC.
%           omitNativeGrid is a flag (0 by default) to bypass (when flag 1)
%               grid_load_native and grid_load_native_RAZ calls (that can
%               complement mygrid based upon e.g. tile*.mitgrid files)

if isempty(whos('memoryLimit')); memoryLimit=0; end;
if isempty(whos('omitNativeGrid')); omitNativeGrid=0; end;

gcmfaces_global; mygrid=[];

if nargin==0;%assume that LLC90 grid is used
  if ~isempty(dir('nctiles_grid')); 
    mygrid.dirGrid=['nctiles_grid' filesep];
    mygrid.fileFormat='nctiles';
  elseif ~isempty(dir('GRID'));
    mygrid.dirGrid=['GRID' filesep];
    mygrid.fileFormat='compact';
  elseif ~isempty(dir(['./XC.meta']));
    mygrid.dirGrid=['.' filesep];
    mygrid.fileFormat='compact';
  else;
     fprintf('\n please indicate the grid directory (e.g., ''./'' or ''nctiles_grid/'') \n\n');
     fprintf('   The ECCO v4 grid can be obtained as follows: \n');
     fprintf(['   wget --recursive ftp://mit.ecco-group.org/ecco_for_las/' ...
              'version_4/release1/nctiles_grid \n']);
     fprintf('   mv mit.ecco-group.org/ecco_for_las/version_4/release1/nctiles_grid . \n\n');
     dirGrid=input('');
     mygrid.dirGrid=[dirGrid filesep];
     if ~isempty(dir([mygrid.dirGrid 'GRID.0001.nc']));
       mygrid.fileFormat='nctiles';
     elseif ~isempty(dir([mygrid.dirGrid 'XC.meta']));
       mygrid.fileFormat='compact';
     else;
       error(['could not find grid files in ' mygrid.dirGrid]);
     end;
  end;
  mygrid.nFaces=5;
  mygrid.gcm2facesFast=false;
  mygrid.memoryLimit=0;
  omitNativeGrid=isempty(dir([mygrid.dirGrid 'tile001.mitgrid']));
else;%user specified settings
  mygrid.dirGrid=dirGrid;
  mygrid.nFaces=nFaces;
  mygrid.fileFormat=fileFormat;
  mygrid.gcm2facesFast=false;
  mygrid.memoryLimit=memoryLimit;
end;

if mygrid.memoryLimit>0;
    gcmfaces_msg(['* Warning from grid_load : memoryLimit>0 ' ...
        'may precludes advanced gmcfaces functions.'],'');
end;
if mygrid.memoryLimit>1;
    gcmfaces_msg(['* Warning from grid_load : memoryLimit>1 ' ...
        'may only allow for basic fields displays.'],'');
end;

if strcmp(mygrid.fileFormat,'nctiles');
    i2=ncread([mygrid.dirGrid 'GRID.0001.nc'],'i2');
    nn=length(i2);
    mygrid.ioSize=[nn nn*13];
    mygrid.facesSize=[[nn nn*3];[nn nn*3];[nn nn];[nn*3 nn];[nn*3 nn];[nn nn]];
    mygrid.facesExpand=[];
elseif ~isempty(dir([mygrid.dirGrid 'grid.specs.mat']));
    specs=open([mygrid.dirGrid 'grid.specs.mat']);
    mygrid.ioSize=specs.ioSize;
    mygrid.facesSize=specs.facesSize;
    mygrid.facesExpand=specs.facesExpand;
    %example for creating grid.specs.mat, to put in dirGrid :
    %ioSize=[364500 1];
    %facesSize=[[270 450];[0 0];[270 270];[180 270];[450 270]];
    %facesExpand=[270 450];
    %save grid.specs.mat ioSize facesSize facesExpand;
elseif strcmp(mygrid.fileFormat,'compact');
    v0=rdmds([mygrid.dirGrid 'XC']);
    mygrid.ioSize=size(v0);
    nn=size(v0,1); pp=size(v0,2)/nn;
    mm=(pp+4-mygrid.nFaces)/4*nn;
    mygrid.facesSize=[[nn mm];[nn mm];[nn nn];[mm nn];[mm nn];[nn nn]];
    mygrid.facesExpand=[];
elseif strcmp(mygrid.fileFormat,'cube');
    v0=rdmds([mygrid.dirGrid 'XC']);
    mygrid.ioSize=size(v0);
    nn=size(v0,2);
    mygrid.facesSize=[[nn nn];[nn nn];[nn nn];[nn nn];[nn nn];[nn nn]];
    mygrid.facesExpand=[];
elseif strcmp(mygrid.fileFormat,'straight');
    v0=rdmds([mygrid.dirGrid 'XC']);
    mygrid.ioSize=size(v0);
    mygrid.facesSize=mygrid.ioSize;
    mygrid.facesExpand=[];
end;

mygrid.missVal=NaN;%will be set to 0 once the grid has been loaded.

if  ~(mygrid.nFaces==1&strcmp(mygrid.fileFormat,'straight'))&...
        ~(mygrid.nFaces==6&strcmp(mygrid.fileFormat,'cube'))&...
        ~(mygrid.nFaces==6&strcmp(mygrid.fileFormat,'compact'))&...
        ~(mygrid.nFaces==5&strcmp(mygrid.fileFormat,'compact'))&...
        ~(mygrid.nFaces==5&strcmp(mygrid.fileFormat,'nctiles'));
    error('non-supported grid topology');
end;

if strcmp(mygrid.fileFormat,'nctiles');
  %place holders (needed for read_nctiles)
  tmp1=NaN*zeros(nn,nn*3);
  tmp2=NaN*zeros(nn,nn);
  tmp3=NaN*zeros(nn*3,nn);
  mygrid.XC=gcmfaces({tmp1,tmp1,tmp2,tmp3,tmp3});
  mygrid.YC=gcmfaces({tmp1,tmp1,tmp2,tmp3,tmp3});
  mygrid.RC=NaN*zeros(50,1);
  clear tmp?;
end;

%the various grid fields:
if mygrid.memoryLimit==0;
    list0={'XC','XG','YC','YG','RAC','RAZ','DXC','DXG','DYC','DYG','hFacC','hFacS','hFacW','Depth'};
elseif mygrid.memoryLimit==1;
    list0={'XC','XG','YC','YG','RAC','RAZ','DXC','DXG','DYC','DYG','hFacC','Depth'};
elseif mygrid.memoryLimit==2;
    list0={'XC','YC'};
end;

for iFld=1:length(list0);
    if ~strcmp(mygrid.fileFormat,'nctiles');
      eval(['mygrid.' list0{iFld} '=rdmds2gcmfaces([mygrid.dirGrid ''' list0{iFld} '*'']);']);
    else;
      eval(['mygrid.' list0{iFld} '=read_nctiles([mygrid.dirGrid ''GRID''],''' list0{iFld} ''');']);
    end;
end;

%the vertical grid
list0={'RC','RF','DRC','DRF'};
for iFld=1:length(list0);
    if ~strcmp(mygrid.fileFormat,'nctiles');
      eval(['mygrid.' list0{iFld} '=squeeze(rdmds([mygrid.dirGrid ''' list0{iFld} '*'']));']);
    else;
      eval(['ncload ' mygrid.dirGrid 'GRID.0001.nc ' list0{iFld} ';']);
      eval(['mygrid.' list0{iFld} '=' list0{iFld} ''';']);
      if strcmp(list0{iFld},'RF'); mygrid.RF=[mygrid.RF;NaN]; end;
    end;
end;

%grid orientation
if mygrid.memoryLimit<2;
    list0={'AngleCS','AngleSN'};
    test0=~isempty(dir([mygrid.dirGrid 'AngleCS*']));
    if strcmp(mygrid.fileFormat,'nctiles');
        for iFld=1:length(list0);
            eval(['mygrid.' list0{iFld} '=read_nctiles([mygrid.dirGrid ''GRID''],''' list0{iFld} ''');']);
        end;
    elseif test0;
        for iFld=1:length(list0);
            eval(['mygrid.' list0{iFld} '=rdmds2gcmfaces([mygrid.dirGrid ''' list0{iFld} '*'']);']);
        end;
    else;
        warning('\n AngleCS/AngleSN not found; set to 1/0 assuming lat/lon grid.\n');
        mygrid.AngleCS=mygrid.XC; mygrid.AngleCS(:)=1;
        mygrid.AngleSN=mygrid.XC; mygrid.AngleSN(:)=0;
    end;
end;

%if the native grid is found then re-load (to benefit from double precision & avoid blank tile issues)
files=dir([mygrid.dirGrid 'grid_cs32*bin']);
if isempty(files); files=dir([mygrid.dirGrid 'tile*.mitgrid']); end;
%logic above needs fixing since I think blank tiles show 0 rather than NaN on some machines
if (length(files)==mygrid.nFaces)&~omitNativeGrid;
  grid_load_native;
  %replace NaNs with 0s if needed (blank tile only issue)
  list0={'hFacC','hFacS','hFacW','Depth','AngleCS','AngleSN'};
  for ii=1:length(list0); 
      if isfield(mygrid,list0{ii});
          eval(['tmp1=mygrid.' list0{ii} ';']);
          tmp1(isnan(tmp1))=0;
          eval(['mygrid.' list0{ii} '=tmp1;']);
      end;
  end;
  %reset angles if needed (blank tile only issue)
  tmp1=mygrid.AngleCS.^2+mygrid.AngleSN.^2;
  tmp1=1*(tmp1>0.999&tmp1<1.001);
  mygrid.AngleCS(tmp1==0)=1;
  mygrid.AngleSN(tmp1==0)=0;
end;

%get full RAZ (incl. 'extra line and column') needed for e.g. rotational computations
if mygrid.memoryLimit<2&~omitNativeGrid;
    grid_load_native_RAZ;
end;

%grid masks
if mygrid.memoryLimit<1;
    mygrid.hFacCsurf=mygrid.hFacC;
    for ff=1:mygrid.hFacC.nFaces; mygrid.hFacCsurf{ff}=mygrid.hFacC{ff}(:,:,1); end;
    
    mskC=mygrid.hFacC; mskC(mskC==0)=NaN; mskC(mskC>0)=1; mygrid.mskC=mskC;
    mskW=mygrid.hFacW; mskW(mskW==0)=NaN; mskW(mskW>0)=1; mygrid.mskW=mskW;
    mskS=mygrid.hFacS; mskS(mskS==0)=NaN; mskS(mskS>0)=1; mygrid.mskS=mskS;
end;

%zonal mean and sections needed for transport computations
% if mygrid.memoryLimit<1;
%     if ~isfield(mygrid,'mygrid.LATS_MASKS');
%         gcmfaces_lines_zonal;
%         mygrid.LATS=[mygrid.LATS_MASKS.lat]';
%     end;
%     if ~isfield(mygrid,'LINES_MASKS');
%         [lonPairs,latPairs,names]=gcmfaces_lines_pairs;
%         gcmfaces_lines_transp(lonPairs,latPairs,names);
%     end;
% end;

%to allow convert2gcmfaces/doFast:
if isempty(mygrid.facesExpand)&mygrid.memoryLimit<2;
    tmp1=convert2gcmfaces(mygrid.XC);
    tmp1(:)=[1:length(tmp1(:))];
    nn=length(tmp1(:));
    mygrid.gcm2faces=convert2gcmfaces(tmp1);
    mygrid.faces2gcmSize=size(tmp1);
    mygrid.faces2gcm=convert2gcmfaces(tmp1);
    for iFace=1:mygrid.nFaces;
        n=length(mygrid.gcm2faces{iFace}(:));
        mygrid.faces2gcm{iFace}=mygrid.gcm2faces{iFace}(:);
        mygrid.gcm2faces{iFace}=sparse([1:n],mygrid.gcm2faces{iFace}(:),ones(1,n),n,nn);
    end;
    mygrid.gcm2facesFast=true;
end;

%reset missVal parameter to 0. 
%Note : this is only used by convert2widefaces, for runs with cropped grids.
%Note : 0 should not be used as a fill for the grid itself (NaN was used).
mygrid.missVal=0;

1	gforget	1.13	function []=grid_load(dirGrid,nFaces,fileFormat,memoryLimit,omitNativeGrid);
2	gforget	1.5	%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	gforget	1.9	%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	gforget	1.13	% 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	gforget	1.1
15	gforget	1.9	if isempty(whos('memoryLimit')); memoryLimit=0; end;
16	gforget	1.13	if isempty(whos('omitNativeGrid')); omitNativeGrid=0; end;
17	gforget	1.9
18	gforget	1.7	gcmfaces_global; mygrid=[];
19
20	gforget	1.15	if nargin==0;%assume that LLC90 grid is used
21			if ~isempty(dir('nctiles_grid'));
22	gforget	1.18	mygrid.dirGrid=['nctiles_grid' filesep];
23	gforget	1.15	mygrid.fileFormat='nctiles';
24			elseif ~isempty(dir('GRID'));
25	gforget	1.18	mygrid.dirGrid=['GRID' filesep];
26	gforget	1.15	mygrid.fileFormat='compact';
27	gforget	1.21	elseif ~isempty(dir(['./XC.meta']));
28			mygrid.dirGrid=['.' filesep];
29			mygrid.fileFormat='compact';
30	gforget	1.15	else;
31	gforget	1.20	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	gforget	1.16	'version_4/release1/nctiles_grid \n']);
35	gforget	1.20	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	gforget	1.15	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	gforget	1.9
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	gforget	1.15	if strcmp(mygrid.fileFormat,'nctiles');
68	zhc	1.25	i2=ncread([mygrid.dirGrid 'GRID.0001.nc'],'i2');
69			nn=length(i2);
70			mygrid.ioSize=[nn nn*13];
71			mygrid.facesSize=[[nn nn3];[nn nn3];[nn nn];[nn3 nn];[nn3 nn];[nn nn]];
72	gforget	1.15	mygrid.facesExpand=[];
73			elseif ~isempty(dir([mygrid.dirGrid 'grid.specs.mat']));
74			specs=open([mygrid.dirGrid 'grid.specs.mat']);
75	gforget	1.9	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	gforget	1.15	elseif strcmp(mygrid.fileFormat,'compact');
84			v0=rdmds([mygrid.dirGrid 'XC']);
85	gforget	1.9	mygrid.ioSize=size(v0);
86			nn=size(v0,1); pp=size(v0,2)/nn;
87			mm=(pp+4-mygrid.nFaces)/4*nn;
88	gforget	1.10	mygrid.facesSize=[[nn mm];[nn mm];[nn nn];[mm nn];[mm nn];[nn nn]];
89			mygrid.facesExpand=[];
90	gforget	1.15	elseif strcmp(mygrid.fileFormat,'cube');
91			v0=rdmds([mygrid.dirGrid 'XC']);
92	gforget	1.10	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	gforget	1.15	elseif strcmp(mygrid.fileFormat,'straight');
97			v0=rdmds([mygrid.dirGrid 'XC']);
98	gforget	1.10	mygrid.ioSize=size(v0);
99			mygrid.facesSize=mygrid.ioSize;
100	gforget	1.9	mygrid.facesExpand=[];
101			end;
102	gforget	1.15
103	gforget	1.12	mygrid.missVal=NaN;%will be set to 0 once the grid has been loaded.
104	gforget	1.1
105	gforget	1.15	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	gforget	1.1	end;
112
113	gforget	1.17	if strcmp(mygrid.fileFormat,'nctiles');
114			%place holders (needed for read_nctiles)
115	zhc	1.25	tmp1=NaNzeros(nn,nn3);
116			tmp2=NaN*zeros(nn,nn);
117			tmp3=NaNzeros(nn3,nn);
118	gforget	1.17	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	gforget	1.6	%the various grid fields:
125	gforget	1.9	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	gforget	1.1	for iFld=1:length(list0);
134	gforget	1.15	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	gforget	1.1	end;
140
141	gforget	1.9	%the vertical grid
142			list0={'RC','RF','DRC','DRF'};
143			for iFld=1:length(list0);
144	gforget	1.15	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	gforget	1.9	end;
152
153			%grid orientation
154			if mygrid.memoryLimit<2;
155			list0={'AngleCS','AngleSN'};
156	gforget	1.15	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	gforget	1.9	for iFld=1:length(list0);
163	gforget	1.15	eval(['mygrid.' list0{iFld} '=rdmds2gcmfaces([mygrid.dirGrid ''' list0{iFld} '*'']);']);
164	gforget	1.9	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	gforget	1.8	end;
170	gforget	1.4	end;
171
172	gforget	1.21	%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	gforget	1.12	list0={'hFacC','hFacS','hFacW','Depth','AngleCS','AngleSN'};
180			for ii=1:length(list0);
181	gforget	1.24	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	gforget	1.12	end;
187	gforget	1.21	%reset angles if needed (blank tile only issue)
188	gforget	1.12	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	gforget	1.11	%get full RAZ (incl. 'extra line and column') needed for e.g. rotational computations
195	gforget	1.13	if mygrid.memoryLimit<2&~omitNativeGrid;
196	gforget	1.11	grid_load_native_RAZ;
197			end;
198
199	gforget	1.9	%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	gforget	1.1	end;
208
209	gforget	1.9	%zonal mean and sections needed for transport computations
210	gforget	1.22	% 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	gforget	1.2
221	gforget	1.8	%to allow convert2gcmfaces/doFast:
222	gforget	1.9	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	gforget	1.6	end;
236
237	gforget	1.12	%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	gforget	1.1