Ejemplo n.º 1
0
def build_beamline(nrays=nrays):
    beamLine = raycing.BeamLine()
    rs.GeometricSource(beamLine,
                       'source',
                       nrays=nrays,
                       polarization=polarization,
                       **kw)

    #    beamLine.bg = BlazedGratingAlt(
    beamLine.bg = roe.BlazedGrating(beamLine,
                                    'BlazedGrating', (0, p, 0),
                                    pitch=pitch,
                                    material=coating,
                                    blaze=blaze,
                                    rho=rho)
    drho = beamLine.bg.get_grating_area_fraction()
    beamLine.bg.area = dx * dz / np.sin(pitch) * drho

    beamLine.gr = Grating(beamLine,
                          'Grating', (0, p, 0),
                          pitch=pitch,
                          material=coatingGr,
                          order=range(minOrder, maxOrder + 1))

    beamLine.fsm = rsc.HemisphericScreen(beamLine,
                                         'FSM', (0, p, 0),
                                         R=q,
                                         x=(0, -np.sin(thetaOffset),
                                            np.cos(thetaOffset)),
                                         z=(0, np.cos(thetaOffset),
                                            np.sin(thetaOffset)))
    return beamLine
Ejemplo n.º 2
0
def visualize_grating():
    beamLine = raycing.BeamLine()
    #    bg = BlazedGratingAlt(
    bg = roe.BlazedGrating(
        beamLine,
        'BlazedGrating',
        (0, p, 0),
        pitch=pitch,
        material=coating,
        blaze=blaze,
        #antiblaze=pitch,
        rho=rho)

    fig1 = plt.figure(figsize=(8, 6), dpi=72)
    rect2d = [0.1, 0.1, 0.8, 0.8]
    ax = fig1.add_axes(rect2d, aspect='auto')
    ax.set_xlabel(u'y (µm)')
    ax.set_ylabel(u'z (nm)')
    ax.set_title(
        u'Grating profile with {0:.0f} lines/mm and {1}° blaze angle\n'.format(
            rho, np.degrees(blaze)) +
        u'and beam footprint at {0}° pitch angle'.format(np.degrees(pitch)))

    maxY = 2.2 * bg.rho_1
    y = np.linspace(-2 * maxY, 2 * maxY, 280)
    z = bg.local_z(0, y)
    ax.plot(y * 1e3, z * 1e6, '-k', lw=2)

    beamSource = rs.Beam(nrays=len(y), forceState=1)
    beamSourceLoc = rs.Beam(copyFrom=beamSource)
    raycing.global_to_virgin_local(bg.bl, beamSource, beamSourceLoc, bg.center,
                                   slice(None))
    raycing.rotate_beam(beamSourceLoc, slice(None), pitch=-pitch)

    beamSource.z[:] = y * np.tan(pitch)
    beamGloSG, beamLoSG = bg.reflect(beamSource)

    ax.plot([beamSourceLoc.y * 1e3, beamLoSG.y * 1e3],
            [beamSourceLoc.z * 1e6, beamLoSG.z * 1e6],
            '-r',
            alpha=0.2,
            lw=0.5)
    ax.plot(beamLoSG.y * 1e3, beamLoSG.z * 1e6, 'or', alpha=0.5, lw=3)

    ax.set_xlim(-maxY * 1e3, maxY * 1e3)
    mz = bg.rho_1 * np.tan(blaze)
    ax.set_ylim(-mz * 1.1e6, mz * 0.2e6)

    y1, y2, z1, z2, d = get_grating_area_fraction(rho, blaze, pitch)
    xs = np.array([y1, y2]) * 1e3
    ys = np.array([z1, z2]) * 1e6
    ax.plot(xs, ys, 'og', lw=3)

    fig1.savefig(prefix + '_profile.png')
    plt.show()
Ejemplo n.º 3
0
def build_beamline(azimuth=0):
    beamLine = raycing.BeamLine(azimuth=azimuth, height=0)

    beamLine.source = rs.Undulator(beamLine,
                                   'Softi53',
                                   nrays=nrays,
                                   eE=3.0,
                                   eI=0.5,
                                   eEspread=0.0008 * energySpreadFactor,
                                   eEpsilonX=0.263 * emittanceFactor,
                                   eEpsilonZ=0.008 * emittanceFactor,
                                   betaX=9.,
                                   betaZ=2.,
                                   period=48.,
                                   n=77,
                                   targetE=(E0, targetHarmonic),
                                   eMin=E0 - dE * vFactor,
                                   eMax=E0 + dE * vFactor,
                                   xPrimeMax=acceptanceHor / 2 * 1e3 * hShrink,
                                   zPrimeMax=acceptanceVer / 2 * 1e3 * vShrink,
                                   xPrimeMaxAutoReduce=False,
                                   zPrimeMaxAutoReduce=False,
                                   uniformRayDensity=True,
                                   filamentBeam=(what != 'rays'),
                                   targetOpenCL='auto')

    opening = [
        -acceptanceHor * pFE / 2 * hShrink, acceptanceHor * pFE / 2 * hShrink,
        -acceptanceVer * pFE / 2 * vShrink, acceptanceVer * pFE / 2 * vShrink
    ]
    #    opening = [-acceptanceHor*pFE/2*hShrink*hFactor,
    #               acceptanceHor*pFE/2*hShrink*hFactor,
    #               -acceptanceVer*pFE/2*vShrink,
    #               acceptanceVer*pFE/2*vShrink]
    beamLine.slitFE = ra.RectangularAperture(
        beamLine,
        'FE slit',
        kind=['left', 'right', 'bottom', 'top'],
        opening=opening)
    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM-M1')

    xShrink = vShrink if what == 'wave' else 1
    yShrink = hShrink if what == 'wave' else 1
    beamLine.m1 = roe.ToroidMirror(beamLine,
                                   'M1',
                                   surface=('Au', ),
                                   material=material,
                                   limPhysX=(-5 * xShrink, 5 * xShrink),
                                   limPhysY=(-150 * yShrink, 150 * yShrink),
                                   positionRoll=np.pi / 2,
                                   R=1e22,
                                   alarmLevel=0.1)
    #    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM-M1')

    xShrink = hShrink if what == 'wave' else 1
    yShrink = vShrink if what == 'wave' else 1
    beamLine.m2 = roe.OE(beamLine,
                         'M2',
                         surface=('Au', ),
                         material=material,
                         limPhysX=(-5 * xShrink, 5 * xShrink),
                         limPhysY=(-225 * yShrink, 225 * yShrink),
                         alarmLevel=0.1)

    gratingKW = dict(
        positionRoll=np.pi,
        limPhysX=(-2 * xShrink, 2 * xShrink),
        #limPhysX=(-2*xShrink*hFactor, 2*xShrink*hFactor),
        limPhysY=(-40 * yShrink, 40 * yShrink),
        alarmLevel=0.1)
    if what == 'rays':
        beamLine.pg = Grating(beamLine,
                              'PlaneGrating',
                              material=gratingMaterial,
                              **gratingKW)
        beamLine.pg.material.efficiency = [(1, 0.4)]
    else:
        beamLine.pg = roe.BlazedGrating(beamLine,
                                        'BlazedGrating',
                                        material=material,
                                        blaze=blaze,
                                        rho=rho,
                                        **gratingKW)
    beamLine.pg.order = 1
    #    beamLine.fsmPG = rsc.Screen(beamLine, 'FSM-PG')

    beamLine.m3 = roe.ToroidMirror(
        beamLine,
        'M3',
        surface=('Au', ),
        material=material,
        positionRoll=-np.pi / 2,
        limPhysX=(-10. * vShrink, 10. * vShrink),
        limPhysY=(-100. * hShrink, 100. * hShrink),
        #limPhysY=(-100.*hShrink*hFactor, 100.*hShrink*hFactor),
        alarmLevel=0.1)
    beamLine.fsm3 = rsc.Screen(beamLine, 'FSM-M3')

    #    beamLine.exitSlit = ra.RoundAperture(
    #         beamLine, 'ExitSlit', r=ESradius, alarmLevel=None)
    beamLine.exitSlit = ra.RectangularAperture(
        beamLine,
        'ExitSlit',
        #         opening=[-ESdX*hFactor/2, ESdX*hFactor/2,
        #                  -ESdZ*vFactor/2, ESdZ*vFactor/2])
        opening=[-ESdX / 2, ESdX / 2, -ESdZ / 2, ESdZ / 2])

    beamLine.m4 = roe.EllipticalMirrorParam(
        beamLine,
        'M4',
        surface=('Au', ),
        material=material,
        positionRoll=np.pi / 2,
        pitch=pitch,
        isCylindrical=True,
        p=43000.,
        q=dM45 + pExp,
        limPhysX=(-0.5 * vShrink, 0.5 * vShrink),
        limPhysY=(-70. * hShrink, 70. * hShrink),
        #limPhysY=(-70.*hShrink*hFactor, 70.*hShrink*hFactor),
        alarmLevel=0.2)
    beamLine.fsm4 = rsc.Screen(beamLine, 'FSM-M4')

    beamLine.m5 = roe.EllipticalMirrorParam(beamLine,
                                            'M5',
                                            surface=('Au', ),
                                            material=material,
                                            yaw=-2 * pitch,
                                            pitch=pitch,
                                            isCylindrical=True,
                                            p=dM4ES + dM45,
                                            q=pExp,
                                            limPhysX=(-0.5 * hShrink,
                                                      0.5 * hShrink),
                                            limPhysY=(-40. * vShrink,
                                                      40. * vShrink),
                                            alarmLevel=0.2)
    beamLine.fsm5 = rsc.Screen(beamLine, 'FSM-M5')

    beamLine.fsmExp = rsc.Screen(beamLine, 'FSM-Exp')

    beamLine.waveOnSampleA = [np.zeros(abins) for sP in dFocus]
    beamLine.waveOnSampleB = [np.zeros(abins) for sP in dFocus]
    beamLine.waveOnSampleC = [np.zeros(abins) for sP in dFocus]

    return beamLine
Ejemplo n.º 4
0
def build_beamline(azimuth=0):
    beamLine = raycing.BeamLine(azimuth=azimuth, height=0)

    beamLine.source = rs.Undulator(
        beamLine, 'Softi53', nrays=nrays,
        eE=3.0, eI=0.5,  eEspread=0.0008*energySpreadFactor,
        eEpsilonX=0.263*emittanceFactor, eEpsilonZ=0.008*emittanceFactor,
        betaX=9., betaZ=2.,
        period=48., n=81, targetE=(E0, targetHarmonic),
        eMin=E0-dE*vFactor, eMax=E0+dE*vFactor,
        xPrimeMax=acceptanceHor/2*1e3*hShrink,
        zPrimeMax=acceptanceVer/2*1e3*vShrink,
        xPrimeMaxAutoReduce=False, zPrimeMaxAutoReduce=False,
        targetOpenCL='CPU',
        uniformRayDensity=True,
        filamentBeam=(what != 'rays'))

    opening = [-acceptanceHor*pFE/2*hShrink, acceptanceHor*pFE/2*hShrink,
               -acceptanceVer*pFE/2*vShrink, acceptanceVer*pFE/2*vShrink]
    beamLine.slitFE = ra.RectangularAperture(
        beamLine, 'FE slit', kind=['left', 'right', 'bottom', 'top'],
        opening=opening)
    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM-M1')

    xShrink = vShrink if what == 'wave' else 1
    yShrink = hShrink if what == 'wave' else 1
    beamLine.m1 = roe.ToroidMirror(
        beamLine, 'M1', surface=('Au',), material=(material,),
        limPhysX=(-5*xShrink, 5*xShrink), limPhysY=(-150*yShrink, 150*yShrink),
        positionRoll=np.pi/2, R=1e22,
        alarmLevel=0.1)
#    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM-M1')

    xShrink = hShrink if what == 'wave' else 1
    yShrink = vShrink if what == 'wave' else 1
    beamLine.m2 = roe.OE(
        beamLine, 'M2', surface=('Au',), material=(material,),
        limPhysX=(-5*xShrink, 5*xShrink), limPhysY=(-225*yShrink, 225*yShrink),
        alarmLevel=0.1)

    gratingKW = dict(
        positionRoll=np.pi, limPhysX=(-2*xShrink, 2*xShrink),
        limPhysY=(-40*yShrink, 40*yShrink), alarmLevel=0.1)
    if what == 'rays':
        beamLine.pg = Grating(beamLine, 'PlaneGrating',
                              material=gratingMaterial, **gratingKW)
        beamLine.pg.material.efficiency = [(1, 0.4)]
    else:
        beamLine.pg = roe.BlazedGrating(
            beamLine, 'BlazedGrating', material=material, blaze=blaze,
            rho=rho, **gratingKW)
    beamLine.pg.order = 1
#    beamLine.fsmPG = rsc.Screen(beamLine, 'FSM-PG')

    beamLine.m3 = roe.ToroidMirror(
        beamLine, 'M3', surface=('Au',), material=(material,),
        positionRoll=-np.pi/2, limPhysX=(-2*vShrink, 2*vShrink),
        limPhysY=(-80*hShrink*hExtraFactor, 80*hShrink*hExtraFactor),
        #limPhysY=(-80*hShrink, 80*hShrink),
        alarmLevel=0.1)
    beamLine.fsm3 = rsc.Screen(beamLine, 'FSM-M3')

#    beamLine.exitSlit = ra.RoundAperture(
#         beamLine, 'ExitSlit', r=ESradius, alarmLevel=None)
    beamLine.exitSlit = ra.RectangularAperture(
         beamLine, 'ExitSlit',
         opening=[-ESdX/2*hFactor*hShrink, ESdX/2*hFactor*hShrink,
                  -ESdZ/2*vFactor*vShrink, ESdZ/2*vFactor*vShrink])

    beamLine.fzp = roe.NormalFZP(
        beamLine, 'FZP', pitch=np.pi/2, material=mAuFZP, f=focus, E=E0,
        N=Nzone)
    beamLine.fzp.order = 1
    beamLine.fzp.material.efficiency = [(1, 0.1)]  # used with rays
    print('outerzone = {0} mm'.format(beamLine.fzp.rn[-1]-beamLine.fzp.rn[-2]))
    beamLine.fzp.area = np.pi * beamLine.fzp.rn[-1]**2 / 2
    beamLine.fsmFZP = rsc.Screen(beamLine, 'FSM-FZP')

    beamLine.fsmExp = rsc.Screen(beamLine, 'FSM-Exp')
    return beamLine
Ejemplo n.º 5
0
def build_beamline(azimuth=0):
    beamLine = raycing.BeamLine(azimuth=azimuth, height=0)

    beamLine.source = rs.Undulator(beamLine,
                                   'Softi53',
                                   nrays=nrays,
                                   eE=3.0,
                                   eI=0.5,
                                   eEspread=0.0008 * energySpreadFactor,
                                   eEpsilonX=0.263 * emittanceFactor,
                                   eEpsilonZ=0.008 * emittanceFactor,
                                   betaX=9.,
                                   betaZ=2.,
                                   period=48.,
                                   n=77,
                                   targetE=(E0, targetHarmonic),
                                   eMin=E0 - dE * vFactor,
                                   eMax=E0 + dE * vFactor,
                                   xPrimeMax=acceptanceHor / 2 * 1e3,
                                   zPrimeMax=acceptanceVer / 2 * 1e3,
                                   xPrimeMaxAutoReduce=False,
                                   zPrimeMaxAutoReduce=False,
                                   uniformRayDensity=True,
                                   filamentBeam=True)

    opening = [
        -acceptanceHor * pFE / 2, acceptanceHor * pFE / 2,
        -acceptanceVer * pFE / 2, acceptanceVer * pFE / 2
    ]
    beamLine.slitFE = ra.RectangularAperture(
        beamLine,
        'FE slit',
        kind=['left', 'right', 'bottom', 'top'],
        opening=opening)
    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM-M1')

    beamLine.m1 = roe.ToroidMirror(beamLine,
                                   'M1',
                                   surface=('Au', ),
                                   material=(mAu, ),
                                   limPhysX=(-5, 5),
                                   limPhysY=(-150, 150),
                                   positionRoll=np.pi / 2,
                                   R=1e22,
                                   alarmLevel=0.1)
    #    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM-M1')

    beamLine.m2 = roe.OE(beamLine,
                         'M2',
                         surface=('Au', ),
                         material=(mAu, ),
                         limPhysX=(-5, 5),
                         limPhysY=(-225, 225),
                         alarmLevel=0.1)

    gratingKW = dict(positionRoll=np.pi,
                     limPhysX=(-2, 2),
                     limPhysY=(-40, 40),
                     alarmLevel=0.1)
    beamLine.pg = roe.BlazedGrating(beamLine,
                                    'BlazedGrating',
                                    material=mGolden,
                                    blaze=blaze,
                                    rho=rho,
                                    **gratingKW)
    beamLine.pg.order = 1
    #    beamLine.fsmPG = rsc.Screen(beamLine, 'FSM-PG')

    beamLine.m3 = roe.ToroidMirror(beamLine,
                                   'M3',
                                   surface=('Au', ),
                                   material=(mAu, ),
                                   positionRoll=-np.pi / 2,
                                   limPhysX=(-10., 10.),
                                   limPhysY=(-100., 100.),
                                   alarmLevel=0.1)
    beamLine.fsm3 = rsc.Screen(beamLine, 'FSM-M3')

    #    beamLine.exitSlit = ra.RoundAperture(
    #         beamLine, 'ExitSlit', r=ESradius, alarmLevel=None)
    beamLine.exitSlit = ra.RectangularAperture(beamLine,
                                               'ExitSlit',
                                               opening=[
                                                   -ESdX * hFactor / 2,
                                                   ESdX * hFactor / 2,
                                                   -ESdZ * vFactor / 2,
                                                   ESdZ * vFactor / 2
                                               ])

    beamLine.m4 = roe.EllipticalMirrorParam(beamLine,
                                            'M4',
                                            surface=('Au', ),
                                            material=(mAu, ),
                                            positionRoll=np.pi / 2,
                                            pitch=pitch,
                                            isCylindrical=True,
                                            p=43000.,
                                            q=dM45 + pExp,
                                            limPhysX=(-0.5, 0.5),
                                            limPhysY=(-70., 70.),
                                            alarmLevel=0.2)

    beamLine.m5 = roe.EllipticalMirrorParam(beamLine,
                                            'M5',
                                            surface=('Au', ),
                                            material=(mAu, ),
                                            yaw=-2 * pitch,
                                            pitch=pitch,
                                            isCylindrical=True,
                                            p=dM4ES + dM45,
                                            q=pExp,
                                            limPhysX=(-0.5, 0.5),
                                            limPhysY=(-40., 40.),
                                            alarmLevel=0.2)

    beamLine.fsmExp = rsc.Screen(beamLine, 'FSM-Exp')

    return beamLine
Ejemplo n.º 6
0
def visualize_grating():
    from  matplotlib.patches import Arc

    beamLine = raycing.BeamLine()
    bg = roe.BlazedGrating(
        beamLine, 'BlazedGrating', (0, p, 0), pitch=pitch, material=coating,
        blaze=blaze,
        #antiblaze=pitch,
        rho=rho,
#        gratingDensity=['y', rho, 1, 0, 1e-7]
        )

    fig1 = plt.figure(figsize=(8, 6), dpi=100)
    rect2d = [0.1, 0.1, 0.8, 0.8]
    ax = fig1.add_axes(rect2d, aspect='auto')
    ax.set_xlabel(u'y (µm)')
    ax.set_ylabel(u'z (nm)')
    ax.set_title(
        u'Grating profile with {0:.0f} lines/mm and {1:.2f}° blaze angle\n'.format(
            rho, np.degrees(blaze)) +
        u'and beam footprint at {0}° pitch angle'.format(np.degrees(pitch)))

    maxY = 2.2 * bg.rho_1
    y = np.linspace(-2*maxY, 2*maxY, 1000)
    z = bg.local_z(0, y)
    ax.plot(y*1e3, z*1e6, '-k', lw=2)

    y = np.linspace(-2*maxY, 2*maxY, 300)
    z = bg.local_z(0, y)
    beamSource = rs.Beam(nrays=len(y), forceState=1)
    beamSourceLoc = rs.Beam(copyFrom=beamSource)
    raycing.global_to_virgin_local(bg.bl, beamSource, beamSourceLoc,
                                   bg.center, slice(None))
    raycing.rotate_beam(beamSourceLoc, slice(None), pitch=-pitch)

    beamSource.z[:] = y * np.tan(pitch)
    beamGloSG, beamLoSG = bg.reflect(beamSource)

    ax.plot([beamSourceLoc.y*1e3, beamLoSG.y*1e3],
            [beamSourceLoc.z*1e6, beamLoSG.z*1e6], '-r', alpha=0.2, lw=0.5)
    ax.plot(beamLoSG.y*1e3, beamLoSG.z*1e6, 'or', alpha=0.5, lw=3)

    ax.set_xlim(-maxY*1e3, maxY*1e3)
    mz = bg.rho_1*np.tan(blaze)
    ax.set_ylim(-mz*1.1e6, mz*0.2e6)

#    y1, y2, z1, z2, d = get_grating_area_fraction(rho, blaze, pitch)
#    xs = np.array([y1, y2]) * 1e3
#    ys = np.array([z1, z2]) * 1e6
#    ax.plot(xs, ys, 'og', lw=3)

    if bg.gratingDensity is not None:
        ax.plot(bg.ticks*1e3, np.zeros_like(bg.ticks), 'og', lw=3)

    ax.plot([-0.5, 2.2], [-mz*1e6, -mz*1e6], alpha=0.5, lw=1)
    ax.add_patch(Arc([0, -mz*1e6], maxY*0.22e3, mz*0.2e6, theta1=0,
                     theta2=90-blazeDeg, color='b'))
    ax.add_patch(Arc([bg.rho_1*1e3, -mz*1e6], maxY*0.22e3, mz*0.2e6, theta1=90,
                     theta2=180, color='b'))
    ax.text(bg.rho_1*0.15e3, -mz*0.9e6, 'blaze', ha='left', va='center',
            fontsize=12, color='b')
    ax.text(bg.rho_1*0.97e3, -mz*0.83e6, 'anti-\nblaze', ha='right', va='center',
            fontsize=12, color='b')

    fig1.savefig(prefix + '_profile.png')
    plt.show()