예제 #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
    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.feMovableMaskLT = ra.RectangularAperture(
        beamLine, 'FEMovableMaskLT', [0, 10000, 0], ('left', 'top'), [-10, 3.])
    beamLine.feMovableMaskRB = ra.RectangularAperture(
        beamLine, 'FEMovableMaskRB', [0, 10500, 0], ('right', 'bottom'),
        [10, -3.])
    beamLine.feMovableMaskLT.set_divergence(
        beamLine.sources[0], [-hDiv/2, vDiv/2])
    beamLine.feMovableMaskRB.set_divergence(
        beamLine.sources[0], [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.qwpSlit = ra.RectangularAperture(
        beamLine, 'QWPslit', [0, yQWP-100, 0],
        ('left', 'right', 'bottom', 'top'),
        [-5., 5., zFlatMirror-20., zFlatMirror+20.])

    beamLine.qwp = roe.LauePlate(beamLine, 'QWP', (0, yQWP, zFlatMirror),
                                 roll=math.pi/4, material=(crystalDiamond,))
    beamLine.qwp.pitch = theta0 + math.pi/2

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

    return beamLine
예제 #2
0
def build_beamline(nrays=mynrays):
    beamLine = raycing.BeamLine()
    beamLine.source = rs.Undulator(beamLine, nrays=nrays, **kwargs)
    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM0', (0, R0, 0))
    beamLine.slit = ra.RectangularAperture(beamLine, 'squareSlit', [0, R0, 0],
                                           ('left', 'right', 'bottom', 'top'),
                                           [-slitDx, slitDx, -slitDz, slitDz])

    beamLine.fsm1 = rsc.Screen(beamLine, 'FSM1', [0, R0, 0])
    return beamLine
예제 #3
0
def build_beamline():
    P02_2 = raycing.BeamLine()

    P02_2.Undulator01 = rsources.GeometricSource(
        bl=P02_2,
        nrays=5e4,
        name='source',
        polarization='horizontal',
        dx=0.5,
        dz=0.5,
        dxprime=0.005e-3,
        dzprime=0.005e-3,
        distx='normal',
        distz='normal',
        energies=(60000, 60) if powder else (1000, 100000),
        distE='normal' if powder else 'flat')

    P02_2.FSM_Source = rscreens.Screen(bl=P02_2,
                                       name=r"FSM_Source",
                                       center=[0, 29001, 0])

    P02_2.Sample = roes.LauePlate(
        bl=P02_2,
        name=r"CeO2 Powder Sample" if powder else "Silicon 001 wafer",
        center=[0, 65000, 0],
        pitch='90deg',
        yaw=0 if powder else '45deg',
        rotationSequence='RxRyRz',
        material=PowderSample if powder else MonoCrystalSample,
        targetOpenCL=(0, 0),
        precisionOpenCL='float32')

    P02_2.FSM_Sample = rscreens.Screen(bl=P02_2,
                                       name=r"After Sample",
                                       center=[0, 65100, 0])

    P02_2.RoundBeamStop01 = rapts.RoundBeamStop(bl=P02_2,
                                                name=r"BeamStop",
                                                center=[0, 65149, 0],
                                                r=5)

    P02_2.Frame = rapts.RectangularAperture(
        bl=P02_2,
        name=r"Frame",
        center=[0, 65149.5, 0],
        opening=[-dSize, dSize, -dSize, dSize])

    P02_2.FSM_Detector = rscreens.Screen(bl=P02_2,
                                         name=r"Detector",
                                         center=[0, 65150, 0])

    return P02_2
예제 #4
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
def build_beamline():
    beamLine = raycing.BeamLine(alignE=10000)

    beamLine.Wiggler = rsources.Wiggler(bl=beamLine,
                                        name=r"Flat-Top Wiggler",
                                        center=[0, 0, 0],
                                        nrays=500000,
                                        eE=2.9,
                                        eI=0.25,
                                        eEpsilonX=18.1,
                                        eEpsilonZ=0.0362,
                                        betaX=9.1,
                                        betaZ=2.8,
                                        xPrimeMax=0.3,
                                        zPrimeMax=0.005,
                                        eMin=9995,
                                        eMax=10005,
                                        K=35,
                                        period=150,
                                        n=11)

    beamLine.Generic_DCM = roes.DCM(bl=beamLine,
                                    name=r"Generic DCM",
                                    center=[0, 25300, 0],
                                    bragg=[10000],
                                    material=Si111,
                                    material2=Si111,
                                    cryst2perpTransl=6.5023)

    beamLine.Aperture = rapts.RectangularAperture(bl=beamLine,
                                                  name=r"Aperture",
                                                  center=[0, 28300, r"auto"],
                                                  opening=[-10, 10, -0.1, 0.1])

    beamLine.FSM = rscreens.Screen(bl=beamLine,
                                   name=r"FSM",
                                   center=[0, 30650, r"auto"])

    return beamLine
예제 #6
0
파일: Softi_CXIw1D.py 프로젝트: wholden/xrt
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
예제 #7
0
파일: BalderDMM.py 프로젝트: silexanaej/xrt
def build_beamline(nrays=1e4,
                   hkl=(1, 1, 1),
                   stripe='Si',
                   eMinRays=2400,
                   eMaxRays=45000):
    filterDiamond = rm.Material('C', rho=3.52, kind='plate')
    if stripe.startswith('S'):
        materialVCM = stripeSi
        materialVFM = stripeSiO2
    elif stripe.startswith('I'):
        materialVCM = stripeIr
        materialVFM = stripeIr
    else:
        raise ('Don' 't know the mirror material')
    height = 0
    beamLine = raycing.BeamLine(azimuth=0, height=height)

    wigglerToStraightSection = 0
    xWiggler = wigglerToStraightSection * beamLine.sinAzimuth
    yWiggler = wigglerToStraightSection * beamLine.cosAzimuth
    #    rs.WigglerWS(
    #        beamLine, name='SoleilW50', center=(xWiggler, yWiggler, height),
    #        nrays=nrays, period=50., K=8.446, n=39, eE=3., eI=0.5,
    #        eSigmaX=48.66, eSigmaZ=6.197, eEpsilonX=0.263, eEpsilonZ=0.008,
    #        eMin=50, eMax=60050, eMinRays=eMinRays, eMaxRays=eMaxRays, eN=2000,
    #        xPrimeMax=0.22, zPrimeMax=0.06, nx=40, nz=10)
    rs.Wiggler(beamLine,
               name='SoleilW50',
               center=(xWiggler, yWiggler, height),
               nrays=nrays,
               period=50.,
               K=8.446,
               n=39,
               eE=3.,
               eI=0.5,
               eSigmaX=48.66,
               eSigmaZ=6.197,
               eEpsilonX=0.263,
               eEpsilonZ=0.008,
               eMin=eMinRays,
               eMax=eMaxRays,
               xPrimeMax=0.22,
               zPrimeMax=0.06)

    beamLine.fsm0 = rsc.Screen(beamLine, 'FSM0', (0, 15000, height))
    beamLine.feFixedMask = ra.RectangularAperture(
        beamLine, 'FEFixedMask', (0, 15750, height),
        ('left', 'right', 'bottom', 'top'), [-3.15, 3.15, -0.7875, 0.7875])
    beamLine.fsmFE = rsc.Screen(beamLine, 'FSM-FE', (0, 16000, height))

    beamLine.filter1 = roe.Plate(beamLine,
                                 'Filter1', (0, 23620, height),
                                 pitch=math.pi / 2,
                                 limPhysX=(-9., 9.),
                                 limPhysY=(-4., 4.),
                                 surface='diamond 60 $\mu$m',
                                 material=filterDiamond,
                                 t=0.06,
                                 alarmLevel=0.)
    if stripe.startswith('I'):
        beamLine.filter2 = roe.Plate(beamLine,
                                     'Filter2', (0, 23720, height),
                                     pitch=math.pi / 2,
                                     limPhysX=(-9., 9.),
                                     limPhysY=(-4., 4.),
                                     surface='diamond 0.4 mm',
                                     material=filterDiamond,
                                     t=0.4,
                                     alarmLevel=0.)

    beamLine.vcm = roe.SimpleVCM(beamLine,
                                 'VCM', [0, 25290, height],
                                 surface=('Si', ),
                                 material=(materialVCM, ),
                                 limPhysX=(-15., 15.),
                                 limPhysY=(-680., 680.),
                                 limOptX=(-6, 6),
                                 limOptY=(-670., 670.),
                                 R=5.0e6,
                                 pitch=2e-3,
                                 alarmLevel=0.)
    beamLine.fsmVCM = rsc.Screen(beamLine, 'FSM-VCM', (0, 26300, height))

    beamLine.dmm = roe.DCM(
        beamLine,
        'DMM',
        [0, 27060, height],
        surface=('mL1', ),
        material=(mL, ),
        material2=(mL, ),
        limPhysX=(-12, 12),
        limPhysY=(-150, 150),
        cryst2perpTransl=20,
        cryst2longTransl=100,
        limPhysX2=(-12, 12),
        limPhysY2=(-200, 200),
        #        targetOpenCL='auto',
        targetOpenCL='CPU',
        alarmLevel=0.05)

    beamLine.BSBlock = ra.RectangularAperture(beamLine,
                                              'BSBlock', (0, 29100, height),
                                              ('bottom', ), (22, ),
                                              alarmLevel=0.)
    beamLine.slitAfterDCM = ra.RectangularAperture(
        beamLine,
        'SlitAfterDCM', (0, 29200, height), ('left', 'right', 'bottom', 'top'),
        [-7, 7, -2, 2],
        alarmLevel=0.5)
    beamLine.fsmDCM = rsc.Screen(beamLine, 'FSM-DCM', (0, 29400, height))

    beamLine.vfm = roe.SimpleVFM(beamLine,
                                 'VFM', [0, 30575, height],
                                 surface=('SiO2', ),
                                 material=(materialVFM, ),
                                 limPhysX=(-20., 20.),
                                 limPhysY=(-700., 700.),
                                 limOptX=(-10, 10),
                                 limOptY=(-700, 700),
                                 positionRoll=math.pi,
                                 R=5.0e6,
                                 r=40.77,
                                 alarmLevel=0.2)
    beamLine.slitAfterVFM = ra.RectangularAperture(
        beamLine,
        'SlitAfterVFM', (0, 31720, height), ('left', 'right', 'bottom', 'top'),
        [-7, 7, -2, 2],
        alarmLevel=0.5)
    beamLine.fsmVFM = rsc.Screen(beamLine, 'FSM-VFM', (0, 32000, height))
    beamLine.ohPS = ra.RectangularAperture(beamLine,
                                           'OH-PS', (0, 32070, height),
                                           ('left', 'right', 'bottom', 'top'),
                                           (-20, 20, 25, 55),
                                           alarmLevel=0.2)

    beamLine.slitEH = ra.RectangularAperture(
        beamLine,
        'slitEH', (0, 43000, height), ('left', 'right', 'bottom', 'top'),
        [-20, 20, -7, 7],
        alarmLevel=0.5)
    beamLine.fsmSample = rsc.Screen(beamLine, 'FSM-Sample', (0, 45863, height))

    return beamLine
예제 #8
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
예제 #9
0
def build_beamline(nrays=raycing.nrays, eMinRays=550, eMaxRays=30550):
    x0, y0 = -30095.04, -30102.65  # straight section center
    xFar, yFar = -59999.67, -198.017
    height = 1400.
    azimuth = np.arctan2(xFar - x0, yFar - y0)

    stripeSi = rm.Material('Si', rho=2.33)
    stripeRh = rm.Material('Rh', rho=12.41)
    stripePt = rm.Material('Pt', rho=21.45)
    si111_1 = rm.CrystalSi(hkl=(1, 1, 1), tK=-171+273.15)
    si311_1 = rm.CrystalSi(hkl=(3, 1, 1), tK=-171+273.15)
    si111_2 = rm.CrystalSi(hkl=(1, 1, 1), tK=-140+273.15)
    si311_2 = rm.CrystalSi(hkl=(3, 1, 1), tK=-140+273.15)
    filterDiamond = rm.Material('C', rho=3.52, kind='plate')
    beamLine = raycing.BeamLine(azimuth=azimuth, height=height)
    wigglerToStraightSection = 645.0
    xWiggler = x0 + wigglerToStraightSection * beamLine.sinAzimuth
    yWiggler = y0 + wigglerToStraightSection * beamLine.cosAzimuth

    rs.Wiggler(beamLine, name='MPW80', center=(
        xWiggler, yWiggler, height),
        nrays=nrays, period=80., K=13, n=12, eE=3., eI=0.4,
        eSigmaX=200, eSigmaZ=15, eEpsilonX=4.3, eEpsilonZ=0.043,
        eMin=eMinRays, eMax=eMaxRays,
        xPrimeMax=1.5, zPrimeMax=0.25)
#    rs.GeometricSource(beamLine, 'Source', (xWiggler, yWiggler, height),
#      nrays=nrays, distE='flat', energies=(2000, 25000),
#        polarization='horizontal')

    sampleToStraightSection = 36554.1
    beamLine.xSample = x0 + sampleToStraightSection * beamLine.sinAzimuth
    beamLine.ySample = y0 + sampleToStraightSection * beamLine.cosAzimuth

    beamLine.feFixedMask = ra.RectangularAperture(
        beamLine, 'FEFixedMask', (-36876.69, -23321.01, height),
        ('left', 'right', 'bottom', 'top'), [-8.3, 8.3, -2.35, 2.35])
    beamLine.fePhotonShutter = ra.RectangularAperture(
        beamLine, 'FEPhotonShutter', (-37133.37, -23064.33, height),
        ('left', 'right', 'bottom', 'top'), [-10.5, 10.5, -8.0, 8.0],
        alarmLevel=0.)
    beamLine.feMovableMaskLT = ra.RectangularAperture(
        beamLine, 'FEMovableMaskLT', (-38979.62, -21218.07, height),
        ('left', 'top'), [-10, 3.], alarmLevel=0.5)
    beamLine.feMovableMaskRB = ra.RectangularAperture(
        beamLine, 'FEMovableMaskRB', (-39262.47, -20935.23, height),
        ('right', 'bottom'), [10, -3.], alarmLevel=0.5)

    beamLine.filter1 = roe.Plate(
        beamLine, 'Filter1',
        (-42740.918, -17456.772, height), pitch=np.pi/2,
        limPhysX=(-20., 20.), limPhysY=(-9., 9.),
        surface=('diamond 90 $\mu$m',), material=(filterDiamond,), t=0.09,
        targetOpenCL=targetOpenCL,
        alarmLevel=0.)

    beamLine.fsm1 = rsc.Screen(
        beamLine, 'DiamondFSM1', (-42920.68, -17277.01, height),
        compressX=1./2.44)

    beamLine.vcm = roe.VCM(
        beamLine, 'VCM', [-43819.49, -16378.20, height],
        surface=('Rh', 'Si', 'Pt'), material=(stripeRh, stripeSi, stripePt),
        limPhysX=(-53., 53.), limPhysY=(-655., 655.),
        limOptX=((-47., -15.5, 16.), (-16., 15.5, 47.)),
        limOptY=((-650., -655., -650.), (650., 655., 650.)),
        R=5.0e6,
        jack1=[-43328.05, -16869.64, 973.0732],
        jack2=[-44403.38, -15964.02, 973.0732],
        jack3=[-44233.68, -15794.31, 973.0732],
        tx1=[0.0, -695.], tx2=[0.0, 705.75],
        targetOpenCL=targetOpenCL,
        alarmLevel=0.)
    beamLine.fsm2 = rsc.Screen(
        beamLine, 'NormalFSM2', (-44745.34, -15452.36, height),
        compressX=1./2.44)

    beamLine.dcm = roe.DCMOnTripodWithOneXStage(
        beamLine, 'DCM',
        [-45342.09, -14855.6, 1415.], surface=('Si311', 'Si111'),
        material=(si311_1, si111_1), material2=(si311_2, si111_2),
        limPhysX=((-51.1, 6.1), (-6.1, 51.1)), limPhysY=(-30., 30.),
        cryst2perpTransl=20., cryst2longTransl=95.,
        limPhysX2=((8.6, -48.6), (48.6, -8.6)), limPhysY2=(-90., 90.),
        jack1=[-45052.88, -15079.04, 702.4973],
        jack2=[-44987.82, -14490.02, 702.4973],
        jack3=[-45576.85, -14555.08, 702.4973],
        targetOpenCL=targetOpenCL,
        alarmLevel=0.)
    beamLine.fsm3 = rsc.Screen(
        beamLine, 'DiamondFSM3', (-46625.89, -13571.81, height),
        compressX=1./2.44)

    beamLine.BSBlock = ra.RectangularAperture(
        beamLine, 'BSBlock',
        (-45988.52, -14209.17, height), ('bottom',), (22,), alarmLevel=0.)
    beamLine.slitAfterDCM_LR = ra.RectangularAperture(
        beamLine, 'SlitAfterDCM_LR', (-46095.65, -14102.04, height),
        ('left', 'right'), [-25.0, 25.0], alarmLevel=0.5)
    beamLine.slitAfterDCM_BT = ra.RectangularAperture(
        beamLine, 'SlitAfterDCM_BT', (-46107.67, -14090.02, height),
        ('bottom', 'top'), [27.0, 77.0], alarmLevel=0.5)
    foilsZActuatorOffset = 0
    beamLine.xbpm4foils = ra.SetOfRectangularAperturesOnZActuator(
        beamLine, 'XBPM4foils', (-46137.73, -14059.97, height),
        (u'Cu5µm', u'Al7µm', u'Al0.8µm', 'top-edge'),
        (1344.607 + foilsZActuatorOffset, 1366.607 + foilsZActuatorOffset,
         1388.607 + foilsZActuatorOffset, 1400. + foilsZActuatorOffset),
        (45, 45, 45), (8, 8, 8), alarmLevel=0.)

    beamLine.vfm = roe.DualVFM(
        beamLine, 'VFM', [-47491.364, -12706.324, 1449.53],
        surface=('Rh', 'Pt'), material=(stripeRh, stripePt),
        limPhysX=(-56., 56.), limPhysY=(-714., 714.),
        limOptX=((1., -46.), (46., -4.)),
        limOptY=((-712., -712.), (712., 712.)),
        positionRoll=np.pi, R=5.0e6,
        r1=70., xCylinder1=23.5, hCylinder1=3.7035,
        r2=35.98, xCylinder2=-25.0, hCylinder2=6.9504,
        jack1=[-46987.20, -13210.49, 1272.88],
        jack2=[-48062.53, -12304.87, 1272.88],
        jack3=[-47892.83, -12135.16, 1272.88],
        tx1=[0.0, -713.], tx2=[0.0, 687.75],
        targetOpenCL=targetOpenCL,
        alarmLevel=0.2)
    beamLine.fsm4 = rsc.Screen(
        beamLine, 'DiamondFSM4', (-48350.17, -11847.53, height),
        compressX=1./2.44)

    beamLine.ohPSFront = ra.RectangularAperture(
        beamLine, 'OH-PS-FrontCollimator', (-48592.22, -11605.47, height),
        ('left', 'right', 'bottom', 'top'), (-23., 23., 30.48, 79.92),
        alarmLevel=0.2)
    beamLine.ohPSBack = ra.RectangularAperture(
        beamLine, 'OH-PS-BackCollimator', (-48708.19, -11489.51, height),
        ('left', 'right', 'bottom', 'top'), (-23., 23., 31.1, 81.1),
        alarmLevel=0.)
    beamLine.eh100To40Flange = ra.RoundAperture(
        beamLine, 'eh100To40Flange', [-53420.63, -6777.058, height], 19.,
        alarmLevel=0.)
    eh100To40FlangeToslit = 1159.
    slitX = beamLine.eh100To40Flange.center[0] +\
        eh100To40FlangeToslit * np.sin(azimuth)
    slitY = beamLine.eh100To40Flange.center[1] +\
        eh100To40FlangeToslit * np.cos(azimuth)
    beamLine.slitEH = ra.RectangularAperture(
        beamLine, 'slitEH', (slitX, slitY, height),
        ('left', 'right', 'bottom', 'top'), [-5, 5, -2.5, 2.5], alarmLevel=0.5)
    beamLine.fsmAtSample = rsc.Screen(
        beamLine, 'FocusAtSample',
        (beamLine.xSample, beamLine.ySample, height))

    return beamLine
예제 #10
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
예제 #11
0
def build_beamline():
    beamLine = raycing.BeamLine()
    #    rs.GeometricSource(
    #        beamLine, 'source', nrays=nrays, polarization='horizontal', **kw)
    rs.Undulator(beamLine, nrays=nrays, **kwargs)

    if case == 'mirror':
        beamLine.diffoe = roe.OE(beamLine,
                                 'PlaneMirror', (0, p, 0),
                                 pitch=pitch,
                                 material=coating)
        phiOffset = 2 * pitch
        zFlatScreen = q * np.sin(2 * pitch)
        zHemScreen = 0
    elif case == 'mirrorEll':
        beamLine.diffoe = roe.EllipticalMirrorParam(beamLine,
                                                    'EllipticalMirror',
                                                    (0, p, 0),
                                                    p=p,
                                                    q=q,
                                                    pitch=pitch,
                                                    material=coating)

        phiOffset = 2 * pitch
        zFlatScreen = q * np.sin(2 * pitch)
        zHemScreen = 0
    elif case == '2mirrors':
        beamLine.oe0 = roe.OE(beamLine,
                              'PlaneMirror0', (0, p - dp, 0),
                              pitch=pitch,
                              material=coating)
        zFlatScreen = dp * np.tan(2 * pitch)
        beamLine.diffoe = roe.OE(beamLine,
                                 'PlaneMirror', (0, p, zFlatScreen),
                                 pitch=-pitch,
                                 positionRoll=np.pi,
                                 material=coating)
        phiOffset = 0
        zHemScreen = zFlatScreen
    elif case == '2mirrorsEll':
        beamLine.oe0 = roe.OE(beamLine,
                              'PlaneMirror0', (0, p - dp, 0),
                              pitch=pitch,
                              material=coating)
        zFlatScreen = dp * np.tan(2 * pitch)
        beamLine.diffoe = roe.EllipticalMirrorParam(beamLine,
                                                    'EllipticalMirror',
                                                    (0, p, zFlatScreen),
                                                    p=p,
                                                    q=q,
                                                    pitch=-pitch,
                                                    positionRoll=np.pi,
                                                    material=coating)
        phiOffset = 0
        zHemScreen = zFlatScreen
    elif case == 'aperture':
        beamLine.diffoe = ra.RectangularAperture(
            beamLine, 'ra', (0, p, 0), ('left', 'right', 'bottom', 'top'))
        phiOffset = 0
        zFlatScreen = 0
        zHemScreen = 0

    if case.startswith('mir'):
        zvec = [0, -np.sin(2 * pitch), np.cos(2 * pitch)]