BMIAcqnvs_v2.asv

function out = BMIAcqnvs_v2(vals,varargin)

%{
    Scanimage needs a linear function script style to run between frames.
    For this reason the code needs to be executed line by line. Besides
    each frame the function gets executed and returns 0, which means,
    variables that are not persistent will be lost. This function needs to
    be as light as possible. Scanimage will not execute the function if it
    does not have time enough for it. Avoid large computations, saving to
    memory, large matrices copying and anything that requires computational
    power, and therefore time, from the CPU

    Inputs: vals is the activity of the neurons selected on scanimage

    expt_str --> buffer:
    0) normal_bmi
    flagBMI = true; (use self-generated hits to give waterer reward, no stim)
    flagwater = true; flagstim = False

    0) dstim_bmi
    flagBMI = true; (use self-generated hits to send D1/D2 stim)
    flagwater = false; flagstim = true;
    
    3) block_bmi
    flagBMI = true; (use self-generated hits to give water reward block D1/D2)
    flagwater = true; flagstim = true;
%}

    %% To initialize the recording:
    

    % this is only to initialize. History keeps most of the persisten vars
    global history
    global data
    
    % this is required to clean all the persistent variables if need be
    flush = 0; 
%     history.index = 1;

    
    if flush 
        vars = whos;
        vars = vars([vars.persistent]);
        varName = {vars.name};
        clear(varName{:});
        out = []; 
        clear a;
        clear history;
        disp('flushiiiing')
        
        return
    end
    
    
    %%
    %**********************************************************
    %****************  PARAMETERS  ****************************
    %**********************************************************
    
    %% BMI parameters
    % parameters for the function that do not change (and we may need in each
    % iteration. --> GIVEN BY SETTINGS (task/calibration/etc)
    out = 0;       %required output to ScanImage

    
    %% needed variables
    % Define persistent variables that will remain in each iteration of this
    % function
    persistent a flags counters task_settings T decoder units back_2_base block_val fb_mapping
    
    
   %%
    %*********************************************************************
    %******************  INITIALIZE  ***********************************
    %*********************************************************************
    
    % initialize arduino for playing sound (if not initialized already).
    if ~isa(a, 'arduino')
        a = arduino('COM15', 'Uno');
        disp('starting arduino')
    end
      
    if history.index==1 %if this is the first time it runs this program (after flush)
        % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        % bring the settings from base
        task_settings = evalin('base','task_settings');
        T = evalin('base','calibration_results.T');
        decoder = evalin('base','calibration_results.decoder');
        units = evalin('base','calibration_settings.units');
        back_2_base = evalin('base','calibration_settings.params.back2base_alpha')*T;
        block_val = evalin('base','task_settings.params.block_at_alpha')*T;
        fb_mapping = evalin('base','calibration_results.fb_mapping');
        
        %global parameters hSI;
        counters.do_not_update_buffer = task_settings.params.initial_count;
        counters.update_buffer = 0;
        counters.miss = 0;
        counters.after_motion = 0;
        counters.trial = 1;
        counters.back_2_base = 0;
        counters.baseline_full = task_settings.base_frames;
        counters.tim = 0;
        counters.tim_frame = 0;
        flags.back_2_baseline = false;
        flags.new_trial = true;
        flags.base_buffer_full = false;
        flags.init_baseline = true;
        flags.motion = false;
        flags.stim_done = false;
        data.cursor = single(nan(1, task_settings.expected_length_experiment));  %define a very long vector for cursor
        data.frequency = single(nan(1, task_settings.expected_length_experiment));
        data.hits = single(nan(1, task_settings.params.length_trials));
        data.miss = single(nan(1, task_settings.params.length_trials));
        data.reward = single(nan(1, task_settings.params.length_trials));
        data.stims = single(nan(1, task_settings.params.length_trials));
        data.trial_end = single(nan(1, task_settings.params.length_trials));
        data.trial_start = single(nan(1, task_settings.params.length_trials));
        data.time_vector = single(nan(1, task_settings.expected_length_experiment));
        history.baseval = single(ones(units,1).*vals);
        history.buffer = single(nan(units, task_settings.moving_average_frames));  %define a windows buffer
        history.last_volume = 0;  %careful with this it may create problems
        history.nZ=evalin('base','hSI.hFastZ.numFramesPerVolume');
        history.number_hits = 0; 
        history.number_miss = 0; 
        history.number_rewards = 0; 
        history.number_trials = 0;
        history.number_stims = 0;
    end
    %% some parameters depending on settinggs
%     init_frame_base = task_settings.params.initial_count + 1;
    % experiment FLAGS
    switch lower(task_settings.experiment) %make it case insensitive. all lower cases
        case 'normal_bmi'
            flags.BMI = true;
            flags.water = true;
            flags.stim_time = false;
            flags.stim_target = false;
            flags.random_stim = false;
        case 'dstim_bmi'
            flags.BMI = true;
            flags.water = false;
            flags.stim_time = false;
            flags.stim_target = true;
            flags.random_stim = false;
        case 'block_bmi_reward'
            flags.BMI = true;
            flags.water = true;
            flags.stim_time = false;
            flags.stim_target = true;
            flags.random_stim = false;
        case 'block_bmi'
            flags.BMI = true;
            flags.water = true;
            flags.stim_time = true;
            flags.stim_target = false;
            flags.random_stim = false;
        case 'random_stim'
            flags.BMI = true;
            flags.water = true;
            flags.stim_time = false;
            flags.stim_target = false;
            flags.random_stim = true;
    end  
    
     %% Prepare the stim !!!TODO!!!
 
        
    %%
    %************************************************************************
    %*************************** RUN ********************************
    %************************************************************************
    
    % acquire the actual frame
    this_frame = evalin('base','hSI.hScan2D.hAcq.hFpga.AcqStatusAcquiredFrames');
    if isempty(history.nZ)
        history.nZ = 1;
    end
    this_volume = floor(this_frame/history.nZ);
    %if we've completed a new volume, update history 
    % store nans on frames that we've skipped so we know we skipped
    % them
    if this_volume > history.last_volume  % if this is a new volume
        counters.tim_frame = cputime;
        % handle ******* MOTION***********
        % because we don't want to stim or reward or update buffer if there is motion
        mot = evalin('base', 'hSI.hMotionManager.motionCorrectionVector');
        if ~isempty(mot)
            motion = sqrt(mot(1)^2 + mot(2)^2 + mot(3)^2); 
        else
            motion = 0;
        end

        if motion > task_settings.params.motion_thresh 
            flags.motion = true; 
            counters.after_motion = 0;
        else
            if counters.after_motion >= task_settings.motion_relaxation_frames
                flags.motion = false;
            else
                counters.after_motion = counters.motion + 1;
            end
        end
        
        % obtain the frame
        steps = this_volume - history.last_volume;
        history.last_volume = this_volume;
        history.index = history.index + steps;
        
        if counters.do_not_update_buffer == 0 && ~flags.motion
            %update frame

            % variable to hold nans in unseen frames
            placeholder = nan(numel(vals),steps-1);
            mVals = [placeholder vals];

            % update buffer of activity history
            if steps < task_settings.moving_average_frames
                history.buffer(:, 1: end-steps) = history.buffer(:, steps+1:end);
                history.buffer(:,end-steps+1:end) = mVals;    
            else
                history.buffer = mVals(:, end-task_settings.moving_average_frames+1:end);
            end
            
            signal = single(nanmean(history.buffer, 2));
            
            % update dynamic baseline. baseline may be seeded if another BMI was run before 
            if flags.init_baseline && ~isnan(sum(sum(task_settings.base_val_seed)))
                flags.base_buffer_full = true; 
                history.baseval = task_settings.base_val_seed; 
                disp('baseBuffer seeded!'); 
            elseif ~ flags.base_buffer_full && counters.baseline_full > 0
                history.baseval = (history.baseval*(single(history.index) - 1) + signal)./single(history.index);
                counters.baseline_full = counters.baseline_full - 1;
                if counters.baseline_full == 0
                    disp('baseline full')
                    flags.base_buffer_full = true;
                end
            else
                history.baseval = (history.baseval*(task_settings.base_frames - 1) + signal)./task_settings.base_frames;
            end
            
            % baseline has been initiated one way or another
            if flags.init_baseline
                flags.init_baseline = false;
            end
            
            if flags.base_buffer_full   % only after it finishes with baseline it will start
                 % calculation of DFF
                dff = (signal - history.baseval) ./ history.baseval;
                data.cursor(history.index) = decoder * dff;
                
                % obtain frequency
                freq = cursor_to_audio(data.cursor(history.index), fb_mapping, task_settings.mice_settings.target_low);
                data.frequency(history.index) = freq; 
            end

            if counters.update_buffer == 0 && flags.base_buffer_full
                % Is it a new trial?
                if flags.new_trial && ~flags.back_2_baseline
                    history.number_trials = history.number_trials + 1;
                    data.trial_start(history.number_trials) = history.index;
                    flags.new_trial = false;
                    counters.tim = cputime;
                    disp('New Trial!')
                    if flags.random_stim
                        flags.stim_done = false;
                        time_stim = rand *(task_settings.params.duration_trial/2 - 1) + 1;
                    end
                end

                if flags.back_2_baseline 
                    if data.cursor(history.index) <= back_2_base
                        counters.back_2_base = counters.back_2_base + 1;
                    end
                    if counters.back_2_base >= task_settings.params.back_2_base_frame_thresh
                        flags.back_2_baseline = false;
                        counters.back_2_base = 0;
                        disp('back to baseline')
                    end
                else
                    a.playTone("D11", freq, 1);

                    data.cursor(history.index)
                    if data.cursor(history.index) >= T      %if it hit the target
                        if flags.BMI
                            disp('target hit')
                            data.trial_end(history.number_trials) = history.index;
                            history.number_hits = history.number_hits + 1;
                            data.hits(history.number_hits) = history.index;
                            if flags.water
                                history.number_rewards = history.number_rewards + 1;
                                data.rewards(history.number_rewards) = history.index;
                                % give water reward
                                a.writeDigitalPin("D10", 1); pause(task_settings.params.water_time); a.writeDigitalPin("D10",0)
                                disp(['Trial: ', num2str(history.number_trials), 'Water rewards: ', num2str(history.number_rewards)]);
                            elseif flags.stim_target
                                history.number_stims = history.number_stims + 1;
                                data.stims(history.number_stims) = history.index;
                                % send stim!! TODO
                                a.writeDigitalPin("D11", 1); pause(task_settings.params.stim_pulse); a.writeDigitalPin("D11",0)
                                disp(['Trial: ', num2str(history.number_trials), 'Stim rewards: ', num2str(history.number_stims)]); 
                            end

                            counters.update_buffer = task_settings.relaxation_frames; 
                            flags.back_2_baseline = true;
                            flags.new_trial = true;                                    
                        else
                            % do nothing for now. Available to implement later 
                        end
                    elseif (cputime - counters.tim) > task_settings.params.trial_max_time
                        disp('Timeout')
                        data.trial_end(history.number_trials) = history.index;
                        history.number_miss = history.number_miss + 1;
                        data.miss(history.number_miss) = history.index;
                        a.playTone("D11", 0, task_settings.params.timeout);
                        flags.new_trial = true;
                        counters.update_buffer = task_settings.timeout_frames;
                    end
                    if ~flags.new_trial
                        if flags.random_stim && ~ flags.stim_done
                            if (cputime - counters.tim) > time_stim
                                disp('random stim')
                                %TODO!!! send stim
                                a.writeDigitalPin("D11", 1); pause(task_settings.params.stim_pulse); a.writeDigitalPin("D11",0)
                                history.number_stims = history.number_stims + 1;
                                data.stims(history.number_stims) = history.index;
                                flags.stim_done = true;
                            end
                        end
                    end
                    if flags.stim_time
                        % sends stim if the cursor is approaching the target
                        if data.cursor(history.index) >= block_val
                            disp('timed stim')
                            a.writeDigitalPin("D11", 1); pause(task_settings.params.stim_pulse); a.writeDigitalPin("D11",0)
                            %TODO send stim
                            if ~flags.stim_done
                                history.number_stims = history.number_stims + 1;
                                data.stims(history.number_stims) = history.index;
                                flags.stim_done = true;
                            end
                        else
                            flags.stim_done = false;
                        end
                    end

                end

            else
                if counters.update_buffer>0
                    counters.update_buffer = counters.update_buffer - 1;
                end
            end
        else
            if counters.do_not_update_buffer>0
                counters.do_not_update_buffer = counters.do_not_update_buffer - 1;
            end
        end

        data.time_vector(history.index) = cputime - counters.tim_frame;

    else
        % do nothing (for now)
    end
end