# Copyright (C) 2001 by Peter J. Gawthrop

###############################################################
## Version control history
###############################################################
## $Header$
## $Log$
## Revision 1.353  2002/05/28 18:08:38  geraint
## Fixed [ 547294 ] CRs are not sought from MTT_CRS.
##
## Revision 1.352  2002/05/24 11:04:10  geraint
## Removed unnecessary message about *.log file not existing when -D option is used.
##
## Revision 1.351  2002/05/23 17:08:20  geraint
## `mtt sys sfun zip` now produces an input block and an interface block for MTT models.
## Models can be embedded within larger Simulink models by the 2 ports.
## The user must edit 2 code blocks in <sys>_sfun_interface.c before compiling with mex.

${sys}_rdae.r: ${sys}_ese.r ${sys}_def.r $1_modpar.r ${Subsystem}_cr.r ${Subsystem}_subs.r
ifneq ($partition,)
	echo Doing subsystems
	mtt_make_subsystems  ${sys} rdae r
endif
	mtt_prepend.sh -p $1_modpar.r $1_ese.r # Add modulated parameters to start
	ese2rdae_r ${cr_first} ${fixcc} ${Subsystem}; tidy ${Subsystem}_rdae.r

${sys}_dae.r: ${Subsystem}_rdae.r ${Subsystem}_def.r ${Subsystem}_subs.r ${Subsystem}_cr.r
ifneq ($partition,)
	echo Doing subsystems
	mtt_make_subsystems  ${sys} dae r
endif
ifeq ($rdae_is_dae,1)

# Copyright (c) P.J.Gawthrop 1991, 1992, 1994.

###############################################################
## Version control history
###############################################################
## $Id$
## $Log$
## Revision 1.20  2002/04/28 18:41:26  geraint
## Fixed [ 549658 ] awk should be gawk.
## Replaced calls to awk with call to gawk.
##
## Revision 1.19  2001/10/26 01:01:49  geraint
## fixcc when rdae_is_dae (-cr).
##
## Revision 1.18  2001/10/05 23:37:32  geraint
## Fixed assignment statement in ae.r when RHS=0.
##
## Revision 1.17  2001/07/27 23:29:10  geraint

        *)
                echo "$1 is an invalid argument - ignoring" ;;
  esac
  shift
done

# Create the reduce output code
def2write_r $optimise $1 ae
def2write_r $optimise $1 cse 
def2write_r $optimise $1 csex # Version without E matrix
def2write_r $optimise $1 cseo

echo "Creating $1_ae.r $optimise_msg"
echo "Creating $1_cse.r $solve_msg $optimise_msg $fix_msg"
echo "Creating $1_csex.r $optimise_msg"
echo "Creating $1_cseo.r $optimise_msg"

# Remove the old log file
rm -f dae2cse_r.log

# Remove some files
rm -f $1_ae.r? $1_cse.r? $1_cseo.r?

# Use reduce to accomplish the transformation
$SYMBOLIC >dae2cse_r.log << EOF

%Read the formatting function
in "$MTTPATH/trans/reduce_matrix.r";

    set(lhs(MTT_sol_i),rhs(MTT_sol_i));
  END;

  % No algebraic variables left!
  MTTNYz := 0;
END; % IF MTTNyz>0 and $solve












OUT "$1_aej.r";
IF (MTTNyz>0) THEN % as above
BEGIN
    WRITE "MATRIX MTTyzj(",MTTNyz,",",MTTNyz,")";
    WRITE "%File: $1_aej.r";
    FOR i := 1:MTTNyz DO
	FOR j := 1:MTTNyz DO
	BEGIN
	   didj := df(MTTyz(i,1),mkid('mttui,j));
	   IF (didj NEQ 0) THEN
	      WRITE "MTTyzj(",i,",",j,") := ",didj," +0";
	END;
END;
WRITE ";END;";
SHUT "$1_aej.r";

IF MTTNyz>0 THEN % not $solve or solution failed
BEGIN
OUT "$1_ae.r1";
write "MATRIX MTTYZ(", MTTNyz, ",", 1, ")$";
SHUT "$1_ae.r1";
OUT "$1_ae.r2";
write "%File: $1_ae.r";
in ("$1_ae_write.r");
write "END;";
SHUT "$1_ae.r2";
END;

% Create the matrix declarations
OUT "$1_cse.r1";
write "%";
IF (MTTNx > 0) THEN
BEGIN
    write "MATRIX MTTEdx(", MTTNx, ",", 1, ")$"; 

in ("$1_cseo_write.r");
write "END;";
SHUT "$1_cseo.r2";
END;
quit;
EOF

touch $1_ae.r1 $1_ae.r2
touch $1_cseo.r1
touch $1_cseo.r2
cat $1_ae.r1 $1_ae.r2 > $1_ae.r
cat $1_cse.r1 $1_cse.r2  > $1_cse.r
cat $1_csex.r1 $1_csex.r2  > $1_csex.r
cat $1_cseo.r1 $1_cseo.r2  > $1_cseo.r

if [ "$solve" = "1" ]; then
    echo "Setting MTTNyz=0 in $1_def.r and updating other $1_def files"
    gawk '{

# Copyright (C) 2000 by Peter J. Gawthrop

###############################################################
## Version control history
###############################################################
## $Id$
## $Log$
## Revision 1.11.2.4  2002/06/05 23:34:33  geraint
## Eliminated argument list too long warnings.
## Now get a Segmentation Fault with very long equations!
##
## Revision 1.11.2.3  2002/06/05 18:23:38  geraint
## Cosmetic change.
##
## Revision 1.11.2.2  2002/06/05 17:57:47  geraint
## Main part of optimisation routine moved to separate file.
##
## Revision 1.11.2.1  2002/06/05 11:14:51  geraint
## ae.r now generated using def2write_r like cse?.r
## fix_c.r called at ese2rdae stage so that pow gets fixed in ae.r.
##
## These changes produce the desired result (optimised algebraic equations) but
## have highlighted a problem; when optimisation fails, Reduce does not write
## a result. For complicated systems, this can lead to missing assignments in
## the resultant code.
##
## Revision 1.11  2002/05/17 09:14:58  geraint
## Optimises each line in a separate session. Allows larger models to be built.
##
## Revision 1.10  2002/04/28 18:41:27  geraint
## Fixed [ 549658 ] awk should be gawk.
## Replaced calls to awk with call to gawk.
##
## Revision 1.9  2001/07/27 23:29:10  geraint
## Optimises only when requested (-opt).
##

Nu=`mtt_getsize $sys u` # Inputs 
Ny=`mtt_getsize $sys y` # Outputs 
Nyz=`mtt_getsize $sys yz` # Zero outputs
#Npar=`wc -l $sys\_sympar.txt | gawk '{print $1}'`

# Set up representation-specific stuff
case $rep in
    ae)
	matrices='Yz'
	ns="$Nyz"
	ms="1"
	;;
    cse)
        matrices='EdX E'
        ns="$Nx $Nx"
        ms="1 $Nx"
	;;
    csex)
        matrices='EdX'

    }'
}

mtt_optimise ()
{
    sys="$1"
    lhs="$2"
    
    lhs=`echo $lhs | sed 's/MTTEdX/MTTdX/'`
    

    dae="${sys}_dae.r"
    tmp=mtt_optimise.tmp


    









    # get rhs and write to tmp file to be processed by mtt_optimise.sh



    eval "grep -i -e \"^$lhs\"" $dae | eval "sed 's/\([.]*\)[;$]*$/\1/'" | eval "sed 's/\ //g'" | eval "sed 's/:=/ /'" > $tmp






    eval mtt_optimise.sh $tmp


    cat $tmp | mtt_fix_integers
    




    return 0
}


# Remove log files
rm -f def2write_r1.log def2write_r2.log

# Write out the code

    m=`first "$ms"`; ms=`rest "$ms"`
    is=`n2m 1 $n`; 
    js=`n2m 1 $m`; 
    for i in $is; do
      for j in $js; do
	if [ ${opt:-""} = "-optimise" ]; then
	    name=`echo MTT$matrix'('$i','$j')'`
	    mtt_optimise $1 "$comma$name"
	    comma=''
	else
	    echo 'write'
	    name=`echo MTT$matrix'('$i','$j')'`
	    echo '  '$comma$name ':=' $name '$'
	fi >> $1_$2_write.r
      done
    done
done
echo ';END;'                           >>$1_$2_write.r

# Copyright (c) P.J.Gawthrop, 1991, 1994, 1996

###############################################################
## Version control history
###############################################################
## $Id$
## $Log$
## Revision 1.12.2.1  2002/06/05 11:14:51  geraint
## ae.r now generated using def2write_r like cse?.r
## fix_c.r called at ese2rdae stage so that pow gets fixed in ae.r.
##
## These changes produce the desired result (optimised algebraic equations) but
## have highlighted a problem; when optimisation fails, Reduce does not write
## a result. For complicated systems, this can lead to missing assignments in
## the resultant code.
##
## Revision 1.12  2001/07/23 23:31:17  gawthrop
## Added -cr option to load CRs first - avoids alg. loops with R
## implementation of mutiports.
##
## Revision 1.11  2001/07/06 00:46:50  gawthrop
## Added -cr option -- forces cr to be loaded before the ese.r file
## This avoids causality problems when using multi-port Rs to represent
## arbitary equations
##
## Revision 1.10  2000/11/30 15:23:16  peterg
## Taken out all subsystem stuff - now done in mtt using

  case $1 in
	-I )
                info=info;;
	-cr )
                load_cr=yes;
                blurb2=' using cr and subs first';
                ;;
      -fixcc )
		include=`echo 'in "'$MTT_LIB'/reduce/fix_c.r";'`
		blurb3='fixing c and cc code';
		;;
	-partition )
                partition=yes;
                blurb='with partitioning';
		;;
	*)
		echo "$1 is an invalid argument - ignoring";
                exit ;;

if [ -n "${load_cr}" ]; then
    load_cr_comm="in \"${crname}\";"
    load_subs_comm="in \"${subsname}\";"
fi

# Inform user
echo Creating $daename $blurb $blurb2 $blurb3

# Remove the old log file
rm -f $logname

# Use symbolic algebra to accomplish the transformation
$SYMBOLIC >$logname  << EOF

%Read in the cr and sub when  -cr is set
$load_cr_comm
$load_subs_comm

%Read the formatting function
in "$MTTPATH/trans/reduce_matrix.r";

% Definitions
in "$defname";

% Elementary system equations
in "$esename";

% Fix c code if required
$include

OFF Echo;
OFF Nat;

%Create the output file
OUT "$daename";

% %%
% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% Field separator
if nargin<3
  FS = ';';
end;

arg = '';
if strcmp(args, '')==0
  L = length(args);
  args_count = 0;
  for i=1:n
    arg_count = 0;
    arg = '';
    if args_count == L
      break;
    end;  
    while args_count < L
      args_count = args_count+1;
      arg_count = arg_count+1;
      ch = str2ch(args,args_count);
      if ch==FS
	break;
      end;
      arg = [arg ch];
    end;
  end;
end;

#! /bin/sh

set -e
set -x

filename="$1"

# set work file names

tmp="$0.tmp"
log="$0.log"

optimise_with_reduce ()
{
    cat <<EOF | reduce > $log
off echo$
load scope$
on double$
on noconvert$
on rounded$
off int$
off nat$

out "${tmp}"$
optimize mtt_tmp0 :=: `cat ${filename} | gawk '{ print $2 }'` iname mtt_tmp$
write "`cat ${filename} | gawk '{ print $1 }'` := mtt_tmp0"$
shut "${tmp}"$

;end;
EOF
}

optimise_with_maxima ()
{
    cat ${filename}					|\
	tr "\t\n" "  "					|\
	sed -e 's/\ //g'				|\
	sed -e 's/\(MTTdX([0-9.]*,[0-9.]*)\)/\1 /'     	|\
	sed -e 's/\(MTTy([0-9.]*,[0-9.]*)\)/\1 /'     	|\
	sed -e 's/\(MTTYz([0-9.]*,[0-9.]*)\)/\1 /'     	|\
	sed -e 's/[A-Za-z0-9_.:()]*(D2)\(.*\)/\1/'	|\
	sed -e 's/\([A-Za-z0-9_.:()]*\)(C3)/\1/g'	|\
	optimise_max2r.awk				|\
	tr "A-Z" "a-z"					> ${tmp}
}


optimise_with_maxima
#cat $filename
mv ${tmp} ${filename}

exit 0

#! /usr/bin/awk -f

# Maxima optimized expression format:
# (C1) DISPLAY2D:FALSE$
# (C2) OPTIMIZE(x);
# (D2) x
# (C3) OPTIMIZE((1.0+a*b)/(2.0+a*b));
# (D3) BLOCK([%1],%1:a*b,(%1+1.0)/(%1+2.0))

function decipher_block(lhs,rhs)
{
  s=rhs;
  s=gensub(/BLOCK/, "", "1", s);		# strip BLOCK keyword
  s=gensub(/\(/, "", "1", s);			# strip leading (
  s=gensub(/\)$/, "", "1", s);			# strip trailing )
  s=gensub(/\[.*\],/, "", "g", s);		# strip declarations
  s=gensub(/%/, "mtt_tmp", "g", s);		# rename tmp variables
  s=gensub(/:/, " := ", "g", s);	        # fix assignment operator

  # commas delimit statements in maxima, so
  # preserve commas within function calls
  # replace remaining commas with semi-colons
  # then put commas back in functions and reinstate parentheses
  while (match(s, (/\(([^()]*),([^()]*)\)/))) {
    s=gensub(/\(([^()]*),([^()]*)\)/, "(\\1__MTT_COMMA__\\2)", "g", s);
    s=gensub(/\(([^,()]*)\)/, "__MTT_LPAREN__\\1__MTT_RPAREN__", "g", s);
  }
  s=gensub(/,/, ";\n", "g", s);
  s=gensub(/__MTT_COMMA__/, ",", "g", s);
  s=gensub(/__MTT_LPAREN__/, "(", "g", s);
  s=gensub(/__MTT_RPAREN__/, ")", "g", s);

  # separate statements
  rhs=gensub(/.*;([^;]*)\n/, "\\1", 1, s);
  s=gensub(/;([^;]*)$/, ";", 1, s);

  print s;					# print intermediate statements
  printf "%s := %s;\n", lhs, rhs;		# print final assignment
}  

# pattern matching:

(! /.* BLOCK.*/ ) { 				# unoptimised statement
  print $1" := "$2";";
}

(  /.* BLOCK.*/ ) {				# optimised statement
  decipher_block($1,$2)
}

#ifndef HAVE_USEFUL_FUNCTIONS_HH
#define HAVE_USEFUL_FUNCTIONS_HH

/* Code generation directives */
#define STANDALONE 0
#define OCTAVEDLD  1
#define MATLABMEX  2
#if (! defined (CODEGENTARGET))
#define CODEGENTARGET -1
#endif /* (! defined (CODEGENTARGET)) */

#ifndef __cplusplus
#define inline			/* strip */
#define cast_to_double	(double)
/*
typedef unsigned int bool;
const bool true = 1;
const bool false = 0;
*/
#else
#define cast_to_double	static_cast<double>
#endif /* ! __cplusplus */

static inline double
max (const double x1, const double x2)
{

sign (const double x)
{
  return cast_to_double ((x > 0) ? +1 : (x < 0) ? -1 : 0);
}


/* Octave functions */
#if ((CODEGENTARGET == STANDALONE) || (CODEGENTARGET == OCTAVEDLD))
#ifdef __cplusplus
static Matrix
ones (const int r = 1, const int c = 1)
{
  Matrix m (r, c, 1.0);
  return m;
}

static Matrix
zeros (const int r, const int c)
{
  Matrix m (r, c, 0.0);
  return m;
}
#endif /* __cplusplus */
#endif /* ((CODEGENTARGET == STANDALONE) || (CODEGENTARGET == OCTAVEDLD)) */



#endif /* HAVE_USEFUL_FUNCTIONS_HH */

#! /bin/sh
# $Id$
# $Log$
# Revision 1.7  2002/07/10 11:53:32  geraint
# Replaced shell loop with template expansion - perceptibly quicker generation of sympar.h.
#
# Revision 1.6  2002/05/19 13:01:22  geraint
# Numerical solution of algebraic equations implemented for S-function target.
#
# Equation solving requires the Matlab Optimization Toolbox to be installed.
#
# Code has been changed from C++ to C to allow mex files to be built with LCC,
# the compiler bundled with Matlab.
#
# Parameters are now obtained from numpar.c instead of a dialogue box.
#
# `mtt <sys> sfun zip` creates all necessary files for building the model mex files.
#
# Revision 1.5  2002/04/28 18:58:06  geraint
# Fixed [ 549658 ] awk should be gawk.
# Replaced calls to awk with call to gawk.
#
# Revision 1.4  2001/08/24 21:41:04  geraint
# Fixed problem with declaration when there are no numerical parameters.
#

}

declare_temp_vars ()
{
for name in ${TMP_VAR_NAMES}
do
    echo ""

    cat <<EOF | head -`expr ${NUM_OF_TMP_VAR} + 1`
static double ${name}0 MTT_UNUSED;
static double ${name}1 MTT_UNUSED;
static double ${name}2 MTT_UNUSED;
static double ${name}3 MTT_UNUSED;
static double ${name}4 MTT_UNUSED;
static double ${name}5 MTT_UNUSED;
static double ${name}6 MTT_UNUSED;
static double ${name}7 MTT_UNUSED;
static double ${name}8 MTT_UNUSED;
static double ${name}9 MTT_UNUSED;
static double ${name}10 MTT_UNUSED;
static double ${name}11 MTT_UNUSED;
static double ${name}12 MTT_UNUSED;
static double ${name}13 MTT_UNUSED;
static double ${name}14 MTT_UNUSED;
static double ${name}15 MTT_UNUSED;
static double ${name}16 MTT_UNUSED;
static double ${name}17 MTT_UNUSED;
static double ${name}18 MTT_UNUSED;
static double ${name}19 MTT_UNUSED;
static double ${name}20 MTT_UNUSED;
static double ${name}21 MTT_UNUSED;
static double ${name}22 MTT_UNUSED;
static double ${name}23 MTT_UNUSED;
static double ${name}24 MTT_UNUSED;
static double ${name}25 MTT_UNUSED;
static double ${name}26 MTT_UNUSED;
static double ${name}27 MTT_UNUSED;
static double ${name}28 MTT_UNUSED;
static double ${name}29 MTT_UNUSED;
static double ${name}30 MTT_UNUSED;
static double ${name}31 MTT_UNUSED;
static double ${name}32 MTT_UNUSED;
static double ${name}33 MTT_UNUSED;
static double ${name}34 MTT_UNUSED;
static double ${name}35 MTT_UNUSED;
static double ${name}36 MTT_UNUSED;
static double ${name}37 MTT_UNUSED;
static double ${name}38 MTT_UNUSED;
static double ${name}39 MTT_UNUSED;
static double ${name}40 MTT_UNUSED;
static double ${name}41 MTT_UNUSED;
static double ${name}42 MTT_UNUSED;
static double ${name}43 MTT_UNUSED;
static double ${name}44 MTT_UNUSED;
static double ${name}45 MTT_UNUSED;
static double ${name}46 MTT_UNUSED;
static double ${name}47 MTT_UNUSED;
static double ${name}48 MTT_UNUSED;
static double ${name}49 MTT_UNUSED;
static double ${name}50 MTT_UNUSED;
static double ${name}51 MTT_UNUSED;
static double ${name}52 MTT_UNUSED;
static double ${name}53 MTT_UNUSED;
static double ${name}54 MTT_UNUSED;
static double ${name}55 MTT_UNUSED;
static double ${name}56 MTT_UNUSED;
static double ${name}57 MTT_UNUSED;
static double ${name}58 MTT_UNUSED;
static double ${name}59 MTT_UNUSED;
static double ${name}60 MTT_UNUSED;
static double ${name}61 MTT_UNUSED;
static double ${name}62 MTT_UNUSED;
static double ${name}63 MTT_UNUSED;
static double ${name}64 MTT_UNUSED;
static double ${name}65 MTT_UNUSED;
static double ${name}66 MTT_UNUSED;
static double ${name}67 MTT_UNUSED;
static double ${name}68 MTT_UNUSED;
static double ${name}69 MTT_UNUSED;
static double ${name}70 MTT_UNUSED;
static double ${name}71 MTT_UNUSED;
static double ${name}72 MTT_UNUSED;
static double ${name}73 MTT_UNUSED;
static double ${name}74 MTT_UNUSED;
static double ${name}75 MTT_UNUSED;
static double ${name}76 MTT_UNUSED;
static double ${name}77 MTT_UNUSED;
static double ${name}78 MTT_UNUSED;
static double ${name}79 MTT_UNUSED;
static double ${name}80 MTT_UNUSED;
static double ${name}81 MTT_UNUSED;
static double ${name}82 MTT_UNUSED;
static double ${name}83 MTT_UNUSED;
static double ${name}84 MTT_UNUSED;
static double ${name}85 MTT_UNUSED;
static double ${name}86 MTT_UNUSED;
static double ${name}87 MTT_UNUSED;
static double ${name}88 MTT_UNUSED;
static double ${name}89 MTT_UNUSED;
static double ${name}90 MTT_UNUSED;
static double ${name}91 MTT_UNUSED;
static double ${name}92 MTT_UNUSED;
static double ${name}93 MTT_UNUSED;
static double ${name}94 MTT_UNUSED;
static double ${name}95 MTT_UNUSED;
static double ${name}96 MTT_UNUSED;
static double ${name}97 MTT_UNUSED;
static double ${name}98 MTT_UNUSED;
static double ${name}99 MTT_UNUSED;
static double ${name}100 MTT_UNUSED;
static double ${name}101 MTT_UNUSED;
static double ${name}102 MTT_UNUSED;
static double ${name}103 MTT_UNUSED;
static double ${name}104 MTT_UNUSED;
static double ${name}105 MTT_UNUSED;
static double ${name}106 MTT_UNUSED;
static double ${name}107 MTT_UNUSED;
static double ${name}108 MTT_UNUSED;
static double ${name}109 MTT_UNUSED;
static double ${name}110 MTT_UNUSED;
static double ${name}111 MTT_UNUSED;
static double ${name}112 MTT_UNUSED;
static double ${name}113 MTT_UNUSED;
static double ${name}114 MTT_UNUSED;
static double ${name}115 MTT_UNUSED;
static double ${name}116 MTT_UNUSED;
static double ${name}117 MTT_UNUSED;
static double ${name}118 MTT_UNUSED;
static double ${name}119 MTT_UNUSED;
static double ${name}120 MTT_UNUSED;
static double ${name}121 MTT_UNUSED;
static double ${name}122 MTT_UNUSED;
static double ${name}123 MTT_UNUSED;
static double ${name}124 MTT_UNUSED;
static double ${name}125 MTT_UNUSED;
static double ${name}126 MTT_UNUSED;
static double ${name}127 MTT_UNUSED;
static double ${name}128 MTT_UNUSED;
static double ${name}129 MTT_UNUSED;
static double ${name}130 MTT_UNUSED;
static double ${name}131 MTT_UNUSED;
static double ${name}132 MTT_UNUSED;
static double ${name}133 MTT_UNUSED;
static double ${name}134 MTT_UNUSED;
static double ${name}135 MTT_UNUSED;
static double ${name}136 MTT_UNUSED;
static double ${name}137 MTT_UNUSED;
static double ${name}138 MTT_UNUSED;
static double ${name}139 MTT_UNUSED;
static double ${name}140 MTT_UNUSED;
static double ${name}141 MTT_UNUSED;
static double ${name}142 MTT_UNUSED;
static double ${name}143 MTT_UNUSED;
static double ${name}144 MTT_UNUSED;
static double ${name}145 MTT_UNUSED;
static double ${name}146 MTT_UNUSED;
static double ${name}147 MTT_UNUSED;
static double ${name}148 MTT_UNUSED;
static double ${name}149 MTT_UNUSED;
static double ${name}150 MTT_UNUSED;
static double ${name}151 MTT_UNUSED;
static double ${name}152 MTT_UNUSED;
static double ${name}153 MTT_UNUSED;
static double ${name}154 MTT_UNUSED;
static double ${name}155 MTT_UNUSED;
static double ${name}156 MTT_UNUSED;
static double ${name}157 MTT_UNUSED;
static double ${name}158 MTT_UNUSED;
static double ${name}159 MTT_UNUSED;
static double ${name}160 MTT_UNUSED;
static double ${name}161 MTT_UNUSED;
static double ${name}162 MTT_UNUSED;
static double ${name}163 MTT_UNUSED;
static double ${name}164 MTT_UNUSED;
static double ${name}165 MTT_UNUSED;
static double ${name}166 MTT_UNUSED;
static double ${name}167 MTT_UNUSED;
static double ${name}168 MTT_UNUSED;
static double ${name}169 MTT_UNUSED;
static double ${name}170 MTT_UNUSED;
static double ${name}171 MTT_UNUSED;
static double ${name}172 MTT_UNUSED;
static double ${name}173 MTT_UNUSED;
static double ${name}174 MTT_UNUSED;
static double ${name}175 MTT_UNUSED;
static double ${name}176 MTT_UNUSED;
static double ${name}177 MTT_UNUSED;
static double ${name}178 MTT_UNUSED;
static double ${name}179 MTT_UNUSED;
static double ${name}180 MTT_UNUSED;
static double ${name}181 MTT_UNUSED;
static double ${name}182 MTT_UNUSED;
static double ${name}183 MTT_UNUSED;
static double ${name}184 MTT_UNUSED;
static double ${name}185 MTT_UNUSED;
static double ${name}186 MTT_UNUSED;
static double ${name}187 MTT_UNUSED;
static double ${name}188 MTT_UNUSED;
static double ${name}189 MTT_UNUSED;
static double ${name}190 MTT_UNUSED;
static double ${name}191 MTT_UNUSED;
static double ${name}192 MTT_UNUSED;
static double ${name}193 MTT_UNUSED;
static double ${name}194 MTT_UNUSED;
static double ${name}195 MTT_UNUSED;
static double ${name}196 MTT_UNUSED;
static double ${name}197 MTT_UNUSED;
static double ${name}198 MTT_UNUSED;
static double ${name}199 MTT_UNUSED;
static double ${name}200 MTT_UNUSED;
static double ${name}201 MTT_UNUSED;
static double ${name}202 MTT_UNUSED;
static double ${name}203 MTT_UNUSED;
static double ${name}204 MTT_UNUSED;
static double ${name}205 MTT_UNUSED;
static double ${name}206 MTT_UNUSED;
static double ${name}207 MTT_UNUSED;
static double ${name}208 MTT_UNUSED;
static double ${name}209 MTT_UNUSED;
static double ${name}210 MTT_UNUSED;
static double ${name}211 MTT_UNUSED;
static double ${name}212 MTT_UNUSED;
static double ${name}213 MTT_UNUSED;
static double ${name}214 MTT_UNUSED;
static double ${name}215 MTT_UNUSED;
static double ${name}216 MTT_UNUSED;
static double ${name}217 MTT_UNUSED;
static double ${name}218 MTT_UNUSED;
static double ${name}219 MTT_UNUSED;
static double ${name}220 MTT_UNUSED;
static double ${name}221 MTT_UNUSED;
static double ${name}222 MTT_UNUSED;
static double ${name}223 MTT_UNUSED;
static double ${name}224 MTT_UNUSED;
static double ${name}225 MTT_UNUSED;
static double ${name}226 MTT_UNUSED;
static double ${name}227 MTT_UNUSED;
static double ${name}228 MTT_UNUSED;
static double ${name}229 MTT_UNUSED;
static double ${name}230 MTT_UNUSED;
static double ${name}231 MTT_UNUSED;
static double ${name}232 MTT_UNUSED;
static double ${name}233 MTT_UNUSED;
static double ${name}234 MTT_UNUSED;
static double ${name}235 MTT_UNUSED;
static double ${name}236 MTT_UNUSED;
static double ${name}237 MTT_UNUSED;
static double ${name}238 MTT_UNUSED;
static double ${name}239 MTT_UNUSED;
static double ${name}240 MTT_UNUSED;
static double ${name}241 MTT_UNUSED;
static double ${name}242 MTT_UNUSED;
static double ${name}243 MTT_UNUSED;
static double ${name}244 MTT_UNUSED;
static double ${name}245 MTT_UNUSED;
static double ${name}246 MTT_UNUSED;
static double ${name}247 MTT_UNUSED;
static double ${name}248 MTT_UNUSED;
static double ${name}249 MTT_UNUSED;
static double ${name}250 MTT_UNUSED;
static double ${name}251 MTT_UNUSED;
static double ${name}252 MTT_UNUSED;
static double ${name}253 MTT_UNUSED;
static double ${name}254 MTT_UNUSED;
static double ${name}255 MTT_UNUSED;
static double ${name}256 MTT_UNUSED;
static double ${name}257 MTT_UNUSED;
static double ${name}258 MTT_UNUSED;
static double ${name}259 MTT_UNUSED;
static double ${name}260 MTT_UNUSED;
static double ${name}261 MTT_UNUSED;
static double ${name}262 MTT_UNUSED;
static double ${name}263 MTT_UNUSED;
static double ${name}264 MTT_UNUSED;
static double ${name}265 MTT_UNUSED;
static double ${name}266 MTT_UNUSED;
static double ${name}267 MTT_UNUSED;
static double ${name}268 MTT_UNUSED;
static double ${name}269 MTT_UNUSED;
static double ${name}270 MTT_UNUSED;
static double ${name}271 MTT_UNUSED;
static double ${name}272 MTT_UNUSED;
static double ${name}273 MTT_UNUSED;
static double ${name}274 MTT_UNUSED;
static double ${name}275 MTT_UNUSED;
static double ${name}276 MTT_UNUSED;
static double ${name}277 MTT_UNUSED;
static double ${name}278 MTT_UNUSED;
static double ${name}279 MTT_UNUSED;
static double ${name}280 MTT_UNUSED;
static double ${name}281 MTT_UNUSED;
static double ${name}282 MTT_UNUSED;
static double ${name}283 MTT_UNUSED;
static double ${name}284 MTT_UNUSED;
static double ${name}285 MTT_UNUSED;
static double ${name}286 MTT_UNUSED;
static double ${name}287 MTT_UNUSED;
static double ${name}288 MTT_UNUSED;
static double ${name}289 MTT_UNUSED;
static double ${name}290 MTT_UNUSED;
static double ${name}291 MTT_UNUSED;
static double ${name}292 MTT_UNUSED;
static double ${name}293 MTT_UNUSED;
static double ${name}294 MTT_UNUSED;
static double ${name}295 MTT_UNUSED;
static double ${name}296 MTT_UNUSED;
static double ${name}297 MTT_UNUSED;
static double ${name}298 MTT_UNUSED;
static double ${name}299 MTT_UNUSED;
static double ${name}300 MTT_UNUSED;
static double ${name}301 MTT_UNUSED;
static double ${name}302 MTT_UNUSED;
static double ${name}303 MTT_UNUSED;
static double ${name}304 MTT_UNUSED;
static double ${name}305 MTT_UNUSED;
static double ${name}306 MTT_UNUSED;
static double ${name}307 MTT_UNUSED;
static double ${name}308 MTT_UNUSED;
static double ${name}309 MTT_UNUSED;
static double ${name}310 MTT_UNUSED;
static double ${name}311 MTT_UNUSED;
static double ${name}312 MTT_UNUSED;
static double ${name}313 MTT_UNUSED;
static double ${name}314 MTT_UNUSED;
static double ${name}315 MTT_UNUSED;
static double ${name}316 MTT_UNUSED;
static double ${name}317 MTT_UNUSED;
static double ${name}318 MTT_UNUSED;
static double ${name}319 MTT_UNUSED;
static double ${name}320 MTT_UNUSED;
static double ${name}321 MTT_UNUSED;
static double ${name}322 MTT_UNUSED;
static double ${name}323 MTT_UNUSED;
static double ${name}324 MTT_UNUSED;
static double ${name}325 MTT_UNUSED;
static double ${name}326 MTT_UNUSED;
static double ${name}327 MTT_UNUSED;
static double ${name}328 MTT_UNUSED;
static double ${name}329 MTT_UNUSED;
static double ${name}330 MTT_UNUSED;
static double ${name}331 MTT_UNUSED;
static double ${name}332 MTT_UNUSED;
static double ${name}333 MTT_UNUSED;
static double ${name}334 MTT_UNUSED;
static double ${name}335 MTT_UNUSED;
static double ${name}336 MTT_UNUSED;
static double ${name}337 MTT_UNUSED;
static double ${name}338 MTT_UNUSED;
static double ${name}339 MTT_UNUSED;
static double ${name}340 MTT_UNUSED;
static double ${name}341 MTT_UNUSED;
static double ${name}342 MTT_UNUSED;
static double ${name}343 MTT_UNUSED;
static double ${name}344 MTT_UNUSED;
static double ${name}345 MTT_UNUSED;
static double ${name}346 MTT_UNUSED;
static double ${name}347 MTT_UNUSED;
static double ${name}348 MTT_UNUSED;
static double ${name}349 MTT_UNUSED;
static double ${name}350 MTT_UNUSED;
static double ${name}351 MTT_UNUSED;
static double ${name}352 MTT_UNUSED;
static double ${name}353 MTT_UNUSED;
static double ${name}354 MTT_UNUSED;
static double ${name}355 MTT_UNUSED;
static double ${name}356 MTT_UNUSED;
static double ${name}357 MTT_UNUSED;
static double ${name}358 MTT_UNUSED;
static double ${name}359 MTT_UNUSED;
static double ${name}360 MTT_UNUSED;
static double ${name}361 MTT_UNUSED;
static double ${name}362 MTT_UNUSED;
static double ${name}363 MTT_UNUSED;
static double ${name}364 MTT_UNUSED;
static double ${name}365 MTT_UNUSED;
static double ${name}366 MTT_UNUSED;
static double ${name}367 MTT_UNUSED;
static double ${name}368 MTT_UNUSED;
static double ${name}369 MTT_UNUSED;
static double ${name}370 MTT_UNUSED;
static double ${name}371 MTT_UNUSED;
static double ${name}372 MTT_UNUSED;
static double ${name}373 MTT_UNUSED;
static double ${name}374 MTT_UNUSED;
static double ${name}375 MTT_UNUSED;
static double ${name}376 MTT_UNUSED;
static double ${name}377 MTT_UNUSED;
static double ${name}378 MTT_UNUSED;
static double ${name}379 MTT_UNUSED;
static double ${name}380 MTT_UNUSED;
static double ${name}381 MTT_UNUSED;
static double ${name}382 MTT_UNUSED;
static double ${name}383 MTT_UNUSED;
static double ${name}384 MTT_UNUSED;
static double ${name}385 MTT_UNUSED;
static double ${name}386 MTT_UNUSED;
static double ${name}387 MTT_UNUSED;
static double ${name}388 MTT_UNUSED;
static double ${name}389 MTT_UNUSED;
static double ${name}390 MTT_UNUSED;
static double ${name}391 MTT_UNUSED;
static double ${name}392 MTT_UNUSED;
static double ${name}393 MTT_UNUSED;
static double ${name}394 MTT_UNUSED;
static double ${name}395 MTT_UNUSED;
static double ${name}396 MTT_UNUSED;
static double ${name}397 MTT_UNUSED;
static double ${name}398 MTT_UNUSED;
static double ${name}399 MTT_UNUSED;
static double ${name}400 MTT_UNUSED;
static double ${name}401 MTT_UNUSED;
static double ${name}402 MTT_UNUSED;
static double ${name}403 MTT_UNUSED;
static double ${name}404 MTT_UNUSED;
static double ${name}405 MTT_UNUSED;
static double ${name}406 MTT_UNUSED;
static double ${name}407 MTT_UNUSED;
static double ${name}408 MTT_UNUSED;
static double ${name}409 MTT_UNUSED;
static double ${name}410 MTT_UNUSED;
static double ${name}411 MTT_UNUSED;
static double ${name}412 MTT_UNUSED;
static double ${name}413 MTT_UNUSED;
static double ${name}414 MTT_UNUSED;
static double ${name}415 MTT_UNUSED;
static double ${name}416 MTT_UNUSED;
static double ${name}417 MTT_UNUSED;
static double ${name}418 MTT_UNUSED;
static double ${name}419 MTT_UNUSED;
static double ${name}420 MTT_UNUSED;
static double ${name}421 MTT_UNUSED;
static double ${name}422 MTT_UNUSED;
static double ${name}423 MTT_UNUSED;
static double ${name}424 MTT_UNUSED;
static double ${name}425 MTT_UNUSED;
static double ${name}426 MTT_UNUSED;
static double ${name}427 MTT_UNUSED;
static double ${name}428 MTT_UNUSED;
static double ${name}429 MTT_UNUSED;
static double ${name}430 MTT_UNUSED;
static double ${name}431 MTT_UNUSED;
static double ${name}432 MTT_UNUSED;
static double ${name}433 MTT_UNUSED;
static double ${name}434 MTT_UNUSED;
static double ${name}435 MTT_UNUSED;
static double ${name}436 MTT_UNUSED;
static double ${name}437 MTT_UNUSED;
static double ${name}438 MTT_UNUSED;
static double ${name}439 MTT_UNUSED;
static double ${name}440 MTT_UNUSED;
static double ${name}441 MTT_UNUSED;
static double ${name}442 MTT_UNUSED;
static double ${name}443 MTT_UNUSED;
static double ${name}444 MTT_UNUSED;
static double ${name}445 MTT_UNUSED;
static double ${name}446 MTT_UNUSED;
static double ${name}447 MTT_UNUSED;
static double ${name}448 MTT_UNUSED;
static double ${name}449 MTT_UNUSED;
static double ${name}450 MTT_UNUSED;
static double ${name}451 MTT_UNUSED;
static double ${name}452 MTT_UNUSED;
static double ${name}453 MTT_UNUSED;
static double ${name}454 MTT_UNUSED;
static double ${name}455 MTT_UNUSED;
static double ${name}456 MTT_UNUSED;
static double ${name}457 MTT_UNUSED;
static double ${name}458 MTT_UNUSED;
static double ${name}459 MTT_UNUSED;
static double ${name}460 MTT_UNUSED;
static double ${name}461 MTT_UNUSED;
static double ${name}462 MTT_UNUSED;
static double ${name}463 MTT_UNUSED;
static double ${name}464 MTT_UNUSED;
static double ${name}465 MTT_UNUSED;
static double ${name}466 MTT_UNUSED;
static double ${name}467 MTT_UNUSED;
static double ${name}468 MTT_UNUSED;
static double ${name}469 MTT_UNUSED;
static double ${name}470 MTT_UNUSED;
static double ${name}471 MTT_UNUSED;
static double ${name}472 MTT_UNUSED;
static double ${name}473 MTT_UNUSED;
static double ${name}474 MTT_UNUSED;
static double ${name}475 MTT_UNUSED;
static double ${name}476 MTT_UNUSED;
static double ${name}477 MTT_UNUSED;
static double ${name}478 MTT_UNUSED;
static double ${name}479 MTT_UNUSED;
static double ${name}480 MTT_UNUSED;
static double ${name}481 MTT_UNUSED;
static double ${name}482 MTT_UNUSED;
static double ${name}483 MTT_UNUSED;
static double ${name}484 MTT_UNUSED;
static double ${name}485 MTT_UNUSED;
static double ${name}486 MTT_UNUSED;
static double ${name}487 MTT_UNUSED;
static double ${name}488 MTT_UNUSED;
static double ${name}489 MTT_UNUSED;
static double ${name}490 MTT_UNUSED;
static double ${name}491 MTT_UNUSED;
static double ${name}492 MTT_UNUSED;
static double ${name}493 MTT_UNUSED;
static double ${name}494 MTT_UNUSED;
static double ${name}495 MTT_UNUSED;
static double ${name}496 MTT_UNUSED;
static double ${name}497 MTT_UNUSED;
static double ${name}498 MTT_UNUSED;
static double ${name}499 MTT_UNUSED;
static double ${name}500 MTT_UNUSED;
EOF

    if [ ${NUM_OF_TMP_VAR} -gt 500 ]; then
	i=501
	while [ ${i} -le ${NUM_OF_TMP_VAR} ]
	do
	  echo "static double ${name}${i} MTT_UNUSED;"
	  i=`expr ${i} + 1`
	done
    fi
done
}

echo Creating ${OUT}
cat <<EOF > ${OUT}
#ifndef MTT_UNUSED
#ifdef __GNUC__

@comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@comment  Version control history
@comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@comment  $Id$
@comment  $Log$
@comment  Revision 1.9  2002/07/05 13:29:34  geraint
@comment  Added notes about generating dynamically linked functions for Octave and Matlab.
@comment
@comment  Revision 1.8  2002/07/04 21:34:12  geraint
@comment  Updated gnuplot view description to describe Tcl/Tk interface instead of obsolete txt method.
@comment
@comment  Revision 1.7  2002/04/23 09:51:54  gawthrop
@comment  Changed incorrect statement about searching for components.
@comment
@comment  Revision 1.6  2001/10/15 14:29:50  gawthrop
@comment  Added documentaton on  [1:N] style port labels
@comment
@comment  Revision 1.5  2001/07/23 03:35:29  geraint
@comment  Updated file structure (mtt/bin).
@comment
@comment  Revision 1.4  2001/07/23 03:25:02  geraint

Simulation parameters

* Euler integration::           
* Implicit integration::        
* Runge Kutta IV integration::  
* Hybrd algebraic solver::      

Simulation code

* Dynamically linked functions::  

Simulation output

* Viewing results with gnuplot::  
* Exporting results to SciGraphica::  

Representations

* Text editors::                
* Octave::                      
* LaTeX::                       

Octave

* Octave control system toolbox (OCST)::  
* Creating GNU Octave .oct files::  
* Creating Matlab .mex files::  
* Embedding MTT models in Simulink::  

Administration

* Software components::         
* REDUCE setup::                
* Octave setup::                
* Paths::                       

@end example

To generate an executable based on the C++ representation:
@example
mtt -cc [options] sys ode2odes exe
@end example

@menu
* Dynamically linked functions::  
@end menu

@node Dynamically linked functions,  , Simulation code, Simulation code
@comment  node-name,  next,  previous,  up
@subsection Dynamically linked functions

Some model representations can be compiled into dynamically loaded
code (shared objects) which are compiled prior to use in other
modelling and simulation environments; in particular, .oct files can
be generated for use in GNU Octave (@pxref{Creating GNU Octave .oct
files}) and .mex files can be generated for use in Matlab
(@pxref{Creating Matlab .mex files}) or Simulink (@pxref{Embedding MTT
models in Simulink}).  The use of compiled (and possibly
compiler-optimised) code can offer significant processing speed
advantages over equivalent interpreted functions (e.g. .m files) for
computationally intensive procedures.

The C++ code generated by @strong{MTT} allows the same code to be
generated as standalone code, Octave .oct files or Matlab .mexglx
files. Although @strong{MTT} usually takes care of the compilation
options, if it is necessary to compile the code on a machine on which
@strong{MTT} is not installed, the appropriate flag should be passed
to the compiler pre-processor:
@itemize @bullet
@item
@code{-DCODEGENTARGET=STANDALONE}
@item
@code{-DCODEGENTARGET=OCTAVEDLD}
@item
@code{-DCODEGENTARGET=MATLABMEX}
@end itemize

@node Simulation output,  , Simulation code, Simulation
@comment  node-name,  next,  previous,  up
@section Simulation output
@cindex Simulation output
The view (@pxref{Views}) representation provides a graphical
representation of the results of a simulation; the postscript language
provides the same thing in a form that can be included in a document.

@end menu

@node Viewing results with gnuplot, Exporting results to SciGraphica, Simulation output, Simulation output
@comment  node-name,  next,  previous,  up@subsection
@subsection Viewing results with gnuplot
@cindex gnuplot

Simulation plots may be conveniently selected, viewed with
@uref{http://www.gnuplot.org,gnuplot} 
and saved to file (in PostScript format) using the command

@example
mtt [options] rc gnuplot view
@end example


This will cause a menu to be displayed, from which states and outputs may be selected for viewing. Clicking on a @emph{parameter name} will cause a new window to be opened displaying the time history of the selected parameter. Selecting the @emph{print} option in the main window provides the option of saving to file a plot of the last selected parameter. Clicking on the @emph{title bar} of the main window (``Outputs'' or ``States'') will alter the order in which the parameter names are displayed.





It should be noted that unlike other representations, if a simulation has been previously run in a directory, this command will @emph{not} cause @strong{MTT} to re-run a simulation, even if any of the input files have been changed.


If it is desired to re-run a simulation, it is advisable to run the command 

@example





mtt [options] rc odeso view ; mtt [options] rc gnuplot view




@end example



As with @strong{xMTT} (@pxref{Menu-driven interface}), the Wish Tcl/Tk interpreter must be installed to make use of this feature.

@node Exporting results to SciGraphica,  , Viewing results with gnuplot, Simulation output
@comment  node-name,  next,  previous,  up
@subsection Exporting results to SciGraphica
@cindex SciGraphica

Simulation results can be converted into an XML-format

%% ss1 is both a source and sensor
ss1     SS              external,external
%% ss1 acts as a flow sensor - it imposes zero effort.
ss2     SS              0,external
@end example


@node Other component labels, Component names, SS component labels , Labels (lbl)
@comment  node-name,  next,  previous,  up
@subsection Other component labels 
@cindex Other component labels 

In addition to the label there are two information fields,
@pxref{Labels (lbl)}.
They correspond to the constitutive relationship 

# Generated by MTT at Mon Jun 16 15:10:17 BST 1997

# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# %% Version control history
# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# %% $Id$
# %% $Log$
# %% Revision 1.9  2002/07/05 13:29:34  geraint
# %% Added notes about generating dynamically linked functions for Octave and Matlab.
# %%
# %% Revision 1.8  2002/07/04 21:34:12  geraint
# %% Updated gnuplot view description to describe Tcl/Tk interface instead of obsolete txt method.
# %%
# %% Revision 1.7  2002/04/23 09:51:54  gawthrop
# %% Changed incorrect statement about searching for components.
# %%
# %% Revision 1.6  2001/10/15 14:29:50  gawthrop
# %% Added documentaton on  [1:N] style port labels
# %%
# %% Revision 1.5  2001/07/23 03:35:29  geraint
# %% Updated file structure (mtt/bin).
# %%
# %% Revision 1.4  2001/07/23 03:25:02  geraint

step(rc);
bode(rc);
@end example


@menu
* Octave control system toolbox (OCST)::  
* Creating GNU Octave .oct files::  
* Creating Matlab .mex files::  
* Embedding MTT models in Simulink::  
@end menu

@node Octave control system toolbox (OCST), Creating GNU Octave .oct files, Octave, Octave
@comment  node-name,  next,  previous,  up
@subsection Octave control system toolbox (OCST)
@cindex Octave
@cindex toolbox
@cindex OCST
@cindex control systems
@cindex mtt2sys

The following octave commands then generate the step reponse and bode
diagram respectively:
@example
step(rc);
bode(rc);
@end example

@node Creating GNU Octave .oct files, Creating Matlab .mex files, Octave control system toolbox (OCST), Octave
@comment  node-name,  next,  previous,  up
@subsection Creating GNU Octave .oct files
@cindex Creating GNU Octave .oct files

GNU Octave dynamically loaded functions (.oct files) can be created by
instructing @strong{MTT} to create the ``oct'' representation:

@example
  mtt [options] sys ode oct
@end example

This will cause @strong{MTT} to create the C++ representation of the system
(sys_ode.cc) and to then compile it as a shared object suitable for
use within Octave. The resultant file may be used in an identical
manner to the equivalent, but generally slower, interpreted .m file.

Usage information for the function may be obtained within Octave in the usual manner:

@example
  octave:1> help rc_ode

  rc_ode is the dynamically-linked function from the file
  /home/mttuser/rc/rc_ode.oct

  Usage: [mttdx] = rc_ode(mttx,mttu,mttt,mttpar)
  Octave ode representation of system rc
  Generated by MTT on Fri Jul  5 11:23:08 BST 2002
@end example

Note that the first line of output from Octave identifies whether the
compiled or interpreted function is being used.

Alternatively, standard representations may be generated using the
Octave DLDs by use of the ``-oct'' switch:

@example
  mtt -oct rc odeso view
@end example

In order to successfully generate .oct files, Octave must be correctly
configured prior to compilation and certain headers and libraries must
be correctly installed on the system (@pxref{.oct file dependencies}).

@node  Creating Matlab .mex files, Embedding MTT models in Simulink, Creating GNU Octave .oct files, Octave
@comment  node-name,  next,  previous,  up
@subsection Creating Matlab .mex files
@cindex Creating Matlab .mex files

On GNU/Linux systems, Matlab dynamically linked executables (.mexglx
files) can created by instructing @strong{MTT} to create the
``mexglx'' representation:

@example
  mtt [options] sys ode mexglx
@end example

This will cause @strong{MTT} to create the C++ representation of the
system (sys_ode.cc) and to then compile it as a shared object suitable
for use within Matlab.

If it is necessary to compile mex files for another platform, then the
usual C++ representation (generated with the -cc flag) can be created
and the resultant file compiled with the -DCODEGENTARGET=MATLABMEX
flag on the target platform.

@example
  mtt_machine:
  mtt -cc rc ode cc

  matlab_machine:
  matlab> mex -DCODEGENTARGET=MATLABMEX rc_ode.cc
@end example

@node  Embedding MTT models in Simulink,  , Creating Matlab .mex files, Octave
@comment  node-name,  next,  previous,  up
@subsection Embedding MTT models in Simulink
@cindex Embedding MTT models in Simulink

It is possible to embed @strong{MTT} functions or entire @strong{MTT}
models within Simulink simulations as Sfun blocks. If the zip package
is installed on the system, the command

@example
  mtt sys sfun zip
@end example

will create a compressed archive containing sys.mdl, which may be
embedded into a larger Simulink model. Also contained within the
archive will be four sys_sfun*.c files,

@itemize @bullet
@item
sys_sfun.c
model state and output equations
@item
sys_sfun_ae.c
model algebraic equations
@item
sys_sfun_input.c
model inputs
@item
sys_sfun_interface.c
interface between MTT model and Simulink
@end itemize

The last of these files must be edited to correctly map the inputs and
outputs between the @strong{MTT} and Simulink models. The two sections
to edit are clearly marked with

@example
  @code{/* Start EDIT */}
  @code{....}
  @code{/* End EDIT */}
@end example

These four files should then be compiled with the Matlab ``mex''
compiler as described in the @emph{README} file in the archive.

If it is desired to compile the .mex files directly from within
@strong{MTT} on a machine which has the Matlab header files installed,
this may be done with the command

@example
  mtt sys sfun mexglx 
@end example

which will generated the four .mex files and the .mdl file. In this
case, the user must ensure that @emph{sys_sfun_interface.c} has been
correctly edited prior to compilation.

Note that solution of algebraic equations within Simulink is not
possible unless the @emph{Matlab Optimisation Toolbox} is installed.

@node LaTeX,  , Octave, Language tools
@comment  node-name,  next,  previous,  up
@section LaTeX
@cindex LaTeX

LaTeX is a powerful text processor which @strong{MTT} uses to provide

empty_list_elements_ok = 1;

@end example

@node .oct file dependencies,  , .octaverc, Octave setup
@comment  node-name,  next,  previous,  up Additionally, it is necessary to
@subsection .oct file dependencies
Successful compilation of .oct code requires that Octave has been
configured to use dynamically linked libraries and that the Octave
libraries @code{liboctave}, @code{libcruft} and @code{liboctinterp}
are available on the system.

This can be acheived by compiling Octave from the source code, configured
with the options @code{--enable-shared} and @code{--enable-dl}.

A number of additional libraries and headers are also required to be
installed on a system. These include,
@itemize @bullet
@item
@emph{ncurses} and @emph{readline}
               terminal control routines
@item
@emph{blas} or @emph{altas}
            basic linear algebra subprograms, usually optimised for the specific processor
@item
@emph{fftw}
        fast Fourier transform routines
@item
@emph{g2c}
        GNU Fortran to C conversion routines
@item
@emph{kpathsea}
        TeX path search routines
@end itemize

Note that on many GNU/Linux distributions, the necessary headers are
contained in development packages which must be installed in addition
to the standard library package.

Further information on configuring and installing Octave to handle dynamic
libraries (DLDs) can be found in the
@uref{http://www.octave.org/docs.html,Octave documentation}.


@node Paths, File structure, Octave setup, Administration

%% Fixes for c-code generation

%% Set PI explicitly here to avoid later conflict with cc headers
%% if PI is not already a number (i.e. on rounded has not been set)
IF NOT NUMBERP (pi) THEN LET PI = 3.14159$

ON ROUNDED$ % No integer output

%% Changes x^y to pow(x,y)
 OPERATOR pow$
 FOR ALL x,y LET x^y = pow(x,y)$ % Use the pow function

 %% Derivatives
 FOR ALL f,g,x LET df(pow(f,g),x)=
 	   pow(f,g-1) * (df(f,x)*g + df(g,x)*f*log(f))$

 %% Special cases
 FOR ALL x LET pow(x,0) = 1$
 FOR ALL x LET pow(x,1) = x$
 FOR ALL x,y,z LET pow(x,y)*pow(x,z) = pow(x,y+z)$ 
 FOR ALL x,y,z LET pow(pow(x,y),z) = pow(x,y*z)$

OPERATOR fabs$
FOR ALL x let abs(x) = fabs(x)$


END$

# -*-makefile-*-
# Makefile for representation ident
# File ident_rep.make

#Copyright (C) 2000,2001,2002 by Peter J. Gawthrop

## Model targets
model_reps =  ${SYS}_sympar.m ${SYS}_simpar.m ${SYS}_state.m 
model_reps += ${SYS}_numpar.m ${SYS}_input.m ${SYS}_ode2odes.m  
model_reps += ${SYS}_def.m

## Prepend s to get the sensitivity targets
sensitivity_reps = ${model_reps:%=s%}

## Simulation targets
sims = ${SYS}_sim.m s${SYS}_ssim.m

## m-files needed for ident
ident_m = ${SYS}_ident.m ${SYS}_ident_numpar.m 

## Targets for the ident simulation
ident_reps = ${ident_m} ${sims} ${model_reps} ${sensitivity_reps}

## ps output files
psfiles = ${SYS}_ident.ps ${SYS}_ident.basis.ps ${SYS}_ident.par.ps ${SYS}_ident.U.ps
figfiles = ${psfiles:%.ps=%.fig}

all: ${SYS}_ident.${LANG}

echo:
	echo "sims: ${sims}"
	echo "model_reps: ${model_reps}"
	echo "sensitivity_reps: ${sensitivity_reps}"
	echo "ident_reps: ${ident_reps}"

${SYS}_ident.view: ${SYS}_ident.ps
	ident_rep.sh ${SYS} view

${psfiles}: ${SYS}_ident.fig
	ident_rep.sh ${SYS} ps

${SYS}_ident.gdat: ${SYS}_ident.dat2
	ident_rep.sh ${SYS} gdat

${SYS}_ident.fig ${SYS}_ident.dat2: ${ident_reps}
	ident_rep.sh ${SYS} dat2

${SYS}_ident.m: 
	ident_rep.sh ${SYS} m

${SYS}_ident_numpar.m:
	ident_rep.sh ${SYS} numpar.m

## System model reps
## Generic txt files 
${SYS}_%.txt:
	mtt ${OPTS} -q -stdin ${SYS} $* txt

## Specific m files
${SYS}_ode2odes.m: ${SYS}_rdae.r
	mtt -q -stdin ${OPTS} ${SYS} ode2odes m

${SYS}_sim.m: ${SYS}_ode2odes.m
	mtt ${OPTS} -q -stdin ${SYS} sim m

## Generic txt to m
${SYS}_%.m: ${SYS}_%.txt
	mtt ${OPTS} -q -stdin ${SYS} $* m

## r files
${SYS}_def.r: ${SYS}_abg.fig
	mtt ${OPTS} -q -stdin ${SYS} def r

${SYS}_rdae.r: 
	mtt ${OPTS} -q -stdin ${SYS} rdae r

## Sensitivity model reps
## Generic txt files 
s${SYS}_%.txt:
	mtt ${OPTS} -q -stdin -s s${SYS} $* txt

## Specific m files
s${SYS}_ode2odes.m: s${SYS}_rdae.r
	mtt -q -stdin ${OPTS} -s s${SYS} ode2odes m

s${SYS}_ssim.m:
	mtt -q -stdin ${OPTS} -s s${SYS} ssim m

s${SYS}_def.m:
	mtt -q -stdin ${OPTS} -s s${SYS} def m


## Generic txt to m
s${SYS}_%.m: s${SYS}_%.txt
	mtt ${OPTS} -q -stdin s${SYS} $* m

## r files
s${SYS}_rdae.r: 
	mtt ${OPTS} -q -stdin -s s${SYS} rdae r

#! /bin/sh

## ident_rep.sh
## DIY representation "ident" for mtt
# Copyright (C) 2002 by Peter J. Gawthrop

sys=$1
rep=ident
lang=$2
mtt_parameters=$3
rep_parameters=$4

## Some names
target=${sys}_${rep}.${lang}
def_file=${sys}_def.r
dat2_file=${sys}_ident.dat2
dat2s_file=${sys}_idents.dat2
ident_numpar_file=${sys}_ident_numpar.m
option_file=${sys}_ident_mtt_options.txt

## Get system information
if [ -f "${def_file}" ]; then
 echo Using ${def_file}
else
  mtt -q ${sys} def r
fi

ny=`mtt_getsize $1 y`
nu=`mtt_getsize $1 u`

check_new_options() {
    if [ -f "${option_file}" ]; then
	old_options=`cat ${option_file}`
        if [ "${mtt_options}" != "${old_options}" ]; then
	   echo ${mtt_options} > ${option_file}
	fi
    else
	echo ${mtt_options} > ${option_file}
    fi
}

## Make the _ident.m file
make_ident() {
filename=${sys}_${rep}.m
echo Creating ${filename}

cat > ${filename} <<EOF    
function [y,u,t] = ${sys}_ident (last, ppp_names, par_names, A_u, A_w, w, Q, extras)

  ## usage:  [y,u,t] = ${sys}_ident (last, ppp_names, par_names, A_u, A_w, w, Q, extras)
  ##
  ## last      last time in run
  ## ppp_names Column vector of names of ppp params
  ## par_names Column vector of names of estimated params
  ## extras    Structure containing additional info

  ##Sanity check
  if nargin<2
    printf("Usage: [y,u,t] = ${sys}_ident(N, ppp_names[, par_names, extras])\n");
    return
  endif

  if nargin<4
    ## Set up optional parameters
    extras.criterion = 1e-3;
    extras.emulate_timing = 0;
    extras.max_iterations = 15;
    extras.simulate = 1;
    extras.v =  1e-6;
    extras.verbose = 0;
    extras.visual = 1;
  endif
  
  ## System info
  [n_x,n_y,n_u,n_z,n_yz] = ${sys}_def;
  sympar  = ${sys}_sympar;
  simpar  = ${sys}_simpar;
  sympars  = s${sys}_sympar;
  simpars  = s${sys}_simpar;
  t_ol = simpar.last;
    
  ## Number of intervals needed
  N = ceil(last/t_ol);

  ## Setpoints
  if extras.verbose
    printf("Open-loop interval %3.2f \n", simpar.last);
    printf(" -- using info in ${sys}_simpar.txt\n");
    printf("PPP optimisation from %3.2f to %3.2f\n", simpars.first, simpars.last);
    printf(" -- using info in s${sys}_simpar.txt\n");
  endif
  
  t_horizon = [simpars.first+simpars.dt:simpars.dt:simpars.last]';
  w_s = ones(length(t_horizon)-1,1)*w';

  ## Setup the indices of the adjustable stuff
  if nargin<2
    i_ppp = []
  else
    i_ppp = ppp_indices (ppp_names,sympar,sympars); # Parameters
  endif

  n_ppp = length(i_ppp(:,1));

  if nargin<3
    i_par = []
  else
    i_par = ppp_indices (par_names,sympar,sympars); # Parameters
  endif
  
    ## Do some simulations to check things out
    ## System itself
    par = ${sys}_numpar;
    x_0_ol = ${sys}_state(par);
    [y_ol,x_ol, t_ol] =  ${sys}_sim(x_0_ol, par, simpar, ones(1,n_u));
    simpar_OL = simpar;
    simpar_OL.last = simpars.last;
    [y_OL,x_OL, t_OL] =  ${sys}_sim(x_0_ol, par, simpar_OL, ones(1,n_u));

    pars = s${sys}_numpar;
    x_0_ppp = s${sys}_state(pars);
    [y_ppp,y_par,x_ppp, t_ppp] =  s${sys}_ssim(x_0_ppp, pars, simpars, ones(1,n_u));

    simpar_PPP = simpars;
    simpar_PPP.first = simpar.first;
    [y_PPP,y_par,x_PPP, t_PPP] =  s${sys}_ssim(x_0_ppp, pars, simpar_PPP, ones(1,n_u));

    ## Basis functions
    Us = ppp_ustar(A_u,1,t_OL',0,0)';


  if extras.visual		#Show some graphs
    figure(2); 	
    grid; title("Outputs of ${sys}_sim and s${sys}_ssim");
    plot(t_ol,y_ol, '*', t_ppp, y_ppp, '+', t_OL, y_OL, t_PPP, y_PPP);


    figure(3); 	
    grid; title("Basis functions");
    plot(t_OL, Us);

  endif



  ## Do it
  [y,u,t,P,U,t_open,t_ppp,t_est,its_ppp,its_est] \
      = ppp_nlin_run ("${sys}",i_ppp,i_par,A_u,w_s,N,Q,extras);

  ## Compute values at ends of ol intervals
  T_open = cumsum(t_open);
  T_open = T_open(1:length(T_open)-1); # Last point not in t
  j=[];
  for i = 1:length(T_open)
    j = [j; find(T_open(i)*ones(size(t))==t)];
  endfor
  y_open = y(j,:);
  u_open = u(j,:);

  ## Plots

    gset nokey
    gset nogrid
    #eval(sprintf("gset xtics %g", simpar.last));
    #gset noytics
    gset format x "%.1f"
    gset format y "%.2f"
    gset term fig monochrome portrait fontsize 20 size 20 20 metric \
	     thickness 4
    gset output "${sys}_ident.fig"

    title("");
    xlabel("Time (s)");
    ylabel("u");
    subplot(2,1,2); plot(t,u,'-',  T_open, u_open,"+");
    #subplot(2,1,2); plot(t,u);   
    ylabel("y");
    subplot(2,1,1); plot(t,y,'-',  T_open, y_open,"+"); 
    #subplot(2,1,1); plot(t,y); 
    oneplot;
    gset term fig monochrome portrait fontsize 20 size 20 10 metric \
	     thickness 4
    gset output "${sys}_ident.basis.fig"
    title("");
    xlabel("Time (s)");
    ylabel("Basis functions");
    plot(t_OL, Us);


    ## Create plot against time
    TTT = [ [0;T_open] [T_open; last] ]';
    TT = TTT(:);

    [n,m] = size(P);
    if m>0
      P = P(1:n-1,:);  # Loose last point
      PP = [];
      for j=1:m
        pp = [P(:,j) P(:,j)]';
        PP = [PP pp(:)];
      endfor

      oneplot;
      gset output "${sys}_ident.par.fig"
      title("");
      xlabel("Time (s)");
      ylabel("Parameters");
      plot(TT,PP);
    endif

    [n,m] = size(U);
    if m>0    oneplot;
      gset output "${sys}_ident.U.fig"
      title("");
      xlabel("Time (s)");
      ylabel("U");
      [n,m] = size(U);
      U = U(1:n-1,:);  # Loose last point
      UU = [];
      for j=1:m
        uu = [U(:,j) U(:,j)]';
        UU = [UU uu(:)];
      endfor
      plot(TT,UU);
    endif

endfunction

EOF
}

make_ident_numpar() {
echo Creating ${ident_numpar_file}
cat > ${sys}_ident_numpar.m <<EOF
function [last, ppp_names, par_names, A_u, A_w, w, Q, extras] = ${sys}_ident_numpar 

## usage:  [last, ppp_names, par_names, A_u, A_w, w, Q, extras] = ${sys}_ident_numpar ()
##
## 

  ## Last time of run
  last = 10;

  ## Specify basis functions
  A_w = zeros(1,1);
  n_ppp = ${nu};
  A_u = ppp_aug(A_w,laguerre_matrix(n_ppp-1,2.0));

 
  ## Names of ppp parameters
  ppp_names = "";
  for i=1:n_ppp
    name = sprintf("ppp_%i", i);
    ppp_names = [ppp_names; name];
  endfor

  ## Estimated parameters
  par_names = [];

  ## Weights
  Q = ones(${ny},1);

  ## Setpoint
  w = zeros(${ny},1); w(1) = 1;

  ## Set up optional parameters
  extras.criterion = 1e-3;
  extras.emulate_timing = 0;
  extras.max_iterations = 15;
  extras.simulate = 1;
  extras.v =  1e-6;
  extras.verbose = 0;
  extras.visual = 0;

endfunction
EOF
}

make_dat2() {

## Inform user
echo Creating ${dat2_file}

## Use octave to generate the data
octave -q <<EOF
  [last, ppp_names, par_names, A_u, A_w, w, Q, extras] = ${sys}_ident_numpar;
  [y,u,t] = ${sys}_ident(last, ppp_names, par_names, A_u, A_w, w, Q, extras);
  data = [t,y,u];
  save -ascii ${dat2_file} data
EOF
}

case ${lang} in
    numpar.m)
        ## Make the numpar stuff
        make_ident_numpar;
	;;
    m)
        ## Make the code
        make_ident;
	;;
    dat2|fig|basis.fig|par.fig|U.fig)
        ## The dat2 language (output data) & fig file
        rm ${sys}_ident*.fig
	make_dat2; 
	;;
    gdat)
        cp ${dat2_file} ${dat2s_file} 
	dat22dat ${sys} ${rep} 
        dat2gdat ${sys} ${rep}
	;;
    ps|basis.ps|par.ps|U.ps)
        figs=`ls ${sys}_ident*.fig | sed -e 's/\.fig//'`
        echo $figs
	for fig in ${figs}; do
            fig2dev -Leps ${fig}.fig > ${fig}.ps
	done
	;;
    view)
	pss=`ls ${sys}_ident*.ps` 
        echo Viewing ${pss}
        for ps in ${pss}; do
          gv ${ps}&
	done
	;;
    *)
	echo Language ${lang} not supported by ${rep} representation
        exit 3
esac

### main program

#set_debug 0
#check_for_valid_input "$*"

OPTS="$1" SYS="$2" REP="$3" LANG="$4" make $make_debug -f ${MTT_REP}/sfun_rep/Makefile ${2}_${3}.${4}
exit 0