Changeset 15009

Timestamp:

05/10/13 15:55:24 (12 years ago)

Author:

Mathieu Morlighem

Message:

CHG: moved DakotaPlugin to dakota_core.cpp

Location:

issm/trunk-jpl/src/c

Files:

• Makefile.am (modified) (1 diff)
• analyses/dakota_core.cpp (modified) (1 diff)
• classes/classes.h (modified) (1 diff)
• classes/dakota (deleted)

issm/trunk-jpl/src/c/Makefile.am

@@ -341 +341 @@
 #}}}
 #DAKOTA sources  {{{
-dakota_sources = ./classes/dakota/DakotaPlugin.h\
-                                          ./classes/dakota/DakotaPlugin.cpp\
-                                          ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h\
+dakota_sources = ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.h\
                                           ./modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp\
                                           ./modules/InputUpdateFromVectorDakotax/InputUpdateFromVectorDakotax.h\

issm/trunk-jpl/src/c/analyses/dakota_core.cpp

@@ -46 +46 @@
 #include <DakotaInterface.H>
 #include "./DakotaSpawnCore.h"
-#include "../classes/dakota/DakotaPlugin.h"
+#endif
+/*}}}*/
+/*DakotaPlugin class {{{*/
+#ifdef _HAVE_DAKOTA_ //only works if dakota library has been compiled in.
+#include <DirectApplicInterface.H>
+#include <DakotaResponse.H>
+#include <ParamResponsePair.H>
+#include <system_defs.h>
+#include <ProblemDescDB.H>
+#include <ParallelLibrary.H>
+namespace SIM {
+        class DakotaPlugin: public Dakota::DirectApplicInterface{
+                public:
+                        /*these fields are used by core solutions: */
+                        void *femmodel;
+                        int   counter;
+                        /*Constructors/Destructors*/
+                        DakotaPlugin(const Dakota::ProblemDescDB& problem_db,void* in_femmodel):Dakota::DirectApplicInterface(problem_db){/*{{{*/
+                                femmodel = in_femmodel;
+                                counter  = 0;
+                        }/*}}}*/
+                        ~DakotaPlugin(){/*{{{*/
+                                /* Virtual destructor handles referenceCount at Interface level. */ 
+                        }/*}}}*/
+                protected:
+                        /*execute the input filter portion of a direct evaluation invocation*/
+                        //int derived_map_if(const Dakota::String& if_name);
+                        /*execute an analysis code portion of a direct evaluation invocation*/
+                        int derived_map_ac(const Dakota::String& driver){/*{{{*/
+
+                                int i;
+                                IssmDouble* variables=NULL;
+                                char** variable_descriptors=NULL;
+                                char*  variable_descriptor=NULL;
+                                IssmDouble* responses=NULL;
+
+                                /*increae counter: */
+                                counter++;
+
+                                /*Before launching analysis, we need to transfer the dakota inputs into Issm 
+                                 *readable variables: */
+
+                                /*First, the variables: */
+                                variables=xNew<IssmDouble>(numACV);
+                                for(i=0;i<numACV;i++){
+                                        variables[i]=xC[i];
+                                }
+                                /*The descriptors: */
+                                variable_descriptors=xNew<char*>(numACV);
+                                for(i=0;i<numACV;i++){
+                                        std::string label=xCLabels[i];
+                                        variable_descriptor=xNew<char>(strlen(label.c_str())+1);
+                                        memcpy(variable_descriptor,label.c_str(),(strlen(label.c_str())+1)*sizeof(char));
+
+                                        variable_descriptors[i]=variable_descriptor;
+                                }
+
+                                /*Initialize responses: */
+                                responses=xNewZeroInit<IssmDouble>(numFns);
+
+                                /*run core solution: */
+                                DakotaSpawnCore(responses,numFns, variables,variable_descriptors,numACV,femmodel,counter);
+
+                                /*populate responses: */
+                                for(i=0;i<numFns;i++){
+                                        fnVals[i]=responses[i];
+                                }
+
+                                /*Free ressources:*/
+                                xDelete<IssmDouble>(variables);
+                                for(i=0;i<numACV;i++){
+                                        variable_descriptor=variable_descriptors[i];
+                                        xDelete<char>(variable_descriptor);
+                                }
+                                xDelete<char*>(variable_descriptors);
+                                xDelete<IssmDouble>(responses);
+
+                                return 0;
+                        }/*}}}*/
+                        /*execute the output filter portion of a direct evaluation invocation*/
+                        //int derived_map_of(const Dakota::String& of_name);
+                        /*add for issm: */
+                        int GetCounter(){/*{{{*/
+                                return counter;
+                        }/*}}}*/
+                private:
+        };
+} 
 #endif
 /*}}}*/

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

@@ -24 +24 @@
 #include "./kriging/krigingobjects.h"
 
-/*dakota:*/
-//#include "./dakota/DakotaPlugin.h"
-
 /*diverse: */
 #include "./Hook.h"