pyMez.Code.Analysis.Transformations API documentation
Description: Transformations is a module with tools for changing data from one format to another, while not prese...

Top

# pyMez.Code.Analysis.Transformations module

Transformations is a module with tools for changing data from one format to another, while not preserving the content. It complements pyMez.Code.DataHandlers.Translations, and can be added as jumps to graph models.

## Examples

## Requirements

- sys
- os
- re
- datetime
- math
- cmath
- numpy
- scipy
- pandas
- matplotlib
- pyMez

## Help

`pyMez.Code.Analysis`

Documentation Home | API Documentation Home | Examples Home | Index

Show source ≡

    #-----------------------------------------------------------------------------
    # Name:        Transformations
    # Purpose:    To hold data manipulations that change the content.
    # Author:      Aric Sanders
    # Created:     2/27/2018
    # License:     MIT License
    #-----------------------------------------------------------------------------
    """ Transformations is a module with tools for changing data from one format to another, while not
    preserving the content. It complements pyMez.Code.DataHandlers.Translations, and can be added as jumps to graph models.

     Examples
    --------
        #!python

    Requirements
    ------------
    + [sys](https://docs.python.org/2/library/sys.html)
    + [os](https://docs.python.org/2/library/os.html)
    + [re](https://docs.python.org/2/library/re.html)
    + [datetime](https://docs.python.org/2/library/datetime.html)
    + [math](https://docs.python.org/2/library/math.html)
    + [cmath](https://docs.python.org/2/library/cmath.html)
    + [numpy](https://docs.scipy.org/doc/)
    + [scipy](https://docs.scipy.org/doc/)
    + [pandas](http://pandas.pydata.org/)
    + [matplotlib](http://matplotlib.org/)
    + [pyMez](https://github.com/aricsanders/pyMez)

    Help
    ---------------
    <a href="./index.html">`pyMez.Code.Analysis`</a>
    <div>
    <a href="../../../pyMez_Documentation.html">Documentation Home</a> |
    <a href="../../index.html">API Documentation Home</a> |
    <a href="../../../Examples/html/Examples_Home.html">Examples Home</a> |
    <a href="../../../Reference_Index.html">Index</a>
    </div>
      """
    #-----------------------------------------------------------------------------
    # Standard Imports
    import sys
    import os
    #-----------------------------------------------------------------------------
    # Third Party Imports
    sys.path.append(os.path.join(os.path.dirname( __file__ ), '..','..'))
    try:
        from Code.DataHandlers.GeneralModels import *
    except:
        print("The module pyMez.Code.DataHandlers.GeneralModels was not found or had an error,"
              "please check module or put it on the python path")
        raise ImportError
    try:
        from Code.DataHandlers.TouchstoneModels import *
    except:
        print("The module pyMez.Code.DataHandlers.TouchstoneModels was not found or had an error,"
              "please check module or put it on the python path")
        raise ImportError
    #-----------------------------------------------------------------------------
    # Module Constants

    #-----------------------------------------------------------------------------
    # Module Functions
    def SixteenTerm_to_EightTermList(s4p_model):
        """Returns two s2p's of the error boxes, with s2p number 1, the same as S11,S13,S31,S33 of error adaptor and
        s2p number 2 as S22,S24,S42,S44 of error adaptor"""
        # sparameter_complex=[Frequency[0],S11[1],S12[2],S13[3],S14[4],S21[5],S22[6],S23[7],S24[8],S31[9],
        # S32[10],S33[11],S34[12],S41[13],S42[14],S43[15],S44[16]]
        s2p_1_complex=[[row[0],row[1],row[3],row[9],row[11]] for row in s4p_model.sparameter_complex]
        s2p_2_complex=[[row[0],row[6],row[8],row[14],row[16]] for row in s4p_model.sparameter_complex]
        s2p_1=S2PV1(sparameter_complex=s2p_1_complex)
        s2p_2=S2PV1(sparameter_complex=s2p_2_complex)
        return [s2p_1,s2p_2]

    def W2p_to_SwitchTerms(w2p):
        """Creates a s2p with switch terms in port1 (reverse), port2 (foward) format given a w2p of a thru."""
        reA1_D2_index=w2p.column_names.index("reA1_D2")
        imA1_D2_index=w2p.column_names.index("imA1_D2")
        reB1_D2_index=w2p.column_names.index("reB1_D2")
        imB1_D2_index=w2p.column_names.index("imB1_D2")
        port_1=[complex(row[reA1_D2_index],row[imA1_D2_index])/complex(row[reB1_D2_index],row[imB1_D2_index]) for row in w2p.data]
        reA2_D1_index=w2p.column_names.index("reA2_D1")
        imA2_D1_index=w2p.column_names.index("imA2_D1")
        reB2_D1_index=w2p.column_names.index("reB2_D1")
        imB2_D1_index=w2p.column_names.index("imB2_D1")
        port_2=[complex(row[reA2_D1_index],row[imA2_D1_index])/complex(row[reB2_D1_index],row[imB2_D1_index]) for row in w2p.data]
        complex_sparameters=[]
        for row_index,row in enumerate(w2p.data[:]):
            new_row=[row[0],port_1[row_index],port_2[row_index]]+[complex(0,0),complex(0,0)]
            complex_sparameters.append(new_row)
        s2p_out=S2PV1(None,sparameter_complex=complex_sparameters)
        return s2p_out

    def W2p_to_S2p(w2p):
        """Creates a s2p with given a w2p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1...imB2_D2]
        Returns the 3 -reciever sparameters or b1/a1 etc."""
        complex_sparameters=[]
        for row_index,row in enumerate(w2p.data[:]):
            # B1_D1/A1_D1
            S11=complex(row[3],row[4])/complex(row[1],row[2])
            # B2_D1/A1_D1
            S21=complex(row[7],row[8])/complex(row[1],row[2])
            # B1_D2/A2_D2
            S12=complex(row[11],row[12])/complex(row[13],row[14])
            # B2_D2/A2_D2
            S22=complex(row[15],row[16])/complex(row[13],row[14])
            new_row=[row[0],S11,S12,S21,S22]
            complex_sparameters.append(new_row)
        s2p_out=S2PV1(None,sparameter_complex=complex_sparameters)
        return s2p_out

    def W1p_to_S1p(w1p):
        """Creates a s1p with given a w1p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1]
        returns a S1PV1 model with columns [Frequency,reS11,imS11]"""
        complex_sparameters=[]
        for row_index,row in enumerate(w1p.data[:]):
            # B1_D1/A1_D1
            S11=complex(row[3],row[4])/complex(row[1],row[2])
            new_row=[row[0],S11]
            complex_sparameters.append(new_row)
        s1p_out=S1PV1(None,sparameter_complex=complex_sparameters)
        return s1p_out

    def S2p_to_S1p(s2p,column="S11"):
        """Creates an s1p from an s2p by taking column and frequency, column can be any value in ["S11","S21","S12","S22"]"""
        columns=["S11","S21","S12","S22"]
        s2p.change_data_format("RI")
        index=columns.index(column)+1
        sparameter_complex=[]
        for row_index,row in enumerate(s2p.sparameter_complex[:]):
            sparameter_complex.append([row[0],row[index]])
        options=s2p.options.copy()
        options["column_names"]=["Frequency","reS11","imS11"]
        options["sparameter_complex"]=sparameter_complex
        options["number_ports"]=1
        options["extension"]="s1p"
        s1p_out=S1PV1(None,**options)
        return s1p_out

    def S1ps_to_S2p(S11_s1p,S22_s1p,S21_fill_value=complex(0,0)):
        """Creates an s2p from two s1ps by filling S11 with S11_s1p and S22 with S22_s1p and S21, and S12 with S21_fill_value,
        Default is 0+ 0i. Assumes both have the same frequency list. """
        #first make sure both s1p 's  are in the right format
        S11_s1p.change_data_format("RI")
        S22_s1p.change_data_format("RI")
        #check the frequency lists
        if len(S11_s1p.data)!=len(S22_s1p.data):
            raise
        sparameter_complex=[]
        for row_index, row in enumerate(S11_s1p.data):
            new_row=[row[0],
                     complex(row[1],row[2]),
                     S21_fill_value,
                     S21_fill_value,
                     complex(S22_s1p.data[row_index][1],S22_s1p.data[row_index][2])]
            sparameter_complex.append(new_row)
        options={}
        options["sparameter_complex"]=sparameter_complex
        s2p=S2PV1(None,**options)
        return s2p

    #-----------------------------------------------------------------------------
    # Module Classes

    #-----------------------------------------------------------------------------
    # Module Scripts

    #-----------------------------------------------------------------------------
    # Module Runner
    if __name__ == '__main__':
        pass

## Functions

def S1ps_to_S2p(

S11_s1p, S22_s1p, S21_fill_value=0j)

Creates an s2p from two s1ps by filling S11 with S11_s1p and S22 with S22_s1p and S21, and S12 with S21_fill_value, Default is 0+ 0i. Assumes both have the same frequency list.

Show source ≡

    def S1ps_to_S2p(S11_s1p,S22_s1p,S21_fill_value=complex(0,0)):
        """Creates an s2p from two s1ps by filling S11 with S11_s1p and S22 with S22_s1p and S21, and S12 with S21_fill_value,
        Default is 0+ 0i. Assumes both have the same frequency list. """
        #first make sure both s1p 's  are in the right format
        S11_s1p.change_data_format("RI")
        S22_s1p.change_data_format("RI")
        #check the frequency lists
        if len(S11_s1p.data)!=len(S22_s1p.data):
            raise
        sparameter_complex=[]
        for row_index, row in enumerate(S11_s1p.data):
            new_row=[row[0],
                     complex(row[1],row[2]),
                     S21_fill_value,
                     S21_fill_value,
                     complex(S22_s1p.data[row_index][1],S22_s1p.data[row_index][2])]
            sparameter_complex.append(new_row)
        options={}
        options["sparameter_complex"]=sparameter_complex
        s2p=S2PV1(None,**options)
        return s2p

def S2p_to_S1p(

s2p, column='S11')

Creates an s1p from an s2p by taking column and frequency, column can be any value in ["S11","S21","S12","S22"]

Show source ≡

    def S2p_to_S1p(s2p,column="S11"):
        """Creates an s1p from an s2p by taking column and frequency, column can be any value in ["S11","S21","S12","S22"]"""
        columns=["S11","S21","S12","S22"]
        s2p.change_data_format("RI")
        index=columns.index(column)+1
        sparameter_complex=[]
        for row_index,row in enumerate(s2p.sparameter_complex[:]):
            sparameter_complex.append([row[0],row[index]])
        options=s2p.options.copy()
        options["column_names"]=["Frequency","reS11","imS11"]
        options["sparameter_complex"]=sparameter_complex
        options["number_ports"]=1
        options["extension"]="s1p"
        s1p_out=S1PV1(None,**options)
        return s1p_out

def SixteenTerm_to_EightTermList(

s4p_model)

Returns two s2p's of the error boxes, with s2p number 1, the same as S11,S13,S31,S33 of error adaptor and s2p number 2 as S22,S24,S42,S44 of error adaptor

Show source ≡

    def SixteenTerm_to_EightTermList(s4p_model):
        """Returns two s2p's of the error boxes, with s2p number 1, the same as S11,S13,S31,S33 of error adaptor and
        s2p number 2 as S22,S24,S42,S44 of error adaptor"""
        # sparameter_complex=[Frequency[0],S11[1],S12[2],S13[3],S14[4],S21[5],S22[6],S23[7],S24[8],S31[9],
        # S32[10],S33[11],S34[12],S41[13],S42[14],S43[15],S44[16]]
        s2p_1_complex=[[row[0],row[1],row[3],row[9],row[11]] for row in s4p_model.sparameter_complex]
        s2p_2_complex=[[row[0],row[6],row[8],row[14],row[16]] for row in s4p_model.sparameter_complex]
        s2p_1=S2PV1(sparameter_complex=s2p_1_complex)
        s2p_2=S2PV1(sparameter_complex=s2p_2_complex)
        return [s2p_1,s2p_2]

def W1p_to_S1p(

w1p)

Creates a s1p with given a w1p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1] returns a S1PV1 model with columns [Frequency,reS11,imS11]

Show source ≡

    def W1p_to_S1p(w1p):
        """Creates a s1p with given a w1p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1]
        returns a S1PV1 model with columns [Frequency,reS11,imS11]"""
        complex_sparameters=[]
        for row_index,row in enumerate(w1p.data[:]):
            # B1_D1/A1_D1
            S11=complex(row[3],row[4])/complex(row[1],row[2])
            new_row=[row[0],S11]
            complex_sparameters.append(new_row)
        s1p_out=S1PV1(None,sparameter_complex=complex_sparameters)
        return s1p_out

def W2p_to_S2p(

w2p)

Creates a s2p with given a w2p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1...imB2_D2] Returns the 3 -reciever sparameters or b1/a1 etc.

Show source ≡

    def W2p_to_S2p(w2p):
        """Creates a s2p with given a w2p assumes data columns are [Frequency,reA1_D1,imA1_D1,reB1_D1,imB1_D1...imB2_D2]
        Returns the 3 -reciever sparameters or b1/a1 etc."""
        complex_sparameters=[]
        for row_index,row in enumerate(w2p.data[:]):
            # B1_D1/A1_D1
            S11=complex(row[3],row[4])/complex(row[1],row[2])
            # B2_D1/A1_D1
            S21=complex(row[7],row[8])/complex(row[1],row[2])
            # B1_D2/A2_D2
            S12=complex(row[11],row[12])/complex(row[13],row[14])
            # B2_D2/A2_D2
            S22=complex(row[15],row[16])/complex(row[13],row[14])
            new_row=[row[0],S11,S12,S21,S22]
            complex_sparameters.append(new_row)
        s2p_out=S2PV1(None,sparameter_complex=complex_sparameters)
        return s2p_out

def W2p_to_SwitchTerms(

w2p)

Creates a s2p with switch terms in port1 (reverse), port2 (foward) format given a w2p of a thru.

Show source ≡

    def W2p_to_SwitchTerms(w2p):
        """Creates a s2p with switch terms in port1 (reverse), port2 (foward) format given a w2p of a thru."""
        reA1_D2_index=w2p.column_names.index("reA1_D2")
        imA1_D2_index=w2p.column_names.index("imA1_D2")
        reB1_D2_index=w2p.column_names.index("reB1_D2")
        imB1_D2_index=w2p.column_names.index("imB1_D2")
        port_1=[complex(row[reA1_D2_index],row[imA1_D2_index])/complex(row[reB1_D2_index],row[imB1_D2_index]) for row in w2p.data]
        reA2_D1_index=w2p.column_names.index("reA2_D1")
        imA2_D1_index=w2p.column_names.index("imA2_D1")
        reB2_D1_index=w2p.column_names.index("reB2_D1")
        imB2_D1_index=w2p.column_names.index("imB2_D1")
        port_2=[complex(row[reA2_D1_index],row[imA2_D1_index])/complex(row[reB2_D1_index],row[imB2_D1_index]) for row in w2p.data]
        complex_sparameters=[]
        for row_index,row in enumerate(w2p.data[:]):
            new_row=[row[0],port_1[row_index],port_2[row_index]]+[complex(0,0),complex(0,0)]
            complex_sparameters.append(new_row)
        s2p_out=S2PV1(None,sparameter_complex=complex_sparameters)
        return s2p_out

## Module variables

var COMMENT_PATTERN

var DEFAULT_FILE_NAME

var EXTENSION_PATTERN

var FORMATS

var FREQUENCY_UNITS

var GENERAL_DESCRIPTORS

var METHOD_ALIASES

var MINIMUM_DB_ARG_VALUE

var MINIMUM_DB_VALUE

var NUMBER_MATCH_STRING

var OPTION_LINE_PATTERN

var PARAMETERS

var S1P_DB_COLUMN_NAMES

var S1P_MA_COLUMN_NAMES

var S1P_RI_COLUMN_NAMES

var S2P_COMPLEX_COLUMN_NAMES

var S2P_DB_COLUMN_DESCRIPTION

var S2P_DB_COLUMN_NAMES

var S2P_MA_COLUMN_DESCRIPTION

var S2P_MA_COLUMN_NAMES

var S2P_NOISE_PARAMETER_COLUMN_NAMES

var S2P_RI_COLUMN_DESCRIPTION

var S2P_RI_COLUMN_NAMES

var SMITHPLOT

var TESTS_DIRECTORY

var TOUCHSTONE_KEYWORDS

var type_names