def stabilizeNetwork(self):
#/###################/#
# Determine the time constant structures
#
#set
if type(self.StabilizingConstantTimeVariable)==None.__class__:
self.StabilizingConstantTimeVariable=map(
lambda __DeriveStabilizer:
__DeriveStabilizer.LifingConstantTimeFloat,
self.TeamDict['Populations'].ManagementDict.values()
)
#debug
'''
self.debug(
[
('self.',self,[
'StabilizingConstantTimeVariable'
])
]
)
'''
#map
map(
lambda __TimeStr:
SYS.setInitArray(
self,
'Stabilize',
__TimeStr+'Time'
),
[
'Constant',
'Delay',
'Decay',
'Rise'
]
)
#/###################/#
# Build the always fixed terms of the perturbation matrix
#
#debug
'''
self.debug(
[
'We init the computations the StabilizedPerturbationWeightFloatsArray',
('self.',self,[
'StationarizingConstantTimeVariable',
'StationarizedMeanWeightFloatsArray',
'StabilizedConstantTimeVariable'
])
]
)
'''
#set
self.StabilizedPerturbationWeightFloatsArray=self.StationarizedMeanWeightFloatsArray[
:
]
#mul
SYS.setMatrixArray(
self.StabilizedPerturbationWeightFloatsArray,
self.StabilizedConstantTimeVariable,
np.ndarray.__mul__
)
#debug
'''
self.debug(
[
'In the end',
('self.',self,[
'StabilizedPerturbationWeightFloatsArray'
])
]
)
'''
#/###################/#
# Determine which function to get for the synaptic computation
#
#debug
'''
self.debug(
[
"We determine the type of Synaptic function",
('self.',self,[
'StabilizedRiseTimeVariable',
'StabilizedDecayTimeVariable',
'StabilizedDelayTimeVariable'
])
]
)
'''
#Check
if SYS.getIsNullBool(
self.StabilizedRiseTimeVariable
):
#Check
if SYS.getIsNullBool(
self.StabilizedDecayTimeVariable
):
#Check
if SYS.getIsNullBool(
self.StabilizedDelayTimeVariable
):
#set
self.StabilizedSynapticPerturbationMethodVariable=lambda __PerturbationComplex:1.
else:
#set
self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticDelayPerturbationVariable
else:
#set
self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticDecayPerturbationVariable
else:
#set
self.StabilizedSynapticPerturbationMethodVariable=self.getSynapticRisePerturbationVariable
#/###################/#
# Prepare the combinations to consider
#
#import
import itertools
#list
self.StabilizedIndexIntsTuplesList=list(
itertools.product(
xrange(self.StationarizingUnitsInt),
xrange(self.StationarizingUnitsInt)
)
)
#debug
'''
self.debug(
[
'We set a one root get',
('self.',self,[
'StabilizedIndexIntsTuplesList'
])
]
)
self.getGlobalPerturbationRootFloatsTuple(
(0.1,2.*np.pi*1.)
)
'''
#import
from numpy import linalg
#set
self.StabilizedDeterminantFunctionVariable=linalg.det
#/################/#
# Look for a rate instability
#
#debug
'''
self.debug(
[
"Ok first we look for a rate instability"
]
)
'''
#set
self.StabilizedLifersVariable = self.TeamDict['Populations'].ManagementDict.values()
#map
self.StabilizedMeanPerturbationNullFloatsList=map(
lambda __DeriveStabilizer:
__DeriveStabilizer.lif(
_ComputeStationaryBool=False,
_PerturbationLambdaVariable=0.,
_PerturbationMethodStr='Brunel',
_ComputeNoisePerturbationBool=False
).LifedPerturbationMeanComplexVariable,
self.StabilizedLifersVariable
) if self.StationarizingInteractionStr=="Spike" else [1.]*self.StationarizingUnitsInt
#debug
'''
self.debug(
[
('self.',self,[
'StabilizedMeanPerturbationNullFloatsList'
])
]
)
'''
#set
self.StabilizedNeuralPerturbationComplexesArrayesArray=np.zeros(
self.StationarizingUnitsInt,
dtype=complex
)
#Check
if self.StabilizingComputeBool:
#get
self.StabilizedNeuralPerturbationMethodVariable=getattr(
self,
'getNeuralNullPerturbationVariable'
)
#get
StabilizedRateDetermintantFloatsTuple=self.getGlobalPerturbationRootFloatsTuple(
(0.,0.)
)
#get
self.StabilizedIsStableBool=StabilizedRateDetermintantFloatsTuple[0]>0.
self.StabilizedRateInstabilityBool=not self.StabilizedIsStableBool
#debug
'''
self.debug(
[
'Is it rate instable ?',
"StabilizedRateDetermintantFloatsTuple is "+str(StabilizedRateDetermintantFloatsTuple),
('self.',self,[
'StabilizedTotalPerturbationComplexesArray',
'StabilizedIsStableBool'
])
]
)
'''
#/################/#
# Look for a hopf instability
#
#Check
if self.StabilizedIsStableBool:
#import
import scipy.optimize
#get
self.StabilizedNeuralPerturbationMethodVariable=getattr(
self,
'get'+self.StationarizingInteractionStr+'NeuralPerturbationVariable'
)
#debug
'''
self.debug(
[
"There is no rate instability so we do a Hopf scan analysis",
('self.',self,['StabilizingScanFrequencyVariable'])
]
)
'''
#type
StabilizedScanType=type(self.StabilizingScanFrequencyVariable)
#Check
if StabilizedScanType==None.__class__:
#Check
StabilizedFirstList=list(np.logspace(0,3,10))
StabilizedSecondList=StabilizedFirstList[:]
StabilizedSecondList.reverse()
StabilizedSecondList=map(lambda __Variable:-__Variable,StabilizedSecondList)
#set
self.StabilizedStabilityScanFrequencyFloatsArray=np.array(
StabilizedSecondList+StabilizedFirstList
)
elif StabilizedScanType in [np.float64,float]:
#Check
self.StabilizedStabilityScanFrequencyFloatsArray=np.array(
[self.StabilizingScanFrequencyVariable]
)
else:
#Check
self.StabilizedStabilityScanFrequencyFloatsArray=np.array(
self.StabilizingScanFrequencyVariable
)
#debug
'''
self.debug(
[
('self.',self,['StabilizedStabilityScanFrequencyFloatsArray'])
]
)
'''
#check
'''
if len(self.StabilizedStabilityScanFrequencyFloatsArray)==1:
#debug
self.debug(
[
"We just debug here"
]
)
#try just the first
self.getGlobalPerturbationRootFloatsTuple(
(-0.1,2.*np.pi*self.StabilizedStabilityScanFrequencyFloatsArray[0])
)
'''
#debug
'''
self.debug(
[
"Ok now we gradient"
]
)
'''
#loop
for __ScanFrequencyFloat in self.StabilizedStabilityScanFrequencyFloatsArray:
#for __ScanFrequencyFloat in [100.]:
#debug
'''
self.debug(
[
'We try to find an instability around '+str(__ScanFrequencyFloat)+'Hz'
]
)
'''
#Get the solve of the ScipyOptimizeRoot
StabilizedOptimizeRoot=scipy.optimize.root(
self.getGlobalPerturbationRootFloatsTuple,
(-0.1,2.*np.pi*__ScanFrequencyFloat),
#method='lm',
#tol=0.001
options={
#'maxiter':1000,
#'ftol':0.001,
#'direc':np.array([-0.1,0.1])
},
)
#set
StabilizedErrorFloat=np.sum(StabilizedOptimizeRoot.fun**2)
#debug
'''
self.debug(
[
'StabilizedOptimizeRoot is ',
str(StabilizedOptimizeRoot),
"StabilizedErrorFloat is ",
str(StabilizedErrorFloat)
]
)
'''
#set
self.StabilizedOptimizeRoot=StabilizedOptimizeRoot
#Check
if StabilizedOptimizeRoot.success and StabilizedErrorFloat<0.001:
#debug
'''
self.debug(
[
"It is a success",
('self.',self,[
'StabilizedBiggestLambdaFloatsTuple',
]),
"StabilizedOptimizeRoot.x is "+str(StabilizedOptimizeRoot.x)
]
)
'''
#Check
if StabilizedOptimizeRoot.x[0]>0.:
#set
self.StabilizedIsStableBool=False
#set
self.StabilizedInstabilityStr="Hopf"
#set
self.StabilizedInstabilityLambdaFloatsTuple=tuple(
StabilizedOptimizeRoot.x
)
self.StabilizedBiggestLambdaFloatsTuple=self.StabilizedInstabilityLambdaFloatsTuple
#set
self.StabilizedInstabilityFrequencyFloat=self.StabilizedInstabilityLambdaFloatsTuple[1]/(
2.*np.pi
)
#break
break
elif len(
self.StabilizedBiggestLambdaFloatsTuple
)==0 or StabilizedOptimizeRoot.x[0]>self.StabilizedBiggestLambdaFloatsTuple[0]:
#Check
self.StabilizedBiggestLambdaFloatsTuple=tuple(
StabilizedOptimizeRoot.x
)
