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')() ])