%MVBLKB   Builds up an appended state space system from

% SISO transfer function blocks   nX, dX

% MIMO transfer function blocks   numX, comdenX

% state space blocks  aX, bX, cX, dX

% SISO transfer function blocks   nXij , dXij

%      to be formed into a MIMO state space system.

%

% The three vectors  nblocks, mvnblks and ssnblks contain the

% values of X respectively for first three forms of block. The

% matrix tfnblks contains the information required for the last

% form. The first row of tfnblks contains the block numbers

% X for the SISO to MIMO blocks, the second row contains the 

% number of inputs, and the third row contains the number of

% outputs for each of the MIMO blocks to be built up from 

% SISO blocks.

%

% The final a,b,c,d  state space system is formed from the blocks 

% in the order of X. If any of the vectors is missing or empty it 

% is ignored. A scalar for nblocks is expanded to a vector.

%

% If the variable verbose == 1 more info is printed.



%	Dr M.P. Ford 13th September 1987

% Copyright (c) 1987 by GEC Engineering Research Centre & Cambridge Control Ltd

%       MR0007

%       MR0032



if exist('verbose')==1

   if verbose == 1

     mv_trace = 1;

     disp('MVBLKB')

   else

     mv_trace = 0;

   end

else

   mv_trace = 0;

end



%  Search for the vectors

if exist('nblocks')==1

   if length(nblocks)==1   % expand

      v_nblk=1:nblocks;

   else

      v_nblk=nblocks(:);

   end    % if length

   if mv_trace

     disp('  SISO transfer function block numbers (nblocks)')

     disp(v_nblk')

   end

else

   v_nblk=[];

   if mv_trace

     disp('  No SISO transfer function blocks (nblocks does not exist)');

   end

end

if exist('mvnblks')==1

   v_mvblk=mvnblks(:);

   if mv_trace

   disp(['  Common denominator MIMO tranfer',...

        ' function block numbers (mvnblks)'])

     disp(v_mvblk')

   end

else

   v_mvblk=[];

   if mv_trace

     disp(['  No common denominator MIMO transfer function blocks',...

           ' (mvnblks does not exist)']);

   end

end

if exist('ssnblks')==1

   v_ssblk=ssnblks(:);

   if mv_trace

     disp('  State Space block numbers (ssnblks)')

     disp(v_ssblk')

   end

else

   v_ssblk=[];

   if mv_trace

     disp('  No State Space blocks (ssnblks does not exist)');

   end

end



if exist('tfnblks')==1

   i_mvtemp=size(tfnblks);

   if i_mvtemp(1)~=3

      disp('MVBLKB  Error tfnblks must have 3 rows')

      return;

   else

      v_tfblk=tfnblks(1,:)';

      sz_tfblk=tfnblks(2:3,:);

      if mv_trace

   disp(['  Non-common denominator MIMO tranfer ',...

        'function block numbers (tfnblks)'])

   disp(v_tfblk')

   end % if mv_trace



   end % else if i_mvtemp

else

   v_tfblk=[];

   sz_tfblk=[0;0];

   if mv_trace

     disp(['  No non-common denom. MIMO tranfer function blocks',...

          ' (tfnblks does not exist)']);

   end

end



% Max blocks

v_mvtemp=[v_nblk; v_mvblk; v_ssblk; v_tfblk];

max_mvtemp=max(v_mvtemp);



% Check for repeated or missing block numbers

if mv_trace

   disp('Checking block numbers.')

end

err_flg=0;

for i_mvtemp=1:max_mvtemp

  if length(find(v_mvtemp==i_mvtemp))~=1  % error

     err_flg=1;

     if length(find(v_mvtemp==i_mvtemp))==0  % block missing

        disp(['MVBLKB  Error Block number ',int2str(i_mvtemp),' is missing'])

     else

        disp(['MVBLKB  Error Block number ',int2str(i_mvtemp),' is repeated'])

     end

  end     % if length

end   % for i_mvtemp



if err_flg

  return

end



% Loop through the blocks

for i_mvtemp=1:max_mvtemp

  ii_mvtemp=int2str(i_mvtemp);

  if length(find(v_nblk==i_mvtemp))==1

  if mv_trace == 1

     disp(['Building SISO transfer function block ',ii_mvtemp])

  end

     eval(['[a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]=mvtf2ss(n',...

             ii_mvtemp,',d',ii_mvtemp,');']);

  elseif length(find(v_mvblk==i_mvtemp))==1

     if mv_trace == 1

        disp(['Building MIMO transfer function block ',ii_mvtemp])

     end

     eval(['[a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]=mvtf2ss(num',...

            ii_mvtemp,',comden',ii_mvtemp,');']);

  elseif length(find(v_ssblk==i_mvtemp))==1

     if mv_trace == 1

        disp(['Building State Space block ',ii_mvtemp])

     end

     eval(['a_mvtemp=a',ii_mvtemp,';']);

     eval(['b_mvtemp=b',ii_mvtemp,';']);

     eval(['c_mvtemp=c',ii_mvtemp,';']);

     eval(['d_mvtemp=d',ii_mvtemp,';']);



  elseif length(find(v_tfblk==i_mvtemp))==1

     if mv_trace == 1

        disp(['Building MIMO transfer function block ',ii_mvtemp])

     end

    blk_str = int2str(i_mvtemp);

    ii_mvtemp=find(v_tfblk==i_mvtemp);

for jj_num = 1:sz_tfblk(1,ii_mvtemp)  % inputs

    jj_str = int2str(jj_num);

    a_par=0;

    b_par=0;

    c_par=zeros(sz_tfblk(2,ii_mvtemp),1);

    d_par=zeros(sz_tfblk(2,ii_mvtemp),1);

    for ii_num = 1:sz_tfblk(2,ii_mvtemp) % outputs

        ii_str = int2str(ii_num);

        nij_str=['n',blk_str,ii_str,jj_str];

        dij_str=['d',blk_str,ii_str,jj_str];

        if exist(nij_str)==1

    if mv_trace

       disp(['                Converting SISO element ',ii_str,jj_str])

    end

        eval(['[a_blk,b_blk,c_blk,d_blk]=mvtf2ss(',nij_str,',',dij_str,');']);

           c_tmp=zeros(sz_tfblk(2,ii_mvtemp),length(c_blk));

           c_tmp(ii_num,:)=c_blk;

           d_tmp=zeros(sz_tfblk(2,ii_mvtemp),1);

           d_tmp(ii_num)=d_blk;

           [a_par,b_par,c_par,d_par]=mvpar(a_par,b_par,c_par,d_par,...

                                        a_blk,b_blk,c_tmp,d_tmp);

        end  % if exists

    end  % for outputs

    if jj_num==1

       a_mvtemp=a_par;

       b_mvtemp=b_par;

       c_mvtemp=c_par;

       d_mvtemp=d_par;

    else

       [a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp]...

         = mvsum(a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp,a_par,b_par,c_par,d_par);

    end  % if



end  % for  inputs



  else     % should not get here

     error(['Cannot find block ',ii_mvtemp]);

  end



  [ma_mvtemp,na_mvtemp]=size(a_mvtemp);

  [mb_mvtemp,nb_mvtemp]=size(b_mvtemp);

  [mc_mvtemp,nc_mvtemp]=size(c_mvtemp);

  if i_mvtemp==1

     sz=[ma_mvtemp;nb_mvtemp;mc_mvtemp];

     a=a_mvtemp;

     b=b_mvtemp;

     c=c_mvtemp;

     d=d_mvtemp;

  else

     sz=[sz,[ma_mvtemp;nb_mvtemp;mc_mvtemp]];

     [a,b,c,d]=append(a,b,c,d,a_mvtemp,b_mvtemp,c_mvtemp,d_mvtemp);

  end  % if i_mvtemp



if mv_trace == 1

   disp(['       ',int2str(nb_mvtemp),' inputs, ',...

			int2str(mc_mvtemp),' outputs'])

end % if mv_trace



end   %  for i_mvtemp



clear err_flg

clear nij_str

clear dij_str

clear a_mvtemp

clear b_mvtemp

clear c_mvtemp

clear d_mvtemp

clear i_mvtemp

clear a_par

clear b_par

clear c_par

clear d_par

clear a_blk

clear b_blk

clear c_blk

clear d_blk

clear c_tmp

clear d_tmp

clear ii_mvtemp

clear ii_num

clear jj_num

clear blk_str

clear max_mvtemp

clear v_mvtemp

clear v_nblk

clear v_mvblk

clear v_ssblk

clear v_tfblk

clear sz_tfblk

clear ma_mvtemp

clear na_mvtemp

clear mb_mvtemp

clear nb_mvtemp

clear mc_mvtemp

clear nc_mvtemp

clear mv_trace

clear ii_str

clear jj_str