def recordSample(self):
#debug
'''
self.debug(
[
'This is the sample record level',
('self.',self,[
'RecordingLabelVariable'
])
]
)
'''
#/##################/#
# Build the colors
#
#Check
if self.RecordingLabelVariable!=None:
#get
self.RecordedColorTuplesList=SYS.getColorTuplesList(
'black',
self.RecordingColorStr,
len(self.RecordingLabelVariable)+3,
_PlotBool=False
)[3:]
#reverse
self.RecordedColorTuplesList.reverse()
#debug
'''
def viewNetwork(self):
#
# Maybe erase
#
del self.TeamDict['Panels']
#
# Plot the transfer functions
#
#Check
if len(self.ViewingColorStrsList)!=self.StationarizingUnitsInt:
#set
self.ViewingColorStrsList = SYS.getColorTuplesList(
_FromColorStr='blue',
_ToColorStr='black',
_SampleInt=self.StationarizingUnitsInt,
_PlotBool=False
)
#Check
if len(self.ViewingLabelStrsList)!=self.StationarizingUnitsInt:
#set
self.ViewingLabelStrsList=map(
lambda _Variable:
_Variable.ManagementTagStr,
self.TeamDict['Populations'].ManagementDict.values()
)
#Debug
'''
self.debug(
[
('self.',self,[
'ViewingColorStrsList',
'ViewingLabelStrsList'
])
]
)
'''
#debug
'''
self.debug(
[
"We transfer view network here"
]
)
'''
#call
ViewedTransferVariable = self.getTeamer(
'Panels'
).getManager(
'Transfer'
)
ViewedChartsVariable=ViewedTransferVariable.getTeamer(
'Charts'
)
#xlim
xlimList = [self.TransferedScanFrequencyFloatsArray[0],self.TransferedScanFrequencyFloatsArray[-1]]
#
# Amplitude
#
#plot
ViewedAmplitudeChartVariable = ViewedChartsVariable.getManager('Amplitude')
#get
ViewedAmplitudeDrawVariable = ViewedAmplitudeChartVariable.getTeamer(
'Draws'
).getManager('0')
#debug
self.debug(
[
('self.',self,[
'StationarizedRateFloatsArraysList',
'StationarizingRateVariable'
])
]
)
#set
yLimAmplitudeList=[
self.TransferedNormRateAmplitudeFloatsArray.min(),
self.TransferedNormRateAmplitudeFloatsArray.max()
]
yTickAmplitudeList=[0.,0.5,1.]
#map
ViewedAmplitudeDrawVariable.PyplotingDrawVariable = map(
lambda __IndexInt:
('plot',{
'#liarg':[
self.TransferedScanFrequencyFloatsArray,
self.TransferedNormRateAmplitudeFloatsArray[__IndexInt,:]
],
'#kwarg':{
'linestyle':'-',
'linewidth':5,
'color':self.ViewingColorStrsList[__IndexInt],
'label':self.ViewingLabelStrsList[__IndexInt]
}
}),
xrange(len(self.TeamDict['Populations'].ManagementDict))
)
#set log
ViewedAmplitudeChartVariable.PyplotingChartVariable=[
('set_xscale','log'),
('set_xlim',xlimList),
('set_xticklabels',[]),
('set_yticks',yTickAmplitudeList),
('set_yticklabels',map(lambda __Float:'$'+str(__Float)+'$',yTickAmplitudeList)),
('set_ylabel',"$amplitude\ r_{a1}/r_{a0}$")
]
ViewedAmplitudeChartVariable.PyplotingLegendDict={
'fontsize':10,
'ncol':2 if self.StationarizingUnitsInt>3 else 1
}
#
# Phase
#
#plot
ViewedPhaseChartVariable = ViewedChartsVariable.getManager('Phase')
#get
ViewedPhaseDrawVariable = ViewedPhaseChartVariable.getTeamer(
'Draws'
).getManager('0')
#set
#yLimPhaseList=[TransferedNormRatePhaseFloatsArray.min(),TransferedNormRatePhaseFloatsArray.max()]
yLimPhaseList=[-180.,180.]
yTickPhaseList=[-180,-90,0,90,180]
#map
ViewedPhaseDrawVariable.PyplotingDrawVariable = map(
lambda __IndexInt:
('plot',{
'#liarg':[
self.TransferedScanFrequencyFloatsArray,
#(180./np.pi)*np.array(map(
# SYS.getArgumentVariable,
# self.TransferedRateComplexesArray[__IndexInt,:]
#))
self.TransferedNormRatePhaseFloatsArray[__IndexInt,:]
],
'#kwarg':{
'linestyle':'-',
'linewidth':5,
'color':self.ViewingColorStrsList[__IndexInt]
}
}),
range(len(self.TeamDict['Populations'].ManagementDict))[1:]
)+[
('plot',{
'#liarg':[
self.TransferedScanFrequencyFloatsArray,
#(180./np.pi)*np.array(map(
# SYS.getArgumentVariable,
# self.TransferedRateComplexesArray[__IndexInt,:]
#))
self.TransferedNormRatePhaseFloatsArray[0,:]
],
'#kwarg':{
'linestyle':'--',
'linewidth':3,
'color':self.ViewingColorStrsList[0]
}
})
]
#set log
ViewedPhaseChartVariable.PyplotingChartVariable=[
('plot',{
'#liarg':[
xlimList,
[0.,0.]
],
'#kwarg':{
'linestyle':'--',
'linewidth':1,
'color':"black"
}
}
),
('set_xscale','log'),
('set_xlim',xlimList),
('set_xlabel',"$frequency (Hz)$"),
('set_ylim',yLimPhaseList),
('set_ylabel',"$phase$"),
('set_yticks',yTickPhaseList),
('set_yticklabels',map(lambda __Float:'$'+str(__Float)+'$',yTickPhaseList))
]
#
# Plot max but just (for the first)
#
#map
ViewedAmplitudeDrawVariable.PyplotingDrawVariable += SYS.sum(map(
lambda __IndexInt:
map(
lambda __FourierMaxTuple:
('plot',{
'#liarg':[
[__FourierMaxTuple[0]]*2,
yLimAmplitudeList
],
'#kwarg':{
'linestyle':'--',
'linewidth':1,
#'color':self.ViewingColorStrsList[__IndexInt]
'color':"black"
}
}),
self.TransferedPeakVariable[__IndexInt]
),
range(len(self.TeamDict['Populations'].ManagementDict))[:1]
))
#map
'''
ViewedPhaseDrawVariable.PyplotingDrawVariable += SYS.sum(map(
lambda __IndexInt:
map(
lambda __FourierMaxTuple:
('plot',{
'#liarg':[
[__FourierMaxTuple[0]]*2,
yLimPhaseList
],
'#kwarg':{
'linestyle':'--',
'linewidth':1,
#'color':self.ViewingColorStrsList[__IndexInt]
'color':"black"
}
}),
self.NumscipiedFourierMaxTupleFloatsArray[__IndexInt]
),
range(len(self.TeamDict['Populations'].ManagementDict))[:1]
))
'''
#map
ViewedPhaseDrawVariable.PyplotingDrawVariable += SYS.sum(map(
lambda __IndexInt:
SYS.sum(map(
lambda __FourierMaxTuple:
map(
lambda __PhaseFloat,_IndInt:
('plot',{
'#liarg':[
__FourierMaxTuple[0],
__PhaseFloat
],
'#kwarg':{
'linestyle':'',
'marker':"o",
'markersize':5,
'color':self.ViewingColorStrsList[_IndInt]
#'color':"black"
}
}),
__FourierMaxTuple[1][1:],
xrange(len(__FourierMaxTuple[1][1:]))
),
self.TransferedPhaseVariable[__IndexInt]
)),
range(len(self.TeamDict['Populations'].ManagementDict))[:1]
))
#
# Recapepete
#
#mapSet
self.mapSet(
{
'PyplotingFigureVariable':{
'figsize':(10,10)
},
'PyplotingGridVariable':(40,30),
'-Panels':[
(
'|Transfer',
{
'PyplotingTextVariable':[-0.6,0.],
'PyplotingShapeVariable':[10,10],
'-Charts':{
'|Amplitude':{
},
'|Phase':{
'PyplotingShiftVariable':[2,0]
}
}
}
)
]
}
)
#base
BaseClass.viewNetwork(self)
def mimic_view(self):
# /#################/#
# First call the base method
#
BaseClass.view(self)
# /#################/#
# Build the Units colors
#
self.PredirateControlColorTuplesList = SYS.getColorTuplesList(
"black", "green", len(self.PrediratingMonitorIntsList) + 3, _PlotBool=False
)[3:]
self.PredirateExactColorTuplesList = SYS.getColorTuplesList(
"black", "blue", len(self.PrediratingMonitorIntsList) + 3, _PlotBool=False
)[3:]
self.PrediratePerturbativeColorTuplesList = SYS.getColorTuplesList(
"black", "red", len(self.PrediratingMonitorIntsList) + 3, _PlotBool=False
)[3:]
# debug
"""
self.debug(
[
'We have built the colors',
('self.',self,['PrediratePerturbativeColorTuplesList'])
]
)
"""
# /#################/#
# Build the input-unit traces axes
#
# debug
self.debug([("self.", self, ["PredisensingMonitorIntsList"])])
# get
self.set(
"/-Charts/|Unit",
{
"-Draws": {
"#map@set": map(
lambda __IntsTuple: (
"|" + str(__IntsTuple[0]),
{
"PyplotingDrawVariable": [
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedControlUnitTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$r_{" + str(__IntsTuple[1]) + "}^{control}$",
"linestyle": "-",
"linewidth": 1,
"color": self.PredirateControlColorTuplesList[__IntsTuple[0]],
},
},
),
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedExactUnitTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$r_{" + str(__IntsTuple[1]) + "}^{exact}$",
"linestyle": "-",
"linewidth": 2,
"color": self.PredirateExactColorTuplesList[__IntsTuple[0]],
},
},
),
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedPerturbativeUnitTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$r_{" + str(__IntsTuple[1]) + "}^{perturb}$",
"linestyle": "-",
"linewidth": 4,
"color": self.PrediratePerturbativeColorTuplesList[__IntsTuple[0]],
},
},
),
]
},
),
enumerate(self.PrediratingMonitorIntsList),
)
},
"PyplotingChartVariable.extend": [
[
("set_ylabel", "$r(t)$"),
(
"set_ylim",
{
"#liarg:#map@get": [
">>SYS.set(SYS,'RateLimFloatsArray',"
+ "".join(
[
"[max(-20.,self.PrediratedPerturbativeUnitTraceFloatsArray.min()),"
"min(20.,self.PrediratedPerturbativeUnitTraceFloatsArray.max())]"
]
)
+ ").RateLimFloatsArray"
]
},
),
(
"set_yticks",
{
"#liarg:#map@get": [
"".join(
[
">>SYS.set(SYS,'RateTickFloatsArray',"
"map(lambda __Float:float('%.2f'%__Float),",
"SYS.getTickFloatsArray(SYS.RateLimFloatsArray,3))",
").RateTickFloatsArray",
]
)
]
},
),
(
"set_yticklabels",
{"#liarg:#map@get": [">>map(lambda __Float:'$'+str(__Float)+'$',SYS.RateTickFloatsArray)"]},
),
("tick_params", {"#kwarg": {"length": 10, "width": 5, "which": "major"}}),
("tick_params", {"#kwarg": {"length": 5, "width": 2, "which": "minor"}}),
("xaxis.set_ticks_position", {"#liarg": ["bottom"]}),
("yaxis.set_ticks_position", {"#liarg": ["left"]}),
(
"legend",
{
"#liarg": [],
"#kwarg": {
"fontsize": 10,
"shadow": True,
"fancybox": True,
"ncol": len(self.PrediratingMonitorIntsList),
"loc": 2,
"bbox_to_anchor": (1.05, 1),
},
},
),
]
],
},
)
# /#################/#
# Build the Decoder colors
#
self.PredirateDecoderControlColorTuplesList = SYS.getColorTuplesList(
"black", "green", len(self.PredisensingMonitorIntsList) + 3, _PlotBool=False
)[3:]
self.PredirateDecoderExactColorTuplesList = SYS.getColorTuplesList(
"black", "blue", len(self.PredisensingMonitorIntsList) + 3, _PlotBool=False
)[3:]
self.PredirateDecoderPerturbativeColorTuplesList = SYS.getColorTuplesList(
"black", "red", len(self.PredisensingMonitorIntsList) + 3, _PlotBool=False
)[3:]
# debug
"""
self.debug(
[
'We have built the colors',
('self.',self,['PrediratePerturbativeColorTuplesList'])
]
)
"""
# get
self.set(
"/-Charts/|Decoder",
{
"-Draws": {
"#map@set": map(
lambda __IntsTuple: (
"|" + str(__IntsTuple[0]),
{
"PyplotingDrawVariable": [
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PredisensedSensorTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$x_{" + str(__IntsTuple[1]) + "}$",
"linestyle": "-",
"linewidth": 1,
"color": self.PredisenseSensorColorTuplesList[__IntsTuple[0]],
},
},
),
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedPerturbativeDecoderTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$\hat{x}_{" + str(__IntsTuple[1]) + "}^{perturb}$",
"linestyle": "--",
"linewidth": 4,
"color": self.PredirateDecoderPerturbativeColorTuplesList[
__IntsTuple[0]
],
},
},
),
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedExactDecoderTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$\hat{x}_{" + str(__IntsTuple[1]) + "}^{exact}$",
"linestyle": "--",
"linewidth": 2,
"color": self.PredirateDecoderExactColorTuplesList[__IntsTuple[0]],
},
},
),
(
"plot",
{
"#liarg:#map@get": [
"PredisensedTimeTraceFloatsArray",
">>self.PrediratedControlDecoderTraceFloatsArray['"
+ str(__IntsTuple[1])
+ "']",
],
"#kwarg": {
"label": "$\hat{x}_{" + str(__IntsTuple[1]) + "}^{control}$",
"linestyle": "--",
"linewidth": 1,
"color": self.PredirateDecoderControlColorTuplesList[__IntsTuple[0]],
},
},
),
]
},
),
enumerate(self.PredisensingMonitorIntsList),
)
},
"PyplotingChartVariable.extend": [
[
("set_ylabel", "$x(t),\ \hat{x}(t)$"),
("set_ylim", {"#liarg:#map@get": [">>SYS.SensorLimFloatsArray"]}),
("set_yticks", {"#liarg:#map@get": [">>SYS.SensorTickFloatsArray"]}),
("set_yticklabels", {"#liarg:#map@get": [">>SYS.SensorTickStrsArray"]}),
("tick_params", {"#kwarg": {"length": 10, "width": 5, "which": "major"}}),
("tick_params", {"#kwarg": {"length": 5, "width": 2, "which": "minor"}}),
("xaxis.set_ticks_position", {"#liarg": ["bottom"]}),
("yaxis.set_ticks_position", {"#liarg": ["left"]}),
(
"legend",
{
"#liarg": [],
"#kwarg": {
"fontsize": 10,
"shadow": True,
"fancybox": True,
"ncol": len(self.PredisensingMonitorIntsList),
"loc": 2,
"bbox_to_anchor": (1.05, 1),
},
},
),
]
],
},
)
def mimic_pyplot(self):
#debug
'''
self.debug(
[
('self.',self,['PredisensingMonitorIntsList'])
]
)
'''
#/#################/#
# Build the colors
#
self.PredisenseCommandColorTuplesList=SYS.getColorTuplesList(
'black','red',len(self.PredisensingMonitorIntsList)+3,_PlotBool=False
)[3:]
self.PredisenseSensorColorTuplesList=SYS.getColorTuplesList(
'black','blue',len(self.PredisensingMonitorIntsList)+3,_PlotBool=False
)[3:]
#debug
'''
self.debug(
[
'We have built the colors',
('self.',self,[
'PredisenseCommandColorTuplesList'
'PredisenseSensorColorTuplesList'])
]
)
'''
#/#################/#
# Build the input-unit traces axes
#
#init
self.mapSet(
{
'-Charts':[
('ManagingBeforeSetVariable',
{
'FiguringShapeIntsTuple':(5,15),
'#copy:PyplotingDrawVariable':
[
(
'#axes',
[
('set_xticks',{
'#liarg:#map@get':[
">>SYS.set(SYS,'TimeTicksArray',SYS.getTickFloatsArray([0.,self.PredisensingRunTimeFloat],4)).TimeTicksArray"
]
}),
('set_xticklabels',{
'#liarg:#map@get':[
">>map(lambda __Float:'$%.0f$'%__Float,SYS.TimeTicksArray)"
]
}),
('set_xlim',{
'#liarg:#map@get':[0.,'>>self.PredisensingRunTimeFloat']
})
]
)
]
}),
('|Sensor',{
'-Draws':{
'#map@set':map(
lambda __IntsTuple:
(
'|'+str(__IntsTuple[0]),
{
'PyplotingDrawVariable':
[
('plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PredisensedInputCurrentTraceFloatsArray.__getitem__('+str(__IntsTuple[1])+')'
],
'#kwarg':{
'label':'$\\tau_{D}c_{'+str(__IntsTuple[1])+'}$',
'linestyle':'-',
'color':self.PredisenseCommandColorTuplesList[__IntsTuple[0]]
}
}),
('plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PredisensedSensorTraceFloatsArray['+str(__IntsTuple[1])+',:]'
],
'#kwarg':{
'color':self.PredisenseSensorColorTuplesList[__IntsTuple[0]],
'label':'$x_{'+str(__IntsTuple[1])+'}$',
'linewidth':3,
'linestyle':'-'
}
})
]
}
),
enumerate(self.PredisensingMonitorIntsList)
)
},
'PyplotingDrawVariable.extend':
[[
(
'#axes',
[
('set_ylabel','$\\tau_{D}c(t),\ x(t)$'),
('set_ylim',{'#liarg:#map@get':[
"".join([
">>SYS.set(SYS,'SensorLimFloatsArray',",
"[min(-0.1,self.PredisensedSensorTraceFloatsArray.min()),1.5*self.PredisensingClampFloat*self.PredictingConstantTimeFloat]",
').SensorLimFloatsArray'
])]
}),
('set_yticks',{
'#liarg:#map@get':[
"".join([
">>SYS.set(SYS,'SensorTickFloatsArray',",
"map(lambda __Float:float('%.2f'%__Float),",
"SYS.getTickFloatsArray(",
"SYS.SensorLimFloatsArray,3",
"))).SensorTickFloatsArray"
])
]
}),
('set_yticklabels',{
'#liarg:#map@get':[
"".join([
">>SYS.set(SYS,'SensorTickStrsArray',",
"map(lambda __Float:'$'+str(__Float)+'$',",
"SYS.SensorTickFloatsArray)).SensorTickStrsArray"
])
]
}),
('tick_params',{
'#kwarg':{
'length':10,
'width':5,
'which':'major'
}
}),
('tick_params',{
'#kwarg':{
'length':5,
'width':2,
'which':'minor'
}
}),
('xaxis.set_ticks_position',
{
'#liarg':['bottom']
}
),
('yaxis.set_ticks_position',
{
'#liarg':['left']
}
),
('legend',{
'#liarg':[],
'#kwarg':{
'fontsize':10,
'shadow':True,
'fancybox':True,
'ncol':max(1,len(self.PredisensingMonitorIntsList)/2),
'loc':2,
'bbox_to_anchor':(1.05, 1)
}
})
]
)
]]
})
]
}
)
#debug
self.debug(
'Ok we have setted the plots'
)
#call the base method
BaseClass.pyplot(self)
def mimic_draw(self):
#/#################/#
# First call the base method
#
BaseClass.draw(self)
#/#################/#
# Build the colors
#
self.PredirateControlColorTuplesList=SYS.getColorTuplesList(
'black','yellow',len(self.PrediratingMonitorIntsList)+3,_PlotBool=False
)[3:]
self.PredirateExactColorTuplesList=SYS.getColorTuplesList(
'black','blue',len(self.PrediratingMonitorIntsList)+3,_PlotBool=False
)[3:]
self.PrediratePerturbativeColorTuplesList=SYS.getColorTuplesList(
'black','red',len(self.PrediratingMonitorIntsList)+3,_PlotBool=False
)[3:]
#debug
'''
self.debug(
[
'We have built the colors',
('self.',self,['PrediratePerturbativeColorTuplesList'])
]
)
'''
#/#################/#
# Build the input-unit traces axes
#
#debug
self.debug(
[
('self.',self,['PredisensingMonitorIntsList'])
]
)
#get
self['/-Views/|A/-Axes'].set(
'|Unit',
{
'-Plots':{
'#map@set':map(
lambda __IntsTuple:
(
'|'+str(__IntsTuple[0]),
{
'FiguringDrawVariable':
[
('#plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PrediratedControlUnitTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
],
'#kwarg':{
'label':'$r_{'+str(__IntsTuple[1])+'}^{control}$',
'linestyle':'-',
'linewidth':1,
'color':self.PredirateControlColorTuplesList[__IntsTuple[0]]
}
}
),
('#plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PrediratedExactUnitTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
],
'#kwarg':{
'label':'$r_{'+str(__IntsTuple[1])+'}^{exact}$',
'linestyle':'-',
'linewidth':2,
'color':self.PredirateExactColorTuplesList[__IntsTuple[0]],
}
}
),
#('#plot',
# {
# '#liarg:#map@get':[
# 'PredisensedTimeTraceFloatsArray',
# '>>self.PrediratedPerturbativeUnitTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
# ],
# '#kwarg':{
# 'label':'$r_{'+str(__IntsTuple[1])+'}^{perturb}$',
# 'linestyle':'-',
# 'linewidth':4,
# 'color':self.PrediratePerturbativeColorTuplesList[__IntsTuple[0]]
#
# }
# }
#)
]
}
),
enumerate(self.PrediratingMonitorIntsList)
)
},
'FiguringDrawVariable.extend':
[[
('#axes',
[
('set_ylabel','$r(t)$'),
('set_ylim',{
'#liarg:#map@get':[
">>SYS.set(SYS,'RateLimFloatsArray',"+"".join([
"[max(-20.,self.PrediratedControlUnitTraceFloatsArray.min()),"
"min(20.,self.PrediratedControlUnitTraceFloatsArray.max())]"
])+').RateLimFloatsArray'
]
}),
('set_yticks',{
'#liarg:#map@get':[
"".join(
[
">>SYS.set(SYS,'RateTickFloatsArray',"
"map(lambda __Float:float('%.2f'%__Float),",
"SYS.getTickFloatsArray(SYS.RateLimFloatsArray,3))",
").RateTickFloatsArray"
]
)
]
}),
('set_yticklabels',{
'#liarg:#map@get':[
">>map(lambda __Float:'$'+str(__Float)+'$',SYS.RateTickFloatsArray)"
]
}),
('tick_params',{
'#kwarg':{
'length':10,
'width':5,
'which':'major'
}
}),
('tick_params',{
'#kwarg':{
'length':5,
'width':2,
'which':'minor'
}
}),
('xaxis.set_ticks_position',
{
'#liarg':['bottom']
}
),
('yaxis.set_ticks_position',
{
'#liarg':['left']
}
),
('legend',{
'#liarg':[],
'#kwarg':{
'fontsize':10,
'shadow':True,
'fancybox':True,
'ncol':len(self.PrediratingMonitorIntsList),
'loc':2,
'bbox_to_anchor':(1.05, 1)
}
})
]
)
]]
}
)
#get
self['/-Views/|A/-Axes'].set(
'|Decoder',
{
'-Plots':{
'#map@set':map(
lambda __IntsTuple:
(
'|'+str(__IntsTuple[0]),
{
'FiguringDrawVariable':
[
('#plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PredisensedSensorTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
],
'#kwarg':{
'label':'$x_{'+str(__IntsTuple[1])+'}$',
'linestyle':'-',
'linewidth':1,
'color':self.PredisenseSensorColorTuplesList[__IntsTuple[0]]
}
}
),
('#plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PrediratedControlDecoderTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
],
'#kwarg':{
'label':'$\hat{x}_{'+str(__IntsTuple[1])+'}^{control}$',
'linestyle':'--',
'linewidth':1,
'color':self.PredisenseSensorColorTuplesList[__IntsTuple[0]],
}
}
),
('#plot',
{
'#liarg:#map@get':[
'PredisensedTimeTraceFloatsArray',
'>>self.PrediratedExactDecoderTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
],
'#kwarg':{
'label':'$\hat{x}_{'+str(__IntsTuple[1])+'}^{exact}$',
'linestyle':'--',
'linewidth':2,
'color':self.PredisenseSensorColorTuplesList[__IntsTuple[0]],
}
}
),
#('#plot',
# {
# '#liarg:#map@get':[
# 'PredisensedTimeTraceFloatsArray',
# '>>self.PrediratedPerturbativDecoderTraceFloatsArray[\''+str(__IntsTuple[1])+'\']'
# ],
# '#kwarg':{
# 'label':'$\hat{x}_{'+str(__IntsTuple[1])+'}^{perturb}$',
# 'linestyle':'--',
# 'linewidth':4,
# 'color':self.PredisenseSensorColorTuplesList[__IntsTuple[0]],
#
# }
# }
#)
]
}
),
enumerate(self.PredisensingMonitorIntsList)
)
},
'FiguringDrawVariable.extend':
[[
(
'#axes',
[
('set_ylabel','$x(t),\ \hat{x}(t)$'),
('set_ylim',{
'#liarg:#map@get':[
">>SYS.set(SYS,'DecoderLimFloatsArray',"+"".join([
"[max(0.,self.PrediratedControlDecoderTraceFloatsArray.min()),"
"min(5.,self.PrediratedControlDecoderTraceFloatsArray.max())]"
])+').DecoderLimFloatsArray'
]
}),
('set_yticks',{
'#liarg:#map@get':[
"".join(
[
">>SYS.set(SYS,'DecoderTickFloatsArray',"
"map(lambda __Float:float('%.2f'%__Float),",
"SYS.getTickFloatsArray(SYS.DecoderLimFloatsArray,3))",
").DecoderTickFloatsArray"
]
)
]
}),
('set_yticklabels',{
'#liarg:#map@get':[
">>map(lambda __Float:'$'+str(__Float)+'$',SYS.DecoderTickFloatsArray)"
]
}),
('tick_params',{
'#kwarg':{
'length':10,
'width':5,
'which':'major'
}
}),
('tick_params',{
'#kwarg':{
'length':5,
'width':2,
'which':'minor'
}
}),
('xaxis.set_ticks_position',
{
'#liarg':['bottom']
}
),
('yaxis.set_ticks_position',
{
'#liarg':['left']
}
),
('legend',{
'#liarg':[],
'#kwarg':{
'fontsize':10,
'shadow':True,
'fancybox':True,
'ncol':len(self.PredisensingMonitorIntsList),
'loc':2,
'bbox_to_anchor':(1.05, 1)
}
})
]
)
]]
}
)