IssmDirectApplicInterface.h

Go to the documentation of this file.

 
/*Issm Configuration: {{{*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#else
#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
#endif 
/*}}}*/
 
#if !defined(_WRAPPERS_) && defined(_HAVE_DAKOTA_) && (_DAKOTA_MAJOR_ <= 5) //this only works for Dakota <=5, which had no effective parallel capabilities yet.
 
/*Dakota include files:{{{*/
#if (_DAKOTA_MAJOR_ < 5 || (_DAKOTA_MAJOR_ == 5 && _DAKOTA_MINOR_ < 3))
#include <DirectApplicInterface.H>
#include <DakotaResponse.H>
#include <ParamResponsePair.H>
#include <system_defs.h>
#include <ProblemDescDB.H>
#include <ParallelLibrary.H>
#else
#include <DirectApplicInterface.hpp>
#include <DakotaResponse.hpp>
#include <ParamResponsePair.hpp>
#include <ProblemDescDB.hpp>
#include <ParallelLibrary.hpp>
#endif
/*}}}*/
 
int  DakotaSpawnCore(double* d_responses, int d_numresponses, double* d_variables, char** d_variables_descriptors,int d_numvariables, void* void_femmodel,int counter);
 
/*IssmDirectApplicInterface class */
namespace SIM {
   class IssmDirectApplicInterface: public Dakota::DirectApplicInterface{
      public:
         /*these fields are used by core solutions: */
         void *femmodel;
         int   counter;
         /*Constructors/Destructors*/
         IssmDirectApplicInterface(const Dakota::ProblemDescDB& problem_db,void* in_femmodel):Dakota::DirectApplicInterface(problem_db){/*{{{*/
            femmodel = in_femmodel;
            counter  = 0;
         }/*}}}*/
         ~IssmDirectApplicInterface(){/*{{{*/
            /* 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