classdef SCDclass_expcode
%An SCD expcode object
%
% Main methods:
% .open: Open baseline .slx model
% open(N): Open node N
% open(N,M): Open thread M of node N
% .build, build(N), build(N,M): Generate C code for node N, thread M
% .compile, compile(N), compile(N,M): Compile Simulink model for node N, thread M)
% .close_all: Close all Simulink block diagrams
%
% .printinfo: Print information about components of this expcode
% .printtasks: Print configured tasks
% .printwavegens: Print configured wavegen signals
%.
properties (Access = public)
% Main properties
maincode % Expcode numerical code
status % Expcode development status
end
properties (Access = protected)
loadverbose % Verbosity level of the loading (currently 0 or 1)
end
properties (SetAccess = private)
name % Expcode main name
initobjlist % list of loaded algorithm objects with configured inits
algonamelist % List of loaded algorithm names
algoddlist % list of data dictionaries at algorithm level
mdscontainer % container class for MDS+ interface objects
taskcontainer % container class for generic init and term task objects
exportedtps % list of tunable parameters variable to be exported
fpinits % list of standard inits scripts
modeltoactualize % name of the algorithm to actualize ('all' means all coonfigured)
algos % list of algorithms objects
nodes % array of node properties structs
definednodes % nodes that are defined in Simulink
ddname = 'tcv.sldd' % main expcode data dictionary name
ddpath % main expcode data dicationary save path
end
%%
%% STATIC METHODS
%%
methods(Static)
function help
help(mfilename)
end
function build_nodes(compileslx_list)
for mynodeslx = compileslx_list
fprintf(' *** Buiding Node %s ***\n',mynodeslx{1});
rtwbuild(mynodeslx{1});
end
end
function myslx = getslxname(inode,icpu)
if nargin==0
myslx = 'tcv';
elseif nargin==1
assert(isnumeric(inode))
myslx = sprintf('SCD_rtc_%02d',inode);
elseif nargin==2
myslx = sprintf('SCD_rtccode_%02d_%02d',inode,icpu);
else
error('invalid number of arguments');
end
end
function close_all(saveflag)
if nargin==0
saveflag = 1;
end
assert(saveflag == 1 || saveflag == 0,'saveflag must be 1 or 0')
if saveflag==1
closemsg = 'Saving and Closing %s\n';
else
closemsg = 'Dicarding changes and closing %s\n';
end
while ~isempty(bdroot)
fprintf(closemsg,bdroot);
close_system(bdroot,saveflag)
end
end
end
%%
%% PUBLIC METHODS
%%
methods
function obj=SCDclass_expcode(name)
% Constructor
if nargin==0; name = 'template'; end
obj.name = name;
obj.maincode = 1;
obj.status = 'debug';
obj.loadverbose = 1;
mainslx = obj.getslxname;
hardwarepath = fileparts(which(mainslx));
assert(~isempty(hardwarepath),'%s not found?',mainslx)
obj.ddpath = hardwarepath;
obj.definednodes = [1 2 6 7 8];
obj.algonamelist = {};
obj.algoddlist = {};
obj.exportedtps = [];
obj.mdscontainer = SCDclass_mdsobjcontainer;
obj.taskcontainer = SCDclass_taskcontainer;
nnodes = numel(obj.definednodes);
obj.nodes = cell(1,nnodes);
for inode = 1:nnodes
nodenr = obj.definednodes(inode);
obj.nodes{nodenr} = SCDclass_node(nodenr);
end
end
%% Main expcode handling methods
function open(~,varargin)
openslx = SCDclass_expcode.getslxname(varargin{:});
fprintf('Opening %s.slx\n',openslx)
open(openslx);
end
function setup(obj)
% This function sets up the TCV Simulink model
% to simulate this experimental code.
% NOTE THAT it doesn't actualize tunable parameters
% and wavegens, call actualizedata for that
fprintf('Setting up expcode %d, ''%s'', configuring data dictionaries ...\n',obj.maincode,obj.name);
obj.createmaindd;
obj.setupwrapperdd;
obj.setupnodedd;
obj.setupmaindd;
fprintf('Setting up expcode %d, ''%s'', configuring default tunable parameters ...\n',obj.maincode,obj.name);
obj.updatedefaulttp;
fprintf('Setting up expcode %d, ''%s'', configuring global data ...\n',obj.maincode,obj.name);
obj.setupmain;
fprintf('Setting up expcode %d, ''%s'', configuring main workspace variables ...\n',obj.maincode,obj.name);
obj.buildworkspacesimstruct;
obj.buildworkspacetpstruct;
% Set cache and codegen folders
obj.setcachefolder;
obj.setcodegenfolder;
end
function createmaindd(obj)
% create main data dictionary from scratch to ensure it exists
if contains(Simulink.data.dictionary.getOpenDictionaryPaths,obj.ddname)
Simulink.data.dictionary.closeAll(obj.ddname,'-discard');
% close if it exists and discard changes
end
delete(which(obj.ddname));
Simulink.data.dictionary.create(fullfile(obj.ddpath,obj.ddname));
end
function setupmaindd(obj)
% prepare main top-level SLDD
dd = Simulink.data.dictionary.open(obj.ddname);
% link data dictionaries for active nodes
for ii=obj.definednodes
mydatasource = obj.nodes{ii}.ddname;
fprintf('adding data source %s to %s\n',mydatasource,obj.ddname)
dd.addDataSource(mydatasource);
end
% Set up RFM bus
fprintf('Setting up RFM main bus\n')
addRFMbus(obj,dd)
fprintf('Setting up variant model configuration')
obj.setupvaralgo;
dd.saveChanges;
end
function actualize(obj, shot, varargin)
p = inputParser;
% if a model name is given, operations will be performed
% only on it, otherwise they will be performed on all
% configured models
addParameter(p,'model','',@(x) ischar(x));
parse(p,varargin{:});
if(isempty(p.Results.model))
obj.modeltoactualize='all';
else
obj.modeltoactualize=p.Results.model;
end
obj.actualizedata(shot);
fprintf('Actualizing expcode %d, ''%s'', performing tasks ...\n',obj.maincode,obj.name);
obj.taskcontainer.modeltoexecute=obj.modeltoactualize;
obj.taskcontainer.exectasksoninit(shot);
end
function obj = init(obj)
% close all data dictionaries
Simulink.data.dictionary.closeAll('-discard')
% Set configuration settings sldd
SCDconf_setConf('SIM')
% carry out any init tasks of algorithms
if ~isempty(obj.initobjlist)
for ii=1:numel(obj.initobjlist)
obj.initobjlist{ii}.init();
opendds = Simulink.data.dictionary.getOpenDictionaryPaths;
% check that tcv.sldd is not opened by some algorithm init
assert(~any(contains(opendds,obj.ddname)),...
'init for %s leaves %s open - this should be avoided',...
obj.initobjlist{ii}.getname,obj.ddname)
end
end
fprintf('\n** DONE WITH ALL SCDINITS **\n');
end
function updatemdsmodel(obj, algo)
obj.updatemds(algo, -1);
end
function compile(~,varargin)
myslx = SCDclass_expcode.getslxname(varargin{:});
fprintf('Compiling %s.slx\n',myslx)
try
eval(sprintf('%s([],[],[],''compile'')',myslx));
eval(sprintf('%s([],[],[],''term'')',myslx));
catch ME
rethrow(ME)
end
end
function sim(~,varargin)
SCDconf_setConf('SIM')
myslx = SCDclass_expcode.getslxname(varargin{:});
fprintf('Simulating %s.slx\n',myslx)
sim(myslx)
end
function build(obj,varargin)
if numel(varargin)==0
fprintf('\n=== Building all threads for %s ===\n',obj.name);
% make list of nodes to build
compileslx_list = cell(0);
for inode=1:8
nodeinfo=obj.nodes(inode);
for icpu = 1:nodeinfo.ncpu
if nodeinfo.cpuactive(icpu)
compileslx_list = [compileslx_list,...
SCDclass_expcode.getslxname(inode,icpu)]; %#ok<AGROW>
end
end
end
if isempty(compileslx_list)
fprintf('No active nodes found, no .slx to compile. Done\n');
return
end
else
% user passed nodes,threads to compile
myslx = SCDclass_expcode.getslxname(varargin{:});
fprintf('building %s.slx\n',myslx)
compileslx_list{1} = myslx;
end
% set CodeGen folder for this expcode (allows fast rebuilding)
CodeGenFolder = obj.setcodegenfolder;
% check env variable
assert(~isempty(getenv('RTCCODE_LIBPATH')),'RTCCODE_LIBPATH environment variable needs to be defined to compile');
% set configuration settings for compilation
SCDconf_setConf('CODE');
% Build
try
SCDclass_expcode.build_nodes(compileslx_list);
catch ME
% if fails on first attempt, clear build folder and retry
fprintf(' **** FIRST ATTEMPT BUILDING %s FAILED **** \n',obj.name)
fprintf(' Error message:\n %s\n',getReport(ME));
fprintf(' Try again clearning build folder\n')
system(sprintf('rm -rf %s/*',CodeGenFolder));
SCDclass_expcode.build_nodes(compileslx_list);
end
end
%% Property access methods
function nodes = getnodes(obj)
nodes = obj.nodes;
end
function obj = setnode(obj,node,nodenr)
node = node.setactive(true);
assert(node.nodenr == nodenr,...
'set node number and node property do not match while setting node %s',nodenr)
obj.nodes{node.nodenr} = node;
% Make lists of data dictionaries, mds objects, init functions etc
% that come with this node.
% wrapper algorithms
for iwrap = 1:numel(node.wrappers)
wrapperObj = node.wrappers{iwrap}.wrapperobj;
cpunr = node.wrappers{iwrap}.cpunr;
for ialgo = 1:numel(wrapperObj.algos)
algoObj = wrapperObj.algos(ialgo);
obj = processalgorithm(obj,algoObj,node.nodenr,cpunr);
end
end
% node algorithms
for ialgo = 1:numel(node.algos)
algoObj = node.algos;
obj = processalgorithm(obj,algoObj,node.nodenr,1);
end
end
%% Printing methods
function printinfo(obj,nodenr,cpunr)
if nargin==3
% thread printinfo
obj.nodes{nodenr}.wrapper{cpunr}.wrapperObj.printinfo;
return
elseif nargin==2
if isempty(obj.nodes{nodenr}); fprintf('no node %d defined\n',nodenr); end
obj.nodes{nodenr}.printinfo;
return
end
fprintf('*****************************************************\n');
fprintf('* SCD expcode: ''%s'', main code: %d\n',obj.name,obj.maincode);
fprintf('*****************************************************\n');
fprintf('* Configured nodes:\n')
for node = obj.nodes
if isempty(node{:}),continue; end
node{:}.printinfo;
end
fprintf('* Configured algorithms:\n');
if(numel(obj.algonamelist)>0)
for ii=1:numel(obj.algonamelist), fprintf(' ''%s''\n', char(obj.algonamelist{ii})); end
end
fprintf('* Configured algorithm data dictionaries:\n')
if(numel(obj.algoddlist)>0)
for ii=1:numel(obj.algoddlist), fprintf(' ''%s''\n', char(obj.algoddlist{ii})); end
end
fprintf('* Configured exported tunparams structures:\n')
if(numel(obj.exportedtps)>0)
for ii=1:numel(obj.exportedtps), fprintf(' ''%s''\n', char(obj.exportedtps{ii})); end
end
fprintf('* Configured MDS tunparams objects: %d (use printparameters method for details)\n', obj.mdscontainer.numparams);
fprintf('* Configured MDS wavegens objects: %d (use printwavegens method for details)\n', obj.mdscontainer.numwavegens);
fprintf('* Configured general purpose tasks: %d (use printtasks method for details)\n', obj.taskcontainer.numtasks);
fprintf('* Configured init scripts: %d (use printinits method for details)\n', numel(obj.initobjlist));
end
function printtasks(obj)
obj.taskcontainer.printtasks;
end
function printinits(obj)
% TODO: uniform the approach between stdinits and fpinits
% but only if fpinits will stay ...
fprintf('* Configured std init scripts:\n');
if(~isempty(obj.initobjlist))
for ii=1:numel(obj.initobjlist)
[stdinitstmp,~]=obj.initobjlist{ii}.getinits;
if ~isempty(stdinitstmp)
for jj=1:numel(stdinitstmp)
fprintf(' %s\n',char(stdinitstmp{jj}));
end
end
end
end
fprintf('* Configured fp init scripts:\n');
if(~isempty(obj.fpinits))
for ii=1:numel(obj.fpinits)
fprintf(' %s -> %s\n',char(obj.fpinits{ii}{1}),char(obj.fpinits{ii}{2}));
end
end
end
function printMARTe2taskconfig(obj, shot, varargin)
p=inputParser;
% if a model name is given, operations will be performed
% only on it, otherwise they will be performed on all
% configured models
addParameter(p,'model','',@(x) ischar(x));
parse(p,varargin{:});
if(isempty(p.Results.model))
obj.taskcontainer.modeltogenerate='all';
else
obj.taskcontainer.modeltogenerate=p.Results.model;
end
obj.taskcontainer.printMARTe2taskconfig(shot);
end
function printMARTe2parconfig(obj, shot, varargin)
p=inputParser;
% if a model name is given, operations will be performed
% only on it, otherwise they will be performed on all
% configured models
addParameter(p,'model','',@(x) ischar(x));
parse(p,varargin{:});
if(isempty(p.Results.model))
obj.mdscontainer.modeltogenerate='all';
else
obj.mdscontainer.modeltogenerate=p.Results.model;
end
obj.mdscontainer.printMARTe2parconfig(shot);
end
function printMARTe2wgbusconfig(obj, shot, busname, frequency, varargin)
% printMARTe2wgbusconfig(obj, shot, busname, frequency, varargin)
%
% prints cfg file for loading busname Simulink.Bus
% as a wavegen (or a set of them) in MARTe2
% shot can be -1 or a fixed shot (usually -1), but currently
% the Shot= entry is populated by a fixed macro
% frequency is the frequency of signal generation in MARTe2
% the optional parameter 'ddname' can be given to specify
% the data dictionary where the bus definition is, if omitted
% the default expcode level data dicationary is used
p=inputParser;
addParameter(p,'ddname',obj.ddname,@(x) ischar(x));
parse(p,varargin{:});
myddname = p.Results.ddname;
obj.mdscontainer.printMARTe2wgbusconfig(shot, myddname, busname, frequency);
end
function printparameters(obj)
obj.mdscontainer.printparameters;
end
function printwavegens(obj)
obj.mdscontainer.printwavegens;
end
%% Configuration methods
function obj = processalgorithm(obj,algoObj,node,cpu)
% Checking and importing algorithm name
if(~ismember(algoObj.getname,obj.algonamelist))
obj.algonamelist{end+1} = algoObj.getname;
obj.algos{end+1} = algoObj;
algoispresent = false;
else
fprintf('algorithm ''%s'' already present in the expcode, importing only wavegens',algoObj.getname);
algoispresent = true;
end
% Importing algorithm MDS objects into the main mdscontainer,
% filling base structure name
algomdscontainer = algoObj.getmdscontainer;
basewgstruct = sprintf('SCDsimdata.SCDnode%02d%02d_simdata.wavegen', node, cpu);
algomdscontainer = algomdscontainer.setwavegenbasestruct(basewgstruct);
obj.mdscontainer = obj.mdscontainer.importmdswavegens(algomdscontainer);
if algoispresent, return; end % return if algo is already present
% Importing exported tunable parameters
obj.mdscontainer=obj.mdscontainer.importmdsparams (algomdscontainer);
algoexptps=algoObj.getexportedtps;
if numel(algoexptps)>0
for ii=1:numel(algoexptps)
if ~ismember(algoexptps{ii},obj.exportedtps)
obj.exportedtps{end+1}=algoexptps{ii};
else
fprintf('exported tunparams sctruct ''%s'' already present, ignoring',algoexptps{ii})
end
end
end
% Importing algorithms data dictionary, only those with proper name
algodd=algoObj.getdatadictionary;
if(strcmp(algodd(1:7),'SCDalgo'))
if(~ismember(algodd,obj.algoddlist))
obj.algoddlist{end+1}=algodd;
else
warning('SCDclass_expcode:addalgorithm','algorithm data dictionary ''%s'' already present, ignoring', algodd);
end
else
error('attempting to add algorithm data dictionary not starting with ''SCDalgo''')
end
% Importing tasks
algotaskcontainer=algoObj.gettaskcontainer;
obj.taskcontainer=obj.taskcontainer.importtaskobjects(algotaskcontainer);
% Importing inits
[stdinitstmp,fpinitstmp]=algoObj.getinits;
if(numel(fpinitstmp)>0)
toadd = ones(numel(fpinitstmp),1);
for ii=1:numel(fpinitstmp)
if(~isempty(obj.fpinits))
for jj=1:numel(obj.fpinits)
for kk=1:numel(obj.fpinits{jj}{2})
if(strcmp(char(obj.fpinits{jj}{2}{kk}),fpinitstmp{ii}{2}))
warning('SCDclass_expcode:addalgorithm','An init driving the structure %s has already been added, ignoring this init',char(fpinitstmp{ii}{2}))
toadd(ii)=0;
end
end
end
end
if toadd(ii)
temp=cell(10,1);
temp{1}=fpinitstmp{ii}{1};
temp{2}=fpinitstmp{ii}{2};
obj.fpinits{end+1}=temp;
end
end
if any(toadd) % if any inits from this algoobj were taken
obj.initobjlist{end+1}=algoObj; %% Add the full algorithm object here, to see if it is fine
end
elseif(numel(stdinitstmp)>0)
obj.initobjlist{end+1}=algoObj;
end
end
function out = getexportedtps(obj)
out = obj.exportedtps;
end
%% Default values setup methods
function updatedefaulttp(obj)
% updatedefaulttp()
%
% updates _tmpl tunparams structures
% for every defined updating function
% To define an update function see SCDclass_algo.addtunparamstruct
for ii=1:numel(obj.nodes)
mynode = obj.nodes{ii};
if ~isempty(mynode)
mynode.updatetemplatetp();
end
end
end
end
%% PRIVATE METHODS
methods (Access = private)
%% Matlab environmental setup methods
function CacheFolder = setcachefolder(obj)
% Set Cache Folder for experimental code (avoid conflicts with other tmp files)
CacheFolder = fullfile(fileparts(mfilename('fullpath')),'..','..',...
'gencodes',sprintf('CacheFolder-%d',obj.maincode));
fprintf('Setting Simulink Cache folder to %s\n',CacheFolder)
Simulink.fileGenControl('set',...
'CacheFolder',CacheFolder,...
'createdir',true);
end
function CodeGenFolder = setcodegenfolder(obj)
CodeGenFolder = fullfile(fileparts(mfilename('fullpath')),'..','..',...
'gencodes',sprintf('CodeGenFolder-%d',obj.maincode));
fprintf('Setting code generation folder to %s\n',CodeGenFolder)
Simulink.fileGenControl('set',...
'CodeGenFolder',CodeGenFolder,...
'createdir',true);
end
function obj=printlog(obj,str,varargin)
% printlog, allows sprintf()-like expressions
if obj.loadverbose==1
fprintf('Expcode %d, ', obj.maincode);
fprintf(str,varargin{:}); fprintf('\n');
end
end
function add_remove_sources(obj,ddsources_to_add,ddname,prefix)
% add and remove data sources from data dictionary ddname
% ddsources_to_add is cell array with sources
% prefix is an optional filter to only remove those with the correct
% prefix.
ddObj = Simulink.data.dictionary.open(ddname);
prevsources = ddObj.DataSources;
prevsources_prefix = prevsources(startsWith(prefix,prevsources));
for ii=1:numel(prevsources_prefix)
myddsource = prevsources_prefix{ii};
if ~contains(ddsources_to_add,myddsource)
obj.printlog('Removing wrapper data source %s from %s', myddsource, ddname);
ddObj.removeDataSource(myddsource)
end
end
for ii=1:numel(ddsources_to_add)
myddsource = ddsources_to_add{ii};
if contains(prevsources_prefix,myddsource)
obj.printlog('Not Adding wrapper data source %s from %s - already there',...
myddsource, ddname);
else
obj.printlog('Adding wrapper data source %s to %s',...
myddsource, ddname);
ddObj.addDataSource(myddsource);
end
end
end
function obj = buildworkspacetpstruct(obj)
% this funtion builds a workspace structures containing
% replicas of all tunable parameters 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 rtccode GIT repo itself
dict=Simulink.data.dictionary.open(obj.ddname);
dd=getSection(dict, 'Design Data');
for ii=1:numel(obj.exportedtps)
simstructnamedd=sprintf('%s_tmpl',char(obj.exportedtps(ii)));
simstructnamews=char(obj.exportedtps(ii));
if ~dd.exist(simstructnamedd)
warning('tunable params structure %s not found', simstructnamedd);
continue
end
Entry = dd.getEntry(simstructnamedd);
assert(numel(Entry)<2,'multiple entries found for %s',simstructnamedd);
simstruct = dd.getEntry(simstructnamedd).getValue;
assignstr = sprintf('%s=temp;',simstructnamews);
assignin('base','temp',simstruct);
evalin('base',assignstr);
end
evalin('base','clear temp;');
end
function setupnodedd(obj)
% For every node, add required wrapper datadicationaries as
% sources for the main data dicationary
% Getting main data dictionary and required data sources
datadictname = obj.ddname;
fprintf('opening %s\n',datadictname)
% Looping through every active node
for idx_nodedds=1:numel(obj.definednodes)
inode = obj.definednodes(idx_nodedds);
mynode = obj.nodes{inode};
% Add all wrapper dictionaries as datasources for main dd
wrapperdd_to_add = cell(numel(mynode.wrappers),1); % init
for iwrap=1:numel(mynode.wrappers)
wrapperdd_to_add{iwrap} = mynode.wrappers{iwrap}.wrapperobj.ddname;
end
ddsources_to_add = wrapperdd_to_add;
% remove ones we don't need
obj.add_remove_sources(ddsources_to_add,datadictname,'SCDwrap')
%%
% Add also node algorithm dd to node dd directly
if ~isempty(mynode.algos)
algodd_to_add = {mynode.algos.getdatadictionary};
else
algodd_to_add = {};
end
obj.add_remove_sources(algodd_to_add,mynode.ddname,'SCDalgo')
end
end
function setupwrapperdd(obj)
% Set up the wrapper data dictionary links
for inode = 1:numel(obj.nodes)
mynode = obj.nodes{inode};
if isempty(mynode), continue; end
for ii=1:numel(mynode.wrappers)
wrapperObj = mynode.wrappers{ii}.wrapperobj;
% link to algorithms contained in the wrappers
wrapperObj.linkalgodd;
end
end
% link to hosting node
end
function buildworkspacesimstruct(obj)
% obj.mdscontainer.buildworkspacesimstructnode(obj,node)
% obj.mdscontainer.buildworkspacesimstruct; % old
dd=SCDconf_getdatadict(obj.ddname);
for ii = 1:numel(obj.definednodes)
inode = obj.definednodes(ii);
buildworkspacesimstructnode(obj,inode,dd);
end
evalin('base', 'SCDrefdata = SCDsimdata;');
end
function obj = setupmain(obj)
% sets up global configs for the expcode
scd.expcode = obj.maincode;
scd.timing.dt = 25e-6; % hard code for now, determine later from slowest thread
Simulink.data.assigninGlobal(obj.getslxname,'scd',scd);
% add configurations.sldd as reference, contains simulation parameters
ddObj = Simulink.data.dictionary.open(obj.ddname);
ddObj.addDataSource('configurations.sldd');
end
function addRFMbus(obj,dd)
ddSection = dd.getSection('Design Data');
zeroElem = Simulink.BusElement;
zeroElem.Name = 'zero';
Elems = repmat(Simulink.BusElement,numel(obj.definednodes),1);
for ii = 1:numel(obj.definednodes)
inode = obj.definednodes(ii);
leafName = sprintf('Node%02d_RFM' ,inode);
subBusName = sprintf('Bus: RFMOUT%02dbus',inode);
% corresponding leaf element in main RFMIn bus
Elems(ii) = Simulink.BusElement;
Elems(ii).Name = leafName;
Elems(ii).Description = sprintf('Node %02d RFM output',inode);
Elems(ii).DataType = subBusName;
end
ii=ii+1;
% Extra bus and leaf for Externals_RFM (non-node entities writing to RFM)
[extBusObj,extBusName] = SCDconf_createRFMOUTextbus;
assignin(ddSection,extBusName,extBusObj);
Elems(ii) = Simulink.BusElement;
Elems(ii).Name = 'Externals_RFM';
Elems(ii).DataType = ['Bus: ',extBusName];
Elems(ii).Description = 'Bus for data from external nodes writing to RFM';
% Assemble RFM input bus
RFMINbus = Simulink.Bus;
RFMINbus.HeaderFile = '';
RFMINbus.Description = 'RFM input bus for all nodes';
RFMINbus.DataScope = 'Auto';
RFMINbus.Alignment = -1;
RFMINbus.Elements = Elems;
assignin(ddSection,'RFMINbus',RFMINbus);
end
function obj = setupvaralgo(obj)
% Sets up varalgo structure in main tcv data dictionary
% according to varalgo info of the nodes
% Getting data section of main tcv data dictionary
fprintf('opening %s to setup variant model configurations\n',obj.ddname);
d=Simulink.data.dictionary.open(obj.ddname);
dd=getSection(d, 'Design Data');
s=struct();
% Looping through every active node
for ii=1:numel(obj.definednodes)
inode = obj.definednodes(ii);
mynode = obj.nodes{inode};
for jj=1:numel(mynode.wrappers)
fieldname = sprintf('algo%02d%02d',inode,jj);
s.(fieldname) = mynode.wrappers{jj}.varalgo;
end
end
% save in data dictionary
if dd.exist('SCDvaralgo')
ee = dd.getEntry('SCDvaralgo'); ee.setValue(s);
else
dd.addEntry('SCDvaralgo',s);
end
end
function obj = buildworkspacesimstructnode(obj,inode,dd)
% build simulation data structure
node = obj.nodes{inode};
if evalin('base','exist(''SCDsimdata'',''var'')')
SCDsimdata = evalin('base','SCDsimdata');
else
SCDsimdata = struct(); % assign here if empty
end
if node.haswavegen
for ithread = 1:node.ncpu
% get whatever is in data dictionary template in wrappers
simstructname = sprintf('SCDnode%02d%02d_simdata',inode,ithread);
wgbusname = sprintf('WG%02d%02dbus',inode,ithread);
fprintf(' setting up %s',simstructname);
if dd.exist(simstructname)
ddentry = dd.getEntry(simstructname);
assert(numel(ddentry)==1,'multiple entries found for %s',simstructname)
simstruct = ddentry.getValue;
mybus=dd.getEntry(wgbusname).getValue; % get from data dictionary
if ~isstruct(simstruct) || ~isfield(simstruct,'wavegen')
fprintf('.. loaded simstruct wavegen is not compatible');
regenerate = true;
elseif SCDconf_structbuscmp(simstruct.wavegen,mybus)
fprintf('... loaded WG from data dictionary\n');
regenerate=false;
else
fprintf('... loaded WG structure from dd does not match bus definition...');
regenerate=true;
end
else
regenerate = true;
fprintf('... could not find %s in data dictionary',simstructname);
end
if regenerate
simstruct.wavegen = SCDconf_createstructfrombus(dd,wgbusname); % structure to match
%ddsource = dd.find('Name',wgbusname).DataSource; % dd containing bus
%wrapdd=Simulink.data.dictionary.open(ddsource).getSection('Design Data');
%wrapdd.addEntry(simstructname,simstruct)
fprintf('... re-generated from bus %s\n',wgbusname')
end
SCDsimdata.(simstructname) = simstruct;
end
end
% Node-specific
simstructname = sprintf('SCDnode%02dsimdata',inode);
if node.hasadc
adcbusname = sprintf('ADC%02dbus',inode);
fprintf(' setting up %s.adc\n',simstructname);
SCDsimdata.(simstructname).adc = SCDconf_createstructfrombus(dd,adcbusname);
end
if node.hasethercat
assert(inode==2,'Ethercat not yet implemented for other node than 2');
ethercatbusname = 'ETHCAT1IN';
fprintf(' setting up %s.ethercat\n',simstructname);
SCDsimdata.(simstructname).ethercat = ...
SCDconf_createstructfrombus(dd,ethercatbusname);
end
% add also RFM
RFMbusname = 'RFMINbus';
SCDsimdata.rfm = SCDconf_createstructfrombus(dd,RFMbusname);
% assign result in base workspace
assignin('base','SCDsimdata',SCDsimdata);
end
%% Actualization methods
function actualizedata(obj, shot)
% This function actualizes configured
% tunable parameters and wavegens timeseries
% according to the given shot
currentexpcode=Simulink.data.evalinGlobal('tcv','scd.expcode');
if(currentexpcode~=obj.maincode)
error('SCDclass_expcode:wrongexpcodeloaded','Cannot perform data actualization, the loaded expcode is not matching, try to setup the expcode first');
end
fprintf('Actualizing expcode %d, ''%s'', configuring tunable parameters ...\n',obj.maincode,obj.name);
obj.actualizeparameters(shot)
fprintf('Actualizing expcode %d, ''%s'', configuring wavegens ...\n',obj.maincode,obj.name);
obj.actualizewavegens(shot);
end
function actualizeparameters(obj,shot)
obj.mdscontainer.modeltoactualize=obj.modeltoactualize;
obj.mdscontainer.actualizeparameters(shot);
end
function actualizewavegens(obj,shot)
obj.mdscontainer.modeltoactualize=obj.modeltoactualize;
obj.mdscontainer.actualizewavegens(shot);
end
%% MDS update methods
function updatemds(obj, algo, shot)
if shot~=-1
error('SCDclass_expcode:updatemds','update permitted only on the model shot');
end
% % first update algorithm tunparams default locally
% for ii=1:numel(obj.algonamelist)
% if strcmp(algo, obj.algonamelist{ii})
% obj.algos{ii}.updatetemplatetp();
% end
% end
% % then update mds
obj.mdscontainer.modeltogenerate=algo;
obj.mdscontainer.autopopulateMDSparams(shot);
obj.mdscontainer.autopopulateMDSwavegens(shot);
end
end
end