Home > classes > @mfir > mfir.m

mfir

PURPOSE ^

MFIR FIR filter object class constructor.

SYNOPSIS ^

function f = mfir(varargin)

DESCRIPTION ^

 MFIR FIR filter object class constructor.
     Create an mfir object.
 
   f = mfir()    - creates an empty miir object.
   f = mfir(fi)  - creates a copy of the input miir object, fi.
   f = mfir(a)   - creates a an miir object based on the magnitude of the 
                   input AO/fsdata object.
   f = mfir(pl)  - create an miir object from the description given in the 
                   parameter list.
   
 Parameters for filter design from AO/fsdata:
   'method' - design method: 
              'frequency-sampling' - uses fir2() 
              'least-squares'      - uses firls()
              'Parks-McClellan'    - uses firpm()
   'Win'    - Window function for frequency-sampling method
   'N'      - filter order
 
 Parameters for standard filters:
 
   'type'   - one of 'highpass', 'lowpass', 'bandpass', 'bandreject'.
              [default: 'lowpass']
   'gain'   - gain of filter [default: 1.0]
   'fs'     - sample frequency to design for [default: 1Hz]
   'order'  - order of filter [default: 1]
   'fc'     - corner frequencies. This is a two element vector for bandpass
              and bandreject filters. [default: 0.25 or [0.1 0.3] ] 
   'Win'    - Specify window function used in filter design [default: Hamming] 
 
 Example 1:
 
 Create a default lowpass filter.
   >> f = mfir(plist()) 
 
 Example 2:
 
 Create an order 1 highpass filter with high frequency gain 2. Filter is
 designed for 1kHz sampled data and has a cut-off frequency of 200Hz.
   >> pl = plist();
   >> pl = append(pl, param('type', 'highpass'))
   >> pl = append(pl, param('gain', 2.0))
   >> pl = append(pl, param('fs', 1000))
   >> pl = append(pl, param('fc', 200))
   >> f = mfir(pl) 
 
 
 M Hewitson 09-02-07

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SUBFUNCTIONS ^

SOURCE CODE ^

0001 function f = mfir(varargin)
0002 
0003 % MFIR FIR filter object class constructor.
0004 %     Create an mfir object.
0005 %
0006 %   f = mfir()    - creates an empty miir object.
0007 %   f = mfir(fi)  - creates a copy of the input miir object, fi.
0008 %   f = mfir(a)   - creates a an miir object based on the magnitude of the
0009 %                   input AO/fsdata object.
0010 %   f = mfir(pl)  - create an miir object from the description given in the
0011 %                   parameter list.
0012 %
0013 % Parameters for filter design from AO/fsdata:
0014 %   'method' - design method:
0015 %              'frequency-sampling' - uses fir2()
0016 %              'least-squares'      - uses firls()
0017 %              'Parks-McClellan'    - uses firpm()
0018 %   'Win'    - Window function for frequency-sampling method
0019 %   'N'      - filter order
0020 %
0021 % Parameters for standard filters:
0022 %
0023 %   'type'   - one of 'highpass', 'lowpass', 'bandpass', 'bandreject'.
0024 %              [default: 'lowpass']
0025 %   'gain'   - gain of filter [default: 1.0]
0026 %   'fs'     - sample frequency to design for [default: 1Hz]
0027 %   'order'  - order of filter [default: 1]
0028 %   'fc'     - corner frequencies. This is a two element vector for bandpass
0029 %              and bandreject filters. [default: 0.25 or [0.1 0.3] ]
0030 %   'Win'    - Specify window function used in filter design [default: Hamming]
0031 %
0032 % Example 1:
0033 %
0034 % Create a default lowpass filter.
0035 %   >> f = mfir(plist())
0036 %
0037 % Example 2:
0038 %
0039 % Create an order 1 highpass filter with high frequency gain 2. Filter is
0040 % designed for 1kHz sampled data and has a cut-off frequency of 200Hz.
0041 %   >> pl = plist();
0042 %   >> pl = append(pl, param('type', 'highpass'))
0043 %   >> pl = append(pl, param('gain', 2.0))
0044 %   >> pl = append(pl, param('fs', 1000))
0045 %   >> pl = append(pl, param('fc', 200))
0046 %   >> f = mfir(pl)
0047 %
0048 %
0049 % M Hewitson 09-02-07
0050 %
0051 
0052 ALGONAME = mfilename;
0053 VERSION  = '$Id: mfir.html,v 1.1 2007/06/08 14:15:05 hewitson Exp $';
0054 
0055 
0056 switch nargin
0057   
0058   % Empty
0059   case 0
0060     
0061     f.name    = 'None';
0062     f.fs      = 0;
0063     f.ntaps   = 0;
0064     f.a       = [];
0065     f.gd      = 0;
0066     f.g       = 0;
0067     f.histout = [];
0068     f.infile  = '';
0069     f.plist   = plist();
0070     f.created = sprintf('%s', datestr(now));
0071     f.version = VERSION;
0072     f = class(f, 'mfir');
0073     
0074   % Copy, standard
0075   case 1
0076     % copy
0077     if isa(varargin{1}, 'mfir')
0078       
0079       f = varargin{1};
0080       f.version = VERSION;
0081 
0082       
0083     % Struct
0084     elseif isstruct(varargin{1})
0085       fstruct = varargin{1};
0086       f.name    = fstruct.name;
0087       f.fs      = fstruct.fs;
0088       f.ntaps   = fstruct.ntaps;
0089       f.a       = fstruct.a;
0090       f.gd      = fstruct.gd;
0091       f.g       = fstruct.g;
0092       f.histout = fstruct.histout;
0093       f.infile  = fstruct.infile;
0094       pl = fstruct.plist;
0095       if isstruct(pl)
0096         pl = plist(pl);
0097       end
0098       f.plist   = pl;
0099       f.created = fstruct.created;
0100       f.version = fstruct.version;
0101       f = class(f, 'mfir');
0102             
0103     % Parameter list
0104     elseif isa(varargin{1}, 'plist')
0105       
0106       pl   = varargin{1};
0107       type = find(pl, 'type');
0108       pzm  = find(pl, 'pzmodel');
0109       
0110       if ~isempty(type)      
0111         % check and fill parameter list
0112         plo = parseFilterParams(pl);
0113         switch type
0114           case 'lowpass'
0115             f = mklowpass(plo);
0116           case 'highpass'
0117             f = mkhighpass(plo);
0118           case 'bandpass'
0119             f = mkbandpass(plo);
0120           case 'bandreject'
0121             f = mkbandreject(plo);
0122           otherwise
0123             error('### unknown standard filter type in miir constructor.');
0124         end
0125         f.infile  = '';
0126         f.plist   = plo;
0127         f.created = sprintf('%s', datestr(now));
0128         f.version = VERSION;
0129         f = class(f, 'mfir');
0130       elseif ~isempty(pzm)
0131         
0132         fs = find(pl, 'fs');
0133         if isempty(fs)
0134           % get max freq in pzmodel
0135           fs = 8*getupperFreq(pzm);
0136           warning([sprintf('!!! no sample rate specified. Designing for fs=%2.2fHz.', fs)...
0137                    sprintf('\nThe filter will be redesigned later when used.')]); 
0138           
0139         end
0140         % make MIIR filter
0141         f = tomfir(pzm, fs);
0142         f = set(f, 'name', get(pzm, 'name'));
0143         f = set(f, 'plist', pl);
0144         
0145       else
0146         error('### unknown constructor type for mfir.');
0147       end
0148     else
0149       error('### unknown constructor type for mfir.');
0150     end
0151     
0152   case 2 % pzmodel followed by plist
0153     
0154     % From spectrum
0155 
0156     if isa(varargin{1}, 'pzmodel')
0157       pzm = varargin{1};
0158       if ~isa(pzm, 'pzmodel')
0159         error('### unknown constructor type for mfir.');
0160       end
0161       pl = varargin{2};
0162       if ~isa(pl, 'plist')
0163         error('### unknown constructor type for mfir.');
0164       end
0165 
0166       pl = append(pl, param('pzmodel', pzm));
0167 
0168       f = mfir(pl);
0169 
0170     elseif isa(varargin{1}, 'ao')
0171 
0172       if isa(varargin{2}, 'plist')
0173         pl = combine(varargin{2}, getDefaultPlist());
0174       else
0175         pl = getDefaultPlist();
0176       end
0177       f = mfirFromAO(ALGONAME, VERSION, varargin{1}, pl);      
0178       
0179     else
0180       error('### Unknown constructor method.');
0181     end
0182   otherwise
0183     error('### incorrect input arguments for miir constructor.');
0184 end
0185       
0186 %--------------------------------------------------------------------------
0187 % create FIR filter from magnitude of input AO/fsdata
0188 function filt = mfirFromAO(ALGONAME, VERSION, a, pl)
0189 
0190 N      = find(pl, 'N');
0191 win    = find(pl, 'Win');
0192 method = find(pl, 'method');
0193 
0194 d  = a.data;
0195 fs = d.fs;
0196 f  = d.f;
0197 xx = abs(d.xx);
0198 g  = 1; %median(xx);
0199 % xx = xx / g;
0200 
0201 
0202 ffm = f/(fs/2);
0203 switch method
0204   case 'frequency-sampling'
0205     % check window
0206     if length(win.win) ~= N+1
0207       warning('!!! resizing window function to match desired filter order.');
0208       if strcmp(win.name, 'Kaiser') || strcmp(win.name, 'Flattop')
0209         win = specwin(win.name, N+1, win.psll);
0210       else
0211         win = specwin(win.name, N+1);
0212       end
0213     end
0214     disp('** designing filter using frequency-sampling method [help fir2]');
0215     mtaps = fir2(N, ffm, xx, win.win);
0216   case 'least-squares'
0217     error('### this design method is not working properly yet.');
0218     if mod(length(ffm),2)
0219       ffm = ffm(1:end-1);
0220       xx  = xx(1:end-1);
0221     end
0222     disp('** designing filter using least-squares method [help firls]');
0223     mtaps = firls(N, ffm, xx);
0224   case 'Parks-McClellan'
0225     error('### this design method is not working properly yet.');
0226     disp('** designing filter using Parks-McClellan method [help firpm]');
0227     mtaps = firpm(N, ffm, xx);
0228   otherwise
0229     error('### unknown filter design method.');
0230 end
0231 
0232 % Make mfir object
0233 filt.name     = sprintf('fir(%s)', a.name);
0234 filt.fs       = fs;
0235 filt.ntaps    = length(mtaps);
0236 filt.a        = mtaps;
0237 filt.gd       = (filt.ntaps+1)/2;
0238 filt.g        = g;
0239 filt.histout  = zeros(1,filt.ntaps-1);   % initialise output history
0240 filt.infile   = '';
0241 filt.plist    = plist();
0242 filt.created  = sprintf('%s', datestr(now));
0243 filt.version  = VERSION;
0244 filt = class(filt, 'mfir');
0245 
0246 
0247 %--------------------------------------------------------------------------
0248 % default plist
0249 function pl = getDefaultPlist()
0250 
0251 N  = 512;
0252 pl = plist(param('N', N));
0253 pl = append(pl, param('method', 'frequency-sampling'));
0254 pl = append(pl, param('Win', specwin('Hanning', N+1)));
0255

Generated on Fri 08-Jun-2007 16:09:11 by m2html © 2003