Changeset 25256

Timestamp:

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

Author:

Eric.Larour

Message:

CHG: new dakota input scaling capability.

Location:

issm/trunk-jpl/src/c/classes/Elements

Files:

• Element.h (modified) (1 diff)
• Penta.cpp (modified) (1 diff)
• Penta.h (modified) (1 diff)
• Seg.h (modified) (1 diff)
• Tetra.h (modified) (1 diff)
• Tria.cpp (modified) (1 diff)
• Tria.h (modified) (1 diff)

issm/trunk-jpl/src/c/classes/Elements/Element.h ¶

@@ -280 +280 @@
                 virtual void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int rows, int ncols, int name, int type)=0;
                 virtual void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type)=0;
+                virtual void  InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name)=0;
                 #endif
                 virtual void  InputUpdateFromIoModel(int index, IoModel* iomodel)=0;

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){/*{{{*/
 

issm/trunk-jpl/src/c/classes/Elements/Penta.h ¶

@@ -200 +200 @@
 
                 #ifdef _HAVE_DAKOTA_
-                void           InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type);
-                void           InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
+                void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type);
+                void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
+                void  InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name);
+
                 #endif
 

issm/trunk-jpl/src/c/classes/Elements/Seg.h ¶

@@ -182 +182 @@
 
 #ifdef _HAVE_DAKOTA_
-                void        InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type){_error_("not implemented yet");};
-                void        InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("not implemented yet");};
+                void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type){_error_("not implemented yet");};
+                void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("not implemented yet");};
+                void  InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name){_error_("not implemented yet!");}
+;
 #endif
                 /*}}}*/

issm/trunk-jpl/src/c/classes/Elements/Tetra.h ¶

@@ -188 +188 @@
 
 #ifdef _HAVE_DAKOTA_
-                void        InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("not implemented yet");};
-                void        InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type){_error_("not implemented yet");};
+                void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type){_error_("not implemented yet");};
+                void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type){_error_("not implemented yet");};
+                void  InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name){_error_("not implemented yet!");}
 #endif
                 /*}}}*/

issm/trunk-jpl/src/c/classes/Elements/Tria.cpp ¶

@@ -6021 +6021 @@
 
 #ifdef _HAVE_DAKOTA_
+void       Tria::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==TriaInput2Enum){
+                /*Figure out if we are P0 or P1 interpolation: */
+                TriaInput2* triainput = this->inputs2->GetTriaInput(name);
+                TriaInput2* triainput2 = this->inputs2->GetTriaInput(DummyEnum);
+                this->InputServe(triainput);
+                interp=triainput->GetInterpolation();
+                
+                if (interp==P0Enum){
+                        /*Update the value if this element belongs to the partition: */
+                        if(partition[this->Sid()]!=-1){
+                                /*scale P0 value  for this element, corresponding to the partition:*/
+                                IssmDouble value = triainput->element_values[0];
+                                value*=distributed_values[(int)partition[this->Sid()]];
+                                triainput2->SetInput(P0Enum,this->lid,value);
+                        }
+                }
+                else if (interp==P1Enum){
+                        IssmDouble values[NUMVERTICES];
+                        int lidlist[NUMVERTICES];
+                        this->GetVerticesLidList(&lidlist[0]);
+                        for (int i=0;i<NUMVERTICES;i++){
+                                values[i]=triainput->element_values[i];
+                                if(partition[this->vertices[i]->Sid()]!=-1) values[i]*=distributed_values[(int)partition[this->vertices[i]->Sid()]];
+                        }
+                        triainput2->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
+                }
+                else _error_("Tria::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_("Tria: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++){
+                        TriaInput2* triainput=transientinput->GetTriaInput(i);
+                        TriaInput2* triainput2=transientinput2->GetTriaInput(i);
+                        this->InputServe(triainput);
+                        interp=triainput->GetInterpolation();
+
+                        if (interp==P0Enum){
+                                /*Update the value if this element belongs to the partition: */
+                                if(partition[this->Sid()]!=-1){
+                                        /*scale P0 value  for this element, corresponding to the partition:*/
+                                        IssmDouble value = triainput->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
+
+                                        triainput2->SetInput(P0Enum,this->lid,value);
+                                }
+                        }
+                        else if (interp==P1Enum){
+                                IssmDouble values[NUMVERTICES];
+                                for (int j=0;j<NUMVERTICES;j++){
+                                        values[j]=triainput->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
+                                        }
+                                }
+                                triainput2->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
+                        }
+                        else _error_("Tria::InputScaleFromDakota error message: input interpolation " << EnumToStringx(interp) << " not supported yet!");
+                }
+        }
+        else _error_("Tria::InputScaleFromDakota error message: input type " << EnumToStringx(name) << " not supported yet!");
+}
+/*}}}*/
 void       Tria::InputUpdateFromMatrixDakota(IssmDouble* matrix, int nrows, int ncols, int name, int type){/*{{{*/
 

issm/trunk-jpl/src/c/classes/Elements/Tria.h ¶

@@ -46 +46 @@
                 void  InputUpdateFromMatrixDakota(IssmDouble* matrix, int nows, int ncols, int name, int type);
                 void  InputUpdateFromVectorDakota(IssmDouble* vector, int name, int type);
+                void  InputScaleFromDakota(IssmDouble* distributed_values, IssmDouble* partition, int npart, int nt, int name);
                 #endif
                 void  InputUpdateFromIoModel(int index, IoModel* iomodel);