class moments(etData):
def __init__(self,allign="para"):
etData.__init__(self)
self.name="moments%scoreff2.dat"%(allign)
self.load()
self.gphist=Gnuplot()
self.gphist("set title '%s'"%(allign))
def load(self):
infile=open(self.name,"r")
keys=(infile.readline()).split()
dat=loadtxt(infile)
for i,key in enumerate(keys):
self.data[key]=copy.deepcopy(dat[:,i])
def plot_hist(self,arg,xvals,xlabel=None,ylabel=None,save=False,title=None,reset=False):
print self.get_hist(arg,xvals)[0],self.get_hist(arg,xvals)[1]
if reset:
self.gphist.reset()
if ylabel:
self.gphist("set ylabel '%s'"%(ylabel))
if xlabel:
self.gphist("set xlabel '%s'"%(xlabel))
if not title:
title=arg
self.gphist.replot(Data(self.get_hist(arg,xvals)[0],self.get_hist(arg,xvals)[1],with_="histeps lw 3",title=title))
if ylabel or xlabel:
self.gphist("unset xlabel")
class Plot:
def __init__(self, fn=None):
self.gp = Gnuplot()
if fn:
self.gp('load "%s"' % fn)
self.items = []
self.needs_update = False
def markdirty(self, d=True):
""" Update will be necessary. """
self.needs_update = d
def update(self):
""" Update the plot, but only if it necessary. """
if self.needs_update:
# only items with 'only_append'?
# ao=all([i.only_append for i in self.items]) python2.5
ao = sum([i.only_append for i in self.items]) == len(self.items)
for i in self.items:
if i.needs_init_plot:
ao = False
break
if not ao:
self.gp.plot() # start with empty plot
for i in self.items:
if i.needs_update:
i.update()
i.needs_update = False
if not ao and not i.empty():
self.gp.replot(i)
i.needs_init_plot = False
if ao:
self.gp.replot(
) # simply cause plot update (FIXME: is this true?)
self.needs_update = False
def add(self, item):
if not item in self.items:
self.items += [item]
self.needs_update = True
connect(self.markdirty, item.changed, weak=False)
connect(item.mouseclick, self.mouseclick, weak=False)
def remove(self, item):
if item in self.items:
self.items.remove(item)
disconnect(self.markdirty, item.changed)
disconnect(item.mouseclick, self.mouseclick)
self.needs_update = True
def mouseclick(self, x, y, btn):
send(self.mouseclick, self, x, y, btn)
gp("set yrange[0.1:1e5]")
gp("set xrange[.1:100.]")
gp("set format y '10^{%T}'")
gp("set xlabel 'keV/amu'")
gp("set ylabel 'N[#]'")
if (len(hedata.time) == 1):
gp("set title '2007 DoY %.3f'" % (hedata.time[0]))
else:
gp("set title '2007 DoY %.3f-%.3f'" %
(hedata.time[0], hedata.time[len(hedata.time) - 1]))
first = 1
for spec in pspec:
if (first):
gp.plot(spec)
first = 0
else:
gp.replot(spec)
#gp.replot(psumhist)
#gp.replot("f(x)")
if (len(hedata.time) == 1):
name = "%.3f" % (hedata.time[0])
else:
name = "%.3f-%.3f" % (hedata.time[0], hedata.time[len(hedata.time) - 1])
gp.hardcopy("%s.ps" % (name), color="true", fontsize=20)
#for i in range(len(fedata[0].time)):
# sumspec.append([
# for j in range(len(fedata)):
class cascade:
def __init__(self, B, power, index, eff, ions, vsw, valf):
"B\t->\t float : magnetic field strength in nT\npower\t->\t float : scales the wavepower spectrum\nindex\t->\t float : spectral index of cascade\neff\t->\t float : efficiency for energy drain from cascade\nions\t->\t [nrions][ioname(str),ionmass(float,in amu),ioncharge(float,in e),iondens(float,in respect to protons)\nvsw\t->\t float : solar wind speed\nvalf\t->\t float : alfven speed"
self.B = B * 1e-9
self.power = power
self.index = index
self.eff = eff
self.vsw = vsw
self.valf = valf
self.name = []
self.dens = []
self.mass = []
self.mqarr = []
self.charge = []
self.sequence = []
for ion in ions:
self.name.append(ion[0])
self.mass.append(ion[1])
self.charge.append(ion[2])
self.dens.append(ion[3])
self.mqarr.append(ion[2] / ion[1])
self.sequence.append(0)
self.qm0 = 1.602176487e-19 / 1.66053886e-27
self.warr = []
self.dim = len(self.mqarr)
self.get_sequence()
self.build_warr()
self.calc_casc()
def set_index(self, a):
self.index = a
def set_B(self, a):
self.B = a * 1e-9
def set_efficiency(self, a):
self.eff = a
def build_warr(self):
"calculates the resonance frequencies"
for i in self.sequence:
self.warr.append(-(self.mqarr[i] * self.qm0 * self.B) /
(1. - self.vsw / self.valf))
def get_sequence(self):
mqarr = []
sequence = []
for val in self.mqarr:
mqarr.append(val)
for i in range(self.dim):
maxval = min(mqarr)
maxpos = 0
i = 0
while (mqarr[i] != maxval):
i += 1
maxpos = i
"""
for i in range(self.dim):
if (mqarr[i]==maxval):
maxpos=i
"""
sequence.append(maxpos)
newmqarr = []
for i in range(self.dim):
if (i != maxpos):
newmqarr.append(mqarr[i])
else:
newmqarr.append(100.)
mqarr = []
for val in newmqarr:
mqarr.append(val)
self.sequence = sequence
def calc_casc(self):
Parr = [[.01, self.power]]
dParr = [[.01, 0.]]
for i in range(self.dim):
Parr.append([self.warr[i], 0.])
dParr.append([self.warr[i], 0.])
Parr[0][1] = (self.power * Parr[0][0]**-self.index)
dParr[0][1] = (self.power * Parr[0][0]**-self.index)
#dParr[0][1]=0.
Parr[1][1] = (self.power * Parr[1][0]**-self.index) - (
self.power * Parr[1][0]**-self.index
) * self.dens[self.sequence[0]] * self.eff * self.charge[
self.sequence[0]]**2 / self.mass[self.sequence[0]]
dParr[1][1] = (self.power * Parr[1][0]**-self.index) * self.dens[
self.sequence[0]] * self.eff * self.charge[
self.sequence[0]]**2 / self.mass[self.sequence[0]]
for i in range(self.dim - 1):
P0 = (self.power * Parr[i + 2][0]**-self.index) - (
(self.power * Parr[i + 1][0]**-self.index) - Parr[i + 1][1])
dP = P0 * self.dens[self.sequence[i + 1]] * self.eff * self.charge[
self.sequence[i + 1]]**2 / self.mass[self.sequence[i + 1]]
print "P0,dP"
print P0, dP
if (dP < P0):
Parr[i + 2][1] = P0 - dP
else:
Parr[i + 2][1] = 1.
dP = P0
dParr[i + 2][1] = dP
if (i == 0):
dParr[i + 2][1] = dP
if (i == 1):
dParr[i + 2][1] = dP
if (i == 2):
dParr[i + 2][1] = dP
self.Parr = Parr
self.dParr = dParr
dParr2 = []
dParr3 = []
dVarr = []
E0 = 0.
ppos = 0
hepos = 0
for j in range(len(self.sequence)):
if (self.name[self.sequence[j]] == "H1+"):
ppos = j
if (self.name[self.sequence[j]] == "He2+"):
hepos = j
for i in range(self.dim):
pos = self.sequence[i]
print "pos = ", i, self.sequence[i], pos
print "p,hepos = ", ppos, hepos
dParr2.append([
dParr[i + 1][0], (dParr[i + 1][1] / self.dens[pos]) /
(dParr[ppos + 1][1] / self.dens[self.sequence[ppos]])
])
# dv/dvHe
#a=sqrt((dParr[i+1][1]*2./self.dens[i]**2)/self.mass[i])*(self.charge[i]**1.5/self.mass[i])/(sqrt((dParr[self.dim-3][1]*2./self.dens[self.dim-4]**2)/self.mass[self.dim-4])*(self.charge[self.dim-4]**1.5/self.mass[self.dim-4]))
a = sqrt(
(dParr[i + 1][1] * 2. / self.dens[pos]**1.) / self.mass[pos]
) * (self.charge[pos]**1.5 / self.mass[pos]**1.) / (sqrt(
(dParr[hepos + 1][1] * 2. / self.dens[self.sequence[hepos]]**
1.) / self.mass[self.sequence[hepos]]) * (
self.charge[self.sequence[hepos]]**1.5 /
self.mass[self.sequence[hepos]]**1.))
# b = E/Ep
b = (dParr[i + 1][1] / self.dens[pos]) / (
dParr[ppos + 1][1] / self.dens[self.sequence[ppos]])
print a, b
#dParr3.append([self.mass[i]/self.charge[i],(a)*(self.charge[i]**1.5/self.mass[i])])
dParr3.append([self.charge[pos] / self.mass[pos], b])
dVarr.append([self.charge[pos] / self.mass[pos], a])
pdParr = []
pdVarr = []
self.pdVarr = []
self.pdParr = []
for j in range(self.dim):
for k in range(self.dim):
if (self.name[self.sequence[k]] == self.name[j]):
pos = k
if (self.name[j] != "H1+"):
self.pdVarr.append(Data([dVarr[pos]]))
self.pdVarr[len(self.pdVarr) - 1].set_option_colonsep(
"with", "p pt %i lt 3" % (j + 1))
self.pdParr.append(Data([dParr3[pos]]))
if (self.name[j] == "H1+"):
self.pdParr[len(self.pdParr) - 1].set_option_colonsep(
"title", "'%s'" % ("H^{1+}"))
if (self.name[j] == "H1+"):
self.pdParr[len(self.pdVarr) - 1].set_option_colonsep(
"with", "p pt %i lt 1" % (j + 1))
else:
self.pdParr[len(self.pdVarr) - 1].set_option_colonsep(
"with", "p pt %i lt 3" % (j + 1))
self.dParr2 = dParr2
self.dParr3 = dParr3
self.dVarr = dVarr
def plot(self):
self.gp = Gnuplot()
#self.gp("set autoscale")
self.gp("set size square")
self.gp("set xrange[0.01:.1]")
self.gp("set yrange[100.:1000.]")
self.gp("set format xy '10^%T'")
self.gp("set xlabel '{/Symbol w} [Hz]'")
self.gp("set ylabel 'Wave Power [arb.]'")
self.gp("set logscale xy")
self.pParr = Data(self.Parr)
self.pParr.set_option_colonsep("with", "lp")
self.gp.plot(self.pParr)
#self.gp.replot(Data(self.dParr2))
#self.gp.replot(Data(self.dParr2))
self.gp("a=%f" % (self.power))
self.gp("k=%f" % (self.index))
self.gp("f(x)=a*x**-k")
self.gp("f2(x)=(a*.7)*x**-(k+.1)")
self.gp("f3(x)=(a*1e-5)*x**-(k+4.)")
#self.gp.replot("f(x) with l lt 3","f2(x) with l lt 4","f3(x) with l lt 5")
self.gp("set term postscript color 18 lw 2 eps")
self.gp.hardcopy("Pcascall.ps", color="true", fontsize=18)
self.gp2 = Gnuplot()
self.gp2("set logscale xy")
self.gp2("set title 'theocasc dE'")
#gp2("set yrange[1:1.1]")
first = 1
for j in range(self.dim):
if (first == 1):
self.gp2.plot(self.pdParr[j])
first = 0
else:
self.gp2.replot(self.pdParr[j])
self.gp3 = Gnuplot()
self.gp3("set logscale xy")
self.gp3("set title 'theocasc dV'")
first = 1
for j in range(self.dim):
if (first == 1):
self.gp3.plot(self.pdVarr[j])
first = 0
else:
self.gp3.replot(self.pdVarr[j])
for step in range(len(alldata[ion][i])):
summe += alldata[ion][i][step][1]
tmpsum.append(summe)
print tmpsum
gp = Gnuplot()
gp("set log y")
first = 1
for ion in range(numberions):
for i in range(len(alldata[ion])):
if (first):
gp.plot(gpalldata[ion][i])
first = 0
else:
gp.replot(gpalldata[ion][i])
maxvel = zeros([numberfiles, numberions], float)
maxflux = zeros([numberfiles, numberions], float)
maxdens = zeros([numberfiles, numberions], float)
for time in range(numberfiles):
for ion in range(numberions):
for i in range(len(alldata[ion][time])):
if (alldata[ion][time][i][1] > maxflux[time][ion]):
maxflux[time][ion] = alldata[ion][time][i][1]
maxvel[time][ion] = alldata[ion][time][i][0]
if (alldata[ion][time][i][1] > maxdens[time][ion]):
maxdens[time][ion] = alldata[ion][time][i][0]
vdfval = []
plot_ion = zeros([numberions])
if (ion_list[ion]==data[time][ion2][0]):
tmpdensplot.append([(279.+time*5.*0.00833),data[time][ion2][7]])
plotdens.append(Data(tmpdensplot))
for ion in range(len(ion_list)):
plottemp[ion].set_option_colonsep("title", "'%s'" %(ion_list[ion]))
plotdens[ion].set_option_colonsep("title", "'%s'" %(ion_list[ion]))
plotvel[ion].set_option_colonsep("title", "'%s'" %(ion_list[ion]))
gp=Gnuplot()
gp("set logscale y")
#gp("set yrange[0.00001:100]")
gp.plot(plotswepamd)
for ion in range(len(plotdens)):
gp.replot(plotdens[ion])
gp.replot(plotswepamr)
gp("set xlabel 'DoY'")
gp("set ylabel 'Density [1/cm^{3}]'")
gp("set title ''")
gp("set term postscript color 18 lw 3 eps")
gp.hardcopy("density.ps", color=True, fontsize=18)
"""
gp.plot(plotswepamt)
for ion in range(len(plottemp)):
gp.replot(plottemp[ion])
gp("set xlabel 'DoY'")
gp("set ylabel 'T [K]'")
gp("set title ''")
gp("set term postscript color 18 lw 3 eps")
class multiplot:
"""
docstring should be added ...
"""
def __init__(self, panels, setformat=0):
self.panel = []
for i in range(panels):
self.panel.append(plotdata())
self.xrange = [0., 100.]
self.xlabel = "DoY"
self.xaxis_flag = 0
self.title = ""
self.gv = 1
self.format = setformat #0 Querformat, 1 Hochformat
self.outname = "multiplot"
self.plotmarks = []
def addplotmark(self, style, lt=5):
self.plotmarks.append(plotmark(style, lt))
def addpanel(self, data):
self.panel.append(plotdata())
def setxrange(self, a, b):
self.xrange[0] = a
self.xrange[1] = b
def settitle(self, a):
self.title = a
def setgv(self, a):
self.gv = a
def setxaxis2(self, a):
"""
This routine plots a seconds xaxis on top of the screen.
Input must be a list of lists containing the x2label and xposition of that label:
e.g: [["Jan",30],["Feb",58]...]
"""
self.xaxis_flag = 1
try:
b = a[0][0]
b = a[0][1]
except:
print "Wrong input for SELF.SETXAXIS2()"
print "Input must be of the form of [['label',xpos],['label',xpos],[],[],...,[]]"
print "Second x axis is omitted. Hit ENTER to proceed"
blub = raw_input()
self.xaxis2 = a
def setxlabel(self, a):
self.xlabel = str(a)
def setname(self, a):
self.outname = str(a)
def build_xaxis2(self):
"""
This routine builds the seconds xaxis from self.xaxis2
"""
for label in self.xaxis2:
if label[1] > self.xrange[0] and label[1] < self.xrange[1]:
self.gp(
"set label center'{/Helvetica=5 %s}' at first %f, screen 1.00"
% (label[0], label[1]))
self.xaxis_flag = 0
def plot(self):
self.gp = Gnuplot()
self.generatebox()
for panel in range(len(self.panel)):
self.plotpanel(panel)
#self.gp("unset tmargin")
#self.gp("unset title")
#self.gp("unset multiplot")
#self.gp("set size 1,1")
#self.gp("set xtics")
self.gp("set autoscale")
self.gp.sync()
os.system("ps2eps -f -B -l %s.ps" % (self.outname))
os.system("rm %s.ps" % (self.outname))
if (self.gv):
os.system("okular %s.eps" % (self.outname))
del self.gp
def generatebox(self):
self.gp("set term postscript solid enhanced color")
self.gp("set output '%s.ps'" % (self.outname))
self.gp("set border front")
self.gp("unset key")
self.gp("unset colorbox")
self.gp(
"set palette model RGB functions gray<1.e-20 ? 1 : gray<0.5 ? gray*2 : 1 , gray<1.e-20 ? 1 : gray<0.5 ? gray*2 : 2-gray*2, gray <1.e-20 ? 1 : gray<0.5 ? 1-sqrt(gray*2) : 0"
)
if (self.format):
self.gp("set xtics nomirror font 'Helvetica,9'")
else:
self.gp("set xtics nomirror")
self.gp("set multiplot")
self.gp("set xlabel 0,0.1")
if (self.format):
self.gp("set xlabel '%s' font 'Helvetica,9'" % (self.xlabel))
else:
self.gp("set xlabel '%s' font 'Helvetica,12'" % (self.xlabel))
self.gp("set xrange[%e:%e]" %
(float(self.xrange[0]), float(self.xrange[1])))
if (self.format):
self.gp("set ytics font 'Helvetica,9'")
else:
self.gp("set ytics")
#self.gp("set autoscale")
self.gp("set key right samplen 0.5")
self.gp("set key spacing 0.8")
self.gp("unset xtics")
self.gp("unset xlabel")
self.gp("set border front")
if self.xaxis_flag == 1:
self.build_xaxis2()
def plotpanel(self, panel):
self.buildplotmarks(panel)
first = 1
self.gp("unset key")
self.gp(
"set label center'{/Helvetica=9 %s}' at screen 0.3, screen 1.02" %
(self.title))
self.gp("set border front")
#self.gp("unset label")
if (self.panel[panel].grid):
self.gp("set grid xtics front")
else:
self.gp("set grid xtics front")
self.gp("unset grid")
size = (.86 / (float(len(self.panel)))) + 0.06
size2 = .86
self.gp("unset xlabel")
self.gp("set format x ''")
self.buildytics(panel)
if (panel == 0):
size = (.86 / float((len(self.panel)))) + 0.1
self.gp("set xlabel 0,0.2")
if (self.format):
self.gp("set xlabel '%s' font 'Helvetica,9'" % (self.xlabel))
else:
self.gp("set xlabel '%s' font 'Helvetica,12'" % (self.xlabel))
self.gp("set format x")
if (self.format):
self.gp("set xtics font 'Helvetica,9'")
else:
self.gp("set xtics")
self.gp("set mxtics 10")
if (self.panel[panel].type == "plot"):
self.gp("set size 1.,%f" % (size))
if (self.format):
self.gp("set size 0.6,%f" % (size))
elif (self.panel[panel].type == "splot"):
self.gp("set size 1.2935,%f" % (size * 1.65))
if (panel == 0):
self.gp("set origin 0,%f" % (0.05))
else:
if (self.panel[panel].type == "plot"):
self.gp("set origin 0,%f" % (0.09 + float(panel) *
(size - 0.06)))
elif (self.panel[panel].type == "splot"):
self.gp("set origin -.147,%f" % ((0.09 + float(panel) *
(size - 0.06)) - .1315))
self.gp("set lmargin 8")
if (self.format):
self.gp(
"set label '%s' at screen 0.05,%f center rotate by 90 font 'Helvetica,9'"
% ((self.panel[panel].ylabel),
(0.09 + float(panel) * (size - 0.06) + size / 2.)))
else:
self.gp(
"set label '%s' at screen 0.03,%f center rotate by 90 font 'Helvetica,12'"
% ((self.panel[panel].ylabel),
(0.09 + float(panel) * (size - 0.06) + size / 2.)))
self.gp("set yrange[%e:%e]" %
(self.panel[panel].yrange[0], self.panel[panel].yrange[1]))
if self.panel[panel].xrange[0] != "NAN":
self.gp("set xrange[%e:%e]" %
(self.panel[panel].xrange[0], self.panel[panel].xrange[1]))
# plot marks
for mark in self.plotmarks:
doplotmark = 0
for i in mark.panels:
if (i == -1
or i == panel and self.panel[panel].type == "plot"):
doplotmark = 1
if (doplotmark):
doplotlabel = 0
if (mark.label != ""):
for i in mark.labelpanels:
if (i == -1 or i == panel):
doplotlabel = 1
if (mark.style == "vline"):
head = ""
if (mark.arrowhead == 0):
head = "nohead"
elif (mark.arrowhead == 1):
head = "head filled"
mark.plot[panel].set_option_colonsep(
"with", "vectors %s lt %i lw %i" %
(head, mark.linetype, mark.linewidth))
#self.gp("plot 'testvector.dat' with vectors")
if (doplotlabel):
if (self.format):
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,9' front"
% ((mark.label, mark.pos[0][0] /
(self.xrange[1] - self.xrange[0]) + 0.01,
0.8, mark.linetype)))
else:
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,12' front"
% ((mark.label, mark.pos[0][0] /
(self.xrange[1] - self.xrange[0]) + 0.01,
0.8, mark.linetype)))
if (first):
self.gp.plot(mark.plot[panel])
first = 0
else:
self.gp.replot(mark.plot[panel])
if (mark.style == "box"):
mark.plot[panel].set_option_colonsep("using", "1:2:3")
mark.plot[panel].set_option_colonsep(
"with", "filledcurves lt %i" % (mark.linetype))
if (doplotlabel):
if (self.format):
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,9' center front"
% (mark.label,
(mark.pos[0][0] +
(mark.pos[0][2] - mark.pos[0][0]) / 2.) /
(self.xrange[1] - self.xrange[0]), 0.8, 0))
else:
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,12' center front"
% (mark.label,
(mark.pos[0][0] +
(mark.pos[0][2] - mark.pos[0][0]) / 2.) /
(self.xrange[1] - self.xrange[0]), 0.8, 0))
if (first):
self.gp.plot(mark.plot[panel])
first = 0
else:
self.gp.replot(mark.plot[panel])
if (mark.style == "hline"):
head = ""
if (mark.arrowhead == 0):
head = "nohead"
elif (mark.arrowhead == 1):
head = "head filled"
mark.plot[panel].set_option_colonsep(
"with", "vectors %s lt %i lw %i" %
(head, mark.linetype, mark.linewidth))
#self.gp("plot 'testvector.dat' with vectors")
if (doplotlabel):
if (self.format):
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,9' front"
% ((mark.label, mark.pos[0][0] /
(self.xrange[1] - self.xrange[0]) + 0.01,
0.8, mark.linetype)))
else:
self.gp(
"set label '%s' at graph %f,%f tc lt %i font 'Helvetica,12' front"
% ((mark.label, mark.pos[0][0] /
(self.xrange[1] - self.xrange[0]) + 0.01,
0.8, mark.linetype)))
if (first):
self.gp.plot(mark.plot[panel])
first = 0
else:
self.gp.replot(mark.plot[panel])
if (mark.style == "function"):
if (first):
self.gp.plot(mark.plot[panel])
else:
self.gp.replot(mark.plot[panel])
if (first and self.panel[panel].type == "plot"):
if len(self.panel[panel].data) == 1:
self.gp("%s" % (self.panel[panel].key))
self.gp.plot(self.panel[panel].data[0])
first = 0
elif (first and self.panel[panel].type == "splot"):
self.gp("set pm3d map")
self.gp.splot(self.panel[panel].data[0])
first = 0
else:
self.gp.replot(self.panel[panel].data[0])
for i in range(len(self.panel[panel].data) - 1):
if i == len(self.panel[panel].data) - 2:
self.gp("%s" % (self.panel[panel].key))
self.gp.replot(self.panel[panel].data[i + 1])
self.gp("unset pm3d")
def buildplotmarks(self, panel):
for mark in self.plotmarks:
tmpmark = []
if (mark.style == "vline"):
tmppos = mark.pos
tmppos[0][1] = self.panel[panel].yrange[0] * 1.01
tmppos[0][3] = (self.panel[panel].yrange[1] -
self.panel[panel].yrange[0]) * 0.99
tmpmark = Data(tmppos)
if (mark.style == "hline"):
tmppos = mark.pos
tmppos[0][0] = self.xrange[0] * 1.01
tmppos[0][2] = (self.xrange[1] - self.xrange[0]) * 0.99
tmpmark = Data(tmppos)
if (mark.style == "box"):
if mark.pos[0][2] == 1e-20:
ymin = self.panel[panel].yrange[0]
else:
ymin = mark.pos[0][2]
if mark.pos[0][3] == 1e20:
ymax = self.panel[panel].yrange[1]
else:
ymax = mark.pos[0][3]
tmppos = [[mark.pos[0][0], ymin, ymax],
[mark.pos[0][1], ymin, ymax]]
#tmppos=[[mark.pos[0][0],self.panel[panel].yrange[1],self.panel[panel].yrange[0]],[mark.pos[0][2],self.panel[panel].yrange[1],self.panel[panel].yrange[0]]]
tmpmark = Data(tmppos)
if (mark.style == "function"):
tmpmark = mark.function
if (tmpmark != []):
mark.addplot(tmpmark)
def buildytics(self, panel):
# the tics for panel=panel are set. The cases logscale and linear scale are handled. In the first panel (panel==0) all tics are labeled set
# in all other panels the first tic is unlabeled to avoid overlapp with the tics from the panel below.
# logscale tics are set ---> if yrange is smaller than 7 orders of magnitude the tics are set each order of magnitude and 8 minor tics
# corresponding to 2*,3*,...,9* are set (will fail if yrange is smaller than one order of magnitude
# if yrange is greater than
# linearscale tics are set --->
if (self.panel[panel].ytics != ""):
if (self.format):
self.gp("set ytics %s font 'Helvetica,9'" %
(self.panel[panel].ytics))
else:
self.gp("set ytics %s" % (self.panel[panel].ytics))
if (self.panel[panel].logscale):
self.gp("set logscale y")
return
# begin if logscale
if (self.panel[panel].logscale):
self.gp("unset ytics")
self.gp("set logscale y")
self.gp("set format y '10^{%2T}'")
adjust = 0
i = 1.e0
while (not adjust):
i = i * 10.
tmp = self.panel[panel].yrange[0]
tmp = tmp * i**6
if (tmp >= self.panel[panel].yrange[1]):
adjust = 1
if (self.panel[panel].minor < 0):
if (i <= 10.):
minor = 8
else:
minor = int(log(i, 10.) + .01)
minor2 = 2
if (self.panel[panel].minor == 0):
if (i <= 10.):
minor = 0
else:
minor = int(log(i, 10.) + .01)
minor2 = 1
if (self.panel[panel].minor > 0):
if (i <= 10.):
minor = self.panel[panel].minor
else:
minor = int(log(i, 10.) + .01)
minor2 = 2
tic = self.panel[panel].yrange[0]
utic = tic
if (i <= 10.):
j = -1
while (utic <= self.panel[panel].yrange[1]):
j += 1
utic = tic * i**j
if (j == 0):
if (panel == 0):
if (self.format):
self.gp("set ytics (%e) font 'Helvetica,9'" %
(utic))
else:
self.gp("set ytics (%e)" % (utic))
else:
if (self.format):
self.gp(
"set ytics (' ' %e) font 'Helvetica,9'" %
(float(utic)))
else:
self.gp("set ytics (' ' %e)" % (float(utic)))
else:
self.gp("set ytics add (%e)" % (utic))
for l in range(minor):
self.gp(
"set ytics add ('' %e 1)" %
(utic +
(utic * 9. / float(minor + 1) * float(l + 1))))
else:
j = -1
while (utic <= self.panel[panel].yrange[1]):
j += 1
utic = tic * i**j
if (j == 0):
if (panel == 0):
if (self.format):
self.gp("set ytics (%e) font 'Helvetica,9'" %
(utic))
else:
self.gp("set ytics (%e)" % (utic))
else:
if (self.format):
self.gp(
"set ytics (' ' %e) font 'Helvetica,9'" %
(float(utic)))
else:
self.gp("set ytics (' ' %e)" % (float(utic)))
else:
self.gp("set ytics add (%e)" % (utic))
for k in range(minor):
for l in range(minor2):
if (not (k == minor - 1 and l == minor2 - 1)):
if (l == minor2 - 1):
self.gp(
"set ytics add ('' %e)" %
(float(utic) * float(10**k) * float(
(l + 1) * 10. / float(minor2))))
else:
self.gp(
"set ytics add ('' %e 1)" %
(float(utic) * float(10**k) * float(
(l + 1) * 10. / float(minor2))))
# begin if linear scale
else:
self.gp("unset ytics")
self.gp("unset logscale y")
self.gp("set format y '%6g'")
i = .1
while (self.panel[panel].yrange[1] - self.panel[panel].yrange[0] >
i):
i = i * 10.
minor = 9
if (i / 4. >=
self.panel[panel].yrange[1] - self.panel[panel].yrange[0]):
i = i / 4.
minor = 4
elif (i / 2. >=
self.panel[panel].yrange[1] - self.panel[panel].yrange[0]):
i = i / 2.
minor = 9
if (self.panel[panel].minor == 0):
minor = 0
elif (self.panel[panel].minor > 0):
minor = self.panel[panel].minor
if (i > 10.):
for j in range(6):
if (j == 0):
if (panel == 0):
if (self.format):
self.gp("set ytics (%i) font 'Helvetica,9'" %
(int(self.panel[panel].yrange[0])))
else:
self.gp("set ytics (%i)" %
(int(self.panel[panel].yrange[0])))
else:
if (self.format):
self.gp(
"set ytics (' ' %i) font 'Helvetica,9'" %
(int(self.panel[panel].yrange[0])))
else:
self.gp("set ytics (' ' %i)" %
(int(self.panel[panel].yrange[0])))
else:
self.gp(
"set ytics add (%i)" %
(int(self.panel[panel].yrange[0] + i / 5. * j)))
print "minor = ", minor
for k in range(minor):
if ((minor + 1) % 5 == 0 and (k + 1) % 5 == 0):
self.gp(
"set ytics add (' ' %i)" %
(int(self.panel[panel].yrange[0] + j * i / 5. +
(i / 5. / float(minor + 1) *
float(k + 1)))))
else:
self.gp(
"set ytics add (' ' %i 1)" %
(int(self.panel[panel].yrange[0] + j * i / 5. +
(i / 5. / float(minor + 1) *
float(k + 1)))))
else:
for j in range(6):
if (j == 0):
if (panel == 0):
if (self.format):
self.gp("set ytics (%f) font 'Helvetica,9'" %
(self.panel[panel].yrange[0]))
else:
self.gp("set ytics (%f)" %
(self.panel[panel].yrange[0]))
else:
if (self.format):
self.gp(
"set ytics (' ' %f) font 'Helvetica,9'" %
(self.panel[panel].yrange[0]))
else:
self.gp("set ytics (' ' %f)" %
(self.panel[panel].yrange[0]))
else:
self.gp("set ytics add (%f)" %
(self.panel[panel].yrange[0] + i / 5. * j))
for k in range(minor):
if ((minor + 1) % 5 == 0 and (k + 1) % 5 == 0):
self.gp(
"set ytics add (' ' %f)" %
(self.panel[panel].yrange[0] + j * i / 5. +
(i / 5. / float(minor + 1) * float(k + 1))))
else:
self.gp(
"set ytics add (' ' %f 1)" %
(self.panel[panel].yrange[0] + j * i / 5. +
(i / 5. / float(minor + 1) * float(k + 1))))
gp("vth=.15*x0")
gp("f(x)= ph*sqrt(1./(2.*pi*sqrt(vth)))*exp(-((x-x0)**2.)/(2.*vth**2))")
gp("fit f(x) '"+allfiles[i].filename+"' using 1:2 via ph")
gp("fit f(x) '"+allfiles[i].filename+"' using 1:2 via vth")
gp("ph2=1.e-6")
gp("x02=1.")
gp("vth2=.15*x0")
gp("g(x)= ph2*sqrt(1./(2.*pi*sqrt(vth2)))*exp(-((x-x02)**2.)/(2.*vth2**2))")
gp("fit g(x) '"+allfiles[j].filename+"' using 1:2 via ph2")
gp("fit g(x) '"+allfiles[j].filename+"' using 1:2 via vth2")
first=1
gp("set xrange[0.9:5.]")
gp("set yrange[1e-12:1e-6]")
gp("set xtics 1,2")
gp.plot(allfiles[i],"f(x) title 'Maxwell-Fit 18:00-19:00'")
gp.replot(allfiles[j],"g(x) title 'Maxwell-Fit 20:00-21:00'")
gp("set term postscript color 18 lw 2 eps")
gp.hardcopy("vdfs.ps",color=True, fontsize=18)
#for k in range(23):
# gp.replot(allfiles[i+k+1])
#for i in range(len(allfiles)):
# if (first):
# gp.plot(allfiles[i])
# first=0
# else:
# gp.replot(allfiles[i])
#tmpplotspthmq.set_option_colonsep("title", "'%s'"%(iondata.name))
tmpplotspthmq.set_option_colonsep("with", "errorbars")
plotspthmq.append(tmpplotspthmq)
del iondata
if (plotspth):
#plotspthmq.set_option_colonsep("with", "lines")
gp=Gnuplot()
gp("set logscale y")
#gp("set yrange[0.:0.015]")
gp("set xrange[1.5:7.5]")
gp("set xlabel 'm/q'")
gp("set ylabel 'tail/bulk'")
gp.plot(plotspthmq[0])
for ion in range(len(plotspthmq)-1):
gp.replot(plotspthmq[ion+1])
gp("set term postscript color 18 lw 2 eps")
gp.hardcopy("mq_tailbulk_quiet_errors_notitles.ps",color=True, fontsize=18)
if (doplotdenstime):
dens=[]
temp=[]
vel=[]
spth=[]
spth2=[]
for i in range(len(iondata.dens)):
if (iondata.dens[i][0]!=0.):
dens.append([iondata.time[i],iondata.dens[i][0]])
temp.append([iondata.time[i],iondata.temp[i][0]])
vel.append([iondata.time[i],iondata.vel[i]])
x0 = gp.eval("x0")
x1 = gp.eval("x1")
x2 = gp.eval("x2")
seqa = gp.eval("a")
seqb = gp.eval("b")
seqc = gp.eval("c")
#gp.plot(ion_data_plot[0],ion_sigp_plot[0],ion_sigm_plot[0])
#for ion in range(len(ion_list)-1):
# gp.replot(ion_data_plot[ion+1],ion_sigp_plot[ion+1],ion_sigm_plot[ion+1])
#gp.plot(ion_data_plot[0],"g(x)")
gp.plot(ion_data_plot[0])
#gp.replot("He(x)","C(x)","N(x)","O(x)","Ne(x)","Mg(x)","Si(x)","S(x)","Ca(x)","Fe(x)")
for ion in range(len(ion_list) - 1):
gp.replot(ion_data_plot[ion + 1])
print k2, k3, k4, x0, x1, x2
gp("set term postscript lw 2")
gp("set grid front noxticks noyticks")
gp.hardcopy("ionpositionshefti.ps", color=True, fontsize=18)
print "seqa=", seqa, " seqb=", seqb, " seqc=", seqc, " phda=", phda, " phdb=", phdb, " phdc=", phdc
corr_ion_data = []
for ion in range(len(ion_list) - 1):
corr_one_ion_data = []
for step in range(dim):
energy = (Eacc + epq_arr[step]) * ion_phd[ion + 1][0][2]
ephd = energy * phd(energy, phda, phdb, phdc)
ech = e2ech(ephd)
tch = tchfit(ech, seqa, seqb, seqc)
# print "energy = ",energy," ephd = ",ephd," ech = ",ech," tch = ",tch
corr_one_ion_data.append([tch, ech])
ion_sigx_plot.append(ion_sigx_plot_tmp)
ion_sigy_plot=[]
for ion in range(len(ion_list)):
ion_sigy_plot_tmp=Data(ion_sigy[ion])
ion_sigy_plot_tmp.set_option_colonsep("using", "1:2")
ion_sigy_plot_tmp.set_option_colonsep("title", "'%ssigy'" %(ion_list[ion]))
ion_sigy_plot.append(ion_sigy_plot_tmp)
gp=Gnuplot()
#gp("set xrange[100:260]")
gp("set yrange[0:5]")
gp("set title 'ion_sigp'")
gp.plot(ion_sigym_plot[0])
for ion in range(len(ion_list)-1):
gp.replot(ion_sigym_plot[ion+1])
#gp.plot(ion_sigxp_plot[0],ion_sigxm_plot[0],ion_sigyp_plot[0],ion_sigym_plot[0])
#for ion in range(len(ion_list)-1):
# gp.replot(ion_sigxp_plot[ion+1],ion_sigxm_plot[ion+1],ion_sigyp_plot[ion+1],ion_sigym_plot[ion+1])
gp.hardcopy("ion_sig.ps",color=True,fontsize=18)
pmeandvwp.append(Data(ion))
pmeandvwp[-1].set_option_colonsep("using","1:2:3")
pmeandvwp[-1].set_option_colonsep("with","yerrorbars lt 1")
pmeandvwp[-1].set_option_colonsep("title","'polarity -'")
pmeandvwp2=[]
for ion in meandvvswparr2:
pmeandvwp2.append(Data(ion))
pmeandvwp2[-1].set_option_colonsep("using","1:2:3")
pmeandvwp2[-1].set_option_colonsep("with","yerrorbars lt 3")
pmeandvwp2[-1].set_option_colonsep("title","'polarity +'")
gp2=Gnuplot()
gp2.plot(pmeandv[0])
for i in range(1,len(pmeandv)):
gp2.replot(pmeandv[i])
for i in range(0,len(pmeandv2)):
gp2.replot(pmeandv2[i])
gp2.hardcopy("dvmeanvsw%s%i.ps"%(ionlist[0][0],year),color="True")
gp3=Gnuplot()
gp3.plot(pmeandvwp[0])
for i in range(1,len(pmeandvwp)):
gp3.replot(pmeandvwp[i])
for i in range(0,len(pmeandvwp2)):
gp3.replot(pmeandvwp2[i])
gp3.hardcopy("dvmeanpbeta%s%i.ps"%(ionlist[0][0],year),color="True")
pmeanhevse=Data(meanhevse)
pmeanhevse.set_option_colonsep("using","1:2:3")
pmeanhevse.set_option_colonsep("with","yerrorbars")
summe += alldata[ion][i][step][1]
tmpsum.append(summe)
print tmpsum
gp = Gnuplot()
gp("set log y")
if (0):
first = 1
for ion in range(numberions):
for i in range(len(alldata[ion])):
if (first):
gp.plot(gpalldata[ion][i])
first = 0
else:
gp.replot(gpalldata[ion][i])
maxvel = zeros([numberfiles, numberions], float)
maxflux = zeros([numberfiles, numberions], float)
maxdens = zeros([numberfiles, numberions], float)
for time in range(numberfiles):
for ion in range(numberions):
for i in range(len(alldata[ion][time])):
if (alldata[ion][time][i][1] > maxflux[time][ion]):
maxflux[time][ion] = alldata[ion][time][i][1]
maxvel[time][ion] = alldata[ion][time][i][0]
if (alldata[ion][time][i][2] > maxdens[time][ion]):
maxdens[time][ion] = alldata[ion][time][i][2]
print "maxdens = ", maxdens
gp("set cbrange[1e0:1e6]")
gp("set format cb '10^%T'")
gp("set contour both")
gp("set cntrparam levels discrete 1e2,3.3e2,6.6e2,1e3,3.3e3,6.6e3,1e4,3.3e4,6.6e4,1e5,3.3e5,6.6e5,1e6"
)
gp("set pm3d map")
#gp("unset clabel")
gp("unset key")
gp.splot(gpdata)
gp("unset ztics")
gp("unset surface")
#gp("set clabel offset -100,0")
gp("set grid front noxtics noytics")
gp("set isosamples 1000")
gp("set pm3d at b corners2color median")
gp.replot(gpdata)
gp("set surface")
gp("set clabel '%0.0f'")
gp("unset contour")
gp("unset pm3d")
gp("unset log z")
gp("set zrange[0.5:1.5]")
gp.splot(gppoints)
gp.replot(gpxerrorp, gpxerrorm, gpyerrorp, gpyerrorm)
#gp.splot(gppoints)
#gp("unset multiplot")
#gp("set pm3d at b")
#gp.replot(gpdata)
#gp("unset contour")
#gp.replot(gppoints,gpxerrorp,gpxerrorm,gpyerrorp,gpyerrorm)
gpplotratio = []
for elem in range(len(data[0])):
tmpplotdata = []
for time in range(len(data)):
if (data[time][elem][3] and data[time][0][3]):
tmpplotdata.append([
279. + (0.00833 * time * 5.),
(10**(cabund[0] - cabund[elem])) /
(data[time][0][3] / data[time][elem][3])
])
else:
tmpplotdata.append([279. + (0.00833 * time * 5.), 0.])
gpplotratio.append(Data(tmpplotdata))
gpplotratio[elem].set_option_colonsep(
"title", "'%s fip %f'" % (data[0][elem][0], fip[elem]))
gp = Gnuplot()
gp("set logscale y")
#gp("set yrang[10000:100000000]")
gp("f(x)=10**(10.93-7.6)")
gpvdata[0].set_option_colonsep("with", "l")
gp.plot(gpplotratio[1], gpvdata[0])
for i in range(len(data[0]) - 2):
gp.replot(gpplotratio[i + 2])
#gp.plot(gpplotdata[1],gpvdata[0])
#for i in range(len(data[0])-2):
# gp.replot(gpplotdata[i+2])
#gp.plot(gpplotdata[0],gpplotdata[1])
tmpion = Data(ionpos[ion])
if (ion_names[ion] != "20Ne8+"):
tmpion.set_option_colonsep("title", "'%s'" % (ion_names[ion]))
else:
tmpion.set_option_colonsep("title", "'Ne8+'")
plotionpos.append(tmpion)
yrange = [0, 127]
xrange = [50, 300]
gp = Gnuplot()
gp("set mouse")
gp("set xlabel 'Time-of-Flight Channel'")
gp("set ylabel 'Energy Channel' ")
gp("set xrange[%i:%i]" % (xrange[0], xrange[1]))
gp("set yrange[%i:%i]" % (yrange[0], yrange[1]))
gp.plot(plotionpos[0])
for ion in range(len(ionpos) - 1):
gp.replot(plotionpos[ion + 1])
if (our):
gp("set title 'New improved Ion Positions'")
else:
gp("set title 'Hefti Ion Positions'")
gp("set term postscript color 18 lw 2 eps")
#gp("set outp 'positions.ps'")
if (our):
gp.hardcopy("positions.ps", color=True, fontsize=18)
else:
gp.hardcopy("positionshefti.ps", color=True, fontsize=18)
gp("set palette model RGB functions gray<1.e-20 ? 1 : gray<0.5 ? gray*2 : 1 , gray<1.e-20 ? 1 : gray<0.5 ? gray*2 : 2-gray*2, gray <1.e-20 ? 1 : gray<0.5 ? 1-sqrt(gray*2) : 0"
)
gp("set logscale cb")
gp.splot(pvivsvparr, pdvzeros) #,pa)
gp.hardcopy("v%s_vs_vp.ps" % (ionlist[0]), color="true", fontsize=20)
pmeandv = []
for ion in meandvvsvparr:
pmeandv.append(Data(ion))
pmeandv[-1].set_option_colonsep("using", "1:2:3")
pmeandv[-1].set_option_colonsep("with", "yerrorbars")
gp2 = Gnuplot()
gp2.plot(pmeandv[0])
for i in range(1, len(pmeandv)):
gp2.replot(pmeandv[i])
pmeanhevse = Data(meanhevse)
pmeanhevse.set_option_colonsep("using", "1:2:3")
pmeanhevse.set_option_colonsep("with", "yerrorbars")
meanelem = []
for i in range(10):
meanelem.append([])
meanelem[-1].append(meanhevse[-1])
meanelem[-2].append(meanhevse[-4])
meanelem[-2].append(meanhevse[-3])
meanelem[-2].append(meanhevse[-2])
meanelem[-3].append(meanhevse[-7])
meanelem[-3].append(meanhevse[-6])
tailbulk = tmpsumme / sdata[ion][time][maxflux][12]
else:
tailbulk = 0.
else:
tailbulk = 0.
tailbulkdisttmp.append([(279. + time * 5. * 0.00833), tailbulk])
tailbulkdist.append(tailbulkdisttmp)
gptailbulkdist = []
for ion in range(len(sdata)):
tmpgptailbulk = Data(tailbulkdist[ion])
tmpgptailbulk.set_option_colonsep("using", "1:2")
tmpgptailbulk.set_option_colonsep("title", "'%s'" % (ion_list[ion]))
gptailbulkdist.append(tmpgptailbulk)
gp = Gnuplot()
gp("set autoscale")
gp("set yrange[0.00001:1.]")
gp("set logscale y")
gp("set xlabel 'DoY'")
gp("set ylabel 'tail/bulk ratio' ")
for ion in range(len(sdata)):
if (first):
gp.plot(gptailbulkdist[ion])
first = 0
else:
gp.replot(gptailbulkdist[ion])
gp("set term postscript color 18 lw 2 eps")
gp.hardcopy("tailbulk.ps", color=True, fontsize=18)
tmpion=[]
for ion in range (len(results)):
tmpgpresults=Data(results[ion])
tmpgpresults.set_option_colonsep("using", "1:2")
tmpgpresults.set_option_colonsep("title", "'%s'" %(ion_list[ion]))
gpresults.append(tmpgpresults)
gp=Gnuplot()
#gp("set log y")
first=1
for ion in range (len(ion_list)):
if (first):
gp.plot(gpresults[ion])
first=0
else:
gp.replot(gpresults[ion])
gp("set xlabel 'SW-Speed'")
gp("set ylabel 'Mean Charge State' ")
first=1
for ion in range (8):
if (first):
gp.plot(gpqges[ion])
first=0
else:
gp.replot(gpqges[ion])
gp("set yrange[0:20]")
gp("set xrange[350:710]")
gp("a1=2.")
class Plot:
def __init__(self):
self.verbose = True
self.origin = (0,0)
self.data2 = []
self.data3 = []
self.g = Gnuplot()
self.g('set data style points')
self.g('set key left top Left title \'Legend\' box 3')
self.title = 'title'
self.xlabel = 'x'
self.ylabel = 'y'
self.zlabel = 'z'
def __call__(self,value):
self.g(value)
def setOrigin(self,x,y):
"""
@type x: float
@type y: float
"""
self.origin = (x,y)
def setVerbose(self,verbose):
"""
@type verbose: binary
"""
self.verbose = verbose
def addArrayTuples(self, data, name = ''):
"""
@param data: data to be added to 2d plot
@type data: (float,float)[]
"""
d = Data(data, title = name)
self.data2.append(d)
def add2Arrays(self,x,y):
"""
@type x: float[]
@type y: float[]
"""
if len(x) != len(y):
return 'arrays not of equal length'
else:
array2 = []
for i in range(len(array)):
value = (x[i],y[i])
array2.append(value)
self.addArrayTuples(array2)
def addArrayTriples(self, data):
"""
@param data: data to be added to 3d plot
@type data: (float, float, float)[]
"""
self.data3.append(data)
def add3Arrays(self,x,y,z):
"""
@type x: float[]
@type y: float[]
@type z: float[]
"""
if (len(x) == len(y) == len(z)):
array3 = []
for i in range(len(x)):
value = (x[i],y[i],z[i])
array3.append(value)
self.addArrayTriples(array3)
else:
print 'arrays not of equal length'
def setLabels(self,title='title',xlabel='x',ylabel='y',zlabel='z'):
"""
@type title: string
@type xlabel: string
@type ylable: string
@type zlable: string
"""
self.title = title
self.xlabel = xlabel
self.ylabel = ylabel
self.zlabel = zlabel
def _plot2D(self):
self.g.title(self.title)
self.g.xlabel(self.xlabel)
self.g.ylabel(self.ylabel)
if len(self.data2) == 0:
return False
self.g.title(self.title)
self.g.xlabel(self.xlabel)
self.g.ylabel(self.ylabel)
self.g.plot(self.data2[0])
for d in self.data2[1:]:
self.g.replot(d)
return True
def plot2DtoScreen(self):
if not self._plot2D():
return None
raw_input('Please press return to continue...\n')
def plot2DtoFile(self, fileName):
"""
@type fileName: string
"""
self.g('set term post eps')
self.g('set output \'%s\'' % fileName)
if not self._plot2D():
return None
self.g.hardcopy(fileName, enhanced=1, color=1)
if self.verbose: print ('\n******** Saved plot to postscript file %s ********\n' % fileName)
def _plot3d(self):
if len(self.data3) == 0:
return False
self.g.title(self.title)
self.g.xlabel(self.xlabel)
self.g.ylabel(self.ylabel)
self.g('set zlabel \"%s\"' % self.zlabel)
self.g.plot([self.data3[0]])
for d in self.data3[1:]:
self.g.replot(d)
return True
def plot3DtoScreen(self):
if not self._plot3D():
return None
raw_input('Please press return to continue...\n')
def plot3DtoFile(self,fileName):
"""
@type fileName: string
"""
self.g('set term post eps')
self.g('set output \'%s\'' % fileName)
if not self._plot3d():
return None
self.g.hardcopy(fileName, enhanced=1, color=1)
if self.verbose: print ('\n******** Saved plot to postscript file %s ********\n' % fileName)
class vspec:
def __init__(self, year, timeframe):
self.year = year
self.timeframe = timeframe
self.hedata = loadswicsiondata("He2+", 720., self.year, self.timeframe,
"/data/etph/ace/")
self.odata = loadswicsiondata("O6+", 720., self.year, self.timeframe,
"/data/etph/ace/")
self.hdata = swicsdcrtcr("H1+", self.year, self.timeframe,
"/data/etph/ace/pui/12mdata/")
self.swedata = swepamdata(64., self.year, self.timeframe,
"/data/etph/ace/swepam/")
self.swedata.sync_h(self.hedata)
self.mag = magdata(1., self.year, self.timeframe,
"/data/etph/ace/mag/")
self.mag.sync_mag(self.hedata)
self.theta = arccos(cos(self.mag.phi) * cos(self.mag.theta))
self.valf = 21.8 / sqrt(self.swedata.dens) * (self.mag.magb)
self.valf[isinf(self.valf)] = -1.
self.valf[isnan(self.valf)] = -2.
self.effh = zeros([58])
self.effhe = zeros([58])
self.effo = zeros([58])
self.gp = Gnuplot()
self.gp("set xr [-2:3]")
self.gp("set yr [0:1]")
self.gp("set xlabel '(v-v_{sw})/C_{A}'")
self.stdhe = []
self.stdo = []
self.stdh = []
self.skewhe = []
self.skewo = []
self.skewh = []
self.kurthe = []
self.kurto = []
self.kurth = []
self.meanvhe = []
self.meanvo = []
self.meanvh = []
self.maxvhe = []
self.maxvo = []
self.maxvh = []
self.time = []
self.years = []
self.valfs = []
self.magb = []
self.thetas = []
self.sigtheta = []
self.vsw = []
self.dsw = []
self.tsw = []
self.load_eff()
def load_eff(self):
effh = loadtxt(open("/data/etph/ace/efficencies/H1+.eff", "r"))
effhe = loadtxt(open("/data/etph/ace/efficencies/He2+.eff", "r"))
effo = loadtxt(open("/data/etph/ace/efficencies/O6+.eff", "r"))
self.effh = effh[:, 1]
self.effhe = effhe[:, 1]
self.effo = effo[:, 1]
def moments(self, thetalist=[[0., pi / 18.], [pi - pi / 18., pi]]):
thetamask = (self.theta >= thetalist[0][0]) * (self.theta <=
thetalist[0][1])
if len(thetalist) > 1:
for val in thetalist[1:]:
thetamask += (self.theta >= val[0]) * (self.theta <= val[1])
for step in where(thetamask)[0]:
if self.valf[step] > 0.:
self.years.append(self.hedata.year)
self.time.append(self.hedata.time[step])
self.valfs.append(self.valf[step])
self.magb.append(self.mag.magb[step])
self.thetas.append(self.mag.THETA[step])
self.sigtheta.append(self.mag.sigTHETA[step])
self.vsw.append(self.swedata.vel[step])
self.dsw.append(self.swedata.dens[step])
self.tsw.append(self.swedata.temp[step])
# Protons
il = where(self.hdata.time == self.hedata.time[step])[0]
if il.shape[0] > 0 and amax(self.hdata.tcrspec[il[0], :] +
self.hdata.dcrspec[il[0], :]) > 0.:
tmpspec = zeros([self.hdata.velspec.shape[0], 2])
tmpspec[:, 0] = self.hdata.velspec
tmpspec[:, 1] = 1. * self.hdata.tcrspec[
il[0]] + 1. * self.hdata.dcrspec[il[0]]
tmpspec[:, 1] = tmpspec[:, 1] / (
tmpspec[:, 0] * 0.03) / self.effh / tmpspec[:, 0]
il2 = where(tmpspec[:, 1] == amax(tmpspec[:, 1]))[0]
if (il2[0] > 0 and il2[0] < tmpspec[:, 1].shape[0] - 1):
maxvh = sum(
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 0] *
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1]
) / sum(tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1])
else:
maxvh = tmpspec[il2[0], 0]
meanvh = sum(tmpspec[:, 0] * tmpspec[:, 1]) / sum(
tmpspec[:, 1])
if maxvh > 390.:
tmphvel = (tmpspec[:, 0] - maxvh) / self.valf[step]
tmphcts = (tmpspec[:, 1]) / sum(tmpspec[:, 1])
maskh = (tmphvel >= -3.) * (tmphvel <= 3.)
stdh = sqrt(sum((tmphvel[maskh]**2) * tmphcts[maskh]))
skewh = (sum(
(tmphvel[maskh]**3) * tmphcts[maskh])) / stdh**3.
kurth = (sum(
(tmphvel[maskh]**4) * tmphcts[maskh])) / stdh**4.
self.stdh.append(stdh)
self.skewh.append(skewh)
self.kurth.append(kurth)
self.meanvh.append(meanvh)
self.maxvh.append(maxvh)
else:
self.stdh.append(-999.)
self.skewh.append(-999.)
self.kurth.append(-999.)
self.meanvh.append(-999.)
self.maxvh.append(-999.)
else:
self.stdh.append(-999.)
self.skewh.append(-999.)
self.kurth.append(-999.)
self.meanvh.append(-999.)
self.maxvh.append(-999.)
# Alphas
if (where(self.hedata.countspec[step, :, 1] > 0.)[0].shape[0]
>= 3):
tmpspec = 1. * self.hedata.countspec[step]
tmpspec[:, 1] = tmpspec[:, 1] / (
tmpspec[:, 0] * 0.03) / self.effhe / tmpspec[:, 0]
il2 = where(tmpspec[:, 1] == amax(tmpspec[:, 1]))[0]
if (il2[0] > 0 and il2[0] < tmpspec[:, 1].shape[0] - 1):
maxvhe = sum(
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 0] *
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1]
) / sum(tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1])
else:
maxvhe = tmpspec[il2[0], 0]
meanvhe = sum(tmpspec[:, 0] * tmpspec[:, 1]) / sum(
tmpspec[:, 1])
tmphevel = (tmpspec[:, 0] - maxvhe) / self.valf[step]
tmphects = (tmpspec[:, 1]) / sum(tmpspec[:, 1])
maskhe = (tmphevel >= -3.) * (tmphevel <= 3.)
stdhe = sqrt(sum((tmphevel[maskhe]**2) * tmphects[maskhe]))
skewhe = (sum(
(tmphevel[maskhe]**3) * tmphects[maskhe])) / stdhe**3.
kurthe = (sum(
(tmphevel[maskhe]**4) * tmphects[maskhe])) / stdhe**4.
self.stdhe.append(stdhe)
self.skewhe.append(skewhe)
self.kurthe.append(kurthe)
self.meanvhe.append(meanvhe)
self.maxvhe.append(maxvhe)
else:
self.stdhe.append(-999.)
self.skewhe.append(-999.)
self.kurthe.append(-999.)
self.meanvhe.append(-999.)
self.maxvhe.append(-999.)
# O6+
if (where(self.odata.countspec[step, :, 1] > 0.)[0].shape[0] >=
3):
tmpspec = 1. * self.odata.countspec[step]
tmpspec[:, 1] = tmpspec[:, 1] / (
tmpspec[:, 0] * 0.03) / self.effo / tmpspec[:, 0]
il2 = where(tmpspec[:, 1] == amax(tmpspec[:, 1]))[0]
if (il2[0] > 0 and il2[0] < tmpspec[:, 1].shape[0] - 1):
maxvo = sum(
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 0] *
tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1]
) / sum(tmpspec[[il2[0] - 1, il2[0], il2[0] + 1], 1])
else:
maxvo = tmpspec[il2[0], 0]
meanvo = sum(tmpspec[:, 0] * tmpspec[:, 1]) / sum(
tmpspec[:, 1])
tmpovel = (tmpspec[:, 0] - maxvo) / self.valf[step]
tmpocts = (tmpspec[:, 1]) / sum(tmpspec[:, 1])
masko = (tmpovel >= -3.) * (tmpovel <= 3.)
stdo = sqrt(sum((tmpovel[masko]**2) * tmpocts[masko]))
skewo = (sum(
(tmpovel[masko]**3) * tmpocts[masko])) / stdo**3.
kurto = (sum(
(tmpovel[masko]**4) * tmpocts[masko])) / stdo**4.
self.stdo.append(stdo)
self.skewo.append(skewo)
self.kurto.append(kurto)
self.meanvo.append(meanvo)
self.maxvo.append(maxvo)
else:
self.stdo.append(-999.)
self.skewo.append(-999.)
self.kurto.append(-999.)
self.meanvo.append(-999.)
self.maxvo.append(-999.)
self.stdhe = array(self.stdhe)
self.stdh = array(self.stdh)
self.stdo = array(self.stdo)
self.skewhe = array(self.skewhe)
self.skewh = array(self.skewh)
self.skewo = array(self.skewo)
self.kurthe = array(self.kurthe)
self.kurth = array(self.kurth)
self.kurto = array(self.kurto)
self.meanvhe = array(self.meanvhe)
self.meanvh = array(self.meanvh)
self.meanvo = array(self.meanvo)
self.maxvhe = array(self.maxvhe)
self.maxvh = array(self.maxvh)
self.maxvo = array(self.maxvo)
self.time = array(self.time)
self.years = array(self.years)
self.valfs = array(self.valfs)
self.magb = array(self.magb)
self.thetas = array(self.thetas)
self.sigtheta = array(self.sigtheta)
self.vsw = array(self.vsw)
self.dsw = array(self.dsw)
self.tsw = array(self.tsw)
return
def plot_vdist(self, thetalist=[[0., pi / 18.], [pi - pi / 18., pi]]):
thetamask = (self.theta >= thetalist[0][0]) * (self.theta <=
thetalist[0][1])
if len(thetalist) > 1:
for val in thetalist[1:]:
thetamask += (self.theta >= val[0]) * (self.theta <= val[1])
print where(thetamask)
for i in where(thetamask)[0]:
self.plot_step(i)
def plot_step(self, step):
if self.valf[step] > 0.:
self.gp("unset label")
self.gp("set label 'v_{sw}=%f' at -1.5,0.95" %
(self.swedata.vel[step]))
self.gp("set label 'C_{A}=%f' at -1.5,0.90" % (self.valf[step]))
self.gp("set label '{/Symbol= Q}=%f' at -1.5,0.85" %
(self.theta[step] / pi * 180.))
self.gp("set label '{/Symbol= dQ}=%f' at -1.5,0.8" %
(self.mag.sigTHETA[step] / pi * 180.))
self.gp("set title '%.4i DoY %f'" %
(self.year, self.hedata.time[step]))
if amax(self.hedata.countspec[step, :, 1]) > 0.:
self.gp.plot(
Data((self.hedata.countspec[step, :, 0] -
self.swedata.vel[step]) / self.valf[step],
self.hedata.countspec[step, :, 1] /
amax(self.hedata.countspec[step, :, 1]),
with_="lp lt 3 lw 3",
title="He^{2+}"))
if amax(self.odata.countspec[step, :, 1]) > 0.:
self.gp.replot(
Data((self.odata.countspec[step, :, 0] -
self.swedata.vel[step]) / self.valf[step],
self.odata.countspec[step, :, 1] /
amax(self.odata.countspec[step, :, 1]),
with_="lp lt 4 lw 3",
title="O^{6+}"))
il = where(self.hdata.time == self.hedata.time[step])[0]
if il.shape[0] > 0 and amax(self.hdata.tcrspec[il[0], :] +
self.hdata.dcrspec[il[0], :]) > 0.:
self.gp.replot(
Data((self.hdata.velspec - self.swedata.vel[step]) /
self.valf[step],
(self.hdata.tcrspec[il[0], :] +
self.hdata.dcrspec[il[0], :]) /
amax(self.hdata.tcrspec[il[0], :] +
self.hdata.dcrspec[il[0], :]),
with_="lp lt 1 lw 3",
title="H^{1+}"))
self.gp.hardcopy("vdistperp_%.4i_%.3i.%.6i.ps" %
(self.year, int(self.hedata.time[step]),
int((self.hedata.time[step] % 1) * 1e6)),
color=True)
self.gp.sync()
if (ionnames[ion]==name[i]):
plotion[i]=ion
plotelem=[]
elemname=["C","N","O","Ne","Mg","Si","S","Fe"]
for i in range(len(elemname)):
plotelem.append(0)
for i in range(len(elemname)):
for elem in range(len(elemnames)):
if (elemnames[elem]==elemname[i]):
plotelem[i]=elem
gp.plot(plotvelocity[plotion[0]])
for ion in range(len(name)-1):
gp.replot(plotvelocity[plotion[ion+1]])
gp.replot(plotdens[plotion[0]])
for ion in range(len(name)-1):
gp.replot(plotdens[plotion[ion+1]])
gp.replot(plottemp[plotion[0]])
for ion in range(len(name)-1):
gp.replot(plottemp[plotion[ion+1]])
gp.replot(plotmaxdens[plotion[0]])
for ion in range(len(name)-1):
gp.replot(plotmaxdens[plotion[ion+1]])
gp.replot(plotmaxvelocity[plotion[0]])
for ion in range(len(name)-1):
gp("unset logscale x")
gp("unset logscale y")
gp("set autoscale")
#gp("set yrange[1:18000000]")
gpvel=[]
for ion in range(numberions):
gptmpvel=Data(fitvel[ion])
gptmpvel.set_option_colonsep("title", "'%s'"%(ion_names[ion]))
gpvel.append(gptmpvel)
gp("set title 'velocity'")
gp.plot(gpvel[2])
for ion in range(numberions-3):
if (plot_ion[ion+3]):
gp.replot(gpvel[ion+3])
gp.hardcopy("velocity.ps", color=True, fontsize=18)
gptemp=[]
for ion in range(numberions):
gptmptemp=Data(fittemp[ion])
gptmptemp.set_option_colonsep("title", "'%s'"%(ion_names[ion]))
gptemp.append(gptmptemp)
#gp("set title 'temperature'")
#gp.plot(gptemp[0])
#for ion in range(numberions-1):
# if (plot_ion[ion]):
# gp.replot(gptemp[ion+1])
#gp.hardcopy("temperature.ps", color=True, fontsize=18)
