Ejemplo n.º 1
0
def simulate(params, msg_callback=lambda _: _):
    """Run a multi-particle (thick) simulation and return results

    Args:
        params (OrderedMapping): configuration parameters
        msg_callback (function): Called at various stages to log output

    Returns:
        OrderedMapping: results and params (see code for format)
    """
    p = pkcollections.OrderedMapping()
    for k in 'simulation_kind', 'wavefront':
        v = params[k]
        p[k] = v.value if hasattr(v, 'value') else v
    pkcollections.mapping_merge(
        p, srw_params.to_undulator_multi_particle(params.undulator))
    p.beam = srw_params.to_beam(params.beam)
    p.stkF = srw_params.to_wavefront_multi_particle(p.wavefront)
    p.stkP = srw_params.to_wavefront_multi_particle(p.wavefront)
    p.ar_prec_f = srw_params.to_flux_precision(params.precision)
    p.ar_prec_p = srw_params.to_power_precision(params.precision)
    p.arPrecPar = [1] #General Precision parameters for Trajectory calculation:
    p.fieldInterpMeth = 4
    p.plots = []
    msg_callback('Performing trajectory calculation')
    _trajectory(p)
    if params.simulation_kind == 'E':
        msg_callback('Performing Electric Field (spectrum vs photon energy) calculation')
        msg_callback('Extracting Intensity from calculated Electric Field')
        srwlib.srwl.CalcStokesUR(p.stkF, p.beam, p.und, p.ar_prec_f)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.stkF.arS,
            [p.stkF.mesh.eStart, p.stkF.mesh.eFin, p.stkF.mesh.ne],
            [
                'Photon Energy [eV]',
                'Flux [ph/s/.1%bw]',
                'Flux through Finite Aperture',
            ],
        ])
    elif params.simulation_kind == 'X':
        msg_callback('Performing Power Density calculation (from field) vs x-coordinate calculation')
        srwlib.srwl.CalcPowDenSR(p.stkP, p.beam, 0, p.magFldCnt, p.ar_prec_p)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.plotMeshX = [1000*p.stkP.mesh.xStart, 1000*p.stkP.mesh.xFin, p.stkP.mesh.nx]
        p.powDenVsX = pkarray.new_float([0]*p.stkP.mesh.nx)
        for i in xrange(p.stkP.mesh.nx):
            powDenVsX[i] = p.stkP.arS[p.stkP.mesh.nx*int(p.stkP.mesh.ny*0.5) + i]
        p.plots.append([
            uti_plot.uti_plot1d,
            p.powDenVsX,
            p.plotMeshX,
            [
                'Horizontal Position [mm]',
                'Power Density [W/mm^2]',
                'Power Density\n(horizontal cut at y = 0)',
            ],
        ])
    elif params.simulation_kind == 'Y':
        msg_callback('Performing Power Density calculation (from field) vs x-coordinate calculation')
        srwlib.srwl.CalcPowDenSR(p.stkP, p.beam, 0, p.magFldCnt, p.ar_prec_p)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.plotMeshY = [1000*p.stkP.mesh.yStart, 1000*p.stkP.mesh.yFin, p.stkP.mesh.ny]
        p.powDenVsY = pkarray.new_float([0]*p.stkP.mesh.ny)
        for i in xrange(p.stkP.mesh.ny):
            p.powDenVsY[i] = p.stkP.arS[p.stkP.mesh.ny*int(p.stkP.mesh.nx*0.5) + i]
        p.plots.append([
            uti_plot.uti_plot1d,
            p.powDenVsY,
            p.plotMeshY,
            [
                'Vertical Position [mm]',
                'Power Density [W/mm^2]',
                'Power Density\n(vertical cut at x = 0)',
            ],
        ])
    elif params.simulation_kind == 'X_AND_Y':
        msg_callback('Performing Electric Field (intensity vs x- and y-coordinate) calculation')
        srwlib.srwl.CalcPowDenSR(p.stkP, p.beam, 0, p.magFldCnt, p.ar_prec_p)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.plotMeshX = [1000*p.stkP.mesh.xStart, 1000*p.stkP.mesh.xFin, p.stkP.mesh.nx]
        p.plotMeshY = [1000*p.stkP.mesh.yStart, 1000*p.stkP.mesh.yFin, p.stkP.mesh.ny]
        p.plots.append([
            uti_plot.uti_plot2d,
            p.stkP.arS,
            p.plotMeshX,
            p.plotMeshY,
            [
                'Horizontal Position [mm]',
                'Vertical Position [mm]',
                'Power Density',
            ],
        ])
    else:
        raise AssertionError('{}: invalid simulation_kind'.format(params.simulation_kind))
    return p
Ejemplo n.º 2
0
def simulate(params, msg_callback):
    """Run a single-particle (thin) simulation and return results

    Args:
        params (OrderedMapping): map of parameters
        msg_callback (function): Called at various stages to log output

    Returns:
        OrderedMapping: results and params (see code for format)
    """
    p = pkcollections.OrderedMapping()
    for k in 'polarization', 'intensity', 'simulation_kind', 'wavefront':
        v = params[k]
        p[k] = v.value if hasattr(v, 'value') else v
    pkcollections.mapping_merge(
        p, srw_params.to_undulator_single_particle(params.undulator))
    p.arPrecPar = srw_params.to_precision_single_particle(params.precision)
    p.wfrE = srw_params.to_wavefront_single_particle(p.wavefront)
    p.wfrE.partBeam = srw_params.to_beam(params.beam)
    p.wfrXY = srw_params.to_wavefront_single_particle(p.wavefront)
    p.wfrXY.partBeam = srw_params.to_beam(params.beam)
    p.beam = srw_params.to_beam(params.beam)
    p.plots = []
    skv = p.simulation_kind
    if params.simulation_kind == 'E':
        msg_callback('Performing Electric Field (spectrum vs photon energy) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrE, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrE.mesh.ne)
        srwlib.srwl.CalcIntFromElecField(
            p.arI1, p.wfrE, p.polarization, p.intensity, skv, p.wfrE.mesh.eStart, 0, 0)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.arI1,
            [p.wfrE.mesh.eStart, p.wfrE.mesh.eFin, p.wfrE.mesh.ne],
            ['Photon energy, eV','Spectral intensity, ph/s/0.1%BW','Intensity vs photon energy'],
        ])
    elif params.simulation_kind == 'X':
        msg_callback('Performing Electric Field (intensity vs x-coordinate) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrXY, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrXY.mesh.nx)
        srwlib.srwl.CalcIntFromElecField(p.arI1, p.wfrXY, p.polarization, p.intensity, skv, 0, p.wfrXY.mesh.xStart, 0)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.arI1,
            [p.wfrXY.mesh.xStart, p.wfrXY.mesh.xFin, p.wfrXY.mesh.nx],
            ['Horizontal Position [m]','Spectral intensity, ph/s/0.1%BW','Intensity vs x-coordinate'],
        ])
    elif params.simulation_kind == 'Y':
        msg_callback('Performing Electric Field (intensity vs y-coordinate) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrXY, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrXY.mesh.ny)
        srwlib.srwl.CalcIntFromElecField(p.arI1, p.wfrXY, p.polarization, p.intensity, skv, 0, p.wfrXY.mesh.yStart, 0)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.arI1,
            [p.wfrXY.mesh.yStart, p.wfrXY.mesh.yFin, p.wfrXY.mesh.ny],
            ['Vertical Position [m]','Spectral intensity, ph/s/0.1%BW','Intensity vs y-coordinate'],
        ])
    elif params.simulation_kind == 'X_AND_Y':
        msg_callback('Performing Electric Field (intensity vs x- and y-coordinate) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrXY, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrXY.mesh.nx*p.wfrXY.mesh.ny)
        srwlib.srwl.CalcIntFromElecField(p.arI1, p.wfrXY, p.polarization, p.intensity, skv, p.wfrXY.mesh.eStart, p.wfrXY.mesh.xStart, p.wfrXY.mesh.yStart)
        p.plots.append([
            uti_plot.uti_plot2d,
            p.arI1,
            [1*p.wfrXY.mesh.xStart, 1*p.wfrXY.mesh.xFin, p.wfrXY.mesh.nx],
            [1*p.wfrXY.mesh.yStart, 1*p.wfrXY.mesh.yFin, p.wfrXY.mesh.ny],
            ['Horizontal Position [m]', 'Vertical Position [m]', 'Intensity at ' + str(wfrXY.mesh.eStart) + ' eV'],
        ]),
    elif params.simulation_kind == 'E_AND_X':
        msg_callback('Performing Electric Field (intensity vs energy- and x-coordinate) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrXY, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('* Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrXY.mesh.ne*p.wfrXY.mesh.nx)
        srwlib.srwl.CalcIntFromElecField(p.arI1, p.wfrXY, p.polarization, p.intensity, skv, p.wfrXY.mesh.eStart, p.wfrXY.mesh.xStart, p.wfrXY.mesh.yStart)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.arI1,
            [1*p.wfrXY.mesh.eStart, 1*p.wfrXY.mesh.eFin, p.wfrXY.mesh.ne],
            [1*p.wfrXY.mesh.xStart, 1*p.wfrXY.mesh.xFin, p.wfrXY.mesh.nx],
            ['Energy [eV]', 'Horizontal Position [m]', 'Intensity integrated from ' + str(p.wfrXY.mesh.yStart) + ' to ' + str(p.wfrXY.mesh.yFin) + ' ,m in y-coordinate'],
        ])
    elif params.simulation_kind == 'E_AND_Y':
        msg_callback('Performing Electric Field (intensity vs energy- and y-coordinate) calculation')
        srwlib.srwl.CalcElecFieldSR(p.wfrXY, 0, p.magFldCnt, p.arPrecPar)
        msg_callback('Extracting Intensity from calculated Electric Field')
        p.arI1 = pkarray.new_float([0]*p.wfrXY.mesh.ne*p.wfrXY.mesh.ny)
        srwlib.srwl.CalcIntFromElecField(p.arI1, p.wfrXY, p.polarization, p.intensity, skv, p.wfrXY.mesh.eStart, p.wfrXY.mesh.xStart, p.wfrXY.mesh.yStart)
        p.plots.append([
            uti_plot.uti_plot1d,
            p.arI1,
            [1*p.wfrXY.mesh.eStart, 1*p.wfrXY.mesh.eFin, p.wfrXY.mesh.ne],
            [1*p.wfrXY.mesh.yStart, 1*p.wfrXY.mesh.yFin, p.wfrXY.mesh.ny],
            ['Energy [eV]', 'Vertical Position [m]', 'Intensity integrated from ' + str(p.wfrXY.mesh.xStart) + ' to ' + str(p.wfrXY.mesh.xFin)+ ' ,m in x-coordinate'],
        ])
    else:
        raise AssertionError('{}: invalid p.simulation_kind'.format(params.simulation_kind))
    return p