tom@516: % Copyright 2012, Google, Inc. tom@516: % Author: Richard F. Lyon tom@516: % tom@516: % This Matlab file is part of an implementation of Lyon's cochlear model: tom@516: % "Cascade of Asymmetric Resonators with Fast-Acting Compression" tom@516: % to supplement Lyon's upcoming book "Human and Machine Hearing" tom@516: % tom@516: % Licensed under the Apache License, Version 2.0 (the "License"); tom@516: % you may not use this file except in compliance with the License. tom@516: % You may obtain a copy of the License at tom@516: % tom@516: % http://www.apache.org/licenses/LICENSE-2.0 tom@516: % tom@516: % Unless required by applicable law or agreed to in writing, software tom@516: % distributed under the License is distributed on an "AS IS" BASIS, tom@516: % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. tom@516: % See the License for the specific language governing permissions and tom@516: % limitations under the License. tom@516: dicklyon@534: function CF = CARFAC_Design(fs, CF_CAR_params, ... tom@516: CF_AGC_params, ERB_break_freq, ERB_Q, CF_IHC_params) dicklyon@534: % function CF = CARFAC_Design(fs, CF_CAR_params, ... tom@516: % CF_AGC_params, ERB_break_freq, ERB_Q, CF_IHC_params) tom@516: % tom@516: % This function designs the CARFAC (Cascade of Asymmetric Resonators with tom@516: % Fast-Acting Compression); that is, it take bundles of parameters and tom@516: % computes all the filter coefficients needed to run it. tom@516: % tom@516: % fs is sample rate (per second) dicklyon@534: % CF_CAR_params bundles all the pole-zero filter cascade parameters tom@516: % CF_AGC_params bundles all the automatic gain control parameters tom@516: % CF_IHC_params bundles all the inner hair cell parameters tom@516: % tom@516: % See other functions for designing and characterizing the CARFAC: tom@516: % [naps, CF] = CARFAC_Run(CF, input_waves) tom@516: % transfns = CARFAC_Transfer_Functions(CF, to_channels, from_channels) tom@516: % tom@516: % Defaults to Glasberg & Moore's ERB curve: tom@516: % ERB_break_freq = 1000/4.37; % 228.833 tom@516: % ERB_Q = 1000/(24.7*4.37); % 9.2645 tom@516: % tom@516: % All args are defaultable; for sample/default args see the code; they tom@516: % make 96 channels at default fs = 22050, 114 channels at 44100. tom@516: tom@516: if nargin < 6 tom@516: % HACK: these constant control the defaults tom@516: one_cap = 0; % bool; 0 for new two-cap hack tom@516: just_hwr = 0; % book; 0 for normal/fancy IHC; 1 for HWR tom@516: if just_hwr tom@516: CF_IHC_params = struct('just_hwr', 1); % just a simple HWR tom@516: else tom@516: if one_cap tom@516: CF_IHC_params = struct( ... dicklyon@523: 'just_hwr', just_hwr, ... % not just a simple HWR tom@516: 'one_cap', one_cap, ... % bool; 0 for new two-cap hack tom@516: 'tau_lpf', 0.000080, ... % 80 microseconds smoothing twice tom@516: 'tau_out', 0.0005, ... % depletion tau is pretty fast tom@516: 'tau_in', 0.010 ); % recovery tau is slower tom@516: else tom@516: CF_IHC_params = struct( ... dicklyon@523: 'just_hwr', just_hwr, ... % not just a simple HWR tom@516: 'one_cap', one_cap, ... % bool; 0 for new two-cap hack tom@516: 'tau_lpf', 0.000080, ... % 80 microseconds smoothing twice tom@516: 'tau1_out', 0.020, ... % depletion tau is pretty fast tom@516: 'tau1_in', 0.020, ... % recovery tau is slower tom@516: 'tau2_out', 0.005, ... % depletion tau is pretty fast tom@516: 'tau2_in', 0.005 ); % recovery tau is slower tom@516: end tom@516: end tom@516: end tom@516: tom@516: if nargin < 5 tom@516: % Ref: Glasberg and Moore: Hearing Research, 47 (1990), 103-138 tom@516: % ERB = 24.7 * (1 + 4.37 * CF_Hz / 1000); tom@516: ERB_Q = 1000/(24.7*4.37); % 9.2645 tom@516: if nargin < 4 dicklyon@536: % ERB_break_freq = 1000/4.37; % 228.833 G&M dicklyon@536: ERB_break_freq = 165.3; % Greenwood map's break freq. tom@516: end tom@516: end tom@516: tom@516: if nargin < 3 tom@516: CF_AGC_params = struct( ... tom@516: 'n_stages', 4, ... tom@516: 'time_constants', [1, 4, 16, 64]*0.002, ... tom@516: 'AGC_stage_gain', 2, ... % gain from each stage to next slower stage dicklyon@523: 'decimation', [8, 2, 2, 2], ... % how often to update the AGC states dicklyon@536: 'AGC1_scales', [1.0, 1.4, 2.0, 2.8], ... % in units of channels dicklyon@536: 'AGC2_scales', [1.6, 2.25, 3.2, 4.5], ... % spread more toward base dicklyon@536: 'detect_scale', 0.25, ... % the desired damping range dicklyon@523: 'AGC_mix_coeff', 0.5); tom@516: end tom@516: tom@516: if nargin < 2 dicklyon@534: CF_CAR_params = struct( ... dicklyon@523: 'velocity_scale', 0.2, ... % for the "cubic" velocity nonlinearity dicklyon@523: 'v_offset', 0.01, ... % offset gives a quadratic part dicklyon@523: 'v2_corner', 0.2, ... % corner for essential nonlin dicklyon@523: 'v_damp_max', 0.01, ... % damping delta damping from velocity nonlin dicklyon@533: 'min_zeta', 0.10, ... % minimum damping factor in mid-freq channels dicklyon@528: 'first_pole_theta', 0.85*pi, ... dicklyon@528: 'zero_ratio', sqrt(2), ... % how far zero is above pole dicklyon@530: 'high_f_damping_compression', 0.5, ... % 0 to 1 to compress zeta dicklyon@528: 'ERB_per_step', 0.5, ... % assume G&M's ERB formula dicklyon@528: 'min_pole_Hz', 30 ); tom@516: end tom@516: tom@516: if nargin < 1 tom@516: fs = 22050; tom@516: end tom@516: tom@516: % first figure out how many filter stages (PZFC/CARFAC channels): dicklyon@534: pole_Hz = CF_CAR_params.first_pole_theta * fs / (2*pi); tom@516: n_ch = 0; dicklyon@534: while pole_Hz > CF_CAR_params.min_pole_Hz tom@516: n_ch = n_ch + 1; dicklyon@534: pole_Hz = pole_Hz - CF_CAR_params.ERB_per_step * ... tom@516: ERB_Hz(pole_Hz, ERB_break_freq, ERB_Q); tom@516: end tom@516: % Now we have n_ch, the number of channels, so can make the array tom@516: % and compute all the frequencies again to put into it: tom@516: pole_freqs = zeros(n_ch, 1); dicklyon@534: pole_Hz = CF_CAR_params.first_pole_theta * fs / (2*pi); tom@516: for ch = 1:n_ch tom@516: pole_freqs(ch) = pole_Hz; dicklyon@534: pole_Hz = pole_Hz - CF_CAR_params.ERB_per_step * ... tom@516: ERB_Hz(pole_Hz, ERB_break_freq, ERB_Q); tom@516: end tom@516: % now we have n_ch, the number of channels, and pole_freqs array tom@516: dicklyon@528: max_channels_per_octave = log(2) / log(pole_freqs(1)/pole_freqs(2)); dicklyon@528: tom@516: CF = struct( ... tom@516: 'fs', fs, ... dicklyon@528: 'max_channels_per_octave', max_channels_per_octave, ... dicklyon@534: 'CAR_params', CF_CAR_params, ... tom@516: 'AGC_params', CF_AGC_params, ... tom@516: 'IHC_params', CF_IHC_params, ... tom@516: 'n_ch', n_ch, ... tom@516: 'pole_freqs', pole_freqs, ... dicklyon@534: 'CAR_coeffs', CARFAC_DesignFilters(CF_CAR_params, fs, pole_freqs), ... dicklyon@534: 'AGC_coeffs', CARFAC_DesignAGC(CF_AGC_params, fs, n_ch), ... dicklyon@534: 'IHC_coeffs', CARFAC_DesignIHC(CF_IHC_params, fs, n_ch), ... dicklyon@534: 'n_ears', 0 ); tom@516: tom@516: % adjust the AGC_coeffs to account for IHC saturation level to get right tom@516: % damping change as specified in CF.AGC_params.detect_scale tom@516: CF.AGC_coeffs.detect_scale = CF.AGC_params.detect_scale / ... tom@516: (CF.IHC_coeffs.saturation_output * CF.AGC_coeffs.AGC_gain); tom@516: dicklyon@534: tom@516: %% Design the filter coeffs: dicklyon@534: function CAR_coeffs = CARFAC_DesignFilters(CAR_params, fs, pole_freqs) tom@516: tom@516: n_ch = length(pole_freqs); tom@516: tom@516: % the filter design coeffs: tom@516: dicklyon@534: CAR_coeffs = struct( ... dicklyon@534: 'n_ch', n_ch, ... dicklyon@534: 'velocity_scale', CAR_params.velocity_scale, ... dicklyon@534: 'v_offset', CAR_params.v_offset, ... dicklyon@534: 'v2_corner', CAR_params.v2_corner, ... dicklyon@534: 'v_damp_max', CAR_params.v_damp_max ... dicklyon@523: ); tom@516: dicklyon@534: CAR_coeffs.r1_coeffs = zeros(n_ch, 1); dicklyon@534: CAR_coeffs.a0_coeffs = zeros(n_ch, 1); dicklyon@534: CAR_coeffs.c0_coeffs = zeros(n_ch, 1); dicklyon@534: CAR_coeffs.h_coeffs = zeros(n_ch, 1); dicklyon@534: CAR_coeffs.g0_coeffs = zeros(n_ch, 1); tom@516: tom@516: % zero_ratio comes in via h. In book's circuit D, zero_ratio is 1/sqrt(a), tom@516: % and that a is here 1 / (1+f) where h = f*c. tom@516: % solve for f: 1/zero_ratio^2 = 1 / (1+f) tom@516: % zero_ratio^2 = 1+f => f = zero_ratio^2 - 1 dicklyon@534: f = CAR_params.zero_ratio^2 - 1; % nominally 1 for half-octave tom@516: tom@516: % Make pole positions, s and c coeffs, h and g coeffs, etc., tom@516: % which mostly depend on the pole angle theta: tom@516: theta = pole_freqs .* (2 * pi / fs); tom@516: dicklyon@530: c0 = sin(theta); dicklyon@530: a0 = cos(theta); dicklyon@530: tom@516: % different possible interpretations for min-damping r: dicklyon@534: % r = exp(-theta * CF_CAR_params.min_zeta). dicklyon@530: % Compress theta to give somewhat higher Q at highest thetas: dicklyon@534: ff = CAR_params.high_f_damping_compression; % 0 to 1; typ. 0.5 dicklyon@530: x = theta/pi; dicklyon@530: zr_coeffs = pi * (x - ff * x.^3); % when ff is 0, this is just theta, dicklyon@530: % and when ff is 1 it goes to zero at theta = pi. dicklyon@534: CAR_coeffs.zr_coeffs = zr_coeffs; % how r relates to zeta dicklyon@530: dicklyon@534: min_zeta = CAR_params.min_zeta; dicklyon@533: % increase the min damping where channels are spaced out more: dicklyon@533: min_zeta = min_zeta + 0.25*(ERB_Hz(pole_freqs) ./ pole_freqs - min_zeta); dicklyon@533: r1 = (1 - zr_coeffs .* min_zeta); % "1" for the min-damping condition dicklyon@533: dicklyon@534: CAR_coeffs.r1_coeffs = r1; tom@516: tom@516: % undamped coupled-form coefficients: dicklyon@534: CAR_coeffs.a0_coeffs = a0; dicklyon@534: CAR_coeffs.c0_coeffs = c0; tom@516: tom@516: % the zeros follow via the h_coeffs dicklyon@530: h = c0 .* f; dicklyon@534: CAR_coeffs.h_coeffs = h; tom@516: dicklyon@530: % for unity gain at min damping, radius r; only used in CARFAC_Init: dicklyon@533: extra_damping = zeros(size(r1)); dicklyon@534: % this function needs to take CAR_coeffs even if we haven't finished dicklyon@530: % constucting it by putting in the g0_coeffs: dicklyon@534: CAR_coeffs.g0_coeffs = CARFAC_Stage_g(CAR_coeffs, extra_damping); tom@516: tom@516: tom@516: %% the AGC design coeffs: dicklyon@534: function AGC_coeffs = CARFAC_DesignAGC(AGC_params, fs, n_ch) tom@516: dicklyon@534: n_AGC_stages = AGC_params.n_stages; dicklyon@534: AGC_coeffs = struct( ... dicklyon@534: 'n_ch', n_ch, ... dicklyon@534: 'n_AGC_stages', n_AGC_stages, ... dicklyon@534: 'AGC_stage_gain', AGC_params.AGC_stage_gain); tom@516: tom@516: % AGC1 pass is smoothing from base toward apex; tom@516: % AGC2 pass is back, which is done first now tom@516: AGC1_scales = AGC_params.AGC1_scales; tom@516: AGC2_scales = AGC_params.AGC2_scales; tom@516: tom@516: AGC_coeffs.AGC_epsilon = zeros(1, n_AGC_stages); % the 1/(tau*fs) roughly dicklyon@523: decim = 1; dicklyon@523: AGC_coeffs.decimation = AGC_params.decimation; dicklyon@523: dicklyon@523: total_DC_gain = 0; tom@516: for stage = 1:n_AGC_stages dicklyon@525: tau = AGC_params.time_constants(stage); % time constant in seconds dicklyon@525: decim = decim * AGC_params.decimation(stage); % net decim to this stage tom@516: % epsilon is how much new input to take at each update step: tom@516: AGC_coeffs.AGC_epsilon(stage) = 1 - exp(-decim / (tau * fs)); dicklyon@523: % effective number of smoothings in a time constant: dicklyon@525: ntimes = tau * (fs / decim); % typically 5 to 50 dicklyon@524: dicklyon@524: % decide on target spread (variance) and delay (mean) of impulse dicklyon@524: % response as a distribution to be convolved ntimes: dicklyon@525: % TODO (dicklyon): specify spread and delay instead of scales??? dicklyon@524: delay = (AGC2_scales(stage) - AGC1_scales(stage)) / ntimes; dicklyon@524: spread_sq = (AGC1_scales(stage)^2 + AGC2_scales(stage)^2) / ntimes; dicklyon@524: dicklyon@525: % get pole positions to better match intended spread and delay of dicklyon@525: % [[geometric distribution]] in each direction (see wikipedia) dicklyon@524: u = 1 + 1 / spread_sq; % these are based on off-line algebra hacking. dicklyon@524: p = u - sqrt(u^2 - 1); % pole that would give spread if used twice. dicklyon@524: dp = delay * (1 - 2*p +p^2)/2; dicklyon@524: polez1 = p - dp; dicklyon@524: polez2 = p + dp; dicklyon@523: AGC_coeffs.AGC_polez1(stage) = polez1; dicklyon@523: AGC_coeffs.AGC_polez2(stage) = polez2; dicklyon@523: dicklyon@525: % try a 3- or 5-tap FIR as an alternative to the double exponential: dicklyon@525: n_taps = 0; dicklyon@525: FIR_OK = 0; dicklyon@525: n_iterations = 1; dicklyon@525: while ~FIR_OK dicklyon@525: switch n_taps dicklyon@525: case 0 dicklyon@525: % first attempt a 3-point FIR to apply once: dicklyon@525: n_taps = 3; dicklyon@525: case 3 dicklyon@525: % second time through, go wider but stick to 1 iteration dicklyon@525: n_taps = 5; dicklyon@525: case 5 dicklyon@525: % apply FIR multiple times instead of going wider: dicklyon@525: n_iterations = n_iterations + 1; dicklyon@525: if n_iterations > 16 dicklyon@525: error('Too many n_iterations in CARFAC_DesignAGC'); dicklyon@525: end dicklyon@525: otherwise dicklyon@525: % to do other n_taps would need changes in CARFAC_Spatial_Smooth dicklyon@525: % and in Design_FIR_coeffs dicklyon@525: error('Bad n_taps in CARFAC_DesignAGC'); dicklyon@523: end dicklyon@525: [AGC_spatial_FIR, FIR_OK] = Design_FIR_coeffs( ... dicklyon@525: n_taps, spread_sq, delay, n_iterations); dicklyon@523: end dicklyon@525: % when FIR_OK, store the resulting FIR design in coeffs: dicklyon@523: AGC_coeffs.AGC_spatial_iterations(stage) = n_iterations; dicklyon@523: AGC_coeffs.AGC_spatial_FIR(:,stage) = AGC_spatial_FIR; dicklyon@536: AGC_coeffs.AGC_spatial_n_taps(stage) = n_taps; dicklyon@523: dicklyon@525: % accumulate DC gains from all the stages, accounting for stage_gain: dicklyon@523: total_DC_gain = total_DC_gain + AGC_params.AGC_stage_gain^(stage-1); dicklyon@523: dicklyon@525: % TODO (dicklyon) -- is this the best binaural mixing plan? dicklyon@523: if stage == 1 dicklyon@523: AGC_coeffs.AGC_mix_coeffs(stage) = 0; dicklyon@523: else dicklyon@523: AGC_coeffs.AGC_mix_coeffs(stage) = AGC_params.AGC_mix_coeff / ... dicklyon@523: (tau * (fs / decim)); dicklyon@523: end tom@516: end tom@516: dicklyon@524: AGC_coeffs.AGC_gain = total_DC_gain; dicklyon@523: dicklyon@525: % % print some results dicklyon@536: AGC_coeffs dicklyon@536: AGC_spatial_FIR = AGC_coeffs.AGC_spatial_FIR dicklyon@536: AGC_spatial_iterations = AGC_coeffs.AGC_spatial_iterations dicklyon@536: AGC_spatial_n_taps = AGC_coeffs.AGC_spatial_n_taps dicklyon@525: dicklyon@525: dicklyon@525: %% dicklyon@525: function [FIR, OK] = Design_FIR_coeffs(n_taps, var, mn, n_iter) dicklyon@525: % function [FIR, OK] = Design_FIR_coeffs(n_taps, spread_sq, delay, n_iter) dicklyon@525: dicklyon@525: % reduce mean and variance of smoothing distribution by n_iterations: dicklyon@525: mn = mn / n_iter; dicklyon@525: var = var / n_iter; dicklyon@525: switch n_taps dicklyon@525: case 3 dicklyon@525: % based on solving to match mean and variance of [a, 1-a-b, b]: dicklyon@525: a = (var + mn*mn - mn) / 2; dicklyon@525: b = (var + mn*mn + mn) / 2; dicklyon@525: FIR = [a, 1 - a - b, b]; dicklyon@525: OK = FIR(2) >= 0.2; dicklyon@525: case 5 dicklyon@525: % based on solving to match [a/2, a/2, 1-a-b, b/2, b/2]: dicklyon@525: a = ((var + mn*mn)*2/5 - mn*2/3) / 2; dicklyon@525: b = ((var + mn*mn)*2/5 + mn*2/3) / 2; dicklyon@525: % first and last coeffs are implicitly duplicated to make 5-point FIR: dicklyon@525: FIR = [a/2, 1 - a - b, b/2]; dicklyon@525: OK = FIR(2) >= 0.1; dicklyon@525: otherwise dicklyon@525: error('Bad n_taps in AGC_spatial_FIR'); dicklyon@525: end dicklyon@523: tom@516: tom@516: %% the IHC design coeffs: dicklyon@534: function IHC_coeffs = CARFAC_DesignIHC(IHC_params, fs, n_ch) tom@516: tom@516: if IHC_params.just_hwr tom@516: IHC_coeffs = struct('just_hwr', 1); tom@516: IHC_coeffs.saturation_output = 10; % HACK: assume some max out tom@516: else tom@516: if IHC_params.one_cap dicklyon@534: IHC_coeffs = struct( ... dicklyon@534: 'n_ch', n_ch, ... tom@516: 'just_hwr', 0, ... tom@516: 'lpf_coeff', 1 - exp(-1/(IHC_params.tau_lpf * fs)), ... tom@516: 'out_rate', 1 / (IHC_params.tau_out * fs), ... tom@516: 'in_rate', 1 / (IHC_params.tau_in * fs), ... tom@516: 'one_cap', IHC_params.one_cap); tom@516: else tom@516: IHC_coeffs = struct(... dicklyon@534: 'n_ch', n_ch, ... tom@516: 'just_hwr', 0, ... tom@516: 'lpf_coeff', 1 - exp(-1/(IHC_params.tau_lpf * fs)), ... tom@516: 'out1_rate', 1 / (IHC_params.tau1_out * fs), ... tom@516: 'in1_rate', 1 / (IHC_params.tau1_in * fs), ... tom@516: 'out2_rate', 1 / (IHC_params.tau2_out * fs), ... tom@516: 'in2_rate', 1 / (IHC_params.tau2_in * fs), ... tom@516: 'one_cap', IHC_params.one_cap); tom@516: end tom@516: tom@516: % run one channel to convergence to get rest state: tom@516: IHC_coeffs.rest_output = 0; tom@516: IHC_state = struct( ... tom@516: 'cap_voltage', 0, ... tom@516: 'cap1_voltage', 0, ... tom@516: 'cap2_voltage', 0, ... tom@516: 'lpf1_state', 0, ... tom@516: 'lpf2_state', 0, ... tom@516: 'ihc_accum', 0); tom@516: dicklyon@534: IHC_in = 0; % the get the IHC output rest level dicklyon@534: for k = 1:20000 dicklyon@534: [IHC_out, IHC_state] = CARFAC_IHC_Step(IHC_in, IHC_coeffs, IHC_state); tom@516: end tom@516: tom@516: IHC_coeffs.rest_output = IHC_out; tom@516: IHC_coeffs.rest_cap = IHC_state.cap_voltage; tom@516: IHC_coeffs.rest_cap1 = IHC_state.cap1_voltage; tom@516: IHC_coeffs.rest_cap2 = IHC_state.cap2_voltage; tom@516: tom@516: LARGE = 2; tom@516: IHC_in = LARGE; % "Large" saturating input to IHC; make it alternate dicklyon@534: for k = 1:20000 dicklyon@534: [IHC_out, IHC_state] = CARFAC_IHC_Step(IHC_in, IHC_coeffs, IHC_state); tom@516: prev_IHC_out = IHC_out; tom@516: IHC_in = -IHC_in; tom@516: end tom@516: tom@516: IHC_coeffs.saturation_output = (IHC_out + prev_IHC_out) / 2; tom@516: end tom@516: tom@516: %% tom@516: % default design result, running this function with no args, should look tom@516: % like this, before CARFAC_Init puts state storage into it: tom@516: % dicklyon@523: % tom@516: % CF = CARFAC_Design dicklyon@534: % CF.CAR_params tom@516: % CF.AGC_params dicklyon@534: % CF.CAR_coeffs tom@516: % CF.AGC_coeffs tom@516: % CF.IHC_coeffs tom@516: % dicklyon@530: % CF = dicklyon@530: % fs: 22050 dicklyon@530: % max_channels_per_octave: 12.1873 dicklyon@534: % CAR_params: [1x1 struct] dicklyon@530: % AGC_params: [1x1 struct] dicklyon@530: % IHC_params: [1x1 struct] dicklyon@530: % n_ch: 66 dicklyon@530: % pole_freqs: [66x1 double] dicklyon@534: % CAR_coeffs: [1x1 struct] dicklyon@530: % AGC_coeffs: [1x1 struct] dicklyon@530: % IHC_coeffs: [1x1 struct] dicklyon@534: % n_ears: 0 dicklyon@530: % ans = dicklyon@530: % velocity_scale: 0.2000 dicklyon@530: % v_offset: 0.0100 dicklyon@530: % v2_corner: 0.2000 dicklyon@530: % v_damp_max: 0.0100 dicklyon@533: % min_zeta: 0.1000 dicklyon@530: % first_pole_theta: 2.6704 dicklyon@530: % zero_ratio: 1.4142 dicklyon@530: % high_f_damping_compression: 0.5000 dicklyon@530: % ERB_per_step: 0.5000 dicklyon@530: % min_pole_Hz: 30 dicklyon@530: % ans = tom@516: % n_stages: 4 tom@516: % time_constants: [0.0020 0.0080 0.0320 0.1280] tom@516: % AGC_stage_gain: 2 dicklyon@523: % decimation: [8 2 2 2] dicklyon@530: % AGC1_scales: [1 2 4 6] dicklyon@530: % AGC2_scales: [1.5000 3 6 9] tom@516: % detect_scale: 0.1500 dicklyon@530: % AGC_mix_coeff: 0.5000 dicklyon@530: % ans = tom@516: % velocity_scale: 0.2000 dicklyon@523: % v_offset: 0.0100 dicklyon@523: % v2_corner: 0.2000 dicklyon@523: % v_damp_max: 0.0100 dicklyon@530: % r1_coeffs: [66x1 double] dicklyon@530: % a0_coeffs: [66x1 double] dicklyon@530: % c0_coeffs: [66x1 double] dicklyon@530: % h_coeffs: [66x1 double] dicklyon@530: % g0_coeffs: [66x1 double] dicklyon@530: % zr_coeffs: [66x1 double] dicklyon@530: % ans = dicklyon@523: % AGC_stage_gain: 2 dicklyon@523: % AGC_epsilon: [0.1659 0.0867 0.0443 0.0224] dicklyon@523: % decimation: [8 2 2 2] dicklyon@530: % AGC_polez1: [0.1627 0.2713 0.3944 0.4194] dicklyon@530: % AGC_polez2: [0.2219 0.3165 0.4260 0.4414] dicklyon@530: % AGC_spatial_iterations: [1 1 2 2] dicklyon@523: % AGC_spatial_FIR: [3x4 double] dicklyon@536: % AGC_spatial_n_taps: [3 5 5 5] dicklyon@530: % AGC_mix_coeffs: [0 0.0454 0.0227 0.0113] dicklyon@523: % AGC_gain: 15 dicklyon@523: % detect_scale: 0.0664 dicklyon@530: % ans = dicklyon@523: % just_hwr: 0 tom@516: % lpf_coeff: 0.4327 tom@516: % out1_rate: 0.0023 tom@516: % in1_rate: 0.0023 tom@516: % out2_rate: 0.0091 tom@516: % in2_rate: 0.0091 tom@516: % one_cap: 0 tom@516: % rest_output: 0.0365 tom@516: % rest_cap: 0 tom@516: % rest_cap1: 0.9635 tom@516: % rest_cap2: 0.9269 dicklyon@523: % saturation_output: 0.1507 tom@516: