Changeset 25256 for issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

Timestamp:

07/10/20 17:03:33 (5 years ago)

Author:

Eric.Larour

Message:

CHG: new dakota input scaling capability.

File:

• issm/trunk-jpl/src/c/classes/Elements/Penta.cpp (modified) (1 diff)

issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

@@ -4707 +4707 @@
 
 #ifdef _HAVE_DAKOTA_
+void       Penta::InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name){/*{{{*/
+
+        int interp;
+        int type;
+        
+        /*Branch according to whether we have a transient or not input: */
+        type=this->inputs2->GetInputObjectEnum(name);
+        if(type==PentaInput2Enum){
+                /*Figure out if we are P0 or P1 interpolation: */
+                PentaInput2* pentainput = this->inputs2->GetPentaInput(name);
+                PentaInput2* pentainput2 = this->inputs2->GetPentaInput(DummyEnum);
+                interp=pentainput->GetInterpolation();
+                
+                if (interp==P0Enum){
+                        /*Update the value if this element belongs to the partition: */
+                        if(partition[this->Sid()]!=-1){
+                                int lid=this->lid; pentainput->Serve(1,&lid);
+                                /*scale P0 value  for this element, corresponding to the partition:*/
+                                IssmDouble value = pentainput->element_values[0];
+                                value*=distributed_values[(int)partition[this->Sid()]];
+                                pentainput2->SetInput(P0Enum,this->lid,value);
+                        }
+                }
+                else if (interp==P1Enum){
+                        IssmDouble values[NUMVERTICES];
+                        int lidlist[NUMVERTICES];
+                        this->GetVerticesLidList(&lidlist[0]);
+                        pentainput->Serve(NUMVERTICES,&lidlist[0]);
+                        for (int i=0;i<NUMVERTICES;i++){
+                                values[i]=pentainput->element_values[i];
+                                if(partition[this->vertices[i]->Sid()]!=-1) values[i]*=distributed_values[(int)partition[this->vertices[i]->Sid()]];
+                        }
+                        pentainput2->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
+                }
+                else _error_("Penta::InputScaleFromDakota error message: input interpolation " << EnumToStringx(interp) << " not supported yet!");
+        }
+        else if(type==TransientInput2Enum){
+
+
+                IssmDouble* steps=NULL;
+                int nsteps;
+                TransientInput2* transientinput = NULL;
+                TransientInput2* transientinput2 = NULL;
+
+                /*retrieve transient input:*/
+                transientinput= this->inputs2->GetTransientInput(name);
+                transientinput2= this->inputs2->GetTransientInput(DummyEnum);
+
+                /*retrieve time steps: */
+                transientinput->GetAllTimes(&steps,&nsteps);
+
+                /*double check:*/
+                if (nsteps!=nt && nt!=1) _error_("Penta:InputScaleFromDakota error message: transient input " << EnumToStringx(name) <<  
+                                " should have the same number of time steps as the number of time values distributed by Dakota: " << nt << "\n");
+
+                /*needed to update inputs:*/
+                int lidlist[NUMVERTICES];
+                this->GetVerticesLidList(&lidlist[0]);
+
+                /*go through the transient inputs, and update:*/
+                for (int i=0;i<nsteps;i++){
+                        PentaInput2* pentainput=transientinput->GetPentaInput(i);
+                        PentaInput2* pentainput2=transientinput2->GetPentaInput(i);
+                        interp=pentainput->GetInterpolation();
+
+                        if (interp==P0Enum){
+                                /*Update the value if this element belongs to the partition: */
+                                if(partition[this->Sid()]!=-1){
+                                        int lid=this->lid; pentainput->Serve(1,&lid);
+                                        /*scale P0 value  for this element, corresponding to the partition:*/
+                                        IssmDouble value = pentainput->element_values[0];
+                                        if(nt==1) value*=distributed_values[(int)partition[this->Sid()]]; //we scale all the time steps  with the same distributed_value 
+                                        else value*=distributed_values[(int)partition[this->Sid()]*nsteps+i]; //we scale all the time steps with distributed value for each step
+
+                                        pentainput2->SetInput(P0Enum,this->lid,value);
+                                }
+                        }
+                        else if (interp==P1Enum){
+                                IssmDouble values[NUMVERTICES];
+                                pentainput->Serve(NUMVERTICES,&lidlist[0]);
+                                for (int j=0;j<NUMVERTICES;j++){
+                                        values[j]=pentainput->element_values[j];
+                                        if(partition[this->vertices[i]->Sid()]!=-1){
+                                                if(nt==1) values[j]*=distributed_values[(int)partition[this->vertices[j]->Sid()]];//we scale all the time steps  with the same distributed_value 
+                                                else values[j]*=distributed_values[(int)partition[this->vertices[j]->Sid()]*nsteps+i];//we scale all the time steps with distributed value for each step
+                                        }
+                                }
+                                pentainput2->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
+                        }
+                        else _error_("Penta::InputScaleFromDakota error message: input interpolation " << EnumToStringx(interp) << " not supported yet!");
+                }
+        }
+        else _error_("Penta::InputScaleFromDakota error message: input type " << EnumToStringx(name) << " not supported yet!");
+}
+/*}}}*/
 void       Penta::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/