({{, (RefLink[SystemsModelDelayApproximate, paclet:ref/SystemsModelDelayApproximate])[sys,ord] 
gives a delay-free system by using approximations of order ord of the time delays in system sys.}})

OpenersNotesSection(Spacer1)Details and Options

The system can be either a (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) or a (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]).

For continuous-time systems, delays are approximated using (RefLink[PadeApproximant, paclet:ref/PadeApproximant]) with order ord.

For discrete-time systems, delays are approximated poles for the integer part of the delay and a Thiran all-pass filter of order ord for the fractional part of the delay.

OpenersPrimaryExamplesSection(Spacer1)Examples  (10)

OpenersExampleSection0(Spacer1)Basic Examples  (2)

Approximate a (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) with an input delay:

SystemsModelDelayApproximate[(StateSpaceModelFull[-1, (SystemsModelDelay[2]), 1, 0, , , ]),3]

A (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]) with delay:

SystemsModelDelayApproximate[(TransferFunctionModelFull[((-1+(SystemsModelDelay[3]))/(3+s)), , , ]),2]

OpenersExampleSection1(Spacer1)Scope  (4)

A continuous-time (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]) with symbolic delay:

SystemsModelDelayApproximate[(StateSpaceModelFull[1, (1/2)+2 (Subscript[\[SystemsModelDelay], T]), 0, 0, -1, 3, 1, 0, 0, 0, 3, 0, , , ]),2]

A discrete-time (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel]):

SystemsModelDelayApproximate[(StateSpaceModelFull[0, 1, 0, -1+((SystemsModelDelay[4])/2), -(1/3), 1, (SystemsModelDelay[1]), 2, 0, 0.25`, , ])]

A continuous-time (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]):

SystemsModelDelayApproximate[
(TransferFunctionModelFull[(1/(4-2 (1+(E^(-s))) s+(s^2))), (2/(4-2 (1+(E^(-s))) s+(s^2))), ((E^(-3 s))/(4-2 (1+(E^(-s))) s+(s^2))), (s/(4-2 (1+(E^(-s))) s+(s^2))), , , ]),2]

A discrete-time (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel]) with integer delay:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((-(1/2)+z) (SystemsModelDelay[3]))/(((1/2)+z) (1+z))), 2, , ])]

With fractional delay:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((-(1/2)+z) (SystemsModelDelay[(5/2)]))/(((1/2)+z) (1+z))), 2, , ])]

Use only a first-order approximation:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((-(1/2)+z) (SystemsModelDelay[(5/2)]))/(((1/2)+z) (1+z))), 2, , ]),1]

OpenersExampleSection2(Spacer1)Generalizations & Extensions  (1)

For discrete-time systems, if the order is omitted, it will be chosen automatically:

SystemsModelDelayApproximate[(StateSpaceModelFull[(1/2), (SystemsModelDelay[3.1`]), 1, 0, T, , ])]

OpenersExampleSection4(Spacer1)Applications  (1)

The model of the lathe below uses an internal delay to account for a varying chip size:

dde=10 x''[t] +  x'[t] +100 x[t] == -200(f[t] +x[t] - x[t-1]);
lathe=StateSpaceModel[dde,{x[t],x'[t]},{f[t]},x[t],t]

The delay causes an instability:

OutputResponse[lathe,UnitStep[t],{t,0,5}];
Plot[%,{t,0,5},PlotRange->All]

Approximate the delays to allow for controller design:

approxLathe=Simplify@SystemsModelDelayApproximate[lathe,2]

kgains=StateFeedbackGains[approxLathe,{-5,-10,-15,-20}];
lgains=EstimatorGains[approxLathe,{-5,-10,-15,-20}];

er=EstimatorRegulator[approxLathe,{lgains,kgains}]

Apply the controller to the original time-delay system:

cl=SystemsModelFeedbackConnect[lathe,er]

The resulting closed-loop system is stable:

OutputResponse[cl,UnitStep[t],{t,0,5}];
Plot[%,{t,0,5},PlotRange->All]

OpenersExampleSection5(Spacer1)Properties & Relations  (1)

Zero-order approximations are equivalent to setting the delay equal to zero:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((SystemsModelDelay[3])-3 (SystemsModelDelay[4]))/(3+s)), , , ]),0]

OpenersExampleSection6(Spacer1)Possible Issues  (1)

Approximating a discrete-time system with too large an order creates an unstable system:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((0.5` +z) (SystemsModelDelay[1.5`]))/((-0.2`+z) (0.2` +z))), 1, , ]),4]//TransferFunctionPoles

Instead, allow the order to be chosen automatically:

SystemsModelDelayApproximate[(TransferFunctionModelFull[(((0.5` +z) (SystemsModelDelay[1.5`]))/((-0.2`+z) (0.2` +z))), 1, , ])]//TransferFunctionPoles

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[SystemsModelDelay, paclet:ref/SystemsModelDelay])  ▪  (RefLink[TransferFunctionModel, paclet:ref/TransferFunctionModel])  ▪  (RefLink[StateSpaceModel, paclet:ref/StateSpaceModel])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Delay Control Systems, paclet:guide/DelayControlSystems])}})}})