Changeset 24988

Timestamp:

06/08/20 22:58:53 (5 years ago)

Author:

Eric.Larour

Message:

CHG: more integration of partition vectors into variables. Slowly stepping
away from the qmu.vpartition vector paradigm, not yet fully though.

Location:

issm/trunk-jpl/src

Files:

• c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp (modified) (9 diffs)
• c/modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp (modified) (4 diffs)
• m/classes/qmu.m (modified) (5 diffs)
• m/qmu/preqmu.m (modified) (1 diff)
• m/qmu/setupdesign/QmuSetupVariables.m (modified) (2 diffs)

issm/trunk-jpl/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

@@ -13 +13 @@
 
         int     i,j,k,l;
-        int     dummy;
 
         int     numberofvertices;
@@ -19 +18 @@
         int     nrows;
         int     ncols;
-        int     npart;
-        double *qmu_vpart  = NULL;
-        double *qmu_epart  = NULL;
+        IssmDouble **variable_partitions         = NULL;
+        IssmDouble * variable_partition         = NULL;
+        int          variable_partitions_num;
+        int         *partitions_m   = NULL;
+        int         *partitions_n   = NULL;
+        int          npart;
+        int          dummy; //should match numvariables
 
         double *distributed_values = NULL;
@@ -29 +32 @@
 
         /*retrieve parameters: */
-        femmodel->parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
-        femmodel->parameters->FindParam(&qmu_vpart,NULL,QmuVpartitionEnum);
-        femmodel->parameters->FindParam(&qmu_epart,NULL,QmuEpartitionEnum);
+        femmodel->parameters->FindParam(&variable_partitions,&variable_partitions_num,&partitions_m,&partitions_n,QmuVariablePartitionsEnum); 
+        
         numberofvertices=femmodel->vertices->NumberOfVertices();
         numberofelements=femmodel->elements->NumberOfElements();
@@ -44 +46 @@
                 /*From descriptor, figure out if the variable is scaled, indexed, nodal, or just a simple variable: */
                 if (strncmp(descriptor,"scaled_",7)==0){
+                
+                        /*recover partition vector: */
+                        variable_partition=variable_partitions[i];
+                        //_printf_("variable_partition_M: " << variable_partition_M << " variable_partition_N " << variable_partition_N << "\n");
+                        npart=partitions_m[i];
 
                         /*Variable is scaled. Determine root name of variable (ex: scaled_DragCoefficient_1 -> DragCoefficient). Allocate distributed_values and fill the 
@@ -57 +64 @@
                         }
 
+                        
                         /*Now, pick up the parameter corresponding to root: */
                         femmodel->parameters->FindParamInDataset(&parameter,&nrows,&ncols,QmuVariableDescriptorsEnum,StringToEnumx(root));
 
-
-                        /*We've got the parameter, we need to update it using qmu_vpart or qmu_epart (depending on whether 
-                         * it is element or vertex distributed), and the distributed_values. 
-                         In addition, the parameter can be either a static or transient (nrows+1) vector. */
+                        /*We've got the parameter, we need to update it using the partition vector, and the distributed_values. 
+                         In addition, the parameter can be either a static or transient (nrows+1) vector. Finally, the partition vectors can include
+                         -1 (meaning, don't update). */
                         
                         //_printf_("nrows: " << nrows << " numberofvertices: " << numberofvertices << " numberofelements: " << numberofelements << "\n");
@@ -69 +76 @@
                         if (nrows==numberofvertices || nrows==(numberofvertices+1)){
                                 for(k=0;k<numberofvertices;k++){
-                                        for(l=0;l<ncols;l++){
-                                                *(parameter+ncols*k+l)=*(parameter+ncols*k+l)*distributed_values[(int)qmu_vpart[k]];
+                                        if (variable_partition[k]==-1)continue;
+                                        else{
+                                                for(l=0;l<ncols;l++){
+                                                        *(parameter+ncols*k+l)=*(parameter+ncols*k+l)*distributed_values[(int)variable_partition[k]];
+                                                }
                                         }
                                 }
@@ -76 +86 @@
                         else if (nrows==numberofelements || nrows==(numberofelements+1)){
                                 for(k=0;k<numberofelements;k++){
-                                        for(l=0;l<ncols;l++){
-                                                *(parameter+ncols*k+l)=*(parameter+ncols*k+l)*distributed_values[(int)qmu_epart[k]];
+                                        if (variable_partition[k]==-1)continue;
+                                        else{
+                                                for(l=0;l<ncols;l++){
+                                                        *(parameter+ncols*k+l)=*(parameter+ncols*k+l)*distributed_values[(int)variable_partition[k]];
+                                                }
                                         }
                                 }
@@ -108 +121 @@
                         /*increment i to skip the distributed values just collected: */
                         i+=npart-1; //careful, the for loop will add 1.
-
+                        
                         /*Free allocations: */
                         xDelete<double>(parameter);
@@ -126 +139 @@
 
         /*Free ressources:*/
-        xDelete<double>(qmu_vpart);
-        xDelete<double>(qmu_epart);
+        for(i=0;i<variable_partitions_num;i++){
+                IssmDouble* matrix=variable_partitions[i];
+                xDelete<IssmDouble>(matrix);
+        }
+        xDelete<int>(partitions_m);
+        xDelete<int>(partitions_n);
+        xDelete<IssmDouble*>(variable_partitions);
+
 }

issm/trunk-jpl/src/c/modules/ModelProcessorx/Dakota/CreateParametersDakota.cpp

@@ -13 +13 @@
         /*variable declarations*/
         int          i;
-        double      *vpart                  = NULL;
-        double      *epart                  = NULL;
-        int          npart;
         char       **responsedescriptors    = NULL;
         int          numresponsedescriptors;
@@ -35 +32 @@
         int   numberofresponses;
         int   nrows,ncols;
+
+        //variable partitions: 
+        IssmDouble **array                      = NULL;
+        int         *mdims_array                = NULL;
+        int         *ndims_array                = NULL;
+        int          num_partitions;
 
         /*recover parameters: */
@@ -70 +73 @@
                 /*Load partitioning vectors (both vertex and element based: */
                 parameters->AddObject(iomodel->CopyConstantObject("md.qmu.numberofpartitions",QmuNumberofpartitionsEnum));
-                iomodel->FetchData(&vpart,&npart,NULL,"md.qmu.vpartition"); if(!vpart) _error_("md.qmu.vpartition is empty");
-                parameters->AddObject(new DoubleVecParam(QmuVpartitionEnum,vpart,npart));
                 
-                iomodel->FetchData(&epart,&npart,NULL,"md.qmu.epartition"); if(!epart) _error_("md.qmu.epartition is empty");
-                parameters->AddObject(new DoubleVecParam(QmuEpartitionEnum,epart,npart));
+                /*Load partitioning vectors specific to variables:*/
+                iomodel->FetchData(&array,&mdims_array,&ndims_array,&num_partitions,"md.qmu.variablepartitions");
+                parameters->AddObject(new DoubleMatArrayParam(QmuVariablePartitionsEnum,array,num_partitions,mdims_array,ndims_array));
+
 
                 /*Deal with data needed because of qmu variables*/
@@ -114 +117 @@
                 }
                 xDelete<char*>(variabledescriptors);
-                xDelete<double>(vpart);
-                xDelete<double>(epart);
                 xDelete<char>(qmuinname);
                 xDelete<char>(qmuerrname);
                 xDelete<char>(qmuoutname);
+
+                for(i=0;i<num_partitions;i++){
+                        IssmDouble* matrix=array[i];
+                        xDelete<IssmDouble>(matrix);
+                }
+                xDelete<int>(mdims_array); 
+                xDelete<int>(ndims_array);
+                xDelete<IssmDouble*>(array);
+
         }
 

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

@@ -18 +18 @@
                 numberofresponses           = 0;
                 variabledescriptors         = {};
+                variablepartitions          = {};
                 responsedescriptors         = {};
                 mass_flux_profile_directory = NaN;
@@ -57 +58 @@
         methods
                 function self = extrude(self,md) % {{{
-                        self.vpartition=project3d(md,'vector',self.vpartition','type','node');
-                        self.epartition=project3d(md,'vector',self.epartition','type','element');
                 end % }}}
                 function self = qmu(varargin) % {{{
@@ -97 +96 @@
                                 end
                         end
-                        if ~isempty(md.qmu.vpartition) & ~any(isnan(md.qmu.vpartition)),
-                                if size(md.qmu.vpartition,1)~=md.mesh.numberofvertices
-                                        md = checkmessage(md,['user supplied vertex partition for qmu analysis should have size md.mesh.numberofvertices x 1']);
-                                end
-                                if min(md.qmu.vpartition)~=0,
-                                        md = checkmessage(md,['vertex partition vector not indexed from 0 on']);
-                                end
-                                if max(md.qmu.vpartition)>=md.qmu.numberofpartitions,
-                                        md = checkmessage(md,['for qmu analysis, vertex partitioning vector cannot go over npart, number of partition areas']);
-                                end
-                        end
-                        if ~isempty(md.qmu.epartition) & ~any(isnan(md.qmu.epartition)),
-                                if size(md.qmu.epartition,1)~=md.mesh.numberofelements,
-                                        md = checkmessage(md,['user supplied element partition for qmu analysis should have size md.mesh.numberofelements x 1']);
-                                end
-                                if min(md.qmu.epartition)~=0,
-                                        md = checkmessage(md,['element partition vector not indexed from 0 on']);
-                                end
-                                if max(md.qmu.epartition)>=md.qmu.numberofpartitions,
-                                        md = checkmessage(md,['for qmu analysis, element partitioning vector cannot go over npart, number of partition areas']);
-                                end
-                        end
-                        if isempty(md.qmu.vpartition) | any(isnan(md.qmu.vpartition)) | isempty(md.qmu.epartition) | any(isnan(md.qmu.epartition)),
-                                md = checkmessage(md,['for qmu analysis, both an element and partitioning vectors need to be supplied with no nan values! One can be defaulted to all zeros.']);
-                        end
 
                         %go through variables and check for consistency: 
@@ -198 +172 @@
                                 end
                         end
-                        fielddisplay(self,'vpartition','user provided mesh partitioning (vertex based)');
-                        fielddisplay(self,'epartition','user provided mesh partitioning (element based)');
-                        fielddisplay(self,'numberofpartitions','number of partitions for semi-discrete qmu')
+                        fielddisplay(self,'variablepartitions','');
                         fielddisplay(self,'variabledescriptors','');
                         fielddisplay(self,'responsedescriptors','');
@@ -223 +195 @@
                         WriteData(fid,prefix,'object',self,'fieldname','numberofresponses','format','Integer');
                         WriteData(fid,prefix,'object',self,'fieldname','variabledescriptors','format','StringArray');
+                        WriteData(fid,prefix,'object',self,'fieldname','variablepartitions','format','MatArray');
                         WriteData(fid,prefix,'object',self,'fieldname','responsedescriptors','format','StringArray');
                         if ~isempty(self.mass_flux_segments),

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

@@ -87 +87 @@
 end
 
+%build a MatArray of variable partitions: 
+variable_fieldnames=fieldnames(md.qmu.variables(ivar));
+variablepartitions={};
+for i=1:length(variable_fieldnames),
+        field_name=variable_fieldnames{i};
+        fieldvariable=md.qmu.variables(ivar).(field_name);
+        if fieldvariable.isscaled();
+                variablepartitions{end+1}=fieldvariable.partition;
+        else
+                variablepartitions{end+1}=[];
+        end
+end
+
+
 %register the fields that will be needed by the Qmu model.
 md.qmu.numberofresponses=numresponses;
 md.qmu.variabledescriptors=variabledescriptors;
+md.qmu.variablepartitions=variablepartitions;
 md.qmu.responsedescriptors=responsedescriptors;
 

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

@@ -9 +9 @@
 %ok, key off according to type of descriptor:
 if strncmp(descriptor,'scaled_',7),
-        %we have a scaled variable, expand it over the partition.
+        %we have a scaled variable, expand it over the partition. First recover the partition: 
+        partition=variables.partition;
+        %figure out number of partitions: 
+        npart=qmupart2npart(partition)
 
         if isa(variables,'uniform_uncertain'),
-                if (length(variables.lower)>md.qmu.numberofpartitions || length(variables.upper)>md.qmu.numberofpartitions)
-                        error('QmuSetupDesign error message: stddev should be either a scalar or a ''npart'' length vector');
+                nlower=length(variables.lower); nupper=length(variables.upper);
+                if (nlower ~= npart || nupper ~=npart),
+                        error('QmuSetupVariables error message: upper and lower fields should be same size as the number of partitions');
                 end
         elseif isa(variables,'normal_uncertain'),
-                if length(variables.stddev)>md.qmu.numberofpartitions,
-                        error('QmuSetupDesign error message: stddev should be either a scalar or a ''npart'' length vector');
+                nstddev=length(variables.stddev);
+                nmean=length(variables.mean);
+                if (nstddev ~= npart || nmean ~=npart),
+                        error('QmuSetupVariables error message: stddev and mean fields should be same size as the number of partitions');
                 end
         end
@@ -23 +29 @@
         %ok, dealing with semi-discrete distributed variable. Distribute according to how many 
         %partitions we want
-        for j=1:md.qmu.numberofpartitions
+        for j=1:npart,
                 dvar(end+1)           =variables;
                 dvar(end  ).descriptor=sprintf('%s_%d',variables.descriptor,j);
                 if isa(variables,'uniform_uncertain'),
-                        if length(variables.lower)>1,
-                                dvar(end  ).lower=variables.lower(j);
-                        end
-                        if length(variables.upper)>1,
-                                dvar(end  ).upper=variables.upper(j);
-                        end
+                        dvar(end  ).lower=variables.lower(j);
+                        dvar(end  ).upper=variables.upper(j);
                 elseif isa(variables,'normal_uncertain'),
-                        if length(variables.stddev)>1,
-                                dvar(end  ).stddev=variables.stddev(j);
-                        end
-                        if length(variables.mean)>1,
-                                dvar(end  ).mean=variables.mean(j);
-                        end
-
+                        dvar(end  ).stddev=variables.stddev(j);
+                        dvar(end  ).mean=variables.mean(j);
                 end
         end