source: issm/branches/trunk-dlcheng-ASE/src/c/classes/Inputs/Inputs.cpp

/*\file Inputs.cpp
 * \brief: Implementation of the Inputs class, derived from DataSet class.
 */

/*Headers: {{{*/
#ifdef HAVE_CONFIG_H
        #include <config.h>
#else
#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
#endif

#include "./Input.h"
#include "./Inputs.h"

#include "./BoolInput.h"
#include "./IntInput.h"
#include "./DoubleInput.h"
#include "./ElementInput.h"
#include "./SegInput.h"
#include "./TriaInput.h"
#include "./PentaInput.h"
#include "./TransientInput.h"
#include "./ControlInput.h"
#include "./DatasetInput.h"
#include "./ArrayInput.h"
#include "./IntArrayInput.h"
using namespace std;
/*}}}*/

/*Object constructors and destructor*/
Inputs::Inputs(void){/*{{{*/

        this->numberofelements_local = 0;
        this->numberofvertices_local = 0;

        /*Initialize pointers*/
        for(int i=0;i<NUMINPUTS;i++) this->inputs[i] = NULL;
}
/*}}}*/
Inputs::Inputs(int nbe,int nbv){/*{{{*/

        this->numberofelements_local = nbe;
        this->numberofvertices_local = nbv;

        /*Initialize pointers*/
        for(int i=0;i<NUMINPUTS;i++) this->inputs[i] = NULL;
}
/*}}}*/
Inputs::~Inputs(){/*{{{*/
        for(int i=0;i<NUMINPUTS;i++){
                if(this->inputs[i]) delete this->inputs[i];
        }
        return;
}
/*}}}*/

Inputs* Inputs::Copy(void){/*{{{*/

        Inputs* output = new Inputs(this->numberofelements_local,this->numberofvertices_local);

        for(int i=0;i<NUMINPUTS;i++){
                if(this->inputs[i]) output->inputs[i]=this->inputs[i]->copy();
        }

        return output;
}/*}}}*/
void Inputs::DeepEcho(void){/*{{{*/
        for(int i=0;i<NUMINPUTS;i++) {
                if(this->inputs[i]) this->inputs[i]->DeepEcho();
        }
        return;
}
/*}}}*/
void Inputs::Echo(void){/*{{{*/
        _printf_("Inputs Echo:\n");
        for(int i=0;i<NUMINPUTS;i++) {
                if(this->inputs[i]) _printf_(setw(25)<<EnumToStringx(i+InputsSTARTEnum+1)<<": set as "<<EnumToStringx(this->inputs[i]->ObjectEnum())<<"\n");
        }
        return;
}
/*}}}*/
void Inputs::DeepEcho(int enum_in){/*{{{*/
        int index= EnumToIndex(enum_in);
        if(this->inputs[index])this->inputs[index]->DeepEcho();
        return;
}
/*}}}*/
void Inputs::Echo(int enum_in){/*{{{*/
        _printf_("Inputs Echo:\n");
        int index= EnumToIndex(enum_in);
        if(this->inputs[index])this->inputs[index]->Echo();
        return;
}
/*}}}*/
void Inputs::Marshall(MarshallHandle* marshallhandle){/*{{{*/

        int num_inputs=0;
        int index;

        int object_enum = InputsEnum;
   marshallhandle->call(object_enum);
        marshallhandle->call(this->numberofelements_local);
        marshallhandle->call(this->numberofvertices_local);

        if(marshallhandle->OperationNumber()!=MARSHALLING_LOAD){

                /*Marshall num_inputs first*/
                for(int i=0;i<NUMINPUTS;i++){
                        if(this->inputs[i]) num_inputs++;
                }
                marshallhandle->call(num_inputs);

                /*Marshall Parameters one by one now*/
                for(int i=0;i<NUMINPUTS;i++){
                        if(this->inputs[i]){
                                object_enum = this->inputs[i]->ObjectEnum();
                                marshallhandle->call(i);
                                marshallhandle->call(object_enum);
                                this->inputs[i]->Marshall(marshallhandle);
                        }
                }
        }
        else{

                /*Get number of inputs marshalled*/
                marshallhandle->call(num_inputs);

                /*Recover input2eters one by one*/
                for(int i=0;i<num_inputs;i++){

                        /*Recover enum of object first: */
                        marshallhandle->call(index);
                        marshallhandle->call(object_enum);

                        if(object_enum==BoolInputEnum){
                                BoolInput* boolinput2=new BoolInput();
                                boolinput2->Marshall(marshallhandle);
                                this->inputs[index]=boolinput2;
                        }
                        else if(object_enum==IntInputEnum){
                                IntInput* intinput2=new IntInput();
                                intinput2->Marshall(marshallhandle);
                                this->inputs[index]=intinput2;
                        }
                        else if(object_enum==TriaInputEnum){
                                TriaInput* triainput2=new TriaInput();
                                triainput2->Marshall(marshallhandle);
                                this->inputs[index]=triainput2;
                        }
                        else if(object_enum==PentaInputEnum){
                                PentaInput* pentainput2=new PentaInput();
                                pentainput2->Marshall(marshallhandle);
                                this->inputs[index]=pentainput2;
                        }
                        else if(object_enum==ControlInputEnum){
                                ControlInput* input=new ControlInput();
                                input->Marshall(marshallhandle);
                                this->inputs[index]=input;
                        }
                        else if(object_enum==TransientInputEnum){
                                TransientInput* input=new TransientInput();
                                input->Marshall(marshallhandle);
                                this->inputs[index]=input;
                        }
                        else if(object_enum==DatasetInputEnum){
                                DatasetInput* input=new DatasetInput();
                                input->Marshall(marshallhandle);
                                this->inputs[index]=input;
                        }
                        else if(object_enum==ArrayInputEnum){
                                ArrayInput* input=new ArrayInput();
                                input->Marshall(marshallhandle);
                                this->inputs[index]=input;
                        }
                        else{
                                _error_("input "<<EnumToStringx(object_enum)<<" not supported");
                        }
                }
        }
}
/*}}}*/

void Inputs::AddInput(Input* newinput){/*{{{*/

        /*Get Enum from Param*/
        _assert_(newinput);
        int input_enum = newinput->InstanceEnum();

        /*Get index in array*/
        #ifdef _ISSM_DEBUG_
        if(input_enum<=InputsSTARTEnum) _error_("Cannot add input: Enum "<<EnumToStringx(input_enum)<<" should appear after InputsSTARTEnum");
        if(input_enum>=InputsENDEnum)   _error_("Cannot add input: Enum "<<EnumToStringx(input_enum)<<" should appear before InputsENDEnum");
        #endif
        int index = input_enum - InputsSTARTEnum -1;

        /*Delete input if it already exists*/
        if(this->inputs[index]){
                delete this->inputs[index];
                this->inputs[index] = NULL;
        }

        /*Add input to array*/
        this->inputs[index] = newinput;
}
/*}}}*/
void Inputs::ChangeEnum(int oldenumtype,int newenumtype){/*{{{*/

        /*Get indices from enums*/
        int index_old = EnumToIndex(oldenumtype);
        int index_new = EnumToIndex(newenumtype);

        /*Delete input if it already exists*/
        if(this->inputs[index_new]) delete this->inputs[index_new];

        /*Make sure that old one exists*/
        if(!this->inputs[index_old]){
                _error_("Input "<<EnumToStringx(oldenumtype)<<" not found");
        }

        /*Replace Enums*/
        this->inputs[index_old]->ChangeEnum(newenumtype);
        this->inputs[index_new] = this->inputs[index_old];
        this->inputs[index_old] = NULL;
}/*}}}*/
void Inputs::Configure(Parameters* parameters){/*{{{*/
        for(int i=0;i<NUMINPUTS;i++){
                if(this->inputs[i]) this->inputs[i]->Configure(parameters);
        }
}
/*}}}*/
int  Inputs::DeleteInput(int input_enum){/*{{{*/

        int index = EnumToIndex(input_enum);
        if(this->inputs[index]){
                delete this->inputs[index];
                this->inputs[index] = NULL;
        }

        return 1;
}
/*}}}*/
void Inputs::DuplicateInput(int original_enum,int new_enum){/*{{{*/

        _assert_(this);

        /*Get indices from enums*/
        int index_ori = EnumToIndex(original_enum);
        int index_new = EnumToIndex(new_enum);

        /*Delete input if it already exists*/
        if(this->inputs[index_new]) delete this->inputs[index_new];

        /*Make sure that old one exists*/
        if(!this->inputs[index_ori]){
                _error_("Input "<<EnumToStringx(original_enum)<<" not found");
        }

        /*Make a copy*/
        Input* copy=this->inputs[index_ori]->copy();

        /*Add copy*/
        this->inputs[index_new] = copy;
}
/*}}}*/
void Inputs::ZAXPY(IssmDouble alpha, int xenum, int yenum, int zenum){/*{{{*/

        _assert_(this);

        /*Get indices from enums*/
        int index_x = EnumToIndex(xenum);
        int index_y = EnumToIndex(yenum);
        int index_z = EnumToIndex(zenum);

        /*Delete output if it already exists*/
        if(this->inputs[index_z]) delete this->inputs[index_z];

        /*Make sure that old one exists*/
        if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");
        if(!this->inputs[index_y]) _error_("Input "<<EnumToStringx(yenum)<<" not found");

        /*Make a copy*/
        this->inputs[index_z]=this->inputs[index_y]->copy();

        /*AXPY: */
        this->inputs[index_z]->AXPY(this->inputs[index_x],alpha);
}
/*}}}*/
void Inputs::AXPY(IssmDouble alpha, int xenum, int yenum ){/*{{{*/

        _assert_(this);

        /*Get indices from enums*/
        int index_x = EnumToIndex(xenum);
        int index_y = EnumToIndex(yenum);

        /*Make sure that old one exists*/
        if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");
        if(!this->inputs[index_y]) _error_("Input "<<EnumToStringx(yenum)<<" not found");

        /*AXPY: */
        this->inputs[index_y]->AXPY(this->inputs[index_x],alpha);
}
/*}}}*/
void     Inputs::Shift(int xenum, IssmDouble alpha){/*{{{*/

        _assert_(this);

        /*Get indices from enums*/
        int index_x = EnumToIndex(xenum);

        /*Make sure that x exists*/
        if(!this->inputs[index_x]) _error_("Input "<<EnumToStringx(xenum)<<" not found");

        /*Shift: */
        this->inputs[index_x]->Shift(alpha);
}
/*}}}*/
int  Inputs::EnumToIndex(int enum_in){/*{{{*/

        _assert_(this);

        /*Make sure this parameter is at the right place*/
        #ifdef _ISSM_DEBUG_
        if(enum_in<=InputsSTARTEnum){
                //int* temp = xNew<int>(3);
                _error_("Enum "<<EnumToStringx(enum_in)<<" should appear after InputsSTARTEnum");
        }
        if(enum_in>=InputsENDEnum){
                _error_("Enum "<<EnumToStringx(enum_in)<<" should appear before InputsENDEnum");
        }
        #endif
        return enum_in - InputsSTARTEnum -1;
}/*}}}*/
bool Inputs::Exist(int enum_in){/*{{{*/

        _assert_(this);

        int index = EnumToIndex(enum_in);
        if(this->inputs[index]) return true;
        return false;
}
/*}}}*/
int Inputs::GetInputObjectEnum(int enum_in){/*{{{*/

        _assert_(this);

        int index = EnumToIndex(enum_in);
        if(!this->inputs[index]) _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        return this->inputs[index]->ObjectEnum();
}
/*}}}*/
void Inputs::GetInputsInterpolations(int* pnuminputs,int** pinterpolations,int** pinputenums){/*{{{*/

        /*First count number of inputs*/
        int count = 0;
        for(int i=0;i<NUMINPUTS;i++){
                if(this->inputs[i]) count++;
        }
        int numinputs = count;

        /*Allocate output*/
        int* interpolations = xNew<int>(count);
        int* enumlist       = xNew<int>(count);

        /*Go through all inputs and assign interpolation in vector*/
        count = 0;
        for(int i=0;i<NUMINPUTS;i++){

                Input* input=this->inputs[i];
                if(!input) continue;

                enumlist[count] = i+InputsSTARTEnum+1;
                switch(input->ObjectEnum()){
                        case BoolInputEnum:
                        case IntInputEnum:
                                interpolations[count] = input->ObjectEnum();
                                break;
                        case TriaInputEnum:
                                interpolations[count] = input->GetResultInterpolation();
                                break;
                        default:
                                _error_("Input "<<EnumToStringx(input->ObjectEnum())<<" not supported yet");
                }
                count++;
        }
        _assert_(count == numinputs);

        /*Return pointer*/
        *pnuminputs = numinputs;
        *pinterpolations = interpolations;
        *pinputenums = enumlist;

}/*}}}*/
SegInput* Inputs::GetSegInput(int enum_in){/*{{{*/

        _assert_(this);

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        return input->GetSegInput();
}/*}}}*/
TriaInput* Inputs::GetTriaInput(int enum_in){/*{{{*/

        _assert_(this);

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        return input->GetTriaInput();
}/*}}}*/
TriaInput* Inputs::GetTriaInput(int enum_in,IssmDouble time){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        if(input->ObjectEnum()==TransientInputEnum){
                return xDynamicCast<TransientInput*>(input)->GetTriaInput(time);
        }
        else{
                return input->GetTriaInput();
        }
}/*}}}*/
TriaInput* Inputs::GetTriaInput(int enum_in,IssmDouble start_time,IssmDouble end_time,int averaging_method){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        if(input->ObjectEnum()==TransientInputEnum){
                return xDynamicCast<TransientInput*>(input)->GetTriaInput(start_time,end_time,averaging_method);
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
        }
}/*}}}*/
PentaInput* Inputs::GetPentaInput(int enum_in){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        return input->GetPentaInput();
}/*}}}*/
PentaInput* Inputs::GetPentaInput(int enum_in,IssmDouble time){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        if(input->ObjectEnum()==TransientInputEnum){
                return xDynamicCast<TransientInput*>(input)->GetPentaInput(time);
        }
        else{
                return input->GetPentaInput();
        }
}/*}}}*/
PentaInput* Inputs::GetPentaInput(int enum_in,IssmDouble start_time,IssmDouble end_time,int averaging_method){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        if(input->ObjectEnum()==TransientInputEnum){
                return xDynamicCast<TransientInput*>(input)->GetPentaInput(start_time,end_time,averaging_method);
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
        }
}/*}}}*/
TransientInput* Inputs::GetTransientInput(int enum_in){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;

        if(input->ObjectEnum() != TransientInputEnum){
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an TransientInput");
        }

        /*Cast and return*/
        TransientInput* output = xDynamicCast<TransientInput*>(input);
        return output;
}/*}}}*/
ElementInput* Inputs::GetControlInputData(int enum_in,const char* data){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;
        if(input->ObjectEnum() != ControlInputEnum){
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an ControlInput");
        }

        /*Cast and return*/
        return xDynamicCast<ControlInput*>(input)->GetInput(data);
}/*}}}*/
DatasetInput* Inputs::GetDatasetInput(int enum_in){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;
        if(input->ObjectEnum() != DatasetInputEnum){
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an DatasetInput");
        }

        /*Cast and return*/
        return xDynamicCast<DatasetInput*>(input);
}/*}}}*/
ControlInput* Inputs::GetControlInput(int enum_in){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Check that it has the right format*/
        Input* input = this->inputs[id];
        if(!input) return NULL;
        if(input->ObjectEnum() != ControlInputEnum){
                _error_("Input "<<EnumToStringx(enum_in)<<" is not an ControlInput");
        }

        /*Cast and return*/
        return xDynamicCast<ControlInput*>(input);
}/*}}}*/
void Inputs::GetArrayPtr(int enum_in,int row,IssmDouble** pvalues,int* pN){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an array");
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
        input->GetArrayPtr(row,pvalues,pN);
}/*}}}*/
void Inputs::GetIntArrayPtr(int enum_in,int row,int** pvalues,int* pN){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an int array");
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
        input->GetArrayPtr(row,pvalues,pN);
}/*}}}*/
void Inputs::GetArray(int enum_in,int row,IssmDouble** pvalues,int* pN){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an array");
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
        input->GetArray(row,pvalues,pN);
}/*}}}*/
void Inputs::GetIntArray(int enum_in,int row,int** pvalues,int* pN){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return an int array");
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
        input->GetArray(row,pvalues,pN);
}/*}}}*/
void Inputs::GetInputValue(bool* pvalue,int enum_in,int index){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=BoolInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a bool");
        }
        else{
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        BoolInput* input = xDynamicCast<BoolInput*>(this->inputs[id]);
        input->GetInput(pvalue,index);
}/*}}}*/
void Inputs::GetInputValue(int* pvalue,int enum_in,int index){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=IntInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a int");
        }
        else{
                int* temp = xNew<int>(3);
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        IntInput* input = xDynamicCast<IntInput*>(this->inputs[id]);
        input->GetInput(pvalue,index);
}/*}}}*/
void Inputs::GetInputValue(IssmDouble* pvalue,int enum_in,int index){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=DoubleInputEnum) _error_(EnumToStringx(this->inputs[id]->ObjectEnum())<<" cannot return a double!");
        }
        else{
                int* temp = xNew<int>(3);
                _error_("Input "<<EnumToStringx(enum_in)<<" not found");
        }

        /*Set input*/
        DoubleInput* input = xDynamicCast<DoubleInput*>(this->inputs[id]);
        input->GetInput(pvalue,index);

}/*}}}*/
void Inputs::ResultInterpolation(int* pinterpolation,int* pnodesperelement,int* parray_size, int output_enum){/*{{{*/

        /*Get input */
        int     index = EnumToIndex(output_enum);
        Input* input = this->inputs[index];

        /*Check that it is found*/
        if(!input){
                _error_("Input "<<EnumToStringx(output_enum)<<" not found and cannot be added to model results");
        }

        /*Assign output pointer*/
        *pinterpolation   = input->GetResultInterpolation();
        *pnodesperelement = input->GetResultNumberOfNodes();
        *parray_size      = input->GetResultArraySize();
}/*}}}*/
void Inputs::SetInput(int enum_in,int index,bool value){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=BoolInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new BoolInput(this->numberofelements_local);
        }

        /*Set input*/
        BoolInput* input = xDynamicCast<BoolInput*>(this->inputs[id]);
        input->SetInput(index,value);
}/*}}}*/
void Inputs::SetInput(int enum_in,int index,int value){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=IntInputEnum) _error_("cannot add an int to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new IntInput(this->numberofelements_local);
        }

        /*Set input*/
        IntInput* input = xDynamicCast<IntInput*>(this->inputs[id]);
        input->SetInput(index,value);
}/*}}}*/
void Inputs::SetDoubleInput(int enum_in,int index,IssmDouble value){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=DoubleInputEnum) _error_("cannot add a double to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new DoubleInput(this->numberofelements_local);
        }

        /*Set input*/
        DoubleInput* input = xDynamicCast<DoubleInput*>(this->inputs[id]);
        input->SetInput(index,value);
}/*}}}*/
void Inputs::SetArrayInput(int enum_in,int row,IssmDouble* values,int numlayers){/*{{{*/

        bool recreate = false;

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=ArrayInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new ArrayInput(this->numberofelements_local);
        }

        /*Set input*/
        ArrayInput* input = xDynamicCast<ArrayInput*>(this->inputs[id]);
        input->SetInput(row,numlayers,values);
}/*}}}*/
void Inputs::SetIntArrayInput(int enum_in,int row,int* values,int numlayers){/*{{{*/

        bool recreate = false;

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=IntArrayInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new IntArrayInput(this->numberofelements_local);
        }

        /*Set input*/
        IntArrayInput* input = xDynamicCast<IntArrayInput*>(this->inputs[id]);
        input->SetInput(row,numlayers,values);
}/*}}}*/
TransientInput* Inputs::SetDatasetTransientInput(int enum_in,int dataset_id,IssmDouble* times,int numtimes){/*{{{*/

        bool recreate = false;
        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
        }

        /*Get Dataset Input now*/
        DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);

        /*Create and return transient input*/
        return input->SetTransientInput(dataset_id,times,numtimes);
}/*}}}*/
void Inputs::SetTransientInput(int enum_in,IssmDouble* times,int numtimes){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                /*Input already there, make sure it is the right type*/
                if(this->inputs[id]->ObjectEnum()!=TransientInputEnum){
                        _error_("cannot add a TransientInput to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
                }
        }
        else{
                this->inputs[id] = new TransientInput(enum_in,this->numberofelements_local,this->numberofvertices_local,times,numtimes);
        }
}/*}}}*/
void Inputs::SetControlInput(int enum_in,int layout,int interpolation,int control_id){/*{{{*/

        bool recreate = false;

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=ControlInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new ControlInput(this->numberofelements_local,this->numberofvertices_local,layout,interpolation,control_id);
        }

}/*}}}*/
void Inputs::SetTransientControlInput(int enum_in,int control_id,IssmDouble* times,int numtimes){/*{{{*/

        bool recreate = false;

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=ControlInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new ControlInput(enum_in,this->numberofelements_local,this->numberofvertices_local,control_id,times,numtimes);
        }

}/*}}}*/
void Inputs::SetTriaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
        if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");

        /*Set input*/
        ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
        input->SetGradient(interpolation,numindices,indices,values);
}/*}}}*/
void Inputs::SetTriaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values,int n){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
        if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");

        /*Set input*/
        ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
        input->SetGradient(interpolation,numindices,indices,values,n);
}/*}}}*/
void Inputs::SetTriaDatasetInput(int enum_in,int id_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        bool recreate = false;
        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
        }

        /*Set input*/
        DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);
        input->SetTriaInput(id_in,P1Enum,numindices,indices,values);
}/*}}}*/
void Inputs::SetTriaInput(int enum_in,int interpolation,int row,IssmDouble value){/*{{{*/

        /*This one only supports P0 and P1 because it assumes col=0*/
        _assert_(interpolation==P0Enum || interpolation==P1Enum);

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=TriaInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
        input->SetInput(interpolation,row,value);
}/*}}}*/
void Inputs::SetTriaInput(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=TriaInputEnum){
                        _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum())<<" while trying to set "<<EnumToStringx(enum_in));
                }
        }
        else{
                this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
        input->SetInput(interpolation,numindices,indices,values);
}/*}}}*/
void Inputs::SetTriaInput(int enum_in,int interpolation,int row,int numindices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=TriaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new TriaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        TriaInput* input = xDynamicCast<TriaInput*>(this->inputs[id]);
        input->SetInput(interpolation,row,numindices,values);
}/*}}}*/
void Inputs::SetPentaControlInputGradient(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(!this->inputs[id]) _error_("could not find Input "<<EnumToStringx(enum_in));
        if( this->inputs[id]->ObjectEnum()!=ControlInputEnum) _error_("Input "<<EnumToStringx(enum_in)<<" is not a ControlInput");

        /*Set input*/
        ControlInput* input = xDynamicCast<ControlInput*>(this->inputs[id]);
        input->SetGradient(interpolation,numindices,indices,values);
}/*}}}*/
void Inputs::SetPentaDatasetInput(int enum_in,int id_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        bool recreate = false;
        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=DatasetInputEnum){
                        delete this->inputs[id];
                        recreate = true;
                }
        }
        else{
                recreate = true;
        }

        if(recreate){
                this->inputs[id] = new DatasetInput(this->numberofelements_local,this->numberofvertices_local);
        }

        /*Set input*/
        DatasetInput* input = xDynamicCast<DatasetInput*>(this->inputs[id]);
        input->SetPentaInput(id_in,P1Enum,numindices,indices,values);
}/*}}}*/
void Inputs::SetPentaInput(int enum_in,int interpolation,int row,IssmDouble value){/*{{{*/

        /*This one only supports P0 and P1 because it assumes col=0*/
        _assert_(interpolation==P0Enum || interpolation==P1Enum);

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add a bool to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
        input->SetInput(interpolation,row,value);
}/*}}}*/
void Inputs::SetPentaInput(int enum_in,int interpolation,int numindices,int* indices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
        input->SetInput(interpolation,numindices,indices,values);
}/*}}}*/
void Inputs::SetPentaInput(int enum_in,int interpolation,int row,int numindices,IssmDouble* values){/*{{{*/

        /*Get input id*/
        int id = EnumToIndex(enum_in);

        /*Create it if necessary*/
        if(this->inputs[id]){
                if(this->inputs[id]->ObjectEnum()!=PentaInputEnum) _error_("cannot add Element values to a "<<EnumToStringx(this->inputs[id]->ObjectEnum()));
        }
        else{
                this->inputs[id] = new PentaInput(this->numberofelements_local,this->numberofvertices_local,interpolation);
        }

        /*Set input*/
        PentaInput* input = xDynamicCast<PentaInput*>(this->inputs[id]);
        input->SetInput(interpolation,row,numindices,values);
}/*}}}*/