Parameters.cpp File Reference

#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
#include "./Parameters.h"
#include "./Param.h"
#include "./BoolParam.h"
#include "./DoubleMatParam.h"
#include "./DataSetParam.h"
#include "./DoubleParam.h"
#include "./DoubleVecParam.h"
#include "./IntParam.h"
#include "./IntVecParam.h"
#include "./IntMatParam.h"
#include "./FileParam.h"
#include "./MatrixParam.h"
#include "./VectorParam.h"
#include "./StringArrayParam.h"
#include "./StringParam.h"
#include "./DoubleMatArrayParam.h"
#include "./TransientParam.h"
#include "./TransientArrayParam.h"
#include "../../shared/shared.h"
#include "../../toolkits/toolkits.h"

Go to the source code of this file.

Functions
char *	OptionsFromAnalysis (char **pouttoolkit, Parameters *parameters, int analysis_type)

Function Documentation

OptionsFromAnalysis()

char* OptionsFromAnalysis	(	char **	pouttoolkit,
		Parameters *	parameters,
		int	analysis_type
	)

Definition at line 595 of file Parameters.cpp.

                                                                                      { /*{{{*/
 
   /* figure out ISSM options for current analysis, return a string. */
 
   /*output: */
   char *outstring  = NULL;
   char *outtoolkit = NULL;
 
   /*intermediary: */
   int          dummy;
   int         *analyses    = NULL;
   char       **strings     = NULL;
   char        *string      = NULL;
   char       **toolkits    = NULL;
   char        *toolkit     = NULL;
   int          numanalyses;
   int          found       = -1;
   int          i;
 
   parameters->FindParam(&strings,&numanalyses,ToolkitsOptionsStringsEnum);
   parameters->FindParam(&toolkits,&dummy,ToolkitsTypesEnum); _assert_(dummy==numanalyses);
   parameters->FindParam(&analyses,&dummy,ToolkitsOptionsAnalysesEnum); _assert_(dummy==numanalyses);
 
   if(numanalyses==0)return NULL; //we did not find petsc options, don't bother.
 
   /*ok, go through analyses and figure out if it corresponds to our analysis_type: */
   for(i=0;i<numanalyses;i++){
      if(analyses[i]==analysis_type){
         found=i;
         break;
      }
   }
   if(found==-1){
      /*still haven't found a list of petsc options, go find the default one, for analysis type DefaultAnalysisEnum: */
      for(i=0;i<numanalyses;i++){
         if(analyses[i]==DefaultAnalysisEnum){
            found=i;
            break;
         }
      }
   }
   if(found==-1){
      _error_("could find neither a default analysis nor analysis " << EnumToStringx(analysis_type));
   }
 
   /*1. Grab the option toolkit: */
   outtoolkit=xNew<char>(strlen(toolkits[found])+1);
   strcpy(outtoolkit,toolkits[found]);
   *pouttoolkit = outtoolkit;
 
   /*2. Grab the option string: */
   outstring=xNew<char>(strlen(strings[found])+1);
   strcpy(outstring,strings[found]);
 
   /*Free ressources*/
   for(i=0;i<numanalyses;i++){
      xDelete<char>(toolkits[i]);
      xDelete<char>(strings[i]);
   }
   xDelete<char*>(toolkits);
   xDelete<char*>(strings);
   xDelete<int>(analyses);
   return outstring;
}