def getLabel(self, label):
sols = parseS.parseS()
#adjust maximum label/branch
mbr = max([abs(d["BR"]) for d in self] or [None])
mlab = max(self.getLabels() or [None])
for d in self:
sols.extend(d.getLabel(None, mbr=mbr, mlab=mlab))
return sols(label)
def getLabel(self, label, mbr=None, mlab=None):
sols = []
for idx in self.labels.getIndices():
x = self._gettypelabel(idx)[1]
if "solution" in x:
br = abs(self["BR"])
pt = idx % 9999 + 1
lab = x["LAB"]
ty = x["TY number"]
sol = x["solution"]
if (sol._mlab != mlab or sol._mbr != mbr or br != sol["BR"]
or pt != sol["PT"] or ty != sol["TY number"]
or lab != sol["LAB"]):
sol = sol.__class__(sol, BR=br, PT=pt, LAB=lab, TY=ty)
sol._mlab = mlab
sol._mbr = mbr
sols.append(sol)
return parseS.parseS(sols)(label)
def readFilename(self,
fort7_filename,
fort8_filename=None,
fort9_filename=None):
parseB.parseBR.readFilename(self, fort7_filename)
for i, d in enumerate(self):
self[i] = bifDiagBranch(d)
if fort8_filename is not None and isinstance(fort8_filename, str):
solution = parseS.parseS(fort8_filename)
i = 0
for d in self:
for k, x in map(d._gettypelabel, d.labels.getIndices()):
if x.get("LAB", 0) != 0:
x["solution"] = solution[i]
i = i + 1
if not fort9_filename is None:
# for now just attach diagnostics information to the first branch
self[0].diagnostics = parseD.parseD(fort9_filename)
def read(self, fort7_input, fort8_input=None, fort9_input=None):
parseB.parseBR.read(self, fort7_input)
for i, d in enumerate(self):
self[i] = bifDiagBranch(d)
if fort8_input is not None and (isinstance(fort8_input,
(file, gzip.GzipFile))):
solution = parseS.parseS()
solution.read(fort8_input)
i = 0
for d in self:
for k, x in map(d._gettypelabel, d.labels.getIndices()):
if x.get("LAB", 0) != 0:
x["solution"] = solution[i]
i = i + 1
if fort9_input is not None:
diagnostics = parseD.parseD()
diagnostics.read(fort9_input)
# for now just attach diagnostics information to the first branch
self[0].diagnostics = diagnostics
def __init__(self,parent=None,**kw):
optionDefaults = {}
# The kind of diagram (single solution vs. bifur diagram)
optionDefaults["type"] = ("bifurcation",self.__optionCallback)
# The X column
optionDefaults["bifurcation_x"] = ([0],self.__optionCallback)
optionDefaults["solution_x"] = ([-1],self.__optionCallback)
# The Y column
optionDefaults["bifurcation_y"] = ([1],self.__optionCallback)
optionDefaults["solution_y"] = ([0],self.__optionCallback)
# The Z column
optionDefaults["bifurcation_z"] = (None,self.__optionCallback)
optionDefaults["solution_z"] = (None,self.__optionCallback)
# The coordinate names
optionDefaults["bifurcation_coordnames"] = (None,self.__optionCallback)
optionDefaults["solution_indepvarname"] = (None,self.__optionCallback)
optionDefaults["solution_coordnames"] = (None,self.__optionCallback)
optionDefaults["labelnames"] = (None,self.__optionCallback)
# Sets of labels that the user is likely to want to use
optionDefaults["label_defaults"] = (None,self.__optionCallback)
# Sets of columns that the user is likely to want to use
optionDefaults["bifurcation_column_defaults"] = (None,self.__optionCallback)
optionDefaults["solution_column_defaults"] = (None,self.__optionCallback)
# The index of the solution we wish to draw
optionDefaults["index"] = ([0],self.__optionCallback)
# The label of the solution we wish to draw
optionDefaults["label"] = ([0],self.__optionCallback)
# Already parsed data structures
optionDefaults["bifurcation_diagram"] = (parseB.parseB(),self.__optionCallback)
optionDefaults["solution"] = (parseS.parseS(),self.__optionCallback)
optionDefaults["bifurcation_diagram_filename"] = ("",self.__optionCallback)
optionDefaults["solution_filename"] = ("",self.__optionCallback)
optionDefaults["runner"] = (None,self.__optionCallback)
optionDefaults["mark_t"] = (None,self.__optionCallback)
optionDefaults["letter_symbols"] = (True,self.__optionCallback)
optionDefaults["bifurcation_symbol"] = ("B",self.__optionCallback)
optionDefaults["limit_point_symbol"] = ("L",self.__optionCallback)
optionDefaults["hopf_symbol"] = ("H",self.__optionCallback)
optionDefaults["zero_hopf_symbol"] = ("ZH",self.__optionCallback)
optionDefaults["bogdanov_takens_symbol"] = ("BT",self.__optionCallback)
optionDefaults["cusp_symbol"] = ("CP",self.__optionCallback)
optionDefaults["generalized_hopf_symbol"]= ("GH",self.__optionCallback)
optionDefaults["1_1_resonance_symbol"] = ("R1",self.__optionCallback)
optionDefaults["1_2_resonance_symbol"] = ("R2",self.__optionCallback)
optionDefaults["1_3_resonance_symbol"] = ("R3",self.__optionCallback)
optionDefaults["1_4_resonance_symbol"] = ("R4",self.__optionCallback)
optionDefaults["fold_flip_symbol"] = ("LPD",self.__optionCallback)
optionDefaults["fold_torus_symbol"] = ("LTR",self.__optionCallback)
optionDefaults["flip_torus_symbol"] = ("PTR",self.__optionCallback)
optionDefaults["torus_torus_symbol"] = ("TTR",self.__optionCallback)
optionDefaults["period_doubling_symbol"] = ("D",self.__optionCallback)
optionDefaults["torus_symbol"] = ("T",self.__optionCallback)
optionDefaults["user_point_symbol"] = ("U",self.__optionCallback)
optionDefaults["error_symbol"] = ("X",self.__optionCallback)
optionDefaults["ps_colormode"] = ("color",self.__optionCallback)
optionDefaults["stability"] = (False,self.__optionCallback)
optionDefaults["coloring_method"] = ("curve",self.__optionCallback)
parser = AUTOutil.getAUTORC("AUTO_plotter")
optionDefaultsRC = {}
c = parseC.parseC()
for option in parser.options("AUTO_plotter"):
try:
optionDefaultsRC[option] = self.parseoption(
option,parser.get("AUTO_plotter",option),c)
except:
optionDefaultsRC[option] = self.parseoption(
option,parser.get("AUTO_plotter",option,raw=True),c)
# Let these override the RC options, if specified.
for key in ["hide","xlabel","ylabel","zlabel"]:
if key in kw:
optionDefaultsRC[key] = kw[key]
self.__needsPlot = None
grapher.GUIGrapher.__init__(self,parent,**optionDefaultsRC)
self.addOptions(**optionDefaults)
self.addRCOptions(**optionDefaultsRC)
for options in [optionDefaultsRC, kw]:
if "letter_symbols" in options:
self.__optionCallback("letter_symbols",
options["letter_symbols"], options)
del options["letter_symbols"]
plotter._configNoDraw(self,**optionDefaultsRC)
plotter._configNoDraw(self,**kw)
self._plotNoDraw()
self.__needsPlot = None
for coord in 'x', 'y', 'z':
if "min"+coord not in kw or "max"+coord not in kw:
self.computeRange(coord,kw.get("min"+coord),
kw.get("max"+coord))
grapher.GUIGrapher.plot(self)
def __realinit(self, fort7_filename, fort8_filename, fort9_filename,
constants):
ioerrors = []
try:
parseB.parseBR.__init__(self, fort7_filename)
for i, d in enumerate(self):
self[i] = bifDiagBranch(d)
except IOError:
ioerrors.append(str(sys.exc_info()[1]))
parseB.parseBR.__init__(self)
fort7_filename = None
if isinstance(fort8_filename, parseS.AUTOSolution):
fort8_filename = [fort8_filename]
try:
solution = parseS.parseS(fort8_filename)
except IOError:
ioerrors.append(str(sys.exc_info()[1]))
solution = None
if fort7_filename is None:
raise AUTOExceptions.AUTORuntimeError('\n'.join(ioerrors))
if fort7_filename is None and fort8_filename is not None:
# simulate a bifurcation diagram
labels = {}
for s in solution:
br = s["Branch number"]
if labels == {} or br != branch.BR:
if labels != {}:
branch.labels = Points.PointInfo(labels)
branch = bifDiagBranch()
self.append(branch)
branch.BR = br
branch.coordarray = []
branch.coordnames = []
branch.headernames = []
branch.headerlist = []
branch.c = constants
labels = {}
base = 0
i = 0
pt = s["PT"]
lab = s["LAB"]
ty = s["TY number"]
if i >= base + pt - 1:
# point numbers wrapped around
base += 9999
i = base + pt - 1
labels[i] = {s["TY"]: {"LAB": lab, "TY number": ty, "PT": pt}}
if labels != {}:
branch.labels = Points.PointInfo(labels)
if fort9_filename is not None and self.data != []:
try:
# for now just attach diagnostics information to first branch
self[0].diagnostics = parseD.parseD(fort9_filename)
except IOError:
pass
i = 0
if solution is not None:
for d in self:
if constants is None and d.c is not None:
constants = d.c
constants = parseC.parseC(constants)
for k in constants:
if k in self.nonekeys:
constants[k] = None
for ind in d.labels.getIndices():
if i >= len(solution):
break
x = d._gettypelabel(ind)[1]
s = solution[i]
if x.get("LAB", 0) != 0 or s["LAB"] == 0:
i = i + 1
s = x["solution"] = parseS.AUTOSolution(
s, constants=constants)
if d.coordnames != []:
s.b = d[ind]