SCDclass_expcode.m

classdef SCDclass_expcode
    %A SCD expcode object
    %   This object is a virgin SCD expode
    %   its constructor builds an expode 
    %   with all templates algorithms
    
    properties (Access = private)     
        activenodes       % numerical list of configured active nodes
        activecpus        % numerical list of configured CPUs
        %nodeddlist       % list of data dictionaries at node level
        wrapperlist       % list of configured wrappers
        algoobjlist       % list of loaded algorithm objects
        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
        stdinits          % list of standard inits scripts
        
    end
    
    properties
        % Main properties
        name              % Expcode main name
        maincode          % Expcode numerical code
        status            % Expcode development status
        loadverbose       % Verbosity level of the loading (currently 0 or 1)        
       
        % Per node properties structs
        node01
        node02
        node03
        node04
        node05
        node06
        node07
        node08
       

    end
    
    methods
        
        function obj=SCDclass_expcode()
           % All templates constructor
       
            obj.name = 'template';
            obj.maincode = 1;
            obj.status = 'debug';
            obj.loadverbose = 1;
            
            obj.activenodes=[1 2 3 6 7 8];
            obj.activecpus=[ {1}; ...
                             {1:4}; ...
                             {1:4}; ...
                             {1:4}; ...
                             {1:4}; ...
                             {1}]; 
            
            
%             obj.nodeddlist=cell(6,1);
%             obj.nodeddlist{1} = 'SCD_rtc_01.sldd';
%             obj.nodeddlist{2} = 'SCD_rtc_02.sldd';
%             obj.nodeddlist{3} = 'SCD_rtc_03.sldd';
%             obj.nodeddlist{4} = 'SCD_rtc_06.sldd';
%             obj.nodeddlist{5} = 'SCD_rtc_07.sldd';
%             obj.nodeddlist{6} = 'SCD_rtc_08.sldd';
            
            obj.algonamelist={};
            obj.algoddlist={};
            obj.wrapperlist={};
            obj.exportedtps = [];
            
            obj.mdscontainer = SCDclass_mdsobjcontainer;
            obj.taskcontainer = SCDclass_taskcontainer;

            
            
            obj.node01.active = 0;
            obj.node01.type = 'std1cpu2015a';
            obj.node01.timing.t_start = -4.5;
            obj.node01.timing.t_stop = 3;
            obj.node01.timing.dt = 1e-4;
            obj.node01.varalgo = 1;
            obj.node01.buildcfg.conffile{1} = 'standard';
            obj.node01.buildcfg.initscdbeforecomp = 0;
            obj.node01.usewavegen = 0;
            obj.node01.datadict='SCD_rtc_01.sldd';
            obj.node01.wrapdatadicts{1} = 'SCDwrap_template0101.sldd';
            
            obj.node02.active = 0;
            obj.node02.type = 'std1cpu2015a';
            obj.node02.timing.t_start = -4.5;
            obj.node02.timing.t_stop = 3;
            obj.node02.timing.dt = 1e-4;
            obj.node02.varalgo = [1 1 1 1];
            obj.node02.thperiod = [1.0000e-03 1.0000e-03 1.0000e-03 1.0000e-03];
            obj.node02.buildcfg.conffile{1} = 'standard';
            obj.node02.buildcfg.conffile{2} = 'standard';
            obj.node02.buildcfg.conffile{3} = 'standard';
            obj.node02.buildcfg.conffile{4} = 'standard';
            obj.node02.buildcfg.conffile=obj.node02.buildcfg.conffile';
            obj.node02.buildcfg.initscdbeforecomp = 0;
            obj.node02.usewavegen = 0;
            obj.node02.datadict='SCD_rtc_02.sldd';
            obj.node02.wrapdatadicts{1} = 'SCDwrap_template0201.sldd';
            obj.node02.wrapdatadicts{2} = 'SCDwrap_template0202.sldd';
            obj.node02.wrapdatadicts{3} = 'SCDwrap_template0203.sldd';
            obj.node02.wrapdatadicts{4} = 'SCDwrap_template0204.sldd';
            obj.node02.wrapdatadicts=obj.node02.wrapdatadicts';
            
            obj.node03.active = 0;
            obj.node03.type = '4cpus2015a';
            obj.node03.timing.t_start = -2.0;
            obj.node03.timing.t_stop = 2.75;
            obj.node03.timing.dt = 1e-3;
            obj.node03.thdwsample = [0 0 0 0];
            obj.node03.thperiod = [1.0000e-03 1.0000e-03 1.0000e-03 1.0000e-03];
            obj.node03.varalgo = [1 1 1 1];
            obj.node03.buildcfg.conffile{1} = 'standard';
            obj.node03.buildcfg.conffile{2} = 'standard';
            obj.node03.buildcfg.conffile{3} = 'standard';
            obj.node03.buildcfg.conffile{4} = 'standard';
            obj.node03.buildcfg.conffile=obj.node03.buildcfg.conffile';
            obj.node03.buildcfg.initscdbeforecomp = [0 0 0 0];
            obj.node03.usewavegen = 0;
            obj.node03.useethcat1 = 0;
            obj.node03.datadict='SCD_rtc_03.sldd';            
            obj.node03.wrapdatadicts{1} = 'SCDwrap_template0301.sldd';
            obj.node03.wrapdatadicts{2} = 'SCDwrap_template0302.sldd';
            obj.node03.wrapdatadicts{3} = 'SCDwrap_template0303.sldd';
            obj.node03.wrapdatadicts{4} = 'SCDwrap_template0304.sldd';
            obj.node03.wrapdatadicts=obj.node03.wrapdatadicts';
            
            obj.node04.active = 0;
            obj.node04.type = 'std1cpu2015a';
            obj.node04.timing.t_start = -4.5;
            obj.node04.timing.t_stop = 3;
            obj.node04.timing.dt = 1e-4;
            obj.node04.varalgo = 1;
            obj.node04.buildcfg.conffile{1} = 'standard';
            obj.node04.buildcfg.initscdbeforecomp = 0;
            obj.node04.usewavegen = 0;

            obj.node05.active = 0;
            obj.node05.type = 'std1cpu2015a';
            obj.node05.timing.t_start = -4.5;
            obj.node05.timing.t_stop = 3;
            obj.node05.timing.dt = 1e-4;
            obj.node05.varalgo = 1;
            obj.node05.buildcfg.conffile{1} = 'standard';
            obj.node05.buildcfg.initscdbeforecomp = 0;
            obj.node05.usewavegen = 0;

            obj.node06.active = 0;
            obj.node06.type = '4cpus2015a';
            obj.node06.timing.t_start = 0.0;
            obj.node06.timing.t_stop = 2.75;
            obj.node06.timing.dt = 1e-3;
            obj.node06.thdwsample = [0 0 0 0];
            obj.node06.thperiod = [1.0000e-03 1.0000e-03 1.0000e-03 1.0000e-03];
            obj.node06.varalgo = [1 1 1 1];
            obj.node06.buildcfg.conffile{1} = 'standard';
            obj.node06.buildcfg.conffile{2} = 'standard';
            obj.node06.buildcfg.conffile{3} = 'standard';
            obj.node06.buildcfg.conffile{4} = 'standard';
            obj.node06.buildcfg.conffile=obj.node06.buildcfg.conffile';
            obj.node06.buildcfg.initscdbeforecomp = [0 0 0 0];
            obj.node06.usewavegen = 0;
            obj.node06.datadict='SCD_rtc_06.sldd';                        
            obj.node06.wrapdatadicts{1} = 'SCDwrap_template0601.sldd';
            obj.node06.wrapdatadicts{2} = 'SCDwrap_template0602.sldd';
            obj.node06.wrapdatadicts{3} = 'SCDwrap_template0603.sldd';
            obj.node06.wrapdatadicts{4} = 'SCDwrap_template0604.sldd';
            obj.node06.wrapdatadicts=obj.node06.wrapdatadicts';
            
            obj.node07.active = 0;
            obj.node07.type = '4cpus2015a';
            obj.node07.timing.t_start = -0.5;
            obj.node07.timing.t_stop = 2.5;
            obj.node07.timing.dt = 1e-3;
            obj.node07.thdwsample = [0 0 0 0];
            obj.node07.thperiod = [1.0000e-03 1.0000e-03 1.0000e-03 1.0000e-03];
            obj.node07.varalgo = [1 1 1 1];
            obj.node07.buildcfg.conffile{1} = 'standard';
            obj.node07.buildcfg.conffile{2} = 'standard';
            obj.node07.buildcfg.conffile{3} = 'standard';
            obj.node07.buildcfg.conffile{4} = 'standard';
            obj.node07.buildcfg.conffile=obj.node07.buildcfg.conffile';
            obj.node07.buildcfg.initscdbeforecomp = [0 0 0 0];
            obj.node07.usewavegen = 0;
            obj.node07.datadict='SCD_rtc_07.sldd';
            obj.node07.wrapdatadicts{1} = 'SCDwrap_template0701.sldd';
            obj.node07.wrapdatadicts{2} = 'SCDwrap_template0702.sldd';
            obj.node07.wrapdatadicts{3} = 'SCDwrap_template0703.sldd';
            obj.node07.wrapdatadicts{4} = 'SCDwrap_template0704.sldd';
            obj.node07.wrapdatadicts=obj.node07.wrapdatadicts';

            obj.node08.active = 0;
            obj.node08.type = '4cpus2015a';
            obj.node08.timing.t_start = -0.5;
            obj.node08.timing.t_stop = 2.5;
            obj.node08.timing.dt = 1e-3;
            obj.node08.thdwsample = [0 0 0 0];
            obj.node08.thperiod = [1.0000e-03 1.0000e-03 1.0000e-03 1.0000e-03];
            obj.node08.varalgo = [1 1 1 1];
            obj.node08.buildcfg.conffile{1} = 'standard';
            obj.node08.buildcfg.conffile{2} = 'standard';
            obj.node08.buildcfg.conffile{3} = 'standard';
            obj.node08.buildcfg.conffile{4} = 'standard';
            obj.node08.buildcfg.conffile=obj.node08.buildcfg.conffile';
            obj.node08.buildcfg.initscdbeforecomp = [0 0 0 0];
            obj.node08.usewavegen = 0;
            obj.node08.datadict='SCD_rtc_08.sldd';            
            obj.node08.wrapdatadicts{1} = 'SCDwrap_template0801.sldd';
       
            
            
        
        end
        
        function printinfo(obj)
           fprintf('*****************************************************\n');
           fprintf('* SCD expcode: ''%s'', main code: %d\n',obj.name,obj.maincode); 
           fprintf('*****************************************************\n');           
           fprintf('* Configured wrappers:\n')
           if(numel(obj.wrapperlist)>0)
               for ii=1:numel(obj.wrapperlist)
                   fprintf('  Node: %d, CPU: %d, varalgo: %d, wrapper: ''%s'', datadict: ''%s''\n', ...
                        obj.wrapperlist{ii}{1}, ...
                        obj.wrapperlist{ii}{2}, ...
                        obj.wrapperlist{ii}{3}, ...
                        obj.wrapperlist{ii}{4}, ...
                        obj.wrapperlist{ii}{5} ...
                    );
               end
           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.stdinits));
        end
        
        function obj = addwrapper(obj, node, cpu, varalgo, modelname, varargin) 
            
            p=inputParser;
            checknodes = @(x) ismember(x,obj.activenodes );
            checkcpu = @(x) ismember(x,obj.activecpus{node});
          
            addRequired(p, 'node', checknodes); 
            addRequired(p, 'cpu', checkcpu); 
            addRequired(p, 'varalgo');
            addRequired(p, 'modelname', @(x) ischar(x));
            addOptional(p, 'datadictionary', '', @(x) ischar(x));
            
            parse(p, node, cpu, varalgo, modelname, varargin{:});
            
            % In data dcitionary is not specified it is assumed having
            % the same name than the model
            if(isempty(p.Results.datadictionary))
                datadictionary=[p.Results.modelname '.sldd'];
            else
                datadictionary=[p.Results.datadictionary '.sldd'];
            end
            
            % Frist checking for duplicates
            if(numel(obj.wrapperlist)>0)
                wrappernamelist={};
                wrapperddnamelist={};
                for ii=1:numel(obj.wrapperlist)
                    wrappernamelist{end+1}=obj.wrapperlist{ii}{4};
                    wrapperddnamelist{end+1}=obj.wrapperlist{ii}{5};
                end
           
                if(ismember(p.Results.modelname,wrappernamelist) || ismember(p.Results.datadictionary,wrapperddnamelist))
                    warning('SCDclass_expcode:addwrapper','wrapper ''%s'' already present, ignoring.',modelname);
                end
                
                return
            end
                
            tempwrapper=cell(10,1);
            tempwrapper{1}=p.Results.node;
            tempwrapper{2}=p.Results.cpu;
            tempwrapper{3}=p.Results.varalgo;
            tempwrapper{4}=p.Results.modelname;
            tempwrapper{5}=datadictionary;
            obj.wrapperlist{end+1}=tempwrapper;
            
        end     
            
        function obj = addalgorithm(obj, in_node, in_cpu, in_algo)
            
            % TODO: import the entrire object into a container class ??
            
            p=inputParser;
            checknodes = @(x) ismember(x,obj.activenodes );
            checkcpu = @(x) ismember(x,obj.activecpus{in_node});
          
            addRequired(p, 'node', checknodes); 
            addRequired(p, 'cpu', checkcpu); 
            addRequired(p, 'algo', @(x) isobject(x));
            
            parse(p, in_node, in_cpu, in_algo);

            node = p.Results.node;
            cpu = p.Results.cpu;
            algo = p.Results.algo;
            
            % Checking and importing algorithm name
            if(~ismember(algo.getname,obj.algonamelist))
                obj.algonamelist{end+1}=algo.getname;
            else
                warning('SCDclass_expcode:addalgorithm','algorithm ''%s'' already present in the expcode, skipping!',algo.getname);
                return;
            end
                
            % Importing algorithm MDS objects into the main mdscontainer,
            % filling base structure name
            algomdscontainer=algo.getmdscontainer;
            basewgstruct=sprintf('SCDsimdata.SCDnode%02d%02d_simdata.wavegen', node, cpu);
            algomdscontainer=algomdscontainer.setwavegenbasestruct(basewgstruct);
            obj.mdscontainer=obj.mdscontainer.importmdsobjects(algomdscontainer);
             
            % Importing exported tps
            algoexptps=algo.getexportedtps;
            if(numel(algoexptps)>0)
                for(ii=1:numel(algoexptps))
                    if(~ismember(algoexptps{ii},obj.exportedtps))
                        obj.exportedtps{end+1}=algoexptps{ii};
                    else
                        warning('SCDclass_expcode:addalgorithm','exported tunparams sctruct ''%s'' already present, ignoring',algoexptps{ii})
                    end
                end
            end
            
            % Importing algorithms data dictionary, only those with proper
            % name
            algodd=algo.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
                % warning here ?
            end
           
            % Importing tasks 
            algotaskcontainer=algo.gettaskcontainer;
            obj.taskcontainer=obj.taskcontainer.importtaskobjects(algotaskcontainer);
            
            % Importing inits
            algoinits=algo.getinits;
            if(numel(algoinits)>0)
                for ii=1:numel(algoinits)
                    toadd=1;
                    if(~isempty(obj.stdinits))
                        for jj=1:numel(obj.stdinits)
                             if(strcmp(char(obj.stdinits{jj}{2}),algoinits{ii}{2}))
                                 warning('SCDclass_expcode:addalgorithm','An init driving the structure %s has already been added, ignoring algorithm object.\d',algoinits{ii}{2})
                                 toadd=0;
                             end
                        end
                    end
                    if(toadd)
                        temp=cell(10,1);
                        temp{1}=algoinits{ii}{1};
                        temp{2}=algoinits{ii}{2};
                        obj.stdinits{end+1}=temp;
                        obj.algoobjlist{end+1}=algo; %% Add the full algorithm object here, to see if it is fine
                    end
                end
            end            
        end     
            
        function out = getexportedtps(obj)
            out = obj.exportedtps;
        end
        
        function obj = importexpcode(obj, expcode)
           % This function imports settings of an existing expcode into another
           
           warning('Not yet supported!');
           return;
           
           % tunparamstruct import
           exportedtpstoadd = expcode.getexportedtps;
           for ii=1:numel(exportedtpstoadd)
               if ~sum(ismember(exportedtpstoadd{ii},obj.exportedtps))
                   obj.addtunparamstruct(exportedtpstoadd{ii});
               end
           end
            
           % parameters import
           obj.mdscontainer=obj.mdscontainer.importmdsobjects(expcode.mdscontainer);
        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 wrappers ...\n',obj.maincode,obj.name);
           obj=obj.setupwrappers;
           obj.setupvaralgo;
           fprintf('Setting up expcode %d, ''%s'', configuring data dictionaries ...\n',obj.maincode,obj.name);
           obj.setupwrapdd;
           obj.setupalgodd;
           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;
        end
        
        function actualize(obj, shot)
            obj.actualizedata(shot);
             fprintf('Actualizing expcode %d, ''%s'', performing tasks ...\n',obj.maincode,obj.name);
            obj.taskcontainer.exectasksoninit(shot);
        end
        
        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 printparameters(obj)
            obj.mdscontainer.printparameters;
        end

        function printwavegens(obj)
            obj.mdscontainer.printwavegens;
        end
        
        function printtasks(obj)
            obj.taskcontainer.printtasks;
        end
        
        function actualizeparameters(obj,shot)
            obj.mdscontainer.actualizeparameters(shot);
        end
        
        function actualizewavegens(obj,shot)
            obj.mdscontainer.actualizewavegens(shot);
        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.algoobjlist))
              for(ii=1:numel(obj.algoobjlist))
                 
                  obj.algoobjlist{ii}.callinits;
                     
              end
          end
        end
        
        function printMARTe2config(obj, shot)
            fprintf("+MDSParameters = {\n");
            fprintf("   Class = MDSParameters\n");
            fprintf("   Shot = %d\n",shot);
            obj.mdscontainer.printMARTe2parconfig(shot);
            fprintf("}\n");
            
            fprintf("+MDSWavegens = {\n");
            fprintf("   Class = MDSWavegens\n");
            fprintf("   Shot = %d\n",shot);
            obj.mdscontainer.printMARTe2wgconfig(shot);
            fprintf("}\n");
            
        end
        
    end
   
    methods (Access = private)
        
        function obj=printlog(obj,str)
            if obj.loadverbose==1
               fprintf('Expcode %d, %s\n', obj.maincode, str); 
            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
           
            dd=SCDconf_getdatadict('tcv.sldd');
            
            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
        
           
        function obj = setupwrapdd(obj)
            % Sets up the data dictionaries of the wrappers to be loaded
            % on the nodes inside the main tcv.sldd
            
            % For every node, given the current status finds its dictionary
            % and the requred data sources, find actions to do and setup
            % wrappers data sources accordingly
            
            % It is assumed that there is only 1 wrapper and 1 wrapper data
            % dictionary active at a given time for every CPU model
            
            % Looping through every active node
            for idx_nodedds=1:numel(obj.activenodes)
                
                
               % Getting data dictionary and required data sources 
               datadictname=eval(sprintf('obj.node%02d.datadict',obj.activenodes(idx_nodedds)));
               nodedd=Simulink.data.dictionary.open(datadictname);
               nodeddsources=nodedd.DataSources;
               reqsources=eval(sprintf('obj.node%02d.wrapdatadicts', obj.activenodes(idx_nodedds)));
               
               % Filtering out not pertinent data sources by name prefix
               nodeddsourcesok={};
               nodeddsourcesokitems=0;
               for ii=1:numel(nodeddsources)
                  if(strcmp(nodeddsources{ii}(1:7),'SCDwrap'))
                      temp={nodeddsources{ii}, 0};
                      nodeddsourcesok=[nodeddsourcesok; temp];
                      nodeddsourcesokitems=nodeddsourcesokitems+1;
                  end
               end
               
               reqsourcesok={};
               reqsourcesokitems=0;
               for ii=1:numel(reqsources)
                  if(strcmp(reqsources{ii}(1:7),'SCDwrap'))           
                      temp={reqsources{ii}, 1};
                      reqsourcesok=[reqsourcesok; temp];
                      reqsourcesokitems=reqsourcesokitems+1;
                  else
                      str=sprintf('Proposed wrapper data dictionary %s does not begin with SCDwrap, ignoring it.', reqsources{ii});
                      warning(str);
                      %obj.printlog(str);
                  end
                  
               end
               
               % Finding which data sources to eliminate and which to add
               if(nodeddsourcesokitems>0 && reqsourcesokitems>0)
                  for ii=1:nodeddsourcesokitems
                     todel=1;
                     for jj=1:reqsourcesokitems
                         if(strcmp(char(nodeddsourcesok{ii,1}),char(reqsourcesok{jj,1})))
                             todel=0;
                             break
                         end
                     end
                     nodeddsourcesok{ii,2}=todel;
                  end
                  
                  for ii=1:reqsourcesokitems
                     toadd=1;
                     for jj=1:nodeddsourcesokitems
                         if(strcmp(char(reqsourcesok{ii,1}),char(nodeddsourcesok{jj,1})))
                             toadd=0;
                             break
                         end
                     end
                     reqsourcesok{ii,2}=toadd;
                  end  
               end
               
               % Removing data sources
               if(nodeddsourcesokitems>0)
                  for ii=1:nodeddsourcesokitems
                    if(nodeddsourcesok{ii,2}==1)
                       str=sprintf('Removing wrapper data source %s from %s', char(nodeddsourcesok{ii,1}), datadictname);
                       obj.printlog(str);
                       removeDataSource(nodedd, char(nodeddsourcesok{ii,1}));
                    end
                  end
               end
               
               % Adding data sources
               if(reqsourcesokitems>0)
                  for ii=1:reqsourcesokitems
                      if(reqsourcesok{ii,2}==1)
                         str=sprintf('Adding wrapper data source %s to %s', char(reqsourcesok{ii,1}), datadictname); 
                         obj.printlog(str);
                         addDataSource(nodedd, char(reqsourcesok{ii,1}));
                      end
                  end
               end
                   
            end  
        end
        
        function obj = setupalgodd(obj)
            
               % Getting data dictionary and required data sources 
               tcvdd=Simulink.data.dictionary.open('tcv.sldd');
               tcvddsources=tcvdd.DataSources;
               reqsources=obj.algoddlist;
               
               % Filtering out not pertinent data sources by name prefix
               tcvddsourcesok={};
               tcvddsourcesokitems=0;
               for ii=1:numel(tcvddsources)
                  if(strcmp(tcvddsources{ii}(1:7),'SCDalgo'))
                      temp={tcvddsources{ii}, 1};
                      tcvddsourcesok=[tcvddsourcesok; temp];
                      tcvddsourcesokitems=tcvddsourcesokitems+1;
                  end
               end
               
               reqsourcesok={};
               reqsourcesokitems=0;
               for ii=1:numel(reqsources)
                  if(strcmp(reqsources{ii}(1:7),'SCDalgo'))           
                      temp={reqsources{ii}, 1};
                      reqsourcesok=[reqsourcesok; temp];
                      reqsourcesokitems=reqsourcesokitems+1;
                  else
                      warning('SCDexpcode:setupalgodd','Proposed algo data dictionary %s does not begin with SCDalgo, ignoring it.', reqsources{ii});
                  end
               end
               
               % Finding which data sources to eliminate and which to add
               if(tcvddsourcesokitems>0 && reqsourcesokitems>0)
                  for ii=1:tcvddsourcesokitems
                     todel=1;
                     for jj=1:reqsourcesokitems
                         if(strcmp(char(tcvddsourcesok{ii,1}),char(reqsourcesok{jj,1})))
                             todel=0;
                             break
                         end
                     end
                     tcvddsourcesok{ii,2}=todel;
                  end

                  for ii=1:reqsourcesokitems
                     toadd=1;
                     for jj=1:tcvddsourcesokitems
                         if(strcmp(char(reqsourcesok{ii,1}),char(tcvddsourcesok{jj,1})))
                             toadd=0;
                             break
                         end
                     end
                     reqsourcesok{ii,2}=toadd;
                  end  
               end
               
               % Removing data sources
               if(tcvddsourcesokitems>0)
                  for ii=1:tcvddsourcesokitems
                    if(tcvddsourcesok{ii,2}==1)
                       str=sprintf('Removing algorithm data source %s', char(tcvddsourcesok{ii,1}));
                       obj.printlog(str);
                       removeDataSource(tcvdd, char(tcvddsourcesok{ii,1}));
                    end
                  end
               end
               
               % Adding data sources
               if(reqsourcesokitems>0)
                  for ii=1:reqsourcesokitems
                      if(reqsourcesok{ii,2}==1)
                         str=sprintf('Adding algorithm data source %s', char(reqsourcesok{ii,1})); 
                         obj.printlog(str);
                         addDataSource(tcvdd, char(reqsourcesok{ii,1}));
                      end
                  end
               end
        end
        
        function buildworkspacesimstruct(obj)
            obj.mdscontainer.buildworkspacesimstruct;
        end    


        function obj = setupmain(obj)
            % sets up global configs for the expcode
            assigncmd=sprintf('scd.expcode=%d;',obj.maincode);
            Simulink.data.evalinGlobal('tcv',assigncmd);
        end
        
        function obj = setupwrappers(obj)
            
            for ii=1:numel(obj.wrapperlist)
                switch obj.wrapperlist{ii}{1}
                    case 1
                        if(obj.wrapperlist{ii}{2}==1)
                            obj.node01.varalgo=obj.wrapperlist{ii}{3};
                            obj.node01.wrapdatadicts{1}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node01 cpu');
                        end
                        
                    case 2
                        if(obj.wrapperlist{ii}{2}>=1 &&  obj.wrapperlist{ii}{2}<=4)
                            obj.node02.varalgo(obj.wrapperlist{ii}{2})=obj.wrapperlist{ii}{3};
                            obj.node02.wrapdatadicts{obj.wrapperlist{ii}{2}}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node02 cpu');
                        end
                        
                    case 3
                        if(obj.wrapperlist{ii}{2}>=1 &&  obj.wrapperlist{ii}{2}<=4)
                            obj.node03.varalgo(obj.wrapperlist{ii}{2})=obj.wrapperlist{ii}{3};
                            obj.node03.wrapdatadicts{obj.wrapperlist{ii}{2}}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node03 cpu');
                        end
                                             
                    case 6
                        if(obj.wrapperlist{ii}{2}>=1 &&  obj.wrapperlist{ii}{2}<=4)
                            obj.node06.varalgo(obj.wrapperlist{ii}{2})=obj.wrapperlist{ii}{3};
                            obj.node06.wrapdatadicts{obj.wrapperlist{ii}{2}}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node06 cpu');
                        end
                        
                    case 7
                        if(obj.wrapperlist{ii}{2}>=1 &&  obj.wrapperlist{ii}{2}<=4)
                            obj.node07.varalgo(obj.wrapperlist{ii}{2})=obj.wrapperlist{ii}{3};
                            obj.node07.wrapdatadicts{obj.wrapperlist{ii}{2}}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node07 cpu');
                        end
                        
                    case 8
                        if(obj.wrapperlist{ii}{2}==1)
                            obj.node08.varalgo=obj.wrapperlist{ii}{3};
                            obj.node08.wrapdatadicts{1}=obj.wrapperlist{ii}{5};
                        else
                            warning('SCDclass_expcode:setupwrappers','not supported node08 cpu');
                        end
                        
                    otherwise
                        warning('SCDclass_expcode:setupwrappers','not supported node');
                  
                end
                
            end
            
        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
            d=Simulink.data.dictionary.open('tcv.sldd');
            dd=getSection(d, 'Design Data');
            varalgodd=dd.getEntry('SCDvaralgo');
            
            s=struct();
            
            % Looping through every active node
            for idx_nodedds=1:numel(obj.activenodes)
               varalgo=eval(sprintf('obj.node%02d.varalgo',obj.activenodes(idx_nodedds)));
               
               for ii=1:numel(varalgo)
                   str=sprintf('s.algo%02d%02d=%d;',obj.activenodes(idx_nodedds),ii,varalgo(ii));
                   eval(str);
               end
            end
            
            varalgodd.setValue(s);
            
        end

        
    end 
    
    
end