# def scan_2DFE_energy():
# def scan_harmonic_energy_pol():


def scan_2DFE_energy():
    # 1 Define detector and scan parameters
    
    sensors = [Keithley_2_raw.getAlias(), CADC2.getAlias(), SR_current.getAlias(), BML_energy_RBV.getAlias()]
    Keithley_channel = Keithley_2_raw.getChannelName()
    Keithley_range = "2 uA"
    #Keithley range:   "AUTO", "20 mA", "2 mA", "200 uA", "20 uA", "2 uA", "200 nA", "20 nA", "2 nA", "200 pA", "20 pA"
    
    emin = 450.0
    emax = 470.0
    esteps = 5.0
    
    #FE_centerX = -0.75
    #FE_centerY = 1.25
    FE_centerX = 0.0
    FE_centerY = 0.0
    
    FE_size_x = 0.1
    FE_size_y = 0.1
    
    x_range = 4.0
    y_range = 4.0
    
    x_steps = 0.1
    y_steps = 0.1
    
    
    # Set detector and slit parameters for scan>
    
    range_number = range_to_number(Keithley_range)
    Keithley_range_cmd = Keithley_channel.replace('READOUT', 'RANGE')
    caput(Keithley_range_cmd, range_number) # 6 --> 200 nA
    
    BML_FE_sizeX.setSpeed(1.0)
    BML_FE_sizeY.setSpeed(1.0)
    BML_FE_centerX.setSpeed(1.0)
    BML_FE_centerY.setSpeed(1.0)
    BML_FE_sizeX.write(FE_size_x)
    BML_FE_sizeY.write(FE_size_y)
    
    Scan_params = [emin, emax, esteps, FE_centerX, FE_centerY, FE_size_x, FE_size_y, x_range, y_range, x_steps, y_steps]
    
    # 3 Perform scans
    
    scan_3D_FE_slits(Scan_params, sensors)
    
    
    # 4 Restore FE motor speed
    
    BML_FE_sizeX.setSpeed(0.1)
    BML_FE_sizeY.setSpeed(0.1)
    BML_FE_centerX.setSpeed(0.1)
    BML_FE_centerY.setSpeed(0.1)
    
    #   FE_centerX_ini = BML_FE_centerX.read()
    #   FE_centerY_ini = BML_FE_centerY.read()
    #   FE_sizeX_ini = BML_FE_sizeX.read()
    #   FE_sizeY_ini = BML_FE_sizeY.read()
    
    
    #    BML_FE_sizeX.move(FE_sizeX)
    #    BML_FE_sizeY.move(FE_sizeY)
    
    #    BML_FE_centerX.move(xmin)
    #    BML_FE_centerY.move(ymin)
    
    #    sleep(1.0)
    
    #   ID2_mode
    
    #   BML_energy_set
    
    #    BML_FE_sizeX.update() 
    #    BML_FE_sizeY.update()
    #    BML_FE_centerX.update()
    #    BML_FE_centerY.update()
    #
    #    BML_FE_sizeX.move(FE_sizeX_ini)
    #    BML_FE_sizeY.move(FE_sizeY_ini)
    #    BML_FE_centerX.move(FE_centerX_ini)
    #    BML_FE_centerY.move(FE_centerY_ini)
    #
    #    BML_FE_sizeX.setSpeed(0.1)
    #    BML_FE_sizeY.setSpeed(0.1)
    #    BML_FE_centerX.setSpeed(0.1)
    #    BML_FE_centerY.setSpeed(0.1)

def scan_2DFE_energy_pol():

    polarizations = [1,2,3,4,5,6,7]
    
    for p in polarizations:
            print(p)
            caput("X11MA-UIND2:MODE", p) 
            sleep(60)
            ID_state = caget("X11MA-UIND2:MODE")
            print(ID_state)
            ID_energy = caget("X11MA-UIND2:ENERGY-RBV")
            print(ID_energy)
            scan_2DFE_energy()

    BML_FE_sizeX.write(0.0)
    BML_FE_sizeY.write(0.0)


def scan_harmonic_energy_pol():

#     0 Off
#     1 Linear H
#     2 Linear V+
#     3 Linear V-
#     4 Circular+
#     5 Circular-
#     6 +45 deg
#     7 -45 deg

    sensors = [Keithley_1_raw.getAlias(), CADC1.getAlias(), SR_current.getAlias(), BML_energy_RBV.getAlias()]
    polarizations = [1,2,3,4,5,6]
#    polarizations = ["Linear H", "Linear V+", "Linear V-","Circular+", "Circular-", "+45 deg", "-45 deg"]
    Keithley_channel = Keithley_2_raw.getChannelName()
    Keithley_range = "AUTO"
    #Keithley range:   "AUTO", "20 mA", "2 mA", "200 uA", "20 uA", "2 uA", "200 nA", "20 nA", "2 nA", "200 pA", "20 pA"
    
    emin = 500.0
    emax = 900.0
    esteps = 0.1
    latency = 1.0
    
    FE_centerX = 0.0
    FE_centerY = 0.0
    FE_size_x = 4.0
    FE_size_y = 4.0

    energy_slit = 200.0

#    # Set detector and slit parameters for scan>
#    range_number = range_to_number(Keithley_range)
#    Keithley_range_cmd = Keithley_channel.replace('READOUT', 'RANGE')
#    caput(Keithley_range_cmd, range_number) # 6 --> 200 nA
#    
#    BML_FE_sizeX.write(FE_size_x)
#    BML_FE_sizeY.write(FE_size_y)
#
#    exit_slit.move(energy_slit)
    
    scan_energy_values = [emin, emax, esteps,latency]
       
    for p in polarizations:
            print(p)
            caput("X11MA-UIND2:MODE", p)
            BML_energy_set.write(emin)
            #    ID2_mode.move("Linear H") 
            sleep(300)
            ID_state = caget("X11MA-UIND2:MODE")
            print(ID_state)
            ID_energy = caget("X11MA-UIND2:ENERGY-RBV")
            print(ID_energy)
            scan_energy(scan_energy_values, sensors)

    BML_FE_sizeX.write(0.0)
    BML_FE_sizeY.write(0.0)