# Copyright (c) 2010 by California Institute of Technology

# Copyright (c) 2012 by Delft University of Technology

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

# 1. Redistributions of source code must retain the above copyright

# notice, this list of conditions and the following disclaimer.

#

# 2. Redistributions in binary form must reproduce the above copyright

# notice, this list of conditions and the following disclaimer in the

# documentation and/or other materials provided with the distribution.

#

# 3. Neither the names of the California Institute of Technology nor

# the Delft University of Technology nor

# the names of its contributors may be used to endorse or promote

# products derived from this software without specific prior

# written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALTECH

# OR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

# frdata.py - frequency response data representation and functions

#

# Author: M.M. (Rene) van Paassen (using xferfcn.py as basis)

# Date: 02 Oct 12

"""

Frequency response data representation and functions.

This module contains the FRD class and also functions that operate on

FRD data.

"""

# External function declarations

from copy import copy

from warnings import warn

import numpy as np

from numpy import angle, array, empty, ones, \

real, imag, absolute, eye, linalg, where, sort

from scipy.interpolate import splprep, splev

from numpy import absolute, angle, array, empty, eye, imag, linalg, ones, \

real, sort, where

from scipy.interpolate import splev, splprep

from .lti import LTI, _process_frequency_response

from . import config

from .exception import pandas_check

from .iosys import InputOutputSystem, _process_iosys_keywords, common_timebase

from . import config

from .lti import LTI, _process_frequency_response

__all__ = ['FrequencyResponseData', 'FRD', 'frd']

dt : float, True, or None

System timebase.

See Also

--------

frd

Notes

-----

The main data members are 'omega' and 'fresp', where 'omega' is a 1D array

for a more detailed description.

"""

#

# Class attributes

#

"Needs 1 or 2 arguments; received %i." % len(args))

#

# Process key word arguments

# Process keyword arguments

#

# If data was generated by a system, keep track of that

self.sysname = kwargs.pop('sysname', None)

# If data was generated by a system, keep track of that (used when

# plotting data). Otherwise, use the system name, if given.

self.sysname = kwargs.pop('sysname', kwargs.get('name', None))

# Keep track of default properties for plotting

self.plot_phase = kwargs.pop('plot_phase', None)

"""String representation of the transfer function."""

mimo = self.ninputs > 1 or self.noutputs > 1

outstr = ['Frequency response data']

outstr = [f"{InputOutputSystem.__str__(self)}"]

for i in range(self.ninputs):

for j in range(self.noutputs):

# Convert the second argument to a frequency response function.

# or re-base the frd to the current omega (if needed)

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

# Check that the input-output sizes are consistent.

if self.ninputs != other.ninputs:

return FRD(self.fresp * other, self.omega,

smooth=(self.ifunc is not None))

else:

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

# Check that the input-output sizes are consistent.

if self.ninputs != other.noutputs:

return FRD(self.fresp * other, self.omega,

smooth=(self.ifunc is not None))

else:

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

# Check that the input-output sizes are consistent.

if self.noutputs != other.ninputs:

return FRD(self.fresp * (1/other), self.omega,

smooth=(self.ifunc is not None))

else:

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

if (self.ninputs > 1 or self.noutputs > 1 or

other.ninputs > 1 or other.noutputs > 1):

return FRD(other / self.fresp, self.omega,

smooth=(self.ifunc is not None))

else:

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

if (self.ninputs > 1 or self.noutputs > 1 or

other.ninputs > 1 or other.noutputs > 1):

------

ValueError

If `s` is not purely imaginary, because

:class:`FrequencyDomainData` systems are only defined at imaginary

frequency values.

:class:`FrequencyResponseData` systems are only defined at

imaginary values (corresponding to real frequencies).

"""

if s is None:

def feedback(self, other=1, sign=-1):

"""Feedback interconnection between two FRD objects."""

other = _convert_to_FRD(other, omega=self.omega)

other = _convert_to_frd(other, omega=self.omega)

if (self.noutputs != other.ninputs or self.ninputs != other.noutputs):

raise ValueError(

FRD = FrequencyResponseData

def _convert_to_FRD(sys, omega, inputs=1, outputs=1):

def _convert_to_frd(sys, omega, inputs=1, outputs=1):

"""Convert a system to frequency response data form (if needed).

If sys is already an frd, and its frequency range matches or

manually, as in:

>>> import numpy as np

>>> from control.frdata import _convert_to_FRD

>>> from control.frdata import _convert_to_frd

>>> omega = np.logspace(-1, 1)

>>> frd = _convert_to_FRD(3., omega) # Assumes inputs = outputs = 1

>>> frd = _convert_to_frd(3., omega) # Assumes inputs = outputs = 1

>>> frd.ninputs, frd.noutputs

(1, 1)

>>> frd = _convert_to_FRD(1., omega, inputs=3, outputs=2)

>>> frd = _convert_to_frd(1., omega, inputs=3, outputs=2)

>>> frd.ninputs, frd.noutputs

(3, 2)

sys.__class__)

def frd(*args):

"""frd(d, w)

Construct a frequency response data model.

def frd(*args, **kwargs):

"""frd(response, omega[, dt])

frd models store the (measured) frequency response of a system.

Construct a frequency response data (FRD) model.

This function can be called in different ways:

A frequency response data model stores the (measured) frequency response

of a system. This factory function can be called in different ways:

``frd(response, freqs)``

``frd(response, omega)``

Create an frd model with the given response data, in the form of

complex response vector, at matching frequency freqs [in rad/s]

complex response vector, at matching frequencies ``omega`` [in rad/s].

``frd(sys, freqs)``

``frd(sys, omega)``

Convert an LTI system into an frd model with data at frequencies

freqs.

``omega``.

Parameters

----------

response: array_like, or list

complex vector with the system response

freq: array_lik or lis

vector with frequencies

sys: LTI (StateSpace or TransferFunction)

A linear system

response : array_like or LTI system

Complex vector with the system response or an LTI system that can

be used to copmute the frequency response at a list of frequencies.

omega : array_like

Vector of frequencies at which the response is evaluated.

dt : float, True, or None

System timebase.

smooth : bool, optional

If ``True``, create an interpolation function that allows the

frequency response to be computed at any frequency within the range

of frequencies give in ``omega``. If ``False`` (default),

frequency response can only be obtained at the frequencies

specified in ``omega``.

Returns

-------

sys: FRD

New frequency response system

sys : :class:`FrequencyResponseData`

New frequency response data system.

Other Parameters

----------------

inputs, outputs : str, or list of str, optional

List of strings that name the individual signals of the transformed

system. If not given, the inputs and outputs are the same as the

original system.

name : string, optional

System name. If unspecified, a generic name <sys[id]> is generated

with a unique integer id.

See Also

--------

FRD, ss, tf

FrequencyResponseData, frequency_response, ss, tf

Examples

--------

>>> # Create from measurements

>>> response = [1.0, 1.0, 0.5]

>>> freqs = [1, 10, 100]

>>> F = ct.frd(response, freqs)

>>> omega = [1, 10, 100]

>>> F = ct.frd(response, omega)

>>> G = ct.tf([1], [1, 1])

>>> freqs = [1, 10, 100]

>>> F = ct.frd(G, freqs)

>>> omega = [1, 10, 100]

>>> F = ct.frd(G, omega)

"""

return FRD(*args)

return FrequencyResponseData(*args, **kwargs)