def _resolve_parameter_transform(parameter_transform):
"""Resolves input parameter transforms to actual objects.
Args:
parameter_transform
(str or :class:`~mdt.model_building.parameter_functions.transformations.AbstractTransformation`):
a parameter transformation name (with or without the postfix ``Transform``) or an actual object we
just return.
Returns:
mdt.model_building.parameter_functions.transformations.AbstractTransformation: an actual transformation object
Raises:
ValueError: if the parameter transformation could not be resolved.
"""
if isinstance(parameter_transform, AbstractTransformation):
return parameter_transform
if has_component('parameter_transforms', parameter_transform):
return get_component('parameter_transforms', parameter_transform)()
if has_component('parameter_transforms',
parameter_transform + 'Transform'):
return get_component('parameter_transforms',
parameter_transform + 'Transform')()
raise ValueError(
'Could not resolve the parameter transformation "{}"'.format(
parameter_transform))
def _resolve_dependencies(dependencies):
"""Resolve the dependency list such that the result contains all functions.
Args:
dependencies (list): the list of dependencies as given by the user. Elements can either include actual
instances of :class:`~mot.library_functions.CLLibrary` or strings with the name of libraries or
other compartments to load.
Returns:
list: a new list with the string elements resolved as :class:`~mot.library_functions.CLLibrary`.
"""
if not len(dependencies):
return []
result = []
for dependency in dependencies:
if isinstance(dependency, str):
if has_component('library_functions', dependency):
result.append(get_component('library_functions', dependency)())
else:
result.append(
get_component('compartment_models', dependency)())
else:
result.append(dependency)
return result
def _resolve_parameters(parameter_list):
"""Convert all the parameters in the given parameter list to actual parameter objects.
This will load all the parameters as :class:`~mdt.model_building.parameters.LibraryParameter`.
Args:
parameter_list (list): a list containing a mix of either parameter objects or strings. If it is a parameter
we add a copy of it to the return list. If it is a string we will autoload it.
Returns:
list: the list of actual parameter objects
"""
parameters = []
for item in parameter_list:
if isinstance(item, str):
if has_component('parameters', item):
param = get_component('parameters', item)()
parameters.append(LibraryParameter(param.data_type, item))
else:
parameters.append(LibraryParameter(SimpleCLDataType.from_string('double'), item))
elif isinstance(item, (tuple, list)):
parameters.append(SimpleCLFunctionParameter(item[0], item[1]))
else:
parameters.append(deepcopy(item))
return parameters
def _resolve_parameters(parameter_list, compartment_name):
"""Convert all the parameters in the given parameter list to actual parameter objects.
Args:
parameter_list (list): a list containing a mix of either parameter objects, strings or tuples. If it is a
parameter we add a copy of it to the return list. If it is a string we will autoload it. It is possible to
specify a nickname for that parameter in this compartment using the syntax: ``<param>(<nickname>)``.
Returns:
list: the list of actual parameter objects
"""
if not parameter_list:
return []
parameters = []
for item in parameter_list:
if isinstance(item, str):
if item == '@observation':
parameters.append(CurrentObservationParam(name='observation'))
elif item == '@cache':
parameters.append(DataCacheParameter(compartment_name, 'cache'))
else:
if '(' in item:
param_name = item[:item.index('(')].strip()
nickname = item[item.index('(')+1:item.index(')')].strip()
else:
param_name = item
nickname = None
parameters.append(get_component('parameters', param_name)(nickname=nickname))
elif isinstance(item, (tuple, list)):
parameters.append(SimpleCLFunctionParameter(item[0], item[1]))
else:
parameters.append(deepcopy(item))
return parameters
def _resolve_signal_noise_model(signal_noise_function):
"""Resolve the signal noise function from a string if necessary.
The composite models accept signal noise functions as a string and as a object. This function
resolves the strings if a string is given, else it returns the object passed.
Args:
signal_noise_function (str or object): the signal noise function to resolve to an object
Returns:
mdt.model_building.signal_noise_models.SignalNoiseModel: the signal noise function to use
"""
if isinstance(signal_noise_function, str):
return get_component('signal_noise_functions', signal_noise_function)()
else:
return signal_noise_function
def _resolve_likelihood_function(likelihood_function):
"""Resolve the likelihood function from a string if necessary.
The composite models accept likelihood functions as a string and as a object. This function
resolves the strings if a string is given, else it returns the object passed.
Args:
likelihood_function (str or object): the likelihood function to resolve to an object
Returns:
mdt.model_building.likelihood_models.LikelihoodFunction: the likelihood function to use
"""
if isinstance(likelihood_function, str):
return get_component('likelihood_functions', likelihood_function)()
else:
return likelihood_function
def model(self, ast):
if isinstance(ast, str):
return get_component('compartment_models', ast)()
else:
return get_component('compartment_models', ast[0])(ast[2])
def _get_compute_function(param_names):
def get_param_cl_ref(param_name):
return 'parameters[{}]'.format(param_names.index(param_name))
param_expansions = [
'mot_float_type {} = params[{}];'.format(name, ind)
for ind, name in enumerate(param_names)
]
return parse_cl_function(
'''
double apparent_kurtosis(
global mot_float_type* params,
float4 direction,
float4 vec0,
float4 vec1,
float4 vec2){
''' + '\n'.join(param_expansions) + '''
double adc = d * pown(dot(vec0, direction), 2) +
dperp0 * pown(dot(vec1, direction), 2) +
dperp1 * pown(dot(vec2, direction), 2);
double tensor_md = (d + dperp0 + dperp1) / 3.0;
double kurtosis_sum = KurtosisMultiplication(
W_0000, W_1111, W_2222, W_1000, W_2000, W_1110,
W_2220, W_2111, W_2221, W_1100, W_2200, W_2211,
W_2100, W_2110, W_2210, direction);
return pown(tensor_md / adc, 2) * kurtosis_sum;
}
void get_principal_and_perpendicular_eigenvector(
mot_float_type d,
mot_float_type dperp0,
mot_float_type dperp1,
float4* vec0,
float4* vec1,
float4* vec2,
float4** principal_vec,
float4** perpendicular_vec){
if(d >= dperp0 && d >= dperp1){
*principal_vec = vec0;
*perpendicular_vec = vec1;
}
if(dperp0 >= d && dperp0 >= dperp1){
*principal_vec = vec1;
*perpendicular_vec = vec0;
}
*principal_vec = vec2;
*perpendicular_vec = vec0;
}
void calculate_measures(global mot_float_type* parameters,
global float4* directions,
uint nmr_directions,
uint nmr_radial_directions,
global float* mks,
global float* aks,
global float* rks){
int i, j;
float4 vec0, vec1, vec2;
TensorSphericalToCartesian(
''' + get_param_cl_ref('theta') + ''',
''' + get_param_cl_ref('phi') + ''',
''' + get_param_cl_ref('psi') + ''',
&vec0, &vec1, &vec2);
float4* principal_vec;
float4* perpendicular_vec;
get_principal_and_perpendicular_eigenvector(
''' + get_param_cl_ref('d') + ''',
''' + get_param_cl_ref('dperp0') + ''',
''' + get_param_cl_ref('dperp1') + ''',
&vec0, &vec1, &vec2,
&principal_vec, &perpendicular_vec);
// Mean Kurtosis integrated over a set of directions
double mean = 0;
for(i = 0; i < nmr_directions; i++){
mean += apparent_kurtosis(parameters, directions[i], vec0, vec1, vec2);
}
*(mks) = clamp(mean / nmr_directions, 0.0, 3.0);
// Axial Kurtosis over the principal direction of diffusion
*(aks) = clamp(apparent_kurtosis(parameters, *principal_vec, vec0, vec1, vec2), 0.0, 10.0);
// Radial Kurtosis integrated over a unit circle around the principal eigenvector.
mean = 0;
float4 rotated_vec;
for(i = 0; i < nmr_radial_directions; i++){
rotated_vec = RotateOrthogonalVector(*principal_vec, *perpendicular_vec,
i * (2 * M_PI_F) / nmr_radial_directions);
mean += (apparent_kurtosis(parameters, rotated_vec, vec0, vec1, vec2) - mean) / (i + 1);
}
*(rks) = max(mean, 0.0);
}
''',
dependencies=[
get_component('library_functions', 'RotateOrthogonalVector')(),
get_component('library_functions',
'TensorSphericalToCartesian')(),
get_component('library_functions', 'KurtosisMultiplication')()
])
