0001 function varargout = ao(varargin)
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029
0030
0031
0032
0033
0034
0035
0036
0037
0038
0039
0040
0041
0042
0043
0044
0045
0046
0047
0048
0049
0050
0051
0052
0053
0054
0055
0056
0057
0058
0059
0060
0061
0062
0063
0064
0065
0066
0067
0068
0069
0070
0071
0072
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085
0086
0087
0088
0089
0090
0091
0092
0093
0094
0095
0096
0097
0098
0099
0100
0101
0102
0103
0104
0105
0106
0107
0108
0109
0110
0111
0112
0113
0114
0115
0116
0117
0118
0119
0120
0121
0122
0123
0124
0125
0126
0127
0128
0129
0130
0131
0132
0133
0134
0135
0136
0137
0138
0139
0140
0141
0142
0143
0144
0145
0146
0147
0148
0149
0150
0151
0152
0153
0154
0155
0156
0157
0158
0159
0160
0161
0162
0163
0164
0165
0166
0167
0168
0169
0170
0171
0172
0173
0174
0175
0176
0177
0178
0179
0180
0181
0182 ALGONAME = mfilename;
0183 VERSION = '$Id: ao.m,v 1.85 2008/03/04 08:46:53 hewitson Exp $';
0184 CATEGORY = 'Constructor';
0185
0186
0187 if (nargin == 2 || nargin == 3) &&...
0188 isa(varargin{1}, 'ao') &&...
0189 ischar(varargin{2})
0190 if strcmp(varargin{2}, 'Params')
0191 if nargin == 2
0192 varargout{1} = getDefaultPlist();
0193 else
0194 varargout{1} = getDefaultPlist(varargin{3});
0195 end
0196 return
0197 elseif strcmp(varargin{2}, 'Version')
0198 varargout{1} = VERSION;
0199 return
0200 elseif strcmp(varargin{2}, 'Category')
0201 varargout{1} = CATEGORY;
0202 return
0203 end
0204 end
0205
0206
0207
0208 args = [];
0209 k = 0;
0210 pls = [];
0211 for j=1:nargin
0212 if ~isempty(varargin{j})
0213 k = k + 1;
0214 if isa(varargin{j}, 'plist')
0215 pls = [pls varargin{j}];
0216 else
0217 args(k).val = varargin{j};
0218 args(k).n = j;
0219 end
0220 end
0221 end
0222
0223
0224 if isa(pls, 'plist')
0225 pl = combine(pls);
0226 else
0227 pl = [];
0228 end
0229
0230 Nargs = length(args);
0231 if ~isempty(pl)
0232 args(Nargs+1).val = pl;
0233 args(Nargs+1).n = j+1;
0234 Nargs = length(args);
0235 end
0236
0237
0238
0239 function a = init()
0240 a.name = 'None';
0241 a.data = {};
0242 a.hist = history(ALGONAME, VERSION);
0243 a.provenance = provenance;
0244 a.description = '';
0245 a.mfile = '';
0246 a.mfilename = '';
0247 a.mdlfile = '';
0248 a.mdlfilename = '';
0249 a.plist = plist();
0250 a.version = VERSION;
0251 a.created = time;
0252 a = class(a, 'ao');
0253 end
0254
0255
0256
0257
0258
0259 if Nargs == 0
0260
0261 varargout{1} = init();
0262
0263
0264
0265
0266 elseif Nargs == 1
0267
0268
0269
0270 if ischar(args(1).val)
0271
0272 a = init();
0273
0274 filename = args(1).val;
0275 [path, name, ext, vers] = fileparts(filename);
0276 switch ext
0277 case '.mat'
0278 a = load(filename);
0279 a = a.a;
0280 a.name = strcat(name, ext);
0281 case '.xml'
0282 root_node = xmlread(filename);
0283 a = ltpda_xmlread(root_node, 'ao');
0284 case {'.txt', '.dat'}
0285 a = aoFromFilenameAndPlist(a, args(1).val, plist(), VERSION, ALGONAME);
0286 a.name = strcat(name, ext);
0287 otherwise
0288 error('### Unknown file type.');
0289 end
0290 varargout{1} = a;
0291
0292
0293 elseif isa(args(1).val, 'ao')
0294 varargout{1} = args(1).val;
0295
0296
0297
0298 elseif isstruct(args(1).val)
0299 a = init();
0300 astruct = args(1).val;
0301 a.name = astruct.name;
0302 data = astruct.data;
0303
0304 if isstruct(data)
0305 if isfield(data, {'t', 'x'})
0306 data = tsdata(data);
0307 elseif isfield(data, {'f', 'xx'})
0308 data = fsdata(data);
0309 elseif isfield(data, {'vals'})
0310 data = cdata(data);
0311 elseif isfield(data, {'x', 'y'})
0312 data = xydata(data);
0313 elseif isfield(data, {'x', 'y', 'z'})
0314 data = xyzdata(data);
0315 else
0316 error('### Unknown data type in input structure.');
0317 end
0318 end
0319
0320 a.data = data;
0321 hist = astruct.hist;
0322 if isstruct(hist)
0323 hist = history(hist);
0324 end
0325 a.hist = hist;
0326 prov = astruct.provenance;
0327 if isstruct(prov)
0328 prov = provenance(prov);
0329 end
0330
0331 a.provenance = prov;
0332 a.description = astruct.description;
0333 a.mfile = astruct.mfile;
0334 a.mfilename = astruct.mfilename;
0335 a.mdlfile = astruct.mdlfile;
0336 a.mdlfilename = astruct.mdlfilename;
0337 a.plist = astruct.plist;
0338 a.version = astruct.version;
0339 created = astruct.created;
0340 if isstruct(created)
0341 created = time(created);
0342 end
0343 a.created = created;
0344 varargout{1} = a;
0345
0346
0347
0348 elseif isnumeric(args(1).val)
0349
0350 a = init();
0351 a.data = cdata(args(1).val);
0352 a.hist = history(ALGONAME, VERSION, plist(param('vals', args(1).val)));
0353
0354 varargout{1} = a;
0355
0356
0357
0358 elseif isa(args(1).val, 'plist')
0359
0360 pl = args(1).val;
0361 filename = find(pl, 'filename');
0362 fcn = find(pl, 'fcn');
0363 vals = find(pl, 'vals');
0364 tsfcn = find(pl, 'tsfcn');
0365 fsfcn = find(pl, 'fsfcn');
0366 win = find(pl, 'win');
0367 waveform = find(pl, 'waveform');
0368 polycoeffs = find(pl, 'polyval');
0369 hostname = find(pl, 'hostname');
0370 ipl = find(pl, 'Plist');
0371
0372 a = init();
0373 a.plist = pl;
0374
0375 if ~isempty(filename)
0376
0377 [path, name, ext, vers] = fileparts(filename);
0378 switch ext
0379 case '.mat'
0380 a = load(filename);
0381 varargout{1} = a.a;
0382 case '.xml'
0383 root_node = xmlread(filename);
0384 a = ltpda_xmlread(root_node, 'ao');
0385 varargout{1} = a;
0386 case {'.txt', '.dat'}
0387 ao_out = aoFromFilenameAndPlist(a, filename, pl, VERSION, ALGONAME);
0388 if nargout == 1
0389 varargout{1} = ao_out;
0390 elseif nargout == length(ao_out)
0391 for ii = 1:length(ao_out)
0392 varargout{ii} = ao_out(ii);
0393 end
0394 else
0395 warning ('### Too few output variables --> useing only the first.');
0396 varargout{1} = ao_out;
0397 end
0398 otherwise
0399 error('### Unknown file type.');
0400 end
0401
0402 elseif ~isempty(fcn)
0403
0404 varargout{1} = aoFromFcn(a, pl, VERSION, ALGONAME);
0405
0406 elseif ~isempty(vals)
0407
0408 varargout{1} = aoFromVals(a, pl, VERSION, ALGONAME);
0409 elseif ~isempty(tsfcn)
0410
0411 varargout{1} = aoFromTSfcn(a, pl, VERSION, ALGONAME);
0412 elseif ~isempty(fsfcn)
0413
0414 varargout{1} = aoFromFSfcn(a, pl, VERSION, ALGONAME);
0415 elseif ~isempty(win)
0416
0417 varargout{1} = aoFromSpecWin(a, win, VERSION, ALGONAME);
0418 elseif ~isempty(waveform)
0419
0420 varargout{1} = aoFromWaveform(a, pl, VERSION, ALGONAME);
0421 elseif ~isempty(hostname)
0422
0423 varargout{1} = aoFromRepository(a, pl, VERSION, ALGONAME);
0424 elseif ~isempty(polycoeffs)
0425
0426 varargout{1} = aoFromPolyval(a, pl, VERSION, ALGONAME);
0427 elseif ~isempty(ipl)
0428
0429 varargout{1} = ao(ipl);
0430 else
0431 error('### Unknown AO constructor method.');
0432 end
0433
0434
0435
0436 elseif isa(args(1).val, 'specwin')
0437 a = init();
0438 varargout{1} = aoFromSpecWin(a, args(1).val, VERSION, ALGONAME);
0439
0440
0441
0442
0443
0444
0445 else
0446 a = init();
0447 data = args(1).val;
0448 a.data = data;
0449 a.hist = history(ALGONAME, VERSION);
0450
0451 if ~isa(a.data, 'tsdata') &&...
0452 ~isa(a.data, 'fsdata') &&...
0453 ~isa(a.data, 'cdata') &&...
0454 ~isa(a.data, 'xydata') &&...
0455 ~isa(a.data, 'xyzdata')
0456 error('### unknown data object.')
0457 end
0458 varargout{1} = a;
0459 end
0460
0461
0462
0463
0464
0465 elseif Nargs == 2
0466
0467
0468 if isa(varargin{1}, 'database')
0469 varargout{1} = retrieve(varargin{1}, varargin{2:end});
0470
0471
0472 elseif ischar(args(1).val) && isa(args(2).val, 'plist')
0473
0474 a = init();
0475
0476 ao_out = aoFromFilenameAndPlist(a, args(1).val, args(2).val, VERSION, ALGONAME);
0477
0478 for ii = numel(ao_out)
0479 ao_out(ii).plist = args(2).val;
0480 ao_out(ii).name = args(1).val;
0481 end
0482
0483 if nargout == 1
0484 varargout{1} = ao_out;
0485 elseif nargout == length(ao_out)
0486 for ii = 1:length(ao_out)
0487 varargout{ii} = ao_out(ii);
0488 end
0489 else
0490 warning ('### Too few output variables --> useing only the first.');
0491 varargout{1} = ao_out;
0492 end
0493
0494
0495 else
0496
0497 a = init();
0498
0499 a.data = args(1).val;
0500 a.hist = args(2).val;
0501
0502 if ~isa(a.data, 'tsdata') &&...
0503 ~isa(a.data, 'fsdata') &&...
0504 ~isa(a.data, 'cdata') &&...
0505 ~isa(a.data, 'xydata')
0506 error('### unknown data object.')
0507 end
0508 if ~isa(a.hist, 'history')
0509 error('### unknown history object.')
0510 end
0511
0512 varargout{1} = a;
0513
0514 end
0515
0516
0517
0518
0519
0520
0521 elseif Nargs == 9
0522
0523 a = init();
0524 a.name = args(1).val;
0525 a.data = args(2).val;
0526 a.hist = args(3).val;
0527 a.provenance = args(4).val;
0528 a.description = args(5).val;
0529 a.mfile = args(6).val;
0530 a.mfilename = args(7).val;
0531 a.mdlfile = args(8).val;
0532 a.mdlfilename = args(9).val;
0533 varargout{1} = a;
0534
0535 else
0536 error('### Unknown number of constructor arguments.');
0537 end
0538
0539
0540
0541
0542
0543
0544
0545
0546
0547
0548
0549
0550
0551
0552
0553
0554
0555
0556 function aos = aoFromRepository(a, pl, VERSION, ALGONAME)
0557
0558 dpl = getDefaultPlist('From Repository');
0559 pl = combine(pl, dpl);
0560
0561
0562 conn = find(pl, 'conn');
0563 hostname = find(pl, 'hostname');
0564 database = find(pl, 'database');
0565 ids = find(pl, 'id');
0566
0567
0568 closeConn = 0;
0569 if isempty(conn)
0570 closeConn = 1;
0571
0572 conn = mysql_connect(hostname, database);
0573 end
0574 if ~isa(conn, 'database')
0575 error('### connection failed.');
0576 end
0577
0578
0579 Nids = length(ids);
0580 aos = [];
0581 for kk=1:Nids
0582
0583
0584 id = ids(kk);
0585 disp(sprintf(' - retrieving ID %d', id));
0586
0587
0588 tt = mysql_getObjType(conn, id);
0589
0590 if strcmp(tt, mfilename)
0591
0592 a = ltpda_obj_retrieve(conn, id);
0593
0594
0595
0596
0597 h = history(ALGONAME, VERSION, remove(pl, 'conn'), a.hist);
0598
0599
0600 a = setnh(a, 'hist', h);
0601
0602
0603 aos = [aos a];
0604 else
0605 warning(' !skipping ID %d, type %s', id, tt);
0606 end
0607
0608 end
0609
0610
0611 if closeConn
0612 close(conn);
0613 end
0614 end
0615
0616
0617
0618
0619
0620
0621
0622
0623
0624
0625
0626
0627
0628
0629
0630
0631
0632
0633
0634 function a = aoFromPolyval(a, pl, VERSION, ALGONAME)
0635
0636 coeffs = find(pl, 'polyval');
0637 Nsecs = find(pl, 'Nsecs');
0638 fs = find(pl, 'fs');
0639 t = find(pl, 't');
0640
0641
0642 if isempty(t)
0643 if isempty(Nsecs) || isempty(fs)
0644 error('### Please provide either ''Nsecs'' and ''fs'', or ''t'' for polyval constructor.');
0645 end
0646 t = linspace(0, Nsecs - 1/fs, Nsecs*fs);
0647 end
0648
0649 y = polyval(coeffs,t);
0650
0651
0652 ts = tsdata(t, y);
0653 ts = set(ts, 'name', 'Polyval');
0654 ts = set(ts, 'xunits', 's');
0655 ts = set(ts, 'yunits', 'V');
0656
0657
0658 a.data = ts;
0659 a.hist = history(ALGONAME, VERSION, pl);
0660 end
0661
0662
0663
0664
0665
0666
0667
0668
0669
0670
0671
0672
0673
0674
0675
0676
0677
0678
0679
0680 function a = aoFromVals(a, pl, VERSION, ALGONAME)
0681
0682 vals = find(pl, 'vals');
0683 N = find(pl, 'N');
0684 if isempty(N)
0685 N = 1;
0686 end
0687
0688 if ischar(vals)
0689 try
0690 vals = eval(vals);
0691 catch
0692 error('Could not convert char array to numeric array.');
0693 end
0694 end
0695
0696
0697 ts = cdata(plist(param('vals', repmat(vals, 1, N))));
0698 ts = set(ts, 'name', 'Vals');
0699
0700
0701 a.data = ts;
0702 a.hist = history(ALGONAME, VERSION, pl);
0703 end
0704
0705
0706
0707
0708
0709
0710
0711
0712
0713
0714
0715
0716
0717
0718
0719
0720
0721
0722
0723 function a = aoFromWaveform(a, pl, VERSION, ALGONAME)
0724
0725 nsecs = find(pl, 'nsecs');
0726 fs = find(pl, 'fs');
0727 t0 = find(pl, 't0');
0728 if isempty(t0)
0729 t0 = time(0);
0730 end
0731
0732 waveform = find(pl, 'waveform');
0733 switch waveform
0734
0735 case 'sine wave'
0736 freq = find(pl, 'f');
0737 phi = find(pl, 'phi');
0738 if isempty(freq)
0739 freq = 1;
0740 end
0741 if isempty(phi)
0742 phi = 0;
0743 end
0744 tsfcn = sprintf('sin(2*pi*%g*t + %g*pi/180)', freq, phi);
0745
0746 case 'noise'
0747 ntype = find(pl, 'type');
0748 if isempty(ntype)
0749 ntype = 'Normal';
0750 end
0751 switch ntype
0752 case 'Normal'
0753 tsfcn = 'randn(size(t))';
0754 case 'Uniform'
0755 tsfcn = 'rand(size(t))';
0756 end
0757
0758 case 'chirp'
0759 f0 = find(pl, 'f0');
0760 fe = find(pl, 'f1');
0761 te = find(pl, 't1');
0762 if isempty(f0)
0763 f0 = 0;
0764 end
0765 if isempty(fe)
0766 fe = fs/2;
0767 end
0768 if isempty(te)
0769 te = nsecs;
0770 end
0771 tsfcn = sprintf('chirp(t,%g,%g,%g)', f0, fe, te);
0772
0773 case 'Gaussian pulse'
0774 fc = find(pl, 'f0');
0775 bw = find(pl, 'bw');
0776 if isempty(fc)
0777 fc = 1;
0778 end
0779 if isempty(bw)
0780 bw = fs/2;
0781 end
0782 tsfcn = sprintf('gauspuls(t,%g,%g)', fc, bw);
0783 case 'Square wave'
0784 freq = find(pl, 'f');
0785 duty = find(pl, 'duty');
0786 if isempty(freq)
0787 freq = 1;
0788 end
0789 if isempty(duty)
0790 duty = 50;
0791 end
0792 tsfcn = sprintf('square(2*pi*%g*t,%g)', freq, duty);
0793 case 'Sawtooth'
0794 freq = find(pl, 'f');
0795 width = find(pl, 'width');
0796 if isempty(freq)
0797 freq = 1;
0798 end
0799 if isempty(width)
0800 width = 0.5;
0801 end
0802 tsfcn = sprintf('sawtooth(2*pi*%g*t,%g)', freq, width);
0803 end
0804
0805
0806
0807 t = linspace(0, nsecs-1/fs, nsecs*fs);
0808
0809 y = eval([tsfcn ';']);
0810
0811 ts = tsdata(t,y);
0812 ts = set(ts, 'name', tsfcn);
0813 ts = set(ts, 'xunits', 's');
0814 ts = set(ts, 'yunits', 'V');
0815 ts = set(ts, 't0', t0);
0816
0817
0818 a.name = waveform;
0819 a.data = ts;
0820 a.hist = history(ALGONAME, VERSION, pl);
0821 end
0822
0823
0824
0825
0826
0827
0828
0829
0830
0831
0832
0833
0834
0835
0836
0837
0838
0839
0840
0841 function a = aoFromTSfcn(a, pl, VERSION, ALGONAME)
0842
0843 nsecs = find(pl, 'nsecs');
0844 fs = find(pl, 'fs');
0845 fcn = find(pl, 'tsfcn');
0846 randn_state = find(pl, 'rand_state');
0847 t0 = find(pl, 't0');
0848 if isempty(t0)
0849 t0 = time(0);
0850 end
0851
0852
0853 t = linspace(0, nsecs-1/fs, nsecs*fs);
0854
0855
0856
0857
0858
0859 if ~isempty(randn_state)
0860 randn('state',randn_state);
0861 else
0862 randn_state = randn('state');
0863 pl = append(pl , 'rand_state', randn_state);
0864 end
0865
0866 y = eval([fcn ';']);
0867
0868 ts = tsdata(t,y);
0869 ts = set(ts, 'name', fcn);
0870 ts = set(ts, 'xunits', 's');
0871 ts = set(ts, 'yunits', 'V');
0872 ts = set(ts, 't0', t0);
0873
0874
0875 a.data = ts;
0876 a.hist = history(ALGONAME, VERSION, pl);
0877 end
0878
0879
0880
0881
0882
0883
0884
0885
0886
0887
0888
0889
0890
0891
0892
0893
0894
0895
0896 function a = aoFromFSfcn(a, pl, VERSION, ALGONAME)
0897
0898 dpl = getDefaultPlist('Frequency-series Function');
0899 pl = combine(pl, dpl);
0900 f = find(pl, 'f');
0901 if isempty(f)
0902 disp('--- generating f')
0903 f1 = find(pl, 'f1');
0904 f2 = find(pl, 'f2');
0905 nf = find(pl, 'nf');
0906 scale = find(pl, 'scale');
0907 switch scale
0908 case 'log'
0909 f = logspace(log10(f1), log10(f2), nf);
0910 case 'lin'
0911 f = linspace(f1, f2, nf);
0912 otherwise
0913 error('### Unknown frequency scale specified');
0914 end
0915 end
0916
0917
0918 fcn = find(pl, 'fsfcn');
0919
0920
0921 y = eval([fcn ';']);
0922
0923 fs = fsdata(f,y);
0924 fs = set(fs, 'name', fcn);
0925 fs = set(fs, 'xunits', 'Hz');
0926 fs = set(fs, 'yunits', 'Arb');
0927
0928
0929 a.data = fs;
0930 a.hist = history(ALGONAME, VERSION, pl);
0931 end
0932
0933
0934
0935
0936
0937
0938
0939
0940
0941
0942
0943
0944
0945
0946
0947
0948
0949
0950
0951 function a = aoFromFcn(a, pl, VERSION, ALGONAME)
0952
0953 fcn = find(pl, 'fcn');
0954
0955
0956 for jj=1:nparams(pl)
0957 p = pl.params(jj);
0958 if ~strcmpi(fcn, p.val)
0959
0960 fcn = strrep(fcn, p.key, mat2str(p.val));
0961
0962 fcn = strrep(fcn, lower(p.key), mat2str(p.val));
0963 end
0964 end
0965
0966
0967 ts = cdata(plist(param('fcn', fcn)));
0968 ts = set(ts, 'name', fcn);
0969
0970
0971 a.data = ts;
0972 a.hist = history(ALGONAME, VERSION, pl);
0973 end
0974
0975
0976
0977
0978
0979
0980
0981
0982
0983
0984
0985
0986
0987
0988
0989
0990
0991
0992
0993
0994 function a = aoFromFilenameAndPlist(init_ao, file_name, pl, VERSION, ALGONAME)
0995
0996 a = [];
0997
0998 [pathstr, f_name, ext] = fileparts(file_name);
0999
1000
1001 pl_default = plist('columns', [1 2], ...
1002 'num_columns', 10, ...
1003 'type', 'tsdata', ...
1004 'use_fs', '', ...
1005 'comment_char', '%', ...
1006 'xunits', 'sec', ...
1007 'yunits', 'V');
1008 pl = combine(pl, pl_default);
1009
1010 pl = pset(pl, param('filename', [f_name ext]));
1011 pl = pset(pl, param('filepath', pathstr));
1012
1013 data_type = find (pl, 'type');
1014 columns = find (pl, 'columns');
1015 num_columns = find (pl, 'num_columns');
1016 comment_char = find (pl, 'comment_char');
1017 use_fs = find (pl, 'use_fs');
1018 xunits = find (pl, 'xunits');
1019 yunits = find (pl, 'yunits');
1020 t0 = find (pl, 't0');
1021
1022
1023 [fid,msg] = fopen (file_name, 'r');
1024 if (fid < 0)
1025 error ('### can not open file: %s \n\n### error msg:',file_name, msg);
1026 end
1027
1028
1029 scan_format = [];
1030 for ii=1:num_columns
1031 scan_format = [scan_format '%f '];
1032 end
1033 scan_format = scan_format(1:end-1);
1034
1035
1036 raw_data = textscan( fid, scan_format, ...
1037 'commentStyle', comment_char, ...
1038 'CollectOutput', 1);
1039 f_data = raw_data{1};
1040
1041 if isempty(f_data)
1042 error([char(10) '### There are no data. ' ...
1043 'Did you use the right comment character?' char(10) ...
1044 '### The current comment character is: ' comment_char char(10) ...
1045 '### Use a parameter list with the parameter:' char(10) ...
1046 '### plist(''comment_char'', ''%'')']);
1047 end
1048
1049 fclose(fid);
1050
1051
1052 if isempty(use_fs)
1053
1054
1055 if mod(length(columns),2) ~= 0
1056 error('### the numbers in columns must be straight');
1057 end
1058
1059 for lauf = 1:length(columns)/2
1060
1061 data_x_axes = f_data(:, columns(lauf*2-1));
1062 data_y_axes = f_data(:, columns(lauf*2));
1063
1064
1065 ao_data = [];
1066 switch data_type
1067 case 'tsdata'
1068 ao_data = tsdata( data_x_axes, data_y_axes);
1069 case 'fsdata'
1070 ao_data = fsdata( data_x_axes, data_y_axes);
1071 case 'cdata'
1072 error ('### please code me up')
1073 case 'xydata'
1074 ao_data = xydata( data_x_axes, data_y_axes);
1075 otherwise
1076 error('### unknown data type ''%s''', data_type);
1077 end
1078 ao_data.name = sprintf('f_name_%02d', lauf);
1079 ao_data.xunits = xunits;
1080 ao_data.yunits = yunits;
1081
1082 aa = init_ao;
1083
1084 aa.name = sprintf('f_name_%02d', lauf);
1085 aa.data = ao_data;
1086 aa.hist = history(ALGONAME, VERSION, pl);
1087
1088
1089 description_pl = find(pl, 'description');
1090 if ~isempty(description_pl)
1091 aa.description = description_pl;
1092 end
1093
1094 a = [a aa];
1095
1096 end
1097
1098
1099 else
1100
1101 for lauf = 1:length(columns)
1102
1103 data_y_axes = f_data(:, columns(lauf));
1104
1105
1106 ao_data = [];
1107 switch data_type
1108 case 'tsdata'
1109 ao_data = tsdata(data_y_axes, use_fs);
1110 case 'fsdata'
1111 ao_data = fsdata(data_y_axes, use_fs);
1112 case 'cdata'
1113 error ('### please code me up')
1114 case 'xydata'
1115 error ('### please code me up')
1116 otherwise
1117 error('### unknown data type ''%s''', data_type);
1118 end
1119 ao_data.name = sprintf('f_name_%02d', lauf);
1120 ao_data.xunits = xunits;
1121 ao_data.yunits = yunits;
1122
1123 aa = init_ao;
1124 aa.name = sprintf('f_name_%02d', lauf);
1125 aa.data = ao_data;
1126 aa.hist = history(ALGONAME, VERSION, pl);
1127
1128
1129 description_pl = find(pl, 'description');
1130 if ~isempty(description_pl)
1131 aa.description = description_pl;
1132 end
1133
1134 a = [a aa];
1135
1136 end
1137
1138 end
1139
1140
1141 for ii = 1:length(a)
1142 fields = fieldnames(a(ii).data);
1143 for jj = 1:length(pl.params)
1144 parameter = lower(pl.params(jj));
1145 if ismember(parameter.key, upper(fields))
1146 if iscell(parameter.val)
1147 if length(parameter.val) > 1
1148 if length(parameter.val) ~= length(a)
1149 warning([sprintf('The values of the key ''%s'' ', parameter.key) ...
1150 'have not the same length as the lentgh of ' ...
1151 'the output. Using the first value!']);
1152 a(ii).data.(lower(parameter.key)) = parameter.val{1};
1153 else
1154 a(ii).data.(lower(parameter.key)) = parameter.val{ii};
1155 end
1156 else
1157 a(ii).data.(lower(parameter.key)) = parameter.val{1};
1158 end
1159 else
1160 a(ii).data.(lower(parameter.key)) = parameter.val;
1161 end
1162
1163 end
1164 end
1165 end
1166 end
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186 function a = aoFromSpecWin(a, win, VERSION, ALGONAME)
1187
1188
1189 ts = cdata(win.win);
1190 ts = set(ts, 'name', win.name);
1191
1192
1193 a.name = win.name;
1194 a.data = ts;
1195 a.hist = history(ALGONAME, VERSION, plist(param('win', win)));
1196 end
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213 function out = getDefaultPlist(varargin)
1214
1215
1216 sets = {'From XML file', 'From ASCII file',...
1217 'Function', 'Values',...
1218 'Time-series Function', 'Frequency-series Function', ...
1219 'From Window', 'Waveform', 'From Polynomial', 'From Repository',...
1220 'From Plist'};
1221
1222 if nargin == 0
1223 out = sets;
1224 return
1225 end
1226
1227 set = varargin{1};
1228
1229 switch set
1230 case 'From Repository'
1231 out = plist('hostname', 'localhost', 'database', 'ltpda', 'ID', []);
1232 case 'From XML file'
1233 out = plist('filename', 'foo.xml');
1234 case 'From ASCII file'
1235 out = plist('filename', 'foo.txt',...
1236 'type', 'tsdata',...
1237 'columns', [1 2],...
1238 'num_columns', 10,...
1239 't0', time(0),...
1240 'comment_char', '%');
1241 case 'Function'
1242 out = plist('fcn', 'randn(100,1)');
1243 case 'Values'
1244 out = plist('vals', [1 2 3], 'N', 1);
1245 case 'Time-series Function'
1246 out = plist('tsfcn', 'randn(size(t))', 'fs', 10, 'nsecs', 100, 't0', time(0));
1247 case 'Frequency-series Function'
1248 out = plist('fsfcn', '1./f', 'f1', 1e-9, 'f2', 100, 'nf', 1000, 'scale', 'log', 'f', []);
1249 case 'From Window'
1250 out = plist('win', specwin('Hanning', 100));
1251 case 'From Polynomial'
1252 out = plist('polyval', [-1e-4 .02 -1 -1], 'Nsecs', 100, 'fs', 10);
1253 case 'From Plist'
1254 out = plist('Plist', plist);
1255 case 'Waveform'
1256 out = plist('waveform', 'sine wave',...
1257 'f', 1.23,...
1258 'phi', 0,...
1259 'fs', 10,...
1260 'nsecs', 10,...
1261 't0', time(0));
1262 otherwise
1263 out = plist();
1264 end
1265
1266 end
1267
1268
1269 end