Changeset 25412


Ignore:
Timestamp:
08/16/20 20:50:42 (5 years ago)
Author:
Mathieu Morlighem
Message:

CHG: starting working on P1 transient inputs

Location:
issm/trunk-jpl/src/c/classes/Elements
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/Elements/Element.cpp

    r25406 r25412  
    17501750        IssmDouble  value,value_min,value_max;
    17511751
    1752         int        *vertexids   = xNew<int>(numvertices);
    1753         IssmDouble *values      = xNew<IssmDouble>(numvertices);
    1754         IssmDouble *values_min  = xNew<IssmDouble>(numvertices);
    1755         IssmDouble *values_max  = xNew<IssmDouble>(numvertices);
     1752        int         vertexids[MAXVERTICES];
     1753        int         vertexlids[MAXVERTICES];
     1754        IssmDouble  values[MAXVERTICES];
     1755        IssmDouble  values_min[MAXVERTICES];
     1756        IssmDouble  values_max[MAXVERTICES];
    17561757
    17571758        /*Some sanity checks*/
    … …  
    17641765        for(int i=0;i<numvertices;i++){
    17651766                vertexids[i]=reCast<int>(iomodel->elements[numvertices*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
     1767                vertexlids[i]=iomodel->my_vertices_lids[vertexids[i]-1];
    17661768        }
    17671769
    … …  
    17731775                        values_max[i] = scale*max_vector[vertexids[i]-1];
    17741776                }
    1775                 this->AddControlInput(input_enum,inputs,iomodel,values,values_min,values_max,P1Enum,id);
     1777                this->AddControlInput(input_enum,inputs,iomodel,&values[0],&values_min[0],&values_max[0],P1Enum,id);
    17761778        }
    17771779        else if(M==iomodel->numberofelements && N==1){
    … …  
    17791781                values_min[0] = scale*min_vector[this->Sid()];
    17801782                values_max[0] = scale*max_vector[this->Sid()];
    1781                 this->AddControlInput(input_enum,inputs,iomodel,values,values_min,values_max,P0Enum,id);
     1783                this->AddControlInput(input_enum,inputs,iomodel,&values[0],&values_min[0],&values_max[0],P0Enum,id);
    17821784        }
    17831785        else if(M==iomodel->numberofelements+1 && N>1){
    … …  
    18131815        }
    18141816        else if(M==iomodel->numberofvertices+1 && N>1){
    1815                 _error_("not supported tet");
    1816                 ///*create transient input: */
    1817                 //IssmDouble* times = xNew<IssmDouble>(N);
    1818                 //for(int t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
    1819                 ///*Create the three transient inputs for the control input*/
    1820                 //TransientInput* values_input=new TransientInput(input_enum,times,N);
    1821                 //TransientInput* mins_input = new TransientInput(ControlInputMinsEnum,times,N);
    1822                 //TransientInput* maxs_input = new TransientInput(ControlInputMaxsEnum,times,N);
    1823                 //TransientInput* grad_input = new TransientInput(ControlInputGradEnum);
    1824                 //for(int t=0;t<N;t++){
    1825                 //      for(int i=0;i<numvertices;i++){
    1826                 //              values[i]=vector[N*(vertexids[i]-1)+t];
    1827                 //              values_min[i] = min_vector[N*(vertexids[i]-1)+t];
    1828                 //              values_max[i] = max_vector[N*(vertexids[i]-1)+t];
    1829                 //      }
    1830                 //      switch(this->ObjectEnum()){
    1831                 //              case TriaEnum:
    1832                 //                      values_input->AddTimeInput(new TriaInput(input_enum,values,P1Enum));
    1833                 //                      mins_input->AddTimeInput(new TriaInput(ControlInputMinsEnum,values_min,P1Enum));
    1834                 //                      maxs_input->AddTimeInput(new TriaInput(ControlInputMaxsEnum,values_max,P1Enum));
    1835                 //                      break;
    1836                 //              case PentaEnum:
    1837                 //                      values_input->AddTimeInput(new PentaInput(input_enum,values,P1Enum));
    1838                 //                      mins_input->AddTimeInput(new PentaInput(ControlInputMinsEnum,values_min,P1Enum));
    1839                 //                      maxs_input->AddTimeInput(new PentaInput(ControlInputMaxsEnum,values_max,P1Enum));
    1840                 //                      break;
    1841                 //              case TetraEnum:
    1842                 //                      values_input->AddTimeInput(new TetraInput(input_enum,values,P1Enum));
    1843                 //                      mins_input->AddTimeInput(new TetraInput(ControlInputMinsEnum,values_min,P1Enum));
    1844                 //                      maxs_input->AddTimeInput(new TetraInput(ControlInputMaxsEnum,values_max,P1Enum));
    1845                 //                      break;
    1846                 //              default: _error_("Not implemented yet");
    1847                 //      }
    1848                 //}
    1849                 //this->inputs->AddInput(new ControlInput(input_enum,TransientInputEnum,values_input,mins_input,maxs_input,grad_input,P1Enum,id));
    1850                 //xDelete<IssmDouble>(times);
     1817
     1818                /*create transient input: */
     1819                IssmDouble* times = xNew<IssmDouble>(N);
     1820                for(int t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
     1821                inputs->SetTransientControlInput(input_enum,id,times,N);
     1822
     1823                /*Get input*/
     1824                ControlInput* control_input = inputs->GetControlInput(input_enum); _assert_(control_input);
     1825                TransientInput* transientinput_val = control_input->GetTransientInput("value");
     1826                TransientInput* transientinput_min = control_input->GetTransientInput("lowerbound");
     1827                TransientInput* transientinput_max = control_input->GetTransientInput("upperbound");
     1828                for(int t=0;t<N;t++){
     1829                        for(int i=0;i<numvertices;i++){
     1830                                values[i]     = vector[N*(vertexids[i]-1)+t];
     1831                                values_min[i] = scale*min_vector[N*(vertexids[i]-1)+t];
     1832                                values_max[i] = scale*max_vector[N*(vertexids[i]-1)+t];
     1833                        }
     1834                        switch(this->ObjectEnum()){
     1835                                case TriaEnum:
     1836                                        transientinput_val->AddTriaTimeInput( t,numvertices,vertexlids,&values[0],P1Enum);
     1837                                        transientinput_min->AddTriaTimeInput( t,numvertices,vertexlids,&values_min[0],P1Enum);
     1838                                        transientinput_max->AddTriaTimeInput( t,numvertices,vertexlids,&values_max[0],P1Enum);
     1839                                        break;
     1840                                case PentaEnum:
     1841                                        //transientinput->AddPentaTimeInput(t,1,&(this->lid),&value,P0Enum);
     1842                                        _error_("to be implemented");
     1843                                        break;
     1844                                default: _error_("Not implemented yet");
     1845                        }
     1846                }
     1847                xDelete<IssmDouble>(times);
    18511848        }
    18521849        else _error_("not currently supported type of M and N attempted");
    1853 
    1854         /*clean up*/
    1855         xDelete<IssmDouble>(values);
    1856         xDelete<IssmDouble>(values_min);
    1857         xDelete<IssmDouble>(values_max);
    1858         xDelete<int>(vertexids);
    1859 }
    1860 /*}}}*/
     1850}/*}}}*/
    18611851void       Element::DatasetInputAdd(int enum_type,IssmDouble* vector,Inputs* inputs,IoModel* iomodel,int M,int N,int vector_type,int input_enum,int code,int input_id){/*{{{*/
    18621852        /*enum_type: the name of the DatasetInput (eg Outputdefinition1)

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

    r25408 r25412  
    11361136        else if(control_input->layout_enum==TransientInputEnum){
    11371137                _assert_(N>1);
     1138
     1139                int* interp = NULL;
     1140                parameters->FindParam(&interp,NULL,ControlInputInterpolationEnum);
     1141
    11381142                TransientInput* gradient_input = control_input->GetTransientInput("gradient"); _assert_(gradient_input);
    11391143
    11401144                for(int n=0;n<N;n++){
    1141                         TriaInput* input_n = gradient_input->GetTriaInput(n); _assert_(input_n);
    1142                         if(input_n->GetInputInterpolationType()==P1Enum){
     1145                        if(interp[control_index]==P1Enum){
    11431146                                _error_("not implemented");
    11441147                        }
    1145                         else if(input_n->GetInputInterpolationType()==P0Enum){
    1146                                 input_n->SetInput(P0Enum,this->lid,gradient[idlist[n]]);
     1148                        else if(interp[control_index]==P0Enum){
     1149                                gradient_input->AddTriaTimeInput(n,1,&(this->lid),&gradient[idlist[n]],P0Enum);
    11471150                        }
    11481151                        else{
    … …  
    11501153                        }
    11511154                }
     1155                xDelete<int>(interp);
    11521156        }
    11531157        else _error_("Type not supported");
    … …  
    24702474                        TriaInput* input_n = input->GetTriaInput(n); _assert_(input_n);
    24712475                        if(input_n->GetInputInterpolationType()==P1Enum){
    2472                                 _error_("not implemented");
     2476                                IssmDouble values[NUMVERTICES];
     2477                                input_n->Serve(NUMVERTICES,&lidlist[0]);
     2478                                for(int i=0;i<NUMVERTICES;i++) values[count+i] = input_n->element_values[i];
     2479                                count=count+NUMVERTICES;
    24732480                        }
    24742481                        else if(input_n->GetInputInterpolationType()==P0Enum){
    24752482                                input_n->Serve(1,&this->lid);
    24762483                                values[n] = input_n->element_values[0];
    2477                                 count++;
    24782484                        }
    24792485                        else{
    … …  
    39643970                        TriaInput* input_n = input->GetTriaInput(n); _assert_(input_n);
    39653971                        if(input_n->GetInputInterpolationType()==P1Enum){
    3966                                 _error_("not implemented");
     3972                                for(int i=0;i<NUMVERTICES;i++) values[i] = vector[idlist[i]];
     3973                                input_n->SetInput(P1Enum,NUMVERTICES,&lidlist[0],&values[0]);
    39673974                        }
    39683975                        else if(input_n->GetInputInterpolationType()==P0Enum){
Note: See TracChangeset for help on using the changeset viewer.