I'm a civil engineering student and as a part of my master thesis I have to run some buckling analysis on laminated glass columns in Abaqus. For this I wrote a Python script.
I create a part with a depth of the sum of the glasses and interlayers. I create some datum planes and create a partition, so I have n layers of glas and n-1 layers of interlayers. For the load intrudoction I need partition faces at the top and bottom in the middle of the glas layers. I create some refpoints for the load an d boundary conditions.
Now I need do create Constraints trough coupling nodes between the refpoints and the partition faces. I do this so the ends are slip free.
I have no idea why the for loop isn't working. Do you guys know where I make a mistake or do you have an idea how i can write a for loop so the coupling works?
Here is my code:
#######################################
# Knickstab VSG Parameterrechnung#
#######################################
"""
Dieses Skript...
... modelliert einen Stab
... führt eine Buckling Analyse durch
... verschiebt eine Ecke aus der Ebene heraus
... und belastet optional um das Eigengewicht
"""
hoehe = 2000.0 #x Ausdehnung
breite = 250.0 #y Ausdehnung
dglas = [8, 12, 14] #z Ausdehnung Glas
dfolie = [1.52, 0.76] #z Ausdehnung Folie
dicke = sum(dglas) + sum(dfolie) #z Ausdehnung Gesamt
meshgroesse = 50
anzElemDickeFolie = 2 #Langosch orientieren später Konervenzstudie durchführen
anzElemDickeGlas = 1 #Langosch orientieren später Konervenzstudie durchführen pro Halbe Scheibendicke
emodulGlas = 70000
mueGlas = 0.23
SchubmodulFolie = 1 # Langosch G[0;1;10;∞]
mueFolie = 0.39
emodulFolie = 2*(1+mueFolie)*SchubmodulFolie
mInc = 0.05 #maximale Inkrementgröße
initInc = 0.05 #Initiale Inkrementgröße
workspace= 'C:'
beElemType='C3D8R'
#Buckle Step bezogen
eNull = hoehe/400 #Amplitude der Imperfektion
numEigForm = 4 #Anzahl der angefragten Eigenformen
eigForm = 1 #ausgewählte Eigenform
###########################################################################################################################################
########################### SKRIPT BODY ###################################################################################################
###########################################################################################################################################
modelname = 'Stuetze_'+str(dglas[0])
for i in range(1,len(dglas)):
modelname=modelname + '-' + str(int(dfolie[i-1]/0.38))+'f'
modelname=modelname + '-' + str(int(dglas[i]))
modelname = modelname + '_G'+str(SchubmodulFolie)
partname = modelname
delta = dicke/anzElemDickeGlas/10
# Do not delete the following import lines
from abaqus import *
from abaqusConstants import *
import __main__
import section
import regionToolset
import displayGroupMdbToolset as dgm
import part
import material
import assembly
import step
import interaction
import load
import mesh
import optimization
import job
import sketch
import visualization
import xyPlot
import displayGroupOdbToolset as dgo
import connectorBehavior
import os
from odbAccess import *
import numpy as np
#############################################################################
#!!!!!!!!!!!!!!WIIIIIICHTIG!!!!!!!!!!!!!!!!!!!
# |
# |
# V
#Anpassen des Workdirectorys
os.chdir(r"C")#
# Erstellen des Modells
mdb.Model(name=modelname, modelType=STANDARD_EXPLICIT)
a = mdb.models[modelname].rootAssembly
# Erstellen des Parts
s1 = mdb.models[modelname].ConstrainedSketch(name='__profile__',
sheetSize=200.0)
s1.rectangle(point1=(0, 0), point2=(breite, hoehe))
p = mdb.models[modelname].Part(name=partname, dimensionality=THREE_D,
type=DEFORMABLE_BODY)
p.BaseSolidExtrude(sketch=s1, depth=dicke)
p = mdb.models[modelname].parts[partname]
del mdb.models[modelname].sketches['__profile__']
# Erstellen der Datumsebenen relativ zu den Flächen mit Berücksichtigung der Dicken
f = p.faces.findAt((delta,delta,0),)
# erstelle Vektor mit Dickenkoordinaten an denen datumplanes erstellt werden
datumDicken = []
datumDicken.append(dglas[0])
for i in range(1,len(dglas)):
if i%2 != 0:
datumDicken.append(datumDicken[i-1]+dfolie[i-1])
else:
datumDicken.append(datumDicken[i-1]+dglas[i-1])
datumDicken.append(datumDicken[-1]+dfolie[-1])
datumDicken.append(datumDicken[-1]+dglas[-1])
for i in range(len(datumDicken)-1):
p.DatumPlaneByOffset(plane=f, flip=SIDE2, offset=float(datumDicken[i]))
# Erstellen der Partition basierend auf den zuvor erstellten Datumsebenen
for i in range(len(datumDicken)-1):
c = p.cells
# Partitionierung der Zellen mit der ersten Datumsebene (f[4])
pickedCells = c.findAt((0,0,datumDicken[i]-0.01),)
d1 = p.datums
p.PartitionCellByDatumPlane(datumPlane=d1[i+2], cells=pickedCells)
#Erstellen einer Partition im Schwerpunkt der Glasscheiben zur Einleitung der Last im Fall ohne Schlupfendbehinderung
for i in range(len(dglas)):
j=i*2
#Partitions an Unterseite
f = p.faces
pickedFaces = f.findAt((breite/2,0,(datumDicken[j]-0.01)),)
v, e, d = p.vertices, p.edges, p.datums
p.PartitionFaceByShortestPath(faces=pickedFaces, point1=p.InterestingPoint(
edge=e.findAt((0,0,datumDicken[j]-0.01),), rule=MIDDLE), point2=p.InterestingPoint(edge=e.findAt((breite,0,datumDicken[j]-0.01),),
rule=MIDDLE))
#Partitions an Oberseite
pickedFaces = f.findAt((breite/2,hoehe,(datumDicken[j]-0.01)),)
v, e, d = p.vertices, p.edges, p.datums
p.PartitionFaceByShortestPath(faces=pickedFaces, point1=p.InterestingPoint(
edge=e.findAt((0,hoehe,datumDicken[j]-0.01),), rule=MIDDLE), point2=p.InterestingPoint(edge=e.findAt((breite,hoehe,datumDicken[j]-0.01),),
rule=MIDDLE))
# Material erstellen Glas
mdb.models[modelname].Material(name='Glas')
mdb.models[modelname].materials['Glas'].Elastic(table=((emodulGlas, mueGlas), ))
# Material erstellen Folie elastischer Schubmodul
mdb.models[modelname].Material(name='Folie')
mdb.models[modelname].materials['Folie'].Elastic(table=((emodulFolie, mueFolie), ))
#Section Erstellung
mdb.models[modelname].HomogeneousSolidSection(name='GlasSection',
material='Glas', thickness=None)
mdb.models[modelname].HomogeneousSolidSection(name='FolieSection',
material='Folie', thickness=None)
#Section Zuweisung
#Zuweisung der Glassection
for i in range(len(dglas)):
j=i*2
c = p.cells
c1 = c.findAt((0,0,datumDicken[j]-0.01), )
q = c1.index
cells = c[q:q+1]
region = p.Set(cells=cells, name='Scheibe-'+str(i))
p.SectionAssignment(region=region, sectionName='GlasSection', offset=0.0,
offsetType=MIDDLE_SURFACE, offsetField='',
thicknessAssignment=FROM_SECTION)
#Zuweisung der Foliensection
for i in range(len(dfolie)):
j=i*2
c = p.cells
c1 = c.findAt((0,0,datumDicken[j]+0.01), )
q = c1.index
cells = c[q:q+1]
region = p.Set(cells=cells, name='Folie-'+str(i))
p.SectionAssignment(region=region, sectionName='FolieSection', offset=0.0,
offsetType=MIDDLE_SURFACE, offsetField='',
thicknessAssignment=FROM_SECTION)
#Instance Erstellen
a.DatumCsysByDefault(CARTESIAN)
a.Instance(name=partname, part=p, dependent=ON)
#Reference Point erstellen und auslesen der ID zur Ansprache in Coupling
a.ReferencePoint(point=(breite/2, hoehe+100, dicke/2))
idRF1 = mdb.models[modelname].rootAssembly.referencePoints.values()[0]
a.ReferencePoint(point=(breite/2, -100, dicke/2))
idRF2 = mdb.models[modelname].rootAssembly.referencePoints.values()[0]
#Refpoint umbenennen
mdb.models[modelname].rootAssembly.features.changeKey(fromName='RP-1',
toName='Loslager+Lastpunkt')
mdb.models[modelname].rootAssembly.features.changeKey(fromName='RP-2',
toName='Festlager')
#Coupling Reference Point mit Glasmitten oben
refPoints1=(idRF1, )
region1=a.Set(referencePoints=refPoints1, name='Loslager+Lastpunkt')
edgesTop1 = a.instances[modelname].edges.findAt((breite/2,hoehe,dglas[0]/2),)
for i in range(1,len(dglas)):
j=i*2
p = mdb.models[modelname].parts[partname]
s = p.edges
edgeCurr = s.getByBoundingBox(-1,hoehe-1,datumDicken[j]-dglas[i]/2-1,breite+1,hoehe+1,datumDicken[j]-dglas[i]/2+1)
print(edgeCurr)
a.Set(edges=edgeCurr, name='slaveTop'+str(i+1))
region2 = a.Set(edges=edgesTop1, name='slaveTop')
mdb.models[modelname].Coupling(name='Loslager+Last',
controlPoint=region1, surface=region2, influenceRadius=WHOLE_SURFACE,
couplingType=KINEMATIC, localCsys=None, u1=ON, u2=ON, u3=ON, ur1=ON,
ur2=ON, ur3=ON)
mdb.models[modelname].Coupling(name='Loslager+Last',
controlPoint=region1, surface=regiono, influenceRadius=WHOLE_SURFACE,
couplingType=KINEMATIC, localCsys=None, u1=ON, u2=ON, u3=ON, ur1=ON,
ur2=ON, ur3=ON)
'''
#Coupling Reference Point mit Glasmitte unten
r1 = a.referencePoints
refPoints1=(r1[5], )
region1=a.Set(referencePoints=refPoints1, name='m_Set-5')
e1 = a.instances[modelname].edges
edges1 = e1.getByBoundingBox(-1, -1, (dicke-(dglas[0]/2)-1), breite+1, 1, (dicke-(dglas[0]/2)+1))
e2 = a.instances[modelname].edges
edges2 = e2.getByBoundingBox(-1, -1, (dglas[1]/2)-1, breite+1, 1, (dglas[1]/2)+1 )
region2=a.Set(edges=edges1+edges2, name='s_Set-8')
mdb.models[modelname].Coupling(name='Festlager',
controlPoint=region1, surface=region2, influenceRadius=WHOLE_SURFACE,
couplingType=KINEMATIC, localCsys=None, u1=ON, u2=ON, u3=ON, ur1=ON,
ur2=ON, ur3=ON)
'''
#BC Erstellen (Euler Fall II)
#BC Festlager
mdb.models[modelname].rootAssembly.Set(name='Set-2', referencePoints=(
mdb.models[modelname].rootAssembly.referencePoints[5], ))
mdb.models[modelname].DisplacementBC(amplitude=UNSET, createStepName=
'Initial', distributionType=UNIFORM, fieldName='', localCsys=None, name=
'Festlager', region=mdb.models[modelname].rootAssembly.sets['Set-2']
, u1=SET, u2=SET, u3=SET, ur1=UNSET, ur2=SET, ur3=UNSET)
#BC Loslager
mdb.models[modelname].rootAssembly.Set(name='Set-3', referencePoints=(
mdb.models[modelname].rootAssembly.referencePoints[4], ))
mdb.models[modelname].DisplacementBC(amplitude=UNSET, createStepName=
'Initial', distributionType=UNIFORM, fieldName='', localCsys=None, name=
'Loslager', region=mdb.models[modelname].rootAssembly.sets['Set-3'],
u1=SET, u2=UNSET, u3=SET, ur1=UNSET, ur2=SET, ur3=UNSET)
###########################################################################################################################################################################################################
# Mesh erstellen
region = (p.cells,)
elemType = mesh.ElemType(
elemCode=C3D20R,
elemLibrary=STANDARD,
kinematicSplit=AVERAGE_STRAIN,
secondOrderAccuracy=OFF,
hourglassControl=ENHANCED,
distortionControl=DEFAULT
)
p.setElementType(regions=region, elemTypes=(elemType,))
p.seedPart(size=meshgroesse, deviationFactor=0.1, minSizeFactor=0.1)
# Seed-Operationen für Kanten basierend auf den verschiedenen Dicken
edges = e.findAt(((0, 0, float(dfolie[0] / 2)),), ((hoehe, 0, float(dfolie[0] / 2)),),
((hoehe, breite, float(dfolie[0] / 2)),), ((0, breite, float(dfolie[0] / 2)),))
p.seedEdgeByNumber(edges=edges, number=anzElemDickeFolie, constraint=FINER)
for d in dglas:
edges = e.findAt(((0, 0, float(d / 2)),), ((hoehe, 0, float(d / 2)),),
((hoehe, breite, float(d / 2)),), ((0, breite, float(d / 2)),))
p.seedEdgeByNumber(edges=edges, number=anzElemDickeGlas, constraint=FINER)
edges = e.findAt(((0, 0, float(dicke - dfolie[0] / 2)),), ((hoehe, 0, float(dicke - dfolie[0] / 2)),),
((hoehe, breite, float(dicke - dfolie[0] / 2)),), ((0, breite, float(dicke - dfolie[0] / 2)),))
p.seedEdgeByNumber(edges=edges, number=anzElemDickeGlas, constraint=FINER)
# Mesh generieren
p.generateMesh()
a.regenerate()
###########################################################################################################################################################################################################
#Modell für Buckling kopieren
modelnamebuckle=modelname+'_buckle'
mdb.Model(name=modelnamebuckle,
objectToCopy=mdb.models[modelname])
a2 = mdb.models[modelnamebuckle].rootAssembly
#Buckling Step erstellen
numEigVectors=numEigForm*2
mdb.models[modelnamebuckle].BuckleStep(name='Buckle',
previous='Initial', numEigen=numEigForm, vectors=numEigVectors, maxIterations=10000)
#Last im Bucklestep
mdb.models[modelnamebuckle].rootAssembly.Set(name='Set-4',
referencePoints=(
mdb.models[modelnamebuckle].rootAssembly.referencePoints[4], ))
mdb.models[modelnamebuckle].ConcentratedForce(cf2=-1.0, createStepName=
'Buckle', distributionType=UNIFORM, field='', localCsys=None, name='1-Last'
, region=mdb.models[modelnamebuckle].rootAssembly.sets['Set-4'])
######################################################################################################################################################################################################################
#Keywords im Bucklemodell ändern
#Zeile finden und bearbeiten fuer Imperfektion
modelkwb = mdb.models[modelnamebuckle].keywordBlock
assembly = mdb.models[modelnamebuckle].rootAssembly
modelkwb.synchVersions(storeNodesAndElements=False)
line_num = 0
n=0
for n, line in enumerate(modelkwb.sieBlocks):
if line.replace(" ","").lower() == "*EndStep".lower():
line_num = n
break
Zeile=line_num-1
mdb.models[modelnamebuckle].keywordBlock.synchVersions(storeNodesAndElements=False)
mdb.models[modelnamebuckle].keywordBlock.insert(Zeile,
"""*NODE FILE""")
mdb.models[modelnamebuckle].keywordBlock.insert(Zeile+1,
"""u""")
print( modelnamebuckle+' completed Keywordchange')
############################################################################################################################
################################### Buckling Analysis ######################################################
############################################################################################################################
# Job Creation
jobNameBuckle = str(modelnamebuckle)
job = mdb.Job(name=jobNameBuckle, model = modelnamebuckle)
job.submit()
job.waitForCompletion()
#######################################################################################################################################
#Eigenvalue ausgeben
r = session.openOdb(name=modelnamebuckle+'.odb')
frame = r.steps['Buckle'].frames[1] # Den ersten Frame auswählen (Index beginnt bei 1)
eigenvalue_description = frame.description
eigenvalues = eigenvalue_description.split()
EigenValue = float(eigenvalues[-1])
print(EigenValue)
##################################################################################################################
#Belastungsstep erstellen
mdb.models[modelname].StaticRiksStep(name='Belastungsstep',
previous='Initial', maxLPF=1.0 , maxNumInc=1000, initialArcInc=0.01, nlgeom=ON)
#Druckkraft im Belastungsstep
mdb.models[modelname].rootAssembly.Set(name='Set-4',
referencePoints=(
mdb.models[modelname].rootAssembly.referencePoints[4], ))
mdb.models[modelname].ConcentratedForce(cf2=-EigenValue, createStepName=
'Belastungsstep', distributionType=UNIFORM, field='', localCsys=None, name='Druckkraft'
, region=mdb.models[modelname].rootAssembly.sets['Set-4'])
##############################################################################################################
############# HISTORY OUTPUT #################################################################################
##############################################################################################################
#HistoryOutput an Mitte Scheibenober- und -unterseite
n1 = a.instances[partname].nodes
nodes1 = n1.getByBoundingBox(breite-delta,hoehe/2-delta,dicke-delta,breite+delta,hoehe/2+delta,dicke+delta)
a.Set(nodes=nodes1, name='ScheibeOben1')
regionDef=a.sets['ScheibeOben1']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeOben1', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes2 = n1.getByBoundingBox(0-delta,hoehe/2-delta,dicke-delta,0+delta,hoehe/2+delta,dicke+delta)
a.Set(nodes=nodes2, name='ScheibeOben2')
regionDef=a.sets['ScheibeOben2']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeOben2', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes3 = n1.getByBoundingBox(breite-delta,hoehe/2-delta,0-delta,breite+delta,hoehe/2+delta,0+delta)
a.Set(nodes=nodes3, name='ScheibeUnten1')
regionDef=a.sets['ScheibeUnten1']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeUnten1', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes4 = n1.getByBoundingBox(0-delta,hoehe/2-delta,0-delta,0+delta,hoehe/2+delta,0+delta)
a.Set(nodes=nodes4, name='ScheibeUnten2')
regionDef=a.sets['ScheibeUnten2']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeUnten2', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
#Set für Paths erstellen
pathNodes1 = n1.getByBoundingBox(breite-delta,hoehe/2-delta,dicke-delta,breite+delta,hoehe/2+delta,dicke+delta)
pathNodes2 = n1.getByBoundingBox(0-delta,hoehe/2-delta,dicke-delta,0+delta,hoehe/2+delta,dicke+delta)
pathNodes3 = n1.getByBoundingBox(breite-delta,hoehe/2-delta,0-delta,breite+delta,hoehe/2+delta,0+delta)
pathNodes4 = n1.getByBoundingBox(0-delta,hoehe/2-delta,0-delta,0+delta,hoehe/2+delta,0+delta)
a.Set(nodes = pathNodes1 , name = 'PathsScheibeOben1')
a.Set(nodes = pathNodes2 , name = 'PathsScheibeOben2')
a.Set(nodes = pathNodes3 , name = 'PathsScheibeUnten1')
a.Set(nodes = pathNodes4 , name = 'PathsScheibeUnten2')
"""
#Findet Node mit findAt nicht
#HistoryOutput an Mitte Scheibenober- und -unterseite
n1 = a.instances[partname].nodes
nodes1 = n1.findAt((breite,hoehe/2,dicke),)
a.Set(nodes=nodes1, name='ScheibeOben1')
regionDef=a.sets['ScheibeOben1']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeOben1', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes2 = n1.findAt((0,hoehe/2,dicke),)
a.Set(nodes=nodes2, name='ScheibeOben2')
regionDef=a.sets['ScheibeOben2']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeOben2', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes3 = n1.findAt((breite,hoehe/2,0),)
a.Set(nodes=nodes3, name='ScheibeUnten1')
regionDef=a.sets['ScheibeUnten1']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeUnten1', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
n1 = a.instances[partname].nodes
nodes4 = n1.findAt((0,hoehe/2,0),)
a.Set(nodes=nodes4, name='ScheibeUnten2')
regionDef=a.sets['ScheibeUnten2']
mdb.models[modelname].HistoryOutputRequest(name='ScheibeUnten2', createStepName='Belastungsstep', variables=('U3','S22',), frequency=1, region=regionDef, sectionPoints=DEFAULT, rebar=EXCLUDE,)
#Set für Paths erstellen
pathNodes1 = n1.findAt((breite,hoehe/2,dicke),)
pathNodes2 = n1.findAt((0,hoehe/2,dicke),)
pathNodes3 = n1.findAt((breite,hoehe/2,0),)
pathNodes4 = n1.findAt((0,hoehe/2,0),)
a.Set(nodes = pathNodes1 , name = 'PathsScheibeOben1')
a.Set(nodes = pathNodes2 , name = 'PathsScheibeOben2')
a.Set(nodes = pathNodes3 , name = 'PathsScheibeUnten1')
a.Set(nodes = pathNodes4 , name = 'PathsScheibeUnten2')
"""
#######################################################################################################################################
#Keywords im Belastungsmodell ändern
#keywords nullen
mdb.models[modelname].keywordBlock.synchVersions(storeNodesAndElements=False)
mdb.models[modelname].keywordBlock.setValues(edited = 0)
mdb.models[modelname].keywordBlock.synchVersions(storeNodesAndElements=False)
#Zeile finden und bearbeiten fuer Imperfektion
modelkwb = mdb.models[modelname].keywordBlock
assembly = mdb.models[modelname].rootAssembly
modelkwb.synchVersions(storeNodesAndElements=False)
line_num = 0
n=0
for n, line in enumerate(modelkwb.sieBlocks):
if line.replace(" ","").lower() == "*Step,name=Belastungsstep,nlgeom=YES,inc=1000".lower():
line_num = n
break
Zeile=line_num-1
mdb.models[modelname].keywordBlock.synchVersions(storeNodesAndElements=False)
mdb.models[modelname].keywordBlock.insert(Zeile-1, """
*IMPERFECTION, File="""+jobNameBuckle+""", Step=1
"""+str(eigForm)+""","""+str(eNull))
print( modelname+'completed Keywordchange')
###################################################################################################################################
# Job Creation
jobName = str(modelname)
job = mdb.Job(name=jobName, model = modelname)
job.submit()
job.waitForCompletion()
################################################################################################
#XY-Data U3 und S22 in Feldmitte Scheibenober- und -unterseite
odb = session.openOdb(name = str(workspace+'/'+jobName+'.odb'))
session.viewports['Viewport: 1'].setValues(displayedObject=odb)
session.mdbData.summary()
xyList = xyPlot.xyDataListFromField(odb=odb, outputPosition=NODAL, variable=((
'U', NODAL, ((COMPONENT, 'U3'), )), ('S', INTEGRATION_POINT, ((
COMPONENT, 'S22'), )), ), nodeSets=('PATHSSCHEIBEOBEN1',
'PATHSSCHEIBEOBEN2', 'PATHSSCHEIBEUNTEN1', 'PATHSSCHEIBEUNTEN2', ))
xyp = session.XYPlot('XYPlot-1')
chartName = xyp.charts.keys()[0]
chart = xyp.charts[chartName]
curveList = session.curveSet(xyData=xyList)
chart.setValues(curvesToPlot=curveList)
print(EigenValue)
Now i edited the whole Script.