Changeset 16461


Ignore:
Timestamp:
10/18/13 15:54:53 (11 years ago)
Author:
Mathieu Morlighem
Message:

NEW: new output API for stressbalance. No call to InputToResults, Results are directly put into femmodel->results as parallel vectors

Location:
issm/trunk-jpl/src/c
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/stressbalance_core.cpp

    r16382 r16461  
    8888        if(save_results){
    8989                if(VerboseSolution()) _printf0_("   saving results\n");
    90                 InputToResultx(femmodel,VxEnum);
    91                 InputToResultx(femmodel,VyEnum);
    92                 InputToResultx(femmodel,VelEnum);
    93                 InputToResultx(femmodel,PressureEnum);
    94                 if(meshtype==Mesh3DEnum) InputToResultx(femmodel,VzEnum);
    95                 femmodel->RequestedOutputsx(requested_outputs,numoutputs);
     90                femmodel->RequestedOutputsx(&femmodel->results,requested_outputs,numoutputs);
    9691        }
    9792

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

    r16442 r16461  
    6363                virtual void   PatchFill(int* pcount, Patch* patch)=0;
    6464                virtual void   ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results)=0;
     65                virtual void   ResultInterpolation(int* pinterpolation,int output_enum)=0;
     66                virtual void   ResultToVector(Vector<IssmPDouble>* vector,int output_enum)=0;
    6567                virtual void   DeleteResults(void)=0;
    6668                virtual void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;

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

    r16102 r16461  
    302302
    303303        local_nelem=this->Size();
    304         ISSM_MPI_Allreduce ( (void*)&local_nelem,(void*)&numberofelements,1,ISSM_MPI_INT,ISSM_MPI_SUM,IssmComm::GetComm());
     304        ISSM_MPI_Allreduce((void*)&local_nelem,(void*)&numberofelements,1,ISSM_MPI_INT,ISSM_MPI_SUM,IssmComm::GetComm());
    305305
    306306        return numberofelements;

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

    r16433 r16461  
    30323032                }
    30333033        }
     3034
     3035}
     3036/*}}}*/
     3037/*FUNCTION Penta::ResultInterpolation{{{*/
     3038void Penta::ResultInterpolation(int* pinterpolation,int output_enum){
     3039
     3040        Input* input=this->inputs->GetInput(output_enum);
     3041
     3042        /*If this input is not already in Inputs, maybe it needs to be computed?*/
     3043        if(!input){
     3044                switch(output_enum){
     3045                        case ViscousHeatingEnum:
     3046                                this->ViscousHeatingCreateInput();
     3047                                input=this->inputs->GetInput(output_enum);
     3048                                break;
     3049                        case StressTensorxxEnum:
     3050                                this->ComputeStressTensor();
     3051                                input=this->inputs->GetInput(output_enum);
     3052                                break;
     3053                        case StressTensorxyEnum:
     3054                                this->ComputeStressTensor();
     3055                                input=this->inputs->GetInput(output_enum);
     3056                                break;
     3057                        case StressTensorxzEnum:
     3058                                this->ComputeStressTensor();
     3059                                input=this->inputs->GetInput(output_enum);
     3060                                break;
     3061                        case StressTensoryyEnum:
     3062                                this->ComputeStressTensor();
     3063                                input=this->inputs->GetInput(output_enum);
     3064                                break;
     3065                        case StressTensoryzEnum:
     3066                                this->ComputeStressTensor();
     3067                                input=this->inputs->GetInput(output_enum);
     3068                                break;
     3069                        case StressTensorzzEnum:
     3070                                this->ComputeStressTensor();
     3071                                input=this->inputs->GetInput(output_enum);
     3072                                break;
     3073                        default:
     3074                                _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     3075                }
     3076        }
     3077
     3078        /*Assign output pointer*/
     3079        *pinterpolation = input->GetResultInterpolation();
     3080
     3081}
     3082/*}}}*/
     3083/*FUNCTION Penta::ResultToVector{{{*/
     3084void Penta::ResultToVector(Vector<IssmPDouble>* vector,int output_enum){
     3085
     3086        Input* input=this->inputs->GetInput(output_enum);
     3087        if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     3088
     3089        switch(input->GetResultInterpolation()){
     3090                case P0Enum:
     3091                        _error_("not implemented...");
     3092                        break;
     3093                case P1Enum:
     3094
     3095                        IssmDouble   values[NUMVERTICES];
     3096                        IssmPDouble pvalues[NUMVERTICES];
     3097                        int          sidlist[NUMVERTICES];
     3098
     3099                        GetVertexSidList(&sidlist[0]);
     3100                        GetInputListOnVertices(&values[0],output_enum);
     3101                        for(int i=0;i<NUMVERTICES;i++) pvalues[i] = reCast<IssmPDouble>(values[i]);
     3102
     3103                        vector->SetValues(NUMVERTICES,sidlist,values,INS_VAL);
     3104                        break;
     3105                default:
     3106                        _error_("interpolation "<<EnumToStringx(input->GetResultInterpolation())<<" not supported yet");
     3107        }
     3108
    30343109
    30353110}

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

    r16442 r16461  
    101101                void   RequestedOutput(int output_enum,int step,IssmDouble time);
    102102                void   ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
     103                void   ResultInterpolation(int* pinterpolation,int output_enum);
     104                void   ResultToVector(Vector<IssmPDouble>* vector,int output_enum);
    103105                void   PatchFill(int* pcount, Patch* patch);
    104106                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);

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

    r16442 r16461  
    119119                void        PatchFill(int* pcount, Patch* patch){_error_("not implemented yet");};
    120120                void        PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes){_error_("not implemented yet");};
     121                void        ResultInterpolation(int* pinterpolation,int output_enum){_error_("not implemented");};
     122                void        ResultToVector(Vector<IssmPDouble>* vector,int output_enum){_error_("not implemented");};
    121123                void        ResetCoordinateSystem(void){_error_("not implemented yet");};
    122124                void          SmbGradients(){_error_("not implemented yet");};

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

    r16442 r16461  
    25912591        xDelete<int>(indices);
    25922592        delete gauss;
     2593}
     2594/*}}}*/
     2595/*FUNCTION Tria::ResultInterpolation{{{*/
     2596void Tria::ResultInterpolation(int* pinterpolation,int output_enum){
     2597
     2598        Input* input=this->inputs->GetInput(output_enum);
     2599
     2600        /*If this input is not already in Inputs, maybe it needs to be computed?*/
     2601        if(!input){
     2602                switch(output_enum){
     2603                        case StressTensorxxEnum:
     2604                                this->ComputeStressTensor();
     2605                                input=this->inputs->GetInput(output_enum);
     2606                                break;
     2607                        case StressTensorxyEnum:
     2608                                this->ComputeStressTensor();
     2609                                input=this->inputs->GetInput(output_enum);
     2610                                break;
     2611                        case StressTensorxzEnum:
     2612                                this->ComputeStressTensor();
     2613                                input=this->inputs->GetInput(output_enum);
     2614                                break;
     2615                        case StressTensoryyEnum:
     2616                                this->ComputeStressTensor();
     2617                                input=this->inputs->GetInput(output_enum);
     2618                                break;
     2619                        case StressTensoryzEnum:
     2620                                this->ComputeStressTensor();
     2621                                input=this->inputs->GetInput(output_enum);
     2622                                break;
     2623                        case StressTensorzzEnum:
     2624                                this->ComputeStressTensor();
     2625                                input=this->inputs->GetInput(output_enum);
     2626                                break;
     2627                        default:
     2628                                _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     2629                }
     2630        }
     2631
     2632        /*Assign output pointer*/
     2633        *pinterpolation = input->GetResultInterpolation();
     2634
     2635}
     2636/*}}}*/
     2637/*FUNCTION Tria::ResultToVector{{{*/
     2638void Tria::ResultToVector(Vector<IssmPDouble>* vector,int output_enum){
     2639
     2640        Input* input=this->inputs->GetInput(output_enum);
     2641        if(!input) _error_("input "<<EnumToStringx(output_enum)<<" not found in element");
     2642
     2643        switch(input->GetResultInterpolation()){
     2644                case P0Enum:
     2645                        _error_("not implemented...");
     2646                        break;
     2647                case P1Enum:
     2648
     2649                        IssmDouble   values[NUMVERTICES];
     2650                        IssmPDouble pvalues[NUMVERTICES];
     2651                        int          sidlist[NUMVERTICES];
     2652
     2653                        GetVertexSidList(&sidlist[0]);
     2654                        GetInputListOnVertices(&values[0],output_enum);
     2655                        for(int i=0;i<NUMVERTICES;i++) pvalues[i] = reCast<IssmPDouble>(values[i]);
     2656
     2657                        vector->SetValues(NUMVERTICES,sidlist,values,INS_VAL);
     2658                        break;
     2659                default:
     2660                        _error_("interpolation "<<EnumToStringx(input->GetResultInterpolation())<<" not supported yet");
     2661        }
     2662
     2663
    25932664}
    25942665/*}}}*/

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

    r16442 r16461  
    108108                void        RequestedOutput(int output_enum,int step,IssmDouble time);
    109109                void        ListResultsInfo(int** results_enums,int** results_size,IssmDouble** results_times,int** results_steps,int* num_results);
     110                void        ResultInterpolation(int* pinterpolation,int output_enum);
     111                void        ResultToVector(Vector<IssmPDouble>* vector,int output_enum);
    110112                void        PatchFill(int* pcount, Patch* patch);
    111113                void        PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);

  • issm/trunk-jpl/src/c/classes/ExternalResults/GenericExternalResult.h

    r16388 r16461  
    350350} /*}}}*/
    351351
     352/*Specifics instantiations for Vector*/
     353template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
     354        _error_("instanciation not correct");
     355}
     356/*}}}*/
     357template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_value,int in_step, IssmDouble in_time){ /*{{{*/
     358        id=in_id;
     359        enum_type=in_enum_type;
     360        M=0;
     361        N=0;
     362
     363        step=in_step;
     364        time=in_time;
     365
     366        value = in_value;
     367} /*}}}*/
     368template <> inline GenericExternalResult<Vector<IssmPDouble>*>::~GenericExternalResult(){ /*{{{*/
     369        delete value;
     370} /*}}}*/
     371template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::Echo(void){ /*{{{*/
     372
     373        _printf_("GenericExternalResult<IssmPDouble*>:\n");
     374        this->GenericEcho();
     375        this->value->Echo();
     376
     377} /*}}}*/
     378template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::DeepEcho(void){ /*{{{*/
     379
     380        this->Echo();
     381
     382} /*}}}*/
     383template <> inline Object* GenericExternalResult<Vector<IssmPDouble>*>::copy(void){ /*{{{*/
     384        return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,this->enum_type,this->value,this->step,this->time);
     385} /*}}}*/
     386template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
     387
     388        char *name   = NULL;
     389        int   length,rows,cols=1;
     390
     391        if(!io_gather){
     392                _error_("not supported yet");
     393        }
     394
     395        /*Serialize vector*/
     396        IssmPDouble* serialvalues = this->value->ToMPISerial();
     397        this->value->GetSize(&rows);
     398
     399        if(IssmComm::GetRank()==0){
     400                /*First write enum: */
     401                EnumToStringx(&name,this->enum_type);
     402                length=(strlen(name)+1)*sizeof(char);
     403                fwrite(&length,sizeof(int),1,fid);
     404                fwrite(name,length,1,fid);
     405                xDelete<char>(name);
     406
     407                /*Now write time and step: */
     408                IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
     409                fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
     410                fwrite(&step,sizeof(int),1,fid);
     411
     412                /*writing a IssmDouble array, type is 3:*/
     413                int type=3;
     414                fwrite(&type,sizeof(int),1,fid);
     415                fwrite(&rows,sizeof(int),1,fid);
     416                fwrite(&cols,sizeof(int),1,fid);
     417                fwrite(serialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
     418        }
     419
     420        /*Clean up*/
     421        xDelete<IssmPDouble>(serialvalues);
     422
     423}
     424/*}}}*/
     425template <> inline int GenericExternalResult<Vector<IssmPDouble>*>::ObjectEnum(void){ /*{{{*/
     426        return NoneEnum;
     427        /*???? FIXME*/
     428} /*}}}*/
     429
    352430#endif  /* _EXTERNAL_RESULTOBJECT_H */

  • issm/trunk-jpl/src/c/classes/ExternalResults/Results.cpp

    r15898 r16461  
    3737void Results::Write(Parameters* parameters){
    3838
    39         int         i;
    40         FILE       *fid          = NULL;
    41         bool        io_gather=true;
     39        FILE       *fid  = NULL;
     40        bool        io_gather;
    4241
    4342        /*Recover file descriptor: */
    … …  
    4544        parameters->FindParam(&io_gather,SettingsIoGatherEnum);
    4645
    47         for(i=0;i<this->Size();i++){
     46        for(int i=0;i<this->Size();i++){
    4847                ExternalResult* result=dynamic_cast<ExternalResult*>(this->GetObjectByOffset(i));
    49 
    50                 /*write result to disk: */
    5148                result->WriteData(fid,io_gather);
    5249        }
    … …  
    5451}
    5552/*}}}*/
    56 /*FUNCTION Results::Write{{{*/
     53/*FUNCTION Results::AddResult(ElementResult* in_result){{{*/
    5754int Results::AddResult(ElementResult* in_result){
    5855

  • issm/trunk-jpl/src/c/classes/FemModel.cpp

    r16447 r16461  
    480480void FemModel::RequestedOutputsx(char** requested_outputs, int numoutputs){/*{{{*/
    481481
    482         char*    output_string;
    483         int      step;
    484         IssmDouble   time;
    485         IssmDouble   output_value;
    486         Element *element      = NULL;
     482        char       *output_string;
     483        int         step;
     484        IssmDouble  time;
     485        IssmDouble  output_value;
    487486
    488487        /*Get time and step*/
    … …  
    519518                                /*create this output in the element inputs, and then transfer to results:*/
    520519                                for(int j=0;j<elements->Size();j++){
    521                                         element=(Element*)elements->GetObjectByOffset(j);
     520                                        Element* element=(Element*)elements->GetObjectByOffset(j);
    522521                                        element->RequestedOutput(StringToEnumx(output_string),step,time);
    523522                                }
    … …  
    525524                }
    526525        }
     526}
     527/*}}}*/
     528void FemModel::RequestedOutputsx(Results **presults,char** requested_outputs, int numoutputs){/*{{{*/
     529
     530        /*Intermediaries*/
     531        bool        isvec;
     532        int         step,output_enum;
     533        IssmDouble  time;
     534        IssmDouble  double_result;
     535        char       *output_string = NULL;
     536
     537        /*recover results*/
     538        Results* results = *presults;
     539        if(!results) results = new Results();
     540
     541        /*Get time and step*/
     542        parameters->FindParam(&step,StepEnum);
     543        parameters->FindParam(&time,TimeEnum);
     544
     545        /*Go through all requested output*/
     546        for(int i=0;i<numoutputs;i++){
     547
     548                output_string = requested_outputs[i];
     549                output_enum   = StringToEnumx(output_string,false);
     550                isvec         = false;
     551
     552                /*If string is not an enum, it is defined in output definitions*/
     553                if(output_enum<0){
     554                        double_result = OutputDefinitionsResponsex(this,output_string);
     555                }
     556                else{
     557                        switch(output_enum){
     558
     559                                #ifdef _HAVE_RESPONSES_
     560                                /*Scalar output*/
     561                                case IceVolumeEnum:                this->IceVolumex(&double_result);                break;
     562                                case IceVolumeAboveFloatationEnum: this->IceVolumeAboveFloatationx(&double_result); break;
     563                                case MinVelEnum:                   this->MinVelx(&double_result);                   break;
     564                                case MaxVelEnum:                   this->MaxVelx(&double_result);                   break;
     565                                case MinVxEnum:                    this->MinVxx(&double_result);                    break;
     566                                case MaxVxEnum:                    this->MaxVxx(&double_result);                    break;
     567                                case MaxAbsVxEnum:                 this->MaxAbsVxx(&double_result);                 break;
     568                                case MinVyEnum:                    this->MinVyx(&double_result);                    break;
     569                                case MaxVyEnum:                    this->MaxVyx(&double_result);                    break;
     570                                case MaxAbsVyEnum:                 this->MaxAbsVyx(&double_result);                 break;
     571                                case MinVzEnum:                    this->MinVzx(&double_result);                    break;
     572                                case MaxVzEnum:                    this->MaxVzx(&double_result);                    break;
     573                                case MaxAbsVzEnum:                 this->MaxAbsVzx(&double_result);                 break;
     574                                case MassFluxEnum:                 this->MassFluxx(&double_result);                 break;
     575                                case TotalSmbEnum:                 this->TotalSmbx(&double_result);                 break;
     576
     577                           /*Scalar control output*/
     578                                #ifdef _HAVE_CONTROL_
     579                                case SurfaceAbsVelMisfitEnum:       SurfaceAbsVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters);        break;
     580                                case SurfaceRelVelMisfitEnum:       SurfaceRelVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters);        break;
     581                                case SurfaceLogVelMisfitEnum:       SurfaceLogVelMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters);        break;
     582                                case SurfaceLogVxVyMisfitEnum:      SurfaceLogVxVyMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters);       break;
     583                                case SurfaceAverageVelMisfitEnum:   SurfaceAverageVelMisfitx(&double_result,this);                                                  break;
     584                                case ThicknessAbsMisfitEnum:        ThicknessAbsMisfitx(&double_result,elements,nodes,vertices,loads,materials,parameters);         break;
     585                                case ThicknessAbsGradientEnum:      this->ThicknessAbsGradientx(&double_result);                                                    break;
     586                                case ThicknessAlongGradientEnum:    ThicknessAlongGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters);     break;
     587                                case ThicknessAcrossGradientEnum:   ThicknessAcrossGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters);    break;
     588                                case RheologyBbarAbsGradientEnum:   RheologyBbarAbsGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters);    break;
     589                                case DragCoefficientAbsGradientEnum:DragCoefficientAbsGradientx(&double_result,elements,nodes,vertices,loads,materials,parameters); break;
     590                                case BalancethicknessMisfitEnum:    BalancethicknessMisfitx(&double_result);                                                        break;
     591                                #endif
     592
     593                           /*Vector */
     594                                default:
     595
     596                                        /*Vector layout*/
     597                                        int interpolation,size;
     598
     599                                        /*Get interpolation (and compute input if necessary)*/
     600                                        for(int j=0;j<elements->Size();j++){
     601                                                Element* element=dynamic_cast<Element*>(this->elements->GetObjectByOffset(j));
     602                                                element->ResultInterpolation(&interpolation,output_enum);
     603                                        }
     604
     605                                        /*Allocate vector depending on interpolation*/
     606                                        switch(interpolation){
     607                                                case P0Enum: size = this->elements->NumberOfElements(); break;
     608                                                case P1Enum: size = this->vertices->NumberOfVertices(); break;
     609                                                default:     _error_("Interpolation "<<EnumToStringx(interpolation)<<" not supported yet");
     610
     611                                        }
     612                                        Vector<IssmPDouble> *vector_result = new Vector<IssmDouble>(this->vertices->NumberOfVertices());
     613
     614                                        /*Fill in vector*/
     615                                        for(int j=0;j<elements->Size();j++){
     616                                                Element* element=(Element*)elements->GetObjectByOffset(j);
     617                                                element->ResultToVector(vector_result,output_enum);
     618                                        }
     619                                        vector_result->Assemble();
     620
     621                                        results->AddObject(new GenericExternalResult<Vector<IssmPDouble>*>(results->Size()+1,output_enum,vector_result,step,time));
     622                                        isvec = true;
     623                                        break;
     624
     625                                #else
     626                                default: _error_("ISSM was not compiled with responses capabilities, exiting!");
     627                                #endif
     628                        }
     629                }
     630
     631                /*Add result to Results*/
     632                if(!isvec){
     633                        results->AddObject(new GenericExternalResult<IssmPDouble>(results->Size()+1,output_string,reCast<IssmPDouble>(double_result),step,time));
     634                }
     635        }
     636
     637        /*Assign pointer and clean up*/
     638        *presults = results;
    527639}
    528640/*}}}*/

  • issm/trunk-jpl/src/c/classes/FemModel.h

    r16442 r16461  
    8282                void DakotaResponsesx(double* d_responses,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);
    8383                #endif
     84                void RequestedOutputsx(Results **presults,char** requested_outputs, int numoutputs);
    8485                void RequestedOutputsx(char** requested_outputs, int numoutputs);
    8586                void RequestedDependentsx(void);

  • issm/trunk-jpl/src/c/classes/Inputs/BoolInput.h

    r16434 r16461  
    4040                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    4141                ElementResult* SpawnResult(int step, IssmDouble time);
     42                int  GetResultInterpolation(void){return P0Enum;};
    4243                void Configure(Parameters* parameters);
    4344                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/ControlInput.h

    r16434 r16461  
    9090                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist);
    9191                ElementResult* SpawnGradient(int step, IssmDouble time);
     92                int  GetResultInterpolation(void){_error_("not implemented yet");};
    9293                void GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist);
    9394                void ScaleGradient(IssmDouble scale);

  • issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.h

    r16434 r16461  
    8686                void GetVectorFromInputs(Vector<IssmDouble>* vector,int* doflist){_error_("not implemented yet");};
    8787                ElementResult* SpawnGradient(int step, IssmDouble time){_error_("not implemented yet");};
     88                int GetResultInterpolation(void){_error_("not implemented yet");};
    8889                void GetGradient(Vector<IssmDouble>* gradient_vec,int* doflist){_error_("not implemented yet");};
    8990                void ScaleGradient(IssmDouble scale){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.h

    r16434 r16461  
    3939                Input* PointwiseMax(Input* inputB);
    4040                ElementResult* SpawnResult(int step, IssmDouble time);
     41                int  GetResultInterpolation(void){return P0Enum;};
    4142                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4243                void Configure(Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/Input.h

    r16434 r16461  
    7373                virtual Input* PointwiseMin(Input* inputmin)=0;
    7474                virtual ElementResult* SpawnResult(int step, IssmDouble time)=0;
     75                virtual int GetResultInterpolation(void)=0;
    7576};
    7677#endif

  • issm/trunk-jpl/src/c/classes/Inputs/IntInput.h

    r16434 r16461  
    4040                Input* PointwiseMax(Input* inputB){_error_("not implemented yet");};
    4141                ElementResult* SpawnResult(int step, IssmDouble time);
     42                int  GetResultInterpolation(void){return P0Enum;};
    4243                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4344                void Configure(Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

    r16382 r16461  
    137137}
    138138/*}}}*/
     139/*FUNCTION PentaInput::GetResultInterpolation{{{*/
     140int  PentaInput::GetResultInterpolation(void){
     141
     142        return P1Enum;
     143
     144}
     145/*}}}*/
    139146
    140147/*Object functions*/

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.h

    r16434 r16461  
    4040                Input* PointwiseMax(Input* inputB);
    4141                ElementResult* SpawnResult(int step, IssmDouble time);
     42                int  GetResultInterpolation(void);
    4243                void AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4344                void Configure(Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/SegInput.h

    r16434 r16461  
    4040                Input* PointwiseMax(Input* inputB){_error_("not supported yet");};
    4141                ElementResult* SpawnResult(int step, IssmDouble time){_error_("not supported yet");};
     42                int  GetResultInterpolation(void){_error_("not implemented");};
    4243                void   AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4344                void   Configure(Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.h

    r16434 r16461  
    4444                Input* PointwiseMax(Input* forcingB){_error_("not implemented yet");};
    4545                ElementResult* SpawnResult(int step, IssmDouble time);
     46                int  GetResultInterpolation(void){_error_("not implemented");};
    4647                void Configure(Parameters* parameters);
    4748                /*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

    r16434 r16461  
    124124}
    125125/*}}}*/
     126/*FUNCTION TriaInput::GetResultInterpolation{{{*/
     127int  TriaInput::GetResultInterpolation(void){
     128
     129        return P1Enum;
     130
     131}
     132/*}}}*/
    126133
    127134/*Object functions*/

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.h

    r16434 r16461  
    4040                Input* PointwiseMax(Input* inputB);
    4141                ElementResult* SpawnResult(int step, IssmDouble time);
     42                int    GetResultInterpolation(void);
    4243                void   AddTimeValues(IssmDouble* values,int step,IssmDouble time){_error_("not supported yet");};
    4344                void   Configure(Parameters* parameters);
Note: See TracChangeset for help on using the changeset viewer.