Esempio n. 1
0
def analyze_matlab(
        data     = None  ,
        camname  = None  ,
        oimg     = None  ,
        rect     = None  ,
        fitpts   = None  ,
        roiaxes  = None  ,
        plotaxes = None  ,
        verbose  = False ,
        uid      = None
        ):

    plt.close()
    # ======================================
    # Log inputs
    # ======================================
    frame = inspect.currentframe()
    args, temp, temp, values = inspect.getargvalues(frame)
    
    logger.log(level=1, msg='Input values:')
    for i, arg in enumerate(args):
        # pdb.set_trace()
        logger.log(level=1, msg='Arg name: {}, arg value: {}'.format(arg, values[arg]))

    logger.log(level=1, msg='Rectangle: x0: {}, y0: {}, x1: {}, y1: {}, width: {}, height: {}'.format(
        rect.x0           ,
        rect.y0           ,
        rect.x1           ,
        rect.y1           ,
        rect.get_width()  ,
        rect.get_height()
        )
        )
    
    # ======================================
    # Load and transfer matlab variables
    # ======================================
    # if (f is None):
    #         infile     = 'forpython.mat'
    #         f          = h5.File(infile);
    f = data.file

    if data is None:
        data       = f['data']

    if camname is None:
        camname = f['camname']
        camname = mt.derefstr(camname)

    # if imgnum is None:
    #         imgnum = f['imgnum'][0, 0]

    imgstr = data['raw']['images'][str(camname)]
    res    = imgstr['RESOLUTION'][0, 0]
    res    = res*1.0e-6

    # ======================================
    # Quadrupole set point
    # ======================================
    raw_rf     = data['raw']
    scalars_rf = raw_rf['scalars']
    setQS_str  = scalars_rf['step_value']
    setQS_dat  = E200.E200_api_getdat(setQS_str, uid).dat[0]
    setQS = mt.hardcode.setQS(setQS_dat)
    logger.info('setQS_dat is: {}'.format(setQS_dat))
    # logger.debug('setQS_dat type is: {}'.format(type(setQS_dat)))
    
    # ======================================
    # Bend magnet strength
    # ======================================
    B5D36     = data['raw']['scalars']['LI20_LGPS_3330_BDES']['dat']
    B5D36     = mt.derefdataset(B5D36, f)
    B5D36_en  = B5D36[0]
    # new_en    = (B5D36_en-4.3)
    gamma     = (B5D36_en/0.5109989)*1e3
    # new_gamma = (new_en/0.5109989)*1e3
    
    # ======================================
    # Translate into script params
    # ======================================
    n_rows    = 5
    if rect is None:
        xstart = 275
        xstop  = 325
        ystart = 1870
        ystop  = 1900
    else:
        xstart = rect.y0
        xstop  = rect.y1
        ystart = rect.x0
        ystop  = rect.x1

        xstart = np.round(xstart)
        xstop  = np.round(xstop)
        ystart = np.round(ystart)
        ystop  = np.round(ystop)
    
    # ======================================
    # Get image
    # ======================================
    # if oimg is None:
    #         oimg = E200.E200_load_images(imgstr, f)
    #         oimg = oimg.image[imgnum-1, :, :]
    # oimg=np.fliplr(oimg)

    img = oimg[xstart:xstop, ystart:ystop]

    # if roiaxes is not None:
    #     imgplot = roiaxes.imshow(img, interpolation='none', origin='lower', aspect='auto')
    
    # ======================================
    # Create a histogram of std dev
    # ======================================
    hist_vec  = mt.linspacestep(ystart, ystop, n_rows)
    n_groups  = np.size(hist_vec)
    # hist_data = np.zeros([n_groups, 2])
    x_pix     = np.round(mt.linspacestep(xstart, xstop-1, 1))
    x_meter   = (x_pix-np.mean(x_pix)) * res
    if camname == 'ELANEX':
        logger.log(level=logging.INFO, msg='Lanex is tipped at 45 degrees: dividing x axis by sqrt(2)')
        x_meter = x_meter/np.sqrt(2)
    # x_sq      = x_meter**2
    
    num_pts      = n_groups
    variance     = np.zeros(num_pts)
    gaussresults = np.empty(num_pts, object)
    stddev       = np.zeros(num_pts)
    varerr       = np.zeros(num_pts)
    chisq_red    = np.zeros(num_pts)
    y            = np.array([])

    for i in mt.linspacestep(0, n_groups-1):
        sum_x = np.sum(img[:, i*n_rows:(i+1)*n_rows], 1)
        y = np.append(y, ystart+n_rows*i+(n_rows-1.)/2.)
        # popt, pcov, chisq_red[i] = mt.gaussfit(x_meter, sum_x, sigma_y=np.sqrt(sum_x), plot=False, variance_bool=True, verbose=False, background_bool=True)
        gaussresults[i] = mt.gaussfit(x_meter, sum_x, sigma_y=np.sqrt(sum_x), plot=False, variance_bool=True, verbose=False, background_bool=True)
        variance[i]         = gaussresults[i].popt[2]
        # varerr[i]           = pcov[2, 2]
        # stddev[i]           = np.sqrt(pcov[2, 2])

    # ======================================
    # Remove nan from arrays
    # ======================================
    nan_ind   = np.logical_not(np.isnan(variance))
    variance  = variance[nan_ind]
    stddev    = stddev[nan_ind]
    varerr    = varerr[nan_ind]
    chisq_red = chisq_red[nan_ind]
    y         = y[nan_ind]
    
    # ======================================
    # Get energy axis
    # ======================================
    if camname == 'ELANEX':
        ymotor = data['raw']['scalars']['XPS_LI20_DWFA_M5']['dat']
        ymotor = mt.derefdataset(ymotor, f)
        ymotor = ymotor[0]*1e-3
        # print 'Ymotor is {}'.format(ymotor)
        logger.log(level=loggerlevel, msg='First: Original ymotor is: {}'.format(ymotor))
    
        ymotor = setQS.elanex_y_motor()*1e-3

        logger.log(level=loggerlevel, msg='First: Reconstructed ymotor is: {ymotor}'.format(ymotor=ymotor))
    else:
        ymotor = None

    # eaxis     = E200.eaxis(camname=camname, y=y, res=res, E0=20.35, etay=0, etapy=0, ymotor=ymotor)

    EnAxis = E200.Energy_Axis(camname=camname, hdf5_data=data, uid=uid)

    #  eaxis = E200.eaxis(y=y, camname=camname, res=res, E0=20.35, etay=0, etapy=0, ymotor=ymotor)
    #  eaxis = E200.eaxis(y=y, uid=uid, camname=camname, hdf5_data=data)
    eaxis = EnAxis.energy(ypx=y)

    yimg     = mt.linspacestep(1, img.shape[1])
    #  imgeaxis = E200.eaxis(camname=camname, y=yimg, res=res, E0=20.35, etay=0, etapy=0, ymotor=ymotor)
    #  imgeaxis = E200.eaxis(y=yimg, uid=uid, camname=camname, hdf5_data=data)
    imgeaxis = EnAxis.energy(ypx=yimg)

    yoimg     = mt.linspacestep(1, oimg.shape[1])
    #  oimgeaxis = E200.eaxis(camname=camname, y=yoimg, res=res, E0=20.35, etay=0, etapy=0, ymotor=ymotor)
    #  oimgeaxis = E200.eaxis(y=yoimg, uid=uid, camname=camname, hdf5_data=data)
    oimgeaxis = EnAxis.energy(ypx=yoimg)
    
    # ======================================
    # Default Twiss and beam params
    # ======================================
    emitx  = 0.001363/gamma
    # betax  = 1
    # alphax = 0
    # gammax = (1+np.power(alphax, 2))/betax
    twiss    = sltr.BeamParams(
        beta  = 0.5,
        alpha = 0,
        emit  = emitx
        )

    # ======================================
    # Quadrupole values
    # ======================================
    QS1_K1 = setQS.QS1.K1
    QS2_K1 = setQS.QS2.K1

    logger.log(level=loggerlevel, msg='QS1_K1 is: {}'.format(QS1_K1))
    logger.log(level=loggerlevel, msg='QS2_K1 is: {}'.format(QS2_K1))

    # ======================================
    # Create beamlines
    # ======================================
    # beamline=bt.beamlines.IP_to_cherfar(twiss_x=twiss, twiss_y=twiss, gamma=gamma)
    if camname == 'ELANEX':
        beamline = bt.beamlines.IP_to_lanex(
            beam_x = twiss, beam_y=twiss,
            QS1_K1 = QS1_K1,
            QS2_K1 = QS2_K1
            )
        #  from PyQt4.QtCore import pyqtRemoveInputHook
        #  pyqtRemoveInputHook()
        #  pdb.set_trace()
    else:
        beamline = bt.beamlines.IP_to_cherfar(
            beam_x=twiss, beam_y=twiss,
            QS1_K1 = QS1_K1,
            QS2_K1 = QS2_K1
            )

    beamline_array = np.array([])
    for i, value in enumerate(eaxis):
        # beamline.gamma = value/5.109989e-4
        beamline.gamma = sltr.GeV2gamma(value)
        beamline_array = np.append(beamline_array, copy.deepcopy(beamline))
    
    # ======================================
    # Fudge error
    # ======================================
    chisq_factor = 1e-28
    # used_error   = stddev*np.sqrt(chisq_factor)
    used_error   = variance*np.sqrt(chisq_factor)

    # ======================================
    # Fit beamline scan
    # ======================================
    scanresults = bt.fitBeamlineScan(beamline_array,
            variance,
            # emitx,
            error=used_error,
            verbose=True,
            plot=False,
            eaxis=eaxis
            )
    
    # ======================================
    # Plot results
    # ======================================
    mpl.rcParams.update({'font.size': 12})

    if plotaxes is not None:
        bt.plotfit(eaxis,
                variance,
                scanresults.fitresults.beta,
                scanresults.fitresults.X_unweighted,
                top='Emittance/Twiss Fit to Witness Butterfly',
                # top='Emittance and Beam Parameter Fit\nto Ionization-Injected Witness Bunch',
                figlabel='Butterfly Fit',
                bottom='Energy [GeV]',
                axes = plotaxes,
                error=used_error
                )
        plt.show()

    out = AnalysisResults(
        gaussfits = gaussresults,
        scanfit   = scanresults ,
        img       = img         ,
        yimg      = yimg        ,
        imgeaxis  = imgeaxis    ,
        oimg      = oimg        ,
        yoimg     = yoimg       ,
        oimgeaxis = oimgeaxis   ,
        eaxis     = eaxis       ,
        variance  = variance    ,
        xstart    = xstart      ,
        xstop     = xstop       ,
        ystart    = ystart      ,
        ystop     = ystop       ,
        res       = res         ,
        x_meter   = x_meter
        )
    
    return out
Esempio n. 2
0
	beamline.elements[5].K1 = LGPS_3311[i]
	beamline_array = np.append(beamline_array,copy.deepcopy(beamline))

# ======================================
# Fudge error
# ======================================
chisq_factor = 1e-28
# used_error   = stddev*np.sqrt(chisq_factor)
used_error   = variance*np.sqrt(chisq_factor)

# ======================================
# Fit beamline scan
# ======================================
out = bt.fitBeamlineScan(beamline_array,
		variance,
		emitx,
		error=used_error,
		verbose=True)

# ======================================
# Plot results
# ======================================
mpl.rcParams.update({'font.size':12})
bt.plotfit(stepvalues/20.35,
		variance,
		out.beta,
		out.X_unweighted,
		top='Emittance/Twiss Fit to Quad Scan',
		figlabel='Quad Scan Fit',
		error=used_error)
mt.addlabel(xlabel='$\delta$')
Esempio n. 3
0
def results2pdf(path, local=False, verbose=False, loglevel=logging.CRITICAL):
    # =====================================
    # Regex-out the dataset number, date
    # =====================================
    dataset_string  = re.search('E200_(\d+)', path).groups()[0]
    date_string_tmp = re.search('\d{8}', path).group()

    year  = np.int(date_string_tmp[0:4])
    month = np.int(date_string_tmp[4:6])
    day   = np.int(date_string_tmp[6:])

    date        = dt.date(year=year, month=month, day=day)
    date_string = date.strftime('%b %-d, %Y')

    # =====================================
    # Load data
    # =====================================
    data = E200.E200_load_data(path, local=local, readonly=True)
    
    processed_drill = data.wdrill.data.processed
    scalars_drill   = processed_drill.scalars
    vectors_drill   = processed_drill.vectors
    arrays_drill    = processed_drill.arrays
    
    scalars_rdrill = data.rdrill.data.raw.scalars
    
    # =====================================
    # Helper function
    # =====================================
    def get_str(drill):
        out_str = drill._hdf5
        return drill, out_str
    
    # =====================================
    # get uids, energy axes, images, etc
    # =====================================
    valid = scalars_drill.ss_ELANEX_valid
    uids = valid.UID[valid.dat is True]
    #  uids = uids[0:4]
    
    valid_drill, valid_str               = get_str(scalars_drill.ss_ELANEX_valid)
    valid                               = E200.E200_api_getdat(valid_str, uids)
    
    quadval_drill, quadval_str           = get_str(scalars_rdrill.step_value)
    quadval                             = E200.E200_api_getdat(quadval_str, uids)
    
    emit_n_drill, emit_n_str             = get_str(scalars_drill.ss_ELANEX_emit_n)
    emit_n                              = E200.E200_api_getdat(emit_n_str, uids)
    
    betastar_drill, betastar_str         = get_str(scalars_drill.ss_ELANEX_betastar)
    betastar                            = E200.E200_api_getdat(betastar_str, uids)
    
    sstar_drill, sstar_str               = get_str(scalars_drill.ss_ELANEX_sstar)
    sstar                               = E200.E200_api_getdat(sstar_str, uids)
    
    rect_drill, rect_str                 = get_str(vectors_drill.ss_ELANEX_rect)
    rects                               = E200.E200_api_getdat(rect_str, uids)
    
    eaxis_drill, eaxis_str               = get_str(vectors_drill.ss_ELANEX_energy_axis)
    eaxis                               = E200.E200_api_getdat(eaxis_str, uids)
    
    variance_drill, variance_str         = get_str(vectors_drill.ss_ELANEX_variance)
    variance                            = E200.E200_api_getdat(variance_str, uids)
    
    beta_drill, beta_str                 = get_str(vectors_drill.ss_ELANEX_LLS_beta)
    beta                                = E200.E200_api_getdat(beta_str, uids)
    
    y_error_drill, y_error_str           = get_str(vectors_drill.ss_ELANEX_LLS_y_error)
    y_error                             = E200.E200_api_getdat(y_error_str, uids)
    
    X_unweighted_drill, X_unweighted_str = get_str(arrays_drill.ss_ELANEX_LLS_X_unweighted)
    X_unweighted                        = E200.E200_api_getdat(X_unweighted_str, uids)
    
    selected_img_drill, selected_img_str = get_str(arrays_drill.ss_ELANEX_selected_img)
    selected_img                        = E200.E200_api_getdat(selected_img_str, uids)
    
    oimg_eaxis_drill, oimg_eaxis_str     = get_str(vectors_drill.ss_ELANEX_oimg_eaxis)
    oimg_eaxis                          = E200.E200_api_getdat(oimg_eaxis_str, uids)
    
    elanex_drill, elanex_str             = get_str(data.rdrill.data.raw.images.ELANEX)
    images                              = E200.E200_load_images(elanex_str, uids)
    
    E224_Probe_drill, E224_Probe_str     = get_str(data.rdrill.data.raw.images.E224_Probe)
    
    # =====================================
    # Determine laser on shots
    # =====================================
    laseron = laser_on_off(E224_Probe_str, uids)
    
    # =====================================
    # Determine number of shots, pages
    # =====================================
    num_shots      = len(valid)
    slots_per_page = 5
    pages          = np.int(np.ceil(num_shots/np.float(slots_per_page)))
    
    # =====================================
    # Create filename, pdf, main title
    # =====================================
    now      = dt.datetime.now()
    filename = '{}_processed_{}-{:02d}-{:02d}_{:02d}{:02d}.pdf'.format(dataset_string, now.year, now.month, now.day, now.hour, now.minute)
    pdf      = PdfPages(filename)
    main_title = 'Single Shot Emittance Analysis, Dataset {dataset}, {datestring}, Page {{}}/{totalpgs}'.format(
        dataset    = dataset_string,
        datestring = date_string,
        totalpgs   = pages+1
        )
    layout_rect = [0, 0, 1, 0.95]

    # =====================================
    # Create overview
    # =====================================

    worksheet(data, pdf, main_title)
    
    # =====================================
    # Basic formatting options
    # =====================================
    linewidth = 1
    fontsize  = 7
    
    # =====================================
    # Create pages with slots_per_page
    # number of analysis/page
    # =====================================
    for i in range(pages):
        gs = gridspec.GridSpec(5, 3)
        fig = plt.figure(figsize=(8.5, 11))
        fig.suptitle(main_title.format(i+2))
    
        # =====================================
        # Add analysis to each slot
        # =====================================
        for j in range(slots_per_page):
            indx = i*slots_per_page+j
            print(indx)
            # =====================================
            # Only add if there are shots left
            # =====================================
            if indx < num_shots:
                # =====================================
                # Plot Energy
                # =====================================
                img_to_plot = np.fliplr(np.rot90(images.images[indx]))
                uid = images.UID[indx]
    
                ax     = fig.add_subplot(gs[j, 0])
                e_axis = oimg_eaxis.dat[indx]
                e_axis = np.flipud(e_axis)
    
                # =====================================
                # Get energy, pixel ranges
                # =====================================
                # x_min = 1
                x_max = img_to_plot.shape[0]
                # x_range = x_max-x_min
    
                # y_min = e_axis[-1]
                # y_max = e_axis[0]
                # y_max = img_to_plot.shape[1]
                # y_range = y_max-y_min
    
                # aspect = x_range/y_range * img_to_plot.shape[1]/img_to_plot.shape[0]
                # aspect = np.power(np.float64(img_to_plot.shape[1])/np.float64(img_to_plot.shape[0]), 2)
                
                # extent = (x_min, x_max, y_min, y_max)
    
                # =====================================
                # Show image
                # =====================================
                #  ax.imshow(img_to_plot, extent=extent, aspect=aspect, origin='lower')
                #  ax.imshow(img_to_plot, aspect=aspect, origin='lower')
                #  img = mpl.image.NonUniformImage(ax)
                #  img.set_data(e_axis, mt.linspacestep(1, x_max), img_to_plot)
                pixels      = selected_img.dat[indx].flatten()
                hist, edges = np.histogram(pixels, bins=50)
                new_edges   = edges[1:]
                max_count   = np.max(new_edges[hist > 50])
                img         = mt.NonUniformImage(e_axis, mt.linspacestep(1, x_max), img_to_plot, ax=ax)
                img.set_clim([0, max_count])
                mt.addlabel(axes            = ax, ylabel='Pixels', xlabel='Energy [GeV]')
                cb                          = fig.colorbar(img)
                ax.tick_params(labelsize    = fontsize)
                cb.ax.tick_params(labelsize = fontsize)
                ax.get_figure().tight_layout()
    
                # =====================================
                # Get rectangle info
                # =====================================
                thisrect = rects.dat[indx]
    
                # =====================================
                # Retool y to energy scale
                # =====================================
                # x = thisrect[0]
                # y = thisrect[1]
                # width = thisrect[2]
                # height=thisrect[3]
    
                myrect = mt.qt.Rectangle(*thisrect)
                y0 = myrect.x0
                y1 = myrect.x1
                temp = np.flipud(e_axis)
                e_y0 = temp[np.int(np.round(y0))]
                e_y1 = temp[np.int(np.round(y1))]
                e_width = e_y1-e_y0
                
                #  rect = mt.qt.Rectangle(x, e_y0, e_width, height, axes=ax, alpha=1, fill=False)
                rect = mt.qt.Rectangle(e_y0, y, e_width, height, axes=ax, alpha=1, fill=False)
                ax.add_patch(rect.get_rect())
    
                mt.graphics.less_labels(ax, y_fraction=1)
                mt.graphics.axesfontsize(ax, fontsize)
    
                # =====================================
                # Plot Fit
                # =====================================
                figlabel = 'Butterfly Fit'
                ax       = fig.add_subplot(gs[j, 1])
                ax0      = bt.plotfit(
                    eaxis.dat[indx],
                    variance.dat[indx],
                    beta.dat[indx],
                    X_unweighted.dat[indx],
                    top        = 'Emittance and Beam Parameter Fit',
                    figlabel   = figlabel,
                    bottom     = 'Energy [GeV]',
                    axes       = ax,
                    error      = y_error.dat[indx],
                    linewidth  = linewidth,
                    fontsize   = fontsize,
                    markersize = 2
                    )
                
                mt.graphics.less_labels(ax0, y_fraction=1)
                mt.graphics.axesfontsize(ax0, fontsize)
    
                ax0.get_figure().tight_layout()
    
                # =====================================
                # Add numbers
                # =====================================
                ax  = fig.add_subplot(gs[j, 2])
    
                # Calculate pinch energy
                size         = np.dot(X_unweighted.dat[indx], beta.dat[indx])
                argmin       = np.argmin(size)
                pinch_energy = eaxis.dat[indx][argmin]
    
                if laseron[indx]:
                    laser_status = 'On'
                else:
                    laser_status = 'Off'
    
                table_begin = r'''
    \begin{{tabular}}{{ll}}
    \toprule
    Date & {} \\
    UID & {:0.0f} \\
    Quad Offset [GeV] & {:0.3f} \\
    \midrule Pinch Energy [GeV] & {:0.3f} \\
    Norm Emit [mm-mrad] &  {:0.3f} \\
    Beta* [m] &  {:0.3f} \\
    S* [m] & {:0.3f} \\
    Laser & {} \\
    \bottomrule
    \end{{tabular}}'''
                table_begin = table_begin.format(
                    date_string,
                    uid,
                    quadval.dat[indx],
                    pinch_energy,
                    emit_n.dat[indx]*1e6,
                    betastar.dat[indx],
                    sstar.dat[indx],
                    laser_status
                    )
                table_begin = re.sub('\\n', ' ', table_begin)
    
                #  table_begin = r'''\begin{tabular}{ c | c | c | c } & col1 & col2 & col3 \\\hline row1 & 11 & 12 & 13 \\\hline row2 & 21 & 22 & 23 \\\hline  row3 & 31 & 32 & 33 \end{tabular}'''
                ax.text(-0.1, 0.25, table_begin, fontsize=fontsize)
                ax.set_frame_on(False)
                ax.get_xaxis().set_visible(False)
                ax.get_yaxis().set_visible(False)
                ax.get_figure().tight_layout()
                
        gs.tight_layout(fig, rect=layout_rect)
        pdf.savefig(fig)
        plt.close()
    
    pdf.close()

    command = 'open {}'.format(filename)
    subprocess.call(shlex.split(command))
Esempio n. 4
0
scanresults = shot17.scanfit

figpath = '/Users/joelfrederico/AAC2014/figs'

linewidth = 2

# =====================================
# Plot Fit
# =====================================
figlabel = 'Butterfly Fit'
ax0      = bt.plotfit(eaxis,
        variance,
        scanresults.fitresults.beta,
        scanresults.fitresults.X_unweighted,
        top       = 'Emittance and Beam Parameter Fit\nto Ionization-Injected Witness Bunch',
        figlabel  = figlabel,
        # figpath = figpath,
        bottom    = 'Energy [GeV]',
        # axes    = plotaxes,
        error     = used_error,
        linewidth = linewidth
        )

mt.graphics.less_labels(ax0, y_fraction=1)
mt.graphics.axesfontsize(ax0, fontsize)
ax0.get_figure().tight_layout()

mt.graphics.savefig(filename=figlabel, path=figpath)

# =====================================
# Plot Image
# =====================================
Esempio n. 5
0
            image_str            = arrays['{}image'.format(head_str)]
            image                = E200.E200_api_getdat(image_str, uid).dat[0]

            quadval_str          = data.read_file['data']['raw']['scalars']['step_value']
            quadval              = E200.E200_api_getdat(quadval_str, uid).dat[0]
        
            # ======================================
            # Fit figure
            # ======================================
            fig = plt.figure()
            ax = fig.add_subplot(1, 1, 1)
            bt.plotfit(
                x     = energy_axis      ,
                y     = variance         ,
                beta  = LLS_beta         ,
                X     = LLS_X_unweighted ,
                error = LLS_y_error      ,
                axes  = ax
                )
        
            filename = '{camname}/{uid:0.0f}/{head_str}min_set_{setnumber}_UID_{uid:0.0f}'.format(camname=camname, setnumber=setnumber, uid=uid, head_str=head_str)
            mt.graphics.savefig(filename, fig=fig)
        
            # plt.close(fig)
            
            # ======================================
            # Image with ROI
            # ======================================
            # # fig = plt.figure()
            # # ax = fig.add_subplot(1, 1, 1)
            # # im=ax.imshow(image, vmin=0, vmax=img_max)
Esempio n. 6
0
betax  = 59.69009e-3
alphax = -0.7705554
gammax = (1+np.power(alphax, 2))/betax
twiss  = np.array([betax, alphax, gammax])
T      = np.array([[betax, -alphax], [-alphax, gammax]])

print('Emittance is {}.'.format(emitx))
print('Normalized emittance is {}.'.format(emitx*40000))
print('Initial beta should be {}.'.format(betax))
print('Initial alpha should be {}.'.format(alphax))
print('Initial gamma should be {}.'.format(gammax))
print('------------------------------')
# }}}

# Run Cherenkov analysis {{{
out = bt.histcher(x, y, res)
[h, xval, davg, filt] = out

stddevsq = bt.getstd(res, h, xval)

out = bt.fitbowtie(beamline, davg, stddevsq, filt, T, twiss, emitx)
# [spotexpected, X, beta] = out
spotexpected = out.spotexpected
X            = out.X
beta         = out.beta
covar = out.covar

figcher = plt.figure()
top     = 'Simulated Cherenkov Emittance Measurement'
bt.plotfit(filt, davg, np.sqrt(stddevsq), beta, X, spotexpected, top, elepath)
plt.close(figcher)