diff --git a/config/agkey b/config/agkey deleted file mode 100644 index a5060b8..0000000 --- a/config/agkey +++ /dev/null @@ -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----- diff --git a/config/config.properties b/config/config.properties index d91fd10..ee28605 100644 --- a/config/config.properties +++ b/config/config.properties @@ -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 diff --git a/config/devices.properties b/config/devices.properties index 063f460..3c5c73b 100644 --- a/config/devices.properties +++ b/config/devices.properties @@ -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| diff --git a/config/jcae.properties b/config/jcae.properties index 84cfba5..ffa04fb 100644 --- a/config/jcae.properties +++ b/config/jcae.properties @@ -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 \ No newline at end of file +ch.psi.jcae.impl.DefaultChannelService.retries=4 +ch.psi.jcae.ContextFactory.addressList= diff --git a/config/plugins.properties b/config/plugins.properties index 8dd6063..d22baf8 100644 --- a/config/plugins.properties +++ b/config/plugins.properties @@ -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 diff --git a/devices/exit_slit.properties b/devices/exit_slit.properties new file mode 100644 index 0000000..62b662f --- /dev/null +++ b/devices/exit_slit.properties @@ -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 diff --git a/devices/needle.properties b/devices/needle.properties new file mode 100644 index 0000000..d0a6e79 --- /dev/null +++ b/devices/needle.properties @@ -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=% diff --git a/devices/p1.properties b/devices/p1.properties new file mode 100644 index 0000000..543c976 --- /dev/null +++ b/devices/p1.properties @@ -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 diff --git a/devices/sample_hor.properties b/devices/sample_hor.properties new file mode 100644 index 0000000..79b84ae --- /dev/null +++ b/devices/sample_hor.properties @@ -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 diff --git a/devices/sample_rot.properties b/devices/sample_rot.properties new file mode 100644 index 0000000..46b358c --- /dev/null +++ b/devices/sample_rot.properties @@ -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 diff --git a/devices/sample_vert.properties b/devices/sample_vert.properties new file mode 100644 index 0000000..1e31559 --- /dev/null +++ b/devices/sample_vert.properties @@ -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 diff --git a/plugins/importer.java b/plugins/importer.java new file mode 100644 index 0000000..d49e709 --- /dev/null +++ b/plugins/importer.java @@ -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[] getBlocks(List lines){ + ArrayList> ret = new ArrayList<>(); + + List 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 getPars(String[] tokens){ + HashMap pars = new HashMap<>(); + for (String par : new String[]{"off", "delay", "repeat", "file", "ppe"}){ + for (int i = 1; i 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 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 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[] blocks = getBlocks(Files.readAllLines(file.toPath())); + for (List 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 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); + } +} diff --git a/script/EnergyScan.py b/script/EnergyScan.py index 24bdf41..4dcc6c7 100644 --- a/script/EnergyScan.py +++ b/script/EnergyScan.py @@ -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 diff --git a/script/EnergyScanNew.py b/script/EnergyScanNew.py new file mode 100644 index 0000000..ba7f851 --- /dev/null +++ b/script/EnergyScanNew.py @@ -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") + + diff --git a/script/HystScanNew.py b/script/HystScanNew.py new file mode 100644 index 0000000..b6636d4 --- /dev/null +++ b/script/HystScanNew.py @@ -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() diff --git a/script/local.py b/script/local.py index 8a104cd..da4613d 100644 --- a/script/local.py +++ b/script/local.py @@ -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 \ No newline at end of file diff --git a/script/refill_1kpot.py b/script/refill_1kpot.py new file mode 100644 index 0000000..62f6f41 --- /dev/null +++ b/script/refill_1kpot.py @@ -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)