ExperimentRunner.m

Go to the documentation of this file.

namespace models{
namespace muscle{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class ExperimentRunner
  :public handle {
    public:

        RunParallel;

        
    public: /* ( Dependent ) */

        StoreExperimentData;

        
    public:

        Config;

        Model;

        
    /* (Access=privat*/
public:

                multipleexperiments = false;

        cache;

        cachedata;

        
    public:

        ExperimentRunner(models.BaseFullModel model) {
            this.Model= model;
            config = model.Config;
            if ~isa(config, " models.muscle.AExperimentModelConfig ")
                error(" 'config' parameter must be a AExperimentModelConfig ");
            end
            this.Config= config;

            /*  Do parallel if parallel toolbox is around! */
            this.RunParallel= exist(" matlabpool "," file ") == 2;
            this.StoreExperimentData= true;
        }


        function [out , matrix<double>y , ct ] = getCachedExperimentConfig(nr,colvec<double> mu) {
            m = this.Model;
            if nargin < 3
                mu = m.DefaultMu;
            end
            /*  The cache key is param + config nr */
            key = [mu; nr; m.Geo.NumElements; m.Config.FEM.GaussPointsPerElem];
            out = [];
            y = [];
            ct = [];
            if this.cachedata && this.cache.hasData(key);
                data = this.cache.getData(key);
                out = data.out;
                y = data.y;
                ct = data.ct;
                this.Config.CurrentConfigNr= nr;
                this.Model.System.setConfig(mu,this.Model.DefaultInput);
            end
        }


        function [out , matrix<double>y , ct ] = runExperimentConfig(nr,colvec<double> mu) {

            m = this.Model;
            if nargin < 3
                mu = m.DefaultMu;
            end
            [out, y, ct] = this.getCachedExperimentConfig(nr, mu);
            /*  Uncomment this to re-generate the output
 *             out = this.Config.getOutputOfInterest(m.Times,y); */
            if isempty(out)
                c = this.Config;
                out = NaN(1,c.NumOutputs);
                try
                    /*  Apply configuration set within ModelConfig
                     * Updates the associated model automatically (precomputations) */
                    c.CurrentConfigNr= nr;

                    /* m.plotGeometrySetup; */

                    /*  Run simulation */
                    [t,y,ct] = m.simulate(mu);

                    /*  Get output of interest */
                    tic;
                    out = c.getOutputOfInterest(t,y);
                    ct = ct + toc;

                    if this.cachedata
                        /*  The cache key is param + config nr */
                        key = [mu; nr; m.Geo.NumElements; c.FEM.GaussPointsPerElem];
                        data = struct(" y ",y," t ",t," mu ",mu," nr ",nr," ct ",ct," out ",out);
                        this.cache.addData(key,data);
                    end
                catch ME
                    /*  Set to NaN to notify there's something wrong */
                    out(:) = NaN;
                    ME.getReport
                end
            end
        }
        function [out , ct ] = runExperiment(colvec<double> mu) {
            if nargin < 2
                mu = this.Model.DefaultMu;
            end
            c = this.Config;
            out = zeros(c.NumConfigurations,c.NumOutputs);
            ct = zeros(c.NumConfigurations,1);
            /*  Run all the settings! */
            if this.RunParallel && ~this.multipleexperiments
                fprintf(" Running %d experiment configurations in parallel...\n ",c.NumConfigurations);
                closeafterrun = false;
                if matlabpool(" size ") == 0
                    matlabpool open;
                    closeafterrun = true;
                end
                parfor nr = 1:c.NumConfigurations
                    t = getCurrentTask();
                    fprintf(" Worker %d: Running configuration %d\n ",t.ID,nr);
                    [out(nr,:), ~, ct(nr)] = this.runExperimentConfig(nr, mu);/* #ok */

                end
                if closeafterrun
                    matlabpool close;
                end
                fprintf(" done ");
            else
                if ~this.multipleexperiments
                    pi = ProcessIndicator(" Running experiment configurations ",c.NumConfigurations);
                end
                for nr = 1:c.NumConfigurations
                    [out(nr,:), ~, ct(nr)] = this.runExperimentConfig(nr, mu);
                    if ~this.multipleexperiments
                        pi.step;
                    end
                end
                if ~this.multipleexperiments
                    pi.stop;
                end
            end
        }
        function [allout , allct ] = runExperiments(mus) {
            c = this.Config;
            nex = size(mus,2);
            allout = zeros(c.NumConfigurations,c.NumOutputs,nex);
            allct = zeros(c.NumConfigurations,nex);
            this.multipleexperiments= nex > 1;

            if this.RunParallel && nex > 1
                closeafterrun = false;
                if matlabpool(" size ") == 0
                    matlabpool open;
                    closeafterrun = true;
                end
                fprintf(" Running %d experiments (%d configs each) in parallel...\n ",nex,c.NumConfigurations);
                parfor k=1:nex
                    t = getCurrentTask();
                    fprintf(" Worker %d: Running experiment %d\n ",t.ID,k);
                    [allout(:,:,k), allct(:,k)] = this.runExperiment(mus(:,k));/* #ok */

                end
                fprintf(" done ");
                if closeafterrun
                    matlabpool close;
                end
            else
                pi = ProcessIndicator(" Running experiment configurations (%d each) for %d parameters ",...
                    nex,false,c.NumConfigurations,nex);
                for k=1:nex
                    [allout(:,:,k), allct(:,k)] = this.runExperiment(mus(:,k));
                    pi.step;
                end
                pi.stop;
            end
            /*  Put number of experiment to first row */
            allout = permute(allout,[3 1 2]);

            this.multipleexperiments= false;
        }
        function res = runExperimentsCached(mus) {
            c = this.Config;
            fi = fullfile(c.OutputDir,[c.getOptionStr " .mat "]);
            if ~(exist(fi," file ") == 2)
                m = this.Model;
                e = this;
                if nargin < 2
                    [o, ct] = this.runExperiment;/* #ok */

                    save(fi," m "," o "," c "," ct "," e ");
                else
                    [o, ct] = this.runExperiments(mus);/* #ok */

                    save(fi," m "," o "," c "," mus "," ct "," e ");
                end
            end
            res = load(fi);
        }


        
#if 0 //mtoc++: 'set.StoreExperimentData'
function  StoreExperimentData(value) {
            if value && isempty(this.cache)
                dir = fullfile(this.Config.OutputDir," trajectories ",this.Config.getOptionStr(false));
                this.cache= data.FileDataCollection(dir);
                this.cache.KeepFiles= true;
            elseif ~isempty(value) && ~value
                this.cache= [];
            end
            this.cachedata= value;
        }

#endif


        
#if 0 //mtoc++: 'get.StoreExperimentData'
function value = StoreExperimentData() {
            value = this.cachedata;
        }

#endif

    
};
}
}