diff --git a/matlab/AUG/gdat_aug.m b/matlab/AUG/gdat_aug.m
index aef8d1479a724067d71c0f085ccea31c80748572..d6d598b4e59c35d361d83de60d1b206506d19a45 100644
--- a/matlab/AUG/gdat_aug.m
+++ b/matlab/AUG/gdat_aug.m
@@ -94,10 +94,10 @@ gdat_params.nverbose = 1;
 data_request_names = get_data_request_names_from_gdat_xxx(default_machine);
 % add AUG specific to all:
 if ~isempty(data_request_names.aug)
-    aug_names = fieldnames(data_request_names.aug);
-    for i=1:length(aug_names)
-        data_request_names.all.(aug_names{i}) = data_request_names.aug.(aug_names{i});
-    end
+  aug_names = fieldnames(data_request_names.aug);
+  for i=1:length(aug_names)
+    data_request_names.all.(aug_names{i}) = data_request_names.aug.(aug_names{i});
+  end
 end
 data_request_names_all = sort(fieldnames(data_request_names.all));
 
@@ -119,8 +119,8 @@ gdat_data.data_fullpath = [];
 ivarargin_first_char = 3;
 data_request_eff = '';
 if nargin>=2 && ischar(data_request);
-    data_request_eff = data_request;
-    data_request = data_request; % should not lower until see if keyword
+  data_request_eff = data_request;
+  data_request = data_request; % should not lower until see if keyword
 end
 
 gdat_data.gdat_request = data_request_names_all; % so if return early gives list of possible request names
@@ -129,149 +129,149 @@ gdat_params = gdat_data.gdat_params;
 
 % no inputs
 if nargin==0
-    % return defaults and list of keywords
-    return
+  % return defaults and list of keywords
+  return
 end
 
 do_mdsopen_mdsclose = 1;
 % treat 1st arg
 if nargin>=1
-    if isempty(shot)
-        % means mdsopen(shot) already performed
-        shot=-999; % means not defined
-        do_mdsopen_mdsclose = 0;
-    elseif isnumeric(shot)
-        gdat_data.shot = shot;
-    elseif ischar(shot)
-        ivarargin_first_char = 1;
-    else
-        if gdat_params.nverbose>=1; warning('type of 1st argument unexpected, should be numeric or char'); end
-        error_status=2;
-        return
-    end
-    if nargin==1
-        % Only shot number given. If there is a default data_request set it and continue, otherwise return
-        return
-    end
+  if isempty(shot)
+    % means mdsopen(shot) already performed
+    shot=-999; % means not defined
+    do_mdsopen_mdsclose = 0;
+  elseif isnumeric(shot)
+    gdat_data.shot = shot;
+  elseif ischar(shot)
+    ivarargin_first_char = 1;
+  else
+    if gdat_params.nverbose>=1; warning('type of 1st argument unexpected, should be numeric or char'); end
+    error_status=2;
+    return
+  end
+  if nargin==1
+    % Only shot number given. If there is a default data_request set it and continue, otherwise return
+    return
+  end
 end
 % 2nd input argument if not part of pairs
 if nargin>=2 && ivarargin_first_char~=1
-    if isempty(data_request)
-        return
+  if isempty(data_request)
+    return
+  end
+  % 2nd arg can be a structure with all options except shot_number, or a string for the pathname or keyword, or the start of pairs string/value for the parameters
+  if isstruct(data_request)
+    if ~isfield(data_request,'data_request')
+      if gdat_params.nverbose>=1; warning('expects field data_request in input parameters structure'); end
+      error_status=3;
+      return
     end
-    % 2nd arg can be a structure with all options except shot_number, or a string for the pathname or keyword, or the start of pairs string/value for the parameters
-    if isstruct(data_request)
-        if ~isfield(data_request,'data_request')
-            if gdat_params.nverbose>=1; warning('expects field data_request in input parameters structure'); end
-            error_status=3;
-            return
-        end
-        %data_request.data_request = lower(data_request.data_request);
-        data_request_eff = data_request.data_request;
-        data_request.data_request = data_request.data_request;
-        gdat_params = data_request;
+    %data_request.data_request = lower(data_request.data_request);
+    data_request_eff = data_request.data_request;
+    data_request.data_request = data_request.data_request;
+    gdat_params = data_request;
+  else
+    % since data_request is char check from nb of args if it is data_request or a start of pairs
+    if mod(nargin-1,2)==0
+      ivarargin_first_char = 2;
     else
-        % since data_request is char check from nb of args if it is data_request or a start of pairs
-        if mod(nargin-1,2)==0
-            ivarargin_first_char = 2;
-        else
-            ivarargin_first_char = 3;
-            data_request_eff = data_request;
-        end
+      ivarargin_first_char = 3;
+      data_request_eff = data_request;
     end
+  end
 end
 if ~isstruct(data_request)
-    gdat_params.data_request = data_request_eff;
+  gdat_params.data_request = data_request_eff;
 end
 
 % if start pairs from shot or data_request, shift varargin
 if ivarargin_first_char==1
-    varargin_eff{1} = shot;
-    varargin_eff{2} = data_request;
-    varargin_eff(3:nargin) = varargin(:);
+  varargin_eff{1} = shot;
+  varargin_eff{2} = data_request;
+  varargin_eff(3:nargin) = varargin(:);
 elseif ivarargin_first_char==2
-    varargin_eff{1} = data_request;
-    varargin_eff(2:nargin-1) = varargin(:);
+  varargin_eff{1} = data_request;
+  varargin_eff(2:nargin-1) = varargin(:);
 else
-    varargin_eff(1:nargin-2) = varargin(:);
+  varargin_eff(1:nargin-2) = varargin(:);
 end
 
 % extract parameters from pairs of varargin:
 if (nargin>=ivarargin_first_char)
-    if mod(nargin-ivarargin_first_char+1,2)==0
-        for i=1:2:nargin-ivarargin_first_char+1
-            if ischar(varargin_eff{i})
-                varargin_eff{i} = lower(varargin_eff{i});
-                % enforce lower case for any character driven input (only for 1st part of pair...)
-                % $$$         if ischar(varargin_eff{i+1})
-                gdat_params.(varargin_eff{i}) = varargin_eff{i+1};
-                % $$$         else
-                % $$$           gdat_params.(lower(varargin_eff{i})) = varargin_eff{i+1};
-                % $$$         end
-            else
-                if gdat_params.nverbose>=1; warning(['input argument nb: ' num2str(i) ' is incorrect, expects a character string']); end
-                error_status=401;
-                return
-            end
-        end
-    else
-        if gdat_params.nverbose>=1; warning('number of input arguments incorrect, cannot make pairs of parameters'); end
-        error_status=402;
+  if mod(nargin-ivarargin_first_char+1,2)==0
+    for i=1:2:nargin-ivarargin_first_char+1
+      if ischar(varargin_eff{i})
+        varargin_eff{i} = lower(varargin_eff{i});
+        % enforce lower case for any character driven input (only for 1st part of pair...)
+% $$$         if ischar(varargin_eff{i+1})
+        gdat_params.(varargin_eff{i}) = varargin_eff{i+1};
+% $$$         else
+% $$$           gdat_params.(lower(varargin_eff{i})) = varargin_eff{i+1};
+% $$$         end
+      else
+        if gdat_params.nverbose>=1; warning(['input argument nb: ' num2str(i) ' is incorrect, expects a character string']); end
+        error_status=401;
         return
+      end
     end
+  else
+    if gdat_params.nverbose>=1; warning('number of input arguments incorrect, cannot make pairs of parameters'); end
+    error_status=402;
+    return
+  end
 end
 data_request_eff = gdat_params.data_request; % in case was defined in pairs
 % defaults for all
 % default equil:
 if ~isfield(gdat_params,'equil');
-    gdat_params.equil = 'EQI';
-    if isfield(gdat_params,'source') && (any(strcmp(lower(gdat_params.source),'ide')) || any(strcmp(lower(gdat_params.source),'idg')) ...
-            || any(strcmp(lower(gdat_params.source),'ida')))
-        gdat_params.equil = 'IDE';
-    end
+  gdat_params.equil = 'EQI';
+  if isfield(gdat_params,'source') && (any(strcmp(lower(gdat_params.source),'ide')) || any(strcmp(lower(gdat_params.source),'idg')) ...
+          || any(strcmp(lower(gdat_params.source),'ida')))
+    gdat_params.equil = 'IDE';
+  end
 end
 % $$$ if isfield(gdat_params,'source') && (any(strcmp(lower(gdat_params.source),'tre')) || any(strcmp(lower(gdat_params.source),'tra')))
 % $$$   gdat_params.equil = 'TRE';
 % $$$ end
 extra_arg_sf2sig = '[]';
 if isfield(gdat_params,'extra_arg_sf2sig') && ~isempty(gdat_params.extra_arg_sf2sig)
-    extra_arg_sf2sig = gdat_params.extra_arg_sf2sig;
+  extra_arg_sf2sig = gdat_params.extra_arg_sf2sig;
 end
 gdat_params.extra_arg_sf2sig = extra_arg_sf2sig;
 %
 special_signal = '';
 if isfield(gdat_params,'special_signal') && ~isempty(gdat_params.special_signal)
-    special_signal = gdat_params.special_signal;
+  special_signal = gdat_params.special_signal;
 end
 gdat_params.special_signal = special_signal;
 
 % if it is a request_keyword can obtain description:
 if ischar(data_request_eff) || length(data_request_eff)==1
-    ij=strmatch(lower(data_request_eff),data_request_names_all,'exact');
+  ij=strmatch(lower(data_request_eff),data_request_names_all,'exact');
 else
-    ij=[];
+  ij=[];
 end
 
 if ~isempty(ij);
-    gdat_data.gdat_request = data_request_names_all{ij};
-    gdat_params.data_request = gdat_data.gdat_request;
-    if isfield(data_request_names.all.(data_request_names_all{ij}),'description') && ~isempty(data_request_names.all.(data_request_names_all{ij}).description)
-        % copy description of keyword
-        gdat_data.request_description = data_request_names.all.(data_request_names_all{ij}).description;
-    end
+  gdat_data.gdat_request = data_request_names_all{ij};
+  gdat_params.data_request = gdat_data.gdat_request;
+  if isfield(data_request_names.all.(data_request_names_all{ij}),'description') && ~isempty(data_request_names.all.(data_request_names_all{ij}).description)
+    % copy description of keyword
+    gdat_data.request_description = data_request_names.all.(data_request_names_all{ij}).description;
+  end
 end
 
 % special treatment if shot and data_request given within pairs
 if isfield(gdat_params,'shot')
-    shot = gdat_params.shot; % should use only gdat_params.shot but change shot to make sure
-    gdat_data.shot = gdat_params.shot;
-    gdat_params=rmfield(gdat_params,'shot');
+  shot = gdat_params.shot; % should use only gdat_params.shot but change shot to make sure
+  gdat_data.shot = gdat_params.shot;
+  gdat_params=rmfield(gdat_params,'shot');
 end
 
 if ~isfield(gdat_params,'data_request') || isempty(gdat_params.data_request)
-    % warning('input for ''data_request'' missing from input arguments') % might be correct, asking for list of requests
-    error_status=5;
-    return
+  % warning('input for ''data_request'' missing from input arguments') % might be correct, asking for list of requests
+  error_status=5;
+  return
 end
 gdat_data.gdat_params = gdat_params; % This means that before here it is gdat_params which should be updated
 
@@ -294,2611 +294,2611 @@ gdat_params = gdat_data.gdat_params;
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 % 1st treat the simplest method: "signal"
 if strcmp(mapping_for_aug.method,'signal')
-    exp_location = gdat_data.gdat_params.exp_name;
-    if ~iscell(mapping_for_aug.expression)
-        error_status = 1010;
-        disp(['expects a cell array with at least 2 cells in expression, mapping_for_aug.expression = ' mapping_for_aug.expression]);
-        if isfield(mapping_for_aug,'not_found') && mapping_for_aug.not_found
-            disp(['data request not found in aug_requests_mapping, see .data_request_names_all to see all options'])
-            gdat_data.data_request_names_all = data_request_names_all;
+  exp_location = gdat_data.gdat_params.exp_name;
+  if ~iscell(mapping_for_aug.expression)
+    error_status = 1010;
+    disp(['expects a cell array with at least 2 cells in expression, mapping_for_aug.expression = ' mapping_for_aug.expression]);
+    if isfield(mapping_for_aug,'not_found') && mapping_for_aug.not_found
+      disp(['data request not found in aug_requests_mapping, see .data_request_names_all to see all options'])
+      gdat_data.data_request_names_all = data_request_names_all;
+    end
+    return
+  elseif length(mapping_for_aug.expression)>=3 && ~isempty(mapping_for_aug.expression{3})
+    exp_location = mapping_for_aug.expression{3};
+  elseif length(mapping_for_aug.expression)>=2
+    mapping_for_aug.expression{3} = exp_location;
+  else
+    error_status = 101;
+    disp(['expects at least 2 cells in expression, mapping_for_aug.expression = ' mapping_for_aug.expression]);
+    if isfield(mapping_for_aug,'not_found') && mapping_for_aug.not_found
+      disp(['data request not found in aug_requests_mapping, see .data_request_names_all to see all options'])
+      gdat_data.data_request_names_all = data_request_names_all;
+    end
+    return
+  end
+  % allow changing main source with simple signals, 'source' parameter relates to mapping_for_aug.expression{1}
+  if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source) || ~ischar(gdat_data.gdat_params.source)
+    gdat_data.gdat_params.source = mapping_for_aug.expression{1};
+  else
+    % special case for EQI,EQH,IDE instead of IDG when FPG is present value
+    if strcmp(lower(gdat_data.gdat_params.source),'ide') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
+      gdat_data.gdat_params.source = 'IDG';
+    elseif strcmp(lower(gdat_data.gdat_params.source),'eqi') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
+      gdat_data.gdat_params.source = 'GQI';
+    elseif strcmp(lower(gdat_data.gdat_params.source),'eqh') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
+      gdat_data.gdat_params.source = 'GQH';
+    end
+    mapping_for_aug.expression{1} = gdat_data.gdat_params.source;
+  end
+  gdat_data.gdat_params.exp_name = exp_location;
+  % time interval
+  time_interval = [];
+  % extra args for rdaAUG_eff
+  if length(mapping_for_aug.expression)>=4 && ~isempty(mapping_for_aug.expression{4})
+    gdat_data.gdat_params.special_signal = mapping_for_aug.expression{4};
+  end
+  [aatmp,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},mapping_for_aug.expression{2},exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+  if error_status~=0
+    if gdat_params.nverbose>=3; disp(['error after rdaAUG in signal with data_request_eff= ' data_request_eff]); end
+    return
+  end
+  if isfield(aatmp,'data'); gdat_data.data = aatmp.data; end
+  if isfield(aatmp,'t'); gdat_data.t = aatmp.t; end
+  if isfield(aatmp,'x'); gdat_data.x = aatmp.x; end
+  if isfield(aatmp,'source'); gdat_data.source = aatmp.source; end
+  if isfield(aatmp,'dim'); gdat_data.dim = aatmp.dim; end
+  if isfield(aatmp,'dimunits'); gdat_data.dimunits = aatmp.dimunits; end
+  if isfield(aatmp,'edition_out'); gdat_data.version = aatmp.edition_out; end
+
+  switch mapping_for_aug.expression{2}
+   case 'q_sa'
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_sa_plu',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar.plu = aerr.data; end
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_sa_min',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar.min = aerr.data; end
+   case 'q_cd'
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_cd_plu',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar.plu = aerr.data; end
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_cd_min',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar.min = aerr.data; end
+   case 'li'
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'li_unc',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
+   case 'Te'
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'Te_unc',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
+   case 'ne'
+    [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'ne_unc',exp_location, ...
+          time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
+    if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
+  end
+  gdat_data.data_fullpath=mapping_for_aug.expression;
+  if isempty(aatmp.data) || (isempty(gdat_data.t) && isempty(gdat_data.x))
+    return
+  end
+  % construct .dim if not present (means coming from sf2sig)
+  if ~isfield(aatmp,'dim')
+    len_t = numel(aatmp.t);
+    len_x = numel(aatmp.x);
+    len_data= size(aatmp.data);
+    itime = find(len_data==len_t);
+    nbdims_eff = sum([size(gdat_data.data)~=1]);
+    aatmp.dim{itime} = aatmp.t;
+    aatmp.dimunits{itime} = aatmp.time_aug.unit;
+    if nbdims_eff >= 2
+      % assume area-base is main 2nd coordinate (did not find a case with 2 area-base (2 coordinates defined in addition to time) to be able to test)
+      i_x = setdiff([1:2],itime);
+      aatmp.dim{i_x} = aatmp.x;
+      if ~isempty(aatmp.area) && isfield(aatmp.area,'unit')
+        aatmp.dimunits(i_x) = aatmp.area.unit;
+      else
+        aatmp.dimunits(i_x) = {''};
+      end
+      if isempty(aatmp.dimunits{i_x}); aatmp.dimunits{i_x} = ''; end
+      for i=3:nbdims_eff
+        aatmp.dim{i} = [1:size(aatmp.data,i)];
+        aatmp.dimunits{i} = '';
+      end
+    end
+    gdat_data.dim = aatmp.dim;
+    gdat_data.dimunits = aatmp.dimunits;
+  end
+  mapping_for_aug_timedim_orig = mapping_for_aug.timedim;
+  if mapping_for_aug.timedim<=0
+    % need to guess timedim
+    if prod(size(aatmp.data)) == length(aatmp.data)
+      mapping_for_aug.timedim = 1;
+    elseif length(size(aatmp.data))==2
+      % 2 true dimensions
+      if length(aatmp.t) == size(aatmp.data,1)
+        mapping_for_aug.timedim = 1;
+      else
+        mapping_for_aug.timedim = 2;
+      end
+    else
+      % more than 2 dimensions, find the one with same length to define timedim
+      mapping_for_aug.timedim = find(size(aatmp.data)==length(aatmp.t));
+      if length(mapping_for_aug.timedim); mapping_for_aug.timedim = mapping_for_aug.timedim(1); end
+    end
+    mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
+  end
+  if length(size(aatmp.data))==1 | (length(size(aatmp.data))==2 & size(aatmp.data,2)==1)
+    gdat_data.dim=[{aatmp.t}];
+    gdat_data.dimunits={'time [s]'};
+  elseif length(size(aatmp.data))==2
+    gdat_data.dim{mapping_for_aug.timedim} = gdat_data.t;
+    gdat_data.dimunits{mapping_for_aug.timedim} = 'time [s]';
+    if isfield(aatmp, 'source')
+      gdat_data.dim{setdiff([1:2],mapping_for_aug.timedim)} = gdat_data.source;
+    else
+      gdat_data.dim{setdiff([1:2],mapping_for_aug.timedim)} = gdat_data.x;
+    end
+  else
+    gdat_data.dim{mapping_for_aug.timedim} = gdat_data.t;
+    gdat_data.dimunits{mapping_for_aug.timedim} = 'time [s]';
+    nbdims = length(size(gdat_data.data));
+    % should copy dims from aatmp but skip time dm already set
+    if numel(aatmp.dim) ~= nbdims
+      error(['in gdat_aug: numel(aatmp.dim)(=',num2str(numel(aatmp.dim)),') ~= nbdims(=',num2str(nbdims),')']);
+    else
+      iotherdims = setdiff([1:nbdims],mapping_for_aug.timedim);
+      % set 1st non-time dim to .x
+      if ~isequal(aatmp.x,aatmp.dim{iotherdims(1)}); warning('aatmp.x was not 1st non-time dim'); end
+      gdat_data.dim(iotherdims) = aatmp.dim(iotherdims);
+      gdat_data.dimunits(iotherdims) = aatmp.dimunits(iotherdims);
+      gdat_data.x = gdat_data.dim{iotherdims(1)};
+      % often time as 1st dim, but would be more "our" standard as 2nd dim, at this stage change systematically
+      if mapping_for_aug_timedim_orig <= 0 && mapping_for_aug.timedim==1
+        % switch 1st two dimensions
+        adim = gdat_data.dim;
+        gdat_data.dim(1:2) = adim([2 1]);
+        adimunits = gdat_data.dimunits;
+        gdat_data.dimunits(1:2) = adimunits([2 1]);
+        mapping_for_aug.timedim = 2;
+        mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
+        if numel(size(gdat_data.dim{1}))==2; gdat_data.dim{1} = gdat_data.dim{1}'; end
+        gdat_data.x = gdat_data.dim{1};
+        gdat_data.t = gdat_data.dim{mapping_for_aug.timedim};
+        adata = gdat_data.data;
+        gdat_data.data = permute(adata,[2 1 3:numel(size(adata))]);
+      end
+    end
+  end
+  nbdims = length(gdat_data.dim);
+  gdat_data.units = aatmp.units;
+  if mapping_for_aug.gdat_timedim>0 && mapping_for_aug.gdat_timedim ~= mapping_for_aug.timedim
+    % shift timedim to gdat_timedim data(i,j,...itime,k,...) -> data(i,inewtime,j,...,k,...)
+    % note that this means that gdat_data.x and gdat_data.t are same and correct,
+    % only .data, .dim and .dimunits need to be changed
+    iprev=[1:nbdims];
+    ij=find(dim_nontim>mapping_for_aug.gdat_timedim-1);
+    inew=[1:mapping_for_aug.gdat_timedim-1 mapping_for_aug.timedim dim_nontim(ij)];
+    data_sizes = size(aatmp.data);
+    gdat_data.data = NaN*ones(data_sizes(inew));
+    abcol=ones(1,nbdims)*double(':'); abcomma=ones(1,nbdims)*double(',');
+    dimstr_prev=['(' repmat(':,',1,mapping_for_aug.timedim-1) 'it,' ...
+                 repmat(':,',1,nbdims-mapping_for_aug.timedim-1) ':)'];
+    dimstr_new=['(' repmat(':,',1,mapping_for_aug.gdat_timedim-1) 'it,' ...
+                repmat(':,',1,nbdims-mapping_for_aug.gdat_timedim-1) ':)'];
+    % eval gdat_data.data(;,:,...,it,...) = aatmp.data(:,:,:,it,...);
+    for it=1:size(aatmp.data,mapping_for_aug.timedim)
+      shift_eval = ['gdat_data.data' dimstr_new ' = aatmp.data'  dimstr_prev ';'];
+      eval(shift_eval);
+    end
+    gdat_data.dim = aatmp.dim(inew);
+    % gdat_data.dimunits = aatmp.dimunits(inew);
+  else
+    mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
+  end
+  % end of method "signal"
+
+  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+elseif strcmp(mapping_for_aug.method,'expression')
+  % 2nd: method="expression"
+  % assume expression contains an expression to evaluate and which creates a local structure into variable gdat_tmp
+  % we copy the structure, to make sure default nodes are defined and to avoid if return is an closed object like tdi
+  % eval_expr = [mapping_for_aug.expression ';'];
+  gdata_data_orig = gdat_data;
+  fields_to_copy = {'gdat_params', 'gdat_request', 'label', 'data_fullpath', 'request_description', 'mapping_for'};
+  eval([mapping_for_aug.expression ';']);
+  for i=1:length(fields_to_copy)
+    if isfield(gdata_data_orig,fields_to_copy{i})
+      gdat_tmp.(fields_to_copy{i}) = gdata_data_orig.(fields_to_copy{i});
+    end
+  end
+  if isempty(gdat_tmp) || (~isstruct(gdat_tmp) & ~isobject(gdat_tmp))
+    if (gdat_params.nverbose>=1); warning(['expression does not create a gdat_tmp structure: ' mapping_for_aug.expression]); end
+    error_status=801;
+    return
+  end
+  tmp_fieldnames = fieldnames(gdat_tmp);
+  if sum(strcmp(tmp_fieldnames,'data'))==0 % note: cannot do isfield since gdat_tmp might be an object
+    if (gdat_params.nverbose>=1); warning(['expression does not return a child name ''data'' for ' data_request_eff]); end
+  end
+  for i=1:length(tmp_fieldnames)
+    gdat_data.(tmp_fieldnames{i}) = gdat_tmp.(tmp_fieldnames{i});
+  end
+  % add .t and .x in case only dim is provided
+  % do not allow shifting of timedim since should be treated in the relevant expression
+  ijdim=find(strcmp(tmp_fieldnames,'dim')==1);
+  if ~isempty(ijdim)
+    nbdims = length(gdat_data.dim);
+    if mapping_for_aug.timedim==-1;
+      mapping_for_aug.timedim = nbdims;
+      if (size(gdat_data.data,nbdims)==1 && nbdims>1); mapping_for_aug.timedim = nbdims-1; end
+    end
+    dim_nontim = setdiff([1:nbdims],mapping_for_aug.timedim);
+    ijt=find(strcmp(tmp_fieldnames,'t')==1);
+    if isempty(ijt)
+      gdat_data.t = gdat_data.dim{mapping_for_aug.timedim};
+    end
+    ijx=find(strcmp(tmp_fieldnames,'x')==1);
+    if isempty(ijx)
+      if ~isempty(dim_nontim)
+        % since most cases have at most 2d, copy as array if data is 2D and as cell if 3D or more
+        if length(dim_nontim)==1
+          gdat_data.x = gdat_data.dim{dim_nontim(1)};
+        else
+          gdat_data.x = gdat_data.dim(dim_nontim);
         end
+      end
+    end
+    gdat_data.data_fullpath=mapping_for_aug.expression;
+  end
+  % end of method "expression"
+
+  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+elseif strcmp(mapping_for_aug.method,'switchcase')
+  switch data_request_eff % not lower(...) since data_request_eff should be lower case already at this stage
+   case {'cxrs', 'cxrs_rho'}
+    % if 'fit' option is added: 'fit',1, then the fitted profiles are returned which means "_rho" is effectively called
+    if ~isfield(gdat_data.gdat_params,'fit') || isempty(gdat_data.gdat_params.fit) || ~isnumeric(gdat_data.gdat_params.fit)
+      if strcmp(data_request_eff,'cxrs')
+        gdat_data.gdat_params.fit = 0;
+      else
+        gdat_data.gdat_params.fit = 1; % add fit as default if cxrs_rho requested (since equil takes most time)
+      end
+    elseif gdat_data.gdat_params.fit==1
+      data_request_eff = 'cxrs_rho';
+    end
+    exp_name_eff = gdat_data.gdat_params.exp_name;
+    sources_available = {'CEZ', 'CMZ', 'CUZ',    'COZ'};
+    r_node_available = {'R_time', 'R', 'R_time', 'R_time'};
+    z_node_available = {'z_time', 'z', 'z_time', 'z_time'};
+    % scroll through list up to first available when no sources provided
+    sources_available_for_scroll = {'CEZ', 'CUZ', 'COZ'};
+    scroll_through_list = 0;
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = sources_available_for_scroll(1);
+      scroll_through_list = 1; % means scroll through sources until one is available
+    elseif ischar(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
+    end
+    if length(gdat_data.gdat_params.source)==1
+      if strcmp(upper(gdat_data.gdat_params.source{1}),'CEZ')
+        gdat_data.gdat_params.source = {'CEZ'};
+      elseif strcmp(upper(gdat_data.gdat_params.source{1}),'CMZ')
+        gdat_data.gdat_params.source = {'CMZ'};
+      elseif strcmp(upper(gdat_data.gdat_params.source{1}),'CUZ')
+        gdat_data.gdat_params.source = {'CUZ'};
+      elseif strcmp(upper(gdat_data.gdat_params.source{1}),'COZ')
+        gdat_data.gdat_params.source = {'COZ'};
+      elseif strcmp(upper(gdat_data.gdat_params.source{1}),'ALL')
+        gdat_data.gdat_params.source = sources_available;
+        scroll_through_list = 2; % means scroll through all sources and load all sources
+      else
+        warning(['source = ' gdat_data.gdat_params.source ' not expected with data_request= ' data_request_eff]);
         return
-    elseif length(mapping_for_aug.expression)>=3 && ~isempty(mapping_for_aug.expression{3})
-        exp_location = mapping_for_aug.expression{3};
-    elseif length(mapping_for_aug.expression)>=2
-        mapping_for_aug.expression{3} = exp_location;
+      end
     else
-        error_status = 101;
-        disp(['expects at least 2 cells in expression, mapping_for_aug.expression = ' mapping_for_aug.expression]);
-        if isfield(mapping_for_aug,'not_found') && mapping_for_aug.not_found
-            disp(['data request not found in aug_requests_mapping, see .data_request_names_all to see all options'])
-            gdat_data.data_request_names_all = data_request_names_all;
+      sources_in = intersect(sources_available,upper(gdat_data.gdat_params.source));
+      if length(sources_in) ~= length(gdat_data.gdat_params.source)
+        disp('following sources not yet available, check with O. Sauter if need be')
+        setdiff(upper(gdat_data.gdat_params.source),sources_available)
+      end
+      gdat_data.gdat_params.source = sources_in;
+    end
+    extra_arg_sf2sig_eff_string = '';
+    if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
+      extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
+    end
+    % set starting source
+    i_count = 1;
+    diag_name = gdat_data.gdat_params.source{i_count};
+    sources_tried{i_count} = diag_name;
+    iload = 1;
+    iequil = 0;
+    while iload==1
+      ishotfile_ok = 1;
+      i_source = strmatch(diag_name,sources_available);
+      r_node = r_node_available{i_source};
+      z_node = z_node_available{i_source};
+      % R, Z positions of measurements
+      try
+        % eval(['[r_time]=sf2ab(diag_name,shot,r_node,''-exp'',exp_name_eff' extra_arg_sf2sig_eff_string ');']);
+        % both for CEZ and CMZ, and.. Ti:1 is ok, otherwise introduce string above
+        [r_time,err]=rdaAUG_eff(shot,diag_name,'Ti',exp_name_eff,[],extra_arg_sf2sig_eff_string,['area-base:' r_node ':1']);
+      catch ME_R_time
+        % assume no shotfile
+        disp(getReport(ME_R_time))
+        ishotfile_ok = 0;
+      end
+      if ishotfile_ok == 1
+        gdat_data.r = r_time.data;
+        inotok=find(gdat_data.r<=0);
+        gdat_data.r(inotok) = NaN;
+        try
+          if [exist('sf2sig')==3]
+            [z_time,err]=rdaAUG_eff(shot,diag_name,'z_time',exp_name_eff,[],extra_arg_sf2sig_eff_string,['area-base:' z_node ':1']);
+          else
+            [z_time,err]=rdaAUG_eff(shot,diag_name,'z_time',exp_name_eff,[],extra_arg_sf2sig_eff_string);
+          end
+          gdat_data.z = z_time.data;
+          inotok=find(gdat_data.z<=0);
+          gdat_data.z(inotok) = NaN;
+        catch ME_R_time
+          disp(getReport(ME_R_time))
+          ishotfile_ok = 0;
+        end
+      else
+        gdat_data.r = [];
+        gdat_data.z = [];
+      end
+      if ishotfile_ok == 1
+        try
+          % eval(['[time]=sf2tb(diag_name,shot,''time'',''-exp'',exp_name_eff' extra_arg_sf2sig_eff_string ');']);
+          if [exist('sf2sig')==3]
+            [time,err] = rdaAUG_eff(shot,diag_name,'time',exp_name_eff,[],extra_arg_sf2sig_eff_string,'time-base:time:0');
+          else
+            time.data = r_time.t;
+          end
+          gdat_data.t = time.data;
+        catch ME_R_time
+          disp(getReport(ME_R_time))
+          ishotfile_ok = 0;
+        end
+      else
+        gdat_data.t = [];
+      end
+      gdat_data.dim{1} = {gdat_data.r , gdat_data.z};
+      gdat_data.dimunits{1} = 'R, Z [m]';
+      gdat_data.dim{2} = gdat_data.t;
+      gdat_data.dimunits{2} = 't [s]';
+      gdat_data.x = gdat_data.dim{1};
+      % vrot
+      if ishotfile_ok == 1
+        try
+          [a,error_status]=rdaAUG_eff(shot,diag_name,'vrot',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+          if isempty(a.data) || isempty(a.t) || error_status>0
+            if gdat_params.nverbose>=3;
+              a
+              disp(['with data_request= ' data_request_eff])
+            end
+          end
+          [aerr,e]=rdaAUG_eff(shot,diag_name,'err_vrot',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+        catch ME_vrot
+          disp(getReport(ME_vrot))
+          ishotfile_ok = 0;
+        end
+        gdat_data.vrot.data = a.data;
+        gdat_data.vrot.error_bar = aerr.data;
+      else
+        gdat_data.vrot.data = [];
+        gdat_data.vrot.error_bar = [];
+      end
+      a.name = 'vrot';
+      if any(strcmp(fieldnames(a),'units')); gdat_data.vrot.units=a.units; end
+      if any(strcmp(fieldnames(a),'name')); gdat_data.vrot.name=a.name; end
+      gdat_data.vrot.label = 'vrot_tor';
+      % Ti
+      %     [a,e]=rdaAUG_eff(shot,diag_name,'Ti',exp_name_eff);
+      %     [aerr,e]=rdaAUG_eff(shot,diag_name,'err_Ti',exp_name_eff);
+      if ishotfile_ok == 1
+        try
+          [a,e]=rdaAUG_eff(shot,diag_name,'Ti_c',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+          [aerr,e]=rdaAUG_eff(shot,diag_name,'err_Ti_c',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+        catch ME_ti
+          disp(getReport(ME_ti))
+          ishotfile_ok = 0;
+        end
+        gdat_data.ti.data = a.data;
+        gdat_data.ti.error_bar = aerr.data;
+      else
+        gdat_data.ti.data = [];
+        gdat_data.ti.error_bar = [];
+      end
+      a.name = 'Ti_c';
+      if any(strcmp(fieldnames(a),'units')); gdat_data.ti.units=a.units; end
+      if any(strcmp(fieldnames(gdat_data.ti),'units')); gdat_data.units=gdat_data.ti.units; end
+      if any(strcmp(fieldnames(a),'name')); gdat_data.ti.name=a.name; end
+      gdat_data.ti.label = 'Ti_c';
+      % main node ti a this stage
+      gdat_data.data = gdat_data.ti.data;
+      gdat_data.label = [gdat_data.label '/Ti'];
+      gdat_data.error_bar = gdat_data.ti.error_bar;
+      gdat_data.data_fullpath=[exp_name_eff '/' diag_name '/' a.name ';vrot, Ti in data, {r;z} in .x'];
+      %
+      if strcmp(data_request_eff,'cxrs_rho')
+        % defaults
+        if iequil == 0
+          gdat_data.equil.data = [];
+          gdat_data.psi = [];
+          gdat_data.rhopolnorm = [];
+          gdat_data.rhotornorm = [];
+          gdat_data.rhovolnorm = [];
+          % defaults for fits, so user always gets std structure
+          gdat_data.fit.rhotornorm = []; % same for both ti and vrot
+          gdat_data.fit.rhopolnorm = [];
+          gdat_data.fit.t = [];
+          gdat_data.fit.ti.data = [];
+          gdat_data.fit.ti.drhotornorm = [];
+          gdat_data.fit.vrot.data = [];
+          gdat_data.fit.vrot.drhotornorm = [];
+          gdat_data.fit.raw.rhotornorm = [];
+          gdat_data.fit.raw.ti.data = [];
+          gdat_data.fit.raw.vrot.data = [];
+          fit_tension_default = -1;
+          if isfield(gdat_data.gdat_params,'fit_tension')
+            fit_tension = gdat_data.gdat_params.fit_tension;
+          else
+            fit_tension = fit_tension_default;
+          end
+          if ~isstruct(fit_tension)
+            fit_tension_eff.ti = fit_tension;
+            fit_tension_eff.vrot = fit_tension;
+            fit_tension = fit_tension_eff;
+          else
+            if ~isfield(fit_tension,'ti'); fit_tension.ti = fit_tension_default; end
+            if ~isfield(fit_tension,'vrot '); fit_tension.vrot = fit_tension_default; end
+          end
+          gdat_data.gdat_params.fit_tension = fit_tension;
+          if isfield(gdat_data.gdat_params,'fit_nb_rho_points')
+            fit_nb_rho_points = gdat_data.gdat_params.fit_nb_rho_points;
+          else
+            fit_nb_rho_points = 201;
+          end
+          gdat_data.gdat_params.fit_nb_rho_points = fit_nb_rho_points;
+        end
+        if ishotfile_ok == 1 && iequil == 0
+          params_equil = gdat_data.gdat_params;
+          params_equil.data_request = 'equil';
+          [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
+          if error_status>0
+            if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
+            return
+          end
+          iequil = 1;
+          gdat_data.gdat_params.equil = params_equil.equil;
+          gdat_data.equil = equil;
+          inb_chord_cxrs=size(gdat_data.data,1);
+          inb_time_cxrs=size(gdat_data.data,2);
+          psi_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
+          rhopolnorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
+          rhotornorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
+          rhovolnorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
+          % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
+          time_equil=[min(gdat_data.t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.t(end)+0.1)];
+          iok=find(~isnan(gdat_data.r(:,1)));
+          for itequil=1:length(time_equil)-1
+            rr=equil.Rmesh(:,itequil);
+            zz=equil.Zmesh(:,itequil);
+            psirz_in = equil.psi2D(:,:,itequil);
+            it_cxrs_inequil = find(gdat_data.t>time_equil(itequil) & gdat_data.t<=time_equil(itequil+1));
+            if ~isempty(it_cxrs_inequil)
+              if ~strcmp(upper(gdat_data.gdat_params.source),'CMZ')
+                rout=gdat_data.r(iok);
+                zout=gdat_data.z(iok);
+              else
+                rout=gdat_data.r(iok,it_cxrs_inequil);
+                zout=gdat_data.z(iok,it_cxrs_inequil);
+              end
+              psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout,zout);
+              if ~strcmp(upper(gdat_data.gdat_params.source),'CMZ')
+                psi_out(iok,it_cxrs_inequil) = repmat(psi_at_routzout,[1,length(it_cxrs_inequil)]);
+              else
+                psi_out(iok,it_cxrs_inequil) = reshape(psi_at_routzout,length(iok),length(it_cxrs_inequil));
+              end
+              rhopolnorm_out(iok,it_cxrs_inequil) = sqrt((psi_out(iok,it_cxrs_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
+              for it_cx=1:length(it_cxrs_inequil)
+                rhotornorm_out(iok,it_cxrs_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out(iok,it_cxrs_inequil(it_cx)),-3,[2 2],[0 1]);
+                rhovolnorm_out(iok,it_cxrs_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out(iok,it_cxrs_inequil(it_cx)),-3,[2 2],[0 1]);
+              end
+            end
+          end
+          gdat_data.psi = psi_out;
+          gdat_data.rhopolnorm = rhopolnorm_out;
+          gdat_data.rhotornorm = rhotornorm_out;
+          gdat_data.rhovolnorm = rhovolnorm_out;
+          aaa.shot = gdat_data.shot;
+          aaa.data = gdat_data.data;
+          aaa.x = gdat_data.rhopolnorm;
+          aaa.t = gdat_data.t;
+          aaa.gdat_params = gdat_data.gdat_params;
+          aaa = get_grids_1d(aaa,2,1);
+          gdat_data.grids_1d = aaa.grids_1d;
+          %
+          if gdat_data.gdat_params.fit==1
+            % add fits
+            gdat_data.fit.raw.rhotornorm = NaN*ones(size(gdat_data.ti.data));
+            gdat_data.fit.raw.ti.data = NaN*ones(size(gdat_data.ti.data));
+            gdat_data.fit.raw.vrot.data = NaN*ones(size(gdat_data.vrot.data));
+            rhotornormfit = linspace(0,1,fit_nb_rho_points)';
+            gdat_data.fit.rhotornorm = rhotornormfit;
+            gdat_data.fit.t = gdat_data.t;
+            for it=1:length(gdat_data.t)
+              % make rhotor->rhopol transformation for each time since equilibrium might have changed
+              gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
+          gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
+              idata = find(gdat_data.ti.data(:,it)>0 & gdat_data.rhotornorm(:,it)<1.01);
+              if length(idata)>0
+                gdat_data.fit.ti.raw.rhotornorm(idata,it) = gdat_data.rhotornorm(idata,it);
+                gdat_data.fit.ti.raw.data(idata,it) = gdat_data.ti.data(idata,it);
+                gdat_data.fit.ti.raw.error_bar(idata,it) = gdat_data.ti.error_bar(idata,it);
+                gdat_data.fit.vrot.raw.rhotornorm(idata,it) = gdat_data.rhotornorm(idata,it);
+                gdat_data.fit.vrot.raw.data(idata,it) = gdat_data.vrot.data(idata,it);
+                gdat_data.fit.vrot.raw.error_bar(idata,it) = gdat_data.vrot.error_bar(idata,it);
+                [rhoeff,irhoeff] = sort(gdat_data.rhotornorm(idata,it));
+                rhoeff = [0; rhoeff];
+                % they are some strange low error_bars, so remove these by max(Ti/error_bar)<=10; and changing it to large error bar
+                tieff = gdat_data.ti.data(idata(irhoeff),it);
+                ti_err_eff = gdat_data.ti.error_bar(idata(irhoeff),it);
+                ij=find(tieff./ti_err_eff>10.);
+                if ~isempty(ij); ti_err_eff(ij) = tieff(ij)./0.1; end
+                vroteff = gdat_data.vrot.data(idata(irhoeff),it);
+                vrot_err_eff = gdat_data.vrot.error_bar(idata(irhoeff),it);
+                ij=find(vroteff./vrot_err_eff>10.);
+                if ~isempty(ij); vrot_err_eff(ij) = vroteff(ij)./0.1; end
+                %
+                tieff =  [tieff(1); tieff];
+                ti_err_eff =  [1e4; ti_err_eff];
+                vroteff =  [vroteff(1); vroteff];
+                vrot_err_eff =  [1e5; vrot_err_eff];
+                [gdat_data.fit.ti.data(:,it), gdat_data.fit.ti.drhotornorm(:,it)] = interpos(rhoeff,tieff,rhotornormfit,fit_tension.ti,[1 0],[0 0],ti_err_eff);
+                [gdat_data.fit.vrot.data(:,it), gdat_data.fit.vrot.drhotornorm(:,it)] = interpos(rhoeff,vroteff,rhotornormfit,fit_tension.vrot,[1 0],[0 0],vrot_err_eff);
+              end
+            end
+          end
+        end
+      end
+      if scroll_through_list == 0 || scroll_through_list == 2
+        if scroll_through_list == 2
+          tmp.(diag_name) = gdat_data;
+        end
+        if length(gdat_data.gdat_params.source) > i_count
+          i_count = i_count + 1;
+          diag_name = gdat_data.gdat_params.source{i_count};
+        else
+          iload = 0;
+        end
+      elseif scroll_through_list == 1
+        if ishotfile_ok == 1
+          iload = 0;
+        else
+          sources_remaining = setdiff(sources_available_for_scroll,sources_tried,'stable');
+          if ~isempty(sources_remaining)
+            i_count = i_count + 1;
+            diag_name = sources_remaining{1};
+            sources_tried{i_count} = diag_name;
+          else
+            iload = 0;
+          end
         end
+      else
+        disp('should not arrive here, check value of scroll_through_list')
+        scroll_through_list
+        iload = 0;
+      end
+    end
+    if scroll_through_list == 2
+      tmp_field=fieldnames(tmp);
+      for i=1:length(tmp_field)
+        gdat_data.(tmp_field{i}) = tmp.(tmp_field{i});
+      end
+    end
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'ece', 'eced', 'ece_rho', 'eced_rho'}
+    nth_points = 13;
+    if isfield(gdat_data.gdat_params,'nth_points') && ~isempty(gdat_data.gdat_params.nth_points)
+      nth_points = gdat_data.gdat_params.nth_points;
+    else
+      gdat_data.gdat_params.nth_points = nth_points;
+    end
+    channels = -1;
+    if isfield(gdat_data.gdat_params,'channels') && ~isempty(gdat_data.gdat_params.channels)
+      channels = gdat_data.gdat_params.channels;
+    end
+    if nth_points>=10
+      match_rz_to_time = 1;
+    else
+      match_rz_to_time = 0;
+    end
+    if isfield(gdat_data.gdat_params,'match_rz_to_time') && ~isempty(gdat_data.gdat_params.match_rz_to_time)
+      match_rz_to_time = gdat_data.gdat_params.match_rz_to_time;
+    else
+      gdat_data.gdat_params.match_rz_to_time = match_rz_to_time;
+    end
+    time_interval = [];
+    if isfield(gdat_data.gdat_params,'time_interval') && ~isempty(gdat_data.gdat_params.time_interval)
+      time_interval = gdat_data.gdat_params.time_interval;
+    else
+      gdat_data.gdat_params.time_interval = time_interval;
+    end
+    %
+    if isfield(gdat_data.gdat_params,'diag_name') && ~isempty(gdat_data.gdat_params.diag_name)
+      diag_name = gdat_data.gdat_params.diag_name;
+      if strcmp(upper(diag_name),'RMD'); gdat_data.gdat_params.exp_name = 'ECED'; end
+    else
+      diag_name = 'CEC';
+      gdat_data.gdat_params.diag_name = diag_name;
+    end
+    exp_name_eff = gdat_data.gdat_params.exp_name;
+    if strcmp(data_request_eff,'eced')
+      exp_name_eff = 'ECED';
+      gdat_data.gdat_params.exp_name = exp_name_eff;
+    end
+    [a,e]=rdaAUG_eff(shot,diag_name,'Trad-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
+    % [a,e]=rdaAUG_eff(shot,diag_name,'Trad-A',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    inb_chord = size(a.data,1);
+    if channels(1)<=0
+      channels = [1:inb_chord];
+    end
+    gdat_data.dim{1} = channels;
+    gdat_data.gdat_params.channels = channels;
+    if nth_points>1
+      gdat_data.data = a.data(channels,1:nth_points:end);
+      gdat_data.dim{2} = a.t(1:nth_points:end);
+    else
+      gdat_data.data = a.data(channels,:);
+      gdat_data.dim{2} = a.t;
+    end
+    gdat_data.x = gdat_data.dim{1};
+    gdat_data.t = gdat_data.dim{2};
+    gdat_data.dimunits=[{'channels'} ; {'time [s]'}];
+    if any(strcmp(fieldnames(a),'units')); gdat_data.units=a.units; end
+    try
+      [aR,e]=rdaAUG_eff(shot,diag_name,'R-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
+    catch
+    end
+    try
+      [aZ,e]=rdaAUG_eff(shot,diag_name,'z-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
+    catch
+      disp(['problem with getting z-A in ' diag_name])
+    end
+    if match_rz_to_time
+      % interpolate R structure on ece data time array, to ease plot vs R
+      for i=1:length(channels)
+        radius.data(i,:) = interp1(aR.t,aR.data(channels(i),:),gdat_data.t);
+        zheight.data(i,:) = interp1(aZ.t,aZ.data(channels(i),:),gdat_data.t);
+      end
+      radiuszheight.t=gdat_data.t;
+    else
+      radius.data = aR.data(channels,:);
+      radiuszheight.t=aR.t;
+      zheight.data = aZ.data(channels,:);
+    end
+    ij=find(gdat_data.data<=0);
+    gdat_data.data(ij)=NaN;
+    gdat_data.rz.r=radius.data;
+    gdat_data.rz.z=zheight.data;
+    gdat_data.rz.t = radiuszheight.t;
+    gdat_data.data_fullpath = [exp_name_eff '/' diag_name '/Trad-A with R, Z in .r,.z'];
+
+    if strcmp(data_request_eff,'ece_rho') || strcmp(data_request_eff,'eced_rho')
+      params_equil = gdat_data.gdat_params;
+      params_equil.data_request = 'equil';
+      [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
+      if error_status>0
+        if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
         return
+      end
+      gdat_data.gdat_params.equil = params_equil.equil;
+      gdat_data.equil = equil;
+      gdat_data.data_fullpath = [exp_name_eff '/' diag_name '/Trad-A with .r,.z projected on equil ' gdat_data.gdat_params.equil ' in .rhos'];
+      inb_chord_ece=size(gdat_data.rz.r,1);
+      inb_time_ece=size(gdat_data.rz.r,2);
+      psi_out = NaN*ones(inb_chord_ece,inb_time_ece);
+      rhopolnorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
+      rhotornorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
+      rhovolnorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
+      % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
+      time_equil=[min(gdat_data.rz.t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.rz.t(end)+0.1)];
+      for itequil=1:length(time_equil)-1
+        rr=equil.Rmesh(:,itequil);
+        zz=equil.Zmesh(:,itequil);
+        psirz_in = equil.psi2D(:,:,itequil);
+        it_ece_inequil = find(gdat_data.rz.t>time_equil(itequil) & gdat_data.rz.t<=time_equil(itequil+1));
+        if ~isempty(it_ece_inequil)
+          r_it_ece_inequil = gdat_data.rz.r(:,it_ece_inequil);
+          iok = find(~isnan(r_it_ece_inequil) & r_it_ece_inequil>0);
+          if ~isempty(iok)
+            rout=r_it_ece_inequil(iok);
+            z_it_ece_inequil = gdat_data.rz.z(:,it_ece_inequil);
+            zout=z_it_ece_inequil(iok);
+            psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout,zout);
+            [ieff,jeff]=ind2sub(size(gdat_data.rz.r(:,it_ece_inequil)),iok);
+            for ij=1:length(iok)
+              psi_out(ieff(ij),it_ece_inequil(jeff(ij))) = psi_at_routzout(ij);
+            end
+            rhopolnorm_out(:,it_ece_inequil) = sqrt(abs((psi_out(:,it_ece_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil))));
+            for it_cx=1:length(it_ece_inequil)
+              rhotornorm_out(:,it_ece_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out(:,it_ece_inequil(it_cx)),-3,[2 2],[0 1]);
+              rhovolnorm_out(:,it_ece_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out(:,it_ece_inequil(it_cx)),-3,[2 2],[0 1]);
+            end
+          end
+        end
+      end
+      gdat_data.rhos.psi = psi_out;
+      gdat_data.rhos.rhopolnorm = rhopolnorm_out;
+      gdat_data.rhos.rhotornorm = rhotornorm_out;
+      gdat_data.rhos.rhovolnorm = rhovolnorm_out;
+      gdat_data.rhos.t = gdat_data.rz.t;
     end
-    % allow changing main source with simple signals, 'source' parameter relates to mapping_for_aug.expression{1}
-    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source) || ~ischar(gdat_data.gdat_params.source)
-        gdat_data.gdat_params.source = mapping_for_aug.expression{1};
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'eqdsk'}
+    %
+    time_eqdsks=1.; % default time
+    if isfield(gdat_data.gdat_params,'time') && ~isempty(gdat_data.gdat_params.time)
+      time_eqdsks = gdat_data.gdat_params.time;
+    else
+      gdat_data.gdat_params.time = time_eqdsks;
+      disp(['"time" is expected as an option, choose default time = ' num2str(time_eqdsks)]);
+    end
+    gdat_data.gdat_params.time = time_eqdsks;
+    gdat_data.t = time_eqdsks;
+    zshift = 0.;
+    if isfield(gdat_data.gdat_params,'zshift') && ~isempty(gdat_data.gdat_params.zshift)
+      zshift = gdat_data.gdat_params.zshift;
     else
-        % special case for EQI,EQH,IDE instead of IDG when FPG is present value
-        if strcmp(lower(gdat_data.gdat_params.source),'ide') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
-            gdat_data.gdat_params.source = 'IDG';
-        elseif strcmp(lower(gdat_data.gdat_params.source),'eqi') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
-            gdat_data.gdat_params.source = 'GQI';
-        elseif strcmp(lower(gdat_data.gdat_params.source),'eqh') && strcmp(lower(mapping_for_aug.expression{1}),'fpg')
-            gdat_data.gdat_params.source = 'GQH';
+      gdat_data.gdat_params.zshift = zshift;
+    end
+    gdat_data.gdat_params.zshift = zshift;
+    dowrite = 1;
+    if isfield(gdat_data.gdat_params,'write') && ~isempty(gdat_data.gdat_params.write)
+      dowrite = gdat_data.gdat_params.write;
+    else
+      gdat_data.gdat_params.write = dowrite;
+    end
+    gdat_data.gdat_params.write = dowrite;
+    params_equil = gdat_data.gdat_params;
+    params_equil.data_request = 'equil';
+    [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
+    if error_status>0
+      if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
+      return
+    end
+    gdat_data.gdat_params = params_equil;
+    gdat_data.equil = equil;
+    if gdat_data.gdat_params.doplot==0
+      fignb_handle = -1;
+    else
+      figure(9999);
+      fignb_handle = gcf;
+    end
+    for itime=1:length(time_eqdsks)
+      time_eff = time_eqdsks(itime);
+      % use read_results updated to effectively obtain an eqdsk with sign correct with COCOS=2
+      [eqdskAUG, equil_all_t, equil_t_index]=geteqdskAUG(equil,time_eff,gdat_data.gdat_params.zshift,'source',gdat_data.gdat_params.equil,'extra_arg_sf2sig',gdat_data.gdat_params.extra_arg_sf2sig,'fignb',fignb_handle);
+      eqdskAUG.fnamefull = fullfile(['/tmp/' getenv('USER')],['EQDSK_' num2str(shot) 't' num2str(time_eff,'%.4f')]);
+      cocos_in = eqdskAUG.cocos;
+      if cocos_in ~= equil.cocos;
+        equil.cocos = eqdskAUG.cocos;
+      end
+      if ~isfield(gdat_data.gdat_params,'cocos') || isempty(gdat_data.gdat_params.cocos)
+        gdat_data.gdat_params.cocos = cocos_in;
+      end
+      cocos_out = gdat_data.gdat_params.cocos;
+      if cocos_in ~= cocos_out
+        [eqdsk_cocosout, eqdsk_cocosout_IpB0pos,cocos_inout]=eqdsk_cocos_transform(eqdskAUG,[cocos_in cocos_out]);
+      else
+        eqdsk_cocosout = eqdskAUG;
+      end
+      % for several times, use array of structure for eqdsks,
+      % cannot use it for psi(R,Z) in .data and .x since R, Z might be different at different times,
+      % so project psi(R,Z) on Rmesh, Zmesh of 1st time
+      if length(time_eqdsks) > 1
+        gdat_data.eqdsk{itime} = eqdsk_cocosout;
+        if gdat_data.gdat_params.write; gdat_data.eqdsk{itime} = write_eqdsk(eqdskAUG.fnamefull,eqdsk_cocosout); end
+        if itime==1
+          gdat_data.data(:,:,itime) = gdat_data.eqdsk{itime}.psi;
+          gdat_data.dim{1} = gdat_data.eqdsk{itime}.rmesh;
+          gdat_data.dim{2} = gdat_data.eqdsk{itime}.zmesh;
+        else
+          xx=repmat(reshape(gdat_data.dim{1},length(gdat_data.dim{1}),1),1,size(gdat_data.eqdsk{itime}.psi,2));
+          yy=repmat(reshape(gdat_data.dim{2},1,length(gdat_data.dim{2})),size(gdat_data.eqdsk{itime}.psi,1),1);
+          aa = interpos2Dcartesian(gdat_data.eqdsk{itime}.rmesh,gdat_data.eqdsk{itime}.zmesh ...
+          ,gdat_data.eqdsk{itime}.psi,xx,yy,-1,-1);
+          gdat_data.data(:,:,itime) = aa;
         end
-        mapping_for_aug.expression{1} = gdat_data.gdat_params.source;
+      else
+        gdat_data.eqdsk = eqdsk_cocosout;
+        if gdat_data.gdat_params.write; gdat_data.eqdsk = write_eqdsk(eqdskAUG.fnamefull,eqdsk_cocosout); end
+        gdat_data.data = gdat_data.eqdsk.psi;
+        gdat_data.dim{1} = gdat_data.eqdsk.rmesh;
+        gdat_data.dim{2} = gdat_data.eqdsk.zmesh;
+      end
     end
-    gdat_data.gdat_params.exp_name = exp_location;
-    % time interval
-    time_interval = [];
-    % extra args for rdaAUG_eff
-    if length(mapping_for_aug.expression)>=4 && ~isempty(mapping_for_aug.expression{4})
-        gdat_data.gdat_params.special_signal = mapping_for_aug.expression{4};
-    end
-    [aatmp,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},mapping_for_aug.expression{2},exp_location, ...
-        time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-    if error_status~=0
-        if gdat_params.nverbose>=3; disp(['error after rdaAUG in signal with data_request_eff= ' data_request_eff]); end
+    gdat_data.dim{3} = gdat_data.t;
+    gdat_data.x = gdat_data.dim(1:2);
+    gdat_data.data_fullpath=['psi(R,Z) and eqdsk from geteqdskAUG with ' gdat_data.gdat_params.equil ' ;zshift=' num2str(zshift)];
+    gdat_data.units = 'T m^2';
+    gdat_data.dimunits = {'m','m','s'};
+    gdat_data.request_description = ['data=psi, x=(R,Z), eqdsk contains eqdsk structure with which ' ...
+                    'plot_eqdsk, write_eqdsk, read_eqdsk can be used'];
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'equil'}
+    % get equil params and time array in gdat_data.t
+    [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL,M_Rmesh,N_Zmesh] = get_EQ_params(gdat_data);
+    if isempty(Lpf1_t)
+      disp('Lpf1_t is empty, probably no data, return')
+      return
+    end
+    % since Lpf depends on time, need to load all first and then loop over time for easier mapping
+    [qpsi,e]=rdaAUG_eff(shot,DIAG,'Qpsi',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    ndimrho = size(qpsi.data,2);
+    if ndimrho==NTIME_Lpf && ndimrho ~= NTIME
+      % data seems to be transposed
+      ndimrho = size(qpsi.data,1);
+      itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
+    else
+      itotransposeback = 0;
+    end
+    qpsi=adapt_rda(qpsi,NTIME,ndimrho,itotransposeback);
+    ijnan=find(isnan(qpsi.value));
+    qpsi.value(ijnan)=0;
+    [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
+    [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
+    [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
+    [Area,e]=rdaAUG_eff(shot,DIAG,'Area',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Area=adapt_rda(Area,NTIME,2*ndimrho,itotransposeback);
+    [Ri,e]=rdaAUG_eff(shot,DIAG,'Ri',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Ri=adapt_rda(Ri,NTIME,M_Rmesh,itotransposeback);
+    [Zj,e]=rdaAUG_eff(shot,DIAG,'Zj',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Zj=adapt_rda(Zj,NTIME,N_Zmesh,itotransposeback);
+    if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
+      [PFM_tree,e]=rdaAUG_eff(shot,DIAG,'PFM',exp_name_eff,[],['''-raw'',' gdat_data.gdat_params.extra_arg_sf2sig]); % -raw necessary for IDE
+    else
+      [PFM_tree,e]=rdaAUG_eff(shot,DIAG,'PFM',exp_name_eff,[],['''-raw''']); % -raw necessary for IDE
+    end
+    PFM_tree=adaptPFM_rda(PFM_tree,M_Rmesh,N_Zmesh,NTIME);
+    [Pres,e]=rdaAUG_eff(shot,DIAG,'Pres',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Pres=adapt_rda(Pres,NTIME,2*ndimrho,itotransposeback);
+    [Jpol,e]=rdaAUG_eff(shot,DIAG,'Jpol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Jpol=adapt_rda(Jpol,NTIME,2*ndimrho,itotransposeback);
+    [FFP,e]=rdaAUG_eff(shot,DIAG,'FFP',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    if ~isempty(FFP.value)
+      FFP=adapt_rda(FFP,NTIME,ndimrho,itotransposeback);
+    else
+      FFP.value=NaN*ones(NTIME,max(Lpf1_t));
+    end
+    if strcmp(DIAG,'EQI') || strcmp(DIAG,'EQH') || strcmp(DIAG,'IDE')
+      [Rinv,e]=rdaAUG_eff(shot,DIAG,'Rinv',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      Rinv=adapt_rda(Rinv,NTIME,ndimrho,itotransposeback);
+      [R2inv,e]=rdaAUG_eff(shot,DIAG,'R2inv',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      R2inv=adapt_rda(R2inv,NTIME,ndimrho,itotransposeback);
+      [Bave,e]=rdaAUG_eff(shot,DIAG,'Bave',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      Bave=adapt_rda(Bave,NTIME,ndimrho,itotransposeback);
+      [B2ave,e]=rdaAUG_eff(shot,DIAG,'B2ave',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      B2ave=adapt_rda(B2ave,NTIME,ndimrho,itotransposeback);
+      if strcmp(DIAG,'IDE')
+        FTRA.value=[];
+      else
+        [FTRA,e]=rdaAUG_eff(shot,DIAG,'FTRA',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+        FTRA=adapt_rda(FTRA,NTIME,ndimrho,itotransposeback);
+      end
+    else
+      Rinv.value=[]; R2inv.value=[]; Bave.value=[]; B2ave.value=[]; FTRA.value=[];
+    end
+    [LPFx,e]=rdaAUG_eff(shot,DIAG,'LPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    LPFx.value=LPFx.value(1:NTIME); LPFx.data=LPFx.value(1:NTIME); LPFx.t=LPFx.t(1:NTIME);
+    [PFxx,e]=rdaAUG_eff(shot,DIAG,'PFxx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    PFxx=adapt_rda(PFxx,NTIME,max(LPFx.value)+1,itotransposeback);
+    [RPFx,e]=rdaAUG_eff(shot,DIAG,'RPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    RPFx=adapt_rda(RPFx,NTIME,max(LPFx.value)+1,itotransposeback);
+    [zPFx,e]=rdaAUG_eff(shot,DIAG,'zPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    zPFx=adapt_rda(zPFx,NTIME,max(LPFx.value)+1,itotransposeback);
+    % seems "LCFS" q-value is far too large, limit to some max (when diverted)
+    max_qValue = 30.; % Note could just put a NaN on LCFS value since ill-defined when diverted
+    for it=1:NTIME
+      Lpf1 = Lpf1_t(it);
+      % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
+      % change it to (radial,time) and use only Lpf+1 points up to LCFS
+      ijok=find(abs(qpsi.value)>0); % note: eqr fills in only odd points radially
+      % set NaNs to zeroes
+      if qpsi.value(ijok(1))<0
+        gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
+      else
+        gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
+      end
+      % get x values
+      gdat_data.psi(:,it)=psi_tree.value(it,Lpf1:-1:1)';
+      gdat_data.psi_axis(it)= gdat_data.psi(1,it);
+      gdat_data.psi_lcfs(it)= gdat_data.psi(end,it);
+      gdat_data.rhopolnorm(:,it) = sqrt(abs((gdat_data.psi(:,it)-gdat_data.psi_axis(it)) ./(gdat_data.psi_lcfs(it)-gdat_data.psi_axis(it))));
+      if strcmp(DIAG,'EQR');
+        % q value has only a few values and from center to edge, assume they are from central rhopol values on
+        % But they are every other point starting from 3rd
+        ijk=find(gdat_data.qvalue(:,it)~=0);
+        if length(ijk)>2
+          % now shots have non-zero axis values in eqr
+          rhoeff=gdat_data.rhopolnorm(ijk,it);
+          qeff=gdat_data.qvalue(ijk,it); % radial order was already inverted above
+          if ijk(1)>1
+            rhoeff = [0.; rhoeff];
+            qeff = [qeff(1) ;qeff];
+          end
+          ij_nonan=find(~isnan(gdat_data.rhopolnorm(:,it)));
+          qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
+          qfit(ij_nonan)=interpos(rhoeff,qeff,gdat_data.rhopolnorm(ij_nonan,it),-0.01,[1 0],[0 0],[300; ones(size(qeff(1:end-1)))]);
+        else
+          qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
+        end
+        gdat_data.qvalue(:,it) = qfit;
+      end
+      % get rhotor values
+      gdat_data.phi(:,it) = phi_tree.value(it,Lpf1:-1:1)';
+      gdat_data.rhotornorm(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.phi(end,it)));
+      % get rhovol values
+      gdat_data.vol(:,it)=Vol.value(it,2*Lpf1-1:-2:1)';
+      gdat_data.dvoldpsi(:,it)=Vol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
+      gdat_data.rhovolnorm(:,it) = sqrt(abs(gdat_data.vol(:,it) ./ gdat_data.vol(end,it)));
+      gdat_data.area(:,it)=Area.value(it,2*Lpf1-1:-2:1)';
+      gdat_data.dareadpsi(:,it)=Area.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
+      gdat_data.Rmesh(:,it) = Ri.value(it,1:M_Rmesh);
+      gdat_data.Zmesh(:,it) = Zj.value(it,1:N_Zmesh);
+      gdat_data.psi2D(1:M_Rmesh,1:N_Zmesh,it) = PFM_tree.value(1:M_Rmesh,1:N_Zmesh,it);
+      gdat_data.pressure(:,it)=Pres.value(it,2*Lpf1-1:-2:1)';
+      gdat_data.dpressuredpsi(:,it)=Pres.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
+      if ~isempty(Jpol.value)
+        gdat_data.jpol(:,it)=Jpol.value(it,2*Lpf1-1:-2:1)';
+        gdat_data.djpolpsi(:,it)=Jpol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
+      else
+        gdat_data.jpol = [];
+        gdat_data.djpolpsi = [];
+      end
+      if ~strcmp(DIAG,'TRE')
+        gdat_data.ffprime(:,it) = FFP.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.ffprime(:,it) = FFP.value(it,Lpf1:-1:1)'/2/pi;
+      end
+      gdat_data.Xpoints.psi(1:LPFx.value(it)+1,it) = PFxx.value(it,1:LPFx.value(it)+1);
+      gdat_data.Xpoints.Rvalue(1:LPFx.value(it)+1,it) = RPFx.value(it,1:LPFx.value(it)+1);
+      gdat_data.Xpoints.Zvalue(1:LPFx.value(it)+1,it) = zPFx.value(it,1:LPFx.value(it)+1);
+      if ~isempty(Rinv.value)
+        gdat_data.rinv(:,it) = Rinv.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.rinv = [];
+      end
+      if ~isempty(R2inv.value)
+        gdat_data.r2inv(:,it) = R2inv.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.r2inv = [];
+      end
+      if ~isempty(Bave.value)
+        gdat_data.bave(:,it) = Bave.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.bave = [];
+      end
+      if ~isempty(B2ave.value)
+        gdat_data.b2ave(:,it) = B2ave.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.b2ave = [];
+      end
+      if ~isempty(FTRA.value)
+        gdat_data.ftra(:,it) = FTRA.value(it,Lpf1:-1:1)';
+      else
+        gdat_data.ftra = [];
+      end
+      %
+    end
+    gdat_data.x = gdat_data.rhopolnorm;
+    %
+    try
+      [equil_Rcoil,e]=rdaAUG_eff(shot,DIAG,'Rcl',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      gdat_data.Rcoils = equil_Rcoil.value;
+      [equil_Zcoil,e]=rdaAUG_eff(shot,DIAG,'Zcl',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      gdat_data.Zcoils = equil_Zcoil.value;
+    catch
+      gdat_data.Rcoils = [];
+      gdat_data.Zcoils = [];
+    end
+    %
+    if strcmp(DIAG,'IDE')
+      [IpiPSI,e]=rdaAUG_eff(shot,'IDG','Itor',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      if length(IpiPSI.value)~=NTIME
+        disp('Problem with nb time points of IDG/Itor with respect to IDE NTIME, check with O. Sauter')
         return
+      end
+    else
+      [IpiPSI,e]=rdaAUG_eff(shot,DIAG,'IpiPSI',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
     end
-    if isfield(aatmp,'data'); gdat_data.data = aatmp.data; end
-    if isfield(aatmp,'t'); gdat_data.t = aatmp.t; end
-    if isfield(aatmp,'x'); gdat_data.x = aatmp.x; end
-    if isfield(aatmp,'source'); gdat_data.source = aatmp.source; end
-    if isfield(aatmp,'dim'); gdat_data.dim = aatmp.dim; end
-    if isfield(aatmp,'dimunits'); gdat_data.dimunits = aatmp.dimunits; end
-    if isfield(aatmp,'edition_out'); gdat_data.version = aatmp.edition_out; end
-    
-    switch mapping_for_aug.expression{2}
-        case 'q_sa'
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_sa_plu',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar.plu = aerr.data; end
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_sa_min',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar.min = aerr.data; end
-        case 'q_cd'
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_cd_plu',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar.plu = aerr.data; end
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'q_cd_min',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar.min = aerr.data; end
-        case 'li'
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'li_unc',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
-        case 'Te'
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'Te_unc',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
-        case 'ne'
-            [aerr,error_status]=rdaAUG_eff(shot,mapping_for_aug.expression{1},'ne_unc',exp_location, ...
-                time_interval,gdat_data.gdat_params.extra_arg_sf2sig,gdat_data.gdat_params.special_signal);
-            if isfield(aerr,'data'); gdat_data.error_bar = aerr.data; end
+    gdat_data.Ip = IpiPSI.value(1:NTIME);
+    %
+    gdat_data.data = gdat_data.qvalue; % put q in data
+    gdat_data.units=[]; % not applicable
+    gdat_data.data_fullpath = [DIAG ' from exp_name: ' gdat_data.gdat_params.exp_name '; q(rhopolnorm,t) in .data(.x,.t)'];
+    gdat_data.cocos = 17; % should check FPP (IDE seems 13)
+    gdat_data.dim{1} = gdat_data.x;
+    gdat_data.dim{2} = gdat_data.t;
+    gdat_data.dimunits{1} = 'rhopolnorm';
+    gdat_data.dimunits{2} = 'time [s]';
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'gas', 'gas_valve', 'gas_valves'}
+    %
+    uvs_signals_source = [{'D_tot','Sum of calibrated D2 gas-fluxes (= D/s)'}; ...
+                    {'N_tot','Sum of calibrated N2 gas-fluxes (= N*7/s)'}; ...
+                    {'H_tot','Sum of calibrated H gas-fluxes (= H/s)'}; ...
+                    {'He_tot','Sum of calibrated He gas-fluxes (= He*2/s)'}; ...
+                    {'Ne_tot','Sum of calibrated Ne gas-fluxes (= Ne*10/s)'}; ...
+                    {'Ar_tot','Sum of calibrated Ar gas-fluxes (= Ar*18/s)'}];
+    for i=1:size(uvs_signals_source,1)
+      uvs_signals.(uvs_signals_source{i,1}) = gdat_aug(shot,{'UVS',uvs_signals_source{i,1}});
+      if isempty(gdat_data.t) && numel(uvs_signals.(uvs_signals_source{i,1}).t)>10
+        gdat_data.t = uvs_signals.(uvs_signals_source{i,1}).t; % all have same time base, could use time signal
+      end
+      if ~isempty(uvs_signals.(uvs_signals_source{i,1}).data) && numel(uvs_signals.(uvs_signals_source{i,1}).data) == numel(gdat_data.t);
+        gdat_data.data(i,:) = uvs_signals.(uvs_signals_source{i,1}).data; % all have same time base
+      else
+        gdat_data.data(i,:) = NaN;
+      end
+      gdat_data.units{i} = uvs_signals_source{i,2};
     end
-    gdat_data.data_fullpath=mapping_for_aug.expression;
-    if isempty(aatmp.data) || (isempty(gdat_data.t) && isempty(gdat_data.x))
+    gdat_data.data_fullpath = 'from UVS and uvs_signals_source';
+    gdat_data.uvs_signals_source = uvs_signals_source;
+    gdat_data.label = uvs_signals_source(:,1)';
+    gdat_data.dim{2} = gdat_data.t;
+    gdat_data.dimunits{2} = 's';
+    gdat_data.dim{1} = [1:size(gdat_data.data,1)];
+    gdat_data.dimunits{1} = 'uvs_signals_source index';
+    gdat_data.x = gdat_data.dim{1};
+    gdat_data.mapping_for.aug.timedim = 1;
+
+    % note also available in UVS, not commented the same way on ISIS
+    uvd_signals_source=[{'CFCu01T','PV01','empty comment'}; ...
+                        {'CFCo02A','PV02','valve flux, normally for prefill'}; ...
+                        {'CFFo02A','PV03','valve flux,'}; ...
+                        {'CFA13B','PV04','valve flux, in-vessel pipe for gas imaging'}; ...
+                        {'CFA03B','PV05','valve flux,'}; ...
+                        {'CFFo07A','PV06','valve flux,'}; ...
+                        {'CFDu05X','PV07','valve flux, normally with N2'}; ...
+                        {'CFDu05B','PV08','valve flux, normally with D2'}; ...
+                        {'CFCo10A','PV09','valve flux, in-vessel pipe into ICRH limiter'}; ...
+                        {'CFDu01B','PV10','valve flux, normally with D2'}; ...
+                        {'CFDu09B','PV11','valve flux, normally with D2'}; ...
+                        {'CFFo10A','PV12','valve flux,'}; ...
+                        {'CFFo14A','PV13','valve flux,'}; ...
+                        {'CFA03C','PV14','valve flux, short feeding pipe for rare gases'}; ...
+                        {'CFA13A','PV15','valve flux,'}; ...
+                        {'CFA03A','PV16','valve flux,'}; ...
+                        {'CFDu09X','PV17','valve flux, normally with N2'}; ...
+                        {'CFDu13X','PV18','valve flux, normally with N2'}; ...
+                        {'CFDu13B','PV19','valve flux, normally with D2'}; ...
+                        {'CFDu01X','PV20','valve flux, normally with N2'}];
+    gdat_data.pvxx.t = [];
+    gdat_data.pvxx.t = [];
+
+    for i=1:size(uvd_signals_source,1)
+      uvd_signals.(uvd_signals_source{i,2}) = gdat_aug(shot,{'UVD',uvd_signals_source{i,1}});
+      if isempty(gdat_data.pvxx.t) && numel(uvd_signals.(uvd_signals_source{i,2}).t)>10
+        gdat_data.pvxx.t = uvd_signals.(uvd_signals_source{i,2}).t; % all have same time base
+      end
+      if ~isempty(uvd_signals.(uvd_signals_source{i,2}).data) && numel(uvd_signals.(uvd_signals_source{i,2}).data) == numel(gdat_data.pvxx.t);
+        gdat_data.pvxx.data(i,:) = uvd_signals.(uvd_signals_source{i,2}).data; % all have same time base
+      else
+        gdat_data.pvxx.data(i,:) = NaN;
+      end
+      gdat_data.pvxx.units{i} = [uvd_signals_source{i,2} ': ' uvd_signals_source{i,3}];
+    end
+    gdat_data.pvxx.data_fullpath = 'from UVD and uvd_signals_source';
+    gdat_data.pvxx.uvd_signals_source = uvd_signals_source;
+    gdat_data.pvxx.label = uvd_signals_source(:,2)';
+    gdat_data.pvxx.dim{2} = gdat_data.t;
+    gdat_data.pvxx.dimunits{2} = 's';
+    gdat_data.pvxx.dim{1} = [1:size(gdat_data.pvxx.data,1)];
+    gdat_data.pvxx.dimunits{1} = 'PVxx index';
+    gdat_data.pvxx.x = gdat_data.dim{1};
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'ids'}
+    params_eff = gdat_data.gdat_params;
+    if isfield(params_eff,'source') && ~isempty(params_eff.source)
+      ids_top_name = params_eff.source;
+    else
+      ids_top_name = [];
+      disp('need an ids name in ''source'' parameter');
+      disp('check substructure gdat_params.source_available for an ids list');
+    end
+    ids_gen_ok = exist('ids_gen');
+    equil_empty = struct([]);
+    if ids_gen_ok ~= 2
+      ids_struct_saved = 'ids_structures_20190312.mat';
+      if ~exist(ids_struct_saved,'file')
+        warning(['function ids_gen not available neither file ids_structures_20190312.mat thus cannot create empty ids: ids_gen(''' ids_top_name ''')']);
         return
+      else
+        eval(['load ' ids_struct_saved ])
+        if isfield(ids_structures,ids_top_name)
+          equil_empty = ids_structures.(ids_top_name);
+        else
+          if ~isempty(ids_top_name);
+            warning(['ids ''' ids_top_name ''' does not exist in ids_structures saved in ' ids_struct_saved]);
+          end
+          gdat_data.gdat_params.source_available = ids_list;
+          return
+        end
+      end
+    else
+      equil_empty = ids_gen(ids_top_name);
+    end
+    try
+      if ~isempty(shot)
+        eval(['[ids_top,ids_top_description]=aug_get_ids_' ids_top_name '(shot,equil_empty);'])
+        gdat_data.(ids_top_name) = ids_top;
+        gdat_data.([ids_top_name '_description']) = ids_top_description;
+      else
+        gdat_data.(ids_top_name) = equil_empty;
+        gdat_data.([ids_top_name '_description']) = ['shot empty so return default empty structure for ' ids_top_name];
+      end
+    catch ME_aug_get_ids
+      getReport(ME_aug_get_ids)
+      disp(['there is a problem with: aug_get_ids_' ids_top_name ...
+            ' , may be check if it exists in your path or test it by itself'])
+      gdat_data.(ids_top_name) = equil_empty;
+      gdat_data.([ids_top_name '_description']) = getReport(ME_aug_get_ids);
+    end
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'ne','te'}
+    exp_name_eff = gdat_data.gdat_params.exp_name;
+    % ne or Te from Thomson data on raw z mesh vs (z,t)
+    nodenameeff = [upper(data_request_eff(1)) 'e_c'];
+    node_child_nameeff = [upper(data_request_eff(1)) 'e_core'];
+    [a,error_status]=rdaAUG_eff(shot,'VTA',nodenameeff,exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    if isempty(a.data) || isempty(a.t) || error_status>0
+      if gdat_params.nverbose>=3;
+        a
+        disp(['with data_request= ' data_request_eff])
+      end
+      return
+    end
+    gdat_data.(lower(node_child_nameeff)).data = a.data;
+    gdat_data.(lower(node_child_nameeff)).t = a.t;
+    gdat_data.t = a.t;
+    if any(strcmp(fieldnames(a),'units'))
+      gdat_data.units=a.units;
+    end
+    [alow,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'elow_c'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    [aup,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'eupp_c'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    gdat_data.(lower(node_child_nameeff)).error_bar = max(aup.value-gdat_data.(lower(node_child_nameeff)).data,gdat_data.(lower(node_child_nameeff)).data-alow.value);
+    [a,error_status]=rdaAUG_eff(shot,'VTA','R_core',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    gdat_data.(lower(node_child_nameeff)).r = repmat(a.data,size(gdat_data.(lower(node_child_nameeff)).data,1),1);
+    [a,error_status]=rdaAUG_eff(shot,'VTA','Z_core',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    gdat_data.(lower(node_child_nameeff)).z = repmat(a.data',1,size(gdat_data.(lower(node_child_nameeff)).data,2));
+    gdat_data.dimunits=[{'Z [m]'} ; {'time [s]'}];
+    gdat_data.data_fullpath=[data_request_eff ' from VTA/' upper(data_request_eff(1)) 'e_c and ' upper(data_request_eff(1)) 'e_e'];
+    nb_core = size(gdat_data.(lower(node_child_nameeff)).z,1);
+    gdat_data.data = [];
+    gdat_data.data(1:nb_core,:) = gdat_data.(lower(node_child_nameeff)).data(1:nb_core,:);
+    gdat_data.dim=[{gdat_data.(lower(node_child_nameeff)).z};{gdat_data.(lower(node_child_nameeff)).t}];
+    gdat_data.error_bar(1:nb_core,:) = gdat_data.(lower(node_child_nameeff)).error_bar(1:nb_core,:);
+
+    % add edge part
+    nodenameeff_e = [upper(data_request_eff(1)) 'e_e'];
+    node_child_nameeff_e = [upper(data_request_eff(1)) 'e_edge'];
+    [a,error_status]=rdaAUG_eff(shot,'VTA',nodenameeff_e,exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    gdat_data.(lower(node_child_nameeff_e)).data = a.data;
+    ij_edge_notok = find(a.data>5e21);
+    gdat_data.(lower(node_child_nameeff_e)).data(ij_edge_notok) = NaN;
+    gdat_data.(lower(node_child_nameeff_e)).t = a.t;
+    if ~isempty(a.data)
+      [a,error_status]=rdaAUG_eff(shot,'VTA','R_edge',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      gdat_data.(lower(node_child_nameeff_e)).r = repmat(a.data,size(gdat_data.(lower(node_child_nameeff_e)).data,1),1);
+      [a,error_status]=rdaAUG_eff(shot,'VTA','Z_edge',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      gdat_data.(lower(node_child_nameeff_e)).z = repmat(a.data',1,size(gdat_data.(lower(node_child_nameeff_e)).data,2));
+      nb_edge = size(gdat_data.(lower(node_child_nameeff_e)).z,1);
+      iaaa=iround_os(gdat_data.(lower(node_child_nameeff_e)).t,gdat_data.(lower(node_child_nameeff)).t);
+      gdat_data.data(nb_core+1:nb_core+nb_edge,:) = gdat_data.(lower(node_child_nameeff_e)).data(1:nb_edge,iaaa);
+      gdat_data.dim{1}(nb_core+1:nb_core+nb_edge,:)=gdat_data.(lower(node_child_nameeff_e)).z(1:nb_edge,iaaa);
+      [alow,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'elow_e'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      [aup,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'eupp_e'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      gdat_data.(lower(node_child_nameeff_e)).error_bar = max(aup.value-gdat_data.(lower(node_child_nameeff_e)).data, ...
+          gdat_data.(lower(node_child_nameeff_e)).data-alow.value);
+      gdat_data.error_bar(nb_core+1:nb_core+nb_edge,:) = gdat_data.(lower(node_child_nameeff_e)).error_bar(1:nb_edge,iaaa);
+    else
+      gdat_data.(lower(node_child_nameeff_e)).data = [];
+      gdat_data.(lower(node_child_nameeff_e)).t = [];
+      gdat_data.(lower(node_child_nameeff_e)).error_bar = [];
+      gdat_data.(lower(node_child_nameeff_e)).r = [];
+      gdat_data.(lower(node_child_nameeff_e)).z = [];
+    end
+    gdat_data.x=gdat_data.dim{1};
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'ne_rho', 'te_rho', 'nete_rho'}
+    sources_available = {'VTA','IDA','TRA'}; % TRA to be included
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = 'VTA'; % default source
+    end
+    sources_exp_name_available = 'AUGD';
+    if isfield(gdat_data.gdat_params,'source_exp_name') && ~isempty(gdat_data.gdat_params.source_exp_name)
+      sources_exp_name_available = gdat_data.gdat_params.source_exp_name;
+    end
+    gdat_data.gdat_params.source_exp_name = sources_exp_name_available;
+    gdat_data.gdat_params.source = upper(gdat_data.gdat_params.source);
+    if strcmp(gdat_data.gdat_params.source(1:2),'EQ');
+      warning('set equilibrium choice in ''equil'' parameter and not source, moved to equil')
+      gdat_data.gdat_params.equil = gdat_data.gdat_params.source;
+      gdat_data.gdat_params.source = [];
+    end
+    if ~isempty(intersect({'THOMSON'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'VTA'; end
+    if ~isempty(intersect({'TRANSP'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'TRA'; end
+    if ~isempty(intersect({'IDE'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'IDA'; end
+    if isempty(intersect(sources_available,gdat_data.gdat_params.source))
+      error(['available source choices: ' sources_available{:} char(10) ' source: ' gdat_data.gdat_params.source ...
+             ' not implemented, ask O. Sauter' char(10)]);
+    elseif ~strcmp(gdat_data.gdat_params.source,'VTA')
+      disp(['At this stage .te, .ne, .fit refer to VTA projected on given equil choice. ' char(10) ...
+            'IDA or TRA profiles are added in .ida or .transp respectively']);
+    end
+    if ~isfield(gdat_data.gdat_params,'fit') || isempty(gdat_data.gdat_params.fit) || ~isnumeric(gdat_data.gdat_params.fit)
+      if strcmp(gdat_data.gdat_params.source,'VTA')
+        gdat_data.gdat_params.fit = 1; % default do fit (only with VTA source requested)
+      else
+        % fit profiles filled in by IDA, TRA, ... profiles
+        gdat_data.gdat_params.fit = 0;
+      end
+    end
+    %
+    params_eff = gdat_data.gdat_params;
+    params_eff.data_request=data_request_eff(1:2); % start with ne if nete_rho
+    % get raw data
+    [gdat_data,params_kin,error_status]=gdat_aug(shot,params_eff);
+    gdat_data.gdat_params.data_request=data_request_eff;
+    gdat_data.gdat_request=data_request_eff;
+    if error_status>0
+      if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
+      return
+    end
+    % add rho coordinates
+    params_eff.data_request='equil';
+    [equil,params_equil,error_status]=gdat_aug(shot,params_eff);
+    if error_status>0
+      if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
+      return
+    end
+    gdat_data.gdat_params.equil = params_equil.equil;
+    %gdat_data.equil = equil;
+
+    % core
+    node_child_nameeff = [upper(data_request_eff(1)) 'e_core'];
+    inb_chord_core=size(gdat_data.(lower(node_child_nameeff)).r,1);
+    inb_time_core=size(gdat_data.(lower(node_child_nameeff)).r,2);
+    psi_out_core = NaN*ones(inb_chord_core,inb_time_core);
+    rhopolnorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
+    rhotornorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
+    rhovolnorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
+    % edge
+    node_child_nameeff_e = [upper(data_request_eff(1)) 'e_edge'];
+    inb_chord_edge=size(gdat_data.(lower(node_child_nameeff_e)).r,1);
+    inb_time_edge=size(gdat_data.(lower(node_child_nameeff_e)).r,2);
+    psi_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
+    rhopolnorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
+    rhotornorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
+    rhovolnorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
+    % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
+    time_equil=[min(gdat_data.(lower(node_child_nameeff)).t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.(lower(node_child_nameeff)).t(end)+0.1)];
+    for itequil=1:length(time_equil)-1
+      rr=equil.Rmesh(:,itequil);
+      zz=equil.Zmesh(:,itequil);
+      psirz_in = equil.psi2D(:,:,itequil);
+      it_core_inequil = find(gdat_data.(lower(node_child_nameeff)).t>time_equil(itequil) & gdat_data.(lower(node_child_nameeff)).t<=time_equil(itequil+1));
+      if ~isempty(it_core_inequil)
+        rout_core=gdat_data.(lower(node_child_nameeff)).r(:,it_core_inequil);
+        zout_core=gdat_data.(lower(node_child_nameeff)).z(:,it_core_inequil);
+        psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout_core,zout_core);
+        psi_out_core(:,it_core_inequil) = reshape(psi_at_routzout,inb_chord_core,length(it_core_inequil));
+        rhopolnorm_out_core(:,it_core_inequil) = sqrt((psi_out_core(:,it_core_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
+        for it_cx=1:length(it_core_inequil)
+          rhotornorm_out_core(:,it_core_inequil(it_cx)) = ...
+              interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out_core(:,it_core_inequil(it_cx)),-3,[2 2],[0 1]);
+          rhovolnorm_out_core(:,it_core_inequil(it_cx)) = ...
+              interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out_core(:,it_core_inequil(it_cx)),-3,[2 2],[0 1]);
+        end
+      end
+      % edge
+      it_edge_inequil = find(gdat_data.(lower(node_child_nameeff_e)).t>time_equil(itequil) & gdat_data.(lower(node_child_nameeff_e)).t<=time_equil(itequil+1));
+      if ~isempty(it_edge_inequil)
+        rout_edge=gdat_data.(lower(node_child_nameeff_e)).r(:,it_edge_inequil);
+        zout_edge=gdat_data.(lower(node_child_nameeff_e)).z(:,it_edge_inequil);
+        psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout_edge,zout_edge);
+        psi_out_edge(:,it_edge_inequil) = reshape(psi_at_routzout,inb_chord_edge,length(it_edge_inequil));
+        rhopolnorm_out_edge(:,it_edge_inequil) = sqrt((psi_out_edge(:,it_edge_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
+        for it_cx=1:length(it_edge_inequil)
+          rhotornorm_out_edge(:,it_edge_inequil(it_cx)) = ...
+              interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out_edge(:,it_edge_inequil(it_cx)),-3,[2 2],[0 1]);
+          rhovolnorm_out_edge(:,it_edge_inequil(it_cx)) = ...
+              interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out_edge(:,it_edge_inequil(it_cx)),-3,[2 2],[0 1]);
+        end
+      end
+    end
+    gdat_data.(lower(node_child_nameeff)).psi = psi_out_core;
+    gdat_data.(lower(node_child_nameeff)).rhopolnorm = rhopolnorm_out_core;
+    gdat_data.(lower(node_child_nameeff)).rhotornorm = rhotornorm_out_core;
+    gdat_data.(lower(node_child_nameeff)).rhovolnorm = rhovolnorm_out_core;
+    gdat_data.(lower(node_child_nameeff_e)).psi = psi_out_edge;
+    gdat_data.(lower(node_child_nameeff_e)).rhopolnorm = rhopolnorm_out_edge;
+    gdat_data.(lower(node_child_nameeff_e)).rhotornorm = rhotornorm_out_edge;
+    gdat_data.(lower(node_child_nameeff_e)).rhovolnorm = rhovolnorm_out_edge;
+    % put values of rhopolnorm for dim{1} by default, all radial mesh for combined core, edge in grids_1d
+    gdat_data.x = gdat_data.(lower(node_child_nameeff)).rhopolnorm;
+    iaaa=iround_os(gdat_data.(lower(node_child_nameeff_e)).t,gdat_data.(lower(node_child_nameeff)).t);
+    gdat_data.x(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhopolnorm(:,iaaa);
+    gdat_data.dim{1} = gdat_data.x;
+    gdat_data.dimunits{1} = 'rhopolnorm';
+    gdat_data2 = get_grids_1d(gdat_data,2,1,gdat_params.nverbose);
+    gdat_data.grids_1d = gdat_data2.grids_1d;
+% $$$     gdat_data.grids_1d.rhopolnorm = gdat_data.x;
+% $$$     gdat_data.grids_1d.psi = gdat_data.(lower(node_child_nameeff)).psi;
+% $$$     gdat_data.grids_1d.psi(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).psi(:,iaaa);
+% $$$     gdat_data.grids_1d.rhotornorm = gdat_data.(lower(node_child_nameeff)).rhotornorm;
+% $$$     gdat_data.grids_1d.rhotornorm(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhotornorm(:,iaaa);
+% $$$     gdat_data.grids_1d.rhovolnorm = gdat_data.(lower(node_child_nameeff)).rhovolnorm;
+% $$$     gdat_data.grids_1d.rhovolnorm(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhovolnorm(:,iaaa);
+
+    gdat_data.data_fullpath = [gdat_data.data_fullpath ' projected on equilibrium ' gdat_data.gdat_params.equil];
+
+    % if nete_rho, copy data as .ne, get .te and put pe=e ne Te in data:
+    gdat_data.(data_request_eff(1:2)).data = gdat_data.data;
+    gdat_data.(data_request_eff(1:2)).error_bar = gdat_data.error_bar;
+    gdat_data.(data_request_eff(1:2)).units = gdat_data.units;
+    gdat_data.(data_request_eff(1:2)).core = gdat_data.([data_request_eff(1:2) '_core']);
+    gdat_data.(data_request_eff(1:2)).edge = gdat_data.([data_request_eff(1:2) '_edge']);
+    gdat_data = rmfield(gdat_data,{[data_request_eff(1:2) '_core'],[data_request_eff(1:2) '_edge']});
+    if strcmp(data_request_eff(1:4),'nete')
+      params_eff.data_request=data_request_eff(3:4);
+      [gdat_data_te,params_kin,error_status]=gdat_aug(shot,params_eff);
+      gdat_data.te.data = gdat_data_te.data;
+      gdat_data.te.error_bar = gdat_data_te.error_bar;
+      gdat_data.te.units = gdat_data_te.units;
+      gdat_data.te.core = gdat_data_te.te_core;
+      gdat_data.te.edge = gdat_data_te.te_edge;
+      gdat_data.te.error_bar = gdat_data_te.error_bar;
+      gdat_data.te.core.psi = gdat_data.ne.core.psi;
+      gdat_data.te.core.rhopolnorm = gdat_data.ne.core.rhopolnorm;
+      gdat_data.te.core.rhotornorm = gdat_data.ne.core.rhotornorm;
+      gdat_data.te.core.rhovolnorm = gdat_data.ne.core.rhovolnorm;
+      gdat_data.te.edge.psi = gdat_data.ne.edge.psi;
+      gdat_data.te.edge.rhopolnorm = gdat_data.ne.edge.rhopolnorm;
+      gdat_data.te.edge.rhotornorm = gdat_data.ne.edge.rhotornorm;
+      gdat_data.te.edge.rhovolnorm = gdat_data.ne.edge.rhovolnorm;
+      % put pe in main gdat_data
+      gdat_data.data = 1.6022e-19.*gdat_data.ne.data.*gdat_data.te.data;
+      gdat_data.error_bar = 1.6022e-19 .* (gdat_data.ne.data .* gdat_data.te.error_bar ...
+          + gdat_data.te.data .* gdat_data.ne.error_bar);
+      gdat_data.units='N/m^2; 1.6022e-19 ne Te';
+      gdat_data.data_fullpath=['pe=1.6e-19*ne*Te in data, .ne, .te ' gdat_data.data_fullpath(3:end)];
+      gdat_data.label = 'pe';
+    end
+    % defaults for fits, so user always gets std structure
+    gdat_data.fit.rhotornorm = []; % same for both ne and te
+    gdat_data.fit.rhopolnorm = [];
+    gdat_data.fit.t = [];
+    gdat_data.fit.te.data = [];
+    gdat_data.fit.te.drhotornorm = [];
+    gdat_data.fit.ne.data = [];
+    gdat_data.fit.ne.drhotornorm = [];
+    gdat_data.fit.raw.te.data = [];
+    gdat_data.fit.raw.te.rhotornorm = [];
+    gdat_data.fit.raw.ne.data = [];
+    gdat_data.fit.raw.ne.rhotornorm = [];
+    fit_tension_default = -0.1;
+    if isfield(gdat_data.gdat_params,'fit_tension')
+      fit_tension = gdat_data.gdat_params.fit_tension;
+    else
+      fit_tension = fit_tension_default;
+    end
+    if ~isstruct(fit_tension)
+      fit_tension_eff.te = fit_tension;
+      fit_tension_eff.ne = fit_tension;
+      fit_tension = fit_tension_eff;
+    else
+      if ~isfield(fit_tension,'te'); fit_tension.te = fit_tension_default; end
+      if ~isfield(fit_tension,'ne '); fit_tension.ne = fit_tension_default; end
     end
-    % construct .dim if not present (means coming from sf2sig)
-    if ~isfield(aatmp,'dim')
-        len_t = numel(aatmp.t);
-        len_x = numel(aatmp.x);
-        len_data= size(aatmp.data);
-        itime = find(len_data==len_t);
-        nbdims_eff = sum([size(gdat_data.data)~=1]);
-        aatmp.dim{itime} = aatmp.t;
-        aatmp.dimunits{itime} = aatmp.time_aug.unit;
-        if nbdims_eff >= 2
-            % assume area-base is main 2nd coordinate (did not find a case with 2 area-base (2 coordinates defined in addition to time) to be able to test)
-            i_x = setdiff([1:2],itime);
-            aatmp.dim{i_x} = aatmp.x;
-            if ~isempty(aatmp.area) && isfield(aatmp.area,'unit')
-                aatmp.dimunits(i_x) = aatmp.area.unit;
+    gdat_data.gdat_params.fit_tension = fit_tension;
+    if isfield(gdat_data.gdat_params,'fit_nb_rho_points')
+      fit_nb_rho_points = gdat_data.gdat_params.fit_nb_rho_points;
+    else
+      fit_nb_rho_points = 201;
+    end
+    gdat_data.gdat_params.fit_nb_rho_points = fit_nb_rho_points;
+    %
+    if gdat_data.gdat_params.fit==1
+      % add "manual" fits
+      gdat_data.fit.t = gdat_data.t;
+      rhotornormfit = linspace(0,1,fit_nb_rho_points)';
+      gdat_data.fit.rhotornorm = rhotornormfit;
+      gdat_data.fit.rhopolnorm = NaN*ones(length(rhotornormfit),length(gdat_data.fit.t));
+      if any(strfind(data_request_eff,'te'))
+        gdat_data.fit.raw.te.data = NaN*ones(size(gdat_data.te.data));
+        gdat_data.fit.raw.te.error_bar = NaN*ones(size(gdat_data.te.data));
+        gdat_data.fit.raw.te.rhotornorm = NaN*ones(size(gdat_data.te.data));
+        gdat_data.fit.te.data = gdat_data.fit.rhopolnorm;
+        gdat_data.fit.te.drhotornorm = gdat_data.fit.rhopolnorm;
+      end
+      if any(strfind(data_request_eff,'ne'))
+        gdat_data.fit.raw.ne.data = NaN*ones(size(gdat_data.ne.data));
+        gdat_data.fit.raw.ne.error_bar = NaN*ones(size(gdat_data.ne.data));
+        gdat_data.fit.raw.ne.rhotornorm = NaN*ones(size(gdat_data.ne.data));
+        gdat_data.fit.ne.data =gdat_data.fit.rhopolnorm;
+        gdat_data.fit.ne.drhotornorm = gdat_data.fit.rhopolnorm;
+      end
+      for it=1:length(gdat_data.t)
+        % make rhotor->rhopol transformation for each time since equilibrium might have changed
+        gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
+          gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
+        gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
+          gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
+        if any(strfind(data_request_eff,'te'))
+          idatate = find(gdat_data.te.data(:,it)>0 & gdat_data.grids_1d.rhotornorm(:,it)<=1.05);
+          if length(idatate)>0
+            gdat_data.fit.raw.te.rhotornorm(idatate,it) = gdat_data.grids_1d.rhotornorm(idatate,it);
+            gdat_data.fit.raw.te.data(idatate,it) = gdat_data.te.data(idatate,it);
+            gdat_data.fit.raw.te.error_bar(idatate,it) = gdat_data.te.error_bar(idatate,it);
+            [rhoeff,irhoeff] = sort(gdat_data.grids_1d.rhotornorm(idatate,it));
+            rhoeff = [0; rhoeff];
+            teeff = gdat_data.te.data(idatate(irhoeff),it);
+            te_err_eff = gdat_data.te.error_bar(idatate(irhoeff),it);
+            % they are some strange low error_bars, so remove these by max(Te/error_bar)<=10; and changing it to large error bar
+            ij=find(teeff./te_err_eff>10.);
+            if ~isempty(ij); te_err_eff(ij) = max(max(te_err_eff),teeff(ij)./0.1); end
+            %
+            teeff =  [teeff(1); teeff];
+            te_err_eff =  [1e4; te_err_eff];
+            % add some points to reach 0 at 1.05
+            if max(rhoeff)<1.03
+              rhoeff = [rhoeff; 1.05];
+              teeff = [teeff; 0.];
+              te_err_eff(end) = 10.*max(te_err_eff(2:end));
+              te_err_eff = [te_err_eff; min(te_err_eff)]; % to give more weight for new last point
             else
-                aatmp.dimunits(i_x) = {''};
-            end
-            if isempty(aatmp.dimunits{i_x}); aatmp.dimunits{i_x} = ''; end
-            for i=3:nbdims_eff
-                aatmp.dim{i} = [1:size(aatmp.data,i)];
-                aatmp.dimunits{i} = '';
-            end
+              teeff(end) = 0.;
+              te_err_eff(end-1) = 10.*max(te_err_eff(2:end));
+              te_err_eff(end) = min(te_err_eff); % to give more weight for new value of last point
+            end
+            [gdat_data.fit.te.data(:,it), gdat_data.fit.te.drhotornorm(:,it)] = interpos(rhoeff,teeff,rhotornormfit,fit_tension.te,[1 0],[0 0],te_err_eff);
+            % avoid neg points or positive edge gradient
+            if ~isempty(find(gdat_data.fit.te.data(:,it)<0)) || gdat_data.fit.te.drhotornorm(end,it) > 0
+              ij= find(rhoeff>=0.85 & rhoeff<1.04);
+              if ~isempty(ij)
+                te_err_eff(ij) = 100.*min(te_err_eff);
+              else
+                te_err_eff(end-min(5,length(te_err_eff)-3):end-1) = 100.*min(te_err_eff);
+              end
+              [gdat_data.fit.te.data(:,it), gdat_data.fit.te.drhotornorm(:,it)] = interpos(rhoeff,teeff,rhotornormfit,fit_tension.te,[1 0],[0 0],te_err_eff);
+            end
+          end
         end
-        gdat_data.dim = aatmp.dim;
-        gdat_data.dimunits = aatmp.dimunits;
-    end
-    mapping_for_aug_timedim_orig = mapping_for_aug.timedim;
-    if mapping_for_aug.timedim<=0
-        % need to guess timedim
-        if prod(size(aatmp.data)) == length(aatmp.data)
-            mapping_for_aug.timedim = 1;
-        elseif length(size(aatmp.data))==2
-            % 2 true dimensions
-            if length(aatmp.t) == size(aatmp.data,1)
-                mapping_for_aug.timedim = 1;
+        if any(strfind(data_request_eff,'ne'))
+          idatane = find(gdat_data.ne.data(:,it)>0 & gdat_data.grids_1d.rhotornorm(:,it)<=1.05);
+          if length(idatane)>0
+            gdat_data.fit.raw.ne.rhotornorm(idatane,it) = gdat_data.grids_1d.rhotornorm(idatane,it);
+            gdat_data.fit.raw.ne.data(idatane,it) = gdat_data.ne.data(idatane,it);
+            gdat_data.fit.raw.ne.error_bar(idatane,it) = gdat_data.ne.error_bar(idatane,it);
+            [rhoeff,irhoeff] = sort(gdat_data.grids_1d.rhotornorm(idatane,it));
+            rhoeff = [0; rhoeff];
+            % they are some strange low error_bars, so remove these by max(Te/error_bar)<=10; and changing it to large error bar
+            neeff = gdat_data.ne.data(idatane(irhoeff),it);
+            ne_err_eff = gdat_data.ne.error_bar(idatane(irhoeff),it);
+            ij=find(neeff./ne_err_eff>10.);
+            if ~isempty(ij); ne_err_eff(ij) = max(max(ne_err_eff),neeff(ij)./0.1); end
+            %
+            neeff =  [neeff(1); neeff];
+            ne_err_eff =  [1e21; ne_err_eff];
+            % add some points to reach 0 at 1.05
+            if max(rhoeff)<1.03
+              rhoeff = [rhoeff; 1.05];
+              neeff = [neeff; 0.];
+              ne_err_eff(end) = 10.*max(ne_err_eff(2:end)); % to give more weight for new last point
+              ne_err_eff = [ne_err_eff; min(ne_err_eff)];
             else
-                mapping_for_aug.timedim = 2;
-            end
+              neeff(end) = 0.;
+              ne_err_eff(end-1) = 10.*max(ne_err_eff(2:end));
+              ne_err_eff(end) = min(ne_err_eff); % to give more weight for new value of last point
+            end
+            [gdat_data.fit.ne.data(:,it), gdat_data.fit.ne.drhotornorm(:,it)] = interpos(rhoeff,neeff,rhotornormfit,fit_tension.ne,[1 0],[0 0],ne_err_eff);
+            % avoid neg points or positive edge gradient
+            if ~isempty(find(gdat_data.fit.ne.data(:,it)<0)) || gdat_data.fit.ne.drhotornorm(end,it) > 0
+              ij= find(rhoeff>=0.85 & rhoeff<1.04);
+              if ~isempty(ij)
+                ne_err_eff(ij) = 100.*min(ne_err_eff);
+              else
+                ne_err_eff(end-min(5,length(ne_err_eff)-3):end-1) = 100.*min(ne_err_eff);
+              end
+              [gdat_data.fit.ne.data(:,it), gdat_data.fit.ne.drhotornorm(:,it)] = interpos(rhoeff,neeff,rhotornormfit,fit_tension.ne,[1 0],[0 0],ne_err_eff);
+            end
+          end
+        end
+      end
+    end
+    % add other profiles in fit (without raw data part)
+    switch gdat_data.gdat_params.source
+     case 'IDA'
+      gdat_data.fit.full_path = 'from IDA: Te, Te_unc, ne, ne_unc, rhop and rhot';
+      params_eff.data_request={'IDA','','','area-base:rhop'};
+      [gdat_data_ida_rhop,params_kin,error_status]=gdat_aug(shot,params_eff);
+      gdat_data.fit.rhopolnorm = gdat_data_ida_rhop.data;
+      params_eff.data_request={'IDA','rhot'}; % it is actually rhotor_norm
+      [gdat_data_te_ida_rhot,params_kin,error_status]=gdat_aug(shot,params_eff);
+      gdat_data.fit.rhotornorm = gdat_data_te_ida_rhot.data;
+      if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'te')
+        % Te
+        params_eff.data_request={'IDA','Te'};
+        [gdat_data_te_ida,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.te.data = gdat_data_te_ida.data;
+        gdat_data.fit.t = gdat_data_te_ida.t;
+        params_eff.data_request={'IDA','Te_unc'};
+        [gdat_data_te_ida_err,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.te.error_bar = gdat_data_te_ida_err.data;
+      end
+      if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'ne')
+        % ne
+        params_eff.data_request={'IDA','ne'};
+        [gdat_data_ne_ida,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.ne.data = gdat_data_ne_ida.data;
+        gdat_data.fit.t = gdat_data_ne_ida.t;
+        params_eff.data_request={'IDA','ne_unc'};
+        [gdat_data_ne_ida_err,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.ne.error_bar = gdat_data_ne_ida_err.data; % time as 2nd dim
+      end
+     case 'TRA'
+      gdat_data.fit.full_path = 'from TRA: TE, NE, rhop from PLFLX and XB (.x is rhotornorm mid-points, XB end-point)';
+      % (tra.XB.data(1:end,it)'+[0 ,tra.XB.data(1:end-1,it)'])/2 = tra.TE.x(1:end,it)'
+      if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'te')
+        % Te
+        params_eff.data_request={'TRA','TE',gdat_data.gdat_params.source_exp_name};
+        [gdat_data_te_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.te.data = gdat_data_te_tra.data;
+        gdat_data.fit.t = gdat_data_te_tra.t;
+        gdat_data.fit.rhotornorm = gdat_data_te_tra.x;
+        params_eff.data_request={'TRA','PLFLX',gdat_data.gdat_params.source_exp_name};
+        [gdat_data_plflx_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
+        rhopol_endpoints = sqrt((gdat_data_plflx_tra.data-0)./(repmat(gdat_data_plflx_tra.data(end,:),size(gdat_data_plflx_tra.data,1),1)-0.));
+        for it=1:size(gdat_data_plflx_tra.data,2)
+          gdat_data.fit.rhopolnorm(:,it) = interpos([0. ; gdat_data_plflx_tra.x(:,it)],[0. ; rhopol_endpoints(:,it)],gdat_data.fit.rhotornorm(:,it));
+        end
+      end
+      if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'ne')
+        % ne
+        params_eff.data_request={'TRA','NE',gdat_data.gdat_params.source_exp_name};
+        [gdat_data_ne_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
+        gdat_data.fit.ne.data = gdat_data_ne_tra.data .* 1e6; % ne in cm^3 !!
+        if ~strcmp(data_request_eff(1:4),'nete')
+          gdat_data.fit.t = gdat_data.t;
+          gdat_data.fit.rhotornorm = gdat_data_ne_tra.x;
+          params_eff.data_request={'TRA','PLFLX',gdat_data.gdat_params.source_exp_name};
+          [gdat_data_plflx_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
+          rhopol_endpoints = sqrt((gdat_data_plflx_tra.data-0)./(repmat(gdat_data_plflx_tra.data(end,:),size(gdat_data_plflx_tra.data,1),1)-0.));
+          for it=1:size(gdat_data_plflx_tra.data,2)
+            gdat_data.fit.rhopolnorm(:,it) = interpos([0. ; gdat_data_plflx_tra.x(:,it)],[0. ; rhopol_endpoints(:,it)],gdat_data.fit.rhotornorm(:,it));
+          end
+        end
+      end
+     otherwise
+      if ~strcmp(gdat_data.gdat_params.source,'VTA')
+        disp(['profiles ''fit'' from ' gdat_data.gdat_params.source ' not defined. At this stage only: ' sources_available{:} ...
+              ' are available. Ask O. Sauter if need be']);
+      end
+    end
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'pgyro'}
+    extra_arg_sf2sig_eff_string = '';
+    if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
+      extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
+    end
+    %  LOAD MULTI CHANNEL DATA ECS
+    %  powers, frequencies, etc
+    params_eff = gdat_data.gdat_params;
+    params_eff.data_request={'ECS','PECRH'};
+    % pgyro tot in index=9
+    try
+      gdat_data=gdat_aug(shot,params_eff);
+      gdat_data.data_request = data_request_eff;
+      gdat_data.gdat_params.data_request = data_request_eff;
+    catch
+      if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
+      gdat_data.data_request = data_request_eff;
+      return
+    end
+    nb_timepoints = length(gdat_data.t);
+    pgyro = NaN*ones(nb_timepoints,9);
+    pgyro(:,9) = reshape(gdat_data.data,nb_timepoints,1);
+    gdat_data.data = pgyro;
+    labels{9} = 'ECtot';
+    for i=1:4
+      % "old" ECRH1 gyrotrons: gyro 1 to 4 in pgyro
+      params_eff.data_request={'ECS',['PG' num2str(i)]};
+      gdat_data_i=gdat_aug(shot,params_eff);
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i} = gdat_data_i;
+        gdat_data.data(:,i) = reshape(gdat_data_i.data,nb_timepoints,1);
+        gdat_data.dim = [{gdat_data_i.t} {[1:9]}];
+        if max(gdat_data_i.data) > 0.
+          labels{i} = ['EC_' num2str(i)];
+        end
+      end
+      sys1_source = 'P_sy1_g';
+      if shot > 33725; sys1_source = 'P_sy3_g'; end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'gyr_freq']);
+        % eval(['a = sf2par(''ECS'',shot,''gyr_freq'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        % gyr_freq not present (old shots for example)
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i}.freq = a;
+        gdat_data.freq_ec(i) = a.value;
+      end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GPolPos']);
+        % eval(['a = sf2par(''ECS'',shot,''GPolPos'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        % GPolPos not present
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i}.polpos = a.value;
+        gdat_data.polpos_ec(i) = a.value;
+      end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GTorPos']);
+        % eval(['a = sf2par(''ECS'',shot,''GTorPos'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i}.torpos = a.value;
+        gdat_data.torpos_ec(i) = a.value;
+      end
+      % "new" ECRH2 gyrotrons: gyro 5 to 8 in pgyro
+      params_eff.data_request={'ECS',['PG' num2str(i) 'N']};
+      gdat_data_i=gdat_aug(shot,params_eff);
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i+4} = gdat_data_i;
+        gdat_data.data(:,i+4) = reshape(gdat_data_i.data,nb_timepoints,1);
+        gdat_data.dim = [{gdat_data_i.t} {[1:9]}];
+        if max(gdat_data_i.data) > 0.
+          labels{i+4} = ['EC_' num2str(i+4)];
+        end
+      end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'gyr_freq']);
+        % eval(['a = sf2par(''ECS'',shot,''gyr_freq'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i+4}.freq = a;
+        gdat_data.freq_ec(i+4) = a.value;
+      end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GPolPos']);
+        % eval(['a = sf2par(''ECS'',shot,''GPolPos'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i+4}.polpos = a.value;
+        gdat_data.polpos_ec(i+4) = a.value;
+      end
+      try
+        [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
+          gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GTorPos']);
+        % eval(['a = sf2par(''ECS'',shot,''GTorPos'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
+      catch
+        a=[];
+      end
+      if isempty(a)
+      else
+        gdat_data.ec{i+4}.torpos = a.value;
+        gdat_data.torpos_ec(i+4) = a.value;
+      end
+      params_eff.data_request={'ECN',['G' num2str(i) 'POL']};
+      gdat_data_i=gdat_aug(shot,params_eff);
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i+4}.gpol_ec = gdat_data_i;
+      end
+      params_eff.data_request={'ECN',['G' num2str(i) 'TOR']};
+      gdat_data_i=gdat_aug(shot,params_eff);
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i+4}.gtor_ec = gdat_data_i;
+      end
+      ishift=0;
+      if shot >= 36794; ishift=4; end
+      params_eff.data_request={'ECN',['G' num2str(i+ishift) 'PO4']};
+      try
+        gdat_data_i=gdat_aug(shot,params_eff);
+      catch ME1
+        disp(getReport(ME1))
+        gdat_data_i.data = [];
+      end
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i+4}.gpo4_ec = gdat_data_i;
+      end
+      params_eff.data_request={'ECN',['G' num2str(i+ishift) 'PO8']};
+      try
+        gdat_data_i=gdat_aug(shot,params_eff);
+      catch ME2
+        disp(getReport(ME2))
+        gdat_data_i.data = [];
+      end
+      if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
+      else
+        gdat_data.ec{i+4}.gpo8_ec = gdat_data_i;
+      end
+    end
+    if ~isempty(gdat_data.dim)
+      gdat_data.t = gdat_data.dim{1};
+      gdat_data.x = gdat_data.dim{2};
+      gdat_data.dimunits=[{'time [s]'} {'ECRH1(1:4) ECRH2(1:4) ECtot'}];
+      gdat_data.units='W';
+      gdat_data.freq_ech_units = 'GHz';
+      gdat_data.data_fullpath=['ECS/' 'PGi and PGiN, etc'];
+      icount=0;
+      for i=1:length(labels)
+        if ~isempty(labels{i})
+          icount=icount+1;
+          gdat_data.label{icount} = labels{i};
+        end
+      end
+    else
+      gdat_data.freq_ech_units =[]';
+      gdat_data.ec = [];
+      gdat_data.freq_ec = [];
+      gdat_data.polpos_ec = [];
+      gdat_data.torpos_ec = [];
+    end
+
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'powers'}
+    sources_avail = {'ohm','ec','nbi','ic','rad'}; % note should allow ech, nbh, ohmic in parameter sources
+    for i=1:length(sources_avail)
+      gdat_data.(sources_avail{i}).data = [];
+      gdat_data.(sources_avail{i}).units = [];
+      gdat_data.(sources_avail{i}).dim=[];
+      gdat_data.(sources_avail{i}).dimunits=[];
+      gdat_data.(sources_avail{i}).t=[];
+      gdat_data.(sources_avail{i}).x=[];
+      gdat_data.(sources_avail{i}).data_fullpath=[];
+      gdat_data.(sources_avail{i}).label=[];
+    end
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = sources_avail;
+    elseif ~iscell(gdat_data.gdat_params.source)
+      if ischar(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
+        if ~any(strmatch(gdat_data.gdat_params.source,lower(sources_avail)))
+          if (gdat_params.nverbose>=1)
+            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
+          end
+          return
         else
-            % more than 2 dimensions, find the one with same length to define timedim
-            mapping_for_aug.timedim = find(size(aatmp.data)==length(aatmp.t));
-            if length(mapping_for_aug.timedim); mapping_for_aug.timedim = mapping_for_aug.timedim(1); end
+          gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
         end
-        mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
+      else
+        if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
+        return
+      end
+    else
+      for i=1:length(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
+        if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
+          if gdat_data.gdat_params.nverbose>=1
+            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
+          end
+        end
+      end
     end
-    if length(size(aatmp.data))==1 | (length(size(aatmp.data))==2 & size(aatmp.data,2)==1)
-        gdat_data.dim=[{aatmp.t}];
-        gdat_data.dimunits={'time [s]'};
-    elseif length(size(aatmp.data))==2
-        gdat_data.dim{mapping_for_aug.timedim} = gdat_data.t;
-        gdat_data.dimunits{mapping_for_aug.timedim} = 'time [s]';
-        if isfield(aatmp, 'source')
-            gdat_data.dim{setdiff([1:2],mapping_for_aug.timedim)} = gdat_data.source;
+    % always start from ohmic so can use this time as base time since should yield full shot
+
+    fields_to_copy = {'data','units','dim','dimunits','t','x','data_fullpath','label','help','gdat_params'};
+    fields_to_not_copy = {'shot','gdat_request'};
+    % total of each source in .data, but full data in subfield like pgyro in .ec, to check for nbi
+    params_eff = gdat_data.gdat_params;
+    % ohmic, use its time-base
+    params_eff.data_request={'TOT','P_OH'};
+    try
+      ohm=gdat_aug(shot,params_eff);
+    catch
+      ohm.data = [];
+      ohm.dim = [];
+    end
+    if ~isempty(ohm.data) && ~isempty(ohm.dim)
+      for i=1:length(fields_to_copy)
+        if isfield(ohm,fields_to_copy{i})
+          gdat_data.ohm.(fields_to_copy{i}) = ohm.(fields_to_copy{i});
+        end
+      end
+      gdat_data.ohm.raw_data = gdat_data.ohm.data;
+    else
+      if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
+      return
+    end
+    mapping_for_aug.timedim = 1; mapping_for_aug.gdat_timedim = 1;
+    taus = -10;
+    %
+    % add each source in main.data, on ohm time array
+    gdat_data.t = gdat_data.ohm.t;
+    gdat_data.dim{1} = gdat_data.t;
+    gdat_data.dimunits{1} = 's';
+    gdat_data.ohm.data = interpos(gdat_data.t,gdat_data.ohm.raw_data,5.*taus);
+    gdat_data.data = reshape(gdat_data.ohm.data,length(gdat_data.t),1);
+    gdat_data.ohm.tension = 5.*taus;
+    gdat_data.x =[1];
+    gdat_data.label={'P_{ohm}'};
+    gdat_data.units = 'W';
+    %
+    if any(strmatch('ec',gdat_data.gdat_params.source))
+      % ec
+      params_eff.data_request={'ECS','PECRH'};
+      params_eff.data_request='pgyro';
+      try
+        ec=gdat_aug(shot,params_eff);
+      catch
+      end
+      if ~isempty(ec.data) && ~isempty(ec.dim)
+        for i=1:length(fields_to_copy)
+          % if has pgyro, use not_copy
+          if isfield(ec,fields_to_copy{i}) && ~any(strmatch(fields_to_not_copy,fields_to_copy{i}))
+            gdat_data.ec.(fields_to_copy{i}) = ec.(fields_to_copy{i});
+          end
+        end
+        gdat_data.data(:,end+1) = interpos(-21,gdat_data.ec.t,gdat_data.ec.data(:,end),gdat_data.t);
+        gdat_data.x(end+1) =gdat_data.x(end)+1;
+        gdat_data.label{end+1}='P_{ec}';
+      end
+    end
+    %
+    if any(strmatch('nb',gdat_data.gdat_params.source))
+      % nbi
+      params_eff.data_request={'NIS','PNIQ'};
+      try
+        nbi=gdat_aug(shot,params_eff);
+      catch
+        nbi.data = [];
+        nbi.dim = [];
+      end
+      if ~isempty(nbi.data) && ~isempty(nbi.dim)
+        for i=1:length(fields_to_copy)
+          if isfield(nbi,fields_to_copy{i})
+            gdat_data.nbi.(fields_to_copy{i}) = nbi.(fields_to_copy{i});
+          end
+        end
+        % add to main with linear interpolation and 0 for extrapolated values
+        gdat_data.data(:,end+1) = interpos(-21,gdat_data.nbi.t,gdat_data.nbi.data(:,end),gdat_data.t);
+        gdat_data.x(end+1) =gdat_data.x(end)+1;
+        gdat_data.label{end+1}='P_{nbi}';
+      end
+    end
+    %
+    if any(strmatch('ic',gdat_data.gdat_params.source))
+      % ic
+      params_eff.data_request={'ICP','PICRN'};
+      try
+        ic=gdat_aug(shot,params_eff);
+      catch
+        ic.data = [];
+        ic.dim = [];
+      end
+      if ~isempty(ic.data) && ~isempty(ic.dim)
+        for i=1:length(fields_to_copy)
+          if isfield(ic,fields_to_copy{i})
+            gdat_data.ic.(fields_to_copy{i}) = ic.(fields_to_copy{i});
+          end
+        end
+        gdat_data.data(:,end+1) = interpos(-21,gdat_data.ic.t,gdat_data.ic.data,gdat_data.t);
+        gdat_data.x(end+1) =gdat_data.x(end)+1;
+        gdat_data.label{end+1}='P_{ic}';
+      end
+    end
+    index_prad = [];
+    if any(strmatch('rad',gdat_data.gdat_params.source))
+      % radiated power
+      params_eff.data_request='prad';
+      try
+        rad=gdat_aug(shot,params_eff);
+      catch
+      end
+      if ~isempty(rad.data) && ~isempty(rad.dim)
+        for i=1:length(fields_to_copy)
+          if isfield(rad,fields_to_copy{i})
+            gdat_data.rad.(fields_to_copy{i}) = rad.(fields_to_copy{i});
+          end
+        end
+        % add to main with linear interpolation and 0 for extrapolated values
+        gdat_data.data(:,end+1) = interpos(-21,gdat_data.rad.t,gdat_data.rad.data,gdat_data.t);
+        index_prad = size(gdat_data.data,2); % to not add for ptot
+        gdat_data.x(end+1) =gdat_data.x(end)+1;
+        gdat_data.label{end+1}='P_{rad}';
+      end
+    end
+    % add tot power
+    index_noprad = setdiff([1:size(gdat_data.data,2)],index_prad);
+    gdat_data.data(:,end+1) = sum(gdat_data.data(:,index_noprad),2);
+    gdat_data.label{end+1}='P_{tot,h}';
+    gdat_data.x(end+1) =gdat_data.x(end)+1;
+    gdat_data.dim{2} = gdat_data.x; gdat_data.dimunits{2} = '';
+    gdat_data.data_fullpath = 'tot powers from each sources, and total heating power in .data(:,end)';
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'q_rho'}
+    [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
+    % since Lpf depends on time, need to load all first and then loop over time for easier mapping
+    [qpsi,e]=rdaAUG_eff(shot,DIAG,'Qpsi',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    ndimrho = size(qpsi.data,2);
+    if ndimrho==NTIME_Lpf
+      % data seems to be transposed
+      ndimrho = size(qpsi.data,1);
+      itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
+    else
+      itotransposeback = 0;
+    end
+    qpsi=adapt_rda(qpsi,NTIME,ndimrho,itotransposeback);
+    ijnan=find(isnan(qpsi.value));
+    qpsi.value(ijnan)=0;
+    [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
+    [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
+    [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
+    % seems "LCFS" q-value is far too large, limit to some max (when diverted)
+    max_qValue = 30.; % Note could just put a NaN on LCFS value since ill-defined when diverted
+    for it=1:NTIME
+      Lpf1 = Lpf1_t(it);
+      % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
+      % change it to (radial,time) and use only Lpf+1 points up to LCFS
+      ijok=find(qpsi.value(:,1)); % note: eqr fills in only odd points radially
+      % set NaNs to zeroes
+      if qpsi.value(ijok(1),1)<0
+        gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
+      else
+        gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
+      end
+      % get x values
+      psi_it=psi_tree.value(it,Lpf1:-1:1)';
+      gdat_data.psi_axis(it)= psi_it(1);
+      gdat_data.psi_lcfs(it)= psi_it(end);
+      gdat_data.rhopolnorm(:,it) = sqrt(abs((psi_it-gdat_data.psi_axis(it)) ./(gdat_data.psi_lcfs(it)-gdat_data.psi_axis(it))));
+      if strcmp(DIAG,'EQR');
+        % q value has only a few values and from center to edge, assume they are from central rhopol values on
+        % But they are every other point starting from 3rd
+        ijk=find(gdat_data.qvalue(:,it)~=0);
+        if length(ijk)>2
+          % now shots have non-zero axis values in eqr
+          rhoeff=gdat_data.rhopolnorm(ijk,it);
+          qeff=gdat_data.qvalue(ijk,it); % radial order was already inverted above
+          if ijk(1)>1
+            rhoeff = [0.; rhoeff];
+            qeff = [qeff(1) ;qeff];
+          end
+          ij_nonan=find(~isnan(gdat_data.rhopolnorm(:,it)));
+          qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
+          qfit(ij_nonan)=interpos(rhoeff,qeff,gdat_data.rhopolnorm(ij_nonan,it),-0.01,[1 0],[0 0],[300; ones(size(qeff(1:end-1)))]);
         else
-            gdat_data.dim{setdiff([1:2],mapping_for_aug.timedim)} = gdat_data.x;
+          qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
         end
+        gdat_data.qvalue(:,it) = qfit;
+      end
+      % get rhotor values
+      phi_it = phi_tree.value(it,Lpf1:-1:1)';
+      gdat_data.rhotornorm(:,it) = sqrt(abs(phi_it ./ phi_it(end)));
+      % get rhovol values
+      vol_it=Vol.value(it,2*Lpf1-1:-2:1)';
+      gdat_data.rhovolnorm(:,it) = sqrt(abs(vol_it ./ vol_it(end)));
+      % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
+      % change it to (radial,time) and use only Lpf+1 points up to LCFS
+      ijok=find(qpsi.value(:,1)); % note: eqr fills in only odd points radially
+      % max value 1e6, change to 2*extrapolation (was max_qValue before)
+      q_edge=interpos(gdat_data.rhotornorm(1:end-1,it),qpsi.value(it,Lpf1:-1:2),1,-0.1);
+      gdat_data.qvalue(:,it) = qpsi.value(it,Lpf1:-1:1)';
+      if abs(gdat_data.qvalue(end,it)) > 1e3
+        % assume diverted
+        gdat_data.qvalue(end,it) = 2. * q_edge;
+      end
+% $$$       if qpsi.value(ijok(1),1)<0
+% $$$   gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
+% $$$       else
+% $$$   gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
+% $$$       end
+    end
+    gdat_data.x = gdat_data.rhopolnorm;
+    % get time values
+    gdat_data.data = gdat_data.qvalue; % put q in data
+    gdat_data.units=[]; % not applicable
+    gdat_data.data_fullpath = [DIAG ' from exp_name: ' gdat_data.gdat_params.exp_name '; q(rhopolnorm,t) in .data(.x,.t)'];
+    gdat_data.cocos = 17; % should check FPP (IDE seems 13)
+    gdat_data.dim{1} = gdat_data.x;
+    gdat_data.dim{2} = gdat_data.t;
+    gdat_data.dimunits{1} = 'rhopolnorm';
+    gdat_data.dimunits{2} = 'time [s]';
+    % add grids_1d to have rhotor, etc
+    gdat_data = get_grids_1d(gdat_data,2,1,gdat_params.nverbose);
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'psi_axis', 'psi_edge'}
+    if strcmp(upper(gdat_data.gdat_params.equil),'FPG')
+      gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
+      gdat_params_eff.data_request = [{'FPG'},{'fax-bnd'},{'AUGD'}];
+      gdat_data = gdat_aug(gdat_data.shot,gdat_params_eff);
+      gdat_data.gdat_params = gdat_params_prev;
+      gdat_data.label = 'psi\_axis-psi\_edge';
+      gdat_data.data_fullpath = [gdat_data.data_fullpath ' yields only psi\_axis-psi\_edge from FPG/fax-bnd'];
     else
-        gdat_data.dim{mapping_for_aug.timedim} = gdat_data.t;
-        gdat_data.dimunits{mapping_for_aug.timedim} = 'time [s]';
-        nbdims = length(size(gdat_data.data));
-        % should copy dims from aatmp but skip time dm already set
-        if numel(aatmp.dim) ~= nbdims
-            error(['in gdat_aug: numel(aatmp.dim)(=',num2str(numel(aatmp.dim)),') ~= nbdims(=',num2str(nbdims),')']);
+      [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
+      % since Lpf depends on time, need to load all first and then loop over time for easier mapping
+      [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+      ndimrho = size(psi_tree.data,2);
+      if ndimrho==NTIME_Lpf
+        % data seems to be transposed
+        ndimrho = size(psi_tree.data,1);
+        itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
+      else
+        itotransposeback = 0;
+      end
+      psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
+      ijnan=find(isnan(psi_tree.value));
+      psi_tree.value(ijnan)=0;
+      gdat_data.dim{1} = gdat_data.t;
+      gdat_data.dimunits{1} = 'time [s]';
+      for it=1:NTIME
+        Lpf1 =min(Lpf1_t(it),size(psi_tree.value,2));
+        psi_it=psi_tree.value(it,Lpf1:-1:1)';
+        if strcmp(data_request_eff,'psi_axis')
+          gdat_data.data(it)= psi_it(1);
+        elseif strcmp(data_request_eff,'psi_edge')
+          gdat_data.data(it)= psi_it(end);
         else
-            iotherdims = setdiff([1:nbdims],mapping_for_aug.timedim);
-            % set 1st non-time dim to .x
-            if ~isequal(aatmp.x,aatmp.dim{iotherdims(1)}); warning('aatmp.x was not 1st non-time dim'); end
-            gdat_data.dim(iotherdims) = aatmp.dim(iotherdims);
-            gdat_data.dimunits(iotherdims) = aatmp.dimunits(iotherdims);
-            gdat_data.x = gdat_data.dim{iotherdims(1)};
-            % often time as 1st dim, but would be more "our" standard as 2nd dim, at this stage change systematically
-            if mapping_for_aug_timedim_orig <= 0 && mapping_for_aug.timedim==1
-                % switch 1st two dimensions
-                adim = gdat_data.dim;
-                gdat_data.dim(1:2) = adim([2 1]);
-                adimunits = gdat_data.dimunits;
-                gdat_data.dimunits(1:2) = adimunits([2 1]);
-                mapping_for_aug.timedim = 2;
-                mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
-                if numel(size(gdat_data.dim{1}))==2; gdat_data.dim{1} = gdat_data.dim{1}'; end
-                gdat_data.x = gdat_data.dim{1};
-                gdat_data.t = gdat_data.dim{mapping_for_aug.timedim};
-                adata = gdat_data.data;
-                gdat_data.data = permute(adata,[2 1 3:numel(size(adata))]);
-            end
         end
+      end
+      gdat_data.units = psi_tree.units;
+      gdat_data.data_fullpath = [DIAG '/PFL extract ' data_request_eff];
     end
-    nbdims = length(gdat_data.dim);
-    gdat_data.units = aatmp.units;
-    if mapping_for_aug.gdat_timedim>0 && mapping_for_aug.gdat_timedim ~= mapping_for_aug.timedim
-        % shift timedim to gdat_timedim data(i,j,...itime,k,...) -> data(i,inewtime,j,...,k,...)
-        % note that this means that gdat_data.x and gdat_data.t are same and correct,
-        % only .data, .dim and .dimunits need to be changed
-        iprev=[1:nbdims];
-        ij=find(dim_nontim>mapping_for_aug.gdat_timedim-1);
-        inew=[1:mapping_for_aug.gdat_timedim-1 mapping_for_aug.timedim dim_nontim(ij)];
-        data_sizes = size(aatmp.data);
-        gdat_data.data = NaN*ones(data_sizes(inew));
-        abcol=ones(1,nbdims)*double(':'); abcomma=ones(1,nbdims)*double(',');
-        dimstr_prev=['(' repmat(':,',1,mapping_for_aug.timedim-1) 'it,' ...
-            repmat(':,',1,nbdims-mapping_for_aug.timedim-1) ':)'];
-        dimstr_new=['(' repmat(':,',1,mapping_for_aug.gdat_timedim-1) 'it,' ...
-            repmat(':,',1,nbdims-mapping_for_aug.gdat_timedim-1) ':)'];
-        % eval gdat_data.data(;,:,...,it,...) = aatmp.data(:,:,:,it,...);
-        for it=1:size(aatmp.data,mapping_for_aug.timedim)
-            shift_eval = ['gdat_data.data' dimstr_new ' = aatmp.data'  dimstr_prev ';'];
-            eval(shift_eval);
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'raptor'}
+    sources_avail = {'observer','predictive'};
+    for i=1:length(sources_avail)
+      gdat_data.(sources_avail{i}).data = [];
+      gdat_data.(sources_avail{i}).units = [];
+      gdat_data.(sources_avail{i}).dim=[];
+      gdat_data.(sources_avail{i}).dimunits=[];
+      gdat_data.(sources_avail{i}).t=[];
+      gdat_data.(sources_avail{i}).x=[];
+      gdat_data.(sources_avail{i}).data_fullpath=[];
+      gdat_data.(sources_avail{i}).label=[];
+    end
+    rap_signals={'ECE_f','Hmode','Ip','P_LH','Phib','beta','cs','exflag','g_f','it','li3','ne_f','res','tcomp','ECEm', ...
+                 'F','Vp','chie','dk_k','dpsi','dte','g1','g23or','g2','g3','iota','jbs','jec','jnb','jpar','ne','ni', ...
+                 'p','paux','pbrem','pec','pei','pnbe','poh','prad','psi','q','rhtECE','sdk_k','shear','signeo','sxk_k', ...
+                 'te','ti','upl','xk_k','ze'};
+
+    rap_desc_signals={'rts:Dia/RAPTOR/ECEflag.val','rts:Dia/RAPTOR/Hmode.val','rts:Dia/RAPTOR/Ip.val','rts:Dia/RAPTOR/P_LH.val',...
+                      'rts:Dia/RAPTOR/Phib.val','rts:Dia/RAPTOR/beta.val','rts:Dia/RAPTOR/conf_state.val', ...
+                      'rts:Dia/RAPTOR/exitflag.val','rts:Dia/RAPTOR/gflag.val','rts:Dia/RAPTOR/it.val', ...
+                      'rts:Dia/RAPTOR/li3.val','rts:Dia/RAPTOR/neflag.val','rts:Dia/RAPTOR/res.val', ...
+                      'rts:Dia/RAPTOR/dtcomp.val','rts:Dia/RAPTOR/ECEmask.val','rts:Dia/RAPTOR/F.val', ...
+                      'rts:Dia/RAPTOR/Vp.val','rts:Dia/RAPTOR/chie.val','rts:Dia/RAPTOR/dk_k.val', ...
+                      'rts:Dia/RAPTOR/dpsi.val','rts:Dia/RAPTOR/dte.val','rts:Dia/RAPTOR/g1.val', ...
+                      'rts:Dia/RAPTOR/g23or.val','rts:Dia/RAPTOR/g2.val','rts:Dia/RAPTOR/g3.val', ...
+                      'rts:Dia/RAPTOR/iota.val','rts:Dia/RAPTOR/jbs.val','rts:Dia/RAPTOR/jec.val', ...
+                      'rts:Dia/RAPTOR/jnb.val','rts:Dia/RAPTOR/jpar.val','rts:Dia/RAPTOR/ne.val', ...
+                      'rts:Dia/RAPTOR/ni.val','rts:Dia/RAPTOR/p.val','rts:Dia/RAPTOR/paux.val', ...
+                      'rts:Dia/RAPTOR/pbrem.val','rts:Dia/RAPTOR/pec.val','rts:Dia/RAPTOR/pei.val', ...
+                      'rts:Dia/RAPTOR/pnbe.val','rts:Dia/RAPTOR/poh.val','rts:Dia/RAPTOR/prad.val', ...
+                      'rts:Dia/RAPTOR/psi.val','rts:Dia/RAPTOR/q.val','rts:Dia/RAPTOR/rhotorECE.val', ...
+                      'rts:Dia/RAPTOR/sdk_k.val','rts:Dia/RAPTOR/shear.val','rts:Dia/RAPTOR/signeo.val', ...
+                      'rts:Dia/RAPTOR/sxk_k.val','rts:Dia/RAPTOR/te.val','rts:Dia/RAPTOR/ti.val', ...
+                      'rts:Dia/RAPTOR/upl.val','rts:Dia/RAPTOR/xk_k.val','rts:Dia/RAPTOR/ze.val'};
+
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = sources_avail;
+    elseif ~iscell(gdat_data.gdat_params.source)
+      if ischar(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
+        if strcmp(gdat_data.gdat_params.source(1),'o'); gdat_data.gdat_params.source = 'observer'; end
+        if strcmp(gdat_data.gdat_params.source(1),'p'); gdat_data.gdat_params.source = 'predictive'; end
+        if ~any(strmatch(gdat_data.gdat_params.source,lower(sources_avail)))
+          if (gdat_params.nverbose>=1)
+            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
+          end
+          return
+        else
+          gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
         end
-        gdat_data.dim = aatmp.dim(inew);
-        % gdat_data.dimunits = aatmp.dimunits(inew);
+      else
+        if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
+        return
+      end
     else
-        mapping_for_aug.gdat_timedim = mapping_for_aug.timedim;
+      for i=1:length(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
+        if strcmp(gdat_data.gdat_params.source{i}(1),'o'); gdat_data.gdat_params.source{i} = 'observer'; end
+        if strcmp(gdat_data.gdat_params.source{i}(1),'p'); gdat_data.gdat_params.source{i} = 'predictive'; end
+        if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
+          if gdat_data.gdat_params.nverbose>=1
+            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
+          end
+        end
+      end
+    end
+
+    for i=1:length(gdat_data.gdat_params.source)
+      it_def=0;
+      for j=1:length(rap_signals)
+        gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
+        gdat_params_eff.data_request = {'RAP',[rap_signals{j} '_' gdat_data.gdat_params.source{i}(1)],gdat_params_eff.exp_name};
+        abcd = gdat_aug(gdat_data.shot,gdat_params_eff);
+        gdat_data.(gdat_data.gdat_params.source{i}).(rap_signals{j}) = abcd;
+        gdat_data.(gdat_data.gdat_params.source{i}).(rap_signals{j}).description = rap_desc_signals{j};
+        if strcmp(rap_signals{j},'q') && ~isempty(abcd.data)
+          % promote q at top level of gdat_data.(gdat_data.gdat_params.source{i})
+          gdat_data.(gdat_data.gdat_params.source{i}).data = abcd.data;
+          gdat_data.(gdat_data.gdat_params.source{i}).t = abcd.t;
+          gdat_data.(gdat_data.gdat_params.source{i}).x = abcd.x;
+          gdat_data.(gdat_data.gdat_params.source{i}).units = ['q RAPTOR_' gdat_data.gdat_params.source{i}(1:3) ' various rho'];
+          gdat_data.(gdat_data.gdat_params.source{i}).dim = abcd.dim;
+          gdat_data.(gdat_data.gdat_params.source{i}).dimunits = abcd.dimunits;
+          gdat_data.(gdat_data.gdat_params.source{i}).dimunits{1} = 'various rhotor';
+          gdat_data.(gdat_data.gdat_params.source{i}).data_fullpath = abcd.data_fullpath;
+          gdat_data.(gdat_data.gdat_params.source{i}).label = ['q RAPTOR_' gdat_data.gdat_params.source{i}(1:3) ' various rho'];
+        end
+      end
+    end
+    %
+    % promote somethin at top level of gdat_data?
+    %
+    gdat_data.data_fullpath = {'RAP','signals_o in observer _p in predictive, one signal(q) copied at top',gdat_data.gdat_params.exp_name};
+    % promote predictive promoted signal if non-empty, otherwise observer one
+    if ~isempty(gdat_data.predictive.data)
+      source_promoted = 'predictive';
+    else
+      source_promoted = 'observer';
+    end
+    gdat_data.data = gdat_data.(source_promoted).data;
+    gdat_data.x = gdat_data.(source_promoted).x;
+    gdat_data.t = gdat_data.(source_promoted).t;
+    gdat_data.units = gdat_data.(source_promoted).units;
+    gdat_data.dim = gdat_data.(source_promoted).dim;
+    gdat_data.dimunits = gdat_data.(source_promoted).dimunits;
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'rhotor', 'rhotor_edge', 'rhotor_norm', 'rhovol', 'volume_rho'}
+    if strcmp(upper(gdat_data.gdat_params.equil),'FPG')
+      gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
+      gdat_params_eff.data_request = [{'FPG'},{'Vol'},{'AUGD'}];
+      gdat_data = gdat_aug(gdat_data.shot,gdat_params_eff);
+      gdat_data.gdat_params = gdat_params_prev;
+      gdat_data.label = 'Vol';
+      gdat_data.data_fullpath = [gdat_data.data_fullpath ' yields only edge Volume from FPG/Vol'];
+      return
+    end
+    [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
+    % since Lpf depends on time, need to load all first and then loop over time for easier mapping
+    [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    ndimrho = size(phi_tree.data,2);
+    if ndimrho==NTIME_Lpf
+      % data seems to be transposed
+      ndimrho = size(phi_tree.data,1);
+      itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
+    else
+      itotransposeback = 0;
     end
-    % end of method "signal"
-    
+    phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
+    ijnan=find(isnan(phi_tree.value));
+    phi_tree.value(ijnan)=0;
+    [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
+    [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+    psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
+    %
+    switch data_request_eff
+     case {'volume_rho', 'rhovol'}
+      for it=1:NTIME
+        Lpf1 = Lpf1_t(it);
+        psi_it=psi_tree.value(it,Lpf1:-1:1)';
+        psi_axis(it)= psi_it(1);
+        psi_lcfs(it)= psi_it(end);
+        gdat_data.x(:,it) = sqrt(abs((psi_it-psi_axis(it)) ./(psi_lcfs(it)-psi_axis(it))));
+        gdat_data.vol(:,it)=Vol.value(it,2*Lpf1-1:-2:1)';
+        % gdat_data.dvoldpsi(:,it)=Vol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
+        gdat_data.rhovolnorm(:,it) = sqrt(abs(gdat_data.vol(:,it) ./ gdat_data.vol(end,it)));
+      end
+      gdat_data.dim{1} = gdat_data.x;
+      gdat_data.dim{2} = gdat_data.t;
+      gdat_data.dimunits{1} = 'rhopolnorm';
+      gdat_data.dimunits{2} = 'time [s]';
+      gdat_data.volume_edge = gdat_data.vol(end,:);
+      if strcmp(data_request_eff,'volume_rho')
+        gdat_data.data = gdat_data.vol;
+        gdat_data.units = Vol.units;
+      else strcmp(data_request_eff,'rhovol');
+        gdat_data.data = gdat_data.rhovolnorm;
+        gdat_data.units = ' ';
+      end
+     case {'rhotor', 'rhotor_edge', 'rhotor_norm'}
+      b0=gdat_aug(shot,'b0');
+      gdat_data.b0 = interpos(b0.t,b0.data,gdat_data.t,-1);
+      for it=1:NTIME
+        Lpf1 = Lpf1_t(it);
+        gdat_data.phi(:,it) = phi_tree.value(it,Lpf1:-1:1)';
+        gdat_data.rhotornorm(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.phi(end,it)));
+        gdat_data.rhotor(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.b0(it) ./ pi));
+        psi_it=psi_tree.value(it,Lpf1:-1:1)';
+        psi_axis(it)= psi_it(1);
+        psi_lcfs(it)= psi_it(end);
+        gdat_data.x(:,it) = sqrt(abs((psi_it-psi_axis(it)) ./(psi_lcfs(it)-psi_axis(it))));
+      end
+      % always provide rhotor_edge so field always exists
+      gdat_data.rhotor_edge = gdat_data.rhotor(end,:);
+      if strcmp(data_request_eff,'rhotor')
+        gdat_data.data = gdat_data.rhotor;
+        gdat_data.units = 'm';
+        gdat_data.dim{1} = gdat_data.x;
+        gdat_data.dim{2} = gdat_data.t;
+        gdat_data.dimunits{1} = 'rhopolnorm';
+        gdat_data.dimunits{2} = 'time [s]';
+      elseif strcmp(data_request_eff,'rhotor_edge')
+        gdat_data.data = gdat_data.rhotor(end,:);
+        gdat_data.units = 'm';
+        gdat_data.dim{1} = gdat_data.t;
+        gdat_data.dimunits{1} = 'time [s]';
+      elseif strcmp(data_request_eff,'rhotor_norm')
+        gdat_data.data = gdat_data.rhotornorm;
+        gdat_data.units = ' ';
+        gdat_data.dim{1} = gdat_data.x;
+        gdat_data.dim{2} = gdat_data.t;
+        gdat_data.dimunits{1} = 'rhopolnorm';
+        gdat_data.dimunits{2} = 'time [s]';
+      end
+    end
+    gdat_data.data_fullpath = [DIAG '/PFL extract in .data: ' data_request_eff];
+
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-elseif strcmp(mapping_for_aug.method,'expression')
-    % 2nd: method="expression"
-    % assume expression contains an expression to evaluate and which creates a local structure into variable gdat_tmp
-    % we copy the structure, to make sure default nodes are defined and to avoid if return is an closed object like tdi
-    % eval_expr = [mapping_for_aug.expression ';'];
-    gdata_data_orig = gdat_data;
-    fields_to_copy = {'gdat_params', 'gdat_request', 'label', 'data_fullpath', 'request_description', 'mapping_for'};
-    eval([mapping_for_aug.expression ';']);
-    for i=1:length(fields_to_copy)
-        if isfield(gdata_data_orig,fields_to_copy{i})
-            gdat_tmp.(fields_to_copy{i}) = gdata_data_orig.(fields_to_copy{i});
+   case {'sxr'}
+    % sxr from B by default or else if 'source','else' is provided
+    if ~isfield(gdat_data.gdat_params,'freq')|| isempty(gdat_data.gdat_params.freq)
+      gdat_data.gdat_params.freq = 'slow';
+    end
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = 'G';
+    elseif length(gdat_data.gdat_params.source)>1 || ...
+          upper(gdat_data.gdat_params.source)<'F' || upper(gdat_data.gdat_params.source)>'M'
+      if gdat_data.gdat_params.nverbose>=1
+        warning(['source = ' gdat_data.gdat_params.source ' not expected with data_request= ' data_request_eff])
+      end
+      return
+    end
+    dim1_len = 'from_chord_nb'; % thus up to max(chords_ok_nb)
+    if ~isfield(gdat_data.gdat_params,'camera') || isempty(gdat_data.gdat_params.camera)
+      gdat_data.gdat_params.camera = [];
+    elseif ischar(gdat_data.gdat_params.camera) && strcmp(gdat_data.gdat_params.camera,'central')
+      gdat_data.gdat_params.source = 'J';
+      gdat_data.gdat_params.camera = 49;
+    elseif isnumeric(gdat_data.gdat_params.camera)
+      % ok keep the array, but first dim to contain just the related chords
+      dim1_len='nb_of_chords';
+    else
+      if gdat_data.gdat_params.nverbose>=1
+        warning(['camera = ' gdat_data.gdat_params.camera ' not expected with data_request= ' data_request_eff])
+      end
+      return
+    end
+    if length(gdat_data.gdat_params.camera)==1; dim1_len='nb_of_chords'; end
+    gdat_data.gdat_params.source = upper(gdat_data.gdat_params.source);
+    %
+    if ~isfield(gdat_data.gdat_params,'time_interval')
+      gdat_data.gdat_params.time_interval = [];
+    end
+    [aa,bb]=unix(['ssh ' '-o "StrictHostKeyChecking no" sxaug20.aug.ipp.mpg.de WhichSX ' num2str(shot) ' ' ...
+                  upper(gdat_data.gdat_params.source)]);
+    chords_ok_diags=regexpi(bb,'(?<chord>[A-Z]_[0-9]+)\saddress:\s[0-9]+\sDiag:\s(?<diag>[A-Z]+)','names');
+    if isempty(chords_ok_diags)
+      chords_ok_nb = [];
+    else
+      for i=1:length(chords_ok_diags)
+        chords_ok_nb(i) =  str2num(chords_ok_diags(i).chord(3:end));
+      end
+    end
+    if isempty(gdat_data.gdat_params.camera);
+      gdat_data.gdat_params.camera = chords_ok_nb;
+    else
+      for i=1:length(gdat_data.gdat_params.camera)
+        ij=find(chords_ok_nb==gdat_data.gdat_params.camera(i));
+        if ~isempty(ij)
+          chords_ok_diags_tmp(i) = chords_ok_diags(ij);
+        else
+          % chord not in use
+          chords_ok_diags_tmp(i).chord = [];
+          chords_ok_diags_tmp(i).diag = [];
         end
+      end
+      chords_ok_diags = chords_ok_diags_tmp;
+      chords_ok_nb = gdat_data.gdat_params.camera;
     end
-    if isempty(gdat_tmp) || (~isstruct(gdat_tmp) & ~isobject(gdat_tmp))
-        if (gdat_params.nverbose>=1); warning(['expression does not create a gdat_tmp structure: ' mapping_for_aug.expression]); end
-        error_status=801;
-        return
+    exp_name_eff = 'AUGD';
+    icount = 0;
+    nnth = 1;
+    if isnumeric(gdat_data.gdat_params.freq) && gdat_data.gdat_params.freq>1;
+      nnth = floor(gdat_data.gdat_params.freq+0.5);
+      gdat_data.gdat_params.freq = nnth;
     end
-    tmp_fieldnames = fieldnames(gdat_tmp);
-    if sum(strcmp(tmp_fieldnames,'data'))==0 % note: cannot do isfield since gdat_tmp might be an object
-        if (gdat_params.nverbose>=1); warning(['expression does not return a child name ''data'' for ' data_request_eff]); end
-    end
-    for i=1:length(tmp_fieldnames)
-        gdat_data.(tmp_fieldnames{i}) = gdat_tmp.(tmp_fieldnames{i});
-    end
-    % add .t and .x in case only dim is provided
-    % do not allow shifting of timedim since should be treated in the relevant expression
-    ijdim=find(strcmp(tmp_fieldnames,'dim')==1);
-    if ~isempty(ijdim)
-        nbdims = length(gdat_data.dim);
-        if mapping_for_aug.timedim==-1;
-            mapping_for_aug.timedim = nbdims;
-            if (size(gdat_data.data,nbdims)==1 && nbdims>1); mapping_for_aug.timedim = nbdims-1; end
+    for i=1:length(gdat_data.gdat_params.camera)
+      if ischar(gdat_data.gdat_params.freq) && strcmp(gdat_data.gdat_params.freq,'slow'); chords_ok_diags(i).diag = 'SSX'; end
+      if ~isempty(chords_ok_diags(i).diag) && ~isempty(chords_ok_diags(i).chord)
+        [a,e]=rdaAUG_eff(shot,chords_ok_diags(i).diag,chords_ok_diags(i).chord,exp_name_eff, ...
+          gdat_data.gdat_params.time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
+      else
+        a.data = [];
+        a.t = [];
+      end
+      if ~isempty(a.data)
+        icount = icount + 1;
+        if icount == 1
+          % first time has data
+          % assume all chords have same time base even if from different shotfile
+          % time missing one point
+          if length(a.value) == length(a.t)+1
+            a.t=linspace(a.range(1),a.range(2),length(a.value));
+            a_time.index(2) = length(a.value);
+          end
+          gdat_data.t = a.t(1:nnth:end);
+          gdat_data.units = a.units;
+          if strcmp(dim1_len,'from_chord_nb')
+            gdat_data.data = NaN*ones(max(chords_ok_nb),length(gdat_data.t));
+            gdat_data.dim{1} = [1:max(chords_ok_nb)]; % simpler to have index corresponding to chord number, except for central
+          else
+            gdat_data.data = NaN*ones(length(chords_ok_nb),length(gdat_data.t));
+            gdat_data.dim{1} = chords_ok_nb;
+          end
+          gdat_data.dim{2} = gdat_data.t;
+          gdat_data.dimunits = [{'chord nb'}; {'s'}];
+          gdat_data.data_fullpath = ['sxr from source=''' gdat_data.gdat_params.source ' uses shotfiles SX' ...
+                    setdiff(unique(strvcat(chords_ok_diags(:).diag)),'SX')'];
+          gdat_data.label = ['SXR/' upper(gdat_data.gdat_params.source)];
         end
-        dim_nontim = setdiff([1:nbdims],mapping_for_aug.timedim);
-        ijt=find(strcmp(tmp_fieldnames,'t')==1);
-        if isempty(ijt)
-            gdat_data.t = gdat_data.dim{mapping_for_aug.timedim};
+        try
+          if strcmp(dim1_len,'from_chord_nb')
+            gdat_data.data(chords_ok_nb(i),:) = a.data(1:nnth:end);
+          else
+            gdat_data.data(i,:) = a.data(1:nnth:end);
+          end
+        catch
+          if (gdat_params.nverbose>=1); disp(['problem with ' chords_ok_diags(i).diag ' ; ' chords_ok_diags(i).chord]); end
+
         end
-        ijx=find(strcmp(tmp_fieldnames,'x')==1);
-        if isempty(ijx)
-            if ~isempty(dim_nontim)
-                % since most cases have at most 2d, copy as array if data is 2D and as cell if 3D or more
-                if length(dim_nontim)==1
-                    gdat_data.x = gdat_data.dim{dim_nontim(1)};
-                else
-                    gdat_data.x = gdat_data.dim(dim_nontim);
-                end
-            end
+      else
+        % add fields not yet defined in case all cases have empty data
+      end
+    end
+    gdat_data.chords = chords_ok_nb;
+    if length(gdat_data.dim)>=1
+      gdat_data.x = gdat_data.dim{1};
+    end
+
+    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+   case {'transp'}
+    extra_arg_sf2sig_eff_string = '';
+    if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
+      extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
+    end
+    % most of the times the exp for the shotfile should be provided
+    shotfile_exp_eff = gdat_params.exp_name;
+    diagname='TRA';
+    gdat_params.equil = 'TRE';
+    gdat_data.gdat_params = gdat_params;
+    TRANSP_signals;
+    for i=1:size(transp_sig,1)
+      if strcmp(lower(transp_sig{i,2}),'signal') || strcmp(lower(transp_sig{i,2}),'signal-group')
+        try
+          abcd = rdaAUG_eff(shot,diagname,transp_sig{i,1},shotfile_exp_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
+          eval(['gdat_data.' transp_sig{i,1} '= abcd;']);
+          % eval(['[gdat_data.' transp_sig{i,1} ',e]=rdaAUG_eff(shot,diagname,''' transp_sig{i,1} ''',shotfile_exp_eff);']);
+        catch
+          eval(['gdat_data.' transp_sig{i,1} '=[];']);
+        end
+      elseif strcmp(lower(transp_sig{i,2}),'area-base')
+        clear adata_area
+        try
+          eval(['[adata_area]=sf2ab(diagname,shot,transp_sig{i,1},''-exp'',shotfile_exp_eff' extra_arg_sf2sig_eff_string  ');']);
+          adata_area.data = adata_area.value{1};
+        catch
+          adata_area.value = cell(0);
         end
-        gdat_data.data_fullpath=mapping_for_aug.expression;
+        eval(['gdat_data.' transp_sig{i,1} '=adata_area;']);
+      elseif strcmp(lower(transp_sig{i,2}),'time-base')
+        clear adata_time
+        try
+          eval(['[adata_time]=sf2tb(diagname,shot,transp_sig{i,1},''-exp'',shotfile_exp_eff,shotfile_exp_eff' extra_arg_sf2sig_eff_string ');']);
+          adata_time.data = adata_time.value;
+        catch
+          adata_time.value = [];
+        end
+        eval(['gdat_data.' transp_sig{i,1} '=adata_time;']);
+      end
+    end
+    % copy TIME to .t
+    if isfield(gdat_data,'TIME') && isfield(gdat_data.TIME,'value') && ~isempty(gdat_data.TIME.value)
+      gdat_data.t = gdat_data.TIME.value;
+      gdat_data.dim{1} = gdat_data.t;
+      gdat_data.dimunits{1} = gdat_data.TIME.unit;
     end
-    % end of method "expression"
-    
+
+    % add equilibrium
+    params_eff = gdat_params;
+    params_eff.data_request = 'equil';
+    gdat_data.equil = gdat_aug(shot,params_eff);
+
     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-elseif strcmp(mapping_for_aug.method,'switchcase')
-    switch data_request_eff % not lower(...) since data_request_eff should be lower case already at this stage
-        case {'cxrs', 'cxrs_rho'}
-            % if 'fit' option is added: 'fit',1, then the fitted profiles are returned which means "_rho" is effectively called
-            if ~isfield(gdat_data.gdat_params,'fit') || isempty(gdat_data.gdat_params.fit) || ~isnumeric(gdat_data.gdat_params.fit)
-                if strcmp(data_request_eff,'cxrs')
-                    gdat_data.gdat_params.fit = 0;
-                else
-                    gdat_data.gdat_params.fit = 1; % add fit as default if cxrs_rho requested (since equil takes most time)
-                end
-            elseif gdat_data.gdat_params.fit==1
-                data_request_eff = 'cxrs_rho';
-            end
-            exp_name_eff = gdat_data.gdat_params.exp_name;
-            sources_available = {'CEZ', 'CMZ', 'CUZ',    'COZ'};
-            r_node_available = {'R_time', 'R', 'R_time', 'R_time'};
-            z_node_available = {'z_time', 'z', 'z_time', 'z_time'};
-            % scroll through list up to first available when no sources provided
-            sources_available_for_scroll = {'CEZ', 'CUZ', 'COZ'};
-            scroll_through_list = 0;
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = sources_available_for_scroll(1);
-                scroll_through_list = 1; % means scroll through sources until one is available
-            elseif ischar(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
-            end
-            if length(gdat_data.gdat_params.source)==1
-                if strcmp(upper(gdat_data.gdat_params.source{1}),'CEZ')
-                    gdat_data.gdat_params.source = {'CEZ'};
-                elseif strcmp(upper(gdat_data.gdat_params.source{1}),'CMZ')
-                    gdat_data.gdat_params.source = {'CMZ'};
-                elseif strcmp(upper(gdat_data.gdat_params.source{1}),'CUZ')
-                    gdat_data.gdat_params.source = {'CUZ'};
-                elseif strcmp(upper(gdat_data.gdat_params.source{1}),'COZ')
-                    gdat_data.gdat_params.source = {'COZ'};
-                elseif strcmp(upper(gdat_data.gdat_params.source{1}),'ALL')
-                    gdat_data.gdat_params.source = sources_available;
-                    scroll_through_list = 2; % means scroll through all sources and load all sources
-                else
-                    warning(['source = ' gdat_data.gdat_params.source ' not expected with data_request= ' data_request_eff]);
-                    return
-                end
-            else
-                sources_in = intersect(sources_available,upper(gdat_data.gdat_params.source));
-                if length(sources_in) ~= length(gdat_data.gdat_params.source)
-                    disp('following sources not yet available, check with O. Sauter if need be')
-                    setdiff(upper(gdat_data.gdat_params.source),sources_available)
-                end
-                gdat_data.gdat_params.source = sources_in;
-            end
-            extra_arg_sf2sig_eff_string = '';
-            if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
-                extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
-            end
-            % set starting source
-            i_count = 1;
-            diag_name = gdat_data.gdat_params.source{i_count};
-            sources_tried{i_count} = diag_name;
-            iload = 1;
-            iequil = 0;
-            while iload==1
-                ishotfile_ok = 1;
-                i_source = strmatch(diag_name,sources_available);
-                r_node = r_node_available{i_source};
-                z_node = z_node_available{i_source};
-                % R, Z positions of measurements
-                try
-                    % eval(['[r_time]=sf2ab(diag_name,shot,r_node,''-exp'',exp_name_eff' extra_arg_sf2sig_eff_string ');']);
-                    % both for CEZ and CMZ, and.. Ti:1 is ok, otherwise introduce string above
-                    [r_time,err]=rdaAUG_eff(shot,diag_name,'Ti',exp_name_eff,[],extra_arg_sf2sig_eff_string,['area-base:' r_node ':1']);
-                catch ME_R_time
-                    % assume no shotfile
-                    disp(getReport(ME_R_time))
-                    ishotfile_ok = 0;
-                end
-                if ishotfile_ok == 1
-                    gdat_data.r = r_time.data;
-                    inotok=find(gdat_data.r<=0);
-                    gdat_data.r(inotok) = NaN;
-                    try
-                        if [exist('sf2sig')==3]
-                            [z_time,err]=rdaAUG_eff(shot,diag_name,'z_time',exp_name_eff,[],extra_arg_sf2sig_eff_string,['area-base:' z_node ':1']);
-                        else
-                            [z_time,err]=rdaAUG_eff(shot,diag_name,'z_time',exp_name_eff,[],extra_arg_sf2sig_eff_string);
-                        end
-                        gdat_data.z = z_time.data;
-                        inotok=find(gdat_data.z<=0);
-                        gdat_data.z(inotok) = NaN;
-                    catch ME_R_time
-                        disp(getReport(ME_R_time))
-                        ishotfile_ok = 0;
-                    end
-                else
-                    gdat_data.r = [];
-                    gdat_data.z = [];
-                end
-                if ishotfile_ok == 1
-                    try
-                        % eval(['[time]=sf2tb(diag_name,shot,''time'',''-exp'',exp_name_eff' extra_arg_sf2sig_eff_string ');']);
-                        if [exist('sf2sig')==3]
-                            [time,err] = rdaAUG_eff(shot,diag_name,'time',exp_name_eff,[],extra_arg_sf2sig_eff_string,'time-base:time:0');
-                        else
-                            time.data = r_time.t;
-                        end
-                        gdat_data.t = time.data;
-                    catch ME_R_time
-                        disp(getReport(ME_R_time))
-                        ishotfile_ok = 0;
-                    end
-                else
-                    gdat_data.t = [];
-                end
-                gdat_data.dim{1} = {gdat_data.r , gdat_data.z};
-                gdat_data.dimunits{1} = 'R, Z [m]';
-                gdat_data.dim{2} = gdat_data.t;
-                gdat_data.dimunits{2} = 't [s]';
-                gdat_data.x = gdat_data.dim{1};
-                % vrot
-                if ishotfile_ok == 1
-                    try
-                        [a,error_status]=rdaAUG_eff(shot,diag_name,'vrot',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                        if isempty(a.data) || isempty(a.t) || error_status>0
-                            if gdat_params.nverbose>=3;
-                                a
-                                disp(['with data_request= ' data_request_eff])
-                            end
-                        end
-                        [aerr,e]=rdaAUG_eff(shot,diag_name,'err_vrot',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                    catch ME_vrot
-                        disp(getReport(ME_vrot))
-                        ishotfile_ok = 0;
-                    end
-                    gdat_data.vrot.data = a.data;
-                    gdat_data.vrot.error_bar = aerr.data;
-                else
-                    gdat_data.vrot.data = [];
-                    gdat_data.vrot.error_bar = [];
-                end
-                a.name = 'vrot';
-                if any(strcmp(fieldnames(a),'units')); gdat_data.vrot.units=a.units; end
-                if any(strcmp(fieldnames(a),'name')); gdat_data.vrot.name=a.name; end
-                gdat_data.vrot.label = 'vrot_tor';
-                % Ti
-                %     [a,e]=rdaAUG_eff(shot,diag_name,'Ti',exp_name_eff);
-                %     [aerr,e]=rdaAUG_eff(shot,diag_name,'err_Ti',exp_name_eff);
-                if ishotfile_ok == 1
-                    try
-                        [a,e]=rdaAUG_eff(shot,diag_name,'Ti_c',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                        [aerr,e]=rdaAUG_eff(shot,diag_name,'err_Ti_c',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                    catch ME_ti
-                        disp(getReport(ME_ti))
-                        ishotfile_ok = 0;
-                    end
-                    gdat_data.ti.data = a.data;
-                    gdat_data.ti.error_bar = aerr.data;
-                else
-                    gdat_data.ti.data = [];
-                    gdat_data.ti.error_bar = [];
-                end
-                a.name = 'Ti_c';
-                if any(strcmp(fieldnames(a),'units')); gdat_data.ti.units=a.units; end
-                if any(strcmp(fieldnames(gdat_data.ti),'units')); gdat_data.units=gdat_data.ti.units; end
-                if any(strcmp(fieldnames(a),'name')); gdat_data.ti.name=a.name; end
-                gdat_data.ti.label = 'Ti_c';
-                % main node ti a this stage
-                gdat_data.data = gdat_data.ti.data;
-                gdat_data.label = [gdat_data.label '/Ti'];
-                gdat_data.error_bar = gdat_data.ti.error_bar;
-                gdat_data.data_fullpath=[exp_name_eff '/' diag_name '/' a.name ';vrot, Ti in data, {r;z} in .x'];
-                %
-                if strcmp(data_request_eff,'cxrs_rho')
-                    % defaults
-                    if iequil == 0
-                        gdat_data.equil.data = [];
-                        gdat_data.psi = [];
-                        gdat_data.rhopolnorm = [];
-                        gdat_data.rhotornorm = [];
-                        gdat_data.rhovolnorm = [];
-                        % defaults for fits, so user always gets std structure
-                        gdat_data.fit.rhotornorm = []; % same for both ti and vrot
-                        gdat_data.fit.rhopolnorm = [];
-                        gdat_data.fit.t = [];
-                        gdat_data.fit.ti.data = [];
-                        gdat_data.fit.ti.drhotornorm = [];
-                        gdat_data.fit.vrot.data = [];
-                        gdat_data.fit.vrot.drhotornorm = [];
-                        gdat_data.fit.raw.rhotornorm = [];
-                        gdat_data.fit.raw.ti.data = [];
-                        gdat_data.fit.raw.vrot.data = [];
-                        fit_tension_default = -1;
-                        if isfield(gdat_data.gdat_params,'fit_tension')
-                            fit_tension = gdat_data.gdat_params.fit_tension;
-                        else
-                            fit_tension = fit_tension_default;
-                        end
-                        if ~isstruct(fit_tension)
-                            fit_tension_eff.ti = fit_tension;
-                            fit_tension_eff.vrot = fit_tension;
-                            fit_tension = fit_tension_eff;
-                        else
-                            if ~isfield(fit_tension,'ti'); fit_tension.ti = fit_tension_default; end
-                            if ~isfield(fit_tension,'vrot '); fit_tension.vrot = fit_tension_default; end
-                        end
-                        gdat_data.gdat_params.fit_tension = fit_tension;
-                        if isfield(gdat_data.gdat_params,'fit_nb_rho_points')
-                            fit_nb_rho_points = gdat_data.gdat_params.fit_nb_rho_points;
-                        else
-                            fit_nb_rho_points = 201;
-                        end
-                        gdat_data.gdat_params.fit_nb_rho_points = fit_nb_rho_points;
-                    end
-                    if ishotfile_ok == 1 && iequil == 0
-                        params_equil = gdat_data.gdat_params;
-                        params_equil.data_request = 'equil';
-                        [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
-                        if error_status>0
-                            if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
-                            return
-                        end
-                        iequil = 1;
-                        gdat_data.gdat_params.equil = params_equil.equil;
-                        gdat_data.equil = equil;
-                        inb_chord_cxrs=size(gdat_data.data,1);
-                        inb_time_cxrs=size(gdat_data.data,2);
-                        psi_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
-                        rhopolnorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
-                        rhotornorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
-                        rhovolnorm_out = NaN*ones(inb_chord_cxrs,inb_time_cxrs);
-                        % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
-                        time_equil=[min(gdat_data.t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.t(end)+0.1)];
-                        iok=find(~isnan(gdat_data.r(:,1)));
-                        for itequil=1:length(time_equil)-1
-                            rr=equil.Rmesh(:,itequil);
-                            zz=equil.Zmesh(:,itequil);
-                            psirz_in = equil.psi2D(:,:,itequil);
-                            it_cxrs_inequil = find(gdat_data.t>time_equil(itequil) & gdat_data.t<=time_equil(itequil+1));
-                            if ~isempty(it_cxrs_inequil)
-                                if ~strcmp(upper(gdat_data.gdat_params.source),'CMZ')
-                                    rout=gdat_data.r(iok);
-                                    zout=gdat_data.z(iok);
-                                else
-                                    rout=gdat_data.r(iok,it_cxrs_inequil);
-                                    zout=gdat_data.z(iok,it_cxrs_inequil);
-                                end
-                                psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout,zout);
-                                if ~strcmp(upper(gdat_data.gdat_params.source),'CMZ')
-                                    psi_out(iok,it_cxrs_inequil) = repmat(psi_at_routzout,[1,length(it_cxrs_inequil)]);
-                                else
-                                    psi_out(iok,it_cxrs_inequil) = reshape(psi_at_routzout,length(iok),length(it_cxrs_inequil));
-                                end
-                                rhopolnorm_out(iok,it_cxrs_inequil) = sqrt((psi_out(iok,it_cxrs_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
-                                for it_cx=1:length(it_cxrs_inequil)
-                                    rhotornorm_out(iok,it_cxrs_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out(iok,it_cxrs_inequil(it_cx)),-3,[2 2],[0 1]);
-                                    rhovolnorm_out(iok,it_cxrs_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out(iok,it_cxrs_inequil(it_cx)),-3,[2 2],[0 1]);
-                                end
-                            end
-                        end
-                        gdat_data.psi = psi_out;
-                        gdat_data.rhopolnorm = rhopolnorm_out;
-                        gdat_data.rhotornorm = rhotornorm_out;
-                        gdat_data.rhovolnorm = rhovolnorm_out;
-                        aaa.shot = gdat_data.shot;
-                        aaa.data = gdat_data.data;
-                        aaa.x = gdat_data.rhopolnorm;
-                        aaa.t = gdat_data.t;
-                        aaa.gdat_params = gdat_data.gdat_params;
-                        aaa = get_grids_1d(aaa,2,1);
-                        gdat_data.grids_1d = aaa.grids_1d;
-                        %
-                        if gdat_data.gdat_params.fit==1
-                            % add fits
-                            gdat_data.fit.raw.rhotornorm = NaN*ones(size(gdat_data.ti.data));
-                            gdat_data.fit.raw.ti.data = NaN*ones(size(gdat_data.ti.data));
-                            gdat_data.fit.raw.vrot.data = NaN*ones(size(gdat_data.vrot.data));
-                            rhotornormfit = linspace(0,1,fit_nb_rho_points)';
-                            gdat_data.fit.rhotornorm = rhotornormfit;
-                            gdat_data.fit.t = gdat_data.t;
-                            for it=1:length(gdat_data.t)
-                                % make rhotor->rhopol transformation for each time since equilibrium might have changed
-                                gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
-                                    gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
-                                idata = find(gdat_data.ti.data(:,it)>0 & gdat_data.rhotornorm(:,it)<1.01);
-                                if length(idata)>0
-                                    gdat_data.fit.ti.raw.rhotornorm(idata,it) = gdat_data.rhotornorm(idata,it);
-                                    gdat_data.fit.ti.raw.data(idata,it) = gdat_data.ti.data(idata,it);
-                                    gdat_data.fit.ti.raw.error_bar(idata,it) = gdat_data.ti.error_bar(idata,it);
-                                    gdat_data.fit.vrot.raw.rhotornorm(idata,it) = gdat_data.rhotornorm(idata,it);
-                                    gdat_data.fit.vrot.raw.data(idata,it) = gdat_data.vrot.data(idata,it);
-                                    gdat_data.fit.vrot.raw.error_bar(idata,it) = gdat_data.vrot.error_bar(idata,it);
-                                    [rhoeff,irhoeff] = sort(gdat_data.rhotornorm(idata,it));
-                                    rhoeff = [0; rhoeff];
-                                    % they are some strange low error_bars, so remove these by max(Ti/error_bar)<=10; and changing it to large error bar
-                                    tieff = gdat_data.ti.data(idata(irhoeff),it);
-                                    ti_err_eff = gdat_data.ti.error_bar(idata(irhoeff),it);
-                                    ij=find(tieff./ti_err_eff>10.);
-                                    if ~isempty(ij); ti_err_eff(ij) = tieff(ij)./0.1; end
-                                    vroteff = gdat_data.vrot.data(idata(irhoeff),it);
-                                    vrot_err_eff = gdat_data.vrot.error_bar(idata(irhoeff),it);
-                                    ij=find(vroteff./vrot_err_eff>10.);
-                                    if ~isempty(ij); vrot_err_eff(ij) = vroteff(ij)./0.1; end
-                                    %
-                                    tieff =  [tieff(1); tieff];
-                                    ti_err_eff =  [1e4; ti_err_eff];
-                                    vroteff =  [vroteff(1); vroteff];
-                                    vrot_err_eff =  [1e5; vrot_err_eff];
-                                    [gdat_data.fit.ti.data(:,it), gdat_data.fit.ti.drhotornorm(:,it)] = interpos(rhoeff,tieff,rhotornormfit,fit_tension.ti,[1 0],[0 0],ti_err_eff);
-                                    [gdat_data.fit.vrot.data(:,it), gdat_data.fit.vrot.drhotornorm(:,it)] = interpos(rhoeff,vroteff,rhotornormfit,fit_tension.vrot,[1 0],[0 0],vrot_err_eff);
-                                end
-                            end
-                        end
-                    end
-                end
-                if scroll_through_list == 0 || scroll_through_list == 2
-                    if scroll_through_list == 2
-                        tmp.(diag_name) = gdat_data;
-                    end
-                    if length(gdat_data.gdat_params.source) > i_count
-                        i_count = i_count + 1;
-                        diag_name = gdat_data.gdat_params.source{i_count};
-                    else
-                        iload = 0;
-                    end
-                elseif scroll_through_list == 1
-                    if ishotfile_ok == 1
-                        iload = 0;
-                    else
-                        sources_remaining = setdiff(sources_available_for_scroll,sources_tried,'stable');
-                        if ~isempty(sources_remaining)
-                            i_count = i_count + 1;
-                            diag_name = sources_remaining{1};
-                            sources_tried{i_count} = diag_name;
-                        else
-                            iload = 0;
-                        end
-                    end
-                else
-                    disp('should not arrive here, check value of scroll_through_list')
-                    scroll_through_list
-                    iload = 0;
-                end
-            end
-            if scroll_through_list == 2
-                tmp_field=fieldnames(tmp);
-                for i=1:length(tmp_field)
-                    gdat_data.(tmp_field{i}) = tmp.(tmp_field{i});
-                end
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'ece', 'eced', 'ece_rho', 'eced_rho'}
-            nth_points = 13;
-            if isfield(gdat_data.gdat_params,'nth_points') && ~isempty(gdat_data.gdat_params.nth_points)
-                nth_points = gdat_data.gdat_params.nth_points;
-            else
-                gdat_data.gdat_params.nth_points = nth_points;
-            end
-            channels = -1;
-            if isfield(gdat_data.gdat_params,'channels') && ~isempty(gdat_data.gdat_params.channels)
-                channels = gdat_data.gdat_params.channels;
-            end
-            if nth_points>=10
-                match_rz_to_time = 1;
-            else
-                match_rz_to_time = 0;
-            end
-            if isfield(gdat_data.gdat_params,'match_rz_to_time') && ~isempty(gdat_data.gdat_params.match_rz_to_time)
-                match_rz_to_time = gdat_data.gdat_params.match_rz_to_time;
-            else
-                gdat_data.gdat_params.match_rz_to_time = match_rz_to_time;
-            end
-            time_interval = [];
-            if isfield(gdat_data.gdat_params,'time_interval') && ~isempty(gdat_data.gdat_params.time_interval)
-                time_interval = gdat_data.gdat_params.time_interval;
-            else
-                gdat_data.gdat_params.time_interval = time_interval;
-            end
-            %
-            if isfield(gdat_data.gdat_params,'diag_name') && ~isempty(gdat_data.gdat_params.diag_name)
-                diag_name = gdat_data.gdat_params.diag_name;
-                if strcmp(upper(diag_name),'RMD'); gdat_data.gdat_params.exp_name = 'ECED'; end
-            else
-                diag_name = 'CEC';
-                gdat_data.gdat_params.diag_name = diag_name;
-            end
-            exp_name_eff = gdat_data.gdat_params.exp_name;
-            if strcmp(data_request_eff,'eced')
-                exp_name_eff = 'ECED';
-                gdat_data.gdat_params.exp_name = exp_name_eff;
-            end
-            [a,e]=rdaAUG_eff(shot,diag_name,'Trad-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
-            % [a,e]=rdaAUG_eff(shot,diag_name,'Trad-A',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            inb_chord = size(a.data,1);
-            if channels(1)<=0
-                channels = [1:inb_chord];
-            end
-            gdat_data.dim{1} = channels;
-            gdat_data.gdat_params.channels = channels;
-            if nth_points>1
-                gdat_data.data = a.data(channels,1:nth_points:end);
-                gdat_data.dim{2} = a.t(1:nth_points:end);
-            else
-                gdat_data.data = a.data(channels,:);
-                gdat_data.dim{2} = a.t;
-            end
-            gdat_data.x = gdat_data.dim{1};
-            gdat_data.t = gdat_data.dim{2};
-            gdat_data.dimunits=[{'channels'} ; {'time [s]'}];
-            if any(strcmp(fieldnames(a),'units')); gdat_data.units=a.units; end
-            try
-                [aR,e]=rdaAUG_eff(shot,diag_name,'R-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
-            catch
-            end
-            try
-                [aZ,e]=rdaAUG_eff(shot,diag_name,'z-A',exp_name_eff,time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
-            catch
-                disp(['problem with getting z-A in ' diag_name])
-            end
-            if match_rz_to_time
-                % interpolate R structure on ece data time array, to ease plot vs R
-                for i=1:length(channels)
-                    radius.data(i,:) = interp1(aR.t,aR.data(channels(i),:),gdat_data.t);
-                    zheight.data(i,:) = interp1(aZ.t,aZ.data(channels(i),:),gdat_data.t);
-                end
-                radiuszheight.t=gdat_data.t;
-            else
-                radius.data = aR.data(channels,:);
-                radiuszheight.t=aR.t;
-                zheight.data = aZ.data(channels,:);
-            end
-            ij=find(gdat_data.data<=0);
-            gdat_data.data(ij)=NaN;
-            gdat_data.rz.r=radius.data;
-            gdat_data.rz.z=zheight.data;
-            gdat_data.rz.t = radiuszheight.t;
-            gdat_data.data_fullpath = [exp_name_eff '/' diag_name '/Trad-A with R, Z in .r,.z'];
-            
-            if strcmp(data_request_eff,'ece_rho') || strcmp(data_request_eff,'eced_rho')
-                params_equil = gdat_data.gdat_params;
-                params_equil.data_request = 'equil';
-                [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
-                if error_status>0
-                    if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
-                    return
-                end
-                gdat_data.gdat_params.equil = params_equil.equil;
-                gdat_data.equil = equil;
-                gdat_data.data_fullpath = [exp_name_eff '/' diag_name '/Trad-A with .r,.z projected on equil ' gdat_data.gdat_params.equil ' in .rhos'];
-                inb_chord_ece=size(gdat_data.rz.r,1);
-                inb_time_ece=size(gdat_data.rz.r,2);
-                psi_out = NaN*ones(inb_chord_ece,inb_time_ece);
-                rhopolnorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
-                rhotornorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
-                rhovolnorm_out = NaN*ones(inb_chord_ece,inb_time_ece);
-                % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
-                time_equil=[min(gdat_data.rz.t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.rz.t(end)+0.1)];
-                for itequil=1:length(time_equil)-1
-                    rr=equil.Rmesh(:,itequil);
-                    zz=equil.Zmesh(:,itequil);
-                    psirz_in = equil.psi2D(:,:,itequil);
-                    it_ece_inequil = find(gdat_data.rz.t>time_equil(itequil) & gdat_data.rz.t<=time_equil(itequil+1));
-                    if ~isempty(it_ece_inequil)
-                        r_it_ece_inequil = gdat_data.rz.r(:,it_ece_inequil);
-                        iok = find(~isnan(r_it_ece_inequil) & r_it_ece_inequil>0);
-                        if ~isempty(iok)
-                            rout=r_it_ece_inequil(iok);
-                            z_it_ece_inequil = gdat_data.rz.z(:,it_ece_inequil);
-                            zout=z_it_ece_inequil(iok);
-                            psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout,zout);
-                            [ieff,jeff]=ind2sub(size(gdat_data.rz.r(:,it_ece_inequil)),iok);
-                            for ij=1:length(iok)
-                                psi_out(ieff(ij),it_ece_inequil(jeff(ij))) = psi_at_routzout(ij);
-                            end
-                            rhopolnorm_out(:,it_ece_inequil) = sqrt(abs((psi_out(:,it_ece_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil))));
-                            for it_cx=1:length(it_ece_inequil)
-                                rhotornorm_out(:,it_ece_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out(:,it_ece_inequil(it_cx)),-3,[2 2],[0 1]);
-                                rhovolnorm_out(:,it_ece_inequil(it_cx)) = interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out(:,it_ece_inequil(it_cx)),-3,[2 2],[0 1]);
-                            end
-                        end
-                    end
-                end
-                gdat_data.rhos.psi = psi_out;
-                gdat_data.rhos.rhopolnorm = rhopolnorm_out;
-                gdat_data.rhos.rhotornorm = rhotornorm_out;
-                gdat_data.rhos.rhovolnorm = rhovolnorm_out;
-                gdat_data.rhos.t = gdat_data.rz.t;
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'eqdsk'}
-            %
-            time_eqdsks=1.; % default time
-            if isfield(gdat_data.gdat_params,'time') && ~isempty(gdat_data.gdat_params.time)
-                time_eqdsks = gdat_data.gdat_params.time;
-            else
-                gdat_data.gdat_params.time = time_eqdsks;
-                disp(['"time" is expected as an option, choose default time = ' num2str(time_eqdsks)]);
-            end
-            gdat_data.gdat_params.time = time_eqdsks;
-            gdat_data.t = time_eqdsks;
-            zshift = 0.;
-            if isfield(gdat_data.gdat_params,'zshift') && ~isempty(gdat_data.gdat_params.zshift)
-                zshift = gdat_data.gdat_params.zshift;
-            else
-                gdat_data.gdat_params.zshift = zshift;
-            end
-            gdat_data.gdat_params.zshift = zshift;
-            dowrite = 1;
-            if isfield(gdat_data.gdat_params,'write') && ~isempty(gdat_data.gdat_params.write)
-                dowrite = gdat_data.gdat_params.write;
-            else
-                gdat_data.gdat_params.write = dowrite;
-            end
-            gdat_data.gdat_params.write = dowrite;
-            params_equil = gdat_data.gdat_params;
-            params_equil.data_request = 'equil';
-            [equil,params_equil,error_status] = gdat_aug(shot,params_equil);
-            if error_status>0
-                if gdat_params.nverbose>=3; disp(['problems with ' params_equil.data_request]); end
-                return
-            end
-            gdat_data.gdat_params = params_equil;
-            gdat_data.equil = equil;
-            if gdat_data.gdat_params.doplot==0
-                fignb_handle = -1;
-            else
-                figure(9999);
-                fignb_handle = gcf;
-            end
-            for itime=1:length(time_eqdsks)
-                time_eff = time_eqdsks(itime);
-                % use read_results updated to effectively obtain an eqdsk with sign correct with COCOS=2
-                [eqdskAUG, equil_all_t, equil_t_index]=geteqdskAUG(equil,time_eff,gdat_data.gdat_params.zshift,'source',gdat_data.gdat_params.equil,'extra_arg_sf2sig',gdat_data.gdat_params.extra_arg_sf2sig,'fignb',fignb_handle);
-                eqdskAUG.fnamefull = fullfile(['/tmp/' getenv('USER')],['EQDSK_' num2str(shot) 't' num2str(time_eff,'%.4f')]);
-                cocos_in = eqdskAUG.cocos;
-                if cocos_in ~= equil.cocos;
-                    equil.cocos = eqdskAUG.cocos;
-                end
-                if ~isfield(gdat_data.gdat_params,'cocos') || isempty(gdat_data.gdat_params.cocos)
-                    gdat_data.gdat_params.cocos = cocos_in;
-                end
-                cocos_out = gdat_data.gdat_params.cocos;
-                if cocos_in ~= cocos_out
-                    [eqdsk_cocosout, eqdsk_cocosout_IpB0pos,cocos_inout]=eqdsk_cocos_transform(eqdskAUG,[cocos_in cocos_out]);
-                else
-                    eqdsk_cocosout = eqdskAUG;
-                end
-                % for several times, use array of structure for eqdsks,
-                % cannot use it for psi(R,Z) in .data and .x since R, Z might be different at different times,
-                % so project psi(R,Z) on Rmesh, Zmesh of 1st time
-                if length(time_eqdsks) > 1
-                    gdat_data.eqdsk{itime} = eqdsk_cocosout;
-                    if gdat_data.gdat_params.write; gdat_data.eqdsk{itime} = write_eqdsk(eqdskAUG.fnamefull,eqdsk_cocosout); end
-                    if itime==1
-                        gdat_data.data(:,:,itime) = gdat_data.eqdsk{itime}.psi;
-                        gdat_data.dim{1} = gdat_data.eqdsk{itime}.rmesh;
-                        gdat_data.dim{2} = gdat_data.eqdsk{itime}.zmesh;
-                    else
-                        xx=repmat(reshape(gdat_data.dim{1},length(gdat_data.dim{1}),1),1,size(gdat_data.eqdsk{itime}.psi,2));
-                        yy=repmat(reshape(gdat_data.dim{2},1,length(gdat_data.dim{2})),size(gdat_data.eqdsk{itime}.psi,1),1);
-                        aa = interpos2Dcartesian(gdat_data.eqdsk{itime}.rmesh,gdat_data.eqdsk{itime}.zmesh ...
-                            ,gdat_data.eqdsk{itime}.psi,xx,yy,-1,-1);
-                        gdat_data.data(:,:,itime) = aa;
-                    end
-                else
-                    gdat_data.eqdsk = eqdsk_cocosout;
-                    if gdat_data.gdat_params.write; gdat_data.eqdsk = write_eqdsk(eqdskAUG.fnamefull,eqdsk_cocosout); end
-                    gdat_data.data = gdat_data.eqdsk.psi;
-                    gdat_data.dim{1} = gdat_data.eqdsk.rmesh;
-                    gdat_data.dim{2} = gdat_data.eqdsk.zmesh;
-                end
-            end
-            gdat_data.dim{3} = gdat_data.t;
-            gdat_data.x = gdat_data.dim(1:2);
-            gdat_data.data_fullpath=['psi(R,Z) and eqdsk from geteqdskAUG with ' gdat_data.gdat_params.equil ' ;zshift=' num2str(zshift)];
-            gdat_data.units = 'T m^2';
-            gdat_data.dimunits = {'m','m','s'};
-            gdat_data.request_description = ['data=psi, x=(R,Z), eqdsk contains eqdsk structure with which ' ...
-                'plot_eqdsk, write_eqdsk, read_eqdsk can be used'];
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'equil'}
-            % get equil params and time array in gdat_data.t
-            [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL,M_Rmesh,N_Zmesh] = get_EQ_params(gdat_data);
-            if isempty(Lpf1_t)
-                disp('Lpf1_t is empty, probably no data, return')
-                return
-            end
-            % since Lpf depends on time, need to load all first and then loop over time for easier mapping
-            [qpsi,e]=rdaAUG_eff(shot,DIAG,'Qpsi',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            ndimrho = size(qpsi.data,2);
-            if ndimrho==NTIME_Lpf && ndimrho ~= NTIME
-                % data seems to be transposed
-                ndimrho = size(qpsi.data,1);
-                itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
-            else
-                itotransposeback = 0;
-            end
-            qpsi=adapt_rda(qpsi,NTIME,ndimrho,itotransposeback);
-            ijnan=find(isnan(qpsi.value));
-            qpsi.value(ijnan)=0;
-            [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
-            [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
-            [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
-            [Area,e]=rdaAUG_eff(shot,DIAG,'Area',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Area=adapt_rda(Area,NTIME,2*ndimrho,itotransposeback);
-            [Ri,e]=rdaAUG_eff(shot,DIAG,'Ri',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Ri=adapt_rda(Ri,NTIME,M_Rmesh,itotransposeback);
-            [Zj,e]=rdaAUG_eff(shot,DIAG,'Zj',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Zj=adapt_rda(Zj,NTIME,N_Zmesh,itotransposeback);
-            if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
-                [PFM_tree,e]=rdaAUG_eff(shot,DIAG,'PFM',exp_name_eff,[],['''-raw'',' gdat_data.gdat_params.extra_arg_sf2sig]); % -raw necessary for IDE
-            else
-                [PFM_tree,e]=rdaAUG_eff(shot,DIAG,'PFM',exp_name_eff,[],['''-raw''']); % -raw necessary for IDE
-            end
-            PFM_tree=adaptPFM_rda(PFM_tree,M_Rmesh,N_Zmesh,NTIME);
-            [Pres,e]=rdaAUG_eff(shot,DIAG,'Pres',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Pres=adapt_rda(Pres,NTIME,2*ndimrho,itotransposeback);
-            [Jpol,e]=rdaAUG_eff(shot,DIAG,'Jpol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Jpol=adapt_rda(Jpol,NTIME,2*ndimrho,itotransposeback);
-            [FFP,e]=rdaAUG_eff(shot,DIAG,'FFP',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            if ~isempty(FFP.value)
-                FFP=adapt_rda(FFP,NTIME,ndimrho,itotransposeback);
-            else
-                FFP.value=NaN*ones(NTIME,max(Lpf1_t));
-            end
-            if strcmp(DIAG,'EQI') || strcmp(DIAG,'EQH') || strcmp(DIAG,'IDE')
-                [Rinv,e]=rdaAUG_eff(shot,DIAG,'Rinv',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                Rinv=adapt_rda(Rinv,NTIME,ndimrho,itotransposeback);
-                [R2inv,e]=rdaAUG_eff(shot,DIAG,'R2inv',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                R2inv=adapt_rda(R2inv,NTIME,ndimrho,itotransposeback);
-                [Bave,e]=rdaAUG_eff(shot,DIAG,'Bave',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                Bave=adapt_rda(Bave,NTIME,ndimrho,itotransposeback);
-                [B2ave,e]=rdaAUG_eff(shot,DIAG,'B2ave',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                B2ave=adapt_rda(B2ave,NTIME,ndimrho,itotransposeback);
-                if strcmp(DIAG,'IDE')
-                    FTRA.value=[];
-                else
-                    [FTRA,e]=rdaAUG_eff(shot,DIAG,'FTRA',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                    FTRA=adapt_rda(FTRA,NTIME,ndimrho,itotransposeback);
-                end
-            else
-                Rinv.value=[]; R2inv.value=[]; Bave.value=[]; B2ave.value=[]; FTRA.value=[];
-            end
-            [LPFx,e]=rdaAUG_eff(shot,DIAG,'LPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            LPFx.value=LPFx.value(1:NTIME); LPFx.data=LPFx.value(1:NTIME); LPFx.t=LPFx.t(1:NTIME);
-            [PFxx,e]=rdaAUG_eff(shot,DIAG,'PFxx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            PFxx=adapt_rda(PFxx,NTIME,max(LPFx.value)+1,itotransposeback);
-            [RPFx,e]=rdaAUG_eff(shot,DIAG,'RPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            RPFx=adapt_rda(RPFx,NTIME,max(LPFx.value)+1,itotransposeback);
-            [zPFx,e]=rdaAUG_eff(shot,DIAG,'zPFx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            zPFx=adapt_rda(zPFx,NTIME,max(LPFx.value)+1,itotransposeback);
-            % seems "LCFS" q-value is far too large, limit to some max (when diverted)
-            max_qValue = 30.; % Note could just put a NaN on LCFS value since ill-defined when diverted
-            for it=1:NTIME
-                Lpf1 = Lpf1_t(it);
-                % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
-                % change it to (radial,time) and use only Lpf+1 points up to LCFS
-                ijok=find(abs(qpsi.value)>0); % note: eqr fills in only odd points radially
-                % set NaNs to zeroes
-                if qpsi.value(ijok(1))<0
-                    gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
-                else
-                    gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
-                end
-                % get x values
-                gdat_data.psi(:,it)=psi_tree.value(it,Lpf1:-1:1)';
-                gdat_data.psi_axis(it)= gdat_data.psi(1,it);
-                gdat_data.psi_lcfs(it)= gdat_data.psi(end,it);
-                gdat_data.rhopolnorm(:,it) = sqrt(abs((gdat_data.psi(:,it)-gdat_data.psi_axis(it)) ./(gdat_data.psi_lcfs(it)-gdat_data.psi_axis(it))));
-                if strcmp(DIAG,'EQR');
-                    % q value has only a few values and from center to edge, assume they are from central rhopol values on
-                    % But they are every other point starting from 3rd
-                    ijk=find(gdat_data.qvalue(:,it)~=0);
-                    if length(ijk)>2
-                        % now shots have non-zero axis values in eqr
-                        rhoeff=gdat_data.rhopolnorm(ijk,it);
-                        qeff=gdat_data.qvalue(ijk,it); % radial order was already inverted above
-                        if ijk(1)>1
-                            rhoeff = [0.; rhoeff];
-                            qeff = [qeff(1) ;qeff];
-                        end
-                        ij_nonan=find(~isnan(gdat_data.rhopolnorm(:,it)));
-                        qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
-                        qfit(ij_nonan)=interpos(rhoeff,qeff,gdat_data.rhopolnorm(ij_nonan,it),-0.01,[1 0],[0 0],[300; ones(size(qeff(1:end-1)))]);
-                    else
-                        qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
-                    end
-                    gdat_data.qvalue(:,it) = qfit;
-                end
-                % get rhotor values
-                gdat_data.phi(:,it) = phi_tree.value(it,Lpf1:-1:1)';
-                gdat_data.rhotornorm(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.phi(end,it)));
-                % get rhovol values
-                gdat_data.vol(:,it)=Vol.value(it,2*Lpf1-1:-2:1)';
-                gdat_data.dvoldpsi(:,it)=Vol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
-                gdat_data.rhovolnorm(:,it) = sqrt(abs(gdat_data.vol(:,it) ./ gdat_data.vol(end,it)));
-                gdat_data.area(:,it)=Area.value(it,2*Lpf1-1:-2:1)';
-                gdat_data.dareadpsi(:,it)=Area.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
-                gdat_data.Rmesh(:,it) = Ri.value(it,1:M_Rmesh);
-                gdat_data.Zmesh(:,it) = Zj.value(it,1:N_Zmesh);
-                gdat_data.psi2D(1:M_Rmesh,1:N_Zmesh,it) = PFM_tree.value(1:M_Rmesh,1:N_Zmesh,it);
-                gdat_data.pressure(:,it)=Pres.value(it,2*Lpf1-1:-2:1)';
-                gdat_data.dpressuredpsi(:,it)=Pres.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
-                if ~isempty(Jpol.value)
-                    gdat_data.jpol(:,it)=Jpol.value(it,2*Lpf1-1:-2:1)';
-                    gdat_data.djpolpsi(:,it)=Jpol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
-                else
-                    gdat_data.jpol = [];
-                    gdat_data.djpolpsi = [];
-                end
-                if ~strcmp(DIAG,'TRE')
-                    gdat_data.ffprime(:,it) = FFP.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.ffprime(:,it) = FFP.value(it,Lpf1:-1:1)'/2/pi;
-                end
-                gdat_data.Xpoints.psi(1:LPFx.value(it)+1,it) = PFxx.value(it,1:LPFx.value(it)+1);
-                gdat_data.Xpoints.Rvalue(1:LPFx.value(it)+1,it) = RPFx.value(it,1:LPFx.value(it)+1);
-                gdat_data.Xpoints.Zvalue(1:LPFx.value(it)+1,it) = zPFx.value(it,1:LPFx.value(it)+1);
-                if ~isempty(Rinv.value)
-                    gdat_data.rinv(:,it) = Rinv.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.rinv = [];
-                end
-                if ~isempty(R2inv.value)
-                    gdat_data.r2inv(:,it) = R2inv.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.r2inv = [];
-                end
-                if ~isempty(Bave.value)
-                    gdat_data.bave(:,it) = Bave.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.bave = [];
-                end
-                if ~isempty(B2ave.value)
-                    gdat_data.b2ave(:,it) = B2ave.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.b2ave = [];
-                end
-                if ~isempty(FTRA.value)
-                    gdat_data.ftra(:,it) = FTRA.value(it,Lpf1:-1:1)';
-                else
-                    gdat_data.ftra = [];
-                end
-                %
-            end
-            gdat_data.x = gdat_data.rhopolnorm;
-            %
-            try
-                [equil_Rcoil,e]=rdaAUG_eff(shot,DIAG,'Rcl',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                gdat_data.Rcoils = equil_Rcoil.value;
-                [equil_Zcoil,e]=rdaAUG_eff(shot,DIAG,'Zcl',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                gdat_data.Zcoils = equil_Zcoil.value;
-            catch
-                gdat_data.Rcoils = [];
-                gdat_data.Zcoils = [];
-            end
-            %
-            if strcmp(DIAG,'IDE')
-                [IpiPSI,e]=rdaAUG_eff(shot,'IDG','Itor',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                if length(IpiPSI.value)~=NTIME
-                    disp('Problem with nb time points of IDG/Itor with respect to IDE NTIME, check with O. Sauter')
-                    return
-                end
-            else
-                [IpiPSI,e]=rdaAUG_eff(shot,DIAG,'IpiPSI',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            end
-            gdat_data.Ip = IpiPSI.value(1:NTIME);
-            %
-            gdat_data.data = gdat_data.qvalue; % put q in data
-            gdat_data.units=[]; % not applicable
-            gdat_data.data_fullpath = [DIAG ' from exp_name: ' gdat_data.gdat_params.exp_name '; q(rhopolnorm,t) in .data(.x,.t)'];
-            gdat_data.cocos = 17; % should check FPP (IDE seems 13)
-            gdat_data.dim{1} = gdat_data.x;
-            gdat_data.dim{2} = gdat_data.t;
-            gdat_data.dimunits{1} = 'rhopolnorm';
-            gdat_data.dimunits{2} = 'time [s]';
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'gas', 'gas_valve', 'gas_valves'}
-            %
-            uvs_signals_source = [{'D_tot','Sum of calibrated D2 gas-fluxes (= D/s)'}; ...
-                {'N_tot','Sum of calibrated N2 gas-fluxes (= N*7/s)'}; ...
-                {'H_tot','Sum of calibrated H gas-fluxes (= H/s)'}; ...
-                {'He_tot','Sum of calibrated He gas-fluxes (= He*2/s)'}; ...
-                {'Ne_tot','Sum of calibrated Ne gas-fluxes (= Ne*10/s)'}; ...
-                {'Ar_tot','Sum of calibrated Ar gas-fluxes (= Ar*18/s)'}];
-            for i=1:size(uvs_signals_source,1)
-                uvs_signals.(uvs_signals_source{i,1}) = gdat_aug(shot,{'UVS',uvs_signals_source{i,1}});
-                if isempty(gdat_data.t) && numel(uvs_signals.(uvs_signals_source{i,1}).t)>10
-                    gdat_data.t = uvs_signals.(uvs_signals_source{i,1}).t; % all have same time base, could use time signal
-                end
-                if ~isempty(uvs_signals.(uvs_signals_source{i,1}).data) && numel(uvs_signals.(uvs_signals_source{i,1}).data) == numel(gdat_data.t);
-                    gdat_data.data(i,:) = uvs_signals.(uvs_signals_source{i,1}).data; % all have same time base
-                else
-                    gdat_data.data(i,:) = NaN;
-                end
-                gdat_data.units{i} = uvs_signals_source{i,2};
-            end
-            gdat_data.data_fullpath = 'from UVS and uvs_signals_source';
-            gdat_data.uvs_signals_source = uvs_signals_source;
-            gdat_data.label = uvs_signals_source(:,1)';
-            gdat_data.dim{2} = gdat_data.t;
-            gdat_data.dimunits{2} = 's';
-            gdat_data.dim{1} = [1:size(gdat_data.data,1)];
-            gdat_data.dimunits{1} = 'uvs_signals_source index';
-            gdat_data.x = gdat_data.dim{1};
-            gdat_data.mapping_for.aug.timedim = 1;
-            
-            % note also available in UVS, not commented the same way on ISIS
-            uvd_signals_source=[{'CFCu01T','PV01','empty comment'}; ...
-                {'CFCo02A','PV02','valve flux, normally for prefill'}; ...
-                {'CFFo02A','PV03','valve flux,'}; ...
-                {'CFA13B','PV04','valve flux, in-vessel pipe for gas imaging'}; ...
-                {'CFA03B','PV05','valve flux,'}; ...
-                {'CFFo07A','PV06','valve flux,'}; ...
-                {'CFDu05X','PV07','valve flux, normally with N2'}; ...
-                {'CFDu05B','PV08','valve flux, normally with D2'}; ...
-                {'CFCo10A','PV09','valve flux, in-vessel pipe into ICRH limiter'}; ...
-                {'CFDu01B','PV10','valve flux, normally with D2'}; ...
-                {'CFDu09B','PV11','valve flux, normally with D2'}; ...
-                {'CFFo10A','PV12','valve flux,'}; ...
-                {'CFFo14A','PV13','valve flux,'}; ...
-                {'CFA03C','PV14','valve flux, short feeding pipe for rare gases'}; ...
-                {'CFA13A','PV15','valve flux,'}; ...
-                {'CFA03A','PV16','valve flux,'}; ...
-                {'CFDu09X','PV17','valve flux, normally with N2'}; ...
-                {'CFDu13X','PV18','valve flux, normally with N2'}; ...
-                {'CFDu13B','PV19','valve flux, normally with D2'}; ...
-                {'CFDu01X','PV20','valve flux, normally with N2'}];
-            gdat_data.pvxx.t = [];
-            gdat_data.pvxx.t = [];
-            
-            for i=1:size(uvd_signals_source,1)
-                uvd_signals.(uvd_signals_source{i,2}) = gdat_aug(shot,{'UVD',uvd_signals_source{i,1}});
-                if isempty(gdat_data.pvxx.t) && numel(uvd_signals.(uvd_signals_source{i,2}).t)>10
-                    gdat_data.pvxx.t = uvd_signals.(uvd_signals_source{i,2}).t; % all have same time base
-                end
-                if ~isempty(uvd_signals.(uvd_signals_source{i,2}).data) && numel(uvd_signals.(uvd_signals_source{i,2}).data) == numel(gdat_data.pvxx.t);
-                    gdat_data.pvxx.data(i,:) = uvd_signals.(uvd_signals_source{i,2}).data; % all have same time base
-                else
-                    gdat_data.pvxx.data(i,:) = NaN;
-                end
-                gdat_data.pvxx.units{i} = [uvd_signals_source{i,2} ': ' uvd_signals_source{i,3}];
-            end
-            gdat_data.pvxx.data_fullpath = 'from UVD and uvd_signals_source';
-            gdat_data.pvxx.uvd_signals_source = uvd_signals_source;
-            gdat_data.pvxx.label = uvd_signals_source(:,2)';
-            gdat_data.pvxx.dim{2} = gdat_data.t;
-            gdat_data.pvxx.dimunits{2} = 's';
-            gdat_data.pvxx.dim{1} = [1:size(gdat_data.pvxx.data,1)];
-            gdat_data.pvxx.dimunits{1} = 'PVxx index';
-            gdat_data.pvxx.x = gdat_data.dim{1};
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'ids'}
-            params_eff = gdat_data.gdat_params;
-            if isfield(params_eff,'source') && ~isempty(params_eff.source)
-                ids_top_name = params_eff.source;
-            else
-                ids_top_name = [];
-                disp('need an ids name in ''source'' parameter');
-                disp('check substructure gdat_params.source_available for an ids list');
-            end
-            ids_gen_ok = exist('ids_gen');
-            equil_empty = struct([]);
-            if ids_gen_ok ~= 2
-                ids_struct_saved = 'ids_structures_20190312.mat';
-                if ~exist(ids_struct_saved,'file')
-                    warning(['function ids_gen not available neither file ids_structures_20190312.mat thus cannot create empty ids: ids_gen(''' ids_top_name ''')']);
-                    return
-                else
-                    eval(['load ' ids_struct_saved ])
-                    if isfield(ids_structures,ids_top_name)
-                        equil_empty = ids_structures.(ids_top_name);
-                    else
-                        if ~isempty(ids_top_name);
-                            warning(['ids ''' ids_top_name ''' does not exist in ids_structures saved in ' ids_struct_saved]);
-                        end
-                        gdat_data.gdat_params.source_available = ids_list;
-                        return
-                    end
-                end
-            else
-                equil_empty = ids_gen(ids_top_name);
-            end
-            try
-                if ~isempty(shot)
-                    eval(['[ids_top,ids_top_description]=aug_get_ids_' ids_top_name '(shot,equil_empty);'])
-                    gdat_data.(ids_top_name) = ids_top;
-                    gdat_data.([ids_top_name '_description']) = ids_top_description;
-                else
-                    gdat_data.(ids_top_name) = equil_empty;
-                    gdat_data.([ids_top_name '_description']) = ['shot empty so return default empty structure for ' ids_top_name];
-                end
-            catch ME_aug_get_ids
-                getReport(ME_aug_get_ids)
-                disp(['there is a problem with: aug_get_ids_' ids_top_name ...
-                    ' , may be check if it exists in your path or test it by itself'])
-                gdat_data.(ids_top_name) = equil_empty;
-                gdat_data.([ids_top_name '_description']) = getReport(ME_aug_get_ids);
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'ne','te'}
-            exp_name_eff = gdat_data.gdat_params.exp_name;
-            % ne or Te from Thomson data on raw z mesh vs (z,t)
-            nodenameeff = [upper(data_request_eff(1)) 'e_c'];
-            node_child_nameeff = [upper(data_request_eff(1)) 'e_core'];
-            [a,error_status]=rdaAUG_eff(shot,'VTA',nodenameeff,exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            if isempty(a.data) || isempty(a.t) || error_status>0
-                if gdat_params.nverbose>=3;
-                    a
-                    disp(['with data_request= ' data_request_eff])
-                end
-                return
-            end
-            gdat_data.(lower(node_child_nameeff)).data = a.data;
-            gdat_data.(lower(node_child_nameeff)).t = a.t;
-            gdat_data.t = a.t;
-            if any(strcmp(fieldnames(a),'units'))
-                gdat_data.units=a.units;
-            end
-            [alow,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'elow_c'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            [aup,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'eupp_c'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            gdat_data.(lower(node_child_nameeff)).error_bar = max(aup.value-gdat_data.(lower(node_child_nameeff)).data,gdat_data.(lower(node_child_nameeff)).data-alow.value);
-            [a,error_status]=rdaAUG_eff(shot,'VTA','R_core',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            gdat_data.(lower(node_child_nameeff)).r = repmat(a.data,size(gdat_data.(lower(node_child_nameeff)).data,1),1);
-            [a,error_status]=rdaAUG_eff(shot,'VTA','Z_core',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            gdat_data.(lower(node_child_nameeff)).z = repmat(a.data',1,size(gdat_data.(lower(node_child_nameeff)).data,2));
-            gdat_data.dimunits=[{'Z [m]'} ; {'time [s]'}];
-            gdat_data.data_fullpath=[data_request_eff ' from VTA/' upper(data_request_eff(1)) 'e_c and ' upper(data_request_eff(1)) 'e_e'];
-            nb_core = size(gdat_data.(lower(node_child_nameeff)).z,1);
-            gdat_data.data = [];
-            gdat_data.data(1:nb_core,:) = gdat_data.(lower(node_child_nameeff)).data(1:nb_core,:);
-            gdat_data.dim=[{gdat_data.(lower(node_child_nameeff)).z};{gdat_data.(lower(node_child_nameeff)).t}];
-            gdat_data.error_bar(1:nb_core,:) = gdat_data.(lower(node_child_nameeff)).error_bar(1:nb_core,:);
-            
-            % add edge part
-            nodenameeff_e = [upper(data_request_eff(1)) 'e_e'];
-            node_child_nameeff_e = [upper(data_request_eff(1)) 'e_edge'];
-            [a,error_status]=rdaAUG_eff(shot,'VTA',nodenameeff_e,exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            gdat_data.(lower(node_child_nameeff_e)).data = a.data;
-            ij_edge_notok = find(a.data>5e21);
-            gdat_data.(lower(node_child_nameeff_e)).data(ij_edge_notok) = NaN;
-            gdat_data.(lower(node_child_nameeff_e)).t = a.t;
-            if ~isempty(a.data)
-                [a,error_status]=rdaAUG_eff(shot,'VTA','R_edge',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                gdat_data.(lower(node_child_nameeff_e)).r = repmat(a.data,size(gdat_data.(lower(node_child_nameeff_e)).data,1),1);
-                [a,error_status]=rdaAUG_eff(shot,'VTA','Z_edge',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                gdat_data.(lower(node_child_nameeff_e)).z = repmat(a.data',1,size(gdat_data.(lower(node_child_nameeff_e)).data,2));
-                nb_edge = size(gdat_data.(lower(node_child_nameeff_e)).z,1);
-                iaaa=iround_os(gdat_data.(lower(node_child_nameeff_e)).t,gdat_data.(lower(node_child_nameeff)).t);
-                gdat_data.data(nb_core+1:nb_core+nb_edge,:) = gdat_data.(lower(node_child_nameeff_e)).data(1:nb_edge,iaaa);
-                gdat_data.dim{1}(nb_core+1:nb_core+nb_edge,:)=gdat_data.(lower(node_child_nameeff_e)).z(1:nb_edge,iaaa);
-                [alow,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'elow_e'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                [aup,e]=rdaAUG_eff(shot,'VTA',[upper(data_request_eff(1)) 'eupp_e'],exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                gdat_data.(lower(node_child_nameeff_e)).error_bar = max(aup.value-gdat_data.(lower(node_child_nameeff_e)).data, ...
-                    gdat_data.(lower(node_child_nameeff_e)).data-alow.value);
-                gdat_data.error_bar(nb_core+1:nb_core+nb_edge,:) = gdat_data.(lower(node_child_nameeff_e)).error_bar(1:nb_edge,iaaa);
-            else
-                gdat_data.(lower(node_child_nameeff_e)).data = [];
-                gdat_data.(lower(node_child_nameeff_e)).t = [];
-                gdat_data.(lower(node_child_nameeff_e)).error_bar = [];
-                gdat_data.(lower(node_child_nameeff_e)).r = [];
-                gdat_data.(lower(node_child_nameeff_e)).z = [];
-            end
-            gdat_data.x=gdat_data.dim{1};
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'ne_rho', 'te_rho', 'nete_rho'}
-            sources_available = {'VTA','IDA','TRA'}; % TRA to be included
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = 'VTA'; % default source
-            end
-            sources_exp_name_available = 'AUGD';
-            if isfield(gdat_data.gdat_params,'source_exp_name') && ~isempty(gdat_data.gdat_params.source_exp_name)
-                sources_exp_name_available = gdat_data.gdat_params.source_exp_name;
-            end
-            gdat_data.gdat_params.source_exp_name = sources_exp_name_available;
-            gdat_data.gdat_params.source = upper(gdat_data.gdat_params.source);
-            if strcmp(gdat_data.gdat_params.source(1:2),'EQ');
-                warning('set equilibrium choice in ''equil'' parameter and not source, moved to equil')
-                gdat_data.gdat_params.equil = gdat_data.gdat_params.source;
-                gdat_data.gdat_params.source = [];
-            end
-            if ~isempty(intersect({'THOMSON'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'VTA'; end
-            if ~isempty(intersect({'TRANSP'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'TRA'; end
-            if ~isempty(intersect({'IDE'},gdat_data.gdat_params.source)); gdat_data.gdat_params.source = 'IDA'; end
-            if isempty(intersect(sources_available,gdat_data.gdat_params.source))
-                error(['available source choices: ' sources_available{:} char(10) ' source: ' gdat_data.gdat_params.source ...
-                    ' not implemented, ask O. Sauter' char(10)]);
-            elseif ~strcmp(gdat_data.gdat_params.source,'VTA')
-                disp(['At this stage .te, .ne, .fit refer to VTA projected on given equil choice. ' char(10) ...
-                    'IDA or TRA profiles are added in .ida or .transp respectively']);
-            end
-            if ~isfield(gdat_data.gdat_params,'fit') || isempty(gdat_data.gdat_params.fit) || ~isnumeric(gdat_data.gdat_params.fit)
-                if strcmp(gdat_data.gdat_params.source,'VTA')
-                    gdat_data.gdat_params.fit = 1; % default do fit (only with VTA source requested)
-                else
-                    % fit profiles filled in by IDA, TRA, ... profiles
-                    gdat_data.gdat_params.fit = 0;
-                end
-            end
-            %
-            params_eff = gdat_data.gdat_params;
-            params_eff.data_request=data_request_eff(1:2); % start with ne if nete_rho
-            % get raw data
-            [gdat_data,params_kin,error_status]=gdat_aug(shot,params_eff);
-            gdat_data.gdat_params.data_request=data_request_eff;
-            gdat_data.gdat_request=data_request_eff;
-            if error_status>0
-                if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
-                return
-            end
-            % add rho coordinates
-            params_eff.data_request='equil';
-            [equil,params_equil,error_status]=gdat_aug(shot,params_eff);
-            if error_status>0
-                if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
-                return
-            end
-            gdat_data.gdat_params.equil = params_equil.equil;
-            %gdat_data.equil = equil;
-            
-            % core
-            node_child_nameeff = [upper(data_request_eff(1)) 'e_core'];
-            inb_chord_core=size(gdat_data.(lower(node_child_nameeff)).r,1);
-            inb_time_core=size(gdat_data.(lower(node_child_nameeff)).r,2);
-            psi_out_core = NaN*ones(inb_chord_core,inb_time_core);
-            rhopolnorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
-            rhotornorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
-            rhovolnorm_out_core = NaN*ones(inb_chord_core,inb_time_core);
-            % edge
-            node_child_nameeff_e = [upper(data_request_eff(1)) 'e_edge'];
-            inb_chord_edge=size(gdat_data.(lower(node_child_nameeff_e)).r,1);
-            inb_time_edge=size(gdat_data.(lower(node_child_nameeff_e)).r,2);
-            psi_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
-            rhopolnorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
-            rhotornorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
-            rhovolnorm_out_edge = NaN*ones(inb_chord_edge,inb_time_edge);
-            % constructs intervals within which a given equil is used: [time_equil(i),time_equil(i+1)]
-            time_equil=[min(gdat_data.(lower(node_child_nameeff)).t(1)-0.1,equil.t(1)-0.1) 0.5.*(equil.t(1:end-1)+equil.t(2:end)) max(equil.t(end)+0.1,gdat_data.(lower(node_child_nameeff)).t(end)+0.1)];
-            for itequil=1:length(time_equil)-1
-                rr=equil.Rmesh(:,itequil);
-                zz=equil.Zmesh(:,itequil);
-                psirz_in = equil.psi2D(:,:,itequil);
-                it_core_inequil = find(gdat_data.(lower(node_child_nameeff)).t>time_equil(itequil) & gdat_data.(lower(node_child_nameeff)).t<=time_equil(itequil+1));
-                if ~isempty(it_core_inequil)
-                    rout_core=gdat_data.(lower(node_child_nameeff)).r(:,it_core_inequil);
-                    zout_core=gdat_data.(lower(node_child_nameeff)).z(:,it_core_inequil);
-                    psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout_core,zout_core);
-                    psi_out_core(:,it_core_inequil) = reshape(psi_at_routzout,inb_chord_core,length(it_core_inequil));
-                    rhopolnorm_out_core(:,it_core_inequil) = sqrt((psi_out_core(:,it_core_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
-                    for it_cx=1:length(it_core_inequil)
-                        rhotornorm_out_core(:,it_core_inequil(it_cx)) = ...
-                            interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out_core(:,it_core_inequil(it_cx)),-3,[2 2],[0 1]);
-                        rhovolnorm_out_core(:,it_core_inequil(it_cx)) = ...
-                            interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out_core(:,it_core_inequil(it_cx)),-3,[2 2],[0 1]);
-                    end
-                end
-                % edge
-                it_edge_inequil = find(gdat_data.(lower(node_child_nameeff_e)).t>time_equil(itequil) & gdat_data.(lower(node_child_nameeff_e)).t<=time_equil(itequil+1));
-                if ~isempty(it_edge_inequil)
-                    rout_edge=gdat_data.(lower(node_child_nameeff_e)).r(:,it_edge_inequil);
-                    zout_edge=gdat_data.(lower(node_child_nameeff_e)).z(:,it_edge_inequil);
-                    psi_at_routzout = interpos2Dcartesian(rr,zz,psirz_in,rout_edge,zout_edge);
-                    psi_out_edge(:,it_edge_inequil) = reshape(psi_at_routzout,inb_chord_edge,length(it_edge_inequil));
-                    rhopolnorm_out_edge(:,it_edge_inequil) = sqrt((psi_out_edge(:,it_edge_inequil)-equil.psi_axis(itequil))./(equil.psi_lcfs(itequil)-equil.psi_axis(itequil)));
-                    for it_cx=1:length(it_edge_inequil)
-                        rhotornorm_out_edge(:,it_edge_inequil(it_cx)) = ...
-                            interpos(equil.rhopolnorm(:,itequil),equil.rhotornorm(:,itequil),rhopolnorm_out_edge(:,it_edge_inequil(it_cx)),-3,[2 2],[0 1]);
-                        rhovolnorm_out_edge(:,it_edge_inequil(it_cx)) = ...
-                            interpos(equil.rhopolnorm(:,itequil),equil.rhovolnorm(:,itequil),rhopolnorm_out_edge(:,it_edge_inequil(it_cx)),-3,[2 2],[0 1]);
-                    end
-                end
-            end
-            gdat_data.(lower(node_child_nameeff)).psi = psi_out_core;
-            gdat_data.(lower(node_child_nameeff)).rhopolnorm = rhopolnorm_out_core;
-            gdat_data.(lower(node_child_nameeff)).rhotornorm = rhotornorm_out_core;
-            gdat_data.(lower(node_child_nameeff)).rhovolnorm = rhovolnorm_out_core;
-            gdat_data.(lower(node_child_nameeff_e)).psi = psi_out_edge;
-            gdat_data.(lower(node_child_nameeff_e)).rhopolnorm = rhopolnorm_out_edge;
-            gdat_data.(lower(node_child_nameeff_e)).rhotornorm = rhotornorm_out_edge;
-            gdat_data.(lower(node_child_nameeff_e)).rhovolnorm = rhovolnorm_out_edge;
-            % put values of rhopolnorm for dim{1} by default, all radial mesh for combined core, edge in grids_1d
-            gdat_data.x = gdat_data.(lower(node_child_nameeff)).rhopolnorm;
-            iaaa=iround_os(gdat_data.(lower(node_child_nameeff_e)).t,gdat_data.(lower(node_child_nameeff)).t);
-            gdat_data.x(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhopolnorm(:,iaaa);
-            gdat_data.dim{1} = gdat_data.x;
-            gdat_data.dimunits{1} = 'rhopolnorm';
-            gdat_data2 = get_grids_1d(gdat_data,2,1,gdat_params.nverbose);
-            gdat_data.grids_1d = gdat_data2.grids_1d;
-            % $$$     gdat_data.grids_1d.rhopolnorm = gdat_data.x;
-            % $$$     gdat_data.grids_1d.psi = gdat_data.(lower(node_child_nameeff)).psi;
-            % $$$     gdat_data.grids_1d.psi(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).psi(:,iaaa);
-            % $$$     gdat_data.grids_1d.rhotornorm = gdat_data.(lower(node_child_nameeff)).rhotornorm;
-            % $$$     gdat_data.grids_1d.rhotornorm(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhotornorm(:,iaaa);
-            % $$$     gdat_data.grids_1d.rhovolnorm = gdat_data.(lower(node_child_nameeff)).rhovolnorm;
-            % $$$     gdat_data.grids_1d.rhovolnorm(inb_chord_core+1:inb_chord_core+inb_chord_edge,:) = gdat_data.(lower(node_child_nameeff_e)).rhovolnorm(:,iaaa);
-            
-            gdat_data.data_fullpath = [gdat_data.data_fullpath ' projected on equilibrium ' gdat_data.gdat_params.equil];
-            
-            % if nete_rho, copy data as .ne, get .te and put pe=e ne Te in data:
-            gdat_data.(data_request_eff(1:2)).data = gdat_data.data;
-            gdat_data.(data_request_eff(1:2)).error_bar = gdat_data.error_bar;
-            gdat_data.(data_request_eff(1:2)).units = gdat_data.units;
-            gdat_data.(data_request_eff(1:2)).core = gdat_data.([data_request_eff(1:2) '_core']);
-            gdat_data.(data_request_eff(1:2)).edge = gdat_data.([data_request_eff(1:2) '_edge']);
-            gdat_data = rmfield(gdat_data,{[data_request_eff(1:2) '_core'],[data_request_eff(1:2) '_edge']});
-            if strcmp(data_request_eff(1:4),'nete')
-                params_eff.data_request=data_request_eff(3:4);
-                [gdat_data_te,params_kin,error_status]=gdat_aug(shot,params_eff);
-                gdat_data.te.data = gdat_data_te.data;
-                gdat_data.te.error_bar = gdat_data_te.error_bar;
-                gdat_data.te.units = gdat_data_te.units;
-                gdat_data.te.core = gdat_data_te.te_core;
-                gdat_data.te.edge = gdat_data_te.te_edge;
-                gdat_data.te.error_bar = gdat_data_te.error_bar;
-                gdat_data.te.core.psi = gdat_data.ne.core.psi;
-                gdat_data.te.core.rhopolnorm = gdat_data.ne.core.rhopolnorm;
-                gdat_data.te.core.rhotornorm = gdat_data.ne.core.rhotornorm;
-                gdat_data.te.core.rhovolnorm = gdat_data.ne.core.rhovolnorm;
-                gdat_data.te.edge.psi = gdat_data.ne.edge.psi;
-                gdat_data.te.edge.rhopolnorm = gdat_data.ne.edge.rhopolnorm;
-                gdat_data.te.edge.rhotornorm = gdat_data.ne.edge.rhotornorm;
-                gdat_data.te.edge.rhovolnorm = gdat_data.ne.edge.rhovolnorm;
-                % put pe in main gdat_data
-                gdat_data.data = 1.6022e-19.*gdat_data.ne.data.*gdat_data.te.data;
-                gdat_data.error_bar = 1.6022e-19 .* (gdat_data.ne.data .* gdat_data.te.error_bar ...
-                    + gdat_data.te.data .* gdat_data.ne.error_bar);
-                gdat_data.units='N/m^2; 1.6022e-19 ne Te';
-                gdat_data.data_fullpath=['pe=1.6e-19*ne*Te in data, .ne, .te ' gdat_data.data_fullpath(3:end)];
-                gdat_data.label = 'pe';
-            end
-            % defaults for fits, so user always gets std structure
-            gdat_data.fit.rhotornorm = []; % same for both ne and te
-            gdat_data.fit.rhopolnorm = [];
-            gdat_data.fit.t = [];
-            gdat_data.fit.te.data = [];
-            gdat_data.fit.te.drhotornorm = [];
-            gdat_data.fit.ne.data = [];
-            gdat_data.fit.ne.drhotornorm = [];
-            gdat_data.fit.raw.te.data = [];
-            gdat_data.fit.raw.te.rhotornorm = [];
-            gdat_data.fit.raw.ne.data = [];
-            gdat_data.fit.raw.ne.rhotornorm = [];
-            fit_tension_default = -0.1;
-            if isfield(gdat_data.gdat_params,'fit_tension')
-                fit_tension = gdat_data.gdat_params.fit_tension;
-            else
-                fit_tension = fit_tension_default;
-            end
-            if ~isstruct(fit_tension)
-                fit_tension_eff.te = fit_tension;
-                fit_tension_eff.ne = fit_tension;
-                fit_tension = fit_tension_eff;
-            else
-                if ~isfield(fit_tension,'te'); fit_tension.te = fit_tension_default; end
-                if ~isfield(fit_tension,'ne '); fit_tension.ne = fit_tension_default; end
-            end
-            gdat_data.gdat_params.fit_tension = fit_tension;
-            if isfield(gdat_data.gdat_params,'fit_nb_rho_points')
-                fit_nb_rho_points = gdat_data.gdat_params.fit_nb_rho_points;
-            else
-                fit_nb_rho_points = 201;
-            end
-            gdat_data.gdat_params.fit_nb_rho_points = fit_nb_rho_points;
-            %
-            if gdat_data.gdat_params.fit==1
-                % add "manual" fits
-                gdat_data.fit.t = gdat_data.t;
-                rhotornormfit = linspace(0,1,fit_nb_rho_points)';
-                gdat_data.fit.rhotornorm = rhotornormfit;
-                gdat_data.fit.rhopolnorm = NaN*ones(length(rhotornormfit),length(gdat_data.fit.t));
-                if any(strfind(data_request_eff,'te'))
-                    gdat_data.fit.raw.te.data = NaN*ones(size(gdat_data.te.data));
-                    gdat_data.fit.raw.te.error_bar = NaN*ones(size(gdat_data.te.data));
-                    gdat_data.fit.raw.te.rhotornorm = NaN*ones(size(gdat_data.te.data));
-                    gdat_data.fit.te.data = gdat_data.fit.rhopolnorm;
-                    gdat_data.fit.te.drhotornorm = gdat_data.fit.rhopolnorm;
-                end
-                if any(strfind(data_request_eff,'ne'))
-                    gdat_data.fit.raw.ne.data = NaN*ones(size(gdat_data.ne.data));
-                    gdat_data.fit.raw.ne.error_bar = NaN*ones(size(gdat_data.ne.data));
-                    gdat_data.fit.raw.ne.rhotornorm = NaN*ones(size(gdat_data.ne.data));
-                    gdat_data.fit.ne.data =gdat_data.fit.rhopolnorm;
-                    gdat_data.fit.ne.drhotornorm = gdat_data.fit.rhopolnorm;
-                end
-                for it=1:length(gdat_data.t)
-                    % make rhotor->rhopol transformation for each time since equilibrium might have changed
-                    gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
-                        gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
-                    gdat_data.fit.rhopolnorm(:,it)=interpos(gdat_data.grids_1d.rhotornorm_equil(:,it), ...
-                        gdat_data.grids_1d.rhopolnorm_equil(:,it),rhotornormfit);
-                    if any(strfind(data_request_eff,'te'))
-                        idatate = find(gdat_data.te.data(:,it)>0 & gdat_data.grids_1d.rhotornorm(:,it)<=1.05);
-                        if length(idatate)>0
-                            gdat_data.fit.raw.te.rhotornorm(idatate,it) = gdat_data.grids_1d.rhotornorm(idatate,it);
-                            gdat_data.fit.raw.te.data(idatate,it) = gdat_data.te.data(idatate,it);
-                            gdat_data.fit.raw.te.error_bar(idatate,it) = gdat_data.te.error_bar(idatate,it);
-                            [rhoeff,irhoeff] = sort(gdat_data.grids_1d.rhotornorm(idatate,it));
-                            rhoeff = [0; rhoeff];
-                            teeff = gdat_data.te.data(idatate(irhoeff),it);
-                            te_err_eff = gdat_data.te.error_bar(idatate(irhoeff),it);
-                            % they are some strange low error_bars, so remove these by max(Te/error_bar)<=10; and changing it to large error bar
-                            ij=find(teeff./te_err_eff>10.);
-                            if ~isempty(ij); te_err_eff(ij) = max(max(te_err_eff),teeff(ij)./0.1); end
-                            %
-                            teeff =  [teeff(1); teeff];
-                            te_err_eff =  [1e4; te_err_eff];
-                            % add some points to reach 0 at 1.05
-                            if max(rhoeff)<1.03
-                                rhoeff = [rhoeff; 1.05];
-                                teeff = [teeff; 0.];
-                                te_err_eff(end) = 10.*max(te_err_eff(2:end));
-                                te_err_eff = [te_err_eff; min(te_err_eff)]; % to give more weight for new last point
-                            else
-                                teeff(end) = 0.;
-                                te_err_eff(end-1) = 10.*max(te_err_eff(2:end));
-                                te_err_eff(end) = min(te_err_eff); % to give more weight for new value of last point
-                            end
-                            [gdat_data.fit.te.data(:,it), gdat_data.fit.te.drhotornorm(:,it)] = interpos(rhoeff,teeff,rhotornormfit,fit_tension.te,[1 0],[0 0],te_err_eff);
-                            % avoid neg points or positive edge gradient
-                            if ~isempty(find(gdat_data.fit.te.data(:,it)<0)) || gdat_data.fit.te.drhotornorm(end,it) > 0
-                                ij= find(rhoeff>=0.85 & rhoeff<1.04);
-                                if ~isempty(ij)
-                                    te_err_eff(ij) = 100.*min(te_err_eff);
-                                else
-                                    te_err_eff(end-min(5,length(te_err_eff)-3):end-1) = 100.*min(te_err_eff);
-                                end
-                                [gdat_data.fit.te.data(:,it), gdat_data.fit.te.drhotornorm(:,it)] = interpos(rhoeff,teeff,rhotornormfit,fit_tension.te,[1 0],[0 0],te_err_eff);
-                            end
-                        end
-                    end
-                    if any(strfind(data_request_eff,'ne'))
-                        idatane = find(gdat_data.ne.data(:,it)>0 & gdat_data.grids_1d.rhotornorm(:,it)<=1.05);
-                        if length(idatane)>0
-                            gdat_data.fit.raw.ne.rhotornorm(idatane,it) = gdat_data.grids_1d.rhotornorm(idatane,it);
-                            gdat_data.fit.raw.ne.data(idatane,it) = gdat_data.ne.data(idatane,it);
-                            gdat_data.fit.raw.ne.error_bar(idatane,it) = gdat_data.ne.error_bar(idatane,it);
-                            [rhoeff,irhoeff] = sort(gdat_data.grids_1d.rhotornorm(idatane,it));
-                            rhoeff = [0; rhoeff];
-                            % they are some strange low error_bars, so remove these by max(Te/error_bar)<=10; and changing it to large error bar
-                            neeff = gdat_data.ne.data(idatane(irhoeff),it);
-                            ne_err_eff = gdat_data.ne.error_bar(idatane(irhoeff),it);
-                            ij=find(neeff./ne_err_eff>10.);
-                            if ~isempty(ij); ne_err_eff(ij) = max(max(ne_err_eff),neeff(ij)./0.1); end
-                            %
-                            neeff =  [neeff(1); neeff];
-                            ne_err_eff =  [1e21; ne_err_eff];
-                            % add some points to reach 0 at 1.05
-                            if max(rhoeff)<1.03
-                                rhoeff = [rhoeff; 1.05];
-                                neeff = [neeff; 0.];
-                                ne_err_eff(end) = 10.*max(ne_err_eff(2:end)); % to give more weight for new last point
-                                ne_err_eff = [ne_err_eff; min(ne_err_eff)];
-                            else
-                                neeff(end) = 0.;
-                                ne_err_eff(end-1) = 10.*max(ne_err_eff(2:end));
-                                ne_err_eff(end) = min(ne_err_eff); % to give more weight for new value of last point
-                            end
-                            [gdat_data.fit.ne.data(:,it), gdat_data.fit.ne.drhotornorm(:,it)] = interpos(rhoeff,neeff,rhotornormfit,fit_tension.ne,[1 0],[0 0],ne_err_eff);
-                            % avoid neg points or positive edge gradient
-                            if ~isempty(find(gdat_data.fit.ne.data(:,it)<0)) || gdat_data.fit.ne.drhotornorm(end,it) > 0
-                                ij= find(rhoeff>=0.85 & rhoeff<1.04);
-                                if ~isempty(ij)
-                                    ne_err_eff(ij) = 100.*min(ne_err_eff);
-                                else
-                                    ne_err_eff(end-min(5,length(ne_err_eff)-3):end-1) = 100.*min(ne_err_eff);
-                                end
-                                [gdat_data.fit.ne.data(:,it), gdat_data.fit.ne.drhotornorm(:,it)] = interpos(rhoeff,neeff,rhotornormfit,fit_tension.ne,[1 0],[0 0],ne_err_eff);
-                            end
-                        end
-                    end
-                end
-            end
-            % add other profiles in fit (without raw data part)
-            switch gdat_data.gdat_params.source
-                case 'IDA'
-                    gdat_data.fit.full_path = 'from IDA: Te, Te_unc, ne, ne_unc, rhop and rhot';
-                    params_eff.data_request={'IDA','','','area-base:rhop'};
-                    [gdat_data_ida_rhop,params_kin,error_status]=gdat_aug(shot,params_eff);
-                    gdat_data.fit.rhopolnorm = gdat_data_ida_rhop.data;
-                    params_eff.data_request={'IDA','rhot'}; % it is actually rhotor_norm
-                    [gdat_data_te_ida_rhot,params_kin,error_status]=gdat_aug(shot,params_eff);
-                    gdat_data.fit.rhotornorm = gdat_data_te_ida_rhot.data;
-                    if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'te')
-                        % Te
-                        params_eff.data_request={'IDA','Te'};
-                        [gdat_data_te_ida,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.te.data = gdat_data_te_ida.data;
-                        gdat_data.fit.t = gdat_data_te_ida.t;
-                        params_eff.data_request={'IDA','Te_unc'};
-                        [gdat_data_te_ida_err,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.te.error_bar = gdat_data_te_ida_err.data;
-                    end
-                    if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'ne')
-                        % ne
-                        params_eff.data_request={'IDA','ne'};
-                        [gdat_data_ne_ida,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.ne.data = gdat_data_ne_ida.data;
-                        gdat_data.fit.t = gdat_data_ne_ida.t;
-                        params_eff.data_request={'IDA','ne_unc'};
-                        [gdat_data_ne_ida_err,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.ne.error_bar = gdat_data_ne_ida_err.data; % time as 2nd dim
-                    end
-                case 'TRA'
-                    gdat_data.fit.full_path = 'from TRA: TE, NE, rhop from PLFLX and XB (.x is rhotornorm mid-points, XB end-point)';
-                    % (tra.XB.data(1:end,it)'+[0 ,tra.XB.data(1:end-1,it)'])/2 = tra.TE.x(1:end,it)'
-                    if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'te')
-                        % Te
-                        params_eff.data_request={'TRA','TE',gdat_data.gdat_params.source_exp_name};
-                        [gdat_data_te_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.te.data = gdat_data_te_tra.data;
-                        gdat_data.fit.t = gdat_data_te_tra.t;
-                        gdat_data.fit.rhotornorm = gdat_data_te_tra.x;
-                        params_eff.data_request={'TRA','PLFLX',gdat_data.gdat_params.source_exp_name};
-                        [gdat_data_plflx_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        rhopol_endpoints = sqrt((gdat_data_plflx_tra.data-0)./(repmat(gdat_data_plflx_tra.data(end,:),size(gdat_data_plflx_tra.data,1),1)-0.));
-                        for it=1:size(gdat_data_plflx_tra.data,2)
-                            gdat_data.fit.rhopolnorm(:,it) = interpos([0. ; gdat_data_plflx_tra.x(:,it)],[0. ; rhopol_endpoints(:,it)],gdat_data.fit.rhotornorm(:,it));
-                        end
-                    end
-                    if strcmp(data_request_eff(1:4),'nete') || strcmp(data_request_eff(1:2),'ne')
-                        % ne
-                        params_eff.data_request={'TRA','NE',gdat_data.gdat_params.source_exp_name};
-                        [gdat_data_ne_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
-                        gdat_data.fit.ne.data = gdat_data_ne_tra.data .* 1e6; % ne in cm^3 !!
-                        if ~strcmp(data_request_eff(1:4),'nete')
-                            gdat_data.fit.t = gdat_data.t;
-                            gdat_data.fit.rhotornorm = gdat_data_ne_tra.x;
-                            params_eff.data_request={'TRA','PLFLX',gdat_data.gdat_params.source_exp_name};
-                            [gdat_data_plflx_tra,params_kin,error_status]=gdat_aug(shot,params_eff);
-                            rhopol_endpoints = sqrt((gdat_data_plflx_tra.data-0)./(repmat(gdat_data_plflx_tra.data(end,:),size(gdat_data_plflx_tra.data,1),1)-0.));
-                            for it=1:size(gdat_data_plflx_tra.data,2)
-                                gdat_data.fit.rhopolnorm(:,it) = interpos([0. ; gdat_data_plflx_tra.x(:,it)],[0. ; rhopol_endpoints(:,it)],gdat_data.fit.rhotornorm(:,it));
-                            end
-                        end
-                    end
-                otherwise
-                    if ~strcmp(gdat_data.gdat_params.source,'VTA')
-                        disp(['profiles ''fit'' from ' gdat_data.gdat_params.source ' not defined. At this stage only: ' sources_available{:} ...
-                            ' are available. Ask O. Sauter if need be']);
-                    end
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'pgyro'}
-            extra_arg_sf2sig_eff_string = '';
-            if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
-                extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
-            end
-            %  LOAD MULTI CHANNEL DATA ECS
-            %  powers, frequencies, etc
-            params_eff = gdat_data.gdat_params;
-            params_eff.data_request={'ECS','PECRH'};
-            % pgyro tot in index=9
-            try
-                gdat_data=gdat_aug(shot,params_eff);
-                gdat_data.data_request = data_request_eff;
-                gdat_data.gdat_params.data_request = data_request_eff;
-            catch
-                if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
-                gdat_data.data_request = data_request_eff;
-                return
-            end
-            nb_timepoints = length(gdat_data.t);
-            pgyro = NaN*ones(nb_timepoints,9);
-            pgyro(:,9) = reshape(gdat_data.data,nb_timepoints,1);
-            gdat_data.data = pgyro;
-            labels{9} = 'ECtot';
-            for i=1:4
-                % "old" ECRH1 gyrotrons: gyro 1 to 4 in pgyro
-                params_eff.data_request={'ECS',['PG' num2str(i)]};
-                gdat_data_i=gdat_aug(shot,params_eff);
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i} = gdat_data_i;
-                    gdat_data.data(:,i) = reshape(gdat_data_i.data,nb_timepoints,1);
-                    gdat_data.dim = [{gdat_data_i.t} {[1:9]}];
-                    if max(gdat_data_i.data) > 0.
-                        labels{i} = ['EC_' num2str(i)];
-                    end
-                end
-                sys1_source = 'P_sy1_g';
-                if shot > 33725; sys1_source = 'P_sy3_g'; end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'gyr_freq']);
-                    % eval(['a = sf2par(''ECS'',shot,''gyr_freq'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    % gyr_freq not present (old shots for example)
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i}.freq = a;
-                    gdat_data.freq_ec(i) = a.value;
-                end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GPolPos']);
-                    % eval(['a = sf2par(''ECS'',shot,''GPolPos'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    % GPolPos not present
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i}.polpos = a.value;
-                    gdat_data.polpos_ec(i) = a.value;
-                end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',[sys1_source num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GTorPos']);
-                    % eval(['a = sf2par(''ECS'',shot,''GTorPos'','sys1_source num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i}.torpos = a.value;
-                    gdat_data.torpos_ec(i) = a.value;
-                end
-                % "new" ECRH2 gyrotrons: gyro 5 to 8 in pgyro
-                params_eff.data_request={'ECS',['PG' num2str(i) 'N']};
-                gdat_data_i=gdat_aug(shot,params_eff);
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i+4} = gdat_data_i;
-                    gdat_data.data(:,i+4) = reshape(gdat_data_i.data,nb_timepoints,1);
-                    gdat_data.dim = [{gdat_data_i.t} {[1:9]}];
-                    if max(gdat_data_i.data) > 0.
-                        labels{i+4} = ['EC_' num2str(i+4)];
-                    end
-                end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'gyr_freq']);
-                    % eval(['a = sf2par(''ECS'',shot,''gyr_freq'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i+4}.freq = a;
-                    gdat_data.freq_ec(i+4) = a.value;
-                end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GPolPos']);
-                    % eval(['a = sf2par(''ECS'',shot,''GPolPos'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i+4}.polpos = a.value;
-                    gdat_data.polpos_ec(i+4) = a.value;
-                end
-                try
-                    [a,e]=rdaAUG_eff(shot,'ECS',['P_sy2_g' num2str(i)],gdat_data.gdat_params.exp_name,[], ...
-                        gdat_data.gdat_params.extra_arg_sf2sig,['param:' 'GTorPos']);
-                    % eval(['a = sf2par(''ECS'',shot,''GTorPos'',''P_sy2_g' num2str(i) '''' extra_arg_sf2sig_eff_string ');']);
-                catch
-                    a=[];
-                end
-                if isempty(a)
-                else
-                    gdat_data.ec{i+4}.torpos = a.value;
-                    gdat_data.torpos_ec(i+4) = a.value;
-                end
-                params_eff.data_request={'ECN',['G' num2str(i) 'POL']};
-                gdat_data_i=gdat_aug(shot,params_eff);
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i+4}.gpol_ec = gdat_data_i;
-                end
-                params_eff.data_request={'ECN',['G' num2str(i) 'TOR']};
-                gdat_data_i=gdat_aug(shot,params_eff);
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i+4}.gtor_ec = gdat_data_i;
-                end
-                ishift=0;
-                if shot >= 36794; ishift=4; end
-                params_eff.data_request={'ECN',['G' num2str(i+ishift) 'PO4']};
-                try
-                    gdat_data_i=gdat_aug(shot,params_eff);
-                catch ME1
-                    disp(getReport(ME1))
-                    gdat_data_i.data = [];
-                end
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i+4}.gpo4_ec = gdat_data_i;
-                end
-                params_eff.data_request={'ECN',['G' num2str(i+ishift) 'PO8']};
-                try
-                    gdat_data_i=gdat_aug(shot,params_eff);
-                catch ME2
-                    disp(getReport(ME2))
-                    gdat_data_i.data = [];
-                end
-                if isempty(gdat_data_i.data) || isempty(gdat_data_i.dim)
-                else
-                    gdat_data.ec{i+4}.gpo8_ec = gdat_data_i;
-                end
-            end
-            if ~isempty(gdat_data.dim)
-                gdat_data.t = gdat_data.dim{1};
-                gdat_data.x = gdat_data.dim{2};
-                gdat_data.dimunits=[{'time [s]'} {'ECRH1(1:4) ECRH2(1:4) ECtot'}];
-                gdat_data.units='W';
-                gdat_data.freq_ech_units = 'GHz';
-                gdat_data.data_fullpath=['ECS/' 'PGi and PGiN, etc'];
-                icount=0;
-                for i=1:length(labels)
-                    if ~isempty(labels{i})
-                        icount=icount+1;
-                        gdat_data.label{icount} = labels{i};
-                    end
-                end
-            else
-                gdat_data.freq_ech_units =[]';
-                gdat_data.ec = [];
-                gdat_data.freq_ec = [];
-                gdat_data.polpos_ec = [];
-                gdat_data.torpos_ec = [];
-            end
-            
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'powers'}
-            sources_avail = {'ohm','ec','nbi','ic','rad'}; % note should allow ech, nbh, ohmic in parameter sources
-            for i=1:length(sources_avail)
-                gdat_data.(sources_avail{i}).data = [];
-                gdat_data.(sources_avail{i}).units = [];
-                gdat_data.(sources_avail{i}).dim=[];
-                gdat_data.(sources_avail{i}).dimunits=[];
-                gdat_data.(sources_avail{i}).t=[];
-                gdat_data.(sources_avail{i}).x=[];
-                gdat_data.(sources_avail{i}).data_fullpath=[];
-                gdat_data.(sources_avail{i}).label=[];
-            end
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = sources_avail;
-            elseif ~iscell(gdat_data.gdat_params.source)
-                if ischar(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
-                    if ~any(strmatch(gdat_data.gdat_params.source,lower(sources_avail)))
-                        if (gdat_params.nverbose>=1)
-                            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
-                        end
-                        return
-                    else
-                        gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
-                    end
-                else
-                    if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
-                    return
-                end
-            else
-                for i=1:length(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
-                    if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
-                        if gdat_data.gdat_params.nverbose>=1
-                            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
-                        end
-                    end
-                end
-            end
-            % always start from ohmic so can use this time as base time since should yield full shot
-            
-            fields_to_copy = {'data','units','dim','dimunits','t','x','data_fullpath','label','help','gdat_params'};
-            fields_to_not_copy = {'shot','gdat_request'};
-            % total of each source in .data, but full data in subfield like pgyro in .ec, to check for nbi
-            params_eff = gdat_data.gdat_params;
-            % ohmic, use its time-base
-            params_eff.data_request={'TOT','P_OH'};
-            try
-                ohm=gdat_aug(shot,params_eff);
-            catch
-                ohm.data = [];
-                ohm.dim = [];
-            end
-            if ~isempty(ohm.data) && ~isempty(ohm.dim)
-                for i=1:length(fields_to_copy)
-                    if isfield(ohm,fields_to_copy{i})
-                        gdat_data.ohm.(fields_to_copy{i}) = ohm.(fields_to_copy{i});
-                    end
-                end
-                gdat_data.ohm.raw_data = gdat_data.ohm.data;
-            else
-                if gdat_params.nverbose>=3; disp(['problems with ' params_eff.data_request]); end
-                return
-            end
-            mapping_for_aug.timedim = 1; mapping_for_aug.gdat_timedim = 1;
-            taus = -10;
-            %
-            % add each source in main.data, on ohm time array
-            gdat_data.t = gdat_data.ohm.t;
-            gdat_data.dim{1} = gdat_data.t;
-            gdat_data.dimunits{1} = 's';
-            gdat_data.ohm.data = interpos(gdat_data.t,gdat_data.ohm.raw_data,5.*taus);
-            gdat_data.data = reshape(gdat_data.ohm.data,length(gdat_data.t),1);
-            gdat_data.ohm.tension = 5.*taus;
-            gdat_data.x =[1];
-            gdat_data.label={'P_{ohm}'};
-            gdat_data.units = 'W';
-            %
-            if any(strmatch('ec',gdat_data.gdat_params.source))
-                % ec
-                params_eff.data_request={'ECS','PECRH'};
-                params_eff.data_request='pgyro';
-                try
-                    ec=gdat_aug(shot,params_eff);
-                catch
-                end
-                if ~isempty(ec.data) && ~isempty(ec.dim)
-                    for i=1:length(fields_to_copy)
-                        % if has pgyro, use not_copy
-                        if isfield(ec,fields_to_copy{i}) && ~any(strmatch(fields_to_not_copy,fields_to_copy{i}))
-                            gdat_data.ec.(fields_to_copy{i}) = ec.(fields_to_copy{i});
-                        end
-                    end
-                    gdat_data.data(:,end+1) = interpos(-21,gdat_data.ec.t,gdat_data.ec.data(:,end),gdat_data.t);
-                    gdat_data.x(end+1) =gdat_data.x(end)+1;
-                    gdat_data.label{end+1}='P_{ec}';
-                end
-            end
-            %
-            if any(strmatch('nb',gdat_data.gdat_params.source))
-                % nbi
-                params_eff.data_request={'NIS','PNIQ'};
-                try
-                    nbi=gdat_aug(shot,params_eff);
-                catch
-                    nbi.data = [];
-                    nbi.dim = [];
-                end
-                if ~isempty(nbi.data) && ~isempty(nbi.dim)
-                    for i=1:length(fields_to_copy)
-                        if isfield(nbi,fields_to_copy{i})
-                            gdat_data.nbi.(fields_to_copy{i}) = nbi.(fields_to_copy{i});
-                        end
-                    end
-                    % add to main with linear interpolation and 0 for extrapolated values
-                    gdat_data.data(:,end+1) = interpos(-21,gdat_data.nbi.t,gdat_data.nbi.data(:,end),gdat_data.t);
-                    gdat_data.x(end+1) =gdat_data.x(end)+1;
-                    gdat_data.label{end+1}='P_{nbi}';
-                end
-            end
-            %
-            if any(strmatch('ic',gdat_data.gdat_params.source))
-                % ic
-                params_eff.data_request={'ICP','PICRN'};
-                try
-                    ic=gdat_aug(shot,params_eff);
-                catch
-                    ic.data = [];
-                    ic.dim = [];
-                end
-                if ~isempty(ic.data) && ~isempty(ic.dim)
-                    for i=1:length(fields_to_copy)
-                        if isfield(ic,fields_to_copy{i})
-                            gdat_data.ic.(fields_to_copy{i}) = ic.(fields_to_copy{i});
-                        end
-                    end
-                    gdat_data.data(:,end+1) = interpos(-21,gdat_data.ic.t,gdat_data.ic.data,gdat_data.t);
-                    gdat_data.x(end+1) =gdat_data.x(end)+1;
-                    gdat_data.label{end+1}='P_{ic}';
-                end
-            end
-            index_prad = [];
-            if any(strmatch('rad',gdat_data.gdat_params.source))
-                % radiated power
-                params_eff.data_request='prad';
-                try
-                    rad=gdat_aug(shot,params_eff);
-                catch
-                end
-                if ~isempty(rad.data) && ~isempty(rad.dim)
-                    for i=1:length(fields_to_copy)
-                        if isfield(rad,fields_to_copy{i})
-                            gdat_data.rad.(fields_to_copy{i}) = rad.(fields_to_copy{i});
-                        end
-                    end
-                    % add to main with linear interpolation and 0 for extrapolated values
-                    gdat_data.data(:,end+1) = interpos(-21,gdat_data.rad.t,gdat_data.rad.data,gdat_data.t);
-                    index_prad = size(gdat_data.data,2); % to not add for ptot
-                    gdat_data.x(end+1) =gdat_data.x(end)+1;
-                    gdat_data.label{end+1}='P_{rad}';
-                end
-            end
-            % add tot power
-            index_noprad = setdiff([1:size(gdat_data.data,2)],index_prad);
-            gdat_data.data(:,end+1) = sum(gdat_data.data(:,index_noprad),2);
-            gdat_data.label{end+1}='P_{tot,h}';
-            gdat_data.x(end+1) =gdat_data.x(end)+1;
-            gdat_data.dim{2} = gdat_data.x; gdat_data.dimunits{2} = '';
-            gdat_data.data_fullpath = 'tot powers from each sources, and total heating power in .data(:,end)';
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'q_rho'}
-            [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
-            % since Lpf depends on time, need to load all first and then loop over time for easier mapping
-            [qpsi,e]=rdaAUG_eff(shot,DIAG,'Qpsi',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            ndimrho = size(qpsi.data,2);
-            if ndimrho==NTIME_Lpf
-                % data seems to be transposed
-                ndimrho = size(qpsi.data,1);
-                itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
-            else
-                itotransposeback = 0;
-            end
-            qpsi=adapt_rda(qpsi,NTIME,ndimrho,itotransposeback);
-            ijnan=find(isnan(qpsi.value));
-            qpsi.value(ijnan)=0;
-            [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
-            [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
-            [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
-            % seems "LCFS" q-value is far too large, limit to some max (when diverted)
-            max_qValue = 30.; % Note could just put a NaN on LCFS value since ill-defined when diverted
-            for it=1:NTIME
-                Lpf1 = Lpf1_t(it);
-                % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
-                % change it to (radial,time) and use only Lpf+1 points up to LCFS
-                ijok=find(qpsi.value(:,1)); % note: eqr fills in only odd points radially
-                % set NaNs to zeroes
-                if qpsi.value(ijok(1),1)<0
-                    gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
-                else
-                    gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
-                end
-                % get x values
-                psi_it=psi_tree.value(it,Lpf1:-1:1)';
-                gdat_data.psi_axis(it)= psi_it(1);
-                gdat_data.psi_lcfs(it)= psi_it(end);
-                gdat_data.rhopolnorm(:,it) = sqrt(abs((psi_it-gdat_data.psi_axis(it)) ./(gdat_data.psi_lcfs(it)-gdat_data.psi_axis(it))));
-                if strcmp(DIAG,'EQR');
-                    % q value has only a few values and from center to edge, assume they are from central rhopol values on
-                    % But they are every other point starting from 3rd
-                    ijk=find(gdat_data.qvalue(:,it)~=0);
-                    if length(ijk)>2
-                        % now shots have non-zero axis values in eqr
-                        rhoeff=gdat_data.rhopolnorm(ijk,it);
-                        qeff=gdat_data.qvalue(ijk,it); % radial order was already inverted above
-                        if ijk(1)>1
-                            rhoeff = [0.; rhoeff];
-                            qeff = [qeff(1) ;qeff];
-                        end
-                        ij_nonan=find(~isnan(gdat_data.rhopolnorm(:,it)));
-                        qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
-                        qfit(ij_nonan)=interpos(rhoeff,qeff,gdat_data.rhopolnorm(ij_nonan,it),-0.01,[1 0],[0 0],[300; ones(size(qeff(1:end-1)))]);
-                    else
-                        qfit = zeros(size(gdat_data.rhopolnorm(:,it)));
-                    end
-                    gdat_data.qvalue(:,it) = qfit;
-                end
-                % get rhotor values
-                phi_it = phi_tree.value(it,Lpf1:-1:1)';
-                gdat_data.rhotornorm(:,it) = sqrt(abs(phi_it ./ phi_it(end)));
-                % get rhovol values
-                vol_it=Vol.value(it,2*Lpf1-1:-2:1)';
-                gdat_data.rhovolnorm(:,it) = sqrt(abs(vol_it ./ vol_it(end)));
-                % Qpsi and similar data is on (time,radius) with radius being: LCFS..Lpf_points dummy LCFS..SOL part
-                % change it to (radial,time) and use only Lpf+1 points up to LCFS
-                ijok=find(qpsi.value(:,1)); % note: eqr fills in only odd points radially
-                % max value 1e6, change to 2*extrapolation (was max_qValue before)
-                q_edge=interpos(gdat_data.rhotornorm(1:end-1,it),qpsi.value(it,Lpf1:-1:2),1,-0.1);
-                gdat_data.qvalue(:,it) = qpsi.value(it,Lpf1:-1:1)';
-                if abs(gdat_data.qvalue(end,it)) > 1e3
-                    % assume diverted
-                    gdat_data.qvalue(end,it) = 2. * q_edge;
-                end
-                % $$$       if qpsi.value(ijok(1),1)<0
-                % $$$   gdat_data.qvalue(:,it) = max(qpsi.value(it,Lpf1:-1:1)',-max_qValue);
-                % $$$       else
-                % $$$   gdat_data.qvalue(:,it) = min(qpsi.value(it,Lpf1:-1:1)',max_qValue);
-                % $$$       end
-            end
-            gdat_data.x = gdat_data.rhopolnorm;
-            % get time values
-            gdat_data.data = gdat_data.qvalue; % put q in data
-            gdat_data.units=[]; % not applicable
-            gdat_data.data_fullpath = [DIAG ' from exp_name: ' gdat_data.gdat_params.exp_name '; q(rhopolnorm,t) in .data(.x,.t)'];
-            gdat_data.cocos = 17; % should check FPP (IDE seems 13)
-            gdat_data.dim{1} = gdat_data.x;
-            gdat_data.dim{2} = gdat_data.t;
-            gdat_data.dimunits{1} = 'rhopolnorm';
-            gdat_data.dimunits{2} = 'time [s]';
-            % add grids_1d to have rhotor, etc
-            gdat_data = get_grids_1d(gdat_data,2,1,gdat_params.nverbose);
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'psi_axis', 'psi_edge'}
-            if strcmp(upper(gdat_data.gdat_params.equil),'FPG')
-                gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
-                gdat_params_eff.data_request = [{'FPG'},{'fax-bnd'},{'AUGD'}];
-                gdat_data = gdat_aug(gdat_data.shot,gdat_params_eff);
-                gdat_data.gdat_params = gdat_params_prev;
-                gdat_data.label = 'psi\_axis-psi\_edge';
-                gdat_data.data_fullpath = [gdat_data.data_fullpath ' yields only psi\_axis-psi\_edge from FPG/fax-bnd'];
-            else
-                [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
-                % since Lpf depends on time, need to load all first and then loop over time for easier mapping
-                [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                ndimrho = size(psi_tree.data,2);
-                if ndimrho==NTIME_Lpf
-                    % data seems to be transposed
-                    ndimrho = size(psi_tree.data,1);
-                    itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
-                else
-                    itotransposeback = 0;
-                end
-                psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
-                ijnan=find(isnan(psi_tree.value));
-                psi_tree.value(ijnan)=0;
-                gdat_data.dim{1} = gdat_data.t;
-                gdat_data.dimunits{1} = 'time [s]';
-                for it=1:NTIME
-                    Lpf1 =min(Lpf1_t(it),size(psi_tree.value,2));
-                    psi_it=psi_tree.value(it,Lpf1:-1:1)';
-                    if strcmp(data_request_eff,'psi_axis')
-                        gdat_data.data(it)= psi_it(1);
-                    elseif strcmp(data_request_eff,'psi_edge')
-                        gdat_data.data(it)= psi_it(end);
-                    else
-                    end
-                end
-                gdat_data.units = psi_tree.units;
-                gdat_data.data_fullpath = [DIAG '/PFL extract ' data_request_eff];
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'raptor'}
-            sources_avail = {'observer','predictive'};
-            for i=1:length(sources_avail)
-                gdat_data.(sources_avail{i}).data = [];
-                gdat_data.(sources_avail{i}).units = [];
-                gdat_data.(sources_avail{i}).dim=[];
-                gdat_data.(sources_avail{i}).dimunits=[];
-                gdat_data.(sources_avail{i}).t=[];
-                gdat_data.(sources_avail{i}).x=[];
-                gdat_data.(sources_avail{i}).data_fullpath=[];
-                gdat_data.(sources_avail{i}).label=[];
-            end
-            rap_signals={'ECE_f','Hmode','Ip','P_LH','Phib','beta','cs','exflag','g_f','it','li3','ne_f','res','tcomp','ECEm', ...
-                'F','Vp','chie','dk_k','dpsi','dte','g1','g23or','g2','g3','iota','jbs','jec','jnb','jpar','ne','ni', ...
-                'p','paux','pbrem','pec','pei','pnbe','poh','prad','psi','q','rhtECE','sdk_k','shear','signeo','sxk_k', ...
-                'te','ti','upl','xk_k','ze'};
-            
-            rap_desc_signals={'rts:Dia/RAPTOR/ECEflag.val','rts:Dia/RAPTOR/Hmode.val','rts:Dia/RAPTOR/Ip.val','rts:Dia/RAPTOR/P_LH.val',...
-                'rts:Dia/RAPTOR/Phib.val','rts:Dia/RAPTOR/beta.val','rts:Dia/RAPTOR/conf_state.val', ...
-                'rts:Dia/RAPTOR/exitflag.val','rts:Dia/RAPTOR/gflag.val','rts:Dia/RAPTOR/it.val', ...
-                'rts:Dia/RAPTOR/li3.val','rts:Dia/RAPTOR/neflag.val','rts:Dia/RAPTOR/res.val', ...
-                'rts:Dia/RAPTOR/dtcomp.val','rts:Dia/RAPTOR/ECEmask.val','rts:Dia/RAPTOR/F.val', ...
-                'rts:Dia/RAPTOR/Vp.val','rts:Dia/RAPTOR/chie.val','rts:Dia/RAPTOR/dk_k.val', ...
-                'rts:Dia/RAPTOR/dpsi.val','rts:Dia/RAPTOR/dte.val','rts:Dia/RAPTOR/g1.val', ...
-                'rts:Dia/RAPTOR/g23or.val','rts:Dia/RAPTOR/g2.val','rts:Dia/RAPTOR/g3.val', ...
-                'rts:Dia/RAPTOR/iota.val','rts:Dia/RAPTOR/jbs.val','rts:Dia/RAPTOR/jec.val', ...
-                'rts:Dia/RAPTOR/jnb.val','rts:Dia/RAPTOR/jpar.val','rts:Dia/RAPTOR/ne.val', ...
-                'rts:Dia/RAPTOR/ni.val','rts:Dia/RAPTOR/p.val','rts:Dia/RAPTOR/paux.val', ...
-                'rts:Dia/RAPTOR/pbrem.val','rts:Dia/RAPTOR/pec.val','rts:Dia/RAPTOR/pei.val', ...
-                'rts:Dia/RAPTOR/pnbe.val','rts:Dia/RAPTOR/poh.val','rts:Dia/RAPTOR/prad.val', ...
-                'rts:Dia/RAPTOR/psi.val','rts:Dia/RAPTOR/q.val','rts:Dia/RAPTOR/rhotorECE.val', ...
-                'rts:Dia/RAPTOR/sdk_k.val','rts:Dia/RAPTOR/shear.val','rts:Dia/RAPTOR/signeo.val', ...
-                'rts:Dia/RAPTOR/sxk_k.val','rts:Dia/RAPTOR/te.val','rts:Dia/RAPTOR/ti.val', ...
-                'rts:Dia/RAPTOR/upl.val','rts:Dia/RAPTOR/xk_k.val','rts:Dia/RAPTOR/ze.val'};
-            
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = sources_avail;
-            elseif ~iscell(gdat_data.gdat_params.source)
-                if ischar(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
-                    if strcmp(gdat_data.gdat_params.source(1),'o'); gdat_data.gdat_params.source = 'observer'; end
-                    if strcmp(gdat_data.gdat_params.source(1),'p'); gdat_data.gdat_params.source = 'predictive'; end
-                    if ~any(strmatch(gdat_data.gdat_params.source,lower(sources_avail)))
-                        if (gdat_params.nverbose>=1)
-                            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
-                        end
-                        return
-                    else
-                        gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
-                    end
-                else
-                    if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
-                    return
-                end
-            else
-                for i=1:length(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
-                    if strcmp(gdat_data.gdat_params.source{i}(1),'o'); gdat_data.gdat_params.source{i} = 'observer'; end
-                    if strcmp(gdat_data.gdat_params.source{i}(1),'p'); gdat_data.gdat_params.source{i} = 'predictive'; end
-                    if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
-                        if gdat_data.gdat_params.nverbose>=1
-                            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
-                        end
-                    end
-                end
-            end
-            
-            for i=1:length(gdat_data.gdat_params.source)
-                it_def=0;
-                for j=1:length(rap_signals)
-                    gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
-                    gdat_params_eff.data_request = {'RAP',[rap_signals{j} '_' gdat_data.gdat_params.source{i}(1)],gdat_params_eff.exp_name};
-                    abcd = gdat_aug(gdat_data.shot,gdat_params_eff);
-                    gdat_data.(gdat_data.gdat_params.source{i}).(rap_signals{j}) = abcd;
-                    gdat_data.(gdat_data.gdat_params.source{i}).(rap_signals{j}).description = rap_desc_signals{j};
-                    if strcmp(rap_signals{j},'q') && ~isempty(abcd.data)
-                        % promote q at top level of gdat_data.(gdat_data.gdat_params.source{i})
-                        gdat_data.(gdat_data.gdat_params.source{i}).data = abcd.data;
-                        gdat_data.(gdat_data.gdat_params.source{i}).t = abcd.t;
-                        gdat_data.(gdat_data.gdat_params.source{i}).x = abcd.x;
-                        gdat_data.(gdat_data.gdat_params.source{i}).units = ['q RAPTOR_' gdat_data.gdat_params.source{i}(1:3) ' various rho'];
-                        gdat_data.(gdat_data.gdat_params.source{i}).dim = abcd.dim;
-                        gdat_data.(gdat_data.gdat_params.source{i}).dimunits = abcd.dimunits;
-                        gdat_data.(gdat_data.gdat_params.source{i}).dimunits{1} = 'various rhotor';
-                        gdat_data.(gdat_data.gdat_params.source{i}).data_fullpath = abcd.data_fullpath;
-                        gdat_data.(gdat_data.gdat_params.source{i}).label = ['q RAPTOR_' gdat_data.gdat_params.source{i}(1:3) ' various rho'];
-                    end
-                end
-            end
-            %
-            % promote somethin at top level of gdat_data?
-            %
-            gdat_data.data_fullpath = {'RAP','signals_o in observer _p in predictive, one signal(q) copied at top',gdat_data.gdat_params.exp_name};
-            % promote predictive promoted signal if non-empty, otherwise observer one
-            if ~isempty(gdat_data.predictive.data)
-                source_promoted = 'predictive';
-            else
-                source_promoted = 'observer';
-            end
-            gdat_data.data = gdat_data.(source_promoted).data;
-            gdat_data.x = gdat_data.(source_promoted).x;
-            gdat_data.t = gdat_data.(source_promoted).t;
-            gdat_data.units = gdat_data.(source_promoted).units;
-            gdat_data.dim = gdat_data.(source_promoted).dim;
-            gdat_data.dimunits = gdat_data.(source_promoted).dimunits;
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'rhotor', 'rhotor_edge', 'rhotor_norm', 'rhovol', 'volume_rho'}
-            if strcmp(upper(gdat_data.gdat_params.equil),'FPG')
-                gdat_params_prev = gdat_data.gdat_params; gdat_params_eff = gdat_params_prev;
-                gdat_params_eff.data_request = [{'FPG'},{'Vol'},{'AUGD'}];
-                gdat_data = gdat_aug(gdat_data.shot,gdat_params_eff);
-                gdat_data.gdat_params = gdat_params_prev;
-                gdat_data.label = 'Vol';
-                gdat_data.data_fullpath = [gdat_data.data_fullpath ' yields only edge Volume from FPG/Vol'];
-                return
-            end
-            [gdat_data,exp_name_eff,DIAG,NTIME_Lpf,NTIME,Lpf1_t,Lpf_SOL] = get_EQ_params(gdat_data);
-            % since Lpf depends on time, need to load all first and then loop over time for easier mapping
-            [phi_tree,e]=rdaAUG_eff(shot,DIAG,'TFLx',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            ndimrho = size(phi_tree.data,2);
-            if ndimrho==NTIME_Lpf
-                % data seems to be transposed
-                ndimrho = size(phi_tree.data,1);
-                itotransposeback = 1; % seems x,time inverted so transpose and exchange .x and .t
-            else
-                itotransposeback = 0;
-            end
-            phi_tree=adapt_rda(phi_tree,NTIME,ndimrho,itotransposeback);
-            ijnan=find(isnan(phi_tree.value));
-            phi_tree.value(ijnan)=0;
-            [Vol,e]=rdaAUG_eff(shot,DIAG,'Vol',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            Vol=adapt_rda(Vol,NTIME,2*ndimrho,itotransposeback);
-            [psi_tree,e]=rdaAUG_eff(shot,DIAG,'PFL',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-            psi_tree=adapt_rda(psi_tree,NTIME,ndimrho,itotransposeback);
-            %
-            switch data_request_eff
-                case {'volume_rho', 'rhovol'}
-                    for it=1:NTIME
-                        Lpf1 = Lpf1_t(it);
-                        psi_it=psi_tree.value(it,Lpf1:-1:1)';
-                        psi_axis(it)= psi_it(1);
-                        psi_lcfs(it)= psi_it(end);
-                        gdat_data.x(:,it) = sqrt(abs((psi_it-psi_axis(it)) ./(psi_lcfs(it)-psi_axis(it))));
-                        gdat_data.vol(:,it)=Vol.value(it,2*Lpf1-1:-2:1)';
-                        % gdat_data.dvoldpsi(:,it)=Vol.value(it,2*Lpf1:-2:2)'; % 2nd index are dV/dpsi
-                        gdat_data.rhovolnorm(:,it) = sqrt(abs(gdat_data.vol(:,it) ./ gdat_data.vol(end,it)));
-                    end
-                    gdat_data.dim{1} = gdat_data.x;
-                    gdat_data.dim{2} = gdat_data.t;
-                    gdat_data.dimunits{1} = 'rhopolnorm';
-                    gdat_data.dimunits{2} = 'time [s]';
-                    gdat_data.volume_edge = gdat_data.vol(end,:);
-                    if strcmp(data_request_eff,'volume_rho')
-                        gdat_data.data = gdat_data.vol;
-                        gdat_data.units = Vol.units;
-                    else strcmp(data_request_eff,'rhovol');
-                        gdat_data.data = gdat_data.rhovolnorm;
-                        gdat_data.units = ' ';
-                    end
-                case {'rhotor', 'rhotor_edge', 'rhotor_norm'}
-                    b0=gdat_aug(shot,'b0');
-                    gdat_data.b0 = interpos(b0.t,b0.data,gdat_data.t,-1);
-                    for it=1:NTIME
-                        Lpf1 = Lpf1_t(it);
-                        gdat_data.phi(:,it) = phi_tree.value(it,Lpf1:-1:1)';
-                        gdat_data.rhotornorm(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.phi(end,it)));
-                        gdat_data.rhotor(:,it) = sqrt(abs(gdat_data.phi(:,it) ./ gdat_data.b0(it) ./ pi));
-                        psi_it=psi_tree.value(it,Lpf1:-1:1)';
-                        psi_axis(it)= psi_it(1);
-                        psi_lcfs(it)= psi_it(end);
-                        gdat_data.x(:,it) = sqrt(abs((psi_it-psi_axis(it)) ./(psi_lcfs(it)-psi_axis(it))));
-                    end
-                    % always provide rhotor_edge so field always exists
-                    gdat_data.rhotor_edge = gdat_data.rhotor(end,:);
-                    if strcmp(data_request_eff,'rhotor')
-                        gdat_data.data = gdat_data.rhotor;
-                        gdat_data.units = 'm';
-                        gdat_data.dim{1} = gdat_data.x;
-                        gdat_data.dim{2} = gdat_data.t;
-                        gdat_data.dimunits{1} = 'rhopolnorm';
-                        gdat_data.dimunits{2} = 'time [s]';
-                    elseif strcmp(data_request_eff,'rhotor_edge')
-                        gdat_data.data = gdat_data.rhotor(end,:);
-                        gdat_data.units = 'm';
-                        gdat_data.dim{1} = gdat_data.t;
-                        gdat_data.dimunits{1} = 'time [s]';
-                    elseif strcmp(data_request_eff,'rhotor_norm')
-                        gdat_data.data = gdat_data.rhotornorm;
-                        gdat_data.units = ' ';
-                        gdat_data.dim{1} = gdat_data.x;
-                        gdat_data.dim{2} = gdat_data.t;
-                        gdat_data.dimunits{1} = 'rhopolnorm';
-                        gdat_data.dimunits{2} = 'time [s]';
-                    end
-            end
-            gdat_data.data_fullpath = [DIAG '/PFL extract in .data: ' data_request_eff];
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'sxr'}
-            % sxr from B by default or else if 'source','else' is provided
-            if ~isfield(gdat_data.gdat_params,'freq')|| isempty(gdat_data.gdat_params.freq)
-                gdat_data.gdat_params.freq = 'slow';
-            end
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = 'G';
-            elseif length(gdat_data.gdat_params.source)>1 || ...
-                    upper(gdat_data.gdat_params.source)<'F' || upper(gdat_data.gdat_params.source)>'M'
-                if gdat_data.gdat_params.nverbose>=1
-                    warning(['source = ' gdat_data.gdat_params.source ' not expected with data_request= ' data_request_eff])
-                end
-                return
-            end
-            dim1_len = 'from_chord_nb'; % thus up to max(chords_ok_nb)
-            if ~isfield(gdat_data.gdat_params,'camera') || isempty(gdat_data.gdat_params.camera)
-                gdat_data.gdat_params.camera = [];
-            elseif ischar(gdat_data.gdat_params.camera) && strcmp(gdat_data.gdat_params.camera,'central')
-                gdat_data.gdat_params.source = 'J';
-                gdat_data.gdat_params.camera = 49;
-            elseif isnumeric(gdat_data.gdat_params.camera)
-                % ok keep the array, but first dim to contain just the related chords
-                dim1_len='nb_of_chords';
-            else
-                if gdat_data.gdat_params.nverbose>=1
-                    warning(['camera = ' gdat_data.gdat_params.camera ' not expected with data_request= ' data_request_eff])
-                end
-                return
-            end
-            if length(gdat_data.gdat_params.camera)==1; dim1_len='nb_of_chords'; end
-            gdat_data.gdat_params.source = upper(gdat_data.gdat_params.source);
-            %
-            if ~isfield(gdat_data.gdat_params,'time_interval')
-                gdat_data.gdat_params.time_interval = [];
-            end
-            [aa,bb]=unix(['ssh ' '-o "StrictHostKeyChecking no" sxaug20.aug.ipp.mpg.de WhichSX ' num2str(shot) ' ' ...
-                upper(gdat_data.gdat_params.source)]);
-            chords_ok_diags=regexpi(bb,'(?<chord>[A-Z]_[0-9]+)\saddress:\s[0-9]+\sDiag:\s(?<diag>[A-Z]+)','names');
-            if isempty(chords_ok_diags)
-                chords_ok_nb = [];
-            else
-                for i=1:length(chords_ok_diags)
-                    chords_ok_nb(i) =  str2num(chords_ok_diags(i).chord(3:end));
-                end
-            end
-            if isempty(gdat_data.gdat_params.camera);
-                gdat_data.gdat_params.camera = chords_ok_nb;
-            else
-                for i=1:length(gdat_data.gdat_params.camera)
-                    ij=find(chords_ok_nb==gdat_data.gdat_params.camera(i));
-                    if ~isempty(ij)
-                        chords_ok_diags_tmp(i) = chords_ok_diags(ij);
-                    else
-                        % chord not in use
-                        chords_ok_diags_tmp(i).chord = [];
-                        chords_ok_diags_tmp(i).diag = [];
-                    end
-                end
-                chords_ok_diags = chords_ok_diags_tmp;
-                chords_ok_nb = gdat_data.gdat_params.camera;
-            end
-            exp_name_eff = 'AUGD';
-            icount = 0;
-            nnth = 1;
-            if isnumeric(gdat_data.gdat_params.freq) && gdat_data.gdat_params.freq>1;
-                nnth = floor(gdat_data.gdat_params.freq+0.5);
-                gdat_data.gdat_params.freq = nnth;
-            end
-            for i=1:length(gdat_data.gdat_params.camera)
-                if ischar(gdat_data.gdat_params.freq) && strcmp(gdat_data.gdat_params.freq,'slow'); chords_ok_diags(i).diag = 'SSX'; end
-                if ~isempty(chords_ok_diags(i).diag) && ~isempty(chords_ok_diags(i).chord)
-                    [a,e]=rdaAUG_eff(shot,chords_ok_diags(i).diag,chords_ok_diags(i).chord,exp_name_eff, ...
-                        gdat_data.gdat_params.time_interval,gdat_data.gdat_params.extra_arg_sf2sig);
-                else
-                    a.data = [];
-                    a.t = [];
-                end
-                if ~isempty(a.data)
-                    icount = icount + 1;
-                    if icount == 1
-                        % first time has data
-                        % assume all chords have same time base even if from different shotfile
-                        % time missing one point
-                        if length(a.value) == length(a.t)+1
-                            a.t=linspace(a.range(1),a.range(2),length(a.value));
-                            a_time.index(2) = length(a.value);
-                        end
-                        gdat_data.t = a.t(1:nnth:end);
-                        gdat_data.units = a.units;
-                        if strcmp(dim1_len,'from_chord_nb')
-                            gdat_data.data = NaN*ones(max(chords_ok_nb),length(gdat_data.t));
-                            gdat_data.dim{1} = [1:max(chords_ok_nb)]; % simpler to have index corresponding to chord number, except for central
-                        else
-                            gdat_data.data = NaN*ones(length(chords_ok_nb),length(gdat_data.t));
-                            gdat_data.dim{1} = chords_ok_nb;
-                        end
-                        gdat_data.dim{2} = gdat_data.t;
-                        gdat_data.dimunits = [{'chord nb'}; {'s'}];
-                        gdat_data.data_fullpath = ['sxr from source=''' gdat_data.gdat_params.source ' uses shotfiles SX' ...
-                            setdiff(unique(strvcat(chords_ok_diags(:).diag)),'SX')'];
-                        gdat_data.label = ['SXR/' upper(gdat_data.gdat_params.source)];
-                    end
-                    try
-                        if strcmp(dim1_len,'from_chord_nb')
-                            gdat_data.data(chords_ok_nb(i),:) = a.data(1:nnth:end);
-                        else
-                            gdat_data.data(i,:) = a.data(1:nnth:end);
-                        end
-                    catch
-                        if (gdat_params.nverbose>=1); disp(['problem with ' chords_ok_diags(i).diag ' ; ' chords_ok_diags(i).chord]); end
-                        
-                    end
-                else
-                    % add fields not yet defined in case all cases have empty data
-                end
-            end
-            gdat_data.chords = chords_ok_nb;
-            if length(gdat_data.dim)>=1
-                gdat_data.x = gdat_data.dim{1};
-            end
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'transp'}
-            extra_arg_sf2sig_eff_string = '';
-            if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
-                extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
-            end
-            % most of the times the exp for the shotfile should be provided
-            shotfile_exp_eff = gdat_params.exp_name;
-            diagname='TRA';
-            gdat_params.equil = 'TRE';
-            gdat_data.gdat_params = gdat_params;
-            TRANSP_signals;
-            for i=1:size(transp_sig,1)
-                if strcmp(lower(transp_sig{i,2}),'signal') || strcmp(lower(transp_sig{i,2}),'signal-group')
-                    try
-                        abcd = rdaAUG_eff(shot,diagname,transp_sig{i,1},shotfile_exp_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
-                        eval(['gdat_data.' transp_sig{i,1} '= abcd;']);
-                        % eval(['[gdat_data.' transp_sig{i,1} ',e]=rdaAUG_eff(shot,diagname,''' transp_sig{i,1} ''',shotfile_exp_eff);']);
-                    catch
-                        eval(['gdat_data.' transp_sig{i,1} '=[];']);
-                    end
-                elseif strcmp(lower(transp_sig{i,2}),'area-base')
-                    clear adata_area
-                    try
-                        eval(['[adata_area]=sf2ab(diagname,shot,transp_sig{i,1},''-exp'',shotfile_exp_eff' extra_arg_sf2sig_eff_string  ');']);
-                        adata_area.data = adata_area.value{1};
-                    catch
-                        adata_area.value = cell(0);
-                    end
-                    eval(['gdat_data.' transp_sig{i,1} '=adata_area;']);
-                elseif strcmp(lower(transp_sig{i,2}),'time-base')
-                    clear adata_time
-                    try
-                        eval(['[adata_time]=sf2tb(diagname,shot,transp_sig{i,1},''-exp'',shotfile_exp_eff,shotfile_exp_eff' extra_arg_sf2sig_eff_string ');']);
-                        adata_time.data = adata_time.value;
-                    catch
-                        adata_time.value = [];
-                    end
-                    eval(['gdat_data.' transp_sig{i,1} '=adata_time;']);
-                end
-            end
-            % copy TIME to .t
-            if isfield(gdat_data,'TIME') && isfield(gdat_data.TIME,'value') && ~isempty(gdat_data.TIME.value)
-                gdat_data.t = gdat_data.TIME.value;
-                gdat_data.dim{1} = gdat_data.t;
-                gdat_data.dimunits{1} = gdat_data.TIME.unit;
-            end
-            
-            % add equilibrium
-            params_eff = gdat_params;
-            params_eff.data_request = 'equil';
-            gdat_data.equil = gdat_aug(shot,params_eff);
-            
-            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-        case {'zeff', 'z_eff'}
-            zeff_max_in_main = 10.;
-            zeff_min_in_main = 0.0;
-            sources_avail = {'ascii','idz'};
-            fields_to_copy = {'data','units','dim','dimunits','t','x','data_fullpath','label','help'};
-            for i=1:length(sources_avail)
-                for j=1:length(fields_to_copy)
-                    gdat_data.(sources_avail{i}).(fields_to_copy{j}) = [];
-                end
-            end
-            if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
-                gdat_data.gdat_params.source = sources_avail;
-            elseif ~iscell(gdat_data.gdat_params.source)
-                if ischar(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
-                    if ~any(strmatch(gdat_data.gdat_params.source,sources_avail))
-                        if (gdat_params.nverbose>=1)
-                            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
-                        end
-                        return
-                    else
-                        gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
-                    end
-                else
-                    if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
-                    return
-                end
-            else
-                for i=1:length(gdat_data.gdat_params.source)
-                    gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
-                    if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
-                        if gdat_data.gdat_params.nverbose>=1
-                            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
-                        end
-                    end
-                end
-            end
-            %
-            % start with ascii then IDZ, each time copy to main, so if IDZ is present it supersedes
-            %
-            if any(strmatch('ascii',gdat_data.gdat_params.source))
-                % try ascii file from Rachael Mc Dermot in folder /afs/ipp-garching.mpg.de/home/r/rmcdermo/idl/Zeff/ascii
-                % if not present ask Rachael
-                dir_ascii = '/afs/ipp-garching.mpg.de/home/r/rmcdermo/idl/Zeff/ascii';
-                [a,b] = unix(['ls ' dir_ascii '/*' num2str(gdat_data.shot) '*.txt']);
-                if a==0
-                    ij1=findstr(b,'/afs');
-                    ij2=findstr(b,'.txt');
-                    file_zeff = b(ij1:ij2+3);
-                    aaa=textread(file_zeff,'%f');
-                    if mod(numel(aaa),2)~=0
-                        error(['problems with odd nb of points in file: ' file_zeff]);
-                    else
-                        nbpoints=length(aaa)/2;
-                    end
-                    zeff.t = aaa(1:nbpoints);
-                    zeff.data = aaa(nbpoints+1:end);
-                    gdat_data.ascii.data = min(max(zeff.data,zeff_min_in_main),zeff_max_in_main);
-                    gdat_data.ascii.units = '';
-                    gdat_data.ascii.t = zeff.t;
-                    gdat_data.ascii.dim{1} = gdat_data.ascii.t;
-                    gdat_data.ascii.dimunits{1} = 'time [s]';
-                    gdat_data.ascii.data_fullpath = [' from file: ' file_zeff];
-                    [a1,a2,a3]=fileparts(file_zeff);
-                    gdat_data.ascii.label = [a2 a3];
-                    for i=1:length(fields_to_copy)
-                        if isfield(gdat_data.ascii,fields_to_copy{i})
-                            gdat_data.(fields_to_copy{i}) = gdat_data.ascii.(fields_to_copy{i});
-                        end
-                    end
-                else
-                    if gdat_data.gdat_params.nverbose >= 3
-                        disp(['No ascii file for zeff in folder: ' dir_ascii '; ask Rachael if need be'])
-                    end
-                end
-            end
-            %
-            % IDZ
-            %
-            if any(strmatch('idz',gdat_data.gdat_params.source))
-                gdat_data.fit.full_path = 'PROFILES from IDZ: Zeff, unc, lower, upper';
-                params_eff = gdat_params;
-                params_eff.data_request={'IDZ','Zeff', params_eff.exp_name};
-                try
-                    [gdat_data_idz_zeff,params_kin,error_status]=gdat_aug(shot,params_eff);
-                    if ~isempty(gdat_data_idz_zeff.data)
-                        gdat_data.idz.data = gdat_data_idz_zeff.data;
-                        gdat_data.idz.units = '';
-                        gdat_data.idz.t = gdat_data_idz_zeff.t;
-                        gdat_data.idz.x = gdat_data_idz_zeff.x;
-                        gdat_data.idz.dim = gdat_data_idz_zeff.dim;
-                        gdat_data.idz.dimunits = gdat_data_idz_zeff.dimunits;
-                        gdat_data.idz.dimunits{1} = 'rhopol';
-                        gdat_data.idz.data_fullpath = gdat_data_idz_zeff.data_fullpath;
-                        gdat_data.idz.label = sprintf('%s/',gdat_data_idz_zeff.data_fullpath{:});
-                        gdat_data.idz.label = ['mean(' gdat_data.idz.label(1:end-1) ',1)'];
-                        fields_to_not_copy = {'data','dim','x','dimunits'}; % only cst value at this stage to main data, should heva zeff_rho to have profile
-                        for i=1:length(fields_to_copy)
-                            if isfield(gdat_data.idz,fields_to_copy{i}) && ~any(strmatch(fields_to_copy{i},fields_to_not_copy))
-                                gdat_data.(fields_to_copy{i}) = gdat_data.idz.(fields_to_copy{i});
-                            end
-                        end
-                        gdat_data.data = min(max(mean(gdat_data_idz_zeff.data,1)',zeff_min_in_main),zeff_max_in_main);
-                        gdat_data.t = gdat_data_idz_zeff.t';
-                        gdat_data.dim{1} = gdat_data.t;
-                        gdat_data.dimunits{1} = gdat_data_idz_zeff.dimunits{2};
-                    else
-                        if gdat_data.gdat_params.nverbose >= 3
-                            disp(['No data in shotfile IDZ ; ask Rainer if need be'])
-                        end
-                    end
-                catch ME
-                    if gdat_data.gdat_params.nverbose >= 3
-                        disp(['No shot file IDZ ; ask Rainer if need be'])
-                    end
-                end
-            end
-            %
-        otherwise
-            if (gdat_params.nverbose>=1); warning(['switchcase= ' data_request_eff ' not known in gdat_aug']); end
-            error_status=901;
-            return
+   case {'zeff', 'z_eff'}
+    zeff_max_in_main = 10.;
+    zeff_min_in_main = 0.0;
+    sources_avail = {'ascii','idz'};
+    fields_to_copy = {'data','units','dim','dimunits','t','x','data_fullpath','label','help'};
+    for i=1:length(sources_avail)
+      for j=1:length(fields_to_copy)
+        gdat_data.(sources_avail{i}).(fields_to_copy{j}) = [];
+      end
     end
-    
-else
-    if (gdat_params.nverbose>=1); warning(['AUG method=' mapping_for_AUG.method ' not known yet, contact Olivier.Sauter@epfl.ch']); end
-    error_status=602;
+    if ~isfield(gdat_data.gdat_params,'source') || isempty(gdat_data.gdat_params.source)
+      gdat_data.gdat_params.source = sources_avail;
+    elseif ~iscell(gdat_data.gdat_params.source)
+      if ischar(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source = lower(gdat_data.gdat_params.source);
+        if ~any(strmatch(gdat_data.gdat_params.source,sources_avail))
+          if (gdat_params.nverbose>=1)
+            warning(['source= ' gdat_data.gdat_params.source ' is not part of the available sources: ' sprintf('''%s'' ',sources_avail{:})]);
+          end
+          return
+        else
+          gdat_data.gdat_params.source = {gdat_data.gdat_params.source};
+        end
+      else
+        if (gdat_params.nverbose>=1); warning([' source parameter not compatible with: ' sprintf('''%s'' ',sources_avail{:})]); end
+        return
+      end
+    else
+      for i=1:length(gdat_data.gdat_params.source)
+        gdat_data.gdat_params.source{i} = lower(gdat_data.gdat_params.source{i});
+        if ~any(strmatch(gdat_data.gdat_params.source{i},lower(sources_avail)))
+          if gdat_data.gdat_params.nverbose>=1
+            warning(['source = ' gdat_data.gdat_params.source{i} ' not expected with data_request= ' data_request_eff])
+          end
+        end
+      end
+    end
+    %
+    % start with ascii then IDZ, each time copy to main, so if IDZ is present it supersedes
+    %
+    if any(strmatch('ascii',gdat_data.gdat_params.source))
+      % try ascii file from Rachael Mc Dermot in folder /afs/ipp-garching.mpg.de/home/r/rmcdermo/idl/Zeff/ascii
+      % if not present ask Rachael
+      dir_ascii = '/afs/ipp-garching.mpg.de/home/r/rmcdermo/idl/Zeff/ascii';
+      [a,b] = unix(['ls ' dir_ascii '/*' num2str(gdat_data.shot) '*.txt']);
+      if a==0
+        ij1=findstr(b,'/afs');
+        ij2=findstr(b,'.txt');
+        file_zeff = b(ij1:ij2+3);
+        aaa=textread(file_zeff,'%f');
+        if mod(numel(aaa),2)~=0
+          error(['problems with odd nb of points in file: ' file_zeff]);
+        else
+          nbpoints=length(aaa)/2;
+        end
+        zeff.t = aaa(1:nbpoints);
+        zeff.data = aaa(nbpoints+1:end);
+        gdat_data.ascii.data = min(max(zeff.data,zeff_min_in_main),zeff_max_in_main);
+        gdat_data.ascii.units = '';
+        gdat_data.ascii.t = zeff.t;
+        gdat_data.ascii.dim{1} = gdat_data.ascii.t;
+        gdat_data.ascii.dimunits{1} = 'time [s]';
+        gdat_data.ascii.data_fullpath = [' from file: ' file_zeff];
+        [a1,a2,a3]=fileparts(file_zeff);
+        gdat_data.ascii.label = [a2 a3];
+        for i=1:length(fields_to_copy)
+          if isfield(gdat_data.ascii,fields_to_copy{i})
+            gdat_data.(fields_to_copy{i}) = gdat_data.ascii.(fields_to_copy{i});
+          end
+        end
+      else
+        if gdat_data.gdat_params.nverbose >= 3
+          disp(['No ascii file for zeff in folder: ' dir_ascii '; ask Rachael if need be'])
+        end
+      end
+    end
+    %
+    % IDZ
+    %
+    if any(strmatch('idz',gdat_data.gdat_params.source))
+      gdat_data.fit.full_path = 'PROFILES from IDZ: Zeff, unc, lower, upper';
+      params_eff = gdat_params;
+      params_eff.data_request={'IDZ','Zeff', params_eff.exp_name};
+      try
+        [gdat_data_idz_zeff,params_kin,error_status]=gdat_aug(shot,params_eff);
+        if ~isempty(gdat_data_idz_zeff.data)
+          gdat_data.idz.data = gdat_data_idz_zeff.data;
+          gdat_data.idz.units = '';
+          gdat_data.idz.t = gdat_data_idz_zeff.t;
+          gdat_data.idz.x = gdat_data_idz_zeff.x;
+          gdat_data.idz.dim = gdat_data_idz_zeff.dim;
+          gdat_data.idz.dimunits = gdat_data_idz_zeff.dimunits;
+          gdat_data.idz.dimunits{1} = 'rhopol';
+          gdat_data.idz.data_fullpath = gdat_data_idz_zeff.data_fullpath;
+          gdat_data.idz.label = sprintf('%s/',gdat_data_idz_zeff.data_fullpath{:});
+          gdat_data.idz.label = ['mean(' gdat_data.idz.label(1:end-1) ',1)'];
+          fields_to_not_copy = {'data','dim','x','dimunits'}; % only cst value at this stage to main data, should heva zeff_rho to have profile
+          for i=1:length(fields_to_copy)
+            if isfield(gdat_data.idz,fields_to_copy{i}) && ~any(strmatch(fields_to_copy{i},fields_to_not_copy))
+              gdat_data.(fields_to_copy{i}) = gdat_data.idz.(fields_to_copy{i});
+            end
+          end
+          gdat_data.data = min(max(mean(gdat_data_idz_zeff.data,1)',zeff_min_in_main),zeff_max_in_main);
+          gdat_data.t = gdat_data_idz_zeff.t';
+          gdat_data.dim{1} = gdat_data.t;
+          gdat_data.dimunits{1} = gdat_data_idz_zeff.dimunits{2};
+        else
+          if gdat_data.gdat_params.nverbose >= 3
+            disp(['No data in shotfile IDZ ; ask Rainer if need be'])
+          end
+        end
+      catch ME
+        if gdat_data.gdat_params.nverbose >= 3
+          disp(['No shot file IDZ ; ask Rainer if need be'])
+        end
+      end
+    end
+    %
+   otherwise
+    if (gdat_params.nverbose>=1); warning(['switchcase= ' data_request_eff ' not known in gdat_aug']); end
+    error_status=901;
     return
+  end
+
+else
+  if (gdat_params.nverbose>=1); warning(['AUG method=' mapping_for_AUG.method ' not known yet, contact Olivier.Sauter@epfl.ch']); end
+  error_status=602;
+  return
 end
 
 gdat_data.gdat_params.help = aug_help_parameters(fieldnames(gdat_data.gdat_params));
@@ -2928,7 +2928,7 @@ N_Zmesh = [];
 
 extra_arg_sf2sig_eff_string = '';
 if ~strcmp(gdat_data.gdat_params.extra_arg_sf2sig,'[]')
-    extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
+  extra_arg_sf2sig_eff_string = [',' gdat_data.gdat_params.extra_arg_sf2sig];
 end
 shot=gdat_data.shot;
 exp_name_eff = gdat_data.gdat_params.exp_name;
@@ -2936,43 +2936,43 @@ gdat_data.gdat_params.equil = upper(gdat_data.gdat_params.equil);
 DIAG = gdat_data.gdat_params.equil; % 'EQI' by default at this stage, should become EQH?
 % eval(['M_Rmesh_par = sf2par(DIAG,shot,''M'',''PARMV''' extra_arg_sf2sig_eff_string ');']);
 [M_Rmesh_par,e]=rdaAUG_eff(shot,DIAG,'PARMV',gdat_data.gdat_params.exp_name,[], ...
-    extra_arg_sf2sig_eff_string,['param:' 'M']);
+          extra_arg_sf2sig_eff_string,['param:' 'M']);
 M_Rmesh = M_Rmesh_par.value + 1; % nb of points
 % eval(['N_Zmesh_par = sf2par(DIAG,shot,''N'',''PARMV''' extra_arg_sf2sig_eff_string ');']);
 [N_Zmesh_par,e]=rdaAUG_eff(shot,DIAG,'PARMV',gdat_data.gdat_params.exp_name,[], ...
-    extra_arg_sf2sig_eff_string,['param:' 'N']);
+          extra_arg_sf2sig_eff_string,['param:' 'N']);
 N_Zmesh = N_Zmesh_par.value + 1; % nb of points
 % eval(['NTIME_par = sf2par(DIAG,shot,''NTIME'',''PARMV''' extra_arg_sf2sig_eff_string ');']);
 [NTIME_par,e]=rdaAUG_eff(shot,DIAG,'PARMV',gdat_data.gdat_params.exp_name,[], ...
-    extra_arg_sf2sig_eff_string,['param:' 'NTIME']);
+          extra_arg_sf2sig_eff_string,['param:' 'NTIME']);
 NTIME = NTIME_par.value; % nb of points
 Lpf_par = rdaAUG_eff(shot,DIAG,'Lpf',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);
 % since June, nb of time points in EQ results is not consistent with NTIME and time
 % It seems the first NTIME points are correct, so use this explicitely
 NTIME_Lpf = length(Lpf_par.value);
 if ~isempty(NTIME) && ~isempty(NTIME_Lpf) && isnumeric(NTIME) && isnumeric(NTIME_Lpf) && (NTIME < NTIME_Lpf)
-    if gdat_data.gdat_params.nverbose>=3; disp('WARNING: nb of times points smaller then equil results, use first NTIME points'); end
+  if gdat_data.gdat_params.nverbose>=3; disp('WARNING: nb of times points smaller then equil results, use first NTIME points'); end
 elseif ischar(NTIME) || ischar(NTIME_Lpf) || (NTIME > NTIME_Lpf)
-    if gdat_data.gdat_params.nverbose >= 1
-        if ischar(NTIME) || ischar(NTIME_Lpf)
-            disp(['probably no data, NTIME_Lpf = ' NTIME_Lpf])
-        else
-            disp('ERROR: nb of times points LARGER then equil results')
-            disp('this is unexpected, so stop there and ask Olivier.Sauter@epfl.ch')
-        end
+  if gdat_data.gdat_params.nverbose >= 1
+    if ischar(NTIME) || ischar(NTIME_Lpf)
+      disp(['probably no data, NTIME_Lpf = ' NTIME_Lpf])
+    else
+      disp('ERROR: nb of times points LARGER then equil results')
+      disp('this is unexpected, so stop there and ask Olivier.Sauter@epfl.ch')
     end
-    return
+  end
+  return
 end
 i_ref = 100000;
 Lpf_tot = Lpf_par.value(1:NTIME); % nb of points: i_ref*nb_SOL points + nb_core
 Lpf_SOL = fix(Lpf_tot/i_ref);
 Lpf1_t = mod(Lpf_tot,i_ref)+1; % nb of Lpf points
 if max(Lpf1_t) > 3000
-    % most probably i_ref wrong
-    i_ref = 10^fix(log10(max(Lpf1_t)));
-    Lpf_tot = Lpf_par.value(1:NTIME); % nb of points: i_ref*nb_SOL points + nb_core
-    Lpf_SOL = fix(Lpf_tot/i_ref);
-    Lpf1_t = mod(Lpf_tot,i_ref)+1; % nb of Lpf points
+  % most probably i_ref wrong
+  i_ref = 10^fix(log10(max(Lpf1_t)));
+  Lpf_tot = Lpf_par.value(1:NTIME); % nb of points: i_ref*nb_SOL points + nb_core
+  Lpf_SOL = fix(Lpf_tot/i_ref);
+  Lpf1_t = mod(Lpf_tot,i_ref)+1; % nb of Lpf points
 end
 
 [equil_time,e]=rdaAUG_eff(shot,DIAG,'time',exp_name_eff,[],gdat_data.gdat_params.extra_arg_sf2sig);