www.gusucode.com > mbcview 工具箱matlab源码程序 > mbcview/+cageview/+optim/Actions.m

    classdef Actions < handle
    %Actions optimization actions
    
    %  Copyright 2005-2016 The MathWorks, Inc. and Ford Global Technologies, Inc.
    
    properties (SetAccess=private)
        %MessageService optimization message service
        MessageService
        %RunActions action group for run actions
        RunActions
        %ImportActions action group for import actions
        ImportActions
        %Run run optimization
        Run
        %SetUpandRun setup optimization parameters then run
        SetUpandRun
        %SetUp setup optimization
        SetUp
        %Reset reset optimization parameters
        Reset
        %ImportDataset import initial values from data set
        ImportDataset
        %ImportOutput import initial values from optimization output
        ImportOutput
        %ImportTableGrid import initial values from table breakpoints
        ImportTableGrid
        %ImportTableValues import initial values from table values
        ImportTableValues
        %EditBounds edit optimization values
        EditBounds
        %ValueSize edit number of points per run
        ValueSize
        %ConvertToMultiValue convert point to sum optimization
        ConvertToMultiValue
        %ConvertToMultiRun convert sum to point optimization
        ConvertToMultiRun
        %Objective objective actions object (cageview.optim.ObjectiveActions)
        Objectives
        %Constraints constraint actions object (cageview.optim.ConstraintsActions)
        Constraints
        %SelectOpVars select operating point variables
        SelectOpVars
        %EditDatasets edit optimization data sets
        EditDatasets
        %Scaling select free variable scaling in optimization
        Scaling
        %ViewResults
        ViewResults
    end
    
    properties (Access=private)
        %Listeners
        Listeners
    end
    
    methods
        function obj = Actions(ms)
        %Actions constructor
        %   obj = Actions(ms)
        
        obj.MessageService = ms;
        % Optimization parameters and run
        obj.Run = mbcgui.actions.StatefulAction(@obj.onRun,'&Run...',...
            'Run optimization', cgrespath('optimgo.bmp'));
        obj.SetUpandRun = mbcgui.actions.StatefulAction(@obj.onSetUpandRun,'Set &Up and Run...',...
            'Set up and run optimization', cgrespath('optimsetupgo.bmp'));
        obj.SetUp = mbcgui.actions.StatefulAction(@obj.onSetUp,'&Set Up',...
            'Set up optimization', cgrespath('optimsetup.bmp'));
        obj.Reset = mbcgui.actions.StatefulAction(@obj.onReset,'Reset &Parameters',...
            'Reset optimization parameters' );
        
        obj.RunActions = mbcgui.actions.ActionGroup('Run actions');
        obj.RunActions.Actions = [obj.Run obj.SetUpandRun obj.SetUp obj.Reset];
        obj.RunActions.MenuType = 'separate';
        
        % import initial values
        obj.ImportDataset = mbcgui.actions.StatefulAction(@obj.onImportDataset,'&Import From Data Set...',...
            'Import initial data from a data set',cgrespath('optimdsimport.bmp') );
        obj.ImportOutput = mbcgui.actions.StatefulAction(@obj.onImportOutput,'Impor&t From Output...',...
            'Import initial data from a data set',cgrespath('optimoutputimport.bmp') );
        obj.ImportTableGrid = mbcgui.actions.StatefulAction(@obj.onImportTableGrid,'Import From Table &Grid...',...
            'Import initial data from a table grid',cgrespath('optimtablegridimport.bmp') );
        obj.ImportTableValues = mbcgui.actions.StatefulAction(@obj.onImportTableValues,'Import From Table &Values...',...
            'Import initial data from table values',cgrespath('optimtableimport.bmp') );

        obj.ImportActions = mbcgui.actions.ActionGroup('Run actions');
        obj.ImportActions.Actions = [obj.ImportDataset obj.ImportOutput obj.ImportTableGrid obj.ImportTableValues];
        obj.ImportActions.MenuType = 'separate';
        
        % other setup actions
        obj.EditBounds = mbcgui.actions.StatefulAction(@obj.onEditBounds,'Edit &Free Variable Ranges' );
        obj.ValueSize = mbcgui.actions.StatefulAction(@obj.onValueSize,'Set Variable &Lengths...' );
        obj.ConvertToMultiValue = mbcgui.actions.StatefulAction(@obj.onConvertToMultiValue,'Convert to Si&ngle Run' );
        obj.ConvertToMultiRun = mbcgui.actions.StatefulAction(@obj.onConvertToMultiRun,'Convert to &Multiple Runs' );
        
        % objectives and constraint actions
        obj.Objectives = cageview.optim.ObjectiveActions(ms);
        obj.Constraints = cageview.optim.ConstraintActions(ms);
        
        % data sets and applocation point set actions 
        obj.SelectOpVars = mbcgui.actions.StatefulAction(@obj.onSelectOpVars,'S&elect Operating Point Variables...' );
        obj.EditDatasets = mbcgui.actions.StatefulAction(@obj.onEditDatasets,'Edit &Data Sets...' );
        obj.Scaling = mbcgui.actions.ToggleAction(@obj.onScaling,'Sc&ale Optimization Items' );
        
        
        obj.ViewResults = mbcgui.actions.StatefulAction(@obj.onViewResults,'View Results','View optimization results',cgrespath('optimoutnode.bmp') );
        obj.ViewResults.TransparentColor = [255 0 255];
        
        obj.Listeners = [event.listener(ms, 'SetupChanged', @obj.onSetupChanged);
            event.listener(ms, 'InputValueChanged', @obj.onInputValueChanged);
            event.listener(ms, 'ScaledChanged', @obj.onScaledChanged)];
        
        end
        
        function createMenu(obj,hParent)
        %createMenu create Optimization menu from actions
        
        hrun = createMenuItem(obj.RunActions,hParent);
        set(hrun,'Interruptible','on');
        createMenuItem(obj.ImportActions,hParent);

        % other setup actions
        SetupActions = mbcgui.actions.ActionGroup('Setup actions');
        SetupActions.Actions = [obj.EditBounds obj.ValueSize obj.ConvertToMultiValue obj.ConvertToMultiRun];
        SetupActions.MenuType = 'separate';  
        createMenuItem(SetupActions,hParent);
        
        OtherActions = mbcgui.actions.ActionGroup('Other actions');
        obj.Objectives.AllActions.MenuType = 'submenu';
        obj.Constraints.AllActions.MenuType = 'submenu';
        OtherActions.Actions = [obj.Objectives.AllActions obj.Constraints.AllActions obj.SelectOpVars obj.EditDatasets obj.Scaling];
        OtherActions.MenuType = 'separate';
        createMenuItem(OtherActions,hParent);

        end
        
        function createToolbar(obj,hParent)
        %createToolbar create optimization setup toolbar
        
        % add objective and constraint
        createToolbutton(obj.Objectives.Add,hParent);
        createToolbutton(obj.Constraints.Add,hParent);
        % import actions
        tb=createToolbutton(obj.ImportActions,hParent);
        tb(1).Separator = 'on';
        
        % run actions
        tbrunActions = mbcgui.actions.ActionGroup('Run actions');
        tbrunActions.Actions = [obj.SetUp obj.SetUpandRun obj.Run ];
        tb = createToolbutton(tbrunActions,hParent);
        tb(1).Separator = 'on';
        tb(2).Interruptible = 'on';
        tb(3).Interruptible = 'on';

        end
        
        function createWorkflowItems(obj,hParent)

        AG= mbcgui.actions.ActionGroup('Common Tasks');
        AG.MenuType = 'separate';
        AG.Actions = [obj.Constraints.Add,obj.SetUp obj.Run,obj.ViewResults];        
        wf=createWorkflowItems(AG,hParent);
        wf(3).Interruptible = 'on';
        end
    end
    
    methods (Access=private)
        function onSetupChanged(obj,ms, ~)
        %onSetupChanged enable and select actions in responsed to optimization setup change
        %   respond to MessageService.SetupChanged event
        ok = checkrun(ms.getOptim, 'precheck');
        obj.SetUpandRun.Enabled = ok;
        obj.Run.Enabled = ok;
        obj.ViewResults.Enabled = numChildren(ms.Node)>0;
        % need to update inputvalue and scaling actions
        onInputValueChanged(obj,ms)
        onScaledChanged(obj,ms);
        end
        
        function onInputValueChanged(obj,ms,~)
        %onInputValueChanged enable convert to multirun/multivalue
        %   respond to MessageService.InputValueChanged event
        
        [OKMultiRun, OKMultiValue] = canconvertinitialvalues(ms.getOptim);
        obj.ConvertToMultiRun.Enabled = OKMultiRun;
        obj.ConvertToMultiValue.Enabled = OKMultiValue;

        end
        
        function onScaledChanged(obj,ms,~)
        %onScaledChanged select scaling
        %   respond to MessageService.Changed event
                
        optim = ms.getOptim;
        currScaledStatus = getScaled(optim);
        obj.Scaling.Selected = currScaledStatus;
        ms.setOptim(optim, 'Scaled');
        end
        
        
        function onImportDataset(obj,~, ~)
        %onImportDataset import initial values from data set 
        ms = obj.MessageService;
        busy(ms)
        optim = ms.getOptim;
        [optim, ok] = guiInitFromDataset(optim, ms.ProjectPointer);
        if ok
            ms.setOptim(optim, 'InputValue');
        end
        idle(ms)
        end
        
        
        function onImportOutput(obj,~, ~)
        %onImportOutput import initial values from optimization output
        
        ms = obj.MessageService;
        busy(ms)
        
        optim = ms.getOptim;
        % Look for an output node to use as the default
        pDefOut = [];
        pOptimNode = ms.Pointer;
        NumOut = pOptimNode.numOutputs;
        if NumOut>0
            pDefOut = pOptimNode.getOutput(NumOut);
        end
        [optim, ok] = guiInitFromOutput(optim, ms.ProjectPointer, pDefOut);
        if ok
            ms.setOptim(optim, 'InputValue');
        end
        idle(ms)
        end
        
        function onImportTableGrid(obj,~, ~)
        %onImportTableGrid import initial values from table breakpoints
        
        ms = obj.MessageService;
        busy(ms);
        optim = ms.getOptim;
        [optim, ok] = guiInitFromTableGrid(optim, ms.ProjectPointer);
        if ok
            ms.setOptim(optim, 'InputValue');
        end
        idle(ms)
        end
        
        function onImportTableValues(obj,~, ~)
        %onImportTableValues import initial values from table values
        
        ms = obj.MessageService;
        busy(ms)
        optim = ms.getOptim;
        [optim, ok] = guiInitFromTableValues(optim, ms.ProjectPointer);
        if ok
            ms.setOptim(optim, 'InputValue');
        end
        idle(ms)
        end
        
        function onEditDatasets(obj,~, ~)
        %onEditDatasets edit optimization datasets
        ms = obj.MessageService;
        optim = ms.getOptim;
        [optim, ok] = guiDatasetManager(optim, ms.ProjectPointer);
        if ok
            ms.setOptim(optim, 'Dataset');
        end
        end
        
        function onSelectOpVars(obj,~, ~)
        %onSelectOpVars select operating point variables
        
        ms = obj.MessageService;
        optim = ms.getOptim;
        [optim, ok] = guiSelectOpVars(optim);
        if ok
            ms.setOptim(optim, 'Dataset');
        end
        end
        
        function onEditBounds(obj,~, ~)
        %onEditBounds edit optimization bounds
        ms = obj.MessageService;
        optim = ms.getOptim;
        [optim, ok] = guiFreeValueRangeEditor(optim);
        if ok
            ms.setOptim(optim, 'FreeVariable');
        end
        end
        
        function onValueSize(obj,~, ~)
        %onValueSize change number of points in a run (size of sum optimization)
        ms = obj.MessageService;
        optim = ms.getOptim;
        [optim, ok] = guiValueSizeEditor(optim);
        if ok
            ms.setOptim(optim, 'InputValue');
        end
        end
        
        
        function onConvertToMultiValue(obj,~, ~)
        %onConvertToMultiValue convert multirun to multivalue (sum)
        %optimization
        ms = obj.MessageService;
        optim = ms.getOptim;
        optim = convertinitialvaluedata(optim, 'multivalue');
        ms.setOptim(optim, 'InputValue');
        end

        function onConvertToMultiRun(obj,~, ~)
        %onConvertToMultiRun convert multivalue to multirun optimization 
        ms = obj.MessageService;
        optim = ms.getOptim;
        optim = convertinitialvaluedata(optim, 'multirun');
        ms.setOptim(optim, 'InputValue');
        end
        
        function onScaling(obj,~, ~)
        %onScaling toggle scaling status
        ms = obj.MessageService;
        optim = ms.getOptim;
        currentStatus = getScaled(optim);
        optim = setScaled(optim, ~currentStatus);
        ms.setOptim(optim, 'Scaled');
        end
        
        function onSetUp(obj, ~,~)
        %onSetUp setup optimization parameters
        ms = obj.MessageService;
        optim = ms.getOptim;
        [optim, ok] = guiParameterEditor(optim);
        if ok
            ms.setOptim(optim, 'Parameter');
        end
        end
        
        function onReset(obj,~, ~)
        %onReset reset optimization parameters
        
        ms = obj.MessageService;
        optim = ms.getOptim;
        optim = resetParameters(optim);
        ms.setOptim(optim, 'Parameter');
        end
        
        function onSetUpandRun(obj, ~, ~)
        %onSetUpandRun setup and run optimization
        
        ms = obj.MessageService;
        optim = ms.getOptim;
        % edit optimization parameters
        [optim, ok] = guiParameterEditor(optim);
        if ok
            ms.setOptim(optim, 'Parameter');
            % run optimization
            onRun(obj);
        end
        end
        
        function onRun(obj,~, ~)
        %onRun run optimization
        
        ms = obj.MessageService;
        nd = ms.Pointer;
        busy(ms,['Running ' nd.name ' optimization...'])
        
        optim = ms.getOptim;
        
        [OK, msg, Output] = run(optim, true);
        if OK
            [~, pOutNode] = attachNewOutput(nd.info, Output);
            % select output node
            gotonode(cgbrowser,pOutNode);
        elseif ~isempty(msg)
             %report error from optimization run
            h = errordlg(msg, 'CAGE Optimization', 'modal');
            waitfor(h);
        end
        idle(ms)
        end
        
        function onViewResults(obj,~,~)
        ms = obj.MessageService;
        if ms.hasData && numChildren(ms.Node)>0
            ch = children(ms.Node);
            gotonode(cgbrowser,ch(end));
        end
        end
        
    end
end