www.gusucode.com > mbcdata 工具箱 matlab 源码程序 > mbcdata/@cgoptim/upgradeV10ToV11.m

    function [obj, pOldDS] = upgradeV10ToV11(obj, action)
%UPGRADEV10TOV11 Perform load-time upgrade.
%
%   [OBJ, P_DS] = UPGRADEV10TOV11(OBJ) is called after loading to complete
%   the upgrade of an optimization object from V10 to V11.
%
%   OUTPUTOBJ = UPGRADEV10TOV11(OBJ, 'getoutput') returns the new output
%   object that is created by the upgrade process.
%
%   OBJ = UPGRADEV10TOV11(OBJ, 'clearupgradedata') clears the remaining
%   upgrade data in the optimization.

%   Copyright 2005-2009 The MathWorks, Inc.


if nargin<2
    action = 'upgrade';
end

switch action
    case 'upgrade'
        [obj, pOldDS] = i_doupgrade(obj);
    case 'getoutput'
        obj = obj.V11UpgradeData.OutputObject;
    case 'clearupgradedata'
        obj.V11UpgradeData = [];
end



function [obj, pOldDS] = i_doupgrade(obj)
ugData = obj.V11UpgradeData;


% ------------------------------------------------------------------------
% Work out number of runs.  This depends on whether there are any sum-style
% objects in the old optimization.
OldObjectives = infoarray(ugData.ObjectivePtrs);
IsSum = false;
for n = 1:length(OldObjectives)
    IsSum = isa(OldObjectives{n}, 'cgobjectivesum');
    if IsSum
        break
    end
end

if ~IsSum
    % point-by point might have many runs
    if ~isempty(obj.oppoints.Datasets)
        obj.NumberOfRuns = max(1, obj.oppoints.Datasets(1).get('numpoints'));
    end
end


% ------------------------------------------------------------------------
% Put initial free value data in the right place
pVals = obj.values;

for n = 1:length(pVals);
    if IsSum
        if ~isempty(ugData.x0)
            setinitialvaluedata(obj, pVals(n), 1, ugData.x0(:,n).');
        end
    else
        if size(ugData.x0,1)==obj.NumberOfRuns
            setinitialvaluedata(obj, pVals(n), 1:obj.NumberOfRuns, ugData.x0(:,n));
        end
    end
end
ugData.x0 = [];



% ------------------------------------------------------------------------
% Update objectives
Objectives = infoarray(ugData.ObjectivePtrs);
for n = 1:length(Objectives)
    % Get the old objects to create a correct new one
    [Objectives{n}, obj] = createNewObjective(Objectives{n}, obj);
end
obj.Objectives = Objectives;
freeptr(ugData.ObjectivePtrs);
ugData.ObjectivePtrs = [];


% ------------------------------------------------------------------------
% Update constraints
Constraints = infoarray(ugData.ConstraintPtrs);
for n = 1:length(Constraints)
    % Set the current inputs in cgconstraint objects again to make sure the
    % correct details are in con objects and the ranges of constraints are
    % correctly estimated.
    Constraints{n} = setinputs(Constraints{n}, getinputs(Constraints{n}));

    % Get the old objects to create a correct new one.  This clones
    % cgconstraint pointers that we want to still use, since it is then
    % easier to flush out all old cgconstraint pointers in the loadobj
    [Constraints{n}, obj] = createOptimConstraint(Constraints{n}, obj);
end
obj.Constraints = Constraints;
obj.ConstraintEnabled = true(size(Constraints));
ugData.ConstraintPtrs = [];


% ------------------------------------------------------------------------
% Put initial fixed value data in the right place
DS = obj.oppoints;
if ~isempty(DS.Datasets)
    pPrimaryDS = DS.Datasets(1);
    pDataFactors = pPrimaryDS.get('ptrlist');
    FixedData = pPrimaryDS.get('data');
    
    pFixed = getfixedvalues(obj);
    [DataAvail, DataIdx] = ismember(pFixed, pDataFactors);
    for n = find(DataAvail)
        if IsSum
            setinitialvaluedata(obj, pFixed(n), 1, FixedData(:,DataIdx(n)).');
        else
            setinitialvaluedata(obj, pFixed(n), 1:obj.NumberOfRuns, FixedData(:,DataIdx(n)));
        end
    end
end



% ------------------------------------------------------------------------
% Construct output data object ready for use in the output node

% Upgrade from older version that has data in oppoints still, if required
[ugData, pOldDS] = i_UpgradeOutputV7ToV8(ugData);

% Create the new output object from the old cube of data
ugData = i_UpgradeOutput(obj, ugData, IsSum, obj.values);

% Save output data object
obj.V11UpgradeData = ugData;





function ugData = i_UpgradeOutput(optim, ugData, IsSum, pFreeVar)

data = ugData.V11OutputData;
ugData.V11OutputData = [];
if isempty(data.outputData)
    % Construct an empty output object
    ugData.OutputObject = cgoptimoutput;
else
    % Pull out free variable data from the output cube
    InpIdx = findptrs(pFreeVar, data.outputColumns);
    % The new data needs to be a 1-by-NFREEVARLAB cell array, with each
    % element being NRUN-by-NFREE-by-NSOL (for that free variable label)
    NewData = cell(1, length(InpIdx));
    for n = 1:length(InpIdx)
        if IsSum
            ThisNewData = permute(data.outputData(:, InpIdx(n), :), [2 1 3]);
        else
            ThisNewData = data.outputData(:, InpIdx(n), :);
        end
        NewData{n} = ThisNewData;
    end

    % Ensure that the diagnostic statistics structure is a vector
    data.diagStat = data.diagStat(:);
    
    % Possible that user defined scripts have diagnostic statistics
    % structures of incorrect size. If structure is incorrect size, then
    % set it to be a scalar.
    if IsSum
        nRun = 1;
    else
        nRun = size(data.outputData, 1);
    end
    if ~isempty(data.diagStat) && length(data.diagStat) ~= nRun
        data.diagStat = data.diagStat(1);
    end
    
    ugData.OutputObject = cgoptimoutput(...
        optim, ...
        NewData, ...
        data.lastErr, ...
        data.lastOK, ...
        data.diagStat);
    ugData.OutputObject = ...
        setSelectedSolutionNumber(ugData.OutputObject, getSol(data.outputSelection));
end




function [ugData, pOldDS] = i_UpgradeOutputV7ToV8(ugData)
pOldDS = mbcpointer(1,0);
if ~isempty(ugData.V8OutputData)
    pOutputs = ugData.V8OutputData.OppointPtrs;
    
    if ~isempty(pOutputs)
        % Reconstruct data fields from the pointer-ed objects
        tmp_data = pveceval(pOutputs, @get, 'data');
        tmp_ptrs = pOutputs(1).get('ptrlist');

        % Ignore columns that have null pointers in the dataset
        ignore_cols = isnull(tmp_ptrs);
        ugData.V11OutputData.outputData = cat(3, tmp_data{:});
        ugData.V11OutputData.outputData = ugData.V11OutputData.outputData(:, ~ignore_cols, :);
        ugData.V11OutputData.outputColumns = tmp_ptrs(~ignore_cols);
    end
    pOldDS = [pOutputs, ugData.V8OutputData.ParetoPtrs];
    ugData.V8OutputData = [];
end