static void PutArray(char dtype, int size, int n_dims, hsize_t *dims, void *ptr, struct descriptor_xd *xd)
{
/***************************************************
Store array of data into MDSplus descriptor. Use simple
array descriptor for one dimensional arrays and a
coefficient array descriptor for multi-dimensional
arrays.
***************************************************/
if (n_dims == 1)
{
DESCRIPTOR_A(dsc,0,0,0,0);
dsc.length = size;
dsc.dtype = dtype;
dsc.pointer = ptr;
dsc.arsize = (int)dims[0] * size;
MdsCopyDxXd(&dsc,xd);
}
else
{
int i;
DESCRIPTOR_A_COEFF(dsc, 0,0,0,8,0);
dsc.length = size;
dsc.dtype = dtype;
dsc.pointer = ptr;
dsc.arsize = size;
dsc.dimct = n_dims;
dsc.a0 = ptr;
for (i=0;i<n_dims;i++)
{
dsc.m[i] = (int)dims[i];
dsc.arsize *= (int)dims[i];
}
MdsCopyDxXd(&dsc,xd);
}
}
EXPORT struct descriptor_xd *MdsEventGetMemState()
{
static EMPTYXD(xd);
DESCRIPTOR_A(stateD, 1, DTYPE_B, 0, 0);
char *state;
int size;
state = EventGetSerializedMemState(&size);
stateD.pointer = state;
stateD.arsize = size;
MdsCopyDxXd((struct descriptor *)&stateD, &xd);
free(state);
return &xd;
}
struct descriptor_xd *MdsFilter(float *in_data, float *in_dim, int *size, float *cut_off, int *num_in_poles)
{
static struct descriptor_xd out_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
DESCRIPTOR_A(data_d, sizeof(float), DTYPE_FLOAT, 0, 0);
DESCRIPTOR_SIGNAL(signal_d, 1, 0, 0);
DESCRIPTOR_DIMENSION(dimension_d, 0, 0);
DESCRIPTOR_WINDOW(window_d, 0, 0, 0);
DESCRIPTOR_RANGE(range_d, 0, 0, 0);
struct descriptor
start_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
end_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
delta_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0},
start_idx_d = {sizeof(int), DTYPE_L, CLASS_S, 0},
end_idx_d = {sizeof(int), DTYPE_L, CLASS_S, 0},
time_at_0_d = {sizeof(float), DTYPE_FLOAT, CLASS_S, 0};
int num_samples, num_poles, start_idx, end_idx, i;
float fc, delta, dummy, *filtered_data, start, end, time_at_0;
float phs_steep, delay;
float *mod, *phs;
static Filter *filter;
if(*num_in_poles > 0)
num_poles = *num_in_poles;
else
num_poles = 10;
signal_d.data = (struct descriptor *)&data_d;
signal_d.dimensions[0] = (struct descriptor *)&dimension_d;
dimension_d.window = (struct descriptor *)&window_d;
dimension_d.axis = (struct descriptor *)&range_d;
window_d.startidx = (struct descriptor *)&start_idx_d;
window_d.endingidx = (struct descriptor *)&end_idx_d;
window_d.value_at_idx0 = (struct descriptor *)&time_at_0_d;
start_idx_d.pointer = (char*)&start_idx;
end_idx_d.pointer = (char *)&end_idx;
time_at_0_d.pointer = (char *)&time_at_0;
range_d.begin = (struct descriptor *)&start_d;
range_d.ending = (struct descriptor *)&end_d;
range_d.deltaval = (struct descriptor *)&delta_d;
start_d.pointer = (char *)&start;
end_d.pointer = (char *)&end;
delta_d.pointer = (char *)δ
num_samples = *size;
fc = 1/ (in_dim[1] - in_dim[0]);
filter = ButtwInvar(cut_off, &dummy, &dummy, &dummy, &fc, &num_poles);
filtered_data = (float *)malloc(num_samples * sizeof(float));
mod = (float *)malloc(sizeof(float) * 1000);
phs = (float *)malloc(sizeof(float) * 1000);
TestFilter(filter, fc, 1000, mod, phs);
for(i = 1; i < 1000 - 1 && !isnan(phs[i]) && !isnan(phs[i+1]) && phs[i] > phs[i+1]; i++);
if(i > 1 && i < 1000)
{
phs_steep = (phs[1] - phs[i])/((i/1000.) * fc/2.);
delay = phs_steep/(2*PI);
}
free((char *)mod);
free((char *)phs);
DoFilter(filter, in_data, filtered_data, &num_samples);
FreeFilter(filter);
data_d.pointer = (char *)filtered_data;
data_d.arsize = num_samples * sizeof(float);
start = in_dim[0]-delay;
end = in_dim[num_samples - 1]-delay;
delta = in_dim[1] - in_dim[0];
start_idx = 0;
end_idx = num_samples - 1;
time_at_0 = in_dim[0] - delay;
MdsCopyDxXd((struct descriptor *)&signal_d, &out_xd);
free((char *)filtered_data);
return &out_xd;
}
int mit_clock__get_setup(Dptr niddsc_ptr, Dptr method, DecoderSetup *setup, EventMask *event_mask, Dptr *output)
{
int status;
InGet_setupStruct s;
status = mit_clock___get_setup(niddsc_ptr,&s);
if (status & 1)
{
float duty_cycle;
int invert = 0;
static float frequency[2];
float max_period;
float period;
static float dt;
DESCRIPTOR_FLOAT(dt_dsc,&dt);
int pulses;
int clock_source;
static DESCRIPTOR(expr, "* : * : $");
static EMPTYXD(out);
DESCRIPTOR_A(frequency_a,sizeof(float),DTYPE_NATIVE_FLOAT,(char *)frequency,sizeof(frequency));
memset(event_mask,0,sizeof(EventMask));
status = TdiData(s.frequency,(struct descriptor *)&frequency_a MDS_END_ARG);
if (!(status & 1))
{
status = TIMING$_INVCLKFRQ;
goto error;
}
if (frequency[1] == frequency[0])
duty_cycle = .5;
else if (frequency[1] < 0.0)
{
invert = 1;
duty_cycle = -frequency[1];
}
else if (frequency[1] > 0.0)
duty_cycle = frequency[1];
if ( (frequency[0] <= 0.0) || (duty_cycle <= 0.0) || (duty_cycle >= 1.0) )
{
status = TIMING$_INVCLKFRQ;
goto error;
}
max_period = 1/frequency[0];
for (clock_source = EXT_1MHZ, period = 1E-6;
period * 65534 < max_period && clock_source <= EXT_100HZ; clock_source++, period *= 10);
if (clock_source > EXT_100HZ)
{
status = TIMING$_INVCLKFRQ;
goto error;
}
setup->output_control = TOGGLE;
setup->start_high = 0;
setup->count_up = 0;
setup->bcd_count = 0;
setup->repeat_count = 1;
setup->double_load = 1;
setup->special_gate = 0;
setup->clock_source = clock_source;
setup->falling_edge = 0;
setup->gating = GATE_NONE;
pulses = max_period/period + .4999;
setup->load = pulses * duty_cycle + .4999;
setup->hold = pulses - setup->load;
if (setup->load == 0)
{
setup->load++;
setup->hold--;
}
if (setup->hold == 0)
{
setup->load--;
setup->hold++;
}
dt = period*(setup->load + setup->hold);
if (invert)
{
int tmp = setup->load;
setup->load = setup->hold;
setup->hold = tmp;
setup->start_high = 1;
}
status = TdiCompile(&expr, &dt_dsc, &out MDS_END_ARG);
if (status&1) {
static int output_nid;
static DESCRIPTOR_NID(output_dsc,(char *)&output_nid);
output_nid = s.head_nid + MIT_CLOCK_N_OUTPUT;
status = TreePutRecord(output_nid, (struct descriptor *)&out,0);
if (status&1) *output = &output_dsc; else *output=0;
}
else
*output = 0;
GenDeviceFree(&s);
}
return status;
error:
GenDeviceFree(&s);
return status;
}
static void StoreSignal(int nid,
int num,
float *v,
TIME *t,
struct descriptor_xd *limits,
int sort)
{
DESCRIPTOR_A(vals, sizeof(float), DTYPE_NATIVE_FLOAT, 0, 0);
DESCRIPTOR_A(tims, sizeof(TIME), DTYPE_QU, 0, 0);
int status;
static struct descriptor_xd tmp_xd = {0, DTYPE_DSC, CLASS_XD, 0, 0};
static struct descriptor_xd values = {0, DTYPE_DSC, CLASS_XD, 0, 0};
static struct descriptor_xd times = {0, DTYPE_DSC, CLASS_XD, 0, 0};
static DESCRIPTOR_SIGNAL_1(signal, &values, 0, ×);
vals.pointer = (char *)v;
vals.arsize = num * sizeof(float);
tims.pointer = (char *)t;
tims.arsize = num * sizeof(TIME);
if (limits->l_length) {
static struct descriptor_xd selections = {0,DTYPE_DSC,CLASS_XD,0,0};
static DESCRIPTOR(select, "(($1 > $2[0]) && ($1 < $2[1]))");
static DESCRIPTOR(pack, "PACK($, $)");
TdiExecute(&select, &vals, limits, &selections MDS_END_ARG);
TdiExecute(&pack, &vals, &selections, &values MDS_END_ARG);
TdiExecute(&pack, &tims, &selections, × MDS_END_ARG);
MdsFree1Dx(&selections,0);
}
else {
MdsCopyDxXd((struct descriptor *)&tims, ×);
MdsCopyDxXd((struct descriptor *)&vals, &values);
}
status = TreeGetRecord(nid, &tmp_xd);
if (status&1) {
static struct descriptor_xd value = {0,DTYPE_DSC,CLASS_XD,0,0};
static struct descriptor_xd time = {0,DTYPE_DSC,CLASS_XD,0,0};
static DESCRIPTOR(sorted_times,"SORT($)");
static DESCRIPTOR(dim_of, "DIM_OF($)");
static DESCRIPTOR(val_of, "DATA($)");
static DESCRIPTOR(set_range, "SET_RANGE(SIZE($1), $1)");
TdiExecute(&dim_of, &tmp_xd, &time MDS_END_ARG);
TdiExecute(&val_of, &tmp_xd, &value MDS_END_ARG);
TdiVector(&value,&values,&values MDS_END_ARG);
TdiVector(&time,×,× MDS_END_ARG);
TdiExecute(&set_range, &values, &values MDS_END_ARG);
TdiExecute(&set_range, ×, × MDS_END_ARG);
if (sort)
{
static struct descriptor_xd index = {0,DTYPE_DSC,CLASS_XD,0,0};
static struct descriptor_xd sorted_values = {0,DTYPE_DSC,CLASS_XD,0,0};
static struct descriptor_xd sorted_times = {0,DTYPE_DSC,CLASS_XD,0,0};
static struct descriptor_xd sorted_signal = {0,DTYPE_DSC,CLASS_XD,0,0};
static DESCRIPTOR_SIGNAL_1(signal, &sorted_values, 0, &sorted_times);
TdiSort(times.pointer,&index MDS_END_ARG);
TdiSubscript(times.pointer,index.pointer,&sorted_times MDS_END_ARG);
TdiSubscript(values.pointer,index.pointer,&sorted_values MDS_END_ARG);
TdiUnion(sorted_times.pointer,&time MDS_END_ARG);
TdiSubscript(&signal,time.pointer,&sorted_signal MDS_END_ARG);
status = TreePutRecord(nid, (struct descriptor *)&sorted_signal,0);
MdsFree1Dx(&index,0);
MdsFree1Dx(&sorted_values,0);
MdsFree1Dx(&sorted_times,0);
}
else
status = TreePutRecord(nid, (struct descriptor *)&signal,0);
MdsFree1Dx(&value,0);
MdsFree1Dx(&time,0);
}
else {
signal.data = (struct descriptor *)&vals;
signal.dimensions[0] = (struct descriptor *)&tims;
status = TreePutRecord(nid, (struct descriptor *)&signal,0);
}
MdsFree1Dx(&tmp_xd,0);
}
