Exemplo n.º 1
0
def build_beamline(nrays=raycing.nrays):
    fixedExit = 15.

    beamLine = raycing.BeamLine(azimuth=0, height=0)
    hDiv = 1.5e-3
    vDiv = 2.5e-4
    beamLine.source = rs.GeometricSource(beamLine,
                                         'GeometricSource', (0, 0, 0),
                                         nrays=nrays,
                                         dx=0.1,
                                         dy=0,
                                         dz=2.,
                                         dxprime=hDiv / 2,
                                         dzprime=0,
                                         distE='flat',
                                         energies=eLimits,
                                         polarization='horizontal')

    beamLine.feMovableMask = ra.RectangularAperture(
        beamLine, 'FEMovableMask', [0, 10000, 0],
        ('left', 'top', 'right', 'bottom'), [-10, 3., 10, -3.])
    beamLine.feMovableMask.set_divergence(
        beamLine.source, [-hDiv / 2, vDiv / 2, hDiv / 2, -vDiv / 2])

    yDCM = 21000.
    si111 = rm.CrystalSi(hkl=(1, 1, 1), tK=-171 + 273.15)
    beamLine.dcm = roe.DCM(beamLine,
                           'DCM', (0, yDCM, 0),
                           surface=('Si111', ),
                           material=(si111, ))
    beamLine.dcm.bragg = math.asin(rm.ch / (2 * si111.d * E0))
    beamLine.dcm.cryst2perpTransl = fixedExit / 2. / math.cos(
        beamLine.dcm.bragg)

    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM1', (0, yDCM + 700, 0))

    yVFM = 24000.
    beamLine.vfm = roe.ToroidMirror(beamLine,
                                    'VFM', (0, yVFM, fixedExit),
                                    pitch=4.0e-3)
    beamLine.vfm.R = yVFM / beamLine.vfm.pitch
    beamLine.vfm.r = 2. / 3. * yVFM * beamLine.vfm.pitch
    yFlatMirror = yVFM + 2000.
    zFlatMirror = (yFlatMirror - yVFM) * 2. * beamLine.vfm.pitch + fixedExit
    beamLine.vdm = roe.OE(beamLine,
                          'FlatMirror', (0, yFlatMirror, zFlatMirror),
                          pitch=-beamLine.vfm.pitch,
                          positionRoll=math.pi)

    ySample = 1.5 * yVFM
    yQWP = ySample - 3000.
    beamLine.qwp = roe.OE(beamLine,
                          'QWP', (0, yQWP, zFlatMirror),
                          roll=math.pi / 4,
                          material=(crystalDiamond, ))
    beamLine.qwp.pitch = theta0

    beamLine.fsm2 = rsc.Screen(beamLine, 'FSM2', (0, ySample, zFlatMirror))

    return beamLine
Exemplo n.º 2
0
def build_beamline(azimuth=0, nrays=raycing.nrays):
    beamLine = raycing.BeamLine(azimuth=azimuth, height=0)
    rs.GeometricSource(
        beamLine, 'MAX-IV',
        nrays=nrays, dx=0.187, dz=0.032, dxprime=77e-6, dzprime=70e-6,
        distE=distE, energies=energies, polarization='horizontal')
    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM0')
    beamLine.m1 = roe.ToroidMirror(
        beamLine, 'M1', surface=('Au',), material=(mGold,),
        limPhysX=(-10., 10.), limPhysY=(-150., 150.), positionRoll=np.pi/2,
        R=1e12, alarmLevel=0.2)
    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM-M1')
    beamLine.m2 = roe.OE(
        beamLine, 'M2', surface=('Au',), material=(mGold,),
        limPhysX=(-10., 10.), limPhysY=(-150., 150.), alarmLevel=0.2)
    beamLine.pg = Grating(
        beamLine, 'PlaneGrating', material=mGoldenGrating,
        positionRoll=np.pi, limPhysX=(-15., 15.), limPhysY=(-55., 55.),
        alarmLevel=0.2)
#    beamLine.pg.order = -2,-1,0,1,2,3
    beamLine.pg.order = 1
    beamLine.fsmPG = rsc.Screen(beamLine, 'FSM-PG')
    beamLine.m3 = roe.ToroidMirror(
        beamLine, 'M3', material=(mGold,),
        positionRoll=-np.pi/2, limPhysX=(-15., 15.), limPhysY=(-150., 150.),
        alarmLevel=0.2)
    beamLine.fsm3hf = rsc.Screen(beamLine, 'FSM-M3hf')
    beamLine.fsm3vf = rsc.Screen(beamLine, 'FSM-M3vf')

    beamLine.s1s = [
        ra.RectangularAperture(
            beamLine, 'vert. slit', [0, 0, 0],
            ('bottom', 'top'), [fixedExit-opening/2., fixedExit+opening/2.])
        for opening in s1openings]

    beamLine.m4 = roe.ToroidMirror(
        beamLine, 'M4', material=(mGold,),
        positionRoll=np.pi/2, limPhysX=(-15., 15.), limPhysY=(-150., 150.),
        alarmLevel=0.2)
    beamLine.fsmExp1 = rsc.Screen(beamLine, 'FSM-Exp1')
    beamLine.fsmExp2 = rsc.Screen(beamLine, 'FSM-Exp2')
    return beamLine
Exemplo 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
Exemplo 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
Exemplo 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