Ignore:
Timestamp:
05/08/20 21:50:12 (5 years ago)
Author:
Eric.Larour
Message:

CHG: cleaneup classes, with semblant of partition code not activated yet. Goal long term
is to take out md.qmu.vpartition and md.qmu.epartition and to stick it into the md.qmu.variables
themselves.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/m/classes/qmu/uniform_uncertain.m

    r24820 r24830  
     1%UNIFORM_UNCERTAIN Class definition
    12%
    2 %  definition for the uniform_uncertain class.
    3 %
    4 %  [uuv]=uniform_uncertain(varargin)
    5 %
    6 %  where the required varargin are:
    7 %    descriptor    (char, description, '')
    8 %    lower         (double, lower bound, -Inf)
    9 %    upper         (double, upper bound,  Inf)
    10 %
    11 %  note that zero arguments constructs a default instance; one
    12 %  argument of the class copies the instance; and three or more
    13 %  arguments constructs a new instance from the arguments.
    14 %
    15 %  "Copyright 2009, by the California Institute of Technology.
    16 %  ALL RIGHTS RESERVED. United States Government Sponsorship
    17 %  acknowledged. Any commercial use must be negotiated with
    18 %  the Office of Technology Transfer at the California Institute
    19 %  of Technology.  (J. Schiermeier, NTR 47078)
    20 %
    21 %  This software may be subject to U.S. export control laws.
    22 %  By accepting this  software, the user agrees to comply with
    23 %  all applicable U.S. export laws and regulations. User has the
    24 %  responsibility to obtain export licenses, or other export
    25 %  authority as may be required before exporting such information
    26 %  to foreign countries or providing access to foreign persons."
    27 %
     3%%   Usage:
     4%      nuv=uniform_uncertain('descriptor',descriptor,'lower',lower,'upper',upper,'partition',partition);
     5%      where nuv is the uniform_uncertain object returned by the constructor, lower and upper are the
     6%      pdf distribution bounds, and partition is the partition vector for distributed variables.
     7%      Can be a partition %      vector over elements or vertices.
     8%
     9%   Example:
     10%      md.qmu.variables.rheology=uniform_uncertain('descriptor','RheologyBBar','lower',1e8,'upper',1e9);
     11%      md.qmu.variables.rheology=uniform_uncertain('descriptor','RheologyBBar','lower',1e8,'upper',1e9,'partition',vpartition);
     12%
     13
    2814classdef uniform_uncertain
    2915    properties
    … …  
    3117        lower     =-Inf;
    3218        upper     = Inf;
     19                partition = [];
    3320    end
     21    methods
     22                function self=uniform_uncertain(varargin) %constructor {{{
    3423
    35     methods
    36         function [uuv]=uniform_uncertain(varargin)
     24                        %recover options:
     25                        options = pairoptions(varargin{:});
    3726
    38             switch nargin
     27                        %initialize fields:
     28                        self.descriptor=getfieldvalue(options,'descriptor');
     29                        self.upper=getfieldvalue(options,'upper');
     30                        self.lower=getfieldvalue(options,'lower');
     31                        self.partition=getfieldvalue(options,'partition',[]); %default not used.
    3932
    40 %  create a default object
     33                end %}}}
     34                function disp(self) % {{{
    4135
    42                 case 0
     36                        disp(sprintf('   uniform uncertain variable: '));
     37                        fielddisplay(self,'descriptor','name tag');
     38                        fielddisplay(self,'lower','pdf lower bound');
     39                        fielddisplay(self,'upper','pdf upper bound');
     40                        if ~isempty(self.partition),
     41                                fielddisplay(self,'partition','partition vector defining where sampling will occur');
     42                        end
     43                end
     44                %}}}
     45                function md=checkconsistency(self,md,solution,analyses) % {{{
    4346
    44 %  copy the object
     47                        md = checkfield(md,'field',self.upper,'fieldname','uniform_uncertain.upper','NaN',1,'Inf',1);
     48                        md = checkfield(md,'field',self.lower,'fieldname','uniform_uncertain.lower','NaN',1,'Inf',1);
     49                        if ~isempty(self.partition),
     50                                md = checkfield(md,'field',self.partition,'fieldname','uniform_uncertain.partition','NaN',1,'Inf',1,'>=',-1,'numel',[md.mesh.numberofvertices,md.mesh.numberofelements]);
     51                                if size(self.partition,1)>1,
     52                                        error('uniform_uncertain error message: partition should be a column vector');
     53                                end
     54                                partcheck=unique(self.partition);
     55                                partmin=min(partcheck);
     56                                partmax=max(partcheck);
     57                                if partmax<-1,
     58                                        error('uniform_uncertain error message: partition vector''s min value should be -1 (for no partition), or start at 0');
     59                                end
     60                                nmax=max(md.mesh.numberofelements,md.mesh.numberofvertices);
     61                                if partmax>nmax,
     62                                        error('uniform_uncertain error message: partition vector''s values cannot go over the number of vertices or elements');
     63                                end
    4564
    46                 case 1
    47                     if isa(varargin{1},'uniform_uncertain')
    48                         uuv=varargin{1};
    49                     else
    50                         error('Object ''%s'' is a ''%s'' class object, not ''%s''.',...
    51                             inputname(1),class(varargin{1}),'uniform_uncertain');
    52                     end
    53 
    54 %  not enough arguments
    55 
    56                 case 2
    57                     error('Construction of ''%s'' class object requires at least %d inputs.',...
    58                         'uniform_uncertain',3)
    59 
    60 %  create the object from the input
    61 
    62                 otherwise
    63                     asizec=num2cell(array_size(varargin{1:min(nargin,3)}));
    64                     uuv(asizec{:})=uniform_uncertain;
    65                     clear asizec
    66 
    67                     if ischar(varargin{1})
    68                         varargin{1}=cellstr(varargin{1});
    69                     end
    70                     for i=1:numel(uuv)
    71                         if (numel(varargin{1}) > 1)
    72                             uuv(i).descriptor=varargin{1}{i};
    73                         else
    74                             uuv(i).descriptor=[char(varargin{1}) string_dim(uuv,i,'vector')];
    75                         end
    76                         if (numel(varargin{2}) > 1)
    77                             uuv(i).lower     =varargin{2}(i);
    78                         else
    79                             uuv(i).lower     =varargin{2};
    80                         end
    81                         if (numel(varargin{3}) > 1)
    82                             uuv(i).upper     =varargin{3}(i);
    83                         else
    84                             uuv(i).upper     =varargin{3};
    85                         end
    86                     end
    87             end
    88 
    89         end
    90 
    91         function []=disp(uuv)
    92 
    93 %  display the object
    94 
    95             disp(sprintf('\n'));
    96             for i=1:numel(uuv)
    97                 disp(sprintf('class ''%s'' object ''%s%s'' = \n',...
    98                     class(uuv),inputname(1),string_dim(uuv,i)));
    99                 disp(sprintf('    descriptor: ''%s'''  ,uuv(i).descriptor));
    100                 disp(sprintf('         lower: %g'      ,uuv(i).lower));
    101                 disp(sprintf('         upper: %g\n'    ,uuv(i).upper));
    102             end
    103 
    104         end
    105 
    106         function [desc]  =prop_desc(uuv,dstr)
    107             desc=cell(1,numel(uuv));
    108             for i=1:numel(uuv)
    109                 if ~isempty(uuv(i).descriptor)
    110                     desc(i)=cellstr(uuv(i).descriptor);
    111                 elseif ~isempty(inputname(1))
    112                     desc(i)=cellstr([inputname(1) string_dim(uuv,i,'vector')]);
    113                 elseif exist('dstr','var')
    114                     desc(i)=cellstr([dstr         string_dim(uuv,i,'vector')]);
    115                 else
    116                     desc(i)=cellstr(['uuv'        string_dim(uuv,i,'vector')]);
    117                 end
    118             end
    119             desc=allempty(desc);
    120         end
    121         function [initpt]=prop_initpt(uuv)
    122             initpt=[];
    123         end
    124         function [lower] =prop_lower(uuv)
    125             lower=zeros(1,numel(uuv));
    126             for i=1:numel(uuv)
    127                 lower(i)=uuv(i).lower;
    128             end
    129             lower=allequal(lower,-Inf);
    130         end
    131         function [upper] =prop_upper(uuv)
    132             upper=zeros(1,numel(uuv));
    133             for i=1:numel(uuv)
    134                 upper(i)=uuv(i).upper;
    135             end
    136             upper=allequal(upper, Inf);
    137         end
    138         function [mean]  =prop_mean(uuv)
    139             mean=[];
    140         end
    141         function [stddev]=prop_stddev(uuv)
    142             stddev=[];
    143         end
    144         function [initst]=prop_initst(uuv)
    145             initst=[];
    146         end
    147         function [stype] =prop_stype(uuv)
    148             stype={};
    149         end
    150         function [scale] =prop_scale(uuv)
    151             scale=[];
    152         end
    153                 function [abscissas] =prop_abscissas(hbu) % {{{
    154             abscissas=[];
    155         end % }}}
    156         function [counts] =prop_counts(hbu) % {{{
    157             counts=[];
    158         end % }}}
    159         function [pairs_per_variable] =prop_pairs_per_variable(hbu) % {{{
    160                         pairs_per_variable=[];
    161         end % }}}
    162                 function checkconsistency(self,md,solution,analyses) % {{{
     65                        end
    16366                end % }}}
    164 
     67        %virtual functions needed by qmu processing algorithms:
     68        %implemented:
     69                function [desc]  =prop_desc(uuv,dstr) % {{{
     70                        desc=cell(1,numel(uuv));
     71                        for i=1:numel(uuv)
     72                                if ~isempty(uuv(i).descriptor)
     73                                        desc(i)=cellstr(uuv(i).descriptor);
     74                                elseif ~isempty(inputname(1))
     75                                        desc(i)=cellstr([inputname(1) string_dim(uuv,i,'vector')]);
     76                                elseif exist('dstr','var')
     77                                        desc(i)=cellstr([dstr         string_dim(uuv,i,'vector')]);
     78                                else
     79                                        desc(i)=cellstr(['uuv'        string_dim(uuv,i,'vector')]);
     80                                end
     81                        end
     82                        desc=allempty(desc);
     83                end %}}}
     84                function [lower] =prop_lower(uuv) %{{{
     85                        lower=zeros(1,numel(uuv));
     86                        for i=1:numel(uuv)
     87                                lower(i)=uuv(i).lower;
     88                        end
     89                        lower=allequal(lower,-Inf);
     90                end %}}}
     91                function [upper] =prop_upper(uuv) %{{{
     92                        upper=zeros(1,numel(uuv));
     93                        for i=1:numel(uuv)
     94                                upper(i)=uuv(i).upper;
     95                        end
     96                        upper=allequal(upper, Inf);
     97                end % }}}
     98        %default
     99                function [stddev]=prop_stddev(uuv)  %{{{
     100                        stddev=[];
     101                        end % }}}
     102                        function [mean]  =prop_mean(nuv) % {{{
     103                        mean=[];
     104                        end % }}}
     105                        function [initpt]=prop_initpt(uuv) %{{{
     106                        initpt=[];
     107                        end %}}}
     108                        function [initst]=prop_initst(uuv) %{{{
     109                                initst=[];
     110                                end %}}}
     111                                function [stype] =prop_stype(uuv) %{{{
     112                                stype={};
     113                                end %}}}
     114                                function [scale] =prop_scale(uuv) %{{{
     115                                scale=[];
     116                                end %}}}
     117                                function [abscissas] =prop_abscissas(hbu) % {{{
     118                                abscissas=[];
     119                                end % }}}
     120                                function [counts] =prop_counts(hbu) % {{{
     121                                counts=[];
     122                                end % }}}
     123                                function [pairs_per_variable] =prop_pairs_per_variable(hbu) % {{{
     124                                pairs_per_variable=[];
     125                                end % }}}
    165126    end
    166 
    167     methods (Static)
    168         function []=dakota_write(fidi,dvar)
    169 
    170 %  collect only the variables of the appropriate class
    171 
     127        methods (Static)
     128        function []=dakota_write(fidi,dvar) % {{{
     129                        %  collect only the variables of the appropriate class
    172130            uuv=struc_class(dvar,'uniform_uncertain');
    173 
    174 %  write variables
    175 
     131                        %  write variables
    176132            vlist_write(fidi,'uniform_uncertain','uuv',uuv);
    177         end
     133        end %}}}
    178134    end
    179135end
Note: See TracChangeset for help on using the changeset viewer.