def post_ilt_2df1(audit, filein, fileout, p_in, f_in, f_out):
"""
This macro realizes the post F1-ILT operation on a 2D spectrum
- smoothing : F2 smoothing of DOSY
%F2-input-domain% time
%F2-output-domain% time
%dimensionality% 2
%author% Marc-Andre Delsuc
%version% 6.0
"""
read_file_2d(audit, filein)
write_file_2d(audit, fileout)
def ilt_2df1(audit, filein_arg, fileout, p_in, f_in, f_out):
"""
This macro realizes the ILT operation on the F1 decay of the 2D
it implements the spectral analysis step :
- damp_width dmin dmax
- minimum S/N
- col_selection
- me_preset
- me_details
size
iteration
ndisp
lambcont
lambsp
miniter
- ILT
- reverse : reverses laplace axis
%F1-input-domain% tabulated
%F1-output-domain% damping
%dimensionality% 2
%author% Marc-Andre Delsuc
%version% 6.0
"""
read_file_2d(audit, filein_arg)
# if complex in t1, assumes it is an error
if (get_itype_2d() >= 2):
itype(get_itype_2d() - 2)
audittrail(audit, "text", "assuming real data-set along F1 !")
# data should be real in F2!
toreal("F2")
tempofile = NPKtempfile('.gs2')
writec(tempofile)
filein = tempofile
# %action% damp_width
# sets-up the border for the laplace spectrum
# %param% damp_width enum diff_standard from_tab defined / default diff_standard
# defines how the window will be defined
# diff_standard is the set-up for a standard solution : 10-5000 um^2 sec-1
# from_tab : the borders are computed from the tabulated values
# defined : the values
# %param% dmin float > 0 / default 10
# %param% dmax float > 0 / default 5000
# %param_cond% [ dmin < dmax ]
set_task("Setting damping window")
if (not key_is_true(p_in, "damp_width")):
p_in["damp_width"] = "diff_standard"
if (p_in["damp_width"] == "diff_standard"):
p_in["dmin"] = 10
p_in["dmax"] = 5000
elif (p_in["damp_width"] == "from_tab"):
p_in["dmin"], p_in["dmax"] = auto_damp_width()
elif (p_in["damp_width"] == "defined"):
if (not key_is_true(p_in, "dmin")):
p_in["dmin"] = 10
if (not key_is_true(p_in, "dmax")):
p_in["dmax"] = 5000
else:
raise "wrong value for damp_width"
if (p_in["dmin"] >= p_in["dmax"]):
raise "wrong values for Dmin and Dmax in parameter file"
audittrail(audit, "text", "damping axis window", "Dmin", p_in["dmin"],
"Dmax", p_in["dmax"])
# %action% minimum_sn
# defines the minimum Signal/Noise ratio required for ILT processing
# No data will ever be processed if the S/N is below this value, independently of the col_selection set-up
# It is considered unsafe to go below 10 for this parameter.
# %param% minimum_sn float / default 32.0
if (not key_is_true(p_in, "minimum_sn")):
p_in["minimum_sn"] = 32
audittrail(audit, "text", "minimum Signal/Noise ratio", "minimum_SN",
p_in["minimum_sn"])
# %action% col_selection
# set-up the conditions for selecting the column to be processed by ILT for DOSY
# %param% col_selection boolean / default 0
# %param% col_selection_mode enum valthreshold zone list none / default none
# none : no selection (only minimum_sn stands)
# valthreshold : absolute value theshold, will not be used if below minimum_sn
# zone : only points within that spectral zone will be considered
# list : explicit list of the columns to consider
#
# %param% col_valthreshold float
#
# %param% col_list (integer list)
# list og the columns to consider, given in index (real part only)
#
# %param% col_selection_left float / default 10.0
# the left border of the selection zone, in unit
# %param% col_selection_left_unit enum ppm hz index / default ppm
# the unit in which selection_left is given
# %param% col_selection_right float / default 0.0
# the right border of the selection zone, in unit
# %param% col_selection_right_unit enum ppm hz index / default ppm
# the unit in which selection_right is given
# %param_cond% (col_selection_left{index} < col_selection_right{index})
# %return% col_selection_left
# the left coordinate of the selection zone in index
# %return% col_selection_right
# the right coordinate of the selection zone in index
#
# set-up default
set_task("Columns checking")
to_check = range(1, get_si2_2d() + 1) # inital list of col to check
thresh = get_noise() * p_in["minimum_sn"]
start = 1
end = get_si1_2d()
if (key_is_true(p_in, "col_selection")):
# first setup selection
if ("zone" == p_in["col_selection_mode"]):
if (p_in["col_selection_left_unit"] == 'ppm'):
start = (ptoi(p_in["col_selection_left"], 1, 1))
elif (p_in["col_selection_left_unit"] == 'hz'):
start = (htoi(p_in["col_selection_left"], 1, 1))
elif (p_in["col_selection_left_unit"] == 'index'):
start = p_in["col_selection_left"]
else:
raise "Error with col_selection_left_unit"
if (p_in["col_selection_right_unit"] == 'ppm'):
end = (ptoi(p_in["col_selection_right"], 1, 1))
elif (p_in["col_selection_right_unit"] == 'hz'):
end = (htoi(p_in["col_selection_right"], 1, 1))
elif (p_in["col_selection_right_unit"] == 'index'):
end = p_in["col_selection_right"]
else:
raise "Error with col_selection_right_unit"
start = (max(1, round(start)))
end = (min(get_si2_2d(), round(end)))
if (start > end):
raise "Wrong selection zone coordinates"
to_check = range(start, end + 1)
# set-up threshold
elif ("valthreshold" == p_in["col_selection_mode"]):
thresh = max(thresh, p_in["col_valthreshold"])
elif ("list" == p_in["col_selection_mode"]):
# to_check = p_in["col_list"]
t = p_in.raw("col_list")
to_check = t[1:len(t) - 1].split(
",") # remove ( ) ad split with ","
#eval() should work here, but we have seen a bug for very long strings with jython 2.1
else:
raise "wrong selection mode"
# then do selection
dim(2) # load in dim(1) the first row of the DOSY file
row(1)
dim(1)
l = []
for i in to_check:
if val1d(int(i)) > thresh:
l.append(i)
f_out["col_selection_left"] = start
f_out["col_selection_right"] = end
audittrail(audit, "text", "column selection", "number of selected columns",
len(l))
print("Number of selected colums: %i" % (len(l)))
# %action% me_preset
# presets the MaxEnt parameters to default values
# %param% me_preset_value enum 0 1 2 3 4 5 / default 3
# sets the parameter for a balance between speed (1) and quality (5), 0 is for fit
set_task("Setting Maximum Entropy parameters")
me = maxent_state()
if (key_is_true(p_in, "me_preset_value")):
preset = p_in["me_preset_value"]
else:
preset = 3
me.dosy_me_preset(preset)
# %action% me_details
# if this flag is on, default parameters can be set.
# %param% me_details boolean / default 0
# %param% me_size integer
# %param% me_iteration integer
# %param% me_int_iteration
# %param% me_ncheck integer
# %param% me_lambda_control integer
# %param% me_lambda_speed
# %param% me_algo enum Fit MaxEnt
if (key_is_true(p_in, "me_details")):
if (key_is_true(p_in, "me_size")):
me.set_iltsize(p_in["me_size"])
if (key_is_true(p_in, "me_iteration")):
me.set_iter(p_in["me_iteration"])
if (key_is_true(p_in, "me_int_iteration")):
me.set_miniter(p_in["me_int_iteration"])
if (key_is_true(p_in, "me_ncheck")):
me.set_ndisp(p_in["me_ncheck"])
if (key_is_true(p_in, "me_lambda_control")):
me.set_lambcont(p_in["me_lambda_control"])
if (key_is_true(p_in, "me_lambda_speed")):
me.set_lambsp(p_in["me_lambda_speed"])
if (key_is_true(p_in, "me_algo")):
me.set_iltalgo(p_in["me_algo"])
# set it in kernel
me.copyto_kernel()
audittrail(audit, "text", "Parameters for ILT processing",
"MaxEnt parameters", me.report())
# %action% dump_preset
# dump all the parameters to a gtb file
# usually used to check the parameter or to prepare for a parallel run
# %param% dump_preset boolean / default 0
# %param% dump_preset_file file / default dosy_preset.gtb
if (key_is_true(p_in, "dump_preset")):
p = p_in.copy(
) # first copy everything, then overwrite specific values
p["damp_width"] = "defined"
p["noise"] = f_out["noise_in_f1_domain"]
p["col_selection"] = 1
p["col_selection_mode"] = "list"
p["col_list"] = tuple(l)
p["me_details"] = 1
p["me_size"] = me.get_iltsize()
p["me_iteration"] = me.get_iter()
p["me_int_iteration"] = me.get_miniter()
p["me_ncheck"] = me.get_ndisp()
p["me_lambda_control"] = me.get_lambcont()
p["me_lambda_speed"] = me.get_lambsp()
p["me_algo"] = me.get_iltalgo()
p["execute_ilt"] = 1
p["dump_preset"] = 0 # remove dump_preset
if (key_is_true(p_in, "dump_preset_file")):
preset_file = p_in["dump_preset_file"]
else:
preset_file = "dosy_preset.gtb"
dict_dump(p, preset_file)
audittrail(audit, "text", "parameter dump",
"Parameters for ILT processing have been dumped to",
preset_file)
# %action% ILT
# perform the ILT computation itself
# %param% execute_ilt boolean / default 1
if (key_is_not_false(p_in, "execute_ilt")):
set_task("Starting ilt processing %d" % (len(l)))
t = time.clock()
dosy2d(filein, p_in["dmin"], p_in["dmax"], p_in["dfactor"], me,
l) # hum, a changer ! MAD
t = time.clock() - t
audittrail(audit, "text", "2D ILT computed",
"number of column computed", len(l), "processing time",
str(t) + " sec")
# %action% f1_reverse
# %param% f1_reverse boolean / default 0
if (key_is_true(p_in, "f1_reverse")):
set_task("Reverse F1 axis")
reverse("f1")
audittrail(audit, "text", "Reverse F1 spectral axis")
(sw, fq,
off) = damp_to_ppm(p_in["dmin"],
p_in["dmax"]) # compute and set pseudo ppm values
dim(2)
specw(sw, get_specw_2_2d())
freq(get_freq(), fq, get_freq_2_2d())
offset(off, get_offset_2_2d())
write_file_2d(audit, fileout)
os.unlink(tempofile)
def pre_ilt_2df1(audit, filein, fileout, p_in, f_in, f_out):
"""
This macro realizes the pre operation on each F1 decay of the 2D
it implements data massaging before ILT:
- ilt_set-up
dosy_q2 dosy_tab tosy_q2 tosy_tab
- load tabulated file
file name
- calibration
- F1 noise evaluation
- wrong points filtering
%F1-input-domain% tabulated
%F1-output-domain% tabulated
%dimensionality% 2
%author% Marc-Andre Delsuc
%version% 6.0
"""
read_file_2d(audit, filein)
# if complex in t1, assumes it is an error
if (get_itype_2d() >= 2):
itype(get_itype_2d() - 2)
audittrail(audit, "text", "assuming real data-set along F1 !")
# data should be real in F2!
toreal("f2")
# %action% ilt_set-up
# determines the kind of analysis to perform
# %param% ilt_type enum dosy tosy / default dosy
# %param% sampling_type enum regular tabulated / default regular
# %param% sampling_tab_file file_name
# sampling_type == tabulated implies sampling_tab_file
set_task("ILT set-up and calibration")
if (not key_is_true(p_in, "ilt_type")):
p_in["ilt_type"] = "dosy"
if (not key_is_true(p_in, "sampling_type")):
p_in["sampling_type"] = "regular"
if (p_in["sampling_type"] == "tabulated"):
load_sq_tab(p_in["sampling_tab_file"])
audittrail(audit, "text", "ILT set-up", "type of analysis",
p_in["ilt_type"], "type of sampling", p_in["sampling_type"],
"sampling file", p_in["sampling_tab_file"])
elif (p_in["sampling_type"] == "regular"):
audittrail(audit, "text", "ILT set-up", "type of analysis",
p_in["ilt_type"], "type of sampling", p_in["sampling_type"])
else:
raise ("wrong sampling_type :" + str(p_in["sampling_type"]))
# %action% ilt_tosy_calibration
# Calibrate ilt axis on physical parameters for Tosy
# %param% ilt_tosy_unit enum usec msec sec / default sec
# value of the Laplace axis unity
if (p_in["ilt_type"] == "tosy"):
if (key_is_true(p_in, "ilt_tosy_unit")):
if (p_in["ilt_tosy_unit"] not in ("usec", "msec", "sec")):
raise "wrong value for ilt_tosy_unit, accepted values are usec, msec, sec "
else:
p_in["ilt_tosy_unit"] = "sec"
# %action% ilt_dosy_calibration
# Calibrate ilt axis on physical parameters for Dosy
# %param% dosy_big_delta float
# "Big Delta" : diffusion delay in msec
# %param% dosy_little_delta float
# "little Delta" : gradient duration in msec
# %param% dosy_seq_typ enum pgse ste bpp_ste ste_2echoes bpp_ste_2echoes oneshot / default ste
# the type of DOSY sequence used
# %param% dosy_nucleus enum 1H 2H 13C 15N 17O 19F 31P / default 1H
# the observed nucleus
# %param% recovery_gradient_delay float / default 0.0
# %param_cond% (recovery_gradient_delay >= 0 )
# Gradient recovery delay
# %param% max_grad float nonnegative / default 50.0
# Maximum Amplificator Gradient Intensity, in G/cm
# %param_cond% (max_grad > 0 )
# %param% max_tab float / default 100.0
# Maximum Tabulated Gradient Value in the tabulated file.
# Bruker users use 100 here
# Varian users use 32768 here
# %param_cond% (max_tab > 0 )
# %param% gradient_shape float / default 1.0
# integral factor depending on the gradient shape used
# typical values are :
# 1.0 for rectangular gradients
# 0.6366 = 2/pi for sine bell gradients
# 0.4839496 for 4% truncated gaussian (Bruker gauss.100 file)
# %param_cond% [ (gradient_shape > 0.0 ) and (gradient_shape <= 1.0 )]
if (key_is_true(p_in, "ilt_dosy_calibration")):
set_task("automatic calibration")
bigdelta = p_in["dosy_big_delta"]
litdelta = p_in["dosy_little_delta"]
if (key_is_true(p_in, "dosy_seq_typ")):
seq_type = p_in["dosy_seq_typ"]
if seq_type not in ("pgse", "ste", "bpp_ste", "ste_2echoes",
"bpp_ste_2echoes", "oneshot"):
raise "wrong DOSY sequence type"
else:
seq_type = "ste"
if (key_is_true(p_in, "dosy_nucleus")):
nucleus = p_in["dosy_nucleus"]
if nucleus not in ("1H", "2H", "13C", "15N", "17O", "19F", "31P"):
raise "unknown nucleus type"
else:
nucleus = "1H"
if (key_is_true(p_in, "recovery_gradient_delay")):
recovery = p_in["recovery_gradient_delay"]
else:
recovery = 0.0
if (key_is_true(p_in, "max_grad")):
maxgrad = p_in["max_grad"]
else:
maxgrad = 50.0
if (key_is_true(p_in, "max_tab")):
maxtab = p_in["max_tab"]
else:
maxtab = 100.0
if (key_is_true(p_in, "gradient_shape")):
gradshape = p_in["gradient_shape"]
else:
gradshape = 1.0
dfactor = calibdosy(litdelta, bigdelta, recovery, seq_type, nucleus,
maxgrad, maxtab, gradshape)
audittrail(audit, "text", "DOSY Calibration", "sequence type",
seq_type, "DFACTOR value", dfactor)
p_in["dfactor"] = dfactor
f_out["dfactor"] = dfactor
print("dfactor: %f" % (dfactor))
# F1 noise evaluation
# %action% f1_noise
# evaluate noise, estimated by finding an empty zone on a given 1D spectrum
# %param% f1_noise boolean / default 1
# %param% f1_noise_n integer / default 30
# number of different zones where noise is evaluated
# %param% f1_noise_row integer / default get_si1_2d()
# the index of the row on which the noise is evaluated
# %param% f1_noise_weight float / default 1.0
# the noise used during the MaxEnt iteration is weigthed with this scalar,
# this permits to compensate for over- or under-estimate of the noise level
# %param_cond% [ noise_weight > 0.0 ]
# %return% noise_in_f1_domain
if (key_is_not_false(p_in, "f1_noise")):
set_task("Noise evaluation")
if (not key_is_true(p_in, "f1_noise_n")):
p_in["f1_noise_n"] = 30
if (not key_is_true(p_in, "f1_noise_row")):
p_in["f1_noise_row"] = get_si1_2d()
dim(2)
row(p_in["f1_noise_row"])
dim(1)
spec_noise(p_in["f1_noise_n"])
dim(2)
if key_is_true(p_in, "f1_noise_weight"):
weight = p_in["f1_noise_weight"]
else:
weight = 1.0
if weight != 1.0:
noise(weight * get_noise())
f_out["noise_in_f1_domain"] = get_noise()
audittrail(audit, "text", "Estimated F1 Noise", "Estimated on row #",
p_in["f1_noise_row"], "Noise weighting", weight,
"Noise estimate", f_out["noise_in_f1_domain"])
else:
if key_is_true(p_in, "f1_noise_weight"):
noise(p_in["f1_noise_weight"] * get_noise())
f_out["noise_in_f1_domain"] = get_noise()
audittrail(audit, "text", "Input F1 Noise", "Noise weighting", weight,
"Noise estimate", f_out["noise_in_f1_domain"])
# wrong points filtering
# %action% f1_ignore_point
# enter the list of the point to ignore along the (gradient) axis
# %param% f1_ignore_point boolean / default 0
# %param% f1_ignore_point_list (list of integer) / default ()
# list of points to ignore
# MAD recopier ce code dans un objet "window"
dim(2)
# window("F1",0) # first resets window MAD
if (key_is_true(p_in, "f1_ignore_point")):
if key_is_true(p_in, "f1_ignore_point_list"):
t = p_in.raw("f1_ignore_point_list")
list = t[1:len(t) - 1].split(",")
RemoveRows(list)
writec("RR.gs2")
dim(1)
get("tab")
RemovePoints(list)
put("tab")
writec("RP.gs1")
audittrail(audit, "text", "Point ignored along F1 axis",
"point list :", str(list))
else:
raise "F1_ignore_point_list undefined"
else:
pass
# com_window_mode(0)
write_file_2d(audit, fileout)
# MAD : AD HOC, To be CHANGED !
dim(1)
window_reset()
window_mode(0)