PWL |

PWL Controlled Source

The Piece-Wise Linear Controlled Source is a single input, single output function similar to the Gain Block. However, the output of the PWL Source is not necessarily linear for all values of input. Instead, it follows an I/O relationship specified by you via the x_arrayand y_array coordinates. This is detailed below.

The x_array and y_array values represent vectors of coordinate points on the x and y axes, respectively. The x_array values are progressively increasing input coordinate points, and the associated y_array values represent the outputs at those points. There may be as few as two (x_array[n],y_array[n]) pairs specified, or as many as memory and simulation speed allow. This permits you to very finely approximate a non-linear function by capturing multiple input-output coordinate points.

Two aspects of the PWL Controlled Source warrant special attention. These are the handling of endpoints and the smoothing of the described transfer function near coordinate points.

In order to fully specify outputs for values of "in" outside of the bounds of the PWL function (i.e., less than x_array[0] or greater than x_array[n], where n is the largest user-specified coordinate index), the PWL Controlled Source model extends the slope found between the lowest two coordinate pairs and the highest two coordinate pairs. This has the effect of making the transfer function completely linear for "in" less than x_array[0] and "in" greater than x_array[n]. It also has the potentially subtle effect of unreabstically causing an output to reach a very large or small value for large inputs. You should thus keep in mind that the PWL Source does not inherently provide a limiting capability.

In order to diminish the potential for nonconvergence of simulations when using the PWL block, a form of smoothing around the x_array, y_array coordinate points is necessary. This is due to the iterative nature of the simulator and its reliance on smooth first derivatives of transfer functions in order to arrive at a matrix solution. Consequently, the "input .domain" and "fraction" parameters are included to allow you some control over the amount and nature of the smoothing performed.

"Fraction" is a switch that is either TRUE or FALSE. When TRUE (the default setting), the simulator assumes that the specified input.domain value is to be interpreted as a fractional figure. Otherwise, it is interpreted as an absolute value. Thus, if fraction=TRUE and input_domain=0.10, The simulator assumes that the smoothing radius about each coordinate point is to be set equal to 107. of the length of cither the x_array segment above each coordinate point, or the x_array segment below each coordinate point. The specific segment length chosen will be the smallest of these two for each coordinate point.

On the other hand, if fraction=FALSE and input=0.10, then the simulator will begin smoothing the transfer function at 0.10 volts (or amperes) below each x_array coordinate and will continue the smoothing process for another 0.10 volts (or amperes) above each x_array coordinate point. Since the overlap of smoothing domains is not allowed, checking is done by the model to ensure that the specified input_domain value is not excessive.

One subtle consequence of the use of the fraction=TRUE feature of the PWL Controlled Source is that, in certain cases, you may inadvertently create extreme smoothing of functions by choosing inappropriate coordinate value points. This can be demonstrated by considering a function described by three coordinate pairs, such as (-1,-1), (1,1), and (2,1). In this case, with a 10%, input_domain value specified (fraction=TRUE, input_domain=0.10), you would expect to see rounding occur between in=0.9 and in=1.1, and nowhere else. On the other hand, if you were to specify the same function using the coordinate pairs (-100,-100), (1,1) and (201,1), you would find that rounding occurs between in=-19 and in=21. Clearly in the latter case the smoothing might cause an excessive divergence from the intended linearity above and below in=1.

Description | Direction | Default Type | Allowed Types | Vector | Vector Bounds | Null Allowed |

input | IN | v | v,vd,i,id,vnam | NO | NO | |

output | OUT | v | v,vd,i,id | NO | NO |

Name | Description | Data Type | Default Value | Limits | Vector | Vector Bounds | Null Allowed |

x_array | x-element array | Real | YES | 2 / - | NO | ||

y_array | y-element array | Real | YES | 2 / - | NO | ||

input_domain | input sm. domain | Real | 0.01 | 1e-12 / 0.5 | NO | YES | |

fraction | smoothing %/abs switch | Boolean | TRUE | NO | YES |

`PWL: Allocation calloc failed!`

Generic storage allocation error.

`PWL: Violation of 50'/, rule in breakpoints!`

This error message indicates that the pwl model has an absolute value for its input_domain, and that the x_array coordinates arc so close together that the required smoothing regions would overlap. To fix the problem, you can either spread the x_array coordinates out or make the input_domain value smaller.

```
a7 2 4 xfer_cntll
.model xfer.cntll pwl(x_array=[-2.0 -1.0 2.0 4.0 5.0]
+ y_array=[-0.2 -0.2 0.1 2.0 10.0]
+ input_domain=0.05 fraction=TRUE)
```