int optimizewavefn(int MaxIter, int Omega, int NumTerms, int qmax, int pmax, int IsTriplet, int Ordering, int Method, double alpha, double beta, double gamma)
{
int par[7] = { Omega, NumTerms, qmax, pmax, IsTriplet, Ordering, Method };
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex; //gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
int iter = 0, status;
double size;
x = gsl_vector_alloc(3);
gsl_vector_set(x, 0, alpha);
gsl_vector_set(x, 1, beta);
gsl_vector_set(x, 2, gamma);
/* Set initial step sizes to 1 */
ss = gsl_vector_alloc(3);
gsl_vector_set_all(ss, 0.05);
/* Initialize method and iterate */
minex_func.n = 3;
minex_func.f = (void*)test;
minex_func.params = par;
//s = gsl_multimin_fminimizer_alloc (T, 2);
s = gsl_multimin_fminimizer_alloc(T, 3);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, 1e-5);
if (status == GSL_SUCCESS) {
printf ("converged to minimum at\n");
}
printf ("%5d %10.5e f() = %12.7f size = %.5f\n",
iter,
gsl_vector_get (s->x, 0),
gsl_vector_get (s->x, 1),
gsl_vector_get (s->x, 2),
s->fval, size);
} while (status == GSL_CONTINUE && iter < MaxIter);
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
return 0; //@TODO: How do I make this into a void subroutine?
}
void NMSimplexMinimization::minimizeEnergy(VMC &vmc)
{
const gsl_multimin_fminimizer_type * T = gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer * s = nullptr;
gsl_vector * ss, * x;
gsl_multimin_function minex_func;
int myrank = MPIVMC::MyRank();
vmc_nms w(vmc, *this);
// Starting point
const auto nvp = static_cast<size_t>(vmc.getNVP());
double vpar[nvp];
vmc.getVP(vpar);
x = gsl_vector_alloc(nvp);
for (size_t i = 0; i < nvp; ++i) {
gsl_vector_set(x, i, vpar[i]);
}
// Set initial step sizes to 1
ss = gsl_vector_alloc(nvp);
gsl_vector_set_all(ss, _rstart);
// Initialize method and iterate
minex_func.n = nvp;
minex_func.f = vmc_cost;
minex_func.params = &w;
s = gsl_multimin_fminimizer_alloc(T, nvp);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
size_t iter = 0;
int status;
do {
status = gsl_multimin_fminimizer_iterate(s);
if (status != 0) { break; }
double size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, _rend);
if (myrank == 0) {
if (status == GSL_SUCCESS) {
std::cout << "converged to minimum at" << std::endl;
}
std::cout << iter << " f() = " << s->fval << " size = " << size << std::endl;
}
++iter;
} while (status == GSL_CONTINUE && (_max_n_iter <= 0 || iter < _max_n_iter));
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
}
int
test_f(const char * desc, gsl_multimin_function *f, initpt_function initpt,
const gsl_multimin_fminimizer_type *T)
{
int status;
size_t i, iter = 0;
gsl_vector *x = gsl_vector_alloc (f->n);
gsl_vector *step_size = gsl_vector_alloc (f->n);
gsl_multimin_fminimizer *s;
fcount = 0; gcount = 0;
(*initpt) (x);
for (i = 0; i < f->n; i++)
gsl_vector_set (step_size, i, 1);
s = gsl_multimin_fminimizer_alloc(T, f->n);
gsl_multimin_fminimizer_set (s, f, x, step_size);
#ifdef DEBUG
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
#endif
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
#ifdef DEBUG
printf("%i: \n",iter);
printf("x "); gsl_vector_fprintf (stdout, s->x, "%g");
printf("f(x) %g\n", gsl_multimin_fminimizer_minimum (s));
printf("size: %g\n", gsl_multimin_fminimizer_size (s));
printf("\n");
#endif
status = gsl_multimin_test_size (gsl_multimin_fminimizer_size (s),
1e-3);
}
while (iter < 5000 && status == GSL_CONTINUE);
status |= (fabs(s->fval) > 1e-5);
gsl_test(status, "%s, on %s: %d iter (fn=%d), f(x)=%g",
gsl_multimin_fminimizer_name(s),desc, iter, fcount, s->fval);
gsl_multimin_fminimizer_free(s);
gsl_vector_free(x);
gsl_vector_free(step_size);
return status;
}
static PyObject* multimin_multimin_iterate(PyObject *self,
PyObject *args
) {
if ( ((multimin_multiminObject*)self)->min==NULL || ((multimin_multiminObject*)self)->func==NULL) {
PyErr_SetString(PyExc_RuntimeError,"no function specified!");
return NULL;
}
return PyInt_FromLong(gsl_multimin_fminimizer_iterate(((multimin_multiminObject*)self)->min));
}
double expfit::findmle(double &mleintercept, double &mlelambda, double &mlesigma2) {
size_t iter = 0;
int status;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_vector *x;
gsl_vector *steps;
gsl_multimin_function my_func;
my_func.n = 2;
my_func.f = neglogd;
my_func.params = this;
x = gsl_vector_alloc (2);
steps = gsl_vector_alloc (2);
gsl_vector_set (x, 0, 0.5);
gsl_vector_set (x, 1, 100.0);
gsl_vector_set (steps, 0, 0.01);
gsl_vector_set (steps, 1, 10.0);
T = gsl_multimin_fminimizer_nmsimplex;
s = gsl_multimin_fminimizer_alloc (T, 2);
gsl_multimin_fminimizer_set (s, &my_func, x, steps);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status)
break;
status = gsl_multimin_test_size(gsl_multimin_fminimizer_size(s),1e-3);
if (status == GSL_SUCCESS)
printf ("Minimum found at:\n");
if ( io::debug >= 1){
printf ("%5d %.5f %.5f %10.5f\n", iter,
gsl_vector_get (s->x, 0),
gsl_vector_get (s->x, 1),
s->fval);
}
}
while (status == GSL_CONTINUE && iter < 100);
mleintercept = gsl_vector_get(s->x,0);
mlelambda = gsl_vector_get(s->x,1);
mlesigma2 = s->fval;
gsl_multimin_fminimizer_free (s);
gsl_vector_free (x);
}
double *Fit::fitGslMultimin(int &iterations, int &status) {
double *result = new double[d_p];
// declare input data
struct FitData data = {static_cast<size_t>(d_n),
static_cast<size_t>(d_p),
d_x,
d_y,
d_y_errors,
this};
gsl_multimin_function f;
f.f = d_fsimplex;
f.n = d_p;
f.params = &data;
// step size (size of the simplex)
// can be increased for faster convergence
gsl_vector *ss = gsl_vector_alloc(f.n);
gsl_vector_set_all(ss, 10.0);
// initialize minimizer
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s_min = gsl_multimin_fminimizer_alloc(T, f.n);
gsl_multimin_fminimizer_set(s_min, &f, d_param_init, ss);
// iterate minimization algorithm
for (iterations = 0; iterations < d_max_iterations; iterations++) {
status = gsl_multimin_fminimizer_iterate(s_min);
if (status) break;
double size = gsl_multimin_fminimizer_size(s_min);
status = gsl_multimin_test_size(size, d_tolerance);
if (status != GSL_CONTINUE) break;
}
// grab results
for (int i = 0; i < d_p; i++) result[i] = gsl_vector_get(s_min->x, i);
chi_2 = s_min->fval;
gsl_matrix *J = gsl_matrix_alloc(d_n, d_p);
d_df(s_min->x, (void *)f.params, J);
gsl_multifit_covar(J, 0.0, covar);
if (d_y_error_source == UnknownErrors) {
// multiply covar by variance of residuals, which is used as an estimate for
// the
// statistical errors (this relies on the Y errors being set to 1.0)
gsl_matrix_scale(covar, chi_2 / (d_n - d_p));
}
// free previously allocated memory
gsl_matrix_free(J);
gsl_multimin_fminimizer_free(s_min);
gsl_vector_free(ss);
return result;
}
int cis_data::learnBetaParameters(vector < double > & pval, double & beta_shape1, double & beta_shape2) {
//Set starting point to moment matching estimates
gsl_vector * x = gsl_vector_alloc (2);
gsl_vector_set (x, 0, beta_shape1);
gsl_vector_set (x, 1, beta_shape2);
//Set initial step sizes to shape1 and shape2 scales
gsl_vector * ss = gsl_vector_alloc (2);
gsl_vector_set (ss, 0, beta_shape1/10);
gsl_vector_set (ss, 1, beta_shape2/10);
//Initialize method and iterate
double par [3];
par[0] = 0.0;
par[1] = 0.0;
for (int e = 0 ; e < pval.size(); e ++) {
if (pval[e] == 1.0) pval[e] = 0.99999999;
par[0] += log (pval[e]);
par[1] += log (1 - pval[e]);
}
par[2] = pval.size();
gsl_multimin_function minex_func;
minex_func.n = 2;
minex_func.f = cis_betaLogLikelihood;
minex_func.params = par;
//Initialize optimization machinery
const gsl_multimin_fminimizer_type * T = gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer * s = gsl_multimin_fminimizer_alloc (T, 2);
gsl_multimin_fminimizer_set (s, &minex_func, x, ss);
//Optimization iteration
size_t iter = 0;
int status;
double size;
do {
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status) break;
size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, 0.01);
} while (status == GSL_CONTINUE && iter < 1000);
//Output new beta shape values
beta_shape1 = gsl_vector_get (s->x, 0);
beta_shape2 = gsl_vector_get (s->x, 1);
//Free allocated memory
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free (s);
return (status == GSL_SUCCESS);
}
gsl_multimin_fminimizer * Fit::fitSimplex(gsl_multimin_function f, int &iterations, int &status)
{
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
//size of the simplex
gsl_vector *ss;
//initial vertex size vector
ss = gsl_vector_alloc (f.n);
//set all step sizes to 1 can be increased to converge faster
gsl_vector_set_all (ss, 10.0);
gsl_multimin_fminimizer *s_min = gsl_multimin_fminimizer_alloc (T, f.n);
status = gsl_multimin_fminimizer_set (s_min, &f, d_param_init, ss);
double size;
size_t iter = 0;
bool inRange = true;
for (int i=0; i<d_p; i++){
double p = gsl_vector_get(d_param_init, i);
d_results[i] = p;
if (p < d_param_range_left[i] || p > d_param_range_right[i]){
inRange = false;
break;
}
}
do{
iter++;
status = gsl_multimin_fminimizer_iterate (s_min);
if (status)
break;
for (int i=0; i<d_p; i++){
double p = gsl_vector_get(s_min->x, i);
if (p < d_param_range_left[i] || p > d_param_range_right[i]){
inRange = false;
break;
}
}
if (!inRange)
break;
for (int i=0; i<d_p; i++)
d_results[i] = gsl_vector_get(s_min->x, i);
size = gsl_multimin_fminimizer_size (s_min);
status = gsl_multimin_test_size (size, d_tolerance);
}
while (inRange && status == GSL_CONTINUE && (int)iter < d_max_iterations);
iterations = iter;
gsl_vector_free(ss);
return s_min;
}
/* estimateDelta: estimate pi, delta, and epsilon using
* the Nelder-Mead Simplex algorithm; code adapted
* from Galassi, M., Davies, J., Theiler, J., Gough, B.,
* Jungman, G., Booth, M., Rossi, F. (2005). GNU
* Scientific Library Reference Manual. Edition 1.6,
* for GSL Version 1.6, 17 March 2005, p 472f.
*/
Result *estimateDelta(Node **profilePairs, int numProfiles, Args *args, Result *result, int dist){
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
size_t iter;
int status, numPara;
double size;
globalProfilePairs = profilePairs;
globalNumProfiles = numProfiles;
T = gsl_multimin_fminimizer_nmsimplex;
s = NULL;
iter = 0;
numPara = 1; /* one parameter estimation */
globalPi = result->pi;
globalEpsilon = result->ee;
globalDist = dist;
/* initialize vertex size vector */
ss = gsl_vector_alloc(numPara);
/* set all step sizes */
gsl_vector_set_all(ss, args->s);
/* starting point */
x = gsl_vector_alloc(numPara);
gsl_vector_set(x, 0, args->D);
/* initialize method and iterate */
minex_func.f = &myF;
minex_func.n = numPara;
minex_func.params = (void *)NULL;
s = gsl_multimin_fminimizer_alloc(T, numPara);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if(status)
break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, args->t);
}while(status == GSL_CONTINUE && iter < args->i);
if(status != GSL_SUCCESS)
printf("WARNING: Estimation of \\Delta failed: %d\n",status);
result->de = gsl_vector_get(s->x, 0);
result->l = s->fval;
result->i = iter;
result->rh = rhoFromDelta(result->pi,result->de)/dist;
conf(args, result);
result->rLo = rhoFromDelta(result->pi,result->dUp)/dist;
result->rUp = rhoFromDelta(result->pi,result->dLo)/dist;
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
/* freeMlComp(); */
return result;
}
int main(void) {
double par[5] = { 1.0, 2.0, 10.0, 20.0, 30.0 };
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
size_t iter = 0;
int status;
double size;
/* Starting point */
x = gsl_vector_alloc(2);
gsl_vector_set(x, 0, 5.0);
gsl_vector_set(x, 1, 7.0);
/* Set initial step sizes to 1 */
ss = gsl_vector_alloc(2);
gsl_vector_set_all(ss, 1.0);
/* Initialize method and iterate */
minex_func.n = 2;
minex_func.f = my_f;
minex_func.params = par;
s = gsl_multimin_fminimizer_alloc(T, 2);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do {
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, 1e-2);
if (status == GSL_SUCCESS) {
printf("converged to minimum at\n");
}
printf("%5d %10.3e %10.3e f() = %7.3f size = %.3f\n", iter,
gsl_vector_get(s->x, 0), gsl_vector_get(s->x, 1), s->fval,
size);
} while (status == GSL_CONTINUE && iter < 100);
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
return EXIT_SUCCESS;
}
int Minimizer<dimension>::minimize(const double start[dimension])
{
assert(function && "Minimizer<dimension>::minimize: function pointer"
" must not be zero!");
gsl_multimin_fminimizer *minimizer;
gsl_multimin_function minex_func;
// Set starting point
for (std::size_t i = 0; i < dimension; i++)
gsl_vector_set(minimum_point, i, start[i]);
// Set initial step sizes
gsl_vector_set_all(step_size, initial_step_size);
// Initialize method and iterate
minex_func.n = dimension;
minex_func.f = function;
minex_func.params = parameters;
minimizer = gsl_multimin_fminimizer_alloc(solver_type, dimension);
gsl_multimin_fminimizer_set(minimizer, &minex_func, minimum_point, step_size);
size_t iter = 0;
int status;
do {
iter++;
status = gsl_multimin_fminimizer_iterate(minimizer);
if (status)
break;
const double size = gsl_multimin_fminimizer_size(minimizer);
status = gsl_multimin_test_size(size, precision);
#ifdef ENABLE_VERBOSE
print_state(minimizer, iter);
#endif
} while (status == GSL_CONTINUE && iter < max_iterations);
#ifdef ENABLE_VERBOSE
printf("\tMinimization status = %s\n", gsl_strerror(status));
#endif
// save minimum point and function value
gsl_vector_memcpy(minimum_point, minimizer->x);
minimum_value = minimizer->fval;
gsl_multimin_fminimizer_free(minimizer);
return status;
}
/**
* Do one iteration.
* @return :: true if iterations to be continued, false if they can stop
*/
bool SimplexMinimizer::iterate(size_t) {
int status = gsl_multimin_fminimizer_iterate(m_gslSolver);
if (status) {
m_errorString = gsl_strerror(status);
return false;
}
double size = gsl_multimin_fminimizer_size(m_gslSolver);
status = gsl_multimin_test_size(size, m_epsabs);
if (status != GSL_CONTINUE) {
m_errorString = gsl_strerror(status);
return false;
}
return true;
}
double GSLOptimizer::optimize(unsigned int iter,
const gsl_multimin_fminimizer_type*t,
double ms, double mxs) {
fis_= get_optimized_attributes();
best_score_=std::numeric_limits<double>::max();
unsigned int n= get_dimension();
if (n ==0) {
IMP_LOG(TERSE, "Nothing to optimize" << std::endl);
return get_scoring_function()->evaluate(false);
}
gsl_multimin_fminimizer *s=gsl_multimin_fminimizer_alloc (t, n);
gsl_vector *x= gsl_vector_alloc(get_dimension());
update_state(x);
gsl_vector *ss= gsl_vector_alloc(get_dimension());
gsl_vector_set_all(ss, mxs);
gsl_multimin_function f= internal::create_f_function_data(this);
gsl_multimin_fminimizer_set (s, &f, x, ss);
try {
int status;
do {
--iter;
//update_state(x);
status = gsl_multimin_fminimizer_iterate(s);
if (status) {
IMP_LOG(TERSE, "Ending optimization because of state " << s
<< std::endl);
break;
}
double sz= gsl_multimin_fminimizer_size(s);
status= gsl_multimin_test_size(sz, ms);
update_states();
if (status == GSL_SUCCESS) {
IMP_LOG(TERSE, "Ending optimization because of small size " << sz
<< std::endl);
break;
}
} while (status == GSL_CONTINUE && iter >0);
} catch (AllDone){
}
gsl_vector *ret=gsl_multimin_fminimizer_x (s);
best_score_=gsl_multimin_fminimizer_minimum (s);
write_state(ret);
gsl_multimin_fminimizer_free (s);
gsl_vector_free (x);
return best_score_;
}
static void func_iteration(gsl_multimin_fminimizer *s){
size_t iter = 0;
int status;
double size;
do{
iter++;
status = gsl_multimin_fminimizer_iterate(s); /* 繰り返し計算を1回行う。予期しない問題が発生した場合はエラーコードを返す。 */
if(status) break;
size = gsl_multimin_fminimizer_size(s); /* sのその時点での最小点の最良推定値を返す */
status = gsl_multimin_test_size(size, 1e-3); /* sizeが閾値(1e-3)より小さければGSL_SUCCESS を、そうでなければGSL_CONTINUEを返す。 */
if(status == GSL_SUCCESS){ LOG("converged to minimum at\n");}
LOG("%5zd p=%.5f n=%.5f p0=%.5f f() = %10.5f size = %f\n", iter, gsl_vector_get(s->x, 0), gsl_vector_get(s->x, 1), gsl_vector_get(s->x, 2), gsl_multimin_fminimizer_minimum(s), size);
}while(status == GSL_CONTINUE && iter < 1000);
return;
}
int MultiDimMinimizer::Main(void)
{
double size;
fminimizer_type = gsl_multimin_fminimizer_nmsimplex;
s = gsl_multimin_fminimizer_alloc (fminimizer_type, np);
gsl_multimin_fminimizer_set (s, &F, x, ss);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status) break;
size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, epsabs);
}
while (status == GSL_CONTINUE && iter < max_iter);
return status;
}
void multidim_minimization_simplex()
{
// Position of the minimum (1,2)
double par[2] = { 1.0, 2.0 };
gsl_multimin_function my_func;
my_func.f = &local::my_f;
my_func.n = 2; // the dimension of the system, i.e. the number of components of the vectors x
my_func.params = (void *)∥
// Starting point, x = (5,7)
gsl_vector *x = gsl_vector_alloc(2);
gsl_vector_set(x, 0, 5.0);
gsl_vector_set(x, 1, 7.0);
gsl_vector *step_size = gsl_vector_alloc(2);
gsl_vector_set(step_size, 0, 0.01);
gsl_vector_set(step_size, 1, 0.01);
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = gsl_multimin_fminimizer_alloc(T, 2);
gsl_multimin_fminimizer_set(s, &my_func, x, step_size);
size_t iter = 0;
int status;
do
{
++iter;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
status = gsl_multimin_test_size(s->size, 1e-7);
if (status == GSL_SUCCESS)
printf("Minimum found at:\n");
printf("%5d %.5f %.5f %10.5f\n", iter,
gsl_vector_get(s->x, 0),
gsl_vector_get(s->x, 1),
s->fval);
} while (status == GSL_CONTINUE && iter < 1000);
//
gsl_multimin_fminimizer_free(s);
gsl_vector_free(x);
}
void
solve_by_simulation (struct experiment_params *params)
{
gsl_multimin_function func_info;
int iter;
double err;
func_info.n = params->minimizer_dimen;
func_info.f = compute_error_func;
func_info.params = params;
gsl_multimin_fminimizer_set (params->minimizer,
&func_info,
params->starting_point,
params->minimizer_step_sizes);
iter = 0;
while (1) {
iter++;
if (iter >= 200) {
fprintf (stderr, "can't find minimum\n");
exit (1);
}
if (gsl_multimin_fminimizer_iterate (params->minimizer)) {
fprintf (stderr, "iterate error\n");
exit (1);
}
err = gsl_multimin_fminimizer_minimum (params->minimizer);
if (fabs (err) < .001) {
if (vflag)
printf ("ok %d\n", iter);
break;
}
}
}
/*
* maximize a function
*
*/
void optimize_f(int dim,
gsl_vector* x,
void* params,
double (*f)(const gsl_vector*, void*)) {
gsl_multimin_function obj;
obj.f = f;
obj.n = dim;
obj.params = params;
const gsl_multimin_fminimizer_type * method =
gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer * opt =
gsl_multimin_fminimizer_alloc(method, dim);
gsl_vector * step_size = gsl_vector_alloc(dim);
gsl_vector_set_all(step_size, 1);
gsl_multimin_fminimizer_set(opt, &obj, x, step_size);
int iter = 0, status;
double converged, f_old;
do {
iter++;
f_old = opt->fval;
status = gsl_multimin_fminimizer_iterate(opt);
converged = fabs((f_old - opt->fval) / f_old);
printf("f = %1.15e; conv = %5.3e; size = %5.3e; niter = %03d\n",
opt->fval, converged, opt->size, iter);
} while ((converged > 1e-10) || (iter < 10000));
// while (status == GSL_CONTINUE);
printf("f = %1.15e; conv = %5.3e; niter = %03d\n",
opt->fval, converged, iter);
gsl_multimin_fminimizer_free(opt);
gsl_vector_free(step_size);
}
Parameters CalibratorGaussian::train(const std::vector<ObsEns>& iData) const {
if(iData.size() == 0) {
std::cout << "No data to train on...";
return Parameters();
}
std::vector<float> obs, mean, spread;
obs.resize(iData.size(), Util::MV);
mean.resize(iData.size(), Util::MV);
spread.resize(iData.size(), Util::MV);
// Compute predictors in model
for(int i = 0; i < iData.size(); i++) {
obs[i] = iData[i].first;
std::vector<float> ens = iData[i].second;
mean[i] = Util::calculateStat(ens, Util::StatTypeMean);
spread[i] = Util::calculateStat(ens, Util::StatTypeStd);
}
int N = mean.size();
double* p = new double[1+3*N];
p[0] = N;
for(int n = 0; n < N; n++) {
p[1+n] = obs[n];
p[1+n+N] = mean[n];
p[1+n+2*N] = spread[n];
}
/*
gsl_multimin_function_fdf my_func;
double p[8] = { 0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1 };
my_func.n = 8;
my_func.f = &CalibratorGaussian::my_f;
my_func.df = &CalibratorGaussian::my_df;
my_func.fdf = &CalibratorGaussian::my_fdf;
my_func.params = (void *)p;
*/
gsl_multimin_function my_func;
my_func.n = mNumParameters;
my_func.f = &CalibratorGaussian::my_f;
my_func.params = (void *)p;
// Initialize parameters
gsl_vector* x = gsl_vector_alloc (mNumParameters);
gsl_vector_set (x, 0, 0);
gsl_vector_set (x, 1, 1);
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = gsl_multimin_fminimizer_alloc (T, mNumParameters);
gsl_vector *ss = gsl_vector_alloc (mNumParameters);
gsl_vector_set_all (ss, 0.01);
gsl_multimin_fminimizer_set (s, &my_func, x, ss);
int iter = 0;
int status = GSL_CONTINUE;
do
{
iter++;
gsl_multimin_fminimizer_iterate (s);
double size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, mLogLikelihoodTolerance);
/*
for(int i = 0; i < 4; i++) {
std::cout << gsl_vector_get (s->x, i) << " ";
}
std::cout << std::endl;
*/
}
while (status == GSL_CONTINUE && iter < 5000);
std::vector<float> values(mNumParameters,0);
for(int i = 0; i < mNumParameters; i++) {
values[i] = gsl_vector_get (s->x, i);
}
// gsl_multimin_fdfminimizer_free (s);
gsl_multimin_fminimizer_free (s);
gsl_vector_free (x);
gsl_vector_free (ss);
Parameters par(values);
std::cout << "Num of iterations: " << iter << std::endl;
return par;
}
double GSL_Minimization_Simplex (Parameter_Fitting * F,
gsl_vector * Initial_Guess,
gsl_vector * Solution,
double ( * Function )( const gsl_vector * , void * ) )
{
int i;
//int key;
double value;
Parameter_Space * Space = F->Space;
// Parameter_Model * P = F->P;
const gsl_multimin_fminimizer_type *T =
gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss;
gsl_multimin_function minex_func;
size_t iter = 0;
int status;
double size;
int No_of_PARAMETERS = Space->No_of_PARAMETERS;
double TOLERANCE = Space->TOLERANCE;
int MAX_No_of_ITERATIONS = Space->MAX_No_of_ITERATIONS;
/* Set initial step sizes */
ss = gsl_vector_alloc ( No_of_PARAMETERS );
// gsl_vector_set_all (ss, 0.01);
gsl_vector_memcpy (ss, Space->Accuracy );
/* Initialize method and iterate */
if ( F->Verbose == 1 ) // Rprintf("No_of_PARAMETERS = %d\n", No_of_PARAMETERS);
Rprintf("No_of_PARAMETERS = %d\n", No_of_PARAMETERS);
minex_func.n = No_of_PARAMETERS;
minex_func.f = Function;
minex_func.params = (void *)F;
//s = gsl_multimin_fminimizer_alloc (T, Space->No_of_PARAMETERS);
s = gsl_multimin_fminimizer_alloc (T, No_of_PARAMETERS);
gsl_multimin_fminimizer_set (s, &minex_func, Initial_Guess, ss);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (size, TOLERANCE);
if (F->Verbose == 1) {
if (status == GSL_SUCCESS)
{
// Rprintf("converged to minimum at\n");
Rprintf("converged to minimum at\n");
}
// Rprintf("%5d ", (int)iter);
Rprintf("%5d ", (int)iter);
// for( i=0; i<Space->No_of_PARAMETERS; i++ ) {
// key = Space->Parameter_Index[i];
// Rprintf("%s = %10.3e\t", P->Symbol[key], gsl_vector_get (s->x, i) );
for( i=0; i<No_of_PARAMETERS; i++ ) {
if (i == 0) //printf("Colonization = %10.3e; ", gsl_vector_get (s->x, i) );
Rprintf("Colonization (C) = %10.3e; ", gsl_vector_get (s->x, i) );
if (i == 1) //printf("Extinction = %10.3e; ", gsl_vector_get (s->x, i) );
Rprintf("Extinction (E) = %10.3e; ", gsl_vector_get (s->x, i) );
if (i == 2) //printf("Detectability = %10.3e; ", gsl_vector_get (s->x, i) );
Rprintf("Detectability (D) = %10.3e; ", gsl_vector_get (s->x, i) );
if (i == 3) //printf("Phi_0 = %10.3e\t", gsl_vector_get (s->x, i) );
Rprintf("Phi_0 (P) = %10.3e\t", gsl_vector_get (s->x, i) );
}
//printf("f() = %7.3f size = %.3f\n", s->fval, size);
Rprintf("NLL(C,E,D,P|Data) = %7.3f size = %.3f\n", s->fval, size);
}
}
while (status == GSL_CONTINUE && iter < MAX_No_of_ITERATIONS );
gsl_vector_memcpy (Solution, s->x );
value = s->fval; // Min Value !!!
gsl_vector_free(ss);
gsl_multimin_fminimizer_free (s);
//return status;
return( value );
}
/** ****************************************************************************************************
***** calc an individual logistic regression model
*******************************************************************************************************/
void calc_node_Score_binary_rv_R(network *dag, datamatrix *obsdata, int nodeid, int errverbose,
datamatrix *designmatrix, const double priormean, const double priorsd, const double priorgamshape, const double priorgamscale,
const int maxiters, const double epsabs,int storeModes, double epsabs_inner, int maxiters_inner, double finitestepsize, int verbose,
double h_guess, double h_epsabs, int maxiters_hessian, int ModesONLY,
double max_hessian_error,double myfactor_brent, int maxiters_hessian_brent, double num_intervals_brent)
{
#ifdef NOPRIOR
Rprintf("############ Warning - Priors turned off - use only for checking mlik value! ################\n");
#endif
int i,status=GSL_SUCCESS,sss,index=0,iter;
/*int j;*/
gsl_vector *myBeta,*vectmp1,*vectmp2,*vectmp1long,*vectmp2long,*localbeta,*localbeta2,/* *dgvalues,*/ *finitefactors,/* *factorindexes,*/ *finitestepsize_vec=0,*nmstepsize=0;/** this will hold the parameter point estimates + 1 is for precision of rv's */
struct fnparams gparams;/** for passing to the gsl zero finding functions */
double gvalue;double nm_size=0.0;
gsl_matrix *mattmp2,*mattmp3,*mattmp4,*hessgvalues,*hessgvalues3pt;
double mydet=0.0,logscore=0.0;/*,logscore3pt=0.0;*/
gsl_permutation *initsperm;
gsl_permutation *perm=0;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_multimin_function F;
double lower,upper,lower_f,upper_f;int found=0; double delta=0.0,new_f_min=0.0, finitestepsize_nm=0.0, increLogscale=0.0, best_Error=0.0,best_h=0.0;
const gsl_min_fminimizer_type *T1;
gsl_min_fminimizer *s1;
int n,m;
/* double min_error,cur_error,accurate_logscore=0,accurate_logscore3pt=0,bestsize=0,lowerend,upperend,h_guess,h_epsabs;*/
/*const gsl_min_fminimizer_type *T;
gsl_min_fminimizer *s;
gsl_function F;*/
/*double h_lowerbound[1],h_upperbound[1],h_guess_array[1];
int h_nbd[1];*/
int nDim;/** dimension of optim problem */
int *nbd;/** nbd is an integer array of dimension nDim.
On entry nbd represents the type of bounds imposed on the variables, and must be specified as follows:
nbd(i)=0 if x(i) is unbounded,
1 if x(i) has only a lower bound,
2 if x(i) has both lower and upper bounds, and
3 if x(i) has only an upper bound.
On exit nbd is unchanged.*/
double *lowerbounds,*upperbounds; /* h_gvalue;*//*,lowestHesserror,beststepsize;*/
int failcode;/** check code see R ?optim - if non-zero then a problem **/
double factr=1e-07;/** error size scaler - this is the default value*/
double pgtol=1e-07;/** default value is zero - this is the gradient tolerance - mmm what does that actually mean? */
int fncount,grcount;/** hold number of evaluations */
char msg[60];/** error message */
int trace=errverbose;/** like verbose */
int nREPORT=1000;/** report freq*/
int lmm=5;/** see R ?optim - number of function evals to store - default is 5 */
/** want to find the modes of the function g(betas) where betas=b_0,b_1,,...,tau, the latter being precision */
/** g(betas) is not differentiable as it contains integrals (which themselves need Laplace estimates **/
/** SETUP things which are the same across all data chunks - groups */
/** build design matrix which is designmatrix->datamatrix=X, designmatrix->Y=Y plus priors designmatrix->priorsd, designmatrix->priormean **/
/** NOTE: design matrix here does include the random effect term **/
/** note - numparams does NOT include precision term - numpars +1 */
build_designmatrix_rv(dag,obsdata,priormean, priorsd,priorgamshape,priorgamscale,designmatrix,nodeid,storeModes);
nDim=designmatrix->numparams+1;
lowerbounds=(double *)R_alloc(nDim,sizeof(double*));
upperbounds=(double *)R_alloc(nDim,sizeof(double*));
nbd=(int *)R_alloc(nDim,sizeof(int*));
for(i=0;i<nDim-1;i++){lowerbounds[i]=-DBL_MAX;
upperbounds[i]=DBL_MAX;
nbd[i]=0;}
nbd[nDim-1]=1;lowerbounds[nDim-1]=0.001;/** lower bound for precision */
finitefactors = gsl_vector_alloc(7);/** used to change stepsize in hessian estimate **/
gsl_vector_set(finitefactors,0,1.0E-03);gsl_vector_set(finitefactors,1,1.0E-02);gsl_vector_set(finitefactors,2,1.0E-01);
gsl_vector_set(finitefactors,3,1.0);gsl_vector_set(finitefactors,4,1.0E+01);gsl_vector_set(finitefactors,5,1.0E+02);
gsl_vector_set(finitefactors,6,1.0E+03);
/*factorindexes = gsl_vector_alloc(7);*//** used to change stepsize in hessian estimate **/
/*for(i=0;i<7;i++){gsl_vector_set(factorindexes,i,i);}*/
/** change finite.step.size by 0.1,1, and 10 factors respectively **/
/*dgvalues = gsl_vector_alloc (designmatrix->numparams+1);*//** inc rv precision */
myBeta = gsl_vector_alloc (designmatrix->numparams+1);/** inc rv precision */
vectmp1 = gsl_vector_alloc (designmatrix->numparams);/** scratch space **/
vectmp2 = gsl_vector_alloc (designmatrix->numparams);/** scratch space **/
mattmp2 = gsl_matrix_alloc (obsdata->numDataPts,designmatrix->numparams);
mattmp3 = gsl_matrix_alloc (designmatrix->numparams,designmatrix->numparams);
mattmp4 = gsl_matrix_alloc (designmatrix->numparams,designmatrix->numparams);
initsperm = gsl_permutation_alloc (designmatrix->numparams);/** for use with initial guesses */
vectmp1long = gsl_vector_alloc (obsdata->numDataPts);/** scratch space **/
vectmp2long = gsl_vector_alloc (obsdata->numDataPts);
localbeta = gsl_vector_alloc (designmatrix->numparams);/** scratch space in later functions - excl. precision **/
localbeta2 = gsl_vector_alloc (designmatrix->numparams+1);/** scratch space in later functions - inc. precision **/
hessgvalues = gsl_matrix_alloc (designmatrix->numparams+1,designmatrix->numparams+1);
hessgvalues3pt = gsl_matrix_alloc (designmatrix->numparams+1,designmatrix->numparams+1);
gparams.designdata=designmatrix;
gparams.vectmp1=vectmp1;
gparams.vectmp2=vectmp2;
gparams.mattmp2=mattmp2;
gparams.mattmp3=mattmp3;
gparams.mattmp4=mattmp4;
gparams.perm=initsperm;
gparams.vectmp1long=vectmp1long;
gparams.vectmp2long=vectmp2long;
gparams.beta=localbeta;
gparams.betaincTau=localbeta2;
gparams.epsabs_inner=epsabs_inner;
gparams.maxiters_inner=maxiters_inner;
gparams.verbose=verbose;
gparams.finitestepsize=finitestepsize;
dag->nodeScoresErrCode[nodeid]=0;/** reset error code to no error **/
/*status=GSL_SUCCESS;*/
generate_rv_inits(myBeta,&gparams);
/*Rprintf("starting optimisation\n");*/
/** run a loop over different stepsize - starting with the smallest first as this is more likely successful **/
for(i=0;i<finitefactors->size;i++){/** go forwards through the factors so start with SMALLEST STEPSIZE */
/*Rprintf("step size iteration %d\n",i);*/
failcode=0;/** reset*/
gparams.finitestepsize=gsl_vector_get(finitefactors,i)*finitestepsize;
lbfgsb(nDim, lmm, myBeta->data, lowerbounds, upperbounds, nbd, &gvalue, &g_outer_R,
&rv_dg_outer_R, &failcode,
&gparams,
factr,
pgtol, &fncount, &grcount,
maxiters, msg, trace, nREPORT);
if(!failcode){dag->nodeScoresErrCode[nodeid]=0;/*bestsize=gparams.finitestepsize;*/break;}/** break out of for loop if no error as we are done **/
} /** end of for loop so now have mode estimates */
if(failcode){Rprintf("%s at node %d\n",msg,nodeid+1);/** notify if there is an error and set final error code **/
dag->nodeScoresErrCode[nodeid]=1;
}
gparams.finitestepsize=finitestepsize;/** reset */
if(storeModes){/** keep a copy of the parameter modes found for use later in other function calls etc**/
index=0; /*Rprintf("size of beta=%d %f %f\n",myBeta->size, gsl_vector_get(myBeta,0),gsl_vector_get(myBeta,1));*/
for(i=0;i<dag->numNodes+3;i++){/** roll myBeta into dag->modes into the appropriate columns**/
if(gsl_matrix_get(dag->modes,nodeid,i)!=DBL_MAX){
gsl_matrix_set(dag->modes,nodeid,i,gsl_vector_get(myBeta,index++));}}
/*for(i=0;i<dag->numNodes+3;i++){Rprintf("%e ",gsl_matrix_get(dag->modes,nodeid,i));}Rprintf("\n");*/
}
if(!ModesONLY){/** only want modes so can skip the rest **/
/** now compute the hessian at the step size with lowest error **/
/*Rprintf("starting hessian estimation\n");*/
n=obsdata->numDataPts;
m=designmatrix->numparams+1;/** inc precision */
perm = gsl_permutation_alloc (m);
/** just re-use as much of existing gparams as possible - so names are meaningless e.g. betafixed is actually gvalue */
gparams.betaincTau=myBeta;
gparams.nDim=n;
gparams.mDim=m;
gparams.perm=perm;
gparams.mattmp2=hessgvalues;
gparams.mattmp3=hessgvalues3pt;
gparams.betafixed=gvalue;
F.f = &compute_mlik_nm;
F.params = &gparams;
F.n = 1;
T = gsl_multimin_fminimizer_nmsimplex2;
s = gsl_multimin_fminimizer_alloc (T, 1);
finitestepsize_vec = gsl_vector_alloc (1);
gsl_vector_set (finitestepsize_vec, 0, h_guess);
nmstepsize = gsl_vector_alloc (1);
gsl_vector_set_all (nmstepsize, h_guess);
gsl_multimin_fminimizer_set (s, &F, finitestepsize_vec,nmstepsize);
status = GSL_SUCCESS;
iter=0;
do
{
iter++;/*Rprintf("iter=%d\n",iter);*/
status = gsl_multimin_fminimizer_iterate (s);
if (status)
break;
nm_size = gsl_multimin_fminimizer_size (s);
status = gsl_multimin_test_size (nm_size, h_epsabs);
/*
if (status == GSL_SUCCESS)
{
Rprintf ("converged to minimum at\n");
}
*/
/*Rprintf ("iter=%5d error in mlik=%3.5e using fin.diff step= %3.2e nmsize=%3.2e\n", iter,s->fval,gsl_vector_get (s->x, 0),nm_size);*/
}
while (status == GSL_CONTINUE && iter < maxiters_hessian);
if( (status != GSL_SUCCESS)){/*actual_status=status;*//** copy for use later **/
status=GSL_FAILURE;} /** solution failed to achieve a value below h_epsabs **/
finitestepsize=gsl_vector_get(s->x,0);/** get best fin.diff stepsize **/
finitestepsize_nm=finitestepsize;/** save nelder mead estimate */
dag->hessianError[nodeid]= s->fval;/** get fin.diff error **/
gsl_multimin_fminimizer_free (s);
/** README - it might be possible to avoid the brent by increasing the epsabs error in nelder mead (and no. of iterations), although for hard cases
this probably will not work but may give a little greater accuracy for easier cases, These are the hessian.params arg in R */
if(dag->hessianError[nodeid]!=DBL_MAX && dag->hessianError[nodeid]>max_hessian_error){Rprintf("Error in mlik = %e > tolerance of %e so continuing optimisation using Brent initial guess h=%e\n",
dag->hessianError[nodeid],max_hessian_error,finitestepsize);
/* Rprintf("stepsize after NM= %e\n",finitestepsize);*/
T1 = gsl_min_fminimizer_brent;
s1 = gsl_min_fminimizer_alloc (T1);
/** must find lower and upper such that f(lower)<f(finitestepsize)<f(upper) **/
/** use an interval of lower=finitestepsize/FACTOR, upper=finitestepsize*FACTOR and then start at the lower end and travel up until
find suitable endpoints - seems to work but not exactly fast!**/
best_Error=dag->hessianError[nodeid];/** original error from nelder */
best_h=finitestepsize; /** original stepsize from nelder */
found=0;/** flag for found good result */
lower=finitestepsize/myfactor_brent;
upper=myfactor_brent*finitestepsize;
lower_f=compute_mlik_brent(lower, &gparams);/** value at lower point **/
upper_f=compute_mlik_brent(upper, &gparams);/** value at higher point **/
increLogscale=(gsl_sf_log(upper)-gsl_sf_log(lower))/num_intervals_brent;/** on a log scale */
for(delta=gsl_sf_log(lower)+increLogscale;delta<gsl_sf_log(upper);delta+=increLogscale){/** linear increments on a log scale **/
R_CheckUserInterrupt();/** allow an interupt from R console */
/** find a point which has f(x) lower than f(lower) and f(upper) **/
new_f_min=compute_mlik_brent(gsl_sf_exp(delta), &gparams);
/* Rprintf("lower=%e, delta=%e, upper=%e\n",lower,gsl_sf_exp(delta),upper);*/
if(lower_f>new_f_min && new_f_min<upper_f && get_best_stepsize(gsl_sf_exp(delta),lower,upper,maxiters_hessian_brent,&gparams, &compute_mlik_brent,
s1,&finitestepsize,&(dag->hessianError[nodeid]) )<=max_hessian_error){/** have an interval suitable for bracketing **/
/** above is address so can store error withouth rerunning function */
/*finitestepsize=delta;*/
found=1;
status=GSL_SUCCESS;
break;/** break out of delta - so have found new x_min **/
} else {/** have not got a good enough error but save the best error and stepsize so far found **/
if(dag->hessianError[nodeid]<best_Error){best_Error=dag->hessianError[nodeid];
best_h=finitestepsize;
}
}
} /** end of search for interval and good error **/
if(!found){/** have not found a suitably small error but may have found a better error than nelder mead **/
/** best_Error will either be the original nelder mean value or better, and best_h is the corresponding stepsize**/
dag->hessianError[nodeid]=best_Error;
finitestepsize=best_h;
/** reset back to nelder-mead estimate **/
status=GSL_FAILURE;/** set to failure since we did not achieve the lower error asked for */
Rprintf("failed to meet tolerance of %e and using best error estimate found of %e\n",max_hessian_error,dag->hessianError[nodeid]);}
gsl_min_fminimizer_free (s1);
} /** end of error being too large **/
if(dag->hessianError[nodeid]==DBL_MAX){/** in this case nelder mead could not estimate the hessian error so abort as something is probably
very wrong here */
error("");}/** use the R tryCatch rather than the switch for status below **/
switch(status){ /** choose which type of node we have */
case GSL_SUCCESS:{
/** successful finite diff so now do final computation with the optimal step size **/
/*Rprintf("search for optimal step size : status = %s at nodeid %d\n", gsl_strerror (status),nodeid+1);*/
rv_hessg_outer(myBeta,&gparams, hessgvalues,finitestepsize,hessgvalues3pt);/** EDIT BACK to "finitestepsize" start with LARGEST STEPSIZE **/
/* Rprintf("HESSIAN using stepsize=%e\n",finitestepsize);
for(i1=0;i1<hessgvalues->size1;i1++){
for(i2=0;i2<hessgvalues->size2;i2++){Rprintf("%e ",gsl_matrix_get(hessgvalues,i1,i2));}Rprintf("\n");} */
status=gsl_linalg_LU_decomp(hessgvalues,perm,&sss);
mydet=gsl_linalg_LU_lndet(hessgvalues);/** compute determinant but this might be a nan - overflow? gsl_linalg_LU_lndet*/
logscore= -n*gvalue-0.5*mydet+(m/2.0)*log((2.0*M_PI)/n);/** this is the final value */
if(gsl_isnan(logscore)){logscore= R_NaN;dag->nodeScoresErrCode[nodeid]=2;}
dag->nodeScores[nodeid]=logscore;
break;
}
case GSL_FAILURE: {/** the minimiser did not find a minimum meeting the accuracy requirements and so may be unreliable **/
Rprintf ("-- ERROR! -- search for optimal step size error: status = %s at nodeid %d\n", gsl_strerror (status),nodeid+1);
rv_hessg_outer(myBeta,&gparams, hessgvalues,finitestepsize,hessgvalues3pt);/** start with LARGEST STEPSIZE **/
/*Rprintf("HESSIAN using stepsize=%e\n",finitestepsize);
for(i1=0;i1<hessgvalues->size1;i1++){
for(i2=0;i2<hessgvalues->size2;i2++){Rprintf("%e ",gsl_matrix_get(hessgvalues,i1,i2));}Rprintf("\n");} */
status=gsl_linalg_LU_decomp(hessgvalues,perm,&sss);
mydet=gsl_linalg_LU_lndet(hessgvalues);/** compute determinant but this might be a nan - overflow? gsl_linalg_LU_lndet*/
logscore= -n*gvalue-0.5*mydet+(m/2.0)*log((2.0*M_PI)/n);/** this is the final value */
dag->nodeScoresErrCode[nodeid]=4;
if(gsl_isnan(logscore)){logscore= R_NaN;dag->nodeScoresErrCode[nodeid]=2;}
dag->nodeScores[nodeid]=logscore;
break;
}
default:{Rprintf("got case %s\n",gsl_strerror (status)); error("in default switch in calc_node_Score_binary_rv_R() - should never get here!");}
}
/** try the bounded search for h stepsize rather than one-dim min which needs bound specified **/
} /** end of ModesONLY **/
/** now free up allocated memory **/
for(i=0;i<designmatrix->numUnqGrps;i++){gsl_matrix_free(designmatrix->array_of_designs[i]);
gsl_vector_free(designmatrix->array_of_Y[i]);}
gsl_vector_free(designmatrix->priormean);
gsl_vector_free(designmatrix->priorsd);
gsl_vector_free(designmatrix->priorgamshape);
gsl_vector_free(designmatrix->priorgamscale);
gsl_vector_free(designmatrix->Y);
gsl_matrix_free(designmatrix->datamatrix_noRV);
/*gsl_vector_free(dgvalues);*/
gsl_vector_free(myBeta);
gsl_vector_free(vectmp1);
gsl_vector_free(vectmp2);
gsl_matrix_free(mattmp2);
gsl_matrix_free(mattmp3);
gsl_matrix_free(mattmp4);
gsl_permutation_free(initsperm);
gsl_vector_free(vectmp1long);
gsl_vector_free(vectmp2long);
gsl_vector_free(localbeta);
gsl_vector_free(localbeta2);
gsl_matrix_free(hessgvalues);
gsl_matrix_free(hessgvalues3pt);
gsl_vector_free(finitefactors);
/*gsl_vector_free(factorindexes);*/
if(!ModesONLY){/** didn't allocate these so don't unallocate! */
gsl_permutation_free(perm);
gsl_vector_free(finitestepsize_vec);
gsl_vector_free(nmstepsize);}
/*if(!failcode){*//*}*/
/*dag->nodeScores[nodeid]=logscore;*/
}
/** Fit peaks' offset by minimize the fitting function
*/
void GetDetOffsetsMultiPeaks::fitPeaksOffset(
const size_t inpnparams, const double minD, const double maxD,
const std::vector<double> &vec_peakPosRef,
const std::vector<double> &vec_peakPosFitted,
const std::vector<double> &vec_peakHeights,
FitPeakOffsetResult &fitresult) {
// Set up array for minimization/optimization by GSL library
size_t nparams = inpnparams;
if (nparams > 50)
nparams = 50;
double params[153];
params[0] = static_cast<double>(nparams);
params[1] = minD;
params[2] = maxD;
for (size_t i = 0; i < nparams; i++) {
params[i + 3] = vec_peakPosRef[i];
}
for (size_t i = 0; i < nparams; i++) {
params[i + 3 + nparams] = vec_peakPosFitted[i];
}
// the reason to put these codes here is that nparams may be altered in this
// method
fitresult.peakPosFittedSize = static_cast<double>(vec_peakPosFitted.size());
for (size_t i = 0; i < nparams; i++) {
params[i + 3 + 2 * nparams] =
(vec_peakHeights[i] * vec_peakHeights[i]); // vec_fitChi2[i];
fitresult.chisqSum +=
1. / (vec_peakHeights[i] * vec_peakHeights[i]); // vec_fitChi2[i];
}
// Set up GSL minimzer
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
// Finally do the fitting
size_t nopt = 1;
size_t iter = 0;
int status = 0;
double size;
/* Starting point */
x = gsl_vector_alloc(nopt);
gsl_vector_set_all(x, 0.0);
/* Set initial step sizes to 0.001 */
ss = gsl_vector_alloc(nopt);
gsl_vector_set_all(ss, 0.001);
/* Initialize method and iterate */
minex_func.n = nopt;
minex_func.f = &gsl_costFunction;
minex_func.params = ¶ms;
s = gsl_multimin_fminimizer_alloc(T, nopt);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do {
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, 1e-4);
} while (status == GSL_CONTINUE && iter < 50);
// Output summary to log file
std::string reportOfDiffractionEventCalibrateDetectors = gsl_strerror(status);
/*
g_log.debug() << " Workspace Index = " << wi <<
" Method used = " << " Simplex" <<
" Iteration = " << iter <<
" Status = " << reportOfDiffractionEventCalibrateDetectors <<
" Minimize Sum = " << s->fval <<
" Offset = " << gsl_vector_get (s->x, 0) << " \n";
*/
fitresult.offset = gsl_vector_get(s->x, 0);
fitresult.fitSum = s->fval;
fitresult.fitoffsetstatus = reportOfDiffractionEventCalibrateDetectors;
fitresult.chi2 = s->fval;
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
return;
}
/** Executes the algorithm
*
* @throw runtime_error Thrown if algorithm cannot execute
*/
void Fit1D::exec() {
// Custom initialization
prepare();
// check if derivative defined in derived class
bool isDerivDefined = true;
gsl_matrix *M = NULL;
try {
const std::vector<double> inTest(m_parameterNames.size(), 1.0);
std::vector<double> outTest(m_parameterNames.size());
const double xValuesTest = 0;
JacobianImpl J;
M = gsl_matrix_alloc(m_parameterNames.size(), 1);
J.setJ(M);
// note nData set to zero (last argument) hence this should avoid further
// memory problems
functionDeriv(&(inTest.front()), &J, &xValuesTest, 0);
} catch (Exception::NotImplementedError &) {
isDerivDefined = false;
}
gsl_matrix_free(M);
// Try to retrieve optional properties
int histNumber = getProperty("WorkspaceIndex");
const int maxInterations = getProperty("MaxIterations");
// Get the input workspace
MatrixWorkspace_const_sptr localworkspace = getProperty("InputWorkspace");
// number of histogram is equal to the number of spectra
const size_t numberOfSpectra = localworkspace->getNumberHistograms();
// Check that the index given is valid
if (histNumber >= static_cast<int>(numberOfSpectra)) {
g_log.warning("Invalid Workspace index given, using first Workspace");
histNumber = 0;
}
// Retrieve the spectrum into a vector
const MantidVec &XValues = localworkspace->readX(histNumber);
const MantidVec &YValues = localworkspace->readY(histNumber);
const MantidVec &YErrors = localworkspace->readE(histNumber);
// Read in the fitting range data that we were sent
double startX = getProperty("StartX");
double endX = getProperty("EndX");
// check if the values had been set, otherwise use defaults
if (isEmpty(startX)) {
startX = XValues.front();
modifyStartOfRange(startX); // does nothing by default but derived class may
// provide a more intelligent value
}
if (isEmpty(endX)) {
endX = XValues.back();
modifyEndOfRange(endX); // does nothing by default but derived class may
// previde a more intelligent value
}
int m_minX;
int m_maxX;
// Check the validity of startX
if (startX < XValues.front()) {
g_log.warning("StartX out of range! Set to start of frame.");
startX = XValues.front();
}
// Get the corresponding bin boundary that comes before (or coincides with)
// this value
for (m_minX = 0; XValues[m_minX + 1] < startX; ++m_minX) {
}
// Check the validity of endX and get the bin boundary that come after (or
// coincides with) it
if (endX >= XValues.back() || endX < startX) {
g_log.warning("EndX out of range! Set to end of frame");
endX = XValues.back();
m_maxX = static_cast<int>(YValues.size());
} else {
for (m_maxX = m_minX; XValues[m_maxX] < endX; ++m_maxX) {
}
}
afterDataRangedDetermined(m_minX, m_maxX);
// create and populate GSL data container warn user if l_data.n < l_data.p
// since as a rule of thumb this is required as a minimum to obtained
// 'accurate'
// fitting parameter values.
FitData l_data(this, getProperty("Fix"));
l_data.n =
m_maxX -
m_minX; // m_minX and m_maxX are array index markers. I.e. e.g. 0 & 19.
if (l_data.n == 0) {
g_log.error("The data set is empty.");
throw std::runtime_error("The data set is empty.");
}
if (l_data.n < l_data.p) {
g_log.error(
"Number of data points less than number of parameters to be fitted.");
throw std::runtime_error(
"Number of data points less than number of parameters to be fitted.");
}
l_data.X = new double[l_data.n];
l_data.sigmaData = new double[l_data.n];
l_data.forSimplexLSwrap = new double[l_data.n];
l_data.parameters = new double[nParams()];
// check if histogram data in which case use mid points of histogram bins
const bool isHistogram = localworkspace->isHistogramData();
for (unsigned int i = 0; i < l_data.n; ++i) {
if (isHistogram)
l_data.X[i] =
0.5 * (XValues[m_minX + i] +
XValues[m_minX + i + 1]); // take mid-point if histogram bin
else
l_data.X[i] = XValues[m_minX + i];
}
l_data.Y = &YValues[m_minX];
// check that no error is negative or zero
for (unsigned int i = 0; i < l_data.n; ++i) {
if (YErrors[m_minX + i] <= 0.0) {
l_data.sigmaData[i] = 1.0;
} else
l_data.sigmaData[i] = YErrors[m_minX + i];
}
// create array of fitted parameter. Take these to those input by the user.
// However, for doing the
// underlying fitting it might be more efficient to actually perform the
// fitting on some of other
// form of the fitted parameters. For instance, take the Gaussian sigma
// parameter. In practice it
// in fact more efficient to perform the fitting not on sigma but 1/sigma^2.
// The methods
// modifyInitialFittedParameters() and modifyFinalFittedParameters() are used
// to allow for this;
// by default these function do nothing.
m_fittedParameter.clear();
for (size_t i = 0; i < nParams(); i++) {
m_fittedParameter.push_back(getProperty(m_parameterNames[i]));
}
modifyInitialFittedParameters(
m_fittedParameter); // does nothing except if overwritten by derived class
for (size_t i = 0; i < nParams(); i++) {
l_data.parameters[i] = m_fittedParameter[i];
}
// set-up initial guess for fit parameters
gsl_vector *initFuncArg;
initFuncArg = gsl_vector_alloc(l_data.p);
for (size_t i = 0, j = 0; i < nParams(); i++) {
if (l_data.active[i])
gsl_vector_set(initFuncArg, j++, m_fittedParameter[i]);
}
// set-up GSL container to be used with GSL simplex algorithm
gsl_multimin_function gslSimplexContainer;
gslSimplexContainer.n = l_data.p; // n here refers to number of parameters
gslSimplexContainer.f = &gsl_costFunction;
gslSimplexContainer.params = &l_data;
// set-up GSL least squares container
gsl_multifit_function_fdf f;
f.f = &gsl_f;
f.df = &gsl_df;
f.fdf = &gsl_fdf;
f.n = l_data.n;
f.p = l_data.p;
f.params = &l_data;
// set-up remaining GSL machinery for least squared
const gsl_multifit_fdfsolver_type *T = gsl_multifit_fdfsolver_lmsder;
gsl_multifit_fdfsolver *s = NULL;
if (isDerivDefined) {
s = gsl_multifit_fdfsolver_alloc(T, l_data.n, l_data.p);
gsl_multifit_fdfsolver_set(s, &f, initFuncArg);
}
// set-up remaining GSL machinery to use simplex algorithm
const gsl_multimin_fminimizer_type *simplexType =
gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *simplexMinimizer = NULL;
gsl_vector *simplexStepSize = NULL;
if (!isDerivDefined) {
simplexMinimizer = gsl_multimin_fminimizer_alloc(simplexType, l_data.p);
simplexStepSize = gsl_vector_alloc(l_data.p);
gsl_vector_set_all(simplexStepSize,
1.0); // is this always a sensible starting step size?
gsl_multimin_fminimizer_set(simplexMinimizer, &gslSimplexContainer,
initFuncArg, simplexStepSize);
}
// finally do the fitting
int iter = 0;
int status;
double finalCostFuncVal;
double dof = static_cast<double>(
l_data.n - l_data.p); // dof stands for degrees of freedom
// Standard least-squares used if derivative function defined otherwise
// simplex
Progress prog(this, 0.0, 1.0, maxInterations);
if (isDerivDefined) {
do {
iter++;
status = gsl_multifit_fdfsolver_iterate(s);
if (status) // break if error
break;
status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4);
prog.report();
} while (status == GSL_CONTINUE && iter < maxInterations);
double chi = gsl_blas_dnrm2(s->f);
finalCostFuncVal = chi * chi / dof;
// put final converged fitting values back into m_fittedParameter
for (size_t i = 0, j = 0; i < nParams(); i++)
if (l_data.active[i])
m_fittedParameter[i] = gsl_vector_get(s->x, j++);
} else {
do {
iter++;
status = gsl_multimin_fminimizer_iterate(simplexMinimizer);
if (status) // break if error
break;
double size = gsl_multimin_fminimizer_size(simplexMinimizer);
status = gsl_multimin_test_size(size, 1e-2);
prog.report();
} while (status == GSL_CONTINUE && iter < maxInterations);
finalCostFuncVal = simplexMinimizer->fval / dof;
// put final converged fitting values back into m_fittedParameter
for (unsigned int i = 0, j = 0; i < m_fittedParameter.size(); i++)
if (l_data.active[i])
m_fittedParameter[i] = gsl_vector_get(simplexMinimizer->x, j++);
}
modifyFinalFittedParameters(
m_fittedParameter); // do nothing except if overwritten by derived class
// Output summary to log file
std::string reportOfFit = gsl_strerror(status);
g_log.information() << "Iteration = " << iter << "\n"
<< "Status = " << reportOfFit << "\n"
<< "Chi^2/DoF = " << finalCostFuncVal << "\n";
for (size_t i = 0; i < m_fittedParameter.size(); i++)
g_log.information() << m_parameterNames[i] << " = " << m_fittedParameter[i]
<< " \n";
// also output summary to properties
setProperty("OutputStatus", reportOfFit);
setProperty("OutputChi2overDoF", finalCostFuncVal);
for (size_t i = 0; i < m_fittedParameter.size(); i++)
setProperty(m_parameterNames[i], m_fittedParameter[i]);
std::string output = getProperty("Output");
if (!output.empty()) {
// calculate covariance matrix if derivatives available
gsl_matrix *covar(NULL);
std::vector<double> standardDeviations;
std::vector<double> sdExtended;
if (isDerivDefined) {
covar = gsl_matrix_alloc(l_data.p, l_data.p);
gsl_multifit_covar(s->J, 0.0, covar);
int iPNotFixed = 0;
for (size_t i = 0; i < nParams(); i++) {
sdExtended.push_back(1.0);
if (l_data.active[i]) {
sdExtended[i] = sqrt(gsl_matrix_get(covar, iPNotFixed, iPNotFixed));
iPNotFixed++;
}
}
modifyFinalFittedParameters(sdExtended);
for (size_t i = 0; i < nParams(); i++)
if (l_data.active[i])
standardDeviations.push_back(sdExtended[i]);
declareProperty(
new WorkspaceProperty<API::ITableWorkspace>(
"OutputNormalisedCovarianceMatrix", "", Direction::Output),
"The name of the TableWorkspace in which to store the final "
"covariance matrix");
setPropertyValue("OutputNormalisedCovarianceMatrix",
output + "_NormalisedCovarianceMatrix");
Mantid::API::ITableWorkspace_sptr m_covariance =
Mantid::API::WorkspaceFactory::Instance().createTable(
"TableWorkspace");
m_covariance->addColumn("str", "Name");
std::vector<std::string>
paramThatAreFitted; // used for populating 1st "name" column
for (size_t i = 0; i < nParams(); i++) {
if (l_data.active[i]) {
m_covariance->addColumn("double", m_parameterNames[i]);
paramThatAreFitted.push_back(m_parameterNames[i]);
}
}
for (size_t i = 0; i < l_data.p; i++) {
Mantid::API::TableRow row = m_covariance->appendRow();
row << paramThatAreFitted[i];
for (size_t j = 0; j < l_data.p; j++) {
if (j == i)
row << 1.0;
else {
row << 100.0 * gsl_matrix_get(covar, i, j) /
sqrt(gsl_matrix_get(covar, i, i) *
gsl_matrix_get(covar, j, j));
}
}
}
setProperty("OutputNormalisedCovarianceMatrix", m_covariance);
}
declareProperty(new WorkspaceProperty<API::ITableWorkspace>(
"OutputParameters", "", Direction::Output),
"The name of the TableWorkspace in which to store the "
"final fit parameters");
declareProperty(
new WorkspaceProperty<MatrixWorkspace>("OutputWorkspace", "",
Direction::Output),
"Name of the output Workspace holding resulting simlated spectrum");
setPropertyValue("OutputParameters", output + "_Parameters");
setPropertyValue("OutputWorkspace", output + "_Workspace");
// Save the final fit parameters in the output table workspace
Mantid::API::ITableWorkspace_sptr m_result =
Mantid::API::WorkspaceFactory::Instance().createTable("TableWorkspace");
m_result->addColumn("str", "Name");
m_result->addColumn("double", "Value");
if (isDerivDefined)
m_result->addColumn("double", "Error");
Mantid::API::TableRow row = m_result->appendRow();
row << "Chi^2/DoF" << finalCostFuncVal;
for (size_t i = 0; i < nParams(); i++) {
Mantid::API::TableRow row = m_result->appendRow();
row << m_parameterNames[i] << m_fittedParameter[i];
if (isDerivDefined && l_data.active[i]) {
// perhaps want to scale standard deviations with sqrt(finalCostFuncVal)
row << sdExtended[i];
}
}
setProperty("OutputParameters", m_result);
// Save the fitted and simulated spectra in the output workspace
MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace");
int iSpec = getProperty("WorkspaceIndex");
const MantidVec &inputX = inputWorkspace->readX(iSpec);
const MantidVec &inputY = inputWorkspace->readY(iSpec);
int histN = isHistogram ? 1 : 0;
Mantid::DataObjects::Workspace2D_sptr ws =
boost::dynamic_pointer_cast<Mantid::DataObjects::Workspace2D>(
Mantid::API::WorkspaceFactory::Instance().create(
"Workspace2D", 3, l_data.n + histN, l_data.n));
ws->setTitle("");
ws->getAxis(0)->unit() =
inputWorkspace->getAxis(0)
->unit(); // UnitFactory::Instance().create("TOF");
for (int i = 0; i < 3; i++)
ws->dataX(i)
.assign(inputX.begin() + m_minX, inputX.begin() + m_maxX + histN);
ws->dataY(0).assign(inputY.begin() + m_minX, inputY.begin() + m_maxX);
MantidVec &Y = ws->dataY(1);
MantidVec &E = ws->dataY(2);
double *lOut =
new double[l_data.n]; // to capture output from call to function()
modifyInitialFittedParameters(m_fittedParameter); // does nothing except if
// overwritten by derived
// class
function(&m_fittedParameter[0], lOut, l_data.X, l_data.n);
modifyInitialFittedParameters(m_fittedParameter); // reverse the effect of
// modifyInitialFittedParameters - if any
for (unsigned int i = 0; i < l_data.n; i++) {
Y[i] = lOut[i];
E[i] = l_data.Y[i] - Y[i];
}
delete[] lOut;
setProperty("OutputWorkspace",
boost::dynamic_pointer_cast<MatrixWorkspace>(ws));
if (isDerivDefined)
gsl_matrix_free(covar);
}
// clean up dynamically allocated gsl stuff
if (isDerivDefined)
gsl_multifit_fdfsolver_free(s);
else {
gsl_vector_free(simplexStepSize);
gsl_multimin_fminimizer_free(simplexMinimizer);
}
delete[] l_data.X;
delete[] l_data.sigmaData;
delete[] l_data.forSimplexLSwrap;
delete[] l_data.parameters;
gsl_vector_free(initFuncArg);
return;
}
int main(int argc, char *argv[]) {
FILE *fpin;
FILE *fpout;
double *input_data[2];
int nchan;
gsl_vector *x;
gsl_vector *step_size;
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = NULL;
gsl_multimin_function minex_func;
double size;
const double eps = 1.0e-6;
double *model_spectrum;
int i;
int status;
if(argc!=12) {
fprintf(stderr, "Usage: %s <inputfilename> <frequency> <vmin> <vmax> <tau_core> <tau_env> <vlsr> <vin> <sigma> <tpeak> <outputfile>\n", argv[0]);
exit(1);
}
fpin = fopen(argv[1],"r");
nchan = read_data(fpin,2,132,input_data);
fclose(fpin);
x = gsl_vector_alloc(6);
gsl_vector_set(x,0,atof(argv[5]));
gsl_vector_set(x,1,atof(argv[6]));
gsl_vector_set(x,2,atof(argv[7]));
gsl_vector_set(x,3,atof(argv[8]));
gsl_vector_set(x,4,atof(argv[9]));
gsl_vector_set(x,5,atof(argv[10]));
step_size = gsl_vector_alloc(6);
gsl_vector_set(step_size,0,0.1);
gsl_vector_set(step_size,1,0.1);
gsl_vector_set(step_size,2,0.005);
gsl_vector_set(step_size,3,0.005);
gsl_vector_set(step_size,4,0.005);
gsl_vector_set(step_size,5,0.05);
minex_func.f = hill6core_gsl;
minex_func.n = 6;
minex_func.params = NULL;
hill6core_init(nchan,input_data[0],input_data[1],atof(argv[2]),atof(argv[3]),atof(argv[4]));
s = gsl_multimin_fminimizer_alloc(T,6);
gsl_multimin_fminimizer_set(s,&minex_func,x,step_size);
i=0;
do {
i++;
status=gsl_multimin_fminimizer_iterate(s);
if(status) break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size,eps);
if(status == GSL_SUCCESS) {
printf("converged in %d iterations\n", i);
}
} while(status==GSL_CONTINUE && i<MAXITER);
if(status!=GSL_SUCCESS) {
printf("Failed to converge after %d iterations\n", i);
exit(1);
}
fpout = fopen(argv[11],"w");
fprintf(fpout,"# Tau_c: %g\n",gsl_vector_get(s->x,0));
fprintf(fpout,"# Tau_e: %g\n",gsl_vector_get(s->x,1));
fprintf(fpout,"# Vlsr: %g\n",gsl_vector_get(s->x,2));
fprintf(fpout,"# Vin: %g\n",gsl_vector_get(s->x,3));
fprintf(fpout,"# sigma: %g\n",gsl_vector_get(s->x,4));
fprintf(fpout,"# Tpeak: %g\n",gsl_vector_get(s->x,5));
fprintf(fpout,"# Attained Chisq: %g\n",hill6core_gsl(s->x,NULL));
model_spectrum = hill6core_getfit();
for(i=0; i<nchan; i++) {
fprintf(fpout,"%g\t%g\t%g\n", input_data[0][i],input_data[1][i],model_spectrum[i]);
}
fclose(fpout);
gsl_vector_free(x);
gsl_vector_free(step_size);
gsl_multimin_fminimizer_free(s);
hill6core_free();
free(input_data[0]);
free(input_data[1]);
exit(0);
}
static VALUE rb_gsl_fminimizer_iterate(VALUE obj)
{
gsl_multimin_fminimizer *gmf = NULL;
Data_Get_Struct(obj, gsl_multimin_fminimizer, gmf);
return INT2FIX(gsl_multimin_fminimizer_iterate(gmf));
}
/** Executes the algorithm
*
* @throw runtime_error Thrown if algorithm cannot execute
*/
void DiffractionEventCalibrateDetectors::exec() {
// Try to retrieve optional properties
const int maxIterations = getProperty("MaxIterations");
const double peakOpt = getProperty("LocationOfPeakToOptimize");
// Get the input workspace
EventWorkspace_sptr inputW = getProperty("InputWorkspace");
// retrieve the properties
const std::string rb_params = getProperty("Params");
// Get some stuff from the input workspace
Instrument_const_sptr inst = inputW->getInstrument();
// Build a list of Rectangular Detectors
std::vector<boost::shared_ptr<RectangularDetector>> detList;
// --------- Loading only one bank ----------------------------------
std::string onebank = getProperty("BankName");
bool doOneBank = (onebank != "");
for (int i = 0; i < inst->nelements(); i++) {
boost::shared_ptr<RectangularDetector> det;
boost::shared_ptr<ICompAssembly> assem;
boost::shared_ptr<ICompAssembly> assem2;
det = boost::dynamic_pointer_cast<RectangularDetector>((*inst)[i]);
if (det) {
if (det->getName().compare(onebank) == 0)
detList.push_back(det);
if (!doOneBank)
detList.push_back(det);
} else {
// Also, look in the first sub-level for RectangularDetectors (e.g. PG3).
// We are not doing a full recursive search since that will be very long
// for lots of pixels.
assem = boost::dynamic_pointer_cast<ICompAssembly>((*inst)[i]);
if (assem) {
for (int j = 0; j < assem->nelements(); j++) {
det = boost::dynamic_pointer_cast<RectangularDetector>((*assem)[j]);
if (det) {
if (det->getName().compare(onebank) == 0)
detList.push_back(det);
if (!doOneBank)
detList.push_back(det);
} else {
// Also, look in the second sub-level for RectangularDetectors (e.g.
// PG3).
// We are not doing a full recursive search since that will be very
// long for lots of pixels.
assem2 = boost::dynamic_pointer_cast<ICompAssembly>((*assem)[j]);
if (assem2) {
for (int k = 0; k < assem2->nelements(); k++) {
det = boost::dynamic_pointer_cast<RectangularDetector>(
(*assem2)[k]);
if (det) {
if (det->getName().compare(onebank) == 0)
detList.push_back(det);
if (!doOneBank)
detList.push_back(det);
}
}
}
}
}
}
}
}
// set-up minimizer
std::string inname = getProperty("InputWorkspace");
std::string outname = inname + "2"; // getProperty("OutputWorkspace");
IAlgorithm_sptr algS = createChildAlgorithm("SortEvents");
algS->setProperty("InputWorkspace", inputW);
algS->setPropertyValue("SortBy", "X Value");
algS->executeAsChildAlg();
// Write DetCal File
std::string filename = getProperty("DetCalFilename");
std::fstream outfile;
outfile.open(filename.c_str(), std::ios::out);
if (detList.size() > 1) {
outfile << "#\n";
outfile << "# Mantid Optimized .DetCal file for SNAP with TWO detector "
"panels\n";
outfile << "# Old Panel, nominal size and distance at -90 degrees.\n";
outfile << "# New Panel, nominal size and distance at +90 degrees.\n";
outfile << "#\n";
outfile << "# Lengths are in centimeters.\n";
outfile << "# Base and up give directions of unit vectors for a local\n";
outfile << "# x,y coordinate system on the face of the detector.\n";
outfile << "#\n";
outfile << "# " << DateAndTime::getCurrentTime().toFormattedString("%c")
<< "\n";
outfile << "#\n";
outfile << "6 L1 T0_SHIFT\n";
IComponent_const_sptr source = inst->getSource();
IComponent_const_sptr sample = inst->getSample();
outfile << "7 " << source->getDistance(*sample) * 100 << " 0\n";
outfile << "4 DETNUM NROWS NCOLS WIDTH HEIGHT DEPTH DETD "
"CenterX CenterY CenterZ BaseX BaseY BaseZ "
"UpX UpY UpZ\n";
}
Progress prog(this, 0.0, 1.0, detList.size());
for (int det = 0; det < static_cast<int>(detList.size()); det++) {
std::string par[6];
par[0] = detList[det]->getName();
par[1] = inname;
par[2] = outname;
std::ostringstream strpeakOpt;
strpeakOpt << peakOpt;
par[3] = strpeakOpt.str();
par[4] = rb_params;
// --- Create a GroupingWorkspace for this detector name ------
CPUTimer tim;
IAlgorithm_sptr alg2 =
AlgorithmFactory::Instance().create("CreateGroupingWorkspace", 1);
alg2->initialize();
alg2->setProperty("InputWorkspace", inputW);
alg2->setPropertyValue("GroupNames", detList[det]->getName());
std::string groupWSName = "group_" + detList[det]->getName();
alg2->setPropertyValue("OutputWorkspace", groupWSName);
alg2->executeAsChildAlg();
par[5] = groupWSName;
std::cout << tim << " to CreateGroupingWorkspace\n";
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
gsl_multimin_fminimizer *s = nullptr;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
// finally do the fitting
int nopt = 6;
int iter = 0;
int status = 0;
/* Starting point */
x = gsl_vector_alloc(nopt);
gsl_vector_set(x, 0, 0.0);
gsl_vector_set(x, 1, 0.0);
gsl_vector_set(x, 2, 0.0);
gsl_vector_set(x, 3, 0.0);
gsl_vector_set(x, 4, 0.0);
gsl_vector_set(x, 5, 0.0);
/* Set initial step sizes to 0.1 */
ss = gsl_vector_alloc(nopt);
gsl_vector_set_all(ss, 0.1);
/* Initialize method and iterate */
minex_func.n = nopt;
minex_func.f = &Mantid::Algorithms::gsl_costFunction;
minex_func.params = ∥
s = gsl_multimin_fminimizer_alloc(T, nopt);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do {
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
double size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, 1e-2);
} while (status == GSL_CONTINUE && iter < maxIterations &&
s->fval != -0.000);
// Output summary to log file
if (s->fval != -0.000)
movedetector(gsl_vector_get(s->x, 0), gsl_vector_get(s->x, 1),
gsl_vector_get(s->x, 2), gsl_vector_get(s->x, 3),
gsl_vector_get(s->x, 4), gsl_vector_get(s->x, 5), par[0],
getProperty("InputWorkspace"));
else {
gsl_vector_set(s->x, 0, 0.0);
gsl_vector_set(s->x, 1, 0.0);
gsl_vector_set(s->x, 2, 0.0);
gsl_vector_set(s->x, 3, 0.0);
gsl_vector_set(s->x, 4, 0.0);
gsl_vector_set(s->x, 5, 0.0);
}
std::string reportOfDiffractionEventCalibrateDetectors =
gsl_strerror(status);
if (s->fval == -0.000)
reportOfDiffractionEventCalibrateDetectors = "No events";
g_log.information() << "Detector = " << det << "\n"
<< "Method used = "
<< "Simplex"
<< "\n"
<< "Iteration = " << iter << "\n"
<< "Status = "
<< reportOfDiffractionEventCalibrateDetectors << "\n"
<< "Minimize PeakLoc-" << peakOpt << " = " << s->fval
<< "\n";
// Move in cm for small shifts
g_log.information() << "Move (X) = " << gsl_vector_get(s->x, 0) * 0.01
<< " \n";
g_log.information() << "Move (Y) = " << gsl_vector_get(s->x, 1) * 0.01
<< " \n";
g_log.information() << "Move (Z) = " << gsl_vector_get(s->x, 2) * 0.01
<< " \n";
g_log.information() << "Rotate (X) = " << gsl_vector_get(s->x, 3) << " \n";
g_log.information() << "Rotate (Y) = " << gsl_vector_get(s->x, 4) << " \n";
g_log.information() << "Rotate (Z) = " << gsl_vector_get(s->x, 5) << " \n";
Kernel::V3D CalCenter =
V3D(gsl_vector_get(s->x, 0) * 0.01, gsl_vector_get(s->x, 1) * 0.01,
gsl_vector_get(s->x, 2) * 0.01);
Kernel::V3D Center = detList[det]->getPos() + CalCenter;
int pixmax = detList[det]->xpixels() - 1;
int pixmid = (detList[det]->ypixels() - 1) / 2;
BoundingBox box;
detList[det]->getAtXY(pixmax, pixmid)->getBoundingBox(box);
double baseX = box.xMax();
double baseY = box.yMax();
double baseZ = box.zMax();
Kernel::V3D Base = V3D(baseX, baseY, baseZ) + CalCenter;
pixmid = (detList[det]->xpixels() - 1) / 2;
pixmax = detList[det]->ypixels() - 1;
detList[det]->getAtXY(pixmid, pixmax)->getBoundingBox(box);
double upX = box.xMax();
double upY = box.yMax();
double upZ = box.zMax();
Kernel::V3D Up = V3D(upX, upY, upZ) + CalCenter;
Base -= Center;
Up -= Center;
// Rotate around x
baseX = Base[0];
baseY = Base[1];
baseZ = Base[2];
double deg2rad = M_PI / 180.0;
double angle = gsl_vector_get(s->x, 3) * deg2rad;
Base = V3D(baseX, baseY * cos(angle) - baseZ * sin(angle),
baseY * sin(angle) + baseZ * cos(angle));
upX = Up[0];
upY = Up[1];
upZ = Up[2];
Up = V3D(upX, upY * cos(angle) - upZ * sin(angle),
upY * sin(angle) + upZ * cos(angle));
// Rotate around y
baseX = Base[0];
baseY = Base[1];
baseZ = Base[2];
angle = gsl_vector_get(s->x, 4) * deg2rad;
Base = V3D(baseZ * sin(angle) + baseX * cos(angle), baseY,
baseZ * cos(angle) - baseX * sin(angle));
upX = Up[0];
upY = Up[1];
upZ = Up[2];
Up = V3D(upZ * cos(angle) - upX * sin(angle), upY,
upZ * sin(angle) + upX * cos(angle));
// Rotate around z
baseX = Base[0];
baseY = Base[1];
baseZ = Base[2];
angle = gsl_vector_get(s->x, 5) * deg2rad;
Base = V3D(baseX * cos(angle) - baseY * sin(angle),
baseX * sin(angle) + baseY * cos(angle), baseZ);
upX = Up[0];
upY = Up[1];
upZ = Up[2];
Up = V3D(upX * cos(angle) - upY * sin(angle),
upX * sin(angle) + upY * cos(angle), upZ);
Base.normalize();
Up.normalize();
Center *= 100.0;
// << det+1 << " "
outfile << "5 " << detList[det]->getName().substr(4) << " "
<< detList[det]->xpixels() << " " << detList[det]->ypixels()
<< " " << 100.0 * detList[det]->xsize() << " "
<< 100.0 * detList[det]->ysize() << " "
<< "0.2000"
<< " " << Center.norm() << " ";
Center.write(outfile);
outfile << " ";
Base.write(outfile);
outfile << " ";
Up.write(outfile);
outfile << "\n";
// clean up dynamically allocated gsl stuff
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
// Remove the now-unneeded grouping workspace
AnalysisDataService::Instance().remove(groupWSName);
prog.report(detList[det]->getName());
}
// Closing
outfile.close();
}
extern real fitGemRecomb(double *ct, double *time, double **ctFit,
const int nData, t_gemParams *params)
{
int nThreads, i, iter, status, maxiter;
real size, d2, tol, *dumpdata;
size_t p, n;
gemFitData *GD;
char *dumpstr, dumpname[128];
/* nmsimplex2 had convergence problems prior to gsl v1.14,
* but it's O(N) instead of O(N) operations, so let's use it if v >= 1.14 */
#ifdef HAVE_LIBGSL
gsl_multimin_fminimizer *s;
gsl_vector *x,*dx; /* parameters and initial step size */
gsl_multimin_function fitFunc;
#ifdef GSL_MAJOR_VERSION
#ifdef GSL_MINOR_VERSION
#if ((GSL_MAJOR_VERSION == 1 && GSL_MINOR_VERSION >= 14) || \
(GSL_MAJOR_VERSION > 1))
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* #if ... */
#endif /* GSL_MINOR_VERSION */
#else
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
#endif /* GSL_MAJOR_VERSION */
fprintf(stdout, "Will fit ka and kd to the ACF according to the reversible geminate recombination model.\n");
#else /* HAVE_LIBGSL */
fprintf(stderr, "Sorry, can't do reversible geminate recombination without gsl. "
"Recompile using --with-gsl.\n");
return -1;
#endif /* HAVE_LIBGSL */
#ifdef HAVE_LIBGSL
#ifdef HAVE_OPENMP
nThreads = omp_get_num_procs();
omp_set_num_threads(nThreads);
fprintf(stdout, "We will be using %i threads.\n", nThreads);
#endif
iter = 0;
status = 0;
maxiter = 100;
tol = 1e-10;
p = 2; /* Number of parameters to fit. ka and kd. */
n = params->nFitPoints; /* params->nLin*2 */; /* Number of points in the reduced dataset */
if (params->D <= 0)
{
fprintf(stderr, "Fitting of D is not implemented yet. It must be provided on the command line.\n");
return -1;
}
/* if (nData<n) { */
/* fprintf(stderr, "Reduced data set larger than the complete data set!\n"); */
/* n=nData; */
/* } */
snew(dumpdata, nData);
snew(GD,1);
GD->n = n;
GD->y = ct;
GD->ctTheory=NULL;
snew(GD->ctTheory, nData);
GD->LinLog=NULL;
snew(GD->LinLog, n);
GD->time = time;
GD->ka = 0;
GD->kd = 0;
GD->tDelta = time[1]-time[0];
GD->nData = nData;
GD->params = params;
snew(GD->logtime,params->nFitPoints);
snew(GD->doubleLogTime,params->nFitPoints);
for (i=0; i<params->nFitPoints; i++)
{
GD->doubleLogTime[i] = (double)(getLogIndex(i, params));
GD->logtime[i] = (int)(GD->doubleLogTime[i]);
GD->doubleLogTime[i]*=GD->tDelta;
if (GD->logtime[i] >= nData)
{
fprintf(stderr, "Ayay. It seems we're indexing out of bounds.\n");
params->nFitPoints = i;
}
}
fitFunc.f = &gemFunc_residual2;
fitFunc.n = 2;
fitFunc.params = (void*)GD;
x = gsl_vector_alloc (fitFunc.n);
dx = gsl_vector_alloc (fitFunc.n);
gsl_vector_set (x, 0, 25);
gsl_vector_set (x, 1, 0.5);
gsl_vector_set (dx, 0, 0.1);
gsl_vector_set (dx, 1, 0.01);
s = gsl_multimin_fminimizer_alloc (T, fitFunc.n);
gsl_multimin_fminimizer_set (s, &fitFunc, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
do {
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
gmx_fatal(FARGS,"Something went wrong in the iteration in minimizer %s:\n \"%s\"\n",
gsl_multimin_fminimizer_name(s), gsl_strerror(status));
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
params->ka = gsl_vector_get (s->x, 0);
params->kd = gsl_vector_get (s->x, 1);
if (status)
{
fprintf(stderr, "%s\n", gsl_strerror(status));
break;
}
status = gsl_multimin_test_size(size,tol);
if (status == GSL_SUCCESS) {
fprintf(stdout, "Converged to minimum at\n");
}
printf ("iter %5d: ka = %2.5f kd = %2.5f f() = %7.3f size = %.3f chi2 = %2.5f\n",
iter,
params->ka,
params->kd,
s->fval, size, d2);
if (iter%1 == 0)
{
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
/* fixGemACF(GD->ctTheory, nFitPoints); */
sprintf(dumpname, "Iter_%i.xvg", iter);
for(i=0; i<GD->nData; i++)
{
dumpdata[i] = (real)(GD->ctTheory[i]);
if (!gmx_isfinite(dumpdata[i]))
{
gmx_fatal(FARGS, "Non-finite value in acf.");
}
}
dumpN(dumpdata, GD->nData, dumpname);
}
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
/* /\* Calculate the theoretical ACF from the parameters one last time. *\/ */
eq10v2(GD->ctTheory, time, nData, params->ka, params->kd, params);
*ctFit = GD->ctTheory;
sfree(GD);
gsl_multimin_fminimizer_free (s);
return d2;
#endif /* HAVE_LIBGSL */
}
static void optimize_remd_parameters(t_remd_data *d, int maxiter,
real tol)
{
real size, d2;
int iter = 0;
int status = 0;
int i;
const gsl_multimin_fminimizer_type *T;
gsl_multimin_fminimizer *s;
gsl_vector *x, *dx;
gsl_multimin_function my_func;
my_func.f = &my_f;
my_func.n = d->nparams;
my_func.params = (void *) d;
/* Starting point */
x = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (x, i, d->params[i]);
}
/* Step size, different for each of the parameters */
dx = gsl_vector_alloc (my_func.n);
for (i = 0; (i < my_func.n); i++)
{
gsl_vector_set (dx, i, 0.1*d->params[i]);
}
T = gsl_multimin_fminimizer_nmsimplex;
s = gsl_multimin_fminimizer_alloc (T, my_func.n);
gsl_multimin_fminimizer_set (s, &my_func, x, dx);
gsl_vector_free (x);
gsl_vector_free (dx);
printf ("%5s", "Iter");
for (i = 0; (i < my_func.n); i++)
{
printf(" %12s", epnm(my_func.n, i));
}
printf (" %12s %12s\n", "NM Size", "Chi2");
do
{
iter++;
status = gsl_multimin_fminimizer_iterate (s);
if (status != 0)
{
gmx_fatal(FARGS, "Something went wrong in the iteration in minimizer %s",
gsl_multimin_fminimizer_name(s));
}
d2 = gsl_multimin_fminimizer_minimum(s);
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, tol);
if (status == GSL_SUCCESS)
{
printf ("Minimum found using %s at:\n",
gsl_multimin_fminimizer_name(s));
}
printf ("%5d", iter);
for (i = 0; (i < my_func.n); i++)
{
printf(" %12.4e", gsl_vector_get (s->x, i));
}
printf (" %12.4e %12.4e\n", size, d2);
}
while ((status == GSL_CONTINUE) && (iter < maxiter));
gsl_multimin_fminimizer_free (s);
}
int SimplexMinimizer::iterate()
{
return gsl_multimin_fminimizer_iterate(m_gslSolver);
}
int VelStereoMatcher::findOptimalStereo(StereoProperties init)
{
const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex2;
gsl_multimin_fminimizer *s = NULL;
gsl_vector *ss, *x;
gsl_multimin_function minex_func;
size_t iter = 0;
int status;
double size;
// Starting point
x = stereoToVec(init);
// Set initial step sizes to 1
ss = gsl_vector_alloc(11);
gsl_vector_set(ss, 0, 0.1);
gsl_vector_set(ss, 1, 0.1);
gsl_vector_set(ss, 2, 0.1);
gsl_vector_set(ss, 3, 0.05);
gsl_vector_set(ss, 4, 0.05);
gsl_vector_set(ss, 5, 0.05);
gsl_vector_set(ss, 6, 5);
gsl_vector_set(ss, 7, 5);
gsl_vector_set(ss, 8, 5);
gsl_vector_set(ss, 9, 5);
gsl_vector_set(ss, 10, 0.001);
// Initialize method and iterate
minex_func.n = 11;
minex_func.f = this->optFuncWrapper;
minex_func.params = this;
s = gsl_multimin_fminimizer_alloc(T, 11);
gsl_multimin_fminimizer_set(s, &minex_func, x, ss);
do
{
iter++;
status = gsl_multimin_fminimizer_iterate(s);
if (status)
break;
size = gsl_multimin_fminimizer_size(s);
status = gsl_multimin_test_size(size, 1e-4);
if (status == GSL_SUCCESS)
{
printf("converged to minimum at\n");
}
printf("%5d x:%2.3f y:%2.3f z:%2.3f rx:%2.3f ry:%2.3f rz:%2.3f fx:%3.1f fy:%3.1f cx:%3.1f cy:%3.1f baseline:%2.3f f() = %7.3f size = %.3f\n", iter,
gsl_vector_get(s->x, 0), gsl_vector_get(s->x, 1), gsl_vector_get(s->x, 2), gsl_vector_get(s->x, 3),
gsl_vector_get(s->x, 4), gsl_vector_get(s->x, 5), gsl_vector_get(s->x, 6), gsl_vector_get(s->x, 7), gsl_vector_get(s->x, 8), gsl_vector_get(s->x, 9), gsl_vector_get(s->x, 10), s->fval, size);
} while (status == GSL_CONTINUE && iter < 100);
gsl_vector_free(x);
gsl_vector_free(ss);
gsl_multimin_fminimizer_free(s);
return status;
}