np.savetxt("ManifoldRossler.txt", manifoldData)
else:
print("Loading data")
sim.loadData("TestRossler")
data = sim.getData()
manifoldData = np.loadtxt("ManifoldRossler.txt")
i = 0
for theta in angles:
print("\n")
print("Current angle = " + str(theta))
spaceVec = np.array([np.cos(theta), np.sin(theta), 0])
planeVec = np.array([np.cos(theta), np.sin(theta)])
dataMapper = PoincareMapper(spaceVec, data, direction=1)
manifoldMapper = PoincareMapper(planeVec, manifoldData, direction=1)
print("Computing return maps")
returnMapData = dataMapper.getValues()
returnMapOfManifold = manifoldMapper.getValues(
) # manifold then return map
indexReturnMapOfManifold = manifoldMapper.getIntersctIndx()
returnMapData2 = []
returnMapOfManifold2 = []
for point in returnMapData:
returnMapData2.append(
[np.sqrt(math.pow(point[0], 2) + math.pow(point[1], 2)), point[2]])
for point in returnMapOfManifold:
print('Interpolating curve')
data = fitz.interpolateCurve()[1000:]
np.savetxt('DataFitz.txt',data)
else:
data = np.loadtxt('DataFitz.txt')
# poincareSection = np.loadtxt('Fitz4DPoincare.txt')
# extremeEvents = np.array([i for i, point in enumerate(poincareSection) if(point[2]>=0.1)])
# manifoldOfPoincareSection = np.loadtxt('Fitz4DManifold.txt')
# normalVector = np.array([0,0,1/math.sqrt(2),1/math.sqrt(2)]) # Includes extreme events
normalVector = np.array([1/math.sqrt(2),1/math.sqrt(2),0,0]) # Orthogonal to extreme events
# normalVector = np.array([0,0,1,0])
print('Constructing Poincare section')
mapper = PoincareMapper(normalVector,data)
poincareSection = np.array(mapper.getValues())
interindxes = mapper.getIntersctIndx()
np.savetxt('Fitz4DPoincare.txt',poincareSection)
poincareSection2 = np.array([point for point in poincareSection if(point[2]<0.1)])
extremeEvents = np.array([i for i, point in enumerate(poincareSection) if(point[2]>=0.1)])
index = np.array([i for i, point in enumerate(poincareSection) if(point[2]<0.1)])
print('Number of extreme events = %g' % len(extremeEvents))
print("Computing LLE embedding of return map")
# manifoldOfPoincareSection, err = manifold.Isomap(8,2).fit_transform(poincareSection) # return map then manifold
# print("Done. Reconstruction error: %g" % err)
manifoldOfPoincareSection = manifold.Isomap(12,2).fit_transform(poincareSection) # return map then manifold
from mpl_toolkits.mplot3d import Axes3D
from sklearn import manifold, datasets
from Simulator import Simulator
from PoincareMapper import PoincareMapper
import Equation
import math
from scipy.integrate import odeint
from FitzSimulator import FitzSimulator
import matplotlib.cm as cm
import matplotlib.colors as colors
print('generating data')
data = np.loadtxt('./FitzFilesO/DataFitz.txt')
normalVector = np.array([1 / math.sqrt(2), 1 / math.sqrt(2), 0, 0])
print('Constructing Poincare section')
mapper = PoincareMapper(normalVector, data)
poincareSection = np.loadtxt('./FitzFilesO/Fitz4DPoincare.txt')
manData = np.loadtxt('./FitzFilesO/Fitz4DManifold.txt')
segmts = 10
print('Generate containers')
y = manData[:, 0]
rmap = np.array([y[:-1], y[1:]])
maxi = max(y)
mini = min(y)
mid = rmap[0, np.argmax(rmap, axis=1)][1]
print('Creating segments')
seg = segmts / 2
segmentsl = np.linspace(mini, mid, seg)
# Create modified data
r = np.sqrt(np.square(data[:, 0]) + np.square(data[:, 1]))
dataMod = np.zeros(np.shape(data))
dataMod[:, 0] = (np.square(data[:, 0]) - np.square(data[:, 1])) / r
dataMod[:, 1] = 2 * data[:, 0] * data[:, 1] / r
dataMod[:, 2] = data[:, 2]
# Plot original
# Compute return maps
angles = np.linspace(0, 2 * np.pi, 8)
i = 0
for theta in angles:
spaceVec = np.array([np.cos(theta), np.sin(theta), 0])
planeVec = np.array([np.cos(theta), np.sin(theta)])
dataMapper = PoincareMapper(spaceVec, data, direction=1)
dataModMapper = PoincareMapper(spaceVec, dataMod, direction=1)
print("Computing return map")
returnMapData = dataMapper.getValues()
print("Computing return map modified")
returnMapDataMod = dataModMapper.getValues()
returnMapData2 = []
returnMapDataMod2 = []
print("Append")
for point in returnMapData:
returnMapData2.append(
[np.sqrt(math.pow(point[0], 2) + math.pow(point[1], 2)), point[2]])
for point in returnMapDataMod:
returnMapDataMod2.append(
# Create manifolder for poincare col
print('Creating embedding')
embedding = manifold.TSNE(n_components=1, init='pca', random_state=0)
#-------------------------------------------------------------------
# -----------------Plotting-----------------------------------------
#-------------------------------------------------------------------
# Choose angle from x-axis for poincaremap
print('Constructing planevectors')
angle = -np.pi / 2.7
spaceVec = np.array([np.cos(angle), np.sin(angle), 0])
planeVec = np.array([np.cos(angle), np.sin(angle)])
#Make poincaremapper
print('Making poincareMappers')
dataMapper = PoincareMapper(spaceVec, simData.T, direction=1)
manifoldMapper = PoincareMapper(planeVec, manData, direction=1)
# Create returnmap of poincare sectionand conduct the manifold on it.
print('Constructing plane intersections')
returnMapData = dataMapper.iterationdifference()
intersectValues = dataMapper.getValues()
returnMapOfManifold = manifoldMapper.iterationdifference()
intsctIndx = dataMapper.getIntersctIndx()
returnMapColor = [colormap[i] for i in intsctIndx[0:-1]
] #Not last index since we remove it
#----------------------------------------------------------------------
# Plot result
fig = plt.figure()
# Original simulation data
from sklearn import manifold, datasets
from Simulator import Simulator
from PoincareMapper import PoincareMapper
from colorPlot import ColorPlot
import Equation
import math
import numpy as np
#Loading the data
simData = np.loadtxt('data.txt').T
print(simData)
#Constructing the poincare section
angle = -np.pi/2.7
spaceVec = np.array([np.cos(angle),np.sin(angle),0])
dataMapper = PoincareMapper(spaceVec,simData.T,direction = 1)
returnMapData = dataMapper.iterationdifference()
intersectValues =dataMapper.getValues()
vector2 = np.array([0,0,1])
vector3 = np.cross(spaceVec,vector2)
vector3 = vector3/np.linalg.norm(vector3)
poincmap1 = [np.dot(p,vector3) for p in intersectValues]
poincmap2 = [np.dot(p,vector2) for p in intersectValues]
fig = plt.figure()
ax = fig.add_subplot(121, projection='3d')
ax.plot(simData[0],simData[1],simData[2],linewidth = 0.7,alpha = 0.7)
ax.set_title('The rossler attractor in conjuction with the poincaré section')
normalVector = np.array([1/math.sqrt(2),1/math.sqrt(2),0,0]) # Orthogonal to extreme events
freq = {}
freqTot = {}
#print('right now in iteration: '+str(i))
#for iteratiions in range(1000)
print('simulating data')
fitz = FitzSimulator(inCond = data[-1])
print('Simulating system')
data = fitz.states(duration = 200000, split = 0.1, rtol = 1.49012e-9, atol = 1.49012e-9)
print('Interpolating curve')
#data = fitz.interpolateCurve()
print('making poincare map')
mapper = PoincareMapper(normalVector,data)
poincareSection = np.array(mapper.getValues())
extremeEvents = np.array([i for i, point in enumerate(poincareSection) if(np.linalg.norm(point)>=0.12)])
print('manifolding')
manifoldOfPoincareSection = manifold.Isomap(12,2).fit_transform(poincareSection) # return map then manifold
y = manifoldOfPoincareSection[:,0]
print('Generate containers')
y = manifoldOfPoincareSection[:,0]
rmap = np.array([y[:-1],y[1:]])
maxi = max(y)
mini = min(y)
mid = rmap[0,np.argmax(rmap,axis=1)][1]
import Equation
from Simulator import Simulator
from Vizualiser import Vizualiser
from PoincareMapper import PoincareMapper
import matplotlib.pyplot as plt
import numpy as np
import math
from mpl_toolkits.mplot3d import Axes3D
eq = Equation.Rossler()
sim = Simulator(eq)
data = sim.states(duration=600)
#sim.tredimplot()
mapper = PoincareMapper([0.5, 1, 0], data, direction=-1)
viz = Vizualiser(sim, mapper)
def f(vector):
return vector[2]
viz.z1Toz2Plot(fun=f)
viz.simplePlot()
#a = mapper.planePoints()
#print(a)
#plt.plot(a[0],a[1],'o')
#plt.show()