Changeset 27725

Timestamp:

05/04/23 12:49:11 (23 months ago)

Author:

Mathieu Morlighem

Message:

CHG: removing index field, not used by anyone

Location:

issm/trunk-jpl/src/c

Files:

• classes/DependentObject.cpp (modified) (4 diffs)
• classes/DependentObject.h (modified) (1 diff)
• modules/ModelProcessorx/Autodiff/CreateParametersAutodiff.cpp (modified) (6 diffs)

issm/trunk-jpl/src/c/classes/DependentObject.cpp ¶

@@ -16 +16 @@
 DependentObject::DependentObject(){/*{{{*/
         this->name=NULL;
-        this->index=-1;
         this->response_value=0.;
 }
 /*}}}*/
-DependentObject::DependentObject(char* in_name,int in_index){/*{{{*/
+DependentObject::DependentObject(char* in_name){/*{{{*/
 
         this->name=xNew<char>(strlen(in_name)+1); xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
-        this->index=in_index;
         this->response_value=0.;
 
 }/*}}}*/
-DependentObject::DependentObject(char* in_name,int in_index,IssmDouble in_response){/*{{{*/
+DependentObject::DependentObject(char* in_name,IssmDouble in_response){/*{{{*/
 
         this->name=xNew<char>(strlen(in_name)+1); xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
-        this->index=in_index;
         this->response_value=in_response;
 
@@ -40 +37 @@
 /*Object virtual functions definitions:*/
 Object* DependentObject::copy(void) { /*{{{*/
-        return new DependentObject(name,index,response_value);
+        return new DependentObject(name,response_value);
 } /*}}}*/
 void DependentObject::DeepEcho(void){/*{{{*/
@@ -50 +47 @@
         _printf_("DependentObject:\n");
         _printf_("   name: " << this->name << "\n");
-        if(this->index>=0) _printf_("   index: " << this->index << "\n");
         _printf_("   response_value: " << this->response_value<< "\n");
 }
@@ -70 +66 @@
         marshallhandle->call(this->name);
 
-        marshallhandle->call(this->index);
         marshallhandle->call(this->response_value);
 }/*}}}*/

issm/trunk-jpl/src/c/classes/DependentObject.h ¶

@@ -18 +18 @@
 
                 char* name;
-                int   index;  /*0: scalar, 1: vertex*/
                 IssmDouble response_value;
 
                 /*DependentObject constructors, destructors */
                 DependentObject();
-                DependentObject(char* name,int index);
-                DependentObject(char* name,int index,IssmDouble in_response);
+                DependentObject(char* name);
+                DependentObject(char* name, IssmDouble in_response);
                 ~DependentObject();
 

issm/trunk-jpl/src/c/modules/ModelProcessorx/Autodiff/CreateParametersAutodiff.cpp ¶

@@ -10 +10 @@
 void CreateParametersAutodiff(Parameters* parameters,IoModel* iomodel){
 
+        #if defined(_HAVE_AD_) 
         int         i;
         bool        isautodiff;
@@ -31 +32 @@
 
         #ifdef _HAVE_ADOLC_
-                /*initialize a placeholder to store solver pointers: {{{*/
-                GenericParam<Adolc_edf> *theAdolcEDF_p=new GenericParam<Adolc_edf>(AdolcParamEnum);
+        /*initialize a placeholder to store solver pointers*/
+        GenericParam<Adolc_edf> *theAdolcEDF_p=new GenericParam<Adolc_edf>(AdolcParamEnum);
 
-                /*Solver pointers depend on what type of solver we are implementing: */
-                options=OptionsFromAnalysis(&toolkit,parameters,DefaultAnalysisEnum);
-                ToolkitOptions::Init(toolkit,options);
-                xDelete<char>(toolkit);
+        /*Solver pointers depend on what type of solver we are implementing: */
+        options=OptionsFromAnalysis(&toolkit,parameters,DefaultAnalysisEnum);
+        ToolkitOptions::Init(toolkit,options);
+        xDelete<char>(toolkit);
 
-                switch(IssmSolverTypeFromToolkitOptions()){
-                        case MumpsEnum:{
-                                #ifdef _HAVE_MUMPS_
-                                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p=reg_ext_fct(mumpsSolveEDF);
-                                #else
-                                _error_("requesting mumps solver without MUMPS being compiled in!");
-                                #endif
-                                break;
+        switch(IssmSolverTypeFromToolkitOptions()){
+                case MumpsEnum:{
+                                                                #ifdef _HAVE_MUMPS_
+                                                                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p=reg_ext_fct(mumpsSolveEDF);
+                                                                #else
+                                                                _error_("requesting mumps solver without MUMPS being compiled in!");
+                                                                #endif
+                                                                break;
                                                         }
-                        case GslEnum: {
-                                #ifdef _HAVE_GSL_
-                                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p=reg_ext_fct(EDF_for_solverx);
-                                #else
-                                _error_("requesting GSL solver without GSL being compiled in!");
-                                #endif
-                            break;
+                case GslEnum: {
+                                                          #ifdef _HAVE_GSL_
+                                                          theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p=reg_ext_fct(EDF_for_solverx);
+                                                          #else
+                                                          _error_("requesting GSL solver without GSL being compiled in!");
+                                                          #endif
+                                                          break;
                                                   }
-                        default:
-                                _error_("solver type not supported yet!");
-                }
+                default:
+                                                _error_("solver type not supported yet!");
+        }
 
-                // to save some space:
-                // we know we won't use adolc inside of  the solver:
-                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->nestedAdolc=false;
-                // the solution vector is just allocated and doesn't have a meaningful prior value
-                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->dp_y_priorRequired=false;
-                // the solver wrapper makes sure the matrix and the right hand side don't change
-                theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->dp_x_changes=false;
-                parameters->AddObject(theAdolcEDF_p);
+        // to save some space:
+        // we know we won't use adolc inside of  the solver:
+        theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->nestedAdolc=false;
+        // the solution vector is just allocated and doesn't have a meaningful prior value
+        theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->dp_y_priorRequired=false;
+        // the solver wrapper makes sure the matrix and the right hand side don't change
+        theAdolcEDF_p->GetParameterValue().myEDF_for_solverx_p->dp_x_changes=false;
+        parameters->AddObject(theAdolcEDF_p);
 
-                /*Free resources: */
-                xDelete<char>(options);
-                /*}}}*/
-                #elif _HAVE_CODIPACK_
-                //fprintf(stderr, "*** Codipack CreateParametersAutodiff()\n");
-                /*initialize a placeholder to store solver pointers: {{{*/
-                /*Solver pointers depend on what type of solver we are implementing: */
-                options=OptionsFromAnalysis(&toolkit,parameters,DefaultAnalysisEnum);
-                ToolkitOptions::Init(toolkit,options);
-                xDelete<char>(toolkit);
+        /*Free resources: */
+        xDelete<char>(options);
 
-                switch(IssmSolverTypeFromToolkitOptions()){
-                        case MumpsEnum:{
-                                #ifndef _HAVE_MUMPS_
-                                _error_("CoDiPack: requesting mumps solver without MUMPS being compiled in!");
-                                #endif
-                                break;
-                                }
-                        case GslEnum: {
-                                #ifndef _HAVE_GSL_
-                                _error_("CoDiPack: requesting GSL solver without GSL being compiled in!");
-                                #endif
-                                break;
-                                }
-                        default:
-                                                        _error_("solver type not supported yet!");
-                }
-                /*Free resources: */
-                xDelete<char>(options);
-                #endif
-                #if defined(_HAVE_AD_) 
+        #elif _HAVE_CODIPACK_
+        /*initialize a placeholder to store solver pointers*/
+        /*Solver pointers depend on what type of solver we are implementing: */
+        options=OptionsFromAnalysis(&toolkit,parameters,DefaultAnalysisEnum);
+        ToolkitOptions::Init(toolkit,options);
+        xDelete<char>(toolkit);
+
+        switch(IssmSolverTypeFromToolkitOptions()){
+                case MumpsEnum:{
+                                                                #ifndef _HAVE_MUMPS_
+                                                                _error_("CoDiPack: requesting mumps solver without MUMPS being compiled in!");
+                                                                #endif
+                                                                break;
+                                                        }
+                case GslEnum: {
+                                                          #ifndef _HAVE_GSL_
+                                                          _error_("CoDiPack: requesting GSL solver without GSL being compiled in!");
+                                                          #endif
+                                                          break;
+                                                  }
+                default:
+                                                _error_("solver type not supported yet!");
+        }
+        /*Free resources: */
+        xDelete<char>(options);
+        #endif
 
         if(isautodiff){
@@ -118 +117 @@
                 #endif
 
-                /*retrieve driver: {{{*/
+                /*retrieve driver:*/
                 iomodel->FindConstant(&autodiff_driver,"md.autodiff.driver");
                 parameters->AddObject(iomodel->CopyConstantObject("md.autodiff.driver",AutodiffDriverEnum));
@@ -143 +142 @@
                 }
                 xDelete<char>(autodiff_driver);
-                /*}}}*/
-                /*Deal with dependents first: {{{*/
+
+                /*Deal with dependents first:*/
+
                 iomodel->FindConstant(&num_dependent_objects,"md.autodiff.num_dependent_objects");
                 dependent_objects=new DataSet();
@@ -168 +168 @@
                 parameters->AddObject(new DataSetParam(AutodiffDependentObjectsEnum,dependent_objects));
                 parameters->AddObject(new IntParam(AutodiffNumDependentsEnum,num_dep));
+                delete dependent_objects;
 
-                delete dependent_objects;
-                /*}}}*/
-                /*Deal with independents: {{{*/
+                /*Deal with independents*/
 
                 /*Independents have already been recovered in iomodel->DeclareIndependents. Just do some more processing. 
@@ -184 +183 @@
                         xDelete<IssmDouble>(xp);
                 }
-                /*}}}*/
         }
         #endif