PyGFETdb package

Subpackages

• PyGFETdb.GuiDBView package
  • Submodules
  • PyGFETdb.GuiDBView.GuiDBView module
  • Module contents

Submodules

PyGFETdb.AnalysisFunctions module

@author: dragc 25/10/19 22:48.

Analysis Functions that do not fit in the previous files.

PyGFETdb.AnalysisFunctions.PrintSummaryPerGroup(iwf, iwfo, perfectc, okc, ic, Classc)

PyGFETdb.AnalysisFunctions.PrintSummaryPerSubGroup(iwf, iwfo, itype, itypeo, perfectc, okc, ic, Classc)

PyGFETdb.AnalysisFunctions.calculateNoise(Fpsd, NoA, NoB, NoC)

PyGFETdb.AnalysisFunctions.getTrtClass(perfect, ok, grad, low=-1, high=0, **kwargs)

Parameters:

• perfect –
• ok –
• grad –
• low –
• high –
• kwargs –

Returns:

1 : 1/f (FIT) and low < gradient < high 2 : Limited by Electronics (FIT) and gradient < low < high 3 : Thermal Noise (NOK) 0 : gradient > 0

PyGFETdb.AnalysisFunctions.isMeanPSDOk(Fpsd, PSD, noise, meanfluctuation=None, meanpeak=None, meangradient=None, meangradientmean=None, fiterror=None, fitgradient=None, **kwargs)

PyGFETdb.AnalysisFunctions.isPSDok(PSD, Fpsd, noise, fluctuation=0.043, peak=0.58, gradient=5e-19, gradientmean=0.5, fiterror=0.3, minfitgradient=5e-21, maxfitgradient=1e-20, normalization=None, **kwargs)

Parameters:

• PSD – PSD of a Group
• Fpsd – Fpsd of a Group
• noise – Noise
• fluctuation – Maximum change allowed between the maximum value and the minimum value
• peak – Maximum change allowed between the maximum value and the mean value
• gradient – Maximum gradient allowed
• fiterror – Maximum error allowed in the fit
• fitgradient – Maximum error allowed in the gradient of the fit

Returns:

ok: True if the noise is fitted well

Returns:

perfect: True if the PSD gradient is acceptable

Returns:

grad: PSD gradient

Returns:

noisegrad: Noise gradient

PyGFETdb.AnalysisFunctions.printReport(perfect, perfect1, perfect2, perfect3, perfect4, ok, ok1, ok2, maxfluct, maxpeak, graderror, mgrad, fitmaxerr, fitmaxgraderror, printbad=True, printok=True, **kwargs)

PyGFETdb.AnalysisFunctions.printReportPerSubgroup(perfect, ok, grad, **kwargs)

PyGFETdb.AnalysisFunctions.processAllNoise(PSD, Fpsd, NoA, NoB, NoC, **kwargs)

PyGFETdb.AnalysisFunctions.processAllNoiseGroup(PSD, Fpsd, NoA, NoB, NoC, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processAllPSDsPerGroup(rPSD, HaltOnFail=False, meanpsd=True, **kwargs)

Parameters:

• rPSD – Results of a param search of PSD, Fpsd, NoA and NoB
• fluctuation – Maximum change allowed between the maximum value and the minimum value
• peak – Maximum change allowed between the maximum value and the mean value
• gradient – Maximum gradient allowed
• fiterror – Maximum error allowed in the fit
• fitgradient – Maximum error allowed in the gradient of the fit

Returns:

A dict with the results of the processing

PyGFETdb.AnalysisFunctions.processAllPSDsPerSubgroup(GrTypes, rPSD, **kwargs)

Parameters:

• GrTypes – Group to process
• rPSD – Results of a param search of PSD, Fpsd, NoA and NoB
• fluctuation – Maximum change allowed between the maximum value and the minimum value
• peak – Maximum change allowed between the maximum value and the mean value
• gradient – Maximum gradient allowed
• fiterror – Maximum error allowed in the fit
• fitgradient – Maximum error allowed in the gradient of the fit

Returns:

A dict with the results of the processing

PyGFETdb.AnalysisFunctions.processIsPSDok(psd, psdi, noise, Fpsd, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processListPSDlist(Fpsd, mPSD, noise, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processNoA(PSD, Fpsd, NoA, NoB, NoC, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processNoAlist(PSD, Fpsd, NoA, NoB, NoC, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processPSDSubgroup(Fpsdt, PSDt, NoAt, NoBt, HaltOnFail=None, **kwargs)

PyGFETdb.AnalysisFunctions.processPSDlist(Fpsd, mPSD, noise, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.processSubGroup(Fpsd, PSD, NoA, NoB, ic, it, okc, okct, perfectc, perfectct, iwf, iwfo, itype, itypeo, results, nType, Classc, HaltOnFail=False, meanpsd=True, **kwargs)

PyGFETdb.AnalysisFunctions.processVgs(PSD, Fpsd, noise, HaltOnFail=False, **kwargs)

PyGFETdb.AnalysisFunctions.reshapePSD(PSD, NoA)

PyGFETdb.AnalyzeData module

@author: Anton Guimerà @version: 0.1b

Revsion history

• 0.1b – First version

TODO implement graph for selected channels

PyGFETdb.AnalyzeData.CalcDCparams(DevDC)

PyGFETdb.AnalyzeData.CalcGM(DevDC, DevAC=None, Order=10)

PyGFETdb.AnalyzeData.CalcGMCh(DCdat, ACdat=None, Order=10)

PyGFETdb.AnalyzeData.CalcNoiseIrms(Dev, Fmin=None, Fmax=None, IsOkFilt=True)

PyGFETdb.AnalyzeData.CalcNoiseIrmsCh(ChDat, Fmin=None, Fmax=None, IsOkFilt=True)

PyGFETdb.AnalyzeData.CheckIsOK(DevDC, DevAC=None, RdsRange=[400, 10000.0])

PyGFETdb.AnalyzeData.FitACNoise(Dev, Fmin=None, Fmax=None, IsOkFilt=True)

PyGFETdb.AnalyzeData.InterpolatePSD(DevACVals, Points=100, Process50Hz=False)

Interpolates the PSD

Parameters:

• DevACVals – Data to interpolate
• Points – Number of points to interpolate
• Process50Hz – Remove noise on 50Hz

Returns:

None

PyGFETdb.DB module

Created on Tue Feb 20 13:42:01 2018

@author: aguimera

PyGFETdb.DBAnalyze module

Created on Tue Jun 27 15:08:05 2017

@author: aguimera

PyGFETdb.DBAnalyze.CalcTLM(Groups, Vds=None, Ax=None, Color=None, DebugPlot=False, Label=None, **kwargs)

PyGFETdb.DBAnalyze.CalcTLM2(Groups, Vds=None, Ax=None, Color=None, DebugPlot=False, Label=None, Lerror=4e-07, TrackResistance=None, **kwargs)

PyGFETdb.DBAnalyze.CreateCycleColors(Vals)

PyGFETdb.DBAnalyze.GetParam(Data, Param, Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

PyGFETdb.DBAnalyze.PlotGroupBy(GroupBase, GroupBy, **kwargs)

PyGFETdb.DBAnalyze.PlotGroupBySearchAndGetParam(GroupBase, GroupBy, **kwargs)

PyGFETdb.DBAnalyze.PlotMeanStd(Data, Xvar, Yvar, Vgs=None, Vds=None, Ax=None, Ud0Norm=True, Color='r', PlotOverlap=False, PlotOverlapMean=False, PlotStd=True, label=None, ScaleFactor=1, **kwargs)

PyGFETdb.DBAnalyze.PlotXYVars(Data, Xvar, Yvar, Vgs, Vds, Ud0Norm=True, label=None, Ax=None, Color=None, **kwargs)

PyGFETdb.DBAnalyze.SearchAndGetParam(Groups, Plot=True, Boxplot=False, ParamUnits=None, **kwargs)

PyGFETdb.DBAnalyze.SearchAndPlot(Groups, Func=<function PlotMeanStd>, **kwargs)

PyGFETdb.DBCore module

Created on Tue Nov 15 23:15:19 2016

@author: aguimera

class PyGFETdb.DBCore.PyFETdb(host=None, user=None, passwd=None, db=None, Update=True)

Bases: PyGFETdb.DBCore._PyFETdb

Subclass maintained by dragc for db optimisation tests

PyGFETdb.DBSearch module

Created on Fri Jan 12 13:12:37 2018

@author: aguimera

PyGFETdb.DBSearch.CheckConditionsCharTable(Conditions, Table)

PyGFETdb.DBSearch.DataSelection(Data, Param, Range, Function=None, InSide=True, Name=None, Units=None, ParArgs={'Ud0Norm': False, 'Units': None, 'Vds': None, 'Vgs': None})

PyGFETdb.DBSearch.FindCommonValues(Parameter, Conditions, Table='ACcharacts', **kwargs)

PyGFETdb.DBSearch.GenBiosensGroups(CondBase, GroupBy='CharTable.FuncStep', AnalyteStep='Tromb', AnalyteGroupBy='CharTable.AnalyteCon')

PyGFETdb.DBSearch.GenGroups(GroupBase, GroupBy, LongName=True)

PyGFETdb.DBSearch.GetFromDB(Conditions, Table='ACcharacts', Last=True, GetGate=True, OutilerFilter=None, DataSelectionConfig=None, remove50Hz=False)

Get data from data base

This function returns data which meets with “Conditions” dictionary for sql select query constructor.

Parameters:Conditions – dictionary, conditions to construct the sql select query.

The dictionary should follow this structure:

{‘Table.Field <sql operator>’ : iterable type of values}

• Example:

  {‘Wafers.Name = ‘:(B10803W17, B10803W11),’CharTable.IsOK > ‘:(0,)}

Parameters:Table – string, optional.

Posible values ‘ACcharacts’ or ‘DCcharacts’.

The default value is ‘ACcharacts’. Characterization table to get data

The characterization table of Conditions dictionary can be indicated as ‘CharTable’. In that case ‘CharTable’ will be replaced by Table value.

Parameters:Last – boolean, optional.

If True (default value) just the last measured data for each transistor is returned.

If False, all measured data is returned

Parameters:Last – boolean, optional.

If True (default value) the gate measured data is also obtained

Parameters:OutilerFilter – dictionary, optional. (default ‘None’),

If defined, dictionary to perform a statistical pre-evaluation of the data.

The data that are not between the p25 and p75 percentile are not returned.

The dictionary should follow this structure:

{‘Param’:Value, –> Characterization parameter, ie. ‘Ids’, ‘Vrms’…

‘Vgs’:Value, –> Vgs evaluation point

‘Vds’:Value, –> Vds evaluationd point

‘Ud0Norm’:Boolean} –> Indicates if Vgs is normalized to CNP

Parameters:remove50Hz – bool to activate the removal of frequency 50Hz Returns:A Dictionary with the data arranged as follows:

{‘Transistor Name’:list of PyGFET.DataClass.DataCharAC classes}

Returns:A List of transistors

PyGFETdb.DBSearch.RemoveOutilers(Data, OutilerFilter)

PyGFETdb.DBSearch.UpdateCharTableField(Conditions, Value, Table='ACcharacts', Field='Comments')

PyGFETdb.DataClass module

Created on Fri Jun 16 17:43:50 2017

@author: aguimera

class PyGFETdb.DataClass.DataCharAC(Data, remove50Hz=False, **kwargs)

Bases: PyGFETdb.DataClass.DataCharDC

CalcIRMS(Fmin, Fmax, **kwargs)

FFmax = None

FFmin = None

FitNoise(Fmin, Fmax)

GetFgm(**kwargs)

GetFpsd(**kwargs)

GetGmMag(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetGmPh(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIrms(Vgs=None, Vds=None, Ud0Norm=False, NFmin=None, NFmax=None, **kwargs)

GetIrmsIds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIrmsIds15(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIrmsIds2(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIrmsVds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetNoA(Vgs=None, Vds=None, Ud0Norm=False, FFmin=None, FFmax=None, **kwargs)

GetNoAIds2(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetNoB(Vgs=None, Vds=None, Ud0Norm=False, FFmin=None, FFmax=None, **kwargs)

GetNoC(Vgs=None, Vds=None, Ud0Norm=False, FFmin=None, FFmax=None, **kwargs)

GetPSD(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetVrms(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

NFmax = None

NFmin = None

class PyGFETdb.DataClass.DataCharDC(Data, remove50Hz=False, **kwargs)

Bases: object

CalcFEM(FEMn0=800000000000.0, FEMq=1.602176565e-19, FEMRc=300, FEMCdl=2e-06, FEMRcVgs=None, **kwargs)

CalcGMPoly(PolyOrder=None)

CalcIdsPoly(PolyOrder=None)

CalcUd0()

CheckVgsRange(Vgs, iVds, Ud0Norm)

GetAnalyteCon(**kwargs)

GetComments(**kwargs)

GetContact(**kwargs)

GetDateTime(**kwargs)

GetFEMmu(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetFEMmuGm(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetFEMn(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetFuncStep(**kwargs)

GetGM(Vgs=None, Vds=None, Normalize=False, Ud0Norm=False, **kwargs)

GetGMMax(**kwargs)

GetGMNorm(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetGMV(AbsVal=True, **kwargs)

GetGds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIg(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetIonStrength(**kwargs)

GetLength(**kwargs)

GetName(**kwargs)

GetPass(**kwargs)

GetPh(**kwargs)

GetRds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetTime(**kwargs)

GetTypeName(**kwargs)

GetUd0(Vds=None, Vgs=None, Ud0Norm=False, Normalize=False, **kwargs)

GetUd0Vds(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetVds(**kwargs)

GetVdsIndexes(Vds)

GetVgs(Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

GetWL(**kwargs)

GetWidth(**kwargs)

IntMethod = 'linear'

PolyOrder = 10

UpdateData(Data)

PyGFETdb.DataClass.FitFNoise(Freq, psd)

PyGFETdb.DataClass.FitLogFnoise(Freq, psd)

PyGFETdb.DataClass.FitLogFnoiseTh(Freq, psd)

PyGFETdb.DataClass.Fnoise(f, a, b)

PyGFETdb.DataClass.FnoiseTh(f, a, b, c)

PyGFETdb.DataClass.LogFnoise(f, a, b)

PyGFETdb.DataClass.process50Hz(Array, process)

Removes the frequency 50Hz

Parameters:

• Array – array of frequencies
• process – bool that activates the function

Returns:

the array without the frequency 50Hz

PyGFETdb.DataClass.process60Hz(Array, process)

Removes the frequency 60Hz

Parameters:

• Array – array of frequencies
• process – bool that activates the function

Returns:

the array without the frequency 50Hz

PyGFETdb.DataClass.processBelow10Hz(Array, process)

Removes the frequencies below 1Hz

Parameters:

• Array – array of frequencies
• process – bool that activates the function

Returns:

the array without the frequencies below 1Hz

PyGFETdb.DataClass.processFreqs(Array, process)

Removes all the unwanted frequencies

Parameters:

• Array – array of frequencies
• process – bool that activates the function

Returns:

the array without the unwanted frequencies

PyGFETdb.DataClass.processHiFreqs(Array, process)

Removes the higher frequencies

Parameters:

• Array – array of frequencies
• process – bool that activates the function

Returns:

the array without the higher frequencies

PyGFETdb.DataStructures module

@author: Anton Guimerà @version: 0.1b

Revsion history

• 0.1b – First version

TODO implement graph for selected channels

PyGFETdb.DataStructures.InitACRecord(nVds, nVgs, nFgm, nFpsd, ChNames)

PyGFETdb.DataStructures.InitDCRecord(nVds, nVgs, ChNames, Gate=True)

PyGFETdb.DataStructures.LoadDataFromFile(FileName)

PyGFETdb.GlobalFunctions module

@author: dragc 25/10/19 22:48.

Global Functions that do not fit in the previous files.

PyGFETdb.GlobalFunctions.remove(Valx, index)

Removes the value at the index specified from an array

Parameters:

• Valx – array to remove the value
• index – index to remove the value

Returns:

the array without the value at the index specified

PyGFETdb.GlobalFunctions.updateDictOfLists(dict, key, value)

Modifies a dictionary of lists, appending the value at the list obtained of applying the key to the dictionary

Parameters:

• dict – A dictionary to update
• key – The key to update
• value – The value to append

Returns:

None

PyGFETdb.Multiprocessing module

@author: dragc

PyGFETdb.Multiprocessing.DataSelection(Data, Param, Range, Function=None, InSide=True, Name=None, Units=None, ParArgs={'Ud0Norm': False, 'Units': None, 'Vds': None, 'Vgs': None})

PyGFETdb.Multiprocessing.GetFromDB(Conditions, Table='ACcharacts', Last=True, GetGate=True, OutilerFilter=None, DataSelectionConfig=None, remove50Hz=False)

Get data from data base

This function returns data which meets with “Conditions” dictionary for sql select query constructor.

Parameters:Conditions – dictionary, conditions to construct the sql select query.

The dictionary should follow this structure:

{‘Table.Field <sql operator>’ : iterable type of values}

• Example:

  {‘Wafers.Name = ‘:(B10803W17, B10803W11),’CharTable.IsOK > ‘:(0,)}

Parameters:Table – string, optional.

Posible values ‘ACcharacts’ or ‘DCcharacts’.

The default value is ‘ACcharacts’. Characterization table to get data

The characterization table of Conditions dictionary can be indicated as ‘CharTable’. In that case ‘CharTable’ will be replaced by Table value.

Parameters:Last – boolean, optional.

If True (default value) just the last measured data for each transistor is returned.

If False, all measured data is returned

Parameters:Last – boolean, optional.

If True (default value) the gate measured data is also obtained

Parameters:OutilerFilter – dictionary, optional. (default ‘None’),

If defined, dictionary to perform a statistical pre-evaluation of the data.

The data that are not between the p25 and p75 percentile are not returned.

The dictionary should follow this structure:

{‘Param’:Value, –> Characterization parameter, ie. ‘Ids’, ‘Vrms’…

‘Vgs’:Value, –> Vgs evaluation point

‘Vds’:Value, –> Vds evaluationd point

‘Ud0Norm’:Boolean} –> Indicates if Vgs is normalized to CNP

Parameters:remove50Hz – bool to activate the removal of frequency 50Hz Returns:A Dictionary with the data arranged as follows:

{‘Transistor Name’:list of PyGFET.DataClass.DataCharAC classes}

Returns:A List of transistors

PyGFETdb.Multiprocessing.GetParam(Data, Param, Vgs=None, Vds=None, Ud0Norm=False, **kwargs)

Multiprocessing Version of GetParam

Parameters:

• Data –
• Param –
• Vgs –
• Vds –
• Ud0Norm –
• kwargs –

Returns:

PyGFETdb.Multiprocessing.GetParams(ResultsDB, GrWfs, args: dict, **kwargs)

Parameters:

• ResultsDB – The results of a search in the database
• Group – A group of conditions to analyse
• args – Arguments for getting the parameters
• Plot – Bool that activates plotting
• kwargs –

Returns:

A dict of args of dicts of groupnames and parameter found in a previous search

PyGFETdb.Multiprocessing.GetParams_MP(ResultsDB, GrWfs, arguments, **kwargs)

Parameters:

• ResultsDB – The results of a search in the database
• Group – A group of conditions to analyse
• args – Arguments for getting the parameters
• Plot – Bool that activates plotting
• kwargs –

Returns:

A dict of args of dicts of groupnames and parameter found in a previous search

PyGFETdb.Multiprocessing.SearchDB(GrWfs, **kwargs)

Parameters:Group – A group of conditions Returns:The results of the search in the database

PyGFETdb.Multiprocessing.SearchDB_MP(GrWfs, **kwargs)

Parameters:Group – A group of conditions Returns:The results of the search in the database

PyGFETdb.Multiprocessing.checkRanges(Val, Units, Range, InSide)

PyGFETdb.Multiprocessing.processGetFromDB(results)

Gathers the results of different processes after a search in the database

Parameters:results – Results obtained with multi-processing from the database Returns:All the results from the search gathered in a tuple

PyGFETdb.Multiprocessing.processGetParams_MP(GrWfs, Results, args)

Parameters:

• GrWfs – A group of conditions
• Results – The results of the parameter search
• args – a dict with the parameters to be searched

Returns:

The results ordered by parameter

PyGFETdb.Multiprocessing.processOneArg(GrWfs, Results, Ret, karg)

Parameters:

• GrWfs – A group of conditions
• Results – Results of the parameter search
• Ret – A dict to update with Eesults
• karg – Key-name of the argument to process

Returns:

None but modifies Ret dict

PyGFETdb.Multiprocessing.processResults(Results, args)

Parameters:

• Results – results to classify
• args – arguments to search

Returns:

A dict of arguments with each corresponding result

PyGFETdb.NoiseModel module

@author: Anton Guimerà @version: 0.1b

Revsion history

• 0.1b – First version

PyGFETdb.NoiseModel.CalcFreqIndexes(Freq, Fmin=None, Fmax=None)

PyGFETdb.NoiseModel.FitFNoise(Freq, psd, Fmin=None, Fmax=None)

return a, b, pcov

PyGFETdb.NoiseModel.FitLogFnoise(Freq, psd, Fmin=None, Fmax=None)

PyGFETdb.NoiseModel.FitNoise(Freq, psd, Fmin=None, Fmax=None)

PyGFETdb.NoiseModel.Fnoise(f, a, b)

return a/f^b

PyGFETdb.NoiseModel.FnoiseTh(f, a, b, c)

return a/f^b+c

PyGFETdb.NoiseModel.LogFnoise(f, a, b)

return b*f+a

PyGFETdb.NoiseModel.PSDintegral(Freq, psd, Fmin=1, Fmax=5000.0)

return Irms

PyGFETdb.PlotDataClass module

Created on Wed Feb 1 10:31:02 2017

@author: aguimera

class PyGFETdb.PlotDataClass.MyCycle(iterable)

Bases: object

next()

reset()

class PyGFETdb.PlotDataClass.PyFETPlot

Bases: PyGFETdb.PlotDataClass.PyFETPlotBase

AxsProp = {'FitErrA': (1, 'Vgs', 0), 'FitErrB': (1, 'Vgs', 0), 'GMPoly': (0, 'Vgs', 1), 'Gm': (0, 'Vgs', 1), 'GmMag': (2, 'Fgm', 0), 'GmPh': (3, 'Fgm', 0), 'Ids': (0, 'Vgs', 1), 'IdsPoly': (0, 'Vgs', 1), 'Ig': (0, 'Vgs', 0), 'Irms': (1, 'Vgs', 0), 'IrmsIds': (2, 'Ids', 0), 'NoA': (1, 'Vgs', 0), 'NoB': (0, 'Vgs', 0), 'PSD': (2, 'Fpsd', 0), 'Rds': (0, 'Vgs', 1), 'Vrms': (1, 'Vgs', 0)}

ColorParams = {'Contact': ('TrtTypes', 'Contact'), 'Date': (None, 'DateTime'), 'Length': ('TrtTypes', 'Length'), 'Pass': ('TrtTypes', 'Pass'), 'Trt': (None, 'Name'), 'Ud0': (None, 'Ud0'), 'W/L': (None, None), 'Width': ('TrtTypes', 'Width')}

GetColorValue(cy, ColorOn)

Plot(Data, iVds=None, iVgs=None, PltUd0=False, PltIsOK=False, ColorOnVgs=False, remove50Hz=False)

PlotDataCh(Data, PltUd0=False, PltIsOK=False)

PlotDataSet(Data, Trts, PltUd0=False, PltIsOK=False, ColorOn='Trt')

class PyGFETdb.PlotDataClass.PyFETPlotBase

Bases: object

AddAxes(AxNames, Xvar=None)

AddLegend(Axn=None, fontsize='xx-small')

ClearAxes()

ColorSet = <matplotlib.colors.LinearSegmentedColormap object>

CreateFigure(Size=(9, 6))

FigExists()

NextColor()

NextLine()

NextMark()

SetAxesLabels(fontsize='medium', labelsize=5, scilimits=(-2, 2), RdsLim=(100, 15000.0))

SetAxesXLabels(Xvar=None)

line = '-'

lines = <PyGFETdb.PlotDataClass.MyCycle object>

mark = ''

marks = <PyGFETdb.PlotDataClass.MyCycle object>

setNColors(ncolors)

class PyGFETdb.PlotDataClass.PyFETPlotDataClass(Size=(9, 6))

Bases: PyGFETdb.PlotDataClass.PyFETPlotBase

AxsProp = {'FEMmu': (1, 0, 'Vgs'), 'FEMmuGm': (1, 0, 'Vgs'), 'FEMn': (0, 0, 'Vgs'), 'FitErrA': (1, 0, 'Vgs'), 'FitErrB': (1, 0, 'Vgs'), 'GM': (0, 0, 'Vgs'), 'GmMag': (1, 1, 'Fgm'), 'GmPh': (0, 1, 'Fgm'), 'Ids': (0, 0, 'Vgs'), 'Ig': (0, 0, 'Vgs'), 'Irms': (1, 0, 'Vgs'), 'NoA': (1, 0, 'Vgs'), 'NoB': (0, 0, 'Vgs'), 'PSD': (1, 1, 'Fpsd'), 'Rds': (0, 0, 'Vgs'), 'Vrms': (1, 0, 'Vgs')}

ColorParams = {'Contact': ('TrtTypes', 'Contact'), 'Date': (None, 'DateTime'), 'Device': ('TrtTypes', 'Devices.Name'), 'Length': ('TrtTypes', 'Length'), 'Pass': ('TrtTypes', 'Pass'), 'Trt': (None, 'Name'), 'Ud0': (None, 'Ud0'), 'W/L': (None, None), 'Wafer': ('TrtTypes', 'Wafers.Name'), 'Width': ('TrtTypes', 'Width')}

GetColorValue(Data, ColorOn)

Plot(Data, Vgs=None, Vds=None, Ud0Norm=False, PltIsOK=True, ColorOnVgs=False, **kwargs)

PlotDataCh(DataDict, Trts, Vgs=None, Vds=None, Ud0Norm=False, PltIsOK=True, ColorOn='Trt')

PlotDataSet(DataDict, Trts=None, Vgs=None, Vds=None, Ud0Norm=False, PltIsOK=True, ColorOn='Trt', MarkOn='Cycle', **kwargs)

class PyGFETdb.PlotDataClass.PyFETPlotParam

Bases: PyGFETdb.PlotDataClass.PyFETPlotBase

AxsProp = {'FitErrA': (0, None, 1), 'FitErrB': (0, None, 1), 'GMPoly': (1, 'Vds', 0), 'GmMax': (0, None, 0), 'IdsPoly': (1, None, 0), 'Irms': (0, None, 1), 'NoA': (0, None, 1), 'NoB': (0, None, 0), 'Rds': (0, None, 0), 'Ud0': (0, None, 0), 'Vrms': (0, None, 1)}

Plot(Data, xVar, Bias, PltUd0)

PlotDataSet(Data, Trts, xVar, Bias, PltUd0=False)

SetAxesXLabels(Xvar, fontsize='medium', scilimits=(-2, 2))

xVarProp = {'Area': ('TrtTypes', 'Area', 1), 'Date': (None, 'DateTime', 0), 'Length': ('TrtTypes', 'Length', 1), 'Pass': ('TrtTypes', 'Pass', 0), 'W/L': (None, None, 1), 'Width': ('TrtTypes', 'Width', 1)}

PyGFETdb.PlotFunctions module

@author: dragc 25/10/19 22:48.

Plot Functions that do not fit in the previous files.

PyGFETdb.PlotFunctions.Legend(Ax, legend, handles)

Parameters:

• Ax –
• legend – Title of the Legend
• handles – Matplotlib handles to plot the Legend

Returns:

None

PyGFETdb.PlotFunctions.PlotGroup(ResultsParams, Group, arguments, handles=None, **kwargs)

Parameters:

• ResultsParams – The results of a search in the database
• Group – A group of conditions to analyse
• args – Arguments for getting the parameters
• kwargs –

Returns:

A dict of args of dicts of groupnames and parameter found in a previous search

PyGFETdb.PlotFunctions.PlotMeanStd(Valx, Valy, Ax=None, PlotStd=True, PlotOverlap=False, label=None, **kwargs)

Parameters:

• Valx – Data for the x axis
• Valy – Data for the y axis
• Ax – Matplotib.Axis
• Color – Color to start plotting
• PlotStd – default true, if true plots the standard deviation
• PlotOverlap – if true plot over the previous plot
• label – label of the Data
• kwargs –

Returns:

PyGFETdb.PlotFunctions.PlotPSD(ax, Fpsd, PSD, noisefit, perfect, ok, nType, PlotStd=True, PlotMean=True, PlotNoise=False, **kwargs)

Parameters:

• Fpsd – Data of the x axis
• PSD – Data of the y axis
• noise – Data of the y axis for noise fitting
• perfect – Boolean to approve the analysis
• nType – Name of the Type of Trt
• PlotStd – Plot Standard Deviation
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.PlotPSDMean(Fpsd, PSD, noisefit, perfect, ok, nType, PlotSuperMean=None, PlotOnlyWorking=False, PlotOnlyFit=False, PlotOnlyPerfect=False, **kwargs)

Parameters:

• Fpsd – Data of the x axis
• PSD – Data of the y axis
• noisefit – Data of the y axis for noise fitting
• perfect – Boolean to approve the analysis
• nType – Name of the Type of Trt
• PlotSuperMean – Plot PSD Mean, if False Plot all the PSDs
• plotonlyworking – Plots only the working items (Devices, Trts, etc).

Returns:

None

PyGFETdb.PlotFunctions.PlotPSDMeanPerClass(Fpsd, PSD, noisefit, perfect, ok, grad, Class, nType, PlotSuperMean=None, PlotClass=None, **kwargs)

Parameters:

• Fpsd – Data of the x axis
• PSD – Data of the y axis
• noisefit – Data of the y axis for noise fitting
• perfect – Boolean to approve the analysis
• nType – Name of the Type of Trt
• PlotSuperMean – Plot PSD Mean, if False Plot all the PSDs

Returns:

None

PyGFETdb.PlotFunctions.PlotPSDPerClass(ax, Fpsd, PSD, noisefit, perfect, ok, mgrad, Class, nType, PlotStd=True, PlotMean=True, PlotNoise=False, **kwargs)

Parameters:

• Fpsd – Data of the x axis
• PSD – Data of the y axis
• noise – Data of the y axis for noise fitting
• perfect – Boolean to approve the analysis
• nType – Name of the Type of Trt
• PlotStd – Plot Standard Deviation
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.PlotPerTypeNoise(Results, handles=None, xlabel=None, legendTitle=None, Colors=None, perType='', **kwargs)

Plots the noise analysis

Parameters:

• Results – The values to plot
• handles – Matplotlib handles to plot the Legend
• xlabel – The title for the x axis
• legendTitle – The title for the Legend
• Colors – Colors to use in the plot
• perType – String to adjust the title of the plot
• kwargs – Keyword arguments

Returns:

None

PyGFETdb.PlotFunctions.PlotPerTypeYield(Results, title=None, handles=None, xlabel=None, perType=None, Colors=None, legendTitle=None, **kwargs)

Plots the percentage of transistors yield per secondary group

Parameters:

• Results – The values to plot
• title – The title of the plot
• handles – Matplotlib handles to plot the Legend
• xlabel – The title for the x axis
• perType – String to adjust the title of the plot
• Colors – Colors to use in the plot
• legendTitle – The title for the Legend
• kwargs – Keyword arguments

Returns:

None

PyGFETdb.PlotFunctions.PlotPerTypeYieldTotal(Results, title=None, Colors=None, xlabel=None, perType=None, **kwargs)

Plots the percentage of transistors yield per primary group

Parameters:

• Results – The values to plot
• title – The title of the plot
• Colors – Colors to use in the plot
• xlabel – The title for the x axis
• kwargs – Keyword arguments

Returns:

None

PyGFETdb.PlotFunctions.PlotResults(Results, arguments, Colors=None, handles=None, xlabel=None, legendTitle=None, **kwargs)

Parameters:

• Results – The results of a search in the database
• Group – A group of conditions to analyse
• args – Arguments for getting the parameters
• kwargs –

Returns:

None

PyGFETdb.PlotFunctions.PlotResultsPSDPerGroup(GrTypes, results, **kwargs)

Plots the results of the Noise Analysis

Parameters:

• GrTypes – Group to plot
• results – results of Noise Analysis
• rPSD – results of a PSD search in the database
• PlotStd – Plot Standard Deviation and Noise
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.PlotResultsPSDPerGroupPerClass(GrTypes, results, **kwargs)

Plots the results of the Noise Analysis

Parameters:

• GrTypes – Group to plot
• results – results of Noise Analysis
• rPSD – results of a PSD search in the database
• PlotStd – Plot Standard Deviation and Noise
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.PlotResultsPSDPerSubgroup(GrTypes, results, rPSD, **kwargs)

Plots the results of the Noise Analysis

Parameters:

• GrTypes – Group to plot
• results – results of Noise Analysis
• rPSD – results of a PSD search in the database
• PlotStd – Plot Standard Deviation and Noise
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.PlotResultsPSDPerSubgroupPerClass(GrTypes, results, rPSD, **kwargs)

Plots the results of the Noise Analysis

Parameters:

• GrTypes – Group to plot
• results – results of Noise Analysis
• rPSD – results of a PSD search in the database
• PlotStd – Plot Standard Deviation and Noise
• PlotMean – Plot PSD Mean, if False Plot all the PSDs
• PlotNoise – Plot Noise Mean

Returns:

None

PyGFETdb.PlotFunctions.processNoiseForPlotPSD(noise)

PyGFETdb.PlotFunctions.reduce(item)

PyGFETdb.QuantitySupport module

@author: dragc 25/10/19 22:48.

Python Quantities Support Class

class PyGFETdb.QuantitySupport.QuantitySupport(Quantities=True)

Bases: object

Divide(Dividend, Divisor)

Parameters:

• Dividend – the Quantity-like to be divided.
• Divisor – the Quantity-like to divide by.

Returns:

Divides Dividend by Divisor avoiding division by zero.

FormatQuantity(Par, ParamName, Units=None, Param=None, **kwargs)

Formats a Quantity

Parameters:

• Par – quantity to format
• ParamName – name of the parameter to format
• Units – wanted units for the parameter
• Param – name of the wanted parameter
• kwargs – keyword arguments

Returns:

a quantity formatted coherently and with the wanted units

appendQuantity(vals, val)

Parameters:

• vals – A list of Quantities.
• val – A Quantity.

Returns:

A new list with val appended to vals.

createDefaultQuantity(key, value)

Parameters:

• key – One of the keys defined in DefaultUnits
• value – The magnitude measured

Returns:

The value with the default units

createQuantityList()

Returns:An empty list if Quantities support is activated or a empty numpy.array otherwise

flatten(quantity)

Parameters:quantity – A Quantity-like variable Returns:A flatted list of values with the magnitudes of quantity

flattenQuantity(quantity)

Flattens a Quantity with the units

Parameters:quantity – Quantity to flatten Returns:the Quantity flattened

getConsistentQuantityFromList(listQty)

Parameters:listQty – Returns:A list of Quantities if all the Quantities have consistent Units, with pq.dimensionless in the case were incompatible, or a ‘nan’ Quantity if it were not possible to convert them

getDefaultUnitsKey(key)

Returns the default units for a parameter

Parameters:key – name of the parameter Returns:the default units for the parameter

getQuantityUnits(qtylist)

Parameters:qtylist – The Quantity-like to obtain the units from Returns:The proper UnitQuantity

isActive()

Returns:if the Quantity support is active

isDefaultQuantityKey(key)

Parameters:key – string indicating the plot parameter to check Returns:if exist a default unit for the plot parameter

rescaleFromKey(qtylist, units)

Parameters:

• qtylist – The input Quantity-like
• units – The units to rescale

Returns:

The input Quantity-like rescaled to the intented units

returnQuantity(param, unitKey=None, **kwargs)

Parameters:

• param – The argument to be evaluated if the Quatities support is activated
• unitKey – The key in Default Units.
• kwargs – The argument keywords in order to check unit rescaling.

Returns:

The Quantity or param if the Quantities support is not activated

setActive(Active=True)

Parameters:Active – sets new state for the Quantity support Returns:None

toQuantity(value)

Parameters:value – The value to be converted, a Quantity-like Returns:A Quantity with consistent units depending on parameter value

PyGFETdb.SearchFunctions module

@author: dragc 25/10/19 22:48.

Search Functions that do not fit in the previous files.

PyGFETdb.SearchFunctions.DBSearchPerDevice(GrBase, args, **kwargs)

Parameters:

• GrBase – A group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerDeviceAndTrt(GrBase, args, **kwargs)

Parameters:

• GrBase – A group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerTrt(GrBase, args, **kwargs)

Parameters:

• GrBase – a group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerType(GrBase, args, **kwargs)

Parameters:

• GrBase – a group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerTypeAndDevice(GrBase, args, **kwargs)

Parameters:

• GrBase – a group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerTypeAndTrt(GrBase, args, **kwargs)

Parameters:

• GrBase – a group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerTypeAndWafer(GrBase, args, **kwargs)

Parameters:

• GrBase – a group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerWafer(GrBase, args, **kwargs)

Parameters:

• GrBase – A group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerWaferAndDevice(GrBase, args, **kwargs)

Parameters:

• GrBase – A group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DBSearchPerWaferAndType(GrBase, args, **kwargs)

Parameters:

• GrBase – A group of conditions
• args – a dict with the parameters to search

Returns:

a group of conditions and the results of the search

PyGFETdb.SearchFunctions.DataClassification(GrWs, arguments, ResultsParams)

Parameters:

• GrWs – A group of conditions
• ResultsParams – the results obtained of a search of parameters

Returns:

A dict with the results classified by argument to plot

PyGFETdb.Thread module

@author: dragc

class PyGFETdb.Thread.MultiProcess(klass, processes=2)

Bases: object

call(key, klass, function, arguments, **kwargs)

Calls a function for multi-processing

Parameters:

• key – The unique-key of the calculation
• klass – Calls where the function to call is
• function – Name of the function to call
• arguments – Arguments of the function to call
• kwargs – Keyword arguments passed to the function to call

Returns:

None if multi-processing support is activated, or the result of the call otherwise

end()

getResults(key)

Obtains the results for a calculation.

Parameters:key – A unique-key identifying the calculation Returns:The results of the previous call

initcall(key, klass)

Initialises the Multi-processing

Parameters:

• key – A unique-key to each calculation
• klass – Calls where the function to call is

Returns:

None

class PyGFETdb.Thread.Thread(package, processes=2)

Bases: multiprocessing.pool.ThreadPool

addResult(result)

This function is used by the threads to return results

Parameters:result – The result to add Returns:None

call(funcname, arguments, **kwargs)

Calls a function for the Thread to process

Parameters:

• funcname – Name of the function to call
• arguments – Arguments of the call
• kwargs –

Returns:

None

end()

errorlog(e)

Parameters:e – Error in multiprocessing Returns:None

getResults()

Finalise the processing and get the results

Returns:A dict of results

PyGFETdb.Thread.call(klass, function, arguments, **kwargs)

Auxiliary function for calling a function with a Multiprocessing

Parameters:

• klass – Class where the function to call is
• function – Name of the function to call
• arguments – Arguments of the function to call
• kwargs – Keyword arguments passed to the function to call

Returns:

the keyid and a pool for getting the results

PyGFETdb.Thread.callThread(klass, function, arguments, **kwargs)

Auxiliary function for calling a function with a single Thread

The use of Multiprocessing class is preferred, as its faster

Parameters:

• klass – Class where the function to call is
• function – Name of the function to call
• arguments – Arguments of the function to call
• kwargs – Keyword arguments passed to the function to call

Returns:

None if multi-processing support is activated, or the result of the call otherwise

PyGFETdb.Thread.key()

Returns:a random number to be used as key for multiprocessing

Module contents

Created on Tue Nov 15 17:27:23 2016

@author: aguimera

PyGFETdb.qty = <PyGFETdb.QuantitySupport.QuantitySupport object>

qty = quantities.QuantitySupport(False) Deactivates Quantities support globally

However, the preferable method to deactivate Quantity support is calling locally the method qty.setActive(False)