function[r] = do_all_time_lev(n,t0,int,duration,N,srate,rat,order,time,MC_L,MC_F,sample_rate)
%do_all_time explores how filter performance changes with time, sample rate,
%and order of filter. Outputs data,noise estimate, structure of max
%rms error and other info. It uses get_data, miso_filter_lev, and miso_filter_int and retrives
%MC_Ldata or MC_Fdata for multiple times, calculates a miso_filter for initial-time data
%file, applies filter to the other data files, and keeps track of the...
%max(rms(residual)) for each filter. n+1 is number of data files. int is time interval between
%data files, t0 is start time, duration is duration of each data file, srate
%is the sample rate for which filter is calculated, n_N is number of orders
%of the filter you want the program to calculate,int_N is interval by which N
%is varied, n_N is number of srates you want the program to calculate filters
%for, srate will be varied as sample_rate_temp=2^(6+j*int_srate) where j-integer,
%rat is the fraction of the initial data file which is used to calculate
%filter. Maybe let n=6 because I not sure I haven't figured out how to fix miso_filter_int to
%work for variable n. You have the option of varying the order, the time, and
%srate by typing 1 or 0 for those inputs. 

%function[r] = do_all_time_lev(n,t0,int,duration,n_N,int_N,n_srate,int_srate,rat,MC_L,MC_F)


time=1
      
if time==1
%getting data for each time and storing in vector z
 for ii = 0:n
   d_t = -ii*int;
   if MC_L==1
     z_temp = get_z_data(t0,d_t,duration);
   end
   if MC_F==1
     z_temp = get_mic_data(t0,d_t,duration);
   end
   if ii == 0
     z = z_temp;
   else
     z = [z ; z_temp];
   end
   clear d_t z_temp;
 end
else
  z=get_mic_data(t0,0,duration);
end

%calculate miso_filter based on initial data file 
%calculating filters for case of not varying order and for case of varying order
if order+sample_rate==0
  w = miso_filter(N,srate,rat,z(1,:));
%applying filter to data files at all the other times
  s = miso_filter_int(w,z(2:n+1,:));
%calculating rms of error=singal-est_signal for each file and creating
%rms vector and time vector to graph  
  x = 0;
  y = 0;
%looping over various times
  for gg=1:n+1
    x_temp = s.t(1,gg);
    x = [x,x_temp];
    y_temp = max(rms(s.f(:,gg),s.perr(:,gg)));
    y = [y, y_temp];
    clear x_temp y_temp
  end
  clear gg 
%getting rid of zeroes in x and y row vectors
  x = x(2:end)
  y = y(2:end)
%graphing rms of error vs time
  plot(x,y);
  xlabel('time(gps)')
  ylabel('cts/rHz')
  title('filter performance over time')
  legend('rms of cost function') 
  B=struct('x_s',x,'y_s',y,'s_s',srate,'N',N)
  r=struct('z',z,'B',B,'N_vector',N) 
%_______________________________ 
elseif sample_rate==0
 %looping over various orders of filter
  for kk=0:20
   % N_temp=2^(8+kk);
    N_temp=floor(2^(8+(kk/4)))
    w_temp = miso_filter_lev(N_temp,srate,rat,z(1,:));
%applying filter to data files at all the other times
    s_temp = miso_filter_int(w_temp,z(2:n+1,:));
%calculating rms of error=singal-est_signal for each file and creating
%rms vector and time vector to graph
    x = 0;
    y = 0;
%looping over various times
    for gg=1:n+1
      x_temp = s_temp.t(1,gg);
      x = [x,x_temp];
      y_temp = max(rms(s_temp.f(:,gg),s_temp.perr(:,gg)));
      y = [y, y_temp];
      clear x_temp y_temp
    end
    clear gg
%getting rid of zeroes in x and y row vectors
    x = x(2:end);
    y = y(2:end);
%storing x and y row vectors as rows in matrices x_n, y_n. Also creating row
%vector for corresponding N's.
    if kk==0
      x_n = x
      y_n = y
      N_n = N_temp
    else
      x_n = [x_n;x];
      y_n = [y_n;y];
      N_n = [N_n;N_temp]
    end
%clearing variables before looping again
    clear N_temp x y w_temp s_temp 
    B=struct('x_n',x_n,'y_n',y_n,'s',srate,'N_n',N_n)
    r=struct('z',z,'B',B,'N_vector',N_n)
  end
%____________________________
elseif order==0
 %looping over various sample rates for filter
  for jj=0:3
    sample_rate_temp=2^(6+jj);
    w_temp = miso_filter_lev(N,sample_rate_temp,rat,z(1,:));
%applying filter to data files at all the other times
    s_temp = miso_filter_int(w_temp,z(2:n+1,:));
%calculating rms of error=singal-est_signal for each file and creating
%rms vector and time vector to graph
    x = 0;
    y = 0;
%looping over various times
    for gg=1:n+1
      x_temp = s_temp.t(1,gg);
      x = [x,x_temp];
      y_temp = max(rms(s_temp.f(:,gg),s_temp.perr(:,gg)));
      y = [y, y_temp];
      clear x_temp y_temp
    end
    clear gg
%getting rid of zeroes in x and y row vectors
    x = x(2:end);
    y = y(2:end);
%storing x and y row vectors as rows in matrices x_s, y_s. Also creating row
%vector for corresponding sample_rate's.
    if kk==0
      x_s = x
      y_s = y
      s_s = sample_rate_temp
    else
      x_s = [x_s;x];
      y_s = [y_s;y];
      s_s = [s_s;sample_rate_temp]
    end
%clearing variables before looping again
    clear s_temp x y w_temp sample_rate_temp 
    B=struct('x_s',x_s,'y_s',y_s,'s_s',s_s,'N',N)
    r=struct('z',z,'B',B,'N_vector',N)
  end
%_________________________  
else
 %want to loop over various sample rates and various orders
  %looping over various orders of filter 
  n_N=19
  int_N=100
  n_srate=2
  int_srate=1
  for kk=0:n_N-1
  %looping over various sample rates for filter
    %N_temp=2^(8+kk);
    N_temp=(2^8)+kk*int_N
    for jj=0:n_srate-1
      sample_rate_temp=2^(6+jj*int_srate);
      w_temp = miso_filter_lev(N_temp,sample_rate_temp,rat,z(1,:));
%applying filter to data files at all the other times
      s_temp = miso_filter_int(w_temp,z(2:n+1,:));
%calculating rms of error=singal-est_signal for each file and creating
%rms vector and time vector to graph
      x = 0;
      y = 0;
%looping over various times
      for gg=1:n+1
        x_temp = s_temp.t(1,gg);
        x = [x,x_temp];
        y_temp = max(rms(s_temp.f(:,gg),s_temp.perr(:,gg)));
        y = [y, y_temp];
        clear x_temp y_temp
      end
      clear gg
%getting rid of zeroes in x and y row vectors
      x = x(2:end);
      y = y(2:end);
%storing x and y row vectors as rows in matrices x_s, y_s. Also creating column
%vector for corresponding sample rates. 
      if jj==0
        x_s = x
        y_s = y
        s_s = sample_rate_temp
      else
        x_s = [x_s;x];
        y_s = [y_s;y];
        s_s = [s_s;sample_rate_temp];
      end
%clearing variables before looping again
      clear sample_rate_temp x y w_temp s_temp 
    end
%want to store the matrices x_s y_s and s_s for each successive iteration of
%N. one could create a structure for the matrices. Use structure called
%B. Also create a vector of B.N to graph with.
    B_temp = struct('x_s',x_s,'y_s',y_s,'s_s',s_s,'N',N_temp);
    if kk==0
      B = B_temp;
    else
      B = [B,B_temp];
    end
%create a column vector of B.N to graph with.    
    for ii=1:length(B)
     if ii==1
       N_vector = B(ii).N;
     else
       N_vector = [N_vector;B(ii).N];
     end
    end
    r=struct('z',z,'B',B,'N_vector',N_vector)
  end  

 end