Beispiel #1
0
def get_dataset_color(dataset,depth=None):
    """Set the colors to ensure a uniform scheme for each dataset """
    dataset=string.lower(dataset)
    d={}
    d["dai"]=cm.Blues(.5)
    d["tree"]=cm.summer(.3)
    d["cru"]=cm.Blues(.9)

    #models
    d["picontrol"]=cm.Purples(.8)
    d["h85"]="k"
    d["tree_noise"]=cm.PiYG(.2)
    
    #Soil moisture
    
    d["merra2"]={}
    d["merra2"]["30cm"]=cm.copper(.3)
    d["merra2"]["2m"]=cm.copper(.3)
    d["gleam"]={}
    d["gleam"]["30cm"]=cm.Reds(.3)
    d["gleam"]["2m"]=cm.Reds(.7)
    if depth is None:
        return d[dataset]
    else:
        return d[dataset][depth]
def four_Vm_traces(data,
                   ax,
                   tzoom=[1000, 2000],
                   Tbar=50,
                   Vshift=30,
                   vpeak=-42,
                   vbottom=-80):

    t = np.arange(int(data['tstop'] / data['dt'])) * data['dt']
    cond = (t > tzoom[0]) & (t < tzoom[1])
    ## excitatory traces:
    for i in range(3):
        ax.plot(t[cond],
                data['VMS_RecExc'][i][cond] + Vshift * i,
                color=copper(i / 3 / 1.5),
                lw=1)
    # adding spikes
    for i in range(3):
        tspikes = data['tRASTER_RecExc'][np.argwhere(
            data['iRASTER_RecExc'] == i).flatten()]
        for ts in tspikes[(tspikes > tzoom[0]) & (tspikes < tzoom[1])]:
            ax.plot([ts, ts],
                    Vshift * i + np.array([-50, vpeak]),
                    '--',
                    color=copper(i / 3 / 1.5),
                    lw=1)
    # ## inhibitory trace:
    cond = (t > tzoom[0]) & (t < tzoom[1])
    ax.plot(t[cond], data['VMS_RecInh'][0][cond] + Vshift * 3, color=Red, lw=1)
    tspikes = data['tRASTER_RecInh'][np.argwhere(
        data['iRASTER_RecInh'] == 0).flatten()]
    for ts in tspikes[(tspikes > tzoom[0]) & (tspikes < tzoom[1])]:
        ax.plot([ts, ts],
                Vshift * 3 + np.array([-53, vpeak]),
                '--',
                color=Red,
                lw=1)

    ax.plot(tzoom[0] * np.ones(2), [-50, -40], lw=5, color='gray')
    ax.annotate('10mV', (-0.1, .4),
                rotation=90,
                fontsize=14,
                xycoords='axes fraction')
    ax.plot([tzoom[0], tzoom[0] + Tbar], [-75, -75], lw=5, color='gray')
    ax.annotate(str(Tbar) + ' ms', (0.1, -0.1),
                fontsize=14,
                xycoords='axes fraction')
    set_plot(ax, [], xticks=[], yticks=[])
def plot_profiles():
    fnames = [
        "chgl_10_00000001000.tsv", "chgl_10_00000005000.tsv",
        "chgl_10_00000010000.tsv", "chgl_10_00000030000.tsv",
        "chgl_10_00000040000.tsv", "chgl_10_00000050000.tsv"
    ]
    times = list(range(len(fnames)))
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    folder = "data/almgsi_ch500K_run3"
    folder = "data/almgsi_ch500K_run_truncnorm"

    times = np.array(times, dtype=np.float64)
    times -= np.min(times)
    times /= np.max(times)
    times = times.tolist()

    for t, fname in zip(times, fnames):
        full_fname = folder + "/" + fname
        freq, prof = fft(full_fname)
        print(np.mean(prof))
        ax.plot(freq,
                prof / np.sum(prof),
                drawstyle='steps',
                color=cm.copper(t))
    ax.set_yscale('log')
    ax.set_xlabel("Frequency (nm \${-1}\$)")
    ax.set_ylabel("Occurence probability")
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    plt.show()
def setup_figure():
    fig=plt.figure(1)
    plt.clf()
    ax = fig.add_subplot(1,1,1)
    ax.set_xlim([-rho-1,rho+1])
    ax.set_ylim([-rho-1,rho+1])
    ax.set_aspect('equal')

    cells=[]
    springs=[]
    borders=[]
    for i in range(0,N):
        c = plt.Circle((-0,0),0.5,color=cm.copper(0))
        cells.append(ax.add_artist(c))

    if plot_springs:
        for i in range(0,len(pairs)):
            springs += ax.plot([], [], color=cm.spectral(0))

    if plot_voronoi:
        for i in range(0, pairs2.shape[0]):
            borders += ax.plot([], [], color='k')

    ang_mom = ax.add_patch(FancyArrowPatch((0,0),(1,1),ec='r', fc='r', zorder=0, arrowstyle=u'simple,head_width=20, head_length=10'))

    return(fig,cells,springs,borders,ang_mom)
Beispiel #5
0
def first():
    filename = "scatter.txt"
    file = open(filename, "r")
    tmp = []
    x = []
    y = []

    for line in file:
        tmp.append(line)

    for word in tmp[0].split():
        x.append(float(word))

    for word in tmp[1].split():
        y.append(float(word))
    file.close

    plt.axes(polar=True)

    data = []
    for num in y:
        data.append((num+5)*20)

    clr = cm.copper(data)

    plt.scatter(x, y, 10, y)
    plt.show()
Beispiel #6
0
    def get_colors(self, qty):

        qty = np.power(qty / qty.max(), 1.0 / CONTRAST)

        if COLORMAP == 0:
            rgba = cm.gray(qty, alpha=ALPHA)
        elif COLORMAP == 1:
            rgba = cm.afmhot(qty, alpha=ALPHA)
        elif COLORMAP == 2:
            rgba = cm.hot(qty, alpha=ALPHA)
        elif COLORMAP == 3:
            rgba = cm.gist_heat(qty, alpha=ALPHA)
        elif COLORMAP == 4:
            rgba = cm.copper(qty, alpha=ALPHA)
        elif COLORMAP == 5:
            rgba = cm.gnuplot2(qty, alpha=ALPHA)
        elif COLORMAP == 6:
            rgba = cm.gnuplot(qty, alpha=ALPHA)
        elif COLORMAP == 7:
            rgba = cm.gist_stern(qty, alpha=ALPHA)
        elif COLORMAP == 8:
            rgba = cm.gist_earth(qty, alpha=ALPHA)
        elif COLORMAP == 9:
            rgba = cm.spectral(qty, alpha=ALPHA)

        return rgba
    def distributions(self, number_of_agents, row_agents, col_agents, row_strategies, col_strategies,plot):
        self.row_strategies_distribution = self.proportion_classified_strategies(row_agents, row_strategies)
        for rs in range(len(row_strategies)):
             self.row_accumulated_strategies[rs].append(self.row_strategies_distribution[rs])
        self.col_strategies_distribution = self.proportion_classified_strategies(col_agents, col_strategies)
        for cs in range(len(col_strategies)):
             self.col_accumulated_strategies[cs].append(self.col_strategies_distribution[cs])

        self.total_strategies_per_generation = self.total_classified_strategies(row_agents, row_strategies, col_agents, col_strategies)
        for sh in range(len(self.strategies_history)):
            self.strategies_history[sh].append(self.total_strategies_per_generation[sh])

        print "\n Row players' strategy distribution:"
        print "\t", self.row_strategies_distribution
        print "\n Column players' strategy distribution:"
        print "\t", self.col_strategies_distribution

        ga.kill_agents(env.row_agents, env.number_of_agents, env.number_of_row_agents, env.row_strategies)
        ga.kill_agents(env.col_agents, env.number_of_agents, env.number_of_col_agents, env.col_strategies)
        print "Row agents eliminated", (number_of_agents / 2) - len(env.col_agents)
        print "Col agents eliminated", (number_of_agents / 2) - len(env.row_agents)
        ga.reproduce_agents(env.row_agents, env.number_of_agents, env.number_of_row_agents, env.row_strategies)
        ga.reproduce_agents(env.col_agents, env.number_of_agents, env.number_of_col_agents, env.col_strategies)

        if plot==True:
            for k in range(len(env.row_strategies)):
                c = cm.copper((k + 1) / len(env.row_strategies))
                pl.plot(self.row_accumulated_strategies[k], color=c, label="Row strategies: %s" % (k + 1))
            for k in range(len(env.col_strategies)):
                c = cm.winter((k + 1) / len(env.row_strategies))
                pl.plot(self.col_accumulated_strategies[k], color=c, label="Col strategies: %s" % (k + 1))
            pl.draw()
Beispiel #8
0
    def get_colors(self, qty):

        qty = np.power(qty / qty.max(), 1.0 / CONTRAST)

        if COLORMAP == 0:
            rgba = cm.gray(qty, alpha=ALPHA)
        elif COLORMAP == 1:
            rgba = cm.afmhot(qty, alpha=ALPHA)
        elif COLORMAP == 2:
            rgba = cm.hot(qty, alpha=ALPHA)
        elif COLORMAP == 3:
            rgba = cm.gist_heat(qty, alpha=ALPHA)
        elif COLORMAP == 4:
            rgba = cm.copper(qty, alpha=ALPHA)
        elif COLORMAP == 5:
            rgba = cm.gnuplot2(qty, alpha=ALPHA)
        elif COLORMAP == 6:
            rgba = cm.gnuplot(qty, alpha=ALPHA)
        elif COLORMAP == 7:
            rgba = cm.gist_stern(qty, alpha=ALPHA)
        elif COLORMAP == 8:
            rgba = cm.gist_earth(qty, alpha=ALPHA)
        elif COLORMAP == 9:
            rgba = cm.spectral(qty, alpha=ALPHA)

        return rgba
Beispiel #9
0
def plt_bw(ground_truth, predicted, loss, rows, ymax=None):
    """Plot windows and color encode by loss"""

    if ymax is None:
        ymax = np.max(ground_truth[rows])

    lossmax = np.max(loss[rows])
    bg = "#ffffff"
    n = rows.size

    plt.figure(figsize=(20, n * 2))
    for i, k in enumerate(rows):
        # display original
        ax = plt.subplot(n * 2, 1, i * 2 + 1)
        ax.set_facecolor("#888888")
        plt.bar(np.arange(ground_truth[k].size), ground_truth[k], color=bg)
        plt.ylim(0, ymax)
        ax.get_xaxis().set_visible(False)

        c = rgba_to_hex(copper((lossmax - loss[k]) / lossmax))

        # display reconstruction
        ax = plt.subplot(n * 2, 1, i * 2 + 2)
        ax.set_facecolor(c)
        plt.bar(np.arange(predicted[k].size), predicted[k], color=bg)
        plt.ylim(0, ymax)
        ax.get_xaxis().set_visible(False)
    plt.show()
Beispiel #10
0
def plot_global_reion_runs(zs, data):
    # Take data (e.g. from get_global_reion_runs) and plot.
    nzeta = zs.shape[0]
    ntvir = zs.shape[1]
    nmfp = zs.shape[2]
    plt.figure('Global runs')
    plt.clf()
    plt.subplot(131)
    colors = iter(cm.copper(np.linspace(0, 1, nzeta)))
    for i in xrange(nzeta):
        plt.plot(zs[i, ntvir / 2, nmfp / 2, :], data[i, ntvir / 2, nmfp / 2, :], color=next(colors))
    plt.subplot(132)
    colors = iter(cm.copper(np.linspace(0, 1, ntvir)))
    for i in xrange(ntvir):
        plt.plot(zs[nzeta / 2, i, nmfp / 2, :], data[nzeta / 2, i, nmfp / 2, :], color=next(colors))
    plt.subplot(133)
    colors = iter(cm.copper(np.linspace(0, 1, nmfp)))
    for i in xrange(nmfp):
        plt.plot(zs[nzeta / 2, ntvir / 2, i, :], data[nzeta / 2, ntvir / 2, i, :], color=next(colors))
Beispiel #11
0
def animate_system(positions: pd.DataFrame,
                   steps: int = 10,
                   size: int = 100) -> int:
    """
    Creates an interactive plot to visualize the positions of the
    moons at each step
    """

    velocities = pd.DataFrame({
        'x': [0] * len(positions),
        'y': [0] * len(positions),
        'z': [0] * len(positions)
    })

    # Create empty plot
    fig = plt.figure(figsize=(7, 7))
    ax = fig.add_subplot(111, projection='3d')
    x, y, z = [], [], []
    colors = cm.copper(4)
    sc = ax.scatter(x, y, z, s=size)

    # Compute all positions
    step_pos = []

    for i in range(steps):

        # Apply gravity
        velocities = update_velocity(positions, velocities)

        # Apply velocity
        positions = positions + velocities

        step_pos.append(positions)

    # Set plot limits
    allx = [i for sl in [list(p['x']) for p in step_pos] for i in sl]
    ally = [i for sl in [list(p['y']) for p in step_pos] for i in sl]
    allz = [i for sl in [list(p['z']) for p in step_pos] for i in sl]
    ax.set_xlim3d(min(allx), max(allx))
    ax.set_ylim3d(min(ally), max(ally))
    ax.set_zlim3d(min(allz), max(allz))

    # Animation
    def animate(i):
        pos = step_pos[i]
        sc._offsets3d = (pos['x'].values, pos['y'].values, pos['z'].values)

    ani = matplotlib.animation.FuncAnimation(fig,
                                             animate,
                                             frames=steps,
                                             interval=200,
                                             repeat=False)
    return ani
def get_colors(color_c=3, color_step=100):
    cmap_colors = np.vstack((
        cm.Oranges(np.linspace(0.4, 1, color_step)),
        cm.Reds(np.linspace(0.4, 1, color_step)),
        cm.Greys(np.linspace(0.4, 1, color_step)),
        cm.Purples(np.linspace(0.4, 1, color_step)),
        cm.Blues(np.linspace(0.4, 1, color_step)),
        cm.Greens(np.linspace(0.4, 1, color_step)),
        cm.pink(np.linspace(0.4, 1, color_step)),
        cm.copper(np.linspace(0.4, 1, color_step)),
    ))
    return cmap_colors[np.arange(color_c * color_step) % (color_step * 8)]
Beispiel #13
0
def soilmoisture_fingerprints(mask, name=None, fortalk=False):
    Fingerprints = {}
    depths = ["pdsi", "30cm", "2m"]
    if fortalk:
        letters = ["", "", ""]
    else:
        letters = ["(a): ", "(b): ", "(c): "]
    pcs = []
    pclabels = []
    for depth in depths:
        i = depths.index(depth)
        if fortalk:
            plt.figure()
        else:
            plt.subplot(2, 2, i + 1)
        sm = soilmoisture(depth, mask=mask)
        solver = Eof(MV.average(sm, axis=0), weights='area')
        Fingerprints[depth] = solver
        fac = da.get_orientation(solver)
        if name is None:
            m = b.landplot(fac * solver.eofs()[0], vmin=-.1, vmax=.1)
            plt.colorbar(orientation='horizontal', label='EOF loading')
        else:
            m = b.plot_regional(fac * solver.eofs()[0],
                                name,
                                vmin=-.1,
                                vmax=.1)
            m.drawcountries()
        m.drawcoastlines(color='gray')

        if depth is not "pdsi":
            plt.title(letters[i] + depth + " fingerprint")
        else:
            plt.title(letters[i] + " PDSI fingerprint")
        pcs += [fac * solver.pcs()[:, 0]]

    if fortalk:
        plt.figure()
    else:
        plt.subplot(2, 2, 4)
    for i in range(3):
        if depths[i] == "pdsi":
            label = "PDSI"
        else:
            label = depths[i]
        time_plot(pcs[i], label=label, lw=3, color=cm.copper(i / 2.))
    plt.legend(loc=0)
    plt.title("(d): Principal Components")
    plt.xlabel("Time")
    plt.ylabel("Temporal amplitude")
    plt.xlim(1900, 2100)
    return Fingerprints
Beispiel #14
0
def analyze_scan(Model, smooth=10, filename=None):

    F_aff, seeds, Model, DATA = get_scan(Model, filename=filename)

    fig1, ax1 = plt.subplots(1, figsize=(4, 2.5))
    plt.subplots_adjust(left=.3, bottom=.4)
    fig2, ax2 = plt.subplots(1, figsize=(4, 2.5))
    plt.subplots_adjust(left=.3, bottom=.4)

    for i in range(len(F_aff)):
        TRACES = []
        for j in range(len(seeds)):
            data = DATA[i * len(seeds) + j]
            # TRACES.append(data['POP_ACT_RecExc'])
            TRACES.append(
                gaussian_smoothing(data['POP_ACT_RecExc'],
                                   int(smooth / data['dt'])))
        mean = np.array(TRACES).mean(axis=0)
        std = np.array(TRACES).std(axis=0)
        # smoothing
        cond = data['t'] > 350
        ax1.plot(data['t'][cond],
                 mean[cond],
                 color=cm.copper(i / len(F_aff)),
                 lw=2)
        ax1.fill_between(data['t'][cond],
                         mean[cond] - std[cond],
                         mean[cond] + std[cond],
                         color=cm.copper(i / len(F_aff)),
                         alpha=.5)
        ax2.plot(data['t'][cond],
                 data['faff'][cond],
                 color=cm.copper(i / len(F_aff)))
    set_plot(ax1, xlabel='time (ms)', ylabel='rate (Hz)')
    set_plot(ax2, xlabel='time (ms)', ylabel='rate (Hz)')
    # put_list_of_figs_to_svg_fig([fig1, fig2])
    return fig1, fig2
def animate(f):
    global pairs, pairs2
    # load data
    F=F_vs_t[f]
    r=r_vs_t[f]
    n=n_vs_t[f]
    p=(rho+0.9)*p_angular[f]/np.sqrt(np.sum(p_angular[f]**2))

    ang_mom.set_positions((0, 0), (p[x_plane], p[y_plane]))

    if update_nn:
        pairs = simforces.get_all_pairs(getDelaunayTrianglesOnSphere(r)+1)
    
    for i in range(0,N):
        #j=indsort[i]
        c=int((r[z_plane,i]+1)/2*256)
        cells[i].center=(r[x_plane,i],r[y_plane,i])
        cells[i].set_facecolor(cm.copper(c))
        cells[i].set_zorder(r[z_plane,i])

    if plot_springs:
        for i in range(0,len(pairs)):
            i1 = pairs[i,0] - 1
            i2 = pairs[i,1] - 1
            if (r[z_plane,i1] > 0) and (r[z_plane,i2] > 0):
                dist = np.sqrt(np.sum((r[:,i1]- r[:,i2])**2))
                c=int((dist-1)*128)
                springs[i].set_data([r[x_plane,i1], r[x_plane,i2]], [r[y_plane,i1], r[y_plane,i2]])
                springs[i].set_color(cm.spectral(c))
            else:
                springs[i].set_data([], [])

    if plot_voronoi:
        list_, baricenters, out_polygon_dict, pairs2, all_areas = getVoronoiOnSphere(r)
        b = rho*baricenters
        for i in range(0,len(pairs2)):
            i1 = pairs2[i,0]
            i2 = pairs2[i,1]
            if (b[z_plane,i1] > 0) and (b[z_plane,i2] > 0):
                borders[i].set_data([b[x_plane,i1], b[x_plane,i2]], [b[y_plane,i1], b[y_plane,i2]])
            else:
                borders[i].set_data([], [])

    if f == 20:
        fig.savefig('test.png')    

      
    return (cells,springs,borders,ang_mom)
    def run(self, plot=False, stack=False):
        if plot==True:
            pl.ion()
            pl.ylim(0, 1)
            pl.xlabel("Generations")
            pl.ylabel("Probability")
            for k in range(len(env.row_strategies)):
                c = cm.copper((k + 1) / len(env.row_strategies))
                pl.plot(self.row_accumulated_strategies[k], color=c, label="Row strategies: %s" % (k + 1))
            for k in range(len(env.col_strategies)):
                c = cm.winter((k + 1) / len(env.row_strategies))
                pl.plot(self.col_accumulated_strategies[k], color=c, label="Col strategies: %s" % (k + 1))
            #pl.legend(bbox_to_anchor=(0.7, 0.85), loc=2, prop={'size':7})
            pl.legend(loc=2, prop={'size':7})
            pl.draw()

        self.generations_passing(ga.generations, ga.rounds_per_generation, env.number_of_agents, env.row_agents, env.col_agents, plot, stack)
Beispiel #17
0
def not_used05():
    jet = cm.get_cmap(
        'jet'
    )  # <matplotlib.colors.LinearSegmentedColormap object at 0x000002D606451E80>
    print(jet(0))
    print(jet(127))
    print(jet(255))
    print(jet(2550))
    print('-' * 50)

    # 색상을 표현하는 다양한 방법
    print(jet([0, 255]))
    print(jet(range(0, 5, 2)))
    print(jet(np.linspace(0.3, 0.7, 5)))
    print('-' * 50)
    print(cm.jet(0))
    print(cm.copper(0))
Beispiel #18
0
L = 32
datamaker0 = fs.SuperRegistration(np.zeros((2, L, L)), deg=deg)
datamaker0.shifts = np.array([3 * np.random.randn(2)])
shifts = datamaker0.shifts
fdata = datamaker0.model
fdata /= fdata.std()

data = fdata + 0.05 * np.random.randn(*fdata.shape)

reg = SuperRegistration(data, 16)
#print(reg.fit(iprint=2, delta=1E-4))
evd, bias = [], []
fig, ax = plt.subplots(1, 2, sharex=True)
order = list(range(10, 25))
nlist = list(range(2, 9, 2))  # [2]
colors = copper(Normalize()(nlist))
shifts = np.random.randn(max(nlist) - 1, 2)

datalist = []
biases = []
evidences = []

# This sequence plots the evidence as a function of complexity as a
# function of the number of images

for n, c in zip(nlist, colors):
    dm = fs.SuperRegistration(np.zeros((n, L, L)), deg)
    dm.coef = datamaker0.coef
    dm.shifts = shifts[:n - 1]
    data = dm.model / dm.model.std()
    data += 0.05 * np.random.randn(*data.shape)
def get_stability_condition(plot_results=True):
    current_factors = [0.6, 0.7, 0.8, 0.9, 1.0]
    colors = cm.copper(np.linspace(0.0, 1.0, len(current_factors)))

    # Get profiles
    dat = np.loadtxt(os.path.join('input_profiles.dat'))
    
    # Modify and plot input profiles
    r = dat[:, 0]
    R = dat[:, 1]
    j_phi = dat[:, 2]
    B_z = dat[:, 3]
    B_theta = dat[:, 4]
    psi_n = dat[:, 5]
    r_to_psin = interpolate.interp1d(r, psi_n)
    psin_to_r = interpolate.interp1d(r, psi_n)
    
    q = r * B_z / (R * B_theta)
    q[0] = q[1]
    if plot_results:
        fig, ax = plt.subplots(2, 2, figsize=(10, 10), sharex=True)

        ax[0, 0].plot(r, B_z, c='k')
        ax[0, 0].set_ylabel('$B_{\phi}$ [T]', fontsize=fontsize)
        ax[1, 0].plot(r, B_theta, c='k')
        ax[1, 0].set_ylabel('$B_{\\theta}$ [T]', fontsize=fontsize)
        for i, factor in enumerate(current_factors[::-1]):
            linestyle = '--' if i > 0 else '-'
            ax[0, 1].plot(r, factor * j_phi * 1e-3, linestyle=linestyle, c=colors[i])
        ax[0, 1].set_ylabel('$j_{\phi}$ [kA]', fontsize=fontsize)
        ax[1, 1].plot(r, q, c='k')
        ax[1, 1].set_ylabel('q', fontsize=fontsize)
        ax[1, 1].set_xlabel('r [m]', fontsize=fontsize)
        ax[1, 0].set_xlabel('r [m]', fontsize=fontsize)
        ax[0, 0].set_xlim([0.0, 1.0])
        fig.tight_layout()
        plt.savefig('input_profiles')
        plt.show()

    plt.figure()
    for epsilon in [1e-12, 1e-8, 1e-6, 1e-4]:
        r_max = r[-1]
        deltas = list()
        alphas = list()

        for factor in current_factors:
            j_phi_sim = j_phi * factor

            solver = TearingModeSolver(m, r, r_max, B_theta, B_z, j_phi_sim, q, num_pts, delta=epsilon)
            solver.find_delta(plot_output=False)

            deltas.append(solver.delta)
            alphas.append(1 - factor)

        plt.plot(alphas, deltas, label="$\epsilon$={}".format(epsilon))
        np.savetxt('deltas_{}.dat'.format(epsilon), np.stack((alphas, deltas), axis=-1))
    
    plt.grid(linestyle='--')
    plt.ylabel('$\Delta\'$', fontsize=fontsize)
    plt.xlabel('$\\alpha$', fontsize=fontsize)
    plt.legend()
    plt.xlim([0.0, 1.0])
    plt.savefig('current_stability_{}'.format(m))
    plt.show()
Beispiel #20
0
def main():
    args = parse_args()
    q_mean, p_mean, Q, P, W = prepare_data(args)
    no_steps = Q.shape[0]
    q_min = Q[:, 0, 0].min()
    q_max = Q[:, 0, -1].max()
    p_min = P[:, 0, 0].min()
    p_max = P[:, -1, 0].max()
    if args.vmin[-1] == "%":
        W_min = numpy.percentile(W[:], float(args.vmin[:-1]))
    else:
        W_min = float(args.vmin)
    if args.vmax[-1] == "%":
        W_max = numpy.percentile(W[:], 100. - float(args.vmax[:-1]))
    else:
        W_max = float(args.vmax)
    midpoint = 1 - W_max / (W_max + abs(W_min))
    cmap = shifted_color_map(cm.coolwarm, midpoint=midpoint, name="shifted")
    fig = pyplot.figure()
    ax = fig.add_subplot(1, 1, 1)
    ax.set_xlim(q_min, q_max)
    ax.set_ylim(p_min, p_max)
    ax.set_xlabel("q")
    ax.set_ylabel("p")
    if args.visualization == "polished":
        shading = "gouraud"
    else:
        shading = "flat"
    quad = QuadContainer(
        ax.pcolormesh(Q[0],
                      P[0],
                      W[0],
                      vmin=W_min,
                      vmax=W_max,
                      cmap=cmap,
                      shading=shading))
    ax.set_aspect("equal")
    if args.track:
        ax.set_color_cycle(
            [cm.copper(1. * i / (no_steps - 1)) for i in range(no_steps - 1)])
        for i in range(no_steps - 1):
            ax.plot(q_mean[i:i + 2], p_mean[i:i + 2], alpha=.3)
    cb = fig.colorbar(quad.quad)
    cb.set_label("Quasiprobability Density")
    cb.solids.set_rasterized(True)
    if args.visualization == "polished":
        ax.set_axis_bgcolor(cb.to_rgba(0.))
    no_digits = int(ceil(log10(no_steps)) + 1)
    title_string = "Wigner Function at step {:{width}}/{:{width}}"
    title = ax.set_title(title_string.format(0, no_steps, width=no_digits))
    ax.grid(True)
    if args.output:
        fig.savefig(args.output + "_thumb.pdf")

    def animate(i):
        title.set_text(title_string.format(i, no_steps, width=no_digits))
        quad.update_quad(
            ax.pcolormesh(Q[i],
                          P[i],
                          W[i],
                          vmin=W_min,
                          vmax=W_max,
                          cmap=cmap,
                          shading=shading))
        ax.grid(True)
        return quad.quad,

    ani = FuncAnimation(fig,
                        animate,
                        no_steps,
                        interval=100,
                        repeat_delay=1000)
    if args.output:
        print("Saving movie to {}. This may take a couple of minutes.".format(
            args.output))
        ani.save(args.output + ".mp4",
                 fps=10,
                 extra_args=['-vcodec', 'libx264'])
    pyplot.show()
def get_stability_condition(plot_results=True):
    current_factors = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.65, 0.675, 0.6875, 0.7, 0.8, 0.9, 1.0]
    colors = cm.copper(np.linspace(0.0, 1.0, len(current_factors)))

    # Get profiles
    dat = np.loadtxt(os.path.join('input_profiles.dat'))
    
    # Modify and plot input profiles
    r = dat[:, 0]
    R = dat[:, 1]
    j_phi = dat[:, 2]
    B_z = dat[:, 3]
    B_theta = dat[:, 4]
    psi_n = dat[:, 5]
    r_to_psin = interpolate.interp1d(r, psi_n)
    psin_to_r = interpolate.interp1d(r, psi_n)
    
    q = r * B_z / (R * B_theta)
    q[0] = q[1]
    if plot_results:
        fig, ax = plt.subplots(2, 2, figsize=(10, 10), sharex=True)

        ax[0, 0].plot(r, B_z, c='k')
        ax[0, 0].set_ylabel('$B_{\phi}$ [T]', fontsize=fontsize)
        ax[1, 0].plot(r, B_theta, c='k')
        ax[1, 0].set_ylabel('$B_{\\theta}$ [T]', fontsize=fontsize)
        for i, factor in enumerate(current_factors[::-1]):
            linestyle = '--' if i > 0 else '-'
            ax[0, 1].plot(r, factor * j_phi * 1e-3, linestyle=linestyle, c=colors[i])
        ax[0, 1].set_ylabel('$j_{\phi}$ [kA]', fontsize=fontsize)
        ax[1, 1].plot(r, q, c='k')
        ax[1, 1].set_ylabel('q', fontsize=fontsize)
        ax[1, 1].set_xlabel('r [m]', fontsize=fontsize)
        ax[1, 0].set_xlabel('r [m]', fontsize=fontsize)
        ax[0, 0].set_xlim([0.0, 1.0])
        fig.tight_layout()
        plt.savefig('input_profiles')
        plt.show()

    r_max = r[-1]
    deltas = list()
    gammas = list()
    alphas = list()
    if os.path.exists(data_output):
        alphas = 1 - np.asarray(current_factors)
        deltas = np.loadtxt(data_output)
        gammas = np.loadtxt(gamma_output)
    else:
        for factor in current_factors:
            j_phi_sim = j_phi * factor

            solver = TearingModeSolver(m, r, r_max, B_theta, B_z, j_phi_sim, q, num_pts, delta=1e-12)
            solver.find_delta(plot_output=False)
            solver.get_gamma()

            # Transform to psi_norm for comparison with JOREK
            psin_lower = r_to_psin(solver.r_lower)
            psin_upper = r_to_psin(solver.r_upper)
            
            if plot_results:
                fig, ax = plt.subplots(2, sharex=True)
                ax[0].plot(psin_lower, solver.psi_sol_lower[:, 0], label='solution from axis')
                ax[0].plot(psin_upper, solver.psi_sol_upper[:, 0], label='solution from boundary')

                # Plot comparison solution if it exists        
                validation_file = 'flux_validation_vc_{}.csv'.format(factor)
                if os.path.exists(validation_file):
                    flux_validation = np.loadtxt(validation_file, delimiter=',')
                    flux_validation[:, 1] /= np.max(flux_validation[:, 1]) 
                    flux_validation[:, 1] *= np.max(solver.psi_sol_lower[:, 0])
                    ax[0].plot(flux_validation[:, 0], flux_validation[:, 1], linestyle='--', label='JOREK')

                ax[0].set_ylabel('$\Psi_1$', fontsize=fontsize)
                ax[0].legend()
                ax[0].set_xlim([0.0, 1.0])
                
                ax[1].plot(psin_lower, solver.psi_sol_lower[:, 1])
                ax[1].plot(psin_upper, solver.psi_sol_upper[:, 1])
                ax[1].set_ylabel('$\\frac{\partial \Psi_1}{\partial r}$', fontsize=fontsize)
                ax[1].set_xlabel('$\hat \Psi$', fontsize=fontsize)
                plt.show()

            deltas.append(solver.delta)
            gammas.append(solver.gamma)
            alphas.append(1 - factor)

        np.savetxt(data_output, np.asarray(deltas))
        np.savetxt(gamma_output, np.asarray(gammas))    

    alphas = np.asarray(alphas)
    deltas = np.asarray(deltas)
    gammas = np.asarray(gammas)

    # Plot gammas
    gammas_jor = np.asarray([0.000112257, 7.25606e-5, 3.87257e-5, 2.29265e-5, 1.50064e-5, 6.86054e-6, 2.586e-6])
    gammas_jor /= 6.4836e-7
    alphas_jor = [0.0, 0.1, 0.2, 0.25, 0.275, 0.3, 0.3125]
    eta = 1e-7 * 1.9382
    rho = 1e20 * 2 * 1.673 * 1e-27
    gammas *= eta ** 0.6 / rho ** 0.2
    fig, ax = plt.subplots(1)
    ax.plot(alphas, gammas, label='Linear $\Delta\'$')
    ax.scatter(alphas, gammas)
    ax.plot(alphas_jor, gammas_jor, label='JOREK $\Delta\'$')
    ax.scatter(alphas_jor, gammas_jor)
    plt.savefig('current_stability_gammas_{}'.format(m))
    ax.set_ylabel('$\gamma\ [s^{-1}]$', fontsize=fontsize)
    ax.set_xlabel('$\\alpha$', fontsize=fontsize)
    plt.show()

    alphas_jor_8 = [0.0, 0.1, 0.2, 0.3]
    gammas_8 = np.asarray([41.701, 25.616, 12.98966, 2.5974])
    gammas_9 = np.asarray([6.809, 4.0393, 1.99651, 0.46058])

    # Plot deltas
    solver = TearingModeSolver(m, r, r_max, B_theta, B_z, j_phi, q, num_pts, delta=1e-12)
    deltas_jor = gammas_jor / 0.55 / (eta / PhysicalConstants.mu_0) ** 0.6
    deltas_jor /= (m * solver.r_to_B_theta(solver.r_instability) / np.sqrt(PhysicalConstants.mu_0 * rho)) ** 0.4
    deltas_jor /= (solver.r_to_q_deriv(solver.r_instability) / (solver.r_instability * solver.r_to_q(solver.r_instability))) ** 0.4 
    deltas_jor = deltas_jor ** (5.0 / 4.0)

    deltas_jor_8 = gammas_8 / 0.55 / (eta * 0.1 / PhysicalConstants.mu_0) ** 0.6
    deltas_jor_8 /= (m * solver.r_to_B_theta(solver.r_instability) / np.sqrt(PhysicalConstants.mu_0 * rho)) ** 0.4
    deltas_jor_8 /= (solver.r_to_q_deriv(solver.r_instability) / (solver.r_instability * solver.r_to_q(solver.r_instability))) ** 0.4 
    deltas_jor_8 = deltas_jor_8 ** (5.0 / 4.0)

    deltas_jor_9 = gammas_9 / 0.55 / (eta * 0.01 / PhysicalConstants.mu_0) ** 0.6
    deltas_jor_9 /= (m * solver.r_to_B_theta(solver.r_instability) / np.sqrt(PhysicalConstants.mu_0 * rho)) ** 0.4
    deltas_jor_9 /= (solver.r_to_q_deriv(solver.r_instability) / (solver.r_instability * solver.r_to_q(solver.r_instability))) ** 0.4 
    deltas_jor_9 = deltas_jor_9 ** (5.0 / 4.0)

    scaling = 1.05
    fig, ax = plt.subplots(1)
    ax.plot(alphas, deltas, label='Linear $\Delta\'$')
    ax.scatter(alphas, deltas)
    ax.plot(alphas_jor, deltas_jor, label='JOREK $\Delta\'$')
    ax.scatter(alphas_jor, deltas_jor)
    ax.plot(alphas_jor_8, deltas_jor_8, label='JOREK $\Delta\' for $\eta=10^{-8}$')
    ax.scatter(alphas_jor_8, deltas_jor_8)
    ax.plot(alphas_jor_8, deltas_jor_9, label='JOREK $\Delta\'$ for $\eta=10^{-9}$')
    ax.scatter(alphas_jor_8, deltas_jor_9)
    ax.axhline(0.0, c='k', linestyle='--')
    ax.axvline(0.346, linestyle='--', color='grey', label='Linear stability boundary')
    ax.axvline(0.3125, linestyle='--', color='g', label='JOREK stability boundary')
    ax.axvline(0.325, linestyle='--', color='g')
    ax.fill_betweenx(scaling * deltas, 0.3125, 0.325, facecolor='green', alpha=0.2)
    ax.set_ylabel('$\Delta\'$', fontsize=fontsize)
    ax.set_xlabel('$\\alpha$', fontsize=fontsize)
    ax.set_xlim([0.0, 1.0])
    ax.set_ylim([scaling * min(deltas), scaling * max(deltas)])
    ax.grid(linestyle='--')
    ax.legend()
    plt.savefig('current_stability_deltas_{}'.format(m))
    plt.show()
Beispiel #22
0
    "params_dam_nilc.yml",
    "params_dam_wfixed.yml",
    "params_dam_tinker10.yml",
    #             "params_wnarrow_ns.yml",
    #             "params_masked.yml"
]

sci = [r"$\mathrm{2MPZ}$"] + \
      [r"$\mathrm{WI \times SC}$ - $\mathrm{%d}$" % i for i in range(1, 6)]
lbls = [
    "Fiducial", "NILC", "Fixed $w_z$", "Tinker 2010",
    r"$\langle N_s \rangle$ independent"
    "tSZ-masked"
]
colours = ["k", "grey", "r", "brown", "orange"]
col = [copper(i) for i in np.linspace(0, 1, len(sci))]
fmts = ["o", "o", "v", "s", "*", "d"]

p = ParamRun(param_yml[0])
#temp = [chan(paryml, diff=True, error_type="hpercentile", chains=False, b_hydro=0.5*np.ones([1,6]))
#        for paryml in param_yml]
#pars = [t[0] for t in temp]
#data = np.array([[p["b_hydro"] for p in par] for par in pars])
#data = [d.T for d in data]
print("HI")
BF = [chan(fname).get_best_fit("b_hydro") for fname in param_yml]
print("Best fits OK")

widths = chan(param_yml[0]).get_best_fit("width")
widths = np.hstack((widths["width"][:, 0]))
dz, dN = [[] for i in range(2)]
def excess(temps):
    ref_energies = {"Al": -3.73667187, "Mg": -1.59090625}
    if (temps == "all"):
        db = connect(mc_db_name)
        all_temps = []
        for row in db.select(converged=1):
            if (row.temperature not in all_temps):
                all_temps.append(row.temperature)
        temps = all_temps
    res = get_free_energies()
    try:
        for key, value in res.iteritems():
            F = np.array(value["free_energy"])
            plt_set = False
            for i in range(1, len(F)):
                if (F[i] < F[i - 1]):
                    print(value["temperature"][i])
                    plt_set = True
            F -= F[0]
            if (plt_set):
                print(key)
                plt.plot(value["temperature"], F)
        plt.show()
        for key, value in res.iteritems():
            E = np.array(value["internal_energy"])
            E -= E[0]
            plt.plot(value["temperature"], E)
        plt.show()
    except Exception as exc:
        print(str(exc))

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    markers = ["o", "x", "^", "v", "d"]
    colors = [
        '#b2182b', '#ef8a62', '#fddbc7', '#f7f7f7', '#d1e5f0', '#67a9cf',
        '#2166ac'
    ]
    fig_entropy = plt.figure()
    ax_entropy = fig_entropy.add_subplot(1, 1, 1)

    fig_mg_weighted = plt.figure()
    ax_mg_weighted = fig_mg_weighted.add_subplot(1, 1, 1)
    fig_F = plt.figure()
    ax_F = fig_F.add_subplot(1, 1, 1)

    Tmin = np.min(temps)
    Tmax = np.max(temps)
    print("Min temp: {}, Max temp: {}".format(Tmin, Tmax))
    all_excess = []
    all_concs = []
    all_temps = []
    for count, T in enumerate(temps):
        excess = []
        concs = []
        entropy = []
        free_eng = []
        temperature = None
        for key, entry in res.iteritems():
            if ("Mg" in entry["conc"].keys()):
                mg_conc = entry["conc"]["Mg"]
            else:
                mg_conc = 0.0
            concs.append(mg_conc)
            diff = np.abs(entry["temperature"] - T)
            indx = np.argmin(diff)
            if (diff[indx] > 1.0):
                print(
                    "Warning! Difference {}. Temperature might not be simulated!"
                    .format(diff[indx]))
            excess.append(entry["internal_energy"][indx] -
                          ref_energies["Al"] * entry["conc"]["Al"] -
                          ref_energies["Mg"] * entry["conc"]["Mg"])
            free_eng.append(entry["free_energy"][indx] -
                            ref_energies["Al"] * entry["conc"]["Al"] -
                            ref_energies["Mg"] * entry["conc"]["Mg"])
            if (temperature is None):
                temperature = entry["temperature"][indx]
            #excess[-1] += entry["TS"][indx]
            entropy.append(entry["entropy"][indx])
            #excess.append( entry["free_energy"][indx]+entry["TS"][indx] )
            #excess.append( entry["free_energy"][indx] )
        concs += [0.0, 1.0]
        excess += [0.0, 0.0]
        entropy += [0.0, 0.0]
        free_eng += [0.0, 0.0]
        srt_indx = np.argsort(concs)
        concs = [concs[indx] for indx in srt_indx]
        excess = np.array([excess[indx] for indx in srt_indx])
        entropy = np.array([entropy[indx] for indx in srt_indx])
        free_eng = np.array([free_eng[indx] for indx in srt_indx])
        all_excess.append(excess)
        all_concs.append(concs)
        mapped_temp = float(temperature - Tmin) / (Tmax - Tmin)
        print(mapped_temp)
        all_temps.append(temperature)
        ax.plot(concs,
                excess * mol / kJ,
                marker=markers[count % len(markers)],
                label="{}K".format(temperature),
                mfc="none",
                color=cm.copper(mapped_temp),
                lw=2)
        ax_entropy.plot(concs,
                        1000.0 * entropy * mol / kJ,
                        marker=markers[count % len(markers)],
                        label="{}K".format(temperature),
                        color=cm.copper(mapped_temp),
                        lw=2,
                        mfc="none")
        ax_F.plot(concs,
                  free_eng * mol / kJ,
                  marker=markers[count % len(markers)],
                  label="{}K".format(temperature),
                  mfc="none",
                  color=cm.copper(mapped_temp),
                  lw=2)
        ax_mg_weighted.plot(concs, (excess / concs) * mol / kJ,
                            marker=markers[count % len(markers)],
                            color=cm.copper(mapped_temp),
                            lw=2,
                            mfc="none")
    ax.legend(frameon=False)
    ax.set_xlabel("Mg concentration")
    ax.set_ylabel("Enthalpy of formation (kJ/mol)")
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)

    ax_entropy.set_xlabel("Mg concentration")
    ax_entropy.set_ylabel("Entropy (J/K mol)")
    ax_entropy.spines["right"].set_visible(False)
    ax_entropy.spines["top"].set_visible(False)
    fig_info = plt.figure()
    Z = [[0, 0], [0, 0]]
    #temp_info = [np.min(T),np.max(T)]
    ax_info = fig_info.add_subplot(1, 1, 1)
    temp_info = np.linspace(np.min(temps), np.max(temps), 256)
    Cb_info = ax_info.contourf(Z, temp_info, cmap="copper")

    cbar = fig.colorbar(Cb_info,
                        orientation="horizontal",
                        ticks=[100, 300, 500, 700])
    cbar.ax.xaxis.set_ticks_position("top")
    cbar.ax.set_xticklabels([100, 300, 500, 700])
    cbar.ax.xaxis.set_label_position("top")

    #cbar.ax.tick_params(axis='x',direction='in',labeltop='on')
    cbar.set_label("Temperature (K)")

    cbar2 = fig_entropy.colorbar(Cb_info,
                                 orientation="horizontal",
                                 ticks=[100, 300, 500, 700])
    cbar2.ax.xaxis.set_ticks_position("top")
    cbar2.ax.set_xticklabels([100, 300, 500, 700])
    cbar2.ax.xaxis.set_label_position("top")
    cbar2.set_label("Temperature (K)")

    all_maxima, all_minima = find_extremal_points(all_concs,
                                                  all_excess,
                                                  show_plot=False)

    ax_F.set_ylabel("Free Energy of Formation (kJ/mol)")

    all_data = []
    for temp, maxima, minima in zip(all_temps, all_maxima, all_minima):
        all_data.append({
            "temperature": temp,
            "maxima": maxima,
            "minima": minima
        })

    with open("data/extremal_points.json", 'w') as outfile:
        json.dump(all_data, outfile, indent=2, separators=(",", ":"))
    plt.show()
hist_dat.append([apc.loc['resp'].drop('v4', level='layer_label').loc[layer]
                 for layer in layers_to_examine] + [apc.loc['resp'].loc['v4'],])
#hist_dat.append([apc.loc['resp'].drop('v4', level='layer_label').loc[layer]
#                 for layer in layers_to_examine])
hist_dat_leg.append({'title':'CN resp', 'labels':layers_to_examine, 
                    'fontsize':'xx-small' , 'frameon':True, 'loc':4,'markerscale':100})

for leg in hist_dat_leg:
    leg['fontsize'] = fs
    leg['labelspacing'] = 0
for i, ax_ind in enumerate(hist_pos):
    ax = ax_list[ax_ind]
    if not (ax_ind==hist_pos[-1]):
        colors = ['g','r','b','m','c', 'k', '0.5']
    else:
        colors = cm.copper(np.linspace(0,1,len(hist_dat[i])))
        colors[-1] = [1, 0, 0, 0]

    for apc_vals, color in zip(hist_dat[i], colors):
        x = apc_vals.dropna().values
        y_c, bins_c = d_hist(ax, np.sqrt(x), cumulative=True, color=color, alpha=0.75, lw=2)   
    bins_c = np.concatenate([apc_vals.dropna().values for apc_vals in hist_dat[i]]).ravel()
    beautify(ax, spines_to_remove=['top','right'])
    ax.set_xticks([0,0.5,1])
    ax.set_xticklabels([0,0.5,1], fontsize=10)
    ax.spines['left'].set_bounds(0,1)
    ax.set_xlim(0,1)
    ax.set_yticks([0, 0.5, 1])
    ax.set_yticklabels([0,  0.5, 1], fontsize=10)
    ax.set_ylim(0,1.1)
    if not (ax_ind==hist_pos[-1]):
from PIL import Image
import numpy as np
from matplotlib import pyplot as plt
from matplotlib import cm
im = Image.open('../data/grenouille.jpg')
rouge, vert, bleu = im.split()
z = np.array(rouge)
z = np.uint8(cm.copper(z) * 255)
im2 = Image.fromarray(z)
im2.save("grenouille_saved.jpg")
Beispiel #26
0
import matplotlib.pyplot as plt
from matplotlib import cm

with open('bars.txt') as f:
    lines = f.readlines()

x = [float(i) for i in lines[0].split()]
y = [float(i) for i in lines[1].split()]

color = cm.copper(y)

fig = plt.figure()
ax = fig.add_subplot(111)
rects = ax.bar(x, y, color=color)

for rect in rects:
    height = rect.get_height()
    ax.text(rect.get_x() + rect.get_width() / 2.,
            1.005 * height,
            '%.2f' % float(height),
            ha='center',
            va='bottom')

plt.show()
def main():
    T = np.array([
        10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000, 1000, 800, 700,
        600, 500, 400, 375, 350, 325, 300, 275, 250, 225, 200, 175, 150
    ])
    mg_concs = []
    enthalpies = []
    free_energy = []
    ref_energies = {"Al": -3.73667187, "Mg": -1.59090625}
    temps = []
    concs = []
    filenames = glob.glob("data/mfa217/*")
    ignore_indx = []
    for i, filename in enumerate(filenames):
        with open(filename, 'r') as infile:
            data = json.load(infile)
        mg_concs.append(data["conc"]["Mg"])
        concs.append(data["conc"])
        print(data["conc"], filename)
        enthalpies.append(
            np.array(data["internal_energy"]) / data["natoms"] -
            ref_energies["Mg"] * data["conc"]["Mg"] -
            ref_energies["Al"] * data["conc"]["Al"])
        free_energy.append(
            np.array(data["free_energy"]) / data["natoms"] -
            ref_energies["Mg"] * data["conc"]["Mg"] -
            ref_energies["Al"] * data["conc"]["Al"])
        try:
            temps.append(data["temperature"])
        except Exception as exc:
            ignore_indx.append(i)
            print("Error occured in {}. Message: {}".format(
                filename, str(exc)))

    if (save_free_eng):
        res = {}
        i = 0
        for indx in range(len(filenames)):
            if (indx in ignore_indx):
                continue
            res[filenames[i]] = {}
            res[filenames[i]]["conc"] = concs[i]
            res[filenames[i]]["free_energy"] = free_energy[i].tolist()
            res[filenames[i]]["temperature"] = temps[i]
            i += 1

        with open(free_eng_file, 'w') as outfile:
            json.dump(res, outfile, indent=2, separators=(",", ":"))
        print("Free energies written to {}".format(free_eng_file))
    figH = plt.figure()
    axH = figH.add_subplot(1, 1, 1)
    figF = plt.figure()
    axF = figF.add_subplot(1, 1, 1)
    figS = plt.figure()
    axS = figS.add_subplot(1, 1, 1)
    Tmax = 800
    Tmin = 150
    print(len(temps[0]))
    print(len(enthalpies[0]))
    for i in range(len(enthalpies[0])):
        try:
            T = temps[0][i]
            if (T > Tmax):
                continue
            srt_indx = np.argsort(mg_concs)
            H = [enthalpies[j][i] for j in range(len(enthalpies))]
            F = [free_energy[j][i] for j in range(len(free_energy))]

            srt_mg = [mg_concs[indx] for indx in srt_indx]
            H = np.array([H[indx] for indx in srt_indx])
            F = np.array([F[indx] for indx in srt_indx])
            mapped_T = float(T - Tmin) / (Tmax - Tmin)
            S = (H - F) / T
            axH.plot(srt_mg,
                     H * mol / kJ,
                     marker="x",
                     color=cm.copper(mapped_T))
            axF.plot(srt_mg,
                     F * mol / kJ,
                     marker="o",
                     color=cm.copper(mapped_T))
            axS.plot(srt_mg,
                     1E6 * S * mol / kJ,
                     marker="o",
                     color=cm.copper(mapped_T))
        except Exception as exc:
            print(str(exc))

    axH.set_xlabel("Mg concentration")
    axH.set_ylabel("Enthalpy of Formation (kJ/mol)")
    axF.set_xlabel("Mg concentration")
    axF.set_ylabel("Free Energy of Formation (kJ/mol)")
    axS.set_xlabel("Mg concentration")
    axS.set_ylabel("Entropy (mJ/K mol)")
    axH.spines["right"].set_visible(False)
    axH.spines["top"].set_visible(False)
    axF.spines["right"].set_visible(False)
    axF.spines["top"].set_visible(False)
    axS.spines["right"].set_visible(False)
    axS.spines["top"].set_visible(False)

    plt.show()
Beispiel #28
0
        if pltcolor:
            plt.figure(1)
            plt.plot(t, en, label=runname)
            plt.figure(2)
            plt.plot(t, hdiss + hdissz, label=runname)
            plt.figure(3)
            plt.plot(t, enz, label=runname)
            plt.figure(4)
            plt.plot(t, diss + dissz, label=runname)

        else:
            plt.figure(1)
            plt.plot(t,
                     en,
                     label=r"$\Omega = %.3f$" % omegas[runname],
                     color=cm.copper(cscale(omegas[runname], omegas)))

            plt.figure(2)
            plt.plot(t,
                     hdiss + hdissz,
                     label=r"$\Omega = %.3f$" % omegas[runname],
                     color=cm.copper(cscale(omegas[runname], omegas)))

            plt.figure(3)
            plt.plot(t,
                     enz,
                     label=r"$\Omega = %.3f$" % omegas[runname],
                     color=cm.copper(cscale(omegas[runname], omegas)))

            plt.figure(4)
            plt.plot(t,
def get_stability_condition(plot_results=True):
    current_factors = [
        0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.65, 0.675, 0.6875, 0.7, 0.8, 0.9,
        1.0, 1.1, 1.2, 1.3
    ]
    colors = cm.copper(np.linspace(0.0, 1.0, len(current_factors)))

    # Get profiles
    dat = np.loadtxt(os.path.join('input_profiles.dat'))

    # Modify and plot input profiles
    r = dat[:, 0]
    R = dat[:, 1]
    j_phi = dat[:, 2]
    B_z = dat[:, 3]
    B_theta = dat[:, 4]
    psi_n = dat[:, 5]
    r_to_psin = interpolate.interp1d(r, psi_n)
    psin_to_r = interpolate.interp1d(r, psi_n)

    q = r * B_z / (R * B_theta)
    q[0] = q[1]
    if plot_results:
        fig, ax = plt.subplots(2, 2, figsize=(10, 10), sharex=True)

        ax[0, 0].plot(r, B_z, c='k')
        ax[0, 0].set_ylabel('$B_{\phi}$ [T]', fontsize=fontsize)
        ax[1, 0].plot(r, B_theta, c='k')
        ax[1, 0].set_ylabel('$B_{\\theta}$ [T]', fontsize=fontsize)
        for i, factor in enumerate(current_factors[::-1]):
            linestyle = '--' if i > 0 else '-'
            ax[0, 1].plot(r,
                          factor * j_phi * 1e-3,
                          linestyle=linestyle,
                          c=colors[i])
        ax[0, 1].set_ylabel('$j_{p}$ [kA]', fontsize=fontsize)
        ax[1, 1].plot(r, q, c='k')
        ax[1, 1].set_ylabel('q', fontsize=fontsize)
        ax[1, 1].set_xlabel('r [m]', fontsize=fontsize)
        ax[1, 0].set_xlabel('r [m]', fontsize=fontsize)
        ax[0, 0].set_xlim([0.0, 1.0])
        fig.tight_layout()
        plt.savefig('input_profiles')
        plt.show()

    r_max = r[-1]
    deltas = list()
    gammas = list()
    alphas = list()
    current = np.zeros((len(current_factors), 3))
    if os.path.exists(data_output):
        alphas = 1 - np.asarray(current_factors)
        deltas = np.loadtxt(data_output)
        gammas = np.loadtxt(gamma_output)

        for i, factor in enumerate(current_factors):
            j_phi_sim = j_phi * (1 - factor)
            solver = TearingModeSolver(m,
                                       r,
                                       r_max,
                                       B_theta,
                                       B_z,
                                       j_phi_sim,
                                       q,
                                       num_pts,
                                       delta=1e-12)
            current[i, 0] = factor
            current[i, 1] = solver.r_to_j_phi(solver.r_instability)
            current[i, 2] = solver.r_to_j_phi_deriv(solver.r_instability)
        np.savetxt('instability_currents.dat',
                   current,
                   header='Alpha\t\tJ [A]\t\tdJ_dr [A/m]')
    else:
        for factor in current_factors:
            j_phi_sim = j_phi * factor

            solver = TearingModeSolver(m,
                                       r,
                                       r_max,
                                       B_theta,
                                       B_z,
                                       j_phi_sim,
                                       q,
                                       num_pts,
                                       delta=1e-12)
            solver.find_delta(plot_output=False)
            solver.get_gamma()

            # Transform to psi_norm for comparison with JOREK
            psin_lower = r_to_psin(solver.r_lower)
            psin_upper = r_to_psin(solver.r_upper)

            if plot_results:
                fig, ax = plt.subplots(2, sharex=True)
                ax[0].plot(psin_lower,
                           solver.psi_sol_lower[:, 0],
                           label='solution from axis')
                ax[0].plot(psin_upper,
                           solver.psi_sol_upper[:, 0],
                           label='solution from boundary')

                # Plot comparison solution if it exists
                validation_file = 'flux_validation_vc_{}.csv'.format(factor)
                if os.path.exists(validation_file):
                    flux_validation = np.loadtxt(validation_file)
                    flux_validation[:, 1] /= np.max(flux_validation[:, 1])
                    flux_validation[:, 1] *= np.max(solver.psi_sol_lower[:, 0])
                    ax[0].plot(flux_validation[:, 0],
                               flux_validation[:, 1],
                               linestyle='--',
                               label='JOREK')

                ax[0].set_ylabel('$\Psi_1$', fontsize=fontsize)
                ax[0].legend()
                ax[0].set_xlim([0.0, 1.0])

                ax[1].plot(psin_lower, solver.psi_sol_lower[:, 1])
                ax[1].plot(psin_upper, solver.psi_sol_upper[:, 1])
                ax[1].set_ylabel('$\\frac{\partial \Psi_1}{\partial r}$',
                                 fontsize=fontsize)
                ax[1].set_xlabel('$\hat \Psi$', fontsize=fontsize)
                plt.show()

            deltas.append(solver.delta)
            gammas.append(solver.gamma)
            alphas.append(1 - factor)

        alphas = np.stack(
            (np.asarray(alphas[::-1]), np.asarray(deltas[::-1]))).transpose()
        gammas = np.stack(
            (np.asarray(alphas[::-1]), np.asarray(gammas[::-1]))).transpose()
        np.savetxt(data_output, alphas)
        np.savetxt(gamma_output, gammas)

    # Load JOREK gammas
    alphas_jor = [
        -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.25, 0.275, 0.3, 0.3125, 0.325,
        0.3375
    ]
    gammas_jor = np.asarray([
        0.000305073, 0.000216954, 0.000154881, 0.000110055, 7.14455e-5,
        3.94265e-5, 2.48401e-5, 1.77428e-5, 1.0663e-5, 7.15803e-6, 3.77522e-6,
        9.28732e-7
    ])
    gammas_jor /= 6.4836e-7
    np.savetxt(
        'gammas_jor_vs_alpha.dat',
        np.stack((np.asarray(alphas_jor), np.asarray(gammas_jor))).transpose())

    alphas_jor_8 = [0.0, 0.1, 0.2, 0.3]
    gammas_8 = np.asarray([41.701, 25.616, 12.98966, 2.5974])
    gammas_9 = np.asarray([6.809, 4.0393, 1.99651, 0.46058])

    # Load tm1 data
    tm1_data = np.loadtxt('gammas_tm1_vs_alpha.dat')

    # Multiply normalised solver gamma by density and resistivity
    eta = 1e-7 * 1.9382
    rho = 1e20 * 2 * 1.673 * 1e-27
    gammas[:, 1] *= eta**0.6 / rho**0.2
    np.savetxt('gammas_vs_alpha_si.dat', gammas)

    # Plot gammas
    fig, ax = plt.subplots(2, sharex=True)
    ax[0].plot(gammas[:, 0], gammas[:, 1], label='Linear')
    ax[0].scatter(gammas[:, 0], gammas[:, 1])
    ax[0].plot(alphas_jor, gammas_jor, label='JOREK')
    ax[0].scatter(alphas_jor, gammas_jor)
    ax[0].plot(tm1_data[:, 0], tm1_data[:, 1], label='TM1')
    ax[0].scatter(tm1_data[:, 0], tm1_data[:, 1])
    ax[0].set_ylabel('$\gamma\ [s^{-1}]$', fontsize=fontsize)
    ax[0].set_xlim([0.0, 1.0])
    ax[0].set_ylim([0.0, 250.0])
    ax[0].legend()

    gammas_interp = interpolate.interp1d(gammas[:, 0], gammas[:, 1])
    gammas_tm1_interp = interpolate.interp1d(tm1_data[:, 0], tm1_data[:, 1])
    ax[1].plot(alphas_jor,
               100 * np.abs(gammas_jor - gammas_interp(alphas_jor)) /
               gammas_interp(alphas_jor),
               label='JOREK vs. Linear',
               c='orange')
    ax[1].scatter(alphas_jor,
                  100 * np.abs(gammas_jor - gammas_interp(alphas_jor)) /
                  gammas_interp(alphas_jor),
                  c='orange')
    ax[1].plot(tm1_data[:, 0],
               100 * np.abs(tm1_data[:, 1] - gammas_interp(tm1_data[:, 0])) /
               gammas_interp(tm1_data[:, 0]),
               label='TM1 vs. Linear',
               c='g')
    ax[1].scatter(tm1_data[:, 0],
                  100 *
                  np.abs(tm1_data[:, 1] - gammas_interp(tm1_data[:, 0])) /
                  gammas_interp(tm1_data[:, 0]),
                  c='g')
    skipped_index_low = 3
    skipped_index_high = -3
    ax[1].plot(
        alphas_jor[skipped_index_low:skipped_index_high],
        100 * np.abs(gammas_jor[skipped_index_low:skipped_index_high] -
                     gammas_tm1_interp(
                         alphas_jor[skipped_index_low:skipped_index_high])) /
        gammas_tm1_interp(alphas_jor[skipped_index_low:skipped_index_high]),
        label='TM1 vs. JOREK',
        c='r')
    ax[1].scatter(
        alphas_jor[skipped_index_low:skipped_index_high],
        100 * np.abs(gammas_jor[skipped_index_low:skipped_index_high] -
                     gammas_tm1_interp(
                         alphas_jor[skipped_index_low:skipped_index_high])) /
        gammas_tm1_interp(alphas_jor[skipped_index_low:skipped_index_high]),
        c='r')
    ax[1].set_ylabel('Relative difference $[\%]$', fontsize=fontsize)
    ax[1].set_xlabel('$\\alpha$', fontsize=fontsize)
    ax[1].set_xlim([0.0, 0.4])
    plt.savefig('current_stability_gammas_{}'.format(m))
    plt.show()

    # Get equivalent JOREK and TM1 delta
    solver = TearingModeSolver(m,
                               r,
                               r_max,
                               B_theta,
                               B_z,
                               j_phi,
                               q,
                               num_pts,
                               delta=1e-12)
    deltas_jor = gammas_jor / 0.55 / (eta / PhysicalConstants.mu_0)**0.6
    deltas_jor /= (m * solver.r_to_B_theta(solver.r_instability) /
                   np.sqrt(PhysicalConstants.mu_0 * rho))**0.4
    deltas_jor /= (
        solver.r_to_q_deriv(solver.r_instability) /
        (solver.r_instability * solver.r_to_q(solver.r_instability)))**0.4
    deltas_jor = deltas_jor**(5.0 / 4.0)

    deltas_jor_8 = gammas_8 / 0.55 / (eta * 0.1 / PhysicalConstants.mu_0)**0.6
    deltas_jor_8 /= (m * solver.r_to_B_theta(solver.r_instability) /
                     np.sqrt(PhysicalConstants.mu_0 * rho))**0.4
    deltas_jor_8 /= (
        solver.r_to_q_deriv(solver.r_instability) /
        (solver.r_instability * solver.r_to_q(solver.r_instability)))**0.4
    deltas_jor_8 = deltas_jor_8**(5.0 / 4.0)

    deltas_jor_9 = gammas_9 / 0.55 / (eta * 0.01 / PhysicalConstants.mu_0)**0.6
    deltas_jor_9 /= (m * solver.r_to_B_theta(solver.r_instability) /
                     np.sqrt(PhysicalConstants.mu_0 * rho))**0.4
    deltas_jor_9 /= (
        solver.r_to_q_deriv(solver.r_instability) /
        (solver.r_instability * solver.r_to_q(solver.r_instability)))**0.4
    deltas_jor_9 = deltas_jor_9**(5.0 / 4.0)

    deltas_tm1 = tm1_data[:, 1] / 0.55 / (eta / PhysicalConstants.mu_0)**0.6
    deltas_tm1 /= (m * solver.r_to_B_theta(solver.r_instability) /
                   np.sqrt(PhysicalConstants.mu_0 * rho))**0.4
    deltas_tm1 /= (
        solver.r_to_q_deriv(solver.r_instability) /
        (solver.r_instability * solver.r_to_q(solver.r_instability)))**0.4
    deltas_tm1 = deltas_tm1**(5.0 / 4.0)

    # Plot equivalent gammas
    scaling = 1.05  # Factor to improve plot
    fig, ax = plt.subplots(1)
    ax.plot(deltas[:, 0], deltas[:, 1], label='Linear')
    ax.scatter(deltas[:, 0], deltas[:, 1])
    ax.plot(alphas_jor, deltas_jor, label='JOREK')
    ax.scatter(alphas_jor, deltas_jor)
    # ax.plot(alphas_jor_8, deltas_jor_8, label='JOREK $\Delta\'$ for $\eta=10^{-8}$')
    # ax.scatter(alphas_jor_8, deltas_jor_8)
    # ax.plot(alphas_jor_8, deltas_jor_9, label='JOREK $\Delta\'$ for $\eta=10^{-9}$')
    # ax.scatter(alphas_jor_8, deltas_jor_9)
    ax.plot(tm1_data[:, 0], deltas_tm1, label='TM1')
    ax.scatter(tm1_data[:, 0], deltas_tm1)
    ax.axhline(0.0, c='k', linestyle='--')
    ax.axvline(0.358,
               linestyle='--',
               color='grey',
               label='Linear stability boundary')
    ax.axvline(0.3375,
               linestyle='--',
               color='g',
               label='JOREK stability boundary')
    ax.axvline(0.35, linestyle='--', color='g')
    ax.fill_betweenx(scaling * deltas[:, 1],
                     0.3375,
                     0.35,
                     facecolor='green',
                     alpha=0.2)
    ax.set_ylabel('$\Delta\'$', fontsize=fontsize)
    ax.set_xlabel('$\\alpha$', fontsize=fontsize)
    ax.set_xlim([0.0, 1.0])
    ax.set_ylim([scaling * min(deltas[:, 1]), 22.0])
    ax.grid(linestyle='--')
    ax.legend()
    plt.savefig('current_stability_deltas_{}'.format(m))
    plt.show()
def enthalpy_form():
    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)
    markers = ["o", "x", "^", "v", "d"]

    all_data = []
    folder = "data/mc_hcp"
    for conc in concs:
        new_data = {}
        fname = "{}/thermo_{}.csv".format(folder, conc)
        T, conc, H_form = np.loadtxt(fname,
                                     delimiter=",",
                                     unpack=True,
                                     usecols=(0, 2, 3))
        new_data["T"] = T[1:]
        new_data["H"] = H_form[1:]
        new_data["conc"] = conc[1:]

        all_data.append(new_data)

    n_temps = len(all_data[0]["T"])
    Tmax = np.max(all_data[0]["T"])
    Tmin = np.min(all_data[0]["T"])
    for i in range(n_temps):
        T = all_data[0]["T"][i]
        form = []
        conc = []
        for dset in all_data:
            form.append(dset["H"][i])
            conc.append(dset["conc"][i])

        srt_indx = np.argsort(conc)
        conc = [conc[indx] for indx in srt_indx]
        form = [form[indx] for indx in srt_indx]
        conc.append(1.0)
        form.append(0.0)
        mapped_temp = (T - Tmin) / (Tmax - Tmin)

        ax.plot(conc,
                form,
                marker=markers[i % len(markers)],
                color=cm.copper(mapped_temp),
                label="{}K".format(T))
    ax.set_xlabel("Mg concentration")
    ax.set_ylabel("Enthalpy of formation (kJ/mol)")
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    #ax.legend()

    Z = [[0, 0], [0, 0]]
    fig_info = plt.figure()
    #temp_info = [np.min(T),np.max(T)]
    ax_info = fig_info.add_subplot(1, 1, 1)
    temp_info = np.linspace(Tmin, Tmax, 256)
    Cb_info = ax_info.contourf(Z, temp_info, cmap="copper")

    cbar = fig.colorbar(Cb_info,
                        orientation="horizontal",
                        ticks=[100, 300, 500, 700])
    cbar.ax.xaxis.set_ticks_position("top")
    cbar.ax.set_xticklabels([100, 300, 500, 700])
    cbar.ax.xaxis.set_label_position("top")

    #cbar.ax.tick_params(axis='x',direction='in',labeltop='on')
    cbar.set_label("Temperature (K)")
Beispiel #31
0
def get_random_plot(name, direc):
    """
    Random plot generation method.
    Inputs:
    name: (string) name of the plot which will be saved.
    Outputs:
    ax : (matplotlib obj) Matplotlib object of the axes of the plot
    fig : (matplotlib obj) Matplotlib object of the figure of the plot
    x, y : (list, list) Actuall x and y coordinates of the points.
    s : (list) sizes of the points.
    categories : (list) categories of the points.
    tick_size : (list) Tick size on the plot. [width, length]
    axes_x_pos, axes_y_pos: (float, float) Position of the labels of the axis.
    """

    # PLOT STYLE
    style = random.choice(styles)
    plt.style.use(style)

    # POINT DISTRIBUTION
    distribution = random.choice(point_dist)

    # RESOLUTION AND TICK SIZE
    dpi = int(dpi_min + np.random.rand(1)[0] * (dpi_max - dpi_min))
    figsize = (figsize_min + np.random.rand(2) *
               (figsize_max - figsize_min)).astype(int)
    tick_size = [(tick_size_width_min + np.random.rand(1)[0] *
                  (tick_size_width_max - tick_size_width_min)),
                 (tick_size_length_min + np.random.rand(1)[0] *
                  (tick_size_length_max - tick_size_length_min))]
    tick_size.sort()
    fig, ax = plt.subplots(figsize=figsize, dpi=dpi)

    # ACTUAL POINTS
    points_nb = int(points_nb_min + (np.random.rand(1)[0]**1.5) *
                    (points_nb_max - points_nb_min))
    #print points_nb
    x_scale = int(x_min_top + np.random.rand(1)[0] * (x_max_top - x_min_top))
    #print x_scale
    y_scale = int(y_min_top + np.random.rand(1)[0] * (y_max_top - y_min_top))
    #print y_scale
    x_scale_range = x_scale + int(np.random.rand(1)[0] * x_scale_range_max)
    #print x_scale_range
    y_scale_range = y_scale + int(np.random.rand(1)[0] * y_scale_range_max)
    #print y_scale_range
    x_min = (-np.random.rand(1)[0] + np.random.rand(1)[0]) * 10**(x_scale)
    x_max = (-np.random.rand(1)[0] +
             np.random.rand(1)[0]) * 10**(x_scale_range)
    x_min, x_max = min(x_min, x_max), max(x_min, x_max)
    y_min = (-np.random.rand(1)[0] + np.random.rand(1)[0]) * 10**(y_scale)
    y_max = (-np.random.rand(1)[0] +
             np.random.rand(1)[0]) * 10**(y_scale_range)
    y_min, y_max = min(y_min, y_max), max(y_min, y_max)

    if distribution == 'uniform':
        x = x_min + np.random.rand(points_nb) * (x_max - x_min)
        y = y_min + np.random.rand(points_nb) * (y_max - y_min)
    elif distribution == 'linear':
        x = x_min + np.random.rand(points_nb) * (x_max - x_min)
        y = x * (max(y_max, -y_min) / (max(x_max, -x_min))) * random.choice(
            [-1.0, 1.0]) + (y_min + np.random.rand(points_nb) *
                            (y_max - y_min)) * np.random.rand(1)[0] / 2.0
    elif distribution == 'quadratic':
        x = x_min + np.random.rand(points_nb) * (x_max - x_min)
        y = x**2 * (1.0 / (max(x_max, -x_min)))**2 * max(
            y_max, -y_min) * random.choice(
                [-1.0, 1.0]) + (y_min + np.random.rand(points_nb) *
                                (y_max - y_min)) * np.random.rand(1)[0] / 2.0

    # POINTS VARIATION
    nb_points_var = 1 + int(np.random.rand(1)[0] * max_points_variations)
    nb_points_var_colors = 1 + int(np.random.rand(1)[0] * nb_points_var)
    nb_points_var_markers = 1 + int(
        np.random.rand(1)[0] * (nb_points_var - nb_points_var_colors))
    nb_points_var_size = max(
        1, 1 + nb_points_var - nb_points_var_colors - nb_points_var_markers)

    rand_color_number = np.random.rand(1)[0]
    if rand_color_number <= 0.5:
        colors = cm.rainbow(np.random.rand(nb_points_var_colors))
    elif rand_color_number > 0.5 and rand_color_number <= 0.7:
        colors = cm.gnuplot(np.random.rand(nb_points_var_colors))
    elif rand_color_number > 0.7 and rand_color_number <= 0.8:
        colors = cm.copper(np.random.rand(nb_points_var_colors))
    else:
        colors = cm.gray(np.linspace(0, 0.6, nb_points_var_colors))
    s_set = (size_points_min + np.random.rand(nb_points_var_size) *
             (size_points_max - size_points_min))**2
    markers_subset = list(np.random.choice(markers,
                                           size=nb_points_var_markers))
    markers_empty = np.random.rand(1)[0] > 0.75
    markers_empty_ratio = random.choice([0.0, 0.5, 0.7])

    # BUILDING THE PLOT
    s = []
    categories = []
    cat_dict = {}
    index_cat = 0

    for _x, _y, in zip(x, y):
        s_ = random.choice(s_set)
        c_ = random.choice(colors)
        m_ = random.choice(markers_subset)
        if m_ in markers_with_full and markers_empty:
            e_ = np.random.rand(1)[0] > markers_empty_ratio
        else:
            e_ = False
        cat = [s_, c_, m_, e_]

        if cat_in_dict(cat, cat_dict) is False:
            cat_dict[index_cat] = cat
            index_cat += 1
        categories.append(cat_in_dict(cat, cat_dict))
        s.append(s_)
        if e_:
            plt.scatter(_x, _y, s=s_, color=c_, marker=m_, facecolors='none')

        else:
            plt.scatter(_x, _y, s=s_, color=c_, marker=m_)

    # PAD BETWEEN TICKS AND LABELS
    #labs = [item.get_text() for item in ax.get_xticklabels()]
    #print labs
    pad_x = max(tick_size[1] + 0.5,
                int(pad_min + np.random.rand(1)[0] * (pad_max - pad_min)))
    pad_y = max(tick_size[1] + 0.5,
                int(pad_min + np.random.rand(1)[0] * (pad_max - pad_min)))
    direction_ticks_x = random.choice(direction_ticks)
    direction_ticks_y = random.choice(direction_ticks)

    # NON-DEFAULT TICKS PROB, WITH THRESHOLD OF 0.6
    weid_ticks_prob = np.random.rand(1)[0]

    # TICKS STYLE AND LOCATION (X AXIS)
    if np.random.rand(1)[0] > 0.5:
        axes_x_pos = 1
        ax.xaxis.tick_top()
        ax.xaxis.set_label_position("top")
        if weid_ticks_prob > 0.6:
            ax.xaxis.set_tick_params(width=tick_size[0],
                                     length=tick_size[1],
                                     color='black',
                                     pad=pad_x,
                                     direction=direction_ticks_x,
                                     bottom=np.random.rand(1)[0] > 0.5,
                                     top=True)
        else:
            ax.xaxis.set_tick_params(bottom=np.random.rand(1)[0] > 0.5,
                                     top=True)
        if np.random.rand(1)[0] > 0.5:
            ax.spines['bottom'].set_visible(False)
            ax.xaxis.set_tick_params(bottom=False)
            if np.random.rand(1)[0] > 0.5:
                axes_x_pos = np.random.rand(1)[0]
                ax.spines['top'].set_position(('axes', axes_x_pos))
    else:
        axes_x_pos = 0
        if weid_ticks_prob > 0.6:
            ax.xaxis.set_tick_params(width=tick_size[0],
                                     length=tick_size[1],
                                     color='black',
                                     pad=pad_x,
                                     direction=direction_ticks_x,
                                     bottom=True,
                                     top=np.random.rand(1)[0] > 0.5)
        else:
            ax.xaxis.set_tick_params(bottom=True,
                                     top=np.random.rand(1)[0] > 0.5)
        if np.random.rand(1)[0] > 0.5:
            ax.spines['top'].set_visible(False)
            ax.xaxis.set_tick_params(top=False)
            if np.random.rand(1)[0] > 0.5:
                axes_x_pos = np.random.rand(1)[0]
                ax.spines['bottom'].set_position(('axes', axes_x_pos))

    # TICKS STYLE AND LOCATION (Y AXIS)
    if np.random.rand(1)[0] > 0.5:
        axes_y_pos = 1
        ax.yaxis.tick_right()
        ax.yaxis.set_label_position("right")
        if weid_ticks_prob > 0.6:
            ax.yaxis.set_tick_params(width=tick_size[0],
                                     length=tick_size[1],
                                     color='black',
                                     pad=pad_y,
                                     direction=direction_ticks_y,
                                     left=np.random.rand(1)[0] > 0.5,
                                     right=True)
        else:
            ax.yaxis.set_tick_params(left=np.random.rand(1)[0] > 0.5,
                                     right=True)
        if np.random.rand(1)[0] > 0.5:
            ax.spines['left'].set_visible(False)
            ax.yaxis.set_tick_params(left=False)
            if np.random.rand(1)[0] > 0.5:
                axes_y_pos = np.random.rand(1)[0]
                ax.spines['right'].set_position(('axes', axes_y_pos))
    else:
        axes_y_pos = 0
        if weid_ticks_prob > 0.6:
            ax.yaxis.set_tick_params(width=tick_size[0],
                                     length=tick_size[1],
                                     color='black',
                                     pad=pad_y,
                                     direction=direction_ticks_y,
                                     left=True,
                                     right=np.random.rand(1)[0] > 0.5)
        else:
            ax.yaxis.set_tick_params(left=True,
                                     right=np.random.rand(1)[0] > 0.5)
        if np.random.rand(1)[0] > 0.5:
            ax.spines['right'].set_visible(False)
            ax.yaxis.set_tick_params(right=False)
            if np.random.rand(1)[0] > 0.5:
                axes_y_pos = np.random.rand(1)[0]
                ax.spines['left'].set_position(('axes', axes_y_pos))

    # LABEL ROTATION
    if np.random.rand(1)[0] > 0.77:
        plt.xticks(rotation=int(np.random.rand(1)[0] * 90))
    if np.random.rand(1)[0] > 0.77:
        plt.yticks(rotation=int(np.random.rand(1)[0] * 90))

    # SUB-TICKs
    if weid_ticks_prob > 0.6:
        color_subtick = random.choice(color_subtick_list)
        length_subtick = 0.75 * np.random.rand(1)[0] * tick_size[1]
        if np.random.rand(1)[0] > 0.7:
            minorLocator = AutoMinorLocator()
            ax.xaxis.set_minor_locator(minorLocator)
            ax.xaxis.set_tick_params(which='minor',
                                     length=length_subtick,
                                     direction=direction_ticks_x,
                                     color=color_subtick,
                                     bottom=ax.spines['bottom'].get_visible(),
                                     top=ax.spines['top'].get_visible())
        if np.random.rand(1)[0] > 0.7:
            minorLocator = AutoMinorLocator()
            ax.yaxis.set_minor_locator(minorLocator)
            ax.yaxis.set_tick_params(which='minor',
                                     length=length_subtick,
                                     direction=direction_ticks_y,
                                     color=color_subtick,
                                     left=ax.spines['left'].get_visible(),
                                     right=ax.spines['right'].get_visible())

    # FONT AND SIZE FOR LABELS (tick labels, axes labels and title)
    font = random.choice(font_list)
    size_ticks = int(tick_label_size_min + np.random.rand(1)[0] *
                     (tick_label_size_max - tick_label_size_min))
    size_axes = int(axes_label_size_min + np.random.rand(1)[0] *
                    (axes_label_size_max - axes_label_size_min))
    size_title = int(title_size_min + np.random.rand(1)[0] *
                     (title_size_max - title_size_min))
    ticks_font = font_manager.FontProperties(fname=font,
                                             style='normal',
                                             size=size_ticks,
                                             weight='normal',
                                             stretch='normal')
    axes_font = font_manager.FontProperties(fname=font,
                                            style='normal',
                                            size=size_axes,
                                            weight='normal',
                                            stretch='normal')
    title_font = font_manager.FontProperties(fname=font,
                                             style='normal',
                                             size=size_title,
                                             weight='normal',
                                             stretch='normal')

    # TEXTS FOR AXIS LABELS AND TITLE
    label_x_length = int(axes_label_length_min + np.random.rand(1)[0] *
                         (axes_label_length_max - axes_label_length_min))
    #print label_x_length
    label_y_length = int(axes_label_length_min + np.random.rand(1)[0] *
                         (axes_label_length_max - axes_label_length_min))
    title_length = int(title_length_min + np.random.rand(1)[0] *
                       (title_length_max - title_length_min))
    x_label = ("".join([
        random.choice(string.ascii_letters + '       ')
        for i in range(label_x_length)
    ])).strip()
    #print x_label
    y_label = ("".join([
        random.choice(string.ascii_letters + '       ')
        for i in range(label_y_length)
    ])).strip()
    title = ("".join([
        random.choice(string.ascii_letters + '       ')
        for i in range(title_length)
    ])).strip()
    plt.xlabel(x_label, fontproperties=axes_font)
    plt.ylabel(y_label, fontproperties=axes_font, color='black')
    if axes_x_pos == 1:
        plt.title(title, fontproperties=title_font, color='black', y=1.1)
    else:
        plt.title(title, fontproperties=title_font, color='black')

    for label in ax.get_xticklabels():
        label.set_fontproperties(ticks_font)

    for label in ax.get_yticklabels():
        label.set_fontproperties(ticks_font)

    # GRID
    if np.random.rand(1)[0] > 0.7:
        plt.grid(b=True,
                 which='major',
                 color=random.choice(color_grid),
                 linestyle=random.choice(linestyles))

    # AXIS LIMITS
    xmin = min(x)
    xmax = max(x)
    deltax = 0.05 * abs(xmax - xmin)
    plt.xlim(xmin - deltax, xmax + deltax)
    ymin = min(y)
    ymax = max(y)
    deltay = 0.05 * abs(ymax - ymin)
    plt.ylim(ymin - deltay, ymax + deltay)

    # BACKGROUND AND PATCH COLORS
    if np.random.rand(1)[0] > 0.75:
        color_bg = (1 - colorbg_transparant_max
                    ) + colorbg_transparant_max * np.random.rand(3)
        ax.set_axis_bgcolor(color_bg)
    if np.random.rand(1)[0] > 0.75:
        color_bg = (1 - colorbg_transparant_max
                    ) + colorbg_transparant_max * np.random.rand(3)
        fig.patch.set_facecolor(color_bg)

    # MAKE SURE THE PLOT FITS INSIDE THE FIGURES
    try:
        plt.tight_layout()

        plt.savefig("./data/{}/".format(direc) + name,
                    dpi='figure',
                    facecolor=fig.get_facecolor())
    except RuntimeError:
        pass

    return ax, fig, x, y, s, categories, tick_size, axes_x_pos, axes_y_pos
Beispiel #32
0
def main():
    ''' set paths & parameters '''
    # Parse information from the command line
    parser = argparse.ArgumentParser(prog='LES_CP')
    parser.add_argument("casename")
    parser.add_argument("path_root")
    parser.add_argument("path1")
    parser.add_argument("path2")
    parser.add_argument("path_out")
    parser.add_argument("--tmin")
    parser.add_argument("--tmax")
    parser.add_argument("--kmax")
    parser.add_argument("--everysecond")
    args = parser.parse_args()

    set_input_parameters(args)
    # ic_arr, jc_arr = define_geometry(nml)
    if args.everysecond:
        every_second = args.everysecond
    else:
        every_second = True
    print('every_second', every_second)

    file_name = 'stats_radial_averaged.nc'
    file1 = nc.Dataset(os.path.join(path1, 'data_analysis', file_name))
    file2 = nc.Dataset(os.path.join(path2, 'data_analysis', file_name))

    dx1 = file1.groups['dimensions'].dimensions['dx'].size
    dx2 = file2.groups['dimensions'].dimensions['dx'].size
    dz1 = file1.groups['dimensions'].dimensions['dz'].size
    dz2 = file2.groups['dimensions'].dimensions['dz'].size
    if dx1 < dx2:  # want to have file2 higher resolution
        file_aux = file2
        file2 = file1
        file1 = file_aux
        del file_aux
    print('dx: ', dx1_nml[0], dx2_nml[0], dx1)
    print('dz: ', dx1_nml[2], dx2_nml[2], dz1)
    print('nx: ', nx1[0], nx2[0])
    print('nz: ', nx1[2], nx2[2])

    grp_stats1 = file1.groups['stats'].variables
    grp_stats2 = file2.groups['stats'].variables

    time1 = file1.groups['timeseries'].variables['time'][:]
    time2 = file2.groups['timeseries'].variables['time'][:]
    print('times: ')
    print time1
    print time2
    nt = np.minimum(len(time1), len(time2))
    time1 = time1[:nt]
    time2 = time2[:nt]
    if len(time1) != len(time2):
        time1 = time1[:nt]
        time2 = time2[:nt]
    if time1.any() != time2.any():
        print 'problem with times'
        sys.exit()

    r1 = file1.groups['stats'].variables['r'][:]
    r2 = file2.groups['stats'].variables['r'][:]
    ri1 = file1.groups['stats'].variables['ri'][:]
    ri2 = file2.groups['stats'].variables['ri'][:]

    try:
        krange1 = file1.groups['dimensions'].variables['krange'][:]
        krange2 = file2.groups['dimensions'].variables['krange'][:]
    except:
        krange1 = np.arange(kmax)
        krange2 = np.arange(kmax)
    print ''
    print 'kranges:'
    print krange1
    print krange2

    if dz1 > dz2:
        print 'dz1 > dz2'
        dz12 = np.double(dz1) / dz2
        kmax_ = np.int(
            np.minimum(np.int(np.round(kmax / dz12)),
                       len(krange2) / dz12))
        krange1 = krange1[:kmax_]
        krange2 = krange2[0::np.int(dz12)]
    elif dz1 < dz2:
        print 'dz1 < dz2'
        dz12 = np.double(dz2) / dz1
        kmax_ = np.int(np.round(kmax / dz12))
        krange1 = krange1[0::2]
        krange2 = krange2[:kmax_]
    else:
        dz12 = 1.
        kmax_ = kmax

    print('')
    print 'dz: ', dz1, dz2, dz12
    print 'kmax: ', kmax, kmax_
    print krange1
    print krange2
    print 'zranges:'
    print krange1 * dz1
    print krange2 * dz2

    var_list = ['w', 'v_rad', 's']
    ncol = len(var_list)
    rmax = 8e3
    irmax1 = np.where(r1 == rmax)[0]
    irmax2 = np.where(r2 == rmax)[0]
    # irmax1 = -1
    # irmax2 = -1
    print ''
    print r1[-1], r2[-1]
    print 'irmax: ', irmax1, irmax2
    print 'rmax', r1[irmax1], r2[irmax2]
    print ''

    for k0 in range(kmax_):
        k1 = krange1[k0]
        k2 = krange2[k0]
        print('z1, z2: ', k1 * dz1, k2 * dz2)
        fig_name = 'radial_average_z' + str(k1 * dz1) + '.png'
        fig, axes = plt.subplots(1, ncol, sharey='none', figsize=(7 * ncol, 5))
        for i, ax in enumerate(axes):
            var1 = grp_stats1[var_list[i]][:, :, :]
            var2 = grp_stats2[var_list[i]][:, :, :]
            if var_list[i] == 'w':
                ax.set_ylim(
                    -6,
                    np.maximum(np.amax(var1[:, :, k0]), np.amax(var2[:, :,
                                                                     k0])))

            if every_second == True:
                for it, t0 in enumerate(time1[1::2]):
                    # print('- t='+str(t0))
                    count_color = 2 * np.double(it) / len(time1)
                    if it == 0:
                        ax.plot(r1[:irmax1],
                                var1[2 * it + 1, :irmax1, k1],
                                color=cm.copper(count_color),
                                linewidth=3,
                                label='t=' + str(t0) + ', dx=' + str(dx1))
                    else:
                        ax.plot(r1[:irmax1],
                                var1[2 * it + 1, :irmax1, k1],
                                color=cm.copper(count_color),
                                linewidth=3,
                                label='t=' + str(t0))
                for it, t0 in enumerate(time1[1::2]):
                    #print('t=' + str(t0))
                    count_color = 2 * np.double(it) / len(time1)
                    if it == 0:
                        ax.plot(r2[:irmax2],
                                var2[2 * it + 1, :irmax2, k2],
                                '-',
                                color=cm.jet(count_color),
                                linewidth=3,
                                label='dx=' + str(dx2))
                    else:
                        # ax.plot(r2[:irmax2], )
                        ax.plot(r2[:irmax2],
                                var2[2 * it + 1, :irmax2, k2],
                                '-',
                                color=cm.jet(count_color),
                                linewidth=2,
                                label='dx=' + str(dx2))
            else:
                for it, t0 in enumerate(time1):
                    print('t=' + str(t0))
                    count_color = np.double(it) / len(time1)
                    if it == 0:
                        ax.plot(r1[:irmax1],
                                var1[it, :irmax1, k1],
                                color=cm.copper(count_color),
                                linewidth=3,
                                label='t=' + str(t0) + ', dx=' + str(dx1))
                    else:
                        ax.plot(r1[:irmax1],
                                var1[it, :irmax1, k1],
                                color=cm.copper(count_color),
                                linewidth=3,
                                label='t=' + str(t0))
                for it, t0 in enumerate(time1):
                    print('t=' + str(t0))
                    count_color = np.double(it) / len(time1)
                    if it == 0:
                        ax.plot(r2[:irmax2],
                                var2[it, :irmax2, k2],
                                '-',
                                color=cm.jet(count_color),
                                linewidth=2,
                                label='dx=' + str(dx2))
                    else:
                        ax.plot(r2[:irmax2],
                                var2[it, :irmax2, k2],
                                '-',
                                color=cm.jet(count_color),
                                linewidth=2,
                                label='dx=' + str(dx2))
            ax.set_title(var_list[i])
            ax.set_xlabel('radius r  [m]')
            ax.set_ylabel(var_list[i])
        axes[2].legend(loc='upper center',
                       bbox_to_anchor=(1.15, 0.8),
                       fancybox=True,
                       ncol=2,
                       fontsize=8)
        # plt.tight_layout()
        plt.subplots_adjust(bottom=0.12,
                            right=.9,
                            left=0.04,
                            top=0.9,
                            wspace=0.15)
        fig.suptitle('Radially averaged variables   (k=' + str(k0) + ')')
        fig.savefig(os.path.join(path_out_figs, fig_name))
        plt.close(fig)

    file1.close()
    file2.close()

    return
def few_Vm_fig(SET_OF_DATA,
               pop_key='Exc',
               tspace=200.,
               tzoom=[200, np.inf],
               VMS1=np.arange(3),
               VMS2=None,
               Tbar=100,
               Vbar=10,
               Vshift=30,
               vpeak=-42,
               vbottom=-80):

    fig, ax = plt.subplots(figsize=(5 * len(SET_OF_DATA), 5))
    # plt.subplots_adjust(left=.15, bottom=.1, right=.99)

    if VMS2 is None:
        VMS2 = VMS1  # ID of cells

    t0 = 0
    for k, data in enumerate(SET_OF_DATA):
        VMS = [VMS1, VMS2][k]
        t = np.arange(int(data['tstop'] / data['dt'])) * data['dt']
        cond = (t > tzoom[0]) & (t < tzoom[1])
        for i, j in enumerate(VMS):
            ax.plot(t[cond]+t0, data['VMS_'+str(pop_key)][j][cond]+Vshift*i,\
                    color=copper(i/len(VMS)/1.5), lw=1)
            ax.plot(t[cond] + t0,
                    0 * t[cond] + -70 + Vshift * i,
                    ':',
                    color=copper(i / len(VMS) / 1.5),
                    lw=1)
            ax.plot([t[cond][0] + t0], [-70 + Vshift * i],
                    '>',
                    color=copper(i / len(VMS) / 1.5))
        # adding spikes
        for i, j in enumerate(VMS):
            tspikes = data['tRASTER_' + str(pop_key)][np.argwhere(
                data['iRASTER_' + str(pop_key)] == j).flatten()]
            cond = (tspikes > tzoom[0]) & (tspikes < tzoom[1])
            for ts in tspikes[cond]:
                ax.plot([ts + t0, ts + t0],
                        Vshift * i + np.array([-50, vpeak]),
                        '--',
                        color=copper(i / len(VMS) / 1.5),
                        lw=1)
        t0 = tspace + tzoom[1] - tzoom[0]

    ax.plot([tzoom[0], tzoom[0] + Tbar],
            ax.get_ylim()[0] * np.ones(2),
            lw=5,
            color='gray')
    ax.annotate(str(Tbar) + 'ms', (tzoom[0], .9 * ax.get_ylim()[0]),
                fontsize=14)
    ax.plot(tzoom[1] * np.ones(2), [-60, -60 + Vbar], lw=5, color='gray')
    ax.annotate(str(Vbar) + 'mV', (tzoom[1], -60), fontsize=14)
    ax.annotate('-70mV', (tzoom[1], -70), fontsize=14)
    set_plot(ax, [], xticks=[], yticks=[])

    c = plt.axes([.5, .5, .01, .2])
    cmap = mpl.colors.ListedColormap(copper(np.linspace(0, 1 / 1.5,
                                                        len(VMS1))))
    cb = mpl.colorbar.ColorbarBase(c, cmap=cmap, orientation='vertical')
    cb.set_label('Cell ID', fontsize=12)
    cb.set_ticks([])
    return fig
import numpy as np
import scipy as sp
from matplotlib.widgets import Slider
from matplotlib.colors import Normalize
from matplotlib import cm
import matplotlib.pyplot as pl

sizes = np.array([128, 256, 512, 1024, 2048])
data = -np.array([np.loadtxt("./df-hist-raw-%i.txt" % i) for i in sizes])
dev = np.array([91.0 / 48 - d.mean() for d in data])
std = np.array([d.std() for d in data])

colors = cm.copper(Normalize()(np.arange(len(dev))))

x, y = [], []
for t in data:
    ty, tx = np.histogram(t, bins=24, normed=True)
    x.append((tx[1:] + tx[:-1]) / 2)
    y.append(ty)
x = np.array(x).T
y = np.array(y).T


def rescale(sizes, xs, ys, dfc, tau):
    return (dfc - xs) * sizes ** tau, ys * sizes ** -tau


def plotall():
    """
    Note: to save, use dpi=300 to match other plots
    """
import numpy as np
import scipy as sp
from matplotlib.widgets import Slider
from matplotlib.colors import Normalize
from matplotlib import cm
import matplotlib.pyplot as pl

sizes = np.array([128, 256, 512, 1024, 2048])
data = -np.array([np.loadtxt("./df-hist-raw-%i.txt" % i) for i in sizes])
dev = np.array([91. / 48 - d.mean() for d in data])
std = np.array([d.std() for d in data])

colors = cm.copper(Normalize()(np.arange(len(dev))))

x, y = [], []
for t in data:
    ty, tx = np.histogram(t, bins=24, normed=True)
    x.append((tx[1:] + tx[:-1]) / 2)
    y.append(ty)
x = np.array(x).T
y = np.array(y).T


def rescale(sizes, xs, ys, dfc, tau):
    return (dfc - xs) * sizes**tau, ys * sizes**-tau


def plotall():
    """
    Note: to save, use dpi=300 to match other plots
    """
def plot_frequency_statistics():
    folder = "data/almgsi_ch500K_run_truncnorm/postproc"
    folder = "/work/sophus/almgsi_ch500K_run2/postproc"
    fnames = [
        "chgl_50_frequency_statistics.csv", "chgl_40_frequency_statistics.csv",
        "chgl_30_frequency_statistics.csv", "chgl_20_frequency_statistics.csv",
        "chgl_10_frequency_statistics.csv"
    ]

    fnames = [folder + "/" + f for f in fnames]

    concs = [0.5, 0.4, 0.3, 0.2, 0.1]
    orig_concs = deepcopy(concs)

    fig = plt.figure()
    ax = fig.add_subplot(1, 1, 1)

    freqs = []
    profiles = []
    markers = ['o', 'd', 'v', '^', 'h', 'p']

    concs = np.array(concs)
    concs -= np.min(concs)
    concs /= np.max(concs)
    col = 1

    if col == 2:
        print("Plotting second moment of distribution")
    elif col == 1:
        print("Plotting first moment of distribution")
    else:
        raise ValueError("col has to be 1 or 2")

    for i, fname in enumerate(fnames):
        data = np.loadtxt(fname, delimiter=",")
        freqs.append(data[:, 0])
        profiles.append(data[:, col])
        ax.plot(data[:, 0],
                data[:, col],
                markers[i],
                mfc="none",
                color=cm.copper(concs[i]),
                ms=8,
                markeredgewidth=1.5,
                label="{}%".format(int(100 * orig_concs[i])))

    # Fit a linear line to beginning
    slope, interscept, _, _, _ = linregress(np.log(freqs[0][:12]),
                                            np.log(profiles[0][:12]))

    print("Slope (exponent)", slope)
    freq_fit = np.logspace(-1.5, 3, 10)
    ax.plot(freq_fit,
            np.exp(interscept) * freq_fit**slope,
            ls='--',
            color="#5d5C61")
    ax.set_xscale("log")
    ax.set_yscale("log", basey=2)
    ax.set_xlabel("Dimensionless time")
    ax.set_ylabel("Frequency (nm\$^{-1}\$)")
    ax.spines["right"].set_visible(False)
    ax.spines["top"].set_visible(False)
    ax.legend(frameon=False)
    plt.show()
def get_stability_condition(plot_results=True):
    current_factors = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
    colors = cm.copper(np.linspace(0.0, 1.0, len(current_factors)))

    # Get profiles
    dat = np.loadtxt(os.path.join('input_profiles.dat'))

    # Modify and plot input profiles
    r = dat[:, 0]
    R = dat[:, 1]
    j_phi = dat[:, 2]
    B_z = dat[:, 3]
    B_theta = dat[:, 4]
    psi_n = dat[:, 5]
    r_to_psin = interpolate.interp1d(r, psi_n)
    psin_to_r = interpolate.interp1d(r, psi_n)

    q = r * B_z / (R * B_theta)
    q[0] = q[1]
    if plot_results:
        fig, ax = plt.subplots(2, 2, figsize=(10, 10), sharex=True)

        ax[0, 0].plot(r, B_z, c='k')
        ax[0, 0].set_ylabel('$B_{\phi}$ [T]', fontsize=fontsize)
        ax[1, 0].plot(r, B_theta, c='k')
        ax[1, 0].set_ylabel('$B_{\\theta}$ [T]', fontsize=fontsize)
        for i, factor in enumerate(current_factors[::-1]):
            linestyle = '--' if i > 0 else '-'
            ax[0, 1].plot(r,
                          factor * j_phi * 1e-3,
                          linestyle=linestyle,
                          c=colors[i])
        ax[0, 1].set_ylabel('$j_{\phi}$ [kA]', fontsize=fontsize)
        ax[1, 1].plot(r, q, c='k')
        ax[1, 1].set_ylabel('q', fontsize=fontsize)
        ax[1, 1].set_xlabel('r [m]', fontsize=fontsize)
        ax[1, 0].set_xlabel('r [m]', fontsize=fontsize)
        ax[0, 0].set_xlim([0.0, 1.0])
        fig.tight_layout()
        plt.savefig('input_profiles')
        plt.show()

    r_max = r[-1]
    deltas = list()
    alphas = list()
    for factor in current_factors:
        j_phi_sim = j_phi * factor

        solver = TearingModeSolver(m,
                                   r,
                                   r_max,
                                   B_theta,
                                   B_z,
                                   j_phi_sim,
                                   q,
                                   num_pts,
                                   delta=1e-12)
        solver.find_delta(plot_output=False)

        psin_lower = r_to_psin(solver.r_lower)
        psin_upper = r_to_psin(solver.r_upper)

        if plot_results:
            fig, ax = plt.subplots(2, sharex=True)
            ax[0].plot(psin_lower,
                       solver.psi_sol_lower[:, 0],
                       label='solution from axis')
            ax[0].plot(psin_upper,
                       solver.psi_sol_upper[:, 0],
                       label='solution from boundary')

            # Plot comparison solution if it exists
            validation_file = 'flux_validation_vc_{}.csv'.format(factor)
            if os.path.exists(validation_file):
                flux_validation = np.loadtxt(validation_file, delimiter=',')
                flux_validation[:, 1] /= np.max(flux_validation[:, 1])
                flux_validation[:, 1] *= np.max(solver.psi_sol_lower[:, 0])
                ax[0].plot(flux_validation[:, 0],
                           flux_validation[:, 1],
                           linestyle='--',
                           label='JOREK')

            ax[0].set_ylabel('$\Psi_1$', fontsize=fontsize)
            ax[0].legend()
            ax[0].set_xlim([0.0, 1.0])

            ax[1].plot(psin_lower, solver.psi_sol_lower[:, 1])
            ax[1].plot(psin_upper, solver.psi_sol_upper[:, 1])
            ax[1].set_ylabel('$\\frac{\partial \Psi_1}{\partial r}$',
                             fontsize=fontsize)
            ax[1].set_xlabel('$\hat \Psi$', fontsize=fontsize)
            plt.show()

        deltas.append(solver.delta)
        alphas.append(1 - factor)

    np.savetxt('deltas', np.asarray(deltas))

    plt.figure()
    plt.plot(alphas, deltas)
    plt.axvline(0.346,
                linestyle='--',
                color='grey',
                label='Linear stability boundary')
    plt.axvline(0.25,
                linestyle='--',
                color='g',
                label='JOREK stability boundary')
    plt.grid(linestyle='--')
    plt.ylabel('$\Delta\'$', fontsize=fontsize)
    plt.xlabel('$\\alpha$', fontsize=fontsize)
    plt.legend()
    plt.xlim([0.0, 1.0])
    plt.savefig('current_stability_{}'.format(m))
    plt.show()
def main():
    args = parse_args()
    q_mean, p_mean, Q, P, W = prepare_data(args)
    no_steps = Q.shape[0]
    q_min = Q[:,0,0].min()
    q_max = Q[:,0,-1].max()
    p_min = P[:,0,0].min()
    p_max = P[:,-1,0].max()
    if args.vmin[-1]=="%":
        W_min = numpy.percentile(W[:], float(args.vmin[:-1]))
    else:
        W_min = float(args.vmin)
    if args.vmax[-1]=="%":
        W_max = numpy.percentile(W[:], 100.-float(args.vmax[:-1]))
    else:
        W_max = float(args.vmax)
    midpoint = 1 - W_max/(W_max + abs(W_min))
    cmap = shifted_color_map(cm.coolwarm, midpoint=midpoint, name="shifted")
    fig = pyplot.figure()
    ax = fig.add_subplot(1,1,1)
    ax.set_xlim(q_min, q_max)
    ax.set_ylim(p_min, p_max)
    ax.set_xlabel("q")
    ax.set_ylabel("p")
    if args.visualization=="polished":
        shading="gouraud"
    else:
        shading="flat"
    quad = QuadContainer(ax.pcolormesh(Q[0], P[0], W[0],
                                       vmin=W_min, vmax=W_max,
                                       cmap=cmap,
                                       shading=shading))
    ax.set_aspect("equal")
    if args.track:
        ax.set_color_cycle([cm.copper(1.*i/(no_steps-1)) for i in range(no_steps-1)])
        for i in range(no_steps-1):
            ax.plot(q_mean[i:i+2],p_mean[i:i+2], alpha=.3)
    cb = fig.colorbar(quad.quad)
    cb.set_label("Quasiprobability Density")
    cb.solids.set_rasterized(True)
    if args.visualization=="polished":
        ax.set_axis_bgcolor(cb.to_rgba(0.))
    no_digits = int(ceil(log10(no_steps))+1)
    title_string = "Wigner Function at step {:{width}}/{:{width}}"
    title = ax.set_title(title_string.format(0, no_steps, width=no_digits))
    ax.grid(True)
    if args.output:
        fig.savefig(args.output+"_thumb.pdf")
    def animate(i):
        title.set_text(title_string.format(i, no_steps, width=no_digits))
        quad.update_quad(ax.pcolormesh(Q[i], P[i], W[i],
                                       vmin=W_min, vmax=W_max,
                                       cmap=cmap,
                                       shading=shading))
        ax.grid(True)
        return quad.quad,
    ani = FuncAnimation(fig, animate, no_steps, interval=100, repeat_delay=1000)
    if args.output:
        print("Saving movie to {}. This may take a couple of minutes.".format(args.output))
        ani.save(args.output+".mp4", fps=10, extra_args=['-vcodec', 'libx264'])
    pyplot.show()