Changeset 530

Timestamp:

Aug 27, 2012, 4:38:41 PM (12 years ago)

Author:

sommeria

Message:

new conventions for find_field_cells .

Location:

trunk/src

Files:

• calc_tps.m (modified) (2 diffs)
• check_field_structure.m (deleted)
• check_files.m (modified) (1 diff)
• displ_uvmat.m (modified) (1 diff)
• find_field_cells.m (modified) (3 diffs)
• get_field.m (modified) (4 diffs)
• mouse_motion.m (modified) (5 diffs)
• plot_field.m (modified) (18 diffs)
• proj_field.m (modified) (31 diffs)
• read_civxdata.m (modified) (1 diff)
• struct2nc.m (modified) (1 diff)
• uvmat.m (modified) (11 diffs)

trunk/src/calc_tps.m

@@ -5 +5 @@
     SubDomain=DataIn.SubDomain;%
 end
-[CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(DataIn);
+%[CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(DataIn);
+[CellInfo,NbDimArray,errormsg]=find_field_cells(DataIn);
 nbtps=0;
-for icell=1:numel(CellVarIndex);
-    VarType=VarTypeCell{icell};
-    if NbDimVec(icell)>=2 && ~isempty(VarType.coord_x)
+for icell=1:numel(CellInfo);
+    %VarType=VarTypeCell{icell};
+    if NbDimArray(icell)>=2 && strcmp(CellInfo{icell}.CoordType,'scattered')%'&& ~isempty(VarType.coord_x)
         nbtps=nbtps+1;
-        X=DataIn.(DataIn.ListVarName{VarType.coord_x});
-        Y=DataIn.(DataIn.ListVarName{VarType.coord_y});
-        if ~isempty(VarType.vector_x)&&~isempty(VarType.vector_y)
-            Attr=DataIn.VarAttribute{VarType.vector_x};
+        X=DataIn.(DataIn.ListVarName{CellInfo{icell}.CoordIndex(end)});
+        Y=DataIn.(DataIn.ListVarName{CellInfo{icell}.CoordIndex(end-1)});
+        if isfield(CellInfo{icell},'VarIndex_vector_x')&&isfield(CellInfo{icell},'VarIndex_vector_y')
+            Attr=DataIn.VarAttribute{CellInfo{icell}.VarIndex_vector_x};
             if ~isfield(Attr,'VarIndex_tps')&& (checkall || (isfield(Attr,'FieldRequest')&&strcmp(Attr.FieldRequest,'interp_tps')))               
-                U=DataIn.(DataIn.ListVarName{VarType.vector_x});
-                V=DataIn.(DataIn.ListVarName{VarType.vector_y});
+                U=DataIn.(DataIn.ListVarName{CellInfo{icell}.VarIndex_vector_x});
+                V=DataIn.(DataIn.ListVarName{CellInfo{icell}.VarIndex_vector_y});
             else
                 continue
             end
         end
-        if ~isempty(VarType.errorflag)
-            FF=DataIn.(DataIn.ListVarName{VarType.errorflag});
+        if isfield(CellInfo{icell},'VarIndex_errorflag')
+            FF=DataIn.(DataIn.ListVarName{CellInfo{icell}.VarIndex_errorflag});
             X=X(FF==0);
             Y=Y(FF==0);
@@ -47 +48 @@
         
         DataOut.VarAttribute{nbvar+3}.Role='coord_tps';
-        DataOut.VarAttribute{nbvar+4}=DataIn.VarAttribute{VarType.vector_x};%reproduce attributes of velocity
+        DataOut.VarAttribute{nbvar+4}=DataIn.VarAttribute{CellInfo{icell}.VarIndex_vector_x};%reproduce attributes of velocity
          DataOut.VarAttribute{nbvar+4}.Role='vector_x_tps';
-         DataIn.VarAttribute{VarType.vector_x}.VarIndex_tps=nbvar+4;% indicte the correspondance with initial data
-        DataOut.VarAttribute{nbvar+5}=DataIn.VarAttribute{VarType.vector_y};%reproduce attributes of velocity 
+         DataIn.VarAttribute{CellInfo{icell}.VarIndex_vector_x}.VarIndex_tps=nbvar+4;% indicte the correspondance with initial data
+        DataOut.VarAttribute{nbvar+5}=DataIn.VarAttribute{CellInfo{icell}.VarIndex_vector_y};%reproduce attributes of velocity 
          DataOut.VarAttribute{nbvar+5}.Role='vector_y_tps';
         if isfield(DataOut,'ListDimName')%cleaning'

trunk/src/check_files.m

@@ -35 +35 @@
     'calc_field_tps';...% defines fields (velocity, vort, div...) and calculate them
     'cell2tab';... %transform a Matlab cell in a character array suitable for display in a table
-    'check_field_structure';...% check the validity of the field struture representation consistant with the netcdf format
     'check_files';...
     'civ';...   %function associated with the interface 'civ.fig' for PIV and spline interpolation

trunk/src/displ_uvmat.m

@@ +1 @@
+%'displ_uvmat': display a message using  msgbox_uvmat or on the log file in batch mode
+%--------------------------------------------------------------------------
+%  function displ_uvmat(title,display_str,Position)
+%
 function displ_uvmat(title,display_str,Position)
 if isequal(Position,0)

trunk/src/find_field_cells.m

@@ -2 +2 @@
 %    group the variables  into 'fields' with common dimensions
 %------------------------------------------------------------------------
-% function  [CellVarIndex,NbDim,CellVarType,errormsg]=find_field_cells(Data)
+% function  [CellInfo,NbDim,errormsg]=find_field_cells(Data)
 %
 % OUTPUT:
-% CellVaxIndex: cell whose elements are arrays of indices in the list data.ListVarName  
-%              CellvarIndex{i} represents a set of variables with the same dimensions
-% NbDim: array with the length of CellVarIndex, giving its  space dimension
-% CellVarType: cell array of structures with fields
-%      .coord_x, y, z: indices (in .ListVarname) of variables representing  unstructured coordinates x, y, z 
-%      .vector_x,_y,_z: indices of variables giving the vector components x, y, z
-%      .warnflag: index of warnflag
-%      .errorflag: index of error flag
-%      .ancillary: indices of ancillary variables
-%      .image   : B/W image, (behaves like scalar)
-%      .color : color image, the last index, which is not a coordinate variable, represent the 3 color components rgb
-%      .discrete: like scalar, but set of data points without continuity, represented as dots in a usual plot, instead of continuous lines otherwise
-%      .scalar: scalar field (default)
-%      .coord: vector of indices of coordinate variables corresponding to matrix dimensions
-%
+% CellInfo: cell of structures describing field cells
+%     .CoordType:  type of coordinates for each field cell = 'scattered','grid','tps';
+%     .CoordIndex: array of the indices of the variables representing the coordinates (in the order z,y,x)
+%     .CoordSize: array of the nbre of values for each  coordinate in a grid, nbre of points in the unstructured case
+%     .NbSite_tps:
+%     .SubRange_tps
+%     .VarIndex: arrays of the variable indices in the field cell
+%     .VarIndex_ancillary: indices of ancillary variables
+%              _color : color image, the last index, which is not a coordinate variable, represent the 3 color components rgb
+%              _discrete: like scalar, but set of data points without continuity, represented as dots in a usual plot, instead of continuous lines otherwise
+%              _errorflag: index of error flag
+%              _image   : B/W image, (behaves like scalar)
+%              _vector_x,_y,_z: indices of variables giving the vector components x, y, z
+%              _warnflag: index of warnflag    
 %      .FieldRequest= 'interp_lin', 'interp_tps' indicate whether lin interpolation  or derivatives (tps) is needed to calculate the requested field
-%      .FieldNames = cell of fields to calculate from the fied cell
-%
+%      .Operation = operation to be performed to finalise the field cell after projection
+%      .SubCheck=0 /1 indicate that the field must be substracted (second  entry in uvmat)
+% NbDim: array with the length of CellVarIndex, giving the space dimension of each field cell
 % errormsg: error message
 %   
@@ -54 +54 @@
 %    group the variables  into 'fields' with common dimensions
 
-function [CellVarIndex,NbDim,CellVarType,errormsg]=find_field_cells(Data)
-CellVarIndex={};
-
-CellVarType=[];
+function [CellInfo,NbDim,errormsg]=find_field_cells(Data)
+% CellVarIndex={};
+% CellInfo={}
+NbDim=0;
+% CellVarType=[];
 errormsg=[];
+if ~isfield(Data,'ListVarName'), errormsg='the list of variables .ListVarName is missing';return;end
+if ~isfield(Data,'VarDimName'), errormsg='the list of dimensions .VarDimName is missing';return;end
 nbvar=numel(Data.ListVarName);%number of field variables
+if ~isequal(numel(Data.VarDimName),nbvar), errormsg='.ListVarName and .VarDimName have unequal length';return;end
+if isfield(Data,'ListDimName')&& isfield(Data,'DimValue')&&isequal(numel(Data.ListDimName),numel(Data.DimValue))
+    check_dim=1;% dimensions of data defined, data not needed for this function
+else
+    check_dim=0;
+    for ilist=1:numel(Data.ListVarName)
+        if ~isfield(Data,Data.ListVarName{ilist})
+            errormsg=['missing variable ' Data.ListVarName{ilist}];
+            return
+        end
+    end
+end
 icell=0;
 
-NbDim=[];
-VarDimIndex=[];
-VarDimName={};
-if ~isfield(Data,'VarDimName')
-    errormsg='missing .VarDimName';
-    return
-end
+% NbDim=[];
+% VarDimIndex=[];
+% VarDimName={};
 
 %% role of variables and list of requested operations
+%ListRole={'coord_x','coord_y','coord_z','vector_x','vector_y','vector_z','vector_x_tps','vector_y_tps','warnflag','errorflag',...
+%   'ancillary','image','color','discrete','scalar','coord_tps'};% rmq vector_x_tps and vector_y_tps to be replaced by vector_x and vector_y
 Role=num2cell(blanks(nbvar));%initialize a cell array of nbvar blanks
 FieldRequest=regexprep(Role,' ',''); % fieldRequest set to '' by default
@@ -93 +106 @@
 end
 
-%% loop on the list of variables, group them by common dimensions
-CellVarType=cell(1,length(CellVarIndex));
-for ivar=1:nbvar
-    if ischar(Data.VarDimName{ivar})
-        Data.VarDimName{ivar}=Data.VarDimName(ivar);%transform char chain into cell
-    end
-    DimCell=Data.VarDimName{ivar}; %dimensions associated with the variable #ivar
-    testnewcell=1;
-    for icell_prev=1:numel(CellVarIndex)%detect whether the dimensions of ivar fit with an existing cell
-        PrevVarIndex=CellVarIndex{icell_prev};%list of variable indices in cell # icell_prev
-        PrevDimCell=Data.VarDimName{PrevVarIndex(1)};%list of corresponding variable names
-        if isequal(PrevDimCell,DimCell)
-            CellVarIndex{icell_prev}=[CellVarIndex{icell_prev} ivar];% add variable index #ivar to the cell #icell_prev
-            testnewcell=0; %existing cell detected
-            break
-        end
-    end
-    if testnewcell
-        icell=icell+1;
-        CellVarIndex{icell}=ivar;%put the current variable index in the new cell 
-        NbDim(icell)=numel(DimCell);%default   
-        CellVarType{icell}=[];
-    end
-    if ~isempty(FieldRequest{ivar})
-       CellVarType{icell}.FieldRequest=FieldRequest{ivar};
-    end
-    if ~isempty(Operation{ivar})
-       CellVarType{icell}.Operation=Operation{ivar};
-    end
-    if CheckSub(ivar)
-    CellVarType{icell}.CheckSub=1;
-    end
-end
-
-%% find dimension variables
-checksinglecell=cellfun(@numel,CellVarIndex)==1 & NbDim==1;% find isolated cells with a single dimension
-ind_dim_var_cell=find(checksinglecell);
-%CoordType(ind_dim_var_cell)='dim_var';% to be used in output
-%VarDimIndex=cell(size(ind_dim_var_cell));
-VarDimName=cell(size(ind_dim_var_cell));
-for icoord=1:numel(ind_dim_var_cell)
-    VarDimIndex(icoord)=CellVarIndex{ind_dim_var_cell(icoord)};
-    VarDimName{icoord}=Data.VarDimName{VarDimIndex(icoord)}{1};
-end
-
-%% find the spatial dimensions and vector components 
-ListRole={'coord_x','coord_y','coord_z','vector_x','vector_y','vector_z','vector_x_tps','vector_y_tps','warnflag','errorflag',...
-    'ancillary','image','color','discrete','scalar','coord_tps'};% rmq vector_x_tps and vector_y_tps to be replaced by vector_x and vector_y
-
-for ilist=1:numel(ListRole)
-    VarType.(ListRole{ilist})=find(strcmp(ListRole{ilist},Role));
-end
-%look for tps coordinates
-if ~isempty(VarType.coord_tps)
-    VarType.subrange_tps=[];
-    VarType.nbsites_tps=[];
-    select=zeros(1,numel(VarType.coord_tps));
-    for ifield=1:numel(VarType.coord_tps)
-        DimCell=Data.VarDimName{VarType.coord_tps(ifield)};
-        if numel(DimCell)==3
-            for ivardim=1:numel(Data.VarDimName)
-                if strcmp(Data.VarDimName{ivardim},DimCell{3})
-                    VarType.nbsites_tps=[VarType.nbsites_tps ivardim];
-                    select(ifield)=select(ifield)+1;
-                elseif strcmp(Data.VarDimName{ivardim}{1},DimCell{2}) && strcmp(Data.VarDimName{ivardim}{3},DimCell{3})
-                    VarType.subrange_tps=[VarType.subrange_tps ivardim];
-                    select(ifield)=select(ifield)+1;
+%% find scattered (unstructured) coordinates
+ivar_coord_x=find(strcmp('coord_x',Role));
+% VarDimCell=cell(numel(ivar_coord_x));
+check_select=zeros(1,nbvar);
+CellInfo=cell(1,numel(ivar_coord_x));
+NbDim=zeros(1,numel(ivar_coord_x));
+for icell=1:numel(ivar_coord_x)
+    DimCell=Data.VarDimName{ivar_coord_x(icell)};
+    if ischar(DimCell),DimCell={DimCell};end
+    check_cell=zeros(numel(DimCell),nbvar);
+    for idim=1:numel(DimCell)
+        for ivar=1:nbvar
+            check_cell(idim,ivar)=max(strcmp(DimCell{idim},Data.VarDimName{ivar}));
+        end
+    end
+    check_cell=sum(check_cell,1)==numel(DimCell);%logical array=1 for variables belonging to the current cell
+    VarIndex=find(check_cell);
+    if ~(numel(VarIndex)==1 && numel(DimCell)==1)% exclude case of isolated coord_x variable (treated later)
+        if ~(numel(VarIndex)==1 && numel(DimCell)>1)% a variable is associated to coordinate
+            CellInfo{icell}.CoordIndex=ivar_coord_x(icell);
+            % size of coordinate var
+            if check_dim
+                for idim=1:numel(DimCell)
+                 check_index= strcmp(DimCell{idim},Data.ListDimName);
+                 CellInfo{icell}.CoordSize(idim)=Data.DimValue(check_index);
+                end
+                CellInfo{icell}.CoordSize=prod(CellInfo{icell}.CoordSize);
+            else
+                CellInfo{icell}.CoordSize=numel(Data.(Data.ListVarName{ivar_coord_x(icell)}));
+            end
+            ind_y=find(strcmp('coord_y',Role(VarIndex)));
+            if numel(VarIndex)==2||isempty(ind_y)% no variable, except possibly y
+                NbDim(icell)=1;
+            else
+                CellInfo{icell}.CoordType='scattered';
+                ind_z=find(strcmp('coord_z',Role(VarIndex)));
+                if numel(VarIndex)==3||isempty(ind_z)% no z variable, except possibly as a fct z(x,y)
+                    CellInfo{icell}.CoordIndex=[VarIndex(ind_y) CellInfo{icell}.CoordIndex];
+                    NbDim(icell)=2;
+                else
+                    CellInfo{icell}.CoordIndex=[VarIndex(ind_z) CellInfo{icell}.CoordIndex];
+                    NbDim(icell)=3;
                 end
             end
         end
-    end
-    VarType.coord_tps=VarType.coord_tps(select==2);
-    VarType.subrange_tps=VarType.subrange_tps(select==2);
-    VarType.nbsites_tps=VarType.nbsites_tps(select==2);
-end
-
-index_remove=[];
-for icell=1:length(CellVarIndex)
-    if checksinglecell(icell)
-        continue
-    end
-    VarIndex=CellVarIndex{icell};%set of variable indices with the same dim
-    check_remove=0;
-    for ifield=1:numel(VarType.coord_tps)
-        if isequal(VarIndex,VarType.coord_tps(ifield))||isequal(VarIndex,VarType.subrange_tps(ifield))||isequal(VarIndex,VarType.nbsites_tps(ifield))
-            index_remove=[index_remove icell];% removes Coord_tps as field cell
-            check_remove=1;
-        end
-    end
-    
-    if ~check_remove
-        for ilist=1:numel(ListRole)
-            CellVarType{icell}.(ListRole{ilist})=VarIndex(find(strcmp(ListRole{ilist},Role(VarIndex))));
-        end
-        DimCell=Data.VarDimName{VarIndex(1)};% list of dimensions for each variable in the cell #icell
-        if numel(CellVarType{icell}.coord_x)>1 || numel(CellVarType{icell}.coord_y)>1 || numel(CellVarType{icell}.coord_z)>1
-            errormsg='multiply defined coordinates  in the same cell';
-            return
-        end
-        % case of x cordinate marked as a dimension variable (var name=dimension name)
-        if isempty(CellVarType{icell}.coord_x)
-            var_dim_index=find(strcmp(DimCell{1},Data.ListVarName(VarIndex)));
-            if ~isempty(var_dim_index)
-                CellVarType{icell}.coord_x=VarIndex(var_dim_index);
+        CellInfo{icell}.VarIndex=VarIndex;
+        check_select=check_select|check_cell;
+    end
+end
+
+%% look for tps coordinates
+ivar_remain=find(~check_select);
+check_coord_tps= strcmp('coord_tps',Role(~check_select));
+ivar_tps=ivar_remain(check_coord_tps);
+for icell_tps=1:numel(ivar_tps)
+    DimCell=Data.VarDimName{ivar_tps(icell_tps)};
+    icell=numel(CellInfo)+icell_tps;
+    CellInfo{icell}.CoordIndex=ivar_tps(icell);
+    CellInfo{icell}.VarIndex_subrange_tps=[];
+    CellInfo{icell}.VarIndex_nbsites_tps=[];
+    if numel(DimCell)==3
+        VarDimName=Data.VarDimName(~check_select);
+        for ivardim=1:numel(VarDimName)
+            if strcmp(VarDimName{ivardim},DimCell{3})
+                CellInfo{icell}.NbSite_tps= ivar_remain(ivardim);
+                check_cell(ivar_remain(ivardim))=1;% nbre of sites for each tps subdomain
+            elseif strcmp(VarDimName{ivardim}{1},DimCell{2}) && strcmp(VarDimName{ivardim}{3},DimCell{3})
+                CellInfo{icell}.SubRange_tps=ivar_remain(ivardim);
+                check_cell(ivar_remain(ivardim))=1;% subrange definiton for tps
+            elseif strcmp(VarDimName{ivardim}{1},DimCell{1}) && strcmp(VarDimName{ivardim}{2},DimCell{3})
+                check_cell(ivar_remain(ivardim))=1;% variable
             end
-        end         
-        if numel(CellVarType{icell}.errorflag)>1
-            errormsg='multiply defined error flag in the same cell';
-            return
-        end
-        if numel(CellVarType{icell}.warnflag)>1
-            errormsg='multiply defined warning flag in the same cell';
-            return
-        end
-        test_coord=0;
-        % look for unstructured coordinates
-        if numel(VarIndex)>1
-            if ~isempty(CellVarType{icell}.coord_z)
-                NbDim(icell)=3;
-                test_coord=1;
-            elseif ~isempty(CellVarType{icell}.coord_y)
-                NbDim(icell)=2;
-                test_coord=1;
-            elseif ~isempty(CellVarType{icell}.coord_x)
-                NbDim(icell)=1;
-                test_coord=1;
-            elseif numel(DimCell)==1
-                NbDim(icell)=0;% set of data without coordinates
-            end
-        end
-        % look for coordinates variables
-        coord=zeros(1,numel(DimCell));%default
-        if  ~test_coord && ~isempty(VarDimName)
-            for idim=1:numel(DimCell)   %loop on the dimensions of the variables in cell #icell
-                ind_coord=find(strcmp(DimCell{idim},VarDimName));
-                if ~isempty(ind_coord)
-                    coord(idim)=VarDimIndex(ind_coord);
-                end
-            end
-            NbDim(icell)=numel(find(coord));
-        end
-        CellVarType{icell}.coord=coord;
-        %look for tps data
-        if ~isempty(VarType.coord_tps)
-            for ilist=1:numel(VarType.coord_tps)
-            tps_dimnames=Data.VarDimName{VarType.coord_tps(ilist)};
-            if length(tps_dimnames)==3 && strcmp(tps_dimnames{1},DimCell{1}) && strcmp(tps_dimnames{3},DimCell{2})
-                CellVarIndex{icell}=[CellVarIndex{icell} VarType.coord_tps(ilist) VarType.nbsites_tps(ilist) VarType.subrange_tps(ilist)];
-                CellVarType{icell}.coord_tps=VarType.coord_tps(ilist);
-                CellVarType{icell}.nbsites_tps=VarType.nbsites_tps(ilist);
-                CellVarType{icell}.subrange_tps=VarType.subrange_tps(ilist);
-                if isfield(Data,'ListDimName')
-                    dim_index=find(strcmp(tps_dimnames{2},Data.ListDimName));
-                    NbDim(icell)=Data.DimValue(dim_index);
-                else
-                NbDim(icell)=size(Data.(Data.ListVarName{VarType.coord_tps(ilist)}),2);
-                end
-            end
-            end
-        end
-    end
-end
-if ~isempty(index_remove)
-    CellVarIndex(index_remove)=[];
-    CellVarType(index_remove)=[];
-    NbDim(index_remove)=[];
-end
+        end
+    end
+    CellInfo{icell}.CoordType='tps';
+    CellInfo{icell}.VarIndex=find(check_cell);
+    if check_dim
+        check_index_1= strcmp(DimCell{1},Data.ListDimName);
+        check_index_2= strcmp(DimCell{2},Data.ListDimName);
+        check_index_3= strcmp(DimCell{3},Data.ListDimName);
+        NbDim(icell)=Data.DimValue(check_index_2);
+        CellInfo{icell}.CoordSize=Data.DimValue(check_index_1)*Data.DimValue(check_index_3);
+    else
+        NbDim(icell)=size(Data.(Data.ListVarName{CellInfo{icell}.CoordIndex}),2);
+        CellInfo{icell}.CoordSize=size(Data.(Data.ListVarName{CellInfo{icell}.CoordIndex}),1)*size(Data.(Data.ListVarName{CellInfo{icell}.CoordIndex}),3);
+    end
+    check_select=check_select|check_cell;
+end
+
+%% look for dimension variables and corresponding gridded data
+ivar_remain=find(~check_select);
+VarDimName=Data.VarDimName(~check_select);%dimensions of remaining variables
+check_coord= cellfun(@numel,VarDimName)==1|cellfun(@ischar,VarDimName)==1;% find variables with a single dimension
+ListCoordIndex=ivar_remain(check_coord);
+ListCoordName=Data.ListVarName(ListCoordIndex);
+ListDimName=Data.VarDimName(ListCoordIndex);
+%remove redondant values
+check_keep=logical(ones(size(ListDimName)));
+for idim=1:numel(ListDimName)
+    prev_ind=strcmp(ListDimName{idim},ListDimName(1:idim-1));
+    if ~isempty(prev_ind)
+        if strcmp(ListCoordName{idim},ListDimName{idim}) %coordinate variable
+            check_keep(prev_ind)=0;
+        else
+           check_keep(idim)=0; 
+        end
+    end
+end
+ListCoordIndex=ListCoordIndex(check_keep);
+ListCoordName=ListCoordName(check_keep);
+ListDimName=ListDimName(check_keep);
+
+CoordSize=[];
+for ilist=1:numel(ListCoordIndex)
+    if iscell(ListDimName{ilist})
+        ListDimName(ilist)=ListDimName{ilist};%transform cell to string
+    end
+    if check_dim% if the list of dimensions is directly defined
+        check_index= strcmp(ListDimName{ilist},Data.ListDimName);
+        DimValue=Data.DimValue(check_index);
+    else
+        DimValue=numel(Data.(ListCoordName{ilist}));
+    end
+    if DimValue==2% case of uniform grid coordinate defined by lower and upper bounds only
+        ListDimName{ilist}=ListCoordName{ilist};% look for dimensions with name equal to coordinate for
+        if check_dim
+            check_index= strcmp(ListCoordName{ilist},Data.ListDimName);
+            CoordSize(ilist)=Data.DimValue(check_index);
+        else
+            CoordSize(ilist)=numel(Data.(ListCoordName{ilist}));
+        end
+    else
+        CoordSize(ilist)=DimValue;
+    end
+end
+NewCellInfo={};
+NewCellDimIndex={};
+NewNbDim=[];
+for ivardim=1:numel(VarDimName) % loop on the list of remaining variables
+    DimCell=VarDimName{ivardim};% dimension names of the current variable
+    if ischar(DimCell), DimCell={DimCell}; end %transform char to cell if needed
+    DimIndices=[];
+    for idim=1:numel(DimCell)
+        ind_dim=find(strcmp(DimCell{idim},ListDimName));%find the dim index in the list of coord dimensions
+        if ~isempty(ind_dim)
+            DimIndices=[DimIndices ind_dim]; %update the list of coord dimensions included in DimCell
+        end
+    end
+    check_previous=0;
+    for iprev=1:numel(NewCellInfo)
+        if isequal(DimIndices,NewCellDimIndex{iprev})
+            check_previous=1;
+            NewCellInfo{iprev}.VarIndex=[NewCellInfo{iprev}.VarIndex ivar_remain(ivardim)];%append the current variable index to the found field cell
+            break
+        end
+    end
+    if ~check_previous
+        nbcell=numel(NewCellInfo)+1;
+        NewCellDimIndex{nbcell}=DimIndices;
+        NewCellInfo{nbcell}.VarIndex=ivar_remain(ivardim);% create a new field cell with the current variable index
+        NewNbDim(nbcell)=numel(DimIndices);
+        NewCellInfo{nbcell}.CoordType='grid';
+        NewCellInfo{nbcell}.CoordSize=CoordSize;
+        NewCellInfo{nbcell}.CoordIndex=ListCoordIndex(DimIndices);
+    end
+end
+NbDim=[NbDim NewNbDim];
+CellInfo=[CellInfo NewCellInfo];
+
+%% suppress empty cells
+check_empty=cellfun(@isempty,CellInfo);
+%check_empty=cellfun(@isempty,CellVarIndex);
+CellInfo(check_empty)=[];
+
+% CellVarIndex(check_empty)=[];
+NbDim(check_empty)=[];
+% CoordType(check_empty)=[];
+% VarRole(check_empty)=[];
+
+%% document roles of non-coordinate variables
+% ListRole={'vector_x','vector_y','vector_z','vector_x_tps','vector_y_tps','warnflag','errorflag',...
+%    'ancillary','image','color','discrete','scalar'};% except coord,coord_x,_y,_z,Coord_tps already taken, into account
+for icell=1:numel(CellInfo)
+    VarIndex=CellInfo{icell}.VarIndex;
+    for ivar=VarIndex
+        if isfield(CellInfo{icell},['VarIndex_' Role{ivar}])
+            CellInfo{icell}.(['VarIndex_' Role{ivar}])=[CellInfo{icell}.(['VarIndex_' Role{ivar}]) ivar];
+        else
+            CellInfo{icell}.(['VarIndex_' Role{ivar}])= ivar;
+        end
+        if ~isempty(FieldRequest{ivar})
+            CellInfo{icell}.FieldRequest=FieldRequest{ivar};
+        end
+        if ~isempty(Operation{ivar})
+            CellInfo{icell}.Operation=Operation{ivar};
+        end
+        if CheckSub(ivar)==1
+            CellInfo{icell}.CheckSub=1;
+        end
+    end
+end

trunk/src/get_field.m

@@ -218 +218 @@
 
 set(handles.scalar,'String', Txt )
-[CellVarIndex,NbDim,VarType,errormsg]=find_field_cells(Field);
+[CellInfo,NbDim,errormsg]=find_field_cells(Field);
+% [CellVarIndex,NbDim,CoordType,VarRole,errormsg]=find_field_cells(Field);
 if ~isempty(errormsg)  
-    msgbox_uvmat('ERROR',['error in get_field/Field_input/find_field_cells: ' errormsg])
+    msgbox_uvmat('ERROR',['get_field / Field_input / find_field_cells: ' errormsg])
     return
 end  
-for icell=1:numel(CellVarIndex)
-    NbDim(icell)=max(NbDim(icell),numel(CellVarIndex{icell}));
+for icell=1:numel(CellInfo)
+    NbDim(icell)=max(NbDim(icell),numel(CellInfo{icell}.VarIndex));
 end
 [maxdim,imax]=max(NbDim);
@@ -242 +243 @@
 if maxdim>=2 
     set(handles.CheckPlot1D,'Value',0)
-    if ~isempty(VarType{imax}.vector_x) && ~isempty(VarType{imax}.vector_y)      
+    if isfield(CellInfo{imax},'VarIndex_vector_x') &&  isfield(CellInfo{imax},'VarIndex_vector_y') 
         set(handles.CheckVector,'Value',1)
         set(handles.CheckScalar,'Value',0)
-        set(handles.vector_x,'Value',VarType{imax}.vector_x(1))
-        set(handles.vector_y,'Value',VarType{imax}.vector_y(1))
-        if ~isempty(VarType{imax}.coord_x) && ~isempty(VarType{imax}.coord_y)
-            set(handles.coord_x_vectors,'Value',VarType{imax}.coord_x+1)
-            set(handles.coord_y_vectors,'Value',VarType{imax}.coord_y+1)
-        end
-        if ~isempty(VarType{imax}.coord) 
-            set(handles.coord_y_vectors,'Value',VarType{imax}.coord(1)+1)
-            if numel(VarType{imax}.coord)>=2
-                set(handles.coord_x_vectors,'Value',VarType{imax}.coord(2)+1)
-            end
+        set(handles.vector_x,'Value',CellInfo{imax}.VarIndex_vector_x(1))
+        set(handles.vector_y,'Value',CellInfo{imax}.VarIndex_vector_y(1))
+        if strcmp(CellInfo{imax}.CoordType,'scattered')
+            set(handles.coord_x_vectors,'Value',CellInfo{imax}.CoordIndex(end))
+            set(handles.coord_y_vectors,'Value',CellInfo{imax}.CoordIndex(end-1))
+        elseif strcmp(CellInfo{imax}.CoordType,'grid')
+            set(handles.coord_x_vectors,'Value',CellInfo{imax}.CoordIndex(end)+1)
+            set(handles.coord_y_vectors,'Value',CellInfo{imax}.CoordIndex(end-1)+1)
         end
     else
         set(handles.CheckScalar,'Value',1)
         set(handles.CheckVector,'Value',0)
-        if isfield(VarType{imax},'scalar') && length(VarType{imax}.scalar)>=1
-            set(handles.scalar,'Value',VarType{imax}.scalar(1))
-            if ~isempty(VarType{imax}.coord_x) && ~isempty(VarType{imax}.coord_y)
-                set(handles.coord_x_scalar,'Value',VarType{imax}.coord_x+1)
-                set(handles.coord_y_scalar,'Value',VarType{imax}.coord_y+1)
-            end
-            if ~isempty(VarType{imax}.coord_z) 
-                set(handles.coord_z_scalar,'Value',VarType{imax}.coord_z+1)
-            end
-            if ~isempty(VarType{imax}.coord)
-                if numel(VarType{imax}.coord)>=maxdim-2 && maxdim>=3
-                    set(handles.coord_z_scalar,'Value',VarType{imax}.coord(maxdim-2)+1)
-                end
-                if numel(VarType{imax}.coord)>=maxdim-1
-                    set(handles.coord_y_scalar,'Value',VarType{imax}.coord(maxdim-1)+1)
-                end
-                if numel(VarType{imax}.coord)>=maxdim
-                    set(handles.coord_x_scalar,'Value',VarType{imax}.coord(maxdim)+1)
-                end     
+        if isfield(CellInfo{imax},'VarIndex_scalar') 
+            set(handles.scalar,'Value',CellInfo{imax}.VarIndex_scalar(1))
+                set(handles.coord_x_scalar,'Value',CellInfo{imax}.CoordIndex(end)+1)
+                set(handles.coord_y_scalar,'Value',CellInfo{imax}.CoordIndex(end-1)+1)
+            if numel(CellInfo{imax}.CoordIndex)==3
+                set(handles.coord_z_scalar,'Value',CellInfo{imax}.CoordIndex(1)+1)
             end
         end
@@ -286 +271 @@
     CheckVector_Callback(handles.CheckVector, [], handles)
 end
-%scalar_Callback(handles.get_field, eventdata, handles)
-%vector_x_Callback(handles.get_field, eventdata, handles)
 
 %------------------------------------------------------------------------
@@ -301 +284 @@
     variables_Callback(hObject, eventdata, handles)
 end
-[CellVarIndex,NbDim,VarType,errormsg]=find_field_cells(Field);
-for icell=1:numel(CellVarIndex)
-    VarIndex=CellVarIndex{icell};
-    if ~isempty(find(VarIndex==yindex,1)) && (isempty(VarType{icell}.coord_x)||~isequal(VarType{icell}.coord_x,VarIndex))
-        cell_select=icell;
-        break
-    end
-end
-
-val=get(handles.abscissa,'Value');
-set(handles.abscissa,'Value',min(val,2));
-coord_x_index=VarType{cell_select}.coord;
-coord_x_index=coord_x_index(coord_x_index~=0);
-set(handles.abscissa,'String',[{''}; (Field.ListVarName(coord_x_index))'; (Field.ListVarName(VarIndex))'])
+[CellInfo,NbDim,errormsg]=find_field_cells(Field);
+%[CellVarIndex,NbDim,VarRole,errormsg]=find_field_cells(Field);
+% for icell=1:numel(CellInfo) TODO: adapt to new convention
+%     VarIndex=CellInfo{icell}.VarIndex;
+%     if ~isempty(find(VarIndex==yindex,1)) && (isempty(VarRole{icell}.coord_x)||~isequal(VarRole{icell}.coord_x,VarIndex))
+%         cell_select=icell;
+%         break
+%     end
+% end
+% 
+% val=get(handles.abscissa,'Value');
+% set(handles.abscissa,'Value',min(val,2));
+% coord_x_index=VarRole{cell_select}.coord;
+% coord_x_index=coord_x_index(coord_x_index~=0);
+% set(handles.abscissa,'String',[{''}; (Field.ListVarName(coord_x_index))'; (Field.ListVarName(VarIndex))'])
 
 %------------------------------------------------------------------------

trunk/src/mouse_motion.m

@@ -99 +99 @@
                 Field=FigData.(tagaxes);
                 if isfield(Field,'ListVarName')
-                    [CellVarIndex,NbDim,VarType]=find_field_cells(Field);%analyse the physical fields contained in Field
+                    [CellInfo,NbDimArray]=find_field_cells(Field);%analyse the physical fields contained in Field
                     text_displ_1='';
                     text_displ_2='';
@@ -107 +107 @@
                     xName='';
                     z=[];
-                    for icell=1:numel(CellVarIndex)%look for all physical fields
-                        if NbDim(icell)>=2 % select 2D field
-                            if  isfield(Field,'Mesh') && ~isempty(Field.Mesh)&& ~isempty(VarType{icell}.coord_x) && ~isempty(VarType{icell}.coord_y)%case of unstructured data
-                                eval(['X=Field.' Field.ListVarName{VarType{icell}.coord_x} ';'])
-                                eval(['Y=Field.' Field.ListVarName{VarType{icell}.coord_y} ';'])
+                    for icell=1:numel(CellInfo)%look for all physical fields
+                        if NbDimArray(icell)>=2 % select 2D field
+                            if  isfield(Field,'Mesh') && ~isempty(Field.Mesh)&& strcmp(CellInfo{icell}.CoordType,'scattered')%case of unstructured data
+                                X=Field.(Field.ListVarName{CellInfo{icell}.CoordIndex(end)});
+                                Y=Field.(Field.ListVarName{CellInfo{icell}.CoordIndex(end-1)});
                                 flag_vec=(X<(xy(1,1)+Field.Mesh/3) & X>(xy(1,1)-Field.Mesh/3)) & ...%flagx=1 for the vectors with x position selected by the mouse
                                     (Y<(xy(1,2)+Field.Mesh/3) & Y>(xy(1,2)-Field.Mesh/3));%f
@@ -132 +132 @@
                                     end
                                     %display the field values
-                                    for ivar=1:numel(CellVarIndex{icell})
-                                        VarName=Field.ListVarName{CellVarIndex{icell}(ivar)};
-                                        eval(['VarVal=Field.' VarName '(ivec);'])
+                                    for ivar=1:numel(CellInfo{icell}.VarIndex)
+                                        VarName=Field.ListVarName{CellInfo{icell}.VarIndex(ivar)};
+                                        VarVal=Field.(VarName)(ivec);
                                         var_text=[VarName '=' num2str(VarVal,3) ','];
-                                        if isequal(ivar,VarType{icell}.coord_x)||isequal(ivar,VarType{icell}.coord_y)||isequal(ivar,VarType{icell}.coord_z)
+                                        if isequal(ivar,CellInfo{icell}.CoordIndex(end))||isequal(ivar,CellInfo{icell}.CoordIndex(end-1))||isequal(ivar,CellInfo{icell}.CoordIndex(1))
                                             text_displ_1=[text_displ_1 var_text];
-                                        elseif isequal(ivar,VarType{icell}.vector_x)||isequal(ivar,VarType{icell}.vector_y)||isequal(ivar,VarType{icell}.vector_z)
+                                        elseif (isfield(CellInfo{icell},'VarIndex_vector_x') && isequal(ivar,CellInfo{icell}.VarIndex_vector_x))||isequal(ivar,CellInfo{icell}.VarIndex_vector_y)||...
+                                                (isfield(CellInfo{icell},'VarIndex_vector_z') && isequal(ivar,CellInfo{icell}.VarIndex_vector_z))
                                             text_displ_3=[text_displ_3 var_text];
                                         else
@@ -149 +150 @@
                                     end
                                 end
-                            elseif numel(VarType{icell}.coord) >=2 & VarType{icell}.coord > 0 %structured coordinates
-                                yName=Field.ListVarName{VarType{icell}.coord(1)};
-                                xName=Field.ListVarName{VarType{icell}.coord(2)};
-                                 eval(['y=Field.' yName ';'])
-                                 eval(['x=Field.' xName ';'])
-                                VarName=Field.ListVarName{CellVarIndex{icell}(1)};
-                                eval(['nxy=size(Field.' VarName ');']);
+                            elseif strcmp(CellInfo{icell}.CoordType,'grid') %structured coordinates
+                                yName=Field.ListVarName{CellInfo{icell}.CoordIndex(1)};
+                                xName=Field.ListVarName{CellInfo{icell}.CoordIndex(2)};
+                                y=Field.(yName);
+                                x=Field.(xName);
+                                VarName=Field.ListVarName{CellInfo{icell}.VarIndex(1)};
+                                nxy=size(Field.(VarName));
                                 MaxAY=max(y(1),y(end)); %#ok<COLND>
                                 MinAY=min(y(1),y(end)); %#ok<COLND>
@@ -163 +164 @@
                                     if indx0>=1 & indx0<=nxy(2) & indy0>=1 & indy0<=nxy(1)
                                         text_displ_2=['i='  num2str(indx0) ',j=' num2str(indy0) ','];
-                                        for ivar=1:numel(CellVarIndex{icell})
-                                            VarName=Field.ListVarName{CellVarIndex{icell}(ivar)};
-                                            eval(['VarVal=Field.' VarName '(indy0,indx0,:);'])
+                                        for ivar=1:numel(CellInfo{icell}.VarIndex)
+                                            VarName=Field.ListVarName{CellInfo{icell}.VarIndex(ivar)};
+                                            VarVal=Field.(VarName)(indy0,indx0,:);
                                             var_text=[VarName '=' num2str(VarVal) ','];
                                             text_displ_2=[text_displ_2 var_text];

trunk/src/plot_field.m

@@ -110 +110 @@
 index_1D=[];
 index_0D=[];
-errormsg=check_field_structure(Data);
-if ~isempty(errormsg)
-    msgbox_uvmat('ERROR',['input of plot_field/check_field_structure: ' errormsg])
-    display(['input of plot_field/check_field_structure: ' errormsg])
-    return
-end
+% errormsg=check_field_structure(Data);
+% if ~isempty(errormsg)
+%     msgbox_uvmat('ERROR',['input of plot_field/check_field_structure: ' errormsg])
+%     display(['input of plot_field/check_field_structure: ' errormsg])
+%     return
+% end
 % check the cells of fields :
-[CellVarIndex,NbDim,VarType,errormsg]=find_field_cells(Data);
+[CellInfo,NbDimArray,errormsg]=find_field_cells(Data);
+%[CellVarIndex,NbDim,CoordType,VarRole,errormsg]=find_field_cells(Data);
 if ~isempty(errormsg)
     msgbox_uvmat('ERROR',['input of plot_field/find_field_cells: ' errormsg]);
     return
 end
-index_2D=find(NbDim==2);%find 2D fields
-index_3D=find(NbDim>2,1);
+
+index_3D=find(NbDimArray>2,1);
 if ~isempty(index_3D)
-    if isfield(Data,'NbDim')&& isequal(Data.NbDim,2)
-        index_2D=[index_2D index_3D];
-    else
+%     if isfield(Data,'NbDimArray')&& isequal(Data.NbDimArray,2)
+%         index_2D=[index_2D index_3D];
+%     else
         msgbox_uvmat('ERROR','volume plot not implemented yet');
         return
-    end
-end
-index_1D=find(NbDim==1&~cellfun(@isempty,VarType));
-index_0D=find(NbDim==0);
+%     end
+end
+index_2D=find(NbDimArray==2);%find 2D fields
+index_1D=find(NbDimArray==1);
+index_0D=find(NbDimArray==0);
 %remove coordinates variables from 1D plot
 % if ~isempty(index_2D)
 %     for ivar=1:length(index_1D)
-%         if isequal(CellVarIndex{index_1D(ivar)},VarType{index_1D(ivar)}.coord)
+%         if isequal(CellVarIndex{index_1D(ivar)},VarRole{index_1D(ivar)}.coord)
 %             index_1D(ivar)=0;
 %         end
@@ -192 +194 @@
 %% 2D plots 
 if isempty(index_2D)
-    plot_plane([],[],[],haxes);%removes images or vector plots in the absence of 2D field plot
+    plot_plane([],[],haxes);%removes images or vector plots in the absence of 2D field plot
 else  %plot 2D field
-    [tild,PlotParamOut,PlotType,errormsg]=plot_plane(Data,CellVarIndex(index_2D),VarType(index_2D),haxes,PlotParam,PosColorbar);
+    [tild,PlotParamOut,PlotType,errormsg]=plot_plane(Data,CellInfo(index_2D),haxes,PlotParam,PosColorbar);
     AxeData.NbDim=2;
     if testzoomaxes && isempty(errormsg)
-        [zoomaxes,PlotParamOut,tild,errormsg]=plot_plane(Data,CellVarIndex(index_2D),VarType(index_2D),zoomaxes,PlotParam,PosColorbar);
+        [zoomaxes,PlotParamOut,tild,errormsg]=plot_plane(Data,CellInfo(index_2D),zoomaxes,PlotParam,PosColorbar);
         AxeData.ZoomAxes=zoomaxes;
     end
@@ -205 +207 @@
 if isempty(index_1D)
     if ~isempty(haxes)
-        plot_profile([],[],[],haxes);%removes usual praphs y vs x in the absence of 1D field plot
+        plot_profile([],[],haxes);%removes usual praphs y vs x in the absence of 1D field plot
     end
 else %plot 1D field (usual graph y vs x)
-    Coordinates=plot_profile(Data,CellVarIndex(index_1D),VarType(index_1D),haxes,PlotParam.Coordinates);%
+    Coordinates=plot_profile(Data,CellInfo(index_1D),haxes,PlotParam.Coordinates);%
     if testzoomaxes
-        [zoomaxes,Coordinates]=plot_profile(Data,CellVarIndex(index_1D),VarType(index_1D),zoomaxes,PlotParam.Coordinates);
+        [zoomaxes,Coordinates]=plot_profile(Data,CellInfo(index_1D),zoomaxes,PlotParam.Coordinates);
         AxeData.ZoomAxes=zoomaxes;
     end
@@ -233 +235 @@
         end
     else
-        [errormsg]=plot_text(Data,CellVarIndex(index_0D),VarType(index_0D),htext);
+        [errormsg]=plot_text(Data,CellInfo(index_0D),htext);
     end
 end
@@ -262 +264 @@
 
 %-------------------------------------------------------------------
-function errormsg=plot_text(FieldData,CellVarIndex,VarTypeCell,htext)
+function errormsg=plot_text(FieldData,CellInfo,htext)
 %-------------------------------------------------------------------
 errormsg=[];
 txt_cell={};
 Data={};
-for icell=1:length(CellVarIndex)
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list data.ListVarName
+for icell=1:length(CellInfo)
+    VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list data.ListVarName
     for ivar=1:length(VarIndex)
         checkancillary=0;
@@ -303 +305 @@
 
 %-------------------------------------------------------------------
-function CoordinatesOut=plot_profile(data,CellVarIndex,VarType,haxes,Coordinates)
+function CoordinatesOut=plot_profile(data,CellInfo,haxes,Coordinates)
 %-------------------------------------------------------------------
 
@@ -341 +343 @@
 
 %loop on input  fields
-for icell=1:length(CellVarIndex)
-    if isempty(VarType{icell})% coordiante variable
-        continue
-    end
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list data.ListVarName
-    if ~isempty(VarType{icell}.coord_x)
-        coord_x_index=VarType{icell}.coord_x;
-    else
-        coord_x_index_cell=VarType{icell}.coord(1);
-        if isequal(coord_x_index_cell,0)
-             continue  % the cell has no abscissa, skip it
-        end
-        coord_x_index=coord_x_index_cell;
-    end
+for icell=1:numel(CellInfo)
+    VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list data.ListVarName
+    coord_x_index=CellInfo{icell}.CoordIndex;
     testplot=ones(size(data.ListVarName));%default test for plotted variables
     coord_x_name{icell}=data.ListVarName{coord_x_index};
@@ -369 +360 @@
     XMax(icell)=max(coord_x{icell});
     testplot(coord_x_index)=0;
-    if ~isempty(VarType{icell}.ancillary')
-        testplot(VarType{icell}.ancillary)=0;
-    end
-    if ~isempty(VarType{icell}.warnflag')
-        testplot(VarType{icell}.warnflag)=0;
+    if isfield(CellInfo{icell},'VarIndex_ancillary')
+        testplot(CellInfo{icell}.VarIndex_ancillary)=0;
+    end
+    if isfield(CellInfo{icell},'VarIndex_warnflag')
+        testplot(CellInfo{icell}.VarIndex_warnflag)=0;
     end
     if isfield(data,'VarAttribute')
@@ -385 +376 @@
         end
     end
-    if ~isempty(VarType{icell}.discrete')
+    if isfield(CellInfo{icell},'VarIndex_discrete')
         charplot_0='''+''';
     else
@@ -507 +498 @@
 
 %-------------------------------------------------------------------
-function [haxes,PlotParamOut,PlotType,errormsg]=plot_plane(Data,CellVarIndex,VarTypeCell,haxes,PlotParam,PosColorbar)
+function [haxes,PlotParamOut,PlotType,errormsg]=plot_plane(Data,CellInfo,haxes,PlotParam,PosColorbar)
 %-------------------------------------------------------------------
 
@@ -538 +529 @@
 YName='';
 y_units='';
-for icell=1:length(CellVarIndex) % length(CellVarIndex) =1 or 2 (from the calling function)
-    VarType=VarTypeCell{icell};
-    if ~isempty(VarType.coord_tps) %do not plot directly tps data (used for projection only)
+for icell=1:numel(CellInfo) % length(CellVarIndex) =1 or 2 (from the calling function)
+%     VarRole=CellInfo{icell};
+    if strcmp(CellInfo{icell}.CoordType,'tps') %do not plot directly tps data (used for projection only)
         continue
     end
-    ivar_X=VarType.coord_x; % defines (unique) index for the variable representing unstructured x coordinate (default =[])
-    ivar_Y=VarType.coord_y; % defines (unique)index for the variable representing unstructured y coordinate (default =[])
-    ivar_U=VarType.vector_x; % defines (unique) index for the variable representing x vector component (default =[])
-    ivar_V=VarType.vector_y; % defines (unique) index for the variable representing y vector component (default =[])
-    ivar_C=[VarType.scalar VarType.image VarType.color VarType.ancillary]; %defines index (indices) for the scalar or ancillary fields
+    ivar_X=CellInfo{icell}.CoordIndex(end); % defines (unique) index for the variable representing unstructured x coordinate (default =[])
+    ivar_Y=CellInfo{icell}.CoordIndex(end-1); % defines (unique)index for the variable representing unstructured y coordinate (default =[])
+    ivar_C=[];
+    if isfield(CellInfo{icell},'VarIndex_scalar')
+        ivar_C=[ivar_C CellInfo{icell}.VarIndex_scalar];
+    end
+    if isfield(CellInfo{icell},'VarIndex_image')
+        ivar_C=[ivar_C CellInfo{icell}.VarIndex_image];
+    end
+    if isfield(CellInfo{icell},'VarIndex_color')
+        ivar_C=[ivar_C CellInfo{icell}.VarIndex_color];
+    end
+    if isfield(CellInfo{icell},'VarIndex_ancillary')
+        ivar_C=[ivar_C CellInfo{icell}.VarIndex_ancillary];
+    end
     if numel(ivar_C)>1
         errormsg= 'error in plot_field: too many scalar inputs';
         return
     end
-    ivar_F=VarType.warnflag; %defines index (unique) for warning flag variable
-    ivar_FF=VarType.errorflag; %defines index (unique) for error flag variable
-    ind_coord=find(VarType.coord);
-    if numel(ind_coord)==2
-        VarType.coord=VarType.coord(ind_coord);
-    end
-    if ~isempty(ivar_U) && ~isempty(ivar_V)% vector components detected
+    ivar_F=[];
+    if isfield(CellInfo{icell},'VarIndex_warnflag')
+    ivar_F=CellInfo{icell}.VarIndex_warnflag; %defines index (unique) for warning flag variable
+    end
+    ivar_FF=[];
+    if isfield(CellInfo{icell},'VarIndex_errorflag')
+    ivar_FF=CellInfo{icell}.VarIndex_errorflag; %defines index (unique) for error flag variable
+    end
+    if isfield(CellInfo{icell},'VarIndex_vector_x')&&isfield(CellInfo{icell},'VarIndex_vector_y') % vector components detected
         if test_vec
             errormsg='error in plot_field: attempt to plot two vector fields: to get the difference project on a plane with mode interp';
@@ -564 +567 @@
         else
             test_vec=1;
-            vec_U=Data.(Data.ListVarName{ivar_U}); 
-            vec_V=Data.(Data.ListVarName{ivar_V});
-            if ~isempty(ivar_X) && ~isempty(ivar_Y)% 2D field with unstructured coordinates 
-                XName=Data.ListVarName{ivar_X};
-                YName=Data.ListVarName{ivar_Y};
+            vec_U=Data.(Data.ListVarName{CellInfo{icell}.VarIndex_vector_x}); 
+            vec_V=Data.(Data.ListVarName{CellInfo{icell}.VarIndex_vector_y});
+            if strcmp(CellInfo{icell}.CoordType,'scattered')%2D field with unstructured coordinates 
+                XName=Data.ListVarName{CellInfo{icell}.CoordIndex(end)};
+                YName=Data.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
                 vec_X=reshape(Data.(XName),[],1); %transform vectors in column matlab vectors
                 vec_Y=reshape(Data.(YName),[],1);
-            elseif numel(VarType.coord)==2 && ~isequal(VarType.coord,[0 0]);%coordinates defines by dimension variables
-                y=Data.(Data.ListVarName{VarType.coord(1)});
-                x=Data.(Data.ListVarName{VarType.coord(2)});
+            elseif strcmp(CellInfo{icell}.CoordType,'grid')%2D field with structured coordinates 
+                y=Data.(Data.ListVarName{CellInfo{icell}.CoordIndex(end-1)});
+                x=Data.(Data.ListVarName{CellInfo{icell}.CoordIndex(end)});
                 if numel(y)==2 % y defined by first and last values on aregular mesh
                     y=linspace(y(1),y(2),size(vec_U,1));
@@ -581 +584 @@
                 end
                 [vec_X,vec_Y]=meshgrid(x,y);  
-            else
-                errormsg='error in plot_field: invalid coordinate definition for vector field';
-                return
             end
             if isfield(PlotParam.Vectors,'ColorScalar') && ~isempty(PlotParam.Vectors.ColorScalar)
                 [VarVal,ListVarName,VarAttribute,errormsg]=calc_field_interp([],Data,PlotParam.Vectors.ColorScalar);
-%             if ~isempty(ivar_C)
-                 %vec_C=Data.(Data.ListVarName{ivar_C});
-                 if ~isempty(VarVal)
-                 vec_C=reshape(VarVal{1},1,numel(VarVal{1}));
-                 test_C=1;
-                 end
+                if ~isempty(VarVal)
+                    vec_C=reshape(VarVal{1},1,numel(VarVal{1}));
+                    test_C=1;
+                end
             end
             if ~isempty(ivar_F)%~(isfield(PlotParam.Vectors,'HideWarning')&& isequal(PlotParam.Vectors.HideWarning,1)) 
@@ -613 +611 @@
             return
         end
-        eval(['A=squeeze(Data.' Data.ListVarName{ivar_C} ');']) ;% scalar represented as color image
+        A=squeeze(Data.(Data.ListVarName{ivar_C}));% scalar represented as color image
         test_ima=1;
-        if ~isempty(ivar_X) && ~isempty(ivar_Y)% 2D field (with unstructured coordinates  (then ivar_X and ivar_Y not empty) 
+        if strcmp(CellInfo{icell}.CoordType,'scattered')%2D field with unstructured coordinates 
             A=reshape(A,1,[]);
             XName=Data.ListVarName{ivar_X};
@@ -630 +628 @@
                 end
             end        
-        elseif numel(VarType.coord)==2 %structured coordinates
-            XName=Data.ListVarName{VarType.coord(2)};
-            YName=Data.ListVarName{VarType.coord(1)};
-            eval(['AY=Data.' Data.ListVarName{VarType.coord(1)} ';']) 
-            eval(['AX=Data.' Data.ListVarName{VarType.coord(2)} ';'])
+        elseif strcmp(CellInfo{icell}.CoordType,'grid')%2D field with structured coordinates 
+            YName=Data.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
+            AY=Data.(YName); 
+            AX=Data.(Data.ListVarName{CellInfo{icell}.CoordIndex(end)});
             test_interp_X=0; %default, regularly meshed X coordinate
             test_interp_Y=0; %default, regularly meshed Y coordinate
             if isfield(Data,'VarAttribute')
-                if numel(Data.VarAttribute)>=VarType.coord(2) && isfield(Data.VarAttribute{VarType.coord(2)},'units')
-                    x_units=Data.VarAttribute{VarType.coord(2)}.units;
-                end
-                if numel(Data.VarAttribute)>=VarType.coord(1) && isfield(Data.VarAttribute{VarType.coord(1)},'units')
-                    y_units=Data.VarAttribute{VarType.coord(1)}.units;
+                if numel(Data.VarAttribute)>=CellInfo{icell}.CoordIndex(end) && isfield(Data.VarAttribute{CellInfo{icell}.CoordIndex(end)},'units')
+                    x_units=Data.VarAttribute{CellInfo{icell}.CoordIndex(end)}.units;
+                end
+                if numel(Data.VarAttribute)>=CellInfo{icell}.CoordIndex(end-1) && isfield(Data.VarAttribute{CellInfo{icell}.CoordIndex(end-1)},'units')
+                    y_units=Data.VarAttribute{CellInfo{icell}.CoordIndex(end-1)}.units;
                 end
             end  
@@ -650 +647 @@
                 DAY_max=max(DAY);
                 if sign(DAY_min)~=sign(DAY_max);% =1 for increasing values, 0 otherwise
-                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarType.coord(1)} ];
+                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarRole.coord(1)} ];
                       return
                 end 
@@ -660 +657 @@
                 DAX_max=max(DAX);
                 if sign(DAX_min)~=sign(DAX_max);% =1 for increasing values, 0 otherwise
-                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarType.coord(2)} ];
+                     errormsg=['errror in plot_field.m: non monotonic dimension variable ' Data.ListVarName{VarRole.coord(2)} ];
                       return
                 end 
@@ -687 +684 @@
             AX=[AX(1) AX(end)];% keep only the lower and upper bounds for image represnetation 
             AY=[AY(1) AY(end)];
-        else
-            errormsg='error in plot_field: invalid coordinate definition ';
-            return
+%         else
+%             errormsg='error in plot_field: invalid coordinate definition ';
+%             return
         end
     end

trunk/src/proj_field.m

@@ -148 +148 @@
 [ProjData,errormsg]=proj_heading(FieldData,ObjectData);
 ProjData.NbDim=0;
-[CellVarIndex,NbDimCell,VarTypeCell,errormsg]=find_field_cells(FieldData);
+[CellInfo,NbDimArray,errormsg]=find_field_cells(FieldData);
+%[CellVarIndex,NbDimCell,VarTypeCell,errormsg]=find_field_cells(FieldData);
 if ~isempty(errormsg)
     errormsg=['error in proj_field/proj_points:' errormsg];
@@ -154 +155 @@
 end
 %LOOP ON GROUPS OF VARIABLES SHARING THE SAME DIMENSIONS
-for icell=1:length(CellVarIndex)
-    if NbDimCell(icell)==1
-        continue
-    end
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list FieldData.ListVarName
-    VarType=VarTypeCell{icell};% structure defining the types of variables in the cell
-    ivar_X=VarType.coord_x;
-    ivar_Y=VarType.coord_y;
-    ivar_Z=VarType.coord_z;
-    ivar_Anc=VarType.ancillary;
-    test_anc(ivar_Anc)=ones(size(ivar_Anc));
-    ivar_F=VarType.warnflag;
-    ivar_FF=VarType.errorflag;
-    VarIndex([ivar_X ivar_Y ivar_Z ivar_Anc ivar_F ivar_FF])=[];% not projected variables removed frlom list
-    if isempty(ivar_X)
-        test_grid=1;%test for input data on regular grid (e.g. image)coordinates      
-    else
-        if length(ivar_X)>1 || length(ivar_Y)>1 || length(ivar_Z)>1
-                 errormsg='multiple coordinate input in proj_field.m';
-                    return
-        end
-        if length(ivar_Y)~=1
-                errormsg='y coordinate not defined in proj_field.m';
-                return
-        end
-        test_grid=0;
-    end
+for icell=1:length(CellInfo)
+    if NbDimArray(icell)<=1
+        continue %projection only for multidimensional fields
+    end
+    VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list FieldData.ListVarName
+   % VarType=CellInfo{icell}.VarType;% structure defining the types of variables in the cell
+    ivar_X=CellInfo{icell}.CoordIndex(end);
+    ivar_Y=CellInfo{icell}.CoordIndex(end-1);
+    ivar_Z=[];
+    if NbDimArray(icell)==3
+        ivar_Z=CellInfo{icell}.CoordIndex(1);
+    end
+%     ivar_rem=[];
+%     if isfield(CellInfo{icell},'VarIndex_ancillary')
+%         ivar_rem=CellInfo{icell}.VarIndex_ancillary;
+%     end
+%     if isfield(CellInfo{icell},'VarIndex_warnflag')
+%         ivar_rem=[ivar_rem CellInfo{icell}.VarIndex_warnflag];
+%     end
+    ivar_FF=[];
+    if isfield(CellInfo{icell},'VarIndex_errorflag')
+        ivar_FF=CellInfo{icell}.VarIndex_errorflag;
+        if numel(ivar_FF)>1
+            errormsg='multiple error flag input';
+            return
+        end
+    end
+%     
+    % select types of  variables to be projected
+   ListProject={'VarIndex_scalar','VarIndex_image','VarIndex_color','VarIndex_vector_x','VarIndex_vector_y'};
+   check_project=false(size(VarIndex));
+   for ilist=1:numel(ListProject)
+       if isfield(CellInfo{icell},ListProject{ilist})
+           check_project(CellInfo{icell}.(ListProject{ilist}))=1;
+       end
+   end
+   VarIndex=VarIndex(check_project);
+     
+%     if isempty(ivar_X)
+%         test_grid=1;%test for input data on regular grid (e.g. image)coordinates      
+%     else
+%         if length(ivar_X)>1 || length(ivar_Y)>1 || length(ivar_Z)>1
+%                  errormsg='multiple coordinate input in proj_field.m';
+%                     return
+%         end
+%         if length(ivar_Y)~=1
+%                 errormsg='y coordinate not defined in proj_field.m';
+%                 return
+%         end
+%         test_grid=0;
+%     end
     ProjData.ListVarName={'Y','X','NbVal'};
     ProjData.VarDimName={'nb_points','nb_points','nb_points'};
@@ -190 +215 @@
         ProjData.ListVarName=[ProjData.ListVarName {VarName}];% add the current variable to the list of projected variables
         ProjData.VarDimName=[ProjData.VarDimName {'nb_points'}]; % projected VarName has a single dimension called 'nb_points' (set of projection points)
-    end
-    if ~test_grid
-        eval(['coord_x=FieldData.' FieldData.ListVarName{ivar_X} ';'])
-        eval(['coord_y=FieldData.' FieldData.ListVarName{ivar_Y} ';'])
+
+    end
+    if strcmp( CellInfo{icell}.CoordType,'scattered')
+        coord_x=FieldData.(FieldData.ListVarName{ivar_X});
+        coord_y=FieldData.(FieldData.ListVarName{ivar_Y});
         test3D=0;% TEST 3D CASE : NOT COMPLETED ,  3D CASE : NOT COMPLETED 
         if length(ivar_Z)==1
-            eval(['coord_z=FieldData.' FieldData.ListVarName{ivar_Z} ';'])
+            coord_z=FieldData.(FieldData.ListVarName{ivar_Z});
             test3D=1;
         end
-        if length(ivar_F)>1 || length(ivar_FF)>1 
-                 msgbox_uvmat('ERROR','multiple flag input in proj_field.m')
-                    return
-        end      
+   
         for ipoint=1:siz(1)
            Xpoint=ObjectData.Coord(ipoint,:);
@@ -231 +254 @@
         end
     else    %case of structured coordinates
-        if  numel(VarType.coord)>=2 & VarType.coord(1:2) > 0;
-            AYName=FieldData.ListVarName{VarType.coord(1)};
-            AXName=FieldData.ListVarName{VarType.coord(2)};
+        if  strcmp( CellInfo{icell}.CoordType,'grid')
+            AYName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
+            AXName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)};
             eval(['AX=FieldData.' AXName ';']);% set of x positions
             eval(['AY=FieldData.' AYName ';']);% set of y positions  
             AName=FieldData.ListVarName{VarIndex(1)};% a single variable assumed in the current cell
             eval(['A=FieldData.' AName ';']);% scalar
-            npxy=size(A);        
-            NbDim=numel(VarType.coord(VarType.coord>0));%number of space dimensions 
+            npxy=size(A);         
             %update VarDimName in case of components (non coordinate dimensions e;g. color components)
-            if numel(npxy)>NbDim
+            if numel(npxy)>NbDimArray(icell)
                 ProjData.VarDimName{end}={'nb_points','component'};
             end
-            for idim=1:NbDim %loop on space dimensions
+            for idim=1:NbDimArray(icell) %loop on space dimensions
                 test_interp(idim)=0;%test for coordiate interpolation (non regular grid), =0 by default
                 test_coord(idim)=0;%test for defined coordinates, =0 by default
-                ivar=VarType.coord(idim);
+                ivar=CellInfo{icell}.CoordIndex(idim);
                 Coord{idim}=FieldData.(FieldData.ListVarName{ivar}); % position for the first index
                 if numel(Coord{idim})==2
@@ -342 +364 @@
 % DimVarIndex=0;%initilise list of indices for dimension variables
 idimvar=0;
-[CellVarIndex,NbDim,VarTypeCell,errormsg]=find_field_cells(FieldData);
+[CellInfo,NbDim,errormsg]=find_field_cells(FieldData);
+%[CellVarIndex,NbDim,VarTypeCell,errormsg]=find_field_cells(FieldData);
 if ~isempty(errormsg)
     errormsg=['error in proj_field/proj_patch:' errormsg];
@@ -350 +373 @@
 %LOOP ON GROUPS OF VARIABLES SHARING THE SAME DIMENSIONS
 dimcounter=0;
-for icell=1:length(CellVarIndex)
+for icell=1:length(CellInfo)
     testX=0;
     testY=0;
     test_Amat=0;
     testfalse=0;
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list FieldData.ListVarName
-    VarType=VarTypeCell{icell};
+    VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list FieldData.ListVarName
+  %  VarType=VarTypeCell{icell};
   %  DimIndices=FieldData.VarDimIndex{VarIndex(1)};%indices of the dimensions of the first variable (common to all variables in the cell)
     if NbDim(icell)~=2% proj_patch acts only on fields of space dimension 2
         continue
     end
-    testX=~isempty(VarType.coord_x) && ~isempty(VarType.coord_y);
-    testfalse=~isempty(VarType.errorflag);
+    %testX=~isempty(VarType.coord_x) && ~isempty(VarType.coord_y);
+    testfalse=isfield(CellInfo{icell},'VarIndex_errorflag');
     testproj(VarIndex)=zeros(size(VarIndex));%default
-    testproj(VarType.scalar)=1;
-    testproj(VarType.vector_x)=1;
-    testproj(VarType.vector_y)=1;
-    testproj(VarType.vector_z)=1;
-    testproj(VarType.image)=1;
-    testproj(VarType.color)=1;
-    VarIndex=VarIndex(find(testproj(VarIndex)));%select only the projected variables
-    if check_unstructured%case of unstructured coordinates
+    ivar_X=CellInfo{icell}.CoordIndex(end);
+    ivar_Y=CellInfo{icell}.CoordIndex(end-1);
+    ivar_Z=[];
+    if NbDimArray(icell)==3
+        ivar_Z=CellInfo{icell}.CoordIndex(1);
+    end
+    ivar_rem=[];
+    if isfield(CellInfo{icell},'VarIndex_ancillary')
+        ivar_rem=CellInfo{icell}.VarIndex_ancillary;
+    end
+    if isfield(CellInfo{icell},'VarIndex_warnflag')
+        ivar_rem=[ivar_rem CellInfo{icell}.VarIndex_warnflag];
+    end
+    if isfield(CellInfo{icell},'VarIndex_errorflag')
+        ivar_rem=[ivar_rem CellInfo{icell}.VarIndex_errorflag];
+        ivar_FF=CellInfo{icell}.VarIndex_errorflag;
+    end
+    VarIndex([ivar_X ivar_Y ivar_Z ivar_rem])=[];% not projected variables removed frlom list
+
+    if strcmp(CellInfo{icell}.CoordType,'scattered')%case of unstructured coordinates
          eval(['nbpoint=numel(FieldData.' FieldData.ListVarName{VarIndex(1)} ');'])
          for ivar=[VarIndex VarType.coord_x VarType.coord_y VarType.errorflag]
@@ -377 +412 @@
             eval(['FieldData.' VarName '=reshape(FieldData.' VarName ',nbpoint,1);'])
          end
-         XName=FieldData.ListVarName{VarType.coord_x};
-         YName=FieldData.ListVarName{VarType.coord_y};
+         XName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)};
+         YName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
          eval(['coord_x=FieldData.' XName ';'])
          eval(['coord_y=FieldData.' YName ';'])
@@ -387 +422 @@
     end
     % image or 2D matrix
-    if numel(VarType.coord)>=2 & VarType.coord(1:2) > 0;
+    if  strcmp(CellInfo{icell}.CoordType,'grid')%case of structured coordinates
         test_Amat=1;% test for image or 2D matrix
-        AYName=FieldData.ListVarName{VarType.coord(1)};
-        AXName=FieldData.ListVarName{VarType.coord(2)};
+        AYName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
+        AXName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)};
         eval(['AX=FieldData.' AXName ';'])% x coordinate
         eval(['AY=FieldData.' AYName ';'])% y coordinate
@@ -562 +597 @@
 
 %% group the variables (fields of 'FieldData') in cells of variables with the same dimensions
-[CellVarIndex,NbDim,VarTypeCell,errormsg]=find_field_cells(FieldData);
+%[CellVarIndex,NbDim,VarTypeCell,errormsg]=find_field_cells(FieldData);
+[CellInfo,NbDim,errormsg]=find_field_cells(FieldData);
 if ~isempty(errormsg)
     errormsg=['error in proj_field/proj_line:' errormsg];
@@ -571 +607 @@
 ProjData.ListVarName={};
 ProjData.VarDimName={};
-testproj=zeros(size(FieldData.ListVarName));
-for icell=1:length(CellVarIndex)
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list FieldData.ListVarName
-    VarType=VarTypeCell{icell}; %types of variables
+for icell=1:length(CellInfo)
+    %VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list FieldData.ListVarName
+   % VarType=VarTypeCell{icell}; %types of variables
     if NbDim(icell)~=2% proj_line acts only on fields of space dimension 2, TODO: check 3D case
         continue
     end
-    check_unstructured=~isempty(VarType.coord_x) && ~isempty(VarType.coord_y);% test for unstructured coordinates
-    test_tps=~isempty(VarType.coord_tps);
-    testU=~isempty(VarType.vector_x) && ~isempty(VarType.vector_y);% test for vectors
-    testfalse=~isempty(VarType.errorflag);% test for error flag
-    testproj(VarIndex)=zeros(size(VarIndex));% test =1 for simply projected variables, default =0
-                                             %=0 for vector components, treated separately
-    testproj([VarType.scalar VarType.image VarType.color VarType.vector_x VarType.vector_y])=1;
-    VarIndex=VarIndex(find(testproj(VarIndex)));%select only the projected variables
+
+    % select types of  variables to be projected
+   ListProject={'VarIndex_scalar','VarIndex_image','VarIndex_color','VarIndex_vector_x','VarIndex_vector_y'};
+   check_project=false(size(FieldData.ListVarName));
+   for ilist=1:numel(ListProject)
+       if isfield(CellInfo{icell},ListProject{ilist})
+           check_project(CellInfo{icell}.(ListProject{ilist}))=1;
+       end
+   end
+   VarIndex=find(check_project);
 
     %identify vector components   
+    testU=isfield(CellInfo{icell},'VarIndex_vector_x') &&isfield(CellInfo{icell},'VarIndex_vector_y') ;% test for vectors
     if testU
-        UName=FieldData.ListVarName{VarType.vector_x};
-        VName=FieldData.ListVarName{VarType.vector_y};
+        UName=FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_x};
+        VName=FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_y};
         vector_x=FieldData.(UName);
         vector_y=FieldData.(VName);
     end  
     %identify error flag
+    testfalse=isfield(CellInfo{icell},'VarIndex_errorflag');% test for error flag
     if testfalse
-        FFName=FieldData.ListVarName{VarType.errorflag};
+        FFName=FieldData.ListVarName{CellInfo{icell}.VarIndex_errorflag};
         errorflag=FieldData.(FFName);
     end   
     % check needed object properties for unstructured positions (position given by the variables with role coord_x, coord_y
-    if check_unstructured
+    if strcmp(CellInfo{icell}.CoordType,'scattered')
         if  ~isequal(ProjMode,'interp')
             if width==0
@@ -617 +656 @@
             end
         end
-        XName= FieldData.ListVarName{VarType.coord_x};
-        YName= FieldData.ListVarName{VarType.coord_y};
+        XName= FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)};
+        YName= FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
         coord_x=FieldData.(XName);    
         coord_y=FieldData.(YName);
@@ -633 +672 @@
   %%%%%%%  % A FAIRE CALCULER MEAN DES QUANTITES    %%%%%%
    %case of unstructured coordinates
-    if check_unstructured   
+    if strcmp(CellInfo{icell}.CoordType,'scattered')  
         for ip=1:siz_line(1)-1     %Loop on the segments of the polyline
             linelength=sqrt(dlinx(ip)*dlinx(ip)+dliny(ip)*dliny(ip));  
@@ -725 +764 @@
     
     %case of structured coordinates
-    elseif  numel(VarType.coord)>=2 & VarType.coord(1:2) > 0;
+    elseif strcmp(CellInfo{icell}.CoordType,'grid')
         if ~isequal(ObjectData.Type,'line')% exclude polyline
             errormsg=['no  projection available on ' ObjectData.Type 'for structured coordinates']; % 
@@ -732 +771 @@
             test_interp2=0;%default
 %             if ~isempty(VarType.coord_y)  
-            AYName=FieldData.ListVarName{VarType.coord(1)};
-            AXName=FieldData.ListVarName{VarType.coord(2)};
+            AYName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)};
+            AXName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)};
             eval(['AX=FieldData.' AXName ';']);% set of x positions
             eval(['AY=FieldData.' AYName ';']);% set of y positions  
@@ -832 +871 @@
             end
             if testU
-                 vector_x =ProjData.(FieldData.ListVarName{VarType.vector_x});
-                 vector_y =ProjData.(FieldData.ListVarName{VarType.vector_y});
-                 ProjData.(FieldData.ListVarName{VarType.vector_x}) =cos(theta)*vector_x+sin(theta)*vector_y;
-                 ProjData.(FieldData.ListVarName{VarType.vector_y}) =-sin(theta)*vector_x+cos(theta)*vector_y;
+                 vector_x =ProjData.(FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_x});
+                 vector_y =ProjData.(FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_y});
+                 ProjData.(FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_x}) =cos(theta)*vector_x+sin(theta)*vector_y;
+                 ProjData.(FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_y}) =-sin(theta)*vector_x+cos(theta)*vector_y;
             end
             ProjData.VarAttribute{nbvar+1}.long_name='abscissa along line';
@@ -842 +881 @@
             end
         end
-    elseif test_tps
+    elseif strcmp(CellInfo{icell}.CoordType,'tps')
          if isfield(ObjectData,'DX')&~isempty(ObjectData.DX)
                 DX=abs(ObjectData.DX);%mesh of interpolation points along the line
@@ -972 +1011 @@
 %% group the variables (fields of 'FieldData') in cells of variables with the same dimensions
 % CellVarIndex=cells of variable index arrays
-[CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(FieldData);
+%[CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(FieldData);
+[CellInfo,NbDimArray,errormsg]=find_field_cells(FieldData);
 if ~isempty(errormsg)
     errormsg=['error in proj_field/proj_plane:' errormsg];
@@ -980 +1020 @@
 %% projection modes
 check_grid=0;
-ProjMode=cell(size(VarTypeCell));
-for icell=1:numel(VarTypeCell)% TODO: recalculate coordinates here to get the bounds in the rotated coordinates
+ProjMode=cell(size(CellInfo));
+for icell=1:numel(CellInfo)% TODO: recalculate coordinates here to get the bounds in the rotated coordinates
     ProjMode{icell}=ObjectData.ProjMode;
-    if isfield(VarTypeCell{icell},'FieldRequest')
-        switch VarTypeCell{icell}.FieldRequest
+    if isfield(CellInfo{icell},'FieldRequest')
+        switch CellInfo{icell}.FieldRequest
             case 'interp_lin'
                 ProjMode{icell}='interp';
@@ -1014 +1054 @@
 vector_x_proj=[];
 vector_y_proj=[];
-for icell=1:length(CellVarIndex)
-    NbDim=NbDimVec(icell);
+for icell=1:length(CellInfo)
+    NbDim=NbDimArray(icell);
     if NbDim<2
         continue % only cells represnting 2D or 3D fields are involved
     end
-    VarIndex=CellVarIndex{icell};%  indices of the selected variables in the list FieldData.ListVarName
-    VarType=VarTypeCell{icell};
-    ivar_U=VarType.vector_x;
-    ivar_V=VarType.vector_y;
-    if ~isempty(VarType.vector_x_tps)&&~isempty(VarType.vector_y_tps)
-        ivar_U=VarType.vector_x_tps;
-        ivar_V=VarType.vector_y_tps;
-    end
-    ivar_W=VarType.vector_z;
-
-    %type of coordinates
-    if ~isempty(VarType.coord_x) && ~isempty(VarType.coord_y)
-        CoordType='unstructured';
-    elseif ~isempty(VarType.coord_tps)
-        CoordType='tps';
-    else
-        CoordType='structured';
-    end
-    
+    VarIndex=CellInfo{icell}.VarIndex;%  indices of the selected variables in the list FieldData.ListVarName
+    ivar_U=[];ivar_V=[];ivar_W=[];
+    if isfield(CellInfo{icell},'VarIndex_vector_x_tps')&&isfield(CellInfo{icell},'VarIndex_vector_y_tps')
+        ivar_U=CellInfo{icell}.VarIndex_vector_x_tps;
+        ivar_V=CellInfo{icell}.VarIndex_vector_y_tps;
+    elseif isfield(CellInfo{icell},'VarIndex_vector_x')&&isfield(CellInfo{icell},'VarIndex_vector_y')
+        ivar_U=CellInfo{icell}.VarIndex_vector_x;
+        ivar_V=CellInfo{icell}.VarIndex_vector_y;
+    end
+%     if ~isempty(VarType.vector_x_tps)&&~isempty(VarType.vector_y_tps)
+%         ivar_U=VarType.vector_x_tps;
+%         ivar_V=VarType.vector_y_tps;
+%     end
+    if isfield(CellInfo{icell},'VarIndex_vector_z')
+    ivar_W=CellInfo{icell}.VarIndex_vector_z;
+    end
+%     %type of coordinates
+%     if ~isempty(VarType.coord_x) && ~isempty(VarType.coord_y)
+%         CoordType='unstructured';
+%     elseif ~isempty(VarType.coord_tps)
+%         CoordType='tps';
+%     else
+%         CoordType='structured';
+%     end
+%     
     %dimensions
     DimCell=FieldData.VarDimName{VarIndex(1)};
@@ -1046 +1092 @@
 
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-    switch CoordType
+    switch CellInfo{icell}.CoordType
         
         %% case of input fields with unstructured coordinates
-        case 'unstructured'
+        case 'scattered'
             if strcmp(ProjMode{icell},'filter')
                 continue %skip for filter (needs tps field cell)
             end
-            coord_x=FieldData.(FieldData.ListVarName{VarType.coord_x});% initial x coordinates 
-            coord_y=FieldData.(FieldData.ListVarName{VarType.coord_y});% initial y coordinates
-            if ~isempty(VarType.coord_z)
-                coord_z=FieldData.(FieldData.ListVarName{VarType.coord_z});% initial z coordinates
+            coord_x=FieldData.(FieldData.ListVarName{CellInfo{icell}.CoordIndex(end)});% initial x coordinates 
+            coord_y=FieldData.(FieldData.ListVarName{CellInfo{icell}.CoordIndex(end-1)});% initial y coordinates
+            check3D=(numel(CellInfo{icell}.CoordIndex)==3);
+            if check3D
+                coord_z=FieldData.(FieldData.ListVarName{CellInfo{icell}.CoordIndex(1)});
             end
             
@@ -1062 +1109 @@
             coord_x=coord_x-ObjectData.Coord(1,1);
             coord_y=coord_y-ObjectData.Coord(1,2);
-            if ~isempty(VarType.coord_z)
+            if check3D
                 coord_z=coord_z-ObjectData.Coord(1,3);
             end
             
             % selection of the vectors in the projection range (3D case)
-            if ~isempty(VarType.coord_z) &&  width > 0
+            if check3D&&  width > 0
                 %components of the unitiy vector normal to the projection plane
                 fieldZ=norm_plane(1)*coord_x + norm_plane(2)*coord_y+ norm_plane(3)*coord_z;% distance to the plane
@@ -1127 +1174 @@
                 coord_X=coord_X(indcut);
                 coord_Y=coord_Y(indcut);
-                if ~isempty(VarType.coord_z)
+                if check3D
                     coord_Z=coord_Z(indcut);
                 end
@@ -1138 +1185 @@
                     for ivar=VarIndex %transfer variables to the projection plane
                         VarName=FieldData.ListVarName{ivar};
-                        if ivar==VarType.coord_x %x coordinate
+                        if ivar==CellInfo{icell}.CoordIndex(end)
                             ProjData.(VarName)=coord_X;
-                        elseif ivar==VarType.coord_y  % y coordinate
+                        elseif ivar==CellInfo{icell}.CoordIndex(end-1)  % y coordinate
                             ProjData.(VarName)=coord_Y;
-                        elseif isempty(VarType.coord_z) || ivar~=VarType.coord_z % other variables (except Z coordinate wyhich is not reproduced)
+                        elseif ~(check3D && ivar==CellInfo{icell}.CoordIndex(1)) % other variables (except Z coordinate wyhich is not reproduced)
                             ProjData.(VarName)=FieldData.(VarName);
                         end
-                        if isempty(VarType.coord_z) || ivar~=VarType.coord_z
+                        if ~(check3D && ivar==CellInfo{icell}.CoordIndex(1))
                             ProjData.ListVarName=[ProjData.ListVarName VarName];
                             ProjData.VarDimName=[ProjData.VarDimName DimCell];
@@ -1158 +1205 @@
                     coord_y_proj=YMin:DY:YMax;
                     [XI,YI]=meshgrid(coord_x_proj,coord_y_proj);
-                    if ~isempty(VarType.errorflag)
-                        VarName_FF=FieldData.ListVarName{VarType.errorflag};
+                    if isfield(CellInfo{icell},'VarIndex_errorflag')
+                        VarName_FF=FieldData.ListVarName{CellInfo{icell}.VarIndex_errorflag};
                         indsel=find(FieldData.(VarName_FF)==0);
                         coord_X=coord_X(indsel);
@@ -1166 +1213 @@
 %                     testFF=0;
 %                     nbvar=numel(ProjData.ListVarName);
-                    if isfield(VarType,'vector_x')&&isfield(VarType,'vector_y')&&~isempty(VarType.vector_x)
-                        VarName_x=FieldData.ListVarName{VarType.vector_x};
-                        VarName_y=FieldData.ListVarName{VarType.vector_y};
-                        if ~isempty(VarType.errorflag)
+                    if isfield(CellInfo{icell},'VarIndex_vector_x')&&isfield(CellInfo{icell},'VarIndex_vector_y')
+                        VarName_x=FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_x};
+                        VarName_y=FieldData.ListVarName{CellInfo{icell}.VarIndex_vector_y};
+                        if isfield(CellInfo{icell},'VarIndex_errorflag')
                             FieldData.(VarName_x)=FieldData.(VarName_x)(indsel);
                             FieldData.(VarName_y)=FieldData.(VarName_y)(indsel);
                         end
                         %FieldVar=cat(2,FieldData.(VarName_x),FieldData.(VarName_y));
-                        if ~isfield(VarType,'CheckSub') || ~VarType.CheckSub
+                        if ~isfield(CellInfo{icell},'CheckSub') || ~CellInfo{icell}.CheckSub
                             vector_x_proj=numel(ProjData.ListVarName)+1;
                             vector_y_proj=numel(ProjData.ListVarName)+2;
                         end
                     end
-                    if ~isempty(VarType.scalar)
-                        VarName_scalar=FieldData.ListVarName{VarType.scalar};
+                    if isfield(CellInfo{icell},'VarIndex_scalar')
+                        VarName_scalar=FieldData.ListVarName{CellInfo{icell}.VarIndex_scalar};
                         if ~isempty(VarType.errorflag)
                             FieldData.(VarName_scalar)=FieldData.(VarName_scalar)(indsel);
                         end
-                       % FieldVar=FieldData.(VarName_scalar);
-                    end
-                    if ~isempty(VarType.ancillary)% do not project ancillary data with interp
-                        FieldData=rmfield(FieldData,FieldData.ListVarName{VarType.ancillary});
-                    end
-                    if ~isempty(VarType.warnflag)% do not project ancillary data with interp
-                        FieldData=rmfield(FieldData,FieldData.ListVarName{VarType.warnflag});
-                    end
-                    [VarVal,ListFieldProj,VarAttribute,errormsg]=calc_field_interp([coord_X coord_Y],FieldData,VarType.Operation,XI,YI);
-                    if isfield(VarType,'CheckSub') && VarType.CheckSub && ~isempty(vector_x_proj)
+                    end
+                    if isfield(CellInfo{icell},'VarIndex_ancillary')% do not project ancillary data with interp
+                        FieldData=rmfield(FieldData,FieldData.ListVarName{CellInfo{icell}.VarIndex_ancillary});
+                    end
+                    if isfield(CellInfo{icell},'VarIndex_warnflag')% do not project ancillary data with interp
+                        FieldData=rmfield(FieldData,FieldData.ListVarName{CellInfo{icell}.VarIndex_warnflag});
+                    end
+                    [VarVal,ListFieldProj,VarAttribute,errormsg]=calc_field_interp([coord_X coord_Y],FieldData,CellInfo{icell}.Operation,XI,YI);
+                    if isfield(CellInfo{icell},'CheckSub') && CellInfo{icell}.CheckSub && ~isempty(vector_x_proj)
                         ProjData.(ProjData.ListVarName{vector_x_proj})=ProjData.(ProjData.ListVarName{vector_x_proj})-VarVal{1};
                         ProjData.(ProjData.ListVarName{vector_y_proj})=ProjData.(ProjData.ListVarName{vector_y_proj})-VarVal{2};
@@ -1242 +1288 @@
             
             %% case of input fields defined on a structured  grid
-        case 'structured'
+        case 'grid'
             
             VarName=FieldData.ListVarName{VarIndex(1)};%get the first variable of the cell to get the input matrix dimensions
@@ -1261 +1307 @@
                 end
             end
-            AYName=FieldData.ListVarName{VarType.coord(NbDim-1)};%name of input x coordinate (name preserved on projection)
-            AXName=FieldData.ListVarName{VarType.coord(NbDim)};%name of input y coordinate (name preserved on projection)
+            AYName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(NbDim-1)};%name of input x coordinate (name preserved on projection)
+            AXName=FieldData.ListVarName{CellInfo{icell}.CoordIndex(NbDim)};%name of input y coordinate (name preserved on projection)
             if testangle% TODO modify name also in case of origin shift in x or y
                 AYProjName='Y';
@@ -1287 +1333 @@
             for idim=1:NbDim %loop on space dimensions
                 test_interp(idim)=0;%test for coordiate interpolation (non regular grid), =0 by default
-                ivar=VarType.coord(idim);% index of the variable corresponding to the current dimension
+                ivar=CellInfo{icell}.CoordIndex(idim);% index of the variable corresponding to the current dimension
                 if ~isequal(ivar,0)%  a variable corresponds to the dimension #idim
-                    eval(['Coord{idim}=FieldData.' FieldData.ListVarName{ivar} ';']) ;% coord values for the input field
+                    Coord{idim}=FieldData.(FieldData.ListVarName{ivar});% coord values for the input field
                     if numel(Coord{idim})==2 %input array defined on a regular grid
                         DCoord_min(idim)=(Coord{idim}(2)-Coord{idim}(1))/DimValue(idim);
@@ -1296 +1342 @@
                         DCoord_min(idim)=min(DCoord);
                         DCoord_max=max(DCoord);
-                        %    test_direct(idim)=DCoord_max>0;% =1 for increasing values, 0 otherwise
                         if abs(DCoord_max-DCoord_min(idim))>abs(DCoord_max/1000)
                             msgbox_uvmat('ERROR',['non monotonic dimension variable # ' num2str(idim)  ' in proj_field.m'])
@@ -1383 +1428 @@
                     ProjData.ListVarName=[ProjData.ListVarName FieldData.ListVarName(VarIndex)];
                     ProjData.VarDimName=[ProjData.VarDimName FieldData.VarDimName(VarIndex)];  
+                    if isfield(FieldData,'VarAttribute')
                     ProjData.VarAttribute=[ProjData.VarAttribute FieldData.VarAttribute(VarIndex)];
+                    end
                     ProjData.(AYProjName)=FieldData.(AYName);
                     ProjData.(AXProjName)=FieldData.(AXName);
@@ -1680 +1727 @@
 %-----------------------------------------------------------------
 idimvar=0;
-[CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(FieldData);
-if ~isempty(errormsg)
-    errormsg=['error in proj_field/proj_plane:' errormsg];
-    return
-end
+% [CellVarIndex,NbDimVec,VarTypeCell,errormsg]=find_field_cells(FieldData);
+% if ~isempty(errormsg)
+%     errormsg=['error in proj_field/proj_plane:' errormsg];
+%     return
+% end
 
 % LOOP ON GROUPS OF VARIABLES SHARING THE SAME DIMENSIONS

trunk/src/read_civxdata.m

@@ -85 +85 @@
 end
 var_ind=find(vardetect);
+% for ilist=1:length(FieldNames)
+%         testinterp=~isempty(regexp(FieldNames{ilist},'(^curl|^div|strain|norm)', 'once'));%test need for gridded data
+%         if testinterp, break;end
+% end   
 for ivar=1:length(var_ind)
     Field.VarAttribute{ivar}.Role=role{var_ind(ivar)};
     Field.VarAttribute{ivar}.Mesh=0.1;%typical mesh for histograms O.1 pixel
+    if strcmp(role{var_ind(ivar)},'vector_x')
+        Field.VarAttribute{ivar}.Operation=FieldNames;
+    end
 end
 VelTypeOut=VelType;

trunk/src/struct2nc.m

@@ -137 +137 @@
 
 
+%'check_field_structure': check the validity of the field struture representation consistant with the netcdf format
+%------------------------------------------------------------------------
+% function [DataOut,errormsg]=check_field_structure(Data)
+%
+% OUTPUT:
+% DataOut: structure reproducing the input structure Data (TODO: suppress this output)
+% errormsg: error message which is not empty when the input structure does not have the right form
+%
+% INPUT:
+% Data:   structure containing 
+%         (optional) .ListGlobalAttribute: cell listing the names of the global attributes
+%                    .Att_1,Att_2... : values of the global attributes
+%         (requested)  .ListVarName: list of variable names to select (cell array of  char strings {'VarName1', 'VarName2',...} ) 
+%         (requested)  .VarDimName: list of dimension names for each element of .ListVarName (cell array of string cells)                         
+%         (requested) .Var1, .Var2....: variables (Matlab arrays) with names listed in .ListVarName
+
+
+function [errormsg,ListDimName,DimValue,VarDimIndex]=check_field_structure(Data)
+errormsg='';
+ListDimName={};
+DimValue=[]; %default
+VarDimIndex={};
+if ~isstruct(Data)
+    errormsg='input field is not a structure';
+    return
+end
+if isfield(Data,'ListVarName') && iscell(Data.ListVarName)
+    nbfield=numel(Data.ListVarName); 
+else
+    errormsg='input field does not contain the cell array of variable names .ListVarName';
+    return
+end
+%check dimension names
+if (isfield(Data,'VarDimName') && iscell(Data.VarDimName))
+    if  numel(Data.VarDimName)~=nbfield
+       errormsg=' .ListVarName and .VarDimName have different lengths';
+        return
+    end
+else
+    errormsg='input field does not contain the  cell array of dimension names .VarDimName';
+    return
+end
+% if isfield(Data,'DimValue')
+%     Data=rmfield(Data,'DimValue');
+% end
+nbdim=0;
+ListDimName={};
+
+%% main loop on the list of variables
+for ivar=1:nbfield
+    VarName=Data.ListVarName{ivar};
+    if ~isfield(Data,VarName)
+        errormsg=['the listed variable ' VarName ' is not found'];
+        return
+    end
+    sizvar=size(Data.(VarName));% sizvar = dimension of variable
+    DimCell=Data.VarDimName{ivar};
+    if ischar(DimCell)
+        DimCell={DimCell};%case of a single dimension name, defined by a string
+    elseif ~iscell(DimCell)
+        errormsg=['wrong format for .VarDimName{' num2str(ivar) ' (must be the cell of dimension names of the variable ' VarName];
+        return
+        
+    end
+    nbcoord=numel(sizvar);%nbre of coordinates for variable named VarName
+    testrange=0;
+    if numel(DimCell)==0
+        errormsg=['empty declared dimension .VarDimName{' num2str(ivar) '} for ' VarName];
+        return
+    elseif numel(DimCell)==1% one dimension declared
+        if nbcoord==2
+            if sizvar(1)==1
+                nbcoord=1;
+                sizvar(1)=sizvar(2);
+            elseif sizvar(2)==1
+                nbcoord=1;
+            else
+                errormsg=['1 dimension declared in .VarDimName{' num2str(ivar) '} inconsistent with the nbre of dimensions =2 of the variable ' VarName];
+                return
+            end
+            if sizvar(1)==2 && isequal(VarName,DimCell{1})
+                testrange=1;% test for a dimension variable representing a range 
+            end
+        else
+            errormsg=['1 dimension declared in .VarDimName{' num2str(ivar) '} inconsistent with the nbre of dimensions =' num2str(nbcoord) ' of the variable ' VarName];
+            return
+        end
+    else
+        if numel(DimCell)>nbcoord
+            sizvar(nbcoord+1:numel(DimCell))=1;% case of singleton dimensions (not seen by the function size)
+           % DimCell=DimCell(end-nbcoord+1:end)%first singleton diemensions omitted,
+        elseif nbcoord > numel(DimCell)
+            errormsg=['nbre of declared dimensions in .VarDimName{' num2str(ivar) '} smaller than the nbre of dimensions =' num2str(nbcoord) ' of the variable ' VarName];
+            return
+        end
+    end
+    DimIndex=[];
+    %for idim=1:nbcoord
+    for idim=1:numel(DimCell) %loop on the coordinates of variable #ivar
+        DimName=DimCell{idim};
+        iprev=find(strcmp(DimName,ListDimName),1);%look for dimension name DimName in the current list
+        if isempty(iprev)% append the dimension name to the current list
+            nbdim=nbdim+1;
+            RangeTest(nbdim)=0; %default
+            if sizvar(idim)==2 && strcmp(DimName,VarName)%case of a coordinate defined by the two end values (regular spacing)
+                RangeTest(nbdim)=1; %to be updated for a later variable  
+            end
+            DimValue(nbdim)=sizvar(idim);
+            ListDimName{nbdim}=DimName;
+            DimIndex=[DimIndex nbdim];
+        else % DimName is detected in the current list of dimension names
+            if ~isequal(DimValue(iprev),sizvar(idim))
+                if isequal(DimValue(iprev),2)&& RangeTest(iprev)  % the dimension has been already detected as a range [min max]
+                    DimValue(iprev)=sizvar(idim); %update with actual value
+                elseif ~testrange                
+                    errormsg=['dimension declaration inconsistent with the size =[' num2str(sizvar) '] for ' VarName];
+                    return
+                end
+            end
+            DimIndex=[DimIndex iprev];
+        end
+    end
+    VarDimIndex{ivar}=DimIndex;
+end
+DataOut=Data;

trunk/src/uvmat.m

@@ -347 +347 @@
 end
 [FileName, PathName] = uigetfile({'*.*','All Files(*.*)'},'Pick a file',oldfile);
+if ~ischar(FileName),return,end %abandon if the browser is cancelled
 fileinput=[PathName FileName];%complete file name 
-if ~exist(fileinput,'file')
-    return %abandon if the browser is cancelled
-end
 
 %% display the selected field and related information
@@ -397 +395 @@
 RootPath=get(handles.RootPath,'String');
 [FileName, PathName] = uigetfile({'*.*','All Files(*.*)'},'Pick a file',RootPath);
+if ~ischar(FileName),return,end %abandon if the browser is cancelled
 fileinput_1=[PathName FileName];%complete file name 
-if ~exist(fileinput_1,'file')
-    return %abandon of the browser is cancelled
-end
 
 % refresh the current displayed field
@@ -1286 +1282 @@
             '*.*', 'All Files (*.*)'}, ...
             'Pick a mask file *.png',FileBase);
+        if ~ischar(FileName),return,end %abandon if the browser is cancelled
         maskname=fullfile(PathName,FileName);
-        if ~exist(maskname,'file')
-            errormsg='no file browsed';
-        end
         [RootDir,SubDir,RootFile,tild,tild,tild,tild,tild,Mask.NomType]=fileparts_uvmat(maskname);
         Mask.Base=fullfile(RootDir,SubDir,RootFile);
@@ -2388 +2382 @@
 
 %% analyse input field
-test_x=0;
-test_z=0;% test for unstructured z coordinate
-[errormsg,ListDimName,DimValue,VarDimIndex]=check_field_structure(UvData.Field);% check the input field structure
-if ~isempty(errormsg)
-    errormsg=['error in uvmat/refresh_field/check_field_structure: ' errormsg];% display error
-    return
-end
-[CellVarIndex,NbDim,VarType,errormsg]=find_field_cells(UvData.Field);% analyse  the input field structure
+%test_x=0;
+%test_z=0;% test for unstructured z coordinate
+%[errormsg,ListDimName,DimValue,VarDimIndex]=check_field_structure(UvData.Field);% check the input field structure
+% if ~isempty(errormsg)
+%     errormsg=['error in uvmat/refresh_field/check_field_structure: ' errormsg];% display error
+%     return
+% end
+[CellInfo,NbDimArray,errormsg]=find_field_cells(UvData.Field);% analyse  the input field structure
 if ~isempty(errormsg)
     errormsg=['uvmat /refresh_field / find_field_cells / ' errormsg];% display error
     return
 end
-[NbDim,imax]=max(NbDim);% spatial dimension of the input field
+
+NbDim=max(NbDimArray);% spatial dimension of the input field
+imax=find(NbDimArray==NbDim);% indices of field cells to consider
 if isfield(UvData.Field,'NbDim')
-    NbDim=UvData.Field.NbDim;% deal with plane fields containing z coordinates
-end
+    NbDim=double(UvData.Field.NbDim);% deal with plane fields containing z coordinates
+end
+
 
 %% get bounds and mesh (needed  to propose default options for projection objects)
 if NbDim>1
-    XName=''; %default
-    YName='';
-    %unstructured coordinates
-    if ~isempty(VarType{imax}.coord_x)&&~isempty(VarType{imax}.coord_y)
-        XName=UvData.Field.ListVarName{VarType{imax}.coord_x};
-        YName=UvData.Field.ListVarName{VarType{imax}.coord_y};
-        test_x=1;%test for unstructured coordinates
-        if ~isempty(VarType{imax}.coord_z)
-            ZName=UvData.Field.ListVarName{VarType{imax}.coord_z};
-        else
-            NbDim=2;
-        end
-        %structured coordinate
-    elseif numel(VarType)>=imax && numel(VarType{imax}.coord)>=NbDim && VarType{imax}.coord(NbDim)>0
-        XName=UvData.Field.ListVarName{VarType{imax}.coord(NbDim)};
-        if NbDim> 1 && VarType{imax}.coord(NbDim-1)>0
-            YName=UvData.Field.ListVarName{VarType{imax}.coord(NbDim-1)}; %structured coordinates
-        end
-        DimIndex=VarDimIndex{CellVarIndex{imax}(1)}; %list of dim indices for the variable
-        nbpoints_x=DimValue(DimIndex(NbDim));
-        XMax=nbpoints_x;%default
-        XMin=1;%default
-    end
-    
+    CoordMax=zeros(1,numel(imax));
+    CoordMin=zeros(1,numel(imax));
+    for ind=1:numel(imax)
+        XName=UvData.Field.ListVarName{CellInfo{imax(ind)}.CoordIndex(end)};
+        YName=UvData.Field.ListVarName{CellInfo{imax(ind)}.CoordIndex(end-1)};
+        CoordMax(ind,1)=max(max(UvData.Field.(XName)));
+        CoordMin(ind,1)=min(min(UvData.Field.(XName)));
+        CoordMax(ind,2)=max(max(UvData.Field.(YName)));
+        CoordMin(ind,2)=min(min(UvData.Field.(YName)));
+        %         test_x=1;%test for unstructured coordinates
+        if NbDim==3
+            ZName=UvData.Field.ListVarName{CellInfo{imax(ind)}.CoordIndex(1)};
+            CoordMax(imax(ind),3)=max(max(UvData.Field.(ZName)));
+            CoordMin(ind,3)=min(min(UvData.Field.(ZName)));
+        end
+        
+        switch CellInfo{imax(ind)}.CoordType
+            
+            case 'scattered' %unstructured coordinates
+                NbPoints(ind)=CellInfo{imax(ind)}.CoordSize;% nbre of points
+                Mesh(ind)=(prod(CoordMax(ind,:)-CoordMin(ind,:))/NbPoints)^(1/NbDim); %(volume or area per point)^(1/NbDim)
+            case 'grid'%structured coordinate
+                NbPoints=CellInfo{imax(ind)}.CoordSize;% nbre of points
+                Mesh(ind)=min((CoordMax(ind,:)-CoordMin(ind,:))./NbPoints);
+                
+        end
+    end
+    UvData.Field.Mesh=min(Mesh);
+    UvData.Field.XMax=max(CoordMax(ind,1));
+    UvData.Field.XMin=min(CoordMin(ind,1));
+    UvData.Field.YMax=max(CoordMax(ind,2));
+    UvData.Field.YMin=max(CoordMin(ind,2));
     if NbDim==3
-        if ~test_x
-            ZName=UvData.Field.ListVarName{VarType{imax}.coord(1)};%structured coordinates in 3D
-        end
-        ZMax=max(UvData.Field.(ZName));
-        ZMin=min(UvData.Field.(ZName));
-        UvData.Field.ZMax=ZMax;
-        UvData.Field.ZMin=ZMin;
-        test_z=1;
-        if isequal(ZMin,ZMax)%no z dependency
-            NbDim=2;
-            test_z=0;
-        end
-    end
-    if ~isempty (XName)
-        XMax=max(max(UvData.Field.(XName)));
-        XMin=min(min(UvData.Field.(XName)));
-        UvData.Field.NbDim=NbDim;
-        UvData.Field.XMax=XMax;
-        UvData.Field.XMin=XMin;
-        if NbDim >1&& ~isempty(YName)
-            YMax=max(max(UvData.Field.(YName)));
-            YMin=min(min(UvData.Field.(YName)));
-            UvData.Field.YMax=YMax;
-            UvData.Field.YMin=YMin;
-        end
-        nbvec=length(UvData.Field.(XName));
-        if test_x %unstructured coordinates
-            if test_z
-                UvData.Field.Mesh=((XMax-XMin)*(YMax-YMin)*(ZMax-ZMin))/nbvec;% volume per vector
-                UvData.Field.Mesh=(UvData.Field.Mesh)^(1/3);
-            else
-                UvData.Field.Mesh=sqrt((XMax-XMin)*(YMax-YMin)/nbvec);%2D
-            end
-        end
-    end
-    % case of structured coordinates
-    if ~test_x
-        DX=(XMax-XMin)/(nbpoints_x-1);
-        if NbDim >1
-            nbpoints_y=DimValue(DimIndex(NbDim-1));
-            if isempty(YName)% if the y coordinate is not expressed, it is taken as the matrix index
-                DY=1;
-                UvData.Field.YMax=nbpoints_y;
-                UvData.Field.YMin=1;
-            else
-                DY=(YMax-YMin)/(nbpoints_y-1);
-            end
-        end
-        if NbDim==3
-            nbpoints_z=DimValue(DimIndex(1));
-            DZ=(ZMax-ZMin)/(nbpoints_z-1);
-            UvData.Field.Mesh=(DX*DY*DZ)^(1/3);
-            UvData.Field.ZMax=ZMax;
-            UvData.Field.ZMin=ZMin;
-        else
-            UvData.Field.Mesh=DX;%sqrt(DX*DY);
-        end
+        UvData.Field.ZMax=max(CoordMax(ind,3));
+        UvData.Field.ZMin=max(CoordMin(ind,3));
     end
     % adjust the mesh to a value 1, 2 , 5 *10^n
@@ -2664 +2614 @@
             ObjectData.A=flag_mask.*double(ObjectData.A);
             ObjectData.A=feval(AClass,ObjectData.A);
-            ind_off=[];
-            if isfield(ObjectData,'ListVarName')
-                for ilist=1:length(ObjectData.ListVarName)
-                    if isequal(ObjectData.ListVarName{ilist},'Mask')||isequal(ObjectData.ListVarName{ilist},'MaskX')||isequal(ObjectData.ListVarName{ilist},'MaskY')
-                        ind_off=[ind_off ilist];
-                    end
-                end
-                ObjectData.ListVarName(ind_off)=[];
-                VarDimIndex(ind_off)=[];
-                ind_off=[];
-                for ilist=1:length(ListDimName)
-                    if isequal(ListDimName{ilist},'MaskX') || isequal(ListDimName{ilist},'MaskY')
-                        ind_off=[ind_off ilist];
-                    end
-                end
-                ListDimName(ind_off)=[];
-                DimValue(ind_off)=[];
-            end
+%             ind_off=[];
+%             if isfield(ObjectData,'ListVarName')
+%                 for ilist=1:length(ObjectData.ListVarName)
+%                     if isequal(ObjectData.ListVarName{ilist},'Mask')||isequal(ObjectData.ListVarName{ilist},'MaskX')||isequal(ObjectData.ListVarName{ilist},'MaskY')
+%                         ind_off=[ind_off ilist];
+%                     end
+%                 end
+%                 ObjectData.ListVarName(ind_off)=[];
+%                 VarDimIndex(ind_off)=[];
+%                 ind_off=[];
+%              
+%             end
         end
         if ~isempty(ObjectData)
@@ -2752 +2696 @@
 function histo1_menu_Callback(hObject, eventdata, handles)
 %--------------------------------------------
-%plot first histo
-%huvmat=get(handles.histo1_menu,'parent');
 histo_menu=get(handles.histo1_menu,'String');
 histo_value=get(handles.histo1_menu,'Value');
 FieldName=histo_menu{histo_value};
-% update_histo(handles.HistoAxes,handles.uvmat,FieldName)
-% 
-% %------------------------------------------------------------------------
-% function histo2_menu_Callback(hObject, eventdata, handles)
-% %------------------------------------------------------------------------
-% %plot second histo
-% %huvmat=get(handles.histo2_menu,'parent');
-% histo_menu=get(handles.histo2_menu,'String');
-% histo_value=get(handles.histo2_menu,'Value');
-% FieldName=histo_menu{histo_value};
-% update_histo(handles.histo_v,handles.uvmat,FieldName)
-% 
-% %------------------------------------------------------------------------
-% %read the field .Fieldname stored in UvData and plot its histogram
-% function update_histo(haxes,huvmat,FieldName)
-%------------------------------------------------------------------------
+
 UvData=get(handles.uvmat,'UserData');
 Field=UvData.Field;
@@ -2845 +2772 @@
             set(hlegend,'String',{FieldName;FieldName_2})
         end
-%         hh=get(handles.HistoAxes,'children');
-%         get(hh(1))
-%         get(hh(2))
     end
 end
@@ -3097 +3021 @@
             '*.vol','.volume images (png)'; ...
             '*.*',  'All Files (*.*)'}, ...
-            'Pick an image',imagename);   
+            'Pick an image',imagename); 
+        if ~ischar(FileName),return,end %abandon if the browser is cancelled
         imagename=[PathName FileName];
     end
@@ -3111 +3036 @@
             '*.*',  'All Files (*.*)'}, ...
             'Pick a netcdf file',FileBase);
+        if ~ischar(FileName),return,end %abandon if the browser is cancelled
         FullFileName=[PathName FileName];
         % display the selected field and related information
@@ -3209 +3135 @@
                 '*.*',  'All Files (*.*)'}, ...
                 'Pick an image',imagename);
+            if ~ischar(FileName),return,end %abandon if the browser is cancelled
             imagename=[PathName FileName];
         end
@@ -3545 +3472 @@
         '*.*', 'All Files (*.*)'}, ...
         'Pick the transform function', prev_path);
+    if ~ischar(FileName),return,end %abandon if the browser is cancelled
     path_transform_fct =fullfile(PathName,FileName);
-    if ~exist(path_transform_fct,'file')% cancel has been activated
-        return
-    end
     if isempty(regexp(FileName,'.m$'))% detect file extension .m
         msgbox_uvmat('ERROR','a Matlab function .m must be introduced');