2020-03-04-Mayr电弧模型的S-function形式建立

Posted on 2020-03-04

test

2020-03-03-如何让分享给人的一个物件显得珍贵

Posted on 2020-03-03

如何给人分享一个东西让人家觉得珍贵，而自己又付出的较少。

利用迭代效应影响他人。

比如茶叶，普洱茶流传着一句至理名言，“越陈越香，越老越贵”。说的是茶存放的时间越长它的品质越好，相应的茶会升值。

利用这个效应来送礼就很合适，送的可以有时间的加成。

朋友请自己喝百茶堂的老茶，我们心里觉得这茶就很贵，很好，自然入喉后仔细的品味一番，然后就会不自然的说这是好茶。

而实际上，朋友买的时候的价格并没有特别贵重，这就是时间的味道。

反过来想问题就是，现在就要为未来请客积攒礼物，如何挑选越陈越值钱的礼物是很关键的，这个需要再仔细思量。

喝到一款很好喝的茶，而并不是百茶堂，忽有感，百茶堂的茶也并没有那么优秀，而在王晨那里喝到很好的茶，年份也好，但就不会觉得特别优秀，这就是如何营造时间的意义方面的话题了。

2020-02-27-关于克服拖延症的5个建议

Posted on 2020-02-27

关于克服拖延症的5个建议

改变想法

一个事情我今天不去做，就不会再去做了，想到一个事情，若必须去做，那么今天就去做，可以做任务分解，然后分解到每一天，若任务太多，将任务分级，做更重要的。
每天进行任务划分

每天做任务计划，然后按照计划去完成，每天都要完成，最开始可以划的粗糙一点，任务量轻一点，然后逐步加大。
仪式感

每天做学习的的任务之前要给自己定一个仪式，就和睡眠仪式一样的，有助于进入状态
每日打卡

对每天的完成情况打卡，有助于积累成就感。
对自己加油！

加油吧！

2020-02-25-微分方程（3）

Posted on 2020-02-25

The Calculus You Need

学习微分方程需要用到一些前置的知识，主要有以下几方面

1. 特殊的一些函数的微分

$x^n$ $sin(x)$ $cos(x)$ $e^x$ $ln(x)$

清楚以上特殊函数的微分。

2. 微分操作定律

$f+g$ $f(x)+g(x)$ $\frac { f ( x ) } { g ( x ) }$ $f(g(x))$

清楚以上方程式的微分。

3. 一个求解公式

用$y ( t ) = \int _ { 0 } ^ { t } e ^ { t - s } 2 ( s ) d s$用来求解$\frac { d } { d x } \int _ { 0 } ^ { x } y ( t ) d t = y ( x )$

我们可以对其证明，对左边的式子左右两端进行微分。

$\frac { d y ( t ) } { d t } = \frac { d } { d t } \left( e ^ { t } \cdot \int _ { 0 } ^ { t } e ^ { - s } q ( u ) d s \right)$

得到

$\frac { d y ( t ) } { d t } = e ^ { t } \int _ { 0 } ^ { t } e ^ { - s } g ( x ) d s + g(t)$

即

$\frac { d } { d x } \int _ { 0 } ^ { x } y ( t ) d t = y ( x )$

4. Taylor级数

我们用一阶导数来形容斜率，我们用二阶导数来形容bending，我们用三阶导数以及更高阶导数去修正曲线，在$t+\Delta t$这段，也就是$\frac{df}{dt}$段更加拟合原函数$f(x+\Delta t)$

$f(t+\Delta t) = f(t) + \Delta t \frac {df(t)}{dt} + \frac{1}{2}(\Delta t)^2 \frac{d^{2}t}{dt^{2}}+ \cdots + \frac { 1 } { n ! } ( \Delta t ) ^ { n } \frac { d ^ { n } f } { d t ^ { n } } + \cdots$

2020-02-25-微分方程（2）

Posted on 2020-02-25

Overview of Differential Equations

https://www.youtube.com/watch?v=ghjOS7Q82s0&list=PLUl4u3cNGP63oTpyxCMLKt_JmB0WtSZfG&index=2

一个典型的一阶的微分方程

$\frac { d y } { d t } = a y + q ( t )$

该方程描述的是y的变化率由y自己的解来决定，同时会在等式右端引入一个激励。这是一个线性的y的方程，因为y是一次的。

$\frac { d y } { d t } = f ( y )$

这可能是一个非线性的，因为$f(y)$可以是y的任何函数，可以是$y^2$、$sin(y)$、$e^y$等等可能形式。

这里可以形象的理解，y是弹簧的长度，$\frac { d y } { d t }$是弹簧长度的变化率。

二阶微分方程

$\frac { d ^ { 2 } y } { d t ^ { 2 } } = - k y$

二阶微分方程可理解为加速度，也是区间的弯折率（beding of a curve），一阶微分方程给的是曲线的方向，是上升还是下降，二阶微分方程给的是曲线向上弯还是向下弯，也就是凸函数还是凹函数。也可以理解为力的变化加速度，而线性的与y有关。

更一般的形式

$m y ^ { \prime \prime } + b y ^ { \prime } + k y = f(t)$

$m y ^ { \prime \prime }$理解为加速度乘以质量，第二项$b y ^ { \prime }$表示阻尼，速度的变化量，第三项是一些强制条款，取决于y自己，$f(t)$是一些外部因素。

我们可解的是线性常微分方程，Linear Constant Coefficients，这样的微分方程我们认为是good equations。

对于不好的方程，比如非线性方程，比如不是常微分方程，即系数（m/k/b）是不变的方程，则需要用数值方法求解。

一个系统经常不止是一个方程，是Systems of n equations.

$\frac { d y } { d t }= A y$其中A是矩阵 $\frac { d ^ { 2 } y } { d t ^ { 2 } } = - S y$

特征值和特征向量。

数值解法很重要Numerical Solutions

目前很好用的方法是Ode45.

而Euler方法可看做是Ode1，Ode45具有更高的精度。“Ode 4 and 5”

偏微分方程，有2个变量，以下是热力学方程，时间以及x是空间向量。

$\frac { \partial u } { \partial t } = \frac { \partial ^ { 2 } u } { \partial x ^ { 2 } }$

以上是一个很重要常微分方程。（PDE，Partial differential equations）偏微分方程

$\frac { \partial ^ { 2 } u } { \partial t ^ { 2 } } = \frac { \partial ^ { 2 } u } { \partial x ^ { 2 } }$

上面是波动方程。

拉普拉斯方程。

$\frac { \partial ^ { 2 } u } { d x ^ { 2 } } + \frac { \partial ^ { 2 } u } { d y ^ { 2 } } = 0$

2020-02-23-Cassie电弧模型离散化

Posted on 2020-02-23 | In 解问题

对于Cassie电弧方程的离散化。

2020-02-22-如何在matlab sfunction 函数中调用自己写的函数？

Posted on 2020-02-22

引用

自己编写了一个s函数，有几个参数引用了自己写的几个函数，在脚本中可以正确运行，但在写成s函数，进行 simulink 仿真的时候，已知提示“too many input auguments”,不知道怎么回事。

经过调试发现，把那几个参数换成常值，simulink 可以正常运行。说明：s函数中，不能直接调用自己写的函数。

那么问题来了：

在用 sfuntmpl 模板用m语言写的s函数中，不能直接调用自己写的函数，怎么办？

具体的解决办法是：

1、打开主页上的‘set path’选项，把自己写的函数所在的文件夹加到搜素路径中。

2、在matlab的安装文件路径 X:\Program Files\MATLAB\R2012\toolbox\ 下，新建一个文件夹 ‘myTool’。把自己写的函数复制到此文件夹下，然后把次文件夹加到路径中。

任选一种方法即可。个人比较推荐2。

2020-02-21-常微分方程解法（1）

Posted on 2020-02-21

在进行电弧模型建模时候，传统的cassie电弧模型的写法都是连续的，但是连续状态的采样率设置上就出现了问题，无法按照自己期望的采样率进行仿真，所以需要对模型进行离散化处理。

转自csdn

建立微分方程只是解决问题的第一步通常需要求出方程的解来说明实际现象，并加以检验。如果能得到即系形式的解固然是便于分析和应用的，但是我们知道，只有线性常系数微分方程，并且自由项是某些特殊类型的函数时，才可以肯定得到这样的解，而绝大多数变系数方程、非线性方程都是所谓“解不出来”的，即使看起来非常简单的方程如$\frac{d y}{d x}=y^{2}+x^{2}$，对于用微分方程解决实际问题来说，数值解法就是一个十分重要的手段。

1. 常微分方程离散化

下面主要讨论一阶常微分方程的初值问题，其一般形式是

$\left\{\begin{array}{l} {\frac{d y}{d x}=f(x, y) \quad a \leq x \leq b} \\ {y(a)=y_{0}} \end{array}\right.\tag{1}$

在下面讨论中，我们总假定函数$f(x,y)$连续，且关于y满足Lipschitz条件，即存在常数L，使得

$|f(x, y)-f(x, \bar{y})| \leq L|y-\bar{y}|$

这样，由常微分方程理论知，处置问题（1）的解必定存在唯一。

数值解法

所谓数值解法，就是求问题（1）的解$y(x)$在若干点

$a=x_{0}<x_{1}<x_{2}<\cdots<x_{N}=b$处的近似值$y_n(n=1,2,…,N)$，$y_n(n=1,2,…,N)$称为问题（1）的数值解，$h_n=x_{n+1}-x_n$称为由$x_n$到$x_{n+1}$的步长，今后如无特别说明，我们总取步长为常量h。

建立数值解法，首先要将微分方程离散化，一般采用以下几种方法：

（i）用差商近似导数——缠粉方程初值问题

若用向前差商$\frac{y\left(x_{n+1}\right)-y\left(x_{n}\right)}{h}$代替$y^{\prime}\left(x_{n}\right)$带入（1）中的微分方程，则得

$\frac{y\left(x_{n+1}\right)-y\left(x_{n}\right)}{h} \approx f\left(x_{n}, y\left(x_{n}\right)\right) \quad(n=0,1, \cdots)$

简化得

$y\left(x_{n+1}\right) \approx y\left(x_{n}\right)+h f\left(x_{n}, y\left(x_{n}\right)\right)$

如果用$y(x_n)$的近似值$y_n$带入上式右端，所得结果作为$y(x_{n+1})$的近似值，记为$y_{n+1}$，则有

$y_{n+1}=y_{n}+h f\left(x_{n}, y_{n}\right) \quad(n=0,1, \cdots)\tag{2}$

这样，问题（1）的近似解可通过求解下述问题

$\left\{\begin{array}{l} {y_{n+1}=y_{n}+h f\left(x_{n}, y_{n}\right) \quad(n=0,1, \cdots)} \\ {y_{0}=y(a)} \end{array}\right.\tag{3}$

按式（3）由初值$y_0$可逐次算出$y_1,y_2…$。式（3）是个离散化的问题，成为差分方程初值问题。

（ii）用数值积分方法

将问题（1）的解表成积分形式，用数值积分方法离散化。例如，对微分方程两端积分，得

$y\left(x_{n+1}\right)-y\left(x_{n}\right)=\int_{x_{n}}^{x_{n+1}} f(x, y(x)) d x \quad(n=0,1, \cdots)\tag{4}$

右边的积分用矩形公式或梯形公式计算。

（iii）Taylor多项式近似

将函数$y(x)$在$x_n$处展开，取一次Taylor多项式近似，则得

$y\left(x_{n+1}\right) \approx y\left(x_{n}\right)+h y^{\prime}\left(x_{n}\right)=y\left(x_{n}\right)+h f\left(x_{n}, y\left(x_{n}\right)\right)$

再将$y(x_n)$的近似值$y_n$代入上式右端，所得结果作为$y(x_{n+1})$的近似值$y_{n+1}$，得到离散化的计算公式

$y_{n+1}=y_{n}+h f\left(x_{n}, y_{n}\right)$

以上三种方法都是将微分方程离散化的常用方法，每一类方法又可导出不同形式的计算公式。其中Taylor展开法，不仅可以得到求数值解的公式，而且容易估计截断误差。

2 欧拉（Euler）方法

2.1 向前Euler公式、向后Euler公式

Euler方法就是用查分方程初值问题（3）的解来近似微分方程初值问题（1）的解，即由公式（3）依次算出$y(x_n)$的近似值$y_n$，（$n=1,2,…$）。这组公式求问题（1）的数值解成为向前Euler公式。

如果在微分方程离散化时，用向后差商代替导数，即$y^{\prime}\left(x_{n+1}\right) \approx \frac{y\left(x_{n+1}\right)-y\left(x_{n}\right)}{h}$，则得计算公式

$\left\{\begin{array}{l} {y_{n+1}=y_{n}+h f\left(x_{n+1}, y_{n+1}\right) \quad(n=0,1, \cdots)} \\ {y_{0}=y(a)} \end{array}\right.\tag{5}$

用这组公式求问题（1）的数值解成为向后Euler公式。

向后Euler法与Euler法形式上相似，但实际计算时却复杂的多。向前Euler公式是显式的，可直接求解。向后Euler公式的右端含有$y_{n+1}$，因此是隐式公式，一般要用迭代法求解，迭代公式通常为

$\left\{\begin{array}{l} {y_{n+1}^{(0)}=y_{n}+h f\left(x_{n}, y_{n}\right)} \\ {y_{n+1}^{(k+1)}=y_{n}+h f\left(x_{n+1}, y_{n+1}^{(k)}\right) \quad(k=0,1,2, \cdots)} \end{array}\right.\tag{6}$

2.2 Euler方法的误差估计

对于向前Euler公式（3）我们看到，当n = 1,2,……时公式右端的$y_n$都是近似的，所以用它计算的$y_{n+1}$会有累积误差，分析累积误差比较复杂，这里先讨论比较简单的所谓局部截断误差。

假定用（3）式右端的$y_n$没有误差，即$y_n=y(x_n)$，那么由此算出

$y_{n+1}=y\left(x_{n}\right)+h f\left(x_{n}, y\left(x_{n}\right)\right)\tag{7}$

局部截断误差指的是，按（7）式计算由$x_n$到$x_{n+1}$这一步的计算值$y_{n+1}$与精确值$y(x_{n+1})$之差$y(x_{n+1})-y_{n+1}$。为了估计它，由Taylor展开得到的精确值$y(x_{n+1})$是

$y\left(x_{n+1}\right)=y\left(x_{n}\right)+h y^{\prime}\left(x_{n}\right)+\frac{h^{2}}{2} y^{\prime \prime}\left(x_{n}\right)+O\left(h^{3}\right)\tag{8}$

(7)、(8)两式相减（注意到$\left.y^{\prime}=f(x, y)\right)$）得

$y\left(x_{n+1}\right)-y_{n+1}=\frac{h^{2}}{2} y^{\prime \prime}\left(x_{n}\right)+O\left(h^{3}\right) \approx O\left(h^{2}\right)\tag{9}$

即局部截断误差是$h^2$阶的，而数值算法的精度定义为：

若一种算法的局部截断误差为$O(h^{p+1})$，则称该算法具有p阶精度。

显然p越大，方法的精度越高。式（9）说明，向前Euler方法是一阶方法，因此它的精度不高。

3 改进的Euler方法

3.1 梯形公式

利用数值积分方法将微分方程离散化时，若用梯形公式计算式（4）中之右端积分，即。

这就是求解初值问题（1）的梯形公式。

直观上容易看出，用梯形公式计算数值积分要比矩形公式好。梯形公式为二阶方法。梯形公式也是隐式格式，一般需用迭代法求解，迭代公式为

如果实际计算时精度要求不太高，用公式（10）求解时，每步可以只迭代一次，由此导出一种新的方法—改进 Euler 法。

3.2 改进Euler法

按式（5）计算问题（1）的数值解，如果每步只迭代一次，相当于将Euler公式与梯形公式结合使用：先用Euler公式求$y_n+1$的一个初步近似值$\bar{y}_{n+1}$，称为预测值，然后用梯形公式校正求得近似值$y_n+1$，即

$\left\{\begin{array}{l} {\bar{y}_{n+1}=y_{n}+h f\left(x_{n}, y_{n}\right)} \\ {y_{n+1}=y_{n}+\frac{h}{2}\left[f\left(x_{n}, y_{n}\right)+f\left(x_{n+1}, \bar{y}_{n+1}\right)\right]} \end{array}\right.\tag{11}$

式（11）称为由Euler公式和梯形公式得到的预测——校正系统，也叫改进Euler法。

为了便于编制程序上机，式（11）常改写成

$\left\{\begin{array}{l} {y_{p}=y_{n}+h f\left(x_{n}, y_{n}\right)} \\ {y_{q}=y_{n}+h f\left(x_{n}+h, y_{p}\right)} \\ {y_{n+1}=\frac{1}{2}\left(y_{p}+y_{q}\right)} \end{array}\right.\tag{12}$

改进Euler法是二阶方法。

4 龙格——库塔（Runge-Kutta）方法

这部分以后再补，暂时用不上。

https://blog.csdn.net/qq_29831163/article/details/89703598

5 Matlab解法

https://blog.csdn.net/qq_29831163/article/details/89703911

5.1 非刚性常微分方程的解法

Matlab 的工具箱提供了几个解非刚性常微分方程的功能函数，如 ode45，ode23， ode113，其中 ode45 采用四五阶 RK 方法，是解非刚性常微分方程的首选方法，ode23 采用二三阶 RK 方法，ode113 采用的是多步法，效率一般比 ode45 高。 Matlab 的工具箱中没有 Euler 方法的功能函数。

（1）对简单的一阶方程的初值问题

自己编写改进的Euler方法函数eulerpro.m如下：

function [x,y]=eulerpro(fun,x0,xfinal,y0,n);
if nargin<5,n=50;end 
h=(xfinal-x0)/n;
x(1)=x0;y(1)=y0;
for i=1:n
    x(i+1)=x(i)+h;
    y1=y(i)+h*feval(fun,x(i),y(i));
    y2=y(i)+h*feval(fun,x(i+1),y1);
    y(i+1)=(y1+y2)/2;
end 

2020-02-18-Level 2 M S函数常见问题

Posted on 2020-02-18

可能提示没有对应的function

看一看对应的function在setup模块中是否被引用。

可能提示Dwork不能有空的。。。

看一下Dwork设定参数的个数，与实际设定的Dwork参数个数是否相符。

不同的function中的参数无法互相通用，也是程序无法正确使用的原因。

Dwork有效性试错

如果Dwork可以看做是全局变量，那么在InitializeConditions中的Dwork的值是可以带入到Output子函数的，现在试试。

设置0.1s，step应该变值，但是很显然没有变化，所以这样是不行的。

也就是说InitializeConditions并不是执行一次就初始化一次么？

调整将Dwork放到Derivatives模块中，这样就相当于原来的了，应该就好用了。

function Derivatives(block)

tau = block.DialogPrm(1).Data;
Uc = block.DialogPrm(2).Data; 

if block.CurrentTime <= block.DialogPrm(3).Data
    block.Dwork(3).Data = 0;
else
    block.Dwork(3).Data = 1;
end
    
block.Derivatives.Data = block.Dwork(3).Data * 1/tau * (block.InputPort(1).data^2 / Uc^2 - 1);
%endfunction

这样是可以的。

2020-02-16-Level 2 M S函数模板

Posted on 2020-02-16

官方模板写的比较啰嗦，找起来比较费力，重新做一个中文的模板。

function msfunCassie(block)
% smileland作品，免费使用，但请不要删除此句话
% 以下设定参数并不一定全部需要，不需要的注释掉就好
setup(block);

%endfunction

function setup(block)
  %block.CurrentTime 只读对象，调用当前时间

  % 初始化对话框参数，即对话框内给定的初始化参数.
  block.NumDialogPrms     = 2;%给定2个参数
  %block.DialogPrmsTunable = {'Tunable','Nontunable','SimOnlyTunable'};%参数是否可变（此句话可选是否需要，默认不可变）

  %%%%%%%%初始化输入输出端口的属性%%%%%%%
  
  % 初始化输入输出端口个数.
  block.NumInputPorts  = 1;%输入端口个数
  block.NumOutputPorts = 1;%输出端口个数
  
  % 设定输入输出端口时继承还是动态，以指示输入和输出端口从模型继承其已编译属性（尺寸、数据类型、复杂度和采样模式）.
  block.SetPreCompInpPortInfoToDynamic;%设定输入端口为动态
  block.SetPreCompOutPortInfoToDynamic;%设定输出端口为动态

  % 设定输入端口属性.（也可以再Dwork中设定，在PostPropagationSetup子方法中）
  block.InputPort(1).DatatypeID  = 0;  % （-1 inherited；0 double;1 single;2 int8;3 uint8;4 int16;5 uint16;6 int32;7 uint12;8 boolean）
  block.InputPort(1).Complexity  = 'Real';%是否为复数
  
  % 设定输出端口属性.（也可以再Dwork中设定，在PostPropagationSetup子方法中）
  block.OutputPort(1).DatatypeID  = 0; % double
  block.OutputPort(1).Complexity  = 'Real';
  
  block.InputPort(1).Dimensions = 1;%输入口1的维数是1，最高支持到2维
  % block.InputPort(1).DimensionsMode = 'Fixed';%Fixed表示端口维数固定，Variable表示端口维数可变
  block.OutputPort(1).Dimensions = 1;%输出口1的维数是1，最高支持到2维
  % block.OutputPort(1).DimensionsMode = 'Fixed';%Fixed表示端口维数固定，Variable表示端口维数可变
  
  block.InputPort(1).DirectFeedthrough = true;%输入口有无直接馈通（true/false）
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  
  % 设定有多少连续状态变量.
  block.NumContStates = 1;
  
  % 设定有多少离散状态变量.
  % block.NumDworkDiscStates = 1;

  % 设定采样时间.
  %  [0 0.5]            : 从0.5s开始连续采样
  %  [0.1 0.5]          : 从0.5s开始，每0.1s采样一次
  %  [-1, 0]            : 继承采样频率
  %  [-2, 0]            : 动态变化的采样频率
  block.SampleTimes = [0 0];%连续采样率
  
  %设定离散工作向量个数
  % block.NumDworks = 1;
  
  % -----------------------------------------------------------------
  % Options，若使用TLC则需要以下语句，否则注释掉即可
  % -----------------------------------------------------------------

  % block.SetAccelRunOnTLC(false);
  
  % block.OperatingPointCompliance = 'Default';
  
  % -----------------------------------------------------------------
  % 引用使用的子方法，主要有PostPropagationSetup;InitializeConditions;
  % Start;Outputs;Updates;Derivatives;Terminate.以下子方法仅保留着几个。
  % -----------------------------------------------------------------
  
  %{
  %包含PostPropagationSetup子方法，用于初始化DWork工作向量
  block.RegBlockMethod('PostPropagationSetup', @DoPostPropSetup);
  %}
  
  %包含InitializeConditions子方法，用于初始化状态变量或DWork工作向量的值
  block.RegBlockMethod('InitializeConditions', @InitializeConditions);
  
  %与InitializeConditions子方法功能一致，但只初始化一次，Ini方法每次调用子方法时均会初始化
  % block.RegBlockMethod('Start', @Start);

  %包含输出模块
  block.RegBlockMethod('Outputs', @Outputs);

  %包含离散状态更新模块
  %block.RegBlockMethod('Update', @Update);

  %包含连续状态微分模块
  block.RegBlockMethod('Derivatives', @Derivatives);
  
  %包含终止模块
  %block.RegBlockMethod('Terminate', @Terminate);

  %还有其他模块，仅将最主要的列出，若需要则使用S函数自带模板。
%endfunction

% -------------------------------------------------------------------
% 以下为子方法模块，同样主要有DoPostPropSetup;InitializeConditions;
  % Start;Outputs;Updates;Derivatives;Terminate.以下子方法仅保留这几个。
% -------------------------------------------------------------------
%{
function DoPostPropSetup(block)
  block.NumDworks = 4;
  
  block.Dwork(1).Name            = 'tau';
  block.Dwork(1).Dimensions      = 1;
  block.Dwork(1).DatatypeID      = 0;      % double
  block.Dwork(1).Complexity      = 'Real'; % real
  block.Dwork(1).UsedAsDiscState = false;
  
  block.Dwork(2).Name            = 'Uc';
  block.Dwork(2).Dimensions      = 1;
  block.Dwork(2).DatatypeID      = 0;      % double
  block.Dwork(2).Complexity      = 'Real'; % real
  block.Dwork(2).UsedAsDiscState = false;
  
  block.Dwork(3).Name            = 'step';
  block.Dwork(3).Dimensions      = 1;
  block.Dwork(3).DatatypeID      = 0;      % double
  block.Dwork(3).Complexity      = 'Real'; % real
  block.Dwork(3).UsedAsDiscState = false;
  
  block.Dwork(4).Name            = 'u';
  block.Dwork(4).Dimensions      = 1;
  block.Dwork(4).DatatypeID      = 0;      % double
  block.Dwork(4).Complexity      = 'Real'; % real
  block.Dwork(4).UsedAsDiscState = false;
  
  % Register all tunable parameters as runtime parameters.
  block.AutoRegRuntimePrms;

%endfunction
%}
%

function InitializeConditions(block)

block.ContStates.Data = log(1e-6);
    
%{
function Start(block)

  tau = block.DialogPrm(1).Data;
  Uc = block.DialogPrm(2).Data; 

%}

%{
  function Update(block)
  block.Dwork(1).Data = [];
%}

function Outputs(block)
  
  block.OutputPort(1).Data = block.InputPort(1).data * exp(block.ContStates.Data);
  
  
function Derivatives(block)

tau = block.DialogPrm(1).Data;
Uc = block.DialogPrm(2).Data; 
  
if block.CurrentTime <= 0.02
    step = 0;
else
    step = 1;
end
    
block.Derivatives.Data = step * 1/tau * (block.InputPort(1).data^2 / Uc^2 - 1);
%endfunction

%endfunction
  
%function Terminate(block)

%disp(['Terminating the block with handle ' num2str(block.BlockHandle) '.']);

%endfunction