Skip to content
Snippets Groups Projects
Commit 32adf946 authored by Cristian Galperti's avatar Cristian Galperti
Browse files

First commit of SCD v2018b on git 

corresponds to svn tag svn://scd.epfl.ch/rtccode/tags/R2018b_version_to_git_April2019
parents
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 2054 additions and 0 deletions
configurationsR2018b/initialization/SCDclass_algo.m 0 → 100644
+ 251
− 0
View file @ 32adf946
classdef SCDclass_algo
%SCD algorithm handling object
% The class holds all information and
% methods for handling a Simulink
% algorithm
properties (Access = private)
modelname % Name of the model
mdscontainer % Container class for MDS+ interface objects
taskcontainer % Container class for init and term tasks
exportedtps % List of tunable parameters variable to be exported
datadictionary % Name of the used data dictionary
stdinits % Standard inits scripts for fixed parameters
timing % Timing info structure
end
methods
%% Constructor
function obj=SCDclass_algo(name)
% Empty algorithm constructor
obj.modelname=name;
obj.mdscontainer = SCDclass_mdsobjcontainer;
obj.taskcontainer = SCDclass_taskcontainer;
obj.exportedtps = {};
obj.stdinits = {};
obj.datadictionary = '';
obj.timing.t_start=0;
obj.timing.t_stop=1;
obj.timing.dt=1e-3;
% Standard data dictionary equal to algorithm name,
% overriddable by the setter method
obj=obj.setdatadictionary([name '.sldd']);
end
%% Print infos
function printinfo(obj)
fprintf('*****************************************************\n');
fprintf('* SCD algorithm: ''%s''\n',obj.modelname);
fprintf('*****************************************************\n');
if(~isempty(obj.datadictionary))
fprintf('* Data dictionary:\n %s\n',obj.datadictionary);
else
fprintf('* Data dictionary:\n base workspace\n');
end
if numel(obj.exportedtps)>0
fprintf('* Tunable params structs:\n');
for ii=1:numel(obj.exportedtps)
fprintf(' %s\n',obj.exportedtps{ii});
end
end
fprintf('* Tunable params objects:\n')
obj.printparameters;
fprintf('* Wavegen objects:\n');
obj.printwavegens;
fprintf('* Tasks objects:\n');
obj.printtasks;
fprintf('* Fixed parameters inits:\n');
obj.printinits;
fprintf('*****************************************************\n');
end
%% General purpose getters
function out = getname(obj)
out=obj.modelname;
end
function out = getmdscontainer(obj)
out=obj.mdscontainer;
end
function out = gettaskcontainer(obj)
out=obj.taskcontainer;
end
function out = gettiming(obj)
out=obj.timing;
end
function out = getinits(obj)
out=obj.stdinits;
end
%% Data dictionary setter and getter
function obj = setdatadictionary(obj, datadict)
obj.datadictionary=datadict;
end
function out = getdatadictionary(obj)
out = obj.datadictionary;
end
%% Tunable parameters structures handling functions
function out = getexportedtps(obj)
out = obj.exportedtps;
end
function obj = addtunparamstruct(obj, structname)
if(~ismember(structname, obj.exportedtps))
obj.exportedtps{end+1}=structname;
else
error('SCDclass_algo:addtunparamsstruct','Tunable parameter struct already present, cannot add!');
end
end
function obj = buildworkspacetpstruct(obj)
% this funtion builds a workspace structures containing
% replicas of all tunable parameters structurea in the data
% dictionaries, this structure is the one actually used
% for loading simulation wavegen data
% It is better not to use directly data dictionaries structures
% to avoid flooding dds with big sim data sets (and
% conseguently the SCD SVN itself
if(isempty(obj.datadictionary))
warning('SCDclass_algo:buildworkspacetpstruct','Methods ignored for this object, data dictionary isn''t configured');
return;
end
dd=SCDconf_getdatadict(obj.datadictionary);
for ii=1:numel(obj.exportedtps)
simstructnamedd=sprintf('%s_tmpl',char(obj.exportedtps(ii)));
simstructnamews=char(obj.exportedtps(ii));
simstruct=dd.getEntry(simstructnamedd).getValue;
assignstr=sprintf('%s=temp;',simstructnamews);
assignin('base','temp',simstruct);
evalin('base',assignstr);
end
evalin('base','clear temp;');
end
%% MDS container methods forwarders
function obj = addparameter(obj, param)
obj.mdscontainer=obj.mdscontainer.addparameter(param);
obj.mdscontainer=obj.mdscontainer.bindlastparameter(obj.modelname, obj.datadictionary, obj.exportedtps);
end
function obj = printparameters(obj)
obj.mdscontainer=obj.mdscontainer.printparameters;
end
function obj = actualizeparameters(obj, shot)
obj.mdscontainer=obj.mdscontainer.actualizeparameters(shot);
end
function obj = addwavegen(obj, wavegen)
obj.mdscontainer=obj.mdscontainer.addwavegen(wavegen);
obj.mdscontainer=obj.mdscontainer.bindlastwavegen(obj.modelname, obj.datadictionary, obj.timing);
end
function obj = printwavegens(obj)
obj.mdscontainer=obj.mdscontainer.printwavegens;
end
function obj = actualizewavegens(obj, shot)
obj.mdscontainer=obj.mdscontainer.actualizewavegens(shot);
end
function obj = cleanwavegens(obj)
obj.mdscontainer=obj.mdscontainer.cleanwavegens;
end
%function obj = bindparameters(obj)
% obj.mdscontainer=obj.mdscontainer.bindparameters(obj.modelname, obj.datadictionary, obj.exportedtps);
%end
% This method has only sense in the expcode context
%function obj = buildworkspacesimstruct(obj)
% obj.mdscontainer=obj.mdscontainer.buildworkspacesimstruct;
%end
%% Task container methods forwarders
function obj = addtask(obj, task)
obj.taskcontainer=obj.taskcontainer.addtask(task);
obj.taskcontainer=obj.taskcontainer.bindlasttask(obj.modelname, obj.datadictionary);
end
function obj = printtasks(obj)
obj.taskcontainer=obj.taskcontainer.printtasks;
end
%% Wavegen timing structure setters
% function obj = setwavegentimingsources(obj, tstart, dt, tstop)
% assert(ischar(tstart), 'SCDclass_algo.setwavegentimingsources first parameter must be a char array');
% assert(ischar(dt), 'SCDclass_algo.setwavegentimingsources first parameter must be a char array');
% assert(ischar(tstop), 'SCDclass_algo.setwavegentimingsources first parameter must be a char array');
%
% obj.wavegentiming.t_start=tstart;
% obj.wavegentiming.dt=dt;
% obj.wavegentiming.t_stop=tstop;
% end
%% Timing information
function obj = settiming(obj, t_start, dt, t_stop)
obj.timing.t_start=t_start;
obj.timing.dt=dt;
obj.timing.t_stop=t_stop;
end
%% Fixed inits
function obj = addfpinitfcn(obj, fcnname, targetstruct)
if(~isempty(obj.stdinits))
for ii=1:numel(obj.stdinits)
if(strcmp(char(obj.stdinits{ii}{2}),targetstruct))
warning('SCDclass_algo:addfpinitfcn','A function driving the structure %s has already been added, ignoring.\d',targetstruct)
return;
end
end
end
temp=cell(10,1);
temp{1}=fcnname;
temp{2}=targetstruct;
obj.stdinits{end+1}=temp;
end
function printinits(obj)
if(~isempty(obj.stdinits))
for ii=1:numel(obj.stdinits)
fprintf('%s -> %s\n',char(obj.stdinits{ii}{1}),char(obj.stdinits{ii}{2}));
end
end
end
function callinits(obj)
if(~isempty(obj.stdinits))
for(ii=1:numel(obj.stdinits))
fprintf('Calling init function ''%s'', assigning its output to ''%s'' ...\n',char(obj.stdinits{ii}{1}),char(obj.stdinits{ii}{2}));
initcmd=sprintf('[fp]=%s(obj);', char(obj.stdinits{ii}{1}));
eval(initcmd);
Simulink.data.assigninGlobal(obj.modelname, char(obj.stdinits{ii}{2}), fp);
end
end
end
end
end
configurationsR2018b/initialization/SCDclass_expcode.m 0 → 100644
+ 0
− 0
View file @ 32adf946
This diff is collapsed.
configurationsR2018b/initialization/SCDclass_expcodecontainer.m 0 → 100644
+ 169
− 0
View file @ 32adf946
classdef SCDclass_expcodecontainer
% A container class for expcodes
properties(Access = private)
numexpcodes
expcodes
end
methods
function obj=SCDclass_expcodecontainer()
obj.numexpcodes=0;
obj.expcodes={};
end
function obj=insertexpcode(obj, maincode, definefunction)
if(obj.numexpcodes==0)
temp=cell(10,1);
temp{1}=maincode;
temp{2}=definefunction;
obj.expcodes{end+1}=temp;
obj.numexpcodes=obj.numexpcodes+1;
fprintf('Expcode %d inserted (pos %d)\n', maincode, 1);
else
expcodepresent=false;
expcodeindex=0;
for(ii=1:numel(obj.expcodes))
if(obj.expcodes{ii}{1}==maincode || strcmp(char(obj.expcodes{ii}{2}),definefunction))
expcodepresent=true;
expcodeindex=ii;
break;
end
end
if(expcodepresent)
obj.expcodes{expcodeindex}=expcode;
fprintf('Expcode %d already present (pos %d), skipped insertion.\n', maincode, expcodeindex);
else
temp=cell(10,1);
temp{1}=maincode;
temp{2}=definefunction;
presentcodes=[];
for(ii=1:obj.numexpcodes)
presentcodes(ii)=obj.expcodes{ii}{1};
end
insertpos=max(find(maincode>presentcodes));
if(insertpos==obj.numexpcodes)
obj.expcodes{end+1}=temp;
fprintf('Expcode %d inserted (pos %d)\n', maincode, obj.numexpcodes+1);
else
for(jj=obj.numexpcodes:-1:insertpos)
obj.expcodes{jj+1}=obj.expcodes{jj};
end
obj.expcodes{insertpos}=temp;
fprintf('Expcode %d inserted (pos %d)\n', expcode.maincode, insertpos);
end
obj.numexpcodes=obj.numexpcodes+1;
end
end
end
function printexpcodes(obj)
if(obj.numexpcodes==0)
disp('No configured expcodes.');
else
fprintf('------------------------------------------------------------------\n');
fprintf('CODE\tSTATUS\tNAME\n');
fprintf('------------------------------------------------------------------\n');
for ii=1:obj.numexpcodes
try
expcode=obj.expcodes{ii}{2}();
if(~isa(expcode,'SCDclass_expcode'))
error('SCDclass_expcodecontainer.getbymaincode','Expcode defining function not returning the right object');
end
fprintf('%d\t%s\t%s\n',obj.expcodes{ii}{1},expcode.status,expcode.name);
catch ME
fprintf('%d\tERROR calling conf function: %s\n', obj.expcodes{ii}{1},char(obj.expcodes{ii}{2}));
end
end
fprintf('------------------------------------------------------------------\n');
end
end
function out=getbymaincode(obj,code)
if(obj.numexpcodes==0)
error('SCDclass_expcodecontainer.getbymaincode','Expcode container empty!');
end
presentcodes=[];
for(ii=1:obj.numexpcodes)
presentcodes=[presentcodes; obj.expcodes{ii}{1}];
end
if(isempty(find(code==presentcodes)))
error('SCDclass_expcodecontainer.getbymaincode','Expcode not present in the container class');
else
deffunc = obj.expcodes{find(code==presentcodes)}{2};
%expcode = eval(char(deffunc));
expcode = deffunc();
assert(isa(expcode,'SCDclass_expcode'),'SCDclass_expcodecontainer.getbymaincode the configured defining function doesn''t return a SCDclass_expcode object');
expcode.maincode=code;
out=expcode;
end
end
end
end
%
% function obj=insertexpcode_object(obj, expcode)
% assert(isa(expcode,'SCDclass_expcode'),'SCDclass_expcodecontainer.insertexpcode only SCDclass_expcode classes accepted as input');
%
% if(obj.numexpcodes==0)
% obj.expcodes{end+1}=expcode;
% obj.numexpcodes=obj.numexpcodes+1;
%
% fprintf('Expcode %d inserted (pos %d)\n', expcode.maincode, 1);
% else
% expcodepresent=false;
% expcodeindex=0;
%
% for(ii=1:numel(obj.expcodes))
% if(obj.expcodes{ii}.maincode==expcode.maincode)
% expcodepresent=true;
% expcodeindex=ii;
% break;
% end
% end
%
% if(expcodepresent)
% obj.expcodes{expcodeindex}=expcode;
%
% fprintf('Expcode %d already present (pos %d), data updated.\n', expcode.maincode, expcodeindex);
% else
%
% presentcodes=[];
% for(ii=1:obj.numexpcodes)
% presentcodes(ii)=obj.expcodes{ii}.maincode;
% end
% insertpos=max(find(expcode.maincode>presentcodes));
%
% if(insertpos==obj.numexpcodes)
% obj.expcodes{end+1}=expcode;
%
% fprintf('Expcode %d inserted (pos %d)\n', expcode.maincode, obj.numexpcodes+1);
% else
% for(jj=obj.numexpcodes:-1:insertpos)
% obj.expcodes{jj+1}=obj.expcodes{jj};
% end
% obj.expcodes{insertpos}=expcode;
% fprintf('Expcode %d inserted (pos %d)\n', expcode.maincode, insertpos);
% end
%
% obj.numexpcodes=obj.numexpcodes+1;
% end
%
% end
% end
configurationsR2018b/initialization/SCDclass_mdsobjcontainer.m 0 → 100644
+ 249
− 0
View file @ 32adf946
classdef SCDclass_mdsobjcontainer
% This class is a container class
% for all MDS objects required for handling
% a no-nocompile Simulink SCD model
%
% Presently it implements methods for handling
% objects of the following classes:
% SCDclass_mdsparam (and childrens)
% SCDclass_mdswavegen (and childrens)
properties
numparams % number of configured params objects
mdsparams % params objects array
numwavegens % number od configured wavegens objects
mdswavegens % wavegens objects array
simstructlist % list of names of simstructs to be transferred to
% base workspace upon expcode setup
end
methods
function obj = SCDclass_mdsobjcontainer()
% contructor, empty container
obj.numparams=0;
obj.numwavegens=0;
obj.simstructlist= [ ...
{'SCDnode01simdata'},...
{'SCDnode02simdata'},...
{'SCDnode03simdata'},...
{'SCDnode06simdata'},...
{'SCDnode07simdata'},...
{'SCDnode08simdata'},...
{'SCDnode0201_simdata'},...
{'SCDnode0202_simdata'},...
{'SCDnode0203_simdata'},...
{'SCDnode0204_simdata'},...
{'SCDnode0301_simdata'},...
{'SCDnode0302_simdata'},...
{'SCDnode0303_simdata'},...
{'SCDnode0304_simdata'},...
{'SCDnode0601_simdata'},...
{'SCDnode0602_simdata'},...
{'SCDnode0603_simdata'},...
{'SCDnode0604_simdata'},...
{'SCDnode0701_simdata'},...
{'SCDnode0702_simdata'},...
{'SCDnode0703_simdata'},...
{'SCDnode0704_simdata'},...
{'SCDnode0801_simdata'}...
];
end
function obj = addparameter(obj, param)
% Adds a parameter object
if obj.numparams==0
obj.mdsparams=param;
else
obj.mdsparams=[obj.mdsparams; param];
end
obj.numparams=obj.numparams+1;
end
function obj = printparameters(obj)
% prints the parameters object list
if obj.numparams>0
for ii=1:obj.numparams
obj.mdsparams(ii).printinfo();
end
end
end
function obj = actualizeparameters(obj, shot)
% actualize the parameters on the gove data dictionary,
% naive version with a mds acces for every parameter
if obj.numparams>0
for ii=1:obj.numparams
obj.mdsparams(ii).actualizedata(shot);
end
end
end
function obj = bindparameters(obj, modelname, datadictionary, exportedtps)
if obj.numparams>0
for ii=1:obj.numparams
obj.mdsparams(ii)=obj.mdsparams(ii).setmodelname(modelname);
obj.mdsparams(ii)=obj.mdsparams(ii).setdatadictionary(datadictionary);
end
if numel(exportedtps)>0
for ii=1:obj.numparams
obj.mdsparams(ii)=obj.mdsparams(ii).setparamstructure(exportedtps{end});
end
end
end
end
function obj = bindlastparameter(obj, modelname, datadictionary, exportedtps)
if obj.numparams>0
obj.mdsparams(end)=obj.mdsparams(end).setmodelname(modelname);
obj.mdsparams(end)=obj.mdsparams(end).setdatadictionary(datadictionary);
if numel(exportedtps)>0
obj.mdsparams(end)=obj.mdsparams(end).setparamstructure(exportedtps{end});
end
end
end
function obj = addwavegen(obj, wavegen)
% adds a wavegen object
if obj.numwavegens==0
obj.mdswavegens=wavegen;
else
obj.mdswavegens=[obj.mdswavegens; wavegen];
end
obj.numwavegens=obj.numwavegens+1;
end
function obj = bindlastwavegen(obj, modelname, datadictionary, timingsrc)
if obj.numwavegens>0
obj.mdswavegens(end)=obj.mdswavegens(end).setmodelname(modelname);
obj.mdswavegens(end)=obj.mdswavegens(end).setdatadictionary(datadictionary);
obj.mdswavegens(end)=obj.mdswavegens(end).settiminginfo(timingsrc);
end
end
function obj = setwavegenbasestruct(obj, basestruct)
if obj.numwavegens>0
for ii=1:obj.numwavegens
obj.mdswavegens(ii)=obj.mdswavegens(ii).setbasestruct(basestruct);
end
end
end
function obj = printwavegens(obj)
% prints the wavegen list
if obj.numwavegens>0
for ii=1:obj.numwavegens
obj.mdswavegens(ii).printinfo();
end
end
end
function obj = actualizewavegens(obj, shot)
% actualize the wavegen waves timeseries
% naive version, a mds connection is called for every object
if obj.numwavegens>0
for ii=1:obj.numwavegens
obj.mdswavegens(ii).actualizedata(shot);
end
end
end
function obj = cleanwavegens(obj)
% clean wavegens leaving a consistent (with model buses)
% empty timeseries data structure
if obj.numwavegens>0
for ii=1:obj.numwavegens
obj.mdswavegens(ii).cleandata;
end
end
end
function obj = buildworkspacesimstruct(obj)
% this funtion builds a workspace structure containing
% a replica of all simulation structures in the data
% dictionaries, this structure is the one actually used
% for loading simulation wavegen data
% It is better not to use directly data dictionaries structures
% to avoid flooding dds with big sim data sets (and
% conseguently the SCD SVN itself
dd=SCDconf_getdatadict('tcv.sldd');
evalin('base','SCDsimdata=struct();');
for ii=1:numel(obj.simstructlist)
simstructname=char(obj.simstructlist(ii));
simstruct=dd.getEntry(simstructname).getValue;
assignstr=sprintf('SCDsimdata.%s=temp;',simstructname);
assignin('base','temp',simstruct);
evalin('base',assignstr);
end
evalin('base','clear temp;');
end
function obj = importmdsobjects(obj, source)
% parameters import
destparamtargets={};
if obj.numparams>0
for ii=1:obj.numparams
destparamtargets{end+1}=obj.mdsparams(ii).gettargetparam;
end
end
numparamstoimport = source.numparams;
paramstoimport = source.mdsparams;
if numparamstoimport>0
for ii=1:numparamstoimport
if ~ismember(paramstoimport(ii).gettargetparam, destparamtargets)
obj=obj.addparameter(paramstoimport(ii));
else
warning('SCDclass_mdsobjcontainer:importmdsobjects','A mds object driving ''%s'' is already present in the dest. expcode, skipping!',paramstoimport(ii).gettargetparam);
end
end
end
% wavegens import
destwavegentargets={};
if obj.numwavegens>0
for ii=1:obj.numwavegens
destwavegentargets{end+1}=obj.mdswavegens(ii).gettargetwavegen;
end
end
numwavegenstoimport = source.numwavegens;
wavegenstoimport = source.mdswavegens;
if numwavegenstoimport>0
for ii=1:numwavegenstoimport
if ~ismember(wavegenstoimport(ii).gettargetwavegen, destwavegentargets)
obj=obj.addwavegen(wavegenstoimport(ii));
else
warning('SCDclass_mdsobjcontainer:importmdsobjects','A mds object driving ''%s'' is already present in the dest. expcode, skipping!',wavegenstoimport(ii).gettargetwavegen);
end
end
end
end
function printMARTe2parconfig(obj, shot)
for ii=1:obj.numparams
str=obj.mdsparams(ii).genMARTe2entry(shot);
fprintf(" %s\n",str);
end
end
function printMARTe2wgconfig(obj, shot)
for ii=1:obj.numwavegens
str=obj.mdswavegens(ii).genMARTe2entry(shot);
fprintf(" %s\n",str);
end
end
end
end
configurationsR2018b/initialization/SCDclass_mdspar.m 0 → 100644
+ 191
− 0
View file @ 32adf946
classdef SCDclass_mdspar < matlab.mixin.Heterogeneous
% Superclass for MDS+ parameters
% the superclass matlab.mixin.Heterogeneous allows
% bilding of lists of mixed kind parameters in the
% expcode configuration (and later in C++ code)
% For all subclasses, by default all NaN values are converted to 0
properties (Access = protected)
mdsserver % The MDS+ server hosting the parameter
mdstree % The MDS+ Tree hosting the parameter
tdiexprmodel % TDI expression to retrieve data when invoked with -1 shot
tdiexprshot % TDI expression to retrieve data when invoked with a give shotno, if empty the -1 is used
tdiexprused % TDI expression actually used
modelparam % Full expansion of the model target parameter (modeltpstruct+modeltargetpar)
modeltpstruct % target tunable parameter structure, if left empty it will be filled once binding to an algorithm
modeltargetpar % Model parameter w/o tunable parameters structure
value % value of the parameter
datadictionary % data dictionary hosting the parameter, if empty base workspace
modelname % name of the Simulink model using the parameter
getcommand % full command for getting the value (callable by matlab eval)
classname % class name for logging
assignvar % actualizedata specific
assignstring % actualizedata specific
denanstring % actualizedata specific
caststring % actualizedata specific
end
properties
verbose % Verbosity of the class
end
methods
function obj=SCDclass_mdspar(srctdimodel,destparam,varargin)
% MDS source and model destination constructor
p=inputParser;
addRequired(p,'srctdimodel',@(x) ischar(x));
addRequired(p,'destparam',@(x) ischar(x));
addParameter(p,'srcsrv','tcvdata',@(x) ischar(x));
addParameter(p,'srctree','tcv_shot',@(x) ischar(x));
addParameter(p,'srctdishot','',@(x) ischar(x));
addParameter(p,'modelname','',@(x) ischar(x));
addParameter(p,'datadictname','',@(x) ischar(x));
addParameter(p,'modeltpstruct','',@(x) ischar(x)); % desttp ?
parse(p,srctdimodel,destparam,varargin{:}{:});
obj.mdsserver=p.Results.srcsrv;
obj.mdstree=p.Results.srctree;
obj.tdiexprmodel=p.Results.srctdimodel;
if isempty(p.Results.srctdishot)
obj.tdiexprshot=p.Results.srctdimodel;
else
obj.tdiexprshot=p.Results.srctdishot;
end
obj.modeltargetpar=p.Results.destparam;
obj.modelname=p.Results.modelname;
obj.datadictionary=p.Results.datadictname;
obj.modeltpstruct=p.Results.modeltpstruct;
obj.verbose=1;
end
end
% Not abstract methods common to all child classes
methods
function mdsconnect(obj, shot)
mdsconnect(obj.mdsserver);
s=mdsopen(obj.mdstree, shot);
str=sprintf('SCDclass_mdsparam (%s), failed opening MDS+ tree', obj.modelparam);
assert(s==shot, str);
end
function obj=preactualizecommon(obj, shot)
% Opening the tree
obj.mdsconnect(shot);
% Checking if data can be retrieved, updating get command
[obj, obj.value]=obj.getdata(shot);
pointspos=strfind(obj.modelparam,'.');
baseparam=obj.modelparam(1:pointspos(1)-1);
structparam=obj.modelparam(pointspos(1):end);
obj.assignvar=sprintf('%s.Value%s',baseparam,structparam);
obj.assignstring=sprintf('%s=%s;',obj.assignvar,obj.getcommand);
obj.denanstring=sprintf('%s(isnan(%s))=0;',obj.assignvar,obj.assignvar);
obj.caststring=sprintf('%s=%s;',obj.assignvar,obj.assignvar);
end
function obj=postactualizecommon(obj, shot)
if obj.verbose==1
fprintf('Actualizing parameter: ''%s'' <- ''%s'' (%s, shot %d)\n', obj.modelparam, obj.tdiexprused, obj.classname, shot);
end
evalin('base', obj.assignstring);
evalin('base', obj.denanstring);
evalin('base', obj.caststring);
end
function [obj,value]=getdatacommon(obj, shot)
obj=obj.actualizegetcmd('mdsvalue(''%s'')', shot);
value=eval(obj.getcommand);
str=sprintf('MDS+ error for parameter %s: %s', obj.modelparam, value);
assert(isnumeric(value), str);
end
function obj=actualizegetcmd(obj, cmdstring, shot)
if(shot==-1)
obj.getcommand=sprintf(cmdstring, obj.tdiexprmodel);
obj.tdiexprused=obj.tdiexprmodel;
else
obj.getcommand=sprintf(cmdstring, obj.tdiexprshot);
obj.tdiexprused=obj.tdiexprshot;
end
obj.modelparam=[obj.modeltpstruct '.' obj.modeltargetpar];
end
function printinfocommon(obj)
fprintf('%s (class %s):\n', obj.modelparam, obj.classname);
fprintf(' Simulink model: ''%s'', data dictionary: ''%s''\n', obj.modelname, obj.datadictionary);
fprintf(' MDS+ source server: ''%s'', Tree: ''%s''\n', obj.mdsserver, obj.mdstree);
fprintf(' MDS+ TDI expressions, model: ''%s''', obj.tdiexprmodel);
if(strcmp(obj.tdiexprmodel, obj.tdiexprshot))
fprintf(', shot: same.\n');
else
fprintf(', shot: ''%s''\n', obj.tdiexprshot);
end
end
function out = gettargetparam(obj)
out = obj.modelparam;
end
function obj = setparamstructure(obj, structname)
%obj.modelparam = [structname '.' obj.modelparam];
if(isempty(obj.modeltpstruct))
obj.modeltpstruct = structname;
end
obj.modelparam=[obj.modeltpstruct '.' obj.modeltargetpar];
end
function obj = setmodelname(obj, modelname)
if(isempty(obj.modelname))
obj.modelname = modelname;
end
end
function obj = setdatadictionary(obj, ddname)
if(isempty(obj.datadictionary))
obj.datadictionary = ddname;
end
end
function entrystring = genMARTe2entrycommon(obj, shot)
obj.mdsconnect(shot);
[obj,~]=obj.getdata(shot);
%entrystring = ['+' obj.modeltargetpar ' = { Class=' obj.classname ' Path=' obj.tdiexprused ' }'];
entrystring = ['+' obj.modeltargetpar ' = { Class=' obj.classname ' Path=' obj.tdiexprused];
end
end
% Abstract method actually implemented by child classes
methods (Abstract)
% Gets data from MDS+ and actualizes it on the model,
% Connects to MDS+ and opens the tree, to be
% improved via container class of this class
actualizedata(obj, shot)
% Gets data from mds, mds connection is assumed already estabilished
% and tree opened
[obj, value] = getdata(obj, shot)
% Generate C++ code
%gencode(obj)
% Generate MARTe2 configuration entry
entrystring = genMARTe2entry(obj, shot)
% Prints the parameter info summary
printinfo(obj)
end
end
configurationsR2018b/initialization/SCDclass_mdspar3Dmatrix.m 0 → 100644
+ 38
− 0
View file @ 32adf946
classdef SCDclass_mdspar3Dmatrix < SCDclass_mdspar
% A constant 3D matrix real (single) MDS+ parameter
properties
end
methods
function obj=SCDclass_mdspar3Dmatrix(srctdimodel, destparam, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj,shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparfixdimvector.m 0 → 100644
+ 55
− 0
View file @ 32adf946
classdef SCDclass_mdsparfixdimvector < SCDclass_mdspar
% A constant 1D vector real (single) MDS+ parameter
% If the number of elements is different w.r.t. the
% property dimension, the size is adjusted by zero
% filling or clipping
properties(Access=private)
dimension
end
methods
function obj=SCDclass_mdsparfixdimvector(srctdimodel, destparam, destdimension, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
obj.dimension=destdimension;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
numelements=numel(obj.value);
if(numelements<obj.dimension)
localgetcommand=sprintf('[%s; zeros(%d,1)]',obj.getcommand, obj.dimension-numelements);
elseif(numelements>obj.dimension)
localgetcommand=sprintf('%s(1:%d)', obj.getcommand, obj.dimension);
else
localgetcommand=obj.getcommand;
end
obj.assignstring=sprintf('%s=%s;',obj.assignvar,localgetcommand);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj,shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
fprintf(' Parameter fixed dimension is: %d\n',obj.dimension);
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparfixdimvectoridx.m 0 → 100644
+ 62
− 0
View file @ 32adf946
classdef SCDclass_mdsparfixdimvectoridx < SCDclass_mdspar
% A constant 1D vector real (single) MDS+ parameter
% with linearly indicized name source.
properties(Access=private)
idxstart
idxstop
end
methods
function obj=SCDclass_mdsparfixdimvectoridx(srctdimodel, destparam, srcinterval, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
intervalchecker=@(x) isnumeric(x) && min(diff(x))==1 && max(diff(x))==1;
assert(intervalchecker(srcinterval));
obj.idxstart=srcinterval(1);
obj.idxstop=srcinterval(end);
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.assignstring=sprintf('%s=temp;',obj.assignvar);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
assignin('base','temp',obj.value);
obj.postactualizecommon(shot);
evalin('base','clear temp');
end
function [obj, value] = getdata(obj,shot)
obj=obj.actualizegetcmd('mdsvalue(''%s'')', shot);
value=[];
for ii=obj.idxstart:obj.idxstop
getcommandstr=sprintf(obj.getcommand, ii);
str=sprintf('MDS+ error for parameter %s: %s', obj.modelparam, eval(getcommandstr));
assert(isnumeric(eval(getcommandstr)), str);
value=[value; eval(getcommandstr)];
end
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
fprintf(' Parameter source index interval is: %d:%d\n',obj.idxstart,obj.idxstop);
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' StartIdx=' num2str(obj.idxstart) ' StopIdx=' num2str(obj.idxstop) ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparfixdimvectorint.m 0 → 100644
+ 54
− 0
View file @ 32adf946
classdef SCDclass_mdsparfixdimvectorint < SCDclass_mdspar
% A constant 1D vector integer (matlab cast to int32) MDS+ parameter
% If the number of elements is different w.r.t. the
% property dimension, the size is adjusted by zero
% filling or clipping
properties(Access=private)
dimension
end
methods
function obj=SCDclass_mdsparfixdimvectorint(srctdimodel, destparam, destdimension, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
obj.dimension=destdimension;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
numelements=numel(obj.value);
if(numelements<obj.dimension)
localgetcommand=sprintf('[%s; zeros(%d,1)]',obj.getcommand, obj.dimension-numelements);
elseif(numelements>obj.dimension)
localgetcommand=sprintf('%s(1:%d)', obj.getcommand, obj.dimension);
else
localgetcommand=obj.getcommand;
end
obj.assignstring=sprintf('%s=%s;',obj.assignvar,localgetcommand);
obj.caststring=sprintf('%s=int32(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj,shot)
[obj,value]=obj.getdatacommon(shot);
value=int32(value);
end
function printinfo(obj)
obj.printinfocommon;
fprintf(' Parameter fixed dimension is: %d\n',obj.dimension);
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparmatrix.m 0 → 100644
+ 36
− 0
View file @ 32adf946
classdef SCDclass_mdsparmatrix < SCDclass_mdspar
% A constant 2D matrix real (single) MDS+ parameter
properties
end
methods
function obj=SCDclass_mdsparmatrix(srctdimodel, destparam, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj,shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparscalar.m 0 → 100644
+ 38
− 0
View file @ 32adf946
classdef SCDclass_mdsparscalar < SCDclass_mdspar
% A constant real (single) MDS+ parameter
properties
end
methods
function obj=SCDclass_mdsparscalar(srctdimodel, destparam, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.getcommand=sprintf('mdsvalue(''%s'')',obj.tdiexprmodel);
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj, shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparscalarint.m 0 → 100644
+ 37
− 0
View file @ 32adf946
classdef SCDclass_mdsparscalarint < SCDclass_mdspar
% A constant int32 MDS+ parameter
properties
end
methods
function obj=SCDclass_mdsparscalarint(srctdimodel, destparam, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.getcommand=sprintf('mdsvalue(''%s'')',obj.tdiexprmodel);
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.caststring=sprintf('%s=int32(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj, shot)
[obj,value]=obj.getdatacommon(shot);
value=int32(value);
end
function printinfo(obj)
obj.printinfocommon;
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparscalartaridx.m 0 → 100644
+ 43
− 0
View file @ 32adf946
classdef SCDclass_mdsparscalartaridx < SCDclass_mdspar
% A constant real (single) MDS+ parameter
% target position is specified
properties
targetidx
end
methods
function obj=SCDclass_mdsparscalartaridx(srctdimodel, destparam, targetidx, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.targetidx=targetidx;
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.assignstring=sprintf('%s(%d)=%s;',obj.assignvar,obj.targetidx,obj.getcommand);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj, shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
fprintf(' Target index is: %d\n',obj.targetidx);
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' Idx=' num2str(obj.targetidx) ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdsparvector.m 0 → 100644
+ 37
− 0
View file @ 32adf946
classdef SCDclass_mdsparvector < SCDclass_mdspar
% A constant 1D vector real (single) MDS+ parameter
properties
end
methods
function obj=SCDclass_mdsparvector(srctdimodel, destparam, varargin)
obj@SCDclass_mdspar(srctdimodel, destparam, varargin);
obj.classname=mfilename;
end
function actualizedata(obj, shot)
obj=obj.preactualizecommon(shot);
obj.caststring=sprintf('%s=single(%s);',obj.assignvar,obj.assignvar);
obj.postactualizecommon(shot);
end
function [obj, value] = getdata(obj,shot)
[obj,value]=obj.getdatacommon(shot);
value=single(value);
end
function printinfo(obj)
obj.printinfocommon;
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdswg.m 0 → 100644
+ 133
− 0
View file @ 32adf946
classdef SCDclass_mdswg < matlab.mixin.Heterogeneous
% Superclass for MDS+ wavegens
% the superclass matlab.mixin.Heterogeneous allows
% building of lists of mixed kind parameters in the
% expcode configuration (and later in C++ code)
%properties (Access = protected)
properties
mdsserver % The MDS+ server hosting the parameter
mdstree % The MDS+ Tree hosting the parameter
tdiexpr % TDI expression to retrieve data
wavegenbasestruct % Wavegen base structure hosting the wavegen toimeseries struct
wavegentarget % Wavegen target to be filled
value % commandile output of the wavegen
datadictionary % data dictionary hosting the parameter, if empty base workspace
modelname % name of the Simulink model using the parameter
getcommand % full command for getting the value (callable by matlab eval)
classname % class name for logging
timebasestart % timebase start time variable
timebasedt % timebase dt variable
timebasestop % timebase stop time variable
end
properties
verbose % Verbosity of the class
end
methods
%function obj=SCDclass_mdswavegen(srcsrv, srctree, srctdi, modelname, destwavegen, timebasestart, timebasedt, timebasestop)
function obj=SCDclass_mdswg(srctdi, destwavegen, varargin)
% MDS source and model destination constructor
p=inputParser;
addRequired(p,'srctdi',@(x) ischar(x));
addRequired(p,'destwavegen',@(x) ischar(x));
addParameter(p,'srcsrv','tcvdata',@(x) ischar(x));
addParameter(p,'srctree','tcv_shot',@(x) ischar(x));
addParameter(p,'modelname','',@(x) ischar(x));
% From subclasses constructors, unused here
addParameter(p,'destinterval',0);
addParameter(p,'destindex',0);
parse(p,srctdi,destwavegen,varargin{:}{:});
obj.mdsserver=p.Results.srcsrv;
obj.mdstree=p.Results.srctree;
obj.tdiexpr=p.Results.srctdi;
obj.wavegentarget=p.Results.destwavegen;
obj.modelname=p.Results.modelname;
obj.verbose=1;
obj.wavegenbasestruct='';
end
end
% Not abstract methods common to all child classes
methods
function mdsconnect(obj, shot)
mdsconnect(obj.mdsserver);
s=mdsopen(obj.mdstree, shot);
str=sprintf('SCDclass_mdswavegen (%s), failed opening MDS+ tree', obj.wavegentarget);
assert(s==shot, str);
end
function printinfocommon(obj)
fprintf('%s (class %s):\n', obj.gettargetwavegen, obj.classname);
fprintf(' Simulink model: ''%s''\n', obj.modelname);
fprintf(' MDS+ source server: ''%s'', Tree: ''%s''\n', obj.mdsserver, obj.mdstree);
fprintf(' MDS+ TDI expression: ''%s''\n',obj.tdiexpr);
end
function obj = settiminginfo(obj, timeinfo)
obj.timebasestart=timeinfo.t_start;
obj.timebasedt=timeinfo.dt;
obj.timebasestop=timeinfo.t_stop;
end
function obj = setmodelname(obj, modelname)
if(isempty(obj.modelname))
obj.modelname = modelname;
end
end
function obj = setdatadictionary(obj, ddname)
if(isempty(obj.datadictionary))
obj.datadictionary = ddname;
end
end
function obj = setbasestruct(obj, basestruct)
obj.wavegenbasestruct = basestruct;
end
%function out = gettargetparam(obj)
% out = obj.modelparam;
%end
function entrystring = genMARTe2entrycommon(obj, shot)
%obj.mdsconnect(shot);
%[obj,~]=obj.getdata;
%entrystring = ['+' obj.wavegentarget ' = { Class=' obj.classname ' Path=' obj.tdiexpr ' }'];
entrystring = ['+' obj.wavegentarget ' = { Class=' obj.classname ' Path=' obj.tdiexpr ];
end
end
% Abstract method actually implemented by child classes
methods (Abstract)
% Gets data from MDS+ and actualizes it on the model,
% MDS+ connection is reopened for every call ...
actualizedata(obj, shot)
% Gets data from mds, mds connection is assumed already estabilished
% and tree opened
value = getdata(obj)
% Gets a string containing the target wavegen of the model
out = gettargetwavegen(obj)
% Generate C++ code
%gencode(obj)
% Prints the parameter info summary
printinfo(obj)
end
end
configurationsR2018b/initialization/SCDclass_mdswgsigarray1.m 0 → 100644
+ 136
− 0
View file @ 32adf946
classdef SCDclass_mdswgsigarray1 < SCDclass_mdswg
% This class loads an array of signals from MDS+, linearly indicized
% linear signal rempping between source and destination can be
% specified as a optional parameter, if not present no remapping
% takes place
properties
srcinterval
dstinterval
srcstartidx
srcstopidx
deststartidx
deststopidx
end
methods
%function obj=SCDclass_mdswgsigarray1(srcsrv, srctree, srctdi, modelname, destwavegen, tbstart, tbdt, tbstop, srcstartidx, srcstopidx, deststartidx, deststopidx)
function obj=SCDclass_mdswgsigarray1(srctdi, destwavegen, srcinterval, varargin)
obj@SCDclass_mdswg(srctdi, destwavegen, varargin);
intervalchecker=@(x) isnumeric(x) && min(diff(x))==1 && max(diff(x))==1;
assert(intervalchecker(srcinterval));
p=inputParser;
p.addParameter('destinterval',srcinterval,intervalchecker);
parse(p,varargin{:});
dstinterval=p.Results.destinterval;
obj.srcstartidx=srcinterval(1);
obj.srcstopidx=srcinterval(end);
obj.deststartidx=dstinterval(1);
obj.deststopidx=dstinterval(end);
obj.classname='SCDclass_mdswgsigarray1';
end
end
methods
function actualizedata(obj, shot)
mdsconnect(obj.mdsserver);
mdsopen(obj.mdstree, shot);
targetfullexpansion=[obj.wavegenbasestruct,'.',obj.wavegentarget];
if obj.verbose==1
fprintf('Actualizing wavegen: ''%s'' [%d,%d] <- ''%s'' [%d,%d] (%s, shot %d)\n', ...
targetfullexpansion, obj.deststartidx, obj.deststopidx, ...
obj.tdiexpr, obj.srcstartidx, obj.srcstopidx, ...
obj.classname, shot);
end
sourceidxs=obj.srcstartidx:obj.srcstopidx;
destidxs=obj.deststartidx:obj.deststopidx;
assert(numel(sourceidxs)==numel(destidxs), 'SCDclass_mdswgsigarray1: destination channel count is different w.r.t. source');
value=obj.getdata();
baseparam=obj.wavegenbasestruct;
structparam=obj.wavegentarget;
wgentryval=evalin('base',baseparam);
getcurrenttssize =sprintf('ddtssamples=numel(wgentryval.%s.Time);',structparam);
eval(getcurrenttssize);
if(ddtssamples~=numel(value.Time))
% the dd timeseries has different dims w.r.t. the signals
% to be loaded, we have to load the timeseries as it is
assigncmd =sprintf('wgentryval.%s=value;',structparam);
eval(assigncmd);
else
% the dd timeseries has the same size than the signals
% to be loaded, we can do a partial loading
assigncmdtime =sprintf('wgentryval.%s.Time=value.Time;',structparam);
assigncmddata =sprintf('wgentryval.%s.Data(:,%d:%d)=value.Data;',structparam,obj.deststartidx,obj.deststopidx);
eval(assigncmdtime);
eval(assigncmddata);
end
assignin('base','temp',wgentryval);
assigncmd=sprintf('%s=temp;',baseparam);
evalin('base',assigncmd);
evalin('base','clear temp');
end
function value=getdata(obj)
value=timeseries;
% Getting the timebase of the model
tstart=obj.timebasestart;
dt=obj.timebasedt;
tstop=obj.timebasestop;
timebase=tstart:dt:tstop;
sourceidxs=obj.srcstartidx:obj.srcstopidx;
value.Time = timebase;
value.Data = single(zeros(numel(timebase), numel(sourceidxs)));
for ii=1:numel(sourceidxs)
mdschannel=sprintf(obj.tdiexpr, sourceidxs(ii));
data=tdi(mdschannel);
value.Data(:,ii)= single(interp1(data.dim{1},data.data,timebase,'linear',0));
end
end
function out=gettargetwavegen(obj)
if(isempty(obj.wavegenbasestruct))
out=sprintf('%s[%d,%d]',obj.wavegentarget, obj.deststartidx, obj.deststopidx);
else
out=sprintf('%s.%s[%d,%d]',obj.wavegenbasestruct,obj.wavegentarget, obj.deststartidx, obj.deststopidx);
end
end
function printinfo(obj)
obj.printinfocommon;
if(obj.srcstartidx~=obj.deststartidx || obj.srcstopidx~=obj.deststopidx)
fprintf(' Remapping: source interval [%d,%d] remapped into dest. interval [%d,%d]\n', obj.srcstartidx, obj.srcstopidx, obj.deststartidx, obj.deststopidx);
end
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
entrystring=[entrystring ' StartIdx=' num2str(obj.srcstartidx) ' StopIdx=' num2str(obj.srcstopidx) ' }'];
end
end
end
configurationsR2018b/initialization/SCDclass_mdswgsigsingle.m 0 → 100644
+ 218
− 0
View file @ 32adf946
classdef SCDclass_mdswgsigsingle < SCDclass_mdswg
% This class loads a signal from MDS+ and puts it into
% the target wavegen timeseries, the signal postition
% in the target timeseries structure is remapped according to
% the optional destidx constructor parameter. If it is not
% specified, no remapping takes places (1-1 load)
properties
destidx
end
methods
function obj=SCDclass_mdswgsigsingle(srctdi, destwavegen, varargin)
obj@SCDclass_mdswg(srctdi, destwavegen, varargin);
destidxvalchecker=@(x) isscalar(x);
p=inputParser;
addParameter(p,'destindex',1,destidxvalchecker);
parse(p,varargin{:});
obj.destidx=p.Results.destindex;
obj.classname='SCDclass_mdswgsigsingle';
end
end
methods
function actualizedata(obj, shot)
mdsconnect(obj.mdsserver);
mdsopen(obj.mdstree, shot);
targetfullexpansion=[obj.wavegenbasestruct,'.',obj.wavegentarget];
if obj.verbose==1
fprintf('Actualizing wavegen: ''%s'' [%d] <- ''%s'' (%s, shot %d)\n', ...
targetfullexpansion, obj.destidx, ...
obj.tdiexpr, ...
obj.classname, shot);
end
value=obj.getdata();
baseparam=obj.wavegenbasestruct;
structparam=obj.wavegentarget;
wgentryval=evalin('base',baseparam);
getcurrenttssize =sprintf('ddtssamples=numel(wgentryval.%s.Time);',structparam);
eval(getcurrenttssize);
if(ddtssamples~=numel(value.Time))
% the dd timeseries has different dims w.r.t. the signals
% to be loaded, we have to load the timeseries as it is
assigncmd =sprintf('wgentryval.%s=value;',structparam);
eval(assigncmd);
else
% the dd timeseries has the same size than the signals
% to be loaded, we can do a partial loading
assigncmdtime =sprintf('wgentryval.%s.Time=value.Time;',structparam);
assigncmddata =sprintf('wgentryval.%s.Data(:,%d)=value.Data;',structparam,obj.destidx);
eval(assigncmdtime);
eval(assigncmddata);
end
assignin('base','temp',wgentryval);
assigncmd=sprintf('%s=temp;',baseparam);
evalin('base',assigncmd);
evalin('base','clear temp');
end
function value=getdata(obj)
value=timeseries;
% Getting the timebase of the model
tstart=obj.timebasestart;
dt=obj.timebasedt;
tstop=obj.timebasestop;
timebase=tstart:dt:tstop;
value.Time = timebase;
value.Data = single(zeros(numel(timebase),1));
data=tdi(obj.tdiexpr);
value.Data = single(interp1(data.dim{1},data.data,timebase,'linear',0))';
end
function out=gettargetwavegen(obj)
if(isempty(obj.wavegenbasestruct))
out=sprintf('%s[%d]',obj.wavegentarget, obj.destidx);
else
out=sprintf('%s.%s[%d]',obj.wavegenbasestruct,obj.wavegentarget, obj.destidx);
end
end
function printinfo(obj)
obj.printinfocommon;
if(obj.destidx~=1)
fprintf(' Remapping: destination signal index is %d\n', obj.destidx);
end
end
function entrystring = genMARTe2entry(obj, shot)
entrystring=obj.genMARTe2entrycommon(shot);
end
end
end
% methods(Access=protected)
%
% function actualizedatadd(obj, shot)
% % Actualizes data in the data dictionary
% % BEWARE at saving and committing big dimension useless
% % data dictionaries
%
% errstr=sprintf('%s:actualizedatadd', obj.classname);
% error(errstr,'actualizing wavegens on data dictionaries not supported');
%
% mdsconnect(obj.mdsserver);
% mdsopen(obj.mdstree, shot);
%
% if obj.verbose==1
% fprintf('Actualizing (DATADICT!) wavegen: ''%s'' [%d] <- ''%s'' (%s, shot %d)\n', ...
% obj.wavegentarget, obj.destidx, ...
% obj.tdiexpr, ...
% obj.classname, shot);
% end
%
% value=obj.getdata();
%
% % We need to access the data dictionary directly here,
% % no way to used automatic dd assign and eval functions,
% % they do not work with timeseries
%
% d=Simulink.data.dictionary.open(sprintf('%s.sldd',obj.modelname));
% dd=getSection(d, 'Design Data');
%
% pointspos=strfind(obj.wavegentarget,'.');
% baseparam=obj.wavegentarget(1:pointspos(1)-1);
% structparam=obj.wavegentarget(pointspos(1)+1:end);
% wgentry=dd.getEntry(baseparam);
% wgentryval=wgentry.getValue;
%
% getcurrenttssize =sprintf('ddtssamples=numel(wgentryval.%s.Time);',structparam);
% eval(getcurrenttssize);
% if(ddtssamples~=numel(value.Time))
% % the dd timeseries has different dims w.r.t. the signals
% % to be loaded, we have to load the timeseries as it is
%
% assigncmd =sprintf('wgentryval.%s=value;',structparam);
% eval(assigncmd);
% else
% % the dd timeseries has the same size than the signals
% % to be loaded, we can do a partial loading
%
% assigncmdtime =sprintf('wgentryval.%s.Time=value.Time;',structparam);
% assigncmddata =sprintf('wgentryval.%s.Data(:,%d)=value.Data;',structparam,obj.destidx);
%
% eval(assigncmdtime);
% eval(assigncmddata);
% end
%
% wgentry.setValue(wgentryval);
%
% end
%
%
%
% function cleandata(obj)
%
% error('SCDclass_mdswgsigsingle:cleandata','cleandata has been deprecated');
%
%
% if obj.verbose==1
% fprintf('Cleaning wavegen: %s [%d] (%s)\n', ...
% obj.wavegentarget, obj.destidx, ...
% obj.classname);
% end
%
% d=Simulink.data.dictionary.open(sprintf('%s.sldd',obj.modelname));
% dd=getSection(d, 'Design Data');
%
% pointspos=strfind(obj.wavegentarget,'.');
% baseparam=obj.wavegentarget(1:pointspos(1)-1);
% structparam=obj.wavegentarget(pointspos(1)+1:end);
% wgentry=dd.getEntry(baseparam);
% wgentryval=wgentry.getValue;
%
% datasizecmd=sprintf('datasize=size(wgentryval.%s.Data);',structparam);
% eval(datasizecmd);
% datasize=datasize(2);
%
% emptyts=timeseries;
% emptyts.Time=[0;1];
% emptyts.Data=single(zeros(2,datasize));
%
% assigncmd=sprintf('wgentryval.%s=emptyts;',structparam);
% eval(assigncmd);
% wgentry.setValue(wgentryval);
%
%
% end
%
%
% end
%
configurationsR2018b/initialization/SCDclass_task.m 0 → 100644
+ 139
− 0
View file @ 32adf946
classdef SCDclass_task < matlab.mixin.Heterogeneous
% Superclass for general purposes init and term tasks
% the superclass matlab.mixin.Heterogeneous allows
% bilding of lists of mixed kind parameters in the
% expcode configuration (and later in C++ code)
properties (Access = protected)
id % Task identification
datadictionary % data dictionary hosting the parameter, if empty base workspace
modelname % name of the Simulink model using the parameter
classname % class name for logging
% Properties for a MDS+ related task (not necessarly used)
mdsserver % MDS+ server for a MDS+ related task
mdstree % MDS+ tree for a MDS+ related task
tdiexprmodel % TDI expression to retrieve data when invoked with -1 shot
tdiexprshot % TDI expression to retrieve data when invoked with a give shotno, if empty the -1 is used
tdiexprused % TDI expression actually used
value % value from MDS+
getcommand % full command for getting the value (callable by matlab eval)
end
properties
verbose % Verbosity of the class
end
methods
%function obj=SCDclass_mdsparam(srcsrv, srctree, srctdimodel, srctdishot, modelname, destparam)
function obj=SCDclass_task(id,varargin)
% MDS source and model destination constructor
p=inputParser;
addRequired(p,'id',@(x) ischar(x));
addParameter(p,'srcsrv','tcvdata',@(x) ischar(x));
addParameter(p,'srctree','tcv_shot',@(x) ischar(x));
addParameter(p,'srctdimodel','',@(x) ischar(x));
addParameter(p,'srctdishot','',@(x) ischar(x));
addParameter(p,'modelname','',@(x) ischar(x));
addParameter(p,'datadictname','',@(x) ischar(x));
parse(p,id,varargin{:}{:});
obj.id=p.Results.id;
obj.mdsserver=p.Results.srcsrv;
obj.mdstree=p.Results.srctree;
obj.tdiexprmodel=p.Results.srctdimodel;
if isempty(p.Results.srctdishot)
obj.tdiexprshot=p.Results.srctdimodel;
else
obj.tdiexprshot=p.Results.srctdishot;
end
obj.modelname=p.Results.modelname;
obj.datadictionary=p.Results.datadictname;
obj.verbose=1;
end
end
% Not abstract methods common to all child classes
methods
function mdsconnect(obj, shot)
mdsconnect(obj.mdsserver);
s=mdsopen(obj.mdstree, shot);
str=sprintf('SCDclass_task (%s), failed opening MDS+ tree', obj.id);
assert(s==shot, str);
end
function obj=actualizegetcmd(obj, cmdstring, shot)
if(shot==-1)
obj.getcommand=sprintf(cmdstring, obj.tdiexprmodel);
obj.tdiexprused=obj.tdiexprmodel;
else
obj.getcommand=sprintf(cmdstring, obj.tdiexprshot);
obj.tdiexprused=obj.tdiexprshot;
end
end
function printinfocommon(obj)
fprintf('%s (class %s):\n', obj.id, obj.classname);
fprintf(' Simulink model: ''%s'', data dictionary: ''%s''\n', obj.modelname, obj.datadictionary);
fprintf(' MDS+ source server: ''%s'', Tree: ''%s''\n', obj.mdsserver, obj.mdstree);
fprintf(' MDS+ TDI expressions, model: ''%s''', obj.tdiexprmodel);
if(strcmp(obj.tdiexprmodel, obj.tdiexprshot))
fprintf(', shot: same\n');
else
fprintf(', shot: ''%s''\n', obj.tdiexprshot);
end
end
function out = getid(obj)
out = obj.id;
end
function obj = setmodelname(obj, modelname)
if(isempty(obj.modelname))
obj.modelname = modelname;
end
end
function obj = setdatadictionary(obj, ddname)
if(isempty(obj.datadictionary))
obj.datadictionary = ddname;
end
end
end
% Abstract method actually implemented by child classes
methods (Abstract)
% Polymorphic inits
init(obj, shot)
% Polymorphic terms
%term(obj, shot)
% Gets data from mds, mds connection is assumed already estabilished
% and tree opened
[obj, value] = getdata(obj, shot)
% Generate C++ code
%gencode(obj)
% Prints the parameter info summary
printinfo(obj)
end
end
configurationsR2018b/initialization/SCDclass_taskcontainer.m 0 → 100644
+ 93
− 0
View file @ 32adf946
classdef SCDclass_taskcontainer
% This class is a container class
% for tasks object, a task object is a
% generic object customizable for
% specifying tasks at init and
% terminate phases
properties
numtasks % number of configured tasks
tasks % tasks list
end
methods
function obj = SCDclass_taskcontainer()
% contructor, empty container
obj.numtasks=0;
end
function obj = addtask(obj, task)
% Adds a parameter object
if obj.numtasks==0
obj.tasks=task;
else
obj.tasks=[obj.tasks; task];
end
obj.numtasks=obj.numtasks+1;
end
function obj = printtasks(obj)
% prints the parameters object list
if obj.numtasks>0
for ii=1:obj.numtasks
obj.tasks(ii).printinfo();
end
end
end
function obj = exectasksoninit(obj, shot)
% execs the init method of all configurted task
if obj.numtasks>0
for ii=1:obj.numtasks
obj.tasks(ii).init(shot);
end
end
end
function obj = exectasksonterm(obj, shot)
% execs the term method of all configurted task
if obj.numtasks>0
for ii=1:obj.numtasks
obj.tasks(ii).term(shot);
end
end
end
function obj = bindlasttask(obj, modelname, datadictionary)
if obj.numtasks>0
obj.tasks(end)=obj.tasks(end).setmodelname(modelname);
obj.tasks(end)=obj.tasks(end).setdatadictionary(datadictionary);
end
end
function obj = importtaskobjects(obj, source)
% parameters import
desttasktargets={};
if obj.numtasks>0
for ii=1:obj.numtasks
desttasktargets{end+1}=obj.tasks(ii).getid;
end
end
numtaskstoimport = source.numtasks;
taskstoimport = source.tasks;
if numtaskstoimport>0
for ii=1:numtaskstoimport
if ~ismember(taskstoimport(ii).getid, desttasktargets)
obj=obj.addtask(taskstoimport(ii));
else
warning('SCDclass_taskcontainer:importtaskobjects','A task object with target ''%s'' is already present in the dest. expcode, skipping!',taskstoimport(ii).getid);
end
end
end
end
end
end
configurationsR2018b/initialization/SCDclass_taskmdscheckbusnames.m 0 → 100644
+ 75
− 0
View file @ 32adf946
classdef SCDclass_taskmdscheckbusnames < SCDclass_task
% This is a special class which checks the names
% of a Simulink bus against the list names given by the tdi expression
% some rules apply:
% 1) : in MDS+ fields are subsituted by _
% 2) check is performed up to the minimum number of elemes ether if the
% MDS+ node or in the simulink one.
% if MDS+ begins with a number, a leading 's' is added to its name
% if MDS+ name is empty the check is skipped (Q: is it safe ?, at least not on -1 shot!)
properties
modelbus
end
methods
function obj=SCDclass_taskmdscheckbusnames(id, modelbus, varargin)
obj@SCDclass_task(id, varargin);
obj.modelbus=modelbus;
obj.classname=mfilename;
end
function init(obj, shot)
mdsconnect(obj.mdsserver);
mdsopen(obj.mdstree, shot);
[obj,value]=obj.getdata(shot);
if obj.verbose==1
fprintf('Cheking bus: ''%s'' <-> ''%s'' (%s, shot %d)\n', obj.modelbus, obj.tdiexprused, obj.classname, shot);
end
d=Simulink.data.dictionary.open(sprintf('%s',obj.datadictionary));
dd=getSection(d, 'Design Data');
busElems=dd.getEntry(obj.modelbus).getValue.Elements;
%assert(numel(busElems)==numel(value), 'SCDclass_mdscheckbus: Number of elements must match.');
lastcheck=min(numel(busElems), numel(value));
for ii=1:lastcheck
if numel(char(value{ii}))==0 || numel(strfind(char(value{ii}),' '))==numel(char(value{ii}))
continue
end
strsrc=upper(deblank(strrep(char(value{ii}),':','_')));
if(isstrprop(strsrc(1),'digit'))
strsrc=['S' strsrc];
end
strdst=upper(deblank(busElems(ii).Name));
assert(strcmp(strsrc,strdst), 'SCDclass_mdscheckbus: names mismatching, MDS+ name: ''%s'', Bus name: ''%s''', strsrc, strdst);
end
end
%function term(obj, shot)
%
%end
function [obj, value] = getdata(obj,shot)
obj=obj.actualizegetcmd('mdsvalue(''%s'')', shot);
value=eval(obj.getcommand);
end
function printinfo(obj)
obj.printinfocommon;
fprintf(' Checked model bus: %s\n',obj.modelbus);
end
end
end
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment