Changeset 25022

Timestamp:

06/11/20 20:34:52 (5 years ago)

Author:

jdquinn

Message:

CHG: More MATLAB to Python API changes for Dakota interface

Location:

issm/trunk-jpl

Files:

• src/m/classes/qmu.py (modified) (3 diffs)
• src/m/classes/qmu/normal_uncertain.m (modified) (1 diff)
• src/m/classes/qmu/normal_uncertain.py (modified) (6 diffs)
• src/m/partition/AreaAverageOntoPartition.py (modified) (2 diffs)
• src/m/qmu/preqmu.m (modified) (3 diffs)
• src/m/qmu/preqmu.py (modified) (6 diffs)
• src/m/qmu/setupdesign/QmuSetupVariables.m (modified) (1 diff)
• src/m/qmu/setupdesign/QmuSetupVariables.py (modified) (1 diff)
• test/NightlyRun/test412.py (modified) (2 diffs)

issm/trunk-jpl/src/m/classes/qmu.py

@@ -34 +34 @@
         self.responsepartitions = []
         self.responsepartitions_npart = []
+        self.responsepartitions_nt = []
         self.mass_flux_profile_directory = float('NaN')
         self.mass_flux_profiles = float('NaN')
@@ -114 +115 @@
         s += "%s\n" % fielddisplay(self, 'variablepartitions', '')
         s += "%s\n" % fielddisplay(self, 'variablepartitions_npart', '')
+        s += "%s\n" % fielddisplay(self, 'variablepartitions_nt', '')
         s += "%s\n" % fielddisplay(self, 'variabledescriptors', '')
         s += "%s\n" % fielddisplay(self, 'responsedescriptors', '')
@@ -174 +176 @@
         WriteData(fid, prefix, 'object', self, 'fieldname', 'variablepartitions', 'format', 'MatArray')
         WriteData(fid, prefix, 'object', self, 'fieldname', 'variablepartitions_npart', 'format', 'IntMat', 'mattype', 3)
+        WriteData(fid, prefix, 'object', self, 'fieldname', 'variablepartitions_nt', 'format', 'IntMat', 'mattype', 3)
         WriteData(fid, prefix, 'object', self, 'fieldname', 'responsedescriptors', 'format', 'StringArray')
         WriteData(fid, prefix, 'object', self, 'fieldname', 'responsepartitions', 'format', 'MatArray')

issm/trunk-jpl/src/m/classes/qmu/normal_uncertain.m

@@ -39 +39 @@
                                 npart=qmupart2npart(self.partition);
                                 if npart~=size(self.mean,1),
-                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the row size of the mean field should be identifical to the number of partitions']);
+                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the row size of the mean field should be identical to the number of partitions']);
                                 end
                                 if npart~=size(self.stddev,1),
-                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the row size of the stddev field should be identifical to the number of partitions']);
+                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the row size of the stddev field should be identical to the number of partitions']);
                                 end
                                 if self.nsteps~=size(self.mean,2),
-                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the col size of the mean field should be identifical to the number of time steps']);
+                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the col size of the mean field should be identical to the number of time steps']);
                                 end
-                                if npart~=size(self.stddev,1),
-                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the col size of the stddev field should be identifical to the number of time steps']);
+                                if self.nsteps~=size(self.stddev,2),
+                                        error(['normal_uncertain constructor: for the scaled variable ' self.descriptor ' the col size of the stddev field should be identical to the number of time steps']);
                                 end
 

issm/trunk-jpl/src/m/classes/qmu/normal_uncertain.py

@@ -6 +6 @@
 from pairoptions import pairoptions
 from partition_npart import *
+from qmupart2npart import qmupart2npart
 
 
@@ -36 +37 @@
         self.stddev     = np.NaN
         self.partition  = []
+        self.nsteps     = 0
 
     @staticmethod
@@ -61 +63 @@
 
             #initialize fields:
-            nuv.descriptor = options.getfieldvalue('descriptor', '')
-            nuv.mean       = options.getfieldvalue('mean', np.NaN)
-            nuv.stddev     = options.getfieldvalue('stddev', np.NaN)
+            nuv.descriptor = options.getfieldvalue('descriptor')
+            nuv.mean       = options.getfieldvalue('mean')
+            nuv.stddev     = options.getfieldvalue('stddev')
 
             #if the variable is scaled, a partition vector should have been supplied, and
@@ -70 +72 @@
             if nuv.isscaled():
                 nuv.partition = options.getfieldvalue('partition')
-                npart = partition_npart(nuv.partition)
-                if npart != len(nuv.mean):
-                    error("normal_uncertain constructor: for the scaled variable %s the mean field is not currently a vector of values for all the partitions described in the partition vector" % nuv.descriptor)
-                if npart != len(nuv.stddev):
-                    error("normal_uncertain constructor: for the scaled variable %s the stddev field is not cureently a vector of values for all the partitions described in the partition vector" % nuv.descriptor)
+                nuv.nsteps = options.getfieldvalue('nsteps', 1)
+                npart = qmupart2npart(nuv.partition)
+                if npart != nuv.mean.shape[0]:
+                    raise RuntimeError("normal_uncertain constructor: for the scaled variable %s the row size of the mean field should be identical to the number of partitions" % nuv.descriptor)
+                if npart != nuv.stddev.shape[0]:
+                    raise RuntimeError("normal_uncertain constructor: for the scaled variable %s the row size of the stddev field should be identical to the number of partitions" % nuv.descriptor)
+                if nuv.nsteps != nuv.mean.shape[1]:
+                    raise RuntimeError("normal_uncertain constructor: for the scaled variable %s the col size of the mean field should be identical to the number of time steps" % nuv.descriptor)
+                if nuv.nsteps != nuv.stddev.shape[1]:
+                    raise RuntimeError("normal_uncertain constructor: for the scaled variable %s the col size of the stddev field should be identical to the number of time steps" % nuv.descriptor)
 
         return [nuv] # Always return a list, so we have something akin to a MATLAB single row matrix
@@ -86 +93 @@
         if self.partition != []:
             string = "%s\n%s" % (string, fielddisplay(self, 'partition', 'partition vector defining where sampling will occur'))
+        string = "%s\n%s" % (string, fielddisplay(self, 'nsteps', 'number of time steps'))
 
         return string
@@ -102 +110 @@
         if self.isscaled():
             if self.partition == []:
-                error("normal_uncertain is a scaled variable, but it's missing a partition vector")
+                raise RuntimeError("normal_uncertain is a scaled variable, but it's missing a partition vector")
             #better have a partition vector that has as many partitions as stddev's size:
-            if len(self.stddev) != partition_npart(self.partititon):
-                error("normal_uncertain error message: stddev and partition should be vectors of identical size")
-            if len(self.mean) != partition_npart(self.partition):
-                error("normal_uncertain error message: mean and partition should be vectors of identical size")
+            if self.stddev.shape[0] != partition_npart(self.partititon):
+                raise RuntimeError("normal_uncertain error message: row size of stddev and partition size should be identical")
+            if self.mean.shape[0] != partition_npart(self.partition):
+                raise RuntimeError("normal_uncertain error message: row size of mean and partition size should be identical")
+            #we need as many steps in stddev and mean as there are in time steps
+            if self.stddev.shape[1] != self.nsteps:
+                raise RuntimeError("normal_uncertain error message: col size of stddev and partition size should be identical")
+            if self.mean.shape[1] != self.nsteps:
+                raise RuntimeError("normal_uncertain error message: col size of mean and partition size should be identical")
             md = checkfield(md, 'field', self.partition, 'fieldname', 'normal_uncertain.partition', 'NaN', 1, 'Inf', 1, '>=', -1, 'numel', [md.mesh.numberofvertices, md.mesh.numberofvertices])
             if self.partition.shape[1] > 1:
-                error("normal_uncertain error message: partition should be a column vector")
+                raise RuntimeError("normal_uncertain error message: partition should be a column vector")
             partcheck = np.unique(self.partition)
             partmin = min(partcheck)
             partmax = max(partcheck)
             if partmax < -1:
-                error("normal_uncertain error message: partition vector's min value should be -1 (for no partition), or start at 0")
+                raise RuntimeError("normal_uncertain error message: partition vector's min value should be -1 (for no partition), or start at 0")
             nmax = max(md.mesh.numberofelements, md.mesh.numberofvertices)
             if partmax > nmax:
-                error("normal_uncertain error message: partition vector's values cannot go over the number of vertices or elements")
+                raise RuntimeError("normal_uncertain error message: partition vector's values cannot go over the number of vertices or elements")
     #}}}
 

issm/trunk-jpl/src/m/partition/AreaAverageOntoPartition.py

@@ -1 +1 @@
 import numpy as np
+
+from adjacency import adjacency
 import copy
-from adjacency import adjacency
 from project2d import project2d
+from qmupart2npart import qmupart2npart
 
 
-def AreaAverageOntoPartition(md, vector, layer=None):
-    '''AREAAVERAGEONTOPARTITION
-   compute partition values for a certain vector expressed on the vertices of the mesh.
-   Use area weighted average.
+def AreaAverageOntoPartition(md, vector, layer=None, partition):
+    '''
+    AREAAVERAGEONTOPARTITION - compute partition values for a certain vector expressed on the vertices of the mesh.
+    Use area weighted average.
 
-   Usage:
-      average = AreaAverageOntoPartition(md, vector)
-      average = AreaAverageOntoPartition(md, vector, layer)  #if in 3D, chose which layer is partitioned
-'''
+    Usage:
+        average = AreaAverageOntoPartition(md, vector)
+        average = AreaAverageOntoPartition(md, vector, layer) # If in 3D, chose which layer is partitioned
+    '''
+
     #some checks
     if(md.mesh.dimension() == 3):
@@ -35 +38 @@
     #finally, project vector:
         vector = project2d(md3d, vector, layer)
-        md.qmu.vpartition = project2d(md3d, md3d.qmu.vpartition, layer)
+        partition = project2d(md3d, partition, layer)
 
     #ok, first check that part is Matlab indexed
-    part = (md.qmu.vpartition).copy()
+    part = partition.copy()
     part = part.flatten() + 1
 
     #some check:
-    if md.qmu.numberofpartitions != max(part):
-        raise RuntimeError('AreaAverageOntoPartition error message: ''npart'' should be equal to max(md.qmu.vpartition)')
+    npart = qmupart2npart(partition)
+    if npart != max(part):
+        raise RuntimeError('AreaAverageOntoPartition error message: ''npart'' should be equal to max(partition)')
 
     #initialize output

issm/trunk-jpl/src/m/qmu/preqmu.m

@@ -59 +59 @@
                         npart=partition_npart(fieldresponses(j).partition);
                         if str2int(fieldresponses(j).descriptor,'last')>npart,
-                                error('preqmu error message: one of the expanded responses has more values than the number of partitions (setup in md.qmu.numberofpartitions)');
+                                error('preqmu error message: one of the expanded responses has more values than the number of partitions');
                         end
                 end
@@ -91 +91 @@
 
 %build a MatArray of variable partitions: 
-variable_fieldnames=fieldnames(md.qmu.variables(ivar));
 variablepartitions={};
 variablepartitions_npart=[];
 variablepartitions_nt=[];
+variable_fieldnames=fieldnames(md.qmu.variables(ivar));
 for i=1:length(variable_fieldnames),
         field_name=variable_fieldnames{i};
@@ -110 +110 @@
 
 %build a MatArray of response partitions: 
-response_fieldnames=fieldnames(md.qmu.responses(ivar));
 responsepartitions={};
 responsepartitions_npart=[];
+response_fieldnames=fieldnames(md.qmu.responses(iresp));
 for i=1:length(response_fieldnames),
         field_name=response_fieldnames{i};
-        fieldresponse=md.qmu.responses(ivar).(field_name);
+        fieldresponse=md.qmu.responses(iresp).(field_name);
         if fieldresponse.isscaled();
                 responsepartitions{end+1}=fieldresponse.partition;

issm/trunk-jpl/src/m/qmu/preqmu.py

@@ -61 +61 @@
         for j in range(np.size(fieldvariables)):
             if strncmpi(fieldvariables[j].descriptor, 'scaled_', 7):
-                npart = partition_npart(fieldvariables[j].partition)
-                if str2int(fieldvariables[j].descriptor, 'last') > npart:
-                    raise RuntimeError('preqmu error message: one of the expanded variables has more values than the number of partitions (setup in md.qmu.numberofpartitions)')
+                npart = qmupart2npart(fieldvariables[j].partition)
+                nt = fieldvariables[j].nsteps
+                if nt == 1:
+                    if str2int(fieldvariables[j].descriptor, 'last') > npart:
+                        raise RuntimeError('preqmu error message: one of the expanded variables has more values than the number of partitions')
         numvariables = numvariables + np.size(vars(variables)[field_name])
 
@@ -74 +76 @@
             if strncmpi(fieldresponses[j].descriptor, 'scaled_', 7):
                 npart = partition_npart(fieldresponses[j].partition)
-                if str2int(fieldresponses[j].descriptor, 'last') > md.qmu.numberofpartitions:
-                    raise RuntimeError('preqmu error message: one of the expanded responses has more values than the number of partitions (setup in md.qmu.numberofpartitions)')
+                if str2int(fieldresponses[j].descriptor, 'last') > npart:
+                    raise RuntimeError('preqmu error message: one of the expanded responses has more values than the number of partitions')
         numresponses = numresponses + np.size(vars(responses)[field_name])
     #}}}
@@ -112 +114 @@
     #}}}
 
-    # Build a list of variable partitions
+    #build a list of variable partitions
     variablepartitions = []
     variablepartitions_npart = []
+    variablepartitions_nt = []
     variable_fieldnames = fieldnames(md.qmu.variables)
     for i in range(len(variable_fieldnames)):
@@ -124 +127 @@
                     variablepartitions.append(fieldvariable[j].partition)
                     variablepartitions_npart.append(qmupart2npart(fieldvariable[j].partition))
+                    variablepartitions_nt.append(fieldvariable.nsteps)
                 else:
                     variablepartitions.append([])
                     variablepartitions_npart.append(0)
+                    variablepartitions_nt.append(1)
         else:
             if fieldvariable.isscaled():
                 variablepartitions.append(fieldvariable.partition)
                 variablepartitions_npart.append(qmupart2npart(fieldvariable.partition))
+                variablepartitions_nt.append(fieldvariable.nsteps)
             else:
                 variablepartitions.append([])
                 variablepartitions_npart.append(0)
+                variablepartitions_nt.append(1)
 
-    # Build a list of response partitions
+    #build a list of response partitions
     responsepartitions = []
     responsepartitions_npart = []
@@ -146 +153 @@
                 if fieldresponse[j].isscaled():
                     responsepartitions.append(fieldresponse[j].partition)
-                    responsepartitions_npart.append(qmupart2npart(fieldresponse.partition))
+                    responsepartitions_npart.append(qmupart2npart(fieldresponse[j].partition))
                 else:
                     responsepartitions.append([])
@@ -163 +170 @@
     md.qmu.variablepartitions = variablepartitions
     md.qmu.variablepartitions_npart = variablepartitions_npart
+    md.qmu.variablepartitions_nt = variablepartitions_nt
     md.qmu.responsedescriptors = responsedescriptors
     md.qmu.responsepartitions = responsepartitions

issm/trunk-jpl/src/m/qmu/setupdesign/QmuSetupVariables.m

@@ -25 +25 @@
                 nmean=size(variables.mean,1);
                 if (nstddev ~= npart || nmean ~=npart),
-                        error('QmuSetupVariables error message: stddev and mean fields should be row sized as the number of partitions');
+                        error('QmuSetupVariables error message: stddev and mean fields should have the same number of rows as the number of partitions');
                 end
                 nstddev=size(variables.stddev,2);
                 nmean=size(variables.mean,2);
                 if (nstddev ~= nt || nmean ~=nt),
-                        error('QmuSetupVariables error message: stddev and mean fields should be col sized as the number of time steps');
+                        error('QmuSetupVariables error message: stddev and mean fields should have the same number of cols as the number of time steps');
                 end
 

issm/trunk-jpl/src/m/qmu/setupdesign/QmuSetupVariables.py

@@ -21 +21 @@
         partition = variables.partition
         #figure out number of partitions
-        npart=qmupart2npart(partition)
+        npart = qmupart2npart(partition)
+        #figure out number of time steps
+        nt = variables.nsteps
 
         if isinstance(variables, uniform_uncertain):
-            nlower=len(variables.lower)
-            nupper=len(variables.upper)
+            nlower = len(variables.lower)
+            nupper = len(variables.upper)
             if nlower != npart or nupper != npart:
                 raise RuntimeError('QmuSetupVariables error message: upper and lower fields should be same size as the number of partitions')
         elif isinstance(variables, normal_uncertain):
-            nstddev=len(variables.stddev)
-            nmean=len(variables.mean)
+            nstddev = variables.stddev.shape[0]
+            nmean = variables.mean.shape[0]
             if nstddev != npart or nmean != npart:
-                raise RuntimeError('QmuSetupVariables error message: stddev and mean fields should be same size as the number of partitions')
+                raise RuntimeError('QmuSetupVariables error message: stddev and mean fields should have the same number of rows as the number of partitions')
+            nstddev = variables.stddev.shape[1]
+            nmean = variables.mean.shape[1]
+            if nstddev != nt or nmean != nt:
+                raise RuntimeError('QmuSetupVariables error message: stddev and mean fields should have the same number of cols as the number of partitions')
 
         #ok, dealing with semi-discrete distributed variable. Distribute according to how many
-        #partitions we want
-        for j in range(npart):
-            dvar.append(deepcopy(variables))
+        #partitions we want, and number of time steps
+        if nt == 1:
+            for j in range(npart):
+                dvar.append(deepcopy(variables))
 
-            # text parsing in dakota requires literal "'identifier'" not just "identifier"
-            dvar[-1].descriptor = "'" + str(variables.descriptor) + '_' + str(j + 1) + "'"
+                # text parsing in dakota requires literal "'identifier'" not just "identifier"
+                dvar[-1].descriptor = "'" + str(variables.descriptor) + '_' + str(j + 1) + "'"
 
-            if isinstance(variables, uniform_uncertain):
-                dvar[-1].lower = variables.lower[j]
-                dvar[-1].upper = variables.upper[j]
-            elif isinstance(variables, normal_uncertain):
-                dvar[-1].stddev = variables.stddev[j]
-                dvar[-1].mean = variables.mean[j]
+                if isinstance(variables, uniform_uncertain):
+                    dvar[-1].lower = variables.lower[j]
+                    dvar[-1].upper = variables.upper[j]
+                elif isinstance(variables, normal_uncertain):
+                    dvar[-1].stddev = variables.stddev[j]
+                    dvar[-1].mean = variables.mean[j]
+        else:
+            for j in range(npart):
+                for k in range(nt):
+                    dvar.append(deepcopy(variables))
+
+                    # text parsing in dakota requires literal "'identifier'" not just "identifier"
+                    dvar[-1].descriptor = "'" + str(variables.descriptor) + '_' + str(j + 1) + '_' + str(k + 1) + "'"
+
+                    if isinstance(variables, uniform_uncertain):
+                        dvar[-1].lower = variables.lower[j][k]
+                        dvar[-1].upper = variables.upper[j][k]
+                    elif isinstance(variables, normal_uncertain):
+                        dvar[-1].stddev = variables.stddev[j][k]
+                        dvar[-1].mean = variables.mean[j][k]
     else:
         dvar.append(deepcopy(variables))

issm/trunk-jpl/test/NightlyRun/test412.py

@@ -19 +19 @@
 
 #partitioning
-md = partitioner(md, 'package', 'linear', 'npart', md.mesh.numberofvertices) - 1
+npart = md.mesh.numberofvertices
+partition = partitioner(md, 'package', 'linear', 'npart', npart) - 1
 md.qmu.isdakota = 1
 
@@ -36 +37 @@
 md.qmu.variables.drag_coefficient = normal_uncertain.normal_uncertain(
     'descriptor', 'scaled_FrictionCoefficient',
-    'mean', np.ones(md.mesh.numberofvertices),
-    'stddev', .01 * np.ones(md.mesh.numberofvertices),
+    'mean', np.ones(npart),
+    'stddev', .01 * np.ones(npart),
     'partition', partition
     )