diff --git a/@MyFit/MyFit.m b/@MyFit/MyFit.m
index a4a08e1..3b286b2 100644
--- a/@MyFit/MyFit.m
+++ b/@MyFit/MyFit.m
@@ -1,599 +1,676 @@
classdef MyFit < dynamicprops
%Note that dynamicprops classes are handle classes.
properties (Access=public)
Data;
init_params=[];
scale_init=[];
lim_lower;
lim_upper;
enable_plot;
plot_handle;
save_name;
save_dir;
%Calibration values supplied externally
CalVals=struct();
init_color='c';
end
properties (GetAccess=public, SetAccess=private)
Fit;
Gui;
Fitdata;
FitStruct;
coeffs;
fit_name='Linear'
end
properties (Access=private)
%Structure used for initializing GUI of userpanel
UserGui;
Parser;
enable_gui=1;
hline_init;
end
properties (Dependent=true)
fit_function;
fit_tex;
fit_params;
fit_param_names;
valid_fit_names;
n_params;
scaled_params;
init_param_fun;
x_vec;
- n_userfields;
+ n_user_fields;
+ user_field_tags;
+ user_field_names;
+ user_field_vals;
+ filename;
end
events
NewFit;
NewInitVal;
end
+ methods (Access=private)
+ %Creates parser for constructor
+ function createParser(this)
+ p=inputParser;
+ addParameter(p,'fit_name','Linear',@ischar)
+ addParameter(p,'Data',MyTrace());
+ addParameter(p,'Fit',MyTrace());
+ addParameter(p,'x',[]);
+ addParameter(p,'y',[]);
+ addParameter(p,'enable_gui',1);
+ addParameter(p,'enable_plot',0);
+ addParameter(p,'plot_handle',[]);
+ addParameter(p,'save_dir',pwd);
+ addParameter(p,'save_name','placeholder');
+ this.Parser=p;
+ end
+
+ end
%%Public methods
methods (Access=public)
%Constructor function
function this=MyFit(varargin)
createFitStruct(this);
createParser(this);
parse(this.Parser,varargin{:});
parseInputs(this);
initCalVals(this);
if ismember('Data',this.Parser.UsingDefaults) &&...
~ismember('x',this.Parser.UsingDefaults) &&...
~ismember('y',this.Parser.UsingDefaults)
this.Data.x=this.Parser.Results.x;
this.Data.y=this.Parser.Results.y;
end
%Sets the scale_init to 1, this is used for the GUI.
this.scale_init=ones(1,this.n_params);
this.init_params=ones(1,this.n_params);
%Creates the structure that contains variables for calibration
%of fit results
createUserGuiStruct(this);
if this.enable_gui; createGui(this); end
%If the data is appropriate, generates initial
%parameters
if validateData(this); genInitParams(this); end
end
%Deletion function of object
function delete(this)
if this.enable_gui
%Avoids loops
set(this.Gui.Window,'CloseRequestFcn','');
%Deletes the figure
delete(this.Gui.Window);
%Removes the figure handle to prevent memory leaks
this.Gui=[];
end
if ~isempty(this.hline_init); delete(this.hline_init); end
if ~isempty(this.Fit.hlines); delete(this.Fit.hlines{:}); end
end
%Close figure callback simply calls delete function for class
function closeFigure(this,~,~)
delete(this);
end
-
+%
+% nmb_fmt_str=repmat(sprintf('%%%i.15e\\t',n),1,length(cell_strings));
+% nmb_fmt_str=[nmb_fmt_str,'\r\n'];
+% % v1=repmat(16,1,100);
+% % v2=repmat(124,1,100);
+% % v3=repmat(12940,1,100);
+% % v4=repmat(129084,1,100);
+% fprintf(fileID,nmb_fmt_str,16,16,16,1e9);
+% fclose(fileID);
+ %Saves the metadata
+ function saveParams(this)
+ assert(~isempty(this.coeffs) && ...
+ length(this.coeffs)==this.n_params,...
+ ['The number of calculated coefficients (%i) is not',...
+ ' equal to the number of parameters (%i).', ...
+ ' Perform a fit before trying to save parameters.'],...
+ length(this.coeffs),this.n_params);
+
+ %Creates combined strings of form: Linewidth (b), where
+ %Linewidth is the parameter name and b is the parameter tag
+ param_headers=cellfun(@(x,y) sprintf('%s (%s)',x,y),...
+ this.fit_param_names, this.fit_params,'UniformOutput',0);
+ user_field_headers=cellfun(@(x,y) ...
+ sprintf('%s. %s',this.UserGui.Fields.(x).parent,y),...
+ this.user_field_tags,this.user_field_names,...
+ 'UniformOutput',0)';
+ headers=[param_headers user_field_headers];
+ n_columns=length(headers);
+
+ %Sets the column width. Pads 2 for legibility.
+ col_width=cellfun(@(x) length(x), headers)+2;
+ %Min column width of 24
+ col_width(col_width<24)=24;
+
+ if exist(this.filename,'file')
+ fileID=fopen(this.filename,'a');
+ else
+ fileID=fopen(this.filename,'w');
+ pre_fmt_str=repmat('%%%is\\t',1,n_columns);
+ fmt_str=sprintf([pre_fmt_str,'\r\n'],col_width);
+ fprintf(fileID,fmt_str,headers{:});
+ end
+
+ pre_fmt_str_nmb=repmat('%%%i.15e\\t',1,n_columns);
+ nmb_fmt_str=sprintf([pre_fmt_str_nmb,'\r\n'],col_width);
+ fprintf(fileID,nmb_fmt_str,[this.coeffs,this.user_field_vals']);
+
+ fclose(fileID);
+ end
+
%Initializes the CalVals structure.
function initCalVals(this)
switch this.fit_name
case 'Lorentzian'
- %Ref spacing is the spacing between the
+ %Line spacing is the spacing between all the lines,
+ %i.e. number of lines times the spacing between each
+ %one
this.CalVals.line_spacing=1;
case 'DoubleLorentzian'
this.CalVals.line_spacing=1;
end
end
+
%Fits the trace using currently set parameters, depending on the
%model.
function fitTrace(this)
this.Fit.x=this.x_vec;
switch this.fit_name
case 'Linear'
%Fits polynomial of order 1
this.coeffs=polyfit(this.Data.x,this.Data.y,1);
this.Fit.y=polyval(this.coeffs,this.Fit.x);
case 'Quadratic'
%Fits polynomial of order 2
this.coeffs=polyfit(this.Data.x,this.Data.y,2);
this.Fit.y=polyval(this.coeffs,this.Fit.x);
case {'Exponential','Gaussian'}
doFit(this)
case {'Lorentzian','DoubleLorentzian'}
doFit(this);
otherwise
error('Selected fit is invalid');
end
calcUserParams(this);
%Sets the new initial parameters to be the fitted parameters
this.init_params=this.coeffs;
%Resets the scale variables for the GUI
this.scale_init=ones(1,this.n_params);
%Updates the gui if it is enabled
if this.enable_gui; updateGui(this); end
%Plots the fit if the flag is on
if this.enable_plot; plotFit(this); end
%Triggers new fit event
triggerNewFit(this);
end
function calcUserParams(this)
switch this.fit_name
case 'Lorentzian'
this.mech_lw=this.coeffs(2); %#ok<MCNPR>
this.mech_freq=this.coeffs(3); %#ok<MCNPR>
this.Q=this.mech_freq/this.mech_lw; %#ok<MCNPR>
this.opt_lw=convOptFreq(this,this.coeffs(2)); %#ok<MCNPR>
case 'DoubleLorentzian'
this.opt_lw1=convOptFreq(this,this.coeffs(2)); %#ok<MCNPR>
this.opt_lw2=convOptFreq(this,this.coeffs(5)); %#ok<MCNPR>
splitting=abs(this.coeffs(6)-this.coeffs(3));
this.mode_split=convOptFreq(this,splitting); %#ok<MCNPR>
otherwise
end
end
function real_freq=convOptFreq(this,freq)
real_freq=freq*this.spacing*this.line_no/this.CalVals.line_spacing;
end
function createUserGuiStruct(this)
this.UserGui=struct('Fields',struct(),'Tabs',struct());
switch this.fit_name
case 'Lorentzian'
%Parameters for the tab relating to mechanics
this.UserGui.Tabs.Mech.tab_title='Mech.';
this.UserGui.Tabs.Mech.Children={};
addUserField(this,'Mech','mech_lw','Linewidth (Hz)',1,...
'enable_flag','off')
addUserField(this,'Mech','Q',...
- 'Qualify Factor (\times10^6)',1e6,...
+ 'Qualify Factor (x10^6)',1e6,...
'enable_flag','off','conv_factor',1e6)
addUserField(this,'Mech','mech_freq','Frequency (MHz)',1e6,...
'conv_factor',1e6, 'enable_flag','off')
%Parameters for the tab relating to optics
this.UserGui.Tabs.Opt.tab_title='Optical';
this.UserGui.Tabs.Opt.Children={};
addUserField(this,'Opt','spacing',...
'Line Spacing (MHz)',1e6,'conv_factor',1e6,...
'Callback', @(~,~) calcUserParams(this));
addUserField(this,'Opt','line_no','Number of lines',10,...
'Callback', @(~,~) calcUserParams(this));
addUserField(this,'Opt','opt_lw','Linewidth (MHz)',1e6,...
'enable_flag','off','conv_factor',1e6);
case 'DoubleLorentzian'
this.UserGui.Tabs.Opt.tab_title='Optical';
this.UserGui.Tabs.Opt.Children={};
addUserField(this,'Opt','spacing',...
'Line Spacing (MHz)',1e6,'conv_factor',1e6,...
'Callback', @(~,~) calcUserParams(this));
addUserField(this,'Opt','line_no','Number of lines',10,...
'Callback', @(~,~) calcUserParams(this));
addUserField(this,'Opt','opt_lw1','Linewidth 1 (MHz)',1e6,...
'enable_flag','off','conv_factor',1e6);
addUserField(this,'Opt','opt_lw2','Linewidth 2 (MHz)',1e6,...
'enable_flag','off','conv_factor',1e6);
addUserField(this,'Opt','mode_split',...
'Modal splitting (MHz)',1e6,...
'enable_flag','off','conv_factor',1e6);
otherwise
+ %Do nothing if there is no defined user parameters
end
end
%Parent is the parent tab for the userfield, tag is the tag given
%to the GUI element, title is the text written next to the field,
%initial value is the initial value of the property and change_flag
%determines whether the gui element is enabled for writing or not.
function addUserField(this, parent, tag, title, ...
init_val,varargin)
%Parsing inputs
p=inputParser();
addRequired(p,'Parent');
addRequired(p,'Tag');
addRequired(p,'Title');
addRequired(p,'init_val');
addParameter(p,'enable_flag','on');
addParameter(p,'Callback','');
addParameter(p,'conv_factor',1);
parse(p,parent,tag,title,init_val,varargin{:});
tag=p.Results.Tag;
%Populates the UserGui struct
this.UserGui.Fields.(tag).parent=p.Results.Parent;
this.UserGui.Fields.(tag).title=p.Results.Title;
this.UserGui.Fields.(tag).init_val=p.Results.init_val;
this.UserGui.Fields.(tag).enable_flag=...
p.Results.enable_flag;
this.UserGui.Fields.(tag).conv_factor=p.Results.conv_factor;
this.UserGui.Fields.(tag).Callback=...
p.Results.Callback;
this.UserGui.Tabs.(p.Results.Parent).Children{end+1}=tag;
%Adds the new property to the class
addUserProp(this, tag);
end
function addUserProp(this,tag)
prop=addprop(this,tag);
if this.enable_gui
prop.GetMethod=@(this) getUserVal(this,tag);
prop.SetMethod=@(this, val) setUserVal(this, val, tag);
prop.Dependent=true;
end
end
function val=getUserVal(this, tag)
conv_factor=this.UserGui.Fields.(tag).conv_factor;
val=str2double(this.Gui.([tag,'Edit']).String)*conv_factor;
end
function setUserVal(this, val, tag)
conv_factor=this.UserGui.Fields.(tag).conv_factor;
this.Gui.([tag,'Edit']).String=num2str(val/conv_factor);
end
%% Callbacks
%Save function callback
function saveCallback(this,~,~)
assert(~isempty(this.save_dir),'Save directory is not specified');
assert(ischar(this.save_dir),...
['Save directory is not specified.',...
' Should be of type char but is %s.'], ...
class(this.save_dir))
try
this.Fit.save('name',this.save_name,...
'save_dir',this.save_dir)
catch
error(['Attempted to save to directory %s',...
' with file name %s, but failed'],this.save_dir,...
this.save_name);
end
end
%Callback functions for sliders in GUI. Uses param_ind to find out
%which slider the call is coming from, this was implemented to
%speed up the callback.
function sliderCallback(this, param_ind, hObject, ~)
%Gets the value from the slider
scale=get(hObject,'Value');
%Updates the scale with a new value
this.scale_init(param_ind)=10^((scale-50)/50);
%Updates the edit box with the new value from the slider
set(this.Gui.(sprintf('Edit_%s',this.fit_params{param_ind})),...
'String',sprintf('%3.3e',this.scaled_params(param_ind)));
if this.enable_plot; plotInitFun(this); end
end
%Callback function for edit boxes in GUI
function editCallback(this, hObject, ~)
init_param=str2double(get(hObject,'String'));
tag=get(hObject,'Tag');
%Finds the index where the fit_param name begins (convention is
%after the underscore)
fit_param=tag((strfind(tag,'_')+1):end);
param_ind=strcmp(fit_param,this.fit_params);
%Updates the slider to be such that the scaling is 1
set(this.Gui.(sprintf('Slider_%s',fit_param)),...
'Value',50);
%Updates the correct initial parameter
this.init_params(param_ind)=init_param;
if this.enable_plot; plotInitFun(this); end
%Triggers event for new init values
triggerNewInitVal(this);
end
%Callback function for analyze button in GUI. Checks if the data is
%ready for fitting.
function analyzeCallback(this, ~, ~)
assert(validateData(this),...
['The length of x is %d and the length of y is',...
' %d. The lengths must be equal and greater than ',...
'the number of fit parameters to perform a fit'],...
length(this.Data.x),length(this.Data.y))
fitTrace(this);
end
%Callback for clearing the fits on the axis.
function clearFitCallback(this,~,~)
clearFit(this);
end
%Callback function for generate init parameters button. Updates GUI
%afterwards
function initParamCallback(this,~,~)
genInitParams(this);
updateGui(this);
end
%Generates model-dependent initial parameters, lower and upper
%boundaries.
function genInitParams(this)
assert(validateData(this), ['The data must be vectors of',...
' equal length greater than the number of fit parameters.',...
' Currently the number of fit parameters is %d, the',...
' length of x is %d and the length of y is %d'],...
this.n_params,length(this.Data.x),length(this.Data.y));
%Cell for putting parameters in to be interpreted in the
%parser. Element 1 contains the init params, Element 2 contains
%the lower limits and Element 3 contains the upper limits.
params={};
switch this.fit_name
case 'Exponential'
[params{1},params{2},params{3}]=...
initParamExponential(this.Data.x,this.Data.y);
case 'Gaussian'
[params{1},params{2},params{3}]=...
initParamGaussian(this.Data.x,this.Data.y);
case 'Lorentzian'
[params{1},params{2},params{3}]=...
initParamLorentzian(this.Data.x,this.Data.y);
case 'DoubleLorentzian'
[params{1},params{2},params{3}]=...
initParamDblLorentzian(this.Data.x,this.Data.y);
end
%Validates the initial parameters
p=createFitParser(this.n_params);
parse(p,params{:});
%Loads the parsed results into the class variables
this.init_params=p.Results.init_params;
this.lim_lower=p.Results.lower;
this.lim_upper=p.Results.upper;
%Plots the fit function with the new initial parameters
- if this.enable_gui; plotInitFun(this); end
+ if this.enable_plot; plotInitFun(this); end
end
%Plots the trace contained in the Fit MyTrace object.
function plotFit(this,varargin)
this.Fit.plotTrace(this.plot_handle,varargin{:});
end
%Clears the plots
function clearFit(this)
cellfun(@(x) delete(x), this.Fit.hlines);
delete(this.hline_init);
this.hline_init=[];
this.Fit.hlines={};
end
%Function for plotting fit model with current initial parameters.
function plotInitFun(this)
%Substantially faster than any alternative - generating
%anonymous functions is very cpu intensive.
input_cell=num2cell(this.scaled_params);
y_vec=feval(this.FitStruct.(this.fit_name).anon_fit_fun,...
this.x_vec,input_cell{:});
if isempty(this.hline_init)
this.hline_init=plot(this.plot_handle,this.x_vec,y_vec,...
'Color',this.init_color);
else
set(this.hline_init,'XData',this.x_vec,'YData',y_vec);
end
end
end
methods(Access=private)
%Creates the GUI of MyFit, in separate file.
createGui(this);
%Creates a panel for the GUI, in separate file
createTab(this, tab_tag, bg_color, button_h);
%Creats two vboxes (from GUI layouts) to display values of
%quantities
createUnitBox(this, bg_color, h_parent, name);
%Creates edit box inside a UnitDisp for showing label and value of
%a quantity. Used in conjunction with createUnitBox
createUnitDisp(this,varargin);
- %Creates parser for constructor
- function createParser(this)
- p=inputParser;
- addParameter(p,'fit_name','Linear',@ischar)
- addParameter(p,'Data',MyTrace());
- addParameter(p,'Fit',MyTrace());
- addParameter(p,'x',[]);
- addParameter(p,'y',[]);
- addParameter(p,'enable_gui',1);
- addParameter(p,'enable_plot',0);
- addParameter(p,'plot_handle',[]);
- addParameter(p,'save_dir',[]);
- addParameter(p,'save_name',[]);
- this.Parser=p;
- end
-
+
%Sets the class variables to the inputs from the inputParser.
function parseInputs(this)
for i=1:length(this.Parser.Parameters)
%Takes the value from the inputParser to the appropriate
%property.
if isprop(this,this.Parser.Parameters{i})
this.(this.Parser.Parameters{i})=...
this.Parser.Results.(this.Parser.Parameters{i});
end
end
end
%Does the fit with the currently set parameters
function doFit(this)
%Fits with the below properties. Chosen for maximum accuracy.
this.Fitdata=fit(this.Data.x,this.Data.y,this.fit_function,...
'Lower',this.lim_lower,'Upper',this.lim_upper,...
'StartPoint',this.init_params, ....
'MaxFunEvals',2000,'MaxIter',2000,'TolFun',1e-9);
%Puts the y values of the fit into the struct.
this.Fit.y=this.Fitdata(this.Fit.x);
%Puts the coeffs into the class variable.
this.coeffs=coeffvalues(this.Fitdata);
end
%Triggers the NewFit event such that other objects can use this to
%e.g. plot new fits
function triggerNewFit(this)
notify(this,'NewFit');
end
function triggerNewInitVal(this)
notify(this,'NewInitVal');
end
%Creates the struct used to get all things relevant to the fit
%model
function createFitStruct(this)
%Adds fits
addFit(this,'Linear','a*x+b','$$ax+b$$',{'a','b'},...
{'Gradient','Offset'})
addFit(this,'Quadratic','a*x^2+b*x+c','$$ax^2+bx+c$$',...
{'a','b','c'},{'Quadratic coeff.','Linear coeff.','Offset'});
addFit(this,'Gaussian','a*exp(-((x-c)/b)^2/2)+d',...
'$$ae^{-\frac{(x-c)^2}{2b^2}}+d$$',{'a','b','c','d'},...
{'Amplitude','Width','Center','Offset'});
addFit(this,'Lorentzian','1/pi*a*b/2/((x-c)^2+(b/2)^2)+d',...
'$$\frac{a}{\pi}\frac{b/2}{(x-c)^2+(b/2)^2}+d$$',{'a','b','c','d'},...
{'Amplitude','Width','Center','Offset'});
addFit(this,'Exponential','a*exp(b*x)+c',...
'$$ae^{bx}+c$$',{'a','b','c'},...
{'Amplitude','Rate','Offset'});
addFit(this,'DoubleLorentzian',...
'1/pi*b/2*a/((x-c)^2+(b/2)^2)+1/pi*e/2*d/((x-f)^2+(e/2)^2)+g',...
'$$\frac{a}{\pi}\frac{b/2}{(x-c)^2+(b/2)^2}+\frac{d}{\pi}\frac{e/2}{(x-f)^2+(e/2)^2}+g$$',...
{'a','b','c','d','e','f','g'},...
{'Amplitude 1','Width 1','Center 1','Amplitude 2',...
'Width 2','Center 2','Offset'});
end
%Updates the GUI if the edit or slider boxes are changed from
%elsewhere.
function updateGui(this)
%Converts the scale variable to the value between 0 and 100
%necessary for the slider
slider_vals=50*log10(this.scale_init)+50;
for i=1:this.n_params
set(this.Gui.(sprintf('Edit_%s',this.fit_params{i})),...
'String',sprintf('%3.3e',this.scaled_params(i)));
set(this.Gui.(sprintf('Slider_%s',this.fit_params{i})),...
'Value',slider_vals(i));
end
end
%Adds a fit to the list of fits
function addFit(this,fit_name,fit_function,fit_tex,fit_params,...
fit_param_names)
this.FitStruct.(fit_name).fit_function=fit_function;
this.FitStruct.(fit_name).fit_tex=fit_tex;
this.FitStruct.(fit_name).fit_params=fit_params;
this.FitStruct.(fit_name).fit_param_names=fit_param_names;
%Generates the anonymous fit function from the above
args=['@(x,', strjoin(fit_params,','),')'];
anon_fit_fun=str2func(vectorize([args,fit_function]));
this.FitStruct.(fit_name).anon_fit_fun=anon_fit_fun;
end
%Checks if the class is ready to perform a fit
function bool=validateData(this)
bool=~isempty(this.Data.x) && ~isempty(this.Data.y) && ...
length(this.Data.x)==length(this.Data.y) && ...
length(this.Data.x)>=this.n_params;
end
end
%% Get and set functions
methods
%% Set functions
%Set function for fit_name.
function set.fit_name(this,fit_name)
assert(ischar(fit_name),'The fit name must be a string');
%Capitalizes the first letter
fit_name=[upper(fit_name(1)),lower(fit_name(2:end))];
%Checks it is a valid fit name
ind=strcmpi(fit_name,this.valid_fit_names);%#ok<MCSUP>
assert(any(ind),'%s is not a supported fit name',fit_name);
this.fit_name=this.valid_fit_names{ind}; %#ok<MCSUP>
end
%% Get functions for dependent variables
%Generates the valid fit names
function valid_fit_names=get.valid_fit_names(this)
valid_fit_names=fieldnames(this.FitStruct);
end
%Grabs the correct fit function from FitStruct
function fit_function=get.fit_function(this)
fit_function=this.FitStruct.(this.fit_name).fit_function;
end
%Grabs the correct tex string from FitStruct
function fit_tex=get.fit_tex(this)
fit_tex=this.FitStruct.(this.fit_name).fit_tex;
end
%Grabs the correct fit parameters from FitStruct
function fit_params=get.fit_params(this)
fit_params=this.FitStruct.(this.fit_name).fit_params;
end
%Grabs the correct fit parameter names from FitStruct
function fit_param_names=get.fit_param_names(this)
fit_param_names=this.FitStruct.(this.fit_name).fit_param_names;
end
%Calculates the scaled initial parameters
function scaled_params=get.scaled_params(this)
scaled_params=this.scale_init.*this.init_params;
end
%Calculates the number of parameters in the fit function
function n_params=get.n_params(this)
n_params=length(this.fit_params);
end
%Generates a vector of x values for plotting
function x_vec=get.x_vec(this)
x_vec=linspace(min(this.Data.x),max(this.Data.x),1000);
end
- function n_userfields=get.n_userfields(this)
- n_userfields=length(fieldnames(this.UserGui.Fields));
+ function n_user_fields=get.n_user_fields(this)
+ n_user_fields=length(this.user_field_tags);
+ end
+
+ function user_field_tags=get.user_field_tags(this)
+ user_field_tags=fieldnames(this.UserGui.Fields);
+ end
+
+ function user_field_names=get.user_field_names(this)
+ user_field_names=cellfun(@(x) this.UserGui.Fields.(x).title,...
+ this.user_field_tags,'UniformOutput',0);
+ end
+
+ function user_field_vals=get.user_field_vals(this)
+ user_field_vals=cellfun(@(x) this.(x), this.user_field_tags);
+ end
+
+ function filename=get.filename(this)
+ filename=[this.save_dir,'\',this.save_name,'.txt'];
end
end
end
\ No newline at end of file
diff --git a/@MyFit/createGui.m b/@MyFit/createGui.m
index 73a3938..e8477b8 100644
--- a/@MyFit/createGui.m
+++ b/@MyFit/createGui.m
@@ -1,172 +1,177 @@
function createGui(this)
%Makes the fit name have the first letter capitalized
fit_name=[upper(this.fit_name(1)),this.fit_name(2:end)];
%Defines the colors for the Gui
rgb_blue=[0.1843,0.4157,1];
rgb_white=[1,1,1];
%Width of the edit boxes in the GUI
edit_width=140;
%Height of buttons in GUI
button_h=25;
%Minimum height of the four vboxes composing the gui.
title_h=40;
equation_h=80;
+savebox_h=60;
slider_h=100;
%Finds the minimum height in button heights of the user field panel. This
%is used to calculate the height of the figure.
tab_fields=fieldnames(this.UserGui.Tabs);
max_fields=max(cellfun(@(x) length(this.UserGui.Tabs.(x).Children),tab_fields));
if max_fields>3
min_user_h=max_fields+2;
else
min_user_h=5;
end
userpanel_h=min_user_h*button_h;
fig_h=title_h+equation_h+slider_h+userpanel_h;
%Name sets the title of the window, NumberTitle turns off the FigureN text
%that would otherwise be before the title, MenuBar is the menu normally on
%the figure, toolbar is the toolbar normally on the figure.
%HandleVisibility refers to whether gcf, gca etc will grab this figure.
this.Gui.Window = figure('Name', 'MyFit', 'NumberTitle', 'off', ...
'MenuBar', 'none', 'Toolbar', 'none', 'HandleVisibility', 'off',...
'Units','Pixels','Position',[500,500,edit_width*this.n_params,fig_h]);
%Sets the close function (runs when x is pressed) to be class function
set(this.Gui.Window, 'CloseRequestFcn',...
@(hObject,eventdata) closeFigure(this, hObject,eventdata));
%The main vertical box. The four main panes of the GUI are stacked in the
%box. We create these four boxes first so that we do not need to redraw
%them later
this.Gui.MainVbox=uix.VBox('Parent',this.Gui.Window,'BackgroundColor','w');
%The title box
this.Gui.Title=annotation(this.Gui.MainVbox,'textbox',[0.5,0.5,0.3,0.3],...
'String',fit_name,'Units','Normalized',...
'HorizontalAlignment','center','VerticalAlignment','middle',...
'FontSize',16,'BackgroundColor',rgb_white);
%Displays the fitted equation
this.Gui.Equation=annotation(this.Gui.MainVbox,'textbox',[0.5,0.5,0.3,0.3],...
'String',this.fit_tex,...
'Units','Normalized','Interpreter','LaTeX',...
'HorizontalAlignment','center','VerticalAlignment','middle',...
'FontSize',20,'BackgroundColor',rgb_white);
%Creates an HBox for extracted parameters and user interactions with GUI
-this.Gui.UserHbox=uix.HBox('Parent',this.Gui.MainVbox,'BackgroundColor',rgb_white);
+this.Gui.UserHbox=uix.HBox('Parent',this.Gui.MainVbox,...
+ 'BackgroundColor',rgb_white);
+%Creates the HBox for saving parameters
+this.Gui.SaveHBox=uix.HBox('Parent',this.Gui.MainVBox,...
+ 'BackgroundColor',rgb_white);
%Creates the HBox for the fitting parameters
this.Gui.FitHbox=uix.HBox('Parent',this.Gui.MainVbox);
%Sets the heights and minimum heights of the four vertical boxes. -1 means
%it resizes with the window
set(this.Gui.MainVbox,'Heights',[title_h,-1,-1,slider_h],...
'MinimumHeights',[title_h,equation_h,userpanel_h,slider_h]);
-%Here we create the save panel in the GUI.
+%Here we create the fit panel in the GUI.
this.Gui.FitPanel=uix.BoxPanel( 'Parent', this.Gui.UserHbox,...
'Padding',0,'BackgroundColor', rgb_white,...
'Title','Fit Panel','TitleColor',rgb_blue);
%Here we create the panel for the useful parameters
this.Gui.UserPanel=uix.BoxPanel( 'Parent', this.Gui.UserHbox,...
'Padding',0,'BackgroundColor', 'w',...
'Title','Calculated parameters','TitleColor',rgb_blue);
%This makes the buttons that go inside the FitPanel
this.Gui.FitVbox=uix.VBox('Parent',this.Gui.FitPanel,'BackgroundColor',...
rgb_white);
%Creates the button for analysis inside the VBox
this.Gui.AnalyzeButton=uicontrol('Parent',this.Gui.FitVbox,...
'style','pushbutton','Background','w','String','Analyze','Callback',...
@(hObject, eventdata) analyzeCallback(this, hObject, eventdata));
%Creates button for generating new initial parameters
this.Gui.InitButton=uicontrol('Parent',this.Gui.FitVbox,...
'style','pushbutton','Background','w',...
'String','Generate Init. Params','Callback',...
@(hObject, eventdata) initParamCallback(this, hObject, eventdata));
%Creates button for clearing fits
this.Gui.ClearButton=uicontrol('Parent',this.Gui.FitVbox,...
'style','pushbutton','Background','w','String','Clear fits','Callback',...
@(hObject, eventdata) clearFitCallback(this, hObject, eventdata));
this.Gui.SaveButton=uicontrol('Parent',this.Gui.FitVbox,...
'style','pushbutton','Background','w','String','Save Fit',...
'Callback', @(hObject, eventdata) saveCallback(this, hObject, eventdata));
set(this.Gui.FitVbox,'Heights',[button_h,button_h,button_h,button_h]);
this.Gui.TabPanel=uix.TabPanel('Parent',this.Gui.UserPanel,...
'BackgroundColor',rgb_white);
%Creates the user values panel with associated tabs. The cellfun here
%creates the appropriately named tabs. To add a tab, add a new field to the
%UserGuiStruct.
usertabs=fieldnames(this.UserGui.Tabs);
if ~isempty(usertabs)
cellfun(@(x) createTab(this,x,rgb_white,button_h),usertabs);
this.Gui.TabPanel.TabTitles=...
cellfun(@(x) this.UserGui.Tabs.(x).tab_title, usertabs,...
'UniformOutput',0);
end
%We first make the BoxPanels to speed up the process. Otherwise everything
%in the BoxPanel must be redrawn every time we make a new one.
panel_str=cell(1,this.n_params);
for i=1:this.n_params
%Generates the string for the panel handle
panel_str{i}=sprintf('Panel_%s',this.fit_params{i});
%Creates the panels
this.Gui.(panel_str{i})=uix.BoxPanel( 'Parent', this.Gui.FitHbox ,...
'Padding',0,'BackgroundColor', 'w',...
'Title',sprintf('%s (%s)',this.fit_param_names{i},this.fit_params{i}),...
'TitleColor',rgb_blue,...
'Position',[1+edit_width*(i-1),1,edit_width,slider_h],...
'Visible','off');
end
%Loops over number of parameters to create a fit panel for each one
for i=1:this.n_params
%Generates the string for the vbox handle
vbox_str=sprintf('Vbox_%s',this.fit_params{i});
%Generates the string for the slider handle
slider_str=sprintf('Slider_%s',this.fit_params{i});
%Generates string for edit panels
edit_str=sprintf('Edit_%s',this.fit_params{i});
%Creates the vbox inside the panel that allows stacking
this.Gui.(vbox_str) =uix.VBox( 'Parent', ...
this.Gui.(panel_str{i}),'Padding',0,'BackgroundColor', 'w');
%Generates edit box for fit parameters
this.Gui.(edit_str)=uicontrol('Parent',this.Gui.(vbox_str),...
'Style','edit','String',sprintf('%3.3e',this.init_params(i)),...
'FontSize',14,'Tag',edit_str,'HorizontalAlignment','Right',...
'Position',[1,48,edit_width-4,30],'Units','Pixels','Callback',...
@(hObject,eventdata) editCallback(this, hObject, eventdata));
%Generates java-based slider. Looks nicer than MATLAB slider
this.Gui.(slider_str)=uicomponent('Parent',this.Gui.(vbox_str),...
'style','jslider','Value',50,'Orientation',0,...
'MajorTickSpacing',20,'MinorTickSpacing',5,'Paintlabels',0,...
'PaintTicks',1,'Background',java.awt.Color.white,...
'pos',[1,-7,edit_width-4,55]);
%Sets up callbacks for the slider
this.Gui.([slider_str,'_callback'])=handle(this.Gui.(slider_str),...
'CallbackProperties');
this.Gui.([slider_str,'_callback']).StateChangedCallback = ....
@(hObject, eventdata) sliderCallback(this,i,hObject,eventdata);
this.Gui.([slider_str,'_callback']).MouseReleasedCallback = ....
@(~, ~) triggerNewInitVal(this);
%Sets heights and minimum heights for the elements in the fit vbox
set(this.Gui.(vbox_str),'Heights',[30,55],'MinimumHeights',[30,55])
end
%Makes all the panels at the bottom visible at the same time
cellfun(@(x) set(this.Gui.(x),'Visible','on'),panel_str);
end
\ No newline at end of file
diff --git a/Utility functions/initParamLorentzian.m b/Utility functions/initParamLorentzian.m
index 13940cf..6fb3180 100644
--- a/Utility functions/initParamLorentzian.m
+++ b/Utility functions/initParamLorentzian.m
@@ -1,45 +1,54 @@
function [p_in,lim_lower,lim_upper]=initParamLorentzian(x,y)
%Assumes form a/pi*b/2/((x-c)^2+(b/2)^2)+d
lim_upper=[Inf,Inf,Inf,Inf];
lim_lower=[-Inf,0,-Inf,-Inf];
%Finds peaks on the positive signal (max 1 peak)
try
[~,locs(1),widths(1),proms(1)]=findpeaks(y,x,...
'MinPeakDistance',range(x)/2,'SortStr','descend',...
'NPeaks',1);
catch
proms(1)=0;
end
%Finds peaks on the negative signal (max 1 peak)
try
[~,locs(2),widths(2),proms(2)]=findpeaks(-y,x,...
'MinPeakDistance',range(x)/2,'SortStr','descend',...
'NPeaks',1);
catch
proms(2)=0;
end
+
+if proms(1)==0 && proms(2)==0
+ warning('No peaks were found in the data, giving default initial parameters to fit function')
+ p_in=[1,1,1,1];
+ lim_lower=-[Inf,0,Inf,Inf];
+ lim_upper=[Inf,Inf,Inf,Inf];
+ return
+end
+
%If the prominence of the peak in the positive signal is greater, we adapt
%our limits and parameters accordingly, if negative signal has a greater
%prominence, we use this for fitting.
if proms(1)>proms(2)
ind=1;
p_in(4)=min(y);
else
ind=2;
p_in(4)=max(y);
proms(2)=-proms(2);
end
p_in(2)=widths(ind);
%Calculates the amplitude, as when x=c, the amplitude is 2a/(pi*b)
p_in(1)=proms(ind)*pi*p_in(2)/2;
p_in(3)=locs(ind);
lim_lower(2)=0.01*p_in(2);
lim_upper(2)=100*p_in(2);
end
\ No newline at end of file