pshell_config/x07ma
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Startup

Browse Source
This commit is contained in:
x07maop
2016-01-21 16:16:24 +01:00
parent 3d862b7e42
commit cb87684437
17 changed files with 982 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
config/agkey
View File

@@ -1,27 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAvEQPJ+OW/ctH32MZKHln9+vXvMpST3UOJbk9nPTGM7bYYMjs
bEjg9hHNTHtr+VA4AtQzmzOXeAPqG5zy1lAcoPMrz3Kj9fou86cdMxbN6ei3rFVb
9dDSMLGrGAVuR+iTAch0FNVru5BvZm4s+fn3pyYuy1GcKLv7/pyYdoqiYdUm7ZDL
VhFJjtSmIswCArcv5rpvlTHLGmLirEq9KC6xkcoWnyPACAw/rbWKUuVobXcrcoic
G6N4gZt5Ekl7qg3AUFnKtw2/l6rfx4WFZjRdevGx7k14I4m6UCv/t040dMhCyUXJ
zP73WZTdV3TR4C643ZXkoXNlnlm8uOeSvOy85wIDAQABAoIBAFJddEP/Tg+637bb
pCYQ92t/wuLVoS0iCQ53/HyumggF9qRhQw4c1E7Tev37AUIR1m9mZy1/ZMUc8U8j
Wxpn8h54RLJ9dT4oNmJiumOflna/WZwLvC/PLCYhlLjtp1HOboJZMG/s7zUf+5zU
ltjGg5KdIdvR2H/5vkWmPQ2fmWszFVKbB+RPX9NbAcQMIXwATcIN3tbsISuydaf6
w0Laa07oGpcMYTJzP1TJAVluUHWfouPoHdDcVc0g737o1wIFQ35e6bbYzM5zBkHJ
dQo7CeET+5+HZjsC9MQRiWw853GYJp0w+bKjDov/aIBJt6ZVx+KB8sZccSofVbaY
JvpwAAECgYEA6nHID0Lgo/P0aFneo38c9MlEdGRLxrfXwsY8LhnKtkF0wgz1Is40
be6cVIz/XzXvHnB3WrAMsdz2MPiU4COz5T48z9hNcb/BMrVvNCN3x2Bu/FU4qMVU
vKJIhsL9Hq/TF3W0crA+DObvl9Kv4tIQ7hQK/xvbGpsoOiqV4A26Lu8CgYEAzZNa
Nl3W5Ut+VqaEdnED26pbZtzM8eLwioUNme9Etl+WrJQervNf8j8GJ8BUhOVjQrDT
hqA2bkXfBqxYaW2G8wnOVhq6jqLFfb3yZjpOsUf1T2x7naHW2Z3VEPlnMez2GJB/
/jkRegcXqPMtk8TahbaY/gTjOc+eFTefuDuQUYkCgYAKxlfve59faaLd+ONmmDz4
cxeWUdW5uFFOPlYduEm8vp1jHb1WcCuwsbq1mBVUhuIKgBi8LkMnGYSnE4WkF3/5
FTcuRj6o76stbXFC8C5dF22CY1hLSWZvlPXIW8XOVz5YYax9aOQxK5vvWluDDSyC
BKHMv7b+LgtXQQXKWlcoOQKBgAv7hsqcdaYv3FFYq2fr9nmbWHCKdjezLqokT0Kl
u6+Vqsasa41vCiyol8dBYqvMYxjEDdBPDl0nHXTaHt0mUTNhYvGJ5U3jFvfZVoO2
6ldTBm12uU3a3RcaKA0xPF6gnUeZRJyg3u/p8esbIZD3bHVWy1wjFMuN2n0KHPk0
H5lhAoGAO8YqRVnHOoz7HeA16+LZoOorDA9r/NEN3/K/jgOJPfrm3CV205Ew7mvQ
Y6im34HAcjHp2fz/kxE0S4vd2iWapMpiQu0U2yvLdX+861pkM/ffAg6x3nEJChzp
lh8rxqEJy4PukTBxUAL0h5wnOWkRYFgOVcx60rHvYJZ8+Qf3lbc=
-----END RSA PRIVATE KEY-----

8
config/config.properties
View File

@@ -1,4 +1,4 @@
#Fri Dec 11 16:12:39 CET 2015
#Thu Jan 21 16:14:35 CET 2016
autoSaveScanData=true
createSessionFiles=false
dataPath={data}/{year}_{month}/{date}
@@ -22,6 +22,6 @@ terminalPort=3579
userAuthenticator=ch.psi.pshell.security.LdapAuthenticator | ldap\\\://d.psi.ch | d.psi.ch | users.psi
userManagement=false
versionTrackingEnabled=true
versionTrackingLogin={config}/agkey
versionTrackingManual=true
versionTrackingRemote=ssh\://git@github.psi.ch\:7999/psd/x07ma.git
versionTrackingLogin=
versionTrackingManual=false
versionTrackingRemote=https\://git.psi.ch/pshell_config/x07ma.git

22
config/devices.properties
View File

@@ -1,3 +1,4 @@
current=ch.psi.pshell.epics.ChannelDouble|ARIDI-PCT:CURRENT|Read||
count=ch.psi.pshell.epics.ChannelInteger|COUNT|Read||true
data=ch.psi.pshell.epics.ChannelDoubleArray|DATA 3|Read||
edata=ch.psi.pshell.epics.ChannelDoubleArray|EDATA 3|Read||
@@ -11,7 +12,28 @@ pol_mode=ch.psi.pshell.epics.DiscretePositioner|X07MA-ID:MODE|||
pol_offset=ch.psi.pshell.epics.ChannelDouble|X07MA-ID:ENERGY-OFFS|||
pol_angle=ch.psi.pshell.epics.ChannelDouble|X07MA-ID:ALPHA|||
pol_done=ch.psi.pshell.epics.ChannelString|X07MA-ID:DONE|Read||
#pol_done_pos=ch.psi.pshell.epics.BinaryPositioner|X07MA-ID:DONE|Read||
ramp_rate=ch.psi.pshell.epics.ChannelDouble|X07MA-PC-PS2:SET:DMD:RAMPRATE:TPM|||
sample_hor=ch.psi.pshell.epics.Motor|X07MA-ES1-MAG:TRZ1|||
sample_vert=ch.psi.pshell.epics.Motor|X07MA-ES1-MAG:TRY1|||
sample_rot=ch.psi.pshell.epics.Motor|X07MA-ES1-MAG:ROY1|||
needle=ch.psi.pshell.epics.ProcessVariable|X07MA-PC-TC:DMD:LOOP2:MANUAL|||
temperature=ch.psi.pshell.epics.ChannelDouble|X07MA-PC-TC:DMD:LOOP1:SETPOINT|||
temperature_readback=ch.psi.pshell.epics.ChannelDouble|X07MA-PC-TC:STS:T1|Read||
valve_try_open=ch.psi.pshell.epics.ChannelInteger|X07MA-OP-VG13:WT_SET|||
energy=ch.psi.pshell.epics.ChannelDouble|X07MA-PHS-E:GO.A|||
energy_readback=ch.psi.pshell.epics.ChannelDouble|X07MA-PGM:CERBK|Read||
energy_done=ch.psi.pshell.epics.ChannelInteger|X07MA-PHS:alldone|Read||
cff=ch.psi.pshell.epics.ChannelDouble|X07MA-PGM:cff|||
exit_slit=ch.psi.pshell.epics.ProcessVariable|X07MA-OP-SL1SV1:TR_AP|||
harmonic=ch.psi.pshell.epics.ChannelInteger|X07MA-ID:HARMONIC|||
signal_tey=ch.psi.pshell.epics.ChannelDouble|X07MA-ES1-AI:SIGNAL0|Read||
signal_i0=ch.psi.pshell.epics.ChannelDouble|X07MA-ES1-AI:SIGNAL1|Read||
signal_trans=ch.psi.pshell.epics.ChannelDouble|X07MA-ES1-AI:SIGNAL2|Read||
signal_field_analog_x=ch.psi.pshell.epics.ChannelDouble|X07MA-ES1-AI:SIGNAL4|Read||
#k10=ch.psi.pshell.epics.ChannelDouble|X07MA-KEI10:SETVOLTAGE|||
#k11=ch.psi.pshell.epics.ChannelDouble|X07MA-KEI11:SETVOLTAGE|||
#k24=ch.psi.pshell.epics.ChannelDouble|X07MA-KEI2400:setVoltAO|||
aperture=ch.psi.pshell.epics.DiscretePositioner|X07MA-FE-DSAPER|||
beam_status=ch.psi.pshell.epics.DiscretePositioner|ACOAU-ACCU:OP-MODE|Read||
sample=ch.psi.pshell.imaging.MjpegSource|http://x07ma-cam-5/axis-cgi/mjpg/video.cgi||-100|

11
config/jcae.properties
View File

@@ -1,14 +1,13 @@
#Wed Jan 20 14:25:21 CET 2016
ch.psi.jcae.ContextFactory.maxArrayBytes=10000000
ch.psi.jcae.ChannelFactory.timeout=2000
ch.psi.jcae.ChannelFactory.retries=2
ch.psi.jcae.ChannelFactory.timeout=1000
ch.psi.jcae.ChannelFactory.retries=1
ch.psi.jcae.ChannelBeanFactory.timeout=10000
ch.psi.jcae.ChannelBeanFactory.waitTimeout=1800000
ch.psi.jcae.ChannelBeanFactory.waitRetryPeriod=30000
ch.psi.jcae.ChannelBeanFactory.retries=4
ch.psi.jcae.impl.DefaultChannelService.timeout=3000
ch.psi.jcae.impl.DefaultChannelService.waitTimeout=60000
ch.psi.jcae.impl.DefaultChannelService.waitRetryPeriod=5000
ch.psi.jcae.impl.DefaultChannelService.retries=4
ch.psi.jcae.impl.DefaultChannelService.retries=4
ch.psi.jcae.ContextFactory.addressList=

4
config/plugins.properties
View File

@@ -1,2 +1,2 @@
/sls/X07MA/data/x07maop/pshell/home/plugins/EnergyScan.java=enabled
/sls/X07MA/data/x07maop/pshell/home/plugins/HystScan.java=enabled
EnergyScan.java=enabled
HystScan.java=enabled

8
devices/exit_slit.properties Normal file
View File

@@ -0,0 +1,8 @@
#Mon Dec 14 09:30:44 CET 2015
maxValue=NaN
minValue=NaN
offset=0.0
precision=6
resolution=NaN
scale=1.0
unit=um

8
devices/needle.properties Normal file
View File

@@ -0,0 +1,8 @@
#Fri Dec 11 17:22:43 CET 2015
maxValue=100.0
minValue=0.0
offset=0.0
precision=3
resolution=NaN
scale=1.0
unit=%

8
devices/p1.properties Normal file
View File

@@ -0,0 +1,8 @@
#Wed Jan 20 14:25:45 CET 2016
maxValue=1000.0
minValue=0.0
offset=0.0
precision=-1
resolution=NaN
scale=1.0
unit=mm

14
devices/sample_hor.properties Normal file
View File

@@ -0,0 +1,14 @@
#Fri Dec 11 17:18:59 CET 2015
defaultSpeed=0.5
estbilizationDelay=0
hasEnable=true
homingType=None
maxSpeed=NaN
maxValue=170.0
minSpeed=0.02
minValue=150.0
offset=0.0
precision=6
resolution=6.23E-4
scale=1.0
unit=mm

14
devices/sample_rot.properties Normal file
View File

@@ -0,0 +1,14 @@
#Fri Dec 11 17:19:07 CET 2015
defaultSpeed=2.0
estbilizationDelay=0
hasEnable=true
homingType=None
maxSpeed=NaN
maxValue=121.08000000000001
minSpeed=0.4
minValue=-241.92
offset=0.0
precision=6
resolution=0.0018
scale=1.0
unit=deg

14
devices/sample_vert.properties Normal file
View File

@@ -0,0 +1,14 @@
#Fri Dec 11 17:19:03 CET 2015
defaultSpeed=0.2
estbilizationDelay=0
hasEnable=true
homingType=None
maxSpeed=NaN
maxValue=45.0
minSpeed=0.02
minValue=0.5
offset=0.0
precision=6
resolution=1.3E-4
scale=1.0
unit=mm

356
plugins/importer.java Normal file
View File

@@ -0,0 +1,356 @@
/*
* Copyright (c) 2014 Paul Scherrer Institute. All rights reserved.
*/
import ch.psi.pshell.core.Controller;
import ch.psi.pshell.ui.Importer;
import ch.psi.pshell.ui.Plugin;
import ch.psi.utils.Str;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
*
*/
public class importer implements Plugin {
public static class MyImporter implements Importer{
StringBuffer sb;
@Override
public String getDescription() {
return "X-Treme scan files";
}
@Override
public String[] getExtensions() {
return new String[]{"txt"};
}
List<String>[] getBlocks(List<String> lines){
ArrayList<List<String>> ret = new ArrayList<>();
List<String> block = new ArrayList<>();
for (String line:lines){
line = line.trim();
if (!line.isEmpty()){
block.add(line);
if (line.equals("start")){
ret.add(block);
block = new ArrayList<>();
}
}
}
if (block.size()>0){
ret.add(block);
}
return ret.toArray(new List[0]);
}
String getRanges(String fileName) throws Exception{
File file = new File(fileName);
if (!file.exists()){
file = Paths.get(Controller.getInstance().getSetup().getScriptPath(), fileName).toFile();
if (!file.exists()){
throw new Exception("Invalid ranges file: " + fileName);
}
}
StringBuffer ret = new StringBuffer();
ret.append("ranges = [");
for (String str : Files.readAllLines(file.toPath())){
str = str.trim();
str = Str.removeMultipleSpaces(str);
String[] tokens = str.split(" ");
if (tokens.length == 3){
ret.append("(").append(tokens[0]).append(",").append(tokens[1]).append(",").append(tokens[2]).append("),");
}
}
ret.append("]");
return ret.toString();
}
String[] getTokens(String line){
return line.replaceAll("\\s+", " ").split(" ");//remove multiple spaces
}
HashMap<String, String> getPars(String[] tokens){
HashMap<String, String> pars = new HashMap<>();
for (String par : new String[]{"off", "delay", "repeat", "file", "ppe"}){
for (int i = 1; i<tokens.length-1; i++){
if (tokens[i].equals(par)){
pars.put(par, tokens[i+1]);
break;
}
}
}
return pars;
}
boolean waitTemp = false;
boolean refill1K = false;
boolean noBeamCkeck = false;
boolean waitInj = false;
String fileName = null;
void parse(List<String> block, int repeat){
String ident = "";
if (repeat > 1){
ident = " ";
sb.append("for i in range(").append(repeat).append("):\n");
}
String scanCommand = null;
String atEnd = null;
for (String line:block){
try{
String[] tokens = getTokens(line);
HashMap<String, String> pars = getPars(tokens);
String delayStr = pars.get("delay") != null ? ", delay=" + pars.get("delay") : "";
System.out.println("----");
System.out.println(line);
System.out.println(pars);
switch (tokens[0]){
case "set":
switch (tokens[1]){
case "Hx":
sb.append(ident).append("set_hx(").append(tokens[2]).append(")").append("\n");
continue;
case "Hz":
sb.append(ident).append("set_hz(").append(tokens[2]).append(")").append("\n");
continue;
case "pol":
String offset = pars.get("off") != null ? pars.get("off") : "None";
switch (tokens[2]){
case "c+":
sb.append(ident).append("set_pol_cplus(offset = ").append(offset).append(")").append("\n");
continue;
case "c-":
sb.append(ident).append("set_pol_cminus(offset = ").append(offset).append(")").append("\n");
continue;
case "pol":
sb.append(ident).append("set_pol_lin(angle = ").append(tokens[3]).append(", offset = ").append(offset).append(")").append("\n");
continue;
}
continue;
case "hor":
sb.append(ident).append("sample_hor.move(").append(tokens[2]).append(")").append("\n");
continue;
case "vert":
sb.append(ident).append("sample_vert.move(").append(tokens[2]).append(")").append("\n");
continue;
case "rot":
sb.append(ident).append("sample_rot.move(").append(tokens[2]).append(")").append("\n");
continue;
case "needle":
sb.append(ident).append("sample_vert.write(").append(tokens[2]).append(")").append("\n");
continue;
case "temp":
sb.append(ident).append("set_temp(").append(tokens[2]).append(delayStr).append(")").append("\n");
continue;
case "E":
sb.append(ident).append("set_energy(").append(tokens[2]).append(delayStr).append(")").append("\n");
continue;
case "cff":
sb.append(ident).append("set_cff(").append(tokens[2]).append(")").append("\n");
continue;
case "slit":
sb.append(ident).append("set_slit(").append(tokens[2]).append(")").append("\n");
continue;
case "har":
sb.append(ident).append("set_har(").append(tokens[2]).append(")").append("\n");
continue;
case "volt":
sb.append(ident).append("set_volt(").append(tokens[2]).append(", ").append(tokens[3]).append(delayStr).append(")").append("\n");
continue;
case "FE":
sb.append(ident).append("set_fe(").append(tokens[2]).append(")").append("\n");
continue;
}
break;
case "open":
sb.append(ident).append("open_valve(").append(delayStr.substring(2)).append(")").append("\n");
continue;
case "close":
sb.append(ident).append("close_valve()").append("\n");
continue;
case "range":
sb.append(ident).append("set_range(").append(tokens[1]).append(", ").append(tokens[2]).append(")\n");
continue;
case "wait_temp":
waitTemp = true;
continue;
case "refill1K":
refill1K = true;
continue;
case "no_beam_check":
noBeamCkeck = true;
continue;
case "wait_inj":
waitInj = true;
continue;
case "file":
fileName = tokens[1];
continue;
case "at_end":
atEnd = tokens[1]+"()";
continue;
case "otf":
case "hyst":
case "scan":
System.out.println("GOT");
if (scanCommand!=null){
throw new Exception("Two scan commands in a single block");
}
scanCommand = line;
continue;
}
sb.append("# TODO: ").append(line).append("\n");
} catch (Exception ex){
sb.append("# Exception: ").append(ex.getMessage()).append( " in ").append(line).append("\n");
}
}
if (scanCommand!=null){
try{
if (waitTemp){
sb.append(ident).append("wait_temp()").append("\n");
}
if (refill1K){
sb.append(ident).append("refill_1k()").append("\n");
}
if (waitInj){
sb.append(ident).append("wait_inj()").append("\n");
}
if (!noBeamCkeck){
sb.append(ident).append("wait_beam()").append("\n");
}
if (fileName!=null){
sb.append(ident).append("set_file('").append(fileName).append("')\n");
}
String[] tokens = getTokens(scanCommand);
HashMap<String, String> pars = getPars(tokens);
String delayStr = pars.get("delay") != null ? ", delay=" + pars.get("delay") : "";
switch (tokens[0]){
case "otf":
String init = "start=" + tokens[1] + ", ";
String finish = "end=" + tokens[2] +
", ";
String time = "time=" + tokens[3];
sb.append(ident).append("otf(").append(init).append(finish).append(time).append(delayStr).append(")\n");
break;
case "hyst":
String ppe = "";
if (pars.containsKey("ppe")){
//TODO
scanCommand = scanCommand.substring(0, scanCommand.lastIndexOf("ppe")).trim();
ppe = ", ppe=" + pars.get("ppe");
}
String energies = "energies=[" + scanCommand.substring(scanCommand.lastIndexOf(" E ") + 3).trim().replace(" ", ", ") + "]" + ppe;
tokens = getTokens(scanCommand.substring(0, scanCommand.lastIndexOf(" E ")).trim());
String field;
switch (tokens[1]){
case "cont":
field = "field=" + tokens[2] + ", ";
if (tokens.length == 4){
String file = tokens[3];
sb.append(ident).append("hyst_cont_mult(").append(field).append(getRanges(file)).append(", ").append(energies).append(")\n");
} else {
String start = "init_field=" + tokens[3] + ", ";
String end = "final_field=" + tokens[4] + ", ";
String ramp = "ramp_speed=" + tokens[5] + ", ";
sb.append(ident).append("hyst_cont(").append(field).append(start).append(end).append(ramp).append(energies).append(")\n");
}
break;
case "step":
String forward = tokens[2].equals("for") ? "forward = True, ": "forward = False, ";
field = "field=" + tokens[3] + ", ";
if (tokens.length == 5){
String file = tokens[4];
sb.append(ident).append("hyst_step_mult(").append(forward).append(field).append(getRanges(file)).append(", ").append(energies).append(")\n");
} else {
String start = "init_field=" + tokens[4] + ", ";
String end = "final_field=" + tokens[5] + ", ";
String ramp = "ramp_speed=" + tokens[6] + ", ";
sb.append(ident).append("hyst_step(").append(forward).append(field).append(start).append(end).append(ramp).append(energies).append(")\n");
}
break;
default:
throw new Exception("Invalid scan command type");
}
break;
case "scan":
switch (tokens[1]){
case "E":
if (tokens.length == 3){
String file = tokens[2];
sb.append(ident).append("scan_e_mult(").append(getRanges(file)).append(")\n");
} else {
sb.append(ident).append("scan_e(").append(tokens[2]).append(", ").append(tokens[3]).append(", ").append(tokens[4]).append(")\n");
}
break;
case "V":
sb.append(ident).append("scan_v(").append(tokens[2]).append(", ").append(tokens[3]).append(", ").append(tokens[4]).append(", ").append(tokens[5]).append(")\n");
break;
default:
throw new Exception("Invalid scan command type");
}
break;
default:
throw new Exception("Invalid scan command type");
}
} catch (Exception ex){
sb.append("# Exception: ").append(ex.getMessage()).append( " in ").append(scanCommand).append("\n");
}
}
if (atEnd!=null){
sb.append(atEnd).append("\n");
}
}
@Override
public String importFile(File file) throws Exception {
waitTemp = false;
refill1K = false;
noBeamCkeck = false;
waitInj = false;
fileName = null;
sb = new StringBuffer();
List<String>[] blocks = getBlocks(Files.readAllLines(file.toPath()));
for (List<String> block : blocks){
for (String line:block){
sb.append("#").append(line).append("\n");
}
//Execution block
if (block.size()>=2) {
String[] tokens = getTokens(block.get(block.size()-1));
if (tokens[0].equals("start")){
HashMap<String, String> pars = getPars(tokens);
if (pars.get("file")!=null){
sb.append("# TODO: 'start file' not supported").append("\n");
}
int repeat = 1;
try{
repeat = Integer.valueOf( pars.get("repeat"));
}catch (Exception ex){
}
block.remove(block.size()-1);
parse(block, repeat);
}
}
sb.append("\n");
}
return sb.toString();
}
}
@Override
public void onStart() {
Importer.addServiceProvider(MyImporter.class);
}
}

19
script/EnergyScan.py
View File

@@ -37,13 +37,15 @@ def wait_channel(name, value, type):
#Pre-actions
#wait_channel('ACOAU-ACCU:OP-MODE', 'Light Available', type = 's')
caput('X07MA-ID:MODE', MODE)
time.sleep(1.0)
if MODE == 'LINEAR':
caput('X07MA-ID:ALPHA', ALPHA)
wait_channel('X07MA-ID:DONE', 'DONE', type = 's')
caput('X07MA-ID:ENERGY-OFFS', OFFSET)
wait_channel('X07MA-ID:DONE', 'DONE', type = 's')
if MODE is not None:
pol_mode.write(MODE)
time.sleep(1.0)
if MODE == 'LINEAR':
pol_angle.write(ALPHA)
wait_device(pol_done,"DONE")
if OFFSET is not None:
caput('X07MA-ID:ENERGY-OFFS', OFFSET)
wait_device(pol_done,"DONE")
caput('E1', E1)
caput('E2', E2)
caput('TIME', TIME)
@@ -56,7 +58,8 @@ time.sleep(0.1)
caput('X07MA-OP-VG13:WT_SET', 'Try open')
time.sleep(5.0)
caput('X07MA-OP-VG13:WT_SET', 'Try open')
time.sleep(DELAY)
if DELAY is not None:
time.sleep(DELAY)
caput('START', '1')
#Post-actions

91
script/EnergyScanNew.py Normal file
View File

@@ -0,0 +1,91 @@
#Script imported from: MgE_plus.xml
#Parameters
"""
E1 = 710
E2 = 720
TIME = 1 #min
DELAY = 10.0 #s
MODE = 'CIRC +'
OFFSET = -9.0
FOLDER = '2015_04/20150417'
FILE = 'Fe_plus'
ALPHA=0
"""
print "\nStarting energy scan - Parameters: ",
print E1,E2,TIME,DELAY,MODE ,OFFSET ,FOLDER ,FILE ,ALPHA
start = time.localtime()
folder = os.path.expanduser("~/Data1/") + FOLDER + "/";
def getNewestFile():
global folder
import glob
try:
return max(glob.iglob(folder+'/*.txt'), key=os.path.getctime)
except:
return None
newest = getNewestFile()
#Pre-actions
wait_beam()
pol_mode.write(MODE) #caput('X07MA-ID:MODE', MODE) #TODO: CAPUT
time.sleep(1.0) #TODO: Needed?
if MODE == 'LINEAR':
pol_angle.write(ALPHA) #TODO: CAPUT
pol_done.waitValue("DONE") #TODO: NEEDED?
pol_offset.write(OFFSET) #TODO: CAPUT
pol_done.waitValue("DONE")
caput('E1', E1)
caput('E2', E2)
caput('TIME', TIME)
caput('FOLDER', FOLDER)
set_energy (E1)
#caputq('X07MA-PHS-E:GO.A', E1)
#wait_channel('X07MA-PHS:alldone', '1', type = 's')
#time.sleep(0.5)
caput('FILE', FILE)
time.sleep(0.1)
open_valve()
open_valve(0.0) #TODO: WHY WRITING AGAIN???
#caput('X07MA-OP-VG13:WT_SET', 'Try open')
#time.sleep(5.0)
#caput('X07MA-OP-VG13:WT_SET', 'Try open')
time.sleep(DELAY)
caput('START', '1')
#Post-actions
wait_channel('START', 'STOP', type = 's')
time.sleep(2.0)
print "Finished Energy scan"
#File convertion
newName = folder + time.strftime("%Y%m%d_%H%M_", start) + FILE + "_0000.txt";
#name = caget("MSG").split(' ')[0]
name = getNewestFile()
if name == newest:
raise Exception("Data file not created")
if not os.path.isfile(name):
raise Exception("Data file not found: " + name)
#cmd = "/sls/X07MA/data/x07maop/bin/modify_otf.pl " + name + " " + newName;
#print("Converting data file: " + cmd);
#import os
#os.system(cmd)
convert_file(name, newName)
print("Success")

151
script/HystScanNew.py Normal file
View File

@@ -0,0 +1,151 @@
#Script imported from: Fe_hyst_plus.xml
#Parameters
"""
START_FIELD = -0.1
END_FIELD = 0.1
ENERGIES = (707.90, 703.90)
RAMP_RATE = 0.2
ENERGY_CHANGE_SLEEP = 0.5
MODE = 'CIRC +'
OFFSET = -1.0
"""
FIELD_PRECISION = 0.01
#Pre-actions
#cawait('ACOAU-ACCU:OP-MODE', 'Light Available', type = 's')
wait_beam()
pol_mode.write(MODE)
pol_offset.write(OFFSET) #caput('X07MA-ID:ENERGY-OFFS', OFFSET)
caputq('X07MA-PC:CSCALER.INPB', '1')
ramp_rate.write(RAMP_RATE)
if len(ENERGIES) ==2:
dif_series = plot([],"Dif", context="Dif")[0].getSeries(0)
else:
dif_series = None
set_preference(Preference.ENABLED_PLOTS, ['field', 'tey_norm', 'trans_norm'])
set_preference(Preference.PLOT_TYPES, {'tey_norm':1, 'trans_norm':1})
scan = ManualScan(['field', 'Energy'], ['TEY', 'I0', 'trans', 'polarization', 'polAngle', 'temperature', 'RingCurrent', 'fieldAnalogX', 'tey_norm','trans_norm'], [0.0, ENERGIES[0]], [0.0, ENERGIES[-1]], [0, len(ENERGIES)-1])
scan.start()
#Stop condition
#ramp_done = Channel('X07MA-PC-MAG:X:RAMP:DONE', type = 'i')
#Creating channels: dimension 1
#RegionPositioner field
#field = Channel('X07MA-PC:GO', type = 'd')
#fieldReadback = Channel('X07MA-PC-PS2:STS:PMCURRENT', type = 'd')
#Creating channels: dimension 2
#ArrayPositioner Energy
#Energy = Channel('X07MA-PHS-E:GO.A', type = 'd')
#EnergyReadback = Channel('X07MA-PGM:CERBK', type = 'd')
#ScalarDetector TEY
#TEY = Channel('X07MA-ES1-AI:SIGNAL0', type = 'd')
#ScalarDetector I0
#I0 = Channel('X07MA-ES1-AI:SIGNAL1', type = 'd')
#ScalarDetector trans
#trans = Channel('X07MA-ES1-AI:SIGNAL2', type = 'd')
#ScalarDetector polarization
#polarization = Channel('X07MA-ID:MODE', type = 'd')
#ScalarDetector polAngle
#polAngle = Channel('X07MA-ID:ALPHA', type = 'd')
#ScalarDetector temperature
#temperature = Channel('X07MA-PC-TC:STS:T1', type = 'd')
#ScalarDetector RingCurrent
#RingCurrent = Channel('ARIDI-PCT:CURRENT', type = 'd')
#ScalarDetector fieldAnalogX
#fieldAnalogX = Channel('X07MA-ES1-AI:SIGNAL4', type = 'd')
print "SKIPPED Waiting for start field"
if abs(field_x.readback.read() - START_FIELD) > FIELD_PRECISION:
field_x.write(START_FIELD)
#if abs(fieldReadback.get() - START_FIELD) > FIELD_PRECISION:
# caput('X07MA-PC-PS2:M:GO.A', START_FIELD)
#caput("X07MA-PC-MAG:X:DMD", START_FIELD)
#caput("X07MA-PC-MAG:STARTRAMP.PROC", 1)
field_x_done.waitValue(1) #ramp_done.wait_for_value(1.0)
pol_done.waitValue("DONE")
#caput('X07MA-OP-VG13:WT_SET', 'Try open')
#time.sleep(2.0)
open(2.0)
print "Set end field"
#caput("X07MA-PC-MAG:X:DMD", END_FIELD)
#caputq("X07MA-PC-MAG:STARTRAMP.PROC", 1)
field_x.write(END_FIELD) #caputq('X07MA-PC-PS2:M:GO.A', END_FIELD)
index = 0
while(True):
#Dimension 2START_FIELD = -0.2
#ArrayPositioner Energy
for setpoint2 in ENERGIES:
#Energy.put(setpoint2, timeout=None) # TODO: Set appropriate timeout
energy.write(setpoint2)
sleep( ENERGY_CHANGE_SLEEP ) # Settling time
#TODO: change to Controlled variable?
readback2 = energy_readback.read() #EnergyReadback.get()
if abs(readback2 - setpoint2) > 0.1 : # TODO: Check accuracy
raise Exception('Energy could not be set to the value ' + str(setpoint2))
#Detector field readback
field_readback = field_x.readback.read() #fieldReadback.get()
detector1 = signal_tey.read() #TEY.get()
detector2 = signal_i0.read() #I0.get()
detector3 = signal_trans.read() #trans.get()
detector4 = float(pol_mode.getPositions().index(pol_mode.readback.read())) #polarization.get()
detector5 = pol_angle.read() #polAngle.get()
detector6 = temperature.read() #temperature.get()
detector7 = current.read()
detector8 = signal_field_analog_x.read() # fieldAnalogX.get()
tey_norm = detector1/detector2
trans_norm = detector3/detector2
if dif_series is not None:
if setpoint2 == ENERGIES[0]:
first = tey_norm
else:
dif = tey_norm-first
dif_series.appendData(field_readback,dif)
scan.append ([field_readback, setpoint2], [field_readback, readback2], [detector1, detector2, detector3, detector4, detector5, detector6, detector7, detector8, tey_norm, trans_norm])
if field_x_done.read() == 1: #If not ramping #ramp_done.get() == 1:
print "Not ramping, breaking execution"
break
index = index+1
#Closing channels
#Energy.close()
#EnergyReadback.close()
#TEY.close()
#I0.close()
#trans.close()
#polarization.close()
#polAngle.close()
#temperature.close()
#RingCurrent.close()
#fieldAnalogX.close()
#field.close()
#fieldReadback.close()
#ramp_done.close()
scan.end()

224
script/local.py
View File

@@ -36,7 +36,9 @@ def getPars(element):
raise Exception ("Invalid element: " + str(element))
#Pseudo-devices
###################################################################################################
# PSeudo-devices
###################################################################################################
energy = None
class SimulatedEnergy(Writable):
def write(self, value):
@@ -64,36 +66,238 @@ class SimulatedEnergyReadback(Readable):
sim_energy = SimulatedEnergy()
sim_energy_readback = SimulatedEnergyReadback()
###################################################################################################
#Definitions for importing text batch felis
# Utilities
###################################################################################################
def get_next_fid(folder, prefix):
try:
import glob
files = glob.glob(folder + prefix + '*_*.txt')
last = max(files)
index = int (last[last.rfind('_')+1 : last.rfind('.')]) + 1
return index
except:
return 0
def wait_channel(name, value, timeout=None, type='s'):
print "Waiting " + str(name) + " = " + str(value)
cawait(name, value, timeout = timeout, type=type)
print "Done waiting"
def wait_device(dev, value, timeout=-1):
if timeout >= 0:
timeout = int( 1000.0 * timeout)
print "Waiting " + dev.getName() + " = " + str(value)
dev.waitValue(value,timeout)
print "Done waiting"
def convert_file(input_file_name, output_file_name):
print "Converting data file: " + input_file_name + " to " + output_file_name
sep = "\t"
line_sep = "\n"
pol= pol_mode.readback.read()
if ret == "LINEAR": pol = str(pol_angle.read())
with open(input_file_name) as inp:
lines = inp.readlines()
with open(output_file_name, "wb") as out:
out.write("Ecrbk" + sep + "CADC1" + sep + "CADC2" + sep + "CADC3" + sep + "CADC4" + sep + "CADC5" + sep + "MCurr" + sep + "Time" + sep + "FieldX" + sep + "FieldZ" + sep + "Pol" + sep + "Temperature" + sep + "NORMtey" + sep + "NORMdiode" + line_sep)
s = sep
for line in lines[1:]:
line = line.strip()
if line=="": break
try:
(Ecrbk, CADC1, CADC2, CADC3, CADC4, CADC5, MCurr, cffrbk, IDErbk, NORM, time, MAGX, MAGZ, EXPT) = line.split(" ")
normtey=repr( float(CADC1)/float(CADC2))
normdiode=repr(float(CADC3)/float(CADC2))
out.write(Ecrbk + s + CADC1 + s + CADC2 + s + CADC3 + s + CADC4 + s + CADC5 + s + MCurr + s + time + s + MAGX + s + MAGZ + s + str(pol) + s + EXPT + s + normtey + s + normdiode + line_sep)
except:
traceback.print_exc()
def plot_file(file, context = None):
"""
"""
table = Table.load(file, "\t", '#')
plots = plot(table, context = context)
###################################################################################################
# Controller state listener
###################################################################################################
class Listener(ControllerListener):
def onControllerStateChanged(self, state, former):
if former == State.Busy:
FILENAME = None
controller.addListener(Listener()) #Old listeners are cleande in startup
###################################################################################################
#Definitions for importing text batch files
###################################################################################################
#TODO: Should set devices? K10, k11, k24 seem not to be defined....
keithleys = {
#name:[Setpoint, range]
"k1": [None , 'X07MA-PC-K428:1:setGain'],
"k2": [None , 'X07MA-PC-K428:2:setGain'],
"k3": [None , 'X07MA-PC-K428:3:setGain'],
"k10":['X07MA-KEI10:SETVOLTAGE' , 'X07MA-KEI10:RANGE'],
"k11":['X07MA-KEI11:SETVOLTAGE' , 'X07MA-KEI11:RANGE'],
"k24":['X07MA-KEI2400:setVoltAO', None]
}
def set_hx(field, timeout = -1):
field_x.write(field)
field_x.write(float(field))
field_x_done.waitValue(1,timeout)
def setHz(field, timeout = -1):
field_z.write(field)
field_z.write(float(field))
field_z_done.waitValue(1,timeout)
def set_pol_cplus(offset = None, timeout = -1):
pol_mode.write("CIRC +")
if off is not None:
pol_offset.write(offset)
pol_done.waitValue("DONE",timeout)
pol_offset.write(float(offset))
pol_done.waitValue("DONE",timeout)
def set_pol_cminus(offset = None, timeout = -1):
pol_mode.write("CIRC -")
if off is not None:
pol_offset.write(offset)
pol_done.waitValue("DONE",timeout)
pol_offset.write(float(offset))
pol_done.waitValue("DONE",timeout)
def set_pol_lin(angle, offset = None, timeout = -1):
pol_mode.write("LINEAR")
pol_angle.write(angle)
pol_angle.write(float(angle))
if off is not None:
pol_offset.write(offset)
pol_offset.write(float(offset))
pol_done.waitValue("DONE",timeout)
def set_temp(value, delay = 30.0):
temperature.write(float(value))
time.sleep(float(delay))
def open_valve(delay = 5.0):
valve_try_open.write(1) #TODO: CAPUT
time.sleep(float(delay))
def close_valve(delay = 0.0): #TODO: Check default delay
valve_try_open.write(0)
time.sleep(float(delay))
def set_energy (value, delay=0.5):
energy.write(float(value))
energy_done.waitValue(1)
time.sleep(float(delay))
def set_cff (value):
cff.write(float(value))
caput("X07MA-PGM:setE.PROC",1)
energy_done.waitValue(1)
def set_slit(value):
exit_slit.write(float(value))
def set_har(value):
harmonic.write(float(value))
def set_volt(keithley, value, dalay=0.1):
#keithley.write(float(value))
if not keithley in keithleys.keys(): raise Exception("Invalid keithley: " + keithley)
caput(keithleys[keithley][0], float(value))
time.sleep(float(delay))
def set_range(keithley, value):
if not keithley in keithleys.keys(): raise Exception("Invalid keithley: " + keithley)
caput(keithleys[keithley][1], int(value))
def set_fe(opening):
opening = float(opening*100)
if opening==0:
aperture.write("closed")
if opening==0.1:
aperture.write("0.1x0.1 mm")
elif opening==0.25:
aperture.write("0.25x0.25 mm")
elif opening==0.5:
aperture.write("0.5x0.5 mm")
elif opening==1.00:
aperture.write("1x1 mm")
elif opening==1.25:
aperture.write("1.25x1.25 mm")
elif opening==2.0:
aperture.write("2x2 mm")
else:
raise Exception("Invalid aperture opening: " + str(opening))
def refill_1k():
run("refill_1kpot")
def wait_temp():
if (temperature.read() < 2.0):
t=ct=temperature_readback.read()
#hl=caget("X07MA-PC-HE:LEVELB", 'd') # TODO: not used
if (t > 3.7):
refill_1k
def rampdown():
field_x.write(0)
field_z.write(0)
def shutdown():
set_fe(0)
rampdown()
def has_beam():
return beam_status.readback.read() !="Machine Down"
def wait_beam():
print "Waiting for beam..."
while !has_beam():
sleep(0.1)
print "Beam OK"
def wait_inj (value, delay=0.5):
wait_channel('X07MA-OP2-EVR:TOPUP-STAT', 'TOPUP-ON')
wait_channel('X07MA-OP2-EVR:TOPUP-STAT', 'TOPUP-OFF')
time.sleep(float(delay))
def set_file(file_name):
FILENAME = file_name
def otf(start, end, time, delay=None):
run("EnergyScan")
def hyst_cont(field, init_field, final_field, ramp_speed, energies):
pass
def hyst_cont_mult(field, ranges, energies):
pass
def hyst_step(forward, field, init_field, final_field, ramp_speed, energies):
pass
def hyst_step_mult(forward, ranges, ramp_speed, energies):
pass
def scan_e(start, end, step):
pass
def scan_e(ranges):
pass
def scan_v(keithley,start, end, step):
pass

60
script/refill_1kpot.py Normal file
View File

@@ -0,0 +1,60 @@
path1=time.strftime("%Y_%m", time.localtime())
path2=time.strftime("%Y%m%d", time.localtime())
path="/sls/X07MA/data/x07maop/Data1/"+path1+"/"+path2 +"/"+"refill.log"
sp = temperature.read
if (sp<2.0):
# open needle valve
print "Open needle valve to 50%"
needle.write(50.0)
print "Wait 1.0 min ..."
time.sleep(60)
print "Wait until T< 4K"
while True:
time.sleep(2)
t=temperature_readback.read()
if t < 4:
break
print "Wait 5 min ..."
time.sleep(300)
print "Set needle valve to 0%"
needle.write(0.0)
print "Wait temperature stabilization"
t_old=0.
while True:
t=temperature_readback.read()
t_diff=abs(t-t_old)
drift_mKelvin_per_min=t_diff*2*1000 # it was t_diff*6*1000, don't know why 6. It takes tooooo long to exit script.CP 23.11.14
print "T drift in mK per minute: ",drift_mKelvin_per_min
t_old=t
if (t>10.0):
break
if ( (drift_mKelvin_per_min<10.0) and (t<2.2) ):
break
time.sleep(30)
file=open(path,'a')
file.write(time.strftime("%d %b %Y %H:%M:%S", time.localtime()))
file.write( '# 1K pot refilled \n' )
file.close()
if ((sp >2.0) and (sp < 15)):
caput ("X07MA-PC-HE:PUMP", "ON")
time.sleep(60)
caput ("X07MA-PC-HE:PUMP", "AUTO")
while True:
time.sleep(20)
hlb=caget("X07MA-PC-HE:LEVELB", 'd')
if (hlb>110.0):
caput ("X07MA-PC-HE:PUMP", "OFF")
time.sleep(300)
break
time.sleep (3)