mds.wave.WaveInterface Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jscope Show documentation
Show all versions of jscope Show documentation
MDSplus data display program for waveforms, images and more.
package mds.wave;
import java.io.IOException;
import java.io.PrintWriter;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import mds.jscope.SignalBox;
public class WaveInterface
{
public static SignalBox sig_box = new SignalBox();
static final int MAX_NUM_SHOT = 30;
static public boolean auto_color_on_expr = false;
public static boolean brief_error = true;
protected static String AddNewLineCode(String s)
{
String s_new = new String();
int new_pos = 0, old_pos = 0;
if (s == null)
return null;
while ((new_pos = s.indexOf("\n", old_pos)) != -1)
{
s_new = s_new.concat(s.substring(old_pos, new_pos));
old_pos = new_pos + "\n".length();
s_new += "|||";
}
s_new = s_new.concat(s.substring(old_pos, s.length()));
return s_new;
}
public static long[] GetShotArray(String in_shots, String exp, DataProvider dp) throws IOException
{
long shot_list[] = null;
String error;
if (in_shots == null || in_shots.trim().length() == 0 || dp == null)
return null;
String shotExpr = in_shots;
if (exp != null)
shotExpr = processShotExpression(in_shots, exp);
shot_list = dp.getShots(shotExpr, exp);
if (shot_list == null || shot_list.length == 0 || shot_list.length > MAX_NUM_SHOT)
{
if (shot_list != null && shot_list.length > MAX_NUM_SHOT)
error = "Too many shots. Max shot list elements " + MAX_NUM_SHOT + "\n";
else
{
if (dp.getError() != null)
{
error = dp.getError();
if (error.indexOf("_jScopeMainShots") != -1)
error = "Undefined main shot value";
}
else
error = "Shot syntax error\n";
}
throw (new IOException(error));
}
return shot_list;
}
static String processShotExpression(String shotExpr, String exp)
{
String outStr = "";
int idx = 0;
int prevIdx = 0;
shotExpr = shotExpr.trim();
if (exp == null || exp.length() == 0)
return shotExpr;
while ((idx = shotExpr.indexOf('0', prevIdx)) != -1)
{
if ((idx > 0 && Character.isLetterOrDigit(shotExpr.charAt(idx - 1)))
|| (idx < (shotExpr.length() - 1) && Character.isLetterOrDigit(shotExpr.charAt(idx + 1))))
{
outStr += shotExpr.substring(prevIdx, idx + 1);
}
else
{
outStr += shotExpr.substring(prevIdx, idx) + "current_shot(\"" + exp + "\")";
}
prevIdx = idx + 1;
}
if (outStr.length() == 0)
return shotExpr;
else
outStr += (prevIdx < shotExpr.length() ? shotExpr.substring(prevIdx, shotExpr.length()) : "");
return outStr;
}
protected static String RemoveNewLineCode(String s)
{
String y_new = new String();
int new_pos = 0, old_pos = 0;
while ((new_pos = s.indexOf("|||", old_pos)) != -1)
{
y_new = y_new.concat(s.substring(old_pos, new_pos));
old_pos = new_pos + "|||".length();
y_new += '\n';
}
y_new = y_new.concat(s.substring(old_pos, s.length()));
return y_new;
}
static String TrimString(String s)
{
String s_new = new String();
int new_pos = 0, old_pos = 0;
while ((new_pos = s.indexOf(" ", old_pos)) != -1)
{
s_new = s_new.concat(s.substring(old_pos, new_pos));
old_pos = new_pos + " ".length();
}
s_new = s_new.concat(s.substring(old_pos, s.length()));
return s_new;
}
public static void WriteLine(PrintWriter out, String prompt, String value)
{
if (value != null && value.length() != 0)
{
out.println(prompt + value);
}
}
public Waveform wave;
public int num_waves;
public boolean x_log, y_log;
public String in_label[], in_x[], in_y[], in_up_err[], in_low_err[];
// Prameter used to evaluate waveform
public String in_xmin, in_xmax, in_ymax, in_ymin, in_timemax, in_timemin;
public String in_title, in_xlabel, in_ylabel;
public String in_def_node;
public boolean in_upd_limits = true;
public String experiment;
public int in_grid_mode;
public int height;
public boolean isContinuousUpdate = false;
public String in_shot;
public int num_shot = 1;
private boolean modified = true;
// Used by GetShotArray methods to define
// if required shots must be evaluate
// private String shot_str_eval = null;
// private long shot_list[] = null;
public boolean reversed = false;
public boolean show_legend = false;
public double legend_x;
public double legend_y;
public int markers_step[];
public int markers[];
public int colors_idx[];
public boolean interpolates[];
public int mode2D[];
public int mode1D[];
public long shots[];
public String error;
private String curr_error;
public String provider;
public String w_error[];
public Signal signals[];
public double xmax, xmin, ymax, ymin, timemax, timemin;
public String title, xlabel, ylabel, zlabel;
public DataProvider dp;
// Used for asynchronous Update
public boolean asynch_update = true;
Signal wave_signals[];
protected boolean evaluated[];
public boolean is_image = false;
public boolean keep_ratio = true;
public boolean horizontal_flip = false;
public boolean vertical_flip = false;
public int signal_select = -1;
private Frames frames;
// True when a signal is added
protected boolean add_signal = false;
protected boolean is_signal_added = false;
public ColorMap colorMap = new ColorMap();
boolean xLimitsLong;
long xminLong = 0;
long xmaxLong = 0;
public WaveInterface()
{
CreateWaveInterface(null, null);
}
public WaveInterface(DataProvider dp)
{
CreateWaveInterface(null, dp);
}
public WaveInterface(Waveform wave)
{
CreateWaveInterface(wave, null);
}
public WaveInterface(Waveform wave, DataProvider dp)
{
CreateWaveInterface(wave, dp);
}
public void AddFrames(String frames)
{
AddFrames(frames, null);
}
public void AddFrames(String frames, String frames_time)
{
SetAsImage(true);
in_x = new String[1];
in_y = new String[1];
in_x[0] = frames_time;
in_y[0] = frames;
}
public boolean AddSignal(String y_expr)
{
return AddSignal("", y_expr);
}
public boolean AddSignal(String x_expr, String y_expr)
{
final String x[] = new String[1];
final String y[] = new String[1];
x[0] = x_expr;
y[0] = y_expr;
return AddSignals(x, y);
}
public boolean AddSignals(String x_expr[], String y_expr[])
{
if (x_expr.length != y_expr.length || x_expr.length == 0)
return false;
int new_num_waves;
int num_sig = x_expr.length;
boolean is_new[] = null;
if (num_waves != 0)
{
is_new = new boolean[x_expr.length];
for (int j = 0; j < x_expr.length; j++)
{
is_new[j] = true;
for (int i = 0; i < num_waves; i++)
{
if (y_expr[j].equals(in_y[i]) && (in_x[i] != null && x_expr[j].equals(in_x[i])))
{
/*
* if(evaluated != null && evaluated[i]) return true; else return false;
*/
is_new[j] = false;
num_sig--;
}
}
}
if (num_sig == 0)
return true;
new_num_waves = num_waves + (num_shot != 0 ? num_shot : 1) * num_sig;
}
else
new_num_waves = x_expr.length;
final String new_in_label[] = new String[new_num_waves];
final String new_in_x[] = new String[new_num_waves];
final String new_in_y[] = new String[new_num_waves];
final String new_in_up_err[] = new String[new_num_waves];
final String new_in_low_err[] = new String[new_num_waves];
final int new_markers[] = new int[new_num_waves];
final int new_markers_step[] = new int[new_num_waves];
final int new_colors_idx[] = new int[new_num_waves];
final boolean new_interpolates[] = new boolean[new_num_waves];
final int new_mode2D[] = new int[new_num_waves];
final int new_mode1D[] = new int[new_num_waves];
long new_shots[] = null;
if (shots != null)
new_shots = new long[new_num_waves];
final boolean new_evaluated[] = new boolean[new_num_waves];
final Signal new_signals[] = new Signal[new_num_waves];
final String new_w_error[] = new String[new_num_waves];
for (int i = 0; i < num_waves; i++)
{
new_in_label[i] = in_label[i];
new_in_x[i] = in_x[i];
new_in_y[i] = in_y[i];
new_in_up_err[i] = in_up_err[i];
new_in_low_err[i] = in_low_err[i];
new_markers[i] = markers[i];
new_markers_step[i] = markers_step[i];
new_colors_idx[i] = colors_idx[i];
new_interpolates[i] = interpolates[i];
new_mode2D[i] = mode2D[i];
new_mode1D[i] = mode1D[i];
if (shots != null)
new_shots[i] = shots[i];
if (evaluated != null)
new_evaluated[i] = evaluated[i];
else
new_evaluated[i] = false;
if (signals != null)
new_signals[i] = signals[i];
if (w_error != null)
new_w_error[i] = w_error[i];
}
for (int i = 0, k = num_waves; i < x_expr.length; i++)
{
if (is_new != null && !is_new[i])
continue;
for (int j = 0; j < num_shot; j++)
{
new_in_label[k] = "";
new_in_x[k] = new String(x_expr[i]);
new_in_y[k] = new String(y_expr[i]);
new_in_up_err[k] = "";
new_in_low_err[k] = "";
new_markers[k] = 0;
new_markers_step[k] = 1;
if (auto_color_on_expr)
new_colors_idx[k] = (k - j) % Waveform.colors.length;
else
new_colors_idx[k] = j % Waveform.colors.length;
new_interpolates[k] = true;
new_evaluated[k] = false;
new_mode2D[k] = Signal.MODE_XZ;
new_mode1D[k] = Signal.MODE_LINE;
if (shots != null && shots.length != 0 && num_shot > 0)
new_shots[k] = shots[j];
k++;
}
}
in_label = new_in_label;
in_x = new_in_x;
in_y = new_in_y;
in_up_err = new_in_up_err;
in_low_err = new_in_low_err;
markers = new_markers;
markers_step = new_markers_step;
colors_idx = new_colors_idx;
interpolates = new_interpolates;
mode2D = new_mode2D;
mode1D = new_mode1D;
shots = new_shots;
num_waves = new_num_waves;
evaluated = new_evaluated;
signals = new_signals;
w_error = new_w_error;
add_signal = true;
return true;
}
public boolean allEvaluated()
{
if (evaluated == null)
return false;
for (int curr_wave = 0; curr_wave < num_waves; curr_wave++)
if (!evaluated[curr_wave])
{
modified = true;
return false;
}
modified = false;
return true;
}
private void CreateNewFramesClass(int image_type) throws IOException
{
if (image_type == FrameData.JAI_IMAGE)
{
try
{
final Class cl = Class.forName("jScope.FrameJAI");
frames = (Frames) cl.newInstance();
}
catch (final Exception e)
{
throw (new IOException("Java Advanced Imaging must be installed to show this type of image"));
}
}
else
{
frames = new Frames();
frames.setColorMap(colorMap);
}
}
private void CreateWaveInterface(Waveform wave, DataProvider dp)
{
this.wave = wave;
this.dp = dp;
if (dp == null)
experiment = null;
shots = null;
in_xmin = in_xmax = in_ymin = in_ymax = in_title = null;
in_xlabel = in_ylabel = in_timemax = in_timemin = null;
markers = null;
interpolates = null;
mode2D = null;
mode1D = null;
x_log = y_log = false;
in_upd_limits = true;
show_legend = false;
reversed = false;
}
public void Erase()
{
num_waves = 0;
in_label = null;
in_x = null;
in_y = null;
in_up_err = null;
in_low_err = null;
in_xmin = null;
in_xmax = null;
in_ymax = null;
in_ymin = null;
in_timemax = null;
in_timemin = null;
in_title = null;
in_xlabel = null;
in_ylabel = null;
experiment = null;
in_shot = null;
num_shot = 1;
modified = true;
markers_step = null;
markers = null;
colors_idx = null;
interpolates = null;
mode2D = null;
mode1D = null;
shots = null;
error = null;
curr_error = null;
w_error = null;
signals = null;
title = null;
xlabel = null;
ylabel = null;
is_image = false;
keep_ratio = true;
horizontal_flip = false;
vertical_flip = false;
frames = null;
show_legend = false;
wave_signals = null;
evaluated = null;
}
public synchronized boolean EvaluateOthers()
{
int curr_wave;
if (is_image)
{
if (!evaluated[0])
{
InitializeFrames();
if (frames != null)
frames.SetViewRect((int) xmin, (int) ymin, (int) xmax, (int) ymax);
error = curr_error;
}
return false;
}
if (evaluated == null)
{
signals = null;
return true;
}
boolean retStatus = true;
for (curr_wave = 0; curr_wave < num_waves; curr_wave++)
{
if (!evaluated[curr_wave] && !(!interpolates[curr_wave] && this.markers[curr_wave] == Signal.NONE))
{
w_error[curr_wave] = null;
try
{
signals[curr_wave] = GetSignal(curr_wave, xmin, xmax);
evaluated[curr_wave] = true;
}
catch (final Exception exc)
{
signals[curr_wave] = null;
curr_error = exc.getMessage();
retStatus = false;
}
if (signals[curr_wave] == null)
{
w_error[curr_wave] = curr_error;
evaluated[curr_wave] = false;
}
else
{
sig_box.AddSignal(in_x[curr_wave], in_y[curr_wave]);
try
{
setLimits(signals[curr_wave]);
}
catch (final Exception exc)
{
signals[curr_wave] = null;
w_error[curr_wave] = exc.getMessage();
retStatus = false;
}
}
}
}
modified = false;
return retStatus;
}
public synchronized void EvaluateShot(long shot) throws Exception
{
int curr_wave;
if (is_image)
return;
// dp.enableAsyncUpdate(false);
for (curr_wave = 0; curr_wave < num_waves; curr_wave++)
{
if ((shot == 0) || (shots[curr_wave] == shot && !evaluated[curr_wave]
&& (interpolates[curr_wave] || markers[curr_wave] != Signal.NONE)))
{
w_error[curr_wave] = null;
try
{
signals[curr_wave] = GetSignal(curr_wave, -Double.MAX_VALUE, Double.MAX_VALUE);
evaluated[curr_wave] = true;
}
catch (final Exception exc)
{
signals[curr_wave] = null;
w_error[curr_wave] = exc.getMessage();
}
if (signals[curr_wave] == null)
{
w_error[curr_wave] = curr_error;
evaluated[curr_wave] = false;
}
else
{
sig_box.AddSignal(in_x[curr_wave], in_y[curr_wave]);
setLimits(signals[curr_wave]);
}
}
}
// dp.enableAsyncUpdate(true);
}
public ColorMap getColorMap()
{ return colorMap; }
public DataProvider getDataProvider()
{ return dp; }
// Try to convert the passed string to a date. Return the converted time in long
// format if it succeeds, -1 otherwise
long getDate(String inVal)
{
try
{
final Calendar cal = Calendar.getInstance();
// cal.setTimeZone(TimeZone.getTimeZone("GMT+00"));
// DateFormat df = new SimpleDateFormat("d-MMM-yyyy HH:mm z");
final DateFormat df = new SimpleDateFormat("d-MMM-yyyy HH:mm");
// Date date = df.parse(inVal + " GMT");
final Date date = df.parse(inVal);
cal.setTime(date);
final long javaTime = cal.getTime().getTime();
return javaTime;
}
catch (final Exception exc)
{
return -1;
}
}
public String getErrorTitle()
{ return getErrorTitle(brief_error); }
public String getErrorTitle(boolean brief)
{
int n_error = 0;
String er = error;
if (num_waves == 0 || (is_image && frames == null))
{
if (error != null)
if (brief)
er = GetFirstLine(new String(error));
return er;
}
for (int ii = 0; ii < num_waves; ii++)
{
if (w_error != null && w_error[ii] != null)
n_error++;
}
if (error == null && n_error > 1 && n_error == num_waves)
{
er = "Evaluation error on all signals";
}
else
{
if (error != null)
er = error;
else
{
if (n_error == 1 && num_waves == 1)
{
er = w_error[0];
}
else if (n_error > 0)
er = "< Evaluation error on " + n_error + " signal" + (n_error > 1 ? "s" : "") + " >";
}
}
if (er != null && brief)
{
final int idx = (er.indexOf('\n') == -1 ? er.length() : er.indexOf('\n'));
er = er.substring(0, idx);
}
return er;
}
private String GetFirstLine(String str)
{
final int idx = str.indexOf("\n");
if (idx != -1)
return str.substring(0, idx);
else
return str;
}
public Frames getFrames()
{ return frames; }
public boolean getModified()
{ return modified; }
public int GetNumEvaluatedSignal()
{
if (signals == null)
return 0;
int i, n = 0;
for (i = 0; i < signals.length; i++)
if (signals[i] != null)
n++;
return n;
}
public long[] GetShotArray(String in_shots) throws IOException
{
final long curr_shots[] = GetShotArray(in_shots, experiment, dp);
return curr_shots;
}
private Signal GetSignal(int curr_wave, double xmin, double xmax) throws IOException
{
Signal out_signal = null;
final int mode = this.wave.GetMode();
try
{
this.wave.SetMode(Waveform.MODE_WAIT);
if (in_y[curr_wave] == null)
{
curr_error = "Missing Y value";
this.wave.SetMode(mode);
return null;
}
synchronized (dp)
{
out_signal = GetSignalFromProvider(curr_wave, xmin, xmax);
}
if (out_signal != null)
{
if (xmin > xmax)
xmin = xmax;
if (ymin > ymax)
ymin = ymax;
out_signal.setXLimits(xmin, xmax, Signal.AT_CREATION | Signal.FIXED_LIMIT);
if (in_ymax != null && (in_ymax.trim()).length() != 0 && in_upd_limits)
out_signal.setYmax(ymax, Signal.AT_CREATION | Signal.FIXED_LIMIT);
if (in_ymin != null && (in_ymin.trim()).length() != 0 && in_upd_limits)
out_signal.setYmin(ymin, Signal.AT_CREATION | Signal.FIXED_LIMIT);
}
this.wave.SetMode(mode);
}
catch (final IOException exc)
{
this.wave.SetMode(mode);
throw (exc);
}
return out_signal;
}
private Signal GetSignalFromProvider(int curr_wave, double xmin, double xmax) throws IOException
{
WaveData up_err = null, low_err = null;
WaveData wd = null;
WaveData xwd = null;
int xDimension = 1;
// final int yDimension = 1;
Signal out_signal;
String xlabel = null, ylabel = null, title = null;
if (shots != null && shots.length != 0)
dp.update(experiment, shots[curr_wave]);
else
dp.update(null, 0);
if (dp.getError() != null)
{
error = dp.getError();
return null;
}
if (in_def_node != null && in_def_node.length() > 0)
{
dp.setEnvironment("__default_node = " + in_def_node);
}
else
{
dp.setEnvironment("__default_node = " + experiment + "::TOP");
}
if (dp.getError() != null)
{
error = dp.getError();
return null;
}
if (in_x[curr_wave] != null && (in_x[curr_wave].trim()).length() != 0)
{
wd = dp.getWaveData(in_y[curr_wave], in_x[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
if (wd != null)
{
xlabel = wd.GetXLabel();
ylabel = wd.GetYLabel();
}
if (wd != null && in_up_err != null && in_up_err[curr_wave] != null
&& (in_up_err[curr_wave].trim()).length() != 0)
{
up_err = dp.getWaveData(in_up_err[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
}
if (in_low_err != null && in_low_err[curr_wave] != null && (in_low_err[curr_wave].trim()).length() != 0)
{
low_err = dp.getWaveData(in_low_err[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
}
}
else // X field not defined
{
if (wd == null)
wd = dp.getWaveData(in_y[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
// if (yDimension == 1)
{
if (in_up_err != null && in_up_err[curr_wave] != null && (in_up_err[curr_wave].trim()).length() != 0)
{
up_err = dp.getWaveData(in_up_err[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
}
if (in_low_err != null && in_low_err[curr_wave] != null && (in_low_err[curr_wave].trim()).length() != 0)
{
low_err = dp.getWaveData(in_low_err[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
}
}
}
if (wd == null)
{
curr_error = dp.getError();
return null;
}
// Check for 2-dimensional X axis
if (in_x[curr_wave] != null)
{
xwd = dp.getWaveData(in_x[curr_wave], wave.getRow(), wave.getColumn(), wave.getIndex());
if ((xDimension = xwd.getNumDimension()) == 1)
xwd = null; // xwd is different from null ONLY for bidimensional X axis
}
if (xDimension == 1)
{
if (xLimitsLong)
out_signal = new Signal(wd, xwd, xminLong, xmaxLong, low_err, up_err);
else
out_signal = new Signal(wd, xwd, xmin, xmax, low_err, up_err);
}
else
{
if (xLimitsLong)
out_signal = new Signal(wd, xwd, xminLong, xmaxLong);
else
out_signal = new Signal(wd, xwd, xmin, xmax);
}
// if (yDimension > 1) out_signal.setMode2D(mode2D[curr_wave]); else
out_signal.setMode1D(mode1D[curr_wave]);
if (wd != null)
{
try
{
title = wd.GetTitle();
}
catch (final Exception exc)
{}
}
if (up_err != null && low_err != null)
out_signal.AddAsymError(up_err, low_err);
else if (up_err != null)
out_signal.AddError(up_err);
if (wd != null)
{
try
{
xlabel = wd.GetXLabel();
ylabel = wd.GetYLabel();
}
catch (final Exception exc)
{}
}
out_signal.setLabels(title, xlabel, ylabel, null);
return out_signal;
}
public String[] GetSignalsName()
{
String name[] = null, s;
if (num_waves != 0)
{
final int ns = (num_shot > 0 ? num_shot : 1);
name = new String[num_waves / ns];
for (int i = 0, j = 0; i < num_waves; i += ns)
{
s = (in_label[i] != null && in_label[i].length() != 0) ? in_label[i] : in_y[i];
name[j++] = s;
}
}
return name;
}
public boolean[] GetSignalsState()
{
boolean state[] = null;
if (num_waves != 0)
{
final int ns = (num_shot > 0 ? num_shot : 1);
state = new boolean[num_waves / ns];
for (int i = 0, j = 0; i < num_waves; i += ns)
state[j++] = (interpolates[i] || (markers[i] != Signal.NONE));
}
return state;
}
public boolean GetSignalState(int i)
{
boolean state = false;
// int idx = i * (num_shot > 0 ? num_shot : 1);
if (i < num_waves)
state = (interpolates[i] || (markers[i] != Signal.NONE));
return state;
}
private void InitializeFrames()
{
curr_error = null;
WaveformEvent we;
final int mode = this.wave.GetMode();
this.wave.SetMode(Waveform.MODE_WAIT);
if (in_y[0] == null)
{
curr_error = "Missing Y value";
return;
}
if (shots != null && shots.length != 0)
dp.update(experiment, shots[0]);
else
dp.update(null, 0);
try
{
we = new WaveformEvent(wave, "Loading single or multi frame image");
wave.dispatchWaveformEvent(we);
final FrameData fd = dp.getFrameData(in_y[0], in_x[0], (float) timemin, (float) timemax);
if (fd != null)
{
CreateNewFramesClass(fd.getFrameType());
/*
* frames.setHorizontalFlip(horizontal_flip);
* frames.setVerticalFlip(vertical_flip);
*/
frames.SetFrameData(fd);
if (in_label != null && in_label[0] != null && in_label[0].length() != 0)
frames.setName(in_label[0]);
else
frames.setName(in_y[0]);
evaluated[0] = true;
}
else
{
frames = null;
curr_error = dp.getError();
evaluated[0] = false;
}
// frames.WaitLoadFrame();
this.wave.SetMode(mode);
}
catch (final Throwable e)
{
// e.printStackTrace();
this.wave.SetMode(mode);
frames = null;
curr_error = " Load Frames error " + e.getMessage();
}
}
public boolean isAddSignal()
{ return add_signal; }
public boolean IsSignalAdded()
{
return is_signal_added;
}
public void setAddSignal(boolean add_signal)
{ this.add_signal = add_signal; }
public void SetAsImage(boolean is_image)
{
this.is_image = is_image;
}
public void setColorMap(ColorMap colorMap)
{ this.colorMap = colorMap; }
public void SetDataProvider(DataProvider _dp)
{
dp = _dp;
error = null;
curr_error = null;
w_error = null;
signals = null;
modified = true;
// When change data provide
// shot variable is reset to
// assure shot avaluation
// shot_str_eval = null;
// shot_list = null;
}
public void setExperiment(String experiment)
{ this.experiment = experiment; }
public void setFrames(Frames f)
{ frames = f; }
public void SetIsSignalAdded(boolean is_signal_added)
{
this.is_signal_added = is_signal_added;
}
public void SetLegendPosition(double x, double y)
{
legend_x = x;
legend_y = y;
show_legend = true;
}
public void setLimits()
{
try
{
for (final Signal signal : signals)
if (signal != null)
setLimits(signal);
}
catch (final Exception e)
{}
}
public void setLimits(Signal s) throws Exception
{
s.setXLimits(xmin, xmax, Signal.AT_CREATION);
s.setYmin(ymin, Signal.AT_CREATION);
s.setYmax(ymax, Signal.AT_CREATION);
}
public void setModified(boolean state)
{ modified = state; }
public void setShotArray(String in_shot) throws IOException
{
this.in_shot = in_shot;
final long curr_shots[] = GetShotArray(in_shot);
UpdateShot(curr_shots);
}
public void setSignalState(String name, boolean state)
{
if (num_waves != 0)
{
final int ns = (num_shot == 0) ? 1 : num_shot;
for (int i = 0; i < num_waves; i++)
if (name.equals(in_y[i]) || name.equals(in_label[i]))
{
for (int j = i; j < i + ns; j++)
{
interpolates[j] = state;
markers[i] = Signal.NONE;
}
return;
}
}
}
public void ShowLegend(boolean state)
{
show_legend = state;
}
public synchronized int StartEvaluate() throws IOException
{
error = null;
if (modified)
evaluated = null;
if ((in_y == null || in_x == null))
{
error = "Missing Y or X values";
signals = null;
return 0;
}
if (shots == null && !(experiment == null || experiment.trim().length() == 0))
{
error = "Missing shot value";
signals = null;
}
if (shots != null && (experiment == null || experiment.trim().length() == 0))
{
error = "Missing experiment name";
signals = null;
}
num_waves = in_y.length;
if (modified)
{
if (!is_image)
signals = new Signal[num_waves];
evaluated = new boolean[num_waves];
w_error = new String[num_waves];
}
if (in_x != null && num_waves != in_x.length)
{
error = "X values are different from Y values";
return 0;
}
if (shots != null && shots.length > 0)
{
int i = 0;
do
{
dp.update(experiment, shots[i]);
i++;
}
while (i < shots.length && dp.getError() != null);
}
else
dp.update(null, 0);
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
// Compute title
if (in_title != null && (in_title.trim()).length() != 0)
{
title = dp.getString(in_title, wave.getRow(), wave.getColumn(), wave.getIndex());
if (title == null)
{
error = dp.getError();
return 0;
}
}
// compute limits
if (in_xmin != null && (in_xmin.trim()).length() != 0 && in_upd_limits)
{
xmin = dp.getFloat(in_xmin, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
final long timeLong = getDate(in_xmin);
if (timeLong != -1)
{
xLimitsLong = true;
xminLong = timeLong;
}
}
else
xmin = (!is_image) ? -Double.MAX_VALUE : -1;
if (in_xmax != null && (in_xmax.trim()).length() != 0 && in_upd_limits)
{
xmax = dp.getFloat(in_xmax, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
final long timeLong = getDate(in_xmax);
if (timeLong != -1)
{
xLimitsLong = true;
xmaxLong = timeLong;
}
}
else
xmax = (!is_image) ? Double.MAX_VALUE : -1;
if (in_ymax != null && (in_ymax.trim()).length() != 0 && in_upd_limits)
{
ymax = dp.getFloat(in_ymax, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
}
else
ymax = (!is_image) ? Double.MAX_VALUE : -1;
if (in_ymin != null && (in_ymin.trim()).length() != 0 && in_upd_limits)
{
ymin = dp.getFloat(in_ymin, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
}
else
ymin = (!is_image) ? -Double.MAX_VALUE : -1;
if (is_image)
{
if (in_timemax != null && (in_timemax.trim()).length() != 0)
{
timemax = dp.getFloat(in_timemax, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
}
else
timemax = Double.MAX_VALUE;
if (in_timemin != null && (in_timemin.trim()).length() != 0)
{
timemin = dp.getFloat(in_timemin, wave.getRow(), wave.getColumn(), wave.getIndex());
if (dp.getError() != null)
{
error = dp.getError();
return 0;
}
}
else
timemin = -Double.MAX_VALUE;
}
// Compute x label, y_label
if (in_xlabel != null && (in_xlabel.trim()).length() != 0)
{
xlabel = dp.getString(in_xlabel, wave.getRow(), wave.getColumn(), wave.getIndex());
if (xlabel == null)
{
error = dp.getError();
return 0;
}
}
if (in_ylabel != null && (in_ylabel.trim()).length() != 0)
{
ylabel = dp.getString(in_ylabel, wave.getRow(), wave.getColumn(), wave.getIndex());
if (ylabel == null)
{
error = dp.getError();
return 0;
}
}
if (xmin > xmax)
xmin = xmax;
if (ymin > ymax)
ymin = ymax;
return 1;
}
public boolean UpdateShot(long curr_shots[]) throws IOException
{
int curr_num_shot;
if (curr_shots == null)
{
curr_num_shot = 1;
shots = null;
if (num_shot == 0)
return false;
}
else
curr_num_shot = curr_shots.length;
int num_signal;
int num_expr;
if (num_shot == 0)
{
num_signal = num_waves * curr_num_shot;
num_expr = num_waves;
}
else
{
num_signal = num_waves / num_shot * curr_num_shot;
num_expr = num_waves / num_shot;
}
if (is_image)
{
modified = true;
shots = curr_shots;
return true;
}
if (num_signal == 0)
return false;
modified = true;
final String[] in_label = new String[num_signal];
final String[] in_x = new String[num_signal];
final String[] in_y = new String[num_signal];
final String[] in_up_err = new String[num_signal];
final String[] in_low_err = new String[num_signal];
final int[] markers = new int[num_signal];
final int[] markers_step = new int[num_signal];
final int[] colors_idx = new int[num_signal];
final boolean[] interpolates = new boolean[num_signal];
final int[] mode2D = new int[num_signal];
final int[] mode1D = new int[num_signal];
long[] shots = null;
if (curr_shots != null)
shots = new long[num_signal];
final int sig_idx = (this.num_shot == 0) ? 1 : this.num_shot;
for (int i = 0, k = 0; i < num_expr; i++)
{
for (int j = 0; j < curr_num_shot; j++, k++)
{
in_label[k] = this.in_label[i * sig_idx];
in_x[k] = this.in_x[i * sig_idx];
in_y[k] = this.in_y[i * sig_idx];
if (j < this.num_shot)
{
markers[k] = this.markers[i * this.num_shot + j];
markers_step[k] = this.markers_step[i * this.num_shot + j];
interpolates[k] = this.interpolates[i * this.num_shot + j];
mode2D[k] = this.mode2D[i * this.num_shot + j];
mode1D[k] = this.mode1D[i * this.num_shot + j];
if (curr_shots != null)
shots[k] = curr_shots[j];
in_up_err[k] = this.in_up_err[i * this.num_shot + j];
in_low_err[k] = this.in_low_err[i * this.num_shot + j];
colors_idx[k] = this.colors_idx[i * this.num_shot + j];
}
else
{
markers[k] = this.markers[i * this.num_shot];
markers_step[k] = this.markers_step[i * this.num_shot];
interpolates[k] = this.interpolates[i * this.num_shot];
mode2D[k] = this.mode2D[i * this.num_shot];
mode1D[k] = this.mode1D[i * this.num_shot];
in_up_err[k] = this.in_up_err[i * this.num_shot];
in_low_err[k] = this.in_low_err[i * this.num_shot];
if (auto_color_on_expr)
colors_idx[k] = i % Waveform.colors.length; // this.colors_idx[i * this.num_shot];
else
colors_idx[k] = j % Waveform.colors.length;
if (curr_shots != null)
shots[k] = curr_shots[j];
}
}
}
this.in_label = in_label;
this.in_x = in_x;
this.in_y = in_y;
this.in_up_err = in_up_err;
this.in_low_err = in_low_err;
this.markers = markers;
this.markers_step = markers_step;
this.colors_idx = colors_idx;
this.interpolates = interpolates;
this.mode2D = mode2D;
this.mode1D = mode1D;
this.shots = shots;
if (shots != null)
this.num_shot = curr_num_shot;
else
this.num_shot = 1;
num_waves = num_signal;
return true;
}
}