std::string ConfigFile::GetStringVA(const char* block, const char* def, const char* name, ...)
{
va_list ap;
va_start(ap, name);
char str[150];
vsnprintf(str, 150, name, ap);
va_end(ap);
return GetStringDefault(str, block, def);
}
inline MOptionValue GetOptionValue(wxConfigBase *config, const MOption opt)
{
MOptionValue value;
const char *name = GetOptionName(opt);
if ( IsNumeric(opt) )
value.Set(config->Read(name, GetNumericDefault(opt)));
else
value.Set(config->Read(name, GetStringDefault(opt)));
return value;
}
bool ConfigFile::GetString(const char* block, char* buffer, const char* name, const char* def, uint32 len)
{
string val = GetStringDefault(block, name, def);
size_t blen = val.length();
if (blen > len)
blen = len;
memcpy(buffer, val.c_str(), blen);
buffer[blen] = 0;
return true;
}
/* static */
wxImage &
wxIconManager::LoadImage(String filename, bool *success, bool showDlg)
{
bool loaded = false;
wxImage *img = new wxImage();
// If we haven't been called yet, find out which image handlers
// are supported:
if(! m_knowHandlers) // first time initialisation
{
ms_NumOfHandlers = 0;
for ( int i = 0; m_wxBitmapHandlers[i] != wxBITMAP_TYPE_MAX; i++ )
{
if ( !wxImage::FindHandler(m_wxBitmapHandlers[i]) )
m_wxBitmapHandlers[i] = wxBITMAP_TYPE_INVALID; // not available
else
ms_NumOfHandlers ++;
}
m_knowHandlers = true;
}
// suppress any error logging from image handlers, some of them
// will fail.
{
wxLogNull logNo;
for ( int i = 0; m_wxBitmapHandlers[i] != wxBITMAP_TYPE_MAX; i++ )
{
if ( m_wxBitmapHandlers[i] != wxBITMAP_TYPE_INVALID )
{
if ( img->LoadFile(filename, m_wxBitmapHandlers[i]) )
break;
}
}
} // normal logging again
#ifdef OS_UNIX
if(! loaded) // try to use imageMagick to convert image to another format:
{
String oldfilename = filename;
String tempfile = filename;
int format = READ_APPCONFIG(MP_TMPGFXFORMAT);
if((format < 0 || format > NUMBER_OF_FORMATS)
|| (format != 0 &&
m_wxBitmapHandlers[format] == wxBITMAP_TYPE_XPM)) //xpm we do ourselves
{
wxLogInfo(_("Unsupported intermediary image format '%s' specified,\n"
"reset to '%s'."),
((format < 0 || format >NUMBER_OF_FORMATS) ?
_T("unknown") : HandlerNames[format]),
HandlerNames[0]);
format = 0;
mApplication->GetProfile()->writeEntry(MP_TMPGFXFORMAT,format);
}
tempfile += wxIconManagerFileExtensions[format];
// strip leading path
int i = tempfile.Length();
while(i && tempfile.c_str()[i] != '/')
i--;
tempfile.assign(tempfile,i+1,tempfile.length()-1-i);
tempfile = String(
(wxGetenv(_T("TMP")) && wxStrlen(wxGetenv(_T("TMP"))))
? wxGetenv(_T("TMP")) : _T("/tmp")
) + _T('/') + tempfile;
if(wxFile::Exists(filename))
{
String strConvertProgram = READ_APPCONFIG(MP_CONVERTPROGRAM);
String strFormatSpec = strutil_extract_formatspec(strConvertProgram);
if ( strFormatSpec != _T("ss") )
{
wxLogError(_("The setting for image conversion program should include "
"exactly two '%%s' format specificators.\n"
"The current setting '%s' is incorrect and "
"the default value will be used instead."),
strConvertProgram.c_str());
strConvertProgram = GetStringDefault(MP_CONVERTPROGRAM);
}
String command;
command.Printf(strConvertProgram, filename.c_str(), tempfile.c_str());
wxLogTrace(wxTraceIconLoading,
_T("wxIconManager::LoadImage() calling '%s'..."),
command.c_str());
if(wxSystem(command) == 0)
{
wxLogNull lo; // suppress error messages
if(format != 0) // not xpm which we handle internally
{
switch(format)
{
case 1: // PNG!
loaded = img->LoadFile(tempfile, wxBITMAP_TYPE_PNG);
break;
case 2: // 2 BMP
loaded = img->LoadFile(tempfile, wxBITMAP_TYPE_BMP);
break;
case 3: // 3 JPG
loaded = img->LoadFile(tempfile, wxBITMAP_TYPE_JPEG);
break;
}
}
} // system()
if(tempfile.length()) // using a temporary file
wxRemoveFile(tempfile);
}// if(wxFile::Exists())
}//! loaded
#endif // OS_UNIX
// if everything else failed, try xpm loading:
if( !loaded ) // try our own XPM loading code
{
char ** cpptr = LoadImageXpm(filename);
if(cpptr)
{
*img = wxBitmap(cpptr).ConvertToImage();
wxIconManager::FreeImage(cpptr);
loaded = true;
}
}
if(success)
*success = loaded;
return *img;
}
PFModule *KinsolNonlinSolverNewPublicXtra()
{
PFModule *this_module = ThisPFModule;
PublicXtra *public_xtra;
char *switch_name;
char key[IDB_MAX_KEY_LEN];
int switch_value;
NameArray switch_na;
NameArray verbosity_switch_na;
NameArray eta_switch_na;
NameArray globalization_switch_na;
NameArray precond_switch_na;
public_xtra = ctalloc(PublicXtra, 1);
sprintf(key, "Solver.Nonlinear.ResidualTol");
(public_xtra->residual_tol) = GetDoubleDefault(key, 1e-7);
sprintf(key, "Solver.Nonlinear.StepTol");
(public_xtra->step_tol) = GetDoubleDefault(key, 1e-7);
sprintf(key, "Solver.Nonlinear.MaxIter");
(public_xtra->max_iter) = GetIntDefault(key, 15);
sprintf(key, "Solver.Linear.KrylovDimension");
(public_xtra->krylov_dimension) = GetIntDefault(key, 10);
sprintf(key, "Solver.Linear.MaxRestarts");
(public_xtra->max_restarts) = GetIntDefault(key, 0);
verbosity_switch_na = NA_NewNameArray("NoVerbosity LowVerbosity "
"NormalVerbosity HighVerbosity");
sprintf(key, "Solver.Nonlinear.PrintFlag");
switch_name = GetStringDefault(key, "LowVerbosity");
(public_xtra->print_flag) = NA_NameToIndex(verbosity_switch_na,
switch_name);
NA_FreeNameArray(verbosity_switch_na);
eta_switch_na = NA_NewNameArray("EtaConstant Walker1 Walker2");
sprintf(key, "Solver.Nonlinear.EtaChoice");
switch_name = GetStringDefault(key, "Walker2");
switch_value = NA_NameToIndex(eta_switch_na, switch_name);
switch (switch_value)
{
case 0:
{
public_xtra->eta_choice = ETACONSTANT;
public_xtra->eta_value
= GetDoubleDefault("Solver.Nonlinear.EtaValue", 1e-4);
public_xtra->eta_alpha = 0.0;
public_xtra->eta_gamma = 0.0;
break;
}
case 1:
{
public_xtra->eta_choice = ETACHOICE1;
public_xtra->eta_alpha = 0.0;
public_xtra->eta_gamma = 0.0;
break;
}
case 2:
{
public_xtra->eta_choice = ETACHOICE2;
public_xtra->eta_alpha
= GetDoubleDefault("Solver.Nonlinear.EtaAlpha", 2.0);
public_xtra->eta_gamma
= GetDoubleDefault("Solver.Nonlinear.EtaGamma", 0.9);
public_xtra->eta_value = 0.0;
break;
}
default:
{
InputError("Error: Invalid value <%s> for key <%s>\n", switch_name,
key);
}
}
NA_FreeNameArray(eta_switch_na);
switch_na = NA_NewNameArray("False True");
sprintf(key, "Solver.Nonlinear.UseJacobian");
switch_name = GetStringDefault(key, "False");
switch_value = NA_NameToIndex(switch_na, switch_name);
switch (switch_value)
{
case 0:
{
(public_xtra->matvec) = NULL;
break;
}
case 1:
{
(public_xtra->matvec) = KINSolMatVec;
break;
}
default:
{
InputError("Error: Invalid value <%s> for key <%s>\n", switch_name,
key);
}
}
NA_FreeNameArray(switch_na);
sprintf(key, "Solver.Nonlinear.DerivativeEpsilon");
(public_xtra->derivative_epsilon) = GetDoubleDefault(key, 1e-7);
globalization_switch_na = NA_NewNameArray("InexactNewton LineSearch");
sprintf(key, "Solver.Nonlinear.Globalization");
switch_name = GetStringDefault(key, "LineSearch");
switch_value = NA_NameToIndex(globalization_switch_na, switch_name);
switch (switch_value)
{
case 0:
{
(public_xtra->globalization) = INEXACT_NEWTON;
break;
}
case 1:
{
(public_xtra->globalization) = LINESEARCH;
break;
}
default:
{
InputError("Error: Invalid value <%s> for key <%s>\n", switch_name,
key);
}
}
NA_FreeNameArray(globalization_switch_na);
precond_switch_na = NA_NewNameArray("NoPC MGSemi SMG PFMG PFMGOctree");
sprintf(key, "Solver.Linear.Preconditioner");
switch_name = GetStringDefault(key, "MGSemi");
switch_value = NA_NameToIndex(precond_switch_na, switch_name);
if (switch_value == 0)
{
(public_xtra->precond) = NULL;
(public_xtra->pcinit) = NULL;
(public_xtra->pcsolve) = NULL;
}
else if (switch_value > 0)
{
(public_xtra->precond) = PFModuleNewModuleType(
KinsolPCNewPublicXtraInvoke,
KinsolPC,
(key, switch_name));
(public_xtra->pcinit) = (KINSpgmrPrecondFn)KINSolInitPC;
(public_xtra->pcsolve) = (KINSpgmrPrecondSolveFn)KINSolCallPC;
}
else
{
InputError("Error: Invalid value <%s> for key <%s>\n", switch_name,
key);
}
NA_FreeNameArray(precond_switch_na);
public_xtra->nl_function_eval = PFModuleNewModule(NlFunctionEval, ());
public_xtra->neq = ((public_xtra->max_restarts) + 1)
* (public_xtra->krylov_dimension);
if (public_xtra->matvec != NULL)
public_xtra->richards_jacobian_eval =
PFModuleNewModuleType(
RichardsJacobianEvalNewPublicXtraInvoke,
RichardsJacobianEval,
("Solver.Nonlinear.Jacobian"));
else
public_xtra->richards_jacobian_eval = NULL;
(public_xtra->time_index) = RegisterTiming("KINSol");
PFModulePublicXtra(this_module) = public_xtra;
return this_module;
}
